bfd/bout.c

   1 /* BFD back-end for Intel 960 b.out binaries.
   2    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "libbfd.h"
  25 #include "bfdlink.h"
  26 #include "bout.h"
  27
  28 #include "aout/stab_gnu.h"
  29 #include "libaout.h"            /* BFD a.out internal data structures */
  30
  31
  32 static boolean b_out_squirt_out_relocs PARAMS ((bfd *abfd, asection *section));
  33 static bfd_target *b_out_callback PARAMS ((bfd *));
  34 static bfd_reloc_status_type calljx_callback
  35   PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR src, PTR dst,
  36            asection *));
  37 static bfd_reloc_status_type callj_callback
  38   PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR data,
  39            unsigned int srcidx, unsigned int dstidx, asection *));
  40 static bfd_vma get_value PARAMS ((arelent *, struct bfd_link_info *,
  41                                   asection *));
  42 static int abs32code PARAMS ((asection *, asymbol **, arelent *,
  43                               unsigned int, struct bfd_link_info *));
  44 static boolean b_out_relax_section PARAMS ((bfd *, asection *,
  45                                             struct bfd_link_info *,
  46                                             asymbol **symbols));
  47 static bfd_byte *b_out_get_relocated_section_contents
  48   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
  49            bfd_byte *, boolean, asymbol **));
  50
  51 /* Swaps the information in an executable header taken from a raw byte
  52    stream memory image, into the internal exec_header structure.  */
  53
  54 void
  55 DEFUN(bout_swap_exec_header_in,(abfd, raw_bytes, execp),
  56       bfd *abfd AND
  57       struct external_exec *raw_bytes AND
  58       struct internal_exec *execp)
  59 {
  60   struct external_exec *bytes = (struct external_exec *)raw_bytes;
  61
  62   /* Now fill in fields in the execp, from the bytes in the raw data.  */
  63   execp->a_info   = bfd_h_get_32 (abfd, bytes->e_info);
  64   execp->a_text   = GET_WORD (abfd, bytes->e_text);
  65   execp->a_data   = GET_WORD (abfd, bytes->e_data);
  66   execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
  67   execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
  68   execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
  69   execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
  70   execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
  71   execp->a_tload  = GET_WORD (abfd, bytes->e_tload);
  72   execp->a_dload  = GET_WORD (abfd, bytes->e_dload);
  73   execp->a_talign = bytes->e_talign[0];
  74   execp->a_dalign = bytes->e_dalign[0];
  75   execp->a_balign = bytes->e_balign[0];
  76   execp->a_relaxable = bytes->e_relaxable[0];
  77 }
  78
  79 /* Swaps the information in an internal exec header structure into the
  80    supplied buffer ready for writing to disk.  */
  81
  82 PROTO(void, bout_swap_exec_header_out,
  83           (bfd *abfd,
  84            struct internal_exec *execp,
  85            struct external_exec *raw_bytes));
  86 void
  87 DEFUN(bout_swap_exec_header_out,(abfd, execp, raw_bytes),
  88      bfd *abfd AND
  89      struct internal_exec *execp AND
  90      struct external_exec *raw_bytes)
  91 {
  92   struct external_exec *bytes = (struct external_exec *)raw_bytes;
  93
  94   /* Now fill in fields in the raw data, from the fields in the exec struct. */
  95   bfd_h_put_32 (abfd, execp->a_info  , bytes->e_info);
  96   PUT_WORD (abfd, execp->a_text  , bytes->e_text);
  97   PUT_WORD (abfd, execp->a_data  , bytes->e_data);
  98   PUT_WORD (abfd, execp->a_bss   , bytes->e_bss);
  99   PUT_WORD (abfd, execp->a_syms  , bytes->e_syms);
 100   PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
 101   PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
 102   PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
 103   PUT_WORD (abfd, execp->a_tload , bytes->e_tload);
 104   PUT_WORD (abfd, execp->a_dload , bytes->e_dload);
 105   bytes->e_talign[0] = execp->a_talign;
 106   bytes->e_dalign[0] = execp->a_dalign;
 107   bytes->e_balign[0] = execp->a_balign;
 108   bytes->e_relaxable[0] = execp->a_relaxable;
 109 }
 110
 111
 112 static bfd_target *
 113 b_out_object_p (abfd)
 114      bfd *abfd;
 115 {
 116   struct internal_exec anexec;
 117   struct external_exec exec_bytes;
 118
 119   if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
 120       != EXEC_BYTES_SIZE) {
 121     bfd_error = wrong_format;
 122     return 0;
 123   }
 124
 125   anexec.a_info = bfd_h_get_32 (abfd, exec_bytes.e_info);
 126
 127   if (N_BADMAG (anexec)) {
 128     bfd_error = wrong_format;
 129     return 0;
 130   }
 131
 132   bout_swap_exec_header_in (abfd, &exec_bytes, &anexec);
 133   return aout_32_some_aout_object_p (abfd, &anexec, b_out_callback);
 134 }
 135
 136
 137 /* Finish up the opening of a b.out file for reading.  Fill in all the
 138    fields that are not handled by common code.  */
 139
 140 static bfd_target *
 141 b_out_callback (abfd)
 142      bfd *abfd;
 143 {
 144   struct internal_exec *execp = exec_hdr (abfd);
 145   unsigned long bss_start;
 146
 147   /* Architecture and machine type */
 148   bfd_set_arch_mach(abfd,
 149                     bfd_arch_i960, /* B.out only used on i960 */
 150                     bfd_mach_i960_core /* Default */
 151                     );
 152
 153   /* The positions of the string table and symbol table.  */
 154   obj_str_filepos (abfd) = N_STROFF (*execp);
 155   obj_sym_filepos (abfd) = N_SYMOFF (*execp);
 156
 157   /* The alignments of the sections */
 158   obj_textsec (abfd)->alignment_power = execp->a_talign;
 159   obj_datasec (abfd)->alignment_power = execp->a_dalign;
 160   obj_bsssec  (abfd)->alignment_power = execp->a_balign;
 161
 162   /* The starting addresses of the sections.  */
 163   obj_textsec (abfd)->vma = execp->a_tload;
 164   obj_datasec (abfd)->vma = execp->a_dload;
 165
 166   /* And reload the sizes, since the aout module zaps them */
 167   obj_textsec (abfd)->_raw_size = execp->a_text;
 168
 169   bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section */
 170   obj_bsssec (abfd)->vma = align_power (bss_start, execp->a_balign);
 171
 172   /* The file positions of the sections */
 173   obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
 174   obj_datasec (abfd)->filepos = N_DATOFF(*execp);
 175
 176   /* The file positions of the relocation info */
 177   obj_textsec (abfd)->rel_filepos = N_TROFF(*execp);
 178   obj_datasec (abfd)->rel_filepos =  N_DROFF(*execp);
 179
 180   adata(abfd).page_size = 1;    /* Not applicable. */
 181   adata(abfd).segment_size = 1; /* Not applicable. */
 182   adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
 183
 184   if (execp->a_relaxable)
 185    abfd->flags |= BFD_IS_RELAXABLE;
 186   return abfd->xvec;
 187 }
 188
 189 struct bout_data_struct {
 190     struct aoutdata a;
 191     struct internal_exec e;
 192 };
 193
 194 static boolean
 195 b_out_mkobject (abfd)
 196      bfd *abfd;
 197 {
 198   struct bout_data_struct *rawptr;
 199
 200   rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, sizeof (struct bout_data_struct));
 201   if (rawptr == NULL) {
 202       bfd_error = no_memory;
 203       return false;
 204     }
 205
 206   abfd->tdata.bout_data = rawptr;
 207   exec_hdr (abfd) = &rawptr->e;
 208
 209   /* For simplicity's sake we just make all the sections right here. */
 210   obj_textsec (abfd) = (asection *)NULL;
 211   obj_datasec (abfd) = (asection *)NULL;
 212   obj_bsssec (abfd) = (asection *)NULL;
 213
 214   bfd_make_section (abfd, ".text");
 215   bfd_make_section (abfd, ".data");
 216   bfd_make_section (abfd, ".bss");
 217
 218   return true;
 219 }
 220
 221 static boolean
 222 b_out_write_object_contents (abfd)
 223      bfd *abfd;
 224 {
 225   struct external_exec swapped_hdr;
 226
 227   exec_hdr (abfd)->a_info = BMAGIC;
 228
 229   exec_hdr (abfd)->a_text = obj_textsec (abfd)->_raw_size;
 230   exec_hdr (abfd)->a_data = obj_datasec (abfd)->_raw_size;
 231   exec_hdr (abfd)->a_bss = obj_bsssec (abfd)->_raw_size;
 232   exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd) * sizeof (struct nlist);
 233   exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
 234   exec_hdr (abfd)->a_trsize = ((obj_textsec (abfd)->reloc_count) *
 235                                sizeof (struct relocation_info));
 236   exec_hdr (abfd)->a_drsize = ((obj_datasec (abfd)->reloc_count) *
 237                                sizeof (struct relocation_info));
 238
 239   exec_hdr (abfd)->a_talign = obj_textsec (abfd)->alignment_power;
 240   exec_hdr (abfd)->a_dalign = obj_datasec (abfd)->alignment_power;
 241   exec_hdr (abfd)->a_balign = obj_bsssec (abfd)->alignment_power;
 242
 243   exec_hdr (abfd)->a_tload = obj_textsec (abfd)->vma;
 244   exec_hdr (abfd)->a_dload = obj_datasec (abfd)->vma;
 245
 246   bout_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
 247
 248   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
 249   bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd);
 250
 251   /* Now write out reloc info, followed by syms and strings */
 252   if (bfd_get_symcount (abfd) != 0)
 253     {
 254       bfd_seek (abfd, (file_ptr)(N_SYMOFF(*exec_hdr(abfd))), SEEK_SET);
 255
 256       if (! aout_32_write_syms (abfd))
 257         return false;
 258
 259       bfd_seek (abfd, (file_ptr)(N_TROFF(*exec_hdr(abfd))), SEEK_SET);
 260
 261       if (!b_out_squirt_out_relocs (abfd, obj_textsec (abfd))) return false;
 262       bfd_seek (abfd, (file_ptr)(N_DROFF(*exec_hdr(abfd))), SEEK_SET);
 263
 264       if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd))) return false;
 265     }
 266   return true;
 267 }
 268 \f
 269 /** Some reloc hackery */
 270
 271 #define CALLS    0x66003800     /* Template for 'calls' instruction     */
 272 #define BAL      0x0b000000     /* Template for 'bal' instruction */
 273 #define BALX     0x85000000     /* Template for 'balx' instruction      */
 274 #define BAL_MASK 0x00ffffff
 275 #define CALL     0x09000000
 276 #define PCREL13_MASK 0x1fff
 277
 278
 279 #define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma)
 280
 281 /* Magic to turn callx into calljx */
 282 static bfd_reloc_status_type
 283 calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
 284      bfd *abfd;
 285      struct bfd_link_info *link_info;
 286      arelent *reloc_entry;
 287      PTR src;
 288      PTR dst;
 289      asection *input_section;
 290 {
 291   int word = bfd_get_32 (abfd, src);
 292   asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
 293   aout_symbol_type *symbol = aout_symbol (symbol_in);
 294   bfd_vma value;
 295
 296   value = get_value (reloc_entry, link_info, input_section);
 297
 298   if (IS_CALLNAME (symbol->other))
 299     {
 300       aout_symbol_type *balsym = symbol+1;
 301       int inst = bfd_get_32 (abfd, (bfd_byte *) src-4);
 302       /* The next symbol should be an N_BALNAME */
 303       BFD_ASSERT (IS_BALNAME (balsym->other));
 304       inst &= BAL_MASK;
 305       inst |= BALX;
 306       bfd_put_32 (abfd, inst, (bfd_byte *) dst-4);
 307       symbol = balsym;
 308       value = (symbol->symbol.value
 309                + output_addr (symbol->symbol.section));
 310     }
 311
 312   word += value + reloc_entry->addend;
 313
 314   bfd_put_32(abfd, word, dst);
 315   return bfd_reloc_ok;
 316 }
 317
 318
 319 /* Magic to turn call into callj */
 320 static bfd_reloc_status_type
 321 callj_callback (abfd, link_info, reloc_entry,  data, srcidx, dstidx,
 322                 input_section)
 323      bfd *abfd;
 324      struct bfd_link_info *link_info;
 325      arelent *reloc_entry;
 326      PTR data;
 327      unsigned int srcidx;
 328      unsigned int dstidx;
 329      asection *input_section;
 330 {
 331   int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
 332   asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
 333   aout_symbol_type *symbol = aout_symbol (symbol_in);
 334   bfd_vma value;
 335
 336   value = get_value (reloc_entry, link_info, input_section);
 337
 338   if (IS_OTHER(symbol->other))
 339     {
 340       /* Call to a system procedure - replace code with system
 341          procedure number.  */
 342       word = CALLS | (symbol->other - 1);
 343     }
 344   else if (IS_CALLNAME(symbol->other))
 345     {
 346       aout_symbol_type *balsym = symbol+1;
 347
 348       /* The next symbol should be an N_BALNAME.  */
 349       BFD_ASSERT(IS_BALNAME(balsym->other));
 350
 351       /* We are calling a leaf, so replace the call instruction with a
 352          bal.  */
 353       word = BAL | ((word
 354                      + output_addr (balsym->symbol.section)
 355                      + balsym->symbol.value + reloc_entry->addend
 356                      - dstidx
 357                      - output_addr (input_section))
 358                     & BAL_MASK);
 359     }
 360   else
 361     {
 362       word = CALL | (((word & BAL_MASK)
 363                       + value
 364                       + reloc_entry->addend
 365                       - dstidx
 366                       - output_addr (input_section))
 367                      & BAL_MASK);
 368     }
 369   bfd_put_32(abfd, word, (bfd_byte *) data + dstidx);
 370   return bfd_reloc_ok;
 371 }
 372
 373 /* type rshift size  bitsize    pcrel   bitpos  absolute overflow check*/
 374
 375 #define ABS32CODE 0
 376 #define ABS32CODE_SHRUNK 1
 377 #define PCREL24 2
 378 #define CALLJ 3
 379 #define ABS32 4
 380 #define PCREL13 5
 381 #define ABS32_MAYBE_RELAXABLE 1
 382 #define ABS32_WAS_RELAXABLE 2
 383
 384 #define ALIGNER 10
 385 #define ALIGNDONE 11
 386 static reloc_howto_type howto_reloc_callj =
 387 HOWTO(CALLJ, 0, 2, 24, true, 0, complain_overflow_signed, 0,"callj", true, 0x00ffffff, 0x00ffffff,false);
 388 static  reloc_howto_type howto_reloc_abs32 =
 389 HOWTO(ABS32, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"abs32", true, 0xffffffff,0xffffffff,false);
 390 static reloc_howto_type howto_reloc_pcrel24 =
 391 HOWTO(PCREL24, 0, 2, 24, true, 0, complain_overflow_signed,0,"pcrel24", true, 0x00ffffff,0x00ffffff,false);
 392
 393 static reloc_howto_type howto_reloc_pcrel13 =
 394 HOWTO(PCREL13, 0, 2, 13, true, 0, complain_overflow_signed,0,"pcrel13", true, 0x00001fff,0x00001fff,false);
 395
 396
 397 static reloc_howto_type howto_reloc_abs32codeshrunk =
 398 HOWTO(ABS32CODE_SHRUNK, 0, 2, 24, true, 0, complain_overflow_signed, 0,"callx->callj", true, 0x00ffffff, 0x00ffffff,false);
 399
 400 static  reloc_howto_type howto_reloc_abs32code =
 401 HOWTO(ABS32CODE, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"callx", true, 0xffffffff,0xffffffff,false);
 402
 403 static reloc_howto_type howto_align_table[] = {
 404   HOWTO (ALIGNER, 0, 0x1, 0, false, 0, complain_overflow_dont, 0, "align16", false, 0, 0, false),
 405   HOWTO (ALIGNER, 0, 0x3, 0, false, 0, complain_overflow_dont, 0, "align32", false, 0, 0, false),
 406   HOWTO (ALIGNER, 0, 0x7, 0, false, 0, complain_overflow_dont, 0, "align64", false, 0, 0, false),
 407   HOWTO (ALIGNER, 0, 0xf, 0, false, 0, complain_overflow_dont, 0, "align128", false, 0, 0, false),
 408 };
 409
 410 static reloc_howto_type howto_done_align_table[] = {
 411   HOWTO (ALIGNDONE, 0x1, 0x1, 0, false, 0, complain_overflow_dont, 0, "donealign16", false, 0, 0, false),
 412   HOWTO (ALIGNDONE, 0x3, 0x3, 0, false, 0, complain_overflow_dont, 0, "donealign32", false, 0, 0, false),
 413   HOWTO (ALIGNDONE, 0x7, 0x7, 0, false, 0, complain_overflow_dont, 0, "donealign64", false, 0, 0, false),
 414   HOWTO (ALIGNDONE, 0xf, 0xf, 0, false, 0, complain_overflow_dont, 0, "donealign128", false, 0, 0, false),
 415 };
 416
 417 static const reloc_howto_type *
 418 b_out_reloc_type_lookup (abfd, code)
 419      bfd *abfd;
 420      bfd_reloc_code_real_type code;
 421 {
 422   switch (code)
 423     {
 424     default:
 425       return 0;
 426     case BFD_RELOC_I960_CALLJ:
 427       return &howto_reloc_callj;
 428     case BFD_RELOC_32:
 429       return &howto_reloc_abs32;
 430     case BFD_RELOC_24_PCREL:
 431       return &howto_reloc_pcrel24;
 432     }
 433 }
 434
 435 /* Allocate enough room for all the reloc entries, plus pointers to them all */
 436
 437 static boolean
 438 b_out_slurp_reloc_table (abfd, asect, symbols)
 439      bfd *abfd;
 440      sec_ptr asect;
 441      asymbol **symbols;
 442 {
 443   register struct relocation_info *rptr;
 444   unsigned int counter ;
 445   arelent *cache_ptr ;
 446   int extern_mask, pcrel_mask, callj_mask, length_shift;
 447   int incode_mask;
 448   int size_mask;
 449   bfd_vma prev_addr = 0;
 450   unsigned int count;
 451   size_t  reloc_size;
 452   struct relocation_info *relocs;
 453   arelent *reloc_cache;
 454
 455   if (asect->relocation) return true;
 456   if (!aout_32_slurp_symbol_table (abfd)) return false;
 457
 458   if (asect == obj_datasec (abfd)) {
 459     reloc_size = exec_hdr(abfd)->a_drsize;
 460     goto doit;
 461   }
 462
 463   if (asect == obj_textsec (abfd)) {
 464     reloc_size = exec_hdr(abfd)->a_trsize;
 465     goto doit;
 466   }
 467
 468   bfd_error = invalid_operation;
 469   return false;
 470
 471  doit:
 472   bfd_seek (abfd, (file_ptr)(asect->rel_filepos),  SEEK_SET);
 473   count = reloc_size / sizeof (struct relocation_info);
 474
 475   relocs = (struct relocation_info *) malloc (reloc_size);
 476   if (!relocs) {
 477     bfd_error = no_memory;
 478     return false;
 479   }
 480   reloc_cache = (arelent *) malloc ((count+1) * sizeof (arelent));
 481   if (!reloc_cache) {
 482     free ((char*)relocs);
 483     bfd_error = no_memory;
 484     return false;
 485   }
 486
 487   if (bfd_read ((PTR) relocs, 1, reloc_size, abfd) != reloc_size) {
 488     bfd_error = system_call_error;
 489     free (reloc_cache);
 490     free (relocs);
 491     return false;
 492   }
 493
 494
 495
 496   if (abfd->xvec->header_byteorder_big_p) {
 497     /* big-endian bit field allocation order */
 498     pcrel_mask  = 0x80;
 499     extern_mask = 0x10;
 500     incode_mask = 0x08;
 501     callj_mask  = 0x02;
 502     size_mask =   0x20;
 503     length_shift = 5;
 504   } else {
 505     /* little-endian bit field allocation order */
 506     pcrel_mask  = 0x01;
 507     extern_mask = 0x08;
 508     incode_mask = 0x10;
 509     callj_mask  = 0x40;
 510     size_mask   = 0x02;
 511     length_shift = 1;
 512   }
 513
 514   for (rptr = relocs, cache_ptr = reloc_cache, counter = 0;
 515        counter < count;
 516        counter++, rptr++, cache_ptr++)
 517   {
 518     unsigned char *raw = (unsigned char *)rptr;
 519     unsigned int symnum;
 520     cache_ptr->address = bfd_h_get_32 (abfd, raw + 0);
 521     cache_ptr->howto = 0;
 522     if (abfd->xvec->header_byteorder_big_p)
 523     {
 524       symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6];
 525     }
 526     else
 527     {
 528       symnum = (raw[6] << 16) | (raw[5] << 8) | raw[4];
 529     }
 530
 531     if (raw[7] & extern_mask)
 532     {
 533       /* if this is set then the r_index is a index into the symbol table;
 534        * if the bit is not set then r_index contains a section map.
 535        * we either fill in the sym entry with a pointer to the symbol,
 536        * or point to the correct section
 537        */
 538       cache_ptr->sym_ptr_ptr = symbols + symnum;
 539       cache_ptr->addend = 0;
 540     } else
 541     {
 542       /* in a.out symbols are relative to the beginning of the
 543        * file rather than sections ?
 544        * (look in translate_from_native_sym_flags)
 545        * the reloc entry addend has added to it the offset into the
 546        * file of the data, so subtract the base to make the reloc
 547        * section relative */
 548       int s;
 549       {
 550         /* sign-extend symnum from 24 bits to whatever host uses */
 551         s = symnum;
 552         if (s & (1 << 23))
 553           s |= (~0) << 24;
 554       }
 555       cache_ptr->sym_ptr_ptr = (asymbol **)NULL;
 556       switch (s)
 557       {
 558        case N_TEXT:
 559        case N_TEXT | N_EXT:
 560         cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr;
 561         cache_ptr->addend = - obj_textsec(abfd)->vma;
 562         break;
 563        case N_DATA:
 564        case N_DATA | N_EXT:
 565         cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr;
 566         cache_ptr->addend = - obj_datasec(abfd)->vma;
 567         break;
 568        case N_BSS:
 569        case N_BSS | N_EXT:
 570         cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr;
 571         cache_ptr->addend =  - obj_bsssec(abfd)->vma;
 572         break;
 573        case N_ABS:
 574        case N_ABS | N_EXT:
 575         cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr;
 576         cache_ptr->addend = 0;
 577         break;
 578       case -2: /* .align */
 579         if (raw[7] & pcrel_mask)
 580           {
 581             cache_ptr->howto = &howto_align_table[(raw[7] >> length_shift) & 3];
 582             cache_ptr->sym_ptr_ptr = &bfd_abs_symbol;
 583           }
 584         else
 585           {
 586             /* .org? */
 587             abort ();
 588           }
 589         cache_ptr->addend = 0;
 590         break;
 591        default:
 592         BFD_ASSERT(0);
 593         break;
 594       }
 595
 596     }
 597
 598     /* the i960 only has a few relocation types:
 599        abs 32-bit and pcrel 24bit.   except for callj's!  */
 600     if (cache_ptr->howto != 0)
 601       ;
 602     else if (raw[7] & callj_mask)
 603     {
 604       cache_ptr->howto = &howto_reloc_callj;
 605     }
 606     else if ( raw[7] & pcrel_mask)
 607     {
 608       if (raw[7] & size_mask)
 609        cache_ptr->howto = &howto_reloc_pcrel13;
 610       else
 611        cache_ptr->howto = &howto_reloc_pcrel24;
 612     }
 613     else
 614     {
 615       if (raw[7] & incode_mask)
 616       {
 617         cache_ptr->howto = &howto_reloc_abs32code;
 618       }
 619       else
 620       {
 621         cache_ptr->howto = &howto_reloc_abs32;
 622       }
 623     }
 624     if (cache_ptr->address < prev_addr)
 625     {
 626       /* Ouch! this reloc is out of order, insert into the right place
 627        */
 628       arelent tmp;
 629       arelent *cursor = cache_ptr-1;
 630       bfd_vma stop = cache_ptr->address;
 631       tmp  = *cache_ptr;
 632       while (cursor->address > stop && cursor >= reloc_cache)
 633       {
 634         cursor[1] = cursor[0];
 635         cursor--;
 636       }
 637       cursor[1] = tmp;
 638     }
 639     else
 640     {
 641       prev_addr = cache_ptr->address;
 642     }
 643   }
 644
 645
 646   free (relocs);
 647   asect->relocation = reloc_cache;
 648   asect->reloc_count = count;
 649
 650
 651   return true;
 652 }
 653
 654
 655 static boolean
 656 b_out_squirt_out_relocs (abfd, section)
 657      bfd *abfd;
 658      asection *section;
 659 {
 660   arelent **generic;
 661   int r_extern = 0;
 662   int r_idx;
 663   int incode_mask;
 664   int len_1;
 665   unsigned int count = section->reloc_count;
 666   struct relocation_info *native, *natptr;
 667   size_t natsize = count * sizeof (struct relocation_info);
 668   int extern_mask, pcrel_mask,  len_2, callj_mask;
 669   if (count == 0) return true;
 670   generic   = section->orelocation;
 671   native = ((struct relocation_info *) malloc (natsize));
 672   if (!native) {
 673     bfd_error = no_memory;
 674     return false;
 675   }
 676
 677   if (abfd->xvec->header_byteorder_big_p)
 678   {
 679     /* Big-endian bit field allocation order */
 680     pcrel_mask  = 0x80;
 681     extern_mask = 0x10;
 682     len_2       = 0x40;
 683     len_1       = 0x20;
 684     callj_mask  = 0x02;
 685     incode_mask = 0x08;
 686   }
 687   else
 688   {
 689     /* Little-endian bit field allocation order */
 690     pcrel_mask  = 0x01;
 691     extern_mask = 0x08;
 692     len_2       = 0x04;
 693     len_1       = 0x02;
 694     callj_mask  = 0x40;
 695     incode_mask = 0x10;
 696   }
 697
 698   for (natptr = native; count > 0; --count, ++natptr, ++generic)
 699   {
 700     arelent *g = *generic;
 701     unsigned char *raw = (unsigned char *)natptr;
 702     asymbol *sym = *(g->sym_ptr_ptr);
 703
 704     asection *output_section = sym->section->output_section;
 705
 706     bfd_h_put_32(abfd, g->address, raw);
 707     /* Find a type in the output format which matches the input howto -
 708      * at the moment we assume input format == output format FIXME!!
 709      */
 710     r_idx = 0;
 711     /* FIXME:  Need callj stuff here, and to check the howto entries to
 712        be sure they are real for this architecture.  */
 713     if (g->howto== &howto_reloc_callj)
 714     {
 715       raw[7] = callj_mask + pcrel_mask + len_2;
 716     }
 717     else if (g->howto == &howto_reloc_pcrel24)
 718     {
 719       raw[7] = pcrel_mask + len_2;
 720     }
 721     else if (g->howto == &howto_reloc_pcrel13)
 722     {
 723       raw[7] = pcrel_mask + len_1;
 724     }
 725     else if (g->howto == &howto_reloc_abs32code)
 726     {
 727       raw[7] = len_2 + incode_mask;
 728     }
 729     else if (g->howto >= howto_align_table
 730              && g->howto <= (howto_align_table
 731                             + sizeof (howto_align_table) / sizeof (howto_align_table[0])
 732                             - 1))
 733       {
 734         /* symnum == -2; extern_mask not set, pcrel_mask set */
 735         r_idx = -2;
 736         r_extern = 0;
 737         raw[7] = (pcrel_mask
 738                   | ((g->howto - howto_align_table) << 1));
 739       }
 740     else {
 741       raw[7] = len_2;
 742     }
 743
 744     if (r_idx != 0)
 745       /* already mucked with r_extern, r_idx */;
 746     else if (bfd_is_com_section (output_section)
 747              || output_section == &bfd_abs_section
 748              || output_section == &bfd_und_section)
 749     {
 750
 751       if (bfd_abs_section.symbol == sym)
 752       {
 753         /* Whoops, looked like an abs symbol, but is really an offset
 754            from the abs section */
 755         r_idx = 0;
 756         r_extern = 0;
 757        }
 758       else
 759       {
 760         /* Fill in symbol */
 761
 762         r_extern = 1;
 763         r_idx =  stoi((*(g->sym_ptr_ptr))->flags);
 764       }
 765     }
 766     else
 767     {
 768       /* Just an ordinary section */
 769       r_extern = 0;
 770       r_idx  = output_section->target_index;
 771     }
 772
 773     if (abfd->xvec->header_byteorder_big_p) {
 774       raw[4] = (unsigned char) (r_idx >> 16);
 775       raw[5] = (unsigned char) (r_idx >>  8);
 776       raw[6] = (unsigned char) (r_idx     );
 777     } else {
 778       raw[6] = (unsigned char) (r_idx >> 16);
 779       raw[5] = (unsigned char) (r_idx>>  8);
 780       raw[4] = (unsigned char) (r_idx     );
 781     }
 782     if (r_extern)
 783      raw[7] |= extern_mask;
 784   }
 785
 786   if (bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
 787     free((PTR)native);
 788     return false;
 789   }
 790   free ((PTR)native);
 791
 792   return true;
 793 }
 794
 795 /* This is stupid.  This function should be a boolean predicate */
 796 static unsigned int
 797 b_out_canonicalize_reloc (abfd, section, relptr, symbols)
 798      bfd *abfd;
 799      sec_ptr section;
 800      arelent **relptr;
 801      asymbol **symbols;
 802 {
 803   arelent *tblptr = section->relocation;
 804   unsigned int count = 0;
 805
 806  if (!(tblptr || b_out_slurp_reloc_table (abfd, section, symbols))) return 0;
 807   tblptr = section->relocation;
 808  if (!tblptr) return 0;
 809
 810   for (; count++ < section->reloc_count;)
 811     *relptr++ = tblptr++;
 812
 813   *relptr = 0;
 814
 815   return section->reloc_count;
 816 }
 817
 818 static unsigned int
 819 b_out_get_reloc_upper_bound (abfd, asect)
 820      bfd *abfd;
 821      sec_ptr asect;
 822 {
 823   if (bfd_get_format (abfd) != bfd_object) {
 824     bfd_error = invalid_operation;
 825     return 0;
 826   }
 827
 828   if (asect == obj_datasec (abfd))
 829     return (sizeof (arelent *) *
 830             ((exec_hdr(abfd)->a_drsize / sizeof (struct relocation_info))
 831              +1));
 832
 833   if (asect == obj_textsec (abfd))
 834     return (sizeof (arelent *) *
 835             ((exec_hdr(abfd)->a_trsize / sizeof (struct relocation_info))
 836              +1));
 837
 838   if (asect == obj_bsssec (abfd))
 839     return 0;
 840
 841   bfd_error = invalid_operation;
 842   return 0;
 843 }
 844 \f
 845 static boolean
 846 b_out_set_section_contents (abfd, section, location, offset, count)
 847      bfd *abfd;
 848      sec_ptr section;
 849      unsigned char *location;
 850      file_ptr offset;
 851       int count;
 852 {
 853
 854   if (abfd->output_has_begun == false) { /* set by bfd.c handler */
 855     if ((obj_textsec (abfd) == NULL) || (obj_datasec (abfd) == NULL) /*||
 856         (obj_textsec (abfd)->_cooked_size == 0) || (obj_datasec (abfd)->_cooked_size == 0)*/) {
 857       bfd_error = invalid_operation;
 858       return false;
 859     }
 860
 861     obj_textsec (abfd)->filepos = sizeof(struct internal_exec);
 862     obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
 863                                  +  obj_textsec (abfd)->_raw_size;
 864
 865   }
 866   /* regardless, once we know what we're doing, we might as well get going */
 867   bfd_seek (abfd, section->filepos + offset, SEEK_SET);
 868
 869   if (count != 0) {
 870     return (bfd_write ((PTR)location, 1, count, abfd) == count) ?true:false;
 871   }
 872   return true;
 873 }
 874
 875 static boolean
 876 b_out_set_arch_mach (abfd, arch, machine)
 877      bfd *abfd;
 878      enum bfd_architecture arch;
 879      unsigned long machine;
 880 {
 881   bfd_default_set_arch_mach(abfd, arch, machine);
 882
 883   if (arch == bfd_arch_unknown) /* Unknown machine arch is OK */
 884     return true;
 885   if (arch == bfd_arch_i960)    /* i960 default is OK */
 886     switch (machine) {
 887     case bfd_mach_i960_core:
 888     case bfd_mach_i960_kb_sb:
 889     case bfd_mach_i960_mc:
 890     case bfd_mach_i960_xa:
 891     case bfd_mach_i960_ca:
 892     case bfd_mach_i960_ka_sa:
 893     case 0:
 894       return true;
 895     default:
 896       return false;
 897     }
 898
 899   return false;
 900 }
 901
 902 static int
 903 DEFUN(b_out_sizeof_headers,(ignore_abfd, ignore),
 904       bfd *ignore_abfd AND
 905       boolean ignore)
 906 {
 907   return sizeof(struct internal_exec);
 908 }
 909
 910
 911
 912 /************************************************************************/
 913 static bfd_vma
 914 get_value (reloc, link_info, input_section)
 915      arelent *reloc;
 916      struct bfd_link_info *link_info;
 917      asection *input_section;
 918 {
 919   bfd_vma value;
 920   asymbol *symbol = *(reloc->sym_ptr_ptr);
 921
 922   /* A symbol holds a pointer to a section, and an offset from the
 923      base of the section.  To relocate, we find where the section will
 924      live in the output and add that in */
 925
 926   if (symbol->section == &bfd_und_section)
 927     {
 928       struct bfd_link_hash_entry *h;
 929
 930       /* The symbol is undefined in this BFD.  Look it up in the
 931          global linker hash table.  FIXME: This should be changed when
 932          we convert b.out to use a specific final_link function and
 933          change the interface to bfd_relax_section to not require the
 934          generic symbols.  */
 935       h = bfd_link_hash_lookup (link_info->hash, bfd_asymbol_name (symbol),
 936                                 false, false, true);
 937       if (h != (struct bfd_link_hash_entry *) NULL
 938           && h->type == bfd_link_hash_defined)
 939         value = h->u.def.value + output_addr (h->u.def.section);
 940       else if (h != (struct bfd_link_hash_entry *) NULL
 941                && h->type == bfd_link_hash_common)
 942         value = h->u.c.size;
 943       else
 944         {
 945           if (! ((*link_info->callbacks->undefined_symbol)
 946                  (link_info, bfd_asymbol_name (symbol),
 947                   input_section->owner, input_section, reloc->address)))
 948             abort ();
 949           value = 0;
 950         }
 951     }
 952   else
 953     {
 954       value = symbol->value + output_addr (symbol->section);
 955     }
 956
 957   /* Add the value contained in the relocation */
 958   value += reloc->addend;
 959
 960   return value;
 961 }
 962
 963 static void
 964 DEFUN(perform_slip,(s, slip, input_section, value),
 965       asymbol **s AND
 966       unsigned int slip AND
 967       asection *input_section AND
 968       bfd_vma value)
 969 {
 970
 971   /* Find all symbols past this point, and make them know
 972      what's happened */
 973   while (*s)
 974   {
 975     asymbol *p = *s;
 976     if (p->section == input_section)
 977     {
 978       /* This was pointing into this section, so mangle it */
 979       if (p->value > value)
 980       {
 981         p->value -=slip;
 982       }
 983     }
 984     s++;
 985
 986   }
 987 }
 988
 989 /* This routine works out if the thing we want to get to can be
 990    reached with a 24bit offset instead of a 32 bit one.
 991    If it can, then it changes the amode */
 992
 993 static int
 994 abs32code (input_section, symbols, r, shrink, link_info)
 995      asection *input_section;
 996      asymbol **symbols;
 997      arelent *r;
 998      unsigned int shrink;
 999      struct bfd_link_info *link_info;
