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