bfd/bout.c

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