bfd/reloc.c

   1 /* BFD support for handling relocation entries.
   2    Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /*
  22 SECTION
  23         Relocations
  24
  25         BFD maintains relocations in much the same way it maintains
  26         symbols: they are left alone until required, then read in
  27         en-mass and translated into an internal form.  A common
  28         routine <<bfd_perform_relocation>> acts upon the
  29         canonical form to do the fixup.
  30
  31         Relocations are maintained on a per section basis,
  32         while symbols are maintained on a per BFD basis.
  33
  34         All that a back end has to do to fit the BFD interface is to create
  35         a <<struct reloc_cache_entry>> for each relocation
  36         in a particular section, and fill in the right bits of the structures.
  37
  38 @menu
  39 @* typedef arelent::
  40 @* howto manager::
  41 @end menu
  42
  43 */
  44
  45 /* DO compile in the reloc_code name table from libbfd.h.  */
  46 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
  47
  48 #include "bfd.h"
  49 #include "sysdep.h"
  50 #include "bfdlink.h"
  51 #include "libbfd.h"
  52 /*
  53 DOCDD
  54 INODE
  55         typedef arelent, howto manager, Relocations, Relocations
  56
  57 SUBSECTION
  58         typedef arelent
  59
  60         This is the structure of a relocation entry:
  61
  62 CODE_FRAGMENT
  63 .
  64 .typedef enum bfd_reloc_status
  65 .{
  66 .       {* No errors detected *}
  67 .  bfd_reloc_ok,
  68 .
  69 .       {* The relocation was performed, but there was an overflow. *}
  70 .  bfd_reloc_overflow,
  71 .
  72 .       {* The address to relocate was not within the section supplied. *}
  73 .  bfd_reloc_outofrange,
  74 .
  75 .       {* Used by special functions *}
  76 .  bfd_reloc_continue,
  77 .
  78 .       {* Unsupported relocation size requested. *}
  79 .  bfd_reloc_notsupported,
  80 .
  81 .       {* Unused *}
  82 .  bfd_reloc_other,
  83 .
  84 .       {* The symbol to relocate against was undefined. *}
  85 .  bfd_reloc_undefined,
  86 .
  87 .       {* The relocation was performed, but may not be ok - presently
  88 .          generated only when linking i960 coff files with i960 b.out
  89 .          symbols.  If this type is returned, the error_message argument
  90 .          to bfd_perform_relocation will be set.  *}
  91 .  bfd_reloc_dangerous
  92 . }
  93 . bfd_reloc_status_type;
  94 .
  95 .
  96 .typedef struct reloc_cache_entry
  97 .{
  98 .       {* A pointer into the canonical table of pointers  *}
  99 .  struct symbol_cache_entry **sym_ptr_ptr;
 100 .
 101 .       {* offset in section *}
 102 .  bfd_size_type address;
 103 .
 104 .       {* addend for relocation value *}
 105 .  bfd_vma addend;
 106 .
 107 .       {* Pointer to how to perform the required relocation *}
 108 .  const struct reloc_howto_struct *howto;
 109 .
 110 .} arelent;
 111
 112 */
 113
 114 /*
 115 DESCRIPTION
 116
 117         Here is a description of each of the fields within an <<arelent>>:
 118
 119         o <<sym_ptr_ptr>>
 120
 121         The symbol table pointer points to a pointer to the symbol
 122         associated with the relocation request.  It is
 123         the pointer into the table returned by the back end's
 124         <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
 125         through a pointer to a pointer so that tools like the linker
 126         can fix up all the symbols of the same name by modifying only
 127         one pointer. The relocation routine looks in the symbol and
 128         uses the base of the section the symbol is attached to and the
 129         value of the symbol as the initial relocation offset. If the
 130         symbol pointer is zero, then the section provided is looked up.
 131
 132         o <<address>>
 133
 134         The <<address>> field gives the offset in bytes from the base of
 135         the section data which owns the relocation record to the first
 136         byte of relocatable information. The actual data relocated
 137         will be relative to this point; for example, a relocation
 138         type which modifies the bottom two bytes of a four byte word
 139         would not touch the first byte pointed to in a big endian
 140         world.
 141
 142         o <<addend>>
 143
 144         The <<addend>> is a value provided by the back end to be added (!)
 145         to the relocation offset. Its interpretation is dependent upon
 146         the howto. For example, on the 68k the code:
 147
 148
 149 |        char foo[];
 150 |        main()
 151 |                {
 152 |                return foo[0x12345678];
 153 |                }
 154
 155         Could be compiled into:
 156
 157 |        linkw fp,#-4
 158 |        moveb @@#12345678,d0
 159 |        extbl d0
 160 |        unlk fp
 161 |        rts
 162
 163
 164         This could create a reloc pointing to <<foo>>, but leave the
 165         offset in the data, something like:
 166
 167
 168 |RELOCATION RECORDS FOR [.text]:
 169 |offset   type      value
 170 |00000006 32        _foo
 171 |
 172 |00000000 4e56 fffc          ; linkw fp,#-4
 173 |00000004 1039 1234 5678     ; moveb @@#12345678,d0
 174 |0000000a 49c0               ; extbl d0
 175 |0000000c 4e5e               ; unlk fp
 176 |0000000e 4e75               ; rts
 177
 178
 179         Using coff and an 88k, some instructions don't have enough
 180         space in them to represent the full address range, and
 181         pointers have to be loaded in two parts. So you'd get something like:
 182
 183
 184 |        or.u     r13,r0,hi16(_foo+0x12345678)
 185 |        ld.b     r2,r13,lo16(_foo+0x12345678)
 186 |        jmp      r1
 187
 188
 189         This should create two relocs, both pointing to <<_foo>>, and with
 190         0x12340000 in their addend field. The data would consist of:
 191
 192
 193 |RELOCATION RECORDS FOR [.text]:
 194 |offset   type      value
 195 |00000002 HVRT16    _foo+0x12340000
 196 |00000006 LVRT16    _foo+0x12340000
 197 |
 198 |00000000 5da05678           ; or.u r13,r0,0x5678
 199 |00000004 1c4d5678           ; ld.b r2,r13,0x5678
 200 |00000008 f400c001           ; jmp r1
 201
 202
 203         The relocation routine digs out the value from the data, adds
 204         it to the addend to get the original offset, and then adds the
 205         value of <<_foo>>. Note that all 32 bits have to be kept around
 206         somewhere, to cope with carry from bit 15 to bit 16.
 207
 208         One further example is the sparc and the a.out format. The
 209         sparc has a similar problem to the 88k, in that some
 210         instructions don't have room for an entire offset, but on the
 211         sparc the parts are created in odd sized lumps. The designers of
 212         the a.out format chose to not use the data within the section
 213         for storing part of the offset; all the offset is kept within
 214         the reloc. Anything in the data should be ignored.
 215
 216 |        save %sp,-112,%sp
 217 |        sethi %hi(_foo+0x12345678),%g2
 218 |        ldsb [%g2+%lo(_foo+0x12345678)],%i0
 219 |        ret
 220 |        restore
 221
 222         Both relocs contain a pointer to <<foo>>, and the offsets
 223         contain junk.
 224
 225
 226 |RELOCATION RECORDS FOR [.text]:
 227 |offset   type      value
 228 |00000004 HI22      _foo+0x12345678
 229 |00000008 LO10      _foo+0x12345678
 230 |
 231 |00000000 9de3bf90     ; save %sp,-112,%sp
 232 |00000004 05000000     ; sethi %hi(_foo+0),%g2
 233 |00000008 f048a000     ; ldsb [%g2+%lo(_foo+0)],%i0
 234 |0000000c 81c7e008     ; ret
 235 |00000010 81e80000     ; restore
 236
 237
 238         o <<howto>>
 239
 240         The <<howto>> field can be imagined as a
 241         relocation instruction. It is a pointer to a structure which
 242         contains information on what to do with all of the other
 243         information in the reloc record and data section. A back end
 244         would normally have a relocation instruction set and turn
 245         relocations into pointers to the correct structure on input -
 246         but it would be possible to create each howto field on demand.
 247
 248 */
 249
 250 /*
 251 SUBSUBSECTION
 252         <<enum complain_overflow>>
 253
 254         Indicates what sort of overflow checking should be done when
 255         performing a relocation.
 256
 257 CODE_FRAGMENT
 258 .
 259 .enum complain_overflow
 260 .{
 261 .       {* Do not complain on overflow. *}
 262 .  complain_overflow_dont,
 263 .
 264 .       {* Complain if the bitfield overflows, whether it is considered
 265 .          as signed or unsigned. *}
 266 .  complain_overflow_bitfield,
 267 .
 268 .       {* Complain if the value overflows when considered as signed
 269 .          number. *}
 270 .  complain_overflow_signed,
 271 .
 272 .       {* Complain if the value overflows when considered as an
 273 .          unsigned number. *}
 274 .  complain_overflow_unsigned
 275 .};
 276
 277 */
 278
 279 /*
 280 SUBSUBSECTION
 281         <<reloc_howto_type>>
 282
 283         The <<reloc_howto_type>> is a structure which contains all the
 284         information that libbfd needs to know to tie up a back end's data.
 285
 286 CODE_FRAGMENT
 287 .struct symbol_cache_entry;             {* Forward declaration *}
 288 .
 289 .typedef unsigned char bfd_byte;
 290 .typedef struct reloc_howto_struct reloc_howto_type;
 291 .
 292 .struct reloc_howto_struct
 293 .{
 294 .       {*  The type field has mainly a documetary use - the back end can
 295 .           do what it wants with it, though normally the back end's
 296 .           external idea of what a reloc number is stored
 297 .           in this field. For example, a PC relative word relocation
 298 .           in a coff environment has the type 023 - because that's
 299 .           what the outside world calls a R_PCRWORD reloc. *}
 300 .  unsigned int type;
 301 .
 302 .       {*  The value the final relocation is shifted right by. This drops
 303 .           unwanted data from the relocation.  *}
 304 .  unsigned int rightshift;
 305 .
 306 .       {*  The size of the item to be relocated.  This is *not* a
 307 .           power-of-two measure.  To get the number of bytes operated
 308 .           on by a type of relocation, use bfd_get_reloc_size.  *}
 309 .  int size;
 310 .
 311 .       {*  The number of bits in the item to be relocated.  This is used
 312 .           when doing overflow checking.  *}
 313 .  unsigned int bitsize;
 314 .
 315 .       {*  Notes that the relocation is relative to the location in the
 316 .           data section of the addend. The relocation function will
 317 .           subtract from the relocation value the address of the location
 318 .           being relocated. *}
 319 .  boolean pc_relative;
 320 .
 321 .       {*  The bit position of the reloc value in the destination.
 322 .           The relocated value is left shifted by this amount. *}
 323 .  unsigned int bitpos;
 324 .
 325 .       {* What type of overflow error should be checked for when
 326 .          relocating. *}
 327 .  enum complain_overflow complain_on_overflow;
 328 .
 329 .       {* If this field is non null, then the supplied function is
 330 .          called rather than the normal function. This allows really
 331 .          strange relocation methods to be accomodated (e.g., i960 callj
 332 .          instructions). *}
 333 .  bfd_reloc_status_type (*special_function)
 334 .                                   PARAMS ((bfd *abfd,
 335 .                                            arelent *reloc_entry,
 336 .                                            struct symbol_cache_entry *symbol,
 337 .                                            PTR data,
 338 .                                            asection *input_section,
 339 .                                            bfd *output_bfd,
 340 .                                            char **error_message));
 341 .
 342 .       {* The textual name of the relocation type. *}
 343 .  char *name;
 344 .
 345 .       {* When performing a partial link, some formats must modify the
 346 .          relocations rather than the data - this flag signals this.*}
 347 .  boolean partial_inplace;
 348 .
 349 .       {* The src_mask selects which parts of the read in data
 350 .          are to be used in the relocation sum.  E.g., if this was an 8 bit
 351 .          bit of data which we read and relocated, this would be
 352 .          0x000000ff. When we have relocs which have an addend, such as
 353 .          sun4 extended relocs, the value in the offset part of a
 354 .          relocating field is garbage so we never use it. In this case
 355 .          the mask would be 0x00000000. *}
 356 .  bfd_vma src_mask;
 357 .
 358 .       {* The dst_mask selects which parts of the instruction are replaced
 359 .          into the instruction. In most cases src_mask == dst_mask,
 360 .          except in the above special case, where dst_mask would be
 361 .          0x000000ff, and src_mask would be 0x00000000.   *}
 362 .  bfd_vma dst_mask;
 363 .
 364 .       {* When some formats create PC relative instructions, they leave
 365 .          the value of the pc of the place being relocated in the offset
 366 .          slot of the instruction, so that a PC relative relocation can
 367 .          be made just by adding in an ordinary offset (e.g., sun3 a.out).
 368 .          Some formats leave the displacement part of an instruction
 369 .          empty (e.g., m88k bcs); this flag signals the fact.*}
 370 .  boolean pcrel_offset;
 371 .
 372 .};
 373
 374 */
 375
 376 /*
 377 FUNCTION
 378         The HOWTO Macro
 379
 380 DESCRIPTION
 381         The HOWTO define is horrible and will go away.
 382
 383
 384 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
 385 .  {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
 386
 387 DESCRIPTION
 388         And will be replaced with the totally magic way. But for the
 389         moment, we are compatible, so do it this way.
 390
 391
 392 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
 393 .
 394 DESCRIPTION
 395         Helper routine to turn a symbol into a relocation value.
 396
 397 .#define HOWTO_PREPARE(relocation, symbol)      \
 398 .  {                                            \
 399 .  if (symbol != (asymbol *)NULL) {             \
 400 .    if (bfd_is_com_section (symbol->section)) { \
 401 .      relocation = 0;                          \
 402 .    }                                          \
 403 .    else {                                     \
 404 .      relocation = symbol->value;              \
 405 .    }                                          \
 406 .  }                                            \
 407 .}
 408
 409 */
 410
 411 /*
 412 FUNCTION
 413         bfd_get_reloc_size
 414
 415 SYNOPSIS
 416         int bfd_get_reloc_size (const reloc_howto_type *);
 417
 418 DESCRIPTION
 419         For a reloc_howto_type that operates on a fixed number of bytes,
 420         this returns the number of bytes operated on.
 421  */
 422
 423 int
 424 bfd_get_reloc_size (howto)
 425      const reloc_howto_type *howto;
 426 {
 427   switch (howto->size)
 428     {
 429     case 0: return 1;
 430     case 1: return 2;
 431     case 2: return 4;
 432     case 3: return 0;
 433     case 4: return 8;
 434     case -2: return 4;
 435     default: abort ();
 436     }
 437 }
 438
 439 /*
 440 TYPEDEF
 441         arelent_chain
 442
 443 DESCRIPTION
 444
 445         How relocs are tied together in an <<asection>>:
 446
 447 .typedef struct relent_chain {
 448 .  arelent relent;
 449 .  struct   relent_chain *next;
 450 .} arelent_chain;
 451
 452 */
 453
 454
 455
 456 /*
 457 FUNCTION
 458         bfd_perform_relocation
 459
 460 SYNOPSIS
 461         bfd_reloc_status_type
 462                 bfd_perform_relocation
 463                         (bfd *abfd,
 464                          arelent *reloc_entry,
 465                          PTR data,
 466                          asection *input_section,
 467                          bfd *output_bfd,
 468                          char **error_message);
 469
 470 DESCRIPTION
 471         If @var{output_bfd} is supplied to this function, the
 472         generated image will be relocatable; the relocations are
 473         copied to the output file after they have been changed to
 474         reflect the new state of the world. There are two ways of
 475         reflecting the results of partial linkage in an output file:
 476         by modifying the output data in place, and by modifying the
 477         relocation record.  Some native formats (e.g., basic a.out and
 478         basic coff) have no way of specifying an addend in the
 479         relocation type, so the addend has to go in the output data.
 480         This is no big deal since in these formats the output data
 481         slot will always be big enough for the addend. Complex reloc
 482         types with addends were invented to solve just this problem.
 483         The @var{error_message} argument is set to an error message if
 484         this return @code{bfd_reloc_dangerous}.
 485
 486 */
 487
 488
 489 bfd_reloc_status_type
 490 bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
 491                         error_message)
 492      bfd *abfd;
 493      arelent *reloc_entry;
 494      PTR data;
 495      asection *input_section;
 496      bfd *output_bfd;
 497      char **error_message;
 498 {
 499   bfd_vma relocation;
 500   bfd_reloc_status_type flag = bfd_reloc_ok;
 501   bfd_size_type addr = reloc_entry->address;
 502   bfd_vma output_base = 0;
 503   const reloc_howto_type *howto = reloc_entry->howto;
 504   asection *reloc_target_output_section;
 505   asymbol *symbol;
 506
 507   symbol = *(reloc_entry->sym_ptr_ptr);
 508   if (bfd_is_abs_section (symbol->section)
 509       && output_bfd != (bfd *) NULL)
 510     {
 511       reloc_entry->address += input_section->output_offset;
 512       return bfd_reloc_ok;
 513     }
 514
 515   /* If we are not producing relocateable output, return an error if
 516      the symbol is not defined.  An undefined weak symbol is
 517      considered to have a value of zero (SVR4 ABI, p. 4-27).  */
 518   if (bfd_is_und_section (symbol->section)
 519       && (symbol->flags & BSF_WEAK) == 0
 520       && output_bfd == (bfd *) NULL)
 521     flag = bfd_reloc_undefined;
 522
 523   /* If there is a function supplied to handle this relocation type,
 524      call it.  It'll return `bfd_reloc_continue' if further processing
 525      can be done.  */
 526   if (howto->special_function)
 527     {
 528       bfd_reloc_status_type cont;
 529       cont = howto->special_function (abfd, reloc_entry, symbol, data,
 530                                       input_section, output_bfd,
 531                                       error_message);
 532       if (cont != bfd_reloc_continue)
 533         return cont;
 534     }
 535
 536   /* Is the address of the relocation really within the section?  */
 537   if (reloc_entry->address > input_section->_cooked_size)
 538     return bfd_reloc_outofrange;
 539
 540   /* Work out which section the relocation is targetted at and the
 541      initial relocation command value.  */
 542
 543   /* Get symbol value.  (Common symbols are special.)  */
 544   if (bfd_is_com_section (symbol->section))
 545     relocation = 0;
 546   else
 547     relocation = symbol->value;
 548
 549
 550   reloc_target_output_section = symbol->section->output_section;
 551
 552   /* Convert input-section-relative symbol value to absolute.  */
 553   if (output_bfd && howto->partial_inplace == false)
 554     output_base = 0;
 555   else
 556     output_base = reloc_target_output_section->vma;
 557
 558   relocation += output_base + symbol->section->output_offset;
 559
 560   /* Add in supplied addend.  */
 561   relocation += reloc_entry->addend;
 562
 563   /* Here the variable relocation holds the final address of the
 564      symbol we are relocating against, plus any addend.  */
 565
 566   if (howto->pc_relative == true)
 567     {
 568       /* This is a PC relative relocation.  We want to set RELOCATION
 569          to the distance between the address of the symbol and the
 570          location.  RELOCATION is already the address of the symbol.
 571
 572          We start by subtracting the address of the section containing
 573          the location.
 574
 575          If pcrel_offset is set, we must further subtract the position
 576          of the location within the section.  Some targets arrange for
 577          the addend to be the negative of the position of the location
 578          within the section; for example, i386-aout does this.  For
 579          i386-aout, pcrel_offset is false.  Some other targets do not
 580          include the position of the location; for example, m88kbcs,
 581          or ELF.  For those targets, pcrel_offset is true.
 582
 583          If we are producing relocateable output, then we must ensure
 584          that this reloc will be correctly computed when the final
 585          relocation is done.  If pcrel_offset is false we want to wind
 586          up with the negative of the location within the section,
 587          which means we must adjust the existing addend by the change
 588          in the location within the section.  If pcrel_offset is true
 589          we do not want to adjust the existing addend at all.
 590
 591          FIXME: This seems logical to me, but for the case of
 592          producing relocateable output it is not what the code
 593          actually does.  I don't want to change it, because it seems
 594          far too likely that something will break.  */
 595
 596       relocation -=
 597         input_section->output_section->vma + input_section->output_offset;
 598
 599       if (howto->pcrel_offset == true)
 600         relocation -= reloc_entry->address;
 601     }
 602
 603   if (output_bfd != (bfd *) NULL)
 604     {
 605       if (howto->partial_inplace == false)
 606         {
 607           /* This is a partial relocation, and we want to apply the relocation
 608              to the reloc entry rather than the raw data. Modify the reloc
 609              inplace to reflect what we now know.  */
 610           reloc_entry->addend = relocation;
 611           reloc_entry->address += input_section->output_offset;
 612           return flag;
 613         }
 614       else
 615         {
 616           /* This is a partial relocation, but inplace, so modify the
 617              reloc record a bit.
 618
 619              If we've relocated with a symbol with a section, change
 620              into a ref to the section belonging to the symbol.  */
 621
 622           reloc_entry->address += input_section->output_offset;
 623
 624           /* WTF?? */
 625           if (abfd->xvec->flavour == bfd_target_coff_flavour
 626               && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
 627               && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
 628               && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
 629             {
 630 #if 1
 631               /* For m68k-coff, the addend was being subtracted twice during
 632                  relocation with -r.  Removing the line below this comment
 633                  fixes that problem; see PR 2953.
 634
 635 However, Ian wrote the following, regarding removing the line below,
 636 which explains why it is still enabled:  --djm
 637
 638 If you put a patch like that into BFD you need to check all the COFF
 639 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
 640 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
 641 problem in a different way.  There may very well be a reason that the
 642 code works as it does.
 643
 644 Hmmm.  The first obvious point is that bfd_perform_relocation should
 645 not have any tests that depend upon the flavour.  It's seem like
 646 entirely the wrong place for such a thing.  The second obvious point
 647 is that the current code ignores the reloc addend when producing
 648 relocateable output for COFF.  That's peculiar.  In fact, I really
 649 have no idea what the point of the line you want to remove is.
 650
 651 A typical COFF reloc subtracts the old value of the symbol and adds in
 652 the new value to the location in the object file (if it's a pc
 653 relative reloc it adds the difference between the symbol value and the
 654 location).  When relocating we need to preserve that property.
 655
 656 BFD handles this by setting the addend to the negative of the old
 657 value of the symbol.  Unfortunately it handles common symbols in a
 658 non-standard way (it doesn't subtract the old value) but that's a
 659 different story (we can't change it without losing backward
 660 compatibility with old object files) (coff-i386 does subtract the old
 661 value, to be compatible with existing coff-i386 targets, like SCO).
 662
 663 So everything works fine when not producing relocateable output.  When
 664 we are producing relocateable output, logically we should do exactly
 665 what we do when not producing relocateable output.  Therefore, your
 666 patch is correct.  In fact, it should probably always just set
 667 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
 668 add the value into the object file.  This won't hurt the COFF code,
 669 which doesn't use the addend; I'm not sure what it will do to other
 670 formats (the thing to check for would be whether any formats both use
 671 the addend and set partial_inplace).
 672
 673 When I wanted to make coff-i386 produce relocateable output, I ran
 674 into the problem that you are running into: I wanted to remove that
 675 line.  Rather than risk it, I made the coff-i386 relocs use a special
 676 function; it's coff_i386_reloc in coff-i386.c.  The function
 677 specifically adds the addend field into the object file, knowing that
 678 bfd_perform_relocation is not going to.  If you remove that line, then
 679 coff-i386.c will wind up adding the addend field in twice.  It's
 680 trivial to fix; it just needs to be done.
 681
 682 The problem with removing the line is just that it may break some
 683 working code.  With BFD it's hard to be sure of anything.  The right
 684 way to deal with this is simply to build and test at least all the
 685 supported COFF targets.  It should be straightforward if time and disk
 686 space consuming.  For each target:
 687     1) build the linker
 688     2) generate some executable, and link it using -r (I would
 689        probably use paranoia.o and link against newlib/libc.a, which
 690        for all the supported targets would be available in
 691        /usr/cygnus/progressive/H-host/target/lib/libc.a).
 692     3) make the change to reloc.c
 693     4) rebuild the linker
 694     5) repeat step 2
 695     6) if the resulting object files are the same, you have at least
 696        made it no worse
 697     7) if they are different you have to figure out which version is
 698        right
 699 */
 700               relocation -= reloc_entry->addend;
 701 #endif
 702               reloc_entry->addend = 0;
 703             }
 704           else
 705             {
 706               reloc_entry->addend = relocation;
 707             }
 708         }
 709     }
 710   else
 711     {
 712       reloc_entry->addend = 0;
 713     }
 714
 715   /* FIXME: This overflow checking is incomplete, because the value
 716      might have overflowed before we get here.  For a correct check we
 717      need to compute the value in a size larger than bitsize, but we
 718      can't reasonably do that for a reloc the same size as a host
 719      machine word.
 720      FIXME: We should also do overflow checking on the result after
 721      adding in the value contained in the object file.  */
 722   if (howto->complain_on_overflow != complain_overflow_dont)
 723     {
 724       bfd_vma check;
 725
 726       /* Get the value that will be used for the relocation, but
 727          starting at bit position zero.  */
 728       if (howto->rightshift > howto->bitpos)
 729         check = relocation >> (howto->rightshift - howto->bitpos);
 730       else
 731         check = relocation << (howto->bitpos - howto->rightshift);
 732       switch (howto->complain_on_overflow)
 733         {
 734         case complain_overflow_signed:
 735           {
 736             /* Assumes two's complement.  */
 737             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
 738             bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
 739
 740             /* The above right shift is incorrect for a signed value.
 741                Fix it up by forcing on the upper bits.  */
 742             if (howto->rightshift > howto->bitpos
 743                 && (bfd_signed_vma) relocation < 0)
 744               check |= ((bfd_vma) - 1
 745                         & ~((bfd_vma) - 1
 746                             >> (howto->rightshift - howto->bitpos)));
 747             if ((bfd_signed_vma) check > reloc_signed_max
 748                 || (bfd_signed_vma) check < reloc_signed_min)
 749               flag = bfd_reloc_overflow;
 750           }
 751           break;
 752         case complain_overflow_unsigned:
 753           {
 754             /* Assumes two's complement.  This expression avoids
 755                overflow if howto->bitsize is the number of bits in
 756                bfd_vma.  */
 757             bfd_vma reloc_unsigned_max =
 758             (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
 759
 760             if ((bfd_vma) check > reloc_unsigned_max)
 761               flag = bfd_reloc_overflow;
 762           }
 763           break;
 764         case complain_overflow_bitfield:
 765           {
 766             /* Assumes two's complement.  This expression avoids
 767                overflow if howto->bitsize is the number of bits in
 768                bfd_vma.  */
 769             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
 770
 771             if (((bfd_vma) check & ~reloc_bits) != 0
 772                 && ((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
 773               {
 774                 /* The above right shift is incorrect for a signed
 775                    value.  See if turning on the upper bits fixes the
 776                    overflow.  */
 777                 if (howto->rightshift > howto->bitpos
 778                     && (bfd_signed_vma) relocation < 0)
 779                   {
 780                     check |= ((bfd_vma) - 1
 781                               & ~((bfd_vma) - 1
 782                                   >> (howto->rightshift - howto->bitpos)));
 783                     if (((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
 784                       flag = bfd_reloc_overflow;
 785                   }
 786                 else
 787                   flag = bfd_reloc_overflow;
 788               }
 789           }
 790           break;
 791         default:
 792           abort ();
 793         }
 794     }
 795
 796   /*
 797     Either we are relocating all the way, or we don't want to apply
 798     the relocation to the reloc entry (probably because there isn't
 799     any room in the output format to describe addends to relocs)
 800     */
 801
 802   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
 803      (OSF version 1.3, compiler version 3.11).  It miscompiles the
 804      following program:
 805
 806      struct str
 807      {
 808        unsigned int i0;
 809      } s = { 0 };
 810
 811      int
 812      main ()
 813      {
 814        unsigned long x;
 815
 816        x = 0x100000000;
 817        x <<= (unsigned long) s.i0;
 818        if (x == 0)
 819          printf ("failed\n");
 820        else
 821          printf ("succeeded (%lx)\n", x);
 822      }
 823      */
 824
 825   relocation >>= (bfd_vma) howto->rightshift;
 826
 827   /* Shift everything up to where it's going to be used */
 828
 829   relocation <<= (bfd_vma) howto->bitpos;
 830
 831   /* Wait for the day when all have the mask in them */
 832
 833   /* What we do:
 834      i instruction to be left alone
 835      o offset within instruction
 836      r relocation offset to apply
 837      S src mask
 838      D dst mask
 839      N ~dst mask
 840      A part 1
 841      B part 2
 842      R result
 843
 844      Do this:
 845      i i i i i o o o o o        from bfd_get<size>
 846      and           S S S S S    to get the size offset we want
 847      +   r r r r r r r r r r  to get the final value to place
 848      and           D D D D D  to chop to right size
 849      -----------------------
 850      A A A A A
 851      And this:
 852      ...   i i i i i o o o o o  from bfd_get<size>
 853      and   N N N N N            get instruction
 854      -----------------------
 855      ...   B B B B B
 856
 857      And then:
 858      B B B B B
 859      or              A A A A A
 860      -----------------------
 861      R R R R R R R R R R        put into bfd_put<size>
 862      */
 863
 864 #define DOIT(x) \
 865   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
 866
 867   switch (howto->size)
 868     {
 869     case 0:
 870       {
 871         char x = bfd_get_8 (abfd, (char *) data + addr);
 872         DOIT (x);
 873         bfd_put_8 (abfd, x, (unsigned char *) data + addr);
 874       }
 875       break;
 876
 877     case 1:
 878       if (relocation)
 879         {
 880           short x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
 881           DOIT (x);
 882           bfd_put_16 (abfd, x, (unsigned char *) data + addr);
 883         }
 884       break;
 885     case 2:
 886       if (relocation)
 887         {
 888           long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 889           DOIT (x);
 890           bfd_put_32 (abfd, x, (bfd_byte *) data + addr);
 891         }
 892       break;
 893     case -2:
 894       {
 895         long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 896         relocation = -relocation;
 897         DOIT (x);
 898         bfd_put_32 (abfd, x, (bfd_byte *) data + addr);
 899       }
 900       break;
 901
 902     case 3:
 903       /* Do nothing */
 904       break;
 905
 906     case 4:
 907 #ifdef BFD64
 908       if (relocation)
 909         {
 910           bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + addr);
 911           DOIT (x);
 912           bfd_put_64 (abfd, x, (bfd_byte *) data + addr);
 913         }
 914 #else
 915       abort ();
 916 #endif
 917       break;
 918     default:
 919       return bfd_reloc_other;
 920     }
 921
 922   return flag;
 923 }
 924
 925 /*
 926 FUNCTION
 927         bfd_install_relocation
 928
 929 SYNOPSIS
 930         bfd_reloc_status_type
 931                 bfd_install_relocation
 932                         (bfd *abfd,
 933                          arelent *reloc_entry,
 934                          PTR data, bfd_vma data_start,
 935                          asection *input_section,
 936                          char **error_message);
 937
 938 DESCRIPTION
 939         This looks remarkably like <<bfd_perform_relocation>>, except it
 940         does not expect that the section contents have been filled in.
 941         I.e., it's suitable for use when creating, rather than applying
 942         a relocation.
 943
 944         For now, this function should be considered reserved for the
 945         assembler.
 946
 947 */
 948
 949
 950 bfd_reloc_status_type
 951 bfd_install_relocation (abfd, reloc_entry, data_start, data_start_offset,
 952                         input_section, error_message)
 953      bfd *abfd;
 954      arelent *reloc_entry;
 955      PTR data_start;
 956      bfd_vma data_start_offset;
 957      asection *input_section;
 958      char **error_message;
 959 {
 960   bfd_vma relocation;
 961   bfd_reloc_status_type flag = bfd_reloc_ok;
 962   bfd_size_type addr = reloc_entry->address;
 963   bfd_vma output_base = 0;
 964   const reloc_howto_type *howto = reloc_entry->howto;
 965   asection *reloc_target_output_section;
 966   asymbol *symbol;
 967   PTR data;
 968
 969   symbol = *(reloc_entry->sym_ptr_ptr);
 970   if (bfd_is_abs_section (symbol->section))
 971     {
 972       reloc_entry->address += input_section->output_offset;
 973       return bfd_reloc_ok;
 974     }
 975
 976   /* If there is a function supplied to handle this relocation type,
 977      call it.  It'll return `bfd_reloc_continue' if further processing
 978      can be done.  */
 979   if (howto->special_function)
 980     {
 981       bfd_reloc_status_type cont;
 982       /* XXX - The special_function calls haven't been fixed up to deal
 983          with creating new relocations and section contents.  */
 984       cont = howto->special_function (abfd, reloc_entry, symbol,
 985                                       /* XXX - Non-portable! */
 986                                       ((bfd_byte *) data_start
 987                                        - data_start_offset),
 988                                       input_section, abfd, error_message);
 989       if (cont != bfd_reloc_continue)
 990         return cont;
 991     }
 992
 993   /* Is the address of the relocation really within the section?  */
 994   if (reloc_entry->address > input_section->_cooked_size)
 995     return bfd_reloc_outofrange;
 996
 997   /* Work out which section the relocation is targetted at and the
 998      initial relocation command value.  */
 999
1000   /* Get symbol value.  (Common symbols are special.)  */
1001   if (bfd_is_com_section (symbol->section))
1002     relocation = 0;
1003   else
1004     relocation = symbol->value;
1005
1006
1007   reloc_target_output_section = symbol->section->output_section;
1008
1009   /* Convert input-section-relative symbol value to absolute.  */
1010   if (howto->partial_inplace == false)
1011     output_base = 0;
1012   else
1013     output_base = reloc_target_output_section->vma;
1014
1015   relocation += output_base + symbol->section->output_offset;
1016
1017   /* Add in supplied addend.  */
1018   relocation += reloc_entry->addend;
1019
1020   /* Here the variable relocation holds the final address of the
1021      symbol we are relocating against, plus any addend.  */
1022
1023   if (howto->pc_relative == true)
1024     {
1025       /* This is a PC relative relocation.  We want to set RELOCATION
1026          to the distance between the address of the symbol and the
1027          location.  RELOCATION is already the address of the symbol.
1028
1029          We start by subtracting the address of the section containing
1030          the location.
1031
1032          If pcrel_offset is set, we must further subtract the position
1033          of the location within the section.  Some targets arrange for
1034          the addend to be the negative of the position of the location
1035          within the section; for example, i386-aout does this.  For
1036          i386-aout, pcrel_offset is false.  Some other targets do not
1037          include the position of the location; for example, m88kbcs,
1038          or ELF.  For those targets, pcrel_offset is true.
1039
1040          If we are producing relocateable output, then we must ensure
1041          that this reloc will be correctly computed when the final
1042          relocation is done.  If pcrel_offset is false we want to wind
1043          up with the negative of the location within the section,
1044          which means we must adjust the existing addend by the change
1045          in the location within the section.  If pcrel_offset is true
1046          we do not want to adjust the existing addend at all.
1047
1048          FIXME: This seems logical to me, but for the case of
1049          producing relocateable output it is not what the code
1050          actually does.  I don't want to change it, because it seems
1051          far too likely that something will break.  */
1052
1053       relocation -=
1054         input_section->output_section->vma + input_section->output_offset;
1055
1056       if (howto->pcrel_offset == true && howto->partial_inplace == true)
1057         relocation -= reloc_entry->address;
1058     }
1059
1060   if (howto->partial_inplace == false)
1061     {
1062       /* This is a partial relocation, and we want to apply the relocation
1063          to the reloc entry rather than the raw data. Modify the reloc
1064          inplace to reflect what we now know.  */
1065       reloc_entry->addend = relocation;
1066       reloc_entry->address += input_section->output_offset;
1067       return flag;
1068     }
1069   else
1070     {
1071       /* This is a partial relocation, but inplace, so modify the
1072          reloc record a bit.
1073
1074          If we've relocated with a symbol with a section, change
1075          into a ref to the section belonging to the symbol.  */
1076
1077       reloc_entry->address += input_section->output_offset;
1078
1079       /* WTF?? */
1080       if (abfd->xvec->flavour == bfd_target_coff_flavour
1081           && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
1082           && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1083           && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1084         {
1085 #if 1
1086 /* For m68k-coff, the addend was being subtracted twice during
1087    relocation with -r.  Removing the line below this comment
1088    fixes that problem; see PR 2953.
1089
1090 However, Ian wrote the following, regarding removing the line below,
1091 which explains why it is still enabled:  --djm
1092
1093 If you put a patch like that into BFD you need to check all the COFF
1094 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
1095 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1096 problem in a different way.  There may very well be a reason that the
1097 code works as it does.
1098
1099 Hmmm.  The first obvious point is that bfd_install_relocation should
1100 not have any tests that depend upon the flavour.  It's seem like
1101 entirely the wrong place for such a thing.  The second obvious point
1102 is that the current code ignores the reloc addend when producing
1103 relocateable output for COFF.  That's peculiar.  In fact, I really
1104 have no idea what the point of the line you want to remove is.
1105
1106 A typical COFF reloc subtracts the old value of the symbol and adds in
1107 the new value to the location in the object file (if it's a pc
1108 relative reloc it adds the difference between the symbol value and the
1109 location).  When relocating we need to preserve that property.
1110
1111 BFD handles this by setting the addend to the negative of the old
1112 value of the symbol.  Unfortunately it handles common symbols in a
1113 non-standard way (it doesn't subtract the old value) but that's a
1114 different story (we can't change it without losing backward
1115 compatibility with old object files) (coff-i386 does subtract the old
1116 value, to be compatible with existing coff-i386 targets, like SCO).
1117
1118 So everything works fine when not producing relocateable output.  When
1119 we are producing relocateable output, logically we should do exactly
1120 what we do when not producing relocateable output.  Therefore, your
1121 patch is correct.  In fact, it should probably always just set
1122 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1123 add the value into the object file.  This won't hurt the COFF code,
1124 which doesn't use the addend; I'm not sure what it will do to other
1125 formats (the thing to check for would be whether any formats both use
1126 the addend and set partial_inplace).
1127
1128 When I wanted to make coff-i386 produce relocateable output, I ran
1129 into the problem that you are running into: I wanted to remove that
1130 line.  Rather than risk it, I made the coff-i386 relocs use a special
1131 function; it's coff_i386_reloc in coff-i386.c.  The function
1132 specifically adds the addend field into the object file, knowing that
1133 bfd_install_relocation is not going to.  If you remove that line, then
1134 coff-i386.c will wind up adding the addend field in twice.  It's
1135 trivial to fix; it just needs to be done.
1136
1137 The problem with removing the line is just that it may break some
1138 working code.  With BFD it's hard to be sure of anything.  The right
1139 way to deal with this is simply to build and test at least all the
1140 supported COFF targets.  It should be straightforward if time and disk
1141 space consuming.  For each target:
1142     1) build the linker
1143     2) generate some executable, and link it using -r (I would
1144        probably use paranoia.o and link against newlib/libc.a, which
1145        for all the supported targets would be available in
1146        /usr/cygnus/progressive/H-host/target/lib/libc.a).
1147     3) make the change to reloc.c
1148     4) rebuild the linker
1149     5) repeat step 2
1150     6) if the resulting object files are the same, you have at least
1151        made it no worse
1152     7) if they are different you have to figure out which version is
1153        right
1154 */
1155           relocation -= reloc_entry->addend;
1156 #endif
1157           reloc_entry->addend = 0;
1158         }
1159       else
1160         {
1161           reloc_entry->addend = relocation;
1162         }
1163     }
1164
1165   /* FIXME: This overflow checking is incomplete, because the value
1166      might have overflowed before we get here.  For a correct check we
1167      need to compute the value in a size larger than bitsize, but we
1168      can't reasonably do that for a reloc the same size as a host
1169      machine word.
1170
1171      FIXME: We should also do overflow checking on the result after
1172      adding in the value contained in the object file.  */
1173   if (howto->complain_on_overflow != complain_overflow_dont)
1174     {
1175       bfd_vma check;
1176
1177       /* Get the value that will be used for the relocation, but
1178          starting at bit position zero.  */
1179       if (howto->rightshift > howto->bitpos)
1180         check = relocation >> (howto->rightshift - howto->bitpos);
1181       else
1182         check = relocation << (howto->bitpos - howto->rightshift);
1183       switch (howto->complain_on_overflow)
1184         {
1185         case complain_overflow_signed:
1186           {
1187             /* Assumes two's complement.  */
1188             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1189             bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1190
1191             /* The above right shift is incorrect for a signed value.
1192                Fix it up by forcing on the upper bits.  */
1193             if (howto->rightshift > howto->bitpos
1194                 && (bfd_signed_vma) relocation < 0)
1195               check |= ((bfd_vma) - 1
1196                         & ~((bfd_vma) - 1
1197                             >> (howto->rightshift - howto->bitpos)));
1198             if ((bfd_signed_vma) check > reloc_signed_max
1199                 || (bfd_signed_vma) check < reloc_signed_min)
1200               flag = bfd_reloc_overflow;
1201           }
1202           break;
1203         case complain_overflow_unsigned:
1204           {
1205             /* Assumes two's complement.  This expression avoids
1206                overflow if howto->bitsize is the number of bits in
1207                bfd_vma.  */
1208             bfd_vma reloc_unsigned_max =
1209             (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1210
1211             if ((bfd_vma) check > reloc_unsigned_max)
1212               flag = bfd_reloc_overflow;
1213           }
1214           break;
1215         case complain_overflow_bitfield:
1216           {
1217             /* Assumes two's complement.  This expression avoids
1218                overflow if howto->bitsize is the number of bits in
1219                bfd_vma.  */
1220             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1221
1222             if (((bfd_vma) check & ~reloc_bits) != 0
1223                 && ((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
1224               {
1225                 /* The above right shift is incorrect for a signed
1226                    value.  See if turning on the upper bits fixes the
1227                    overflow.  */
1228                 if (howto->rightshift > howto->bitpos
1229                     && (bfd_signed_vma) relocation < 0)
1230                   {
1231                     check |= ((bfd_vma) - 1
1232                               & ~((bfd_vma) - 1
1233                                   >> (howto->rightshift - howto->bitpos)));
1234                     if (((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
1235                       flag = bfd_reloc_overflow;
1236                   }
1237                 else
1238                   flag = bfd_reloc_overflow;
1239               }
1240           }
1241           break;
1242         default:
1243           abort ();
1244         }
1245     }
1246
1247   /*
1248     Either we are relocating all the way, or we don't want to apply
1249     the relocation to the reloc entry (probably because there isn't
1250     any room in the output format to describe addends to relocs)
1251     */
1252
1253   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1254      (OSF version 1.3, compiler version 3.11).  It miscompiles the
1255      following program:
1256
1257      struct str
1258      {
1259        unsigned int i0;
1260      } s = { 0 };
1261
1262      int
1263      main ()
1264      {
1265        unsigned long x;
1266
1267        x = 0x100000000;
1268        x <<= (unsigned long) s.i0;
1269        if (x == 0)
1270          printf ("failed\n");
1271        else
1272          printf ("succeeded (%lx)\n", x);
1273      }
1274      */
1275
1276   relocation >>= (bfd_vma) howto->rightshift;
1277
1278   /* Shift everything up to where it's going to be used */
1279
1280   relocation <<= (bfd_vma) howto->bitpos;
1281
1282   /* Wait for the day when all have the mask in them */
1283
1284   /* What we do:
1285      i instruction to be left alone
1286      o offset within instruction
1287      r relocation offset to apply
1288      S src mask
1289      D dst mask
1290      N ~dst mask
1291      A part 1
1292      B part 2
1293      R result
1294
1295      Do this:
1296      i i i i i o o o o o        from bfd_get<size>
1297      and           S S S S S    to get the size offset we want
1298      +   r r r r r r r r r r  to get the final value to place
1299      and           D D D D D  to chop to right size
1300      -----------------------
1301      A A A A A
1302      And this:
1303      ...   i i i i i o o o o o  from bfd_get<size>
1304      and   N N N N N            get instruction
1305      -----------------------
1306      ...   B B B B B
1307
1308      And then:
1309      B B B B B
1310      or              A A A A A
1311      -----------------------
1312      R R R R R R R R R R        put into bfd_put<size>
1313      */
1314
1315 #define DOIT(x) \
1316   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
1317
1318   data = (bfd_byte *) data_start + (addr - data_start_offset);
1319
1320   switch (howto->size)
1321     {
1322     case 0:
1323       {
1324         char x = bfd_get_8 (abfd, (char *) data);
1325         DOIT (x);
1326         bfd_put_8 (abfd, x, (unsigned char *) data);
1327       }
1328       break;
1329
1330     case 1:
1331       if (relocation)
1332         {
1333           short x = bfd_get_16 (abfd, (bfd_byte *) data);
1334           DOIT (x);
1335           bfd_put_16 (abfd, x, (unsigned char *) data);
1336         }
1337       break;
1338     case 2:
1339       if (relocation)
1340         {
1341           long x = bfd_get_32 (abfd, (bfd_byte *) data);
1342           DOIT (x);
1343           bfd_put_32 (abfd, x, (bfd_byte *) data);
1344         }
1345       break;
1346     case -2:
1347       {
1348         long x = bfd_get_32 (abfd, (bfd_byte *) data);
1349         relocation = -relocation;
1350         DOIT (x);
1351         bfd_put_32 (abfd, x, (bfd_byte *) data);
1352       }
1353       break;
1354
1355     case 3:
1356       /* Do nothing */
1357       break;
1358
1359     case 4:
1360       if (relocation)
1361         {
1362           bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
1363           DOIT (x);
1364           bfd_put_64 (abfd, x, (bfd_byte *) data);
1365         }
1366       break;
1367     default:
1368       return bfd_reloc_other;
1369     }
1370
1371   return flag;
1372 }
1373
1374 /* This relocation routine is used by some of the backend linkers.
1375    They do not construct asymbol or arelent structures, so there is no
1376    reason for them to use bfd_perform_relocation.  Also,
1377    bfd_perform_relocation is so hacked up it is easier to write a new
1378    function than to try to deal with it.
1379
1380    This routine does a final relocation.  It should not be used when
1381    generating relocateable output.
1382
1383    FIXME: This routine ignores any special_function in the HOWTO,
1384    since the existing special_function values have been written for
1385    bfd_perform_relocation.
1386
1387    HOWTO is the reloc howto information.
1388    INPUT_BFD is the BFD which the reloc applies to.
1389    INPUT_SECTION is the section which the reloc applies to.
1390    CONTENTS is the contents of the section.
1391    ADDRESS is the address of the reloc within INPUT_SECTION.
1392    VALUE is the value of the symbol the reloc refers to.
1393    ADDEND is the addend of the reloc.  */
1394
1395 bfd_reloc_status_type
1396 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
1397                           value, addend)
1398      const reloc_howto_type *howto;
1399      bfd *input_bfd;
1400      asection *input_section;
1401      bfd_byte *contents;
1402      bfd_vma address;
1403      bfd_vma value;
1404      bfd_vma addend;
1405 {
1406   bfd_vma relocation;
1407
1408   /* Sanity check the address.  */
1409   if (address > input_section->_cooked_size)
1410     return bfd_reloc_outofrange;
1411
1412   /* This function assumes that we are dealing with a basic relocation
1413      against a symbol.  We want to compute the value of the symbol to
1414      relocate to.  This is just VALUE, the value of the symbol, plus
1415      ADDEND, any addend associated with the reloc.  */
1416   relocation = value + addend;
1417
1418   /* If the relocation is PC relative, we want to set RELOCATION to
1419      the distance between the symbol (currently in RELOCATION) and the
1420      location we are relocating.  Some targets (e.g., i386-aout)
1421      arrange for the contents of the section to be the negative of the
1422      offset of the location within the section; for such targets
1423      pcrel_offset is false.  Other targets (e.g., m88kbcs or ELF)
1424      simply leave the contents of the section as zero; for such
1425      targets pcrel_offset is true.  If pcrel_offset is false we do not
1426      need to subtract out the offset of the location within the
1427      section (which is just ADDRESS).  */
1428   if (howto->pc_relative)
1429     {
1430       relocation -= (input_section->output_section->vma
1431                      + input_section->output_offset);
1432       if (howto->pcrel_offset)
1433         relocation -= address;
1434     }
1435
1436   return _bfd_relocate_contents (howto, input_bfd, relocation,
1437                                  contents + address);
1438 }
1439
1440 /* Relocate a given location using a given value and howto.  */
1441
1442 bfd_reloc_status_type
1443 _bfd_relocate_contents (howto, input_bfd, relocation, location)
1444      const reloc_howto_type *howto;
1445      bfd *input_bfd;
1446      bfd_vma relocation;
1447      bfd_byte *location;
1448 {
1449   int size;
1450   bfd_vma x;
1451   boolean overflow;
1452
1453   /* If the size is negative, negate RELOCATION.  This isn't very
1454      general.  */
1455   if (howto->size < 0)
1456     relocation = -relocation;
1457
1458   /* Get the value we are going to relocate.  */
1459   size = bfd_get_reloc_size (howto);
1460   switch (size)
1461     {
1462     default:
1463     case 0:
1464       abort ();
1465     case 1:
1466       x = bfd_get_8 (input_bfd, location);
1467       break;
1468     case 2:
1469       x = bfd_get_16 (input_bfd, location);
1470       break;
1471     case 4:
1472       x = bfd_get_32 (input_bfd, location);
1473       break;
1474     case 8:
1475 #ifdef BFD64
1476       x = bfd_get_64 (input_bfd, location);
1477 #else
1478       abort ();
1479 #endif
1480       break;
1481     }
1482
1483   /* Check for overflow.  FIXME: We may drop bits during the addition
1484      which we don't check for.  We must either check at every single
1485      operation, which would be tedious, or we must do the computations
1486      in a type larger than bfd_vma, which would be inefficient.  */
1487   overflow = false;
1488   if (howto->complain_on_overflow != complain_overflow_dont)
1489     {
1490       bfd_vma check;
1491       bfd_signed_vma signed_check;
1492       bfd_vma add;
1493       bfd_signed_vma signed_add;
1494
1495       if (howto->rightshift == 0)
1496         {
1497           check = relocation;
1498           signed_check = (bfd_signed_vma) relocation;
1499         }
1500       else
1501         {
1502           /* Drop unwanted bits from the value we are relocating to.  */
1503           check = relocation >> howto->rightshift;
1504
1505           /* If this is a signed value, the rightshift just dropped
1506              leading 1 bits (assuming twos complement).  */
1507           if ((bfd_signed_vma) relocation >= 0)
1508             signed_check = check;
1509           else
1510             signed_check = (check
1511                             | ((bfd_vma) - 1
1512                                & ~((bfd_vma) - 1 >> howto->rightshift)));
1513         }
1514
1515       /* Get the value from the object file.  */
1516       add = x & howto->src_mask;
1517
1518       /* Get the value from the object file with an appropriate sign.
1519          The expression involving howto->src_mask isolates the upper
1520          bit of src_mask.  If that bit is set in the value we are
1521          adding, it is negative, and we subtract out that number times
1522          two.  If src_mask includes the highest possible bit, then we
1523          can not get the upper bit, but that does not matter since
1524          signed_add needs no adjustment to become negative in that
1525          case.  */
1526       signed_add = add;
1527       if ((add & (((~howto->src_mask) >> 1) & howto->src_mask)) != 0)
1528         signed_add -= (((~howto->src_mask) >> 1) & howto->src_mask) << 1;
1529
1530       /* Add the value from the object file, shifted so that it is a
1531          straight number.  */
1532       if (howto->bitpos == 0)
1533         {
1534           check += add;
1535           signed_check += signed_add;
1536         }
1537       else
1538         {
1539           check += add >> howto->bitpos;
1540
1541           /* For the signed case we use ADD, rather than SIGNED_ADD,
1542              to avoid warnings from SVR4 cc.  This is OK since we
1543              explictly handle the sign bits.  */
1544           if (signed_add >= 0)
1545             signed_check += add >> howto->bitpos;
1546           else
1547             signed_check += ((add >> howto->bitpos)
1548                              | ((bfd_vma) - 1
1549                                 & ~((bfd_vma) - 1 >> howto->bitpos)));
1550         }
1551
1552       switch (howto->complain_on_overflow)
1553         {
1554         case complain_overflow_signed:
1555           {
1556             /* Assumes two's complement.  */
1557             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1558             bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1559
1560             if (signed_check > reloc_signed_max
1561                 || signed_check < reloc_signed_min)
1562               overflow = true;
1563           }
1564           break;
1565         case complain_overflow_unsigned:
1566           {
1567             /* Assumes two's complement.  This expression avoids
1568                overflow if howto->bitsize is the number of bits in
1569                bfd_vma.  */
1570             bfd_vma reloc_unsigned_max =
1571             (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1572
1573             if (check > reloc_unsigned_max)
1574               overflow = true;
1575           }
1576           break;
1577         case complain_overflow_bitfield:
1578           {
1579             /* Assumes two's complement.  This expression avoids
1580                overflow if howto->bitsize is the number of bits in
1581                bfd_vma.  */
1582             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1583
1584             if ((check & ~reloc_bits) != 0
1585                 && (((bfd_vma) signed_check & ~reloc_bits)
1586                     != (-1 & ~reloc_bits)))
1587               overflow = true;
1588           }
1589           break;
1590         default:
1591           abort ();
1592         }
1593     }
1594
1595   /* Put RELOCATION in the right bits.  */
1596   relocation >>= (bfd_vma) howto->rightshift;
1597   relocation <<= (bfd_vma) howto->bitpos;
1598
1599   /* Add RELOCATION to the right bits of X.  */
1600   x = ((x & ~howto->dst_mask)
1601        | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1602
1603   /* Put the relocated value back in the object file.  */
1604   switch (size)
1605     {
1606     default:
1607     case 0:
1608       abort ();
1609     case 1:
1610       bfd_put_8 (input_bfd, x, location);
1611       break;
1612     case 2:
1613       bfd_put_16 (input_bfd, x, location);
1614       break;
1615     case 4:
1616       bfd_put_32 (input_bfd, x, location);
1617       break;
1618     case 8:
1619 #ifdef BFD64
1620       bfd_put_64 (input_bfd, x, location);
1621 #else
1622       abort ();
1623 #endif
1624       break;
1625     }
1626
1627   return overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1628 }
1629
1630 /*
1631 DOCDD
1632 INODE
1633         howto manager,  , typedef arelent, Relocations
1634
1635 SECTION
1636         The howto manager
1637
1638         When an application wants to create a relocation, but doesn't
1639         know what the target machine might call it, it can find out by
1640         using this bit of code.
1641
1642 */
1643
1644 /*
1645 TYPEDEF
1646         bfd_reloc_code_type
1647
1648 DESCRIPTION
1649         The insides of a reloc code.  The idea is that, eventually, there
1650         will be one enumerator for every type of relocation we ever do.
1651         Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1652         return a howto pointer.
1653
1654         This does mean that the application must determine the correct
1655         enumerator value; you can't get a howto pointer from a random set
1656         of attributes.
1657
1658 SENUM
1659    bfd_reloc_code_real
1660
1661 ENUM
1662   BFD_RELOC_64
1663 ENUMX
1664   BFD_RELOC_32
1665 ENUMX
1666   BFD_RELOC_26
1667 ENUMX
1668   BFD_RELOC_16
1669 ENUMX
1670   BFD_RELOC_14
1671 ENUMX
1672   BFD_RELOC_8
1673 ENUMDOC
1674   Basic absolute relocations of N bits.
1675
1676 ENUM
1677   BFD_RELOC_64_PCREL
1678 ENUMX
1679   BFD_RELOC_32_PCREL
1680 ENUMX
1681   BFD_RELOC_24_PCREL
1682 ENUMX
1683   BFD_RELOC_16_PCREL
1684 ENUMX
1685   BFD_RELOC_8_PCREL
1686 ENUMDOC
1687   PC-relative relocations.  Sometimes these are relative to the address
1688 of the relocation itself; sometimes they are relative to the start of
1689 the section containing the relocation.  It depends on the specific target.
1690
1691 The 24-bit relocation is used in some Intel 960 configurations.
1692
1693 ENUM
1694   BFD_RELOC_32_BASEREL
1695 ENUMX
1696   BFD_RELOC_16_BASEREL
1697 ENUMX
1698   BFD_RELOC_8_BASEREL
1699 ENUMDOC
1700   Linkage-table relative.
1701
1702 ENUM
1703   BFD_RELOC_8_FFnn
1704 ENUMDOC
1705   Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1706
1707 ENUM
1708   BFD_RELOC_32_PCREL_S2
1709 ENUMX
1710   BFD_RELOC_16_PCREL_S2
1711 ENUMX
1712   BFD_RELOC_23_PCREL_S2
1713 ENUMDOC
1714   These PC-relative relocations are stored as word displacements -- i.e.,
1715 byte displacements shifted right two bits.  The 30-bit word displacement
1716 (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the SPARC.  The signed
1717 16-bit displacement is used on the MIPS, and the 23-bit displacement is
1718 used on the Alpha.
1719
1720 ENUM
1721   BFD_RELOC_HI22
1722 ENUMX
1723   BFD_RELOC_LO10
1724 ENUMDOC
1725   High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1726 the target word.  These are used on the SPARC.
1727
1728 ENUM
1729   BFD_RELOC_GPREL16
1730 ENUMX
1731   BFD_RELOC_GPREL32
1732 ENUMDOC
1733   For systems that allocate a Global Pointer register, these are
1734 displacements off that register.  These relocation types are
1735 handled specially, because the value the register will have is
1736 decided relatively late.
1737
1738
1739 ENUM
1740   BFD_RELOC_I960_CALLJ
1741 ENUMDOC
1742   Reloc types used for i960/b.out.
1743
1744 ENUM
1745   BFD_RELOC_NONE
1746 ENUMX
1747   BFD_RELOC_SPARC_WDISP22
1748 ENUMX
1749   BFD_RELOC_SPARC22
1750 ENUMX
1751   BFD_RELOC_SPARC13
1752 ENUMX
1753   BFD_RELOC_SPARC_GOT10
1754 ENUMX
1755   BFD_RELOC_SPARC_GOT13
1756 ENUMX
1757   BFD_RELOC_SPARC_GOT22
1758 ENUMX
1759   BFD_RELOC_SPARC_PC10
1760 ENUMX
1761   BFD_RELOC_SPARC_PC22
1762 ENUMX
1763   BFD_RELOC_SPARC_WPLT30
1764 ENUMX
1765   BFD_RELOC_SPARC_COPY
1766 ENUMX
1767   BFD_RELOC_SPARC_GLOB_DAT
1768 ENUMX
1769   BFD_RELOC_SPARC_JMP_SLOT
1770 ENUMX
1771   BFD_RELOC_SPARC_RELATIVE
1772 ENUMX
1773   BFD_RELOC_SPARC_UA32
1774 ENUMDOC
1775   SPARC ELF relocations.  There is probably some overlap with other
1776   relocation types already defined.
1777
1778 ENUM
1779   BFD_RELOC_SPARC_BASE13
1780 ENUMX
1781   BFD_RELOC_SPARC_BASE22
1782 ENUMDOC
1783   I think these are specific to SPARC a.out (e.g., Sun 4).
1784
1785 ENUMEQ
1786   BFD_RELOC_SPARC_64
1787   BFD_RELOC_64
1788 ENUMX
1789   BFD_RELOC_SPARC_10
1790 ENUMX
1791   BFD_RELOC_SPARC_11
1792 ENUMX
1793   BFD_RELOC_SPARC_OLO10
1794 ENUMX
1795   BFD_RELOC_SPARC_HH22
1796 ENUMX
1797   BFD_RELOC_SPARC_HM10
1798 ENUMX
1799   BFD_RELOC_SPARC_LM22
1800 ENUMX
1801   BFD_RELOC_SPARC_PC_HH22
1802 ENUMX
1803   BFD_RELOC_SPARC_PC_HM10
1804 ENUMX
1805   BFD_RELOC_SPARC_PC_LM22
1806 ENUMX
1807   BFD_RELOC_SPARC_WDISP16
1808 ENUMX
1809   BFD_RELOC_SPARC_WDISP19
1810 ENUMX
1811   BFD_RELOC_SPARC_GLOB_JMP
1812 ENUMX
1813   BFD_RELOC_SPARC_LO7
1814 ENUMDOC
1815   Some relocations we're using for SPARC V9 -- subject to change.
1816
1817 ENUM
1818   BFD_RELOC_ALPHA_GPDISP_HI16
1819 ENUMDOC
1820   Alpha ECOFF relocations.  Some of these treat the symbol or "addend"
1821      in some special way.
1822   For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1823      writing; when reading, it will be the absolute section symbol.  The
1824      addend is the displacement in bytes of the "lda" instruction from
1825      the "ldah" instruction (which is at the address of this reloc).
1826 ENUM
1827   BFD_RELOC_ALPHA_GPDISP_LO16
1828 ENUMDOC
1829   For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1830      with GPDISP_HI16 relocs.  The addend is ignored when writing the
1831      relocations out, and is filled in with the file's GP value on
1832      reading, for convenience.
1833
1834 ENUM
1835   BFD_RELOC_ALPHA_LITERAL
1836 ENUMX
1837   BFD_RELOC_ALPHA_LITUSE
1838 ENUMDOC
1839   The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1840      the assembler turns it into a LDQ instruction to load the address of
1841      the symbol, and then fills in a register in the real instruction.
1842
1843      The LITERAL reloc, at the LDQ instruction, refers to the .lita
1844      section symbol.  The addend is ignored when writing, but is filled
1845      in with the file's GP value on reading, for convenience, as with the
1846      GPDISP_LO16 reloc.
1847
1848      The LITUSE reloc, on the instruction using the loaded address, gives
1849      information to the linker that it might be able to use to optimize
1850      away some literal section references.  The symbol is ignored (read
1851      as the absolute section symbol), and the "addend" indicates the type
1852      of instruction using the register:
1853               1 - "memory" fmt insn
1854               2 - byte-manipulation (byte offset reg)
1855               3 - jsr (target of branch)
1856
1857      The GNU linker currently doesn't do any of this optimizing.
1858
1859 ENUM
1860   BFD_RELOC_ALPHA_HINT
1861 ENUMDOC
1862   The HINT relocation indicates a value that should be filled into the
1863      "hint" field of a jmp/jsr/ret instruction, for possible branch-
1864      prediction logic which may be provided on some processors.
1865
1866 ENUM
1867   BFD_RELOC_MIPS_JMP
1868 ENUMDOC
1869   Bits 27..2 of the relocation address shifted right 2 bits;
1870      simple reloc otherwise.
1871
1872 ENUM
1873   BFD_RELOC_HI16
1874 ENUMDOC
1875   High 16 bits of 32-bit value; simple reloc.
1876 ENUM
1877   BFD_RELOC_HI16_S
1878 ENUMDOC
1879   High 16 bits of 32-bit value but the low 16 bits will be sign
1880      extended and added to form the final result.  If the low 16
1881      bits form a negative number, we need to add one to the high value
1882      to compensate for the borrow when the low bits are added.
1883 ENUM
1884   BFD_RELOC_LO16
1885 ENUMDOC
1886   Low 16 bits.
1887 ENUM
1888   BFD_RELOC_PCREL_HI16_S
1889 ENUMDOC
1890   Like BFD_RELOC_HI16_S, but PC relative.
1891 ENUM
1892   BFD_RELOC_PCREL_LO16
1893 ENUMDOC
1894   Like BFD_RELOC_LO16, but PC relative.
1895
1896 ENUMEQ
1897   BFD_RELOC_MIPS_GPREL
1898   BFD_RELOC_GPREL16
1899 ENUMDOC
1900   Relocation relative to the global pointer.
1901
1902 ENUM
1903   BFD_RELOC_MIPS_LITERAL
1904 ENUMDOC
1905   Relocation against a MIPS literal section.
1906
1907 ENUM
1908   BFD_RELOC_MIPS_GOT16
1909 ENUMX
1910   BFD_RELOC_MIPS_CALL16
1911 ENUMEQX
1912   BFD_RELOC_MIPS_GPREL32
1913   BFD_RELOC_GPREL32
1914 ENUMDOC
1915   MIPS ELF relocations.
1916
1917 ENUM
1918   BFD_RELOC_386_GOT32
1919 ENUMX
1920   BFD_RELOC_386_PLT32
1921 ENUMX
1922   BFD_RELOC_386_COPY
1923 ENUMX
1924   BFD_RELOC_386_GLOB_DAT
1925 ENUMX
1926   BFD_RELOC_386_JUMP_SLOT
1927 ENUMX
1928   BFD_RELOC_386_RELATIVE
1929 ENUMX
1930   BFD_RELOC_386_GOTOFF
1931 ENUMX
1932   BFD_RELOC_386_GOTPC
1933 ENUMDOC
1934   i386/elf relocations
1935
1936 ENUM
1937   BFD_RELOC_NS32K_IMM_8
1938 ENUMX
1939   BFD_RELOC_NS32K_IMM_16
1940 ENUMX
1941   BFD_RELOC_NS32K_IMM_32
1942 ENUMX
1943   BFD_RELOC_NS32K_IMM_8_PCREL
1944 ENUMX
1945   BFD_RELOC_NS32K_IMM_16_PCREL
1946 ENUMX
1947   BFD_RELOC_NS32K_IMM_32_PCREL
1948 ENUMX
1949   BFD_RELOC_NS32K_DISP_8
1950 ENUMX
1951   BFD_RELOC_NS32K_DISP_16
1952 ENUMX
1953   BFD_RELOC_NS32K_DISP_32
1954 ENUMX
1955   BFD_RELOC_NS32K_DISP_8_PCREL
1956 ENUMX
1957   BFD_RELOC_NS32K_DISP_16_PCREL
1958 ENUMX
1959   BFD_RELOC_NS32K_DISP_32_PCREL
1960 ENUMDOC
1961   ns32k relocations
1962
1963 ENUM
1964   BFD_RELOC_PPC_B26
1965 ENUMDOC
1966   PowerPC/POWER (RS/6000) relocs.
1967   26 bit relative branch.  Low two bits must be zero.  High 24
1968      bits installed in bits 6 through 29 of instruction.
1969 ENUM
1970   BFD_RELOC_PPC_BA26
1971 ENUMDOC
1972   26 bit absolute branch, like BFD_RELOC_PPC_B26 but absolute.
1973 ENUM
1974   BFD_RELOC_PPC_TOC16
1975 ENUMDOC
1976   16 bit TOC relative reference.
1977
1978 ENUM
1979   BFD_RELOC_CTOR
1980 ENUMDOC
1981   The type of reloc used to build a contructor table - at the moment
1982   probably a 32 bit wide absolute relocation, but the target can choose.
1983   It generally does map to one of the other relocation types.
1984
1985 ENUM
1986   BFD_RELOC_ARM_PCREL_BRANCH
1987 ENUMDOC
1988   ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
1989   not stored in the instruction.
1990 ENUM
1991   BFD_RELOC_ARM_IMMEDIATE
1992 ENUMX
1993   BFD_RELOC_ARM_OFFSET_IMM
1994 ENUMX
1995   BFD_RELOC_ARM_SHIFT_IMM
1996 ENUMX
1997   BFD_RELOC_ARM_SWI
1998 ENUMX
1999   BFD_RELOC_ARM_MULTI
2000 ENUMX
2001   BFD_RELOC_ARM_CP_OFF_IMM
2002 ENUMDOC
2003   These relocs are only used within the ARM assembler.  They are not
2004   (at present) written to any object files.
2005
2006 ENDSENUM
2007   BFD_RELOC_UNUSED
2008
2009 CODE_FRAGMENT
2010 .
2011 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2012 */
2013
2014
2015 /*
2016 FUNCTION
2017         bfd_reloc_type_lookup
2018
2019 SYNOPSIS
2020         const struct reloc_howto_struct *
2021         bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
2022
2023 DESCRIPTION
2024         Return a pointer to a howto structure which, when
2025         invoked, will perform the relocation @var{code} on data from the
2026         architecture noted.
2027
2028 */
2029
2030
2031 const struct reloc_howto_struct *
2032 bfd_reloc_type_lookup (abfd, code)
2033      bfd *abfd;
2034      bfd_reloc_code_real_type code;
2035 {
2036   return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
2037 }
2038
2039 static reloc_howto_type bfd_howto_32 =
2040 HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
2041
2042
2043 /*
2044 INTERNAL_FUNCTION
2045         bfd_default_reloc_type_lookup
2046
2047 SYNOPSIS
2048         const struct reloc_howto_struct *bfd_default_reloc_type_lookup
2049         (bfd *abfd, bfd_reloc_code_real_type  code);
2050
2051 DESCRIPTION
2052         Provides a default relocation lookup routine for any architecture.
2053
2054
2055 */
2056
2057 const struct reloc_howto_struct *
2058 bfd_default_reloc_type_lookup (abfd, code)
2059      bfd *abfd;
2060      bfd_reloc_code_real_type code;
2061 {
2062   switch (code)
2063     {
2064     case BFD_RELOC_CTOR:
2065       /* The type of reloc used in a ctor, which will be as wide as the
2066          address - so either a 64, 32, or 16 bitter.  */
2067       switch (bfd_get_arch_info (abfd)->bits_per_address)
2068         {
2069         case 64:
2070           BFD_FAIL ();
2071         case 32:
2072           return &bfd_howto_32;
2073         case 16:
2074           BFD_FAIL ();
2075         default:
2076           BFD_FAIL ();
2077         }
2078     default:
2079       BFD_FAIL ();
2080     }
2081   return (const struct reloc_howto_struct *) NULL;
2082 }
2083
2084 /*
2085 FUNCTION
2086         bfd_get_reloc_code_name
2087
2088 SYNOPSIS
2089         const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
2090
2091 DESCRIPTION
2092         Provides a printable name for the supplied relocation code.
2093         Useful mainly for printing error messages.
2094 */
2095
2096 const char *
2097 bfd_get_reloc_code_name (code)
2098      bfd_reloc_code_real_type code;
2099 {
2100   if (code > BFD_RELOC_UNUSED)
2101     return 0;
2102   return bfd_reloc_code_real_names[(int)code];
2103 }
2104
2105 /*
2106 INTERNAL_FUNCTION
2107         bfd_generic_relax_section
2108
2109 SYNOPSIS
2110         boolean bfd_generic_relax_section
2111          (bfd *abfd,
2112           asection *section,
2113           struct bfd_link_info *,
2114           boolean *);
2115
2116 DESCRIPTION
2117         Provides default handling for relaxing for back ends which
2118         don't do relaxing -- i.e., does nothing.
2119 */
2120
2121 /*ARGSUSED*/
2122 boolean
2123 bfd_generic_relax_section (abfd, section, link_info, again)
2124      bfd *abfd;
2125      asection *section;
2126      struct bfd_link_info *link_info;
2127      boolean *again;
2128 {
2129   *again = false;
2130   return true;
2131 }
2132
2133 /*
2134 INTERNAL_FUNCTION
2135         bfd_generic_get_relocated_section_contents
2136
2137 SYNOPSIS
2138         bfd_byte *
2139            bfd_generic_get_relocated_section_contents (bfd *abfd,
2140              struct bfd_link_info *link_info,
2141              struct bfd_link_order *link_order,
2142              bfd_byte *data,
2143              boolean relocateable,
2144              asymbol **symbols);
2145
2146 DESCRIPTION
2147         Provides default handling of relocation effort for back ends
2148         which can't be bothered to do it efficiently.
2149
2150 */
2151
2152 bfd_byte *
2153 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
2154                                             relocateable, symbols)
2155      bfd *abfd;
2156      struct bfd_link_info *link_info;
2157      struct bfd_link_order *link_order;
2158      bfd_byte *data;
2159      boolean relocateable;
2160      asymbol **symbols;
2161 {
2162   /* Get enough memory to hold the stuff */
2163   bfd *input_bfd = link_order->u.indirect.section->owner;
2164   asection *input_section = link_order->u.indirect.section;
2165
2166   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
2167   arelent **reloc_vector = NULL;
2168   long reloc_count;
2169
2170   if (reloc_size < 0)
2171     goto error_return;
2172
2173   reloc_vector = (arelent **) malloc (reloc_size);
2174   if (reloc_vector == NULL && reloc_size != 0)
2175     {
2176       bfd_set_error (bfd_error_no_memory);
2177       goto error_return;
2178     }
2179
2180   /* read in the section */
2181   if (!bfd_get_section_contents (input_bfd,
2182                                  input_section,
2183                                  (PTR) data,
2184                                  0,
2185                                  input_section->_raw_size))
2186     goto error_return;
2187
2188   /* We're not relaxing the section, so just copy the size info */
2189   input_section->_cooked_size = input_section->_raw_size;
2190   input_section->reloc_done = true;
2191
2192   reloc_count = bfd_canonicalize_reloc (input_bfd,
2193                                         input_section,
2194                                         reloc_vector,
2195                                         symbols);
2196   if (reloc_count < 0)
2197     goto error_return;
2198
2199   if (reloc_count > 0)
2200     {
2201       arelent **parent;
2202       for (parent = reloc_vector; *parent != (arelent *) NULL;
2203            parent++)
2204         {
2205           char *error_message = (char *) NULL;
2206           bfd_reloc_status_type r =
2207             bfd_perform_relocation (input_bfd,
2208                                     *parent,
2209                                     (PTR) data,
2210                                     input_section,
2211                                     relocateable ? abfd : (bfd *) NULL,
2212                                     &error_message);
2213
2214           if (relocateable)
2215             {
2216               asection *os = input_section->output_section;
2217
2218               /* A partial link, so keep the relocs */
2219               os->orelocation[os->reloc_count] = *parent;
2220               os->reloc_count++;
2221             }
2222
2223           if (r != bfd_reloc_ok)
2224             {
2225               switch (r)
2226                 {
2227                 case bfd_reloc_undefined:
2228                   if (!((*link_info->callbacks->undefined_symbol)
2229                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2230                          input_bfd, input_section, (*parent)->address)))
2231                     goto error_return;
2232                   break;
2233                 case bfd_reloc_dangerous:
2234                   BFD_ASSERT (error_message != (char *) NULL);
2235                   if (!((*link_info->callbacks->reloc_dangerous)
2236                         (link_info, error_message, input_bfd, input_section,
2237                          (*parent)->address)))
2238                     goto error_return;
2239                   break;
2240                 case bfd_reloc_overflow:
2241                   if (!((*link_info->callbacks->reloc_overflow)
2242                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2243                          (*parent)->howto->name, (*parent)->addend,
2244                          input_bfd, input_section, (*parent)->address)))
2245                     goto error_return;
2246                   break;
2247                 case bfd_reloc_outofrange:
2248                 default:
2249                   abort ();
2250                   break;
2251                 }
2252
2253             }
2254         }
2255     }
2256   if (reloc_vector != NULL)
2257     free (reloc_vector);
2258   return data;
2259
2260 error_return:
2261   if (reloc_vector != NULL)
2262     free (reloc_vector);
2263   return NULL;
2264 }