bfd/reloc.c

   1 /* BFD support for handling relocation entries.
   2    Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /*
  22 SECTION
  23         Relocations
  24
  25         BFD maintains relocations in much the same way it maintains
  26         symbols: they are left alone until required, then read in
  27         en-mass and translated into an internal form.  A common
  28         routine <<bfd_perform_relocation>> acts upon the
  29         canonical form to do the fixup.
  30
  31         Relocations are maintained on a per section basis,
  32         while symbols are maintained on a per BFD basis.
  33
  34         All that a back end has to do to fit the BFD interface is to create
  35         a <<struct reloc_cache_entry>> for each relocation
  36         in a particular section, and fill in the right bits of the structures.
  37
  38 @menu
  39 @* typedef arelent::
  40 @* howto manager::
  41 @end menu
  42
  43 */
  44 #include "bfd.h"
  45 #include "sysdep.h"
  46 #include "bfdlink.h"
  47 #include "libbfd.h"
  48 /*
  49 DOCDD
  50 INODE
  51         typedef arelent, howto manager, Relocations, Relocations
  52
  53 SUBSECTION
  54         typedef arelent
  55
  56         This is the structure of a relocation entry:
  57
  58 CODE_FRAGMENT
  59 .
  60 .typedef enum bfd_reloc_status
  61 .{
  62 .       {* No errors detected *}
  63 .  bfd_reloc_ok,
  64 .
  65 .       {* The relocation was performed, but there was an overflow. *}
  66 .  bfd_reloc_overflow,
  67 .
  68 .       {* The address to relocate was not within the section supplied. *}
  69 .  bfd_reloc_outofrange,
  70 .
  71 .       {* Used by special functions *}
  72 .  bfd_reloc_continue,
  73 .
  74 .       {* Unsupported relocation size requested. *}
  75 .  bfd_reloc_notsupported,
  76 .
  77 .       {* Unused *}
  78 .  bfd_reloc_other,
  79 .
  80 .       {* The symbol to relocate against was undefined. *}
  81 .  bfd_reloc_undefined,
  82 .
  83 .       {* The relocation was performed, but may not be ok - presently
  84 .          generated only when linking i960 coff files with i960 b.out
  85 .          symbols.  If this type is returned, the error_message argument
  86 .          to bfd_perform_relocation will be set.  *}
  87 .  bfd_reloc_dangerous
  88 . }
  89 . bfd_reloc_status_type;
  90 .
  91 .
  92 .typedef struct reloc_cache_entry
  93 .{
  94 .       {* A pointer into the canonical table of pointers  *}
  95 .  struct symbol_cache_entry **sym_ptr_ptr;
  96 .
  97 .       {* offset in section *}
  98 .  bfd_size_type address;
  99 .
 100 .       {* addend for relocation value *}
 101 .  bfd_vma addend;
 102 .
 103 .       {* Pointer to how to perform the required relocation *}
 104 .  const struct reloc_howto_struct *howto;
 105 .
 106 .} arelent;
 107
 108 */
 109
 110 /*
 111 DESCRIPTION
 112
 113         Here is a description of each of the fields within an <<arelent>>:
 114
 115         o <<sym_ptr_ptr>>
 116
 117         The symbol table pointer points to a pointer to the symbol
 118         associated with the relocation request.  It is
 119         the pointer into the table returned by the back end's
 120         <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
 121         through a pointer to a pointer so that tools like the linker
 122         can fix up all the symbols of the same name by modifying only
 123         one pointer. The relocation routine looks in the symbol and
 124         uses the base of the section the symbol is attached to and the
 125         value of the symbol as the initial relocation offset. If the
 126         symbol pointer is zero, then the section provided is looked up.
 127
 128         o <<address>>
 129
 130         The <<address>> field gives the offset in bytes from the base of
 131         the section data which owns the relocation record to the first
 132         byte of relocatable information. The actual data relocated
 133         will be relative to this point; for example, a relocation
 134         type which modifies the bottom two bytes of a four byte word
 135         would not touch the first byte pointed to in a big endian
 136         world.
 137
 138         o <<addend>>
 139
 140         The <<addend>> is a value provided by the back end to be added (!)
 141         to the relocation offset. Its interpretation is dependent upon
 142         the howto. For example, on the 68k the code:
 143
 144
 145 |        char foo[];
 146 |        main()
 147 |                {
 148 |                return foo[0x12345678];
 149 |                }
 150
 151         Could be compiled into:
 152
 153 |        linkw fp,#-4
 154 |        moveb @@#12345678,d0
 155 |        extbl d0
 156 |        unlk fp
 157 |        rts
 158
 159
 160         This could create a reloc pointing to <<foo>>, but leave the
 161         offset in the data, something like:
 162
 163
 164 |RELOCATION RECORDS FOR [.text]:
 165 |offset   type      value
 166 |00000006 32        _foo
 167 |
 168 |00000000 4e56 fffc          ; linkw fp,#-4
 169 |00000004 1039 1234 5678     ; moveb @@#12345678,d0
 170 |0000000a 49c0               ; extbl d0
 171 |0000000c 4e5e               ; unlk fp
 172 |0000000e 4e75               ; rts
 173
 174
 175         Using coff and an 88k, some instructions don't have enough
 176         space in them to represent the full address range, and
 177         pointers have to be loaded in two parts. So you'd get something like:
 178
 179
 180 |        or.u     r13,r0,hi16(_foo+0x12345678)
 181 |        ld.b     r2,r13,lo16(_foo+0x12345678)
 182 |        jmp      r1
 183
 184
 185         This should create two relocs, both pointing to <<_foo>>, and with
 186         0x12340000 in their addend field. The data would consist of:
 187
 188
 189 |RELOCATION RECORDS FOR [.text]:
 190 |offset   type      value
 191 |00000002 HVRT16    _foo+0x12340000
 192 |00000006 LVRT16    _foo+0x12340000
 193 |
 194 |00000000 5da05678           ; or.u r13,r0,0x5678
 195 |00000004 1c4d5678           ; ld.b r2,r13,0x5678
 196 |00000008 f400c001           ; jmp r1
 197
 198
 199         The relocation routine digs out the value from the data, adds
 200         it to the addend to get the original offset, and then adds the
 201         value of <<_foo>>. Note that all 32 bits have to be kept around
 202         somewhere, to cope with carry from bit 15 to bit 16.
 203
 204         One further example is the sparc and the a.out format. The
 205         sparc has a similar problem to the 88k, in that some
 206         instructions don't have room for an entire offset, but on the
 207         sparc the parts are created in odd sized lumps. The designers of
 208         the a.out format chose to not use the data within the section
 209         for storing part of the offset; all the offset is kept within
 210         the reloc. Anything in the data should be ignored.
 211
 212 |        save %sp,-112,%sp
 213 |        sethi %hi(_foo+0x12345678),%g2
 214 |        ldsb [%g2+%lo(_foo+0x12345678)],%i0
 215 |        ret
 216 |        restore
 217
 218         Both relocs contain a pointer to <<foo>>, and the offsets
 219         contain junk.
 220
 221
 222 |RELOCATION RECORDS FOR [.text]:
 223 |offset   type      value
 224 |00000004 HI22      _foo+0x12345678
 225 |00000008 LO10      _foo+0x12345678
 226 |
 227 |00000000 9de3bf90     ; save %sp,-112,%sp
 228 |00000004 05000000     ; sethi %hi(_foo+0),%g2
 229 |00000008 f048a000     ; ldsb [%g2+%lo(_foo+0)],%i0
 230 |0000000c 81c7e008     ; ret
 231 |00000010 81e80000     ; restore
 232
 233
 234         o <<howto>>
 235
 236         The <<howto>> field can be imagined as a
 237         relocation instruction. It is a pointer to a structure which
 238         contains information on what to do with all of the other
 239         information in the reloc record and data section. A back end
 240         would normally have a relocation instruction set and turn
 241         relocations into pointers to the correct structure on input -
 242         but it would be possible to create each howto field on demand.
 243
 244 */
 245
 246 /*
 247 SUBSUBSECTION
 248         <<enum complain_overflow>>
 249
 250         Indicates what sort of overflow checking should be done when
 251         performing a relocation.
 252
 253 CODE_FRAGMENT
 254 .
 255 .enum complain_overflow
 256 .{
 257 .       {* Do not complain on overflow. *}
 258 .  complain_overflow_dont,
 259 .
 260 .       {* Complain if the bitfield overflows, whether it is considered
 261 .          as signed or unsigned. *}
 262 .  complain_overflow_bitfield,
 263 .
 264 .       {* Complain if the value overflows when considered as signed
 265 .          number. *}
 266 .  complain_overflow_signed,
 267 .
 268 .       {* Complain if the value overflows when considered as an
 269 .          unsigned number. *}
 270 .  complain_overflow_unsigned
 271 .};
 272
 273 */
 274
 275 /*
 276 SUBSUBSECTION
 277         <<reloc_howto_type>>
 278
 279         The <<reloc_howto_type>> is a structure which contains all the
 280         information that libbfd needs to know to tie up a back end's data.
 281
 282 CODE_FRAGMENT
 283 .struct symbol_cache_entry;             {* Forward declaration *}
 284 .
 285 .typedef struct reloc_howto_struct
 286 .{
 287 .       {*  The type field has mainly a documetary use - the back end can
 288 .           do what it wants with it, though normally the back end's
 289 .           external idea of what a reloc number is stored
 290 .           in this field. For example, a PC relative word relocation
 291 .           in a coff environment has the type 023 - because that's
 292 .           what the outside world calls a R_PCRWORD reloc. *}
 293 .  unsigned int type;
 294 .
 295 .       {*  The value the final relocation is shifted right by. This drops
 296 .           unwanted data from the relocation.  *}
 297 .  unsigned int rightshift;
 298 .
 299 .       {*  The size of the item to be relocated.  This is *not* a
 300 .           power-of-two measure.  To get the number of bytes operated
 301 .           on by a type of relocation, use bfd_get_reloc_size.  *}
 302 .  int size;
 303 .
 304 .       {*  The number of bits in the item to be relocated.  This is used
 305 .           when doing overflow checking.  *}
 306 .  unsigned int bitsize;
 307 .
 308 .       {*  Notes that the relocation is relative to the location in the
 309 .           data section of the addend. The relocation function will
 310 .           subtract from the relocation value the address of the location
 311 .           being relocated. *}
 312 .  boolean pc_relative;
 313 .
 314 .       {*  The bit position of the reloc value in the destination.
 315 .           The relocated value is left shifted by this amount. *}
 316 .  unsigned int bitpos;
 317 .
 318 .       {* What type of overflow error should be checked for when
 319 .          relocating. *}
 320 .  enum complain_overflow complain_on_overflow;
 321 .
 322 .       {* If this field is non null, then the supplied function is
 323 .          called rather than the normal function. This allows really
 324 .          strange relocation methods to be accomodated (e.g., i960 callj
 325 .          instructions). *}
 326 .  bfd_reloc_status_type (*special_function)
 327 .                                   PARAMS ((bfd *abfd,
 328 .                                            arelent *reloc_entry,
 329 .                                            struct symbol_cache_entry *symbol,
 330 .                                            PTR data,
 331 .                                            asection *input_section,
 332 .                                            bfd *output_bfd,
 333 .                                            char **error_message));
 334 .
 335 .       {* The textual name of the relocation type. *}
 336 .  char *name;
 337 .
 338 .       {* When performing a partial link, some formats must modify the
 339 .          relocations rather than the data - this flag signals this.*}
 340 .  boolean partial_inplace;
 341 .
 342 .       {* The src_mask selects which parts of the read in data
 343 .          are to be used in the relocation sum.  E.g., if this was an 8 bit
 344 .          bit of data which we read and relocated, this would be
 345 .          0x000000ff. When we have relocs which have an addend, such as
 346 .          sun4 extended relocs, the value in the offset part of a
 347 .          relocating field is garbage so we never use it. In this case
 348 .          the mask would be 0x00000000. *}
 349 .  bfd_vma src_mask;
 350 .
 351 .       {* The dst_mask selects which parts of the instruction are replaced
 352 .          into the instruction. In most cases src_mask == dst_mask,
 353 .          except in the above special case, where dst_mask would be
 354 .          0x000000ff, and src_mask would be 0x00000000.   *}
 355 .  bfd_vma dst_mask;
 356 .
 357 .       {* When some formats create PC relative instructions, they leave
 358 .          the value of the pc of the place being relocated in the offset
 359 .          slot of the instruction, so that a PC relative relocation can
 360 .          be made just by adding in an ordinary offset (e.g., sun3 a.out).
 361 .          Some formats leave the displacement part of an instruction
 362 .          empty (e.g., m88k bcs); this flag signals the fact.*}
 363 .  boolean pcrel_offset;
 364 .
 365 .} reloc_howto_type;
 366
 367 */
 368
 369 /*
 370 FUNCTION
 371         The HOWTO Macro
 372
 373 DESCRIPTION
 374         The HOWTO define is horrible and will go away.
 375
 376
 377 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
 378 .  {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
 379
 380 DESCRIPTION
 381         And will be replaced with the totally magic way. But for the
 382         moment, we are compatible, so do it this way.
 383
 384
 385 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
 386 .
 387 DESCRIPTION
 388         Helper routine to turn a symbol into a relocation value.
 389
 390 .#define HOWTO_PREPARE(relocation, symbol)      \
 391 .  {                                            \
 392 .  if (symbol != (asymbol *)NULL) {             \
 393 .    if (bfd_is_com_section (symbol->section)) { \
 394 .      relocation = 0;                          \
 395 .    }                                          \
 396 .    else {                                     \
 397 .      relocation = symbol->value;              \
 398 .    }                                          \
 399 .  }                                            \
 400 .}
 401
 402 */
 403
 404 /*
 405 FUNCTION
 406         bfd_get_reloc_size
 407
 408 SYNOPSIS
 409         int bfd_get_reloc_size (const reloc_howto_type *);
 410
 411 DESCRIPTION
 412         For a reloc_howto_type that operates on a fixed number of bytes,
 413         this returns the number of bytes operated on.
 414  */
 415
 416 int
 417 bfd_get_reloc_size (howto)
 418      const reloc_howto_type *howto;
 419 {
 420   switch (howto->size) {
 421   case 0: return 1;
 422   case 1: return 2;
 423   case 2: return 4;
 424   case 3: return 0;
 425   case 4: return 8;
 426   case -2: return 4;
 427   default: abort ();
 428   }
 429 }
 430
 431 /*
 432 TYPEDEF
 433         arelent_chain
 434
 435 DESCRIPTION
 436
 437         How relocs are tied together in an <<asection>>:
 438
 439 .typedef unsigned char bfd_byte;
 440 .
 441 .typedef struct relent_chain {
 442 .  arelent relent;
 443 .  struct   relent_chain *next;
 444 .} arelent_chain;
 445
 446 */
 447
 448
 449
 450 /*
 451 FUNCTION
 452         bfd_perform_relocation
 453
 454 SYNOPSIS
 455         bfd_reloc_status_type
 456                 bfd_perform_relocation
 457                         (bfd *abfd,
 458                          arelent *reloc_entry,
 459                          PTR data,
 460                          asection *input_section,
 461                          bfd *output_bfd,
 462                          char **error_message);
 463
 464 DESCRIPTION
 465         If @var{output_bfd} is supplied to this function, the
 466         generated image will be relocatable; the relocations are
 467         copied to the output file after they have been changed to
 468         reflect the new state of the world. There are two ways of
 469         reflecting the results of partial linkage in an output file:
 470         by modifying the output data in place, and by modifying the
 471         relocation record.  Some native formats (e.g., basic a.out and
 472         basic coff) have no way of specifying an addend in the
 473         relocation type, so the addend has to go in the output data.
 474         This is no big deal since in these formats the output data
 475         slot will always be big enough for the addend. Complex reloc
 476         types with addends were invented to solve just this problem.
 477         The @var{error_message} argument is set to an error message if
 478         this return @code{bfd_reloc_dangerous}.
 479
 480 */
 481
 482
 483 bfd_reloc_status_type
 484 bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
 485                         error_message)
 486      bfd *abfd;
 487      arelent *reloc_entry;
 488      PTR data;
 489      asection *input_section;
 490      bfd *output_bfd;
 491      char **error_message;
 492 {
 493   bfd_vma relocation;
 494   bfd_reloc_status_type flag = bfd_reloc_ok;
 495   bfd_size_type addr = reloc_entry->address ;
 496   bfd_vma output_base = 0;
 497   const reloc_howto_type *howto = reloc_entry->howto;
 498   asection *reloc_target_output_section;
 499   asymbol *symbol;
 500
 501   symbol = *(reloc_entry->sym_ptr_ptr);
 502   if ((symbol->section == &bfd_abs_section)
 503       && output_bfd != (bfd *)NULL)
 504     {
 505       reloc_entry->address += input_section->output_offset;
 506       return bfd_reloc_ok;
 507     }
 508
 509   /* If we are not producing relocateable output, return an error if
 510      the symbol is not defined.  An undefined weak symbol is
 511      considered to have a value of zero (SVR4 ABI, p. 4-27).  */
 512   if (symbol->section == &bfd_und_section
 513       && (symbol->flags & BSF_WEAK) == 0
 514       && output_bfd == (bfd *) NULL)
 515     flag = bfd_reloc_undefined;
 516
 517   /* If there is a function supplied to handle this relocation type,
 518      call it.  It'll return `bfd_reloc_continue' if further processing
 519      can be done.  */
 520   if (howto->special_function)
 521     {
 522       bfd_reloc_status_type cont;
 523       cont = howto->special_function (abfd, reloc_entry, symbol, data,
 524                                       input_section, output_bfd,
 525                                       error_message);
 526       if (cont != bfd_reloc_continue)
 527         return cont;
 528     }
 529
 530   /* Is the address of the relocation really within the section?  */
 531   if (reloc_entry->address > input_section->_cooked_size)
 532     return bfd_reloc_outofrange;
 533
 534   /* Work out which section the relocation is targetted at and the
 535      initial relocation command value.  */
 536
 537   /* Get symbol value.  (Common symbols are special.)  */
 538   if (bfd_is_com_section (symbol->section))
 539     relocation = 0;
 540   else
 541     relocation = symbol->value;
 542
 543
 544   reloc_target_output_section = symbol->section->output_section;
 545
 546   /* Convert input-section-relative symbol value to absolute.  */
 547   if (output_bfd && howto->partial_inplace==false)
 548     output_base = 0;
 549   else
 550     output_base = reloc_target_output_section->vma;
 551
 552   relocation += output_base + symbol->section->output_offset;
 553
 554   /* Add in supplied addend.  */
 555   relocation += reloc_entry->addend;
 556
 557   /* Here the variable relocation holds the final address of the
 558      symbol we are relocating against, plus any addend.  */
 559
 560   if (howto->pc_relative == true)
 561     {
 562       /* This is a PC relative relocation.  We want to set RELOCATION
 563          to the distance between the address of the symbol and the
 564          location.  RELOCATION is already the address of the symbol.
 565
 566          We start by subtracting the address of the section containing
 567          the location.
 568
 569          If pcrel_offset is set, we must further subtract the position
 570          of the location within the section.  Some targets arrange for
 571          the addend to be the negative of the position of the location
 572          within the section; for example, i386-aout does this.  For
 573          i386-aout, pcrel_offset is false.  Some other targets do not
 574          include the position of the location; for example, m88kbcs,
 575          or ELF.  For those targets, pcrel_offset is true.
 576
 577          If we are producing relocateable output, then we must ensure
 578          that this reloc will be correctly computed when the final
 579          relocation is done.  If pcrel_offset is false we want to wind
 580          up with the negative of the location within the section,
 581          which means we must adjust the existing addend by the change
 582          in the location within the section.  If pcrel_offset is true
 583          we do not want to adjust the existing addend at all.
 584
 585          FIXME: This seems logical to me, but for the case of
 586          producing relocateable output it is not what the code
 587          actually does.  I don't want to change it, because it seems
 588          far too likely that something will break.  */
 589
 590       relocation -=
 591         input_section->output_section->vma + input_section->output_offset;
 592
 593       if (howto->pcrel_offset == true)
 594         relocation -= reloc_entry->address;
 595     }
 596
 597   if (output_bfd!= (bfd *)NULL)
 598     {
 599       if ( howto->partial_inplace == false)
 600         {
 601           /* This is a partial relocation, and we want to apply the relocation
 602              to the reloc entry rather than the raw data. Modify the reloc
 603              inplace to reflect what we now know.  */
 604           reloc_entry->addend = relocation;
 605           reloc_entry->address +=  input_section->output_offset;
 606           return flag;
 607         }
 608       else
 609         {
 610           /* This is a partial relocation, but inplace, so modify the
 611              reloc record a bit.
 612
 613              If we've relocated with a symbol with a section, change
 614              into a ref to the section belonging to the symbol.  */
 615
 616           reloc_entry->address += input_section->output_offset;
 617
 618           /* WTF?? */
 619           if (abfd->xvec->flavour == bfd_target_coff_flavour)
 620             {
 621 #if 1
 622               /* For m68k-coff, the addend was being subtracted twice during
 623                  relocation with -r.  Removing the line below this comment
 624                  fixes that problem; see PR 2953.
 625
 626 However, Ian wrote the following, regarding removing the line below,
 627 which explains why it is still enabled:  --djm
 628
 629 If you put a patch like that into BFD you need to check all the COFF
 630 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
 631 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
 632 problem in a different way.  There may very well be a reason that the
 633 code works as it does.
 634
 635 Hmmm.  The first obvious point is that bfd_perform_relocation should
 636 not have any tests that depend upon the flavour.  It's seem like
 637 entirely the wrong place for such a thing.  The second obvious point
 638 is that the current code ignores the reloc addend when producing
 639 relocateable output for COFF.  That's peculiar.  In fact, I really
 640 have no idea what the point of the line you want to remove is.
 641
 642 A typical COFF reloc subtracts the old value of the symbol and adds in
 643 the new value to the location in the object file (if it's a pc
 644 relative reloc it adds the difference between the symbol value and the
 645 location).  When relocating we need to preserve that property.
 646
 647 BFD handles this by setting the addend to the negative of the old
 648 value of the symbol.  Unfortunately it handles common symbols in a
 649 non-standard way (it doesn't subtract the old value) but that's a
 650 different story (we can't change it without losing backward
 651 compatibility with old object files) (coff-i386 does subtract the old
 652 value, to be compatible with existing coff-i386 targets, like SCO).
 653
 654 So everything works fine when not producing relocateable output.  When
 655 we are producing relocateable output, logically we should do exactly
 656 what we do when not producing relocateable output.  Therefore, your
 657 patch is correct.  In fact, it should probably always just set
 658 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
 659 add the value into the object file.  This won't hurt the COFF code,
 660 which doesn't use the addend; I'm not sure what it will do to other
 661 formats (the thing to check for would be whether any formats both use
 662 the addend and set partial_inplace).
 663
 664 When I wanted to make coff-i386 produce relocateable output, I ran
 665 into the problem that you are running into: I wanted to remove that
 666 line.  Rather than risk it, I made the coff-i386 relocs use a special
 667 function; it's coff_i386_reloc in coff-i386.c.  The function
 668 specifically adds the addend field into the object file, knowing that
 669 bfd_perform_relocation is not going to.  If you remove that line, then
 670 coff-i386.c will wind up adding the addend field in twice.  It's
 671 trivial to fix; it just needs to be done.
 672
 673 The problem with removing the line is just that it may break some
 674 working code.  With BFD it's hard to be sure of anything.  The right
 675 way to deal with this is simply to build and test at least all the
 676 supported COFF targets.  It should be straightforward if time and disk
 677 space consuming.  For each target:
 678     1) build the linker
 679     2) generate some executable, and link it using -r (I would
 680        probably use paranoia.o and link against newlib/libc.a, which
 681        for all the supported targets would be available in
 682        /usr/cygnus/progressive/H-host/target/lib/libc.a).
 683     3) make the change to reloc.c
 684     4) rebuild the linker
 685     5) repeat step 2
 686     6) if the resulting object files are the same, you have at least
 687        made it no worse
 688     7) if they are different you have to figure out which version is
 689        right
 690 */
 691               relocation -= reloc_entry->addend;
 692 #endif
 693               reloc_entry->addend = 0;
 694             }
 695           else
 696             {
 697               reloc_entry->addend = relocation;
 698             }
 699         }
 700     }
 701   else
 702     {
 703       reloc_entry->addend = 0;
 704     }
 705
 706   /* FIXME: This overflow checking is incomplete, because the value
 707      might have overflowed before we get here.  For a correct check we
 708      need to compute the value in a size larger than bitsize, but we
 709      can't reasonably do that for a reloc the same size as a host
 710      machine word.
 711      FIXME: We should also do overflow checking on the result after
 712      adding in the value contained in the object file.  */
 713   if (howto->complain_on_overflow != complain_overflow_dont)
 714     {
 715       bfd_vma check;
 716
 717       /* Get the value that will be used for the relocation, but
 718          starting at bit position zero.  */
 719       if (howto->rightshift > howto->bitpos)
 720         check = relocation >> (howto->rightshift - howto->bitpos);
 721       else
 722         check = relocation << (howto->bitpos - howto->rightshift);
 723       switch (howto->complain_on_overflow)
 724         {
 725         case complain_overflow_signed:
 726           {
 727             /* Assumes two's complement.  */
 728             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
 729             bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
 730
 731             /* The above right shift is incorrect for a signed value.
 732                Fix it up by forcing on the upper bits.  */
 733             if (howto->rightshift > howto->bitpos
 734                 && (bfd_signed_vma) relocation < 0)
 735               check |= ((bfd_vma) -1
 736                         &~ ((bfd_vma) -1
 737                             >> (howto->rightshift - howto->bitpos)));
 738             if ((bfd_signed_vma) check > reloc_signed_max
 739                 || (bfd_signed_vma) check < reloc_signed_min)
 740               flag = bfd_reloc_overflow;
 741           }
 742           break;
 743         case complain_overflow_unsigned:
 744           {
 745             /* Assumes two's complement.  This expression avoids
 746                overflow if howto->bitsize is the number of bits in
 747                bfd_vma.  */
 748             bfd_vma reloc_unsigned_max =
 749               (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
 750
 751             if ((bfd_vma) check > reloc_unsigned_max)
 752               flag = bfd_reloc_overflow;
 753           }
 754           break;
 755         case complain_overflow_bitfield:
 756           {
 757             /* Assumes two's complement.  This expression avoids
 758                overflow if howto->bitsize is the number of bits in
 759                bfd_vma.  */
 760             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
 761
 762             if (((bfd_vma) check &~ reloc_bits) != 0
 763                 && ((bfd_vma) check &~ reloc_bits) != (-1 &~ reloc_bits))
 764               {
 765                 /* The above right shift is incorrect for a signed
 766                    value.  See if turning on the upper bits fixes the
 767                    overflow.  */
 768                 if (howto->rightshift > howto->bitpos
 769                     && (bfd_signed_vma) relocation < 0)
 770                   {
 771                     check |= ((bfd_vma) -1
 772                               &~ ((bfd_vma) -1
 773                                   >> (howto->rightshift - howto->bitpos)));
 774                     if (((bfd_vma) check &~ reloc_bits) != (-1 &~ reloc_bits))
 775                       flag = bfd_reloc_overflow;
 776                   }
 777                 else
 778                   flag = bfd_reloc_overflow;
 779               }
 780           }
 781           break;
 782         default:
 783           abort ();
 784         }
 785     }
 786
 787   /*
 788     Either we are relocating all the way, or we don't want to apply
 789     the relocation to the reloc entry (probably because there isn't
 790     any room in the output format to describe addends to relocs)
 791     */
 792
 793   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
 794      (OSF version 1.3, compiler version 3.11).  It miscompiles the
 795      following program:
 796
 797      struct str
 798      {
 799        unsigned int i0;
 800      } s = { 0 };
 801
 802      int
 803      main ()
 804      {
 805        unsigned long x;
 806
 807        x = 0x100000000;
 808        x <<= (unsigned long) s.i0;
 809        if (x == 0)
 810          printf ("failed\n");
 811        else
 812          printf ("succeeded (%lx)\n", x);
 813      }
 814      */
 815
 816   relocation >>= (bfd_vma) howto->rightshift;
 817
 818   /* Shift everything up to where it's going to be used */
 819
 820   relocation <<= (bfd_vma) howto->bitpos;
 821
 822   /* Wait for the day when all have the mask in them */
 823
 824   /* What we do:
 825      i instruction to be left alone
 826      o offset within instruction
 827      r relocation offset to apply
 828      S src mask
 829      D dst mask
 830      N ~dst mask
 831      A part 1
 832      B part 2
 833      R result
 834
 835      Do this:
 836      i i i i i o o o o o        from bfd_get<size>
 837      and           S S S S S    to get the size offset we want
 838      +   r r r r r r r r r r  to get the final value to place
 839      and           D D D D D  to chop to right size
 840      -----------------------
 841      A A A A A
 842      And this:
 843      ...   i i i i i o o o o o  from bfd_get<size>
 844      and   N N N N N            get instruction
 845      -----------------------
 846      ...   B B B B B
 847
 848      And then:
 849      B B B B B
 850      or              A A A A A
 851      -----------------------
 852      R R R R R R R R R R        put into bfd_put<size>
 853      */
 854
 855 #define DOIT(x) \
 856   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
 857
 858    switch (howto->size)
 859      {
 860      case 0:
 861        {
 862          char x = bfd_get_8(abfd, (char *)data + addr);
 863          DOIT(x);
 864          bfd_put_8(abfd,x, (unsigned char *) data + addr);
 865        }
 866        break;
 867
 868      case 1:
 869        if (relocation)
 870          {
 871            short x = bfd_get_16(abfd, (bfd_byte *)data + addr);
 872            DOIT(x);
 873            bfd_put_16(abfd, x,   (unsigned char *)data + addr);
 874          }
 875        break;
 876      case 2:
 877        if (relocation)
 878          {
 879            long  x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 880            DOIT (x);
 881            bfd_put_32 (abfd, x, (bfd_byte *)data + addr);
 882          }
 883        break;
 884      case -2:
 885        {
 886          long  x = bfd_get_32(abfd, (bfd_byte *) data + addr);
 887          relocation = -relocation;
 888          DOIT(x);
 889          bfd_put_32(abfd,x,    (bfd_byte *)data + addr);
 890        }
 891        break;
 892
 893      case 3:
 894        /* Do nothing */
 895        break;
 896
 897      case 4:
 898 #ifdef BFD64
 899        if (relocation)
 900          {
 901            bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + addr);
 902            DOIT (x);
 903            bfd_put_64 (abfd, x, (bfd_byte *) data + addr);
 904          }
 905 #else
 906        abort ();
 907 #endif
 908        break;
 909      default:
 910        return bfd_reloc_other;
 911      }
 912
 913   return flag;
 914 }
 915
 916 /* This relocation routine is used by some of the backend linkers.
 917    They do not construct asymbol or arelent structures, so there is no
 918    reason for them to use bfd_perform_relocation.  Also,
 919    bfd_perform_relocation is so hacked up it is easier to write a new
 920    function than to try to deal with it.
 921
 922    This routine does a final relocation.  It should not be used when
 923    generating relocateable output.
 924
 925    FIXME: This routine ignores any special_function in the HOWTO,
 926    since the existing special_function values have been written for
 927    bfd_perform_relocation.
 928
 929    HOWTO is the reloc howto information.
 930    INPUT_BFD is the BFD which the reloc applies to.
 931    INPUT_SECTION is the section which the reloc applies to.
 932    CONTENTS is the contents of the section.
 933    ADDRESS is the address of the reloc within INPUT_SECTION.
 934    VALUE is the value of the symbol the reloc refers to.
 935    ADDEND is the addend of the reloc.  */
 936
 937 bfd_reloc_status_type
 938 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
 939                          value, addend)
 940      const reloc_howto_type *howto;
 941      bfd *input_bfd;
 942      asection *input_section;
 943      bfd_byte *contents;
 944      bfd_vma address;
 945      bfd_vma value;
 946      bfd_vma addend;
 947 {
 948   bfd_vma relocation;
 949
 950   /* Sanity check the address.  */
 951   if (address > input_section->_cooked_size)
 952     return bfd_reloc_outofrange;
 953
 954   /* This function assumes that we are dealing with a basic relocation
 955      against a symbol.  We want to compute the value of the symbol to
 956      relocate to.  This is just VALUE, the value of the symbol, plus
 957      ADDEND, any addend associated with the reloc.  */
 958   relocation = value + addend;
 959
 960   /* If the relocation is PC relative, we want to set RELOCATION to
 961      the distance between the symbol (currently in RELOCATION) and the
 962      location we are relocating.  Some targets (e.g., i386-aout)
 963      arrange for the contents of the section to be the negative of the
 964      offset of the location within the section; for such targets
 965      pcrel_offset is false.  Other targets (e.g., m88kbcs or ELF)
 966      simply leave the contents of the section as zero; for such
 967      targets pcrel_offset is true.  If pcrel_offset is false we do not
 968      need to subtract out the offset of the location within the
 969      section (which is just ADDRESS).  */
 970   if (howto->pc_relative)
 971     {
 972       relocation -= (input_section->output_section->vma
 973                      + input_section->output_offset);
 974       if (howto->pcrel_offset)
 975         relocation -= address;
 976     }
 977
 978   return _bfd_relocate_contents (howto, input_bfd, relocation,
 979                                  contents + address);
 980 }
 981
 982 /* Relocate a given location using a given value and howto.  */
 983
 984 bfd_reloc_status_type
 985 _bfd_relocate_contents (howto, input_bfd, relocation, location)
 986      const reloc_howto_type *howto;
 987      bfd *input_bfd;
 988      bfd_vma relocation;
 989      bfd_byte *location;
 990 {
 991   int size;
 992   bfd_vma x;
 993   boolean overflow;
 994
 995   /* If the size is negative, negate RELOCATION.  This isn't very
 996      general.  */
 997   if (howto->size < 0)
 998     relocation = - relocation;
 999
1000   /* Get the value we are going to relocate.  */
1001   size = bfd_get_reloc_size (howto);
1002   switch (size)
1003     {
1004     default:
1005     case 0:
1006       abort ();
1007     case 1:
1008       x = bfd_get_8 (input_bfd, location);
1009       break;
1010     case 2:
1011       x = bfd_get_16 (input_bfd, location);
1012       break;
1013     case 4:
1014       x = bfd_get_32 (input_bfd, location);
1015       break;
1016     case 8:
1017 #ifdef BFD64
1018       x = bfd_get_64 (input_bfd, location);
1019 #else
1020       abort ();
1021 #endif
1022       break;
1023     }
1024
1025   /* Check for overflow.  FIXME: We may drop bits during the addition
1026      which we don't check for.  We must either check at every single
1027      operation, which would be tedious, or we must do the computations
1028      in a type larger than bfd_vma, which would be inefficient.  */
1029   overflow = false;
1030   if (howto->complain_on_overflow != complain_overflow_dont)
1031     {
1032       bfd_vma check;
1033       bfd_signed_vma signed_check;
1034       bfd_vma add;
1035       bfd_signed_vma signed_add;
1036
1037       if (howto->rightshift == 0)
1038         {
1039           check = relocation;
1040           signed_check = (bfd_signed_vma) relocation;
1041         }
1042       else
1043         {
1044           /* Drop unwanted bits from the value we are relocating to.  */
1045           check = relocation >> howto->rightshift;
1046
1047           /* If this is a signed value, the rightshift just dropped
1048              leading 1 bits (assuming twos complement).  */
1049           if ((bfd_signed_vma) relocation >= 0)
1050             signed_check = check;
1051           else
1052             signed_check = (check
1053                             | ((bfd_vma) -1
1054                                &~ ((bfd_vma) -1 >> howto->rightshift)));
1055         }
1056
1057       /* Add in the value from the object file, shifted down so that
1058          it is a straight number.  */
1059       add = x & howto->src_mask;
1060       if ((add & (((~ howto->src_mask) >> 1) & howto->src_mask)) == 0)
1061         signed_add = add;
1062       else
1063         signed_add = add | ((bfd_vma) -1 &~ howto->src_mask);
1064       if (howto->bitpos == 0)
1065         {
1066           check += add;
1067           signed_check += signed_add;
1068         }
1069       else
1070         {
1071           check += add >> howto->bitpos;
1072           if (signed_add >= 0)
1073             signed_check += signed_add >> howto->bitpos;
1074           else
1075             signed_check += ((signed_add >> howto->bitpos)
1076                              | ((bfd_vma) -1
1077                                 &~ ((bfd_vma) -1 >> howto->bitpos)));
1078         }
1079
1080       switch (howto->complain_on_overflow)
1081         {
1082         case complain_overflow_signed:
1083           {
1084             /* Assumes two's complement.  */
1085             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1086             bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1087
1088             if (signed_check > reloc_signed_max
1089                 || signed_check < reloc_signed_min)
1090               overflow = true;
1091           }
1092           break;
1093         case complain_overflow_unsigned:
1094           {
1095             /* Assumes two's complement.  This expression avoids
1096                overflow if howto->bitsize is the number of bits in
1097                bfd_vma.  */
1098             bfd_vma reloc_unsigned_max =
1099               (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1100
1101             if (check > reloc_unsigned_max)
1102               overflow = true;
1103           }
1104           break;
1105         case complain_overflow_bitfield:
1106           {
1107             /* Assumes two's complement.  This expression avoids
1108                overflow if howto->bitsize is the number of bits in
1109                bfd_vma.  */
1110             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1111
1112             if ((check &~ reloc_bits) != 0
1113                 && (((bfd_vma) signed_check &~ reloc_bits)
1114                     != (-1 &~ reloc_bits)))
1115               overflow = true;
1116           }
1117           break;
1118         default:
1119           abort ();
1120         }
1121     }
1122
1123   /* Put RELOCATION in the right bits.  */
1124   relocation >>= (bfd_vma) howto->rightshift;
1125   relocation <<= (bfd_vma) howto->bitpos;
1126
1127   /* Add RELOCATION to the right bits of X.  */
1128   x = ((x &~ howto->dst_mask)
1129        | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1130
1131   /* Put the relocated value back in the object file.  */
1132   switch (size)
1133     {
1134     default:
1135     case 0:
1136       abort ();
1137     case 1:
1138       bfd_put_8 (input_bfd, x, location);
1139       break;
1140     case 2:
1141       bfd_put_16 (input_bfd, x, location);
1142       break;
1143     case 4:
1144       bfd_put_32 (input_bfd, x, location);
1145       break;
1146     case 8:
1147 #ifdef BFD64
1148       bfd_put_64 (input_bfd, x, location);
1149 #else
1150       abort ();
1151 #endif
1152       break;
1153     }
1154
1155   return overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1156 }
1157
1158 /*
1159 DOCDD
1160 INODE
1161         howto manager,  , typedef arelent, Relocations
1162
1163 SECTION
1164         The howto manager
1165
1166         When an application wants to create a relocation, but doesn't
1167         know what the target machine might call it, it can find out by
1168         using this bit of code.
1169
1170 */
1171
1172 /*
1173 TYPEDEF
1174         bfd_reloc_code_type
1175
1176 DESCRIPTION
1177         The insides of a reloc code.  The idea is that, eventually, there
1178         will be one enumerator for every type of relocation we ever do.
1179         Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1180         return a howto pointer.
1181
1182         This does mean that the application must determine the correct
1183         enumerator value; you can't get a howto pointer from a random set
1184         of attributes.
1185
1186 CODE_FRAGMENT
1187 .
1188 .typedef enum bfd_reloc_code_real
1189 .{
1190 .  {* Basic absolute relocations *}
1191 .  BFD_RELOC_64,
1192 .  BFD_RELOC_32,
1193 .  BFD_RELOC_16,
1194 .  BFD_RELOC_14,
1195 .  BFD_RELOC_8,
1196 .
1197 .  {* PC-relative relocations *}
1198 .  BFD_RELOC_64_PCREL,
1199 .  BFD_RELOC_32_PCREL,
1200 .  BFD_RELOC_24_PCREL,    {* used by i960 *}
1201 .  BFD_RELOC_16_PCREL,
1202 .  BFD_RELOC_8_PCREL,
1203 .
1204 .  {* Linkage-table relative *}
1205 .  BFD_RELOC_32_BASEREL,
1206 .  BFD_RELOC_16_BASEREL,
1207 .  BFD_RELOC_8_BASEREL,
1208 .
1209 .  {* The type of reloc used to build a contructor table - at the moment
1210 .     probably a 32 bit wide abs address, but the cpu can choose. *}
1211 .  BFD_RELOC_CTOR,
1212 .
1213 .  {* 8 bits wide, but used to form an address like 0xffnn *}
1214 .  BFD_RELOC_8_FFnn,
1215 .
1216 .  {* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit
1217 .     word displacement, e.g. for SPARC) *}
1218 .  BFD_RELOC_32_PCREL_S2,
1219 .  {* signed 16-bit pc-relative, shifted right 2 bits (e.g. for MIPS) *}
1220 .  BFD_RELOC_16_PCREL_S2,
1221 .  {* this is used on the Alpha *}
1222 .  BFD_RELOC_23_PCREL_S2,
1223 .
1224 .  {* High 22 bits of 32-bit value, placed into lower 22 bits of
1225 .     target word; simple reloc.  *}
1226 .  BFD_RELOC_HI22,
1227 .  {* Low 10 bits.  *}
1228 .  BFD_RELOC_LO10,
1229 .
1230 .  {* For systems that allocate a Global Pointer register, these are
1231 .     displacements off that register.  These relocation types are
1232 .     handled specially, because the value the register will have is
1233 .     decided relatively late.  *}
1234 .  BFD_RELOC_GPREL16,
1235 .  BFD_RELOC_GPREL32,
1236 .
1237 .  {* Reloc types used for i960/b.out.  *}
1238 .  BFD_RELOC_I960_CALLJ,
1239 .
1240 .  {* now for the sparc/elf codes *}
1241 .  BFD_RELOC_NONE,              {* actually used *}
1242 .  BFD_RELOC_SPARC_WDISP22,
1243 .  BFD_RELOC_SPARC22,
1244 .  BFD_RELOC_SPARC13,
1245 .  BFD_RELOC_SPARC_GOT10,
1246 .  BFD_RELOC_SPARC_GOT13,
1247 .  BFD_RELOC_SPARC_GOT22,
1248 .  BFD_RELOC_SPARC_PC10,
1249 .  BFD_RELOC_SPARC_PC22,
1250 .  BFD_RELOC_SPARC_WPLT30,
1251 .  BFD_RELOC_SPARC_COPY,
1252 .  BFD_RELOC_SPARC_GLOB_DAT,
1253 .  BFD_RELOC_SPARC_JMP_SLOT,
1254 .  BFD_RELOC_SPARC_RELATIVE,
1255 .  BFD_RELOC_SPARC_UA32,
1256 .
1257 .  {* these are a.out specific? *}
1258 .  BFD_RELOC_SPARC_BASE13,
1259 .  BFD_RELOC_SPARC_BASE22,
1260 .
1261 .  {* start-sanitize-v9 *}
1262 .  BFD_RELOC_SPARC_10,
1263 .  BFD_RELOC_SPARC_11,
1264 .#define  BFD_RELOC_SPARC_64 BFD_RELOC_64
1265 .  BFD_RELOC_SPARC_OLO10,
1266 .  BFD_RELOC_SPARC_HH22,
1267 .  BFD_RELOC_SPARC_HM10,
1268 .  BFD_RELOC_SPARC_LM22,
1269 .  BFD_RELOC_SPARC_PC_HH22,
1270 .  BFD_RELOC_SPARC_PC_HM10,
1271 .  BFD_RELOC_SPARC_PC_LM22,
1272 .  BFD_RELOC_SPARC_WDISP16,
1273 .  BFD_RELOC_SPARC_WDISP19,
1274 .  BFD_RELOC_SPARC_GLOB_JMP,
1275 .  BFD_RELOC_SPARC_LO7,
1276 .  {* end-sanitize-v9 *}
1277 .
1278 .  {* Alpha ECOFF relocations.  Some of these treat the symbol or "addend"
1279 .     in some special way.  *}
1280 .  {* For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1281 .     writing; when reading, it will be the absolute section symbol.  The
1282 .     addend is the displacement in bytes of the "lda" instruction from
1283 .     the "ldah" instruction (which is at the address of this reloc).  *}
1284 .  BFD_RELOC_ALPHA_GPDISP_HI16,
1285 .  {* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1286 .     with GPDISP_HI16 relocs.  The addend is ignored when writing the
1287 .     relocations out, and is filled in with the file's GP value on
1288 .     reading, for convenience.  *}
1289 .  BFD_RELOC_ALPHA_GPDISP_LO16,
1290 .
1291 .  {* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1292 .     the assembler turns it into a LDQ instruction to load the address of
1293 .     the symbol, and then fills in a register in the real instruction.
1294 .
1295 .     The LITERAL reloc, at the LDQ instruction, refers to the .lita
1296 .     section symbol.  The addend is ignored when writing, but is filled
1297 .     in with the file's GP value on reading, for convenience, as with the
1298 .     GPDISP_LO16 reloc.
1299 .
1300 .     The LITUSE reloc, on the instruction using the loaded address, gives
1301 .     information to the linker that it might be able to use to optimize
1302 .     away some literal section references.  The symbol is ignored (read
1303 .     as the absolute section symbol), and the "addend" indicates the type
1304 .     of instruction using the register:
1305 .              1 - "memory" fmt insn
1306 .              2 - byte-manipulation (byte offset reg)
1307 .              3 - jsr (target of branch)
1308 .
1309 .     The GNU linker currently doesn't do any of this optimizing.  *}
1310 .  BFD_RELOC_ALPHA_LITERAL,
1311 .  BFD_RELOC_ALPHA_LITUSE,
1312 .
1313 .  {* The HINT relocation indicates a value that should be filled into the
1314 .     "hint" field of a jmp/jsr/ret instruction, for possible branch-
1315 .     prediction logic which may be provided on some processors.  *}
1316 .  BFD_RELOC_ALPHA_HINT,
1317 .
1318 .  {* Bits 27..2 of the relocation address shifted right 2 bits;
1319 .     simple reloc otherwise.  *}
1320 .  BFD_RELOC_MIPS_JMP,
1321 .
1322 .  {* High 16 bits of 32-bit value; simple reloc.  *}
1323 .  BFD_RELOC_HI16,
1324 .  {* High 16 bits of 32-bit value but the low 16 bits will be sign
1325 .     extended and added to form the final result.  If the low 16
1326 .     bits form a negative number, we need to add one to the high value
1327 .     to compensate for the borrow when the low bits are added.  *}
1328 .  BFD_RELOC_HI16_S,
1329 .  {* Low 16 bits.  *}
1330 .  BFD_RELOC_LO16,
1331 .
1332 .  {* relocation relative to the global pointer.  *}
1333 .#define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16
1334 .
1335 .  {* Relocation against a MIPS literal section.  *}
1336 .  BFD_RELOC_MIPS_LITERAL,
1337 .
1338 .  {* MIPS ELF relocations.  *}
1339 .  BFD_RELOC_MIPS_GOT16,
1340 .  BFD_RELOC_MIPS_CALL16,
1341 .#define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32
1342 .
1343 .  {* These are, so far, specific to HPPA processors.  I'm not sure that some
1344 .     don't duplicate other reloc types, such as BFD_RELOC_32 and _32_PCREL.
1345 .     Also, many more were in the list I got that don't fit in well in the
1346 .     model BFD uses, so I've omitted them for now.  If we do make this reloc
1347 .     type get used for code that really does implement the funky reloc types,
1348 .     they'll have to be added to this list.  *}
1349 .  BFD_RELOC_HPPA_32,
1350 .  BFD_RELOC_HPPA_11,
1351 .  BFD_RELOC_HPPA_14,
1352 .  BFD_RELOC_HPPA_17,
1353 .
1354 .  BFD_RELOC_HPPA_L21,
1355 .  BFD_RELOC_HPPA_R11,
1356 .  BFD_RELOC_HPPA_R14,
1357 .  BFD_RELOC_HPPA_R17,
1358 .  BFD_RELOC_HPPA_LS21,
1359 .  BFD_RELOC_HPPA_RS11,
1360 .  BFD_RELOC_HPPA_RS14,
1361 .  BFD_RELOC_HPPA_RS17,
1362 .  BFD_RELOC_HPPA_LD21,
1363 .  BFD_RELOC_HPPA_RD11,
1364 .  BFD_RELOC_HPPA_RD14,
1365 .  BFD_RELOC_HPPA_RD17,
1366 .  BFD_RELOC_HPPA_LR21,
1367 .  BFD_RELOC_HPPA_RR14,
1368 .  BFD_RELOC_HPPA_RR17,
1369 .
1370 .  BFD_RELOC_HPPA_GOTOFF_11,
1371 .  BFD_RELOC_HPPA_GOTOFF_14,
1372 .  BFD_RELOC_HPPA_GOTOFF_L21,
1373 .  BFD_RELOC_HPPA_GOTOFF_R11,
1374 .  BFD_RELOC_HPPA_GOTOFF_R14,
1375 .  BFD_RELOC_HPPA_GOTOFF_LS21,
1376 .  BFD_RELOC_HPPA_GOTOFF_RS11,
1377 .  BFD_RELOC_HPPA_GOTOFF_RS14,
1378 .  BFD_RELOC_HPPA_GOTOFF_LD21,
1379 .  BFD_RELOC_HPPA_GOTOFF_RD11,
1380 .  BFD_RELOC_HPPA_GOTOFF_RD14,
1381 .  BFD_RELOC_HPPA_GOTOFF_LR21,
1382 .  BFD_RELOC_HPPA_GOTOFF_RR14,
1383 .
1384 .  BFD_RELOC_HPPA_DLT_32,
1385 .  BFD_RELOC_HPPA_DLT_11,
1386 .  BFD_RELOC_HPPA_DLT_14,
1387 .  BFD_RELOC_HPPA_DLT_L21,
1388 .  BFD_RELOC_HPPA_DLT_R11,
1389 .  BFD_RELOC_HPPA_DLT_R14,
1390 .
1391 .  BFD_RELOC_HPPA_ABS_CALL_11,
1392 .  BFD_RELOC_HPPA_ABS_CALL_14,
1393 .  BFD_RELOC_HPPA_ABS_CALL_17,
1394 .  BFD_RELOC_HPPA_ABS_CALL_L21,
1395 .  BFD_RELOC_HPPA_ABS_CALL_R11,
1396 .  BFD_RELOC_HPPA_ABS_CALL_R14,
1397 .  BFD_RELOC_HPPA_ABS_CALL_R17,
1398 .  BFD_RELOC_HPPA_ABS_CALL_LS21,
1399 .  BFD_RELOC_HPPA_ABS_CALL_RS11,
1400 .  BFD_RELOC_HPPA_ABS_CALL_RS14,
1401 .  BFD_RELOC_HPPA_ABS_CALL_RS17,
1402 .  BFD_RELOC_HPPA_ABS_CALL_LD21,
1403 .  BFD_RELOC_HPPA_ABS_CALL_RD11,
1404 .  BFD_RELOC_HPPA_ABS_CALL_RD14,
1405 .  BFD_RELOC_HPPA_ABS_CALL_RD17,
1406 .  BFD_RELOC_HPPA_ABS_CALL_LR21,
1407 .  BFD_RELOC_HPPA_ABS_CALL_RR14,
1408 .  BFD_RELOC_HPPA_ABS_CALL_RR17,
1409 .
1410 .  BFD_RELOC_HPPA_PCREL_CALL_11,
1411 .  BFD_RELOC_HPPA_PCREL_CALL_12,
1412 .  BFD_RELOC_HPPA_PCREL_CALL_14,
1413 .  BFD_RELOC_HPPA_PCREL_CALL_17,
1414 .  BFD_RELOC_HPPA_PCREL_CALL_L21,
1415 .  BFD_RELOC_HPPA_PCREL_CALL_R11,
1416 .  BFD_RELOC_HPPA_PCREL_CALL_R14,
1417 .  BFD_RELOC_HPPA_PCREL_CALL_R17,
1418 .  BFD_RELOC_HPPA_PCREL_CALL_LS21,
1419 .  BFD_RELOC_HPPA_PCREL_CALL_RS11,
1420 .  BFD_RELOC_HPPA_PCREL_CALL_RS14,
1421 .  BFD_RELOC_HPPA_PCREL_CALL_RS17,
1422 .  BFD_RELOC_HPPA_PCREL_CALL_LD21,
1423 .  BFD_RELOC_HPPA_PCREL_CALL_RD11,
1424 .  BFD_RELOC_HPPA_PCREL_CALL_RD14,
1425 .  BFD_RELOC_HPPA_PCREL_CALL_RD17,
1426 .  BFD_RELOC_HPPA_PCREL_CALL_LR21,
1427 .  BFD_RELOC_HPPA_PCREL_CALL_RR14,
1428 .  BFD_RELOC_HPPA_PCREL_CALL_RR17,
1429 .
1430 .  BFD_RELOC_HPPA_PLABEL_32,
1431 .  BFD_RELOC_HPPA_PLABEL_11,
1432 .  BFD_RELOC_HPPA_PLABEL_14,
1433 .  BFD_RELOC_HPPA_PLABEL_L21,
1434 .  BFD_RELOC_HPPA_PLABEL_R11,
1435 .  BFD_RELOC_HPPA_PLABEL_R14,
1436 .
1437 .  BFD_RELOC_HPPA_UNWIND_ENTRY,
1438 .  BFD_RELOC_HPPA_UNWIND_ENTRIES,
1439 .
1440 .  {* i386/elf relocations *}
1441 .  BFD_RELOC_386_GOT32,
1442 .  BFD_RELOC_386_PLT32,
1443 .  BFD_RELOC_386_COPY,
1444 .  BFD_RELOC_386_GLOB_DAT,
1445 .  BFD_RELOC_386_JUMP_SLOT,
1446 .  BFD_RELOC_386_RELATIVE,
1447 .  BFD_RELOC_386_GOTOFF,
1448 .  BFD_RELOC_386_GOTPC,
1449 .
1450 .  {* this must be the highest numeric value *}
1451 .  BFD_RELOC_UNUSED
1452 . } bfd_reloc_code_real_type;
1453 */
1454
1455
1456 /*
1457 FUNCTION
1458         bfd_reloc_type_lookup
1459
1460 SYNOPSIS
1461         const struct reloc_howto_struct *
1462         bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
1463
1464 DESCRIPTION
1465         Return a pointer to a howto structure which, when
1466         invoked, will perform the relocation @var{code} on data from the
1467         architecture noted.
1468
1469 */
1470
1471
1472 const struct reloc_howto_struct *
1473 DEFUN(bfd_reloc_type_lookup,(abfd, code),
1474       bfd *abfd AND
1475       bfd_reloc_code_real_type code)
1476 {
1477   return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
1478 }
1479
1480 static reloc_howto_type bfd_howto_32 =
1481  HOWTO(0, 00,2,32,false,0,complain_overflow_bitfield,0,"VRT32", false,0xffffffff,0xffffffff,true);
1482
1483
1484 /*
1485 INTERNAL_FUNCTION
1486         bfd_default_reloc_type_lookup
1487
1488 SYNOPSIS
1489         const struct reloc_howto_struct *bfd_default_reloc_type_lookup
1490         (bfd *abfd AND
1491          bfd_reloc_code_real_type  code);
1492
1493 DESCRIPTION
1494         Provides a default relocation lookup routine for any architecture.
1495
1496
1497 */
1498
1499 const struct reloc_howto_struct *
1500 DEFUN(bfd_default_reloc_type_lookup, (abfd, code),
1501       bfd *abfd AND
1502       bfd_reloc_code_real_type code)
1503 {
1504   switch (code)
1505     {
1506     case BFD_RELOC_CTOR:
1507       /* The type of reloc used in a ctor, which will be as wide as the
1508          address - so either a 64, 32, or 16 bitter.  */
1509       switch (bfd_get_arch_info (abfd)->bits_per_address) {
1510       case 64:
1511         BFD_FAIL();
1512       case 32:
1513         return &bfd_howto_32;
1514       case 16:
1515         BFD_FAIL();
1516       default:
1517         BFD_FAIL();
1518       }
1519     default:
1520       BFD_FAIL();
1521     }
1522   return (const struct reloc_howto_struct *)NULL;
1523 }
1524
1525
1526 /*
1527 INTERNAL_FUNCTION
1528         bfd_generic_relax_section
1529
1530 SYNOPSIS
1531         boolean bfd_generic_relax_section
1532          (bfd *abfd,
1533           asection *section,
1534           struct bfd_link_info *,
1535           asymbol **symbols);
1536
1537 DESCRIPTION
1538         Provides default handling for relaxing for back ends which
1539         don't do relaxing -- i.e., does nothing.
1540 */
1541
1542 /*ARGSUSED*/
1543 boolean
1544 bfd_generic_relax_section (abfd, section, link_info, symbols)
1545      bfd *abfd;
1546      asection *section;
1547      struct bfd_link_info *link_info;
1548      asymbol **symbols;
1549 {
1550   return false;
1551 }
1552
1553 /*
1554 INTERNAL_FUNCTION
1555         bfd_generic_get_relocated_section_contents
1556
1557 SYNOPSIS
1558         bfd_byte *
1559            bfd_generic_get_relocated_section_contents (bfd *abfd,
1560              struct bfd_link_info *link_info,
1561              struct bfd_link_order *link_order,
1562              bfd_byte *data,
1563              boolean relocateable,
1564              asymbol **symbols);
1565
1566 DESCRIPTION
1567         Provides default handling of relocation effort for back ends
1568         which can't be bothered to do it efficiently.
1569
1570 */
1571
1572 bfd_byte *
1573 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
1574                                             relocateable, symbols)
1575      bfd *abfd;
1576      struct bfd_link_info *link_info;
1577      struct bfd_link_order *link_order;
1578      bfd_byte *data;
1579      boolean relocateable;
1580      asymbol **symbols;
1581 {
1582   /* Get enough memory to hold the stuff */
1583   bfd *input_bfd = link_order->u.indirect.section->owner;
1584   asection *input_section = link_order->u.indirect.section;
1585
1586
1587
1588   size_t reloc_size = bfd_get_reloc_upper_bound(input_bfd, input_section);
1589   arelent **reloc_vector = (arelent **) alloca(reloc_size);
1590
1591   /* read in the section */
1592   bfd_get_section_contents(input_bfd,
1593                            input_section,
1594                            (PTR) data,
1595                            0,
1596                            input_section->_raw_size);
1597
1598 /* We're not relaxing the section, so just copy the size info */
1599   input_section->_cooked_size = input_section->_raw_size;
1600   input_section->reloc_done = true;
1601
1602
1603   if (bfd_canonicalize_reloc(input_bfd,
1604                              input_section,
1605                              reloc_vector,
1606                              symbols) )
1607   {
1608     arelent **parent;
1609     for (parent = reloc_vector;  * parent != (arelent *)NULL;
1610          parent++)
1611     {
1612       char *error_message = (char *) NULL;
1613       bfd_reloc_status_type r=
1614        bfd_perform_relocation(input_bfd,
1615                               *parent,
1616                               (PTR) data,
1617                               input_section,
1618                               relocateable ? abfd : (bfd *) NULL,
1619                               &error_message);
1620
1621       if (relocateable)
1622         {
1623           asection *os = input_section->output_section;
1624
1625           /* A partial link, so keep the relocs */
1626           os->orelocation[os->reloc_count] = *parent;
1627           os->reloc_count++;
1628         }
1629
1630       if (r != bfd_reloc_ok)
1631       {
1632         switch (r)
1633         {
1634         case bfd_reloc_undefined:
1635           if (! ((*link_info->callbacks->undefined_symbol)
1636                  (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
1637                   input_bfd, input_section, (*parent)->address)))
1638             return NULL;
1639           break;
1640         case bfd_reloc_dangerous:
1641           BFD_ASSERT (error_message != (char *) NULL);
1642           if (! ((*link_info->callbacks->reloc_dangerous)
1643                  (link_info, error_message, input_bfd, input_section,
1644                   (*parent)->address)))
1645             return NULL;
1646           break;
1647         case bfd_reloc_overflow:
1648           if (! ((*link_info->callbacks->reloc_overflow)
1649                  (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
1650                   (*parent)->howto->name, (*parent)->addend,
1651                   input_bfd, input_section, (*parent)->address)))
1652             return NULL;
1653           break;
1654         case bfd_reloc_outofrange:
1655         default:
1656           abort();
1657           break;
1658         }
1659
1660       }
1661     }
1662   }
1663
1664
1665   return data;
1666
1667
1668 }