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