bfd/reloc.c

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