bfd/bout.c

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