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