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