1/* BFD support for handling relocation entries. 2 Copyright (C) 1990-2017 Free Software Foundation, Inc. 3 Written by Cygnus Support. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22/* 23SECTION 24 Relocations 25 26 BFD maintains relocations in much the same way it maintains 27 symbols: they are left alone until required, then read in 28 en-masse and translated into an internal form. A common 29 routine <<bfd_perform_relocation>> acts upon the 30 canonical form to do the fixup. 31 32 Relocations are maintained on a per section basis, 33 while symbols are maintained on a per BFD basis. 34 35 All that a back end has to do to fit the BFD interface is to create 36 a <<struct reloc_cache_entry>> for each relocation 37 in a particular section, and fill in the right bits of the structures. 38 39@menu 40@* typedef arelent:: 41@* howto manager:: 42@end menu 43 44*/ 45 46/* DO compile in the reloc_code name table from libbfd.h. */ 47#define _BFD_MAKE_TABLE_bfd_reloc_code_real 48 49#include "sysdep.h" 50#include "bfd.h" 51#include "bfdlink.h" 52#include "libbfd.h" 53/* 54DOCDD 55INODE 56 typedef arelent, howto manager, Relocations, Relocations 57 58SUBSECTION 59 typedef arelent 60 61 This is the structure of a relocation entry: 62 63CODE_FRAGMENT 64. 65.typedef enum bfd_reloc_status 66.{ 67. {* No errors detected. *} 68. bfd_reloc_ok, 69. 70. {* The relocation was performed, but there was an overflow. *} 71. bfd_reloc_overflow, 72. 73. {* The address to relocate was not within the section supplied. *} 74. bfd_reloc_outofrange, 75. 76. {* Used by special functions. *} 77. bfd_reloc_continue, 78. 79. {* Unsupported relocation size requested. *} 80. bfd_reloc_notsupported, 81. 82. {* Unused. *} 83. bfd_reloc_other, 84. 85. {* The symbol to relocate against was undefined. *} 86. bfd_reloc_undefined, 87. 88. {* The relocation was performed, but may not be ok - presently 89. generated only when linking i960 coff files with i960 b.out 90. symbols. If this type is returned, the error_message argument 91. to bfd_perform_relocation will be set. *} 92. bfd_reloc_dangerous 93. } 94. bfd_reloc_status_type; 95. 96. 97.typedef struct reloc_cache_entry 98.{ 99. {* A pointer into the canonical table of pointers. *} 100. struct bfd_symbol **sym_ptr_ptr; 101. 102. {* offset in section. *} 103. bfd_size_type address; 104. 105. {* addend for relocation value. *} 106. bfd_vma addend; 107. 108. {* Pointer to how to perform the required relocation. *} 109. reloc_howto_type *howto; 110. 111.} 112.arelent; 113. 114*/ 115 116/* 117DESCRIPTION 118 119 Here is a description of each of the fields within an <<arelent>>: 120 121 o <<sym_ptr_ptr>> 122 123 The symbol table pointer points to a pointer to the symbol 124 associated with the relocation request. It is the pointer 125 into the table returned by the back end's 126 <<canonicalize_symtab>> action. @xref{Symbols}. The symbol is 127 referenced through a pointer to a pointer so that tools like 128 the linker can fix up all the symbols of the same name by 129 modifying only one pointer. The relocation routine looks in 130 the symbol and uses the base of the section the symbol is 131 attached to and the value of the symbol as the initial 132 relocation offset. If the symbol pointer is zero, then the 133 section provided is looked up. 134 135 o <<address>> 136 137 The <<address>> field gives the offset in bytes from the base of 138 the section data which owns the relocation record to the first 139 byte of relocatable information. The actual data relocated 140 will be relative to this point; for example, a relocation 141 type which modifies the bottom two bytes of a four byte word 142 would not touch the first byte pointed to in a big endian 143 world. 144 145 o <<addend>> 146 147 The <<addend>> is a value provided by the back end to be added (!) 148 to the relocation offset. Its interpretation is dependent upon 149 the howto. For example, on the 68k the code: 150 151| char foo[]; 152| main() 153| { 154| return foo[0x12345678]; 155| } 156 157 Could be compiled into: 158 159| linkw fp,#-4 160| moveb @@#12345678,d0 161| extbl d0 162| unlk fp 163| rts 164 165 This could create a reloc pointing to <<foo>>, but leave the 166 offset in the data, something like: 167 168|RELOCATION RECORDS FOR [.text]: 169|offset type value 170|00000006 32 _foo 171| 172|00000000 4e56 fffc ; linkw fp,#-4 173|00000004 1039 1234 5678 ; moveb @@#12345678,d0 174|0000000a 49c0 ; extbl d0 175|0000000c 4e5e ; unlk fp 176|0000000e 4e75 ; rts 177 178 Using coff and an 88k, some instructions don't have enough 179 space in them to represent the full address range, and 180 pointers have to be loaded in two parts. So you'd get something like: 181 182| or.u r13,r0,hi16(_foo+0x12345678) 183| ld.b r2,r13,lo16(_foo+0x12345678) 184| jmp r1 185 186 This should create two relocs, both pointing to <<_foo>>, and with 187 0x12340000 in their addend field. The data would consist of: 188 189|RELOCATION RECORDS FOR [.text]: 190|offset type value 191|00000002 HVRT16 _foo+0x12340000 192|00000006 LVRT16 _foo+0x12340000 193| 194|00000000 5da05678 ; or.u r13,r0,0x5678 195|00000004 1c4d5678 ; ld.b r2,r13,0x5678 196|00000008 f400c001 ; jmp r1 197 198 The relocation routine digs out the value from the data, adds 199 it to the addend to get the original offset, and then adds the 200 value of <<_foo>>. Note that all 32 bits have to be kept around 201 somewhere, to cope with carry from bit 15 to bit 16. 202 203 One further example is the sparc and the a.out format. The 204 sparc has a similar problem to the 88k, in that some 205 instructions don't have room for an entire offset, but on the 206 sparc the parts are created in odd sized lumps. The designers of 207 the a.out format chose to not use the data within the section 208 for storing part of the offset; all the offset is kept within 209 the reloc. Anything in the data should be ignored. 210 211| save %sp,-112,%sp 212| sethi %hi(_foo+0x12345678),%g2 213| ldsb [%g2+%lo(_foo+0x12345678)],%i0 214| ret 215| restore 216 217 Both relocs contain a pointer to <<foo>>, and the offsets 218 contain junk. 219 220|RELOCATION RECORDS FOR [.text]: 221|offset type value 222|00000004 HI22 _foo+0x12345678 223|00000008 LO10 _foo+0x12345678 224| 225|00000000 9de3bf90 ; save %sp,-112,%sp 226|00000004 05000000 ; sethi %hi(_foo+0),%g2 227|00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0 228|0000000c 81c7e008 ; ret 229|00000010 81e80000 ; restore 230 231 o <<howto>> 232 233 The <<howto>> field can be imagined as a 234 relocation instruction. It is a pointer to a structure which 235 contains information on what to do with all of the other 236 information in the reloc record and data section. A back end 237 would normally have a relocation instruction set and turn 238 relocations into pointers to the correct structure on input - 239 but it would be possible to create each howto field on demand. 240 241*/ 242 243/* 244SUBSUBSECTION 245 <<enum complain_overflow>> 246 247 Indicates what sort of overflow checking should be done when 248 performing a relocation. 249 250CODE_FRAGMENT 251. 252.enum complain_overflow 253.{ 254. {* Do not complain on overflow. *} 255. complain_overflow_dont, 256. 257. {* Complain if the value overflows when considered as a signed 258. number one bit larger than the field. ie. A bitfield of N bits 259. is allowed to represent -2**n to 2**n-1. *} 260. complain_overflow_bitfield, 261. 262. {* Complain if the value overflows when considered as a 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. {* The relocation is relative to the field being relocated. *} 307. bfd_boolean pc_relative; 308. 309. {* The bit position of the reloc value in the destination. 310. The relocated value is left shifted by this amount. *} 311. unsigned int bitpos; 312. 313. {* What type of overflow error should be checked for when 314. relocating. *} 315. enum complain_overflow complain_on_overflow; 316. 317. {* If this field is non null, then the supplied function is 318. called rather than the normal function. This allows really 319. strange relocation methods to be accommodated (e.g., i960 callj 320. instructions). *} 321. bfd_reloc_status_type (*special_function) 322. (bfd *, arelent *, struct bfd_symbol *, void *, asection *, 323. bfd *, char **); 324. 325. {* The textual name of the relocation type. *} 326. char *name; 327. 328. {* Some formats record a relocation addend in the section contents 329. rather than with the relocation. For ELF formats this is the 330. distinction between USE_REL and USE_RELA (though the code checks 331. for USE_REL == 1/0). The value of this field is TRUE if the 332. addend is recorded with the section contents; when performing a 333. partial link (ld -r) the section contents (the data) will be 334. modified. The value of this field is FALSE if addends are 335. recorded with the relocation (in arelent.addend); when performing 336. a partial link the relocation will be modified. 337. All relocations for all ELF USE_RELA targets should set this field 338. to FALSE (values of TRUE should be looked on with suspicion). 339. However, the converse is not true: not all relocations of all ELF 340. USE_REL targets set this field to TRUE. Why this is so is peculiar 341. to each particular target. For relocs that aren't used in partial 342. links (e.g. GOT stuff) it doesn't matter what this is set to. *} 343. bfd_boolean partial_inplace; 344. 345. {* src_mask selects the part of the instruction (or data) to be used 346. in the relocation sum. If the target relocations don't have an 347. addend in the reloc, eg. ELF USE_REL, src_mask will normally equal 348. dst_mask to extract the addend from the section contents. If 349. relocations do have an addend in the reloc, eg. ELF USE_RELA, this 350. field should be zero. Non-zero values for ELF USE_RELA targets are 351. bogus as in those cases the value in the dst_mask part of the 352. section contents should be treated as garbage. *} 353. bfd_vma src_mask; 354. 355. {* dst_mask selects which parts of the instruction (or data) are 356. replaced with a relocated value. *} 357. bfd_vma dst_mask; 358. 359. {* When some formats create PC relative instructions, they leave 360. the value of the pc of the place being relocated in the offset 361. slot of the instruction, so that a PC relative relocation can 362. be made just by adding in an ordinary offset (e.g., sun3 a.out). 363. Some formats leave the displacement part of an instruction 364. empty (e.g., m88k bcs); this flag signals the fact. *} 365. bfd_boolean pcrel_offset; 366.}; 367. 368*/ 369 370/* 371FUNCTION 372 The HOWTO Macro 373 374DESCRIPTION 375 The HOWTO define is horrible and will go away. 376 377.#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ 378. { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC } 379 380DESCRIPTION 381 And will be replaced with the totally magic way. But for the 382 moment, we are compatible, so do it this way. 383 384.#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \ 385. HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \ 386. NAME, FALSE, 0, 0, IN) 387. 388 389DESCRIPTION 390 This is used to fill in an empty howto entry in an array. 391 392.#define EMPTY_HOWTO(C) \ 393. HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \ 394. NULL, FALSE, 0, 0, FALSE) 395. 396 397DESCRIPTION 398 Helper routine to turn a symbol into a relocation value. 399 400.#define HOWTO_PREPARE(relocation, symbol) \ 401. { \ 402. if (symbol != NULL) \ 403. { \ 404. if (bfd_is_com_section (symbol->section)) \ 405. { \ 406. relocation = 0; \ 407. } \ 408. else \ 409. { \ 410. relocation = symbol->value; \ 411. } \ 412. } \ 413. } 414. 415*/ 416 417/* 418FUNCTION 419 bfd_get_reloc_size 420 421SYNOPSIS 422 unsigned int bfd_get_reloc_size (reloc_howto_type *); 423 424DESCRIPTION 425 For a reloc_howto_type that operates on a fixed number of bytes, 426 this returns the number of bytes operated on. 427 */ 428 429unsigned int 430bfd_get_reloc_size (reloc_howto_type *howto) 431{ 432 switch (howto->size) 433 { 434 case 0: return 1; 435 case 1: return 2; 436 case 2: return 4; 437 case 3: return 0; 438 case 4: return 8; 439 case 8: return 16; 440 case -1: return 2; 441 case -2: return 4; 442 default: abort (); 443 } 444} 445 446/* 447TYPEDEF 448 arelent_chain 449 450DESCRIPTION 451 452 How relocs are tied together in an <<asection>>: 453 454.typedef struct relent_chain 455.{ 456. arelent relent; 457. struct relent_chain *next; 458.} 459.arelent_chain; 460. 461*/ 462 463/* N_ONES produces N one bits, without overflowing machine arithmetic. */ 464#define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1) 465 466/* 467FUNCTION 468 bfd_check_overflow 469 470SYNOPSIS 471 bfd_reloc_status_type bfd_check_overflow 472 (enum complain_overflow how, 473 unsigned int bitsize, 474 unsigned int rightshift, 475 unsigned int addrsize, 476 bfd_vma relocation); 477 478DESCRIPTION 479 Perform overflow checking on @var{relocation} which has 480 @var{bitsize} significant bits and will be shifted right by 481 @var{rightshift} bits, on a machine with addresses containing 482 @var{addrsize} significant bits. The result is either of 483 @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}. 484 485*/ 486 487bfd_reloc_status_type 488bfd_check_overflow (enum complain_overflow how, 489 unsigned int bitsize, 490 unsigned int rightshift, 491 unsigned int addrsize, 492 bfd_vma relocation) 493{ 494 bfd_vma fieldmask, addrmask, signmask, ss, a; 495 bfd_reloc_status_type flag = bfd_reloc_ok; 496 497 /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not, 498 we'll be permissive: extra bits in the field mask will 499 automatically extend the address mask for purposes of the 500 overflow check. */ 501 fieldmask = N_ONES (bitsize); 502 signmask = ~fieldmask; 503 addrmask = N_ONES (addrsize) | (fieldmask << rightshift); 504 a = (relocation & addrmask) >> rightshift; 505 506 switch (how) 507 { 508 case complain_overflow_dont: 509 break; 510 511 case complain_overflow_signed: 512 /* If any sign bits are set, all sign bits must be set. That 513 is, A must be a valid negative address after shifting. */ 514 signmask = ~ (fieldmask >> 1); 515 /* Fall thru */ 516 517 case complain_overflow_bitfield: 518 /* Bitfields are sometimes signed, sometimes unsigned. We 519 explicitly allow an address wrap too, which means a bitfield 520 of n bits is allowed to store -2**n to 2**n-1. Thus overflow 521 if the value has some, but not all, bits set outside the 522 field. */ 523 ss = a & signmask; 524 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask)) 525 flag = bfd_reloc_overflow; 526 break; 527 528 case complain_overflow_unsigned: 529 /* We have an overflow if the address does not fit in the field. */ 530 if ((a & signmask) != 0) 531 flag = bfd_reloc_overflow; 532 break; 533 534 default: 535 abort (); 536 } 537 538 return flag; 539} 540 541/* 542FUNCTION 543 bfd_perform_relocation 544 545SYNOPSIS 546 bfd_reloc_status_type bfd_perform_relocation 547 (bfd *abfd, 548 arelent *reloc_entry, 549 void *data, 550 asection *input_section, 551 bfd *output_bfd, 552 char **error_message); 553 554DESCRIPTION 555 If @var{output_bfd} is supplied to this function, the 556 generated image will be relocatable; the relocations are 557 copied to the output file after they have been changed to 558 reflect the new state of the world. There are two ways of 559 reflecting the results of partial linkage in an output file: 560 by modifying the output data in place, and by modifying the 561 relocation record. Some native formats (e.g., basic a.out and 562 basic coff) have no way of specifying an addend in the 563 relocation type, so the addend has to go in the output data. 564 This is no big deal since in these formats the output data 565 slot will always be big enough for the addend. Complex reloc 566 types with addends were invented to solve just this problem. 567 The @var{error_message} argument is set to an error message if 568 this return @code{bfd_reloc_dangerous}. 569 570*/ 571 572bfd_reloc_status_type 573bfd_perform_relocation (bfd *abfd, 574 arelent *reloc_entry, 575 void *data, 576 asection *input_section, 577 bfd *output_bfd, 578 char **error_message) 579{ 580 bfd_vma relocation; 581 bfd_reloc_status_type flag = bfd_reloc_ok; 582 bfd_size_type octets; 583 bfd_vma output_base = 0; 584 reloc_howto_type *howto = reloc_entry->howto; 585 asection *reloc_target_output_section; 586 asymbol *symbol; 587 588 symbol = *(reloc_entry->sym_ptr_ptr); 589 590 /* If we are not producing relocatable output, return an error if 591 the symbol is not defined. An undefined weak symbol is 592 considered to have a value of zero (SVR4 ABI, p. 4-27). */ 593 if (bfd_is_und_section (symbol->section) 594 && (symbol->flags & BSF_WEAK) == 0 595 && output_bfd == NULL) 596 flag = bfd_reloc_undefined; 597 598 /* If there is a function supplied to handle this relocation type, 599 call it. It'll return `bfd_reloc_continue' if further processing 600 can be done. */ 601 if (howto && howto->special_function) 602 { 603 bfd_reloc_status_type cont; 604 cont = howto->special_function (abfd, reloc_entry, symbol, data, 605 input_section, output_bfd, 606 error_message); 607 if (cont != bfd_reloc_continue) 608 return cont; 609 } 610 611 if (bfd_is_abs_section (symbol->section) 612 && output_bfd != NULL) 613 { 614 reloc_entry->address += input_section->output_offset; 615 return bfd_reloc_ok; 616 } 617 618 /* PR 17512: file: 0f67f69d. */ 619 if (howto == NULL) 620 return bfd_reloc_undefined; 621 622 /* Is the address of the relocation really within the section? 623 Include the size of the reloc in the test for out of range addresses. 624 PR 17512: file: c146ab8b, 46dff27f, 38e53ebf. */ 625 octets = reloc_entry->address * bfd_octets_per_byte (abfd); 626 if (octets + bfd_get_reloc_size (howto) 627 > bfd_get_section_limit_octets (abfd, input_section)) 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 /* For m68k-coff, the addend was being subtracted twice during 720 relocation with -r. Removing the line below this comment 721 fixes that problem; see PR 2953. 722 723However, Ian wrote the following, regarding removing the line below, 724which explains why it is still enabled: --djm 725 726If you put a patch like that into BFD you need to check all the COFF 727linkers. I am fairly certain that patch will break coff-i386 (e.g., 728SCO); see coff_i386_reloc in coff-i386.c where I worked around the 729problem in a different way. There may very well be a reason that the 730code works as it does. 731 732Hmmm. The first obvious point is that bfd_perform_relocation should 733not have any tests that depend upon the flavour. It's seem like 734entirely the wrong place for such a thing. The second obvious point 735is that the current code ignores the reloc addend when producing 736relocatable output for COFF. That's peculiar. In fact, I really 737have no idea what the point of the line you want to remove is. 738 739A typical COFF reloc subtracts the old value of the symbol and adds in 740the new value to the location in the object file (if it's a pc 741relative reloc it adds the difference between the symbol value and the 742location). When relocating we need to preserve that property. 743 744BFD handles this by setting the addend to the negative of the old 745value of the symbol. Unfortunately it handles common symbols in a 746non-standard way (it doesn't subtract the old value) but that's a 747different story (we can't change it without losing backward 748compatibility with old object files) (coff-i386 does subtract the old 749value, to be compatible with existing coff-i386 targets, like SCO). 750 751So everything works fine when not producing relocatable output. When 752we are producing relocatable output, logically we should do exactly 753what we do when not producing relocatable output. Therefore, your 754patch is correct. In fact, it should probably always just set 755reloc_entry->addend to 0 for all cases, since it is, in fact, going to 756add the value into the object file. This won't hurt the COFF code, 757which doesn't use the addend; I'm not sure what it will do to other 758formats (the thing to check for would be whether any formats both use 759the addend and set partial_inplace). 760 761When I wanted to make coff-i386 produce relocatable output, I ran 762into the problem that you are running into: I wanted to remove that 763line. Rather than risk it, I made the coff-i386 relocs use a special 764function; it's coff_i386_reloc in coff-i386.c. The function 765specifically adds the addend field into the object file, knowing that 766bfd_perform_relocation is not going to. If you remove that line, then 767coff-i386.c will wind up adding the addend field in twice. It's 768trivial to fix; it just needs to be done. 769 770The problem with removing the line is just that it may break some 771working code. With BFD it's hard to be sure of anything. The right 772way to deal with this is simply to build and test at least all the 773supported COFF targets. It should be straightforward if time and disk 774space consuming. For each target: 775 1) build the linker 776 2) generate some executable, and link it using -r (I would 777 probably use paranoia.o and link against newlib/libc.a, which 778 for all the supported targets would be available in 779 /usr/cygnus/progressive/H-host/target/lib/libc.a). 780 3) make the change to reloc.c 781 4) rebuild the linker 782 5) repeat step 2 783 6) if the resulting object files are the same, you have at least 784 made it no worse 785 7) if they are different you have to figure out which version is 786 right 787*/ 788 relocation -= reloc_entry->addend; 789 reloc_entry->addend = 0; 790 } 791 else 792 { 793 reloc_entry->addend = relocation; 794 } 795 } 796 } 797 798 /* FIXME: This overflow checking is incomplete, because the value 799 might have overflowed before we get here. For a correct check we 800 need to compute the value in a size larger than bitsize, but we 801 can't reasonably do that for a reloc the same size as a host 802 machine word. 803 FIXME: We should also do overflow checking on the result after 804 adding in the value contained in the object file. */ 805 if (howto->complain_on_overflow != complain_overflow_dont 806 && flag == bfd_reloc_ok) 807 flag = bfd_check_overflow (howto->complain_on_overflow, 808 howto->bitsize, 809 howto->rightshift, 810 bfd_arch_bits_per_address (abfd), 811 relocation); 812 813 /* Either we are relocating all the way, or we don't want to apply 814 the relocation to the reloc entry (probably because there isn't 815 any room in the output format to describe addends to relocs). */ 816 817 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler 818 (OSF version 1.3, compiler version 3.11). It miscompiles the 819 following program: 820 821 struct str 822 { 823 unsigned int i0; 824 } s = { 0 }; 825 826 int 827 main () 828 { 829 unsigned long x; 830 831 x = 0x100000000; 832 x <<= (unsigned long) s.i0; 833 if (x == 0) 834 printf ("failed\n"); 835 else 836 printf ("succeeded (%lx)\n", x); 837 } 838 */ 839 840 relocation >>= (bfd_vma) howto->rightshift; 841 842 /* Shift everything up to where it's going to be used. */ 843 relocation <<= (bfd_vma) howto->bitpos; 844 845 /* Wait for the day when all have the mask in them. */ 846 847 /* What we do: 848 i instruction to be left alone 849 o offset within instruction 850 r relocation offset to apply 851 S src mask 852 D dst mask 853 N ~dst mask 854 A part 1 855 B part 2 856 R result 857 858 Do this: 859 (( i i i i i o o o o o from bfd_get<size> 860 and S S S S S) to get the size offset we want 861 + r r r r r r r r r r) to get the final value to place 862 and D D D D D to chop to right size 863 ----------------------- 864 = A A A A A 865 And this: 866 ( i i i i i o o o o o from bfd_get<size> 867 and N N N N N ) get instruction 868 ----------------------- 869 = B B B B B 870 871 And then: 872 ( B B B B B 873 or A A A A A) 874 ----------------------- 875 = R R R R R R R R R R put into bfd_put<size> 876 */ 877 878#define DOIT(x) \ 879 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask)) 880 881 switch (howto->size) 882 { 883 case 0: 884 { 885 char x = bfd_get_8 (abfd, (char *) data + octets); 886 DOIT (x); 887 bfd_put_8 (abfd, x, (unsigned char *) data + octets); 888 } 889 break; 890 891 case 1: 892 { 893 short x = bfd_get_16 (abfd, (bfd_byte *) data + octets); 894 DOIT (x); 895 bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets); 896 } 897 break; 898 case 2: 899 { 900 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets); 901 DOIT (x); 902 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 903 } 904 break; 905 case -2: 906 { 907 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets); 908 relocation = -relocation; 909 DOIT (x); 910 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 911 } 912 break; 913 914 case -1: 915 { 916 long x = bfd_get_16 (abfd, (bfd_byte *) data + octets); 917 relocation = -relocation; 918 DOIT (x); 919 bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 920 } 921 break; 922 923 case 3: 924 /* Do nothing */ 925 break; 926 927 case 4: 928#ifdef BFD64 929 { 930 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets); 931 DOIT (x); 932 bfd_put_64 (abfd, x, (bfd_byte *) data + octets); 933 } 934#else 935 abort (); 936#endif 937 break; 938 default: 939 return bfd_reloc_other; 940 } 941 942 return flag; 943} 944 945/* 946FUNCTION 947 bfd_install_relocation 948 949SYNOPSIS 950 bfd_reloc_status_type bfd_install_relocation 951 (bfd *abfd, 952 arelent *reloc_entry, 953 void *data, bfd_vma data_start, 954 asection *input_section, 955 char **error_message); 956 957DESCRIPTION 958 This looks remarkably like <<bfd_perform_relocation>>, except it 959 does not expect that the section contents have been filled in. 960 I.e., it's suitable for use when creating, rather than applying 961 a relocation. 962 963 For now, this function should be considered reserved for the 964 assembler. 965*/ 966 967bfd_reloc_status_type 968bfd_install_relocation (bfd *abfd, 969 arelent *reloc_entry, 970 void *data_start, 971 bfd_vma data_start_offset, 972 asection *input_section, 973 char **error_message) 974{ 975 bfd_vma relocation; 976 bfd_reloc_status_type flag = bfd_reloc_ok; 977 bfd_size_type octets; 978 bfd_vma output_base = 0; 979 reloc_howto_type *howto = reloc_entry->howto; 980 asection *reloc_target_output_section; 981 asymbol *symbol; 982 bfd_byte *data; 983 984 symbol = *(reloc_entry->sym_ptr_ptr); 985 986 /* If there is a function supplied to handle this relocation type, 987 call it. It'll return `bfd_reloc_continue' if further processing 988 can be done. */ 989 if (howto && howto->special_function) 990 { 991 bfd_reloc_status_type cont; 992 993 /* XXX - The special_function calls haven't been fixed up to deal 994 with creating new relocations and section contents. */ 995 cont = howto->special_function (abfd, reloc_entry, symbol, 996 /* XXX - Non-portable! */ 997 ((bfd_byte *) data_start 998 - data_start_offset), 999 input_section, abfd, error_message); 1000 if (cont != bfd_reloc_continue) 1001 return cont; 1002 } 1003 1004 if (bfd_is_abs_section (symbol->section)) 1005 { 1006 reloc_entry->address += input_section->output_offset; 1007 return bfd_reloc_ok; 1008 } 1009 1010 /* No need to check for howto != NULL if !bfd_is_abs_section as 1011 it will have been checked in `bfd_perform_relocation already'. */ 1012 1013 /* Is the address of the relocation really within the section? */ 1014 octets = reloc_entry->address * bfd_octets_per_byte (abfd); 1015 if (octets + bfd_get_reloc_size (howto) 1016 > bfd_get_section_limit_octets (abfd, input_section)) 1017 return bfd_reloc_outofrange; 1018 1019 /* Work out which section the relocation is targeted at and the 1020 initial relocation command value. */ 1021 1022 /* Get symbol value. (Common symbols are special.) */ 1023 if (bfd_is_com_section (symbol->section)) 1024 relocation = 0; 1025 else 1026 relocation = symbol->value; 1027 1028 reloc_target_output_section = symbol->section->output_section; 1029 1030 /* Convert input-section-relative symbol value to absolute. */ 1031 if (! howto->partial_inplace) 1032 output_base = 0; 1033 else 1034 output_base = reloc_target_output_section->vma; 1035 1036 relocation += output_base + symbol->section->output_offset; 1037 1038 /* Add in supplied addend. */ 1039 relocation += reloc_entry->addend; 1040 1041 /* Here the variable relocation holds the final address of the 1042 symbol we are relocating against, plus any addend. */ 1043 1044 if (howto->pc_relative) 1045 { 1046 /* This is a PC relative relocation. We want to set RELOCATION 1047 to the distance between the address of the symbol and the 1048 location. RELOCATION is already the address of the symbol. 1049 1050 We start by subtracting the address of the section containing 1051 the location. 1052 1053 If pcrel_offset is set, we must further subtract the position 1054 of the location within the section. Some targets arrange for 1055 the addend to be the negative of the position of the location 1056 within the section; for example, i386-aout does this. For 1057 i386-aout, pcrel_offset is FALSE. Some other targets do not 1058 include the position of the location; for example, m88kbcs, 1059 or ELF. For those targets, pcrel_offset is TRUE. 1060 1061 If we are producing relocatable output, then we must ensure 1062 that this reloc will be correctly computed when the final 1063 relocation is done. If pcrel_offset is FALSE we want to wind 1064 up with the negative of the location within the section, 1065 which means we must adjust the existing addend by the change 1066 in the location within the section. If pcrel_offset is TRUE 1067 we do not want to adjust the existing addend at all. 1068 1069 FIXME: This seems logical to me, but for the case of 1070 producing relocatable output it is not what the code 1071 actually does. I don't want to change it, because it seems 1072 far too likely that something will break. */ 1073 1074 relocation -= 1075 input_section->output_section->vma + input_section->output_offset; 1076 1077 if (howto->pcrel_offset && howto->partial_inplace) 1078 relocation -= reloc_entry->address; 1079 } 1080 1081 if (! howto->partial_inplace) 1082 { 1083 /* This is a partial relocation, and we want to apply the relocation 1084 to the reloc entry rather than the raw data. Modify the reloc 1085 inplace to reflect what we now know. */ 1086 reloc_entry->addend = relocation; 1087 reloc_entry->address += input_section->output_offset; 1088 return flag; 1089 } 1090 else 1091 { 1092 /* This is a partial relocation, but inplace, so modify the 1093 reloc record a bit. 1094 1095 If we've relocated with a symbol with a section, change 1096 into a ref to the section belonging to the symbol. */ 1097 reloc_entry->address += input_section->output_offset; 1098 1099 /* WTF?? */ 1100 if (abfd->xvec->flavour == bfd_target_coff_flavour 1101 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0 1102 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0) 1103 { 1104 1105 /* For m68k-coff, the addend was being subtracted twice during 1106 relocation with -r. Removing the line below this comment 1107 fixes that problem; see PR 2953. 1108 1109However, Ian wrote the following, regarding removing the line below, 1110which explains why it is still enabled: --djm 1111 1112If you put a patch like that into BFD you need to check all the COFF 1113linkers. I am fairly certain that patch will break coff-i386 (e.g., 1114SCO); see coff_i386_reloc in coff-i386.c where I worked around the 1115problem in a different way. There may very well be a reason that the 1116code works as it does. 1117 1118Hmmm. The first obvious point is that bfd_install_relocation should 1119not have any tests that depend upon the flavour. It's seem like 1120entirely the wrong place for such a thing. The second obvious point 1121is that the current code ignores the reloc addend when producing 1122relocatable output for COFF. That's peculiar. In fact, I really 1123have no idea what the point of the line you want to remove is. 1124 1125A typical COFF reloc subtracts the old value of the symbol and adds in 1126the new value to the location in the object file (if it's a pc 1127relative reloc it adds the difference between the symbol value and the 1128location). When relocating we need to preserve that property. 1129 1130BFD handles this by setting the addend to the negative of the old 1131value of the symbol. Unfortunately it handles common symbols in a 1132non-standard way (it doesn't subtract the old value) but that's a 1133different story (we can't change it without losing backward 1134compatibility with old object files) (coff-i386 does subtract the old 1135value, to be compatible with existing coff-i386 targets, like SCO). 1136 1137So everything works fine when not producing relocatable output. When 1138we are producing relocatable output, logically we should do exactly 1139what we do when not producing relocatable output. Therefore, your 1140patch is correct. In fact, it should probably always just set 1141reloc_entry->addend to 0 for all cases, since it is, in fact, going to 1142add the value into the object file. This won't hurt the COFF code, 1143which doesn't use the addend; I'm not sure what it will do to other 1144formats (the thing to check for would be whether any formats both use 1145the addend and set partial_inplace). 1146 1147When I wanted to make coff-i386 produce relocatable output, I ran 1148into the problem that you are running into: I wanted to remove that 1149line. Rather than risk it, I made the coff-i386 relocs use a special 1150function; it's coff_i386_reloc in coff-i386.c. The function 1151specifically adds the addend field into the object file, knowing that 1152bfd_install_relocation is not going to. If you remove that line, then 1153coff-i386.c will wind up adding the addend field in twice. It's 1154trivial to fix; it just needs to be done. 1155 1156The problem with removing the line is just that it may break some 1157working code. With BFD it's hard to be sure of anything. The right 1158way to deal with this is simply to build and test at least all the 1159supported COFF targets. It should be straightforward if time and disk 1160space consuming. For each target: 1161 1) build the linker 1162 2) generate some executable, and link it using -r (I would 1163 probably use paranoia.o and link against newlib/libc.a, which 1164 for all the supported targets would be available in 1165 /usr/cygnus/progressive/H-host/target/lib/libc.a). 1166 3) make the change to reloc.c 1167 4) rebuild the linker 1168 5) repeat step 2 1169 6) if the resulting object files are the same, you have at least 1170 made it no worse 1171 7) if they are different you have to figure out which version is 1172 right. */ 1173 relocation -= reloc_entry->addend; 1174 /* FIXME: There should be no target specific code here... */ 1175 if (strcmp (abfd->xvec->name, "coff-z8k") != 0) 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 bfd_size_type octets = address * bfd_octets_per_byte (input_bfd); 1352 1353 /* Sanity check the address. */ 1354 if (octets + bfd_get_reloc_size (howto) 1355 > bfd_get_section_limit_octets (input_bfd, input_section)) 1356 return bfd_reloc_outofrange; 1357 1358 /* This function assumes that we are dealing with a basic relocation 1359 against a symbol. We want to compute the value of the symbol to 1360 relocate to. This is just VALUE, the value of the symbol, plus 1361 ADDEND, any addend associated with the reloc. */ 1362 relocation = value + addend; 1363 1364 /* If the relocation is PC relative, we want to set RELOCATION to 1365 the distance between the symbol (currently in RELOCATION) and the 1366 location we are relocating. Some targets (e.g., i386-aout) 1367 arrange for the contents of the section to be the negative of the 1368 offset of the location within the section; for such targets 1369 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF) 1370 simply leave the contents of the section as zero; for such 1371 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not 1372 need to subtract out the offset of the location within the 1373 section (which is just ADDRESS). */ 1374 if (howto->pc_relative) 1375 { 1376 relocation -= (input_section->output_section->vma 1377 + input_section->output_offset); 1378 if (howto->pcrel_offset) 1379 relocation -= address; 1380 } 1381 1382 return _bfd_relocate_contents (howto, input_bfd, relocation, 1383 contents 1384 + address * bfd_octets_per_byte (input_bfd)); 1385} 1386 1387/* Relocate a given location using a given value and howto. */ 1388 1389bfd_reloc_status_type 1390_bfd_relocate_contents (reloc_howto_type *howto, 1391 bfd *input_bfd, 1392 bfd_vma relocation, 1393 bfd_byte *location) 1394{ 1395 int size; 1396 bfd_vma x = 0; 1397 bfd_reloc_status_type flag; 1398 unsigned int rightshift = howto->rightshift; 1399 unsigned int bitpos = howto->bitpos; 1400 1401 /* If the size is negative, negate RELOCATION. This isn't very 1402 general. */ 1403 if (howto->size < 0) 1404 relocation = -relocation; 1405 1406 /* Get the value we are going to relocate. */ 1407 size = bfd_get_reloc_size (howto); 1408 switch (size) 1409 { 1410 default: 1411 abort (); 1412 case 0: 1413 return bfd_reloc_ok; 1414 case 1: 1415 x = bfd_get_8 (input_bfd, location); 1416 break; 1417 case 2: 1418 x = bfd_get_16 (input_bfd, location); 1419 break; 1420 case 4: 1421 x = bfd_get_32 (input_bfd, location); 1422 break; 1423 case 8: 1424#ifdef BFD64 1425 x = bfd_get_64 (input_bfd, location); 1426#else 1427 abort (); 1428#endif 1429 break; 1430 } 1431 1432 /* Check for overflow. FIXME: We may drop bits during the addition 1433 which we don't check for. We must either check at every single 1434 operation, which would be tedious, or we must do the computations 1435 in a type larger than bfd_vma, which would be inefficient. */ 1436 flag = bfd_reloc_ok; 1437 if (howto->complain_on_overflow != complain_overflow_dont) 1438 { 1439 bfd_vma addrmask, fieldmask, signmask, ss; 1440 bfd_vma a, b, sum; 1441 1442 /* Get the values to be added together. For signed and unsigned 1443 relocations, we assume that all values should be truncated to 1444 the size of an address. For bitfields, all the bits matter. 1445 See also bfd_check_overflow. */ 1446 fieldmask = N_ONES (howto->bitsize); 1447 signmask = ~fieldmask; 1448 addrmask = (N_ONES (bfd_arch_bits_per_address (input_bfd)) 1449 | (fieldmask << rightshift)); 1450 a = (relocation & addrmask) >> rightshift; 1451 b = (x & howto->src_mask & addrmask) >> bitpos; 1452 addrmask >>= rightshift; 1453 1454 switch (howto->complain_on_overflow) 1455 { 1456 case complain_overflow_signed: 1457 /* If any sign bits are set, all sign bits must be set. 1458 That is, A must be a valid negative address after 1459 shifting. */ 1460 signmask = ~(fieldmask >> 1); 1461 /* Fall thru */ 1462 1463 case complain_overflow_bitfield: 1464 /* Much like the signed check, but for a field one bit 1465 wider. We allow a bitfield to represent numbers in the 1466 range -2**n to 2**n-1, where n is the number of bits in the 1467 field. Note that when bfd_vma is 32 bits, a 32-bit reloc 1468 can't overflow, which is exactly what we want. */ 1469 ss = a & signmask; 1470 if (ss != 0 && ss != (addrmask & signmask)) 1471 flag = bfd_reloc_overflow; 1472 1473 /* We only need this next bit of code if the sign bit of B 1474 is below the sign bit of A. This would only happen if 1475 SRC_MASK had fewer bits than BITSIZE. Note that if 1476 SRC_MASK has more bits than BITSIZE, we can get into 1477 trouble; we would need to verify that B is in range, as 1478 we do for A above. */ 1479 ss = ((~howto->src_mask) >> 1) & howto->src_mask; 1480 ss >>= bitpos; 1481 1482 /* Set all the bits above the sign bit. */ 1483 b = (b ^ ss) - ss; 1484 1485 /* Now we can do the addition. */ 1486 sum = a + b; 1487 1488 /* See if the result has the correct sign. Bits above the 1489 sign bit are junk now; ignore them. If the sum is 1490 positive, make sure we did not have all negative inputs; 1491 if the sum is negative, make sure we did not have all 1492 positive inputs. The test below looks only at the sign 1493 bits, and it really just 1494 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM) 1495 1496 We mask with addrmask here to explicitly allow an address 1497 wrap-around. The Linux kernel relies on it, and it is 1498 the only way to write assembler code which can run when 1499 loaded at a location 0x80000000 away from the location at 1500 which it is linked. */ 1501 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask) 1502 flag = bfd_reloc_overflow; 1503 break; 1504 1505 case complain_overflow_unsigned: 1506 /* Checking for an unsigned overflow is relatively easy: 1507 trim the addresses and add, and trim the result as well. 1508 Overflow is normally indicated when the result does not 1509 fit in the field. However, we also need to consider the 1510 case when, e.g., fieldmask is 0x7fffffff or smaller, an 1511 input is 0x80000000, and bfd_vma is only 32 bits; then we 1512 will get sum == 0, but there is an overflow, since the 1513 inputs did not fit in the field. Instead of doing a 1514 separate test, we can check for this by or-ing in the 1515 operands when testing for the sum overflowing its final 1516 field. */ 1517 sum = (a + b) & addrmask; 1518 if ((a | b | sum) & signmask) 1519 flag = bfd_reloc_overflow; 1520 break; 1521 1522 default: 1523 abort (); 1524 } 1525 } 1526 1527 /* Put RELOCATION in the right bits. */ 1528 relocation >>= (bfd_vma) rightshift; 1529 relocation <<= (bfd_vma) bitpos; 1530 1531 /* Add RELOCATION to the right bits of X. */ 1532 x = ((x & ~howto->dst_mask) 1533 | (((x & howto->src_mask) + relocation) & howto->dst_mask)); 1534 1535 /* Put the relocated value back in the object file. */ 1536 switch (size) 1537 { 1538 default: 1539 abort (); 1540 case 1: 1541 bfd_put_8 (input_bfd, x, location); 1542 break; 1543 case 2: 1544 bfd_put_16 (input_bfd, x, location); 1545 break; 1546 case 4: 1547 bfd_put_32 (input_bfd, x, location); 1548 break; 1549 case 8: 1550#ifdef BFD64 1551 bfd_put_64 (input_bfd, x, location); 1552#else 1553 abort (); 1554#endif 1555 break; 1556 } 1557 1558 return flag; 1559} 1560 1561/* Clear a given location using a given howto, by applying a fixed relocation 1562 value and discarding any in-place addend. This is used for fixed-up 1563 relocations against discarded symbols, to make ignorable debug or unwind 1564 information more obvious. */ 1565 1566void 1567_bfd_clear_contents (reloc_howto_type *howto, 1568 bfd *input_bfd, 1569 asection *input_section, 1570 bfd_byte *location) 1571{ 1572 int size; 1573 bfd_vma x = 0; 1574 1575 /* Get the value we are going to relocate. */ 1576 size = bfd_get_reloc_size (howto); 1577 switch (size) 1578 { 1579 default: 1580 abort (); 1581 case 0: 1582 return; 1583 case 1: 1584 x = bfd_get_8 (input_bfd, location); 1585 break; 1586 case 2: 1587 x = bfd_get_16 (input_bfd, location); 1588 break; 1589 case 4: 1590 x = bfd_get_32 (input_bfd, location); 1591 break; 1592 case 8: 1593#ifdef BFD64 1594 x = bfd_get_64 (input_bfd, location); 1595#else 1596 abort (); 1597#endif 1598 break; 1599 } 1600 1601 /* Zero out the unwanted bits of X. */ 1602 x &= ~howto->dst_mask; 1603 1604 /* For a range list, use 1 instead of 0 as placeholder. 0 1605 would terminate the list, hiding any later entries. */ 1606 if (strcmp (bfd_get_section_name (input_bfd, input_section), 1607 ".debug_ranges") == 0 1608 && (howto->dst_mask & 1) != 0) 1609 x |= 1; 1610 1611 /* Put the relocated value back in the object file. */ 1612 switch (size) 1613 { 1614 default: 1615 case 0: 1616 abort (); 1617 case 1: 1618 bfd_put_8 (input_bfd, x, location); 1619 break; 1620 case 2: 1621 bfd_put_16 (input_bfd, x, location); 1622 break; 1623 case 4: 1624 bfd_put_32 (input_bfd, x, location); 1625 break; 1626 case 8: 1627#ifdef BFD64 1628 bfd_put_64 (input_bfd, x, location); 1629#else 1630 abort (); 1631#endif 1632 break; 1633 } 1634} 1635 1636/* 1637DOCDD 1638INODE 1639 howto manager, , typedef arelent, Relocations 1640 1641SUBSECTION 1642 The howto manager 1643 1644 When an application wants to create a relocation, but doesn't 1645 know what the target machine might call it, it can find out by 1646 using this bit of code. 1647 1648*/ 1649 1650/* 1651TYPEDEF 1652 bfd_reloc_code_type 1653 1654DESCRIPTION 1655 The insides of a reloc code. The idea is that, eventually, there 1656 will be one enumerator for every type of relocation we ever do. 1657 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll 1658 return a howto pointer. 1659 1660 This does mean that the application must determine the correct 1661 enumerator value; you can't get a howto pointer from a random set 1662 of attributes. 1663 1664SENUM 1665 bfd_reloc_code_real 1666 1667ENUM 1668 BFD_RELOC_64 1669ENUMX 1670 BFD_RELOC_32 1671ENUMX 1672 BFD_RELOC_26 1673ENUMX 1674 BFD_RELOC_24 1675ENUMX 1676 BFD_RELOC_16 1677ENUMX 1678 BFD_RELOC_14 1679ENUMX 1680 BFD_RELOC_8 1681ENUMDOC 1682 Basic absolute relocations of N bits. 1683 1684ENUM 1685 BFD_RELOC_64_PCREL 1686ENUMX 1687 BFD_RELOC_32_PCREL 1688ENUMX 1689 BFD_RELOC_24_PCREL 1690ENUMX 1691 BFD_RELOC_16_PCREL 1692ENUMX 1693 BFD_RELOC_12_PCREL 1694ENUMX 1695 BFD_RELOC_8_PCREL 1696ENUMDOC 1697 PC-relative relocations. Sometimes these are relative to the address 1698of the relocation itself; sometimes they are relative to the start of 1699the section containing the relocation. It depends on the specific target. 1700 1701The 24-bit relocation is used in some Intel 960 configurations. 1702 1703ENUM 1704 BFD_RELOC_32_SECREL 1705ENUMDOC 1706 Section relative relocations. Some targets need this for DWARF2. 1707 1708ENUM 1709 BFD_RELOC_32_GOT_PCREL 1710ENUMX 1711 BFD_RELOC_16_GOT_PCREL 1712ENUMX 1713 BFD_RELOC_8_GOT_PCREL 1714ENUMX 1715 BFD_RELOC_32_GOTOFF 1716ENUMX 1717 BFD_RELOC_16_GOTOFF 1718ENUMX 1719 BFD_RELOC_LO16_GOTOFF 1720ENUMX 1721 BFD_RELOC_HI16_GOTOFF 1722ENUMX 1723 BFD_RELOC_HI16_S_GOTOFF 1724ENUMX 1725 BFD_RELOC_8_GOTOFF 1726ENUMX 1727 BFD_RELOC_64_PLT_PCREL 1728ENUMX 1729 BFD_RELOC_32_PLT_PCREL 1730ENUMX 1731 BFD_RELOC_24_PLT_PCREL 1732ENUMX 1733 BFD_RELOC_16_PLT_PCREL 1734ENUMX 1735 BFD_RELOC_8_PLT_PCREL 1736ENUMX 1737 BFD_RELOC_64_PLTOFF 1738ENUMX 1739 BFD_RELOC_32_PLTOFF 1740ENUMX 1741 BFD_RELOC_16_PLTOFF 1742ENUMX 1743 BFD_RELOC_LO16_PLTOFF 1744ENUMX 1745 BFD_RELOC_HI16_PLTOFF 1746ENUMX 1747 BFD_RELOC_HI16_S_PLTOFF 1748ENUMX 1749 BFD_RELOC_8_PLTOFF 1750ENUMDOC 1751 For ELF. 1752 1753ENUM 1754 BFD_RELOC_SIZE32 1755ENUMX 1756 BFD_RELOC_SIZE64 1757ENUMDOC 1758 Size relocations. 1759 1760ENUM 1761 BFD_RELOC_68K_GLOB_DAT 1762ENUMX 1763 BFD_RELOC_68K_JMP_SLOT 1764ENUMX 1765 BFD_RELOC_68K_RELATIVE 1766ENUMX 1767 BFD_RELOC_68K_TLS_GD32 1768ENUMX 1769 BFD_RELOC_68K_TLS_GD16 1770ENUMX 1771 BFD_RELOC_68K_TLS_GD8 1772ENUMX 1773 BFD_RELOC_68K_TLS_LDM32 1774ENUMX 1775 BFD_RELOC_68K_TLS_LDM16 1776ENUMX 1777 BFD_RELOC_68K_TLS_LDM8 1778ENUMX 1779 BFD_RELOC_68K_TLS_LDO32 1780ENUMX 1781 BFD_RELOC_68K_TLS_LDO16 1782ENUMX 1783 BFD_RELOC_68K_TLS_LDO8 1784ENUMX 1785 BFD_RELOC_68K_TLS_IE32 1786ENUMX 1787 BFD_RELOC_68K_TLS_IE16 1788ENUMX 1789 BFD_RELOC_68K_TLS_IE8 1790ENUMX 1791 BFD_RELOC_68K_TLS_LE32 1792ENUMX 1793 BFD_RELOC_68K_TLS_LE16 1794ENUMX 1795 BFD_RELOC_68K_TLS_LE8 1796ENUMDOC 1797 Relocations used by 68K ELF. 1798 1799ENUM 1800 BFD_RELOC_32_BASEREL 1801ENUMX 1802 BFD_RELOC_16_BASEREL 1803ENUMX 1804 BFD_RELOC_LO16_BASEREL 1805ENUMX 1806 BFD_RELOC_HI16_BASEREL 1807ENUMX 1808 BFD_RELOC_HI16_S_BASEREL 1809ENUMX 1810 BFD_RELOC_8_BASEREL 1811ENUMX 1812 BFD_RELOC_RVA 1813ENUMDOC 1814 Linkage-table relative. 1815 1816ENUM 1817 BFD_RELOC_8_FFnn 1818ENUMDOC 1819 Absolute 8-bit relocation, but used to form an address like 0xFFnn. 1820 1821ENUM 1822 BFD_RELOC_32_PCREL_S2 1823ENUMX 1824 BFD_RELOC_16_PCREL_S2 1825ENUMX 1826 BFD_RELOC_23_PCREL_S2 1827ENUMDOC 1828 These PC-relative relocations are stored as word displacements -- 1829i.e., byte displacements shifted right two bits. The 30-bit word 1830displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the 1831SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The 1832signed 16-bit displacement is used on the MIPS, and the 23-bit 1833displacement is used on the Alpha. 1834 1835ENUM 1836 BFD_RELOC_HI22 1837ENUMX 1838 BFD_RELOC_LO10 1839ENUMDOC 1840 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of 1841the target word. These are used on the SPARC. 1842 1843ENUM 1844 BFD_RELOC_GPREL16 1845ENUMX 1846 BFD_RELOC_GPREL32 1847ENUMDOC 1848 For systems that allocate a Global Pointer register, these are 1849displacements off that register. These relocation types are 1850handled specially, because the value the register will have is 1851decided relatively late. 1852 1853ENUM 1854 BFD_RELOC_I960_CALLJ 1855ENUMDOC 1856 Reloc types used for i960/b.out. 1857 1858ENUM 1859 BFD_RELOC_NONE 1860ENUMX 1861 BFD_RELOC_SPARC_WDISP22 1862ENUMX 1863 BFD_RELOC_SPARC22 1864ENUMX 1865 BFD_RELOC_SPARC13 1866ENUMX 1867 BFD_RELOC_SPARC_GOT10 1868ENUMX 1869 BFD_RELOC_SPARC_GOT13 1870ENUMX 1871 BFD_RELOC_SPARC_GOT22 1872ENUMX 1873 BFD_RELOC_SPARC_PC10 1874ENUMX 1875 BFD_RELOC_SPARC_PC22 1876ENUMX 1877 BFD_RELOC_SPARC_WPLT30 1878ENUMX 1879 BFD_RELOC_SPARC_COPY 1880ENUMX 1881 BFD_RELOC_SPARC_GLOB_DAT 1882ENUMX 1883 BFD_RELOC_SPARC_JMP_SLOT 1884ENUMX 1885 BFD_RELOC_SPARC_RELATIVE 1886ENUMX 1887 BFD_RELOC_SPARC_UA16 1888ENUMX 1889 BFD_RELOC_SPARC_UA32 1890ENUMX 1891 BFD_RELOC_SPARC_UA64 1892ENUMX 1893 BFD_RELOC_SPARC_GOTDATA_HIX22 1894ENUMX 1895 BFD_RELOC_SPARC_GOTDATA_LOX10 1896ENUMX 1897 BFD_RELOC_SPARC_GOTDATA_OP_HIX22 1898ENUMX 1899 BFD_RELOC_SPARC_GOTDATA_OP_LOX10 1900ENUMX 1901 BFD_RELOC_SPARC_GOTDATA_OP 1902ENUMX 1903 BFD_RELOC_SPARC_JMP_IREL 1904ENUMX 1905 BFD_RELOC_SPARC_IRELATIVE 1906ENUMDOC 1907 SPARC ELF relocations. There is probably some overlap with other 1908 relocation types already defined. 1909 1910ENUM 1911 BFD_RELOC_SPARC_BASE13 1912ENUMX 1913 BFD_RELOC_SPARC_BASE22 1914ENUMDOC 1915 I think these are specific to SPARC a.out (e.g., Sun 4). 1916 1917ENUMEQ 1918 BFD_RELOC_SPARC_64 1919 BFD_RELOC_64 1920ENUMX 1921 BFD_RELOC_SPARC_10 1922ENUMX 1923 BFD_RELOC_SPARC_11 1924ENUMX 1925 BFD_RELOC_SPARC_OLO10 1926ENUMX 1927 BFD_RELOC_SPARC_HH22 1928ENUMX 1929 BFD_RELOC_SPARC_HM10 1930ENUMX 1931 BFD_RELOC_SPARC_LM22 1932ENUMX 1933 BFD_RELOC_SPARC_PC_HH22 1934ENUMX 1935 BFD_RELOC_SPARC_PC_HM10 1936ENUMX 1937 BFD_RELOC_SPARC_PC_LM22 1938ENUMX 1939 BFD_RELOC_SPARC_WDISP16 1940ENUMX 1941 BFD_RELOC_SPARC_WDISP19 1942ENUMX 1943 BFD_RELOC_SPARC_7 1944ENUMX 1945 BFD_RELOC_SPARC_6 1946ENUMX 1947 BFD_RELOC_SPARC_5 1948ENUMEQX 1949 BFD_RELOC_SPARC_DISP64 1950 BFD_RELOC_64_PCREL 1951ENUMX 1952 BFD_RELOC_SPARC_PLT32 1953ENUMX 1954 BFD_RELOC_SPARC_PLT64 1955ENUMX 1956 BFD_RELOC_SPARC_HIX22 1957ENUMX 1958 BFD_RELOC_SPARC_LOX10 1959ENUMX 1960 BFD_RELOC_SPARC_H44 1961ENUMX 1962 BFD_RELOC_SPARC_M44 1963ENUMX 1964 BFD_RELOC_SPARC_L44 1965ENUMX 1966 BFD_RELOC_SPARC_REGISTER 1967ENUMX 1968 BFD_RELOC_SPARC_H34 1969ENUMX 1970 BFD_RELOC_SPARC_SIZE32 1971ENUMX 1972 BFD_RELOC_SPARC_SIZE64 1973ENUMX 1974 BFD_RELOC_SPARC_WDISP10 1975ENUMDOC 1976 SPARC64 relocations 1977 1978ENUM 1979 BFD_RELOC_SPARC_REV32 1980ENUMDOC 1981 SPARC little endian relocation 1982ENUM 1983 BFD_RELOC_SPARC_TLS_GD_HI22 1984ENUMX 1985 BFD_RELOC_SPARC_TLS_GD_LO10 1986ENUMX 1987 BFD_RELOC_SPARC_TLS_GD_ADD 1988ENUMX 1989 BFD_RELOC_SPARC_TLS_GD_CALL 1990ENUMX 1991 BFD_RELOC_SPARC_TLS_LDM_HI22 1992ENUMX 1993 BFD_RELOC_SPARC_TLS_LDM_LO10 1994ENUMX 1995 BFD_RELOC_SPARC_TLS_LDM_ADD 1996ENUMX 1997 BFD_RELOC_SPARC_TLS_LDM_CALL 1998ENUMX 1999 BFD_RELOC_SPARC_TLS_LDO_HIX22 2000ENUMX 2001 BFD_RELOC_SPARC_TLS_LDO_LOX10 2002ENUMX 2003 BFD_RELOC_SPARC_TLS_LDO_ADD 2004ENUMX 2005 BFD_RELOC_SPARC_TLS_IE_HI22 2006ENUMX 2007 BFD_RELOC_SPARC_TLS_IE_LO10 2008ENUMX 2009 BFD_RELOC_SPARC_TLS_IE_LD 2010ENUMX 2011 BFD_RELOC_SPARC_TLS_IE_LDX 2012ENUMX 2013 BFD_RELOC_SPARC_TLS_IE_ADD 2014ENUMX 2015 BFD_RELOC_SPARC_TLS_LE_HIX22 2016ENUMX 2017 BFD_RELOC_SPARC_TLS_LE_LOX10 2018ENUMX 2019 BFD_RELOC_SPARC_TLS_DTPMOD32 2020ENUMX 2021 BFD_RELOC_SPARC_TLS_DTPMOD64 2022ENUMX 2023 BFD_RELOC_SPARC_TLS_DTPOFF32 2024ENUMX 2025 BFD_RELOC_SPARC_TLS_DTPOFF64 2026ENUMX 2027 BFD_RELOC_SPARC_TLS_TPOFF32 2028ENUMX 2029 BFD_RELOC_SPARC_TLS_TPOFF64 2030ENUMDOC 2031 SPARC TLS relocations 2032 2033ENUM 2034 BFD_RELOC_SPU_IMM7 2035ENUMX 2036 BFD_RELOC_SPU_IMM8 2037ENUMX 2038 BFD_RELOC_SPU_IMM10 2039ENUMX 2040 BFD_RELOC_SPU_IMM10W 2041ENUMX 2042 BFD_RELOC_SPU_IMM16 2043ENUMX 2044 BFD_RELOC_SPU_IMM16W 2045ENUMX 2046 BFD_RELOC_SPU_IMM18 2047ENUMX 2048 BFD_RELOC_SPU_PCREL9a 2049ENUMX 2050 BFD_RELOC_SPU_PCREL9b 2051ENUMX 2052 BFD_RELOC_SPU_PCREL16 2053ENUMX 2054 BFD_RELOC_SPU_LO16 2055ENUMX 2056 BFD_RELOC_SPU_HI16 2057ENUMX 2058 BFD_RELOC_SPU_PPU32 2059ENUMX 2060 BFD_RELOC_SPU_PPU64 2061ENUMX 2062 BFD_RELOC_SPU_ADD_PIC 2063ENUMDOC 2064 SPU Relocations. 2065 2066ENUM 2067 BFD_RELOC_ALPHA_GPDISP_HI16 2068ENUMDOC 2069 Alpha ECOFF and ELF relocations. Some of these treat the symbol or 2070 "addend" in some special way. 2071 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when 2072 writing; when reading, it will be the absolute section symbol. The 2073 addend is the displacement in bytes of the "lda" instruction from 2074 the "ldah" instruction (which is at the address of this reloc). 2075ENUM 2076 BFD_RELOC_ALPHA_GPDISP_LO16 2077ENUMDOC 2078 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as 2079 with GPDISP_HI16 relocs. The addend is ignored when writing the 2080 relocations out, and is filled in with the file's GP value on 2081 reading, for convenience. 2082 2083ENUM 2084 BFD_RELOC_ALPHA_GPDISP 2085ENUMDOC 2086 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 2087 relocation except that there is no accompanying GPDISP_LO16 2088 relocation. 2089 2090ENUM 2091 BFD_RELOC_ALPHA_LITERAL 2092ENUMX 2093 BFD_RELOC_ALPHA_ELF_LITERAL 2094ENUMX 2095 BFD_RELOC_ALPHA_LITUSE 2096ENUMDOC 2097 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; 2098 the assembler turns it into a LDQ instruction to load the address of 2099 the symbol, and then fills in a register in the real instruction. 2100 2101 The LITERAL reloc, at the LDQ instruction, refers to the .lita 2102 section symbol. The addend is ignored when writing, but is filled 2103 in with the file's GP value on reading, for convenience, as with the 2104 GPDISP_LO16 reloc. 2105 2106 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16. 2107 It should refer to the symbol to be referenced, as with 16_GOTOFF, 2108 but it generates output not based on the position within the .got 2109 section, but relative to the GP value chosen for the file during the 2110 final link stage. 2111 2112 The LITUSE reloc, on the instruction using the loaded address, gives 2113 information to the linker that it might be able to use to optimize 2114 away some literal section references. The symbol is ignored (read 2115 as the absolute section symbol), and the "addend" indicates the type 2116 of instruction using the register: 2117 1 - "memory" fmt insn 2118 2 - byte-manipulation (byte offset reg) 2119 3 - jsr (target of branch) 2120 2121ENUM 2122 BFD_RELOC_ALPHA_HINT 2123ENUMDOC 2124 The HINT relocation indicates a value that should be filled into the 2125 "hint" field of a jmp/jsr/ret instruction, for possible branch- 2126 prediction logic which may be provided on some processors. 2127 2128ENUM 2129 BFD_RELOC_ALPHA_LINKAGE 2130ENUMDOC 2131 The LINKAGE relocation outputs a linkage pair in the object file, 2132 which is filled by the linker. 2133 2134ENUM 2135 BFD_RELOC_ALPHA_CODEADDR 2136ENUMDOC 2137 The CODEADDR relocation outputs a STO_CA in the object file, 2138 which is filled by the linker. 2139 2140ENUM 2141 BFD_RELOC_ALPHA_GPREL_HI16 2142ENUMX 2143 BFD_RELOC_ALPHA_GPREL_LO16 2144ENUMDOC 2145 The GPREL_HI/LO relocations together form a 32-bit offset from the 2146 GP register. 2147 2148ENUM 2149 BFD_RELOC_ALPHA_BRSGP 2150ENUMDOC 2151 Like BFD_RELOC_23_PCREL_S2, except that the source and target must 2152 share a common GP, and the target address is adjusted for 2153 STO_ALPHA_STD_GPLOAD. 2154 2155ENUM 2156 BFD_RELOC_ALPHA_NOP 2157ENUMDOC 2158 The NOP relocation outputs a NOP if the longword displacement 2159 between two procedure entry points is < 2^21. 2160 2161ENUM 2162 BFD_RELOC_ALPHA_BSR 2163ENUMDOC 2164 The BSR relocation outputs a BSR if the longword displacement 2165 between two procedure entry points is < 2^21. 2166 2167ENUM 2168 BFD_RELOC_ALPHA_LDA 2169ENUMDOC 2170 The LDA relocation outputs a LDA if the longword displacement 2171 between two procedure entry points is < 2^16. 2172 2173ENUM 2174 BFD_RELOC_ALPHA_BOH 2175ENUMDOC 2176 The BOH relocation outputs a BSR if the longword displacement 2177 between two procedure entry points is < 2^21, or else a hint. 2178 2179ENUM 2180 BFD_RELOC_ALPHA_TLSGD 2181ENUMX 2182 BFD_RELOC_ALPHA_TLSLDM 2183ENUMX 2184 BFD_RELOC_ALPHA_DTPMOD64 2185ENUMX 2186 BFD_RELOC_ALPHA_GOTDTPREL16 2187ENUMX 2188 BFD_RELOC_ALPHA_DTPREL64 2189ENUMX 2190 BFD_RELOC_ALPHA_DTPREL_HI16 2191ENUMX 2192 BFD_RELOC_ALPHA_DTPREL_LO16 2193ENUMX 2194 BFD_RELOC_ALPHA_DTPREL16 2195ENUMX 2196 BFD_RELOC_ALPHA_GOTTPREL16 2197ENUMX 2198 BFD_RELOC_ALPHA_TPREL64 2199ENUMX 2200 BFD_RELOC_ALPHA_TPREL_HI16 2201ENUMX 2202 BFD_RELOC_ALPHA_TPREL_LO16 2203ENUMX 2204 BFD_RELOC_ALPHA_TPREL16 2205ENUMDOC 2206 Alpha thread-local storage relocations. 2207 2208ENUM 2209 BFD_RELOC_MIPS_JMP 2210ENUMX 2211 BFD_RELOC_MICROMIPS_JMP 2212ENUMDOC 2213 The MIPS jump instruction. 2214 2215ENUM 2216 BFD_RELOC_MIPS16_JMP 2217ENUMDOC 2218 The MIPS16 jump instruction. 2219 2220ENUM 2221 BFD_RELOC_MIPS16_GPREL 2222ENUMDOC 2223 MIPS16 GP relative reloc. 2224 2225ENUM 2226 BFD_RELOC_HI16 2227ENUMDOC 2228 High 16 bits of 32-bit value; simple reloc. 2229 2230ENUM 2231 BFD_RELOC_HI16_S 2232ENUMDOC 2233 High 16 bits of 32-bit value but the low 16 bits will be sign 2234 extended and added to form the final result. If the low 16 2235 bits form a negative number, we need to add one to the high value 2236 to compensate for the borrow when the low bits are added. 2237 2238ENUM 2239 BFD_RELOC_LO16 2240ENUMDOC 2241 Low 16 bits. 2242 2243ENUM 2244 BFD_RELOC_HI16_PCREL 2245ENUMDOC 2246 High 16 bits of 32-bit pc-relative value 2247ENUM 2248 BFD_RELOC_HI16_S_PCREL 2249ENUMDOC 2250 High 16 bits of 32-bit pc-relative value, adjusted 2251ENUM 2252 BFD_RELOC_LO16_PCREL 2253ENUMDOC 2254 Low 16 bits of pc-relative value 2255 2256ENUM 2257 BFD_RELOC_MIPS16_GOT16 2258ENUMX 2259 BFD_RELOC_MIPS16_CALL16 2260ENUMDOC 2261 Equivalent of BFD_RELOC_MIPS_*, but with the MIPS16 layout of 2262 16-bit immediate fields 2263ENUM 2264 BFD_RELOC_MIPS16_HI16 2265ENUMDOC 2266 MIPS16 high 16 bits of 32-bit value. 2267ENUM 2268 BFD_RELOC_MIPS16_HI16_S 2269ENUMDOC 2270 MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign 2271 extended and added to form the final result. If the low 16 2272 bits form a negative number, we need to add one to the high value 2273 to compensate for the borrow when the low bits are added. 2274ENUM 2275 BFD_RELOC_MIPS16_LO16 2276ENUMDOC 2277 MIPS16 low 16 bits. 2278 2279ENUM 2280 BFD_RELOC_MIPS16_TLS_GD 2281ENUMX 2282 BFD_RELOC_MIPS16_TLS_LDM 2283ENUMX 2284 BFD_RELOC_MIPS16_TLS_DTPREL_HI16 2285ENUMX 2286 BFD_RELOC_MIPS16_TLS_DTPREL_LO16 2287ENUMX 2288 BFD_RELOC_MIPS16_TLS_GOTTPREL 2289ENUMX 2290 BFD_RELOC_MIPS16_TLS_TPREL_HI16 2291ENUMX 2292 BFD_RELOC_MIPS16_TLS_TPREL_LO16 2293ENUMDOC 2294 MIPS16 TLS relocations 2295 2296ENUM 2297 BFD_RELOC_MIPS_LITERAL 2298ENUMX 2299 BFD_RELOC_MICROMIPS_LITERAL 2300ENUMDOC 2301 Relocation against a MIPS literal section. 2302 2303ENUM 2304 BFD_RELOC_MICROMIPS_7_PCREL_S1 2305ENUMX 2306 BFD_RELOC_MICROMIPS_10_PCREL_S1 2307ENUMX 2308 BFD_RELOC_MICROMIPS_16_PCREL_S1 2309ENUMDOC 2310 microMIPS PC-relative relocations. 2311 2312ENUM 2313 BFD_RELOC_MIPS16_16_PCREL_S1 2314ENUMDOC 2315 MIPS16 PC-relative relocation. 2316 2317ENUM 2318 BFD_RELOC_MIPS_21_PCREL_S2 2319ENUMX 2320 BFD_RELOC_MIPS_26_PCREL_S2 2321ENUMX 2322 BFD_RELOC_MIPS_18_PCREL_S3 2323ENUMX 2324 BFD_RELOC_MIPS_19_PCREL_S2 2325ENUMDOC 2326 MIPS PC-relative relocations. 2327 2328ENUM 2329 BFD_RELOC_MICROMIPS_GPREL16 2330ENUMX 2331 BFD_RELOC_MICROMIPS_HI16 2332ENUMX 2333 BFD_RELOC_MICROMIPS_HI16_S 2334ENUMX 2335 BFD_RELOC_MICROMIPS_LO16 2336ENUMDOC 2337 microMIPS versions of generic BFD relocs. 2338 2339ENUM 2340 BFD_RELOC_MIPS_GOT16 2341ENUMX 2342 BFD_RELOC_MICROMIPS_GOT16 2343ENUMX 2344 BFD_RELOC_MIPS_CALL16 2345ENUMX 2346 BFD_RELOC_MICROMIPS_CALL16 2347ENUMX 2348 BFD_RELOC_MIPS_GOT_HI16 2349ENUMX 2350 BFD_RELOC_MICROMIPS_GOT_HI16 2351ENUMX 2352 BFD_RELOC_MIPS_GOT_LO16 2353ENUMX 2354 BFD_RELOC_MICROMIPS_GOT_LO16 2355ENUMX 2356 BFD_RELOC_MIPS_CALL_HI16 2357ENUMX 2358 BFD_RELOC_MICROMIPS_CALL_HI16 2359ENUMX 2360 BFD_RELOC_MIPS_CALL_LO16 2361ENUMX 2362 BFD_RELOC_MICROMIPS_CALL_LO16 2363ENUMX 2364 BFD_RELOC_MIPS_SUB 2365ENUMX 2366 BFD_RELOC_MICROMIPS_SUB 2367ENUMX 2368 BFD_RELOC_MIPS_GOT_PAGE 2369ENUMX 2370 BFD_RELOC_MICROMIPS_GOT_PAGE 2371ENUMX 2372 BFD_RELOC_MIPS_GOT_OFST 2373ENUMX 2374 BFD_RELOC_MICROMIPS_GOT_OFST 2375ENUMX 2376 BFD_RELOC_MIPS_GOT_DISP 2377ENUMX 2378 BFD_RELOC_MICROMIPS_GOT_DISP 2379ENUMX 2380 BFD_RELOC_MIPS_SHIFT5 2381ENUMX 2382 BFD_RELOC_MIPS_SHIFT6 2383ENUMX 2384 BFD_RELOC_MIPS_INSERT_A 2385ENUMX 2386 BFD_RELOC_MIPS_INSERT_B 2387ENUMX 2388 BFD_RELOC_MIPS_DELETE 2389ENUMX 2390 BFD_RELOC_MIPS_HIGHEST 2391ENUMX 2392 BFD_RELOC_MICROMIPS_HIGHEST 2393ENUMX 2394 BFD_RELOC_MIPS_HIGHER 2395ENUMX 2396 BFD_RELOC_MICROMIPS_HIGHER 2397ENUMX 2398 BFD_RELOC_MIPS_SCN_DISP 2399ENUMX 2400 BFD_RELOC_MICROMIPS_SCN_DISP 2401ENUMX 2402 BFD_RELOC_MIPS_REL16 2403ENUMX 2404 BFD_RELOC_MIPS_RELGOT 2405ENUMX 2406 BFD_RELOC_MIPS_JALR 2407ENUMX 2408 BFD_RELOC_MICROMIPS_JALR 2409ENUMX 2410 BFD_RELOC_MIPS_TLS_DTPMOD32 2411ENUMX 2412 BFD_RELOC_MIPS_TLS_DTPREL32 2413ENUMX 2414 BFD_RELOC_MIPS_TLS_DTPMOD64 2415ENUMX 2416 BFD_RELOC_MIPS_TLS_DTPREL64 2417ENUMX 2418 BFD_RELOC_MIPS_TLS_GD 2419ENUMX 2420 BFD_RELOC_MICROMIPS_TLS_GD 2421ENUMX 2422 BFD_RELOC_MIPS_TLS_LDM 2423ENUMX 2424 BFD_RELOC_MICROMIPS_TLS_LDM 2425ENUMX 2426 BFD_RELOC_MIPS_TLS_DTPREL_HI16 2427ENUMX 2428 BFD_RELOC_MICROMIPS_TLS_DTPREL_HI16 2429ENUMX 2430 BFD_RELOC_MIPS_TLS_DTPREL_LO16 2431ENUMX 2432 BFD_RELOC_MICROMIPS_TLS_DTPREL_LO16 2433ENUMX 2434 BFD_RELOC_MIPS_TLS_GOTTPREL 2435ENUMX 2436 BFD_RELOC_MICROMIPS_TLS_GOTTPREL 2437ENUMX 2438 BFD_RELOC_MIPS_TLS_TPREL32 2439ENUMX 2440 BFD_RELOC_MIPS_TLS_TPREL64 2441ENUMX 2442 BFD_RELOC_MIPS_TLS_TPREL_HI16 2443ENUMX 2444 BFD_RELOC_MICROMIPS_TLS_TPREL_HI16 2445ENUMX 2446 BFD_RELOC_MIPS_TLS_TPREL_LO16 2447ENUMX 2448 BFD_RELOC_MICROMIPS_TLS_TPREL_LO16 2449ENUMX 2450 BFD_RELOC_MIPS_EH 2451ENUMDOC 2452 MIPS ELF relocations. 2453COMMENT 2454 2455ENUM 2456 BFD_RELOC_MIPS_COPY 2457ENUMX 2458 BFD_RELOC_MIPS_JUMP_SLOT 2459ENUMDOC 2460 MIPS ELF relocations (VxWorks and PLT extensions). 2461COMMENT 2462 2463ENUM 2464 BFD_RELOC_MOXIE_10_PCREL 2465ENUMDOC 2466 Moxie ELF relocations. 2467COMMENT 2468 2469ENUM 2470 BFD_RELOC_FT32_10 2471ENUMX 2472 BFD_RELOC_FT32_20 2473ENUMX 2474 BFD_RELOC_FT32_17 2475ENUMX 2476 BFD_RELOC_FT32_18 2477ENUMDOC 2478 FT32 ELF relocations. 2479COMMENT 2480 2481ENUM 2482 BFD_RELOC_FRV_LABEL16 2483ENUMX 2484 BFD_RELOC_FRV_LABEL24 2485ENUMX 2486 BFD_RELOC_FRV_LO16 2487ENUMX 2488 BFD_RELOC_FRV_HI16 2489ENUMX 2490 BFD_RELOC_FRV_GPREL12 2491ENUMX 2492 BFD_RELOC_FRV_GPRELU12 2493ENUMX 2494 BFD_RELOC_FRV_GPREL32 2495ENUMX 2496 BFD_RELOC_FRV_GPRELHI 2497ENUMX 2498 BFD_RELOC_FRV_GPRELLO 2499ENUMX 2500 BFD_RELOC_FRV_GOT12 2501ENUMX 2502 BFD_RELOC_FRV_GOTHI 2503ENUMX 2504 BFD_RELOC_FRV_GOTLO 2505ENUMX 2506 BFD_RELOC_FRV_FUNCDESC 2507ENUMX 2508 BFD_RELOC_FRV_FUNCDESC_GOT12 2509ENUMX 2510 BFD_RELOC_FRV_FUNCDESC_GOTHI 2511ENUMX 2512 BFD_RELOC_FRV_FUNCDESC_GOTLO 2513ENUMX 2514 BFD_RELOC_FRV_FUNCDESC_VALUE 2515ENUMX 2516 BFD_RELOC_FRV_FUNCDESC_GOTOFF12 2517ENUMX 2518 BFD_RELOC_FRV_FUNCDESC_GOTOFFHI 2519ENUMX 2520 BFD_RELOC_FRV_FUNCDESC_GOTOFFLO 2521ENUMX 2522 BFD_RELOC_FRV_GOTOFF12 2523ENUMX 2524 BFD_RELOC_FRV_GOTOFFHI 2525ENUMX 2526 BFD_RELOC_FRV_GOTOFFLO 2527ENUMX 2528 BFD_RELOC_FRV_GETTLSOFF 2529ENUMX 2530 BFD_RELOC_FRV_TLSDESC_VALUE 2531ENUMX 2532 BFD_RELOC_FRV_GOTTLSDESC12 2533ENUMX 2534 BFD_RELOC_FRV_GOTTLSDESCHI 2535ENUMX 2536 BFD_RELOC_FRV_GOTTLSDESCLO 2537ENUMX 2538 BFD_RELOC_FRV_TLSMOFF12 2539ENUMX 2540 BFD_RELOC_FRV_TLSMOFFHI 2541ENUMX 2542 BFD_RELOC_FRV_TLSMOFFLO 2543ENUMX 2544 BFD_RELOC_FRV_GOTTLSOFF12 2545ENUMX 2546 BFD_RELOC_FRV_GOTTLSOFFHI 2547ENUMX 2548 BFD_RELOC_FRV_GOTTLSOFFLO 2549ENUMX 2550 BFD_RELOC_FRV_TLSOFF 2551ENUMX 2552 BFD_RELOC_FRV_TLSDESC_RELAX 2553ENUMX 2554 BFD_RELOC_FRV_GETTLSOFF_RELAX 2555ENUMX 2556 BFD_RELOC_FRV_TLSOFF_RELAX 2557ENUMX 2558 BFD_RELOC_FRV_TLSMOFF 2559ENUMDOC 2560 Fujitsu Frv Relocations. 2561COMMENT 2562 2563ENUM 2564 BFD_RELOC_MN10300_GOTOFF24 2565ENUMDOC 2566 This is a 24bit GOT-relative reloc for the mn10300. 2567ENUM 2568 BFD_RELOC_MN10300_GOT32 2569ENUMDOC 2570 This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes 2571 in the instruction. 2572ENUM 2573 BFD_RELOC_MN10300_GOT24 2574ENUMDOC 2575 This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes 2576 in the instruction. 2577ENUM 2578 BFD_RELOC_MN10300_GOT16 2579ENUMDOC 2580 This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes 2581 in the instruction. 2582ENUM 2583 BFD_RELOC_MN10300_COPY 2584ENUMDOC 2585 Copy symbol at runtime. 2586ENUM 2587 BFD_RELOC_MN10300_GLOB_DAT 2588ENUMDOC 2589 Create GOT entry. 2590ENUM 2591 BFD_RELOC_MN10300_JMP_SLOT 2592ENUMDOC 2593 Create PLT entry. 2594ENUM 2595 BFD_RELOC_MN10300_RELATIVE 2596ENUMDOC 2597 Adjust by program base. 2598ENUM 2599 BFD_RELOC_MN10300_SYM_DIFF 2600ENUMDOC 2601 Together with another reloc targeted at the same location, 2602 allows for a value that is the difference of two symbols 2603 in the same section. 2604ENUM 2605 BFD_RELOC_MN10300_ALIGN 2606ENUMDOC 2607 The addend of this reloc is an alignment power that must 2608 be honoured at the offset's location, regardless of linker 2609 relaxation. 2610ENUM 2611 BFD_RELOC_MN10300_TLS_GD 2612ENUMX 2613 BFD_RELOC_MN10300_TLS_LD 2614ENUMX 2615 BFD_RELOC_MN10300_TLS_LDO 2616ENUMX 2617 BFD_RELOC_MN10300_TLS_GOTIE 2618ENUMX 2619 BFD_RELOC_MN10300_TLS_IE 2620ENUMX 2621 BFD_RELOC_MN10300_TLS_LE 2622ENUMX 2623 BFD_RELOC_MN10300_TLS_DTPMOD 2624ENUMX 2625 BFD_RELOC_MN10300_TLS_DTPOFF 2626ENUMX 2627 BFD_RELOC_MN10300_TLS_TPOFF 2628ENUMDOC 2629 Various TLS-related relocations. 2630ENUM 2631 BFD_RELOC_MN10300_32_PCREL 2632ENUMDOC 2633 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the 2634 instruction. 2635ENUM 2636 BFD_RELOC_MN10300_16_PCREL 2637ENUMDOC 2638 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the 2639 instruction. 2640COMMENT 2641 2642ENUM 2643 BFD_RELOC_386_GOT32 2644ENUMX 2645 BFD_RELOC_386_PLT32 2646ENUMX 2647 BFD_RELOC_386_COPY 2648ENUMX 2649 BFD_RELOC_386_GLOB_DAT 2650ENUMX 2651 BFD_RELOC_386_JUMP_SLOT 2652ENUMX 2653 BFD_RELOC_386_RELATIVE 2654ENUMX 2655 BFD_RELOC_386_GOTOFF 2656ENUMX 2657 BFD_RELOC_386_GOTPC 2658ENUMX 2659 BFD_RELOC_386_TLS_TPOFF 2660ENUMX 2661 BFD_RELOC_386_TLS_IE 2662ENUMX 2663 BFD_RELOC_386_TLS_GOTIE 2664ENUMX 2665 BFD_RELOC_386_TLS_LE 2666ENUMX 2667 BFD_RELOC_386_TLS_GD 2668ENUMX 2669 BFD_RELOC_386_TLS_LDM 2670ENUMX 2671 BFD_RELOC_386_TLS_LDO_32 2672ENUMX 2673 BFD_RELOC_386_TLS_IE_32 2674ENUMX 2675 BFD_RELOC_386_TLS_LE_32 2676ENUMX 2677 BFD_RELOC_386_TLS_DTPMOD32 2678ENUMX 2679 BFD_RELOC_386_TLS_DTPOFF32 2680ENUMX 2681 BFD_RELOC_386_TLS_TPOFF32 2682ENUMX 2683 BFD_RELOC_386_TLS_GOTDESC 2684ENUMX 2685 BFD_RELOC_386_TLS_DESC_CALL 2686ENUMX 2687 BFD_RELOC_386_TLS_DESC 2688ENUMX 2689 BFD_RELOC_386_IRELATIVE 2690ENUMX 2691 BFD_RELOC_386_GOT32X 2692ENUMDOC 2693 i386/elf relocations 2694 2695ENUM 2696 BFD_RELOC_X86_64_GOT32 2697ENUMX 2698 BFD_RELOC_X86_64_PLT32 2699ENUMX 2700 BFD_RELOC_X86_64_COPY 2701ENUMX 2702 BFD_RELOC_X86_64_GLOB_DAT 2703ENUMX 2704 BFD_RELOC_X86_64_JUMP_SLOT 2705ENUMX 2706 BFD_RELOC_X86_64_RELATIVE 2707ENUMX 2708 BFD_RELOC_X86_64_GOTPCREL 2709ENUMX 2710 BFD_RELOC_X86_64_32S 2711ENUMX 2712 BFD_RELOC_X86_64_DTPMOD64 2713ENUMX 2714 BFD_RELOC_X86_64_DTPOFF64 2715ENUMX 2716 BFD_RELOC_X86_64_TPOFF64 2717ENUMX 2718 BFD_RELOC_X86_64_TLSGD 2719ENUMX 2720 BFD_RELOC_X86_64_TLSLD 2721ENUMX 2722 BFD_RELOC_X86_64_DTPOFF32 2723ENUMX 2724 BFD_RELOC_X86_64_GOTTPOFF 2725ENUMX 2726 BFD_RELOC_X86_64_TPOFF32 2727ENUMX 2728 BFD_RELOC_X86_64_GOTOFF64 2729ENUMX 2730 BFD_RELOC_X86_64_GOTPC32 2731ENUMX 2732 BFD_RELOC_X86_64_GOT64 2733ENUMX 2734 BFD_RELOC_X86_64_GOTPCREL64 2735ENUMX 2736 BFD_RELOC_X86_64_GOTPC64 2737ENUMX 2738 BFD_RELOC_X86_64_GOTPLT64 2739ENUMX 2740 BFD_RELOC_X86_64_PLTOFF64 2741ENUMX 2742 BFD_RELOC_X86_64_GOTPC32_TLSDESC 2743ENUMX 2744 BFD_RELOC_X86_64_TLSDESC_CALL 2745ENUMX 2746 BFD_RELOC_X86_64_TLSDESC 2747ENUMX 2748 BFD_RELOC_X86_64_IRELATIVE 2749ENUMX 2750 BFD_RELOC_X86_64_PC32_BND 2751ENUMX 2752 BFD_RELOC_X86_64_PLT32_BND 2753ENUMX 2754 BFD_RELOC_X86_64_GOTPCRELX 2755ENUMX 2756 BFD_RELOC_X86_64_REX_GOTPCRELX 2757ENUMDOC 2758 x86-64/elf relocations 2759 2760ENUM 2761 BFD_RELOC_NS32K_IMM_8 2762ENUMX 2763 BFD_RELOC_NS32K_IMM_16 2764ENUMX 2765 BFD_RELOC_NS32K_IMM_32 2766ENUMX 2767 BFD_RELOC_NS32K_IMM_8_PCREL 2768ENUMX 2769 BFD_RELOC_NS32K_IMM_16_PCREL 2770ENUMX 2771 BFD_RELOC_NS32K_IMM_32_PCREL 2772ENUMX 2773 BFD_RELOC_NS32K_DISP_8 2774ENUMX 2775 BFD_RELOC_NS32K_DISP_16 2776ENUMX 2777 BFD_RELOC_NS32K_DISP_32 2778ENUMX 2779 BFD_RELOC_NS32K_DISP_8_PCREL 2780ENUMX 2781 BFD_RELOC_NS32K_DISP_16_PCREL 2782ENUMX 2783 BFD_RELOC_NS32K_DISP_32_PCREL 2784ENUMDOC 2785 ns32k relocations 2786 2787ENUM 2788 BFD_RELOC_PDP11_DISP_8_PCREL 2789ENUMX 2790 BFD_RELOC_PDP11_DISP_6_PCREL 2791ENUMDOC 2792 PDP11 relocations 2793 2794ENUM 2795 BFD_RELOC_PJ_CODE_HI16 2796ENUMX 2797 BFD_RELOC_PJ_CODE_LO16 2798ENUMX 2799 BFD_RELOC_PJ_CODE_DIR16 2800ENUMX 2801 BFD_RELOC_PJ_CODE_DIR32 2802ENUMX 2803 BFD_RELOC_PJ_CODE_REL16 2804ENUMX 2805 BFD_RELOC_PJ_CODE_REL32 2806ENUMDOC 2807 Picojava relocs. Not all of these appear in object files. 2808 2809ENUM 2810 BFD_RELOC_PPC_B26 2811ENUMX 2812 BFD_RELOC_PPC_BA26 2813ENUMX 2814 BFD_RELOC_PPC_TOC16 2815ENUMX 2816 BFD_RELOC_PPC_B16 2817ENUMX 2818 BFD_RELOC_PPC_B16_BRTAKEN 2819ENUMX 2820 BFD_RELOC_PPC_B16_BRNTAKEN 2821ENUMX 2822 BFD_RELOC_PPC_BA16 2823ENUMX 2824 BFD_RELOC_PPC_BA16_BRTAKEN 2825ENUMX 2826 BFD_RELOC_PPC_BA16_BRNTAKEN 2827ENUMX 2828 BFD_RELOC_PPC_COPY 2829ENUMX 2830 BFD_RELOC_PPC_GLOB_DAT 2831ENUMX 2832 BFD_RELOC_PPC_JMP_SLOT 2833ENUMX 2834 BFD_RELOC_PPC_RELATIVE 2835ENUMX 2836 BFD_RELOC_PPC_LOCAL24PC 2837ENUMX 2838 BFD_RELOC_PPC_EMB_NADDR32 2839ENUMX 2840 BFD_RELOC_PPC_EMB_NADDR16 2841ENUMX 2842 BFD_RELOC_PPC_EMB_NADDR16_LO 2843ENUMX 2844 BFD_RELOC_PPC_EMB_NADDR16_HI 2845ENUMX 2846 BFD_RELOC_PPC_EMB_NADDR16_HA 2847ENUMX 2848 BFD_RELOC_PPC_EMB_SDAI16 2849ENUMX 2850 BFD_RELOC_PPC_EMB_SDA2I16 2851ENUMX 2852 BFD_RELOC_PPC_EMB_SDA2REL 2853ENUMX 2854 BFD_RELOC_PPC_EMB_SDA21 2855ENUMX 2856 BFD_RELOC_PPC_EMB_MRKREF 2857ENUMX 2858 BFD_RELOC_PPC_EMB_RELSEC16 2859ENUMX 2860 BFD_RELOC_PPC_EMB_RELST_LO 2861ENUMX 2862 BFD_RELOC_PPC_EMB_RELST_HI 2863ENUMX 2864 BFD_RELOC_PPC_EMB_RELST_HA 2865ENUMX 2866 BFD_RELOC_PPC_EMB_BIT_FLD 2867ENUMX 2868 BFD_RELOC_PPC_EMB_RELSDA 2869ENUMX 2870 BFD_RELOC_PPC_VLE_REL8 2871ENUMX 2872 BFD_RELOC_PPC_VLE_REL15 2873ENUMX 2874 BFD_RELOC_PPC_VLE_REL24 2875ENUMX 2876 BFD_RELOC_PPC_VLE_LO16A 2877ENUMX 2878 BFD_RELOC_PPC_VLE_LO16D 2879ENUMX 2880 BFD_RELOC_PPC_VLE_HI16A 2881ENUMX 2882 BFD_RELOC_PPC_VLE_HI16D 2883ENUMX 2884 BFD_RELOC_PPC_VLE_HA16A 2885ENUMX 2886 BFD_RELOC_PPC_VLE_HA16D 2887ENUMX 2888 BFD_RELOC_PPC_VLE_SDA21 2889ENUMX 2890 BFD_RELOC_PPC_VLE_SDA21_LO 2891ENUMX 2892 BFD_RELOC_PPC_VLE_SDAREL_LO16A 2893ENUMX 2894 BFD_RELOC_PPC_VLE_SDAREL_LO16D 2895ENUMX 2896 BFD_RELOC_PPC_VLE_SDAREL_HI16A 2897ENUMX 2898 BFD_RELOC_PPC_VLE_SDAREL_HI16D 2899ENUMX 2900 BFD_RELOC_PPC_VLE_SDAREL_HA16A 2901ENUMX 2902 BFD_RELOC_PPC_VLE_SDAREL_HA16D 2903ENUMX 2904 BFD_RELOC_PPC_16DX_HA 2905ENUMX 2906 BFD_RELOC_PPC_REL16DX_HA 2907ENUMX 2908 BFD_RELOC_PPC64_HIGHER 2909ENUMX 2910 BFD_RELOC_PPC64_HIGHER_S 2911ENUMX 2912 BFD_RELOC_PPC64_HIGHEST 2913ENUMX 2914 BFD_RELOC_PPC64_HIGHEST_S 2915ENUMX 2916 BFD_RELOC_PPC64_TOC16_LO 2917ENUMX 2918 BFD_RELOC_PPC64_TOC16_HI 2919ENUMX 2920 BFD_RELOC_PPC64_TOC16_HA 2921ENUMX 2922 BFD_RELOC_PPC64_TOC 2923ENUMX 2924 BFD_RELOC_PPC64_PLTGOT16 2925ENUMX 2926 BFD_RELOC_PPC64_PLTGOT16_LO 2927ENUMX 2928 BFD_RELOC_PPC64_PLTGOT16_HI 2929ENUMX 2930 BFD_RELOC_PPC64_PLTGOT16_HA 2931ENUMX 2932 BFD_RELOC_PPC64_ADDR16_DS 2933ENUMX 2934 BFD_RELOC_PPC64_ADDR16_LO_DS 2935ENUMX 2936 BFD_RELOC_PPC64_GOT16_DS 2937ENUMX 2938 BFD_RELOC_PPC64_GOT16_LO_DS 2939ENUMX 2940 BFD_RELOC_PPC64_PLT16_LO_DS 2941ENUMX 2942 BFD_RELOC_PPC64_SECTOFF_DS 2943ENUMX 2944 BFD_RELOC_PPC64_SECTOFF_LO_DS 2945ENUMX 2946 BFD_RELOC_PPC64_TOC16_DS 2947ENUMX 2948 BFD_RELOC_PPC64_TOC16_LO_DS 2949ENUMX 2950 BFD_RELOC_PPC64_PLTGOT16_DS 2951ENUMX 2952 BFD_RELOC_PPC64_PLTGOT16_LO_DS 2953ENUMX 2954 BFD_RELOC_PPC64_ADDR16_HIGH 2955ENUMX 2956 BFD_RELOC_PPC64_ADDR16_HIGHA 2957ENUMX 2958 BFD_RELOC_PPC64_ADDR64_LOCAL 2959ENUMX 2960 BFD_RELOC_PPC64_ENTRY 2961ENUMDOC 2962 Power(rs6000) and PowerPC relocations. 2963 2964ENUM 2965 BFD_RELOC_PPC_TLS 2966ENUMX 2967 BFD_RELOC_PPC_TLSGD 2968ENUMX 2969 BFD_RELOC_PPC_TLSLD 2970ENUMX 2971 BFD_RELOC_PPC_DTPMOD 2972ENUMX 2973 BFD_RELOC_PPC_TPREL16 2974ENUMX 2975 BFD_RELOC_PPC_TPREL16_LO 2976ENUMX 2977 BFD_RELOC_PPC_TPREL16_HI 2978ENUMX 2979 BFD_RELOC_PPC_TPREL16_HA 2980ENUMX 2981 BFD_RELOC_PPC_TPREL 2982ENUMX 2983 BFD_RELOC_PPC_DTPREL16 2984ENUMX 2985 BFD_RELOC_PPC_DTPREL16_LO 2986ENUMX 2987 BFD_RELOC_PPC_DTPREL16_HI 2988ENUMX 2989 BFD_RELOC_PPC_DTPREL16_HA 2990ENUMX 2991 BFD_RELOC_PPC_DTPREL 2992ENUMX 2993 BFD_RELOC_PPC_GOT_TLSGD16 2994ENUMX 2995 BFD_RELOC_PPC_GOT_TLSGD16_LO 2996ENUMX 2997 BFD_RELOC_PPC_GOT_TLSGD16_HI 2998ENUMX 2999 BFD_RELOC_PPC_GOT_TLSGD16_HA 3000ENUMX 3001 BFD_RELOC_PPC_GOT_TLSLD16 3002ENUMX 3003 BFD_RELOC_PPC_GOT_TLSLD16_LO 3004ENUMX 3005 BFD_RELOC_PPC_GOT_TLSLD16_HI 3006ENUMX 3007 BFD_RELOC_PPC_GOT_TLSLD16_HA 3008ENUMX 3009 BFD_RELOC_PPC_GOT_TPREL16 3010ENUMX 3011 BFD_RELOC_PPC_GOT_TPREL16_LO 3012ENUMX 3013 BFD_RELOC_PPC_GOT_TPREL16_HI 3014ENUMX 3015 BFD_RELOC_PPC_GOT_TPREL16_HA 3016ENUMX 3017 BFD_RELOC_PPC_GOT_DTPREL16 3018ENUMX 3019 BFD_RELOC_PPC_GOT_DTPREL16_LO 3020ENUMX 3021 BFD_RELOC_PPC_GOT_DTPREL16_HI 3022ENUMX 3023 BFD_RELOC_PPC_GOT_DTPREL16_HA 3024ENUMX 3025 BFD_RELOC_PPC64_TPREL16_DS 3026ENUMX 3027 BFD_RELOC_PPC64_TPREL16_LO_DS 3028ENUMX 3029 BFD_RELOC_PPC64_TPREL16_HIGHER 3030ENUMX 3031 BFD_RELOC_PPC64_TPREL16_HIGHERA 3032ENUMX 3033 BFD_RELOC_PPC64_TPREL16_HIGHEST 3034ENUMX 3035 BFD_RELOC_PPC64_TPREL16_HIGHESTA 3036ENUMX 3037 BFD_RELOC_PPC64_DTPREL16_DS 3038ENUMX 3039 BFD_RELOC_PPC64_DTPREL16_LO_DS 3040ENUMX 3041 BFD_RELOC_PPC64_DTPREL16_HIGHER 3042ENUMX 3043 BFD_RELOC_PPC64_DTPREL16_HIGHERA 3044ENUMX 3045 BFD_RELOC_PPC64_DTPREL16_HIGHEST 3046ENUMX 3047 BFD_RELOC_PPC64_DTPREL16_HIGHESTA 3048ENUMX 3049 BFD_RELOC_PPC64_TPREL16_HIGH 3050ENUMX 3051 BFD_RELOC_PPC64_TPREL16_HIGHA 3052ENUMX 3053 BFD_RELOC_PPC64_DTPREL16_HIGH 3054ENUMX 3055 BFD_RELOC_PPC64_DTPREL16_HIGHA 3056ENUMDOC 3057 PowerPC and PowerPC64 thread-local storage relocations. 3058 3059ENUM 3060 BFD_RELOC_I370_D12 3061ENUMDOC 3062 IBM 370/390 relocations 3063 3064ENUM 3065 BFD_RELOC_CTOR 3066ENUMDOC 3067 The type of reloc used to build a constructor table - at the moment 3068 probably a 32 bit wide absolute relocation, but the target can choose. 3069 It generally does map to one of the other relocation types. 3070 3071ENUM 3072 BFD_RELOC_ARM_PCREL_BRANCH 3073ENUMDOC 3074 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are 3075 not stored in the instruction. 3076ENUM 3077 BFD_RELOC_ARM_PCREL_BLX 3078ENUMDOC 3079 ARM 26 bit pc-relative branch. The lowest bit must be zero and is 3080 not stored in the instruction. The 2nd lowest bit comes from a 1 bit 3081 field in the instruction. 3082ENUM 3083 BFD_RELOC_THUMB_PCREL_BLX 3084ENUMDOC 3085 Thumb 22 bit pc-relative branch. The lowest bit must be zero and is 3086 not stored in the instruction. The 2nd lowest bit comes from a 1 bit 3087 field in the instruction. 3088ENUM 3089 BFD_RELOC_ARM_PCREL_CALL 3090ENUMDOC 3091 ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction. 3092ENUM 3093 BFD_RELOC_ARM_PCREL_JUMP 3094ENUMDOC 3095 ARM 26-bit pc-relative branch for B or conditional BL instruction. 3096 3097ENUM 3098 BFD_RELOC_THUMB_PCREL_BRANCH7 3099ENUMX 3100 BFD_RELOC_THUMB_PCREL_BRANCH9 3101ENUMX 3102 BFD_RELOC_THUMB_PCREL_BRANCH12 3103ENUMX 3104 BFD_RELOC_THUMB_PCREL_BRANCH20 3105ENUMX 3106 BFD_RELOC_THUMB_PCREL_BRANCH23 3107ENUMX 3108 BFD_RELOC_THUMB_PCREL_BRANCH25 3109ENUMDOC 3110 Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches. 3111 The lowest bit must be zero and is not stored in the instruction. 3112 Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an 3113 "nn" one smaller in all cases. Note further that BRANCH23 3114 corresponds to R_ARM_THM_CALL. 3115 3116ENUM 3117 BFD_RELOC_ARM_OFFSET_IMM 3118ENUMDOC 3119 12-bit immediate offset, used in ARM-format ldr and str instructions. 3120 3121ENUM 3122 BFD_RELOC_ARM_THUMB_OFFSET 3123ENUMDOC 3124 5-bit immediate offset, used in Thumb-format ldr and str instructions. 3125 3126ENUM 3127 BFD_RELOC_ARM_TARGET1 3128ENUMDOC 3129 Pc-relative or absolute relocation depending on target. Used for 3130 entries in .init_array sections. 3131ENUM 3132 BFD_RELOC_ARM_ROSEGREL32 3133ENUMDOC 3134 Read-only segment base relative address. 3135ENUM 3136 BFD_RELOC_ARM_SBREL32 3137ENUMDOC 3138 Data segment base relative address. 3139ENUM 3140 BFD_RELOC_ARM_TARGET2 3141ENUMDOC 3142 This reloc is used for references to RTTI data from exception handling 3143 tables. The actual definition depends on the target. It may be a 3144 pc-relative or some form of GOT-indirect relocation. 3145ENUM 3146 BFD_RELOC_ARM_PREL31 3147ENUMDOC 3148 31-bit PC relative address. 3149ENUM 3150 BFD_RELOC_ARM_MOVW 3151ENUMX 3152 BFD_RELOC_ARM_MOVT 3153ENUMX 3154 BFD_RELOC_ARM_MOVW_PCREL 3155ENUMX 3156 BFD_RELOC_ARM_MOVT_PCREL 3157ENUMX 3158 BFD_RELOC_ARM_THUMB_MOVW 3159ENUMX 3160 BFD_RELOC_ARM_THUMB_MOVT 3161ENUMX 3162 BFD_RELOC_ARM_THUMB_MOVW_PCREL 3163ENUMX 3164 BFD_RELOC_ARM_THUMB_MOVT_PCREL 3165ENUMDOC 3166 Low and High halfword relocations for MOVW and MOVT instructions. 3167 3168ENUM 3169 BFD_RELOC_ARM_JUMP_SLOT 3170ENUMX 3171 BFD_RELOC_ARM_GLOB_DAT 3172ENUMX 3173 BFD_RELOC_ARM_GOT32 3174ENUMX 3175 BFD_RELOC_ARM_PLT32 3176ENUMX 3177 BFD_RELOC_ARM_RELATIVE 3178ENUMX 3179 BFD_RELOC_ARM_GOTOFF 3180ENUMX 3181 BFD_RELOC_ARM_GOTPC 3182ENUMX 3183 BFD_RELOC_ARM_GOT_PREL 3184ENUMDOC 3185 Relocations for setting up GOTs and PLTs for shared libraries. 3186 3187ENUM 3188 BFD_RELOC_ARM_TLS_GD32 3189ENUMX 3190 BFD_RELOC_ARM_TLS_LDO32 3191ENUMX 3192 BFD_RELOC_ARM_TLS_LDM32 3193ENUMX 3194 BFD_RELOC_ARM_TLS_DTPOFF32 3195ENUMX 3196 BFD_RELOC_ARM_TLS_DTPMOD32 3197ENUMX 3198 BFD_RELOC_ARM_TLS_TPOFF32 3199ENUMX 3200 BFD_RELOC_ARM_TLS_IE32 3201ENUMX 3202 BFD_RELOC_ARM_TLS_LE32 3203ENUMX 3204 BFD_RELOC_ARM_TLS_GOTDESC 3205ENUMX 3206 BFD_RELOC_ARM_TLS_CALL 3207ENUMX 3208 BFD_RELOC_ARM_THM_TLS_CALL 3209ENUMX 3210 BFD_RELOC_ARM_TLS_DESCSEQ 3211ENUMX 3212 BFD_RELOC_ARM_THM_TLS_DESCSEQ 3213ENUMX 3214 BFD_RELOC_ARM_TLS_DESC 3215ENUMDOC 3216 ARM thread-local storage relocations. 3217 3218ENUM 3219 BFD_RELOC_ARM_ALU_PC_G0_NC 3220ENUMX 3221 BFD_RELOC_ARM_ALU_PC_G0 3222ENUMX 3223 BFD_RELOC_ARM_ALU_PC_G1_NC 3224ENUMX 3225 BFD_RELOC_ARM_ALU_PC_G1 3226ENUMX 3227 BFD_RELOC_ARM_ALU_PC_G2 3228ENUMX 3229 BFD_RELOC_ARM_LDR_PC_G0 3230ENUMX 3231 BFD_RELOC_ARM_LDR_PC_G1 3232ENUMX 3233 BFD_RELOC_ARM_LDR_PC_G2 3234ENUMX 3235 BFD_RELOC_ARM_LDRS_PC_G0 3236ENUMX 3237 BFD_RELOC_ARM_LDRS_PC_G1 3238ENUMX 3239 BFD_RELOC_ARM_LDRS_PC_G2 3240ENUMX 3241 BFD_RELOC_ARM_LDC_PC_G0 3242ENUMX 3243 BFD_RELOC_ARM_LDC_PC_G1 3244ENUMX 3245 BFD_RELOC_ARM_LDC_PC_G2 3246ENUMX 3247 BFD_RELOC_ARM_ALU_SB_G0_NC 3248ENUMX 3249 BFD_RELOC_ARM_ALU_SB_G0 3250ENUMX 3251 BFD_RELOC_ARM_ALU_SB_G1_NC 3252ENUMX 3253 BFD_RELOC_ARM_ALU_SB_G1 3254ENUMX 3255 BFD_RELOC_ARM_ALU_SB_G2 3256ENUMX 3257 BFD_RELOC_ARM_LDR_SB_G0 3258ENUMX 3259 BFD_RELOC_ARM_LDR_SB_G1 3260ENUMX 3261 BFD_RELOC_ARM_LDR_SB_G2 3262ENUMX 3263 BFD_RELOC_ARM_LDRS_SB_G0 3264ENUMX 3265 BFD_RELOC_ARM_LDRS_SB_G1 3266ENUMX 3267 BFD_RELOC_ARM_LDRS_SB_G2 3268ENUMX 3269 BFD_RELOC_ARM_LDC_SB_G0 3270ENUMX 3271 BFD_RELOC_ARM_LDC_SB_G1 3272ENUMX 3273 BFD_RELOC_ARM_LDC_SB_G2 3274ENUMDOC 3275 ARM group relocations. 3276 3277ENUM 3278 BFD_RELOC_ARM_V4BX 3279ENUMDOC 3280 Annotation of BX instructions. 3281 3282ENUM 3283 BFD_RELOC_ARM_IRELATIVE 3284ENUMDOC 3285 ARM support for STT_GNU_IFUNC. 3286 3287ENUM 3288 BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC 3289ENUMX 3290 BFD_RELOC_ARM_THUMB_ALU_ABS_G1_NC 3291ENUMX 3292 BFD_RELOC_ARM_THUMB_ALU_ABS_G2_NC 3293ENUMX 3294 BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC 3295ENUMDOC 3296 Thumb1 relocations to support execute-only code. 3297 3298ENUM 3299 BFD_RELOC_ARM_IMMEDIATE 3300ENUMX 3301 BFD_RELOC_ARM_ADRL_IMMEDIATE 3302ENUMX 3303 BFD_RELOC_ARM_T32_IMMEDIATE 3304ENUMX 3305 BFD_RELOC_ARM_T32_ADD_IMM 3306ENUMX 3307 BFD_RELOC_ARM_T32_IMM12 3308ENUMX 3309 BFD_RELOC_ARM_T32_ADD_PC12 3310ENUMX 3311 BFD_RELOC_ARM_SHIFT_IMM 3312ENUMX 3313 BFD_RELOC_ARM_SMC 3314ENUMX 3315 BFD_RELOC_ARM_HVC 3316ENUMX 3317 BFD_RELOC_ARM_SWI 3318ENUMX 3319 BFD_RELOC_ARM_MULTI 3320ENUMX 3321 BFD_RELOC_ARM_CP_OFF_IMM 3322ENUMX 3323 BFD_RELOC_ARM_CP_OFF_IMM_S2 3324ENUMX 3325 BFD_RELOC_ARM_T32_CP_OFF_IMM 3326ENUMX 3327 BFD_RELOC_ARM_T32_CP_OFF_IMM_S2 3328ENUMX 3329 BFD_RELOC_ARM_ADR_IMM 3330ENUMX 3331 BFD_RELOC_ARM_LDR_IMM 3332ENUMX 3333 BFD_RELOC_ARM_LITERAL 3334ENUMX 3335 BFD_RELOC_ARM_IN_POOL 3336ENUMX 3337 BFD_RELOC_ARM_OFFSET_IMM8 3338ENUMX 3339 BFD_RELOC_ARM_T32_OFFSET_U8 3340ENUMX 3341 BFD_RELOC_ARM_T32_OFFSET_IMM 3342ENUMX 3343 BFD_RELOC_ARM_HWLITERAL 3344ENUMX 3345 BFD_RELOC_ARM_THUMB_ADD 3346ENUMX 3347 BFD_RELOC_ARM_THUMB_IMM 3348ENUMX 3349 BFD_RELOC_ARM_THUMB_SHIFT 3350ENUMDOC 3351 These relocs are only used within the ARM assembler. They are not 3352 (at present) written to any object files. 3353 3354ENUM 3355 BFD_RELOC_SH_PCDISP8BY2 3356ENUMX 3357 BFD_RELOC_SH_PCDISP12BY2 3358ENUMX 3359 BFD_RELOC_SH_IMM3 3360ENUMX 3361 BFD_RELOC_SH_IMM3U 3362ENUMX 3363 BFD_RELOC_SH_DISP12 3364ENUMX 3365 BFD_RELOC_SH_DISP12BY2 3366ENUMX 3367 BFD_RELOC_SH_DISP12BY4 3368ENUMX 3369 BFD_RELOC_SH_DISP12BY8 3370ENUMX 3371 BFD_RELOC_SH_DISP20 3372ENUMX 3373 BFD_RELOC_SH_DISP20BY8 3374ENUMX 3375 BFD_RELOC_SH_IMM4 3376ENUMX 3377 BFD_RELOC_SH_IMM4BY2 3378ENUMX 3379 BFD_RELOC_SH_IMM4BY4 3380ENUMX 3381 BFD_RELOC_SH_IMM8 3382ENUMX 3383 BFD_RELOC_SH_IMM8BY2 3384ENUMX 3385 BFD_RELOC_SH_IMM8BY4 3386ENUMX 3387 BFD_RELOC_SH_PCRELIMM8BY2 3388ENUMX 3389 BFD_RELOC_SH_PCRELIMM8BY4 3390ENUMX 3391 BFD_RELOC_SH_SWITCH16 3392ENUMX 3393 BFD_RELOC_SH_SWITCH32 3394ENUMX 3395 BFD_RELOC_SH_USES 3396ENUMX 3397 BFD_RELOC_SH_COUNT 3398ENUMX 3399 BFD_RELOC_SH_ALIGN 3400ENUMX 3401 BFD_RELOC_SH_CODE 3402ENUMX 3403 BFD_RELOC_SH_DATA 3404ENUMX 3405 BFD_RELOC_SH_LABEL 3406ENUMX 3407 BFD_RELOC_SH_LOOP_START 3408ENUMX 3409 BFD_RELOC_SH_LOOP_END 3410ENUMX 3411 BFD_RELOC_SH_COPY 3412ENUMX 3413 BFD_RELOC_SH_GLOB_DAT 3414ENUMX 3415 BFD_RELOC_SH_JMP_SLOT 3416ENUMX 3417 BFD_RELOC_SH_RELATIVE 3418ENUMX 3419 BFD_RELOC_SH_GOTPC 3420ENUMX 3421 BFD_RELOC_SH_GOT_LOW16 3422ENUMX 3423 BFD_RELOC_SH_GOT_MEDLOW16 3424ENUMX 3425 BFD_RELOC_SH_GOT_MEDHI16 3426ENUMX 3427 BFD_RELOC_SH_GOT_HI16 3428ENUMX 3429 BFD_RELOC_SH_GOTPLT_LOW16 3430ENUMX 3431 BFD_RELOC_SH_GOTPLT_MEDLOW16 3432ENUMX 3433 BFD_RELOC_SH_GOTPLT_MEDHI16 3434ENUMX 3435 BFD_RELOC_SH_GOTPLT_HI16 3436ENUMX 3437 BFD_RELOC_SH_PLT_LOW16 3438ENUMX 3439 BFD_RELOC_SH_PLT_MEDLOW16 3440ENUMX 3441 BFD_RELOC_SH_PLT_MEDHI16 3442ENUMX 3443 BFD_RELOC_SH_PLT_HI16 3444ENUMX 3445 BFD_RELOC_SH_GOTOFF_LOW16 3446ENUMX 3447 BFD_RELOC_SH_GOTOFF_MEDLOW16 3448ENUMX 3449 BFD_RELOC_SH_GOTOFF_MEDHI16 3450ENUMX 3451 BFD_RELOC_SH_GOTOFF_HI16 3452ENUMX 3453 BFD_RELOC_SH_GOTPC_LOW16 3454ENUMX 3455 BFD_RELOC_SH_GOTPC_MEDLOW16 3456ENUMX 3457 BFD_RELOC_SH_GOTPC_MEDHI16 3458ENUMX 3459 BFD_RELOC_SH_GOTPC_HI16 3460ENUMX 3461 BFD_RELOC_SH_COPY64 3462ENUMX 3463 BFD_RELOC_SH_GLOB_DAT64 3464ENUMX 3465 BFD_RELOC_SH_JMP_SLOT64 3466ENUMX 3467 BFD_RELOC_SH_RELATIVE64 3468ENUMX 3469 BFD_RELOC_SH_GOT10BY4 3470ENUMX 3471 BFD_RELOC_SH_GOT10BY8 3472ENUMX 3473 BFD_RELOC_SH_GOTPLT10BY4 3474ENUMX 3475 BFD_RELOC_SH_GOTPLT10BY8 3476ENUMX 3477 BFD_RELOC_SH_GOTPLT32 3478ENUMX 3479 BFD_RELOC_SH_SHMEDIA_CODE 3480ENUMX 3481 BFD_RELOC_SH_IMMU5 3482ENUMX 3483 BFD_RELOC_SH_IMMS6 3484ENUMX 3485 BFD_RELOC_SH_IMMS6BY32 3486ENUMX 3487 BFD_RELOC_SH_IMMU6 3488ENUMX 3489 BFD_RELOC_SH_IMMS10 3490ENUMX 3491 BFD_RELOC_SH_IMMS10BY2 3492ENUMX 3493 BFD_RELOC_SH_IMMS10BY4 3494ENUMX 3495 BFD_RELOC_SH_IMMS10BY8 3496ENUMX 3497 BFD_RELOC_SH_IMMS16 3498ENUMX 3499 BFD_RELOC_SH_IMMU16 3500ENUMX 3501 BFD_RELOC_SH_IMM_LOW16 3502ENUMX 3503 BFD_RELOC_SH_IMM_LOW16_PCREL 3504ENUMX 3505 BFD_RELOC_SH_IMM_MEDLOW16 3506ENUMX 3507 BFD_RELOC_SH_IMM_MEDLOW16_PCREL 3508ENUMX 3509 BFD_RELOC_SH_IMM_MEDHI16 3510ENUMX 3511 BFD_RELOC_SH_IMM_MEDHI16_PCREL 3512ENUMX 3513 BFD_RELOC_SH_IMM_HI16 3514ENUMX 3515 BFD_RELOC_SH_IMM_HI16_PCREL 3516ENUMX 3517 BFD_RELOC_SH_PT_16 3518ENUMX 3519 BFD_RELOC_SH_TLS_GD_32 3520ENUMX 3521 BFD_RELOC_SH_TLS_LD_32 3522ENUMX 3523 BFD_RELOC_SH_TLS_LDO_32 3524ENUMX 3525 BFD_RELOC_SH_TLS_IE_32 3526ENUMX 3527 BFD_RELOC_SH_TLS_LE_32 3528ENUMX 3529 BFD_RELOC_SH_TLS_DTPMOD32 3530ENUMX 3531 BFD_RELOC_SH_TLS_DTPOFF32 3532ENUMX 3533 BFD_RELOC_SH_TLS_TPOFF32 3534ENUMX 3535 BFD_RELOC_SH_GOT20 3536ENUMX 3537 BFD_RELOC_SH_GOTOFF20 3538ENUMX 3539 BFD_RELOC_SH_GOTFUNCDESC 3540ENUMX 3541 BFD_RELOC_SH_GOTFUNCDESC20 3542ENUMX 3543 BFD_RELOC_SH_GOTOFFFUNCDESC 3544ENUMX 3545 BFD_RELOC_SH_GOTOFFFUNCDESC20 3546ENUMX 3547 BFD_RELOC_SH_FUNCDESC 3548ENUMDOC 3549 Renesas / SuperH SH relocs. Not all of these appear in object files. 3550 3551ENUM 3552 BFD_RELOC_ARC_NONE 3553ENUMX 3554 BFD_RELOC_ARC_8 3555ENUMX 3556 BFD_RELOC_ARC_16 3557ENUMX 3558 BFD_RELOC_ARC_24 3559ENUMX 3560 BFD_RELOC_ARC_32 3561ENUMX 3562 BFD_RELOC_ARC_N8 3563ENUMX 3564 BFD_RELOC_ARC_N16 3565ENUMX 3566 BFD_RELOC_ARC_N24 3567ENUMX 3568 BFD_RELOC_ARC_N32 3569ENUMX 3570 BFD_RELOC_ARC_SDA 3571ENUMX 3572 BFD_RELOC_ARC_SECTOFF 3573ENUMX 3574 BFD_RELOC_ARC_S21H_PCREL 3575ENUMX 3576 BFD_RELOC_ARC_S21W_PCREL 3577ENUMX 3578 BFD_RELOC_ARC_S25H_PCREL 3579ENUMX 3580 BFD_RELOC_ARC_S25W_PCREL 3581ENUMX 3582 BFD_RELOC_ARC_SDA32 3583ENUMX 3584 BFD_RELOC_ARC_SDA_LDST 3585ENUMX 3586 BFD_RELOC_ARC_SDA_LDST1 3587ENUMX 3588 BFD_RELOC_ARC_SDA_LDST2 3589ENUMX 3590 BFD_RELOC_ARC_SDA16_LD 3591ENUMX 3592 BFD_RELOC_ARC_SDA16_LD1 3593ENUMX 3594 BFD_RELOC_ARC_SDA16_LD2 3595ENUMX 3596 BFD_RELOC_ARC_S13_PCREL 3597ENUMX 3598 BFD_RELOC_ARC_W 3599ENUMX 3600 BFD_RELOC_ARC_32_ME 3601ENUMX 3602 BFD_RELOC_ARC_32_ME_S 3603ENUMX 3604 BFD_RELOC_ARC_N32_ME 3605ENUMX 3606 BFD_RELOC_ARC_SECTOFF_ME 3607ENUMX 3608 BFD_RELOC_ARC_SDA32_ME 3609ENUMX 3610 BFD_RELOC_ARC_W_ME 3611ENUMX 3612 BFD_RELOC_AC_SECTOFF_U8 3613ENUMX 3614 BFD_RELOC_AC_SECTOFF_U8_1 3615ENUMX 3616 BFD_RELOC_AC_SECTOFF_U8_2 3617ENUMX 3618 BFD_RELOC_AC_SECTOFF_S9 3619ENUMX 3620 BFD_RELOC_AC_SECTOFF_S9_1 3621ENUMX 3622 BFD_RELOC_AC_SECTOFF_S9_2 3623ENUMX 3624 BFD_RELOC_ARC_SECTOFF_ME_1 3625ENUMX 3626 BFD_RELOC_ARC_SECTOFF_ME_2 3627ENUMX 3628 BFD_RELOC_ARC_SECTOFF_1 3629ENUMX 3630 BFD_RELOC_ARC_SECTOFF_2 3631ENUMX 3632 BFD_RELOC_ARC_SDA_12 3633ENUMX 3634 BFD_RELOC_ARC_SDA16_ST2 3635ENUMX 3636 BFD_RELOC_ARC_32_PCREL 3637ENUMX 3638 BFD_RELOC_ARC_PC32 3639ENUMX 3640 BFD_RELOC_ARC_GOT32 3641ENUMX 3642 BFD_RELOC_ARC_GOTPC32 3643ENUMX 3644 BFD_RELOC_ARC_PLT32 3645ENUMX 3646 BFD_RELOC_ARC_COPY 3647ENUMX 3648 BFD_RELOC_ARC_GLOB_DAT 3649ENUMX 3650 BFD_RELOC_ARC_JMP_SLOT 3651ENUMX 3652 BFD_RELOC_ARC_RELATIVE 3653ENUMX 3654 BFD_RELOC_ARC_GOTOFF 3655ENUMX 3656 BFD_RELOC_ARC_GOTPC 3657ENUMX 3658 BFD_RELOC_ARC_S21W_PCREL_PLT 3659ENUMX 3660 BFD_RELOC_ARC_S25H_PCREL_PLT 3661ENUMX 3662 BFD_RELOC_ARC_TLS_DTPMOD 3663ENUMX 3664 BFD_RELOC_ARC_TLS_TPOFF 3665ENUMX 3666 BFD_RELOC_ARC_TLS_GD_GOT 3667ENUMX 3668 BFD_RELOC_ARC_TLS_GD_LD 3669ENUMX 3670 BFD_RELOC_ARC_TLS_GD_CALL 3671ENUMX 3672 BFD_RELOC_ARC_TLS_IE_GOT 3673ENUMX 3674 BFD_RELOC_ARC_TLS_DTPOFF 3675ENUMX 3676 BFD_RELOC_ARC_TLS_DTPOFF_S9 3677ENUMX 3678 BFD_RELOC_ARC_TLS_LE_S9 3679ENUMX 3680 BFD_RELOC_ARC_TLS_LE_32 3681ENUMX 3682 BFD_RELOC_ARC_S25W_PCREL_PLT 3683ENUMX 3684 BFD_RELOC_ARC_S21H_PCREL_PLT 3685ENUMX 3686 BFD_RELOC_ARC_NPS_CMEM16 3687ENUMDOC 3688 ARC relocs. 3689 3690ENUM 3691 BFD_RELOC_BFIN_16_IMM 3692ENUMDOC 3693 ADI Blackfin 16 bit immediate absolute reloc. 3694ENUM 3695 BFD_RELOC_BFIN_16_HIGH 3696ENUMDOC 3697 ADI Blackfin 16 bit immediate absolute reloc higher 16 bits. 3698ENUM 3699 BFD_RELOC_BFIN_4_PCREL 3700ENUMDOC 3701 ADI Blackfin 'a' part of LSETUP. 3702ENUM 3703 BFD_RELOC_BFIN_5_PCREL 3704ENUMDOC 3705 ADI Blackfin. 3706ENUM 3707 BFD_RELOC_BFIN_16_LOW 3708ENUMDOC 3709 ADI Blackfin 16 bit immediate absolute reloc lower 16 bits. 3710ENUM 3711 BFD_RELOC_BFIN_10_PCREL 3712ENUMDOC 3713 ADI Blackfin. 3714ENUM 3715 BFD_RELOC_BFIN_11_PCREL 3716ENUMDOC 3717 ADI Blackfin 'b' part of LSETUP. 3718ENUM 3719 BFD_RELOC_BFIN_12_PCREL_JUMP 3720ENUMDOC 3721 ADI Blackfin. 3722ENUM 3723 BFD_RELOC_BFIN_12_PCREL_JUMP_S 3724ENUMDOC 3725 ADI Blackfin Short jump, pcrel. 3726ENUM 3727 BFD_RELOC_BFIN_24_PCREL_CALL_X 3728ENUMDOC 3729 ADI Blackfin Call.x not implemented. 3730ENUM 3731 BFD_RELOC_BFIN_24_PCREL_JUMP_L 3732ENUMDOC 3733 ADI Blackfin Long Jump pcrel. 3734ENUM 3735 BFD_RELOC_BFIN_GOT17M4 3736ENUMX 3737 BFD_RELOC_BFIN_GOTHI 3738ENUMX 3739 BFD_RELOC_BFIN_GOTLO 3740ENUMX 3741 BFD_RELOC_BFIN_FUNCDESC 3742ENUMX 3743 BFD_RELOC_BFIN_FUNCDESC_GOT17M4 3744ENUMX 3745 BFD_RELOC_BFIN_FUNCDESC_GOTHI 3746ENUMX 3747 BFD_RELOC_BFIN_FUNCDESC_GOTLO 3748ENUMX 3749 BFD_RELOC_BFIN_FUNCDESC_VALUE 3750ENUMX 3751 BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4 3752ENUMX 3753 BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI 3754ENUMX 3755 BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO 3756ENUMX 3757 BFD_RELOC_BFIN_GOTOFF17M4 3758ENUMX 3759 BFD_RELOC_BFIN_GOTOFFHI 3760ENUMX 3761 BFD_RELOC_BFIN_GOTOFFLO 3762ENUMDOC 3763 ADI Blackfin FD-PIC relocations. 3764ENUM 3765 BFD_RELOC_BFIN_GOT 3766ENUMDOC 3767 ADI Blackfin GOT relocation. 3768ENUM 3769 BFD_RELOC_BFIN_PLTPC 3770ENUMDOC 3771 ADI Blackfin PLTPC relocation. 3772ENUM 3773 BFD_ARELOC_BFIN_PUSH 3774ENUMDOC 3775 ADI Blackfin arithmetic relocation. 3776ENUM 3777 BFD_ARELOC_BFIN_CONST 3778ENUMDOC 3779 ADI Blackfin arithmetic relocation. 3780ENUM 3781 BFD_ARELOC_BFIN_ADD 3782ENUMDOC 3783 ADI Blackfin arithmetic relocation. 3784ENUM 3785 BFD_ARELOC_BFIN_SUB 3786ENUMDOC 3787 ADI Blackfin arithmetic relocation. 3788ENUM 3789 BFD_ARELOC_BFIN_MULT 3790ENUMDOC 3791 ADI Blackfin arithmetic relocation. 3792ENUM 3793 BFD_ARELOC_BFIN_DIV 3794ENUMDOC 3795 ADI Blackfin arithmetic relocation. 3796ENUM 3797 BFD_ARELOC_BFIN_MOD 3798ENUMDOC 3799 ADI Blackfin arithmetic relocation. 3800ENUM 3801 BFD_ARELOC_BFIN_LSHIFT 3802ENUMDOC 3803 ADI Blackfin arithmetic relocation. 3804ENUM 3805 BFD_ARELOC_BFIN_RSHIFT 3806ENUMDOC 3807 ADI Blackfin arithmetic relocation. 3808ENUM 3809 BFD_ARELOC_BFIN_AND 3810ENUMDOC 3811 ADI Blackfin arithmetic relocation. 3812ENUM 3813 BFD_ARELOC_BFIN_OR 3814ENUMDOC 3815 ADI Blackfin arithmetic relocation. 3816ENUM 3817 BFD_ARELOC_BFIN_XOR 3818ENUMDOC 3819 ADI Blackfin arithmetic relocation. 3820ENUM 3821 BFD_ARELOC_BFIN_LAND 3822ENUMDOC 3823 ADI Blackfin arithmetic relocation. 3824ENUM 3825 BFD_ARELOC_BFIN_LOR 3826ENUMDOC 3827 ADI Blackfin arithmetic relocation. 3828ENUM 3829 BFD_ARELOC_BFIN_LEN 3830ENUMDOC 3831 ADI Blackfin arithmetic relocation. 3832ENUM 3833 BFD_ARELOC_BFIN_NEG 3834ENUMDOC 3835 ADI Blackfin arithmetic relocation. 3836ENUM 3837 BFD_ARELOC_BFIN_COMP 3838ENUMDOC 3839 ADI Blackfin arithmetic relocation. 3840ENUM 3841 BFD_ARELOC_BFIN_PAGE 3842ENUMDOC 3843 ADI Blackfin arithmetic relocation. 3844ENUM 3845 BFD_ARELOC_BFIN_HWPAGE 3846ENUMDOC 3847 ADI Blackfin arithmetic relocation. 3848ENUM 3849 BFD_ARELOC_BFIN_ADDR 3850ENUMDOC 3851 ADI Blackfin arithmetic relocation. 3852 3853ENUM 3854 BFD_RELOC_D10V_10_PCREL_R 3855ENUMDOC 3856 Mitsubishi D10V relocs. 3857 This is a 10-bit reloc with the right 2 bits 3858 assumed to be 0. 3859ENUM 3860 BFD_RELOC_D10V_10_PCREL_L 3861ENUMDOC 3862 Mitsubishi D10V relocs. 3863 This is a 10-bit reloc with the right 2 bits 3864 assumed to be 0. This is the same as the previous reloc 3865 except it is in the left container, i.e., 3866 shifted left 15 bits. 3867ENUM 3868 BFD_RELOC_D10V_18 3869ENUMDOC 3870 This is an 18-bit reloc with the right 2 bits 3871 assumed to be 0. 3872ENUM 3873 BFD_RELOC_D10V_18_PCREL 3874ENUMDOC 3875 This is an 18-bit reloc with the right 2 bits 3876 assumed to be 0. 3877 3878ENUM 3879 BFD_RELOC_D30V_6 3880ENUMDOC 3881 Mitsubishi D30V relocs. 3882 This is a 6-bit absolute reloc. 3883ENUM 3884 BFD_RELOC_D30V_9_PCREL 3885ENUMDOC 3886 This is a 6-bit pc-relative reloc with 3887 the right 3 bits assumed to be 0. 3888ENUM 3889 BFD_RELOC_D30V_9_PCREL_R 3890ENUMDOC 3891 This is a 6-bit pc-relative reloc with 3892 the right 3 bits assumed to be 0. Same 3893 as the previous reloc but on the right side 3894 of the container. 3895ENUM 3896 BFD_RELOC_D30V_15 3897ENUMDOC 3898 This is a 12-bit absolute reloc with the 3899 right 3 bitsassumed to be 0. 3900ENUM 3901 BFD_RELOC_D30V_15_PCREL 3902ENUMDOC 3903 This is a 12-bit pc-relative reloc with 3904 the right 3 bits assumed to be 0. 3905ENUM 3906 BFD_RELOC_D30V_15_PCREL_R 3907ENUMDOC 3908 This is a 12-bit pc-relative reloc with 3909 the right 3 bits assumed to be 0. Same 3910 as the previous reloc but on the right side 3911 of the container. 3912ENUM 3913 BFD_RELOC_D30V_21 3914ENUMDOC 3915 This is an 18-bit absolute reloc with 3916 the right 3 bits assumed to be 0. 3917ENUM 3918 BFD_RELOC_D30V_21_PCREL 3919ENUMDOC 3920 This is an 18-bit pc-relative reloc with 3921 the right 3 bits assumed to be 0. 3922ENUM 3923 BFD_RELOC_D30V_21_PCREL_R 3924ENUMDOC 3925 This is an 18-bit pc-relative reloc with 3926 the right 3 bits assumed to be 0. Same 3927 as the previous reloc but on the right side 3928 of the container. 3929ENUM 3930 BFD_RELOC_D30V_32 3931ENUMDOC 3932 This is a 32-bit absolute reloc. 3933ENUM 3934 BFD_RELOC_D30V_32_PCREL 3935ENUMDOC 3936 This is a 32-bit pc-relative reloc. 3937 3938ENUM 3939 BFD_RELOC_DLX_HI16_S 3940ENUMDOC 3941 DLX relocs 3942ENUM 3943 BFD_RELOC_DLX_LO16 3944ENUMDOC 3945 DLX relocs 3946ENUM 3947 BFD_RELOC_DLX_JMP26 3948ENUMDOC 3949 DLX relocs 3950 3951ENUM 3952 BFD_RELOC_M32C_HI8 3953ENUMX 3954 BFD_RELOC_M32C_RL_JUMP 3955ENUMX 3956 BFD_RELOC_M32C_RL_1ADDR 3957ENUMX 3958 BFD_RELOC_M32C_RL_2ADDR 3959ENUMDOC 3960 Renesas M16C/M32C Relocations. 3961 3962ENUM 3963 BFD_RELOC_M32R_24 3964ENUMDOC 3965 Renesas M32R (formerly Mitsubishi M32R) relocs. 3966 This is a 24 bit absolute address. 3967ENUM 3968 BFD_RELOC_M32R_10_PCREL 3969ENUMDOC 3970 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. 3971ENUM 3972 BFD_RELOC_M32R_18_PCREL 3973ENUMDOC 3974 This is an 18-bit reloc with the right 2 bits assumed to be 0. 3975ENUM 3976 BFD_RELOC_M32R_26_PCREL 3977ENUMDOC 3978 This is a 26-bit reloc with the right 2 bits assumed to be 0. 3979ENUM 3980 BFD_RELOC_M32R_HI16_ULO 3981ENUMDOC 3982 This is a 16-bit reloc containing the high 16 bits of an address 3983 used when the lower 16 bits are treated as unsigned. 3984ENUM 3985 BFD_RELOC_M32R_HI16_SLO 3986ENUMDOC 3987 This is a 16-bit reloc containing the high 16 bits of an address 3988 used when the lower 16 bits are treated as signed. 3989ENUM 3990 BFD_RELOC_M32R_LO16 3991ENUMDOC 3992 This is a 16-bit reloc containing the lower 16 bits of an address. 3993ENUM 3994 BFD_RELOC_M32R_SDA16 3995ENUMDOC 3996 This is a 16-bit reloc containing the small data area offset for use in 3997 add3, load, and store instructions. 3998ENUM 3999 BFD_RELOC_M32R_GOT24 4000ENUMX 4001 BFD_RELOC_M32R_26_PLTREL 4002ENUMX 4003 BFD_RELOC_M32R_COPY 4004ENUMX 4005 BFD_RELOC_M32R_GLOB_DAT 4006ENUMX 4007 BFD_RELOC_M32R_JMP_SLOT 4008ENUMX 4009 BFD_RELOC_M32R_RELATIVE 4010ENUMX 4011 BFD_RELOC_M32R_GOTOFF 4012ENUMX 4013 BFD_RELOC_M32R_GOTOFF_HI_ULO 4014ENUMX 4015 BFD_RELOC_M32R_GOTOFF_HI_SLO 4016ENUMX 4017 BFD_RELOC_M32R_GOTOFF_LO 4018ENUMX 4019 BFD_RELOC_M32R_GOTPC24 4020ENUMX 4021 BFD_RELOC_M32R_GOT16_HI_ULO 4022ENUMX 4023 BFD_RELOC_M32R_GOT16_HI_SLO 4024ENUMX 4025 BFD_RELOC_M32R_GOT16_LO 4026ENUMX 4027 BFD_RELOC_M32R_GOTPC_HI_ULO 4028ENUMX 4029 BFD_RELOC_M32R_GOTPC_HI_SLO 4030ENUMX 4031 BFD_RELOC_M32R_GOTPC_LO 4032ENUMDOC 4033 For PIC. 4034 4035 4036ENUM 4037 BFD_RELOC_NDS32_20 4038ENUMDOC 4039 NDS32 relocs. 4040 This is a 20 bit absolute address. 4041ENUM 4042 BFD_RELOC_NDS32_9_PCREL 4043ENUMDOC 4044 This is a 9-bit pc-relative reloc with the right 1 bit assumed to be 0. 4045ENUM 4046 BFD_RELOC_NDS32_WORD_9_PCREL 4047ENUMDOC 4048 This is a 9-bit pc-relative reloc with the right 1 bit assumed to be 0. 4049ENUM 4050 BFD_RELOC_NDS32_15_PCREL 4051ENUMDOC 4052 This is an 15-bit reloc with the right 1 bit assumed to be 0. 4053ENUM 4054 BFD_RELOC_NDS32_17_PCREL 4055ENUMDOC 4056 This is an 17-bit reloc with the right 1 bit assumed to be 0. 4057ENUM 4058 BFD_RELOC_NDS32_25_PCREL 4059ENUMDOC 4060 This is a 25-bit reloc with the right 1 bit assumed to be 0. 4061ENUM 4062 BFD_RELOC_NDS32_HI20 4063ENUMDOC 4064 This is a 20-bit reloc containing the high 20 bits of an address 4065 used with the lower 12 bits 4066ENUM 4067 BFD_RELOC_NDS32_LO12S3 4068ENUMDOC 4069 This is a 12-bit reloc containing the lower 12 bits of an address 4070 then shift right by 3. This is used with ldi,sdi... 4071ENUM 4072 BFD_RELOC_NDS32_LO12S2 4073ENUMDOC 4074 This is a 12-bit reloc containing the lower 12 bits of an address 4075 then shift left by 2. This is used with lwi,swi... 4076ENUM 4077 BFD_RELOC_NDS32_LO12S1 4078ENUMDOC 4079 This is a 12-bit reloc containing the lower 12 bits of an address 4080 then shift left by 1. This is used with lhi,shi... 4081ENUM 4082 BFD_RELOC_NDS32_LO12S0 4083ENUMDOC 4084 This is a 12-bit reloc containing the lower 12 bits of an address 4085 then shift left by 0. This is used with lbisbi... 4086ENUM 4087 BFD_RELOC_NDS32_LO12S0_ORI 4088ENUMDOC 4089 This is a 12-bit reloc containing the lower 12 bits of an address 4090 then shift left by 0. This is only used with branch relaxations 4091ENUM 4092 BFD_RELOC_NDS32_SDA15S3 4093ENUMDOC 4094 This is a 15-bit reloc containing the small data area 18-bit signed offset 4095 and shift left by 3 for use in ldi, sdi... 4096ENUM 4097 BFD_RELOC_NDS32_SDA15S2 4098ENUMDOC 4099 This is a 15-bit reloc containing the small data area 17-bit signed offset 4100 and shift left by 2 for use in lwi, swi... 4101ENUM 4102 BFD_RELOC_NDS32_SDA15S1 4103ENUMDOC 4104 This is a 15-bit reloc containing the small data area 16-bit signed offset 4105 and shift left by 1 for use in lhi, shi... 4106ENUM 4107 BFD_RELOC_NDS32_SDA15S0 4108ENUMDOC 4109 This is a 15-bit reloc containing the small data area 15-bit signed offset 4110 and shift left by 0 for use in lbi, sbi... 4111ENUM 4112 BFD_RELOC_NDS32_SDA16S3 4113ENUMDOC 4114 This is a 16-bit reloc containing the small data area 16-bit signed offset 4115 and shift left by 3 4116ENUM 4117 BFD_RELOC_NDS32_SDA17S2 4118ENUMDOC 4119 This is a 17-bit reloc containing the small data area 17-bit signed offset 4120 and shift left by 2 for use in lwi.gp, swi.gp... 4121ENUM 4122 BFD_RELOC_NDS32_SDA18S1 4123ENUMDOC 4124 This is a 18-bit reloc containing the small data area 18-bit signed offset 4125 and shift left by 1 for use in lhi.gp, shi.gp... 4126ENUM 4127 BFD_RELOC_NDS32_SDA19S0 4128ENUMDOC 4129 This is a 19-bit reloc containing the small data area 19-bit signed offset 4130 and shift left by 0 for use in lbi.gp, sbi.gp... 4131ENUM 4132 BFD_RELOC_NDS32_GOT20 4133ENUMX 4134 BFD_RELOC_NDS32_9_PLTREL 4135ENUMX 4136 BFD_RELOC_NDS32_25_PLTREL 4137ENUMX 4138 BFD_RELOC_NDS32_COPY 4139ENUMX 4140 BFD_RELOC_NDS32_GLOB_DAT 4141ENUMX 4142 BFD_RELOC_NDS32_JMP_SLOT 4143ENUMX 4144 BFD_RELOC_NDS32_RELATIVE 4145ENUMX 4146 BFD_RELOC_NDS32_GOTOFF 4147ENUMX 4148 BFD_RELOC_NDS32_GOTOFF_HI20 4149ENUMX 4150 BFD_RELOC_NDS32_GOTOFF_LO12 4151ENUMX 4152 BFD_RELOC_NDS32_GOTPC20 4153ENUMX 4154 BFD_RELOC_NDS32_GOT_HI20 4155ENUMX 4156 BFD_RELOC_NDS32_GOT_LO12 4157ENUMX 4158 BFD_RELOC_NDS32_GOTPC_HI20 4159ENUMX 4160 BFD_RELOC_NDS32_GOTPC_LO12 4161ENUMDOC 4162 for PIC 4163ENUM 4164 BFD_RELOC_NDS32_INSN16 4165ENUMX 4166 BFD_RELOC_NDS32_LABEL 4167ENUMX 4168 BFD_RELOC_NDS32_LONGCALL1 4169ENUMX 4170 BFD_RELOC_NDS32_LONGCALL2 4171ENUMX 4172 BFD_RELOC_NDS32_LONGCALL3 4173ENUMX 4174 BFD_RELOC_NDS32_LONGJUMP1 4175ENUMX 4176 BFD_RELOC_NDS32_LONGJUMP2 4177ENUMX 4178 BFD_RELOC_NDS32_LONGJUMP3 4179ENUMX 4180 BFD_RELOC_NDS32_LOADSTORE 4181ENUMX 4182 BFD_RELOC_NDS32_9_FIXED 4183ENUMX 4184 BFD_RELOC_NDS32_15_FIXED 4185ENUMX 4186 BFD_RELOC_NDS32_17_FIXED 4187ENUMX 4188 BFD_RELOC_NDS32_25_FIXED 4189ENUMX 4190 BFD_RELOC_NDS32_LONGCALL4 4191ENUMX 4192 BFD_RELOC_NDS32_LONGCALL5 4193ENUMX 4194 BFD_RELOC_NDS32_LONGCALL6 4195ENUMX 4196 BFD_RELOC_NDS32_LONGJUMP4 4197ENUMX 4198 BFD_RELOC_NDS32_LONGJUMP5 4199ENUMX 4200 BFD_RELOC_NDS32_LONGJUMP6 4201ENUMX 4202 BFD_RELOC_NDS32_LONGJUMP7 4203ENUMDOC 4204 for relax 4205ENUM 4206 BFD_RELOC_NDS32_PLTREL_HI20 4207ENUMX 4208 BFD_RELOC_NDS32_PLTREL_LO12 4209ENUMX 4210 BFD_RELOC_NDS32_PLT_GOTREL_HI20 4211ENUMX 4212 BFD_RELOC_NDS32_PLT_GOTREL_LO12 4213ENUMDOC 4214 for PIC 4215ENUM 4216 BFD_RELOC_NDS32_SDA12S2_DP 4217ENUMX 4218 BFD_RELOC_NDS32_SDA12S2_SP 4219ENUMX 4220 BFD_RELOC_NDS32_LO12S2_DP 4221ENUMX 4222 BFD_RELOC_NDS32_LO12S2_SP 4223ENUMDOC 4224 for floating point 4225ENUM 4226 BFD_RELOC_NDS32_DWARF2_OP1 4227ENUMX 4228 BFD_RELOC_NDS32_DWARF2_OP2 4229ENUMX 4230 BFD_RELOC_NDS32_DWARF2_LEB 4231ENUMDOC 4232 for dwarf2 debug_line. 4233ENUM 4234 BFD_RELOC_NDS32_UPDATE_TA 4235ENUMDOC 4236 for eliminate 16-bit instructions 4237ENUM 4238 BFD_RELOC_NDS32_PLT_GOTREL_LO20 4239ENUMX 4240 BFD_RELOC_NDS32_PLT_GOTREL_LO15 4241ENUMX 4242 BFD_RELOC_NDS32_PLT_GOTREL_LO19 4243ENUMX 4244 BFD_RELOC_NDS32_GOT_LO15 4245ENUMX 4246 BFD_RELOC_NDS32_GOT_LO19 4247ENUMX 4248 BFD_RELOC_NDS32_GOTOFF_LO15 4249ENUMX 4250 BFD_RELOC_NDS32_GOTOFF_LO19 4251ENUMX 4252 BFD_RELOC_NDS32_GOT15S2 4253ENUMX 4254 BFD_RELOC_NDS32_GOT17S2 4255ENUMDOC 4256 for PIC object relaxation 4257ENUM 4258 BFD_RELOC_NDS32_5 4259ENUMDOC 4260 NDS32 relocs. 4261 This is a 5 bit absolute address. 4262ENUM 4263 BFD_RELOC_NDS32_10_UPCREL 4264ENUMDOC 4265 This is a 10-bit unsigned pc-relative reloc with the right 1 bit assumed to be 0. 4266ENUM 4267 BFD_RELOC_NDS32_SDA_FP7U2_RELA 4268ENUMDOC 4269 If fp were omitted, fp can used as another gp. 4270ENUM 4271 BFD_RELOC_NDS32_RELAX_ENTRY 4272ENUMX 4273 BFD_RELOC_NDS32_GOT_SUFF 4274ENUMX 4275 BFD_RELOC_NDS32_GOTOFF_SUFF 4276ENUMX 4277 BFD_RELOC_NDS32_PLT_GOT_SUFF 4278ENUMX 4279 BFD_RELOC_NDS32_MULCALL_SUFF 4280ENUMX 4281 BFD_RELOC_NDS32_PTR 4282ENUMX 4283 BFD_RELOC_NDS32_PTR_COUNT 4284ENUMX 4285 BFD_RELOC_NDS32_PTR_RESOLVED 4286ENUMX 4287 BFD_RELOC_NDS32_PLTBLOCK 4288ENUMX 4289 BFD_RELOC_NDS32_RELAX_REGION_BEGIN 4290ENUMX 4291 BFD_RELOC_NDS32_RELAX_REGION_END 4292ENUMX 4293 BFD_RELOC_NDS32_MINUEND 4294ENUMX 4295 BFD_RELOC_NDS32_SUBTRAHEND 4296ENUMX 4297 BFD_RELOC_NDS32_DIFF8 4298ENUMX 4299 BFD_RELOC_NDS32_DIFF16 4300ENUMX 4301 BFD_RELOC_NDS32_DIFF32 4302ENUMX 4303 BFD_RELOC_NDS32_DIFF_ULEB128 4304ENUMX 4305 BFD_RELOC_NDS32_EMPTY 4306ENUMDOC 4307 relaxation relative relocation types 4308ENUM 4309 BFD_RELOC_NDS32_25_ABS 4310ENUMDOC 4311 This is a 25 bit absolute address. 4312ENUM 4313 BFD_RELOC_NDS32_DATA 4314ENUMX 4315 BFD_RELOC_NDS32_TRAN 4316ENUMX 4317 BFD_RELOC_NDS32_17IFC_PCREL 4318ENUMX 4319 BFD_RELOC_NDS32_10IFCU_PCREL 4320ENUMDOC 4321 For ex9 and ifc using. 4322ENUM 4323 BFD_RELOC_NDS32_TPOFF 4324ENUMX 4325 BFD_RELOC_NDS32_TLS_LE_HI20 4326ENUMX 4327 BFD_RELOC_NDS32_TLS_LE_LO12 4328ENUMX 4329 BFD_RELOC_NDS32_TLS_LE_ADD 4330ENUMX 4331 BFD_RELOC_NDS32_TLS_LE_LS 4332ENUMX 4333 BFD_RELOC_NDS32_GOTTPOFF 4334ENUMX 4335 BFD_RELOC_NDS32_TLS_IE_HI20 4336ENUMX 4337 BFD_RELOC_NDS32_TLS_IE_LO12S2 4338ENUMX 4339 BFD_RELOC_NDS32_TLS_TPOFF 4340ENUMX 4341 BFD_RELOC_NDS32_TLS_LE_20 4342ENUMX 4343 BFD_RELOC_NDS32_TLS_LE_15S0 4344ENUMX 4345 BFD_RELOC_NDS32_TLS_LE_15S1 4346ENUMX 4347 BFD_RELOC_NDS32_TLS_LE_15S2 4348ENUMDOC 4349 For TLS. 4350 4351 4352ENUM 4353 BFD_RELOC_V850_9_PCREL 4354ENUMDOC 4355 This is a 9-bit reloc 4356ENUM 4357 BFD_RELOC_V850_22_PCREL 4358ENUMDOC 4359 This is a 22-bit reloc 4360 4361ENUM 4362 BFD_RELOC_V850_SDA_16_16_OFFSET 4363ENUMDOC 4364 This is a 16 bit offset from the short data area pointer. 4365ENUM 4366 BFD_RELOC_V850_SDA_15_16_OFFSET 4367ENUMDOC 4368 This is a 16 bit offset (of which only 15 bits are used) from the 4369 short data area pointer. 4370ENUM 4371 BFD_RELOC_V850_ZDA_16_16_OFFSET 4372ENUMDOC 4373 This is a 16 bit offset from the zero data area pointer. 4374ENUM 4375 BFD_RELOC_V850_ZDA_15_16_OFFSET 4376ENUMDOC 4377 This is a 16 bit offset (of which only 15 bits are used) from the 4378 zero data area pointer. 4379ENUM 4380 BFD_RELOC_V850_TDA_6_8_OFFSET 4381ENUMDOC 4382 This is an 8 bit offset (of which only 6 bits are used) from the 4383 tiny data area pointer. 4384ENUM 4385 BFD_RELOC_V850_TDA_7_8_OFFSET 4386ENUMDOC 4387 This is an 8bit offset (of which only 7 bits are used) from the tiny 4388 data area pointer. 4389ENUM 4390 BFD_RELOC_V850_TDA_7_7_OFFSET 4391ENUMDOC 4392 This is a 7 bit offset from the tiny data area pointer. 4393ENUM 4394 BFD_RELOC_V850_TDA_16_16_OFFSET 4395ENUMDOC 4396 This is a 16 bit offset from the tiny data area pointer. 4397COMMENT 4398ENUM 4399 BFD_RELOC_V850_TDA_4_5_OFFSET 4400ENUMDOC 4401 This is a 5 bit offset (of which only 4 bits are used) from the tiny 4402 data area pointer. 4403ENUM 4404 BFD_RELOC_V850_TDA_4_4_OFFSET 4405ENUMDOC 4406 This is a 4 bit offset from the tiny data area pointer. 4407ENUM 4408 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET 4409ENUMDOC 4410 This is a 16 bit offset from the short data area pointer, with the 4411 bits placed non-contiguously in the instruction. 4412ENUM 4413 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET 4414ENUMDOC 4415 This is a 16 bit offset from the zero data area pointer, with the 4416 bits placed non-contiguously in the instruction. 4417ENUM 4418 BFD_RELOC_V850_CALLT_6_7_OFFSET 4419ENUMDOC 4420 This is a 6 bit offset from the call table base pointer. 4421ENUM 4422 BFD_RELOC_V850_CALLT_16_16_OFFSET 4423ENUMDOC 4424 This is a 16 bit offset from the call table base pointer. 4425ENUM 4426 BFD_RELOC_V850_LONGCALL 4427ENUMDOC 4428 Used for relaxing indirect function calls. 4429ENUM 4430 BFD_RELOC_V850_LONGJUMP 4431ENUMDOC 4432 Used for relaxing indirect jumps. 4433ENUM 4434 BFD_RELOC_V850_ALIGN 4435ENUMDOC 4436 Used to maintain alignment whilst relaxing. 4437ENUM 4438 BFD_RELOC_V850_LO16_SPLIT_OFFSET 4439ENUMDOC 4440 This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu 4441 instructions. 4442ENUM 4443 BFD_RELOC_V850_16_PCREL 4444ENUMDOC 4445 This is a 16-bit reloc. 4446ENUM 4447 BFD_RELOC_V850_17_PCREL 4448ENUMDOC 4449 This is a 17-bit reloc. 4450ENUM 4451 BFD_RELOC_V850_23 4452ENUMDOC 4453 This is a 23-bit reloc. 4454ENUM 4455 BFD_RELOC_V850_32_PCREL 4456ENUMDOC 4457 This is a 32-bit reloc. 4458ENUM 4459 BFD_RELOC_V850_32_ABS 4460ENUMDOC 4461 This is a 32-bit reloc. 4462ENUM 4463 BFD_RELOC_V850_16_SPLIT_OFFSET 4464ENUMDOC 4465 This is a 16-bit reloc. 4466ENUM 4467 BFD_RELOC_V850_16_S1 4468ENUMDOC 4469 This is a 16-bit reloc. 4470ENUM 4471 BFD_RELOC_V850_LO16_S1 4472ENUMDOC 4473 Low 16 bits. 16 bit shifted by 1. 4474ENUM 4475 BFD_RELOC_V850_CALLT_15_16_OFFSET 4476ENUMDOC 4477 This is a 16 bit offset from the call table base pointer. 4478ENUM 4479 BFD_RELOC_V850_32_GOTPCREL 4480ENUMDOC 4481 DSO relocations. 4482ENUM 4483 BFD_RELOC_V850_16_GOT 4484ENUMDOC 4485 DSO relocations. 4486ENUM 4487 BFD_RELOC_V850_32_GOT 4488ENUMDOC 4489 DSO relocations. 4490ENUM 4491 BFD_RELOC_V850_22_PLT_PCREL 4492ENUMDOC 4493 DSO relocations. 4494ENUM 4495 BFD_RELOC_V850_32_PLT_PCREL 4496ENUMDOC 4497 DSO relocations. 4498ENUM 4499 BFD_RELOC_V850_COPY 4500ENUMDOC 4501 DSO relocations. 4502ENUM 4503 BFD_RELOC_V850_GLOB_DAT 4504ENUMDOC 4505 DSO relocations. 4506ENUM 4507 BFD_RELOC_V850_JMP_SLOT 4508ENUMDOC 4509 DSO relocations. 4510ENUM 4511 BFD_RELOC_V850_RELATIVE 4512ENUMDOC 4513 DSO relocations. 4514ENUM 4515 BFD_RELOC_V850_16_GOTOFF 4516ENUMDOC 4517 DSO relocations. 4518ENUM 4519 BFD_RELOC_V850_32_GOTOFF 4520ENUMDOC 4521 DSO relocations. 4522ENUM 4523 BFD_RELOC_V850_CODE 4524ENUMDOC 4525 start code. 4526ENUM 4527 BFD_RELOC_V850_DATA 4528ENUMDOC 4529 start data in text. 4530 4531ENUM 4532 BFD_RELOC_TIC30_LDP 4533ENUMDOC 4534 This is a 8bit DP reloc for the tms320c30, where the most 4535 significant 8 bits of a 24 bit word are placed into the least 4536 significant 8 bits of the opcode. 4537 4538ENUM 4539 BFD_RELOC_TIC54X_PARTLS7 4540ENUMDOC 4541 This is a 7bit reloc for the tms320c54x, where the least 4542 significant 7 bits of a 16 bit word are placed into the least 4543 significant 7 bits of the opcode. 4544 4545ENUM 4546 BFD_RELOC_TIC54X_PARTMS9 4547ENUMDOC 4548 This is a 9bit DP reloc for the tms320c54x, where the most 4549 significant 9 bits of a 16 bit word are placed into the least 4550 significant 9 bits of the opcode. 4551 4552ENUM 4553 BFD_RELOC_TIC54X_23 4554ENUMDOC 4555 This is an extended address 23-bit reloc for the tms320c54x. 4556 4557ENUM 4558 BFD_RELOC_TIC54X_16_OF_23 4559ENUMDOC 4560 This is a 16-bit reloc for the tms320c54x, where the least 4561 significant 16 bits of a 23-bit extended address are placed into 4562 the opcode. 4563 4564ENUM 4565 BFD_RELOC_TIC54X_MS7_OF_23 4566ENUMDOC 4567 This is a reloc for the tms320c54x, where the most 4568 significant 7 bits of a 23-bit extended address are placed into 4569 the opcode. 4570 4571ENUM 4572 BFD_RELOC_C6000_PCR_S21 4573ENUMX 4574 BFD_RELOC_C6000_PCR_S12 4575ENUMX 4576 BFD_RELOC_C6000_PCR_S10 4577ENUMX 4578 BFD_RELOC_C6000_PCR_S7 4579ENUMX 4580 BFD_RELOC_C6000_ABS_S16 4581ENUMX 4582 BFD_RELOC_C6000_ABS_L16 4583ENUMX 4584 BFD_RELOC_C6000_ABS_H16 4585ENUMX 4586 BFD_RELOC_C6000_SBR_U15_B 4587ENUMX 4588 BFD_RELOC_C6000_SBR_U15_H 4589ENUMX 4590 BFD_RELOC_C6000_SBR_U15_W 4591ENUMX 4592 BFD_RELOC_C6000_SBR_S16 4593ENUMX 4594 BFD_RELOC_C6000_SBR_L16_B 4595ENUMX 4596 BFD_RELOC_C6000_SBR_L16_H 4597ENUMX 4598 BFD_RELOC_C6000_SBR_L16_W 4599ENUMX 4600 BFD_RELOC_C6000_SBR_H16_B 4601ENUMX 4602 BFD_RELOC_C6000_SBR_H16_H 4603ENUMX 4604 BFD_RELOC_C6000_SBR_H16_W 4605ENUMX 4606 BFD_RELOC_C6000_SBR_GOT_U15_W 4607ENUMX 4608 BFD_RELOC_C6000_SBR_GOT_L16_W 4609ENUMX 4610 BFD_RELOC_C6000_SBR_GOT_H16_W 4611ENUMX 4612 BFD_RELOC_C6000_DSBT_INDEX 4613ENUMX 4614 BFD_RELOC_C6000_PREL31 4615ENUMX 4616 BFD_RELOC_C6000_COPY 4617ENUMX 4618 BFD_RELOC_C6000_JUMP_SLOT 4619ENUMX 4620 BFD_RELOC_C6000_EHTYPE 4621ENUMX 4622 BFD_RELOC_C6000_PCR_H16 4623ENUMX 4624 BFD_RELOC_C6000_PCR_L16 4625ENUMX 4626 BFD_RELOC_C6000_ALIGN 4627ENUMX 4628 BFD_RELOC_C6000_FPHEAD 4629ENUMX 4630 BFD_RELOC_C6000_NOCMP 4631ENUMDOC 4632 TMS320C6000 relocations. 4633 4634ENUM 4635 BFD_RELOC_FR30_48 4636ENUMDOC 4637 This is a 48 bit reloc for the FR30 that stores 32 bits. 4638ENUM 4639 BFD_RELOC_FR30_20 4640ENUMDOC 4641 This is a 32 bit reloc for the FR30 that stores 20 bits split up into 4642 two sections. 4643ENUM 4644 BFD_RELOC_FR30_6_IN_4 4645ENUMDOC 4646 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in 4647 4 bits. 4648ENUM 4649 BFD_RELOC_FR30_8_IN_8 4650ENUMDOC 4651 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset 4652 into 8 bits. 4653ENUM 4654 BFD_RELOC_FR30_9_IN_8 4655ENUMDOC 4656 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset 4657 into 8 bits. 4658ENUM 4659 BFD_RELOC_FR30_10_IN_8 4660ENUMDOC 4661 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset 4662 into 8 bits. 4663ENUM 4664 BFD_RELOC_FR30_9_PCREL 4665ENUMDOC 4666 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative 4667 short offset into 8 bits. 4668ENUM 4669 BFD_RELOC_FR30_12_PCREL 4670ENUMDOC 4671 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative 4672 short offset into 11 bits. 4673 4674ENUM 4675 BFD_RELOC_MCORE_PCREL_IMM8BY4 4676ENUMX 4677 BFD_RELOC_MCORE_PCREL_IMM11BY2 4678ENUMX 4679 BFD_RELOC_MCORE_PCREL_IMM4BY2 4680ENUMX 4681 BFD_RELOC_MCORE_PCREL_32 4682ENUMX 4683 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2 4684ENUMX 4685 BFD_RELOC_MCORE_RVA 4686ENUMDOC 4687 Motorola Mcore relocations. 4688 4689ENUM 4690 BFD_RELOC_MEP_8 4691ENUMX 4692 BFD_RELOC_MEP_16 4693ENUMX 4694 BFD_RELOC_MEP_32 4695ENUMX 4696 BFD_RELOC_MEP_PCREL8A2 4697ENUMX 4698 BFD_RELOC_MEP_PCREL12A2 4699ENUMX 4700 BFD_RELOC_MEP_PCREL17A2 4701ENUMX 4702 BFD_RELOC_MEP_PCREL24A2 4703ENUMX 4704 BFD_RELOC_MEP_PCABS24A2 4705ENUMX 4706 BFD_RELOC_MEP_LOW16 4707ENUMX 4708 BFD_RELOC_MEP_HI16U 4709ENUMX 4710 BFD_RELOC_MEP_HI16S 4711ENUMX 4712 BFD_RELOC_MEP_GPREL 4713ENUMX 4714 BFD_RELOC_MEP_TPREL 4715ENUMX 4716 BFD_RELOC_MEP_TPREL7 4717ENUMX 4718 BFD_RELOC_MEP_TPREL7A2 4719ENUMX 4720 BFD_RELOC_MEP_TPREL7A4 4721ENUMX 4722 BFD_RELOC_MEP_UIMM24 4723ENUMX 4724 BFD_RELOC_MEP_ADDR24A4 4725ENUMX 4726 BFD_RELOC_MEP_GNU_VTINHERIT 4727ENUMX 4728 BFD_RELOC_MEP_GNU_VTENTRY 4729ENUMDOC 4730 Toshiba Media Processor Relocations. 4731COMMENT 4732 4733ENUM 4734 BFD_RELOC_METAG_HIADDR16 4735ENUMX 4736 BFD_RELOC_METAG_LOADDR16 4737ENUMX 4738 BFD_RELOC_METAG_RELBRANCH 4739ENUMX 4740 BFD_RELOC_METAG_GETSETOFF 4741ENUMX 4742 BFD_RELOC_METAG_HIOG 4743ENUMX 4744 BFD_RELOC_METAG_LOOG 4745ENUMX 4746 BFD_RELOC_METAG_REL8 4747ENUMX 4748 BFD_RELOC_METAG_REL16 4749ENUMX 4750 BFD_RELOC_METAG_HI16_GOTOFF 4751ENUMX 4752 BFD_RELOC_METAG_LO16_GOTOFF 4753ENUMX 4754 BFD_RELOC_METAG_GETSET_GOTOFF 4755ENUMX 4756 BFD_RELOC_METAG_GETSET_GOT 4757ENUMX 4758 BFD_RELOC_METAG_HI16_GOTPC 4759ENUMX 4760 BFD_RELOC_METAG_LO16_GOTPC 4761ENUMX 4762 BFD_RELOC_METAG_HI16_PLT 4763ENUMX 4764 BFD_RELOC_METAG_LO16_PLT 4765ENUMX 4766 BFD_RELOC_METAG_RELBRANCH_PLT 4767ENUMX 4768 BFD_RELOC_METAG_GOTOFF 4769ENUMX 4770 BFD_RELOC_METAG_PLT 4771ENUMX 4772 BFD_RELOC_METAG_COPY 4773ENUMX 4774 BFD_RELOC_METAG_JMP_SLOT 4775ENUMX 4776 BFD_RELOC_METAG_RELATIVE 4777ENUMX 4778 BFD_RELOC_METAG_GLOB_DAT 4779ENUMX 4780 BFD_RELOC_METAG_TLS_GD 4781ENUMX 4782 BFD_RELOC_METAG_TLS_LDM 4783ENUMX 4784 BFD_RELOC_METAG_TLS_LDO_HI16 4785ENUMX 4786 BFD_RELOC_METAG_TLS_LDO_LO16 4787ENUMX 4788 BFD_RELOC_METAG_TLS_LDO 4789ENUMX 4790 BFD_RELOC_METAG_TLS_IE 4791ENUMX 4792 BFD_RELOC_METAG_TLS_IENONPIC 4793ENUMX 4794 BFD_RELOC_METAG_TLS_IENONPIC_HI16 4795ENUMX 4796 BFD_RELOC_METAG_TLS_IENONPIC_LO16 4797ENUMX 4798 BFD_RELOC_METAG_TLS_TPOFF 4799ENUMX 4800 BFD_RELOC_METAG_TLS_DTPMOD 4801ENUMX 4802 BFD_RELOC_METAG_TLS_DTPOFF 4803ENUMX 4804 BFD_RELOC_METAG_TLS_LE 4805ENUMX 4806 BFD_RELOC_METAG_TLS_LE_HI16 4807ENUMX 4808 BFD_RELOC_METAG_TLS_LE_LO16 4809ENUMDOC 4810 Imagination Technologies Meta relocations. 4811 4812ENUM 4813 BFD_RELOC_MMIX_GETA 4814ENUMX 4815 BFD_RELOC_MMIX_GETA_1 4816ENUMX 4817 BFD_RELOC_MMIX_GETA_2 4818ENUMX 4819 BFD_RELOC_MMIX_GETA_3 4820ENUMDOC 4821 These are relocations for the GETA instruction. 4822ENUM 4823 BFD_RELOC_MMIX_CBRANCH 4824ENUMX 4825 BFD_RELOC_MMIX_CBRANCH_J 4826ENUMX 4827 BFD_RELOC_MMIX_CBRANCH_1 4828ENUMX 4829 BFD_RELOC_MMIX_CBRANCH_2 4830ENUMX 4831 BFD_RELOC_MMIX_CBRANCH_3 4832ENUMDOC 4833 These are relocations for a conditional branch instruction. 4834ENUM 4835 BFD_RELOC_MMIX_PUSHJ 4836ENUMX 4837 BFD_RELOC_MMIX_PUSHJ_1 4838ENUMX 4839 BFD_RELOC_MMIX_PUSHJ_2 4840ENUMX 4841 BFD_RELOC_MMIX_PUSHJ_3 4842ENUMX 4843 BFD_RELOC_MMIX_PUSHJ_STUBBABLE 4844ENUMDOC 4845 These are relocations for the PUSHJ instruction. 4846ENUM 4847 BFD_RELOC_MMIX_JMP 4848ENUMX 4849 BFD_RELOC_MMIX_JMP_1 4850ENUMX 4851 BFD_RELOC_MMIX_JMP_2 4852ENUMX 4853 BFD_RELOC_MMIX_JMP_3 4854ENUMDOC 4855 These are relocations for the JMP instruction. 4856ENUM 4857 BFD_RELOC_MMIX_ADDR19 4858ENUMDOC 4859 This is a relocation for a relative address as in a GETA instruction or 4860 a branch. 4861ENUM 4862 BFD_RELOC_MMIX_ADDR27 4863ENUMDOC 4864 This is a relocation for a relative address as in a JMP instruction. 4865ENUM 4866 BFD_RELOC_MMIX_REG_OR_BYTE 4867ENUMDOC 4868 This is a relocation for an instruction field that may be a general 4869 register or a value 0..255. 4870ENUM 4871 BFD_RELOC_MMIX_REG 4872ENUMDOC 4873 This is a relocation for an instruction field that may be a general 4874 register. 4875ENUM 4876 BFD_RELOC_MMIX_BASE_PLUS_OFFSET 4877ENUMDOC 4878 This is a relocation for two instruction fields holding a register and 4879 an offset, the equivalent of the relocation. 4880ENUM 4881 BFD_RELOC_MMIX_LOCAL 4882ENUMDOC 4883 This relocation is an assertion that the expression is not allocated as 4884 a global register. It does not modify contents. 4885 4886ENUM 4887 BFD_RELOC_AVR_7_PCREL 4888ENUMDOC 4889 This is a 16 bit reloc for the AVR that stores 8 bit pc relative 4890 short offset into 7 bits. 4891ENUM 4892 BFD_RELOC_AVR_13_PCREL 4893ENUMDOC 4894 This is a 16 bit reloc for the AVR that stores 13 bit pc relative 4895 short offset into 12 bits. 4896ENUM 4897 BFD_RELOC_AVR_16_PM 4898ENUMDOC 4899 This is a 16 bit reloc for the AVR that stores 17 bit value (usually 4900 program memory address) into 16 bits. 4901ENUM 4902 BFD_RELOC_AVR_LO8_LDI 4903ENUMDOC 4904 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 4905 data memory address) into 8 bit immediate value of LDI insn. 4906ENUM 4907 BFD_RELOC_AVR_HI8_LDI 4908ENUMDOC 4909 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 4910 of data memory address) into 8 bit immediate value of LDI insn. 4911ENUM 4912 BFD_RELOC_AVR_HH8_LDI 4913ENUMDOC 4914 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 4915 of program memory address) into 8 bit immediate value of LDI insn. 4916ENUM 4917 BFD_RELOC_AVR_MS8_LDI 4918ENUMDOC 4919 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 4920 of 32 bit value) into 8 bit immediate value of LDI insn. 4921ENUM 4922 BFD_RELOC_AVR_LO8_LDI_NEG 4923ENUMDOC 4924 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4925 (usually data memory address) into 8 bit immediate value of SUBI insn. 4926ENUM 4927 BFD_RELOC_AVR_HI8_LDI_NEG 4928ENUMDOC 4929 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4930 (high 8 bit of data memory address) into 8 bit immediate value of 4931 SUBI insn. 4932ENUM 4933 BFD_RELOC_AVR_HH8_LDI_NEG 4934ENUMDOC 4935 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4936 (most high 8 bit of program memory address) into 8 bit immediate value 4937 of LDI or SUBI insn. 4938ENUM 4939 BFD_RELOC_AVR_MS8_LDI_NEG 4940ENUMDOC 4941 This is a 16 bit reloc for the AVR that stores negated 8 bit value (msb 4942 of 32 bit value) into 8 bit immediate value of LDI insn. 4943ENUM 4944 BFD_RELOC_AVR_LO8_LDI_PM 4945ENUMDOC 4946 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 4947 command address) into 8 bit immediate value of LDI insn. 4948ENUM 4949 BFD_RELOC_AVR_LO8_LDI_GS 4950ENUMDOC 4951 This is a 16 bit reloc for the AVR that stores 8 bit value 4952 (command address) into 8 bit immediate value of LDI insn. If the address 4953 is beyond the 128k boundary, the linker inserts a jump stub for this reloc 4954 in the lower 128k. 4955ENUM 4956 BFD_RELOC_AVR_HI8_LDI_PM 4957ENUMDOC 4958 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 4959 of command address) into 8 bit immediate value of LDI insn. 4960ENUM 4961 BFD_RELOC_AVR_HI8_LDI_GS 4962ENUMDOC 4963 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 4964 of command address) into 8 bit immediate value of LDI insn. If the address 4965 is beyond the 128k boundary, the linker inserts a jump stub for this reloc 4966 below 128k. 4967ENUM 4968 BFD_RELOC_AVR_HH8_LDI_PM 4969ENUMDOC 4970 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 4971 of command address) into 8 bit immediate value of LDI insn. 4972ENUM 4973 BFD_RELOC_AVR_LO8_LDI_PM_NEG 4974ENUMDOC 4975 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4976 (usually command address) into 8 bit immediate value of SUBI insn. 4977ENUM 4978 BFD_RELOC_AVR_HI8_LDI_PM_NEG 4979ENUMDOC 4980 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4981 (high 8 bit of 16 bit command address) into 8 bit immediate value 4982 of SUBI insn. 4983ENUM 4984 BFD_RELOC_AVR_HH8_LDI_PM_NEG 4985ENUMDOC 4986 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4987 (high 6 bit of 22 bit command address) into 8 bit immediate 4988 value of SUBI insn. 4989ENUM 4990 BFD_RELOC_AVR_CALL 4991ENUMDOC 4992 This is a 32 bit reloc for the AVR that stores 23 bit value 4993 into 22 bits. 4994ENUM 4995 BFD_RELOC_AVR_LDI 4996ENUMDOC 4997 This is a 16 bit reloc for the AVR that stores all needed bits 4998 for absolute addressing with ldi with overflow check to linktime 4999ENUM 5000 BFD_RELOC_AVR_6 5001ENUMDOC 5002 This is a 6 bit reloc for the AVR that stores offset for ldd/std 5003 instructions 5004ENUM 5005 BFD_RELOC_AVR_6_ADIW 5006ENUMDOC 5007 This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw 5008 instructions 5009ENUM 5010 BFD_RELOC_AVR_8_LO 5011ENUMDOC 5012 This is a 8 bit reloc for the AVR that stores bits 0..7 of a symbol 5013 in .byte lo8(symbol) 5014ENUM 5015 BFD_RELOC_AVR_8_HI 5016ENUMDOC 5017 This is a 8 bit reloc for the AVR that stores bits 8..15 of a symbol 5018 in .byte hi8(symbol) 5019ENUM 5020 BFD_RELOC_AVR_8_HLO 5021ENUMDOC 5022 This is a 8 bit reloc for the AVR that stores bits 16..23 of a symbol 5023 in .byte hlo8(symbol) 5024ENUM 5025 BFD_RELOC_AVR_DIFF8 5026ENUMX 5027 BFD_RELOC_AVR_DIFF16 5028ENUMX 5029 BFD_RELOC_AVR_DIFF32 5030ENUMDOC 5031 AVR relocations to mark the difference of two local symbols. 5032 These are only needed to support linker relaxation and can be ignored 5033 when not relaxing. The field is set to the value of the difference 5034 assuming no relaxation. The relocation encodes the position of the 5035 second symbol so the linker can determine whether to adjust the field 5036 value. 5037ENUM 5038 BFD_RELOC_AVR_LDS_STS_16 5039ENUMDOC 5040 This is a 7 bit reloc for the AVR that stores SRAM address for 16bit 5041 lds and sts instructions supported only tiny core. 5042ENUM 5043 BFD_RELOC_AVR_PORT6 5044ENUMDOC 5045 This is a 6 bit reloc for the AVR that stores an I/O register 5046 number for the IN and OUT instructions 5047ENUM 5048 BFD_RELOC_AVR_PORT5 5049ENUMDOC 5050 This is a 5 bit reloc for the AVR that stores an I/O register 5051 number for the SBIC, SBIS, SBI and CBI instructions 5052 5053ENUM 5054 BFD_RELOC_RISCV_HI20 5055ENUMX 5056 BFD_RELOC_RISCV_PCREL_HI20 5057ENUMX 5058 BFD_RELOC_RISCV_PCREL_LO12_I 5059ENUMX 5060 BFD_RELOC_RISCV_PCREL_LO12_S 5061ENUMX 5062 BFD_RELOC_RISCV_LO12_I 5063ENUMX 5064 BFD_RELOC_RISCV_LO12_S 5065ENUMX 5066 BFD_RELOC_RISCV_GPREL12_I 5067ENUMX 5068 BFD_RELOC_RISCV_GPREL12_S 5069ENUMX 5070 BFD_RELOC_RISCV_TPREL_HI20 5071ENUMX 5072 BFD_RELOC_RISCV_TPREL_LO12_I 5073ENUMX 5074 BFD_RELOC_RISCV_TPREL_LO12_S 5075ENUMX 5076 BFD_RELOC_RISCV_TPREL_ADD 5077ENUMX 5078 BFD_RELOC_RISCV_CALL 5079ENUMX 5080 BFD_RELOC_RISCV_CALL_PLT 5081ENUMX 5082 BFD_RELOC_RISCV_ADD8 5083ENUMX 5084 BFD_RELOC_RISCV_ADD16 5085ENUMX 5086 BFD_RELOC_RISCV_ADD32 5087ENUMX 5088 BFD_RELOC_RISCV_ADD64 5089ENUMX 5090 BFD_RELOC_RISCV_SUB8 5091ENUMX 5092 BFD_RELOC_RISCV_SUB16 5093ENUMX 5094 BFD_RELOC_RISCV_SUB32 5095ENUMX 5096 BFD_RELOC_RISCV_SUB64 5097ENUMX 5098 BFD_RELOC_RISCV_GOT_HI20 5099ENUMX 5100 BFD_RELOC_RISCV_TLS_GOT_HI20 5101ENUMX 5102 BFD_RELOC_RISCV_TLS_GD_HI20 5103ENUMX 5104 BFD_RELOC_RISCV_JMP 5105ENUMX 5106 BFD_RELOC_RISCV_TLS_DTPMOD32 5107ENUMX 5108 BFD_RELOC_RISCV_TLS_DTPREL32 5109ENUMX 5110 BFD_RELOC_RISCV_TLS_DTPMOD64 5111ENUMX 5112 BFD_RELOC_RISCV_TLS_DTPREL64 5113ENUMX 5114 BFD_RELOC_RISCV_TLS_TPREL32 5115ENUMX 5116 BFD_RELOC_RISCV_TLS_TPREL64 5117ENUMX 5118 BFD_RELOC_RISCV_ALIGN 5119ENUMX 5120 BFD_RELOC_RISCV_RVC_BRANCH 5121ENUMX 5122 BFD_RELOC_RISCV_RVC_JUMP 5123ENUMX 5124 BFD_RELOC_RISCV_RVC_LUI 5125ENUMX 5126 BFD_RELOC_RISCV_GPREL_I 5127ENUMX 5128 BFD_RELOC_RISCV_GPREL_S 5129ENUMX 5130 BFD_RELOC_RISCV_TPREL_I 5131ENUMX 5132 BFD_RELOC_RISCV_TPREL_S 5133ENUMX 5134 BFD_RELOC_RISCV_RELAX 5135ENUMX 5136 BFD_RELOC_RISCV_CFA 5137ENUMX 5138 BFD_RELOC_RISCV_SUB6 5139ENUMX 5140 BFD_RELOC_RISCV_SET6 5141ENUMX 5142 BFD_RELOC_RISCV_SET8 5143ENUMX 5144 BFD_RELOC_RISCV_SET16 5145ENUMX 5146 BFD_RELOC_RISCV_SET32 5147ENUMDOC 5148 RISC-V relocations. 5149 5150ENUM 5151 BFD_RELOC_RL78_NEG8 5152ENUMX 5153 BFD_RELOC_RL78_NEG16 5154ENUMX 5155 BFD_RELOC_RL78_NEG24 5156ENUMX 5157 BFD_RELOC_RL78_NEG32 5158ENUMX 5159 BFD_RELOC_RL78_16_OP 5160ENUMX 5161 BFD_RELOC_RL78_24_OP 5162ENUMX 5163 BFD_RELOC_RL78_32_OP 5164ENUMX 5165 BFD_RELOC_RL78_8U 5166ENUMX 5167 BFD_RELOC_RL78_16U 5168ENUMX 5169 BFD_RELOC_RL78_24U 5170ENUMX 5171 BFD_RELOC_RL78_DIR3U_PCREL 5172ENUMX 5173 BFD_RELOC_RL78_DIFF 5174ENUMX 5175 BFD_RELOC_RL78_GPRELB 5176ENUMX 5177 BFD_RELOC_RL78_GPRELW 5178ENUMX 5179 BFD_RELOC_RL78_GPRELL 5180ENUMX 5181 BFD_RELOC_RL78_SYM 5182ENUMX 5183 BFD_RELOC_RL78_OP_SUBTRACT 5184ENUMX 5185 BFD_RELOC_RL78_OP_NEG 5186ENUMX 5187 BFD_RELOC_RL78_OP_AND 5188ENUMX 5189 BFD_RELOC_RL78_OP_SHRA 5190ENUMX 5191 BFD_RELOC_RL78_ABS8 5192ENUMX 5193 BFD_RELOC_RL78_ABS16 5194ENUMX 5195 BFD_RELOC_RL78_ABS16_REV 5196ENUMX 5197 BFD_RELOC_RL78_ABS32 5198ENUMX 5199 BFD_RELOC_RL78_ABS32_REV 5200ENUMX 5201 BFD_RELOC_RL78_ABS16U 5202ENUMX 5203 BFD_RELOC_RL78_ABS16UW 5204ENUMX 5205 BFD_RELOC_RL78_ABS16UL 5206ENUMX 5207 BFD_RELOC_RL78_RELAX 5208ENUMX 5209 BFD_RELOC_RL78_HI16 5210ENUMX 5211 BFD_RELOC_RL78_HI8 5212ENUMX 5213 BFD_RELOC_RL78_LO16 5214ENUMX 5215 BFD_RELOC_RL78_CODE 5216ENUMX 5217 BFD_RELOC_RL78_SADDR 5218ENUMDOC 5219 Renesas RL78 Relocations. 5220 5221ENUM 5222 BFD_RELOC_RX_NEG8 5223ENUMX 5224 BFD_RELOC_RX_NEG16 5225ENUMX 5226 BFD_RELOC_RX_NEG24 5227ENUMX 5228 BFD_RELOC_RX_NEG32 5229ENUMX 5230 BFD_RELOC_RX_16_OP 5231ENUMX 5232 BFD_RELOC_RX_24_OP 5233ENUMX 5234 BFD_RELOC_RX_32_OP 5235ENUMX 5236 BFD_RELOC_RX_8U 5237ENUMX 5238 BFD_RELOC_RX_16U 5239ENUMX 5240 BFD_RELOC_RX_24U 5241ENUMX 5242 BFD_RELOC_RX_DIR3U_PCREL 5243ENUMX 5244 BFD_RELOC_RX_DIFF 5245ENUMX 5246 BFD_RELOC_RX_GPRELB 5247ENUMX 5248 BFD_RELOC_RX_GPRELW 5249ENUMX 5250 BFD_RELOC_RX_GPRELL 5251ENUMX 5252 BFD_RELOC_RX_SYM 5253ENUMX 5254 BFD_RELOC_RX_OP_SUBTRACT 5255ENUMX 5256 BFD_RELOC_RX_OP_NEG 5257ENUMX 5258 BFD_RELOC_RX_ABS8 5259ENUMX 5260 BFD_RELOC_RX_ABS16 5261ENUMX 5262 BFD_RELOC_RX_ABS16_REV 5263ENUMX 5264 BFD_RELOC_RX_ABS32 5265ENUMX 5266 BFD_RELOC_RX_ABS32_REV 5267ENUMX 5268 BFD_RELOC_RX_ABS16U 5269ENUMX 5270 BFD_RELOC_RX_ABS16UW 5271ENUMX 5272 BFD_RELOC_RX_ABS16UL 5273ENUMX 5274 BFD_RELOC_RX_RELAX 5275ENUMDOC 5276 Renesas RX Relocations. 5277 5278ENUM 5279 BFD_RELOC_390_12 5280ENUMDOC 5281 Direct 12 bit. 5282ENUM 5283 BFD_RELOC_390_GOT12 5284ENUMDOC 5285 12 bit GOT offset. 5286ENUM 5287 BFD_RELOC_390_PLT32 5288ENUMDOC 5289 32 bit PC relative PLT address. 5290ENUM 5291 BFD_RELOC_390_COPY 5292ENUMDOC 5293 Copy symbol at runtime. 5294ENUM 5295 BFD_RELOC_390_GLOB_DAT 5296ENUMDOC 5297 Create GOT entry. 5298ENUM 5299 BFD_RELOC_390_JMP_SLOT 5300ENUMDOC 5301 Create PLT entry. 5302ENUM 5303 BFD_RELOC_390_RELATIVE 5304ENUMDOC 5305 Adjust by program base. 5306ENUM 5307 BFD_RELOC_390_GOTPC 5308ENUMDOC 5309 32 bit PC relative offset to GOT. 5310ENUM 5311 BFD_RELOC_390_GOT16 5312ENUMDOC 5313 16 bit GOT offset. 5314ENUM 5315 BFD_RELOC_390_PC12DBL 5316ENUMDOC 5317 PC relative 12 bit shifted by 1. 5318ENUM 5319 BFD_RELOC_390_PLT12DBL 5320ENUMDOC 5321 12 bit PC rel. PLT shifted by 1. 5322ENUM 5323 BFD_RELOC_390_PC16DBL 5324ENUMDOC 5325 PC relative 16 bit shifted by 1. 5326ENUM 5327 BFD_RELOC_390_PLT16DBL 5328ENUMDOC 5329 16 bit PC rel. PLT shifted by 1. 5330ENUM 5331 BFD_RELOC_390_PC24DBL 5332ENUMDOC 5333 PC relative 24 bit shifted by 1. 5334ENUM 5335 BFD_RELOC_390_PLT24DBL 5336ENUMDOC 5337 24 bit PC rel. PLT shifted by 1. 5338ENUM 5339 BFD_RELOC_390_PC32DBL 5340ENUMDOC 5341 PC relative 32 bit shifted by 1. 5342ENUM 5343 BFD_RELOC_390_PLT32DBL 5344ENUMDOC 5345 32 bit PC rel. PLT shifted by 1. 5346ENUM 5347 BFD_RELOC_390_GOTPCDBL 5348ENUMDOC 5349 32 bit PC rel. GOT shifted by 1. 5350ENUM 5351 BFD_RELOC_390_GOT64 5352ENUMDOC 5353 64 bit GOT offset. 5354ENUM 5355 BFD_RELOC_390_PLT64 5356ENUMDOC 5357 64 bit PC relative PLT address. 5358ENUM 5359 BFD_RELOC_390_GOTENT 5360ENUMDOC 5361 32 bit rel. offset to GOT entry. 5362ENUM 5363 BFD_RELOC_390_GOTOFF64 5364ENUMDOC 5365 64 bit offset to GOT. 5366ENUM 5367 BFD_RELOC_390_GOTPLT12 5368ENUMDOC 5369 12-bit offset to symbol-entry within GOT, with PLT handling. 5370ENUM 5371 BFD_RELOC_390_GOTPLT16 5372ENUMDOC 5373 16-bit offset to symbol-entry within GOT, with PLT handling. 5374ENUM 5375 BFD_RELOC_390_GOTPLT32 5376ENUMDOC 5377 32-bit offset to symbol-entry within GOT, with PLT handling. 5378ENUM 5379 BFD_RELOC_390_GOTPLT64 5380ENUMDOC 5381 64-bit offset to symbol-entry within GOT, with PLT handling. 5382ENUM 5383 BFD_RELOC_390_GOTPLTENT 5384ENUMDOC 5385 32-bit rel. offset to symbol-entry within GOT, with PLT handling. 5386ENUM 5387 BFD_RELOC_390_PLTOFF16 5388ENUMDOC 5389 16-bit rel. offset from the GOT to a PLT entry. 5390ENUM 5391 BFD_RELOC_390_PLTOFF32 5392ENUMDOC 5393 32-bit rel. offset from the GOT to a PLT entry. 5394ENUM 5395 BFD_RELOC_390_PLTOFF64 5396ENUMDOC 5397 64-bit rel. offset from the GOT to a PLT entry. 5398 5399ENUM 5400 BFD_RELOC_390_TLS_LOAD 5401ENUMX 5402 BFD_RELOC_390_TLS_GDCALL 5403ENUMX 5404 BFD_RELOC_390_TLS_LDCALL 5405ENUMX 5406 BFD_RELOC_390_TLS_GD32 5407ENUMX 5408 BFD_RELOC_390_TLS_GD64 5409ENUMX 5410 BFD_RELOC_390_TLS_GOTIE12 5411ENUMX 5412 BFD_RELOC_390_TLS_GOTIE32 5413ENUMX 5414 BFD_RELOC_390_TLS_GOTIE64 5415ENUMX 5416 BFD_RELOC_390_TLS_LDM32 5417ENUMX 5418 BFD_RELOC_390_TLS_LDM64 5419ENUMX 5420 BFD_RELOC_390_TLS_IE32 5421ENUMX 5422 BFD_RELOC_390_TLS_IE64 5423ENUMX 5424 BFD_RELOC_390_TLS_IEENT 5425ENUMX 5426 BFD_RELOC_390_TLS_LE32 5427ENUMX 5428 BFD_RELOC_390_TLS_LE64 5429ENUMX 5430 BFD_RELOC_390_TLS_LDO32 5431ENUMX 5432 BFD_RELOC_390_TLS_LDO64 5433ENUMX 5434 BFD_RELOC_390_TLS_DTPMOD 5435ENUMX 5436 BFD_RELOC_390_TLS_DTPOFF 5437ENUMX 5438 BFD_RELOC_390_TLS_TPOFF 5439ENUMDOC 5440 s390 tls relocations. 5441 5442ENUM 5443 BFD_RELOC_390_20 5444ENUMX 5445 BFD_RELOC_390_GOT20 5446ENUMX 5447 BFD_RELOC_390_GOTPLT20 5448ENUMX 5449 BFD_RELOC_390_TLS_GOTIE20 5450ENUMDOC 5451 Long displacement extension. 5452 5453ENUM 5454 BFD_RELOC_390_IRELATIVE 5455ENUMDOC 5456 STT_GNU_IFUNC relocation. 5457 5458ENUM 5459 BFD_RELOC_SCORE_GPREL15 5460ENUMDOC 5461 Score relocations 5462 Low 16 bit for load/store 5463ENUM 5464 BFD_RELOC_SCORE_DUMMY2 5465ENUMX 5466 BFD_RELOC_SCORE_JMP 5467ENUMDOC 5468 This is a 24-bit reloc with the right 1 bit assumed to be 0 5469ENUM 5470 BFD_RELOC_SCORE_BRANCH 5471ENUMDOC 5472 This is a 19-bit reloc with the right 1 bit assumed to be 0 5473ENUM 5474 BFD_RELOC_SCORE_IMM30 5475ENUMDOC 5476 This is a 32-bit reloc for 48-bit instructions. 5477ENUM 5478 BFD_RELOC_SCORE_IMM32 5479ENUMDOC 5480 This is a 32-bit reloc for 48-bit instructions. 5481ENUM 5482 BFD_RELOC_SCORE16_JMP 5483ENUMDOC 5484 This is a 11-bit reloc with the right 1 bit assumed to be 0 5485ENUM 5486 BFD_RELOC_SCORE16_BRANCH 5487ENUMDOC 5488 This is a 8-bit reloc with the right 1 bit assumed to be 0 5489ENUM 5490 BFD_RELOC_SCORE_BCMP 5491ENUMDOC 5492 This is a 9-bit reloc with the right 1 bit assumed to be 0 5493ENUM 5494 BFD_RELOC_SCORE_GOT15 5495ENUMX 5496 BFD_RELOC_SCORE_GOT_LO16 5497ENUMX 5498 BFD_RELOC_SCORE_CALL15 5499ENUMX 5500 BFD_RELOC_SCORE_DUMMY_HI16 5501ENUMDOC 5502 Undocumented Score relocs 5503 5504ENUM 5505 BFD_RELOC_IP2K_FR9 5506ENUMDOC 5507 Scenix IP2K - 9-bit register number / data address 5508ENUM 5509 BFD_RELOC_IP2K_BANK 5510ENUMDOC 5511 Scenix IP2K - 4-bit register/data bank number 5512ENUM 5513 BFD_RELOC_IP2K_ADDR16CJP 5514ENUMDOC 5515 Scenix IP2K - low 13 bits of instruction word address 5516ENUM 5517 BFD_RELOC_IP2K_PAGE3 5518ENUMDOC 5519 Scenix IP2K - high 3 bits of instruction word address 5520ENUM 5521 BFD_RELOC_IP2K_LO8DATA 5522ENUMX 5523 BFD_RELOC_IP2K_HI8DATA 5524ENUMX 5525 BFD_RELOC_IP2K_EX8DATA 5526ENUMDOC 5527 Scenix IP2K - ext/low/high 8 bits of data address 5528ENUM 5529 BFD_RELOC_IP2K_LO8INSN 5530ENUMX 5531 BFD_RELOC_IP2K_HI8INSN 5532ENUMDOC 5533 Scenix IP2K - low/high 8 bits of instruction word address 5534ENUM 5535 BFD_RELOC_IP2K_PC_SKIP 5536ENUMDOC 5537 Scenix IP2K - even/odd PC modifier to modify snb pcl.0 5538ENUM 5539 BFD_RELOC_IP2K_TEXT 5540ENUMDOC 5541 Scenix IP2K - 16 bit word address in text section. 5542ENUM 5543 BFD_RELOC_IP2K_FR_OFFSET 5544ENUMDOC 5545 Scenix IP2K - 7-bit sp or dp offset 5546ENUM 5547 BFD_RELOC_VPE4KMATH_DATA 5548ENUMX 5549 BFD_RELOC_VPE4KMATH_INSN 5550ENUMDOC 5551 Scenix VPE4K coprocessor - data/insn-space addressing 5552 5553ENUM 5554 BFD_RELOC_VTABLE_INHERIT 5555ENUMX 5556 BFD_RELOC_VTABLE_ENTRY 5557ENUMDOC 5558 These two relocations are used by the linker to determine which of 5559 the entries in a C++ virtual function table are actually used. When 5560 the --gc-sections option is given, the linker will zero out the entries 5561 that are not used, so that the code for those functions need not be 5562 included in the output. 5563 5564 VTABLE_INHERIT is a zero-space relocation used to describe to the 5565 linker the inheritance tree of a C++ virtual function table. The 5566 relocation's symbol should be the parent class' vtable, and the 5567 relocation should be located at the child vtable. 5568 5569 VTABLE_ENTRY is a zero-space relocation that describes the use of a 5570 virtual function table entry. The reloc's symbol should refer to the 5571 table of the class mentioned in the code. Off of that base, an offset 5572 describes the entry that is being used. For Rela hosts, this offset 5573 is stored in the reloc's addend. For Rel hosts, we are forced to put 5574 this offset in the reloc's section offset. 5575 5576ENUM 5577 BFD_RELOC_IA64_IMM14 5578ENUMX 5579 BFD_RELOC_IA64_IMM22 5580ENUMX 5581 BFD_RELOC_IA64_IMM64 5582ENUMX 5583 BFD_RELOC_IA64_DIR32MSB 5584ENUMX 5585 BFD_RELOC_IA64_DIR32LSB 5586ENUMX 5587 BFD_RELOC_IA64_DIR64MSB 5588ENUMX 5589 BFD_RELOC_IA64_DIR64LSB 5590ENUMX 5591 BFD_RELOC_IA64_GPREL22 5592ENUMX 5593 BFD_RELOC_IA64_GPREL64I 5594ENUMX 5595 BFD_RELOC_IA64_GPREL32MSB 5596ENUMX 5597 BFD_RELOC_IA64_GPREL32LSB 5598ENUMX 5599 BFD_RELOC_IA64_GPREL64MSB 5600ENUMX 5601 BFD_RELOC_IA64_GPREL64LSB 5602ENUMX 5603 BFD_RELOC_IA64_LTOFF22 5604ENUMX 5605 BFD_RELOC_IA64_LTOFF64I 5606ENUMX 5607 BFD_RELOC_IA64_PLTOFF22 5608ENUMX 5609 BFD_RELOC_IA64_PLTOFF64I 5610ENUMX 5611 BFD_RELOC_IA64_PLTOFF64MSB 5612ENUMX 5613 BFD_RELOC_IA64_PLTOFF64LSB 5614ENUMX 5615 BFD_RELOC_IA64_FPTR64I 5616ENUMX 5617 BFD_RELOC_IA64_FPTR32MSB 5618ENUMX 5619 BFD_RELOC_IA64_FPTR32LSB 5620ENUMX 5621 BFD_RELOC_IA64_FPTR64MSB 5622ENUMX 5623 BFD_RELOC_IA64_FPTR64LSB 5624ENUMX 5625 BFD_RELOC_IA64_PCREL21B 5626ENUMX 5627 BFD_RELOC_IA64_PCREL21BI 5628ENUMX 5629 BFD_RELOC_IA64_PCREL21M 5630ENUMX 5631 BFD_RELOC_IA64_PCREL21F 5632ENUMX 5633 BFD_RELOC_IA64_PCREL22 5634ENUMX 5635 BFD_RELOC_IA64_PCREL60B 5636ENUMX 5637 BFD_RELOC_IA64_PCREL64I 5638ENUMX 5639 BFD_RELOC_IA64_PCREL32MSB 5640ENUMX 5641 BFD_RELOC_IA64_PCREL32LSB 5642ENUMX 5643 BFD_RELOC_IA64_PCREL64MSB 5644ENUMX 5645 BFD_RELOC_IA64_PCREL64LSB 5646ENUMX 5647 BFD_RELOC_IA64_LTOFF_FPTR22 5648ENUMX 5649 BFD_RELOC_IA64_LTOFF_FPTR64I 5650ENUMX 5651 BFD_RELOC_IA64_LTOFF_FPTR32MSB 5652ENUMX 5653 BFD_RELOC_IA64_LTOFF_FPTR32LSB 5654ENUMX 5655 BFD_RELOC_IA64_LTOFF_FPTR64MSB 5656ENUMX 5657 BFD_RELOC_IA64_LTOFF_FPTR64LSB 5658ENUMX 5659 BFD_RELOC_IA64_SEGREL32MSB 5660ENUMX 5661 BFD_RELOC_IA64_SEGREL32LSB 5662ENUMX 5663 BFD_RELOC_IA64_SEGREL64MSB 5664ENUMX 5665 BFD_RELOC_IA64_SEGREL64LSB 5666ENUMX 5667 BFD_RELOC_IA64_SECREL32MSB 5668ENUMX 5669 BFD_RELOC_IA64_SECREL32LSB 5670ENUMX 5671 BFD_RELOC_IA64_SECREL64MSB 5672ENUMX 5673 BFD_RELOC_IA64_SECREL64LSB 5674ENUMX 5675 BFD_RELOC_IA64_REL32MSB 5676ENUMX 5677 BFD_RELOC_IA64_REL32LSB 5678ENUMX 5679 BFD_RELOC_IA64_REL64MSB 5680ENUMX 5681 BFD_RELOC_IA64_REL64LSB 5682ENUMX 5683 BFD_RELOC_IA64_LTV32MSB 5684ENUMX 5685 BFD_RELOC_IA64_LTV32LSB 5686ENUMX 5687 BFD_RELOC_IA64_LTV64MSB 5688ENUMX 5689 BFD_RELOC_IA64_LTV64LSB 5690ENUMX 5691 BFD_RELOC_IA64_IPLTMSB 5692ENUMX 5693 BFD_RELOC_IA64_IPLTLSB 5694ENUMX 5695 BFD_RELOC_IA64_COPY 5696ENUMX 5697 BFD_RELOC_IA64_LTOFF22X 5698ENUMX 5699 BFD_RELOC_IA64_LDXMOV 5700ENUMX 5701 BFD_RELOC_IA64_TPREL14 5702ENUMX 5703 BFD_RELOC_IA64_TPREL22 5704ENUMX 5705 BFD_RELOC_IA64_TPREL64I 5706ENUMX 5707 BFD_RELOC_IA64_TPREL64MSB 5708ENUMX 5709 BFD_RELOC_IA64_TPREL64LSB 5710ENUMX 5711 BFD_RELOC_IA64_LTOFF_TPREL22 5712ENUMX 5713 BFD_RELOC_IA64_DTPMOD64MSB 5714ENUMX 5715 BFD_RELOC_IA64_DTPMOD64LSB 5716ENUMX 5717 BFD_RELOC_IA64_LTOFF_DTPMOD22 5718ENUMX 5719 BFD_RELOC_IA64_DTPREL14 5720ENUMX 5721 BFD_RELOC_IA64_DTPREL22 5722ENUMX 5723 BFD_RELOC_IA64_DTPREL64I 5724ENUMX 5725 BFD_RELOC_IA64_DTPREL32MSB 5726ENUMX 5727 BFD_RELOC_IA64_DTPREL32LSB 5728ENUMX 5729 BFD_RELOC_IA64_DTPREL64MSB 5730ENUMX 5731 BFD_RELOC_IA64_DTPREL64LSB 5732ENUMX 5733 BFD_RELOC_IA64_LTOFF_DTPREL22 5734ENUMDOC 5735 Intel IA64 Relocations. 5736 5737ENUM 5738 BFD_RELOC_M68HC11_HI8 5739ENUMDOC 5740 Motorola 68HC11 reloc. 5741 This is the 8 bit high part of an absolute address. 5742ENUM 5743 BFD_RELOC_M68HC11_LO8 5744ENUMDOC 5745 Motorola 68HC11 reloc. 5746 This is the 8 bit low part of an absolute address. 5747ENUM 5748 BFD_RELOC_M68HC11_3B 5749ENUMDOC 5750 Motorola 68HC11 reloc. 5751 This is the 3 bit of a value. 5752ENUM 5753 BFD_RELOC_M68HC11_RL_JUMP 5754ENUMDOC 5755 Motorola 68HC11 reloc. 5756 This reloc marks the beginning of a jump/call instruction. 5757 It is used for linker relaxation to correctly identify beginning 5758 of instruction and change some branches to use PC-relative 5759 addressing mode. 5760ENUM 5761 BFD_RELOC_M68HC11_RL_GROUP 5762ENUMDOC 5763 Motorola 68HC11 reloc. 5764 This reloc marks a group of several instructions that gcc generates 5765 and for which the linker relaxation pass can modify and/or remove 5766 some of them. 5767ENUM 5768 BFD_RELOC_M68HC11_LO16 5769ENUMDOC 5770 Motorola 68HC11 reloc. 5771 This is the 16-bit lower part of an address. It is used for 'call' 5772 instruction to specify the symbol address without any special 5773 transformation (due to memory bank window). 5774ENUM 5775 BFD_RELOC_M68HC11_PAGE 5776ENUMDOC 5777 Motorola 68HC11 reloc. 5778 This is a 8-bit reloc that specifies the page number of an address. 5779 It is used by 'call' instruction to specify the page number of 5780 the symbol. 5781ENUM 5782 BFD_RELOC_M68HC11_24 5783ENUMDOC 5784 Motorola 68HC11 reloc. 5785 This is a 24-bit reloc that represents the address with a 16-bit 5786 value and a 8-bit page number. The symbol address is transformed 5787 to follow the 16K memory bank of 68HC12 (seen as mapped in the window). 5788ENUM 5789 BFD_RELOC_M68HC12_5B 5790ENUMDOC 5791 Motorola 68HC12 reloc. 5792 This is the 5 bits of a value. 5793ENUM 5794 BFD_RELOC_XGATE_RL_JUMP 5795ENUMDOC 5796 Freescale XGATE reloc. 5797 This reloc marks the beginning of a bra/jal instruction. 5798ENUM 5799 BFD_RELOC_XGATE_RL_GROUP 5800ENUMDOC 5801 Freescale XGATE reloc. 5802 This reloc marks a group of several instructions that gcc generates 5803 and for which the linker relaxation pass can modify and/or remove 5804 some of them. 5805ENUM 5806 BFD_RELOC_XGATE_LO16 5807ENUMDOC 5808 Freescale XGATE reloc. 5809 This is the 16-bit lower part of an address. It is used for the '16-bit' 5810 instructions. 5811ENUM 5812 BFD_RELOC_XGATE_GPAGE 5813ENUMDOC 5814 Freescale XGATE reloc. 5815ENUM 5816 BFD_RELOC_XGATE_24 5817ENUMDOC 5818 Freescale XGATE reloc. 5819ENUM 5820 BFD_RELOC_XGATE_PCREL_9 5821ENUMDOC 5822 Freescale XGATE reloc. 5823 This is a 9-bit pc-relative reloc. 5824ENUM 5825 BFD_RELOC_XGATE_PCREL_10 5826ENUMDOC 5827 Freescale XGATE reloc. 5828 This is a 10-bit pc-relative reloc. 5829ENUM 5830 BFD_RELOC_XGATE_IMM8_LO 5831ENUMDOC 5832 Freescale XGATE reloc. 5833 This is the 16-bit lower part of an address. It is used for the '16-bit' 5834 instructions. 5835ENUM 5836 BFD_RELOC_XGATE_IMM8_HI 5837ENUMDOC 5838 Freescale XGATE reloc. 5839 This is the 16-bit higher part of an address. It is used for the '16-bit' 5840 instructions. 5841ENUM 5842 BFD_RELOC_XGATE_IMM3 5843ENUMDOC 5844 Freescale XGATE reloc. 5845 This is a 3-bit pc-relative reloc. 5846ENUM 5847 BFD_RELOC_XGATE_IMM4 5848ENUMDOC 5849 Freescale XGATE reloc. 5850 This is a 4-bit pc-relative reloc. 5851ENUM 5852 BFD_RELOC_XGATE_IMM5 5853ENUMDOC 5854 Freescale XGATE reloc. 5855 This is a 5-bit pc-relative reloc. 5856ENUM 5857 BFD_RELOC_M68HC12_9B 5858ENUMDOC 5859 Motorola 68HC12 reloc. 5860 This is the 9 bits of a value. 5861ENUM 5862 BFD_RELOC_M68HC12_16B 5863ENUMDOC 5864 Motorola 68HC12 reloc. 5865 This is the 16 bits of a value. 5866ENUM 5867 BFD_RELOC_M68HC12_9_PCREL 5868ENUMDOC 5869 Motorola 68HC12/XGATE reloc. 5870 This is a PCREL9 branch. 5871ENUM 5872 BFD_RELOC_M68HC12_10_PCREL 5873ENUMDOC 5874 Motorola 68HC12/XGATE reloc. 5875 This is a PCREL10 branch. 5876ENUM 5877 BFD_RELOC_M68HC12_LO8XG 5878ENUMDOC 5879 Motorola 68HC12/XGATE reloc. 5880 This is the 8 bit low part of an absolute address and immediately precedes 5881 a matching HI8XG part. 5882ENUM 5883 BFD_RELOC_M68HC12_HI8XG 5884ENUMDOC 5885 Motorola 68HC12/XGATE reloc. 5886 This is the 8 bit high part of an absolute address and immediately follows 5887 a matching LO8XG part. 5888ENUM 5889 BFD_RELOC_16C_NUM08 5890ENUMX 5891 BFD_RELOC_16C_NUM08_C 5892ENUMX 5893 BFD_RELOC_16C_NUM16 5894ENUMX 5895 BFD_RELOC_16C_NUM16_C 5896ENUMX 5897 BFD_RELOC_16C_NUM32 5898ENUMX 5899 BFD_RELOC_16C_NUM32_C 5900ENUMX 5901 BFD_RELOC_16C_DISP04 5902ENUMX 5903 BFD_RELOC_16C_DISP04_C 5904ENUMX 5905 BFD_RELOC_16C_DISP08 5906ENUMX 5907 BFD_RELOC_16C_DISP08_C 5908ENUMX 5909 BFD_RELOC_16C_DISP16 5910ENUMX 5911 BFD_RELOC_16C_DISP16_C 5912ENUMX 5913 BFD_RELOC_16C_DISP24 5914ENUMX 5915 BFD_RELOC_16C_DISP24_C 5916ENUMX 5917 BFD_RELOC_16C_DISP24a 5918ENUMX 5919 BFD_RELOC_16C_DISP24a_C 5920ENUMX 5921 BFD_RELOC_16C_REG04 5922ENUMX 5923 BFD_RELOC_16C_REG04_C 5924ENUMX 5925 BFD_RELOC_16C_REG04a 5926ENUMX 5927 BFD_RELOC_16C_REG04a_C 5928ENUMX 5929 BFD_RELOC_16C_REG14 5930ENUMX 5931 BFD_RELOC_16C_REG14_C 5932ENUMX 5933 BFD_RELOC_16C_REG16 5934ENUMX 5935 BFD_RELOC_16C_REG16_C 5936ENUMX 5937 BFD_RELOC_16C_REG20 5938ENUMX 5939 BFD_RELOC_16C_REG20_C 5940ENUMX 5941 BFD_RELOC_16C_ABS20 5942ENUMX 5943 BFD_RELOC_16C_ABS20_C 5944ENUMX 5945 BFD_RELOC_16C_ABS24 5946ENUMX 5947 BFD_RELOC_16C_ABS24_C 5948ENUMX 5949 BFD_RELOC_16C_IMM04 5950ENUMX 5951 BFD_RELOC_16C_IMM04_C 5952ENUMX 5953 BFD_RELOC_16C_IMM16 5954ENUMX 5955 BFD_RELOC_16C_IMM16_C 5956ENUMX 5957 BFD_RELOC_16C_IMM20 5958ENUMX 5959 BFD_RELOC_16C_IMM20_C 5960ENUMX 5961 BFD_RELOC_16C_IMM24 5962ENUMX 5963 BFD_RELOC_16C_IMM24_C 5964ENUMX 5965 BFD_RELOC_16C_IMM32 5966ENUMX 5967 BFD_RELOC_16C_IMM32_C 5968ENUMDOC 5969 NS CR16C Relocations. 5970 5971ENUM 5972 BFD_RELOC_CR16_NUM8 5973ENUMX 5974 BFD_RELOC_CR16_NUM16 5975ENUMX 5976 BFD_RELOC_CR16_NUM32 5977ENUMX 5978 BFD_RELOC_CR16_NUM32a 5979ENUMX 5980 BFD_RELOC_CR16_REGREL0 5981ENUMX 5982 BFD_RELOC_CR16_REGREL4 5983ENUMX 5984 BFD_RELOC_CR16_REGREL4a 5985ENUMX 5986 BFD_RELOC_CR16_REGREL14 5987ENUMX 5988 BFD_RELOC_CR16_REGREL14a 5989ENUMX 5990 BFD_RELOC_CR16_REGREL16 5991ENUMX 5992 BFD_RELOC_CR16_REGREL20 5993ENUMX 5994 BFD_RELOC_CR16_REGREL20a 5995ENUMX 5996 BFD_RELOC_CR16_ABS20 5997ENUMX 5998 BFD_RELOC_CR16_ABS24 5999ENUMX 6000 BFD_RELOC_CR16_IMM4 6001ENUMX 6002 BFD_RELOC_CR16_IMM8 6003ENUMX 6004 BFD_RELOC_CR16_IMM16 6005ENUMX 6006 BFD_RELOC_CR16_IMM20 6007ENUMX 6008 BFD_RELOC_CR16_IMM24 6009ENUMX 6010 BFD_RELOC_CR16_IMM32 6011ENUMX 6012 BFD_RELOC_CR16_IMM32a 6013ENUMX 6014 BFD_RELOC_CR16_DISP4 6015ENUMX 6016 BFD_RELOC_CR16_DISP8 6017ENUMX 6018 BFD_RELOC_CR16_DISP16 6019ENUMX 6020 BFD_RELOC_CR16_DISP20 6021ENUMX 6022 BFD_RELOC_CR16_DISP24 6023ENUMX 6024 BFD_RELOC_CR16_DISP24a 6025ENUMX 6026 BFD_RELOC_CR16_SWITCH8 6027ENUMX 6028 BFD_RELOC_CR16_SWITCH16 6029ENUMX 6030 BFD_RELOC_CR16_SWITCH32 6031ENUMX 6032 BFD_RELOC_CR16_GOT_REGREL20 6033ENUMX 6034 BFD_RELOC_CR16_GOTC_REGREL20 6035ENUMX 6036 BFD_RELOC_CR16_GLOB_DAT 6037ENUMDOC 6038 NS CR16 Relocations. 6039 6040ENUM 6041 BFD_RELOC_CRX_REL4 6042ENUMX 6043 BFD_RELOC_CRX_REL8 6044ENUMX 6045 BFD_RELOC_CRX_REL8_CMP 6046ENUMX 6047 BFD_RELOC_CRX_REL16 6048ENUMX 6049 BFD_RELOC_CRX_REL24 6050ENUMX 6051 BFD_RELOC_CRX_REL32 6052ENUMX 6053 BFD_RELOC_CRX_REGREL12 6054ENUMX 6055 BFD_RELOC_CRX_REGREL22 6056ENUMX 6057 BFD_RELOC_CRX_REGREL28 6058ENUMX 6059 BFD_RELOC_CRX_REGREL32 6060ENUMX 6061 BFD_RELOC_CRX_ABS16 6062ENUMX 6063 BFD_RELOC_CRX_ABS32 6064ENUMX 6065 BFD_RELOC_CRX_NUM8 6066ENUMX 6067 BFD_RELOC_CRX_NUM16 6068ENUMX 6069 BFD_RELOC_CRX_NUM32 6070ENUMX 6071 BFD_RELOC_CRX_IMM16 6072ENUMX 6073 BFD_RELOC_CRX_IMM32 6074ENUMX 6075 BFD_RELOC_CRX_SWITCH8 6076ENUMX 6077 BFD_RELOC_CRX_SWITCH16 6078ENUMX 6079 BFD_RELOC_CRX_SWITCH32 6080ENUMDOC 6081 NS CRX Relocations. 6082 6083ENUM 6084 BFD_RELOC_CRIS_BDISP8 6085ENUMX 6086 BFD_RELOC_CRIS_UNSIGNED_5 6087ENUMX 6088 BFD_RELOC_CRIS_SIGNED_6 6089ENUMX 6090 BFD_RELOC_CRIS_UNSIGNED_6 6091ENUMX 6092 BFD_RELOC_CRIS_SIGNED_8 6093ENUMX 6094 BFD_RELOC_CRIS_UNSIGNED_8 6095ENUMX 6096 BFD_RELOC_CRIS_SIGNED_16 6097ENUMX 6098 BFD_RELOC_CRIS_UNSIGNED_16 6099ENUMX 6100 BFD_RELOC_CRIS_LAPCQ_OFFSET 6101ENUMX 6102 BFD_RELOC_CRIS_UNSIGNED_4 6103ENUMDOC 6104 These relocs are only used within the CRIS assembler. They are not 6105 (at present) written to any object files. 6106ENUM 6107 BFD_RELOC_CRIS_COPY 6108ENUMX 6109 BFD_RELOC_CRIS_GLOB_DAT 6110ENUMX 6111 BFD_RELOC_CRIS_JUMP_SLOT 6112ENUMX 6113 BFD_RELOC_CRIS_RELATIVE 6114ENUMDOC 6115 Relocs used in ELF shared libraries for CRIS. 6116ENUM 6117 BFD_RELOC_CRIS_32_GOT 6118ENUMDOC 6119 32-bit offset to symbol-entry within GOT. 6120ENUM 6121 BFD_RELOC_CRIS_16_GOT 6122ENUMDOC 6123 16-bit offset to symbol-entry within GOT. 6124ENUM 6125 BFD_RELOC_CRIS_32_GOTPLT 6126ENUMDOC 6127 32-bit offset to symbol-entry within GOT, with PLT handling. 6128ENUM 6129 BFD_RELOC_CRIS_16_GOTPLT 6130ENUMDOC 6131 16-bit offset to symbol-entry within GOT, with PLT handling. 6132ENUM 6133 BFD_RELOC_CRIS_32_GOTREL 6134ENUMDOC 6135 32-bit offset to symbol, relative to GOT. 6136ENUM 6137 BFD_RELOC_CRIS_32_PLT_GOTREL 6138ENUMDOC 6139 32-bit offset to symbol with PLT entry, relative to GOT. 6140ENUM 6141 BFD_RELOC_CRIS_32_PLT_PCREL 6142ENUMDOC 6143 32-bit offset to symbol with PLT entry, relative to this relocation. 6144 6145ENUM 6146 BFD_RELOC_CRIS_32_GOT_GD 6147ENUMX 6148 BFD_RELOC_CRIS_16_GOT_GD 6149ENUMX 6150 BFD_RELOC_CRIS_32_GD 6151ENUMX 6152 BFD_RELOC_CRIS_DTP 6153ENUMX 6154 BFD_RELOC_CRIS_32_DTPREL 6155ENUMX 6156 BFD_RELOC_CRIS_16_DTPREL 6157ENUMX 6158 BFD_RELOC_CRIS_32_GOT_TPREL 6159ENUMX 6160 BFD_RELOC_CRIS_16_GOT_TPREL 6161ENUMX 6162 BFD_RELOC_CRIS_32_TPREL 6163ENUMX 6164 BFD_RELOC_CRIS_16_TPREL 6165ENUMX 6166 BFD_RELOC_CRIS_DTPMOD 6167ENUMX 6168 BFD_RELOC_CRIS_32_IE 6169ENUMDOC 6170 Relocs used in TLS code for CRIS. 6171 6172ENUM 6173 BFD_RELOC_860_COPY 6174ENUMX 6175 BFD_RELOC_860_GLOB_DAT 6176ENUMX 6177 BFD_RELOC_860_JUMP_SLOT 6178ENUMX 6179 BFD_RELOC_860_RELATIVE 6180ENUMX 6181 BFD_RELOC_860_PC26 6182ENUMX 6183 BFD_RELOC_860_PLT26 6184ENUMX 6185 BFD_RELOC_860_PC16 6186ENUMX 6187 BFD_RELOC_860_LOW0 6188ENUMX 6189 BFD_RELOC_860_SPLIT0 6190ENUMX 6191 BFD_RELOC_860_LOW1 6192ENUMX 6193 BFD_RELOC_860_SPLIT1 6194ENUMX 6195 BFD_RELOC_860_LOW2 6196ENUMX 6197 BFD_RELOC_860_SPLIT2 6198ENUMX 6199 BFD_RELOC_860_LOW3 6200ENUMX 6201 BFD_RELOC_860_LOGOT0 6202ENUMX 6203 BFD_RELOC_860_SPGOT0 6204ENUMX 6205 BFD_RELOC_860_LOGOT1 6206ENUMX 6207 BFD_RELOC_860_SPGOT1 6208ENUMX 6209 BFD_RELOC_860_LOGOTOFF0 6210ENUMX 6211 BFD_RELOC_860_SPGOTOFF0 6212ENUMX 6213 BFD_RELOC_860_LOGOTOFF1 6214ENUMX 6215 BFD_RELOC_860_SPGOTOFF1 6216ENUMX 6217 BFD_RELOC_860_LOGOTOFF2 6218ENUMX 6219 BFD_RELOC_860_LOGOTOFF3 6220ENUMX 6221 BFD_RELOC_860_LOPC 6222ENUMX 6223 BFD_RELOC_860_HIGHADJ 6224ENUMX 6225 BFD_RELOC_860_HAGOT 6226ENUMX 6227 BFD_RELOC_860_HAGOTOFF 6228ENUMX 6229 BFD_RELOC_860_HAPC 6230ENUMX 6231 BFD_RELOC_860_HIGH 6232ENUMX 6233 BFD_RELOC_860_HIGOT 6234ENUMX 6235 BFD_RELOC_860_HIGOTOFF 6236ENUMDOC 6237 Intel i860 Relocations. 6238 6239ENUM 6240 BFD_RELOC_OR1K_REL_26 6241ENUMX 6242 BFD_RELOC_OR1K_GOTPC_HI16 6243ENUMX 6244 BFD_RELOC_OR1K_GOTPC_LO16 6245ENUMX 6246 BFD_RELOC_OR1K_GOT16 6247ENUMX 6248 BFD_RELOC_OR1K_PLT26 6249ENUMX 6250 BFD_RELOC_OR1K_GOTOFF_HI16 6251ENUMX 6252 BFD_RELOC_OR1K_GOTOFF_LO16 6253ENUMX 6254 BFD_RELOC_OR1K_COPY 6255ENUMX 6256 BFD_RELOC_OR1K_GLOB_DAT 6257ENUMX 6258 BFD_RELOC_OR1K_JMP_SLOT 6259ENUMX 6260 BFD_RELOC_OR1K_RELATIVE 6261ENUMX 6262 BFD_RELOC_OR1K_TLS_GD_HI16 6263ENUMX 6264 BFD_RELOC_OR1K_TLS_GD_LO16 6265ENUMX 6266 BFD_RELOC_OR1K_TLS_LDM_HI16 6267ENUMX 6268 BFD_RELOC_OR1K_TLS_LDM_LO16 6269ENUMX 6270 BFD_RELOC_OR1K_TLS_LDO_HI16 6271ENUMX 6272 BFD_RELOC_OR1K_TLS_LDO_LO16 6273ENUMX 6274 BFD_RELOC_OR1K_TLS_IE_HI16 6275ENUMX 6276 BFD_RELOC_OR1K_TLS_IE_LO16 6277ENUMX 6278 BFD_RELOC_OR1K_TLS_LE_HI16 6279ENUMX 6280 BFD_RELOC_OR1K_TLS_LE_LO16 6281ENUMX 6282 BFD_RELOC_OR1K_TLS_TPOFF 6283ENUMX 6284 BFD_RELOC_OR1K_TLS_DTPOFF 6285ENUMX 6286 BFD_RELOC_OR1K_TLS_DTPMOD 6287ENUMDOC 6288 OpenRISC 1000 Relocations. 6289 6290ENUM 6291 BFD_RELOC_H8_DIR16A8 6292ENUMX 6293 BFD_RELOC_H8_DIR16R8 6294ENUMX 6295 BFD_RELOC_H8_DIR24A8 6296ENUMX 6297 BFD_RELOC_H8_DIR24R8 6298ENUMX 6299 BFD_RELOC_H8_DIR32A16 6300ENUMX 6301 BFD_RELOC_H8_DISP32A16 6302ENUMDOC 6303 H8 elf Relocations. 6304 6305ENUM 6306 BFD_RELOC_XSTORMY16_REL_12 6307ENUMX 6308 BFD_RELOC_XSTORMY16_12 6309ENUMX 6310 BFD_RELOC_XSTORMY16_24 6311ENUMX 6312 BFD_RELOC_XSTORMY16_FPTR16 6313ENUMDOC 6314 Sony Xstormy16 Relocations. 6315 6316ENUM 6317 BFD_RELOC_RELC 6318ENUMDOC 6319 Self-describing complex relocations. 6320COMMENT 6321 6322ENUM 6323 BFD_RELOC_XC16X_PAG 6324ENUMX 6325 BFD_RELOC_XC16X_POF 6326ENUMX 6327 BFD_RELOC_XC16X_SEG 6328ENUMX 6329 BFD_RELOC_XC16X_SOF 6330ENUMDOC 6331 Infineon Relocations. 6332 6333ENUM 6334 BFD_RELOC_VAX_GLOB_DAT 6335ENUMX 6336 BFD_RELOC_VAX_JMP_SLOT 6337ENUMX 6338 BFD_RELOC_VAX_RELATIVE 6339ENUMDOC 6340 Relocations used by VAX ELF. 6341 6342ENUM 6343 BFD_RELOC_MT_PC16 6344ENUMDOC 6345 Morpho MT - 16 bit immediate relocation. 6346ENUM 6347 BFD_RELOC_MT_HI16 6348ENUMDOC 6349 Morpho MT - Hi 16 bits of an address. 6350ENUM 6351 BFD_RELOC_MT_LO16 6352ENUMDOC 6353 Morpho MT - Low 16 bits of an address. 6354ENUM 6355 BFD_RELOC_MT_GNU_VTINHERIT 6356ENUMDOC 6357 Morpho MT - Used to tell the linker which vtable entries are used. 6358ENUM 6359 BFD_RELOC_MT_GNU_VTENTRY 6360ENUMDOC 6361 Morpho MT - Used to tell the linker which vtable entries are used. 6362ENUM 6363 BFD_RELOC_MT_PCINSN8 6364ENUMDOC 6365 Morpho MT - 8 bit immediate relocation. 6366 6367ENUM 6368 BFD_RELOC_MSP430_10_PCREL 6369ENUMX 6370 BFD_RELOC_MSP430_16_PCREL 6371ENUMX 6372 BFD_RELOC_MSP430_16 6373ENUMX 6374 BFD_RELOC_MSP430_16_PCREL_BYTE 6375ENUMX 6376 BFD_RELOC_MSP430_16_BYTE 6377ENUMX 6378 BFD_RELOC_MSP430_2X_PCREL 6379ENUMX 6380 BFD_RELOC_MSP430_RL_PCREL 6381ENUMX 6382 BFD_RELOC_MSP430_ABS8 6383ENUMX 6384 BFD_RELOC_MSP430X_PCR20_EXT_SRC 6385ENUMX 6386 BFD_RELOC_MSP430X_PCR20_EXT_DST 6387ENUMX 6388 BFD_RELOC_MSP430X_PCR20_EXT_ODST 6389ENUMX 6390 BFD_RELOC_MSP430X_ABS20_EXT_SRC 6391ENUMX 6392 BFD_RELOC_MSP430X_ABS20_EXT_DST 6393ENUMX 6394 BFD_RELOC_MSP430X_ABS20_EXT_ODST 6395ENUMX 6396 BFD_RELOC_MSP430X_ABS20_ADR_SRC 6397ENUMX 6398 BFD_RELOC_MSP430X_ABS20_ADR_DST 6399ENUMX 6400 BFD_RELOC_MSP430X_PCR16 6401ENUMX 6402 BFD_RELOC_MSP430X_PCR20_CALL 6403ENUMX 6404 BFD_RELOC_MSP430X_ABS16 6405ENUMX 6406 BFD_RELOC_MSP430_ABS_HI16 6407ENUMX 6408 BFD_RELOC_MSP430_PREL31 6409ENUMX 6410 BFD_RELOC_MSP430_SYM_DIFF 6411ENUMDOC 6412 msp430 specific relocation codes 6413 6414ENUM 6415 BFD_RELOC_NIOS2_S16 6416ENUMX 6417 BFD_RELOC_NIOS2_U16 6418ENUMX 6419 BFD_RELOC_NIOS2_CALL26 6420ENUMX 6421 BFD_RELOC_NIOS2_IMM5 6422ENUMX 6423 BFD_RELOC_NIOS2_CACHE_OPX 6424ENUMX 6425 BFD_RELOC_NIOS2_IMM6 6426ENUMX 6427 BFD_RELOC_NIOS2_IMM8 6428ENUMX 6429 BFD_RELOC_NIOS2_HI16 6430ENUMX 6431 BFD_RELOC_NIOS2_LO16 6432ENUMX 6433 BFD_RELOC_NIOS2_HIADJ16 6434ENUMX 6435 BFD_RELOC_NIOS2_GPREL 6436ENUMX 6437 BFD_RELOC_NIOS2_UJMP 6438ENUMX 6439 BFD_RELOC_NIOS2_CJMP 6440ENUMX 6441 BFD_RELOC_NIOS2_CALLR 6442ENUMX 6443 BFD_RELOC_NIOS2_ALIGN 6444ENUMX 6445 BFD_RELOC_NIOS2_GOT16 6446ENUMX 6447 BFD_RELOC_NIOS2_CALL16 6448ENUMX 6449 BFD_RELOC_NIOS2_GOTOFF_LO 6450ENUMX 6451 BFD_RELOC_NIOS2_GOTOFF_HA 6452ENUMX 6453 BFD_RELOC_NIOS2_PCREL_LO 6454ENUMX 6455 BFD_RELOC_NIOS2_PCREL_HA 6456ENUMX 6457 BFD_RELOC_NIOS2_TLS_GD16 6458ENUMX 6459 BFD_RELOC_NIOS2_TLS_LDM16 6460ENUMX 6461 BFD_RELOC_NIOS2_TLS_LDO16 6462ENUMX 6463 BFD_RELOC_NIOS2_TLS_IE16 6464ENUMX 6465 BFD_RELOC_NIOS2_TLS_LE16 6466ENUMX 6467 BFD_RELOC_NIOS2_TLS_DTPMOD 6468ENUMX 6469 BFD_RELOC_NIOS2_TLS_DTPREL 6470ENUMX 6471 BFD_RELOC_NIOS2_TLS_TPREL 6472ENUMX 6473 BFD_RELOC_NIOS2_COPY 6474ENUMX 6475 BFD_RELOC_NIOS2_GLOB_DAT 6476ENUMX 6477 BFD_RELOC_NIOS2_JUMP_SLOT 6478ENUMX 6479 BFD_RELOC_NIOS2_RELATIVE 6480ENUMX 6481 BFD_RELOC_NIOS2_GOTOFF 6482ENUMX 6483 BFD_RELOC_NIOS2_CALL26_NOAT 6484ENUMX 6485 BFD_RELOC_NIOS2_GOT_LO 6486ENUMX 6487 BFD_RELOC_NIOS2_GOT_HA 6488ENUMX 6489 BFD_RELOC_NIOS2_CALL_LO 6490ENUMX 6491 BFD_RELOC_NIOS2_CALL_HA 6492ENUMX 6493 BFD_RELOC_NIOS2_R2_S12 6494ENUMX 6495 BFD_RELOC_NIOS2_R2_I10_1_PCREL 6496ENUMX 6497 BFD_RELOC_NIOS2_R2_T1I7_1_PCREL 6498ENUMX 6499 BFD_RELOC_NIOS2_R2_T1I7_2 6500ENUMX 6501 BFD_RELOC_NIOS2_R2_T2I4 6502ENUMX 6503 BFD_RELOC_NIOS2_R2_T2I4_1 6504ENUMX 6505 BFD_RELOC_NIOS2_R2_T2I4_2 6506ENUMX 6507 BFD_RELOC_NIOS2_R2_X1I7_2 6508ENUMX 6509 BFD_RELOC_NIOS2_R2_X2L5 6510ENUMX 6511 BFD_RELOC_NIOS2_R2_F1I5_2 6512ENUMX 6513 BFD_RELOC_NIOS2_R2_L5I4X1 6514ENUMX 6515 BFD_RELOC_NIOS2_R2_T1X1I6 6516ENUMX 6517 BFD_RELOC_NIOS2_R2_T1X1I6_2 6518ENUMDOC 6519 Relocations used by the Altera Nios II core. 6520 6521ENUM 6522 BFD_RELOC_IQ2000_OFFSET_16 6523ENUMX 6524 BFD_RELOC_IQ2000_OFFSET_21 6525ENUMX 6526 BFD_RELOC_IQ2000_UHI16 6527ENUMDOC 6528 IQ2000 Relocations. 6529 6530ENUM 6531 BFD_RELOC_XTENSA_RTLD 6532ENUMDOC 6533 Special Xtensa relocation used only by PLT entries in ELF shared 6534 objects to indicate that the runtime linker should set the value 6535 to one of its own internal functions or data structures. 6536ENUM 6537 BFD_RELOC_XTENSA_GLOB_DAT 6538ENUMX 6539 BFD_RELOC_XTENSA_JMP_SLOT 6540ENUMX 6541 BFD_RELOC_XTENSA_RELATIVE 6542ENUMDOC 6543 Xtensa relocations for ELF shared objects. 6544ENUM 6545 BFD_RELOC_XTENSA_PLT 6546ENUMDOC 6547 Xtensa relocation used in ELF object files for symbols that may require 6548 PLT entries. Otherwise, this is just a generic 32-bit relocation. 6549ENUM 6550 BFD_RELOC_XTENSA_DIFF8 6551ENUMX 6552 BFD_RELOC_XTENSA_DIFF16 6553ENUMX 6554 BFD_RELOC_XTENSA_DIFF32 6555ENUMDOC 6556 Xtensa relocations to mark the difference of two local symbols. 6557 These are only needed to support linker relaxation and can be ignored 6558 when not relaxing. The field is set to the value of the difference 6559 assuming no relaxation. The relocation encodes the position of the 6560 first symbol so the linker can determine whether to adjust the field 6561 value. 6562ENUM 6563 BFD_RELOC_XTENSA_SLOT0_OP 6564ENUMX 6565 BFD_RELOC_XTENSA_SLOT1_OP 6566ENUMX 6567 BFD_RELOC_XTENSA_SLOT2_OP 6568ENUMX 6569 BFD_RELOC_XTENSA_SLOT3_OP 6570ENUMX 6571 BFD_RELOC_XTENSA_SLOT4_OP 6572ENUMX 6573 BFD_RELOC_XTENSA_SLOT5_OP 6574ENUMX 6575 BFD_RELOC_XTENSA_SLOT6_OP 6576ENUMX 6577 BFD_RELOC_XTENSA_SLOT7_OP 6578ENUMX 6579 BFD_RELOC_XTENSA_SLOT8_OP 6580ENUMX 6581 BFD_RELOC_XTENSA_SLOT9_OP 6582ENUMX 6583 BFD_RELOC_XTENSA_SLOT10_OP 6584ENUMX 6585 BFD_RELOC_XTENSA_SLOT11_OP 6586ENUMX 6587 BFD_RELOC_XTENSA_SLOT12_OP 6588ENUMX 6589 BFD_RELOC_XTENSA_SLOT13_OP 6590ENUMX 6591 BFD_RELOC_XTENSA_SLOT14_OP 6592ENUMDOC 6593 Generic Xtensa relocations for instruction operands. Only the slot 6594 number is encoded in the relocation. The relocation applies to the 6595 last PC-relative immediate operand, or if there are no PC-relative 6596 immediates, to the last immediate operand. 6597ENUM 6598 BFD_RELOC_XTENSA_SLOT0_ALT 6599ENUMX 6600 BFD_RELOC_XTENSA_SLOT1_ALT 6601ENUMX 6602 BFD_RELOC_XTENSA_SLOT2_ALT 6603ENUMX 6604 BFD_RELOC_XTENSA_SLOT3_ALT 6605ENUMX 6606 BFD_RELOC_XTENSA_SLOT4_ALT 6607ENUMX 6608 BFD_RELOC_XTENSA_SLOT5_ALT 6609ENUMX 6610 BFD_RELOC_XTENSA_SLOT6_ALT 6611ENUMX 6612 BFD_RELOC_XTENSA_SLOT7_ALT 6613ENUMX 6614 BFD_RELOC_XTENSA_SLOT8_ALT 6615ENUMX 6616 BFD_RELOC_XTENSA_SLOT9_ALT 6617ENUMX 6618 BFD_RELOC_XTENSA_SLOT10_ALT 6619ENUMX 6620 BFD_RELOC_XTENSA_SLOT11_ALT 6621ENUMX 6622 BFD_RELOC_XTENSA_SLOT12_ALT 6623ENUMX 6624 BFD_RELOC_XTENSA_SLOT13_ALT 6625ENUMX 6626 BFD_RELOC_XTENSA_SLOT14_ALT 6627ENUMDOC 6628 Alternate Xtensa relocations. Only the slot is encoded in the 6629 relocation. The meaning of these relocations is opcode-specific. 6630ENUM 6631 BFD_RELOC_XTENSA_OP0 6632ENUMX 6633 BFD_RELOC_XTENSA_OP1 6634ENUMX 6635 BFD_RELOC_XTENSA_OP2 6636ENUMDOC 6637 Xtensa relocations for backward compatibility. These have all been 6638 replaced by BFD_RELOC_XTENSA_SLOT0_OP. 6639ENUM 6640 BFD_RELOC_XTENSA_ASM_EXPAND 6641ENUMDOC 6642 Xtensa relocation to mark that the assembler expanded the 6643 instructions from an original target. The expansion size is 6644 encoded in the reloc size. 6645ENUM 6646 BFD_RELOC_XTENSA_ASM_SIMPLIFY 6647ENUMDOC 6648 Xtensa relocation to mark that the linker should simplify 6649 assembler-expanded instructions. This is commonly used 6650 internally by the linker after analysis of a 6651 BFD_RELOC_XTENSA_ASM_EXPAND. 6652ENUM 6653 BFD_RELOC_XTENSA_TLSDESC_FN 6654ENUMX 6655 BFD_RELOC_XTENSA_TLSDESC_ARG 6656ENUMX 6657 BFD_RELOC_XTENSA_TLS_DTPOFF 6658ENUMX 6659 BFD_RELOC_XTENSA_TLS_TPOFF 6660ENUMX 6661 BFD_RELOC_XTENSA_TLS_FUNC 6662ENUMX 6663 BFD_RELOC_XTENSA_TLS_ARG 6664ENUMX 6665 BFD_RELOC_XTENSA_TLS_CALL 6666ENUMDOC 6667 Xtensa TLS relocations. 6668 6669ENUM 6670 BFD_RELOC_Z80_DISP8 6671ENUMDOC 6672 8 bit signed offset in (ix+d) or (iy+d). 6673 6674ENUM 6675 BFD_RELOC_Z8K_DISP7 6676ENUMDOC 6677 DJNZ offset. 6678ENUM 6679 BFD_RELOC_Z8K_CALLR 6680ENUMDOC 6681 CALR offset. 6682ENUM 6683 BFD_RELOC_Z8K_IMM4L 6684ENUMDOC 6685 4 bit value. 6686 6687ENUM 6688 BFD_RELOC_LM32_CALL 6689ENUMX 6690 BFD_RELOC_LM32_BRANCH 6691ENUMX 6692 BFD_RELOC_LM32_16_GOT 6693ENUMX 6694 BFD_RELOC_LM32_GOTOFF_HI16 6695ENUMX 6696 BFD_RELOC_LM32_GOTOFF_LO16 6697ENUMX 6698 BFD_RELOC_LM32_COPY 6699ENUMX 6700 BFD_RELOC_LM32_GLOB_DAT 6701ENUMX 6702 BFD_RELOC_LM32_JMP_SLOT 6703ENUMX 6704 BFD_RELOC_LM32_RELATIVE 6705ENUMDOC 6706 Lattice Mico32 relocations. 6707 6708ENUM 6709 BFD_RELOC_MACH_O_SECTDIFF 6710ENUMDOC 6711 Difference between two section addreses. Must be followed by a 6712 BFD_RELOC_MACH_O_PAIR. 6713ENUM 6714 BFD_RELOC_MACH_O_LOCAL_SECTDIFF 6715ENUMDOC 6716 Like BFD_RELOC_MACH_O_SECTDIFF but with a local symbol. 6717ENUM 6718 BFD_RELOC_MACH_O_PAIR 6719ENUMDOC 6720 Pair of relocation. Contains the first symbol. 6721ENUM 6722 BFD_RELOC_MACH_O_SUBTRACTOR32 6723ENUMDOC 6724 Symbol will be substracted. Must be followed by a BFD_RELOC_32. 6725ENUM 6726 BFD_RELOC_MACH_O_SUBTRACTOR64 6727ENUMDOC 6728 Symbol will be substracted. Must be followed by a BFD_RELOC_64. 6729 6730ENUM 6731 BFD_RELOC_MACH_O_X86_64_BRANCH32 6732ENUMX 6733 BFD_RELOC_MACH_O_X86_64_BRANCH8 6734ENUMDOC 6735 PCREL relocations. They are marked as branch to create PLT entry if 6736 required. 6737ENUM 6738 BFD_RELOC_MACH_O_X86_64_GOT 6739ENUMDOC 6740 Used when referencing a GOT entry. 6741ENUM 6742 BFD_RELOC_MACH_O_X86_64_GOT_LOAD 6743ENUMDOC 6744 Used when loading a GOT entry with movq. It is specially marked so that 6745 the linker could optimize the movq to a leaq if possible. 6746ENUM 6747 BFD_RELOC_MACH_O_X86_64_PCREL32_1 6748ENUMDOC 6749 Same as BFD_RELOC_32_PCREL but with an implicit -1 addend. 6750ENUM 6751 BFD_RELOC_MACH_O_X86_64_PCREL32_2 6752ENUMDOC 6753 Same as BFD_RELOC_32_PCREL but with an implicit -2 addend. 6754ENUM 6755 BFD_RELOC_MACH_O_X86_64_PCREL32_4 6756ENUMDOC 6757 Same as BFD_RELOC_32_PCREL but with an implicit -4 addend. 6758 6759 6760ENUM 6761 BFD_RELOC_MACH_O_ARM64_ADDEND 6762ENUMDOC 6763 Addend for PAGE or PAGEOFF. 6764ENUM 6765 BFD_RELOC_MACH_O_ARM64_GOT_LOAD_PAGE21 6766ENUMDOC 6767 Relative offset to page of GOT slot. 6768ENUM 6769 BFD_RELOC_MACH_O_ARM64_GOT_LOAD_PAGEOFF12 6770ENUMDOC 6771 Relative offset within page of GOT slot. 6772ENUM 6773 BFD_RELOC_MACH_O_ARM64_POINTER_TO_GOT 6774ENUMDOC 6775 Address of a GOT entry. 6776 6777ENUM 6778 BFD_RELOC_MICROBLAZE_32_LO 6779ENUMDOC 6780 This is a 32 bit reloc for the microblaze that stores the 6781 low 16 bits of a value 6782ENUM 6783 BFD_RELOC_MICROBLAZE_32_LO_PCREL 6784ENUMDOC 6785 This is a 32 bit pc-relative reloc for the microblaze that 6786 stores the low 16 bits of a value 6787ENUM 6788 BFD_RELOC_MICROBLAZE_32_ROSDA 6789ENUMDOC 6790 This is a 32 bit reloc for the microblaze that stores a 6791 value relative to the read-only small data area anchor 6792ENUM 6793 BFD_RELOC_MICROBLAZE_32_RWSDA 6794ENUMDOC 6795 This is a 32 bit reloc for the microblaze that stores a 6796 value relative to the read-write small data area anchor 6797ENUM 6798 BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM 6799ENUMDOC 6800 This is a 32 bit reloc for the microblaze to handle 6801 expressions of the form "Symbol Op Symbol" 6802ENUM 6803 BFD_RELOC_MICROBLAZE_64_NONE 6804ENUMDOC 6805 This is a 64 bit reloc that stores the 32 bit pc relative 6806 value in two words (with an imm instruction). No relocation is 6807 done here - only used for relaxing 6808ENUM 6809 BFD_RELOC_MICROBLAZE_64_GOTPC 6810ENUMDOC 6811 This is a 64 bit reloc that stores the 32 bit pc relative 6812 value in two words (with an imm instruction). The relocation is 6813 PC-relative GOT offset 6814ENUM 6815 BFD_RELOC_MICROBLAZE_64_GOT 6816ENUMDOC 6817 This is a 64 bit reloc that stores the 32 bit pc relative 6818 value in two words (with an imm instruction). The relocation is 6819 GOT offset 6820ENUM 6821 BFD_RELOC_MICROBLAZE_64_PLT 6822ENUMDOC 6823 This is a 64 bit reloc that stores the 32 bit pc relative 6824 value in two words (with an imm instruction). The relocation is 6825 PC-relative offset into PLT 6826ENUM 6827 BFD_RELOC_MICROBLAZE_64_GOTOFF 6828ENUMDOC 6829 This is a 64 bit reloc that stores the 32 bit GOT relative 6830 value in two words (with an imm instruction). The relocation is 6831 relative offset from _GLOBAL_OFFSET_TABLE_ 6832ENUM 6833 BFD_RELOC_MICROBLAZE_32_GOTOFF 6834ENUMDOC 6835 This is a 32 bit reloc that stores the 32 bit GOT relative 6836 value in a word. The relocation is relative offset from 6837 _GLOBAL_OFFSET_TABLE_ 6838ENUM 6839 BFD_RELOC_MICROBLAZE_COPY 6840ENUMDOC 6841 This is used to tell the dynamic linker to copy the value out of 6842 the dynamic object into the runtime process image. 6843ENUM 6844 BFD_RELOC_MICROBLAZE_64_TLS 6845ENUMDOC 6846 Unused Reloc 6847ENUM 6848 BFD_RELOC_MICROBLAZE_64_TLSGD 6849ENUMDOC 6850 This is a 64 bit reloc that stores the 32 bit GOT relative value 6851 of the GOT TLS GD info entry in two words (with an imm instruction). The 6852 relocation is GOT offset. 6853ENUM 6854 BFD_RELOC_MICROBLAZE_64_TLSLD 6855ENUMDOC 6856 This is a 64 bit reloc that stores the 32 bit GOT relative value 6857 of the GOT TLS LD info entry in two words (with an imm instruction). The 6858 relocation is GOT offset. 6859ENUM 6860 BFD_RELOC_MICROBLAZE_32_TLSDTPMOD 6861ENUMDOC 6862 This is a 32 bit reloc that stores the Module ID to GOT(n). 6863ENUM 6864 BFD_RELOC_MICROBLAZE_32_TLSDTPREL 6865ENUMDOC 6866 This is a 32 bit reloc that stores TLS offset to GOT(n+1). 6867ENUM 6868 BFD_RELOC_MICROBLAZE_64_TLSDTPREL 6869ENUMDOC 6870 This is a 32 bit reloc for storing TLS offset to two words (uses imm 6871 instruction) 6872ENUM 6873 BFD_RELOC_MICROBLAZE_64_TLSGOTTPREL 6874ENUMDOC 6875 This is a 64 bit reloc that stores 32-bit thread pointer relative offset 6876 to two words (uses imm instruction). 6877ENUM 6878 BFD_RELOC_MICROBLAZE_64_TLSTPREL 6879ENUMDOC 6880 This is a 64 bit reloc that stores 32-bit thread pointer relative offset 6881 to two words (uses imm instruction). 6882 6883ENUM 6884 BFD_RELOC_AARCH64_RELOC_START 6885ENUMDOC 6886 AArch64 pseudo relocation code to mark the start of the AArch64 6887 relocation enumerators. N.B. the order of the enumerators is 6888 important as several tables in the AArch64 bfd backend are indexed 6889 by these enumerators; make sure they are all synced. 6890ENUM 6891 BFD_RELOC_AARCH64_NULL 6892ENUMDOC 6893 Deprecated AArch64 null relocation code. 6894ENUM 6895 BFD_RELOC_AARCH64_NONE 6896ENUMDOC 6897 AArch64 null relocation code. 6898ENUM 6899 BFD_RELOC_AARCH64_64 6900ENUMX 6901 BFD_RELOC_AARCH64_32 6902ENUMX 6903 BFD_RELOC_AARCH64_16 6904ENUMDOC 6905 Basic absolute relocations of N bits. These are equivalent to 6906BFD_RELOC_N and they were added to assist the indexing of the howto 6907table. 6908ENUM 6909 BFD_RELOC_AARCH64_64_PCREL 6910ENUMX 6911 BFD_RELOC_AARCH64_32_PCREL 6912ENUMX 6913 BFD_RELOC_AARCH64_16_PCREL 6914ENUMDOC 6915 PC-relative relocations. These are equivalent to BFD_RELOC_N_PCREL 6916and they were added to assist the indexing of the howto table. 6917ENUM 6918 BFD_RELOC_AARCH64_MOVW_G0 6919ENUMDOC 6920 AArch64 MOV[NZK] instruction with most significant bits 0 to 15 6921 of an unsigned address/value. 6922ENUM 6923 BFD_RELOC_AARCH64_MOVW_G0_NC 6924ENUMDOC 6925 AArch64 MOV[NZK] instruction with less significant bits 0 to 15 of 6926 an address/value. No overflow checking. 6927ENUM 6928 BFD_RELOC_AARCH64_MOVW_G1 6929ENUMDOC 6930 AArch64 MOV[NZK] instruction with most significant bits 16 to 31 6931 of an unsigned address/value. 6932ENUM 6933 BFD_RELOC_AARCH64_MOVW_G1_NC 6934ENUMDOC 6935 AArch64 MOV[NZK] instruction with less significant bits 16 to 31 6936 of an address/value. No overflow checking. 6937ENUM 6938 BFD_RELOC_AARCH64_MOVW_G2 6939ENUMDOC 6940 AArch64 MOV[NZK] instruction with most significant bits 32 to 47 6941 of an unsigned address/value. 6942ENUM 6943 BFD_RELOC_AARCH64_MOVW_G2_NC 6944ENUMDOC 6945 AArch64 MOV[NZK] instruction with less significant bits 32 to 47 6946 of an address/value. No overflow checking. 6947ENUM 6948 BFD_RELOC_AARCH64_MOVW_G3 6949ENUMDOC 6950 AArch64 MOV[NZK] instruction with most signficant bits 48 to 64 6951 of a signed or unsigned address/value. 6952ENUM 6953 BFD_RELOC_AARCH64_MOVW_G0_S 6954ENUMDOC 6955 AArch64 MOV[NZ] instruction with most significant bits 0 to 15 6956 of a signed value. Changes instruction to MOVZ or MOVN depending on the 6957 value's sign. 6958ENUM 6959 BFD_RELOC_AARCH64_MOVW_G1_S 6960ENUMDOC 6961 AArch64 MOV[NZ] instruction with most significant bits 16 to 31 6962 of a signed value. Changes instruction to MOVZ or MOVN depending on the 6963 value's sign. 6964ENUM 6965 BFD_RELOC_AARCH64_MOVW_G2_S 6966ENUMDOC 6967 AArch64 MOV[NZ] instruction with most significant bits 32 to 47 6968 of a signed value. Changes instruction to MOVZ or MOVN depending on the 6969 value's sign. 6970ENUM 6971 BFD_RELOC_AARCH64_LD_LO19_PCREL 6972ENUMDOC 6973 AArch64 Load Literal instruction, holding a 19 bit pc-relative word 6974 offset. The lowest two bits must be zero and are not stored in the 6975 instruction, giving a 21 bit signed byte offset. 6976ENUM 6977 BFD_RELOC_AARCH64_ADR_LO21_PCREL 6978ENUMDOC 6979 AArch64 ADR instruction, holding a simple 21 bit pc-relative byte offset. 6980ENUM 6981 BFD_RELOC_AARCH64_ADR_HI21_PCREL 6982ENUMDOC 6983 AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page 6984 offset, giving a 4KB aligned page base address. 6985ENUM 6986 BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL 6987ENUMDOC 6988 AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page 6989 offset, giving a 4KB aligned page base address, but with no overflow 6990 checking. 6991ENUM 6992 BFD_RELOC_AARCH64_ADD_LO12 6993ENUMDOC 6994 AArch64 ADD immediate instruction, holding bits 0 to 11 of the address. 6995 Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL. 6996ENUM 6997 BFD_RELOC_AARCH64_LDST8_LO12 6998ENUMDOC 6999 AArch64 8-bit load/store instruction, holding bits 0 to 11 of the 7000 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL. 7001ENUM 7002 BFD_RELOC_AARCH64_TSTBR14 7003ENUMDOC 7004 AArch64 14 bit pc-relative test bit and branch. 7005 The lowest two bits must be zero and are not stored in the instruction, 7006 giving a 16 bit signed byte offset. 7007ENUM 7008 BFD_RELOC_AARCH64_BRANCH19 7009ENUMDOC 7010 AArch64 19 bit pc-relative conditional branch and compare & branch. 7011 The lowest two bits must be zero and are not stored in the instruction, 7012 giving a 21 bit signed byte offset. 7013ENUM 7014 BFD_RELOC_AARCH64_JUMP26 7015ENUMDOC 7016 AArch64 26 bit pc-relative unconditional branch. 7017 The lowest two bits must be zero and are not stored in the instruction, 7018 giving a 28 bit signed byte offset. 7019ENUM 7020 BFD_RELOC_AARCH64_CALL26 7021ENUMDOC 7022 AArch64 26 bit pc-relative unconditional branch and link. 7023 The lowest two bits must be zero and are not stored in the instruction, 7024 giving a 28 bit signed byte offset. 7025ENUM 7026 BFD_RELOC_AARCH64_LDST16_LO12 7027ENUMDOC 7028 AArch64 16-bit load/store instruction, holding bits 0 to 11 of the 7029 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL. 7030ENUM 7031 BFD_RELOC_AARCH64_LDST32_LO12 7032ENUMDOC 7033 AArch64 32-bit load/store instruction, holding bits 0 to 11 of the 7034 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL. 7035ENUM 7036 BFD_RELOC_AARCH64_LDST64_LO12 7037ENUMDOC 7038 AArch64 64-bit load/store instruction, holding bits 0 to 11 of the 7039 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL. 7040ENUM 7041 BFD_RELOC_AARCH64_LDST128_LO12 7042ENUMDOC 7043 AArch64 128-bit load/store instruction, holding bits 0 to 11 of the 7044 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL. 7045ENUM 7046 BFD_RELOC_AARCH64_GOT_LD_PREL19 7047ENUMDOC 7048 AArch64 Load Literal instruction, holding a 19 bit PC relative word 7049 offset of the global offset table entry for a symbol. The lowest two 7050 bits must be zero and are not stored in the instruction, giving a 21 7051 bit signed byte offset. This relocation type requires signed overflow 7052 checking. 7053ENUM 7054 BFD_RELOC_AARCH64_ADR_GOT_PAGE 7055ENUMDOC 7056 Get to the page base of the global offset table entry for a symbol as 7057 part of an ADRP instruction using a 21 bit PC relative value.Used in 7058 conjunction with BFD_RELOC_AARCH64_LD64_GOT_LO12_NC. 7059ENUM 7060 BFD_RELOC_AARCH64_LD64_GOT_LO12_NC 7061ENUMDOC 7062 Unsigned 12 bit byte offset for 64 bit load/store from the page of 7063 the GOT entry for this symbol. Used in conjunction with 7064 BFD_RELOC_AARCH64_ADR_GOTPAGE. Valid in LP64 ABI only. 7065ENUM 7066 BFD_RELOC_AARCH64_LD32_GOT_LO12_NC 7067ENUMDOC 7068 Unsigned 12 bit byte offset for 32 bit load/store from the page of 7069 the GOT entry for this symbol. Used in conjunction with 7070 BFD_RELOC_AARCH64_ADR_GOTPAGE. Valid in ILP32 ABI only. 7071 ENUM 7072 BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC 7073ENUMDOC 7074 Unsigned 16 bit byte offset for 64 bit load/store from the GOT entry 7075 for this symbol. Valid in LP64 ABI only. 7076ENUM 7077 BFD_RELOC_AARCH64_MOVW_GOTOFF_G1 7078ENUMDOC 7079 Unsigned 16 bit byte higher offset for 64 bit load/store from the GOT entry 7080 for this symbol. Valid in LP64 ABI only. 7081ENUM 7082 BFD_RELOC_AARCH64_LD64_GOTOFF_LO15 7083ENUMDOC 7084 Unsigned 15 bit byte offset for 64 bit load/store from the page of 7085 the GOT entry for this symbol. Valid in LP64 ABI only. 7086ENUM 7087 BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14 7088ENUMDOC 7089 Scaled 14 bit byte offset to the page base of the global offset table. 7090ENUM 7091 BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15 7092ENUMDOC 7093 Scaled 15 bit byte offset to the page base of the global offset table. 7094ENUM 7095 BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21 7096ENUMDOC 7097 Get to the page base of the global offset table entry for a symbols 7098 tls_index structure as part of an adrp instruction using a 21 bit PC 7099 relative value. Used in conjunction with 7100 BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC. 7101ENUM 7102 BFD_RELOC_AARCH64_TLSGD_ADR_PREL21 7103ENUMDOC 7104 AArch64 TLS General Dynamic 7105ENUM 7106 BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC 7107ENUMDOC 7108 Unsigned 12 bit byte offset to global offset table entry for a symbols 7109 tls_index structure. Used in conjunction with 7110 BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21. 7111ENUM 7112 BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC 7113ENUMDOC 7114 AArch64 TLS General Dynamic relocation. 7115ENUM 7116 BFD_RELOC_AARCH64_TLSGD_MOVW_G1 7117ENUMDOC 7118 AArch64 TLS General Dynamic relocation. 7119ENUM 7120 BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 7121ENUMDOC 7122 AArch64 TLS INITIAL EXEC relocation. 7123ENUM 7124 BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC 7125ENUMDOC 7126 AArch64 TLS INITIAL EXEC relocation. 7127ENUM 7128 BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC 7129ENUMDOC 7130 AArch64 TLS INITIAL EXEC relocation. 7131ENUM 7132 BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19 7133ENUMDOC 7134 AArch64 TLS INITIAL EXEC relocation. 7135ENUM 7136 BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC 7137ENUMDOC 7138 AArch64 TLS INITIAL EXEC relocation. 7139ENUM 7140 BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1 7141ENUMDOC 7142 AArch64 TLS INITIAL EXEC relocation. 7143ENUM 7144 BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_HI12 7145ENUMDOC 7146 bit[23:12] of byte offset to module TLS base address. 7147ENUM 7148 BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12 7149ENUMDOC 7150 Unsigned 12 bit byte offset to module TLS base address. 7151ENUM 7152 BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12_NC 7153ENUMDOC 7154 No overflow check version of BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12. 7155ENUM 7156 BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC 7157ENUMDOC 7158 Unsigned 12 bit byte offset to global offset table entry for a symbols 7159 tls_index structure. Used in conjunction with 7160 BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21. 7161ENUM 7162 BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21 7163ENUMDOC 7164 GOT entry page address for AArch64 TLS Local Dynamic, used with ADRP 7165 instruction. 7166ENUM 7167 BFD_RELOC_AARCH64_TLSLD_ADR_PREL21 7168ENUMDOC 7169 GOT entry address for AArch64 TLS Local Dynamic, used with ADR instruction. 7170ENUM 7171 BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12 7172ENUMDOC 7173 bit[11:1] of byte offset to module TLS base address, encoded in ldst 7174 instructions. 7175ENUM 7176 BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC 7177ENUMDOC 7178 Similar as BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12, but no overflow check. 7179ENUM 7180 BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12 7181ENUMDOC 7182 bit[11:2] of byte offset to module TLS base address, encoded in ldst 7183 instructions. 7184ENUM 7185 BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC 7186ENUMDOC 7187 Similar as BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12, but no overflow check. 7188ENUM 7189 BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12 7190ENUMDOC 7191 bit[11:3] of byte offset to module TLS base address, encoded in ldst 7192 instructions. 7193ENUM 7194 BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC 7195ENUMDOC 7196 Similar as BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12, but no overflow check. 7197ENUM 7198 BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12 7199ENUMDOC 7200 bit[11:0] of byte offset to module TLS base address, encoded in ldst 7201 instructions. 7202ENUM 7203 BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC 7204ENUMDOC 7205 Similar as BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12, but no overflow check. 7206ENUM 7207 BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0 7208ENUMDOC 7209 bit[15:0] of byte offset to module TLS base address. 7210ENUM 7211 BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0_NC 7212ENUMDOC 7213 No overflow check version of BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0 7214ENUM 7215 BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1 7216ENUMDOC 7217 bit[31:16] of byte offset to module TLS base address. 7218ENUM 7219 BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1_NC 7220ENUMDOC 7221 No overflow check version of BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1 7222ENUM 7223 BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G2 7224ENUMDOC 7225 bit[47:32] of byte offset to module TLS base address. 7226ENUM 7227 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2 7228ENUMDOC 7229 AArch64 TLS LOCAL EXEC relocation. 7230ENUM 7231 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1 7232ENUMDOC 7233 AArch64 TLS LOCAL EXEC relocation. 7234ENUM 7235 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC 7236ENUMDOC 7237 AArch64 TLS LOCAL EXEC relocation. 7238ENUM 7239 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0 7240ENUMDOC 7241 AArch64 TLS LOCAL EXEC relocation. 7242ENUM 7243 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC 7244ENUMDOC 7245 AArch64 TLS LOCAL EXEC relocation. 7246ENUM 7247 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12 7248ENUMDOC 7249 AArch64 TLS LOCAL EXEC relocation. 7250ENUM 7251 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12 7252ENUMDOC 7253 AArch64 TLS LOCAL EXEC relocation. 7254ENUM 7255 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC 7256ENUMDOC 7257 AArch64 TLS LOCAL EXEC relocation. 7258ENUM 7259 BFD_RELOC_AARCH64_TLSDESC_LD_PREL19 7260ENUMDOC 7261 AArch64 TLS DESC relocation. 7262ENUM 7263 BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21 7264ENUMDOC 7265 AArch64 TLS DESC relocation. 7266ENUM 7267 BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21 7268ENUMDOC 7269 AArch64 TLS DESC relocation. 7270ENUM 7271 BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC 7272ENUMDOC 7273 AArch64 TLS DESC relocation. 7274ENUM 7275 BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC 7276ENUMDOC 7277 AArch64 TLS DESC relocation. 7278ENUM 7279 BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC 7280ENUMDOC 7281 AArch64 TLS DESC relocation. 7282ENUM 7283 BFD_RELOC_AARCH64_TLSDESC_OFF_G1 7284ENUMDOC 7285 AArch64 TLS DESC relocation. 7286ENUM 7287 BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC 7288ENUMDOC 7289 AArch64 TLS DESC relocation. 7290ENUM 7291 BFD_RELOC_AARCH64_TLSDESC_LDR 7292ENUMDOC 7293 AArch64 TLS DESC relocation. 7294ENUM 7295 BFD_RELOC_AARCH64_TLSDESC_ADD 7296ENUMDOC 7297 AArch64 TLS DESC relocation. 7298ENUM 7299 BFD_RELOC_AARCH64_TLSDESC_CALL 7300ENUMDOC 7301 AArch64 TLS DESC relocation. 7302ENUM 7303 BFD_RELOC_AARCH64_COPY 7304ENUMDOC 7305 AArch64 TLS relocation. 7306ENUM 7307 BFD_RELOC_AARCH64_GLOB_DAT 7308ENUMDOC 7309 AArch64 TLS relocation. 7310ENUM 7311 BFD_RELOC_AARCH64_JUMP_SLOT 7312ENUMDOC 7313 AArch64 TLS relocation. 7314ENUM 7315 BFD_RELOC_AARCH64_RELATIVE 7316ENUMDOC 7317 AArch64 TLS relocation. 7318ENUM 7319 BFD_RELOC_AARCH64_TLS_DTPMOD 7320ENUMDOC 7321 AArch64 TLS relocation. 7322ENUM 7323 BFD_RELOC_AARCH64_TLS_DTPREL 7324ENUMDOC 7325 AArch64 TLS relocation. 7326ENUM 7327 BFD_RELOC_AARCH64_TLS_TPREL 7328ENUMDOC 7329 AArch64 TLS relocation. 7330ENUM 7331 BFD_RELOC_AARCH64_TLSDESC 7332ENUMDOC 7333 AArch64 TLS relocation. 7334ENUM 7335 BFD_RELOC_AARCH64_IRELATIVE 7336ENUMDOC 7337 AArch64 support for STT_GNU_IFUNC. 7338ENUM 7339 BFD_RELOC_AARCH64_RELOC_END 7340ENUMDOC 7341 AArch64 pseudo relocation code to mark the end of the AArch64 7342 relocation enumerators that have direct mapping to ELF reloc codes. 7343 There are a few more enumerators after this one; those are mainly 7344 used by the AArch64 assembler for the internal fixup or to select 7345 one of the above enumerators. 7346ENUM 7347 BFD_RELOC_AARCH64_GAS_INTERNAL_FIXUP 7348ENUMDOC 7349 AArch64 pseudo relocation code to be used internally by the AArch64 7350 assembler and not (currently) written to any object files. 7351ENUM 7352 BFD_RELOC_AARCH64_LDST_LO12 7353ENUMDOC 7354 AArch64 unspecified load/store instruction, holding bits 0 to 11 of the 7355 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL. 7356ENUM 7357 BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12 7358ENUMDOC 7359 AArch64 pseudo relocation code for TLS local dynamic mode. It's to be 7360 used internally by the AArch64 assembler and not (currently) written to 7361 any object files. 7362ENUM 7363 BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12_NC 7364ENUMDOC 7365 Similar as BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12, but no overflow check. 7366ENUM 7367 BFD_RELOC_AARCH64_LD_GOT_LO12_NC 7368ENUMDOC 7369 AArch64 pseudo relocation code to be used internally by the AArch64 7370 assembler and not (currently) written to any object files. 7371ENUM 7372 BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_LO12_NC 7373ENUMDOC 7374 AArch64 pseudo relocation code to be used internally by the AArch64 7375 assembler and not (currently) written to any object files. 7376ENUM 7377 BFD_RELOC_AARCH64_TLSDESC_LD_LO12_NC 7378ENUMDOC 7379 AArch64 pseudo relocation code to be used internally by the AArch64 7380 assembler and not (currently) written to any object files. 7381ENUM 7382 BFD_RELOC_TILEPRO_COPY 7383ENUMX 7384 BFD_RELOC_TILEPRO_GLOB_DAT 7385ENUMX 7386 BFD_RELOC_TILEPRO_JMP_SLOT 7387ENUMX 7388 BFD_RELOC_TILEPRO_RELATIVE 7389ENUMX 7390 BFD_RELOC_TILEPRO_BROFF_X1 7391ENUMX 7392 BFD_RELOC_TILEPRO_JOFFLONG_X1 7393ENUMX 7394 BFD_RELOC_TILEPRO_JOFFLONG_X1_PLT 7395ENUMX 7396 BFD_RELOC_TILEPRO_IMM8_X0 7397ENUMX 7398 BFD_RELOC_TILEPRO_IMM8_Y0 7399ENUMX 7400 BFD_RELOC_TILEPRO_IMM8_X1 7401ENUMX 7402 BFD_RELOC_TILEPRO_IMM8_Y1 7403ENUMX 7404 BFD_RELOC_TILEPRO_DEST_IMM8_X1 7405ENUMX 7406 BFD_RELOC_TILEPRO_MT_IMM15_X1 7407ENUMX 7408 BFD_RELOC_TILEPRO_MF_IMM15_X1 7409ENUMX 7410 BFD_RELOC_TILEPRO_IMM16_X0 7411ENUMX 7412 BFD_RELOC_TILEPRO_IMM16_X1 7413ENUMX 7414 BFD_RELOC_TILEPRO_IMM16_X0_LO 7415ENUMX 7416 BFD_RELOC_TILEPRO_IMM16_X1_LO 7417ENUMX 7418 BFD_RELOC_TILEPRO_IMM16_X0_HI 7419ENUMX 7420 BFD_RELOC_TILEPRO_IMM16_X1_HI 7421ENUMX 7422 BFD_RELOC_TILEPRO_IMM16_X0_HA 7423ENUMX 7424 BFD_RELOC_TILEPRO_IMM16_X1_HA 7425ENUMX 7426 BFD_RELOC_TILEPRO_IMM16_X0_PCREL 7427ENUMX 7428 BFD_RELOC_TILEPRO_IMM16_X1_PCREL 7429ENUMX 7430 BFD_RELOC_TILEPRO_IMM16_X0_LO_PCREL 7431ENUMX 7432 BFD_RELOC_TILEPRO_IMM16_X1_LO_PCREL 7433ENUMX 7434 BFD_RELOC_TILEPRO_IMM16_X0_HI_PCREL 7435ENUMX 7436 BFD_RELOC_TILEPRO_IMM16_X1_HI_PCREL 7437ENUMX 7438 BFD_RELOC_TILEPRO_IMM16_X0_HA_PCREL 7439ENUMX 7440 BFD_RELOC_TILEPRO_IMM16_X1_HA_PCREL 7441ENUMX 7442 BFD_RELOC_TILEPRO_IMM16_X0_GOT 7443ENUMX 7444 BFD_RELOC_TILEPRO_IMM16_X1_GOT 7445ENUMX 7446 BFD_RELOC_TILEPRO_IMM16_X0_GOT_LO 7447ENUMX 7448 BFD_RELOC_TILEPRO_IMM16_X1_GOT_LO 7449ENUMX 7450 BFD_RELOC_TILEPRO_IMM16_X0_GOT_HI 7451ENUMX 7452 BFD_RELOC_TILEPRO_IMM16_X1_GOT_HI 7453ENUMX 7454 BFD_RELOC_TILEPRO_IMM16_X0_GOT_HA 7455ENUMX 7456 BFD_RELOC_TILEPRO_IMM16_X1_GOT_HA 7457ENUMX 7458 BFD_RELOC_TILEPRO_MMSTART_X0 7459ENUMX 7460 BFD_RELOC_TILEPRO_MMEND_X0 7461ENUMX 7462 BFD_RELOC_TILEPRO_MMSTART_X1 7463ENUMX 7464 BFD_RELOC_TILEPRO_MMEND_X1 7465ENUMX 7466 BFD_RELOC_TILEPRO_SHAMT_X0 7467ENUMX 7468 BFD_RELOC_TILEPRO_SHAMT_X1 7469ENUMX 7470 BFD_RELOC_TILEPRO_SHAMT_Y0 7471ENUMX 7472 BFD_RELOC_TILEPRO_SHAMT_Y1 7473ENUMX 7474 BFD_RELOC_TILEPRO_TLS_GD_CALL 7475ENUMX 7476 BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD 7477ENUMX 7478 BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD 7479ENUMX 7480 BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD 7481ENUMX 7482 BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD 7483ENUMX 7484 BFD_RELOC_TILEPRO_TLS_IE_LOAD 7485ENUMX 7486 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD 7487ENUMX 7488 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD 7489ENUMX 7490 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO 7491ENUMX 7492 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_LO 7493ENUMX 7494 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HI 7495ENUMX 7496 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HI 7497ENUMX 7498 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HA 7499ENUMX 7500 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HA 7501ENUMX 7502 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE 7503ENUMX 7504 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE 7505ENUMX 7506 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_LO 7507ENUMX 7508 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_LO 7509ENUMX 7510 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HI 7511ENUMX 7512 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HI 7513ENUMX 7514 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HA 7515ENUMX 7516 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HA 7517ENUMX 7518 BFD_RELOC_TILEPRO_TLS_DTPMOD32 7519ENUMX 7520 BFD_RELOC_TILEPRO_TLS_DTPOFF32 7521ENUMX 7522 BFD_RELOC_TILEPRO_TLS_TPOFF32 7523ENUMX 7524 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE 7525ENUMX 7526 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE 7527ENUMX 7528 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_LO 7529ENUMX 7530 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_LO 7531ENUMX 7532 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HI 7533ENUMX 7534 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HI 7535ENUMX 7536 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HA 7537ENUMX 7538 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HA 7539ENUMDOC 7540 Tilera TILEPro Relocations. 7541ENUM 7542 BFD_RELOC_TILEGX_HW0 7543ENUMX 7544 BFD_RELOC_TILEGX_HW1 7545ENUMX 7546 BFD_RELOC_TILEGX_HW2 7547ENUMX 7548 BFD_RELOC_TILEGX_HW3 7549ENUMX 7550 BFD_RELOC_TILEGX_HW0_LAST 7551ENUMX 7552 BFD_RELOC_TILEGX_HW1_LAST 7553ENUMX 7554 BFD_RELOC_TILEGX_HW2_LAST 7555ENUMX 7556 BFD_RELOC_TILEGX_COPY 7557ENUMX 7558 BFD_RELOC_TILEGX_GLOB_DAT 7559ENUMX 7560 BFD_RELOC_TILEGX_JMP_SLOT 7561ENUMX 7562 BFD_RELOC_TILEGX_RELATIVE 7563ENUMX 7564 BFD_RELOC_TILEGX_BROFF_X1 7565ENUMX 7566 BFD_RELOC_TILEGX_JUMPOFF_X1 7567ENUMX 7568 BFD_RELOC_TILEGX_JUMPOFF_X1_PLT 7569ENUMX 7570 BFD_RELOC_TILEGX_IMM8_X0 7571ENUMX 7572 BFD_RELOC_TILEGX_IMM8_Y0 7573ENUMX 7574 BFD_RELOC_TILEGX_IMM8_X1 7575ENUMX 7576 BFD_RELOC_TILEGX_IMM8_Y1 7577ENUMX 7578 BFD_RELOC_TILEGX_DEST_IMM8_X1 7579ENUMX 7580 BFD_RELOC_TILEGX_MT_IMM14_X1 7581ENUMX 7582 BFD_RELOC_TILEGX_MF_IMM14_X1 7583ENUMX 7584 BFD_RELOC_TILEGX_MMSTART_X0 7585ENUMX 7586 BFD_RELOC_TILEGX_MMEND_X0 7587ENUMX 7588 BFD_RELOC_TILEGX_SHAMT_X0 7589ENUMX 7590 BFD_RELOC_TILEGX_SHAMT_X1 7591ENUMX 7592 BFD_RELOC_TILEGX_SHAMT_Y0 7593ENUMX 7594 BFD_RELOC_TILEGX_SHAMT_Y1 7595ENUMX 7596 BFD_RELOC_TILEGX_IMM16_X0_HW0 7597ENUMX 7598 BFD_RELOC_TILEGX_IMM16_X1_HW0 7599ENUMX 7600 BFD_RELOC_TILEGX_IMM16_X0_HW1 7601ENUMX 7602 BFD_RELOC_TILEGX_IMM16_X1_HW1 7603ENUMX 7604 BFD_RELOC_TILEGX_IMM16_X0_HW2 7605ENUMX 7606 BFD_RELOC_TILEGX_IMM16_X1_HW2 7607ENUMX 7608 BFD_RELOC_TILEGX_IMM16_X0_HW3 7609ENUMX 7610 BFD_RELOC_TILEGX_IMM16_X1_HW3 7611ENUMX 7612 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST 7613ENUMX 7614 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST 7615ENUMX 7616 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST 7617ENUMX 7618 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST 7619ENUMX 7620 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST 7621ENUMX 7622 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST 7623ENUMX 7624 BFD_RELOC_TILEGX_IMM16_X0_HW0_PCREL 7625ENUMX 7626 BFD_RELOC_TILEGX_IMM16_X1_HW0_PCREL 7627ENUMX 7628 BFD_RELOC_TILEGX_IMM16_X0_HW1_PCREL 7629ENUMX 7630 BFD_RELOC_TILEGX_IMM16_X1_HW1_PCREL 7631ENUMX 7632 BFD_RELOC_TILEGX_IMM16_X0_HW2_PCREL 7633ENUMX 7634 BFD_RELOC_TILEGX_IMM16_X1_HW2_PCREL 7635ENUMX 7636 BFD_RELOC_TILEGX_IMM16_X0_HW3_PCREL 7637ENUMX 7638 BFD_RELOC_TILEGX_IMM16_X1_HW3_PCREL 7639ENUMX 7640 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PCREL 7641ENUMX 7642 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PCREL 7643ENUMX 7644 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PCREL 7645ENUMX 7646 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PCREL 7647ENUMX 7648 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PCREL 7649ENUMX 7650 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PCREL 7651ENUMX 7652 BFD_RELOC_TILEGX_IMM16_X0_HW0_GOT 7653ENUMX 7654 BFD_RELOC_TILEGX_IMM16_X1_HW0_GOT 7655ENUMX 7656 BFD_RELOC_TILEGX_IMM16_X0_HW0_PLT_PCREL 7657ENUMX 7658 BFD_RELOC_TILEGX_IMM16_X1_HW0_PLT_PCREL 7659ENUMX 7660 BFD_RELOC_TILEGX_IMM16_X0_HW1_PLT_PCREL 7661ENUMX 7662 BFD_RELOC_TILEGX_IMM16_X1_HW1_PLT_PCREL 7663ENUMX 7664 BFD_RELOC_TILEGX_IMM16_X0_HW2_PLT_PCREL 7665ENUMX 7666 BFD_RELOC_TILEGX_IMM16_X1_HW2_PLT_PCREL 7667ENUMX 7668 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_GOT 7669ENUMX 7670 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_GOT 7671ENUMX 7672 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_GOT 7673ENUMX 7674 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_GOT 7675ENUMX 7676 BFD_RELOC_TILEGX_IMM16_X0_HW3_PLT_PCREL 7677ENUMX 7678 BFD_RELOC_TILEGX_IMM16_X1_HW3_PLT_PCREL 7679ENUMX 7680 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_GD 7681ENUMX 7682 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_GD 7683ENUMX 7684 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_LE 7685ENUMX 7686 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_LE 7687ENUMX 7688 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_LE 7689ENUMX 7690 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_LE 7691ENUMX 7692 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_LE 7693ENUMX 7694 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_LE 7695ENUMX 7696 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_GD 7697ENUMX 7698 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_GD 7699ENUMX 7700 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_GD 7701ENUMX 7702 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_GD 7703ENUMX 7704 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_IE 7705ENUMX 7706 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_IE 7707ENUMX 7708 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL 7709ENUMX 7710 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL 7711ENUMX 7712 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL 7713ENUMX 7714 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL 7715ENUMX 7716 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL 7717ENUMX 7718 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL 7719ENUMX 7720 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_IE 7721ENUMX 7722 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_IE 7723ENUMX 7724 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_IE 7725ENUMX 7726 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_IE 7727ENUMX 7728 BFD_RELOC_TILEGX_TLS_DTPMOD64 7729ENUMX 7730 BFD_RELOC_TILEGX_TLS_DTPOFF64 7731ENUMX 7732 BFD_RELOC_TILEGX_TLS_TPOFF64 7733ENUMX 7734 BFD_RELOC_TILEGX_TLS_DTPMOD32 7735ENUMX 7736 BFD_RELOC_TILEGX_TLS_DTPOFF32 7737ENUMX 7738 BFD_RELOC_TILEGX_TLS_TPOFF32 7739ENUMX 7740 BFD_RELOC_TILEGX_TLS_GD_CALL 7741ENUMX 7742 BFD_RELOC_TILEGX_IMM8_X0_TLS_GD_ADD 7743ENUMX 7744 BFD_RELOC_TILEGX_IMM8_X1_TLS_GD_ADD 7745ENUMX 7746 BFD_RELOC_TILEGX_IMM8_Y0_TLS_GD_ADD 7747ENUMX 7748 BFD_RELOC_TILEGX_IMM8_Y1_TLS_GD_ADD 7749ENUMX 7750 BFD_RELOC_TILEGX_TLS_IE_LOAD 7751ENUMX 7752 BFD_RELOC_TILEGX_IMM8_X0_TLS_ADD 7753ENUMX 7754 BFD_RELOC_TILEGX_IMM8_X1_TLS_ADD 7755ENUMX 7756 BFD_RELOC_TILEGX_IMM8_Y0_TLS_ADD 7757ENUMX 7758 BFD_RELOC_TILEGX_IMM8_Y1_TLS_ADD 7759ENUMDOC 7760 Tilera TILE-Gx Relocations. 7761 7762ENUM 7763 BFD_RELOC_EPIPHANY_SIMM8 7764ENUMDOC 7765 Adapteva EPIPHANY - 8 bit signed pc-relative displacement 7766ENUM 7767 BFD_RELOC_EPIPHANY_SIMM24 7768ENUMDOC 7769 Adapteva EPIPHANY - 24 bit signed pc-relative displacement 7770ENUM 7771 BFD_RELOC_EPIPHANY_HIGH 7772ENUMDOC 7773 Adapteva EPIPHANY - 16 most-significant bits of absolute address 7774ENUM 7775 BFD_RELOC_EPIPHANY_LOW 7776ENUMDOC 7777 Adapteva EPIPHANY - 16 least-significant bits of absolute address 7778ENUM 7779 BFD_RELOC_EPIPHANY_SIMM11 7780ENUMDOC 7781 Adapteva EPIPHANY - 11 bit signed number - add/sub immediate 7782ENUM 7783 BFD_RELOC_EPIPHANY_IMM11 7784ENUMDOC 7785 Adapteva EPIPHANY - 11 bit sign-magnitude number (ld/st displacement) 7786ENUM 7787 BFD_RELOC_EPIPHANY_IMM8 7788ENUMDOC 7789 Adapteva EPIPHANY - 8 bit immediate for 16 bit mov instruction. 7790 7791ENUM 7792 BFD_RELOC_VISIUM_HI16 7793ENUMX 7794 BFD_RELOC_VISIUM_LO16 7795ENUMX 7796 BFD_RELOC_VISIUM_IM16 7797ENUMX 7798 BFD_RELOC_VISIUM_REL16 7799ENUMX 7800 BFD_RELOC_VISIUM_HI16_PCREL 7801ENUMX 7802 BFD_RELOC_VISIUM_LO16_PCREL 7803ENUMX 7804 BFD_RELOC_VISIUM_IM16_PCREL 7805ENUMDOC 7806 Visium Relocations. 7807 7808ENDSENUM 7809 BFD_RELOC_UNUSED 7810CODE_FRAGMENT 7811. 7812.typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; 7813*/ 7814 7815/* 7816FUNCTION 7817 bfd_reloc_type_lookup 7818 bfd_reloc_name_lookup 7819 7820SYNOPSIS 7821 reloc_howto_type *bfd_reloc_type_lookup 7822 (bfd *abfd, bfd_reloc_code_real_type code); 7823 reloc_howto_type *bfd_reloc_name_lookup 7824 (bfd *abfd, const char *reloc_name); 7825 7826DESCRIPTION 7827 Return a pointer to a howto structure which, when 7828 invoked, will perform the relocation @var{code} on data from the 7829 architecture noted. 7830 7831*/ 7832 7833reloc_howto_type * 7834bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 7835{ 7836 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code)); 7837} 7838 7839reloc_howto_type * 7840bfd_reloc_name_lookup (bfd *abfd, const char *reloc_name) 7841{ 7842 return BFD_SEND (abfd, reloc_name_lookup, (abfd, reloc_name)); 7843} 7844 7845static reloc_howto_type bfd_howto_32 = 7846HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_dont, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE); 7847 7848/* 7849INTERNAL_FUNCTION 7850 bfd_default_reloc_type_lookup 7851 7852SYNOPSIS 7853 reloc_howto_type *bfd_default_reloc_type_lookup 7854 (bfd *abfd, bfd_reloc_code_real_type code); 7855 7856DESCRIPTION 7857 Provides a default relocation lookup routine for any architecture. 7858 7859*/ 7860 7861reloc_howto_type * 7862bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 7863{ 7864 switch (code) 7865 { 7866 case BFD_RELOC_CTOR: 7867 /* The type of reloc used in a ctor, which will be as wide as the 7868 address - so either a 64, 32, or 16 bitter. */ 7869 switch (bfd_arch_bits_per_address (abfd)) 7870 { 7871 case 64: 7872 BFD_FAIL (); 7873 break; 7874 case 32: 7875 return &bfd_howto_32; 7876 case 16: 7877 BFD_FAIL (); 7878 break; 7879 default: 7880 BFD_FAIL (); 7881 } 7882 break; 7883 default: 7884 BFD_FAIL (); 7885 } 7886 return NULL; 7887} 7888 7889/* 7890FUNCTION 7891 bfd_get_reloc_code_name 7892 7893SYNOPSIS 7894 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); 7895 7896DESCRIPTION 7897 Provides a printable name for the supplied relocation code. 7898 Useful mainly for printing error messages. 7899*/ 7900 7901const char * 7902bfd_get_reloc_code_name (bfd_reloc_code_real_type code) 7903{ 7904 if (code > BFD_RELOC_UNUSED) 7905 return 0; 7906 return bfd_reloc_code_real_names[code]; 7907} 7908 7909/* 7910INTERNAL_FUNCTION 7911 bfd_generic_relax_section 7912 7913SYNOPSIS 7914 bfd_boolean bfd_generic_relax_section 7915 (bfd *abfd, 7916 asection *section, 7917 struct bfd_link_info *, 7918 bfd_boolean *); 7919 7920DESCRIPTION 7921 Provides default handling for relaxing for back ends which 7922 don't do relaxing. 7923*/ 7924 7925bfd_boolean 7926bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, 7927 asection *section ATTRIBUTE_UNUSED, 7928 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 7929 bfd_boolean *again) 7930{ 7931 if (bfd_link_relocatable (link_info)) 7932 (*link_info->callbacks->einfo) 7933 (_("%P%F: --relax and -r may not be used together\n")); 7934 7935 *again = FALSE; 7936 return TRUE; 7937} 7938 7939/* 7940INTERNAL_FUNCTION 7941 bfd_generic_gc_sections 7942 7943SYNOPSIS 7944 bfd_boolean bfd_generic_gc_sections 7945 (bfd *, struct bfd_link_info *); 7946 7947DESCRIPTION 7948 Provides default handling for relaxing for back ends which 7949 don't do section gc -- i.e., does nothing. 7950*/ 7951 7952bfd_boolean 7953bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, 7954 struct bfd_link_info *info ATTRIBUTE_UNUSED) 7955{ 7956 return TRUE; 7957} 7958 7959/* 7960INTERNAL_FUNCTION 7961 bfd_generic_lookup_section_flags 7962 7963SYNOPSIS 7964 bfd_boolean bfd_generic_lookup_section_flags 7965 (struct bfd_link_info *, struct flag_info *, asection *); 7966 7967DESCRIPTION 7968 Provides default handling for section flags lookup 7969 -- i.e., does nothing. 7970 Returns FALSE if the section should be omitted, otherwise TRUE. 7971*/ 7972 7973bfd_boolean 7974bfd_generic_lookup_section_flags (struct bfd_link_info *info ATTRIBUTE_UNUSED, 7975 struct flag_info *flaginfo, 7976 asection *section ATTRIBUTE_UNUSED) 7977{ 7978 if (flaginfo != NULL) 7979 { 7980 _bfd_error_handler (_("INPUT_SECTION_FLAGS are not supported.\n")); 7981 return FALSE; 7982 } 7983 return TRUE; 7984} 7985 7986/* 7987INTERNAL_FUNCTION 7988 bfd_generic_merge_sections 7989 7990SYNOPSIS 7991 bfd_boolean bfd_generic_merge_sections 7992 (bfd *, struct bfd_link_info *); 7993 7994DESCRIPTION 7995 Provides default handling for SEC_MERGE section merging for back ends 7996 which don't have SEC_MERGE support -- i.e., does nothing. 7997*/ 7998 7999bfd_boolean 8000bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, 8001 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 8002{ 8003 return TRUE; 8004} 8005 8006/* 8007INTERNAL_FUNCTION 8008 bfd_generic_get_relocated_section_contents 8009 8010SYNOPSIS 8011 bfd_byte *bfd_generic_get_relocated_section_contents 8012 (bfd *abfd, 8013 struct bfd_link_info *link_info, 8014 struct bfd_link_order *link_order, 8015 bfd_byte *data, 8016 bfd_boolean relocatable, 8017 asymbol **symbols); 8018 8019DESCRIPTION 8020 Provides default handling of relocation effort for back ends 8021 which can't be bothered to do it efficiently. 8022 8023*/ 8024 8025bfd_byte * 8026bfd_generic_get_relocated_section_contents (bfd *abfd, 8027 struct bfd_link_info *link_info, 8028 struct bfd_link_order *link_order, 8029 bfd_byte *data, 8030 bfd_boolean relocatable, 8031 asymbol **symbols) 8032{ 8033 bfd *input_bfd = link_order->u.indirect.section->owner; 8034 asection *input_section = link_order->u.indirect.section; 8035 long reloc_size; 8036 arelent **reloc_vector; 8037 long reloc_count; 8038 8039 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 8040 if (reloc_size < 0) 8041 return NULL; 8042 8043 /* Read in the section. */ 8044 if (!bfd_get_full_section_contents (input_bfd, input_section, &data)) 8045 return NULL; 8046 8047 if (reloc_size == 0) 8048 return data; 8049 8050 reloc_vector = (arelent **) bfd_malloc (reloc_size); 8051 if (reloc_vector == NULL) 8052 return NULL; 8053 8054 reloc_count = bfd_canonicalize_reloc (input_bfd, 8055 input_section, 8056 reloc_vector, 8057 symbols); 8058 if (reloc_count < 0) 8059 goto error_return; 8060 8061 if (reloc_count > 0) 8062 { 8063 arelent **parent; 8064 8065 for (parent = reloc_vector; *parent != NULL; parent++) 8066 { 8067 char *error_message = NULL; 8068 asymbol *symbol; 8069 bfd_reloc_status_type r; 8070 8071 symbol = *(*parent)->sym_ptr_ptr; 8072 /* PR ld/19628: A specially crafted input file 8073 can result in a NULL symbol pointer here. */ 8074 if (symbol == NULL) 8075 { 8076 link_info->callbacks->einfo 8077 /* xgettext:c-format */ 8078 (_("%X%P: %B(%A): error: relocation for offset %V has no value\n"), 8079 abfd, input_section, (* parent)->address); 8080 goto error_return; 8081 } 8082 8083 if (symbol->section && discarded_section (symbol->section)) 8084 { 8085 bfd_byte *p; 8086 static reloc_howto_type none_howto 8087 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, 8088 "unused", FALSE, 0, 0, FALSE); 8089 8090 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd); 8091 _bfd_clear_contents ((*parent)->howto, input_bfd, input_section, 8092 p); 8093 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 8094 (*parent)->addend = 0; 8095 (*parent)->howto = &none_howto; 8096 r = bfd_reloc_ok; 8097 } 8098 else 8099 r = bfd_perform_relocation (input_bfd, 8100 *parent, 8101 data, 8102 input_section, 8103 relocatable ? abfd : NULL, 8104 &error_message); 8105 8106 if (relocatable) 8107 { 8108 asection *os = input_section->output_section; 8109 8110 /* A partial link, so keep the relocs. */ 8111 os->orelocation[os->reloc_count] = *parent; 8112 os->reloc_count++; 8113 } 8114 8115 if (r != bfd_reloc_ok) 8116 { 8117 switch (r) 8118 { 8119 case bfd_reloc_undefined: 8120 (*link_info->callbacks->undefined_symbol) 8121 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 8122 input_bfd, input_section, (*parent)->address, TRUE); 8123 break; 8124 case bfd_reloc_dangerous: 8125 BFD_ASSERT (error_message != NULL); 8126 (*link_info->callbacks->reloc_dangerous) 8127 (link_info, error_message, 8128 input_bfd, input_section, (*parent)->address); 8129 break; 8130 case bfd_reloc_overflow: 8131 (*link_info->callbacks->reloc_overflow) 8132 (link_info, NULL, 8133 bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 8134 (*parent)->howto->name, (*parent)->addend, 8135 input_bfd, input_section, (*parent)->address); 8136 break; 8137 case bfd_reloc_outofrange: 8138 /* PR ld/13730: 8139 This error can result when processing some partially 8140 complete binaries. Do not abort, but issue an error 8141 message instead. */ 8142 link_info->callbacks->einfo 8143 /* xgettext:c-format */ 8144 (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"), 8145 abfd, input_section, * parent); 8146 goto error_return; 8147 8148 case bfd_reloc_notsupported: 8149 /* PR ld/17512 8150 This error can result when processing a corrupt binary. 8151 Do not abort. Issue an error message instead. */ 8152 link_info->callbacks->einfo 8153 /* xgettext:c-format */ 8154 (_("%X%P: %B(%A): relocation \"%R\" is not supported\n"), 8155 abfd, input_section, * parent); 8156 goto error_return; 8157 8158 default: 8159 /* PR 17512; file: 90c2a92e. 8160 Report unexpected results, without aborting. */ 8161 link_info->callbacks->einfo 8162 /* xgettext:c-format */ 8163 (_("%X%P: %B(%A): relocation \"%R\" returns an unrecognized value %x\n"), 8164 abfd, input_section, * parent, r); 8165 break; 8166 } 8167 8168 } 8169 } 8170 } 8171 8172 free (reloc_vector); 8173 return data; 8174 8175error_return: 8176 free (reloc_vector); 8177 return NULL; 8178} 8179