1000 {
1001   bfd_vma value = get_value (r, link_info, input_section);
1002   bfd_vma dot = output_addr (input_section) + r->address;
1003   bfd_vma gap;
1004
1005   /* See if the address we're looking at within 2^23 bytes of where
1006      we are, if so then we can use a small branch rather than the
1007      jump we were going to */
1008
1009   gap = value - (dot - shrink);
1010
1011
1012   if (-1<<23 < (long)gap && (long)gap < 1<<23 )
1013   {
1014     /* Change the reloc type from 32bitcode possible 24, to 24bit
1015        possible 32 */
1016
1017     r->howto = &howto_reloc_abs32codeshrunk;
1018     /* The place to relc moves back by four bytes */
1019     r->address -=4;
1020
1021     /* This will be four bytes smaller in the long run */
1022     shrink += 4 ;
1023     perform_slip(symbols, 4, input_section, r->address-shrink +4);
1024   }
1025   return shrink;
1026 }
1027
1028 static int
1029 DEFUN(aligncode,(input_section, symbols, r, shrink),
1030       asection *input_section AND
1031       asymbol **symbols AND
1032       arelent *r AND
1033       unsigned int shrink)
1034 {
1035   bfd_vma dot = output_addr (input_section) + r->address;
1036   bfd_vma gap;
1037   bfd_vma old_end;
1038   bfd_vma new_end;
1039   int shrink_delta;
1040   int size = r->howto->size;
1041
1042   /* Reduce the size of the alignment so that it's still aligned but
1043      smaller  - the current size is already the same size as or bigger
1044      than the alignment required.  */
1045
1046   /* calculate the first byte following the padding before we optimize */
1047   old_end = ((dot + size ) & ~size) + size+1;
1048   /* work out where the new end will be - remember that we're smaller
1049      than we used to be */
1050   new_end = ((dot - shrink + size) & ~size);
1051
1052   /* This is the new end */
1053   gap = old_end - ((dot + size) & ~size);
1054
1055   shrink_delta = (old_end - new_end) - shrink;
1056
1057   if (shrink_delta)
1058   {
1059     /* Change the reloc so that it knows how far to align to */
1060     r->howto = howto_done_align_table + (r->howto - howto_align_table);
1061
1062     /* Encode the stuff into the addend - for future use we need to
1063        know how big the reloc used to be */
1064     r->addend = old_end - dot + r->address;
1065
1066     /* This will be N bytes smaller in the long run, adjust all the symbols */
1067     perform_slip(symbols, shrink_delta, input_section, r->address - shrink );
1068     shrink += shrink_delta;
1069   }
1070   return shrink;
1071 }
1072
1073 static boolean
1074 b_out_relax_section (abfd, i, link_info, symbols)
1075      bfd *abfd;
1076      asection *i;
1077      struct bfd_link_info *link_info;
1078      asymbol **symbols;
1079 {
1080
1081   /* Get enough memory to hold the stuff */
1082   bfd *input_bfd = i->owner;
1083   asection *input_section = i;
1084   int shrink = 0 ;
1085   boolean new = false;
1086
1087   bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
1088                                                        input_section);
1089
1090   if (reloc_size)
1091     {
1092       arelent **reloc_vector = (arelent **)alloca(reloc_size);
1093
1094       /* Get the relocs and think about them */
1095       if (bfd_canonicalize_reloc(input_bfd, input_section, reloc_vector,
1096                                  symbols))
1097         {
1098           arelent **parent;
1099           for (parent = reloc_vector; *parent; parent++)
1100             {
1101               arelent *r = *parent;
1102               switch (r->howto->type)
1103                 {
1104                 case ALIGNER:
1105                   /* An alignment reloc */
1106                   shrink = aligncode(input_section, symbols, r,shrink);
1107                   new=true;
1108                   break;
1109                 case ABS32CODE:
1110                   /* A 32bit reloc in an addressing mode */
1111                   shrink = abs32code (input_section, symbols, r, shrink, link_info);
1112                   new=true;
1113                   break;
1114                 case ABS32CODE_SHRUNK:
1115                   shrink+=4;
1116                   break;
1117                 }
1118             }
1119         }
1120     }
1121   input_section->_cooked_size = input_section->_raw_size - shrink;
1122
1123   return new;
1124 }
1125
1126 static bfd_byte *
1127 b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data,
1128                                       relocateable, symbols)
1129      bfd *in_abfd;
1130      struct bfd_link_info *link_info;
1131      struct bfd_link_order *link_order;
1132      bfd_byte *data;
1133      boolean relocateable;
1134      asymbol **symbols;
1135 {
1136   /* Get enough memory to hold the stuff */
1137   bfd *input_bfd = link_order->u.indirect.section->owner;
1138   asection *input_section = link_order->u.indirect.section;
1139   bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
1140                                                        input_section);
1141   arelent **reloc_vector = (arelent **)alloca(reloc_size);
1142
1143   /* If producing relocateable output, don't bother to relax.  */
1144   if (relocateable)
1145     return bfd_generic_get_relocated_section_contents (in_abfd, link_info,
1146                                                        link_order,
1147                                                        data, relocateable,
1148                                                        symbols);
1149
1150   input_section->reloc_done = 1;
1151
1152   /* read in the section */
1153   BFD_ASSERT (true == bfd_get_section_contents(input_bfd,
1154                                                input_section,
1155                                                data,
1156                                                0,
1157                                                input_section->_raw_size));
1158
1159   if (bfd_canonicalize_reloc(input_bfd,
1160                              input_section,
1161                              reloc_vector,
1162                              symbols) )
1163     {
1164       arelent **parent = reloc_vector;
1165       arelent *reloc ;
1166
1167       unsigned int dst_address = 0;
1168       unsigned int src_address = 0;
1169       unsigned int run;
1170       unsigned int idx;
1171
1172       /* Find how long a run we can do */
1173       while (dst_address < link_order->size)
1174         {
1175           reloc = *parent;
1176           if (reloc)
1177             {
1178               /* Note that the relaxing didn't tie up the addresses in the
1179                  relocation, so we use the original address to work out the
1180                  run of non-relocated data */
1181               BFD_ASSERT (reloc->address >= src_address);
1182               run = reloc->address - src_address;
1183               parent++;
1184             }
1185           else
1186             {
1187               run = link_order->size - dst_address;
1188             }
1189           /* Copy the bytes */
1190           for (idx = 0; idx < run; idx++)
1191             {
1192               data[dst_address++] = data[src_address++];
1193             }
1194
1195           /* Now do the relocation */
1196
1197           if (reloc)
1198             {
1199               switch (reloc->howto->type)
1200                 {
1201                 case ABS32CODE:
1202                   calljx_callback (in_abfd, link_info, reloc,
1203                                    src_address + data, dst_address + data,
1204                                    input_section);
1205                   src_address+=4;
1206                   dst_address+=4;
1207                   break;
1208                 case ABS32:
1209                   bfd_put_32(in_abfd,
1210                              (bfd_get_32 (in_abfd, data+src_address)
1211                               + get_value (reloc, link_info, input_section)),
1212                              data+dst_address);
1213                   src_address+=4;
1214                   dst_address+=4;
1215                   break;
1216                 case CALLJ:
1217                   callj_callback (in_abfd, link_info, reloc, data, src_address,
1218                                   dst_address, input_section);
1219                   src_address+=4;
1220                   dst_address+=4;
1221                   break;
1222                 case ALIGNDONE:
1223                   BFD_ASSERT (reloc->addend >= src_address);
1224                   BFD_ASSERT (reloc->addend <= input_section->_raw_size);
1225                   src_address = reloc->addend;
1226                   dst_address = ((dst_address + reloc->howto->size)
1227                                  & ~reloc->howto->size);
1228                   break;
1229                 case ABS32CODE_SHRUNK:
1230                   /* This used to be a callx, but we've found out that a
1231                      callj will reach, so do the right thing.  */
1232                   callj_callback (in_abfd, link_info, reloc, data,
1233                                   src_address + 4, dst_address, input_section);
1234                   dst_address+=4;
1235                   src_address+=8;
1236                   break;
1237                 case PCREL24:
1238                   {
1239                     long int word = bfd_get_32(in_abfd, data+src_address);
1240                     bfd_vma value;
1241
1242                     value = get_value (reloc, link_info, input_section);
1243                     word = ((word & ~BAL_MASK)
1244                             | (((word & BAL_MASK)
1245                                 + value
1246                                 - output_addr (input_section)
1247                                 + reloc->addend)
1248                                & BAL_MASK));
1249
1250                     bfd_put_32(in_abfd,word,  data+dst_address);
1251                     dst_address+=4;
1252                     src_address+=4;
1253
1254                   }
1255                   break;
1256
1257                 case PCREL13:
1258                   {
1259                     long int word = bfd_get_32(in_abfd, data+src_address);
1260                     bfd_vma value;
1261
1262                     value = get_value (reloc, link_info, input_section);
1263                     word = ((word & ~PCREL13_MASK)
1264                             | (((word & PCREL13_MASK)
1265                                 + value
1266                                 + reloc->addend
1267                                 - output_addr (input_section))
1268                                & PCREL13_MASK));
1269
1270                     bfd_put_32(in_abfd,word,  data+dst_address);
1271                     dst_address+=4;
1272                     src_address+=4;
1273
1274                   }
1275                   break;
1276
1277                 default:
1278                   abort();
1279                 }
1280             }
1281         }
1282     }
1283   return data;
1284 }
1285 /***********************************************************************/
1286
1287 /* Build the transfer vectors for Big and Little-Endian B.OUT files.  */
1288
1289 /* We don't have core files.  */
1290 #define aout_32_core_file_failing_command _bfd_dummy_core_file_failing_command
1291 #define aout_32_core_file_failing_signal _bfd_dummy_core_file_failing_signal
1292 #define aout_32_core_file_matches_executable_p  \
1293                                 _bfd_dummy_core_file_matches_executable_p
1294
1295 /* We use BSD-Unix generic archive files.  */
1296 #define aout_32_openr_next_archived_file        bfd_generic_openr_next_archived_file
1297 #define aout_32_generic_stat_arch_elt   bfd_generic_stat_arch_elt
1298 #define aout_32_slurp_armap             bfd_slurp_bsd_armap
1299 #define aout_32_slurp_extended_name_table       _bfd_slurp_extended_name_table
1300 #define aout_32_write_armap             bsd_write_armap
1301 #define aout_32_truncate_arname         bfd_bsd_truncate_arname
1302
1303 /* We override these routines from the usual a.out file routines.  */
1304 #define aout_32_canonicalize_reloc      b_out_canonicalize_reloc
1305 #define aout_32_get_reloc_upper_bound   b_out_get_reloc_upper_bound
1306 #define aout_32_set_section_contents    b_out_set_section_contents
1307 #define aout_32_set_arch_mach           b_out_set_arch_mach
1308 #define aout_32_sizeof_headers          b_out_sizeof_headers
1309
1310 #define aout_32_bfd_debug_info_start            bfd_void
1311 #define aout_32_bfd_debug_info_end              bfd_void
1312 #define aout_32_bfd_debug_info_accumulate       (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
1313
1314 #define aout_32_bfd_get_relocated_section_contents  b_out_get_relocated_section_contents
1315 #define aout_32_bfd_relax_section                   b_out_relax_section
1316 #define aout_32_bfd_reloc_type_lookup               b_out_reloc_type_lookup
1317 #define aout_32_bfd_make_debug_symbol \
1318   ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
1319 #define aout_32_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1320 #define aout_32_bfd_link_add_symbols _bfd_generic_link_add_symbols
1321 #define aout_32_bfd_final_link _bfd_generic_final_link
1322
1323 bfd_target b_out_vec_big_host =
1324 {
1325   "b.out.big",                  /* name */
1326   bfd_target_aout_flavour,
1327   false,                        /* data byte order is little */
1328   true,                         /* hdr byte order is big */
1329   (HAS_RELOC | EXEC_P |         /* object flags */
1330    HAS_LINENO | HAS_DEBUG |
1331    HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
1332   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1333   '_',                          /* symbol leading char */
1334   ' ',                          /* ar_pad_char */
1335   16,                           /* ar_max_namelen */
1336   2,                            /* minumum alignment power */
1337
1338   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1339      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1340      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1341   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1342      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1343      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1344  {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
1345    bfd_generic_archive_p, _bfd_dummy_target},
1346  {bfd_false, b_out_mkobject,    /* bfd_set_format */
1347    _bfd_generic_mkarchive, bfd_false},
1348  {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
1349    _bfd_write_archive_contents, bfd_false},
1350
1351   JUMP_TABLE(aout_32),
1352   (PTR) 0,
1353 };
1354
1355
1356 bfd_target b_out_vec_little_host =
1357 {
1358   "b.out.little",               /* name */
1359   bfd_target_aout_flavour,
1360   false,                        /* data byte order is little */
1361   false,                        /* header byte order is little */
1362   (HAS_RELOC | EXEC_P |         /* object flags */
1363    HAS_LINENO | HAS_DEBUG |
1364    HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
1365   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1366   '_',                          /* symbol leading char */
1367   ' ',                          /* ar_pad_char */
1368   16,                           /* ar_max_namelen */
1369   2,                            /* minum align */
1370   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1371     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1372      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1373   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1374      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1375      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1376
1377   {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
1378      bfd_generic_archive_p, _bfd_dummy_target},
1379   {bfd_false, b_out_mkobject,   /* bfd_set_format */
1380      _bfd_generic_mkarchive, bfd_false},
1381   {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
1382      _bfd_write_archive_contents, bfd_false},
1383   JUMP_TABLE(aout_32),
1384   (PTR) 0
1385 };