bfd/bout.c

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