reloc.c revision 130562
1/* BFD support for handling relocation entries. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 22 23/* 24SECTION 25 Relocations 26 27 BFD maintains relocations in much the same way it maintains 28 symbols: they are left alone until required, then read in 29 en-masse and translated into an internal form. A common 30 routine <<bfd_perform_relocation>> acts upon the 31 canonical form to do the fixup. 32 33 Relocations are maintained on a per section basis, 34 while symbols are maintained on a per BFD basis. 35 36 All that a back end has to do to fit the BFD interface is to create 37 a <<struct reloc_cache_entry>> for each relocation 38 in a particular section, and fill in the right bits of the structures. 39 40@menu 41@* typedef arelent:: 42@* howto manager:: 43@end menu 44 45*/ 46 47/* DO compile in the reloc_code name table from libbfd.h. */ 48#define _BFD_MAKE_TABLE_bfd_reloc_code_real 49 50#include "bfd.h" 51#include "sysdep.h" 52#include "bfdlink.h" 53#include "libbfd.h" 54/* 55DOCDD 56INODE 57 typedef arelent, howto manager, Relocations, Relocations 58 59SUBSECTION 60 typedef arelent 61 62 This is the structure of a relocation entry: 63 64CODE_FRAGMENT 65. 66.typedef enum bfd_reloc_status 67.{ 68. {* No errors detected. *} 69. bfd_reloc_ok, 70. 71. {* The relocation was performed, but there was an overflow. *} 72. bfd_reloc_overflow, 73. 74. {* The address to relocate was not within the section supplied. *} 75. bfd_reloc_outofrange, 76. 77. {* Used by special functions. *} 78. bfd_reloc_continue, 79. 80. {* Unsupported relocation size requested. *} 81. bfd_reloc_notsupported, 82. 83. {* Unused. *} 84. bfd_reloc_other, 85. 86. {* The symbol to relocate against was undefined. *} 87. bfd_reloc_undefined, 88. 89. {* The relocation was performed, but may not be ok - presently 90. generated only when linking i960 coff files with i960 b.out 91. symbols. If this type is returned, the error_message argument 92. to bfd_perform_relocation will be set. *} 93. bfd_reloc_dangerous 94. } 95. bfd_reloc_status_type; 96. 97. 98.typedef struct reloc_cache_entry 99.{ 100. {* A pointer into the canonical table of pointers. *} 101. struct bfd_symbol **sym_ptr_ptr; 102. 103. {* offset in section. *} 104. bfd_size_type address; 105. 106. {* addend for relocation value. *} 107. bfd_vma addend; 108. 109. {* Pointer to how to perform the required relocation. *} 110. reloc_howto_type *howto; 111. 112.} 113.arelent; 114. 115*/ 116 117/* 118DESCRIPTION 119 120 Here is a description of each of the fields within an <<arelent>>: 121 122 o <<sym_ptr_ptr>> 123 124 The symbol table pointer points to a pointer to the symbol 125 associated with the relocation request. It is the pointer 126 into the table returned by the back end's 127 <<canonicalize_symtab>> action. @xref{Symbols}. The symbol is 128 referenced through a pointer to a pointer so that tools like 129 the linker can fix up all the symbols of the same name by 130 modifying only one pointer. The relocation routine looks in 131 the symbol and uses the base of the section the symbol is 132 attached to and the value of the symbol as the initial 133 relocation offset. If the symbol pointer is zero, then the 134 section provided is looked up. 135 136 o <<address>> 137 138 The <<address>> field gives the offset in bytes from the base of 139 the section data which owns the relocation record to the first 140 byte of relocatable information. The actual data relocated 141 will be relative to this point; for example, a relocation 142 type which modifies the bottom two bytes of a four byte word 143 would not touch the first byte pointed to in a big endian 144 world. 145 146 o <<addend>> 147 148 The <<addend>> is a value provided by the back end to be added (!) 149 to the relocation offset. Its interpretation is dependent upon 150 the howto. For example, on the 68k the code: 151 152| char foo[]; 153| main() 154| { 155| return foo[0x12345678]; 156| } 157 158 Could be compiled into: 159 160| linkw fp,#-4 161| moveb @@#12345678,d0 162| extbl d0 163| unlk fp 164| rts 165 166 This could create a reloc pointing to <<foo>>, but leave the 167 offset in the data, something like: 168 169|RELOCATION RECORDS FOR [.text]: 170|offset type value 171|00000006 32 _foo 172| 173|00000000 4e56 fffc ; linkw fp,#-4 174|00000004 1039 1234 5678 ; moveb @@#12345678,d0 175|0000000a 49c0 ; extbl d0 176|0000000c 4e5e ; unlk fp 177|0000000e 4e75 ; rts 178 179 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| or.u r13,r0,hi16(_foo+0x12345678) 184| ld.b r2,r13,lo16(_foo+0x12345678) 185| jmp r1 186 187 This should create two relocs, both pointing to <<_foo>>, and with 188 0x12340000 in their addend field. The data would consist of: 189 190|RELOCATION RECORDS FOR [.text]: 191|offset type value 192|00000002 HVRT16 _foo+0x12340000 193|00000006 LVRT16 _foo+0x12340000 194| 195|00000000 5da05678 ; or.u r13,r0,0x5678 196|00000004 1c4d5678 ; ld.b r2,r13,0x5678 197|00000008 f400c001 ; jmp r1 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|RELOCATION RECORDS FOR [.text]: 222|offset type value 223|00000004 HI22 _foo+0x12345678 224|00000008 LO10 _foo+0x12345678 225| 226|00000000 9de3bf90 ; save %sp,-112,%sp 227|00000004 05000000 ; sethi %hi(_foo+0),%g2 228|00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0 229|0000000c 81c7e008 ; ret 230|00000010 81e80000 ; restore 231 232 o <<howto>> 233 234 The <<howto>> field can be imagined as a 235 relocation instruction. It is a pointer to a structure which 236 contains information on what to do with all of the other 237 information in the reloc record and data section. A back end 238 would normally have a relocation instruction set and turn 239 relocations into pointers to the correct structure on input - 240 but it would be possible to create each howto field on demand. 241 242*/ 243 244/* 245SUBSUBSECTION 246 <<enum complain_overflow>> 247 248 Indicates what sort of overflow checking should be done when 249 performing a relocation. 250 251CODE_FRAGMENT 252. 253.enum complain_overflow 254.{ 255. {* Do not complain on overflow. *} 256. complain_overflow_dont, 257. 258. {* Complain if the bitfield overflows, whether it is considered 259. as signed or unsigned. *} 260. complain_overflow_bitfield, 261. 262. {* Complain if the value overflows when considered as signed 263. number. *} 264. complain_overflow_signed, 265. 266. {* Complain if the value overflows when considered as an 267. unsigned number. *} 268. complain_overflow_unsigned 269.}; 270 271*/ 272 273/* 274SUBSUBSECTION 275 <<reloc_howto_type>> 276 277 The <<reloc_howto_type>> is a structure which contains all the 278 information that libbfd needs to know to tie up a back end's data. 279 280CODE_FRAGMENT 281.struct bfd_symbol; {* Forward declaration. *} 282. 283.struct reloc_howto_struct 284.{ 285. {* The type field has mainly a documentary use - the back end can 286. do what it wants with it, though normally the back end's 287. external idea of what a reloc number is stored 288. in this field. For example, a PC relative word relocation 289. in a coff environment has the type 023 - because that's 290. what the outside world calls a R_PCRWORD reloc. *} 291. unsigned int type; 292. 293. {* The value the final relocation is shifted right by. This drops 294. unwanted data from the relocation. *} 295. unsigned int rightshift; 296. 297. {* The size of the item to be relocated. This is *not* a 298. power-of-two measure. To get the number of bytes operated 299. on by a type of relocation, use bfd_get_reloc_size. *} 300. int size; 301. 302. {* The number of bits in the item to be relocated. This is used 303. when doing overflow checking. *} 304. unsigned int bitsize; 305. 306. {* Notes that the relocation is relative to the location in the 307. data section of the addend. The relocation function will 308. subtract from the relocation value the address of the location 309. being relocated. *} 310. bfd_boolean pc_relative; 311. 312. {* The bit position of the reloc value in the destination. 313. The relocated value is left shifted by this amount. *} 314. unsigned int bitpos; 315. 316. {* What type of overflow error should be checked for when 317. relocating. *} 318. enum complain_overflow complain_on_overflow; 319. 320. {* If this field is non null, then the supplied function is 321. called rather than the normal function. This allows really 322. strange relocation methods to be accommodated (e.g., i960 callj 323. instructions). *} 324. bfd_reloc_status_type (*special_function) 325. (bfd *, arelent *, struct bfd_symbol *, void *, asection *, 326. bfd *, char **); 327. 328. {* The textual name of the relocation type. *} 329. char *name; 330. 331. {* Some formats record a relocation addend in the section contents 332. rather than with the relocation. For ELF formats this is the 333. distinction between USE_REL and USE_RELA (though the code checks 334. for USE_REL == 1/0). The value of this field is TRUE if the 335. addend is recorded with the section contents; when performing a 336. partial link (ld -r) the section contents (the data) will be 337. modified. The value of this field is FALSE if addends are 338. recorded with the relocation (in arelent.addend); when performing 339. a partial link the relocation will be modified. 340. All relocations for all ELF USE_RELA targets should set this field 341. to FALSE (values of TRUE should be looked on with suspicion). 342. However, the converse is not true: not all relocations of all ELF 343. USE_REL targets set this field to TRUE. Why this is so is peculiar 344. to each particular target. For relocs that aren't used in partial 345. links (e.g. GOT stuff) it doesn't matter what this is set to. *} 346. bfd_boolean partial_inplace; 347. 348. {* src_mask selects the part of the instruction (or data) to be used 349. in the relocation sum. If the target relocations don't have an 350. addend in the reloc, eg. ELF USE_REL, src_mask will normally equal 351. dst_mask to extract the addend from the section contents. If 352. relocations do have an addend in the reloc, eg. ELF USE_RELA, this 353. field should be zero. Non-zero values for ELF USE_RELA targets are 354. bogus as in those cases the value in the dst_mask part of the 355. section contents should be treated as garbage. *} 356. bfd_vma src_mask; 357. 358. {* dst_mask selects which parts of the instruction (or data) are 359. replaced with a relocated value. *} 360. bfd_vma dst_mask; 361. 362. {* When some formats create PC relative instructions, they leave 363. the value of the pc of the place being relocated in the offset 364. slot of the instruction, so that a PC relative relocation can 365. be made just by adding in an ordinary offset (e.g., sun3 a.out). 366. Some formats leave the displacement part of an instruction 367. empty (e.g., m88k bcs); this flag signals the fact. *} 368. bfd_boolean pcrel_offset; 369.}; 370. 371*/ 372 373/* 374FUNCTION 375 The HOWTO Macro 376 377DESCRIPTION 378 The HOWTO define is horrible and will go away. 379 380.#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ 381. { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC } 382 383DESCRIPTION 384 And will be replaced with the totally magic way. But for the 385 moment, we are compatible, so do it this way. 386 387.#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \ 388. HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \ 389. NAME, FALSE, 0, 0, IN) 390. 391 392DESCRIPTION 393 This is used to fill in an empty howto entry in an array. 394 395.#define EMPTY_HOWTO(C) \ 396. HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \ 397. NULL, FALSE, 0, 0, FALSE) 398. 399 400DESCRIPTION 401 Helper routine to turn a symbol into a relocation value. 402 403.#define HOWTO_PREPARE(relocation, symbol) \ 404. { \ 405. if (symbol != NULL) \ 406. { \ 407. if (bfd_is_com_section (symbol->section)) \ 408. { \ 409. relocation = 0; \ 410. } \ 411. else \ 412. { \ 413. relocation = symbol->value; \ 414. } \ 415. } \ 416. } 417. 418*/ 419 420/* 421FUNCTION 422 bfd_get_reloc_size 423 424SYNOPSIS 425 unsigned int bfd_get_reloc_size (reloc_howto_type *); 426 427DESCRIPTION 428 For a reloc_howto_type that operates on a fixed number of bytes, 429 this returns the number of bytes operated on. 430 */ 431 432unsigned int 433bfd_get_reloc_size (reloc_howto_type *howto) 434{ 435 switch (howto->size) 436 { 437 case 0: return 1; 438 case 1: return 2; 439 case 2: return 4; 440 case 3: return 0; 441 case 4: return 8; 442 case 8: return 16; 443 case -2: return 4; 444 default: abort (); 445 } 446} 447 448/* 449TYPEDEF 450 arelent_chain 451 452DESCRIPTION 453 454 How relocs are tied together in an <<asection>>: 455 456.typedef struct relent_chain 457.{ 458. arelent relent; 459. struct relent_chain *next; 460.} 461.arelent_chain; 462. 463*/ 464 465/* N_ONES produces N one bits, without overflowing machine arithmetic. */ 466#define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1) 467 468/* 469FUNCTION 470 bfd_check_overflow 471 472SYNOPSIS 473 bfd_reloc_status_type bfd_check_overflow 474 (enum complain_overflow how, 475 unsigned int bitsize, 476 unsigned int rightshift, 477 unsigned int addrsize, 478 bfd_vma relocation); 479 480DESCRIPTION 481 Perform overflow checking on @var{relocation} which has 482 @var{bitsize} significant bits and will be shifted right by 483 @var{rightshift} bits, on a machine with addresses containing 484 @var{addrsize} significant bits. The result is either of 485 @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}. 486 487*/ 488 489bfd_reloc_status_type 490bfd_check_overflow (enum complain_overflow how, 491 unsigned int bitsize, 492 unsigned int rightshift, 493 unsigned int addrsize, 494 bfd_vma relocation) 495{ 496 bfd_vma fieldmask, addrmask, signmask, ss, a; 497 bfd_reloc_status_type flag = bfd_reloc_ok; 498 499 a = relocation; 500 501 /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not, 502 we'll be permissive: extra bits in the field mask will 503 automatically extend the address mask for purposes of the 504 overflow check. */ 505 fieldmask = N_ONES (bitsize); 506 addrmask = N_ONES (addrsize) | fieldmask; 507 508 switch (how) 509 { 510 case complain_overflow_dont: 511 break; 512 513 case complain_overflow_signed: 514 /* If any sign bits are set, all sign bits must be set. That 515 is, A must be a valid negative address after shifting. */ 516 a = (a & addrmask) >> rightshift; 517 signmask = ~ (fieldmask >> 1); 518 ss = a & signmask; 519 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask)) 520 flag = bfd_reloc_overflow; 521 break; 522 523 case complain_overflow_unsigned: 524 /* We have an overflow if the address does not fit in the field. */ 525 a = (a & addrmask) >> rightshift; 526 if ((a & ~ fieldmask) != 0) 527 flag = bfd_reloc_overflow; 528 break; 529 530 case complain_overflow_bitfield: 531 /* Bitfields are sometimes signed, sometimes unsigned. We 532 explicitly allow an address wrap too, which means a bitfield 533 of n bits is allowed to store -2**n to 2**n-1. Thus overflow 534 if the value has some, but not all, bits set outside the 535 field. */ 536 a >>= rightshift; 537 ss = a & ~ fieldmask; 538 if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & ~ fieldmask)) 539 flag = bfd_reloc_overflow; 540 break; 541 542 default: 543 abort (); 544 } 545 546 return flag; 547} 548 549/* 550FUNCTION 551 bfd_perform_relocation 552 553SYNOPSIS 554 bfd_reloc_status_type bfd_perform_relocation 555 (bfd *abfd, 556 arelent *reloc_entry, 557 void *data, 558 asection *input_section, 559 bfd *output_bfd, 560 char **error_message); 561 562DESCRIPTION 563 If @var{output_bfd} is supplied to this function, the 564 generated image will be relocatable; the relocations are 565 copied to the output file after they have been changed to 566 reflect the new state of the world. There are two ways of 567 reflecting the results of partial linkage in an output file: 568 by modifying the output data in place, and by modifying the 569 relocation record. Some native formats (e.g., basic a.out and 570 basic coff) have no way of specifying an addend in the 571 relocation type, so the addend has to go in the output data. 572 This is no big deal since in these formats the output data 573 slot will always be big enough for the addend. Complex reloc 574 types with addends were invented to solve just this problem. 575 The @var{error_message} argument is set to an error message if 576 this return @code{bfd_reloc_dangerous}. 577 578*/ 579 580bfd_reloc_status_type 581bfd_perform_relocation (bfd *abfd, 582 arelent *reloc_entry, 583 void *data, 584 asection *input_section, 585 bfd *output_bfd, 586 char **error_message) 587{ 588 bfd_vma relocation; 589 bfd_reloc_status_type flag = bfd_reloc_ok; 590 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd); 591 bfd_vma output_base = 0; 592 reloc_howto_type *howto = reloc_entry->howto; 593 asection *reloc_target_output_section; 594 asymbol *symbol; 595 596 symbol = *(reloc_entry->sym_ptr_ptr); 597 if (bfd_is_abs_section (symbol->section) 598 && output_bfd != NULL) 599 { 600 reloc_entry->address += input_section->output_offset; 601 return bfd_reloc_ok; 602 } 603 604 /* If we are not producing relocatable output, return an error if 605 the symbol is not defined. An undefined weak symbol is 606 considered to have a value of zero (SVR4 ABI, p. 4-27). */ 607 if (bfd_is_und_section (symbol->section) 608 && (symbol->flags & BSF_WEAK) == 0 609 && output_bfd == NULL) 610 flag = bfd_reloc_undefined; 611 612 /* If there is a function supplied to handle this relocation type, 613 call it. It'll return `bfd_reloc_continue' if further processing 614 can be done. */ 615 if (howto->special_function) 616 { 617 bfd_reloc_status_type cont; 618 cont = howto->special_function (abfd, reloc_entry, symbol, data, 619 input_section, output_bfd, 620 error_message); 621 if (cont != bfd_reloc_continue) 622 return cont; 623 } 624 625 /* Is the address of the relocation really within the section? */ 626 if (reloc_entry->address > (input_section->_cooked_size 627 / bfd_octets_per_byte (abfd))) 628 return bfd_reloc_outofrange; 629 630 /* Work out which section the relocation is targeted at and the 631 initial relocation command value. */ 632 633 /* Get symbol value. (Common symbols are special.) */ 634 if (bfd_is_com_section (symbol->section)) 635 relocation = 0; 636 else 637 relocation = symbol->value; 638 639 reloc_target_output_section = symbol->section->output_section; 640 641 /* Convert input-section-relative symbol value to absolute. */ 642 if ((output_bfd && ! howto->partial_inplace) 643 || reloc_target_output_section == NULL) 644 output_base = 0; 645 else 646 output_base = reloc_target_output_section->vma; 647 648 relocation += output_base + symbol->section->output_offset; 649 650 /* Add in supplied addend. */ 651 relocation += reloc_entry->addend; 652 653 /* Here the variable relocation holds the final address of the 654 symbol we are relocating against, plus any addend. */ 655 656 if (howto->pc_relative) 657 { 658 /* This is a PC relative relocation. We want to set RELOCATION 659 to the distance between the address of the symbol and the 660 location. RELOCATION is already the address of the symbol. 661 662 We start by subtracting the address of the section containing 663 the location. 664 665 If pcrel_offset is set, we must further subtract the position 666 of the location within the section. Some targets arrange for 667 the addend to be the negative of the position of the location 668 within the section; for example, i386-aout does this. For 669 i386-aout, pcrel_offset is FALSE. Some other targets do not 670 include the position of the location; for example, m88kbcs, 671 or ELF. For those targets, pcrel_offset is TRUE. 672 673 If we are producing relocatable output, then we must ensure 674 that this reloc will be correctly computed when the final 675 relocation is done. If pcrel_offset is FALSE we want to wind 676 up with the negative of the location within the section, 677 which means we must adjust the existing addend by the change 678 in the location within the section. If pcrel_offset is TRUE 679 we do not want to adjust the existing addend at all. 680 681 FIXME: This seems logical to me, but for the case of 682 producing relocatable output it is not what the code 683 actually does. I don't want to change it, because it seems 684 far too likely that something will break. */ 685 686 relocation -= 687 input_section->output_section->vma + input_section->output_offset; 688 689 if (howto->pcrel_offset) 690 relocation -= reloc_entry->address; 691 } 692 693 if (output_bfd != NULL) 694 { 695 if (! howto->partial_inplace) 696 { 697 /* This is a partial relocation, and we want to apply the relocation 698 to the reloc entry rather than the raw data. Modify the reloc 699 inplace to reflect what we now know. */ 700 reloc_entry->addend = relocation; 701 reloc_entry->address += input_section->output_offset; 702 return flag; 703 } 704 else 705 { 706 /* This is a partial relocation, but inplace, so modify the 707 reloc record a bit. 708 709 If we've relocated with a symbol with a section, change 710 into a ref to the section belonging to the symbol. */ 711 712 reloc_entry->address += input_section->output_offset; 713 714 /* WTF?? */ 715 if (abfd->xvec->flavour == bfd_target_coff_flavour 716 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0 717 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0) 718 { 719#if 1 720 /* For m68k-coff, the addend was being subtracted twice during 721 relocation with -r. Removing the line below this comment 722 fixes that problem; see PR 2953. 723 724However, Ian wrote the following, regarding removing the line below, 725which explains why it is still enabled: --djm 726 727If you put a patch like that into BFD you need to check all the COFF 728linkers. I am fairly certain that patch will break coff-i386 (e.g., 729SCO); see coff_i386_reloc in coff-i386.c where I worked around the 730problem in a different way. There may very well be a reason that the 731code works as it does. 732 733Hmmm. The first obvious point is that bfd_perform_relocation should 734not have any tests that depend upon the flavour. It's seem like 735entirely the wrong place for such a thing. The second obvious point 736is that the current code ignores the reloc addend when producing 737relocatable output for COFF. That's peculiar. In fact, I really 738have no idea what the point of the line you want to remove is. 739 740A typical COFF reloc subtracts the old value of the symbol and adds in 741the new value to the location in the object file (if it's a pc 742relative reloc it adds the difference between the symbol value and the 743location). When relocating we need to preserve that property. 744 745BFD handles this by setting the addend to the negative of the old 746value of the symbol. Unfortunately it handles common symbols in a 747non-standard way (it doesn't subtract the old value) but that's a 748different story (we can't change it without losing backward 749compatibility with old object files) (coff-i386 does subtract the old 750value, to be compatible with existing coff-i386 targets, like SCO). 751 752So everything works fine when not producing relocatable output. When 753we are producing relocatable output, logically we should do exactly 754what we do when not producing relocatable output. Therefore, your 755patch is correct. In fact, it should probably always just set 756reloc_entry->addend to 0 for all cases, since it is, in fact, going to 757add the value into the object file. This won't hurt the COFF code, 758which doesn't use the addend; I'm not sure what it will do to other 759formats (the thing to check for would be whether any formats both use 760the addend and set partial_inplace). 761 762When I wanted to make coff-i386 produce relocatable output, I ran 763into the problem that you are running into: I wanted to remove that 764line. Rather than risk it, I made the coff-i386 relocs use a special 765function; it's coff_i386_reloc in coff-i386.c. The function 766specifically adds the addend field into the object file, knowing that 767bfd_perform_relocation is not going to. If you remove that line, then 768coff-i386.c will wind up adding the addend field in twice. It's 769trivial to fix; it just needs to be done. 770 771The problem with removing the line is just that it may break some 772working code. With BFD it's hard to be sure of anything. The right 773way to deal with this is simply to build and test at least all the 774supported COFF targets. It should be straightforward if time and disk 775space consuming. For each target: 776 1) build the linker 777 2) generate some executable, and link it using -r (I would 778 probably use paranoia.o and link against newlib/libc.a, which 779 for all the supported targets would be available in 780 /usr/cygnus/progressive/H-host/target/lib/libc.a). 781 3) make the change to reloc.c 782 4) rebuild the linker 783 5) repeat step 2 784 6) if the resulting object files are the same, you have at least 785 made it no worse 786 7) if they are different you have to figure out which version is 787 right 788*/ 789 relocation -= reloc_entry->addend; 790#endif 791 reloc_entry->addend = 0; 792 } 793 else 794 { 795 reloc_entry->addend = relocation; 796 } 797 } 798 } 799 else 800 { 801 reloc_entry->addend = 0; 802 } 803 804 /* FIXME: This overflow checking is incomplete, because the value 805 might have overflowed before we get here. For a correct check we 806 need to compute the value in a size larger than bitsize, but we 807 can't reasonably do that for a reloc the same size as a host 808 machine word. 809 FIXME: We should also do overflow checking on the result after 810 adding in the value contained in the object file. */ 811 if (howto->complain_on_overflow != complain_overflow_dont 812 && flag == bfd_reloc_ok) 813 flag = bfd_check_overflow (howto->complain_on_overflow, 814 howto->bitsize, 815 howto->rightshift, 816 bfd_arch_bits_per_address (abfd), 817 relocation); 818 819 /* Either we are relocating all the way, or we don't want to apply 820 the relocation to the reloc entry (probably because there isn't 821 any room in the output format to describe addends to relocs). */ 822 823 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler 824 (OSF version 1.3, compiler version 3.11). It miscompiles the 825 following program: 826 827 struct str 828 { 829 unsigned int i0; 830 } s = { 0 }; 831 832 int 833 main () 834 { 835 unsigned long x; 836 837 x = 0x100000000; 838 x <<= (unsigned long) s.i0; 839 if (x == 0) 840 printf ("failed\n"); 841 else 842 printf ("succeeded (%lx)\n", x); 843 } 844 */ 845 846 relocation >>= (bfd_vma) howto->rightshift; 847 848 /* Shift everything up to where it's going to be used. */ 849 relocation <<= (bfd_vma) howto->bitpos; 850 851 /* Wait for the day when all have the mask in them. */ 852 853 /* What we do: 854 i instruction to be left alone 855 o offset within instruction 856 r relocation offset to apply 857 S src mask 858 D dst mask 859 N ~dst mask 860 A part 1 861 B part 2 862 R result 863 864 Do this: 865 (( i i i i i o o o o o from bfd_get<size> 866 and S S S S S) to get the size offset we want 867 + r r r r r r r r r r) to get the final value to place 868 and D D D D D to chop to right size 869 ----------------------- 870 = A A A A A 871 And this: 872 ( i i i i i o o o o o from bfd_get<size> 873 and N N N N N ) get instruction 874 ----------------------- 875 = B B B B B 876 877 And then: 878 ( B B B B B 879 or A A A A A) 880 ----------------------- 881 = R R R R R R R R R R put into bfd_put<size> 882 */ 883 884#define DOIT(x) \ 885 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask)) 886 887 switch (howto->size) 888 { 889 case 0: 890 { 891 char x = bfd_get_8 (abfd, (char *) data + octets); 892 DOIT (x); 893 bfd_put_8 (abfd, x, (unsigned char *) data + octets); 894 } 895 break; 896 897 case 1: 898 { 899 short x = bfd_get_16 (abfd, (bfd_byte *) data + octets); 900 DOIT (x); 901 bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets); 902 } 903 break; 904 case 2: 905 { 906 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets); 907 DOIT (x); 908 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 909 } 910 break; 911 case -2: 912 { 913 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets); 914 relocation = -relocation; 915 DOIT (x); 916 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 917 } 918 break; 919 920 case -1: 921 { 922 long x = bfd_get_16 (abfd, (bfd_byte *) data + octets); 923 relocation = -relocation; 924 DOIT (x); 925 bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 926 } 927 break; 928 929 case 3: 930 /* Do nothing */ 931 break; 932 933 case 4: 934#ifdef BFD64 935 { 936 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets); 937 DOIT (x); 938 bfd_put_64 (abfd, x, (bfd_byte *) data + octets); 939 } 940#else 941 abort (); 942#endif 943 break; 944 default: 945 return bfd_reloc_other; 946 } 947 948 return flag; 949} 950 951/* 952FUNCTION 953 bfd_install_relocation 954 955SYNOPSIS 956 bfd_reloc_status_type bfd_install_relocation 957 (bfd *abfd, 958 arelent *reloc_entry, 959 void *data, bfd_vma data_start, 960 asection *input_section, 961 char **error_message); 962 963DESCRIPTION 964 This looks remarkably like <<bfd_perform_relocation>>, except it 965 does not expect that the section contents have been filled in. 966 I.e., it's suitable for use when creating, rather than applying 967 a relocation. 968 969 For now, this function should be considered reserved for the 970 assembler. 971*/ 972 973bfd_reloc_status_type 974bfd_install_relocation (bfd *abfd, 975 arelent *reloc_entry, 976 void *data_start, 977 bfd_vma data_start_offset, 978 asection *input_section, 979 char **error_message) 980{ 981 bfd_vma relocation; 982 bfd_reloc_status_type flag = bfd_reloc_ok; 983 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd); 984 bfd_vma output_base = 0; 985 reloc_howto_type *howto = reloc_entry->howto; 986 asection *reloc_target_output_section; 987 asymbol *symbol; 988 bfd_byte *data; 989 990 symbol = *(reloc_entry->sym_ptr_ptr); 991 if (bfd_is_abs_section (symbol->section)) 992 { 993 reloc_entry->address += input_section->output_offset; 994 return bfd_reloc_ok; 995 } 996 997 /* If there is a function supplied to handle this relocation type, 998 call it. It'll return `bfd_reloc_continue' if further processing 999 can be done. */ 1000 if (howto->special_function) 1001 { 1002 bfd_reloc_status_type cont; 1003 1004 /* XXX - The special_function calls haven't been fixed up to deal 1005 with creating new relocations and section contents. */ 1006 cont = howto->special_function (abfd, reloc_entry, symbol, 1007 /* XXX - Non-portable! */ 1008 ((bfd_byte *) data_start 1009 - data_start_offset), 1010 input_section, abfd, error_message); 1011 if (cont != bfd_reloc_continue) 1012 return cont; 1013 } 1014 1015 /* Is the address of the relocation really within the section? */ 1016 if (reloc_entry->address > (input_section->_cooked_size 1017 / bfd_octets_per_byte (abfd))) 1018 return bfd_reloc_outofrange; 1019 1020 /* Work out which section the relocation is targeted at and the 1021 initial relocation command value. */ 1022 1023 /* Get symbol value. (Common symbols are special.) */ 1024 if (bfd_is_com_section (symbol->section)) 1025 relocation = 0; 1026 else 1027 relocation = symbol->value; 1028 1029 reloc_target_output_section = symbol->section->output_section; 1030 1031 /* Convert input-section-relative symbol value to absolute. */ 1032 if (! howto->partial_inplace) 1033 output_base = 0; 1034 else 1035 output_base = reloc_target_output_section->vma; 1036 1037 relocation += output_base + symbol->section->output_offset; 1038 1039 /* Add in supplied addend. */ 1040 relocation += reloc_entry->addend; 1041 1042 /* Here the variable relocation holds the final address of the 1043 symbol we are relocating against, plus any addend. */ 1044 1045 if (howto->pc_relative) 1046 { 1047 /* This is a PC relative relocation. We want to set RELOCATION 1048 to the distance between the address of the symbol and the 1049 location. RELOCATION is already the address of the symbol. 1050 1051 We start by subtracting the address of the section containing 1052 the location. 1053 1054 If pcrel_offset is set, we must further subtract the position 1055 of the location within the section. Some targets arrange for 1056 the addend to be the negative of the position of the location 1057 within the section; for example, i386-aout does this. For 1058 i386-aout, pcrel_offset is FALSE. Some other targets do not 1059 include the position of the location; for example, m88kbcs, 1060 or ELF. For those targets, pcrel_offset is TRUE. 1061 1062 If we are producing relocatable output, then we must ensure 1063 that this reloc will be correctly computed when the final 1064 relocation is done. If pcrel_offset is FALSE we want to wind 1065 up with the negative of the location within the section, 1066 which means we must adjust the existing addend by the change 1067 in the location within the section. If pcrel_offset is TRUE 1068 we do not want to adjust the existing addend at all. 1069 1070 FIXME: This seems logical to me, but for the case of 1071 producing relocatable output it is not what the code 1072 actually does. I don't want to change it, because it seems 1073 far too likely that something will break. */ 1074 1075 relocation -= 1076 input_section->output_section->vma + input_section->output_offset; 1077 1078 if (howto->pcrel_offset && howto->partial_inplace) 1079 relocation -= reloc_entry->address; 1080 } 1081 1082 if (! howto->partial_inplace) 1083 { 1084 /* This is a partial relocation, and we want to apply the relocation 1085 to the reloc entry rather than the raw data. Modify the reloc 1086 inplace to reflect what we now know. */ 1087 reloc_entry->addend = relocation; 1088 reloc_entry->address += input_section->output_offset; 1089 return flag; 1090 } 1091 else 1092 { 1093 /* This is a partial relocation, but inplace, so modify the 1094 reloc record a bit. 1095 1096 If we've relocated with a symbol with a section, change 1097 into a ref to the section belonging to the symbol. */ 1098 reloc_entry->address += input_section->output_offset; 1099 1100 /* WTF?? */ 1101 if (abfd->xvec->flavour == bfd_target_coff_flavour 1102 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0 1103 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0) 1104 { 1105#if 1 1106/* For m68k-coff, the addend was being subtracted twice during 1107 relocation with -r. Removing the line below this comment 1108 fixes that problem; see PR 2953. 1109 1110However, Ian wrote the following, regarding removing the line below, 1111which explains why it is still enabled: --djm 1112 1113If you put a patch like that into BFD you need to check all the COFF 1114linkers. I am fairly certain that patch will break coff-i386 (e.g., 1115SCO); see coff_i386_reloc in coff-i386.c where I worked around the 1116problem in a different way. There may very well be a reason that the 1117code works as it does. 1118 1119Hmmm. The first obvious point is that bfd_install_relocation should 1120not have any tests that depend upon the flavour. It's seem like 1121entirely the wrong place for such a thing. The second obvious point 1122is that the current code ignores the reloc addend when producing 1123relocatable output for COFF. That's peculiar. In fact, I really 1124have no idea what the point of the line you want to remove is. 1125 1126A typical COFF reloc subtracts the old value of the symbol and adds in 1127the new value to the location in the object file (if it's a pc 1128relative reloc it adds the difference between the symbol value and the 1129location). When relocating we need to preserve that property. 1130 1131BFD handles this by setting the addend to the negative of the old 1132value of the symbol. Unfortunately it handles common symbols in a 1133non-standard way (it doesn't subtract the old value) but that's a 1134different story (we can't change it without losing backward 1135compatibility with old object files) (coff-i386 does subtract the old 1136value, to be compatible with existing coff-i386 targets, like SCO). 1137 1138So everything works fine when not producing relocatable output. When 1139we are producing relocatable output, logically we should do exactly 1140what we do when not producing relocatable output. Therefore, your 1141patch is correct. In fact, it should probably always just set 1142reloc_entry->addend to 0 for all cases, since it is, in fact, going to 1143add the value into the object file. This won't hurt the COFF code, 1144which doesn't use the addend; I'm not sure what it will do to other 1145formats (the thing to check for would be whether any formats both use 1146the addend and set partial_inplace). 1147 1148When I wanted to make coff-i386 produce relocatable output, I ran 1149into the problem that you are running into: I wanted to remove that 1150line. Rather than risk it, I made the coff-i386 relocs use a special 1151function; it's coff_i386_reloc in coff-i386.c. The function 1152specifically adds the addend field into the object file, knowing that 1153bfd_install_relocation is not going to. If you remove that line, then 1154coff-i386.c will wind up adding the addend field in twice. It's 1155trivial to fix; it just needs to be done. 1156 1157The problem with removing the line is just that it may break some 1158working code. With BFD it's hard to be sure of anything. The right 1159way to deal with this is simply to build and test at least all the 1160supported COFF targets. It should be straightforward if time and disk 1161space consuming. For each target: 1162 1) build the linker 1163 2) generate some executable, and link it using -r (I would 1164 probably use paranoia.o and link against newlib/libc.a, which 1165 for all the supported targets would be available in 1166 /usr/cygnus/progressive/H-host/target/lib/libc.a). 1167 3) make the change to reloc.c 1168 4) rebuild the linker 1169 5) repeat step 2 1170 6) if the resulting object files are the same, you have at least 1171 made it no worse 1172 7) if they are different you have to figure out which version is 1173 right. */ 1174 relocation -= reloc_entry->addend; 1175#endif 1176 reloc_entry->addend = 0; 1177 } 1178 else 1179 { 1180 reloc_entry->addend = relocation; 1181 } 1182 } 1183 1184 /* FIXME: This overflow checking is incomplete, because the value 1185 might have overflowed before we get here. For a correct check we 1186 need to compute the value in a size larger than bitsize, but we 1187 can't reasonably do that for a reloc the same size as a host 1188 machine word. 1189 FIXME: We should also do overflow checking on the result after 1190 adding in the value contained in the object file. */ 1191 if (howto->complain_on_overflow != complain_overflow_dont) 1192 flag = bfd_check_overflow (howto->complain_on_overflow, 1193 howto->bitsize, 1194 howto->rightshift, 1195 bfd_arch_bits_per_address (abfd), 1196 relocation); 1197 1198 /* Either we are relocating all the way, or we don't want to apply 1199 the relocation to the reloc entry (probably because there isn't 1200 any room in the output format to describe addends to relocs). */ 1201 1202 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler 1203 (OSF version 1.3, compiler version 3.11). It miscompiles the 1204 following program: 1205 1206 struct str 1207 { 1208 unsigned int i0; 1209 } s = { 0 }; 1210 1211 int 1212 main () 1213 { 1214 unsigned long x; 1215 1216 x = 0x100000000; 1217 x <<= (unsigned long) s.i0; 1218 if (x == 0) 1219 printf ("failed\n"); 1220 else 1221 printf ("succeeded (%lx)\n", x); 1222 } 1223 */ 1224 1225 relocation >>= (bfd_vma) howto->rightshift; 1226 1227 /* Shift everything up to where it's going to be used. */ 1228 relocation <<= (bfd_vma) howto->bitpos; 1229 1230 /* Wait for the day when all have the mask in them. */ 1231 1232 /* What we do: 1233 i instruction to be left alone 1234 o offset within instruction 1235 r relocation offset to apply 1236 S src mask 1237 D dst mask 1238 N ~dst mask 1239 A part 1 1240 B part 2 1241 R result 1242 1243 Do this: 1244 (( i i i i i o o o o o from bfd_get<size> 1245 and S S S S S) to get the size offset we want 1246 + r r r r r r r r r r) to get the final value to place 1247 and D D D D D to chop to right size 1248 ----------------------- 1249 = A A A A A 1250 And this: 1251 ( i i i i i o o o o o from bfd_get<size> 1252 and N N N N N ) get instruction 1253 ----------------------- 1254 = B B B B B 1255 1256 And then: 1257 ( B B B B B 1258 or A A A A A) 1259 ----------------------- 1260 = R R R R R R R R R R put into bfd_put<size> 1261 */ 1262 1263#define DOIT(x) \ 1264 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask)) 1265 1266 data = (bfd_byte *) data_start + (octets - data_start_offset); 1267 1268 switch (howto->size) 1269 { 1270 case 0: 1271 { 1272 char x = bfd_get_8 (abfd, data); 1273 DOIT (x); 1274 bfd_put_8 (abfd, x, data); 1275 } 1276 break; 1277 1278 case 1: 1279 { 1280 short x = bfd_get_16 (abfd, data); 1281 DOIT (x); 1282 bfd_put_16 (abfd, (bfd_vma) x, data); 1283 } 1284 break; 1285 case 2: 1286 { 1287 long x = bfd_get_32 (abfd, data); 1288 DOIT (x); 1289 bfd_put_32 (abfd, (bfd_vma) x, data); 1290 } 1291 break; 1292 case -2: 1293 { 1294 long x = bfd_get_32 (abfd, data); 1295 relocation = -relocation; 1296 DOIT (x); 1297 bfd_put_32 (abfd, (bfd_vma) x, data); 1298 } 1299 break; 1300 1301 case 3: 1302 /* Do nothing */ 1303 break; 1304 1305 case 4: 1306 { 1307 bfd_vma x = bfd_get_64 (abfd, data); 1308 DOIT (x); 1309 bfd_put_64 (abfd, x, data); 1310 } 1311 break; 1312 default: 1313 return bfd_reloc_other; 1314 } 1315 1316 return flag; 1317} 1318 1319/* This relocation routine is used by some of the backend linkers. 1320 They do not construct asymbol or arelent structures, so there is no 1321 reason for them to use bfd_perform_relocation. Also, 1322 bfd_perform_relocation is so hacked up it is easier to write a new 1323 function than to try to deal with it. 1324 1325 This routine does a final relocation. Whether it is useful for a 1326 relocatable link depends upon how the object format defines 1327 relocations. 1328 1329 FIXME: This routine ignores any special_function in the HOWTO, 1330 since the existing special_function values have been written for 1331 bfd_perform_relocation. 1332 1333 HOWTO is the reloc howto information. 1334 INPUT_BFD is the BFD which the reloc applies to. 1335 INPUT_SECTION is the section which the reloc applies to. 1336 CONTENTS is the contents of the section. 1337 ADDRESS is the address of the reloc within INPUT_SECTION. 1338 VALUE is the value of the symbol the reloc refers to. 1339 ADDEND is the addend of the reloc. */ 1340 1341bfd_reloc_status_type 1342_bfd_final_link_relocate (reloc_howto_type *howto, 1343 bfd *input_bfd, 1344 asection *input_section, 1345 bfd_byte *contents, 1346 bfd_vma address, 1347 bfd_vma value, 1348 bfd_vma addend) 1349{ 1350 bfd_vma relocation; 1351 1352 /* Sanity check the address. */ 1353 if (address > input_section->_raw_size) 1354 return bfd_reloc_outofrange; 1355 1356 /* This function assumes that we are dealing with a basic relocation 1357 against a symbol. We want to compute the value of the symbol to 1358 relocate to. This is just VALUE, the value of the symbol, plus 1359 ADDEND, any addend associated with the reloc. */ 1360 relocation = value + addend; 1361 1362 /* If the relocation is PC relative, we want to set RELOCATION to 1363 the distance between the symbol (currently in RELOCATION) and the 1364 location we are relocating. Some targets (e.g., i386-aout) 1365 arrange for the contents of the section to be the negative of the 1366 offset of the location within the section; for such targets 1367 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF) 1368 simply leave the contents of the section as zero; for such 1369 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not 1370 need to subtract out the offset of the location within the 1371 section (which is just ADDRESS). */ 1372 if (howto->pc_relative) 1373 { 1374 relocation -= (input_section->output_section->vma 1375 + input_section->output_offset); 1376 if (howto->pcrel_offset) 1377 relocation -= address; 1378 } 1379 1380 return _bfd_relocate_contents (howto, input_bfd, relocation, 1381 contents + address); 1382} 1383 1384/* Relocate a given location using a given value and howto. */ 1385 1386bfd_reloc_status_type 1387_bfd_relocate_contents (reloc_howto_type *howto, 1388 bfd *input_bfd, 1389 bfd_vma relocation, 1390 bfd_byte *location) 1391{ 1392 int size; 1393 bfd_vma x = 0; 1394 bfd_reloc_status_type flag; 1395 unsigned int rightshift = howto->rightshift; 1396 unsigned int bitpos = howto->bitpos; 1397 1398 /* If the size is negative, negate RELOCATION. This isn't very 1399 general. */ 1400 if (howto->size < 0) 1401 relocation = -relocation; 1402 1403 /* Get the value we are going to relocate. */ 1404 size = bfd_get_reloc_size (howto); 1405 switch (size) 1406 { 1407 default: 1408 case 0: 1409 abort (); 1410 case 1: 1411 x = bfd_get_8 (input_bfd, location); 1412 break; 1413 case 2: 1414 x = bfd_get_16 (input_bfd, location); 1415 break; 1416 case 4: 1417 x = bfd_get_32 (input_bfd, location); 1418 break; 1419 case 8: 1420#ifdef BFD64 1421 x = bfd_get_64 (input_bfd, location); 1422#else 1423 abort (); 1424#endif 1425 break; 1426 } 1427 1428 /* Check for overflow. FIXME: We may drop bits during the addition 1429 which we don't check for. We must either check at every single 1430 operation, which would be tedious, or we must do the computations 1431 in a type larger than bfd_vma, which would be inefficient. */ 1432 flag = bfd_reloc_ok; 1433 if (howto->complain_on_overflow != complain_overflow_dont) 1434 { 1435 bfd_vma addrmask, fieldmask, signmask, ss; 1436 bfd_vma a, b, sum; 1437 1438 /* Get the values to be added together. For signed and unsigned 1439 relocations, we assume that all values should be truncated to 1440 the size of an address. For bitfields, all the bits matter. 1441 See also bfd_check_overflow. */ 1442 fieldmask = N_ONES (howto->bitsize); 1443 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask; 1444 a = relocation; 1445 b = x & howto->src_mask; 1446 1447 switch (howto->complain_on_overflow) 1448 { 1449 case complain_overflow_signed: 1450 a = (a & addrmask) >> rightshift; 1451 1452 /* If any sign bits are set, all sign bits must be set. 1453 That is, A must be a valid negative address after 1454 shifting. */ 1455 signmask = ~ (fieldmask >> 1); 1456 ss = a & signmask; 1457 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask)) 1458 flag = bfd_reloc_overflow; 1459 1460 /* We only need this next bit of code if the sign bit of B 1461 is below the sign bit of A. This would only happen if 1462 SRC_MASK had fewer bits than BITSIZE. Note that if 1463 SRC_MASK has more bits than BITSIZE, we can get into 1464 trouble; we would need to verify that B is in range, as 1465 we do for A above. */ 1466 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask; 1467 1468 /* Set all the bits above the sign bit. */ 1469 b = (b ^ signmask) - signmask; 1470 1471 b = (b & addrmask) >> bitpos; 1472 1473 /* Now we can do the addition. */ 1474 sum = a + b; 1475 1476 /* See if the result has the correct sign. Bits above the 1477 sign bit are junk now; ignore them. If the sum is 1478 positive, make sure we did not have all negative inputs; 1479 if the sum is negative, make sure we did not have all 1480 positive inputs. The test below looks only at the sign 1481 bits, and it really just 1482 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM) 1483 */ 1484 signmask = (fieldmask >> 1) + 1; 1485 if (((~ (a ^ b)) & (a ^ sum)) & signmask) 1486 flag = bfd_reloc_overflow; 1487 1488 break; 1489 1490 case complain_overflow_unsigned: 1491 /* Checking for an unsigned overflow is relatively easy: 1492 trim the addresses and add, and trim the result as well. 1493 Overflow is normally indicated when the result does not 1494 fit in the field. However, we also need to consider the 1495 case when, e.g., fieldmask is 0x7fffffff or smaller, an 1496 input is 0x80000000, and bfd_vma is only 32 bits; then we 1497 will get sum == 0, but there is an overflow, since the 1498 inputs did not fit in the field. Instead of doing a 1499 separate test, we can check for this by or-ing in the 1500 operands when testing for the sum overflowing its final 1501 field. */ 1502 a = (a & addrmask) >> rightshift; 1503 b = (b & addrmask) >> bitpos; 1504 sum = (a + b) & addrmask; 1505 if ((a | b | sum) & ~ fieldmask) 1506 flag = bfd_reloc_overflow; 1507 1508 break; 1509 1510 case complain_overflow_bitfield: 1511 /* Much like the signed check, but for a field one bit 1512 wider, and no trimming inputs with addrmask. We allow a 1513 bitfield to represent numbers in the range -2**n to 1514 2**n-1, where n is the number of bits in the field. 1515 Note that when bfd_vma is 32 bits, a 32-bit reloc can't 1516 overflow, which is exactly what we want. */ 1517 a >>= rightshift; 1518 1519 signmask = ~ fieldmask; 1520 ss = a & signmask; 1521 if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & signmask)) 1522 flag = bfd_reloc_overflow; 1523 1524 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask; 1525 b = (b ^ signmask) - signmask; 1526 1527 b >>= bitpos; 1528 1529 sum = a + b; 1530 1531 /* We mask with addrmask here to explicitly allow an address 1532 wrap-around. The Linux kernel relies on it, and it is 1533 the only way to write assembler code which can run when 1534 loaded at a location 0x80000000 away from the location at 1535 which it is linked. */ 1536 signmask = fieldmask + 1; 1537 if (((~ (a ^ b)) & (a ^ sum)) & signmask & addrmask) 1538 flag = bfd_reloc_overflow; 1539 1540 break; 1541 1542 default: 1543 abort (); 1544 } 1545 } 1546 1547 /* Put RELOCATION in the right bits. */ 1548 relocation >>= (bfd_vma) rightshift; 1549 relocation <<= (bfd_vma) bitpos; 1550 1551 /* Add RELOCATION to the right bits of X. */ 1552 x = ((x & ~howto->dst_mask) 1553 | (((x & howto->src_mask) + relocation) & howto->dst_mask)); 1554 1555 /* Put the relocated value back in the object file. */ 1556 switch (size) 1557 { 1558 default: 1559 case 0: 1560 abort (); 1561 case 1: 1562 bfd_put_8 (input_bfd, x, location); 1563 break; 1564 case 2: 1565 bfd_put_16 (input_bfd, x, location); 1566 break; 1567 case 4: 1568 bfd_put_32 (input_bfd, x, location); 1569 break; 1570 case 8: 1571#ifdef BFD64 1572 bfd_put_64 (input_bfd, x, location); 1573#else 1574 abort (); 1575#endif 1576 break; 1577 } 1578 1579 return flag; 1580} 1581 1582/* 1583DOCDD 1584INODE 1585 howto manager, , typedef arelent, Relocations 1586 1587SECTION 1588 The howto manager 1589 1590 When an application wants to create a relocation, but doesn't 1591 know what the target machine might call it, it can find out by 1592 using this bit of code. 1593 1594*/ 1595 1596/* 1597TYPEDEF 1598 bfd_reloc_code_type 1599 1600DESCRIPTION 1601 The insides of a reloc code. The idea is that, eventually, there 1602 will be one enumerator for every type of relocation we ever do. 1603 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll 1604 return a howto pointer. 1605 1606 This does mean that the application must determine the correct 1607 enumerator value; you can't get a howto pointer from a random set 1608 of attributes. 1609 1610SENUM 1611 bfd_reloc_code_real 1612 1613ENUM 1614 BFD_RELOC_64 1615ENUMX 1616 BFD_RELOC_32 1617ENUMX 1618 BFD_RELOC_26 1619ENUMX 1620 BFD_RELOC_24 1621ENUMX 1622 BFD_RELOC_16 1623ENUMX 1624 BFD_RELOC_14 1625ENUMX 1626 BFD_RELOC_8 1627ENUMDOC 1628 Basic absolute relocations of N bits. 1629 1630ENUM 1631 BFD_RELOC_64_PCREL 1632ENUMX 1633 BFD_RELOC_32_PCREL 1634ENUMX 1635 BFD_RELOC_24_PCREL 1636ENUMX 1637 BFD_RELOC_16_PCREL 1638ENUMX 1639 BFD_RELOC_12_PCREL 1640ENUMX 1641 BFD_RELOC_8_PCREL 1642ENUMDOC 1643 PC-relative relocations. Sometimes these are relative to the address 1644of the relocation itself; sometimes they are relative to the start of 1645the section containing the relocation. It depends on the specific target. 1646 1647The 24-bit relocation is used in some Intel 960 configurations. 1648 1649ENUM 1650 BFD_RELOC_32_GOT_PCREL 1651ENUMX 1652 BFD_RELOC_16_GOT_PCREL 1653ENUMX 1654 BFD_RELOC_8_GOT_PCREL 1655ENUMX 1656 BFD_RELOC_32_GOTOFF 1657ENUMX 1658 BFD_RELOC_16_GOTOFF 1659ENUMX 1660 BFD_RELOC_LO16_GOTOFF 1661ENUMX 1662 BFD_RELOC_HI16_GOTOFF 1663ENUMX 1664 BFD_RELOC_HI16_S_GOTOFF 1665ENUMX 1666 BFD_RELOC_8_GOTOFF 1667ENUMX 1668 BFD_RELOC_64_PLT_PCREL 1669ENUMX 1670 BFD_RELOC_32_PLT_PCREL 1671ENUMX 1672 BFD_RELOC_24_PLT_PCREL 1673ENUMX 1674 BFD_RELOC_16_PLT_PCREL 1675ENUMX 1676 BFD_RELOC_8_PLT_PCREL 1677ENUMX 1678 BFD_RELOC_64_PLTOFF 1679ENUMX 1680 BFD_RELOC_32_PLTOFF 1681ENUMX 1682 BFD_RELOC_16_PLTOFF 1683ENUMX 1684 BFD_RELOC_LO16_PLTOFF 1685ENUMX 1686 BFD_RELOC_HI16_PLTOFF 1687ENUMX 1688 BFD_RELOC_HI16_S_PLTOFF 1689ENUMX 1690 BFD_RELOC_8_PLTOFF 1691ENUMDOC 1692 For ELF. 1693 1694ENUM 1695 BFD_RELOC_68K_GLOB_DAT 1696ENUMX 1697 BFD_RELOC_68K_JMP_SLOT 1698ENUMX 1699 BFD_RELOC_68K_RELATIVE 1700ENUMDOC 1701 Relocations used by 68K ELF. 1702 1703ENUM 1704 BFD_RELOC_32_BASEREL 1705ENUMX 1706 BFD_RELOC_16_BASEREL 1707ENUMX 1708 BFD_RELOC_LO16_BASEREL 1709ENUMX 1710 BFD_RELOC_HI16_BASEREL 1711ENUMX 1712 BFD_RELOC_HI16_S_BASEREL 1713ENUMX 1714 BFD_RELOC_8_BASEREL 1715ENUMX 1716 BFD_RELOC_RVA 1717ENUMDOC 1718 Linkage-table relative. 1719 1720ENUM 1721 BFD_RELOC_8_FFnn 1722ENUMDOC 1723 Absolute 8-bit relocation, but used to form an address like 0xFFnn. 1724 1725ENUM 1726 BFD_RELOC_32_PCREL_S2 1727ENUMX 1728 BFD_RELOC_16_PCREL_S2 1729ENUMX 1730 BFD_RELOC_23_PCREL_S2 1731ENUMDOC 1732 These PC-relative relocations are stored as word displacements -- 1733i.e., byte displacements shifted right two bits. The 30-bit word 1734displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the 1735SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The 1736signed 16-bit displacement is used on the MIPS, and the 23-bit 1737displacement is used on the Alpha. 1738 1739ENUM 1740 BFD_RELOC_HI22 1741ENUMX 1742 BFD_RELOC_LO10 1743ENUMDOC 1744 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of 1745the target word. These are used on the SPARC. 1746 1747ENUM 1748 BFD_RELOC_GPREL16 1749ENUMX 1750 BFD_RELOC_GPREL32 1751ENUMDOC 1752 For systems that allocate a Global Pointer register, these are 1753displacements off that register. These relocation types are 1754handled specially, because the value the register will have is 1755decided relatively late. 1756 1757ENUM 1758 BFD_RELOC_I960_CALLJ 1759ENUMDOC 1760 Reloc types used for i960/b.out. 1761 1762ENUM 1763 BFD_RELOC_NONE 1764ENUMX 1765 BFD_RELOC_SPARC_WDISP22 1766ENUMX 1767 BFD_RELOC_SPARC22 1768ENUMX 1769 BFD_RELOC_SPARC13 1770ENUMX 1771 BFD_RELOC_SPARC_GOT10 1772ENUMX 1773 BFD_RELOC_SPARC_GOT13 1774ENUMX 1775 BFD_RELOC_SPARC_GOT22 1776ENUMX 1777 BFD_RELOC_SPARC_PC10 1778ENUMX 1779 BFD_RELOC_SPARC_PC22 1780ENUMX 1781 BFD_RELOC_SPARC_WPLT30 1782ENUMX 1783 BFD_RELOC_SPARC_COPY 1784ENUMX 1785 BFD_RELOC_SPARC_GLOB_DAT 1786ENUMX 1787 BFD_RELOC_SPARC_JMP_SLOT 1788ENUMX 1789 BFD_RELOC_SPARC_RELATIVE 1790ENUMX 1791 BFD_RELOC_SPARC_UA16 1792ENUMX 1793 BFD_RELOC_SPARC_UA32 1794ENUMX 1795 BFD_RELOC_SPARC_UA64 1796ENUMDOC 1797 SPARC ELF relocations. There is probably some overlap with other 1798 relocation types already defined. 1799 1800ENUM 1801 BFD_RELOC_SPARC_BASE13 1802ENUMX 1803 BFD_RELOC_SPARC_BASE22 1804ENUMDOC 1805 I think these are specific to SPARC a.out (e.g., Sun 4). 1806 1807ENUMEQ 1808 BFD_RELOC_SPARC_64 1809 BFD_RELOC_64 1810ENUMX 1811 BFD_RELOC_SPARC_10 1812ENUMX 1813 BFD_RELOC_SPARC_11 1814ENUMX 1815 BFD_RELOC_SPARC_OLO10 1816ENUMX 1817 BFD_RELOC_SPARC_HH22 1818ENUMX 1819 BFD_RELOC_SPARC_HM10 1820ENUMX 1821 BFD_RELOC_SPARC_LM22 1822ENUMX 1823 BFD_RELOC_SPARC_PC_HH22 1824ENUMX 1825 BFD_RELOC_SPARC_PC_HM10 1826ENUMX 1827 BFD_RELOC_SPARC_PC_LM22 1828ENUMX 1829 BFD_RELOC_SPARC_WDISP16 1830ENUMX 1831 BFD_RELOC_SPARC_WDISP19 1832ENUMX 1833 BFD_RELOC_SPARC_7 1834ENUMX 1835 BFD_RELOC_SPARC_6 1836ENUMX 1837 BFD_RELOC_SPARC_5 1838ENUMEQX 1839 BFD_RELOC_SPARC_DISP64 1840 BFD_RELOC_64_PCREL 1841ENUMX 1842 BFD_RELOC_SPARC_PLT32 1843ENUMX 1844 BFD_RELOC_SPARC_PLT64 1845ENUMX 1846 BFD_RELOC_SPARC_HIX22 1847ENUMX 1848 BFD_RELOC_SPARC_LOX10 1849ENUMX 1850 BFD_RELOC_SPARC_H44 1851ENUMX 1852 BFD_RELOC_SPARC_M44 1853ENUMX 1854 BFD_RELOC_SPARC_L44 1855ENUMX 1856 BFD_RELOC_SPARC_REGISTER 1857ENUMDOC 1858 SPARC64 relocations 1859 1860ENUM 1861 BFD_RELOC_SPARC_REV32 1862ENUMDOC 1863 SPARC little endian relocation 1864ENUM 1865 BFD_RELOC_SPARC_TLS_GD_HI22 1866ENUMX 1867 BFD_RELOC_SPARC_TLS_GD_LO10 1868ENUMX 1869 BFD_RELOC_SPARC_TLS_GD_ADD 1870ENUMX 1871 BFD_RELOC_SPARC_TLS_GD_CALL 1872ENUMX 1873 BFD_RELOC_SPARC_TLS_LDM_HI22 1874ENUMX 1875 BFD_RELOC_SPARC_TLS_LDM_LO10 1876ENUMX 1877 BFD_RELOC_SPARC_TLS_LDM_ADD 1878ENUMX 1879 BFD_RELOC_SPARC_TLS_LDM_CALL 1880ENUMX 1881 BFD_RELOC_SPARC_TLS_LDO_HIX22 1882ENUMX 1883 BFD_RELOC_SPARC_TLS_LDO_LOX10 1884ENUMX 1885 BFD_RELOC_SPARC_TLS_LDO_ADD 1886ENUMX 1887 BFD_RELOC_SPARC_TLS_IE_HI22 1888ENUMX 1889 BFD_RELOC_SPARC_TLS_IE_LO10 1890ENUMX 1891 BFD_RELOC_SPARC_TLS_IE_LD 1892ENUMX 1893 BFD_RELOC_SPARC_TLS_IE_LDX 1894ENUMX 1895 BFD_RELOC_SPARC_TLS_IE_ADD 1896ENUMX 1897 BFD_RELOC_SPARC_TLS_LE_HIX22 1898ENUMX 1899 BFD_RELOC_SPARC_TLS_LE_LOX10 1900ENUMX 1901 BFD_RELOC_SPARC_TLS_DTPMOD32 1902ENUMX 1903 BFD_RELOC_SPARC_TLS_DTPMOD64 1904ENUMX 1905 BFD_RELOC_SPARC_TLS_DTPOFF32 1906ENUMX 1907 BFD_RELOC_SPARC_TLS_DTPOFF64 1908ENUMX 1909 BFD_RELOC_SPARC_TLS_TPOFF32 1910ENUMX 1911 BFD_RELOC_SPARC_TLS_TPOFF64 1912ENUMDOC 1913 SPARC TLS relocations 1914 1915ENUM 1916 BFD_RELOC_ALPHA_GPDISP_HI16 1917ENUMDOC 1918 Alpha ECOFF and ELF relocations. Some of these treat the symbol or 1919 "addend" in some special way. 1920 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when 1921 writing; when reading, it will be the absolute section symbol. The 1922 addend is the displacement in bytes of the "lda" instruction from 1923 the "ldah" instruction (which is at the address of this reloc). 1924ENUM 1925 BFD_RELOC_ALPHA_GPDISP_LO16 1926ENUMDOC 1927 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as 1928 with GPDISP_HI16 relocs. The addend is ignored when writing the 1929 relocations out, and is filled in with the file's GP value on 1930 reading, for convenience. 1931 1932ENUM 1933 BFD_RELOC_ALPHA_GPDISP 1934ENUMDOC 1935 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 1936 relocation except that there is no accompanying GPDISP_LO16 1937 relocation. 1938 1939ENUM 1940 BFD_RELOC_ALPHA_LITERAL 1941ENUMX 1942 BFD_RELOC_ALPHA_ELF_LITERAL 1943ENUMX 1944 BFD_RELOC_ALPHA_LITUSE 1945ENUMDOC 1946 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; 1947 the assembler turns it into a LDQ instruction to load the address of 1948 the symbol, and then fills in a register in the real instruction. 1949 1950 The LITERAL reloc, at the LDQ instruction, refers to the .lita 1951 section symbol. The addend is ignored when writing, but is filled 1952 in with the file's GP value on reading, for convenience, as with the 1953 GPDISP_LO16 reloc. 1954 1955 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16. 1956 It should refer to the symbol to be referenced, as with 16_GOTOFF, 1957 but it generates output not based on the position within the .got 1958 section, but relative to the GP value chosen for the file during the 1959 final link stage. 1960 1961 The LITUSE reloc, on the instruction using the loaded address, gives 1962 information to the linker that it might be able to use to optimize 1963 away some literal section references. The symbol is ignored (read 1964 as the absolute section symbol), and the "addend" indicates the type 1965 of instruction using the register: 1966 1 - "memory" fmt insn 1967 2 - byte-manipulation (byte offset reg) 1968 3 - jsr (target of branch) 1969 1970ENUM 1971 BFD_RELOC_ALPHA_HINT 1972ENUMDOC 1973 The HINT relocation indicates a value that should be filled into the 1974 "hint" field of a jmp/jsr/ret instruction, for possible branch- 1975 prediction logic which may be provided on some processors. 1976 1977ENUM 1978 BFD_RELOC_ALPHA_LINKAGE 1979ENUMDOC 1980 The LINKAGE relocation outputs a linkage pair in the object file, 1981 which is filled by the linker. 1982 1983ENUM 1984 BFD_RELOC_ALPHA_CODEADDR 1985ENUMDOC 1986 The CODEADDR relocation outputs a STO_CA in the object file, 1987 which is filled by the linker. 1988 1989ENUM 1990 BFD_RELOC_ALPHA_GPREL_HI16 1991ENUMX 1992 BFD_RELOC_ALPHA_GPREL_LO16 1993ENUMDOC 1994 The GPREL_HI/LO relocations together form a 32-bit offset from the 1995 GP register. 1996 1997ENUM 1998 BFD_RELOC_ALPHA_BRSGP 1999ENUMDOC 2000 Like BFD_RELOC_23_PCREL_S2, except that the source and target must 2001 share a common GP, and the target address is adjusted for 2002 STO_ALPHA_STD_GPLOAD. 2003 2004ENUM 2005 BFD_RELOC_ALPHA_TLSGD 2006ENUMX 2007 BFD_RELOC_ALPHA_TLSLDM 2008ENUMX 2009 BFD_RELOC_ALPHA_DTPMOD64 2010ENUMX 2011 BFD_RELOC_ALPHA_GOTDTPREL16 2012ENUMX 2013 BFD_RELOC_ALPHA_DTPREL64 2014ENUMX 2015 BFD_RELOC_ALPHA_DTPREL_HI16 2016ENUMX 2017 BFD_RELOC_ALPHA_DTPREL_LO16 2018ENUMX 2019 BFD_RELOC_ALPHA_DTPREL16 2020ENUMX 2021 BFD_RELOC_ALPHA_GOTTPREL16 2022ENUMX 2023 BFD_RELOC_ALPHA_TPREL64 2024ENUMX 2025 BFD_RELOC_ALPHA_TPREL_HI16 2026ENUMX 2027 BFD_RELOC_ALPHA_TPREL_LO16 2028ENUMX 2029 BFD_RELOC_ALPHA_TPREL16 2030ENUMDOC 2031 Alpha thread-local storage relocations. 2032 2033ENUM 2034 BFD_RELOC_MIPS_JMP 2035ENUMDOC 2036 Bits 27..2 of the relocation address shifted right 2 bits; 2037 simple reloc otherwise. 2038 2039ENUM 2040 BFD_RELOC_MIPS16_JMP 2041ENUMDOC 2042 The MIPS16 jump instruction. 2043 2044ENUM 2045 BFD_RELOC_MIPS16_GPREL 2046ENUMDOC 2047 MIPS16 GP relative reloc. 2048 2049ENUM 2050 BFD_RELOC_HI16 2051ENUMDOC 2052 High 16 bits of 32-bit value; simple reloc. 2053ENUM 2054 BFD_RELOC_HI16_S 2055ENUMDOC 2056 High 16 bits of 32-bit value but the low 16 bits will be sign 2057 extended and added to form the final result. If the low 16 2058 bits form a negative number, we need to add one to the high value 2059 to compensate for the borrow when the low bits are added. 2060ENUM 2061 BFD_RELOC_LO16 2062ENUMDOC 2063 Low 16 bits. 2064ENUM 2065 BFD_RELOC_PCREL_HI16_S 2066ENUMDOC 2067 Like BFD_RELOC_HI16_S, but PC relative. 2068ENUM 2069 BFD_RELOC_PCREL_LO16 2070ENUMDOC 2071 Like BFD_RELOC_LO16, but PC relative. 2072 2073ENUM 2074 BFD_RELOC_MIPS_LITERAL 2075ENUMDOC 2076 Relocation against a MIPS literal section. 2077 2078ENUM 2079 BFD_RELOC_MIPS_GOT16 2080ENUMX 2081 BFD_RELOC_MIPS_CALL16 2082ENUMX 2083 BFD_RELOC_MIPS_GOT_HI16 2084ENUMX 2085 BFD_RELOC_MIPS_GOT_LO16 2086ENUMX 2087 BFD_RELOC_MIPS_CALL_HI16 2088ENUMX 2089 BFD_RELOC_MIPS_CALL_LO16 2090ENUMX 2091 BFD_RELOC_MIPS_SUB 2092ENUMX 2093 BFD_RELOC_MIPS_GOT_PAGE 2094ENUMX 2095 BFD_RELOC_MIPS_GOT_OFST 2096ENUMX 2097 BFD_RELOC_MIPS_GOT_DISP 2098ENUMX 2099 BFD_RELOC_MIPS_SHIFT5 2100ENUMX 2101 BFD_RELOC_MIPS_SHIFT6 2102ENUMX 2103 BFD_RELOC_MIPS_INSERT_A 2104ENUMX 2105 BFD_RELOC_MIPS_INSERT_B 2106ENUMX 2107 BFD_RELOC_MIPS_DELETE 2108ENUMX 2109 BFD_RELOC_MIPS_HIGHEST 2110ENUMX 2111 BFD_RELOC_MIPS_HIGHER 2112ENUMX 2113 BFD_RELOC_MIPS_SCN_DISP 2114ENUMX 2115 BFD_RELOC_MIPS_REL16 2116ENUMX 2117 BFD_RELOC_MIPS_RELGOT 2118ENUMX 2119 BFD_RELOC_MIPS_JALR 2120ENUMDOC 2121 MIPS ELF relocations. 2122COMMENT 2123 2124ENUM 2125 BFD_RELOC_FRV_LABEL16 2126ENUMX 2127 BFD_RELOC_FRV_LABEL24 2128ENUMX 2129 BFD_RELOC_FRV_LO16 2130ENUMX 2131 BFD_RELOC_FRV_HI16 2132ENUMX 2133 BFD_RELOC_FRV_GPREL12 2134ENUMX 2135 BFD_RELOC_FRV_GPRELU12 2136ENUMX 2137 BFD_RELOC_FRV_GPREL32 2138ENUMX 2139 BFD_RELOC_FRV_GPRELHI 2140ENUMX 2141 BFD_RELOC_FRV_GPRELLO 2142ENUMX 2143 BFD_RELOC_FRV_GOT12 2144ENUMX 2145 BFD_RELOC_FRV_GOTHI 2146ENUMX 2147 BFD_RELOC_FRV_GOTLO 2148ENUMX 2149 BFD_RELOC_FRV_FUNCDESC 2150ENUMX 2151 BFD_RELOC_FRV_FUNCDESC_GOT12 2152ENUMX 2153 BFD_RELOC_FRV_FUNCDESC_GOTHI 2154ENUMX 2155 BFD_RELOC_FRV_FUNCDESC_GOTLO 2156ENUMX 2157 BFD_RELOC_FRV_FUNCDESC_VALUE 2158ENUMX 2159 BFD_RELOC_FRV_FUNCDESC_GOTOFF12 2160ENUMX 2161 BFD_RELOC_FRV_FUNCDESC_GOTOFFHI 2162ENUMX 2163 BFD_RELOC_FRV_FUNCDESC_GOTOFFLO 2164ENUMX 2165 BFD_RELOC_FRV_GOTOFF12 2166ENUMX 2167 BFD_RELOC_FRV_GOTOFFHI 2168ENUMX 2169 BFD_RELOC_FRV_GOTOFFLO 2170ENUMDOC 2171 Fujitsu Frv Relocations. 2172COMMENT 2173 2174ENUM 2175 BFD_RELOC_MN10300_GOTOFF24 2176ENUMDOC 2177 This is a 24bit GOT-relative reloc for the mn10300. 2178ENUM 2179 BFD_RELOC_MN10300_GOT32 2180ENUMDOC 2181 This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes 2182 in the instruction. 2183ENUM 2184 BFD_RELOC_MN10300_GOT24 2185ENUMDOC 2186 This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes 2187 in the instruction. 2188ENUM 2189 BFD_RELOC_MN10300_GOT16 2190ENUMDOC 2191 This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes 2192 in the instruction. 2193ENUM 2194 BFD_RELOC_MN10300_COPY 2195ENUMDOC 2196 Copy symbol at runtime. 2197ENUM 2198 BFD_RELOC_MN10300_GLOB_DAT 2199ENUMDOC 2200 Create GOT entry. 2201ENUM 2202 BFD_RELOC_MN10300_JMP_SLOT 2203ENUMDOC 2204 Create PLT entry. 2205ENUM 2206 BFD_RELOC_MN10300_RELATIVE 2207ENUMDOC 2208 Adjust by program base. 2209COMMENT 2210 2211ENUM 2212 BFD_RELOC_386_GOT32 2213ENUMX 2214 BFD_RELOC_386_PLT32 2215ENUMX 2216 BFD_RELOC_386_COPY 2217ENUMX 2218 BFD_RELOC_386_GLOB_DAT 2219ENUMX 2220 BFD_RELOC_386_JUMP_SLOT 2221ENUMX 2222 BFD_RELOC_386_RELATIVE 2223ENUMX 2224 BFD_RELOC_386_GOTOFF 2225ENUMX 2226 BFD_RELOC_386_GOTPC 2227ENUMX 2228 BFD_RELOC_386_TLS_TPOFF 2229ENUMX 2230 BFD_RELOC_386_TLS_IE 2231ENUMX 2232 BFD_RELOC_386_TLS_GOTIE 2233ENUMX 2234 BFD_RELOC_386_TLS_LE 2235ENUMX 2236 BFD_RELOC_386_TLS_GD 2237ENUMX 2238 BFD_RELOC_386_TLS_LDM 2239ENUMX 2240 BFD_RELOC_386_TLS_LDO_32 2241ENUMX 2242 BFD_RELOC_386_TLS_IE_32 2243ENUMX 2244 BFD_RELOC_386_TLS_LE_32 2245ENUMX 2246 BFD_RELOC_386_TLS_DTPMOD32 2247ENUMX 2248 BFD_RELOC_386_TLS_DTPOFF32 2249ENUMX 2250 BFD_RELOC_386_TLS_TPOFF32 2251ENUMDOC 2252 i386/elf relocations 2253 2254ENUM 2255 BFD_RELOC_X86_64_GOT32 2256ENUMX 2257 BFD_RELOC_X86_64_PLT32 2258ENUMX 2259 BFD_RELOC_X86_64_COPY 2260ENUMX 2261 BFD_RELOC_X86_64_GLOB_DAT 2262ENUMX 2263 BFD_RELOC_X86_64_JUMP_SLOT 2264ENUMX 2265 BFD_RELOC_X86_64_RELATIVE 2266ENUMX 2267 BFD_RELOC_X86_64_GOTPCREL 2268ENUMX 2269 BFD_RELOC_X86_64_32S 2270ENUMX 2271 BFD_RELOC_X86_64_DTPMOD64 2272ENUMX 2273 BFD_RELOC_X86_64_DTPOFF64 2274ENUMX 2275 BFD_RELOC_X86_64_TPOFF64 2276ENUMX 2277 BFD_RELOC_X86_64_TLSGD 2278ENUMX 2279 BFD_RELOC_X86_64_TLSLD 2280ENUMX 2281 BFD_RELOC_X86_64_DTPOFF32 2282ENUMX 2283 BFD_RELOC_X86_64_GOTTPOFF 2284ENUMX 2285 BFD_RELOC_X86_64_TPOFF32 2286ENUMDOC 2287 x86-64/elf relocations 2288 2289ENUM 2290 BFD_RELOC_NS32K_IMM_8 2291ENUMX 2292 BFD_RELOC_NS32K_IMM_16 2293ENUMX 2294 BFD_RELOC_NS32K_IMM_32 2295ENUMX 2296 BFD_RELOC_NS32K_IMM_8_PCREL 2297ENUMX 2298 BFD_RELOC_NS32K_IMM_16_PCREL 2299ENUMX 2300 BFD_RELOC_NS32K_IMM_32_PCREL 2301ENUMX 2302 BFD_RELOC_NS32K_DISP_8 2303ENUMX 2304 BFD_RELOC_NS32K_DISP_16 2305ENUMX 2306 BFD_RELOC_NS32K_DISP_32 2307ENUMX 2308 BFD_RELOC_NS32K_DISP_8_PCREL 2309ENUMX 2310 BFD_RELOC_NS32K_DISP_16_PCREL 2311ENUMX 2312 BFD_RELOC_NS32K_DISP_32_PCREL 2313ENUMDOC 2314 ns32k relocations 2315 2316ENUM 2317 BFD_RELOC_PDP11_DISP_8_PCREL 2318ENUMX 2319 BFD_RELOC_PDP11_DISP_6_PCREL 2320ENUMDOC 2321 PDP11 relocations 2322 2323ENUM 2324 BFD_RELOC_PJ_CODE_HI16 2325ENUMX 2326 BFD_RELOC_PJ_CODE_LO16 2327ENUMX 2328 BFD_RELOC_PJ_CODE_DIR16 2329ENUMX 2330 BFD_RELOC_PJ_CODE_DIR32 2331ENUMX 2332 BFD_RELOC_PJ_CODE_REL16 2333ENUMX 2334 BFD_RELOC_PJ_CODE_REL32 2335ENUMDOC 2336 Picojava relocs. Not all of these appear in object files. 2337 2338ENUM 2339 BFD_RELOC_PPC_B26 2340ENUMX 2341 BFD_RELOC_PPC_BA26 2342ENUMX 2343 BFD_RELOC_PPC_TOC16 2344ENUMX 2345 BFD_RELOC_PPC_B16 2346ENUMX 2347 BFD_RELOC_PPC_B16_BRTAKEN 2348ENUMX 2349 BFD_RELOC_PPC_B16_BRNTAKEN 2350ENUMX 2351 BFD_RELOC_PPC_BA16 2352ENUMX 2353 BFD_RELOC_PPC_BA16_BRTAKEN 2354ENUMX 2355 BFD_RELOC_PPC_BA16_BRNTAKEN 2356ENUMX 2357 BFD_RELOC_PPC_COPY 2358ENUMX 2359 BFD_RELOC_PPC_GLOB_DAT 2360ENUMX 2361 BFD_RELOC_PPC_JMP_SLOT 2362ENUMX 2363 BFD_RELOC_PPC_RELATIVE 2364ENUMX 2365 BFD_RELOC_PPC_LOCAL24PC 2366ENUMX 2367 BFD_RELOC_PPC_EMB_NADDR32 2368ENUMX 2369 BFD_RELOC_PPC_EMB_NADDR16 2370ENUMX 2371 BFD_RELOC_PPC_EMB_NADDR16_LO 2372ENUMX 2373 BFD_RELOC_PPC_EMB_NADDR16_HI 2374ENUMX 2375 BFD_RELOC_PPC_EMB_NADDR16_HA 2376ENUMX 2377 BFD_RELOC_PPC_EMB_SDAI16 2378ENUMX 2379 BFD_RELOC_PPC_EMB_SDA2I16 2380ENUMX 2381 BFD_RELOC_PPC_EMB_SDA2REL 2382ENUMX 2383 BFD_RELOC_PPC_EMB_SDA21 2384ENUMX 2385 BFD_RELOC_PPC_EMB_MRKREF 2386ENUMX 2387 BFD_RELOC_PPC_EMB_RELSEC16 2388ENUMX 2389 BFD_RELOC_PPC_EMB_RELST_LO 2390ENUMX 2391 BFD_RELOC_PPC_EMB_RELST_HI 2392ENUMX 2393 BFD_RELOC_PPC_EMB_RELST_HA 2394ENUMX 2395 BFD_RELOC_PPC_EMB_BIT_FLD 2396ENUMX 2397 BFD_RELOC_PPC_EMB_RELSDA 2398ENUMX 2399 BFD_RELOC_PPC64_HIGHER 2400ENUMX 2401 BFD_RELOC_PPC64_HIGHER_S 2402ENUMX 2403 BFD_RELOC_PPC64_HIGHEST 2404ENUMX 2405 BFD_RELOC_PPC64_HIGHEST_S 2406ENUMX 2407 BFD_RELOC_PPC64_TOC16_LO 2408ENUMX 2409 BFD_RELOC_PPC64_TOC16_HI 2410ENUMX 2411 BFD_RELOC_PPC64_TOC16_HA 2412ENUMX 2413 BFD_RELOC_PPC64_TOC 2414ENUMX 2415 BFD_RELOC_PPC64_PLTGOT16 2416ENUMX 2417 BFD_RELOC_PPC64_PLTGOT16_LO 2418ENUMX 2419 BFD_RELOC_PPC64_PLTGOT16_HI 2420ENUMX 2421 BFD_RELOC_PPC64_PLTGOT16_HA 2422ENUMX 2423 BFD_RELOC_PPC64_ADDR16_DS 2424ENUMX 2425 BFD_RELOC_PPC64_ADDR16_LO_DS 2426ENUMX 2427 BFD_RELOC_PPC64_GOT16_DS 2428ENUMX 2429 BFD_RELOC_PPC64_GOT16_LO_DS 2430ENUMX 2431 BFD_RELOC_PPC64_PLT16_LO_DS 2432ENUMX 2433 BFD_RELOC_PPC64_SECTOFF_DS 2434ENUMX 2435 BFD_RELOC_PPC64_SECTOFF_LO_DS 2436ENUMX 2437 BFD_RELOC_PPC64_TOC16_DS 2438ENUMX 2439 BFD_RELOC_PPC64_TOC16_LO_DS 2440ENUMX 2441 BFD_RELOC_PPC64_PLTGOT16_DS 2442ENUMX 2443 BFD_RELOC_PPC64_PLTGOT16_LO_DS 2444ENUMDOC 2445 Power(rs6000) and PowerPC relocations. 2446 2447ENUM 2448 BFD_RELOC_PPC_TLS 2449ENUMX 2450 BFD_RELOC_PPC_DTPMOD 2451ENUMX 2452 BFD_RELOC_PPC_TPREL16 2453ENUMX 2454 BFD_RELOC_PPC_TPREL16_LO 2455ENUMX 2456 BFD_RELOC_PPC_TPREL16_HI 2457ENUMX 2458 BFD_RELOC_PPC_TPREL16_HA 2459ENUMX 2460 BFD_RELOC_PPC_TPREL 2461ENUMX 2462 BFD_RELOC_PPC_DTPREL16 2463ENUMX 2464 BFD_RELOC_PPC_DTPREL16_LO 2465ENUMX 2466 BFD_RELOC_PPC_DTPREL16_HI 2467ENUMX 2468 BFD_RELOC_PPC_DTPREL16_HA 2469ENUMX 2470 BFD_RELOC_PPC_DTPREL 2471ENUMX 2472 BFD_RELOC_PPC_GOT_TLSGD16 2473ENUMX 2474 BFD_RELOC_PPC_GOT_TLSGD16_LO 2475ENUMX 2476 BFD_RELOC_PPC_GOT_TLSGD16_HI 2477ENUMX 2478 BFD_RELOC_PPC_GOT_TLSGD16_HA 2479ENUMX 2480 BFD_RELOC_PPC_GOT_TLSLD16 2481ENUMX 2482 BFD_RELOC_PPC_GOT_TLSLD16_LO 2483ENUMX 2484 BFD_RELOC_PPC_GOT_TLSLD16_HI 2485ENUMX 2486 BFD_RELOC_PPC_GOT_TLSLD16_HA 2487ENUMX 2488 BFD_RELOC_PPC_GOT_TPREL16 2489ENUMX 2490 BFD_RELOC_PPC_GOT_TPREL16_LO 2491ENUMX 2492 BFD_RELOC_PPC_GOT_TPREL16_HI 2493ENUMX 2494 BFD_RELOC_PPC_GOT_TPREL16_HA 2495ENUMX 2496 BFD_RELOC_PPC_GOT_DTPREL16 2497ENUMX 2498 BFD_RELOC_PPC_GOT_DTPREL16_LO 2499ENUMX 2500 BFD_RELOC_PPC_GOT_DTPREL16_HI 2501ENUMX 2502 BFD_RELOC_PPC_GOT_DTPREL16_HA 2503ENUMX 2504 BFD_RELOC_PPC64_TPREL16_DS 2505ENUMX 2506 BFD_RELOC_PPC64_TPREL16_LO_DS 2507ENUMX 2508 BFD_RELOC_PPC64_TPREL16_HIGHER 2509ENUMX 2510 BFD_RELOC_PPC64_TPREL16_HIGHERA 2511ENUMX 2512 BFD_RELOC_PPC64_TPREL16_HIGHEST 2513ENUMX 2514 BFD_RELOC_PPC64_TPREL16_HIGHESTA 2515ENUMX 2516 BFD_RELOC_PPC64_DTPREL16_DS 2517ENUMX 2518 BFD_RELOC_PPC64_DTPREL16_LO_DS 2519ENUMX 2520 BFD_RELOC_PPC64_DTPREL16_HIGHER 2521ENUMX 2522 BFD_RELOC_PPC64_DTPREL16_HIGHERA 2523ENUMX 2524 BFD_RELOC_PPC64_DTPREL16_HIGHEST 2525ENUMX 2526 BFD_RELOC_PPC64_DTPREL16_HIGHESTA 2527ENUMDOC 2528 PowerPC and PowerPC64 thread-local storage relocations. 2529 2530ENUM 2531 BFD_RELOC_I370_D12 2532ENUMDOC 2533 IBM 370/390 relocations 2534 2535ENUM 2536 BFD_RELOC_CTOR 2537ENUMDOC 2538 The type of reloc used to build a constructor table - at the moment 2539 probably a 32 bit wide absolute relocation, but the target can choose. 2540 It generally does map to one of the other relocation types. 2541 2542ENUM 2543 BFD_RELOC_ARM_PCREL_BRANCH 2544ENUMDOC 2545 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are 2546 not stored in the instruction. 2547ENUM 2548 BFD_RELOC_ARM_PCREL_BLX 2549ENUMDOC 2550 ARM 26 bit pc-relative branch. The lowest bit must be zero and is 2551 not stored in the instruction. The 2nd lowest bit comes from a 1 bit 2552 field in the instruction. 2553ENUM 2554 BFD_RELOC_THUMB_PCREL_BLX 2555ENUMDOC 2556 Thumb 22 bit pc-relative branch. The lowest bit must be zero and is 2557 not stored in the instruction. The 2nd lowest bit comes from a 1 bit 2558 field in the instruction. 2559ENUM 2560 BFD_RELOC_ARM_IMMEDIATE 2561ENUMX 2562 BFD_RELOC_ARM_ADRL_IMMEDIATE 2563ENUMX 2564 BFD_RELOC_ARM_OFFSET_IMM 2565ENUMX 2566 BFD_RELOC_ARM_SHIFT_IMM 2567ENUMX 2568 BFD_RELOC_ARM_SWI 2569ENUMX 2570 BFD_RELOC_ARM_MULTI 2571ENUMX 2572 BFD_RELOC_ARM_CP_OFF_IMM 2573ENUMX 2574 BFD_RELOC_ARM_CP_OFF_IMM_S2 2575ENUMX 2576 BFD_RELOC_ARM_ADR_IMM 2577ENUMX 2578 BFD_RELOC_ARM_LDR_IMM 2579ENUMX 2580 BFD_RELOC_ARM_LITERAL 2581ENUMX 2582 BFD_RELOC_ARM_IN_POOL 2583ENUMX 2584 BFD_RELOC_ARM_OFFSET_IMM8 2585ENUMX 2586 BFD_RELOC_ARM_HWLITERAL 2587ENUMX 2588 BFD_RELOC_ARM_THUMB_ADD 2589ENUMX 2590 BFD_RELOC_ARM_THUMB_IMM 2591ENUMX 2592 BFD_RELOC_ARM_THUMB_SHIFT 2593ENUMX 2594 BFD_RELOC_ARM_THUMB_OFFSET 2595ENUMX 2596 BFD_RELOC_ARM_GOT12 2597ENUMX 2598 BFD_RELOC_ARM_GOT32 2599ENUMX 2600 BFD_RELOC_ARM_JUMP_SLOT 2601ENUMX 2602 BFD_RELOC_ARM_COPY 2603ENUMX 2604 BFD_RELOC_ARM_GLOB_DAT 2605ENUMX 2606 BFD_RELOC_ARM_PLT32 2607ENUMX 2608 BFD_RELOC_ARM_RELATIVE 2609ENUMX 2610 BFD_RELOC_ARM_GOTOFF 2611ENUMX 2612 BFD_RELOC_ARM_GOTPC 2613ENUMDOC 2614 These relocs are only used within the ARM assembler. They are not 2615 (at present) written to any object files. 2616 2617ENUM 2618 BFD_RELOC_SH_PCDISP8BY2 2619ENUMX 2620 BFD_RELOC_SH_PCDISP12BY2 2621ENUMX 2622 BFD_RELOC_SH_IMM4 2623ENUMX 2624 BFD_RELOC_SH_IMM4BY2 2625ENUMX 2626 BFD_RELOC_SH_IMM4BY4 2627ENUMX 2628 BFD_RELOC_SH_IMM8 2629ENUMX 2630 BFD_RELOC_SH_IMM8BY2 2631ENUMX 2632 BFD_RELOC_SH_IMM8BY4 2633ENUMX 2634 BFD_RELOC_SH_PCRELIMM8BY2 2635ENUMX 2636 BFD_RELOC_SH_PCRELIMM8BY4 2637ENUMX 2638 BFD_RELOC_SH_SWITCH16 2639ENUMX 2640 BFD_RELOC_SH_SWITCH32 2641ENUMX 2642 BFD_RELOC_SH_USES 2643ENUMX 2644 BFD_RELOC_SH_COUNT 2645ENUMX 2646 BFD_RELOC_SH_ALIGN 2647ENUMX 2648 BFD_RELOC_SH_CODE 2649ENUMX 2650 BFD_RELOC_SH_DATA 2651ENUMX 2652 BFD_RELOC_SH_LABEL 2653ENUMX 2654 BFD_RELOC_SH_LOOP_START 2655ENUMX 2656 BFD_RELOC_SH_LOOP_END 2657ENUMX 2658 BFD_RELOC_SH_COPY 2659ENUMX 2660 BFD_RELOC_SH_GLOB_DAT 2661ENUMX 2662 BFD_RELOC_SH_JMP_SLOT 2663ENUMX 2664 BFD_RELOC_SH_RELATIVE 2665ENUMX 2666 BFD_RELOC_SH_GOTPC 2667ENUMX 2668 BFD_RELOC_SH_GOT_LOW16 2669ENUMX 2670 BFD_RELOC_SH_GOT_MEDLOW16 2671ENUMX 2672 BFD_RELOC_SH_GOT_MEDHI16 2673ENUMX 2674 BFD_RELOC_SH_GOT_HI16 2675ENUMX 2676 BFD_RELOC_SH_GOTPLT_LOW16 2677ENUMX 2678 BFD_RELOC_SH_GOTPLT_MEDLOW16 2679ENUMX 2680 BFD_RELOC_SH_GOTPLT_MEDHI16 2681ENUMX 2682 BFD_RELOC_SH_GOTPLT_HI16 2683ENUMX 2684 BFD_RELOC_SH_PLT_LOW16 2685ENUMX 2686 BFD_RELOC_SH_PLT_MEDLOW16 2687ENUMX 2688 BFD_RELOC_SH_PLT_MEDHI16 2689ENUMX 2690 BFD_RELOC_SH_PLT_HI16 2691ENUMX 2692 BFD_RELOC_SH_GOTOFF_LOW16 2693ENUMX 2694 BFD_RELOC_SH_GOTOFF_MEDLOW16 2695ENUMX 2696 BFD_RELOC_SH_GOTOFF_MEDHI16 2697ENUMX 2698 BFD_RELOC_SH_GOTOFF_HI16 2699ENUMX 2700 BFD_RELOC_SH_GOTPC_LOW16 2701ENUMX 2702 BFD_RELOC_SH_GOTPC_MEDLOW16 2703ENUMX 2704 BFD_RELOC_SH_GOTPC_MEDHI16 2705ENUMX 2706 BFD_RELOC_SH_GOTPC_HI16 2707ENUMX 2708 BFD_RELOC_SH_COPY64 2709ENUMX 2710 BFD_RELOC_SH_GLOB_DAT64 2711ENUMX 2712 BFD_RELOC_SH_JMP_SLOT64 2713ENUMX 2714 BFD_RELOC_SH_RELATIVE64 2715ENUMX 2716 BFD_RELOC_SH_GOT10BY4 2717ENUMX 2718 BFD_RELOC_SH_GOT10BY8 2719ENUMX 2720 BFD_RELOC_SH_GOTPLT10BY4 2721ENUMX 2722 BFD_RELOC_SH_GOTPLT10BY8 2723ENUMX 2724 BFD_RELOC_SH_GOTPLT32 2725ENUMX 2726 BFD_RELOC_SH_SHMEDIA_CODE 2727ENUMX 2728 BFD_RELOC_SH_IMMU5 2729ENUMX 2730 BFD_RELOC_SH_IMMS6 2731ENUMX 2732 BFD_RELOC_SH_IMMS6BY32 2733ENUMX 2734 BFD_RELOC_SH_IMMU6 2735ENUMX 2736 BFD_RELOC_SH_IMMS10 2737ENUMX 2738 BFD_RELOC_SH_IMMS10BY2 2739ENUMX 2740 BFD_RELOC_SH_IMMS10BY4 2741ENUMX 2742 BFD_RELOC_SH_IMMS10BY8 2743ENUMX 2744 BFD_RELOC_SH_IMMS16 2745ENUMX 2746 BFD_RELOC_SH_IMMU16 2747ENUMX 2748 BFD_RELOC_SH_IMM_LOW16 2749ENUMX 2750 BFD_RELOC_SH_IMM_LOW16_PCREL 2751ENUMX 2752 BFD_RELOC_SH_IMM_MEDLOW16 2753ENUMX 2754 BFD_RELOC_SH_IMM_MEDLOW16_PCREL 2755ENUMX 2756 BFD_RELOC_SH_IMM_MEDHI16 2757ENUMX 2758 BFD_RELOC_SH_IMM_MEDHI16_PCREL 2759ENUMX 2760 BFD_RELOC_SH_IMM_HI16 2761ENUMX 2762 BFD_RELOC_SH_IMM_HI16_PCREL 2763ENUMX 2764 BFD_RELOC_SH_PT_16 2765ENUMX 2766 BFD_RELOC_SH_TLS_GD_32 2767ENUMX 2768 BFD_RELOC_SH_TLS_LD_32 2769ENUMX 2770 BFD_RELOC_SH_TLS_LDO_32 2771ENUMX 2772 BFD_RELOC_SH_TLS_IE_32 2773ENUMX 2774 BFD_RELOC_SH_TLS_LE_32 2775ENUMX 2776 BFD_RELOC_SH_TLS_DTPMOD32 2777ENUMX 2778 BFD_RELOC_SH_TLS_DTPOFF32 2779ENUMX 2780 BFD_RELOC_SH_TLS_TPOFF32 2781ENUMDOC 2782 Renesas / SuperH SH relocs. Not all of these appear in object files. 2783 2784ENUM 2785 BFD_RELOC_THUMB_PCREL_BRANCH9 2786ENUMX 2787 BFD_RELOC_THUMB_PCREL_BRANCH12 2788ENUMX 2789 BFD_RELOC_THUMB_PCREL_BRANCH23 2790ENUMDOC 2791 Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must 2792 be zero and is not stored in the instruction. 2793 2794ENUM 2795 BFD_RELOC_ARC_B22_PCREL 2796ENUMDOC 2797 ARC Cores relocs. 2798 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are 2799 not stored in the instruction. The high 20 bits are installed in bits 26 2800 through 7 of the instruction. 2801ENUM 2802 BFD_RELOC_ARC_B26 2803ENUMDOC 2804 ARC 26 bit absolute branch. The lowest two bits must be zero and are not 2805 stored in the instruction. The high 24 bits are installed in bits 23 2806 through 0. 2807 2808ENUM 2809 BFD_RELOC_D10V_10_PCREL_R 2810ENUMDOC 2811 Mitsubishi D10V relocs. 2812 This is a 10-bit reloc with the right 2 bits 2813 assumed to be 0. 2814ENUM 2815 BFD_RELOC_D10V_10_PCREL_L 2816ENUMDOC 2817 Mitsubishi D10V relocs. 2818 This is a 10-bit reloc with the right 2 bits 2819 assumed to be 0. This is the same as the previous reloc 2820 except it is in the left container, i.e., 2821 shifted left 15 bits. 2822ENUM 2823 BFD_RELOC_D10V_18 2824ENUMDOC 2825 This is an 18-bit reloc with the right 2 bits 2826 assumed to be 0. 2827ENUM 2828 BFD_RELOC_D10V_18_PCREL 2829ENUMDOC 2830 This is an 18-bit reloc with the right 2 bits 2831 assumed to be 0. 2832 2833ENUM 2834 BFD_RELOC_D30V_6 2835ENUMDOC 2836 Mitsubishi D30V relocs. 2837 This is a 6-bit absolute reloc. 2838ENUM 2839 BFD_RELOC_D30V_9_PCREL 2840ENUMDOC 2841 This is a 6-bit pc-relative reloc with 2842 the right 3 bits assumed to be 0. 2843ENUM 2844 BFD_RELOC_D30V_9_PCREL_R 2845ENUMDOC 2846 This is a 6-bit pc-relative reloc with 2847 the right 3 bits assumed to be 0. Same 2848 as the previous reloc but on the right side 2849 of the container. 2850ENUM 2851 BFD_RELOC_D30V_15 2852ENUMDOC 2853 This is a 12-bit absolute reloc with the 2854 right 3 bitsassumed to be 0. 2855ENUM 2856 BFD_RELOC_D30V_15_PCREL 2857ENUMDOC 2858 This is a 12-bit pc-relative reloc with 2859 the right 3 bits assumed to be 0. 2860ENUM 2861 BFD_RELOC_D30V_15_PCREL_R 2862ENUMDOC 2863 This is a 12-bit pc-relative reloc with 2864 the right 3 bits assumed to be 0. Same 2865 as the previous reloc but on the right side 2866 of the container. 2867ENUM 2868 BFD_RELOC_D30V_21 2869ENUMDOC 2870 This is an 18-bit absolute reloc with 2871 the right 3 bits assumed to be 0. 2872ENUM 2873 BFD_RELOC_D30V_21_PCREL 2874ENUMDOC 2875 This is an 18-bit pc-relative reloc with 2876 the right 3 bits assumed to be 0. 2877ENUM 2878 BFD_RELOC_D30V_21_PCREL_R 2879ENUMDOC 2880 This is an 18-bit pc-relative reloc with 2881 the right 3 bits assumed to be 0. Same 2882 as the previous reloc but on the right side 2883 of the container. 2884ENUM 2885 BFD_RELOC_D30V_32 2886ENUMDOC 2887 This is a 32-bit absolute reloc. 2888ENUM 2889 BFD_RELOC_D30V_32_PCREL 2890ENUMDOC 2891 This is a 32-bit pc-relative reloc. 2892 2893ENUM 2894 BFD_RELOC_DLX_HI16_S 2895ENUMDOC 2896 DLX relocs 2897ENUM 2898 BFD_RELOC_DLX_LO16 2899ENUMDOC 2900 DLX relocs 2901ENUM 2902 BFD_RELOC_DLX_JMP26 2903ENUMDOC 2904 DLX relocs 2905 2906ENUM 2907 BFD_RELOC_M32R_24 2908ENUMDOC 2909 Renesas M32R (formerly Mitsubishi M32R) relocs. 2910 This is a 24 bit absolute address. 2911ENUM 2912 BFD_RELOC_M32R_10_PCREL 2913ENUMDOC 2914 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. 2915ENUM 2916 BFD_RELOC_M32R_18_PCREL 2917ENUMDOC 2918 This is an 18-bit reloc with the right 2 bits assumed to be 0. 2919ENUM 2920 BFD_RELOC_M32R_26_PCREL 2921ENUMDOC 2922 This is a 26-bit reloc with the right 2 bits assumed to be 0. 2923ENUM 2924 BFD_RELOC_M32R_HI16_ULO 2925ENUMDOC 2926 This is a 16-bit reloc containing the high 16 bits of an address 2927 used when the lower 16 bits are treated as unsigned. 2928ENUM 2929 BFD_RELOC_M32R_HI16_SLO 2930ENUMDOC 2931 This is a 16-bit reloc containing the high 16 bits of an address 2932 used when the lower 16 bits are treated as signed. 2933ENUM 2934 BFD_RELOC_M32R_LO16 2935ENUMDOC 2936 This is a 16-bit reloc containing the lower 16 bits of an address. 2937ENUM 2938 BFD_RELOC_M32R_SDA16 2939ENUMDOC 2940 This is a 16-bit reloc containing the small data area offset for use in 2941 add3, load, and store instructions. 2942ENUM 2943 BFD_RELOC_M32R_GOT24 2944ENUMX 2945 BFD_RELOC_M32R_26_PLTREL 2946ENUMX 2947 BFD_RELOC_M32R_COPY 2948ENUMX 2949 BFD_RELOC_M32R_GLOB_DAT 2950ENUMX 2951 BFD_RELOC_M32R_JMP_SLOT 2952ENUMX 2953 BFD_RELOC_M32R_RELATIVE 2954ENUMX 2955 BFD_RELOC_M32R_GOTOFF 2956ENUMX 2957 BFD_RELOC_M32R_GOTPC24 2958ENUMX 2959 BFD_RELOC_M32R_GOT16_HI_ULO 2960ENUMX 2961 BFD_RELOC_M32R_GOT16_HI_SLO 2962ENUMX 2963 BFD_RELOC_M32R_GOT16_LO 2964ENUMX 2965 BFD_RELOC_M32R_GOTPC_HI_ULO 2966ENUMX 2967 BFD_RELOC_M32R_GOTPC_HI_SLO 2968ENUMX 2969 BFD_RELOC_M32R_GOTPC_LO 2970ENUMDOC 2971 For PIC. 2972 2973 2974ENUM 2975 BFD_RELOC_V850_9_PCREL 2976ENUMDOC 2977 This is a 9-bit reloc 2978ENUM 2979 BFD_RELOC_V850_22_PCREL 2980ENUMDOC 2981 This is a 22-bit reloc 2982 2983ENUM 2984 BFD_RELOC_V850_SDA_16_16_OFFSET 2985ENUMDOC 2986 This is a 16 bit offset from the short data area pointer. 2987ENUM 2988 BFD_RELOC_V850_SDA_15_16_OFFSET 2989ENUMDOC 2990 This is a 16 bit offset (of which only 15 bits are used) from the 2991 short data area pointer. 2992ENUM 2993 BFD_RELOC_V850_ZDA_16_16_OFFSET 2994ENUMDOC 2995 This is a 16 bit offset from the zero data area pointer. 2996ENUM 2997 BFD_RELOC_V850_ZDA_15_16_OFFSET 2998ENUMDOC 2999 This is a 16 bit offset (of which only 15 bits are used) from the 3000 zero data area pointer. 3001ENUM 3002 BFD_RELOC_V850_TDA_6_8_OFFSET 3003ENUMDOC 3004 This is an 8 bit offset (of which only 6 bits are used) from the 3005 tiny data area pointer. 3006ENUM 3007 BFD_RELOC_V850_TDA_7_8_OFFSET 3008ENUMDOC 3009 This is an 8bit offset (of which only 7 bits are used) from the tiny 3010 data area pointer. 3011ENUM 3012 BFD_RELOC_V850_TDA_7_7_OFFSET 3013ENUMDOC 3014 This is a 7 bit offset from the tiny data area pointer. 3015ENUM 3016 BFD_RELOC_V850_TDA_16_16_OFFSET 3017ENUMDOC 3018 This is a 16 bit offset from the tiny data area pointer. 3019COMMENT 3020ENUM 3021 BFD_RELOC_V850_TDA_4_5_OFFSET 3022ENUMDOC 3023 This is a 5 bit offset (of which only 4 bits are used) from the tiny 3024 data area pointer. 3025ENUM 3026 BFD_RELOC_V850_TDA_4_4_OFFSET 3027ENUMDOC 3028 This is a 4 bit offset from the tiny data area pointer. 3029ENUM 3030 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET 3031ENUMDOC 3032 This is a 16 bit offset from the short data area pointer, with the 3033 bits placed non-contiguously in the instruction. 3034ENUM 3035 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET 3036ENUMDOC 3037 This is a 16 bit offset from the zero data area pointer, with the 3038 bits placed non-contiguously in the instruction. 3039ENUM 3040 BFD_RELOC_V850_CALLT_6_7_OFFSET 3041ENUMDOC 3042 This is a 6 bit offset from the call table base pointer. 3043ENUM 3044 BFD_RELOC_V850_CALLT_16_16_OFFSET 3045ENUMDOC 3046 This is a 16 bit offset from the call table base pointer. 3047ENUM 3048 BFD_RELOC_V850_LONGCALL 3049ENUMDOC 3050 Used for relaxing indirect function calls. 3051ENUM 3052 BFD_RELOC_V850_LONGJUMP 3053ENUMDOC 3054 Used for relaxing indirect jumps. 3055ENUM 3056 BFD_RELOC_V850_ALIGN 3057ENUMDOC 3058 Used to maintain alignment whilst relaxing. 3059ENUM 3060 BFD_RELOC_MN10300_32_PCREL 3061ENUMDOC 3062 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the 3063 instruction. 3064ENUM 3065 BFD_RELOC_MN10300_16_PCREL 3066ENUMDOC 3067 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the 3068 instruction. 3069 3070ENUM 3071 BFD_RELOC_TIC30_LDP 3072ENUMDOC 3073 This is a 8bit DP reloc for the tms320c30, where the most 3074 significant 8 bits of a 24 bit word are placed into the least 3075 significant 8 bits of the opcode. 3076 3077ENUM 3078 BFD_RELOC_TIC54X_PARTLS7 3079ENUMDOC 3080 This is a 7bit reloc for the tms320c54x, where the least 3081 significant 7 bits of a 16 bit word are placed into the least 3082 significant 7 bits of the opcode. 3083 3084ENUM 3085 BFD_RELOC_TIC54X_PARTMS9 3086ENUMDOC 3087 This is a 9bit DP reloc for the tms320c54x, where the most 3088 significant 9 bits of a 16 bit word are placed into the least 3089 significant 9 bits of the opcode. 3090 3091ENUM 3092 BFD_RELOC_TIC54X_23 3093ENUMDOC 3094 This is an extended address 23-bit reloc for the tms320c54x. 3095 3096ENUM 3097 BFD_RELOC_TIC54X_16_OF_23 3098ENUMDOC 3099 This is a 16-bit reloc for the tms320c54x, where the least 3100 significant 16 bits of a 23-bit extended address are placed into 3101 the opcode. 3102 3103ENUM 3104 BFD_RELOC_TIC54X_MS7_OF_23 3105ENUMDOC 3106 This is a reloc for the tms320c54x, where the most 3107 significant 7 bits of a 23-bit extended address are placed into 3108 the opcode. 3109 3110ENUM 3111 BFD_RELOC_FR30_48 3112ENUMDOC 3113 This is a 48 bit reloc for the FR30 that stores 32 bits. 3114ENUM 3115 BFD_RELOC_FR30_20 3116ENUMDOC 3117 This is a 32 bit reloc for the FR30 that stores 20 bits split up into 3118 two sections. 3119ENUM 3120 BFD_RELOC_FR30_6_IN_4 3121ENUMDOC 3122 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in 3123 4 bits. 3124ENUM 3125 BFD_RELOC_FR30_8_IN_8 3126ENUMDOC 3127 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset 3128 into 8 bits. 3129ENUM 3130 BFD_RELOC_FR30_9_IN_8 3131ENUMDOC 3132 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset 3133 into 8 bits. 3134ENUM 3135 BFD_RELOC_FR30_10_IN_8 3136ENUMDOC 3137 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset 3138 into 8 bits. 3139ENUM 3140 BFD_RELOC_FR30_9_PCREL 3141ENUMDOC 3142 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative 3143 short offset into 8 bits. 3144ENUM 3145 BFD_RELOC_FR30_12_PCREL 3146ENUMDOC 3147 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative 3148 short offset into 11 bits. 3149 3150ENUM 3151 BFD_RELOC_MCORE_PCREL_IMM8BY4 3152ENUMX 3153 BFD_RELOC_MCORE_PCREL_IMM11BY2 3154ENUMX 3155 BFD_RELOC_MCORE_PCREL_IMM4BY2 3156ENUMX 3157 BFD_RELOC_MCORE_PCREL_32 3158ENUMX 3159 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2 3160ENUMX 3161 BFD_RELOC_MCORE_RVA 3162ENUMDOC 3163 Motorola Mcore relocations. 3164 3165ENUM 3166 BFD_RELOC_MMIX_GETA 3167ENUMX 3168 BFD_RELOC_MMIX_GETA_1 3169ENUMX 3170 BFD_RELOC_MMIX_GETA_2 3171ENUMX 3172 BFD_RELOC_MMIX_GETA_3 3173ENUMDOC 3174 These are relocations for the GETA instruction. 3175ENUM 3176 BFD_RELOC_MMIX_CBRANCH 3177ENUMX 3178 BFD_RELOC_MMIX_CBRANCH_J 3179ENUMX 3180 BFD_RELOC_MMIX_CBRANCH_1 3181ENUMX 3182 BFD_RELOC_MMIX_CBRANCH_2 3183ENUMX 3184 BFD_RELOC_MMIX_CBRANCH_3 3185ENUMDOC 3186 These are relocations for a conditional branch instruction. 3187ENUM 3188 BFD_RELOC_MMIX_PUSHJ 3189ENUMX 3190 BFD_RELOC_MMIX_PUSHJ_1 3191ENUMX 3192 BFD_RELOC_MMIX_PUSHJ_2 3193ENUMX 3194 BFD_RELOC_MMIX_PUSHJ_3 3195ENUMX 3196 BFD_RELOC_MMIX_PUSHJ_STUBBABLE 3197ENUMDOC 3198 These are relocations for the PUSHJ instruction. 3199ENUM 3200 BFD_RELOC_MMIX_JMP 3201ENUMX 3202 BFD_RELOC_MMIX_JMP_1 3203ENUMX 3204 BFD_RELOC_MMIX_JMP_2 3205ENUMX 3206 BFD_RELOC_MMIX_JMP_3 3207ENUMDOC 3208 These are relocations for the JMP instruction. 3209ENUM 3210 BFD_RELOC_MMIX_ADDR19 3211ENUMDOC 3212 This is a relocation for a relative address as in a GETA instruction or 3213 a branch. 3214ENUM 3215 BFD_RELOC_MMIX_ADDR27 3216ENUMDOC 3217 This is a relocation for a relative address as in a JMP instruction. 3218ENUM 3219 BFD_RELOC_MMIX_REG_OR_BYTE 3220ENUMDOC 3221 This is a relocation for an instruction field that may be a general 3222 register or a value 0..255. 3223ENUM 3224 BFD_RELOC_MMIX_REG 3225ENUMDOC 3226 This is a relocation for an instruction field that may be a general 3227 register. 3228ENUM 3229 BFD_RELOC_MMIX_BASE_PLUS_OFFSET 3230ENUMDOC 3231 This is a relocation for two instruction fields holding a register and 3232 an offset, the equivalent of the relocation. 3233ENUM 3234 BFD_RELOC_MMIX_LOCAL 3235ENUMDOC 3236 This relocation is an assertion that the expression is not allocated as 3237 a global register. It does not modify contents. 3238 3239ENUM 3240 BFD_RELOC_AVR_7_PCREL 3241ENUMDOC 3242 This is a 16 bit reloc for the AVR that stores 8 bit pc relative 3243 short offset into 7 bits. 3244ENUM 3245 BFD_RELOC_AVR_13_PCREL 3246ENUMDOC 3247 This is a 16 bit reloc for the AVR that stores 13 bit pc relative 3248 short offset into 12 bits. 3249ENUM 3250 BFD_RELOC_AVR_16_PM 3251ENUMDOC 3252 This is a 16 bit reloc for the AVR that stores 17 bit value (usually 3253 program memory address) into 16 bits. 3254ENUM 3255 BFD_RELOC_AVR_LO8_LDI 3256ENUMDOC 3257 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 3258 data memory address) into 8 bit immediate value of LDI insn. 3259ENUM 3260 BFD_RELOC_AVR_HI8_LDI 3261ENUMDOC 3262 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 3263 of data memory address) into 8 bit immediate value of LDI insn. 3264ENUM 3265 BFD_RELOC_AVR_HH8_LDI 3266ENUMDOC 3267 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 3268 of program memory address) into 8 bit immediate value of LDI insn. 3269ENUM 3270 BFD_RELOC_AVR_LO8_LDI_NEG 3271ENUMDOC 3272 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3273 (usually data memory address) into 8 bit immediate value of SUBI insn. 3274ENUM 3275 BFD_RELOC_AVR_HI8_LDI_NEG 3276ENUMDOC 3277 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3278 (high 8 bit of data memory address) into 8 bit immediate value of 3279 SUBI insn. 3280ENUM 3281 BFD_RELOC_AVR_HH8_LDI_NEG 3282ENUMDOC 3283 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3284 (most high 8 bit of program memory address) into 8 bit immediate value 3285 of LDI or SUBI insn. 3286ENUM 3287 BFD_RELOC_AVR_LO8_LDI_PM 3288ENUMDOC 3289 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 3290 command address) into 8 bit immediate value of LDI insn. 3291ENUM 3292 BFD_RELOC_AVR_HI8_LDI_PM 3293ENUMDOC 3294 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 3295 of command address) into 8 bit immediate value of LDI insn. 3296ENUM 3297 BFD_RELOC_AVR_HH8_LDI_PM 3298ENUMDOC 3299 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 3300 of command address) into 8 bit immediate value of LDI insn. 3301ENUM 3302 BFD_RELOC_AVR_LO8_LDI_PM_NEG 3303ENUMDOC 3304 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3305 (usually command address) into 8 bit immediate value of SUBI insn. 3306ENUM 3307 BFD_RELOC_AVR_HI8_LDI_PM_NEG 3308ENUMDOC 3309 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3310 (high 8 bit of 16 bit command address) into 8 bit immediate value 3311 of SUBI insn. 3312ENUM 3313 BFD_RELOC_AVR_HH8_LDI_PM_NEG 3314ENUMDOC 3315 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3316 (high 6 bit of 22 bit command address) into 8 bit immediate 3317 value of SUBI insn. 3318ENUM 3319 BFD_RELOC_AVR_CALL 3320ENUMDOC 3321 This is a 32 bit reloc for the AVR that stores 23 bit value 3322 into 22 bits. 3323 3324ENUM 3325 BFD_RELOC_390_12 3326ENUMDOC 3327 Direct 12 bit. 3328ENUM 3329 BFD_RELOC_390_GOT12 3330ENUMDOC 3331 12 bit GOT offset. 3332ENUM 3333 BFD_RELOC_390_PLT32 3334ENUMDOC 3335 32 bit PC relative PLT address. 3336ENUM 3337 BFD_RELOC_390_COPY 3338ENUMDOC 3339 Copy symbol at runtime. 3340ENUM 3341 BFD_RELOC_390_GLOB_DAT 3342ENUMDOC 3343 Create GOT entry. 3344ENUM 3345 BFD_RELOC_390_JMP_SLOT 3346ENUMDOC 3347 Create PLT entry. 3348ENUM 3349 BFD_RELOC_390_RELATIVE 3350ENUMDOC 3351 Adjust by program base. 3352ENUM 3353 BFD_RELOC_390_GOTPC 3354ENUMDOC 3355 32 bit PC relative offset to GOT. 3356ENUM 3357 BFD_RELOC_390_GOT16 3358ENUMDOC 3359 16 bit GOT offset. 3360ENUM 3361 BFD_RELOC_390_PC16DBL 3362ENUMDOC 3363 PC relative 16 bit shifted by 1. 3364ENUM 3365 BFD_RELOC_390_PLT16DBL 3366ENUMDOC 3367 16 bit PC rel. PLT shifted by 1. 3368ENUM 3369 BFD_RELOC_390_PC32DBL 3370ENUMDOC 3371 PC relative 32 bit shifted by 1. 3372ENUM 3373 BFD_RELOC_390_PLT32DBL 3374ENUMDOC 3375 32 bit PC rel. PLT shifted by 1. 3376ENUM 3377 BFD_RELOC_390_GOTPCDBL 3378ENUMDOC 3379 32 bit PC rel. GOT shifted by 1. 3380ENUM 3381 BFD_RELOC_390_GOT64 3382ENUMDOC 3383 64 bit GOT offset. 3384ENUM 3385 BFD_RELOC_390_PLT64 3386ENUMDOC 3387 64 bit PC relative PLT address. 3388ENUM 3389 BFD_RELOC_390_GOTENT 3390ENUMDOC 3391 32 bit rel. offset to GOT entry. 3392ENUM 3393 BFD_RELOC_390_GOTOFF64 3394ENUMDOC 3395 64 bit offset to GOT. 3396ENUM 3397 BFD_RELOC_390_GOTPLT12 3398ENUMDOC 3399 12-bit offset to symbol-entry within GOT, with PLT handling. 3400ENUM 3401 BFD_RELOC_390_GOTPLT16 3402ENUMDOC 3403 16-bit offset to symbol-entry within GOT, with PLT handling. 3404ENUM 3405 BFD_RELOC_390_GOTPLT32 3406ENUMDOC 3407 32-bit offset to symbol-entry within GOT, with PLT handling. 3408ENUM 3409 BFD_RELOC_390_GOTPLT64 3410ENUMDOC 3411 64-bit offset to symbol-entry within GOT, with PLT handling. 3412ENUM 3413 BFD_RELOC_390_GOTPLTENT 3414ENUMDOC 3415 32-bit rel. offset to symbol-entry within GOT, with PLT handling. 3416ENUM 3417 BFD_RELOC_390_PLTOFF16 3418ENUMDOC 3419 16-bit rel. offset from the GOT to a PLT entry. 3420ENUM 3421 BFD_RELOC_390_PLTOFF32 3422ENUMDOC 3423 32-bit rel. offset from the GOT to a PLT entry. 3424ENUM 3425 BFD_RELOC_390_PLTOFF64 3426ENUMDOC 3427 64-bit rel. offset from the GOT to a PLT entry. 3428 3429ENUM 3430 BFD_RELOC_390_TLS_LOAD 3431ENUMX 3432 BFD_RELOC_390_TLS_GDCALL 3433ENUMX 3434 BFD_RELOC_390_TLS_LDCALL 3435ENUMX 3436 BFD_RELOC_390_TLS_GD32 3437ENUMX 3438 BFD_RELOC_390_TLS_GD64 3439ENUMX 3440 BFD_RELOC_390_TLS_GOTIE12 3441ENUMX 3442 BFD_RELOC_390_TLS_GOTIE32 3443ENUMX 3444 BFD_RELOC_390_TLS_GOTIE64 3445ENUMX 3446 BFD_RELOC_390_TLS_LDM32 3447ENUMX 3448 BFD_RELOC_390_TLS_LDM64 3449ENUMX 3450 BFD_RELOC_390_TLS_IE32 3451ENUMX 3452 BFD_RELOC_390_TLS_IE64 3453ENUMX 3454 BFD_RELOC_390_TLS_IEENT 3455ENUMX 3456 BFD_RELOC_390_TLS_LE32 3457ENUMX 3458 BFD_RELOC_390_TLS_LE64 3459ENUMX 3460 BFD_RELOC_390_TLS_LDO32 3461ENUMX 3462 BFD_RELOC_390_TLS_LDO64 3463ENUMX 3464 BFD_RELOC_390_TLS_DTPMOD 3465ENUMX 3466 BFD_RELOC_390_TLS_DTPOFF 3467ENUMX 3468 BFD_RELOC_390_TLS_TPOFF 3469ENUMDOC 3470 s390 tls relocations. 3471 3472ENUM 3473 BFD_RELOC_390_20 3474ENUMX 3475 BFD_RELOC_390_GOT20 3476ENUMX 3477 BFD_RELOC_390_GOTPLT20 3478ENUMX 3479 BFD_RELOC_390_TLS_GOTIE20 3480ENUMDOC 3481 Long displacement extension. 3482 3483ENUM 3484 BFD_RELOC_IP2K_FR9 3485ENUMDOC 3486 Scenix IP2K - 9-bit register number / data address 3487ENUM 3488 BFD_RELOC_IP2K_BANK 3489ENUMDOC 3490 Scenix IP2K - 4-bit register/data bank number 3491ENUM 3492 BFD_RELOC_IP2K_ADDR16CJP 3493ENUMDOC 3494 Scenix IP2K - low 13 bits of instruction word address 3495ENUM 3496 BFD_RELOC_IP2K_PAGE3 3497ENUMDOC 3498 Scenix IP2K - high 3 bits of instruction word address 3499ENUM 3500 BFD_RELOC_IP2K_LO8DATA 3501ENUMX 3502 BFD_RELOC_IP2K_HI8DATA 3503ENUMX 3504 BFD_RELOC_IP2K_EX8DATA 3505ENUMDOC 3506 Scenix IP2K - ext/low/high 8 bits of data address 3507ENUM 3508 BFD_RELOC_IP2K_LO8INSN 3509ENUMX 3510 BFD_RELOC_IP2K_HI8INSN 3511ENUMDOC 3512 Scenix IP2K - low/high 8 bits of instruction word address 3513ENUM 3514 BFD_RELOC_IP2K_PC_SKIP 3515ENUMDOC 3516 Scenix IP2K - even/odd PC modifier to modify snb pcl.0 3517ENUM 3518 BFD_RELOC_IP2K_TEXT 3519ENUMDOC 3520 Scenix IP2K - 16 bit word address in text section. 3521ENUM 3522 BFD_RELOC_IP2K_FR_OFFSET 3523ENUMDOC 3524 Scenix IP2K - 7-bit sp or dp offset 3525ENUM 3526 BFD_RELOC_VPE4KMATH_DATA 3527ENUMX 3528 BFD_RELOC_VPE4KMATH_INSN 3529ENUMDOC 3530 Scenix VPE4K coprocessor - data/insn-space addressing 3531 3532ENUM 3533 BFD_RELOC_VTABLE_INHERIT 3534ENUMX 3535 BFD_RELOC_VTABLE_ENTRY 3536ENUMDOC 3537 These two relocations are used by the linker to determine which of 3538 the entries in a C++ virtual function table are actually used. When 3539 the --gc-sections option is given, the linker will zero out the entries 3540 that are not used, so that the code for those functions need not be 3541 included in the output. 3542 3543 VTABLE_INHERIT is a zero-space relocation used to describe to the 3544 linker the inheritance tree of a C++ virtual function table. The 3545 relocation's symbol should be the parent class' vtable, and the 3546 relocation should be located at the child vtable. 3547 3548 VTABLE_ENTRY is a zero-space relocation that describes the use of a 3549 virtual function table entry. The reloc's symbol should refer to the 3550 table of the class mentioned in the code. Off of that base, an offset 3551 describes the entry that is being used. For Rela hosts, this offset 3552 is stored in the reloc's addend. For Rel hosts, we are forced to put 3553 this offset in the reloc's section offset. 3554 3555ENUM 3556 BFD_RELOC_IA64_IMM14 3557ENUMX 3558 BFD_RELOC_IA64_IMM22 3559ENUMX 3560 BFD_RELOC_IA64_IMM64 3561ENUMX 3562 BFD_RELOC_IA64_DIR32MSB 3563ENUMX 3564 BFD_RELOC_IA64_DIR32LSB 3565ENUMX 3566 BFD_RELOC_IA64_DIR64MSB 3567ENUMX 3568 BFD_RELOC_IA64_DIR64LSB 3569ENUMX 3570 BFD_RELOC_IA64_GPREL22 3571ENUMX 3572 BFD_RELOC_IA64_GPREL64I 3573ENUMX 3574 BFD_RELOC_IA64_GPREL32MSB 3575ENUMX 3576 BFD_RELOC_IA64_GPREL32LSB 3577ENUMX 3578 BFD_RELOC_IA64_GPREL64MSB 3579ENUMX 3580 BFD_RELOC_IA64_GPREL64LSB 3581ENUMX 3582 BFD_RELOC_IA64_LTOFF22 3583ENUMX 3584 BFD_RELOC_IA64_LTOFF64I 3585ENUMX 3586 BFD_RELOC_IA64_PLTOFF22 3587ENUMX 3588 BFD_RELOC_IA64_PLTOFF64I 3589ENUMX 3590 BFD_RELOC_IA64_PLTOFF64MSB 3591ENUMX 3592 BFD_RELOC_IA64_PLTOFF64LSB 3593ENUMX 3594 BFD_RELOC_IA64_FPTR64I 3595ENUMX 3596 BFD_RELOC_IA64_FPTR32MSB 3597ENUMX 3598 BFD_RELOC_IA64_FPTR32LSB 3599ENUMX 3600 BFD_RELOC_IA64_FPTR64MSB 3601ENUMX 3602 BFD_RELOC_IA64_FPTR64LSB 3603ENUMX 3604 BFD_RELOC_IA64_PCREL21B 3605ENUMX 3606 BFD_RELOC_IA64_PCREL21BI 3607ENUMX 3608 BFD_RELOC_IA64_PCREL21M 3609ENUMX 3610 BFD_RELOC_IA64_PCREL21F 3611ENUMX 3612 BFD_RELOC_IA64_PCREL22 3613ENUMX 3614 BFD_RELOC_IA64_PCREL60B 3615ENUMX 3616 BFD_RELOC_IA64_PCREL64I 3617ENUMX 3618 BFD_RELOC_IA64_PCREL32MSB 3619ENUMX 3620 BFD_RELOC_IA64_PCREL32LSB 3621ENUMX 3622 BFD_RELOC_IA64_PCREL64MSB 3623ENUMX 3624 BFD_RELOC_IA64_PCREL64LSB 3625ENUMX 3626 BFD_RELOC_IA64_LTOFF_FPTR22 3627ENUMX 3628 BFD_RELOC_IA64_LTOFF_FPTR64I 3629ENUMX 3630 BFD_RELOC_IA64_LTOFF_FPTR32MSB 3631ENUMX 3632 BFD_RELOC_IA64_LTOFF_FPTR32LSB 3633ENUMX 3634 BFD_RELOC_IA64_LTOFF_FPTR64MSB 3635ENUMX 3636 BFD_RELOC_IA64_LTOFF_FPTR64LSB 3637ENUMX 3638 BFD_RELOC_IA64_SEGREL32MSB 3639ENUMX 3640 BFD_RELOC_IA64_SEGREL32LSB 3641ENUMX 3642 BFD_RELOC_IA64_SEGREL64MSB 3643ENUMX 3644 BFD_RELOC_IA64_SEGREL64LSB 3645ENUMX 3646 BFD_RELOC_IA64_SECREL32MSB 3647ENUMX 3648 BFD_RELOC_IA64_SECREL32LSB 3649ENUMX 3650 BFD_RELOC_IA64_SECREL64MSB 3651ENUMX 3652 BFD_RELOC_IA64_SECREL64LSB 3653ENUMX 3654 BFD_RELOC_IA64_REL32MSB 3655ENUMX 3656 BFD_RELOC_IA64_REL32LSB 3657ENUMX 3658 BFD_RELOC_IA64_REL64MSB 3659ENUMX 3660 BFD_RELOC_IA64_REL64LSB 3661ENUMX 3662 BFD_RELOC_IA64_LTV32MSB 3663ENUMX 3664 BFD_RELOC_IA64_LTV32LSB 3665ENUMX 3666 BFD_RELOC_IA64_LTV64MSB 3667ENUMX 3668 BFD_RELOC_IA64_LTV64LSB 3669ENUMX 3670 BFD_RELOC_IA64_IPLTMSB 3671ENUMX 3672 BFD_RELOC_IA64_IPLTLSB 3673ENUMX 3674 BFD_RELOC_IA64_COPY 3675ENUMX 3676 BFD_RELOC_IA64_LTOFF22X 3677ENUMX 3678 BFD_RELOC_IA64_LDXMOV 3679ENUMX 3680 BFD_RELOC_IA64_TPREL14 3681ENUMX 3682 BFD_RELOC_IA64_TPREL22 3683ENUMX 3684 BFD_RELOC_IA64_TPREL64I 3685ENUMX 3686 BFD_RELOC_IA64_TPREL64MSB 3687ENUMX 3688 BFD_RELOC_IA64_TPREL64LSB 3689ENUMX 3690 BFD_RELOC_IA64_LTOFF_TPREL22 3691ENUMX 3692 BFD_RELOC_IA64_DTPMOD64MSB 3693ENUMX 3694 BFD_RELOC_IA64_DTPMOD64LSB 3695ENUMX 3696 BFD_RELOC_IA64_LTOFF_DTPMOD22 3697ENUMX 3698 BFD_RELOC_IA64_DTPREL14 3699ENUMX 3700 BFD_RELOC_IA64_DTPREL22 3701ENUMX 3702 BFD_RELOC_IA64_DTPREL64I 3703ENUMX 3704 BFD_RELOC_IA64_DTPREL32MSB 3705ENUMX 3706 BFD_RELOC_IA64_DTPREL32LSB 3707ENUMX 3708 BFD_RELOC_IA64_DTPREL64MSB 3709ENUMX 3710 BFD_RELOC_IA64_DTPREL64LSB 3711ENUMX 3712 BFD_RELOC_IA64_LTOFF_DTPREL22 3713ENUMDOC 3714 Intel IA64 Relocations. 3715 3716ENUM 3717 BFD_RELOC_M68HC11_HI8 3718ENUMDOC 3719 Motorola 68HC11 reloc. 3720 This is the 8 bit high part of an absolute address. 3721ENUM 3722 BFD_RELOC_M68HC11_LO8 3723ENUMDOC 3724 Motorola 68HC11 reloc. 3725 This is the 8 bit low part of an absolute address. 3726ENUM 3727 BFD_RELOC_M68HC11_3B 3728ENUMDOC 3729 Motorola 68HC11 reloc. 3730 This is the 3 bit of a value. 3731ENUM 3732 BFD_RELOC_M68HC11_RL_JUMP 3733ENUMDOC 3734 Motorola 68HC11 reloc. 3735 This reloc marks the beginning of a jump/call instruction. 3736 It is used for linker relaxation to correctly identify beginning 3737 of instruction and change some branches to use PC-relative 3738 addressing mode. 3739ENUM 3740 BFD_RELOC_M68HC11_RL_GROUP 3741ENUMDOC 3742 Motorola 68HC11 reloc. 3743 This reloc marks a group of several instructions that gcc generates 3744 and for which the linker relaxation pass can modify and/or remove 3745 some of them. 3746ENUM 3747 BFD_RELOC_M68HC11_LO16 3748ENUMDOC 3749 Motorola 68HC11 reloc. 3750 This is the 16-bit lower part of an address. It is used for 'call' 3751 instruction to specify the symbol address without any special 3752 transformation (due to memory bank window). 3753ENUM 3754 BFD_RELOC_M68HC11_PAGE 3755ENUMDOC 3756 Motorola 68HC11 reloc. 3757 This is a 8-bit reloc that specifies the page number of an address. 3758 It is used by 'call' instruction to specify the page number of 3759 the symbol. 3760ENUM 3761 BFD_RELOC_M68HC11_24 3762ENUMDOC 3763 Motorola 68HC11 reloc. 3764 This is a 24-bit reloc that represents the address with a 16-bit 3765 value and a 8-bit page number. The symbol address is transformed 3766 to follow the 16K memory bank of 68HC12 (seen as mapped in the window). 3767ENUM 3768 BFD_RELOC_M68HC12_5B 3769ENUMDOC 3770 Motorola 68HC12 reloc. 3771 This is the 5 bits of a value. 3772 3773ENUM 3774 BFD_RELOC_CRIS_BDISP8 3775ENUMX 3776 BFD_RELOC_CRIS_UNSIGNED_5 3777ENUMX 3778 BFD_RELOC_CRIS_SIGNED_6 3779ENUMX 3780 BFD_RELOC_CRIS_UNSIGNED_6 3781ENUMX 3782 BFD_RELOC_CRIS_UNSIGNED_4 3783ENUMDOC 3784 These relocs are only used within the CRIS assembler. They are not 3785 (at present) written to any object files. 3786ENUM 3787 BFD_RELOC_CRIS_COPY 3788ENUMX 3789 BFD_RELOC_CRIS_GLOB_DAT 3790ENUMX 3791 BFD_RELOC_CRIS_JUMP_SLOT 3792ENUMX 3793 BFD_RELOC_CRIS_RELATIVE 3794ENUMDOC 3795 Relocs used in ELF shared libraries for CRIS. 3796ENUM 3797 BFD_RELOC_CRIS_32_GOT 3798ENUMDOC 3799 32-bit offset to symbol-entry within GOT. 3800ENUM 3801 BFD_RELOC_CRIS_16_GOT 3802ENUMDOC 3803 16-bit offset to symbol-entry within GOT. 3804ENUM 3805 BFD_RELOC_CRIS_32_GOTPLT 3806ENUMDOC 3807 32-bit offset to symbol-entry within GOT, with PLT handling. 3808ENUM 3809 BFD_RELOC_CRIS_16_GOTPLT 3810ENUMDOC 3811 16-bit offset to symbol-entry within GOT, with PLT handling. 3812ENUM 3813 BFD_RELOC_CRIS_32_GOTREL 3814ENUMDOC 3815 32-bit offset to symbol, relative to GOT. 3816ENUM 3817 BFD_RELOC_CRIS_32_PLT_GOTREL 3818ENUMDOC 3819 32-bit offset to symbol with PLT entry, relative to GOT. 3820ENUM 3821 BFD_RELOC_CRIS_32_PLT_PCREL 3822ENUMDOC 3823 32-bit offset to symbol with PLT entry, relative to this relocation. 3824 3825ENUM 3826 BFD_RELOC_860_COPY 3827ENUMX 3828 BFD_RELOC_860_GLOB_DAT 3829ENUMX 3830 BFD_RELOC_860_JUMP_SLOT 3831ENUMX 3832 BFD_RELOC_860_RELATIVE 3833ENUMX 3834 BFD_RELOC_860_PC26 3835ENUMX 3836 BFD_RELOC_860_PLT26 3837ENUMX 3838 BFD_RELOC_860_PC16 3839ENUMX 3840 BFD_RELOC_860_LOW0 3841ENUMX 3842 BFD_RELOC_860_SPLIT0 3843ENUMX 3844 BFD_RELOC_860_LOW1 3845ENUMX 3846 BFD_RELOC_860_SPLIT1 3847ENUMX 3848 BFD_RELOC_860_LOW2 3849ENUMX 3850 BFD_RELOC_860_SPLIT2 3851ENUMX 3852 BFD_RELOC_860_LOW3 3853ENUMX 3854 BFD_RELOC_860_LOGOT0 3855ENUMX 3856 BFD_RELOC_860_SPGOT0 3857ENUMX 3858 BFD_RELOC_860_LOGOT1 3859ENUMX 3860 BFD_RELOC_860_SPGOT1 3861ENUMX 3862 BFD_RELOC_860_LOGOTOFF0 3863ENUMX 3864 BFD_RELOC_860_SPGOTOFF0 3865ENUMX 3866 BFD_RELOC_860_LOGOTOFF1 3867ENUMX 3868 BFD_RELOC_860_SPGOTOFF1 3869ENUMX 3870 BFD_RELOC_860_LOGOTOFF2 3871ENUMX 3872 BFD_RELOC_860_LOGOTOFF3 3873ENUMX 3874 BFD_RELOC_860_LOPC 3875ENUMX 3876 BFD_RELOC_860_HIGHADJ 3877ENUMX 3878 BFD_RELOC_860_HAGOT 3879ENUMX 3880 BFD_RELOC_860_HAGOTOFF 3881ENUMX 3882 BFD_RELOC_860_HAPC 3883ENUMX 3884 BFD_RELOC_860_HIGH 3885ENUMX 3886 BFD_RELOC_860_HIGOT 3887ENUMX 3888 BFD_RELOC_860_HIGOTOFF 3889ENUMDOC 3890 Intel i860 Relocations. 3891 3892ENUM 3893 BFD_RELOC_OPENRISC_ABS_26 3894ENUMX 3895 BFD_RELOC_OPENRISC_REL_26 3896ENUMDOC 3897 OpenRISC Relocations. 3898 3899ENUM 3900 BFD_RELOC_H8_DIR16A8 3901ENUMX 3902 BFD_RELOC_H8_DIR16R8 3903ENUMX 3904 BFD_RELOC_H8_DIR24A8 3905ENUMX 3906 BFD_RELOC_H8_DIR24R8 3907ENUMX 3908 BFD_RELOC_H8_DIR32A16 3909ENUMDOC 3910 H8 elf Relocations. 3911 3912ENUM 3913 BFD_RELOC_XSTORMY16_REL_12 3914ENUMX 3915 BFD_RELOC_XSTORMY16_12 3916ENUMX 3917 BFD_RELOC_XSTORMY16_24 3918ENUMX 3919 BFD_RELOC_XSTORMY16_FPTR16 3920ENUMDOC 3921 Sony Xstormy16 Relocations. 3922 3923ENUM 3924 BFD_RELOC_VAX_GLOB_DAT 3925ENUMX 3926 BFD_RELOC_VAX_JMP_SLOT 3927ENUMX 3928 BFD_RELOC_VAX_RELATIVE 3929ENUMDOC 3930 Relocations used by VAX ELF. 3931 3932ENUM 3933 BFD_RELOC_MSP430_10_PCREL 3934ENUMX 3935 BFD_RELOC_MSP430_16_PCREL 3936ENUMX 3937 BFD_RELOC_MSP430_16 3938ENUMX 3939 BFD_RELOC_MSP430_16_PCREL_BYTE 3940ENUMX 3941 BFD_RELOC_MSP430_16_BYTE 3942ENUMDOC 3943 msp430 specific relocation codes 3944 3945ENUM 3946 BFD_RELOC_IQ2000_OFFSET_16 3947ENUMX 3948 BFD_RELOC_IQ2000_OFFSET_21 3949ENUMX 3950 BFD_RELOC_IQ2000_UHI16 3951ENUMDOC 3952 IQ2000 Relocations. 3953 3954ENUM 3955 BFD_RELOC_XTENSA_RTLD 3956ENUMDOC 3957 Special Xtensa relocation used only by PLT entries in ELF shared 3958 objects to indicate that the runtime linker should set the value 3959 to one of its own internal functions or data structures. 3960ENUM 3961 BFD_RELOC_XTENSA_GLOB_DAT 3962ENUMX 3963 BFD_RELOC_XTENSA_JMP_SLOT 3964ENUMX 3965 BFD_RELOC_XTENSA_RELATIVE 3966ENUMDOC 3967 Xtensa relocations for ELF shared objects. 3968ENUM 3969 BFD_RELOC_XTENSA_PLT 3970ENUMDOC 3971 Xtensa relocation used in ELF object files for symbols that may require 3972 PLT entries. Otherwise, this is just a generic 32-bit relocation. 3973ENUM 3974 BFD_RELOC_XTENSA_OP0 3975ENUMX 3976 BFD_RELOC_XTENSA_OP1 3977ENUMX 3978 BFD_RELOC_XTENSA_OP2 3979ENUMDOC 3980 Generic Xtensa relocations. Only the operand number is encoded 3981 in the relocation. The details are determined by extracting the 3982 instruction opcode. 3983ENUM 3984 BFD_RELOC_XTENSA_ASM_EXPAND 3985ENUMDOC 3986 Xtensa relocation to mark that the assembler expanded the 3987 instructions from an original target. The expansion size is 3988 encoded in the reloc size. 3989ENUM 3990 BFD_RELOC_XTENSA_ASM_SIMPLIFY 3991ENUMDOC 3992 Xtensa relocation to mark that the linker should simplify 3993 assembler-expanded instructions. This is commonly used 3994 internally by the linker after analysis of a 3995 BFD_RELOC_XTENSA_ASM_EXPAND. 3996 3997ENDSENUM 3998 BFD_RELOC_UNUSED 3999CODE_FRAGMENT 4000. 4001.typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; 4002*/ 4003 4004/* 4005FUNCTION 4006 bfd_reloc_type_lookup 4007 4008SYNOPSIS 4009 reloc_howto_type *bfd_reloc_type_lookup 4010 (bfd *abfd, bfd_reloc_code_real_type code); 4011 4012DESCRIPTION 4013 Return a pointer to a howto structure which, when 4014 invoked, will perform the relocation @var{code} on data from the 4015 architecture noted. 4016 4017*/ 4018 4019reloc_howto_type * 4020bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 4021{ 4022 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code)); 4023} 4024 4025static reloc_howto_type bfd_howto_32 = 4026HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE); 4027 4028/* 4029INTERNAL_FUNCTION 4030 bfd_default_reloc_type_lookup 4031 4032SYNOPSIS 4033 reloc_howto_type *bfd_default_reloc_type_lookup 4034 (bfd *abfd, bfd_reloc_code_real_type code); 4035 4036DESCRIPTION 4037 Provides a default relocation lookup routine for any architecture. 4038 4039*/ 4040 4041reloc_howto_type * 4042bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 4043{ 4044 switch (code) 4045 { 4046 case BFD_RELOC_CTOR: 4047 /* The type of reloc used in a ctor, which will be as wide as the 4048 address - so either a 64, 32, or 16 bitter. */ 4049 switch (bfd_get_arch_info (abfd)->bits_per_address) 4050 { 4051 case 64: 4052 BFD_FAIL (); 4053 case 32: 4054 return &bfd_howto_32; 4055 case 16: 4056 BFD_FAIL (); 4057 default: 4058 BFD_FAIL (); 4059 } 4060 default: 4061 BFD_FAIL (); 4062 } 4063 return NULL; 4064} 4065 4066/* 4067FUNCTION 4068 bfd_get_reloc_code_name 4069 4070SYNOPSIS 4071 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); 4072 4073DESCRIPTION 4074 Provides a printable name for the supplied relocation code. 4075 Useful mainly for printing error messages. 4076*/ 4077 4078const char * 4079bfd_get_reloc_code_name (bfd_reloc_code_real_type code) 4080{ 4081 if (code > BFD_RELOC_UNUSED) 4082 return 0; 4083 return bfd_reloc_code_real_names[code]; 4084} 4085 4086/* 4087INTERNAL_FUNCTION 4088 bfd_generic_relax_section 4089 4090SYNOPSIS 4091 bfd_boolean bfd_generic_relax_section 4092 (bfd *abfd, 4093 asection *section, 4094 struct bfd_link_info *, 4095 bfd_boolean *); 4096 4097DESCRIPTION 4098 Provides default handling for relaxing for back ends which 4099 don't do relaxing -- i.e., does nothing except make sure that the 4100 final size of the section is set. 4101*/ 4102 4103bfd_boolean 4104bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, 4105 asection *section ATTRIBUTE_UNUSED, 4106 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 4107 bfd_boolean *again) 4108{ 4109 /* We're not relaxing the section, so just copy the size info if it's 4110 zero. Someone else, like bfd_merge_sections, might have set it, so 4111 don't overwrite a non-zero value. */ 4112 if (section->_cooked_size == 0) 4113 section->_cooked_size = section->_raw_size; 4114 *again = FALSE; 4115 return TRUE; 4116} 4117 4118/* 4119INTERNAL_FUNCTION 4120 bfd_generic_gc_sections 4121 4122SYNOPSIS 4123 bfd_boolean bfd_generic_gc_sections 4124 (bfd *, struct bfd_link_info *); 4125 4126DESCRIPTION 4127 Provides default handling for relaxing for back ends which 4128 don't do section gc -- i.e., does nothing. 4129*/ 4130 4131bfd_boolean 4132bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, 4133 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 4134{ 4135 return TRUE; 4136} 4137 4138/* 4139INTERNAL_FUNCTION 4140 bfd_generic_merge_sections 4141 4142SYNOPSIS 4143 bfd_boolean bfd_generic_merge_sections 4144 (bfd *, struct bfd_link_info *); 4145 4146DESCRIPTION 4147 Provides default handling for SEC_MERGE section merging for back ends 4148 which don't have SEC_MERGE support -- i.e., does nothing. 4149*/ 4150 4151bfd_boolean 4152bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, 4153 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 4154{ 4155 return TRUE; 4156} 4157 4158/* 4159INTERNAL_FUNCTION 4160 bfd_generic_get_relocated_section_contents 4161 4162SYNOPSIS 4163 bfd_byte *bfd_generic_get_relocated_section_contents 4164 (bfd *abfd, 4165 struct bfd_link_info *link_info, 4166 struct bfd_link_order *link_order, 4167 bfd_byte *data, 4168 bfd_boolean relocatable, 4169 asymbol **symbols); 4170 4171DESCRIPTION 4172 Provides default handling of relocation effort for back ends 4173 which can't be bothered to do it efficiently. 4174 4175*/ 4176 4177bfd_byte * 4178bfd_generic_get_relocated_section_contents (bfd *abfd, 4179 struct bfd_link_info *link_info, 4180 struct bfd_link_order *link_order, 4181 bfd_byte *data, 4182 bfd_boolean relocatable, 4183 asymbol **symbols) 4184{ 4185 /* Get enough memory to hold the stuff. */ 4186 bfd *input_bfd = link_order->u.indirect.section->owner; 4187 asection *input_section = link_order->u.indirect.section; 4188 4189 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 4190 arelent **reloc_vector = NULL; 4191 long reloc_count; 4192 4193 if (reloc_size < 0) 4194 goto error_return; 4195 4196 reloc_vector = bfd_malloc (reloc_size); 4197 if (reloc_vector == NULL && reloc_size != 0) 4198 goto error_return; 4199 4200 /* Read in the section. */ 4201 if (!bfd_get_section_contents (input_bfd, 4202 input_section, 4203 data, 4204 0, 4205 input_section->_raw_size)) 4206 goto error_return; 4207 4208 /* Don't set input_section->_cooked_size here. The caller has set 4209 _cooked_size or called bfd_relax_section, which sets _cooked_size. 4210 Despite using this generic relocation function, some targets perform 4211 target-specific relaxation or string merging, which happens before 4212 this function is called. We do not want to clobber the _cooked_size 4213 they computed. */ 4214 4215 input_section->reloc_done = TRUE; 4216 4217 reloc_count = bfd_canonicalize_reloc (input_bfd, 4218 input_section, 4219 reloc_vector, 4220 symbols); 4221 if (reloc_count < 0) 4222 goto error_return; 4223 4224 if (reloc_count > 0) 4225 { 4226 arelent **parent; 4227 for (parent = reloc_vector; *parent != NULL; parent++) 4228 { 4229 char *error_message = NULL; 4230 bfd_reloc_status_type r = 4231 bfd_perform_relocation (input_bfd, 4232 *parent, 4233 data, 4234 input_section, 4235 relocatable ? abfd : NULL, 4236 &error_message); 4237 4238 if (relocatable) 4239 { 4240 asection *os = input_section->output_section; 4241 4242 /* A partial link, so keep the relocs. */ 4243 os->orelocation[os->reloc_count] = *parent; 4244 os->reloc_count++; 4245 } 4246 4247 if (r != bfd_reloc_ok) 4248 { 4249 switch (r) 4250 { 4251 case bfd_reloc_undefined: 4252 if (!((*link_info->callbacks->undefined_symbol) 4253 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 4254 input_bfd, input_section, (*parent)->address, 4255 TRUE))) 4256 goto error_return; 4257 break; 4258 case bfd_reloc_dangerous: 4259 BFD_ASSERT (error_message != NULL); 4260 if (!((*link_info->callbacks->reloc_dangerous) 4261 (link_info, error_message, input_bfd, input_section, 4262 (*parent)->address))) 4263 goto error_return; 4264 break; 4265 case bfd_reloc_overflow: 4266 if (!((*link_info->callbacks->reloc_overflow) 4267 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 4268 (*parent)->howto->name, (*parent)->addend, 4269 input_bfd, input_section, (*parent)->address))) 4270 goto error_return; 4271 break; 4272 case bfd_reloc_outofrange: 4273 default: 4274 abort (); 4275 break; 4276 } 4277 4278 } 4279 } 4280 } 4281 if (reloc_vector != NULL) 4282 free (reloc_vector); 4283 return data; 4284 4285error_return: 4286 if (reloc_vector != NULL) 4287 free (reloc_vector); 4288 return NULL; 4289} 4290