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