bfd/reloc.c

   1 /* BFD support for handling relocation entries.
   2    Copyright (C) 1990, 91, 92, 93, 94, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 .  reloc_howto_type *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 .struct reloc_howto_struct
 290 .{
 291 .       {*  The type field has mainly a documetary use - the back end can
 292 .           do what it wants with it, though normally the back end's
 293 .           external idea of what a reloc number is stored
 294 .           in this field. For example, a PC relative word relocation
 295 .           in a coff environment has the type 023 - because that's
 296 .           what the outside world calls a R_PCRWORD reloc. *}
 297 .  unsigned int type;
 298 .
 299 .       {*  The value the final relocation is shifted right by. This drops
 300 .           unwanted data from the relocation.  *}
 301 .  unsigned int rightshift;
 302 .
 303 .       {*  The size of the item to be relocated.  This is *not* a
 304 .           power-of-two measure.  To get the number of bytes operated
 305 .           on by a type of relocation, use bfd_get_reloc_size.  *}
 306 .  int size;
 307 .
 308 .       {*  The number of bits in the item to be relocated.  This is used
 309 .           when doing overflow checking.  *}
 310 .  unsigned int bitsize;
 311 .
 312 .       {*  Notes that the relocation is relative to the location in the
 313 .           data section of the addend. The relocation function will
 314 .           subtract from the relocation value the address of the location
 315 .           being relocated. *}
 316 .  boolean pc_relative;
 317 .
 318 .       {*  The bit position of the reloc value in the destination.
 319 .           The relocated value is left shifted by this amount. *}
 320 .  unsigned int bitpos;
 321 .
 322 .       {* What type of overflow error should be checked for when
 323 .          relocating. *}
 324 .  enum complain_overflow complain_on_overflow;
 325 .
 326 .       {* If this field is non null, then the supplied function is
 327 .          called rather than the normal function. This allows really
 328 .          strange relocation methods to be accomodated (e.g., i960 callj
 329 .          instructions). *}
 330 .  bfd_reloc_status_type (*special_function)
 331 .                                   PARAMS ((bfd *abfd,
 332 .                                            arelent *reloc_entry,
 333 .                                            struct symbol_cache_entry *symbol,
 334 .                                            PTR data,
 335 .                                            asection *input_section,
 336 .                                            bfd *output_bfd,
 337 .                                            char **error_message));
 338 .
 339 .       {* The textual name of the relocation type. *}
 340 .  char *name;
 341 .
 342 .       {* When performing a partial link, some formats must modify the
 343 .          relocations rather than the data - this flag signals this.*}
 344 .  boolean partial_inplace;
 345 .
 346 .       {* The src_mask selects which parts of the read in data
 347 .          are to be used in the relocation sum.  E.g., if this was an 8 bit
 348 .          bit of data which we read and relocated, this would be
 349 .          0x000000ff. When we have relocs which have an addend, such as
 350 .          sun4 extended relocs, the value in the offset part of a
 351 .          relocating field is garbage so we never use it. In this case
 352 .          the mask would be 0x00000000. *}
 353 .  bfd_vma src_mask;
 354 .
 355 .       {* The dst_mask selects which parts of the instruction are replaced
 356 .          into the instruction. In most cases src_mask == dst_mask,
 357 .          except in the above special case, where dst_mask would be
 358 .          0x000000ff, and src_mask would be 0x00000000.   *}
 359 .  bfd_vma dst_mask;
 360 .
 361 .       {* When some formats create PC relative instructions, they leave
 362 .          the value of the pc of the place being relocated in the offset
 363 .          slot of the instruction, so that a PC relative relocation can
 364 .          be made just by adding in an ordinary offset (e.g., sun3 a.out).
 365 .          Some formats leave the displacement part of an instruction
 366 .          empty (e.g., m88k bcs); this flag signals the fact.*}
 367 .  boolean pcrel_offset;
 368 .
 369 .};
 370
 371 */
 372
 373 /*
 374 FUNCTION
 375         The HOWTO Macro
 376
 377 DESCRIPTION
 378         The HOWTO define is horrible and will go away.
 379
 380
 381 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
 382 .  {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
 383
 384 DESCRIPTION
 385         And will be replaced with the totally magic way. But for the
 386         moment, we are compatible, so do it this way.
 387
 388
 389 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
 390 .
 391 DESCRIPTION
 392         Helper routine to turn a symbol into a relocation value.
 393
 394 .#define HOWTO_PREPARE(relocation, symbol)      \
 395 .  {                                            \
 396 .  if (symbol != (asymbol *)NULL) {             \
 397 .    if (bfd_is_com_section (symbol->section)) { \
 398 .      relocation = 0;                          \
 399 .    }                                          \
 400 .    else {                                     \
 401 .      relocation = symbol->value;              \
 402 .    }                                          \
 403 .  }                                            \
 404 .}
 405
 406 */
 407
 408 /*
 409 FUNCTION
 410         bfd_get_reloc_size
 411
 412 SYNOPSIS
 413         int bfd_get_reloc_size (reloc_howto_type *);
 414
 415 DESCRIPTION
 416         For a reloc_howto_type that operates on a fixed number of bytes,
 417         this returns the number of bytes operated on.
 418  */
 419
 420 int
 421 bfd_get_reloc_size (howto)
 422      reloc_howto_type *howto;
 423 {
 424   switch (howto->size)
 425     {
 426     case 0: return 1;
 427     case 1: return 2;
 428     case 2: return 4;
 429     case 3: return 0;
 430     case 4: return 8;
 431     case -2: return 4;
 432     default: abort ();
 433     }
 434 }
 435
 436 /*
 437 TYPEDEF
 438         arelent_chain
 439
 440 DESCRIPTION
 441
 442         How relocs are tied together in an <<asection>>:
 443
 444 .typedef struct relent_chain {
 445 .  arelent relent;
 446 .  struct   relent_chain *next;
 447 .} arelent_chain;
 448
 449 */
 450
 451
 452
 453 /*
 454 FUNCTION
 455         bfd_perform_relocation
 456
 457 SYNOPSIS
 458         bfd_reloc_status_type
 459                 bfd_perform_relocation
 460                         (bfd *abfd,
 461                          arelent *reloc_entry,
 462                          PTR data,
 463                          asection *input_section,
 464                          bfd *output_bfd,
 465                          char **error_message);
 466
 467 DESCRIPTION
 468         If @var{output_bfd} is supplied to this function, the
 469         generated image will be relocatable; the relocations are
 470         copied to the output file after they have been changed to
 471         reflect the new state of the world. There are two ways of
 472         reflecting the results of partial linkage in an output file:
 473         by modifying the output data in place, and by modifying the
 474         relocation record.  Some native formats (e.g., basic a.out and
 475         basic coff) have no way of specifying an addend in the
 476         relocation type, so the addend has to go in the output data.
 477         This is no big deal since in these formats the output data
 478         slot will always be big enough for the addend. Complex reloc
 479         types with addends were invented to solve just this problem.
 480         The @var{error_message} argument is set to an error message if
 481         this return @code{bfd_reloc_dangerous}.
 482
 483 */
 484
 485
 486 bfd_reloc_status_type
 487 bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
 488                         error_message)
 489      bfd *abfd;
 490      arelent *reloc_entry;
 491      PTR data;
 492      asection *input_section;
 493      bfd *output_bfd;
 494      char **error_message;
 495 {
 496   bfd_vma relocation;
 497   bfd_reloc_status_type flag = bfd_reloc_ok;
 498   bfd_size_type addr = reloc_entry->address;
 499   bfd_vma output_base = 0;
 500   reloc_howto_type *howto = reloc_entry->howto;
 501   asection *reloc_target_output_section;
 502   asymbol *symbol;
 503
 504   symbol = *(reloc_entry->sym_ptr_ptr);
 505   if (bfd_is_abs_section (symbol->section)
 506       && output_bfd != (bfd *) NULL)
 507     {
 508       reloc_entry->address += input_section->output_offset;
 509       return bfd_reloc_ok;
 510     }
 511
 512   /* If we are not producing relocateable output, return an error if
 513      the symbol is not defined.  An undefined weak symbol is
 514      considered to have a value of zero (SVR4 ABI, p. 4-27).  */
 515   if (bfd_is_und_section (symbol->section)
 516       && (symbol->flags & BSF_WEAK) == 0
 517       && output_bfd == (bfd *) NULL)
 518     flag = bfd_reloc_undefined;
 519
 520   /* If there is a function supplied to handle this relocation type,
 521      call it.  It'll return `bfd_reloc_continue' if further processing
 522      can be done.  */
 523   if (howto->special_function)
 524     {
 525       bfd_reloc_status_type cont;
 526       cont = howto->special_function (abfd, reloc_entry, symbol, data,
 527                                       input_section, output_bfd,
 528                                       error_message);
 529       if (cont != bfd_reloc_continue)
 530         return cont;
 531     }
 532
 533   /* Is the address of the relocation really within the section?  */
 534   if (reloc_entry->address > input_section->_cooked_size)
 535     return bfd_reloc_outofrange;
 536
 537   /* Work out which section the relocation is targetted at and the
 538      initial relocation command value.  */
 539
 540   /* Get symbol value.  (Common symbols are special.)  */
 541   if (bfd_is_com_section (symbol->section))
 542     relocation = 0;
 543   else
 544     relocation = symbol->value;
 545
 546
 547   reloc_target_output_section = symbol->section->output_section;
 548
 549   /* Convert input-section-relative symbol value to absolute.  */
 550   if (output_bfd && howto->partial_inplace == false)
 551     output_base = 0;
 552   else
 553     output_base = reloc_target_output_section->vma;
 554
 555   relocation += output_base + symbol->section->output_offset;
 556
 557   /* Add in supplied addend.  */
 558   relocation += reloc_entry->addend;
 559
 560   /* Here the variable relocation holds the final address of the
 561      symbol we are relocating against, plus any addend.  */
 562
 563   if (howto->pc_relative == true)
 564     {
 565       /* This is a PC relative relocation.  We want to set RELOCATION
 566          to the distance between the address of the symbol and the
 567          location.  RELOCATION is already the address of the symbol.
 568
 569          We start by subtracting the address of the section containing
 570          the location.
 571
 572          If pcrel_offset is set, we must further subtract the position
 573          of the location within the section.  Some targets arrange for
 574          the addend to be the negative of the position of the location
 575          within the section; for example, i386-aout does this.  For
 576          i386-aout, pcrel_offset is false.  Some other targets do not
 577          include the position of the location; for example, m88kbcs,
 578          or ELF.  For those targets, pcrel_offset is true.
 579
 580          If we are producing relocateable output, then we must ensure
 581          that this reloc will be correctly computed when the final
 582          relocation is done.  If pcrel_offset is false we want to wind
 583          up with the negative of the location within the section,
 584          which means we must adjust the existing addend by the change
 585          in the location within the section.  If pcrel_offset is true
 586          we do not want to adjust the existing addend at all.
 587
 588          FIXME: This seems logical to me, but for the case of
 589          producing relocateable output it is not what the code
 590          actually does.  I don't want to change it, because it seems
 591          far too likely that something will break.  */
 592
 593       relocation -=
 594         input_section->output_section->vma + input_section->output_offset;
 595
 596       if (howto->pcrel_offset == true)
 597         relocation -= reloc_entry->address;
 598     }
 599
 600   if (output_bfd != (bfd *) NULL)
 601     {
 602       if (howto->partial_inplace == false)
 603         {
 604           /* This is a partial relocation, and we want to apply the relocation
 605              to the reloc entry rather than the raw data. Modify the reloc
 606              inplace to reflect what we now know.  */
 607           reloc_entry->addend = relocation;
 608           reloc_entry->address += input_section->output_offset;
 609           return flag;
 610         }
 611       else
 612         {
 613           /* This is a partial relocation, but inplace, so modify the
 614              reloc record a bit.
 615
 616              If we've relocated with a symbol with a section, change
 617              into a ref to the section belonging to the symbol.  */
 618
 619           reloc_entry->address += input_section->output_offset;
 620
 621           /* WTF?? */
 622           if (abfd->xvec->flavour == bfd_target_coff_flavour
 623               && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
 624               && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
 625               && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
 626             {
 627 #if 1
 628               /* For m68k-coff, the addend was being subtracted twice during
 629                  relocation with -r.  Removing the line below this comment
 630                  fixes that problem; see PR 2953.
 631
 632 However, Ian wrote the following, regarding removing the line below,
 633 which explains why it is still enabled:  --djm
 634
 635 If you put a patch like that into BFD you need to check all the COFF
 636 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
 637 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
 638 problem in a different way.  There may very well be a reason that the
 639 code works as it does.
 640
 641 Hmmm.  The first obvious point is that bfd_perform_relocation should
 642 not have any tests that depend upon the flavour.  It's seem like
 643 entirely the wrong place for such a thing.  The second obvious point
 644 is that the current code ignores the reloc addend when producing
 645 relocateable output for COFF.  That's peculiar.  In fact, I really
 646 have no idea what the point of the line you want to remove is.
 647
 648 A typical COFF reloc subtracts the old value of the symbol and adds in
 649 the new value to the location in the object file (if it's a pc
 650 relative reloc it adds the difference between the symbol value and the
 651 location).  When relocating we need to preserve that property.
 652
 653 BFD handles this by setting the addend to the negative of the old
 654 value of the symbol.  Unfortunately it handles common symbols in a
 655 non-standard way (it doesn't subtract the old value) but that's a
 656 different story (we can't change it without losing backward
 657 compatibility with old object files) (coff-i386 does subtract the old
 658 value, to be compatible with existing coff-i386 targets, like SCO).
 659
 660 So everything works fine when not producing relocateable output.  When
 661 we are producing relocateable output, logically we should do exactly
 662 what we do when not producing relocateable output.  Therefore, your
 663 patch is correct.  In fact, it should probably always just set
 664 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
 665 add the value into the object file.  This won't hurt the COFF code,
 666 which doesn't use the addend; I'm not sure what it will do to other
 667 formats (the thing to check for would be whether any formats both use
 668 the addend and set partial_inplace).
 669
 670 When I wanted to make coff-i386 produce relocateable output, I ran
 671 into the problem that you are running into: I wanted to remove that
 672 line.  Rather than risk it, I made the coff-i386 relocs use a special
 673 function; it's coff_i386_reloc in coff-i386.c.  The function
 674 specifically adds the addend field into the object file, knowing that
 675 bfd_perform_relocation is not going to.  If you remove that line, then
 676 coff-i386.c will wind up adding the addend field in twice.  It's
 677 trivial to fix; it just needs to be done.
 678
 679 The problem with removing the line is just that it may break some
 680 working code.  With BFD it's hard to be sure of anything.  The right
 681 way to deal with this is simply to build and test at least all the
 682 supported COFF targets.  It should be straightforward if time and disk
 683 space consuming.  For each target:
 684     1) build the linker
 685     2) generate some executable, and link it using -r (I would
 686        probably use paranoia.o and link against newlib/libc.a, which
 687        for all the supported targets would be available in
 688        /usr/cygnus/progressive/H-host/target/lib/libc.a).
 689     3) make the change to reloc.c
 690     4) rebuild the linker
 691     5) repeat step 2
 692     6) if the resulting object files are the same, you have at least
 693        made it no worse
 694     7) if they are different you have to figure out which version is
 695        right
 696 */
 697               relocation -= reloc_entry->addend;
 698 #endif
 699               reloc_entry->addend = 0;
 700             }
 701           else
 702             {
 703               reloc_entry->addend = relocation;
 704             }
 705         }
 706     }
 707   else
 708     {
 709       reloc_entry->addend = 0;
 710     }
 711
 712   /* FIXME: This overflow checking is incomplete, because the value
 713      might have overflowed before we get here.  For a correct check we
 714      need to compute the value in a size larger than bitsize, but we
 715      can't reasonably do that for a reloc the same size as a host
 716      machine word.
 717      FIXME: We should also do overflow checking on the result after
 718      adding in the value contained in the object file.  */
 719   if (howto->complain_on_overflow != complain_overflow_dont
 720       && flag == bfd_reloc_ok)
 721     {
 722       bfd_vma check;
 723
 724       /* Get the value that will be used for the relocation, but
 725          starting at bit position zero.  */
 726       check = relocation >> howto->rightshift;
 727       switch (howto->complain_on_overflow)
 728         {
 729         case complain_overflow_signed:
 730           {
 731             /* Assumes two's complement.  */
 732             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
 733             bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
 734
 735             /* The above right shift is incorrect for a signed value.
 736                Fix it up by forcing on the upper bits.  */
 737             if (howto->rightshift > 0
 738                 && (bfd_signed_vma) relocation < 0)
 739               check |= ((bfd_vma) - 1
 740                         & ~((bfd_vma) - 1
 741                             >> howto->rightshift));
 742             if ((bfd_signed_vma) check > reloc_signed_max
 743                 || (bfd_signed_vma) check < reloc_signed_min)
 744               flag = bfd_reloc_overflow;
 745           }
 746           break;
 747         case complain_overflow_unsigned:
 748           {
 749             /* Assumes two's complement.  This expression avoids
 750                overflow if howto->bitsize is the number of bits in
 751                bfd_vma.  */
 752             bfd_vma reloc_unsigned_max =
 753             (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
 754
 755             if ((bfd_vma) check > reloc_unsigned_max)
 756               flag = bfd_reloc_overflow;
 757           }
 758           break;
 759         case complain_overflow_bitfield:
 760           {
 761             /* Assumes two's complement.  This expression avoids
 762                overflow if howto->bitsize is the number of bits in
 763                bfd_vma.  */
 764             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
 765
 766             if (((bfd_vma) check & ~reloc_bits) != 0
 767                 && ((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
 768               {
 769                 /* The above right shift is incorrect for a signed
 770                    value.  See if turning on the upper bits fixes the
 771                    overflow.  */
 772                 if (howto->rightshift > 0
 773                     && (bfd_signed_vma) relocation < 0)
 774                   {
 775                     check |= ((bfd_vma) - 1
 776                               & ~((bfd_vma) - 1
 777                                   >> howto->rightshift));
 778                     if (((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
 779                       flag = bfd_reloc_overflow;
 780                   }
 781                 else
 782                   flag = bfd_reloc_overflow;
 783               }
 784           }
 785           break;
 786         default:
 787           abort ();
 788         }
 789     }
 790
 791   /*
 792     Either we are relocating all the way, or we don't want to apply
 793     the relocation to the reloc entry (probably because there isn't
 794     any room in the output format to describe addends to relocs)
 795     */
 796
 797   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
 798      (OSF version 1.3, compiler version 3.11).  It miscompiles the
 799      following program:
 800
 801      struct str
 802      {
 803        unsigned int i0;
 804      } s = { 0 };
 805
 806      int
 807      main ()
 808      {
 809        unsigned long x;
 810
 811        x = 0x100000000;
 812        x <<= (unsigned long) s.i0;
 813        if (x == 0)
 814          printf ("failed\n");
 815        else
 816          printf ("succeeded (%lx)\n", x);
 817      }
 818      */
 819
 820   relocation >>= (bfd_vma) howto->rightshift;
 821
 822   /* Shift everything up to where it's going to be used */
 823
 824   relocation <<= (bfd_vma) howto->bitpos;
 825
 826   /* Wait for the day when all have the mask in them */
 827
 828   /* What we do:
 829      i instruction to be left alone
 830      o offset within instruction
 831      r relocation offset to apply
 832      S src mask
 833      D dst mask
 834      N ~dst mask
 835      A part 1
 836      B part 2
 837      R result
 838
 839      Do this:
 840      i i i i i o o o o o        from bfd_get<size>
 841      and           S S S S S    to get the size offset we want
 842      +   r r r r r r r r r r  to get the final value to place
 843      and           D D D D D  to chop to right size
 844      -----------------------
 845      A A A A A
 846      And this:
 847      ...   i i i i i o o o o o  from bfd_get<size>
 848      and   N N N N N            get instruction
 849      -----------------------
 850      ...   B B B B B
 851
 852      And then:
 853      B B B B B
 854      or              A A A A A
 855      -----------------------
 856      R R R R R R R R R R        put into bfd_put<size>
 857      */
 858
 859 #define DOIT(x) \
 860   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
 861
 862   switch (howto->size)
 863     {
 864     case 0:
 865       {
 866         char x = bfd_get_8 (abfd, (char *) data + addr);
 867         DOIT (x);
 868         bfd_put_8 (abfd, x, (unsigned char *) data + addr);
 869       }
 870       break;
 871
 872     case 1:
 873       if (relocation)
 874         {
 875           short x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
 876           DOIT (x);
 877           bfd_put_16 (abfd, x, (unsigned char *) data + addr);
 878         }
 879       break;
 880     case 2:
 881       if (relocation)
 882         {
 883           long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 884           DOIT (x);
 885           bfd_put_32 (abfd, x, (bfd_byte *) data + addr);
 886         }
 887       break;
 888     case -2:
 889       {
 890         long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 891         relocation = -relocation;
 892         DOIT (x);
 893         bfd_put_32 (abfd, x, (bfd_byte *) data + addr);
 894       }
 895       break;
 896
 897     case -1:
 898       {
 899         long x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
 900         relocation = -relocation;
 901         DOIT (x);
 902         bfd_put_16 (abfd, x, (bfd_byte *) data + addr);
 903       }
 904       break;
 905
 906     case 3:
 907       /* Do nothing */
 908       break;
 909
 910     case 4:
 911 #ifdef BFD64
 912       if (relocation)
 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, "coff-Intel-little") != 0
1087           && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1088         {
1089 #if 1
1090 /* For m68k-coff, the addend was being subtracted twice during
1091    relocation with -r.  Removing the line below this comment
1092    fixes that problem; see PR 2953.
1093
1094 However, Ian wrote the following, regarding removing the line below,
1095 which explains why it is still enabled:  --djm
1096
1097 If you put a patch like that into BFD you need to check all the COFF
1098 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
1099 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1100 problem in a different way.  There may very well be a reason that the
1101 code works as it does.
1102
1103 Hmmm.  The first obvious point is that bfd_install_relocation should
1104 not have any tests that depend upon the flavour.  It's seem like
1105 entirely the wrong place for such a thing.  The second obvious point
1106 is that the current code ignores the reloc addend when producing
1107 relocateable output for COFF.  That's peculiar.  In fact, I really
1108 have no idea what the point of the line you want to remove is.
1109
1110 A typical COFF reloc subtracts the old value of the symbol and adds in
1111 the new value to the location in the object file (if it's a pc
1112 relative reloc it adds the difference between the symbol value and the
1113 location).  When relocating we need to preserve that property.
1114
1115 BFD handles this by setting the addend to the negative of the old
1116 value of the symbol.  Unfortunately it handles common symbols in a
1117 non-standard way (it doesn't subtract the old value) but that's a
1118 different story (we can't change it without losing backward
1119 compatibility with old object files) (coff-i386 does subtract the old
1120 value, to be compatible with existing coff-i386 targets, like SCO).
1121
1122 So everything works fine when not producing relocateable output.  When
1123 we are producing relocateable output, logically we should do exactly
1124 what we do when not producing relocateable output.  Therefore, your
1125 patch is correct.  In fact, it should probably always just set
1126 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1127 add the value into the object file.  This won't hurt the COFF code,
1128 which doesn't use the addend; I'm not sure what it will do to other
1129 formats (the thing to check for would be whether any formats both use
1130 the addend and set partial_inplace).
1131
1132 When I wanted to make coff-i386 produce relocateable output, I ran
1133 into the problem that you are running into: I wanted to remove that
1134 line.  Rather than risk it, I made the coff-i386 relocs use a special
1135 function; it's coff_i386_reloc in coff-i386.c.  The function
1136 specifically adds the addend field into the object file, knowing that
1137 bfd_install_relocation is not going to.  If you remove that line, then
1138 coff-i386.c will wind up adding the addend field in twice.  It's
1139 trivial to fix; it just needs to be done.
1140
1141 The problem with removing the line is just that it may break some
1142 working code.  With BFD it's hard to be sure of anything.  The right
1143 way to deal with this is simply to build and test at least all the
1144 supported COFF targets.  It should be straightforward if time and disk
1145 space consuming.  For each target:
1146     1) build the linker
1147     2) generate some executable, and link it using -r (I would
1148        probably use paranoia.o and link against newlib/libc.a, which
1149        for all the supported targets would be available in
1150        /usr/cygnus/progressive/H-host/target/lib/libc.a).
1151     3) make the change to reloc.c
1152     4) rebuild the linker
1153     5) repeat step 2
1154     6) if the resulting object files are the same, you have at least
1155        made it no worse
1156     7) if they are different you have to figure out which version is
1157        right
1158 */
1159           relocation -= reloc_entry->addend;
1160 #endif
1161           reloc_entry->addend = 0;
1162         }
1163       else
1164         {
1165           reloc_entry->addend = relocation;
1166         }
1167     }
1168
1169   /* FIXME: This overflow checking is incomplete, because the value
1170      might have overflowed before we get here.  For a correct check we
1171      need to compute the value in a size larger than bitsize, but we
1172      can't reasonably do that for a reloc the same size as a host
1173      machine word.
1174
1175      FIXME: We should also do overflow checking on the result after
1176      adding in the value contained in the object file.  */
1177   if (howto->complain_on_overflow != complain_overflow_dont)
1178     {
1179       bfd_vma check;
1180
1181       /* Get the value that will be used for the relocation, but
1182          starting at bit position zero.  */
1183       check = relocation >> howto->rightshift;
1184       switch (howto->complain_on_overflow)
1185         {
1186         case complain_overflow_signed:
1187           {
1188             /* Assumes two's complement.  */
1189             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1190             bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1191
1192             /* The above right shift is incorrect for a signed value.
1193                Fix it up by forcing on the upper bits.  */
1194             if (howto->rightshift > 0
1195                 && (bfd_signed_vma) relocation < 0)
1196               check |= ((bfd_vma) - 1
1197                         & ~((bfd_vma) - 1
1198                             >> howto->rightshift));
1199             if ((bfd_signed_vma) check > reloc_signed_max
1200                 || (bfd_signed_vma) check < reloc_signed_min)
1201               flag = bfd_reloc_overflow;
1202           }
1203           break;
1204         case complain_overflow_unsigned:
1205           {
1206             /* Assumes two's complement.  This expression avoids
1207                overflow if howto->bitsize is the number of bits in
1208                bfd_vma.  */
1209             bfd_vma reloc_unsigned_max =
1210             (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1211
1212             if ((bfd_vma) check > reloc_unsigned_max)
1213               flag = bfd_reloc_overflow;
1214           }
1215           break;
1216         case complain_overflow_bitfield:
1217           {
1218             /* Assumes two's complement.  This expression avoids
1219                overflow if howto->bitsize is the number of bits in
1220                bfd_vma.  */
1221             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1222
1223             if (((bfd_vma) check & ~reloc_bits) != 0
1224                 && ((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
1225               {
1226                 /* The above right shift is incorrect for a signed
1227                    value.  See if turning on the upper bits fixes the
1228                    overflow.  */
1229                 if (howto->rightshift > 0
1230                     && (bfd_signed_vma) relocation < 0)
1231                   {
1232                     check |= ((bfd_vma) - 1
1233                               & ~((bfd_vma) - 1
1234                                   >> howto->rightshift));
1235                     if (((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
1236                       flag = bfd_reloc_overflow;
1237                   }
1238                 else
1239                   flag = bfd_reloc_overflow;
1240               }
1241           }
1242           break;
1243         default:
1244           abort ();
1245         }
1246     }
1247
1248   /*
1249     Either we are relocating all the way, or we don't want to apply
1250     the relocation to the reloc entry (probably because there isn't
1251     any room in the output format to describe addends to relocs)
1252     */
1253
1254   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1255      (OSF version 1.3, compiler version 3.11).  It miscompiles the
1256      following program:
1257
1258      struct str
1259      {
1260        unsigned int i0;
1261      } s = { 0 };
1262
1263      int
1264      main ()
1265      {
1266        unsigned long x;
1267
1268        x = 0x100000000;
1269        x <<= (unsigned long) s.i0;
1270        if (x == 0)
1271          printf ("failed\n");
1272        else
1273          printf ("succeeded (%lx)\n", x);
1274      }
1275      */
1276
1277   relocation >>= (bfd_vma) howto->rightshift;
1278
1279   /* Shift everything up to where it's going to be used */
1280
1281   relocation <<= (bfd_vma) howto->bitpos;
1282
1283   /* Wait for the day when all have the mask in them */
1284
1285   /* What we do:
1286      i instruction to be left alone
1287      o offset within instruction
1288      r relocation offset to apply
1289      S src mask
1290      D dst mask
1291      N ~dst mask
1292      A part 1
1293      B part 2
1294      R result
1295
1296      Do this:
1297      i i i i i o o o o o        from bfd_get<size>
1298      and           S S S S S    to get the size offset we want
1299      +   r r r r r r r r r r  to get the final value to place
1300      and           D D D D D  to chop to right size
1301      -----------------------
1302      A A A A A
1303      And this:
1304      ...   i i i i i o o o o o  from bfd_get<size>
1305      and   N N N N N            get instruction
1306      -----------------------
1307      ...   B B B B B
1308
1309      And then:
1310      B B B B B
1311      or              A A A A A
1312      -----------------------
1313      R R R R R R R R R R        put into bfd_put<size>
1314      */
1315
1316 #define DOIT(x) \
1317   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
1318
1319   data = (bfd_byte *) data_start + (addr - data_start_offset);
1320
1321   switch (howto->size)
1322     {
1323     case 0:
1324       {
1325         char x = bfd_get_8 (abfd, (char *) data);
1326         DOIT (x);
1327         bfd_put_8 (abfd, x, (unsigned char *) data);
1328       }
1329       break;
1330
1331     case 1:
1332       if (relocation)
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       if (relocation)
1341         {
1342           long x = bfd_get_32 (abfd, (bfd_byte *) data);
1343           DOIT (x);
1344           bfd_put_32 (abfd, x, (bfd_byte *) data);
1345         }
1346       break;
1347     case -2:
1348       {
1349         long x = bfd_get_32 (abfd, (bfd_byte *) data);
1350         relocation = -relocation;
1351         DOIT (x);
1352         bfd_put_32 (abfd, x, (bfd_byte *) data);
1353       }
1354       break;
1355
1356     case 3:
1357       /* Do nothing */
1358       break;
1359
1360     case 4:
1361       if (relocation)
1362         {
1363           bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
1364           DOIT (x);
1365           bfd_put_64 (abfd, x, (bfd_byte *) data);
1366         }
1367       break;
1368     default:
1369       return bfd_reloc_other;
1370     }
1371
1372   return flag;
1373 }
1374
1375 /* This relocation routine is used by some of the backend linkers.
1376    They do not construct asymbol or arelent structures, so there is no
1377    reason for them to use bfd_perform_relocation.  Also,
1378    bfd_perform_relocation is so hacked up it is easier to write a new
1379    function than to try to deal with it.
1380
1381    This routine does a final relocation.  It should not be used when
1382    generating relocateable output.
1383
1384    FIXME: This routine ignores any special_function in the HOWTO,
1385    since the existing special_function values have been written for
1386    bfd_perform_relocation.
1387
1388    HOWTO is the reloc howto information.
1389    INPUT_BFD is the BFD which the reloc applies to.
1390    INPUT_SECTION is the section which the reloc applies to.
1391    CONTENTS is the contents of the section.
1392    ADDRESS is the address of the reloc within INPUT_SECTION.
1393    VALUE is the value of the symbol the reloc refers to.
1394    ADDEND is the addend of the reloc.  */
1395
1396 bfd_reloc_status_type
1397 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
1398                           value, addend)
1399      reloc_howto_type *howto;
1400      bfd *input_bfd;
1401      asection *input_section;
1402      bfd_byte *contents;
1403      bfd_vma address;
1404      bfd_vma value;
1405      bfd_vma addend;
1406 {
1407   bfd_vma relocation;
1408
1409   /* Sanity check the address.  */
1410   if (address > input_section->_cooked_size)
1411     return bfd_reloc_outofrange;
1412
1413   /* This function assumes that we are dealing with a basic relocation
1414      against a symbol.  We want to compute the value of the symbol to
1415      relocate to.  This is just VALUE, the value of the symbol, plus
1416      ADDEND, any addend associated with the reloc.  */
1417   relocation = value + addend;
1418
1419   /* If the relocation is PC relative, we want to set RELOCATION to
1420      the distance between the symbol (currently in RELOCATION) and the
1421      location we are relocating.  Some targets (e.g., i386-aout)
1422      arrange for the contents of the section to be the negative of the
1423      offset of the location within the section; for such targets
1424      pcrel_offset is false.  Other targets (e.g., m88kbcs or ELF)
1425      simply leave the contents of the section as zero; for such
1426      targets pcrel_offset is true.  If pcrel_offset is false we do not
1427      need to subtract out the offset of the location within the
1428      section (which is just ADDRESS).  */
1429   if (howto->pc_relative)
1430     {
1431       relocation -= (input_section->output_section->vma
1432                      + input_section->output_offset);
1433       if (howto->pcrel_offset)
1434         relocation -= address;
1435     }
1436
1437   return _bfd_relocate_contents (howto, input_bfd, relocation,
1438                                  contents + address);
1439 }
1440
1441 /* Relocate a given location using a given value and howto.  */
1442
1443 bfd_reloc_status_type
1444 _bfd_relocate_contents (howto, input_bfd, relocation, location)
1445      reloc_howto_type *howto;
1446      bfd *input_bfd;
1447      bfd_vma relocation;
1448      bfd_byte *location;
1449 {
1450   int size;
1451   bfd_vma x;
1452   boolean overflow;
1453
1454   /* If the size is negative, negate RELOCATION.  This isn't very
1455      general.  */
1456   if (howto->size < 0)
1457     relocation = -relocation;
1458
1459   /* Get the value we are going to relocate.  */
1460   size = bfd_get_reloc_size (howto);
1461   switch (size)
1462     {
1463     default:
1464     case 0:
1465       abort ();
1466     case 1:
1467       x = bfd_get_8 (input_bfd, location);
1468       break;
1469     case 2:
1470       x = bfd_get_16 (input_bfd, location);
1471       break;
1472     case 4:
1473       x = bfd_get_32 (input_bfd, location);
1474       break;
1475     case 8:
1476 #ifdef BFD64
1477       x = bfd_get_64 (input_bfd, location);
1478 #else
1479       abort ();
1480 #endif
1481       break;
1482     }
1483
1484   /* Check for overflow.  FIXME: We may drop bits during the addition
1485      which we don't check for.  We must either check at every single
1486      operation, which would be tedious, or we must do the computations
1487      in a type larger than bfd_vma, which would be inefficient.  */
1488   overflow = false;
1489   if (howto->complain_on_overflow != complain_overflow_dont)
1490     {
1491       bfd_vma check;
1492       bfd_signed_vma signed_check;
1493       bfd_vma add;
1494       bfd_signed_vma signed_add;
1495
1496       if (howto->rightshift == 0)
1497         {
1498           check = relocation;
1499           signed_check = (bfd_signed_vma) relocation;
1500         }
1501       else
1502         {
1503           /* Drop unwanted bits from the value we are relocating to.  */
1504           check = relocation >> howto->rightshift;
1505
1506           /* If this is a signed value, the rightshift just dropped
1507              leading 1 bits (assuming twos complement).  */
1508           if ((bfd_signed_vma) relocation >= 0)
1509             signed_check = check;
1510           else
1511             signed_check = (check
1512                             | ((bfd_vma) - 1
1513                                & ~((bfd_vma) - 1 >> howto->rightshift)));
1514         }
1515
1516       /* Get the value from the object file.  */
1517       add = x & howto->src_mask;
1518
1519       /* Get the value from the object file with an appropriate sign.
1520          The expression involving howto->src_mask isolates the upper
1521          bit of src_mask.  If that bit is set in the value we are
1522          adding, it is negative, and we subtract out that number times
1523          two.  If src_mask includes the highest possible bit, then we
1524          can not get the upper bit, but that does not matter since
1525          signed_add needs no adjustment to become negative in that
1526          case.  */
1527       signed_add = add;
1528       if ((add & (((~howto->src_mask) >> 1) & howto->src_mask)) != 0)
1529         signed_add -= (((~howto->src_mask) >> 1) & howto->src_mask) << 1;
1530
1531       /* Add the value from the object file, shifted so that it is a
1532          straight number.  */
1533       if (howto->bitpos == 0)
1534         {
1535           check += add;
1536           signed_check += signed_add;
1537         }
1538       else
1539         {
1540           check += add >> howto->bitpos;
1541
1542           /* For the signed case we use ADD, rather than SIGNED_ADD,
1543              to avoid warnings from SVR4 cc.  This is OK since we
1544              explictly handle the sign bits.  */
1545           if (signed_add >= 0)
1546             signed_check += add >> howto->bitpos;
1547           else
1548             signed_check += ((add >> howto->bitpos)
1549                              | ((bfd_vma) - 1
1550                                 & ~((bfd_vma) - 1 >> howto->bitpos)));
1551         }
1552
1553       switch (howto->complain_on_overflow)
1554         {
1555         case complain_overflow_signed:
1556           {
1557             /* Assumes two's complement.  */
1558             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1559             bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1560
1561             if (signed_check > reloc_signed_max
1562                 || signed_check < reloc_signed_min)
1563               overflow = true;
1564           }
1565           break;
1566         case complain_overflow_unsigned:
1567           {
1568             /* Assumes two's complement.  This expression avoids
1569                overflow if howto->bitsize is the number of bits in
1570                bfd_vma.  */
1571             bfd_vma reloc_unsigned_max =
1572             (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1573
1574             if (check > reloc_unsigned_max)
1575               overflow = true;
1576           }
1577           break;
1578         case complain_overflow_bitfield:
1579           {
1580             /* Assumes two's complement.  This expression avoids
1581                overflow if howto->bitsize is the number of bits in
1582                bfd_vma.  */
1583             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1584
1585             if ((check & ~reloc_bits) != 0
1586                 && (((bfd_vma) signed_check & ~reloc_bits)
1587                     != (-1 & ~reloc_bits)))
1588               overflow = true;
1589           }
1590           break;
1591         default:
1592           abort ();
1593         }
1594     }
1595
1596   /* Put RELOCATION in the right bits.  */
1597   relocation >>= (bfd_vma) howto->rightshift;
1598   relocation <<= (bfd_vma) howto->bitpos;
1599
1600   /* Add RELOCATION to the right bits of X.  */
1601   x = ((x & ~howto->dst_mask)
1602        | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1603
1604   /* Put the relocated value back in the object file.  */
1605   switch (size)
1606     {
1607     default:
1608     case 0:
1609       abort ();
1610     case 1:
1611       bfd_put_8 (input_bfd, x, location);
1612       break;
1613     case 2:
1614       bfd_put_16 (input_bfd, x, location);
1615       break;
1616     case 4:
1617       bfd_put_32 (input_bfd, x, location);
1618       break;
1619     case 8:
1620 #ifdef BFD64
1621       bfd_put_64 (input_bfd, x, location);
1622 #else
1623       abort ();
1624 #endif
1625       break;
1626     }
1627
1628   return overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1629 }
1630
1631 /*
1632 DOCDD
1633 INODE
1634         howto manager,  , typedef arelent, Relocations
1635
1636 SECTION
1637         The howto manager
1638
1639         When an application wants to create a relocation, but doesn't
1640         know what the target machine might call it, it can find out by
1641         using this bit of code.
1642
1643 */
1644
1645 /*
1646 TYPEDEF
1647         bfd_reloc_code_type
1648
1649 DESCRIPTION
1650         The insides of a reloc code.  The idea is that, eventually, there
1651         will be one enumerator for every type of relocation we ever do.
1652         Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1653         return a howto pointer.
1654
1655         This does mean that the application must determine the correct
1656         enumerator value; you can't get a howto pointer from a random set
1657         of attributes.
1658
1659 SENUM
1660    bfd_reloc_code_real
1661
1662 ENUM
1663   BFD_RELOC_64
1664 ENUMX
1665   BFD_RELOC_32
1666 ENUMX
1667   BFD_RELOC_26
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 relocations.  Some of these treat the symbol or "addend"
1887      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_LITERAL
1902 ENUMX
1903   BFD_RELOC_ALPHA_LITUSE
1904 ENUMDOC
1905   The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1906      the assembler turns it into a LDQ instruction to load the address of
1907      the symbol, and then fills in a register in the real instruction.
1908
1909      The LITERAL reloc, at the LDQ instruction, refers to the .lita
1910      section symbol.  The addend is ignored when writing, but is filled
1911      in with the file's GP value on reading, for convenience, as with the
1912      GPDISP_LO16 reloc.
1913
1914      The LITUSE reloc, on the instruction using the loaded address, gives
1915      information to the linker that it might be able to use to optimize
1916      away some literal section references.  The symbol is ignored (read
1917      as the absolute section symbol), and the "addend" indicates the type
1918      of instruction using the register:
1919               1 - "memory" fmt insn
1920               2 - byte-manipulation (byte offset reg)
1921               3 - jsr (target of branch)
1922
1923      The GNU linker currently doesn't do any of this optimizing.
1924
1925 ENUM
1926   BFD_RELOC_ALPHA_HINT
1927 ENUMDOC
1928   The HINT relocation indicates a value that should be filled into the
1929      "hint" field of a jmp/jsr/ret instruction, for possible branch-
1930      prediction logic which may be provided on some processors.
1931
1932 ENUM
1933   BFD_RELOC_MIPS_JMP
1934 ENUMDOC
1935   Bits 27..2 of the relocation address shifted right 2 bits;
1936      simple reloc otherwise.
1937
1938 ENUM
1939   BFD_RELOC_HI16
1940 ENUMDOC
1941   High 16 bits of 32-bit value; simple reloc.
1942 ENUM
1943   BFD_RELOC_HI16_S
1944 ENUMDOC
1945   High 16 bits of 32-bit value but the low 16 bits will be sign
1946      extended and added to form the final result.  If the low 16
1947      bits form a negative number, we need to add one to the high value
1948      to compensate for the borrow when the low bits are added.
1949 ENUM
1950   BFD_RELOC_LO16
1951 ENUMDOC
1952   Low 16 bits.
1953 ENUM
1954   BFD_RELOC_PCREL_HI16_S
1955 ENUMDOC
1956   Like BFD_RELOC_HI16_S, but PC relative.
1957 ENUM
1958   BFD_RELOC_PCREL_LO16
1959 ENUMDOC
1960   Like BFD_RELOC_LO16, but PC relative.
1961
1962 ENUMEQ
1963   BFD_RELOC_MIPS_GPREL
1964   BFD_RELOC_GPREL16
1965 ENUMDOC
1966   Relocation relative to the global pointer.
1967
1968 ENUM
1969   BFD_RELOC_MIPS_LITERAL
1970 ENUMDOC
1971   Relocation against a MIPS literal section.
1972
1973 ENUM
1974   BFD_RELOC_MIPS_GOT16
1975 ENUMX
1976   BFD_RELOC_MIPS_CALL16
1977 ENUMEQX
1978   BFD_RELOC_MIPS_GPREL32
1979   BFD_RELOC_GPREL32
1980 ENUMX
1981   BFD_RELOC_MIPS_GOT_HI16
1982 ENUMX
1983   BFD_RELOC_MIPS_GOT_LO16
1984 ENUMDOC
1985   MIPS ELF relocations.
1986
1987 ENUM
1988   BFD_RELOC_386_GOT32
1989 ENUMX
1990   BFD_RELOC_386_PLT32
1991 ENUMX
1992   BFD_RELOC_386_COPY
1993 ENUMX
1994   BFD_RELOC_386_GLOB_DAT
1995 ENUMX
1996   BFD_RELOC_386_JUMP_SLOT
1997 ENUMX
1998   BFD_RELOC_386_RELATIVE
1999 ENUMX
2000   BFD_RELOC_386_GOTOFF
2001 ENUMX
2002   BFD_RELOC_386_GOTPC
2003 ENUMDOC
2004   i386/elf relocations
2005
2006 ENUM
2007   BFD_RELOC_NS32K_IMM_8
2008 ENUMX
2009   BFD_RELOC_NS32K_IMM_16
2010 ENUMX
2011   BFD_RELOC_NS32K_IMM_32
2012 ENUMX
2013   BFD_RELOC_NS32K_IMM_8_PCREL
2014 ENUMX
2015   BFD_RELOC_NS32K_IMM_16_PCREL
2016 ENUMX
2017   BFD_RELOC_NS32K_IMM_32_PCREL
2018 ENUMX
2019   BFD_RELOC_NS32K_DISP_8
2020 ENUMX
2021   BFD_RELOC_NS32K_DISP_16
2022 ENUMX
2023   BFD_RELOC_NS32K_DISP_32
2024 ENUMX
2025   BFD_RELOC_NS32K_DISP_8_PCREL
2026 ENUMX
2027   BFD_RELOC_NS32K_DISP_16_PCREL
2028 ENUMX
2029   BFD_RELOC_NS32K_DISP_32_PCREL
2030 ENUMDOC
2031   ns32k relocations
2032
2033 ENUM
2034   BFD_RELOC_PPC_B26
2035 ENUMX
2036   BFD_RELOC_PPC_BA26
2037 ENUMX
2038   BFD_RELOC_PPC_TOC16
2039 ENUMX
2040   BFD_RELOC_PPC_B16
2041 ENUMX
2042   BFD_RELOC_PPC_B16_BRTAKEN
2043 ENUMX
2044   BFD_RELOC_PPC_B16_BRNTAKEN
2045 ENUMX
2046   BFD_RELOC_PPC_BA16
2047 ENUMX
2048   BFD_RELOC_PPC_BA16_BRTAKEN
2049 ENUMX
2050   BFD_RELOC_PPC_BA16_BRNTAKEN
2051 ENUMX
2052   BFD_RELOC_PPC_COPY
2053 ENUMX
2054   BFD_RELOC_PPC_GLOB_DAT
2055 ENUMX
2056   BFD_RELOC_PPC_JMP_SLOT
2057 ENUMX
2058   BFD_RELOC_PPC_RELATIVE
2059 ENUMX
2060   BFD_RELOC_PPC_LOCAL24PC
2061 ENUMX
2062   BFD_RELOC_PPC_EMB_NADDR32
2063 ENUMX
2064   BFD_RELOC_PPC_EMB_NADDR16
2065 ENUMX
2066   BFD_RELOC_PPC_EMB_NADDR16_LO
2067 ENUMX
2068   BFD_RELOC_PPC_EMB_NADDR16_HI
2069 ENUMX
2070   BFD_RELOC_PPC_EMB_NADDR16_HA
2071 ENUMX
2072   BFD_RELOC_PPC_EMB_SDAI16
2073 ENUMX
2074   BFD_RELOC_PPC_EMB_SDA2I16
2075 ENUMX
2076   BFD_RELOC_PPC_EMB_SDA2REL
2077 ENUMX
2078   BFD_RELOC_PPC_EMB_SDA21
2079 ENUMX
2080   BFD_RELOC_PPC_EMB_MRKREF
2081 ENUMX
2082   BFD_RELOC_PPC_EMB_RELSEC16
2083 ENUMX
2084   BFD_RELOC_PPC_EMB_RELST_LO
2085 ENUMX
2086   BFD_RELOC_PPC_EMB_RELST_HI
2087 ENUMX
2088   BFD_RELOC_PPC_EMB_RELST_HA
2089 ENUMX
2090   BFD_RELOC_PPC_EMB_BIT_FLD
2091 ENUMX
2092   BFD_RELOC_PPC_EMB_RELSDA
2093 ENUMDOC
2094   Power(rs6000) and PowerPC relocations.
2095
2096 ENUM
2097   BFD_RELOC_CTOR
2098 ENUMDOC
2099   The type of reloc used to build a contructor table - at the moment
2100   probably a 32 bit wide absolute relocation, but the target can choose.
2101   It generally does map to one of the other relocation types.
2102
2103 ENUM
2104   BFD_RELOC_ARM_PCREL_BRANCH
2105 ENUMDOC
2106   ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
2107   not stored in the instruction.
2108 ENUM
2109   BFD_RELOC_ARM_IMMEDIATE
2110 ENUMX
2111   BFD_RELOC_ARM_OFFSET_IMM
2112 ENUMX
2113   BFD_RELOC_ARM_SHIFT_IMM
2114 ENUMX
2115   BFD_RELOC_ARM_SWI
2116 ENUMX
2117   BFD_RELOC_ARM_MULTI
2118 ENUMX
2119   BFD_RELOC_ARM_CP_OFF_IMM
2120 ENUMX
2121   BFD_RELOC_ARM_ADR_IMM
2122 ENUMX
2123   BFD_RELOC_ARM_LDR_IMM
2124 ENUMX
2125   BFD_RELOC_ARM_LITERAL
2126 ENUMX
2127   BFD_RELOC_ARM_IN_POOL
2128 ENUMDOC
2129   These relocs are only used within the ARM assembler.  They are not
2130   (at present) written to any object files.
2131
2132 COMMENT
2133 {* start-sanitize-arc *}
2134 ENUM
2135   BFD_RELOC_ARC_B22_PCREL
2136 ENUMDOC
2137   Argonaut RISC Core (ARC) relocs.
2138   ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
2139   not stored in the instruction.  The high 20 bits are installed in bits 26
2140   through 7 of the instruction.
2141 ENUM
2142   BFD_RELOC_ARC_B26
2143 ENUMDOC
2144   ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
2145   stored in the instruction.  The high 24 bits are installed in bits 23
2146   through 0.
2147 COMMENT
2148 {* end-sanitize-arc *}
2149 ENDSENUM
2150   BFD_RELOC_UNUSED
2151 CODE_FRAGMENT
2152 .
2153 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2154 */
2155
2156
2157 /*
2158 FUNCTION
2159         bfd_reloc_type_lookup
2160
2161 SYNOPSIS
2162         reloc_howto_type *
2163         bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
2164
2165 DESCRIPTION
2166         Return a pointer to a howto structure which, when
2167         invoked, will perform the relocation @var{code} on data from the
2168         architecture noted.
2169
2170 */
2171
2172
2173 reloc_howto_type *
2174 bfd_reloc_type_lookup (abfd, code)
2175      bfd *abfd;
2176      bfd_reloc_code_real_type code;
2177 {
2178   return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
2179 }
2180
2181 static reloc_howto_type bfd_howto_32 =
2182 HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
2183
2184
2185 /*
2186 INTERNAL_FUNCTION
2187         bfd_default_reloc_type_lookup
2188
2189 SYNOPSIS
2190         reloc_howto_type *bfd_default_reloc_type_lookup
2191         (bfd *abfd, bfd_reloc_code_real_type  code);
2192
2193 DESCRIPTION
2194         Provides a default relocation lookup routine for any architecture.
2195
2196
2197 */
2198
2199 reloc_howto_type *
2200 bfd_default_reloc_type_lookup (abfd, code)
2201      bfd *abfd;
2202      bfd_reloc_code_real_type code;
2203 {
2204   switch (code)
2205     {
2206     case BFD_RELOC_CTOR:
2207       /* The type of reloc used in a ctor, which will be as wide as the
2208          address - so either a 64, 32, or 16 bitter.  */
2209       switch (bfd_get_arch_info (abfd)->bits_per_address)
2210         {
2211         case 64:
2212           BFD_FAIL ();
2213         case 32:
2214           return &bfd_howto_32;
2215         case 16:
2216           BFD_FAIL ();
2217         default:
2218           BFD_FAIL ();
2219         }
2220     default:
2221       BFD_FAIL ();
2222     }
2223   return (reloc_howto_type *) NULL;
2224 }
2225
2226 /*
2227 FUNCTION
2228         bfd_get_reloc_code_name
2229
2230 SYNOPSIS
2231         const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
2232
2233 DESCRIPTION
2234         Provides a printable name for the supplied relocation code.
2235         Useful mainly for printing error messages.
2236 */
2237
2238 const char *
2239 bfd_get_reloc_code_name (code)
2240      bfd_reloc_code_real_type code;
2241 {
2242   if (code > BFD_RELOC_UNUSED)
2243     return 0;
2244   return bfd_reloc_code_real_names[(int)code];
2245 }
2246
2247 /*
2248 INTERNAL_FUNCTION
2249         bfd_generic_relax_section
2250
2251 SYNOPSIS
2252         boolean bfd_generic_relax_section
2253          (bfd *abfd,
2254           asection *section,
2255           struct bfd_link_info *,
2256           boolean *);
2257
2258 DESCRIPTION
2259         Provides default handling for relaxing for back ends which
2260         don't do relaxing -- i.e., does nothing.
2261 */
2262
2263 /*ARGSUSED*/
2264 boolean
2265 bfd_generic_relax_section (abfd, section, link_info, again)
2266      bfd *abfd;
2267      asection *section;
2268      struct bfd_link_info *link_info;
2269      boolean *again;
2270 {
2271   *again = false;
2272   return true;
2273 }
2274
2275 /*
2276 INTERNAL_FUNCTION
2277         bfd_generic_get_relocated_section_contents
2278
2279 SYNOPSIS
2280         bfd_byte *
2281            bfd_generic_get_relocated_section_contents (bfd *abfd,
2282              struct bfd_link_info *link_info,
2283              struct bfd_link_order *link_order,
2284              bfd_byte *data,
2285              boolean relocateable,
2286              asymbol **symbols);
2287
2288 DESCRIPTION
2289         Provides default handling of relocation effort for back ends
2290         which can't be bothered to do it efficiently.
2291
2292 */
2293
2294 bfd_byte *
2295 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
2296                                             relocateable, symbols)
2297      bfd *abfd;
2298      struct bfd_link_info *link_info;
2299      struct bfd_link_order *link_order;
2300      bfd_byte *data;
2301      boolean relocateable;
2302      asymbol **symbols;
2303 {
2304   /* Get enough memory to hold the stuff */
2305   bfd *input_bfd = link_order->u.indirect.section->owner;
2306   asection *input_section = link_order->u.indirect.section;
2307
2308   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
2309   arelent **reloc_vector = NULL;
2310   long reloc_count;
2311
2312   if (reloc_size < 0)
2313     goto error_return;
2314
2315   reloc_vector = (arelent **) bfd_malloc ((size_t) reloc_size);
2316   if (reloc_vector == NULL && reloc_size != 0)
2317     goto error_return;
2318
2319   /* read in the section */
2320   if (!bfd_get_section_contents (input_bfd,
2321                                  input_section,
2322                                  (PTR) data,
2323                                  0,
2324                                  input_section->_raw_size))
2325     goto error_return;
2326
2327   /* We're not relaxing the section, so just copy the size info */
2328   input_section->_cooked_size = input_section->_raw_size;
2329   input_section->reloc_done = true;
2330
2331   reloc_count = bfd_canonicalize_reloc (input_bfd,
2332                                         input_section,
2333                                         reloc_vector,
2334                                         symbols);
2335   if (reloc_count < 0)
2336     goto error_return;
2337
2338   if (reloc_count > 0)
2339     {
2340       arelent **parent;
2341       for (parent = reloc_vector; *parent != (arelent *) NULL;
2342            parent++)
2343         {
2344           char *error_message = (char *) NULL;
2345           bfd_reloc_status_type r =
2346             bfd_perform_relocation (input_bfd,
2347                                     *parent,
2348                                     (PTR) data,
2349                                     input_section,
2350                                     relocateable ? abfd : (bfd *) NULL,
2351                                     &error_message);
2352
2353           if (relocateable)
2354             {
2355               asection *os = input_section->output_section;
2356
2357               /* A partial link, so keep the relocs */
2358               os->orelocation[os->reloc_count] = *parent;
2359               os->reloc_count++;
2360             }
2361
2362           if (r != bfd_reloc_ok)
2363             {
2364               switch (r)
2365                 {
2366                 case bfd_reloc_undefined:
2367                   if (!((*link_info->callbacks->undefined_symbol)
2368                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2369                          input_bfd, input_section, (*parent)->address)))
2370                     goto error_return;
2371                   break;
2372                 case bfd_reloc_dangerous:
2373                   BFD_ASSERT (error_message != (char *) NULL);
2374                   if (!((*link_info->callbacks->reloc_dangerous)
2375                         (link_info, error_message, input_bfd, input_section,
2376                          (*parent)->address)))
2377                     goto error_return;
2378                   break;
2379                 case bfd_reloc_overflow:
2380                   if (!((*link_info->callbacks->reloc_overflow)
2381                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2382                          (*parent)->howto->name, (*parent)->addend,
2383                          input_bfd, input_section, (*parent)->address)))
2384                     goto error_return;
2385                   break;
2386                 case bfd_reloc_outofrange:
2387                 default:
2388                   abort ();
2389                   break;
2390                 }
2391
2392             }
2393         }
2394     }
2395   if (reloc_vector != NULL)
2396     free (reloc_vector);
2397   return data;
2398
2399 error_return:
2400   if (reloc_vector != NULL)
2401     free (reloc_vector);
2402   return NULL;
2403 }