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