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 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 /* 25 SECTION 26 Relocations 27 28 BFD maintains relocations in much the same way it maintains 29 symbols: they are left alone until required, then read in 30 en-masse and translated into an internal form. A common 31 routine <<bfd_perform_relocation>> acts upon the 32 canonical form to do the fixup. 33 34 Relocations are maintained on a per section basis, 35 while symbols are maintained on a per BFD basis. 36 37 All that a back end has to do to fit the BFD interface is to create 38 a <<struct reloc_cache_entry>> for each relocation 39 in a particular section, and fill in the right bits of the structures. 40 41 @menu 42 @* typedef arelent:: 43 @* howto manager:: 44 @end menu 45 46 */ 47 48 /* DO compile in the reloc_code name table from libbfd.h. */ 49 #define _BFD_MAKE_TABLE_bfd_reloc_code_real 50 51 #include "sysdep.h" 52 #include "bfd.h" 53 #include "bfdlink.h" 54 #include "libbfd.h" 55 /* 56 DOCDD 57 INODE 58 typedef arelent, howto manager, Relocations, Relocations 59 60 SUBSECTION 61 typedef arelent 62 63 This is the structure of a relocation entry: 64 65 CODE_FRAGMENT 66 . 67 .typedef enum bfd_reloc_status 68 .{ 69 . {* No errors detected. *} 70 . bfd_reloc_ok, 71 . 72 . {* The relocation was performed, but there was an overflow. *} 73 . bfd_reloc_overflow, 74 . 75 . {* The address to relocate was not within the section supplied. *} 76 . bfd_reloc_outofrange, 77 . 78 . {* Used by special functions. *} 79 . bfd_reloc_continue, 80 . 81 . {* Unsupported relocation size requested. *} 82 . bfd_reloc_notsupported, 83 . 84 . {* Unused. *} 85 . bfd_reloc_other, 86 . 87 . {* The symbol to relocate against was undefined. *} 88 . bfd_reloc_undefined, 89 . 90 . {* The relocation was performed, but may not be ok - presently 91 . generated only when linking i960 coff files with i960 b.out 92 . symbols. If this type is returned, the error_message argument 93 . to bfd_perform_relocation will be set. *} 94 . bfd_reloc_dangerous 95 . } 96 . bfd_reloc_status_type; 97 . 98 . 99 .typedef struct reloc_cache_entry 100 .{ 101 . {* A pointer into the canonical table of pointers. *} 102 . struct bfd_symbol **sym_ptr_ptr; 103 . 104 . {* offset in section. *} 105 . bfd_size_type address; 106 . 107 . {* addend for relocation value. *} 108 . bfd_vma addend; 109 . 110 . {* Pointer to how to perform the required relocation. *} 111 . reloc_howto_type *howto; 112 . 113 .} 114 .arelent; 115 . 116 */ 117 118 /* 119 DESCRIPTION 120 121 Here is a description of each of the fields within an <<arelent>>: 122 123 o <<sym_ptr_ptr>> 124 125 The symbol table pointer points to a pointer to the symbol 126 associated with the relocation request. It is the pointer 127 into the table returned by the back end's 128 <<canonicalize_symtab>> action. @xref{Symbols}. The symbol is 129 referenced through a pointer to a pointer so that tools like 130 the linker can fix up all the symbols of the same name by 131 modifying only one pointer. The relocation routine looks in 132 the symbol and uses the base of the section the symbol is 133 attached to and the value of the symbol as the initial 134 relocation offset. If the symbol pointer is zero, then the 135 section provided is looked up. 136 137 o <<address>> 138 139 The <<address>> field gives the offset in bytes from the base of 140 the section data which owns the relocation record to the first 141 byte of relocatable information. The actual data relocated 142 will be relative to this point; for example, a relocation 143 type which modifies the bottom two bytes of a four byte word 144 would not touch the first byte pointed to in a big endian 145 world. 146 147 o <<addend>> 148 149 The <<addend>> is a value provided by the back end to be added (!) 150 to the relocation offset. Its interpretation is dependent upon 151 the howto. For example, on the 68k the code: 152 153 | char foo[]; 154 | main() 155 | { 156 | return foo[0x12345678]; 157 | } 158 159 Could be compiled into: 160 161 | linkw fp,#-4 162 | moveb @@#12345678,d0 163 | extbl d0 164 | unlk fp 165 | rts 166 167 This could create a reloc pointing to <<foo>>, but leave the 168 offset in the data, something like: 169 170 |RELOCATION RECORDS FOR [.text]: 171 |offset type value 172 |00000006 32 _foo 173 | 174 |00000000 4e56 fffc ; linkw fp,#-4 175 |00000004 1039 1234 5678 ; moveb @@#12345678,d0 176 |0000000a 49c0 ; extbl d0 177 |0000000c 4e5e ; unlk fp 178 |0000000e 4e75 ; rts 179 180 Using coff and an 88k, some instructions don't have enough 181 space in them to represent the full address range, and 182 pointers have to be loaded in two parts. So you'd get something like: 183 184 | or.u r13,r0,hi16(_foo+0x12345678) 185 | ld.b r2,r13,lo16(_foo+0x12345678) 186 | jmp r1 187 188 This should create two relocs, both pointing to <<_foo>>, and with 189 0x12340000 in their addend field. The data would consist of: 190 191 |RELOCATION RECORDS FOR [.text]: 192 |offset type value 193 |00000002 HVRT16 _foo+0x12340000 194 |00000006 LVRT16 _foo+0x12340000 195 | 196 |00000000 5da05678 ; or.u r13,r0,0x5678 197 |00000004 1c4d5678 ; ld.b r2,r13,0x5678 198 |00000008 f400c001 ; jmp r1 199 200 The relocation routine digs out the value from the data, adds 201 it to the addend to get the original offset, and then adds the 202 value of <<_foo>>. Note that all 32 bits have to be kept around 203 somewhere, to cope with carry from bit 15 to bit 16. 204 205 One further example is the sparc and the a.out format. The 206 sparc has a similar problem to the 88k, in that some 207 instructions don't have room for an entire offset, but on the 208 sparc the parts are created in odd sized lumps. The designers of 209 the a.out format chose to not use the data within the section 210 for storing part of the offset; all the offset is kept within 211 the reloc. Anything in the data should be ignored. 212 213 | save %sp,-112,%sp 214 | sethi %hi(_foo+0x12345678),%g2 215 | ldsb [%g2+%lo(_foo+0x12345678)],%i0 216 | ret 217 | restore 218 219 Both relocs contain a pointer to <<foo>>, and the offsets 220 contain junk. 221 222 |RELOCATION RECORDS FOR [.text]: 223 |offset type value 224 |00000004 HI22 _foo+0x12345678 225 |00000008 LO10 _foo+0x12345678 226 | 227 |00000000 9de3bf90 ; save %sp,-112,%sp 228 |00000004 05000000 ; sethi %hi(_foo+0),%g2 229 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0 230 |0000000c 81c7e008 ; ret 231 |00000010 81e80000 ; restore 232 233 o <<howto>> 234 235 The <<howto>> field can be imagined as a 236 relocation instruction. It is a pointer to a structure which 237 contains information on what to do with all of the other 238 information in the reloc record and data section. A back end 239 would normally have a relocation instruction set and turn 240 relocations into pointers to the correct structure on input - 241 but it would be possible to create each howto field on demand. 242 243 */ 244 245 /* 246 SUBSUBSECTION 247 <<enum complain_overflow>> 248 249 Indicates what sort of overflow checking should be done when 250 performing a relocation. 251 252 CODE_FRAGMENT 253 . 254 .enum complain_overflow 255 .{ 256 . {* Do not complain on overflow. *} 257 . complain_overflow_dont, 258 . 259 . {* Complain if the value overflows when considered as a signed 260 . number one bit larger than the field. ie. A bitfield of N bits 261 . is allowed to represent -2**n to 2**n-1. *} 262 . complain_overflow_bitfield, 263 . 264 . {* Complain if the value overflows when considered as a signed 265 . number. *} 266 . complain_overflow_signed, 267 . 268 . {* Complain if the value overflows when considered as an 269 . unsigned number. *} 270 . complain_overflow_unsigned 271 .}; 272 273 */ 274 275 /* 276 SUBSUBSECTION 277 <<reloc_howto_type>> 278 279 The <<reloc_howto_type>> is a structure which contains all the 280 information that libbfd needs to know to tie up a back end's data. 281 282 CODE_FRAGMENT 283 .struct bfd_symbol; {* Forward declaration. *} 284 . 285 .struct reloc_howto_struct 286 .{ 287 . {* The type field has mainly a documentary use - the back end can 288 . do what it wants with it, though normally the back end's 289 . external idea of what a reloc number is stored 290 . in this field. For example, a PC relative word relocation 291 . in a coff environment has the type 023 - because that's 292 . what the outside world calls a R_PCRWORD reloc. *} 293 . unsigned int type; 294 . 295 . {* The value the final relocation is shifted right by. This drops 296 . unwanted data from the relocation. *} 297 . unsigned int rightshift; 298 . 299 . {* The size of the item to be relocated. This is *not* a 300 . power-of-two measure. To get the number of bytes operated 301 . on by a type of relocation, use bfd_get_reloc_size. *} 302 . int size; 303 . 304 . {* The number of bits in the item to be relocated. This is used 305 . when doing overflow checking. *} 306 . unsigned int bitsize; 307 . 308 . {* Notes that the relocation is relative to the location in the 309 . data section of the addend. The relocation function will 310 . subtract from the relocation value the address of the location 311 . being relocated. *} 312 . bfd_boolean pc_relative; 313 . 314 . {* The bit position of the reloc value in the destination. 315 . The relocated value is left shifted by this amount. *} 316 . unsigned int bitpos; 317 . 318 . {* What type of overflow error should be checked for when 319 . relocating. *} 320 . enum complain_overflow complain_on_overflow; 321 . 322 . {* If this field is non null, then the supplied function is 323 . called rather than the normal function. This allows really 324 . strange relocation methods to be accommodated (e.g., i960 callj 325 . instructions). *} 326 . bfd_reloc_status_type (*special_function) 327 . (bfd *, arelent *, struct bfd_symbol *, void *, asection *, 328 . bfd *, char **); 329 . 330 . {* The textual name of the relocation type. *} 331 . char *name; 332 . 333 . {* Some formats record a relocation addend in the section contents 334 . rather than with the relocation. For ELF formats this is the 335 . distinction between USE_REL and USE_RELA (though the code checks 336 . for USE_REL == 1/0). The value of this field is TRUE if the 337 . addend is recorded with the section contents; when performing a 338 . partial link (ld -r) the section contents (the data) will be 339 . modified. The value of this field is FALSE if addends are 340 . recorded with the relocation (in arelent.addend); when performing 341 . a partial link the relocation will be modified. 342 . All relocations for all ELF USE_RELA targets should set this field 343 . to FALSE (values of TRUE should be looked on with suspicion). 344 . However, the converse is not true: not all relocations of all ELF 345 . USE_REL targets set this field to TRUE. Why this is so is peculiar 346 . to each particular target. For relocs that aren't used in partial 347 . links (e.g. GOT stuff) it doesn't matter what this is set to. *} 348 . bfd_boolean partial_inplace; 349 . 350 . {* src_mask selects the part of the instruction (or data) to be used 351 . in the relocation sum. If the target relocations don't have an 352 . addend in the reloc, eg. ELF USE_REL, src_mask will normally equal 353 . dst_mask to extract the addend from the section contents. If 354 . relocations do have an addend in the reloc, eg. ELF USE_RELA, this 355 . field should be zero. Non-zero values for ELF USE_RELA targets are 356 . bogus as in those cases the value in the dst_mask part of the 357 . section contents should be treated as garbage. *} 358 . bfd_vma src_mask; 359 . 360 . {* dst_mask selects which parts of the instruction (or data) are 361 . replaced with a relocated value. *} 362 . bfd_vma dst_mask; 363 . 364 . {* When some formats create PC relative instructions, they leave 365 . the value of the pc of the place being relocated in the offset 366 . slot of the instruction, so that a PC relative relocation can 367 . be made just by adding in an ordinary offset (e.g., sun3 a.out). 368 . Some formats leave the displacement part of an instruction 369 . empty (e.g., m88k bcs); this flag signals the fact. *} 370 . bfd_boolean pcrel_offset; 371 .}; 372 . 373 */ 374 375 /* 376 FUNCTION 377 The HOWTO Macro 378 379 DESCRIPTION 380 The HOWTO define is horrible and will go away. 381 382 .#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ 383 . { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC } 384 385 DESCRIPTION 386 And will be replaced with the totally magic way. But for the 387 moment, we are compatible, so do it this way. 388 389 .#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \ 390 . HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \ 391 . NAME, FALSE, 0, 0, IN) 392 . 393 394 DESCRIPTION 395 This is used to fill in an empty howto entry in an array. 396 397 .#define EMPTY_HOWTO(C) \ 398 . HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \ 399 . NULL, FALSE, 0, 0, FALSE) 400 . 401 402 DESCRIPTION 403 Helper routine to turn a symbol into a relocation value. 404 405 .#define HOWTO_PREPARE(relocation, symbol) \ 406 . { \ 407 . if (symbol != NULL) \ 408 . { \ 409 . if (bfd_is_com_section (symbol->section)) \ 410 . { \ 411 . relocation = 0; \ 412 . } \ 413 . else \ 414 . { \ 415 . relocation = symbol->value; \ 416 . } \ 417 . } \ 418 . } 419 . 420 */ 421 422 /* 423 FUNCTION 424 bfd_get_reloc_size 425 426 SYNOPSIS 427 unsigned int bfd_get_reloc_size (reloc_howto_type *); 428 429 DESCRIPTION 430 For a reloc_howto_type that operates on a fixed number of bytes, 431 this returns the number of bytes operated on. 432 */ 433 434 unsigned int 435 bfd_get_reloc_size (reloc_howto_type *howto) 436 { 437 switch (howto->size) 438 { 439 case 0: return 1; 440 case 1: return 2; 441 case 2: return 4; 442 case 3: return 0; 443 case 4: return 8; 444 case 8: return 16; 445 case -2: return 4; 446 default: abort (); 447 } 448 } 449 450 /* 451 TYPEDEF 452 arelent_chain 453 454 DESCRIPTION 455 456 How relocs are tied together in an <<asection>>: 457 458 .typedef struct relent_chain 459 .{ 460 . arelent relent; 461 . struct relent_chain *next; 462 .} 463 .arelent_chain; 464 . 465 */ 466 467 /* N_ONES produces N one bits, without overflowing machine arithmetic. */ 468 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1) 469 470 /* 471 FUNCTION 472 bfd_check_overflow 473 474 SYNOPSIS 475 bfd_reloc_status_type bfd_check_overflow 476 (enum complain_overflow how, 477 unsigned int bitsize, 478 unsigned int rightshift, 479 unsigned int addrsize, 480 bfd_vma relocation); 481 482 DESCRIPTION 483 Perform overflow checking on @var{relocation} which has 484 @var{bitsize} significant bits and will be shifted right by 485 @var{rightshift} bits, on a machine with addresses containing 486 @var{addrsize} significant bits. The result is either of 487 @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}. 488 489 */ 490 491 bfd_reloc_status_type 492 bfd_check_overflow (enum complain_overflow how, 493 unsigned int bitsize, 494 unsigned int rightshift, 495 unsigned int addrsize, 496 bfd_vma relocation) 497 { 498 bfd_vma fieldmask, addrmask, signmask, ss, a; 499 bfd_reloc_status_type flag = bfd_reloc_ok; 500 501 /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not, 502 we'll be permissive: extra bits in the field mask will 503 automatically extend the address mask for purposes of the 504 overflow check. */ 505 fieldmask = N_ONES (bitsize); 506 signmask = ~fieldmask; 507 addrmask = N_ONES (addrsize) | fieldmask; 508 a = (relocation & addrmask) >> rightshift;; 509 510 switch (how) 511 { 512 case complain_overflow_dont: 513 break; 514 515 case complain_overflow_signed: 516 /* If any sign bits are set, all sign bits must be set. That 517 is, A must be a valid negative address after shifting. */ 518 signmask = ~ (fieldmask >> 1); 519 /* Fall thru */ 520 521 case complain_overflow_bitfield: 522 /* Bitfields are sometimes signed, sometimes unsigned. We 523 explicitly allow an address wrap too, which means a bitfield 524 of n bits is allowed to store -2**n to 2**n-1. Thus overflow 525 if the value has some, but not all, bits set outside the 526 field. */ 527 ss = a & signmask; 528 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask)) 529 flag = bfd_reloc_overflow; 530 break; 531 532 case complain_overflow_unsigned: 533 /* We have an overflow if the address does not fit in the field. */ 534 if ((a & signmask) != 0) 535 flag = bfd_reloc_overflow; 536 break; 537 538 default: 539 abort (); 540 } 541 542 return flag; 543 } 544 545 /* 546 FUNCTION 547 bfd_perform_relocation 548 549 SYNOPSIS 550 bfd_reloc_status_type bfd_perform_relocation 551 (bfd *abfd, 552 arelent *reloc_entry, 553 void *data, 554 asection *input_section, 555 bfd *output_bfd, 556 char **error_message); 557 558 DESCRIPTION 559 If @var{output_bfd} is supplied to this function, the 560 generated image will be relocatable; the relocations are 561 copied to the output file after they have been changed to 562 reflect the new state of the world. There are two ways of 563 reflecting the results of partial linkage in an output file: 564 by modifying the output data in place, and by modifying the 565 relocation record. Some native formats (e.g., basic a.out and 566 basic coff) have no way of specifying an addend in the 567 relocation type, so the addend has to go in the output data. 568 This is no big deal since in these formats the output data 569 slot will always be big enough for the addend. Complex reloc 570 types with addends were invented to solve just this problem. 571 The @var{error_message} argument is set to an error message if 572 this return @code{bfd_reloc_dangerous}. 573 574 */ 575 576 bfd_reloc_status_type 577 bfd_perform_relocation (bfd *abfd, 578 arelent *reloc_entry, 579 void *data, 580 asection *input_section, 581 bfd *output_bfd, 582 char **error_message) 583 { 584 bfd_vma relocation; 585 bfd_reloc_status_type flag = bfd_reloc_ok; 586 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd); 587 bfd_vma output_base = 0; 588 reloc_howto_type *howto = reloc_entry->howto; 589 asection *reloc_target_output_section; 590 asymbol *symbol; 591 592 symbol = *(reloc_entry->sym_ptr_ptr); 593 if (bfd_is_abs_section (symbol->section) 594 && output_bfd != NULL) 595 { 596 reloc_entry->address += input_section->output_offset; 597 return bfd_reloc_ok; 598 } 599 600 /* If we are not producing relocatable output, return an error if 601 the symbol is not defined. An undefined weak symbol is 602 considered to have a value of zero (SVR4 ABI, p. 4-27). */ 603 if (bfd_is_und_section (symbol->section) 604 && (symbol->flags & BSF_WEAK) == 0 605 && output_bfd == NULL) 606 flag = bfd_reloc_undefined; 607 608 /* If there is a function supplied to handle this relocation type, 609 call it. It'll return `bfd_reloc_continue' if further processing 610 can be done. */ 611 if (howto->special_function) 612 { 613 bfd_reloc_status_type cont; 614 cont = howto->special_function (abfd, reloc_entry, symbol, data, 615 input_section, output_bfd, 616 error_message); 617 if (cont != bfd_reloc_continue) 618 return cont; 619 } 620 621 /* Is the address of the relocation really within the section? */ 622 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 623 return bfd_reloc_outofrange; 624 625 /* Work out which section the relocation is targeted at and the 626 initial relocation command value. */ 627 628 /* Get symbol value. (Common symbols are special.) */ 629 if (bfd_is_com_section (symbol->section)) 630 relocation = 0; 631 else 632 relocation = symbol->value; 633 634 reloc_target_output_section = symbol->section->output_section; 635 636 /* Convert input-section-relative symbol value to absolute. */ 637 if ((output_bfd && ! howto->partial_inplace) 638 || reloc_target_output_section == NULL) 639 output_base = 0; 640 else 641 output_base = reloc_target_output_section->vma; 642 643 relocation += output_base + symbol->section->output_offset; 644 645 /* Add in supplied addend. */ 646 relocation += reloc_entry->addend; 647 648 /* Here the variable relocation holds the final address of the 649 symbol we are relocating against, plus any addend. */ 650 651 if (howto->pc_relative) 652 { 653 /* This is a PC relative relocation. We want to set RELOCATION 654 to the distance between the address of the symbol and the 655 location. RELOCATION is already the address of the symbol. 656 657 We start by subtracting the address of the section containing 658 the location. 659 660 If pcrel_offset is set, we must further subtract the position 661 of the location within the section. Some targets arrange for 662 the addend to be the negative of the position of the location 663 within the section; for example, i386-aout does this. For 664 i386-aout, pcrel_offset is FALSE. Some other targets do not 665 include the position of the location; for example, m88kbcs, 666 or ELF. For those targets, pcrel_offset is TRUE. 667 668 If we are producing relocatable output, then we must ensure 669 that this reloc will be correctly computed when the final 670 relocation is done. If pcrel_offset is FALSE we want to wind 671 up with the negative of the location within the section, 672 which means we must adjust the existing addend by the change 673 in the location within the section. If pcrel_offset is TRUE 674 we do not want to adjust the existing addend at all. 675 676 FIXME: This seems logical to me, but for the case of 677 producing relocatable output it is not what the code 678 actually does. I don't want to change it, because it seems 679 far too likely that something will break. */ 680 681 relocation -= 682 input_section->output_section->vma + input_section->output_offset; 683 684 if (howto->pcrel_offset) 685 relocation -= reloc_entry->address; 686 } 687 688 if (output_bfd != NULL) 689 { 690 if (! howto->partial_inplace) 691 { 692 /* This is a partial relocation, and we want to apply the relocation 693 to the reloc entry rather than the raw data. Modify the reloc 694 inplace to reflect what we now know. */ 695 reloc_entry->addend = relocation; 696 reloc_entry->address += input_section->output_offset; 697 return flag; 698 } 699 else 700 { 701 /* This is a partial relocation, but inplace, so modify the 702 reloc record a bit. 703 704 If we've relocated with a symbol with a section, change 705 into a ref to the section belonging to the symbol. */ 706 707 reloc_entry->address += input_section->output_offset; 708 709 /* WTF?? */ 710 if (abfd->xvec->flavour == bfd_target_coff_flavour 711 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0 712 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0) 713 { 714 /* For m68k-coff, the addend was being subtracted twice during 715 relocation with -r. Removing the line below this comment 716 fixes that problem; see PR 2953. 717 718 However, Ian wrote the following, regarding removing the line below, 719 which explains why it is still enabled: --djm 720 721 If you put a patch like that into BFD you need to check all the COFF 722 linkers. I am fairly certain that patch will break coff-i386 (e.g., 723 SCO); see coff_i386_reloc in coff-i386.c where I worked around the 724 problem in a different way. There may very well be a reason that the 725 code works as it does. 726 727 Hmmm. The first obvious point is that bfd_perform_relocation should 728 not have any tests that depend upon the flavour. It's seem like 729 entirely the wrong place for such a thing. The second obvious point 730 is that the current code ignores the reloc addend when producing 731 relocatable output for COFF. That's peculiar. In fact, I really 732 have no idea what the point of the line you want to remove is. 733 734 A typical COFF reloc subtracts the old value of the symbol and adds in 735 the new value to the location in the object file (if it's a pc 736 relative reloc it adds the difference between the symbol value and the 737 location). When relocating we need to preserve that property. 738 739 BFD handles this by setting the addend to the negative of the old 740 value of the symbol. Unfortunately it handles common symbols in a 741 non-standard way (it doesn't subtract the old value) but that's a 742 different story (we can't change it without losing backward 743 compatibility with old object files) (coff-i386 does subtract the old 744 value, to be compatible with existing coff-i386 targets, like SCO). 745 746 So everything works fine when not producing relocatable output. When 747 we are producing relocatable output, logically we should do exactly 748 what we do when not producing relocatable output. Therefore, your 749 patch is correct. In fact, it should probably always just set 750 reloc_entry->addend to 0 for all cases, since it is, in fact, going to 751 add the value into the object file. This won't hurt the COFF code, 752 which doesn't use the addend; I'm not sure what it will do to other 753 formats (the thing to check for would be whether any formats both use 754 the addend and set partial_inplace). 755 756 When I wanted to make coff-i386 produce relocatable output, I ran 757 into the problem that you are running into: I wanted to remove that 758 line. Rather than risk it, I made the coff-i386 relocs use a special 759 function; it's coff_i386_reloc in coff-i386.c. The function 760 specifically adds the addend field into the object file, knowing that 761 bfd_perform_relocation is not going to. If you remove that line, then 762 coff-i386.c will wind up adding the addend field in twice. It's 763 trivial to fix; it just needs to be done. 764 765 The problem with removing the line is just that it may break some 766 working code. With BFD it's hard to be sure of anything. The right 767 way to deal with this is simply to build and test at least all the 768 supported COFF targets. It should be straightforward if time and disk 769 space consuming. For each target: 770 1) build the linker 771 2) generate some executable, and link it using -r (I would 772 probably use paranoia.o and link against newlib/libc.a, which 773 for all the supported targets would be available in 774 /usr/cygnus/progressive/H-host/target/lib/libc.a). 775 3) make the change to reloc.c 776 4) rebuild the linker 777 5) repeat step 2 778 6) if the resulting object files are the same, you have at least 779 made it no worse 780 7) if they are different you have to figure out which version is 781 right 782 */ 783 relocation -= reloc_entry->addend; 784 reloc_entry->addend = 0; 785 } 786 else 787 { 788 reloc_entry->addend = relocation; 789 } 790 } 791 } 792 else 793 { 794 reloc_entry->addend = 0; 795 } 796 797 /* FIXME: This overflow checking is incomplete, because the value 798 might have overflowed before we get here. For a correct check we 799 need to compute the value in a size larger than bitsize, but we 800 can't reasonably do that for a reloc the same size as a host 801 machine word. 802 FIXME: We should also do overflow checking on the result after 803 adding in the value contained in the object file. */ 804 if (howto->complain_on_overflow != complain_overflow_dont 805 && flag == bfd_reloc_ok) 806 flag = bfd_check_overflow (howto->complain_on_overflow, 807 howto->bitsize, 808 howto->rightshift, 809 bfd_arch_bits_per_address (abfd), 810 relocation); 811 812 /* Either we are relocating all the way, or we don't want to apply 813 the relocation to the reloc entry (probably because there isn't 814 any room in the output format to describe addends to relocs). */ 815 816 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler 817 (OSF version 1.3, compiler version 3.11). It miscompiles the 818 following program: 819 820 struct str 821 { 822 unsigned int i0; 823 } s = { 0 }; 824 825 int 826 main () 827 { 828 unsigned long x; 829 830 x = 0x100000000; 831 x <<= (unsigned long) s.i0; 832 if (x == 0) 833 printf ("failed\n"); 834 else 835 printf ("succeeded (%lx)\n", x); 836 } 837 */ 838 839 relocation >>= (bfd_vma) howto->rightshift; 840 841 /* Shift everything up to where it's going to be used. */ 842 relocation <<= (bfd_vma) howto->bitpos; 843 844 /* Wait for the day when all have the mask in them. */ 845 846 /* What we do: 847 i instruction to be left alone 848 o offset within instruction 849 r relocation offset to apply 850 S src mask 851 D dst mask 852 N ~dst mask 853 A part 1 854 B part 2 855 R result 856 857 Do this: 858 (( i i i i i o o o o o from bfd_get<size> 859 and S S S S S) to get the size offset we want 860 + r r r r r r r r r r) to get the final value to place 861 and D D D D D to chop to right size 862 ----------------------- 863 = A A A A A 864 And this: 865 ( i i i i i o o o o o from bfd_get<size> 866 and N N N N N ) get instruction 867 ----------------------- 868 = B B B B B 869 870 And then: 871 ( B B B B B 872 or A A A A A) 873 ----------------------- 874 = R R R R R R R R R R put into bfd_put<size> 875 */ 876 877 #define DOIT(x) \ 878 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask)) 879 880 switch (howto->size) 881 { 882 case 0: 883 { 884 char x = bfd_get_8 (abfd, (char *) data + octets); 885 DOIT (x); 886 bfd_put_8 (abfd, x, (unsigned char *) data + octets); 887 } 888 break; 889 890 case 1: 891 { 892 short x = bfd_get_16 (abfd, (bfd_byte *) data + octets); 893 DOIT (x); 894 bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets); 895 } 896 break; 897 case 2: 898 { 899 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets); 900 DOIT (x); 901 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 902 } 903 break; 904 case -2: 905 { 906 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets); 907 relocation = -relocation; 908 DOIT (x); 909 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 910 } 911 break; 912 913 case -1: 914 { 915 long x = bfd_get_16 (abfd, (bfd_byte *) data + octets); 916 relocation = -relocation; 917 DOIT (x); 918 bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 919 } 920 break; 921 922 case 3: 923 /* Do nothing */ 924 break; 925 926 case 4: 927 #ifdef BFD64 928 { 929 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets); 930 DOIT (x); 931 bfd_put_64 (abfd, x, (bfd_byte *) data + octets); 932 } 933 #else 934 abort (); 935 #endif 936 break; 937 default: 938 return bfd_reloc_other; 939 } 940 941 return flag; 942 } 943 944 /* 945 FUNCTION 946 bfd_install_relocation 947 948 SYNOPSIS 949 bfd_reloc_status_type bfd_install_relocation 950 (bfd *abfd, 951 arelent *reloc_entry, 952 void *data, bfd_vma data_start, 953 asection *input_section, 954 char **error_message); 955 956 DESCRIPTION 957 This looks remarkably like <<bfd_perform_relocation>>, except it 958 does not expect that the section contents have been filled in. 959 I.e., it's suitable for use when creating, rather than applying 960 a relocation. 961 962 For now, this function should be considered reserved for the 963 assembler. 964 */ 965 966 bfd_reloc_status_type 967 bfd_install_relocation (bfd *abfd, 968 arelent *reloc_entry, 969 void *data_start, 970 bfd_vma data_start_offset, 971 asection *input_section, 972 char **error_message) 973 { 974 bfd_vma relocation; 975 bfd_reloc_status_type flag = bfd_reloc_ok; 976 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd); 977 bfd_vma output_base = 0; 978 reloc_howto_type *howto = reloc_entry->howto; 979 asection *reloc_target_output_section; 980 asymbol *symbol; 981 bfd_byte *data; 982 983 symbol = *(reloc_entry->sym_ptr_ptr); 984 if (bfd_is_abs_section (symbol->section)) 985 { 986 reloc_entry->address += input_section->output_offset; 987 return bfd_reloc_ok; 988 } 989 990 /* If there is a function supplied to handle this relocation type, 991 call it. It'll return `bfd_reloc_continue' if further processing 992 can be done. */ 993 if (howto->special_function) 994 { 995 bfd_reloc_status_type cont; 996 997 /* XXX - The special_function calls haven't been fixed up to deal 998 with creating new relocations and section contents. */ 999 cont = howto->special_function (abfd, reloc_entry, symbol, 1000 /* XXX - Non-portable! */ 1001 ((bfd_byte *) data_start 1002 - data_start_offset), 1003 input_section, abfd, error_message); 1004 if (cont != bfd_reloc_continue) 1005 return cont; 1006 } 1007 1008 /* Is the address of the relocation really within the section? */ 1009 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 1010 return bfd_reloc_outofrange; 1011 1012 /* Work out which section the relocation is targeted at and the 1013 initial relocation command value. */ 1014 1015 /* Get symbol value. (Common symbols are special.) */ 1016 if (bfd_is_com_section (symbol->section)) 1017 relocation = 0; 1018 else 1019 relocation = symbol->value; 1020 1021 reloc_target_output_section = symbol->section->output_section; 1022 1023 /* Convert input-section-relative symbol value to absolute. */ 1024 if (! howto->partial_inplace) 1025 output_base = 0; 1026 else 1027 output_base = reloc_target_output_section->vma; 1028 1029 relocation += output_base + symbol->section->output_offset; 1030 1031 /* Add in supplied addend. */ 1032 relocation += reloc_entry->addend; 1033 1034 /* Here the variable relocation holds the final address of the 1035 symbol we are relocating against, plus any addend. */ 1036 1037 if (howto->pc_relative) 1038 { 1039 /* This is a PC relative relocation. We want to set RELOCATION 1040 to the distance between the address of the symbol and the 1041 location. RELOCATION is already the address of the symbol. 1042 1043 We start by subtracting the address of the section containing 1044 the location. 1045 1046 If pcrel_offset is set, we must further subtract the position 1047 of the location within the section. Some targets arrange for 1048 the addend to be the negative of the position of the location 1049 within the section; for example, i386-aout does this. For 1050 i386-aout, pcrel_offset is FALSE. Some other targets do not 1051 include the position of the location; for example, m88kbcs, 1052 or ELF. For those targets, pcrel_offset is TRUE. 1053 1054 If we are producing relocatable output, then we must ensure 1055 that this reloc will be correctly computed when the final 1056 relocation is done. If pcrel_offset is FALSE we want to wind 1057 up with the negative of the location within the section, 1058 which means we must adjust the existing addend by the change 1059 in the location within the section. If pcrel_offset is TRUE 1060 we do not want to adjust the existing addend at all. 1061 1062 FIXME: This seems logical to me, but for the case of 1063 producing relocatable output it is not what the code 1064 actually does. I don't want to change it, because it seems 1065 far too likely that something will break. */ 1066 1067 relocation -= 1068 input_section->output_section->vma + input_section->output_offset; 1069 1070 if (howto->pcrel_offset && howto->partial_inplace) 1071 relocation -= reloc_entry->address; 1072 } 1073 1074 if (! howto->partial_inplace) 1075 { 1076 /* This is a partial relocation, and we want to apply the relocation 1077 to the reloc entry rather than the raw data. Modify the reloc 1078 inplace to reflect what we now know. */ 1079 reloc_entry->addend = relocation; 1080 reloc_entry->address += input_section->output_offset; 1081 return flag; 1082 } 1083 else 1084 { 1085 /* This is a partial relocation, but inplace, so modify the 1086 reloc record a bit. 1087 1088 If we've relocated with a symbol with a section, change 1089 into a ref to the section belonging to the symbol. */ 1090 reloc_entry->address += input_section->output_offset; 1091 1092 /* WTF?? */ 1093 if (abfd->xvec->flavour == bfd_target_coff_flavour 1094 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0 1095 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0) 1096 { 1097 1098 /* For m68k-coff, the addend was being subtracted twice during 1099 relocation with -r. Removing the line below this comment 1100 fixes that problem; see PR 2953. 1101 1102 However, Ian wrote the following, regarding removing the line below, 1103 which explains why it is still enabled: --djm 1104 1105 If you put a patch like that into BFD you need to check all the COFF 1106 linkers. I am fairly certain that patch will break coff-i386 (e.g., 1107 SCO); see coff_i386_reloc in coff-i386.c where I worked around the 1108 problem in a different way. There may very well be a reason that the 1109 code works as it does. 1110 1111 Hmmm. The first obvious point is that bfd_install_relocation should 1112 not have any tests that depend upon the flavour. It's seem like 1113 entirely the wrong place for such a thing. The second obvious point 1114 is that the current code ignores the reloc addend when producing 1115 relocatable output for COFF. That's peculiar. In fact, I really 1116 have no idea what the point of the line you want to remove is. 1117 1118 A typical COFF reloc subtracts the old value of the symbol and adds in 1119 the new value to the location in the object file (if it's a pc 1120 relative reloc it adds the difference between the symbol value and the 1121 location). When relocating we need to preserve that property. 1122 1123 BFD handles this by setting the addend to the negative of the old 1124 value of the symbol. Unfortunately it handles common symbols in a 1125 non-standard way (it doesn't subtract the old value) but that's a 1126 different story (we can't change it without losing backward 1127 compatibility with old object files) (coff-i386 does subtract the old 1128 value, to be compatible with existing coff-i386 targets, like SCO). 1129 1130 So everything works fine when not producing relocatable output. When 1131 we are producing relocatable output, logically we should do exactly 1132 what we do when not producing relocatable output. Therefore, your 1133 patch is correct. In fact, it should probably always just set 1134 reloc_entry->addend to 0 for all cases, since it is, in fact, going to 1135 add the value into the object file. This won't hurt the COFF code, 1136 which doesn't use the addend; I'm not sure what it will do to other 1137 formats (the thing to check for would be whether any formats both use 1138 the addend and set partial_inplace). 1139 1140 When I wanted to make coff-i386 produce relocatable output, I ran 1141 into the problem that you are running into: I wanted to remove that 1142 line. Rather than risk it, I made the coff-i386 relocs use a special 1143 function; it's coff_i386_reloc in coff-i386.c. The function 1144 specifically adds the addend field into the object file, knowing that 1145 bfd_install_relocation is not going to. If you remove that line, then 1146 coff-i386.c will wind up adding the addend field in twice. It's 1147 trivial to fix; it just needs to be done. 1148 1149 The problem with removing the line is just that it may break some 1150 working code. With BFD it's hard to be sure of anything. The right 1151 way to deal with this is simply to build and test at least all the 1152 supported COFF targets. It should be straightforward if time and disk 1153 space consuming. For each target: 1154 1) build the linker 1155 2) generate some executable, and link it using -r (I would 1156 probably use paranoia.o and link against newlib/libc.a, which 1157 for all the supported targets would be available in 1158 /usr/cygnus/progressive/H-host/target/lib/libc.a). 1159 3) make the change to reloc.c 1160 4) rebuild the linker 1161 5) repeat step 2 1162 6) if the resulting object files are the same, you have at least 1163 made it no worse 1164 7) if they are different you have to figure out which version is 1165 right. */ 1166 relocation -= reloc_entry->addend; 1167 /* FIXME: There should be no target specific code here... */ 1168 if (strcmp (abfd->xvec->name, "coff-z8k") != 0) 1169 reloc_entry->addend = 0; 1170 } 1171 else 1172 { 1173 reloc_entry->addend = relocation; 1174 } 1175 } 1176 1177 /* FIXME: This overflow checking is incomplete, because the value 1178 might have overflowed before we get here. For a correct check we 1179 need to compute the value in a size larger than bitsize, but we 1180 can't reasonably do that for a reloc the same size as a host 1181 machine word. 1182 FIXME: We should also do overflow checking on the result after 1183 adding in the value contained in the object file. */ 1184 if (howto->complain_on_overflow != complain_overflow_dont) 1185 flag = bfd_check_overflow (howto->complain_on_overflow, 1186 howto->bitsize, 1187 howto->rightshift, 1188 bfd_arch_bits_per_address (abfd), 1189 relocation); 1190 1191 /* Either we are relocating all the way, or we don't want to apply 1192 the relocation to the reloc entry (probably because there isn't 1193 any room in the output format to describe addends to relocs). */ 1194 1195 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler 1196 (OSF version 1.3, compiler version 3.11). It miscompiles the 1197 following program: 1198 1199 struct str 1200 { 1201 unsigned int i0; 1202 } s = { 0 }; 1203 1204 int 1205 main () 1206 { 1207 unsigned long x; 1208 1209 x = 0x100000000; 1210 x <<= (unsigned long) s.i0; 1211 if (x == 0) 1212 printf ("failed\n"); 1213 else 1214 printf ("succeeded (%lx)\n", x); 1215 } 1216 */ 1217 1218 relocation >>= (bfd_vma) howto->rightshift; 1219 1220 /* Shift everything up to where it's going to be used. */ 1221 relocation <<= (bfd_vma) howto->bitpos; 1222 1223 /* Wait for the day when all have the mask in them. */ 1224 1225 /* What we do: 1226 i instruction to be left alone 1227 o offset within instruction 1228 r relocation offset to apply 1229 S src mask 1230 D dst mask 1231 N ~dst mask 1232 A part 1 1233 B part 2 1234 R result 1235 1236 Do this: 1237 (( i i i i i o o o o o from bfd_get<size> 1238 and S S S S S) to get the size offset we want 1239 + r r r r r r r r r r) to get the final value to place 1240 and D D D D D to chop to right size 1241 ----------------------- 1242 = A A A A A 1243 And this: 1244 ( i i i i i o o o o o from bfd_get<size> 1245 and N N N N N ) get instruction 1246 ----------------------- 1247 = B B B B B 1248 1249 And then: 1250 ( B B B B B 1251 or A A A A A) 1252 ----------------------- 1253 = R R R R R R R R R R put into bfd_put<size> 1254 */ 1255 1256 #define DOIT(x) \ 1257 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask)) 1258 1259 data = (bfd_byte *) data_start + (octets - data_start_offset); 1260 1261 switch (howto->size) 1262 { 1263 case 0: 1264 { 1265 char x = bfd_get_8 (abfd, data); 1266 DOIT (x); 1267 bfd_put_8 (abfd, x, data); 1268 } 1269 break; 1270 1271 case 1: 1272 { 1273 short x = bfd_get_16 (abfd, data); 1274 DOIT (x); 1275 bfd_put_16 (abfd, (bfd_vma) x, data); 1276 } 1277 break; 1278 case 2: 1279 { 1280 long x = bfd_get_32 (abfd, data); 1281 DOIT (x); 1282 bfd_put_32 (abfd, (bfd_vma) x, data); 1283 } 1284 break; 1285 case -2: 1286 { 1287 long x = bfd_get_32 (abfd, data); 1288 relocation = -relocation; 1289 DOIT (x); 1290 bfd_put_32 (abfd, (bfd_vma) x, data); 1291 } 1292 break; 1293 1294 case 3: 1295 /* Do nothing */ 1296 break; 1297 1298 case 4: 1299 { 1300 bfd_vma x = bfd_get_64 (abfd, data); 1301 DOIT (x); 1302 bfd_put_64 (abfd, x, data); 1303 } 1304 break; 1305 default: 1306 return bfd_reloc_other; 1307 } 1308 1309 return flag; 1310 } 1311 1312 /* This relocation routine is used by some of the backend linkers. 1313 They do not construct asymbol or arelent structures, so there is no 1314 reason for them to use bfd_perform_relocation. Also, 1315 bfd_perform_relocation is so hacked up it is easier to write a new 1316 function than to try to deal with it. 1317 1318 This routine does a final relocation. Whether it is useful for a 1319 relocatable link depends upon how the object format defines 1320 relocations. 1321 1322 FIXME: This routine ignores any special_function in the HOWTO, 1323 since the existing special_function values have been written for 1324 bfd_perform_relocation. 1325 1326 HOWTO is the reloc howto information. 1327 INPUT_BFD is the BFD which the reloc applies to. 1328 INPUT_SECTION is the section which the reloc applies to. 1329 CONTENTS is the contents of the section. 1330 ADDRESS is the address of the reloc within INPUT_SECTION. 1331 VALUE is the value of the symbol the reloc refers to. 1332 ADDEND is the addend of the reloc. */ 1333 1334 bfd_reloc_status_type 1335 _bfd_final_link_relocate (reloc_howto_type *howto, 1336 bfd *input_bfd, 1337 asection *input_section, 1338 bfd_byte *contents, 1339 bfd_vma address, 1340 bfd_vma value, 1341 bfd_vma addend) 1342 { 1343 bfd_vma relocation; 1344 1345 /* Sanity check the address. */ 1346 if (address > bfd_get_section_limit (input_bfd, input_section)) 1347 return bfd_reloc_outofrange; 1348 1349 /* This function assumes that we are dealing with a basic relocation 1350 against a symbol. We want to compute the value of the symbol to 1351 relocate to. This is just VALUE, the value of the symbol, plus 1352 ADDEND, any addend associated with the reloc. */ 1353 relocation = value + addend; 1354 1355 /* If the relocation is PC relative, we want to set RELOCATION to 1356 the distance between the symbol (currently in RELOCATION) and the 1357 location we are relocating. Some targets (e.g., i386-aout) 1358 arrange for the contents of the section to be the negative of the 1359 offset of the location within the section; for such targets 1360 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF) 1361 simply leave the contents of the section as zero; for such 1362 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not 1363 need to subtract out the offset of the location within the 1364 section (which is just ADDRESS). */ 1365 if (howto->pc_relative) 1366 { 1367 relocation -= (input_section->output_section->vma 1368 + input_section->output_offset); 1369 if (howto->pcrel_offset) 1370 relocation -= address; 1371 } 1372 1373 return _bfd_relocate_contents (howto, input_bfd, relocation, 1374 contents + address); 1375 } 1376 1377 /* Relocate a given location using a given value and howto. */ 1378 1379 bfd_reloc_status_type 1380 _bfd_relocate_contents (reloc_howto_type *howto, 1381 bfd *input_bfd, 1382 bfd_vma relocation, 1383 bfd_byte *location) 1384 { 1385 int size; 1386 bfd_vma x = 0; 1387 bfd_reloc_status_type flag; 1388 unsigned int rightshift = howto->rightshift; 1389 unsigned int bitpos = howto->bitpos; 1390 1391 /* If the size is negative, negate RELOCATION. This isn't very 1392 general. */ 1393 if (howto->size < 0) 1394 relocation = -relocation; 1395 1396 /* Get the value we are going to relocate. */ 1397 size = bfd_get_reloc_size (howto); 1398 switch (size) 1399 { 1400 default: 1401 case 0: 1402 abort (); 1403 case 1: 1404 x = bfd_get_8 (input_bfd, location); 1405 break; 1406 case 2: 1407 x = bfd_get_16 (input_bfd, location); 1408 break; 1409 case 4: 1410 x = bfd_get_32 (input_bfd, location); 1411 break; 1412 case 8: 1413 #ifdef BFD64 1414 x = bfd_get_64 (input_bfd, location); 1415 #else 1416 abort (); 1417 #endif 1418 break; 1419 } 1420 1421 /* Check for overflow. FIXME: We may drop bits during the addition 1422 which we don't check for. We must either check at every single 1423 operation, which would be tedious, or we must do the computations 1424 in a type larger than bfd_vma, which would be inefficient. */ 1425 flag = bfd_reloc_ok; 1426 if (howto->complain_on_overflow != complain_overflow_dont) 1427 { 1428 bfd_vma addrmask, fieldmask, signmask, ss; 1429 bfd_vma a, b, sum; 1430 1431 /* Get the values to be added together. For signed and unsigned 1432 relocations, we assume that all values should be truncated to 1433 the size of an address. For bitfields, all the bits matter. 1434 See also bfd_check_overflow. */ 1435 fieldmask = N_ONES (howto->bitsize); 1436 signmask = ~fieldmask; 1437 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask; 1438 a = (relocation & addrmask) >> rightshift; 1439 b = (x & howto->src_mask & addrmask) >> bitpos; 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 >> rightshift) & 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 relocation value 1549 of zero 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 bfd_byte *location) 1557 { 1558 int size; 1559 bfd_vma x = 0; 1560 1561 /* Get the value we are going to relocate. */ 1562 size = bfd_get_reloc_size (howto); 1563 switch (size) 1564 { 1565 default: 1566 case 0: 1567 abort (); 1568 case 1: 1569 x = bfd_get_8 (input_bfd, location); 1570 break; 1571 case 2: 1572 x = bfd_get_16 (input_bfd, location); 1573 break; 1574 case 4: 1575 x = bfd_get_32 (input_bfd, location); 1576 break; 1577 case 8: 1578 #ifdef BFD64 1579 x = bfd_get_64 (input_bfd, location); 1580 #else 1581 abort (); 1582 #endif 1583 break; 1584 } 1585 1586 /* Zero out the unwanted bits of X. */ 1587 x &= ~howto->dst_mask; 1588 1589 /* Put the relocated value back in the object file. */ 1590 switch (size) 1591 { 1592 default: 1593 case 0: 1594 abort (); 1595 case 1: 1596 bfd_put_8 (input_bfd, x, location); 1597 break; 1598 case 2: 1599 bfd_put_16 (input_bfd, x, location); 1600 break; 1601 case 4: 1602 bfd_put_32 (input_bfd, x, location); 1603 break; 1604 case 8: 1605 #ifdef BFD64 1606 bfd_put_64 (input_bfd, x, location); 1607 #else 1608 abort (); 1609 #endif 1610 break; 1611 } 1612 } 1613 1614 /* 1615 DOCDD 1616 INODE 1617 howto manager, , typedef arelent, Relocations 1618 1619 SUBSECTION 1620 The howto manager 1621 1622 When an application wants to create a relocation, but doesn't 1623 know what the target machine might call it, it can find out by 1624 using this bit of code. 1625 1626 */ 1627 1628 /* 1629 TYPEDEF 1630 bfd_reloc_code_type 1631 1632 DESCRIPTION 1633 The insides of a reloc code. The idea is that, eventually, there 1634 will be one enumerator for every type of relocation we ever do. 1635 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll 1636 return a howto pointer. 1637 1638 This does mean that the application must determine the correct 1639 enumerator value; you can't get a howto pointer from a random set 1640 of attributes. 1641 1642 SENUM 1643 bfd_reloc_code_real 1644 1645 ENUM 1646 BFD_RELOC_64 1647 ENUMX 1648 BFD_RELOC_32 1649 ENUMX 1650 BFD_RELOC_26 1651 ENUMX 1652 BFD_RELOC_24 1653 ENUMX 1654 BFD_RELOC_16 1655 ENUMX 1656 BFD_RELOC_14 1657 ENUMX 1658 BFD_RELOC_8 1659 ENUMDOC 1660 Basic absolute relocations of N bits. 1661 1662 ENUM 1663 BFD_RELOC_64_PCREL 1664 ENUMX 1665 BFD_RELOC_32_PCREL 1666 ENUMX 1667 BFD_RELOC_24_PCREL 1668 ENUMX 1669 BFD_RELOC_16_PCREL 1670 ENUMX 1671 BFD_RELOC_12_PCREL 1672 ENUMX 1673 BFD_RELOC_8_PCREL 1674 ENUMDOC 1675 PC-relative relocations. Sometimes these are relative to the address 1676 of the relocation itself; sometimes they are relative to the start of 1677 the section containing the relocation. It depends on the specific target. 1678 1679 The 24-bit relocation is used in some Intel 960 configurations. 1680 1681 ENUM 1682 BFD_RELOC_32_SECREL 1683 ENUMDOC 1684 Section relative relocations. Some targets need this for DWARF2. 1685 1686 ENUM 1687 BFD_RELOC_32_GOT_PCREL 1688 ENUMX 1689 BFD_RELOC_16_GOT_PCREL 1690 ENUMX 1691 BFD_RELOC_8_GOT_PCREL 1692 ENUMX 1693 BFD_RELOC_32_GOTOFF 1694 ENUMX 1695 BFD_RELOC_16_GOTOFF 1696 ENUMX 1697 BFD_RELOC_LO16_GOTOFF 1698 ENUMX 1699 BFD_RELOC_HI16_GOTOFF 1700 ENUMX 1701 BFD_RELOC_HI16_S_GOTOFF 1702 ENUMX 1703 BFD_RELOC_8_GOTOFF 1704 ENUMX 1705 BFD_RELOC_64_PLT_PCREL 1706 ENUMX 1707 BFD_RELOC_32_PLT_PCREL 1708 ENUMX 1709 BFD_RELOC_24_PLT_PCREL 1710 ENUMX 1711 BFD_RELOC_16_PLT_PCREL 1712 ENUMX 1713 BFD_RELOC_8_PLT_PCREL 1714 ENUMX 1715 BFD_RELOC_64_PLTOFF 1716 ENUMX 1717 BFD_RELOC_32_PLTOFF 1718 ENUMX 1719 BFD_RELOC_16_PLTOFF 1720 ENUMX 1721 BFD_RELOC_LO16_PLTOFF 1722 ENUMX 1723 BFD_RELOC_HI16_PLTOFF 1724 ENUMX 1725 BFD_RELOC_HI16_S_PLTOFF 1726 ENUMX 1727 BFD_RELOC_8_PLTOFF 1728 ENUMDOC 1729 For ELF. 1730 1731 ENUM 1732 BFD_RELOC_68K_GLOB_DAT 1733 ENUMX 1734 BFD_RELOC_68K_JMP_SLOT 1735 ENUMX 1736 BFD_RELOC_68K_RELATIVE 1737 ENUMX 1738 BFD_RELOC_68K_TLS_GD32 1739 ENUMX 1740 BFD_RELOC_68K_TLS_GD16 1741 ENUMX 1742 BFD_RELOC_68K_TLS_GD8 1743 ENUMX 1744 BFD_RELOC_68K_TLS_LDM32 1745 ENUMX 1746 BFD_RELOC_68K_TLS_LDM16 1747 ENUMX 1748 BFD_RELOC_68K_TLS_LDM8 1749 ENUMX 1750 BFD_RELOC_68K_TLS_LDO32 1751 ENUMX 1752 BFD_RELOC_68K_TLS_LDO16 1753 ENUMX 1754 BFD_RELOC_68K_TLS_LDO8 1755 ENUMX 1756 BFD_RELOC_68K_TLS_IE32 1757 ENUMX 1758 BFD_RELOC_68K_TLS_IE16 1759 ENUMX 1760 BFD_RELOC_68K_TLS_IE8 1761 ENUMX 1762 BFD_RELOC_68K_TLS_LE32 1763 ENUMX 1764 BFD_RELOC_68K_TLS_LE16 1765 ENUMX 1766 BFD_RELOC_68K_TLS_LE8 1767 ENUMDOC 1768 Relocations used by 68K ELF. 1769 1770 ENUM 1771 BFD_RELOC_32_BASEREL 1772 ENUMX 1773 BFD_RELOC_16_BASEREL 1774 ENUMX 1775 BFD_RELOC_LO16_BASEREL 1776 ENUMX 1777 BFD_RELOC_HI16_BASEREL 1778 ENUMX 1779 BFD_RELOC_HI16_S_BASEREL 1780 ENUMX 1781 BFD_RELOC_8_BASEREL 1782 ENUMX 1783 BFD_RELOC_RVA 1784 ENUMDOC 1785 Linkage-table relative. 1786 1787 ENUM 1788 BFD_RELOC_8_FFnn 1789 ENUMDOC 1790 Absolute 8-bit relocation, but used to form an address like 0xFFnn. 1791 1792 ENUM 1793 BFD_RELOC_32_PCREL_S2 1794 ENUMX 1795 BFD_RELOC_16_PCREL_S2 1796 ENUMX 1797 BFD_RELOC_23_PCREL_S2 1798 ENUMDOC 1799 These PC-relative relocations are stored as word displacements -- 1800 i.e., byte displacements shifted right two bits. The 30-bit word 1801 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the 1802 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The 1803 signed 16-bit displacement is used on the MIPS, and the 23-bit 1804 displacement is used on the Alpha. 1805 1806 ENUM 1807 BFD_RELOC_HI22 1808 ENUMX 1809 BFD_RELOC_LO10 1810 ENUMDOC 1811 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of 1812 the target word. These are used on the SPARC. 1813 1814 ENUM 1815 BFD_RELOC_GPREL16 1816 ENUMX 1817 BFD_RELOC_GPREL32 1818 ENUMDOC 1819 For systems that allocate a Global Pointer register, these are 1820 displacements off that register. These relocation types are 1821 handled specially, because the value the register will have is 1822 decided relatively late. 1823 1824 ENUM 1825 BFD_RELOC_I960_CALLJ 1826 ENUMDOC 1827 Reloc types used for i960/b.out. 1828 1829 ENUM 1830 BFD_RELOC_NONE 1831 ENUMX 1832 BFD_RELOC_SPARC_WDISP22 1833 ENUMX 1834 BFD_RELOC_SPARC22 1835 ENUMX 1836 BFD_RELOC_SPARC13 1837 ENUMX 1838 BFD_RELOC_SPARC_GOT10 1839 ENUMX 1840 BFD_RELOC_SPARC_GOT13 1841 ENUMX 1842 BFD_RELOC_SPARC_GOT22 1843 ENUMX 1844 BFD_RELOC_SPARC_PC10 1845 ENUMX 1846 BFD_RELOC_SPARC_PC22 1847 ENUMX 1848 BFD_RELOC_SPARC_WPLT30 1849 ENUMX 1850 BFD_RELOC_SPARC_COPY 1851 ENUMX 1852 BFD_RELOC_SPARC_GLOB_DAT 1853 ENUMX 1854 BFD_RELOC_SPARC_JMP_SLOT 1855 ENUMX 1856 BFD_RELOC_SPARC_RELATIVE 1857 ENUMX 1858 BFD_RELOC_SPARC_UA16 1859 ENUMX 1860 BFD_RELOC_SPARC_UA32 1861 ENUMX 1862 BFD_RELOC_SPARC_UA64 1863 ENUMX 1864 BFD_RELOC_SPARC_GOTDATA_HIX22 1865 ENUMX 1866 BFD_RELOC_SPARC_GOTDATA_LOX10 1867 ENUMX 1868 BFD_RELOC_SPARC_GOTDATA_OP_HIX22 1869 ENUMX 1870 BFD_RELOC_SPARC_GOTDATA_OP_LOX10 1871 ENUMX 1872 BFD_RELOC_SPARC_GOTDATA_OP 1873 ENUMDOC 1874 SPARC ELF relocations. There is probably some overlap with other 1875 relocation types already defined. 1876 1877 ENUM 1878 BFD_RELOC_SPARC_BASE13 1879 ENUMX 1880 BFD_RELOC_SPARC_BASE22 1881 ENUMDOC 1882 I think these are specific to SPARC a.out (e.g., Sun 4). 1883 1884 ENUMEQ 1885 BFD_RELOC_SPARC_64 1886 BFD_RELOC_64 1887 ENUMX 1888 BFD_RELOC_SPARC_10 1889 ENUMX 1890 BFD_RELOC_SPARC_11 1891 ENUMX 1892 BFD_RELOC_SPARC_OLO10 1893 ENUMX 1894 BFD_RELOC_SPARC_HH22 1895 ENUMX 1896 BFD_RELOC_SPARC_HM10 1897 ENUMX 1898 BFD_RELOC_SPARC_LM22 1899 ENUMX 1900 BFD_RELOC_SPARC_PC_HH22 1901 ENUMX 1902 BFD_RELOC_SPARC_PC_HM10 1903 ENUMX 1904 BFD_RELOC_SPARC_PC_LM22 1905 ENUMX 1906 BFD_RELOC_SPARC_WDISP16 1907 ENUMX 1908 BFD_RELOC_SPARC_WDISP19 1909 ENUMX 1910 BFD_RELOC_SPARC_7 1911 ENUMX 1912 BFD_RELOC_SPARC_6 1913 ENUMX 1914 BFD_RELOC_SPARC_5 1915 ENUMEQX 1916 BFD_RELOC_SPARC_DISP64 1917 BFD_RELOC_64_PCREL 1918 ENUMX 1919 BFD_RELOC_SPARC_PLT32 1920 ENUMX 1921 BFD_RELOC_SPARC_PLT64 1922 ENUMX 1923 BFD_RELOC_SPARC_HIX22 1924 ENUMX 1925 BFD_RELOC_SPARC_LOX10 1926 ENUMX 1927 BFD_RELOC_SPARC_H44 1928 ENUMX 1929 BFD_RELOC_SPARC_M44 1930 ENUMX 1931 BFD_RELOC_SPARC_L44 1932 ENUMX 1933 BFD_RELOC_SPARC_REGISTER 1934 ENUMDOC 1935 SPARC64 relocations 1936 1937 ENUM 1938 BFD_RELOC_SPARC_REV32 1939 ENUMDOC 1940 SPARC little endian relocation 1941 ENUM 1942 BFD_RELOC_SPARC_TLS_GD_HI22 1943 ENUMX 1944 BFD_RELOC_SPARC_TLS_GD_LO10 1945 ENUMX 1946 BFD_RELOC_SPARC_TLS_GD_ADD 1947 ENUMX 1948 BFD_RELOC_SPARC_TLS_GD_CALL 1949 ENUMX 1950 BFD_RELOC_SPARC_TLS_LDM_HI22 1951 ENUMX 1952 BFD_RELOC_SPARC_TLS_LDM_LO10 1953 ENUMX 1954 BFD_RELOC_SPARC_TLS_LDM_ADD 1955 ENUMX 1956 BFD_RELOC_SPARC_TLS_LDM_CALL 1957 ENUMX 1958 BFD_RELOC_SPARC_TLS_LDO_HIX22 1959 ENUMX 1960 BFD_RELOC_SPARC_TLS_LDO_LOX10 1961 ENUMX 1962 BFD_RELOC_SPARC_TLS_LDO_ADD 1963 ENUMX 1964 BFD_RELOC_SPARC_TLS_IE_HI22 1965 ENUMX 1966 BFD_RELOC_SPARC_TLS_IE_LO10 1967 ENUMX 1968 BFD_RELOC_SPARC_TLS_IE_LD 1969 ENUMX 1970 BFD_RELOC_SPARC_TLS_IE_LDX 1971 ENUMX 1972 BFD_RELOC_SPARC_TLS_IE_ADD 1973 ENUMX 1974 BFD_RELOC_SPARC_TLS_LE_HIX22 1975 ENUMX 1976 BFD_RELOC_SPARC_TLS_LE_LOX10 1977 ENUMX 1978 BFD_RELOC_SPARC_TLS_DTPMOD32 1979 ENUMX 1980 BFD_RELOC_SPARC_TLS_DTPMOD64 1981 ENUMX 1982 BFD_RELOC_SPARC_TLS_DTPOFF32 1983 ENUMX 1984 BFD_RELOC_SPARC_TLS_DTPOFF64 1985 ENUMX 1986 BFD_RELOC_SPARC_TLS_TPOFF32 1987 ENUMX 1988 BFD_RELOC_SPARC_TLS_TPOFF64 1989 ENUMDOC 1990 SPARC TLS relocations 1991 1992 ENUM 1993 BFD_RELOC_SPU_IMM7 1994 ENUMX 1995 BFD_RELOC_SPU_IMM8 1996 ENUMX 1997 BFD_RELOC_SPU_IMM10 1998 ENUMX 1999 BFD_RELOC_SPU_IMM10W 2000 ENUMX 2001 BFD_RELOC_SPU_IMM16 2002 ENUMX 2003 BFD_RELOC_SPU_IMM16W 2004 ENUMX 2005 BFD_RELOC_SPU_IMM18 2006 ENUMX 2007 BFD_RELOC_SPU_PCREL9a 2008 ENUMX 2009 BFD_RELOC_SPU_PCREL9b 2010 ENUMX 2011 BFD_RELOC_SPU_PCREL16 2012 ENUMX 2013 BFD_RELOC_SPU_LO16 2014 ENUMX 2015 BFD_RELOC_SPU_HI16 2016 ENUMX 2017 BFD_RELOC_SPU_PPU32 2018 ENUMX 2019 BFD_RELOC_SPU_PPU64 2020 ENUMX 2021 BFD_RELOC_SPU_ADD_PIC 2022 ENUMDOC 2023 SPU Relocations. 2024 2025 ENUM 2026 BFD_RELOC_ALPHA_GPDISP_HI16 2027 ENUMDOC 2028 Alpha ECOFF and ELF relocations. Some of these treat the symbol or 2029 "addend" in some special way. 2030 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when 2031 writing; when reading, it will be the absolute section symbol. The 2032 addend is the displacement in bytes of the "lda" instruction from 2033 the "ldah" instruction (which is at the address of this reloc). 2034 ENUM 2035 BFD_RELOC_ALPHA_GPDISP_LO16 2036 ENUMDOC 2037 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as 2038 with GPDISP_HI16 relocs. The addend is ignored when writing the 2039 relocations out, and is filled in with the file's GP value on 2040 reading, for convenience. 2041 2042 ENUM 2043 BFD_RELOC_ALPHA_GPDISP 2044 ENUMDOC 2045 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 2046 relocation except that there is no accompanying GPDISP_LO16 2047 relocation. 2048 2049 ENUM 2050 BFD_RELOC_ALPHA_LITERAL 2051 ENUMX 2052 BFD_RELOC_ALPHA_ELF_LITERAL 2053 ENUMX 2054 BFD_RELOC_ALPHA_LITUSE 2055 ENUMDOC 2056 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; 2057 the assembler turns it into a LDQ instruction to load the address of 2058 the symbol, and then fills in a register in the real instruction. 2059 2060 The LITERAL reloc, at the LDQ instruction, refers to the .lita 2061 section symbol. The addend is ignored when writing, but is filled 2062 in with the file's GP value on reading, for convenience, as with the 2063 GPDISP_LO16 reloc. 2064 2065 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16. 2066 It should refer to the symbol to be referenced, as with 16_GOTOFF, 2067 but it generates output not based on the position within the .got 2068 section, but relative to the GP value chosen for the file during the 2069 final link stage. 2070 2071 The LITUSE reloc, on the instruction using the loaded address, gives 2072 information to the linker that it might be able to use to optimize 2073 away some literal section references. The symbol is ignored (read 2074 as the absolute section symbol), and the "addend" indicates the type 2075 of instruction using the register: 2076 1 - "memory" fmt insn 2077 2 - byte-manipulation (byte offset reg) 2078 3 - jsr (target of branch) 2079 2080 ENUM 2081 BFD_RELOC_ALPHA_HINT 2082 ENUMDOC 2083 The HINT relocation indicates a value that should be filled into the 2084 "hint" field of a jmp/jsr/ret instruction, for possible branch- 2085 prediction logic which may be provided on some processors. 2086 2087 ENUM 2088 BFD_RELOC_ALPHA_LINKAGE 2089 ENUMDOC 2090 The LINKAGE relocation outputs a linkage pair in the object file, 2091 which is filled by the linker. 2092 2093 ENUM 2094 BFD_RELOC_ALPHA_CODEADDR 2095 ENUMDOC 2096 The CODEADDR relocation outputs a STO_CA in the object file, 2097 which is filled by the linker. 2098 2099 ENUM 2100 BFD_RELOC_ALPHA_GPREL_HI16 2101 ENUMX 2102 BFD_RELOC_ALPHA_GPREL_LO16 2103 ENUMDOC 2104 The GPREL_HI/LO relocations together form a 32-bit offset from the 2105 GP register. 2106 2107 ENUM 2108 BFD_RELOC_ALPHA_BRSGP 2109 ENUMDOC 2110 Like BFD_RELOC_23_PCREL_S2, except that the source and target must 2111 share a common GP, and the target address is adjusted for 2112 STO_ALPHA_STD_GPLOAD. 2113 2114 ENUM 2115 BFD_RELOC_ALPHA_NOP 2116 ENUMDOC 2117 The NOP relocation outputs a NOP if the longword displacement 2118 between two procedure entry points is < 2^21. 2119 2120 ENUM 2121 BFD_RELOC_ALPHA_BSR 2122 ENUMDOC 2123 The BSR relocation outputs a BSR if the longword displacement 2124 between two procedure entry points is < 2^21. 2125 2126 ENUM 2127 BFD_RELOC_ALPHA_LDA 2128 ENUMDOC 2129 The LDA relocation outputs a LDA if the longword displacement 2130 between two procedure entry points is < 2^16. 2131 2132 ENUM 2133 BFD_RELOC_ALPHA_BOH 2134 ENUMDOC 2135 The BOH relocation outputs a BSR if the longword displacement 2136 between two procedure entry points is < 2^21, or else a hint. 2137 2138 ENUM 2139 BFD_RELOC_ALPHA_TLSGD 2140 ENUMX 2141 BFD_RELOC_ALPHA_TLSLDM 2142 ENUMX 2143 BFD_RELOC_ALPHA_DTPMOD64 2144 ENUMX 2145 BFD_RELOC_ALPHA_GOTDTPREL16 2146 ENUMX 2147 BFD_RELOC_ALPHA_DTPREL64 2148 ENUMX 2149 BFD_RELOC_ALPHA_DTPREL_HI16 2150 ENUMX 2151 BFD_RELOC_ALPHA_DTPREL_LO16 2152 ENUMX 2153 BFD_RELOC_ALPHA_DTPREL16 2154 ENUMX 2155 BFD_RELOC_ALPHA_GOTTPREL16 2156 ENUMX 2157 BFD_RELOC_ALPHA_TPREL64 2158 ENUMX 2159 BFD_RELOC_ALPHA_TPREL_HI16 2160 ENUMX 2161 BFD_RELOC_ALPHA_TPREL_LO16 2162 ENUMX 2163 BFD_RELOC_ALPHA_TPREL16 2164 ENUMDOC 2165 Alpha thread-local storage relocations. 2166 2167 ENUM 2168 BFD_RELOC_MIPS_JMP 2169 ENUMDOC 2170 Bits 27..2 of the relocation address shifted right 2 bits; 2171 simple reloc otherwise. 2172 2173 ENUM 2174 BFD_RELOC_MIPS16_JMP 2175 ENUMDOC 2176 The MIPS16 jump instruction. 2177 2178 ENUM 2179 BFD_RELOC_MIPS16_GPREL 2180 ENUMDOC 2181 MIPS16 GP relative reloc. 2182 2183 ENUM 2184 BFD_RELOC_HI16 2185 ENUMDOC 2186 High 16 bits of 32-bit value; simple reloc. 2187 ENUM 2188 BFD_RELOC_HI16_S 2189 ENUMDOC 2190 High 16 bits of 32-bit value but the low 16 bits will be sign 2191 extended and added to form the final result. If the low 16 2192 bits form a negative number, we need to add one to the high value 2193 to compensate for the borrow when the low bits are added. 2194 ENUM 2195 BFD_RELOC_LO16 2196 ENUMDOC 2197 Low 16 bits. 2198 2199 ENUM 2200 BFD_RELOC_HI16_PCREL 2201 ENUMDOC 2202 High 16 bits of 32-bit pc-relative value 2203 ENUM 2204 BFD_RELOC_HI16_S_PCREL 2205 ENUMDOC 2206 High 16 bits of 32-bit pc-relative value, adjusted 2207 ENUM 2208 BFD_RELOC_LO16_PCREL 2209 ENUMDOC 2210 Low 16 bits of pc-relative value 2211 2212 ENUM 2213 BFD_RELOC_MIPS16_GOT16 2214 ENUMX 2215 BFD_RELOC_MIPS16_CALL16 2216 ENUMDOC 2217 Equivalent of BFD_RELOC_MIPS_*, but with the MIPS16 layout of 2218 16-bit immediate fields 2219 ENUM 2220 BFD_RELOC_MIPS16_HI16 2221 ENUMDOC 2222 MIPS16 high 16 bits of 32-bit value. 2223 ENUM 2224 BFD_RELOC_MIPS16_HI16_S 2225 ENUMDOC 2226 MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign 2227 extended and added to form the final result. If the low 16 2228 bits form a negative number, we need to add one to the high value 2229 to compensate for the borrow when the low bits are added. 2230 ENUM 2231 BFD_RELOC_MIPS16_LO16 2232 ENUMDOC 2233 MIPS16 low 16 bits. 2234 2235 ENUM 2236 BFD_RELOC_MIPS_LITERAL 2237 ENUMDOC 2238 Relocation against a MIPS literal section. 2239 2240 ENUM 2241 BFD_RELOC_MIPS_GOT16 2242 ENUMX 2243 BFD_RELOC_MIPS_CALL16 2244 ENUMX 2245 BFD_RELOC_MIPS_GOT_HI16 2246 ENUMX 2247 BFD_RELOC_MIPS_GOT_LO16 2248 ENUMX 2249 BFD_RELOC_MIPS_CALL_HI16 2250 ENUMX 2251 BFD_RELOC_MIPS_CALL_LO16 2252 ENUMX 2253 BFD_RELOC_MIPS_SUB 2254 ENUMX 2255 BFD_RELOC_MIPS_GOT_PAGE 2256 ENUMX 2257 BFD_RELOC_MIPS_GOT_OFST 2258 ENUMX 2259 BFD_RELOC_MIPS_GOT_DISP 2260 ENUMX 2261 BFD_RELOC_MIPS_SHIFT5 2262 ENUMX 2263 BFD_RELOC_MIPS_SHIFT6 2264 ENUMX 2265 BFD_RELOC_MIPS_INSERT_A 2266 ENUMX 2267 BFD_RELOC_MIPS_INSERT_B 2268 ENUMX 2269 BFD_RELOC_MIPS_DELETE 2270 ENUMX 2271 BFD_RELOC_MIPS_HIGHEST 2272 ENUMX 2273 BFD_RELOC_MIPS_HIGHER 2274 ENUMX 2275 BFD_RELOC_MIPS_SCN_DISP 2276 ENUMX 2277 BFD_RELOC_MIPS_REL16 2278 ENUMX 2279 BFD_RELOC_MIPS_RELGOT 2280 ENUMX 2281 BFD_RELOC_MIPS_JALR 2282 ENUMX 2283 BFD_RELOC_MIPS_TLS_DTPMOD32 2284 ENUMX 2285 BFD_RELOC_MIPS_TLS_DTPREL32 2286 ENUMX 2287 BFD_RELOC_MIPS_TLS_DTPMOD64 2288 ENUMX 2289 BFD_RELOC_MIPS_TLS_DTPREL64 2290 ENUMX 2291 BFD_RELOC_MIPS_TLS_GD 2292 ENUMX 2293 BFD_RELOC_MIPS_TLS_LDM 2294 ENUMX 2295 BFD_RELOC_MIPS_TLS_DTPREL_HI16 2296 ENUMX 2297 BFD_RELOC_MIPS_TLS_DTPREL_LO16 2298 ENUMX 2299 BFD_RELOC_MIPS_TLS_GOTTPREL 2300 ENUMX 2301 BFD_RELOC_MIPS_TLS_TPREL32 2302 ENUMX 2303 BFD_RELOC_MIPS_TLS_TPREL64 2304 ENUMX 2305 BFD_RELOC_MIPS_TLS_TPREL_HI16 2306 ENUMX 2307 BFD_RELOC_MIPS_TLS_TPREL_LO16 2308 ENUMDOC 2309 MIPS ELF relocations. 2310 COMMENT 2311 2312 ENUM 2313 BFD_RELOC_MIPS_COPY 2314 ENUMX 2315 BFD_RELOC_MIPS_JUMP_SLOT 2316 ENUMDOC 2317 MIPS ELF relocations (VxWorks and PLT extensions). 2318 COMMENT 2319 2320 ENUM 2321 BFD_RELOC_MOXIE_10_PCREL 2322 ENUMDOC 2323 Moxie ELF relocations. 2324 COMMENT 2325 2326 ENUM 2327 BFD_RELOC_FRV_LABEL16 2328 ENUMX 2329 BFD_RELOC_FRV_LABEL24 2330 ENUMX 2331 BFD_RELOC_FRV_LO16 2332 ENUMX 2333 BFD_RELOC_FRV_HI16 2334 ENUMX 2335 BFD_RELOC_FRV_GPREL12 2336 ENUMX 2337 BFD_RELOC_FRV_GPRELU12 2338 ENUMX 2339 BFD_RELOC_FRV_GPREL32 2340 ENUMX 2341 BFD_RELOC_FRV_GPRELHI 2342 ENUMX 2343 BFD_RELOC_FRV_GPRELLO 2344 ENUMX 2345 BFD_RELOC_FRV_GOT12 2346 ENUMX 2347 BFD_RELOC_FRV_GOTHI 2348 ENUMX 2349 BFD_RELOC_FRV_GOTLO 2350 ENUMX 2351 BFD_RELOC_FRV_FUNCDESC 2352 ENUMX 2353 BFD_RELOC_FRV_FUNCDESC_GOT12 2354 ENUMX 2355 BFD_RELOC_FRV_FUNCDESC_GOTHI 2356 ENUMX 2357 BFD_RELOC_FRV_FUNCDESC_GOTLO 2358 ENUMX 2359 BFD_RELOC_FRV_FUNCDESC_VALUE 2360 ENUMX 2361 BFD_RELOC_FRV_FUNCDESC_GOTOFF12 2362 ENUMX 2363 BFD_RELOC_FRV_FUNCDESC_GOTOFFHI 2364 ENUMX 2365 BFD_RELOC_FRV_FUNCDESC_GOTOFFLO 2366 ENUMX 2367 BFD_RELOC_FRV_GOTOFF12 2368 ENUMX 2369 BFD_RELOC_FRV_GOTOFFHI 2370 ENUMX 2371 BFD_RELOC_FRV_GOTOFFLO 2372 ENUMX 2373 BFD_RELOC_FRV_GETTLSOFF 2374 ENUMX 2375 BFD_RELOC_FRV_TLSDESC_VALUE 2376 ENUMX 2377 BFD_RELOC_FRV_GOTTLSDESC12 2378 ENUMX 2379 BFD_RELOC_FRV_GOTTLSDESCHI 2380 ENUMX 2381 BFD_RELOC_FRV_GOTTLSDESCLO 2382 ENUMX 2383 BFD_RELOC_FRV_TLSMOFF12 2384 ENUMX 2385 BFD_RELOC_FRV_TLSMOFFHI 2386 ENUMX 2387 BFD_RELOC_FRV_TLSMOFFLO 2388 ENUMX 2389 BFD_RELOC_FRV_GOTTLSOFF12 2390 ENUMX 2391 BFD_RELOC_FRV_GOTTLSOFFHI 2392 ENUMX 2393 BFD_RELOC_FRV_GOTTLSOFFLO 2394 ENUMX 2395 BFD_RELOC_FRV_TLSOFF 2396 ENUMX 2397 BFD_RELOC_FRV_TLSDESC_RELAX 2398 ENUMX 2399 BFD_RELOC_FRV_GETTLSOFF_RELAX 2400 ENUMX 2401 BFD_RELOC_FRV_TLSOFF_RELAX 2402 ENUMX 2403 BFD_RELOC_FRV_TLSMOFF 2404 ENUMDOC 2405 Fujitsu Frv Relocations. 2406 COMMENT 2407 2408 ENUM 2409 BFD_RELOC_MN10300_GOTOFF24 2410 ENUMDOC 2411 This is a 24bit GOT-relative reloc for the mn10300. 2412 ENUM 2413 BFD_RELOC_MN10300_GOT32 2414 ENUMDOC 2415 This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes 2416 in the instruction. 2417 ENUM 2418 BFD_RELOC_MN10300_GOT24 2419 ENUMDOC 2420 This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes 2421 in the instruction. 2422 ENUM 2423 BFD_RELOC_MN10300_GOT16 2424 ENUMDOC 2425 This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes 2426 in the instruction. 2427 ENUM 2428 BFD_RELOC_MN10300_COPY 2429 ENUMDOC 2430 Copy symbol at runtime. 2431 ENUM 2432 BFD_RELOC_MN10300_GLOB_DAT 2433 ENUMDOC 2434 Create GOT entry. 2435 ENUM 2436 BFD_RELOC_MN10300_JMP_SLOT 2437 ENUMDOC 2438 Create PLT entry. 2439 ENUM 2440 BFD_RELOC_MN10300_RELATIVE 2441 ENUMDOC 2442 Adjust by program base. 2443 ENUM 2444 BFD_RELOC_MN10300_SYM_DIFF 2445 ENUMDOC 2446 Together with another reloc targeted at the same location, 2447 allows for a value that is the difference of two symbols 2448 in the same section. 2449 ENUM 2450 BFD_RELOC_MN10300_ALIGN 2451 ENUMDOC 2452 The addend of this reloc is an alignment power that must 2453 be honoured at the offset's location, regardless of linker 2454 relaxation. 2455 COMMENT 2456 2457 ENUM 2458 BFD_RELOC_386_GOT32 2459 ENUMX 2460 BFD_RELOC_386_PLT32 2461 ENUMX 2462 BFD_RELOC_386_COPY 2463 ENUMX 2464 BFD_RELOC_386_GLOB_DAT 2465 ENUMX 2466 BFD_RELOC_386_JUMP_SLOT 2467 ENUMX 2468 BFD_RELOC_386_RELATIVE 2469 ENUMX 2470 BFD_RELOC_386_GOTOFF 2471 ENUMX 2472 BFD_RELOC_386_GOTPC 2473 ENUMX 2474 BFD_RELOC_386_TLS_TPOFF 2475 ENUMX 2476 BFD_RELOC_386_TLS_IE 2477 ENUMX 2478 BFD_RELOC_386_TLS_GOTIE 2479 ENUMX 2480 BFD_RELOC_386_TLS_LE 2481 ENUMX 2482 BFD_RELOC_386_TLS_GD 2483 ENUMX 2484 BFD_RELOC_386_TLS_LDM 2485 ENUMX 2486 BFD_RELOC_386_TLS_LDO_32 2487 ENUMX 2488 BFD_RELOC_386_TLS_IE_32 2489 ENUMX 2490 BFD_RELOC_386_TLS_LE_32 2491 ENUMX 2492 BFD_RELOC_386_TLS_DTPMOD32 2493 ENUMX 2494 BFD_RELOC_386_TLS_DTPOFF32 2495 ENUMX 2496 BFD_RELOC_386_TLS_TPOFF32 2497 ENUMX 2498 BFD_RELOC_386_TLS_GOTDESC 2499 ENUMX 2500 BFD_RELOC_386_TLS_DESC_CALL 2501 ENUMX 2502 BFD_RELOC_386_TLS_DESC 2503 ENUMX 2504 BFD_RELOC_386_IRELATIVE 2505 ENUMDOC 2506 i386/elf relocations 2507 2508 ENUM 2509 BFD_RELOC_X86_64_GOT32 2510 ENUMX 2511 BFD_RELOC_X86_64_PLT32 2512 ENUMX 2513 BFD_RELOC_X86_64_COPY 2514 ENUMX 2515 BFD_RELOC_X86_64_GLOB_DAT 2516 ENUMX 2517 BFD_RELOC_X86_64_JUMP_SLOT 2518 ENUMX 2519 BFD_RELOC_X86_64_RELATIVE 2520 ENUMX 2521 BFD_RELOC_X86_64_GOTPCREL 2522 ENUMX 2523 BFD_RELOC_X86_64_32S 2524 ENUMX 2525 BFD_RELOC_X86_64_DTPMOD64 2526 ENUMX 2527 BFD_RELOC_X86_64_DTPOFF64 2528 ENUMX 2529 BFD_RELOC_X86_64_TPOFF64 2530 ENUMX 2531 BFD_RELOC_X86_64_TLSGD 2532 ENUMX 2533 BFD_RELOC_X86_64_TLSLD 2534 ENUMX 2535 BFD_RELOC_X86_64_DTPOFF32 2536 ENUMX 2537 BFD_RELOC_X86_64_GOTTPOFF 2538 ENUMX 2539 BFD_RELOC_X86_64_TPOFF32 2540 ENUMX 2541 BFD_RELOC_X86_64_GOTOFF64 2542 ENUMX 2543 BFD_RELOC_X86_64_GOTPC32 2544 ENUMX 2545 BFD_RELOC_X86_64_GOT64 2546 ENUMX 2547 BFD_RELOC_X86_64_GOTPCREL64 2548 ENUMX 2549 BFD_RELOC_X86_64_GOTPC64 2550 ENUMX 2551 BFD_RELOC_X86_64_GOTPLT64 2552 ENUMX 2553 BFD_RELOC_X86_64_PLTOFF64 2554 ENUMX 2555 BFD_RELOC_X86_64_GOTPC32_TLSDESC 2556 ENUMX 2557 BFD_RELOC_X86_64_TLSDESC_CALL 2558 ENUMX 2559 BFD_RELOC_X86_64_TLSDESC 2560 ENUMX 2561 BFD_RELOC_X86_64_IRELATIVE 2562 ENUMDOC 2563 x86-64/elf relocations 2564 2565 ENUM 2566 BFD_RELOC_NS32K_IMM_8 2567 ENUMX 2568 BFD_RELOC_NS32K_IMM_16 2569 ENUMX 2570 BFD_RELOC_NS32K_IMM_32 2571 ENUMX 2572 BFD_RELOC_NS32K_IMM_8_PCREL 2573 ENUMX 2574 BFD_RELOC_NS32K_IMM_16_PCREL 2575 ENUMX 2576 BFD_RELOC_NS32K_IMM_32_PCREL 2577 ENUMX 2578 BFD_RELOC_NS32K_DISP_8 2579 ENUMX 2580 BFD_RELOC_NS32K_DISP_16 2581 ENUMX 2582 BFD_RELOC_NS32K_DISP_32 2583 ENUMX 2584 BFD_RELOC_NS32K_DISP_8_PCREL 2585 ENUMX 2586 BFD_RELOC_NS32K_DISP_16_PCREL 2587 ENUMX 2588 BFD_RELOC_NS32K_DISP_32_PCREL 2589 ENUMDOC 2590 ns32k relocations 2591 2592 ENUM 2593 BFD_RELOC_PDP11_DISP_8_PCREL 2594 ENUMX 2595 BFD_RELOC_PDP11_DISP_6_PCREL 2596 ENUMDOC 2597 PDP11 relocations 2598 2599 ENUM 2600 BFD_RELOC_PJ_CODE_HI16 2601 ENUMX 2602 BFD_RELOC_PJ_CODE_LO16 2603 ENUMX 2604 BFD_RELOC_PJ_CODE_DIR16 2605 ENUMX 2606 BFD_RELOC_PJ_CODE_DIR32 2607 ENUMX 2608 BFD_RELOC_PJ_CODE_REL16 2609 ENUMX 2610 BFD_RELOC_PJ_CODE_REL32 2611 ENUMDOC 2612 Picojava relocs. Not all of these appear in object files. 2613 2614 ENUM 2615 BFD_RELOC_PPC_B26 2616 ENUMX 2617 BFD_RELOC_PPC_BA26 2618 ENUMX 2619 BFD_RELOC_PPC_TOC16 2620 ENUMX 2621 BFD_RELOC_PPC_B16 2622 ENUMX 2623 BFD_RELOC_PPC_B16_BRTAKEN 2624 ENUMX 2625 BFD_RELOC_PPC_B16_BRNTAKEN 2626 ENUMX 2627 BFD_RELOC_PPC_BA16 2628 ENUMX 2629 BFD_RELOC_PPC_BA16_BRTAKEN 2630 ENUMX 2631 BFD_RELOC_PPC_BA16_BRNTAKEN 2632 ENUMX 2633 BFD_RELOC_PPC_COPY 2634 ENUMX 2635 BFD_RELOC_PPC_GLOB_DAT 2636 ENUMX 2637 BFD_RELOC_PPC_JMP_SLOT 2638 ENUMX 2639 BFD_RELOC_PPC_RELATIVE 2640 ENUMX 2641 BFD_RELOC_PPC_LOCAL24PC 2642 ENUMX 2643 BFD_RELOC_PPC_EMB_NADDR32 2644 ENUMX 2645 BFD_RELOC_PPC_EMB_NADDR16 2646 ENUMX 2647 BFD_RELOC_PPC_EMB_NADDR16_LO 2648 ENUMX 2649 BFD_RELOC_PPC_EMB_NADDR16_HI 2650 ENUMX 2651 BFD_RELOC_PPC_EMB_NADDR16_HA 2652 ENUMX 2653 BFD_RELOC_PPC_EMB_SDAI16 2654 ENUMX 2655 BFD_RELOC_PPC_EMB_SDA2I16 2656 ENUMX 2657 BFD_RELOC_PPC_EMB_SDA2REL 2658 ENUMX 2659 BFD_RELOC_PPC_EMB_SDA21 2660 ENUMX 2661 BFD_RELOC_PPC_EMB_MRKREF 2662 ENUMX 2663 BFD_RELOC_PPC_EMB_RELSEC16 2664 ENUMX 2665 BFD_RELOC_PPC_EMB_RELST_LO 2666 ENUMX 2667 BFD_RELOC_PPC_EMB_RELST_HI 2668 ENUMX 2669 BFD_RELOC_PPC_EMB_RELST_HA 2670 ENUMX 2671 BFD_RELOC_PPC_EMB_BIT_FLD 2672 ENUMX 2673 BFD_RELOC_PPC_EMB_RELSDA 2674 ENUMX 2675 BFD_RELOC_PPC64_HIGHER 2676 ENUMX 2677 BFD_RELOC_PPC64_HIGHER_S 2678 ENUMX 2679 BFD_RELOC_PPC64_HIGHEST 2680 ENUMX 2681 BFD_RELOC_PPC64_HIGHEST_S 2682 ENUMX 2683 BFD_RELOC_PPC64_TOC16_LO 2684 ENUMX 2685 BFD_RELOC_PPC64_TOC16_HI 2686 ENUMX 2687 BFD_RELOC_PPC64_TOC16_HA 2688 ENUMX 2689 BFD_RELOC_PPC64_TOC 2690 ENUMX 2691 BFD_RELOC_PPC64_PLTGOT16 2692 ENUMX 2693 BFD_RELOC_PPC64_PLTGOT16_LO 2694 ENUMX 2695 BFD_RELOC_PPC64_PLTGOT16_HI 2696 ENUMX 2697 BFD_RELOC_PPC64_PLTGOT16_HA 2698 ENUMX 2699 BFD_RELOC_PPC64_ADDR16_DS 2700 ENUMX 2701 BFD_RELOC_PPC64_ADDR16_LO_DS 2702 ENUMX 2703 BFD_RELOC_PPC64_GOT16_DS 2704 ENUMX 2705 BFD_RELOC_PPC64_GOT16_LO_DS 2706 ENUMX 2707 BFD_RELOC_PPC64_PLT16_LO_DS 2708 ENUMX 2709 BFD_RELOC_PPC64_SECTOFF_DS 2710 ENUMX 2711 BFD_RELOC_PPC64_SECTOFF_LO_DS 2712 ENUMX 2713 BFD_RELOC_PPC64_TOC16_DS 2714 ENUMX 2715 BFD_RELOC_PPC64_TOC16_LO_DS 2716 ENUMX 2717 BFD_RELOC_PPC64_PLTGOT16_DS 2718 ENUMX 2719 BFD_RELOC_PPC64_PLTGOT16_LO_DS 2720 ENUMDOC 2721 Power(rs6000) and PowerPC relocations. 2722 2723 ENUM 2724 BFD_RELOC_PPC_TLS 2725 ENUMX 2726 BFD_RELOC_PPC_TLSGD 2727 ENUMX 2728 BFD_RELOC_PPC_TLSLD 2729 ENUMX 2730 BFD_RELOC_PPC_DTPMOD 2731 ENUMX 2732 BFD_RELOC_PPC_TPREL16 2733 ENUMX 2734 BFD_RELOC_PPC_TPREL16_LO 2735 ENUMX 2736 BFD_RELOC_PPC_TPREL16_HI 2737 ENUMX 2738 BFD_RELOC_PPC_TPREL16_HA 2739 ENUMX 2740 BFD_RELOC_PPC_TPREL 2741 ENUMX 2742 BFD_RELOC_PPC_DTPREL16 2743 ENUMX 2744 BFD_RELOC_PPC_DTPREL16_LO 2745 ENUMX 2746 BFD_RELOC_PPC_DTPREL16_HI 2747 ENUMX 2748 BFD_RELOC_PPC_DTPREL16_HA 2749 ENUMX 2750 BFD_RELOC_PPC_DTPREL 2751 ENUMX 2752 BFD_RELOC_PPC_GOT_TLSGD16 2753 ENUMX 2754 BFD_RELOC_PPC_GOT_TLSGD16_LO 2755 ENUMX 2756 BFD_RELOC_PPC_GOT_TLSGD16_HI 2757 ENUMX 2758 BFD_RELOC_PPC_GOT_TLSGD16_HA 2759 ENUMX 2760 BFD_RELOC_PPC_GOT_TLSLD16 2761 ENUMX 2762 BFD_RELOC_PPC_GOT_TLSLD16_LO 2763 ENUMX 2764 BFD_RELOC_PPC_GOT_TLSLD16_HI 2765 ENUMX 2766 BFD_RELOC_PPC_GOT_TLSLD16_HA 2767 ENUMX 2768 BFD_RELOC_PPC_GOT_TPREL16 2769 ENUMX 2770 BFD_RELOC_PPC_GOT_TPREL16_LO 2771 ENUMX 2772 BFD_RELOC_PPC_GOT_TPREL16_HI 2773 ENUMX 2774 BFD_RELOC_PPC_GOT_TPREL16_HA 2775 ENUMX 2776 BFD_RELOC_PPC_GOT_DTPREL16 2777 ENUMX 2778 BFD_RELOC_PPC_GOT_DTPREL16_LO 2779 ENUMX 2780 BFD_RELOC_PPC_GOT_DTPREL16_HI 2781 ENUMX 2782 BFD_RELOC_PPC_GOT_DTPREL16_HA 2783 ENUMX 2784 BFD_RELOC_PPC64_TPREL16_DS 2785 ENUMX 2786 BFD_RELOC_PPC64_TPREL16_LO_DS 2787 ENUMX 2788 BFD_RELOC_PPC64_TPREL16_HIGHER 2789 ENUMX 2790 BFD_RELOC_PPC64_TPREL16_HIGHERA 2791 ENUMX 2792 BFD_RELOC_PPC64_TPREL16_HIGHEST 2793 ENUMX 2794 BFD_RELOC_PPC64_TPREL16_HIGHESTA 2795 ENUMX 2796 BFD_RELOC_PPC64_DTPREL16_DS 2797 ENUMX 2798 BFD_RELOC_PPC64_DTPREL16_LO_DS 2799 ENUMX 2800 BFD_RELOC_PPC64_DTPREL16_HIGHER 2801 ENUMX 2802 BFD_RELOC_PPC64_DTPREL16_HIGHERA 2803 ENUMX 2804 BFD_RELOC_PPC64_DTPREL16_HIGHEST 2805 ENUMX 2806 BFD_RELOC_PPC64_DTPREL16_HIGHESTA 2807 ENUMDOC 2808 PowerPC and PowerPC64 thread-local storage relocations. 2809 2810 ENUM 2811 BFD_RELOC_I370_D12 2812 ENUMDOC 2813 IBM 370/390 relocations 2814 2815 ENUM 2816 BFD_RELOC_CTOR 2817 ENUMDOC 2818 The type of reloc used to build a constructor table - at the moment 2819 probably a 32 bit wide absolute relocation, but the target can choose. 2820 It generally does map to one of the other relocation types. 2821 2822 ENUM 2823 BFD_RELOC_ARM_PCREL_BRANCH 2824 ENUMDOC 2825 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are 2826 not stored in the instruction. 2827 ENUM 2828 BFD_RELOC_ARM_PCREL_BLX 2829 ENUMDOC 2830 ARM 26 bit pc-relative branch. The lowest bit must be zero and is 2831 not stored in the instruction. The 2nd lowest bit comes from a 1 bit 2832 field in the instruction. 2833 ENUM 2834 BFD_RELOC_THUMB_PCREL_BLX 2835 ENUMDOC 2836 Thumb 22 bit pc-relative branch. The lowest bit must be zero and is 2837 not stored in the instruction. The 2nd lowest bit comes from a 1 bit 2838 field in the instruction. 2839 ENUM 2840 BFD_RELOC_ARM_PCREL_CALL 2841 ENUMDOC 2842 ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction. 2843 ENUM 2844 BFD_RELOC_ARM_PCREL_JUMP 2845 ENUMDOC 2846 ARM 26-bit pc-relative branch for B or conditional BL instruction. 2847 2848 ENUM 2849 BFD_RELOC_THUMB_PCREL_BRANCH7 2850 ENUMX 2851 BFD_RELOC_THUMB_PCREL_BRANCH9 2852 ENUMX 2853 BFD_RELOC_THUMB_PCREL_BRANCH12 2854 ENUMX 2855 BFD_RELOC_THUMB_PCREL_BRANCH20 2856 ENUMX 2857 BFD_RELOC_THUMB_PCREL_BRANCH23 2858 ENUMX 2859 BFD_RELOC_THUMB_PCREL_BRANCH25 2860 ENUMDOC 2861 Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches. 2862 The lowest bit must be zero and is not stored in the instruction. 2863 Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an 2864 "nn" one smaller in all cases. Note further that BRANCH23 2865 corresponds to R_ARM_THM_CALL. 2866 2867 ENUM 2868 BFD_RELOC_ARM_OFFSET_IMM 2869 ENUMDOC 2870 12-bit immediate offset, used in ARM-format ldr and str instructions. 2871 2872 ENUM 2873 BFD_RELOC_ARM_THUMB_OFFSET 2874 ENUMDOC 2875 5-bit immediate offset, used in Thumb-format ldr and str instructions. 2876 2877 ENUM 2878 BFD_RELOC_ARM_TARGET1 2879 ENUMDOC 2880 Pc-relative or absolute relocation depending on target. Used for 2881 entries in .init_array sections. 2882 ENUM 2883 BFD_RELOC_ARM_ROSEGREL32 2884 ENUMDOC 2885 Read-only segment base relative address. 2886 ENUM 2887 BFD_RELOC_ARM_SBREL32 2888 ENUMDOC 2889 Data segment base relative address. 2890 ENUM 2891 BFD_RELOC_ARM_TARGET2 2892 ENUMDOC 2893 This reloc is used for references to RTTI data from exception handling 2894 tables. The actual definition depends on the target. It may be a 2895 pc-relative or some form of GOT-indirect relocation. 2896 ENUM 2897 BFD_RELOC_ARM_PREL31 2898 ENUMDOC 2899 31-bit PC relative address. 2900 ENUM 2901 BFD_RELOC_ARM_MOVW 2902 ENUMX 2903 BFD_RELOC_ARM_MOVT 2904 ENUMX 2905 BFD_RELOC_ARM_MOVW_PCREL 2906 ENUMX 2907 BFD_RELOC_ARM_MOVT_PCREL 2908 ENUMX 2909 BFD_RELOC_ARM_THUMB_MOVW 2910 ENUMX 2911 BFD_RELOC_ARM_THUMB_MOVT 2912 ENUMX 2913 BFD_RELOC_ARM_THUMB_MOVW_PCREL 2914 ENUMX 2915 BFD_RELOC_ARM_THUMB_MOVT_PCREL 2916 ENUMDOC 2917 Low and High halfword relocations for MOVW and MOVT instructions. 2918 2919 ENUM 2920 BFD_RELOC_ARM_JUMP_SLOT 2921 ENUMX 2922 BFD_RELOC_ARM_GLOB_DAT 2923 ENUMX 2924 BFD_RELOC_ARM_GOT32 2925 ENUMX 2926 BFD_RELOC_ARM_PLT32 2927 ENUMX 2928 BFD_RELOC_ARM_RELATIVE 2929 ENUMX 2930 BFD_RELOC_ARM_GOTOFF 2931 ENUMX 2932 BFD_RELOC_ARM_GOTPC 2933 ENUMDOC 2934 Relocations for setting up GOTs and PLTs for shared libraries. 2935 2936 ENUM 2937 BFD_RELOC_ARM_TLS_GD32 2938 ENUMX 2939 BFD_RELOC_ARM_TLS_LDO32 2940 ENUMX 2941 BFD_RELOC_ARM_TLS_LDM32 2942 ENUMX 2943 BFD_RELOC_ARM_TLS_DTPOFF32 2944 ENUMX 2945 BFD_RELOC_ARM_TLS_DTPMOD32 2946 ENUMX 2947 BFD_RELOC_ARM_TLS_TPOFF32 2948 ENUMX 2949 BFD_RELOC_ARM_TLS_IE32 2950 ENUMX 2951 BFD_RELOC_ARM_TLS_LE32 2952 ENUMDOC 2953 ARM thread-local storage relocations. 2954 2955 ENUM 2956 BFD_RELOC_ARM_ALU_PC_G0_NC 2957 ENUMX 2958 BFD_RELOC_ARM_ALU_PC_G0 2959 ENUMX 2960 BFD_RELOC_ARM_ALU_PC_G1_NC 2961 ENUMX 2962 BFD_RELOC_ARM_ALU_PC_G1 2963 ENUMX 2964 BFD_RELOC_ARM_ALU_PC_G2 2965 ENUMX 2966 BFD_RELOC_ARM_LDR_PC_G0 2967 ENUMX 2968 BFD_RELOC_ARM_LDR_PC_G1 2969 ENUMX 2970 BFD_RELOC_ARM_LDR_PC_G2 2971 ENUMX 2972 BFD_RELOC_ARM_LDRS_PC_G0 2973 ENUMX 2974 BFD_RELOC_ARM_LDRS_PC_G1 2975 ENUMX 2976 BFD_RELOC_ARM_LDRS_PC_G2 2977 ENUMX 2978 BFD_RELOC_ARM_LDC_PC_G0 2979 ENUMX 2980 BFD_RELOC_ARM_LDC_PC_G1 2981 ENUMX 2982 BFD_RELOC_ARM_LDC_PC_G2 2983 ENUMX 2984 BFD_RELOC_ARM_ALU_SB_G0_NC 2985 ENUMX 2986 BFD_RELOC_ARM_ALU_SB_G0 2987 ENUMX 2988 BFD_RELOC_ARM_ALU_SB_G1_NC 2989 ENUMX 2990 BFD_RELOC_ARM_ALU_SB_G1 2991 ENUMX 2992 BFD_RELOC_ARM_ALU_SB_G2 2993 ENUMX 2994 BFD_RELOC_ARM_LDR_SB_G0 2995 ENUMX 2996 BFD_RELOC_ARM_LDR_SB_G1 2997 ENUMX 2998 BFD_RELOC_ARM_LDR_SB_G2 2999 ENUMX 3000 BFD_RELOC_ARM_LDRS_SB_G0 3001 ENUMX 3002 BFD_RELOC_ARM_LDRS_SB_G1 3003 ENUMX 3004 BFD_RELOC_ARM_LDRS_SB_G2 3005 ENUMX 3006 BFD_RELOC_ARM_LDC_SB_G0 3007 ENUMX 3008 BFD_RELOC_ARM_LDC_SB_G1 3009 ENUMX 3010 BFD_RELOC_ARM_LDC_SB_G2 3011 ENUMDOC 3012 ARM group relocations. 3013 3014 ENUM 3015 BFD_RELOC_ARM_V4BX 3016 ENUMDOC 3017 Annotation of BX instructions. 3018 3019 ENUM 3020 BFD_RELOC_ARM_IMMEDIATE 3021 ENUMX 3022 BFD_RELOC_ARM_ADRL_IMMEDIATE 3023 ENUMX 3024 BFD_RELOC_ARM_T32_IMMEDIATE 3025 ENUMX 3026 BFD_RELOC_ARM_T32_ADD_IMM 3027 ENUMX 3028 BFD_RELOC_ARM_T32_IMM12 3029 ENUMX 3030 BFD_RELOC_ARM_T32_ADD_PC12 3031 ENUMX 3032 BFD_RELOC_ARM_SHIFT_IMM 3033 ENUMX 3034 BFD_RELOC_ARM_SMC 3035 ENUMX 3036 BFD_RELOC_ARM_SWI 3037 ENUMX 3038 BFD_RELOC_ARM_MULTI 3039 ENUMX 3040 BFD_RELOC_ARM_CP_OFF_IMM 3041 ENUMX 3042 BFD_RELOC_ARM_CP_OFF_IMM_S2 3043 ENUMX 3044 BFD_RELOC_ARM_T32_CP_OFF_IMM 3045 ENUMX 3046 BFD_RELOC_ARM_T32_CP_OFF_IMM_S2 3047 ENUMX 3048 BFD_RELOC_ARM_ADR_IMM 3049 ENUMX 3050 BFD_RELOC_ARM_LDR_IMM 3051 ENUMX 3052 BFD_RELOC_ARM_LITERAL 3053 ENUMX 3054 BFD_RELOC_ARM_IN_POOL 3055 ENUMX 3056 BFD_RELOC_ARM_OFFSET_IMM8 3057 ENUMX 3058 BFD_RELOC_ARM_T32_OFFSET_U8 3059 ENUMX 3060 BFD_RELOC_ARM_T32_OFFSET_IMM 3061 ENUMX 3062 BFD_RELOC_ARM_HWLITERAL 3063 ENUMX 3064 BFD_RELOC_ARM_THUMB_ADD 3065 ENUMX 3066 BFD_RELOC_ARM_THUMB_IMM 3067 ENUMX 3068 BFD_RELOC_ARM_THUMB_SHIFT 3069 ENUMDOC 3070 These relocs are only used within the ARM assembler. They are not 3071 (at present) written to any object files. 3072 3073 ENUM 3074 BFD_RELOC_SH_PCDISP8BY2 3075 ENUMX 3076 BFD_RELOC_SH_PCDISP12BY2 3077 ENUMX 3078 BFD_RELOC_SH_IMM3 3079 ENUMX 3080 BFD_RELOC_SH_IMM3U 3081 ENUMX 3082 BFD_RELOC_SH_DISP12 3083 ENUMX 3084 BFD_RELOC_SH_DISP12BY2 3085 ENUMX 3086 BFD_RELOC_SH_DISP12BY4 3087 ENUMX 3088 BFD_RELOC_SH_DISP12BY8 3089 ENUMX 3090 BFD_RELOC_SH_DISP20 3091 ENUMX 3092 BFD_RELOC_SH_DISP20BY8 3093 ENUMX 3094 BFD_RELOC_SH_IMM4 3095 ENUMX 3096 BFD_RELOC_SH_IMM4BY2 3097 ENUMX 3098 BFD_RELOC_SH_IMM4BY4 3099 ENUMX 3100 BFD_RELOC_SH_IMM8 3101 ENUMX 3102 BFD_RELOC_SH_IMM8BY2 3103 ENUMX 3104 BFD_RELOC_SH_IMM8BY4 3105 ENUMX 3106 BFD_RELOC_SH_PCRELIMM8BY2 3107 ENUMX 3108 BFD_RELOC_SH_PCRELIMM8BY4 3109 ENUMX 3110 BFD_RELOC_SH_SWITCH16 3111 ENUMX 3112 BFD_RELOC_SH_SWITCH32 3113 ENUMX 3114 BFD_RELOC_SH_USES 3115 ENUMX 3116 BFD_RELOC_SH_COUNT 3117 ENUMX 3118 BFD_RELOC_SH_ALIGN 3119 ENUMX 3120 BFD_RELOC_SH_CODE 3121 ENUMX 3122 BFD_RELOC_SH_DATA 3123 ENUMX 3124 BFD_RELOC_SH_LABEL 3125 ENUMX 3126 BFD_RELOC_SH_LOOP_START 3127 ENUMX 3128 BFD_RELOC_SH_LOOP_END 3129 ENUMX 3130 BFD_RELOC_SH_COPY 3131 ENUMX 3132 BFD_RELOC_SH_GLOB_DAT 3133 ENUMX 3134 BFD_RELOC_SH_JMP_SLOT 3135 ENUMX 3136 BFD_RELOC_SH_RELATIVE 3137 ENUMX 3138 BFD_RELOC_SH_GOTPC 3139 ENUMX 3140 BFD_RELOC_SH_GOT_LOW16 3141 ENUMX 3142 BFD_RELOC_SH_GOT_MEDLOW16 3143 ENUMX 3144 BFD_RELOC_SH_GOT_MEDHI16 3145 ENUMX 3146 BFD_RELOC_SH_GOT_HI16 3147 ENUMX 3148 BFD_RELOC_SH_GOTPLT_LOW16 3149 ENUMX 3150 BFD_RELOC_SH_GOTPLT_MEDLOW16 3151 ENUMX 3152 BFD_RELOC_SH_GOTPLT_MEDHI16 3153 ENUMX 3154 BFD_RELOC_SH_GOTPLT_HI16 3155 ENUMX 3156 BFD_RELOC_SH_PLT_LOW16 3157 ENUMX 3158 BFD_RELOC_SH_PLT_MEDLOW16 3159 ENUMX 3160 BFD_RELOC_SH_PLT_MEDHI16 3161 ENUMX 3162 BFD_RELOC_SH_PLT_HI16 3163 ENUMX 3164 BFD_RELOC_SH_GOTOFF_LOW16 3165 ENUMX 3166 BFD_RELOC_SH_GOTOFF_MEDLOW16 3167 ENUMX 3168 BFD_RELOC_SH_GOTOFF_MEDHI16 3169 ENUMX 3170 BFD_RELOC_SH_GOTOFF_HI16 3171 ENUMX 3172 BFD_RELOC_SH_GOTPC_LOW16 3173 ENUMX 3174 BFD_RELOC_SH_GOTPC_MEDLOW16 3175 ENUMX 3176 BFD_RELOC_SH_GOTPC_MEDHI16 3177 ENUMX 3178 BFD_RELOC_SH_GOTPC_HI16 3179 ENUMX 3180 BFD_RELOC_SH_COPY64 3181 ENUMX 3182 BFD_RELOC_SH_GLOB_DAT64 3183 ENUMX 3184 BFD_RELOC_SH_JMP_SLOT64 3185 ENUMX 3186 BFD_RELOC_SH_RELATIVE64 3187 ENUMX 3188 BFD_RELOC_SH_GOT10BY4 3189 ENUMX 3190 BFD_RELOC_SH_GOT10BY8 3191 ENUMX 3192 BFD_RELOC_SH_GOTPLT10BY4 3193 ENUMX 3194 BFD_RELOC_SH_GOTPLT10BY8 3195 ENUMX 3196 BFD_RELOC_SH_GOTPLT32 3197 ENUMX 3198 BFD_RELOC_SH_SHMEDIA_CODE 3199 ENUMX 3200 BFD_RELOC_SH_IMMU5 3201 ENUMX 3202 BFD_RELOC_SH_IMMS6 3203 ENUMX 3204 BFD_RELOC_SH_IMMS6BY32 3205 ENUMX 3206 BFD_RELOC_SH_IMMU6 3207 ENUMX 3208 BFD_RELOC_SH_IMMS10 3209 ENUMX 3210 BFD_RELOC_SH_IMMS10BY2 3211 ENUMX 3212 BFD_RELOC_SH_IMMS10BY4 3213 ENUMX 3214 BFD_RELOC_SH_IMMS10BY8 3215 ENUMX 3216 BFD_RELOC_SH_IMMS16 3217 ENUMX 3218 BFD_RELOC_SH_IMMU16 3219 ENUMX 3220 BFD_RELOC_SH_IMM_LOW16 3221 ENUMX 3222 BFD_RELOC_SH_IMM_LOW16_PCREL 3223 ENUMX 3224 BFD_RELOC_SH_IMM_MEDLOW16 3225 ENUMX 3226 BFD_RELOC_SH_IMM_MEDLOW16_PCREL 3227 ENUMX 3228 BFD_RELOC_SH_IMM_MEDHI16 3229 ENUMX 3230 BFD_RELOC_SH_IMM_MEDHI16_PCREL 3231 ENUMX 3232 BFD_RELOC_SH_IMM_HI16 3233 ENUMX 3234 BFD_RELOC_SH_IMM_HI16_PCREL 3235 ENUMX 3236 BFD_RELOC_SH_PT_16 3237 ENUMX 3238 BFD_RELOC_SH_TLS_GD_32 3239 ENUMX 3240 BFD_RELOC_SH_TLS_LD_32 3241 ENUMX 3242 BFD_RELOC_SH_TLS_LDO_32 3243 ENUMX 3244 BFD_RELOC_SH_TLS_IE_32 3245 ENUMX 3246 BFD_RELOC_SH_TLS_LE_32 3247 ENUMX 3248 BFD_RELOC_SH_TLS_DTPMOD32 3249 ENUMX 3250 BFD_RELOC_SH_TLS_DTPOFF32 3251 ENUMX 3252 BFD_RELOC_SH_TLS_TPOFF32 3253 ENUMDOC 3254 Renesas / SuperH SH relocs. Not all of these appear in object files. 3255 3256 ENUM 3257 BFD_RELOC_ARC_B22_PCREL 3258 ENUMDOC 3259 ARC Cores relocs. 3260 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are 3261 not stored in the instruction. The high 20 bits are installed in bits 26 3262 through 7 of the instruction. 3263 ENUM 3264 BFD_RELOC_ARC_B26 3265 ENUMDOC 3266 ARC 26 bit absolute branch. The lowest two bits must be zero and are not 3267 stored in the instruction. The high 24 bits are installed in bits 23 3268 through 0. 3269 3270 ENUM 3271 BFD_RELOC_BFIN_16_IMM 3272 ENUMDOC 3273 ADI Blackfin 16 bit immediate absolute reloc. 3274 ENUM 3275 BFD_RELOC_BFIN_16_HIGH 3276 ENUMDOC 3277 ADI Blackfin 16 bit immediate absolute reloc higher 16 bits. 3278 ENUM 3279 BFD_RELOC_BFIN_4_PCREL 3280 ENUMDOC 3281 ADI Blackfin 'a' part of LSETUP. 3282 ENUM 3283 BFD_RELOC_BFIN_5_PCREL 3284 ENUMDOC 3285 ADI Blackfin. 3286 ENUM 3287 BFD_RELOC_BFIN_16_LOW 3288 ENUMDOC 3289 ADI Blackfin 16 bit immediate absolute reloc lower 16 bits. 3290 ENUM 3291 BFD_RELOC_BFIN_10_PCREL 3292 ENUMDOC 3293 ADI Blackfin. 3294 ENUM 3295 BFD_RELOC_BFIN_11_PCREL 3296 ENUMDOC 3297 ADI Blackfin 'b' part of LSETUP. 3298 ENUM 3299 BFD_RELOC_BFIN_12_PCREL_JUMP 3300 ENUMDOC 3301 ADI Blackfin. 3302 ENUM 3303 BFD_RELOC_BFIN_12_PCREL_JUMP_S 3304 ENUMDOC 3305 ADI Blackfin Short jump, pcrel. 3306 ENUM 3307 BFD_RELOC_BFIN_24_PCREL_CALL_X 3308 ENUMDOC 3309 ADI Blackfin Call.x not implemented. 3310 ENUM 3311 BFD_RELOC_BFIN_24_PCREL_JUMP_L 3312 ENUMDOC 3313 ADI Blackfin Long Jump pcrel. 3314 ENUM 3315 BFD_RELOC_BFIN_GOT17M4 3316 ENUMX 3317 BFD_RELOC_BFIN_GOTHI 3318 ENUMX 3319 BFD_RELOC_BFIN_GOTLO 3320 ENUMX 3321 BFD_RELOC_BFIN_FUNCDESC 3322 ENUMX 3323 BFD_RELOC_BFIN_FUNCDESC_GOT17M4 3324 ENUMX 3325 BFD_RELOC_BFIN_FUNCDESC_GOTHI 3326 ENUMX 3327 BFD_RELOC_BFIN_FUNCDESC_GOTLO 3328 ENUMX 3329 BFD_RELOC_BFIN_FUNCDESC_VALUE 3330 ENUMX 3331 BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4 3332 ENUMX 3333 BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI 3334 ENUMX 3335 BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO 3336 ENUMX 3337 BFD_RELOC_BFIN_GOTOFF17M4 3338 ENUMX 3339 BFD_RELOC_BFIN_GOTOFFHI 3340 ENUMX 3341 BFD_RELOC_BFIN_GOTOFFLO 3342 ENUMDOC 3343 ADI Blackfin FD-PIC relocations. 3344 ENUM 3345 BFD_RELOC_BFIN_GOT 3346 ENUMDOC 3347 ADI Blackfin GOT relocation. 3348 ENUM 3349 BFD_RELOC_BFIN_PLTPC 3350 ENUMDOC 3351 ADI Blackfin PLTPC relocation. 3352 ENUM 3353 BFD_ARELOC_BFIN_PUSH 3354 ENUMDOC 3355 ADI Blackfin arithmetic relocation. 3356 ENUM 3357 BFD_ARELOC_BFIN_CONST 3358 ENUMDOC 3359 ADI Blackfin arithmetic relocation. 3360 ENUM 3361 BFD_ARELOC_BFIN_ADD 3362 ENUMDOC 3363 ADI Blackfin arithmetic relocation. 3364 ENUM 3365 BFD_ARELOC_BFIN_SUB 3366 ENUMDOC 3367 ADI Blackfin arithmetic relocation. 3368 ENUM 3369 BFD_ARELOC_BFIN_MULT 3370 ENUMDOC 3371 ADI Blackfin arithmetic relocation. 3372 ENUM 3373 BFD_ARELOC_BFIN_DIV 3374 ENUMDOC 3375 ADI Blackfin arithmetic relocation. 3376 ENUM 3377 BFD_ARELOC_BFIN_MOD 3378 ENUMDOC 3379 ADI Blackfin arithmetic relocation. 3380 ENUM 3381 BFD_ARELOC_BFIN_LSHIFT 3382 ENUMDOC 3383 ADI Blackfin arithmetic relocation. 3384 ENUM 3385 BFD_ARELOC_BFIN_RSHIFT 3386 ENUMDOC 3387 ADI Blackfin arithmetic relocation. 3388 ENUM 3389 BFD_ARELOC_BFIN_AND 3390 ENUMDOC 3391 ADI Blackfin arithmetic relocation. 3392 ENUM 3393 BFD_ARELOC_BFIN_OR 3394 ENUMDOC 3395 ADI Blackfin arithmetic relocation. 3396 ENUM 3397 BFD_ARELOC_BFIN_XOR 3398 ENUMDOC 3399 ADI Blackfin arithmetic relocation. 3400 ENUM 3401 BFD_ARELOC_BFIN_LAND 3402 ENUMDOC 3403 ADI Blackfin arithmetic relocation. 3404 ENUM 3405 BFD_ARELOC_BFIN_LOR 3406 ENUMDOC 3407 ADI Blackfin arithmetic relocation. 3408 ENUM 3409 BFD_ARELOC_BFIN_LEN 3410 ENUMDOC 3411 ADI Blackfin arithmetic relocation. 3412 ENUM 3413 BFD_ARELOC_BFIN_NEG 3414 ENUMDOC 3415 ADI Blackfin arithmetic relocation. 3416 ENUM 3417 BFD_ARELOC_BFIN_COMP 3418 ENUMDOC 3419 ADI Blackfin arithmetic relocation. 3420 ENUM 3421 BFD_ARELOC_BFIN_PAGE 3422 ENUMDOC 3423 ADI Blackfin arithmetic relocation. 3424 ENUM 3425 BFD_ARELOC_BFIN_HWPAGE 3426 ENUMDOC 3427 ADI Blackfin arithmetic relocation. 3428 ENUM 3429 BFD_ARELOC_BFIN_ADDR 3430 ENUMDOC 3431 ADI Blackfin arithmetic relocation. 3432 3433 ENUM 3434 BFD_RELOC_D10V_10_PCREL_R 3435 ENUMDOC 3436 Mitsubishi D10V relocs. 3437 This is a 10-bit reloc with the right 2 bits 3438 assumed to be 0. 3439 ENUM 3440 BFD_RELOC_D10V_10_PCREL_L 3441 ENUMDOC 3442 Mitsubishi D10V relocs. 3443 This is a 10-bit reloc with the right 2 bits 3444 assumed to be 0. This is the same as the previous reloc 3445 except it is in the left container, i.e., 3446 shifted left 15 bits. 3447 ENUM 3448 BFD_RELOC_D10V_18 3449 ENUMDOC 3450 This is an 18-bit reloc with the right 2 bits 3451 assumed to be 0. 3452 ENUM 3453 BFD_RELOC_D10V_18_PCREL 3454 ENUMDOC 3455 This is an 18-bit reloc with the right 2 bits 3456 assumed to be 0. 3457 3458 ENUM 3459 BFD_RELOC_D30V_6 3460 ENUMDOC 3461 Mitsubishi D30V relocs. 3462 This is a 6-bit absolute reloc. 3463 ENUM 3464 BFD_RELOC_D30V_9_PCREL 3465 ENUMDOC 3466 This is a 6-bit pc-relative reloc with 3467 the right 3 bits assumed to be 0. 3468 ENUM 3469 BFD_RELOC_D30V_9_PCREL_R 3470 ENUMDOC 3471 This is a 6-bit pc-relative reloc with 3472 the right 3 bits assumed to be 0. Same 3473 as the previous reloc but on the right side 3474 of the container. 3475 ENUM 3476 BFD_RELOC_D30V_15 3477 ENUMDOC 3478 This is a 12-bit absolute reloc with the 3479 right 3 bitsassumed to be 0. 3480 ENUM 3481 BFD_RELOC_D30V_15_PCREL 3482 ENUMDOC 3483 This is a 12-bit pc-relative reloc with 3484 the right 3 bits assumed to be 0. 3485 ENUM 3486 BFD_RELOC_D30V_15_PCREL_R 3487 ENUMDOC 3488 This is a 12-bit pc-relative reloc with 3489 the right 3 bits assumed to be 0. Same 3490 as the previous reloc but on the right side 3491 of the container. 3492 ENUM 3493 BFD_RELOC_D30V_21 3494 ENUMDOC 3495 This is an 18-bit absolute reloc with 3496 the right 3 bits assumed to be 0. 3497 ENUM 3498 BFD_RELOC_D30V_21_PCREL 3499 ENUMDOC 3500 This is an 18-bit pc-relative reloc with 3501 the right 3 bits assumed to be 0. 3502 ENUM 3503 BFD_RELOC_D30V_21_PCREL_R 3504 ENUMDOC 3505 This is an 18-bit pc-relative reloc with 3506 the right 3 bits assumed to be 0. Same 3507 as the previous reloc but on the right side 3508 of the container. 3509 ENUM 3510 BFD_RELOC_D30V_32 3511 ENUMDOC 3512 This is a 32-bit absolute reloc. 3513 ENUM 3514 BFD_RELOC_D30V_32_PCREL 3515 ENUMDOC 3516 This is a 32-bit pc-relative reloc. 3517 3518 ENUM 3519 BFD_RELOC_DLX_HI16_S 3520 ENUMDOC 3521 DLX relocs 3522 ENUM 3523 BFD_RELOC_DLX_LO16 3524 ENUMDOC 3525 DLX relocs 3526 ENUM 3527 BFD_RELOC_DLX_JMP26 3528 ENUMDOC 3529 DLX relocs 3530 3531 ENUM 3532 BFD_RELOC_M32C_HI8 3533 ENUMX 3534 BFD_RELOC_M32C_RL_JUMP 3535 ENUMX 3536 BFD_RELOC_M32C_RL_1ADDR 3537 ENUMX 3538 BFD_RELOC_M32C_RL_2ADDR 3539 ENUMDOC 3540 Renesas M16C/M32C Relocations. 3541 3542 ENUM 3543 BFD_RELOC_M32R_24 3544 ENUMDOC 3545 Renesas M32R (formerly Mitsubishi M32R) relocs. 3546 This is a 24 bit absolute address. 3547 ENUM 3548 BFD_RELOC_M32R_10_PCREL 3549 ENUMDOC 3550 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. 3551 ENUM 3552 BFD_RELOC_M32R_18_PCREL 3553 ENUMDOC 3554 This is an 18-bit reloc with the right 2 bits assumed to be 0. 3555 ENUM 3556 BFD_RELOC_M32R_26_PCREL 3557 ENUMDOC 3558 This is a 26-bit reloc with the right 2 bits assumed to be 0. 3559 ENUM 3560 BFD_RELOC_M32R_HI16_ULO 3561 ENUMDOC 3562 This is a 16-bit reloc containing the high 16 bits of an address 3563 used when the lower 16 bits are treated as unsigned. 3564 ENUM 3565 BFD_RELOC_M32R_HI16_SLO 3566 ENUMDOC 3567 This is a 16-bit reloc containing the high 16 bits of an address 3568 used when the lower 16 bits are treated as signed. 3569 ENUM 3570 BFD_RELOC_M32R_LO16 3571 ENUMDOC 3572 This is a 16-bit reloc containing the lower 16 bits of an address. 3573 ENUM 3574 BFD_RELOC_M32R_SDA16 3575 ENUMDOC 3576 This is a 16-bit reloc containing the small data area offset for use in 3577 add3, load, and store instructions. 3578 ENUM 3579 BFD_RELOC_M32R_GOT24 3580 ENUMX 3581 BFD_RELOC_M32R_26_PLTREL 3582 ENUMX 3583 BFD_RELOC_M32R_COPY 3584 ENUMX 3585 BFD_RELOC_M32R_GLOB_DAT 3586 ENUMX 3587 BFD_RELOC_M32R_JMP_SLOT 3588 ENUMX 3589 BFD_RELOC_M32R_RELATIVE 3590 ENUMX 3591 BFD_RELOC_M32R_GOTOFF 3592 ENUMX 3593 BFD_RELOC_M32R_GOTOFF_HI_ULO 3594 ENUMX 3595 BFD_RELOC_M32R_GOTOFF_HI_SLO 3596 ENUMX 3597 BFD_RELOC_M32R_GOTOFF_LO 3598 ENUMX 3599 BFD_RELOC_M32R_GOTPC24 3600 ENUMX 3601 BFD_RELOC_M32R_GOT16_HI_ULO 3602 ENUMX 3603 BFD_RELOC_M32R_GOT16_HI_SLO 3604 ENUMX 3605 BFD_RELOC_M32R_GOT16_LO 3606 ENUMX 3607 BFD_RELOC_M32R_GOTPC_HI_ULO 3608 ENUMX 3609 BFD_RELOC_M32R_GOTPC_HI_SLO 3610 ENUMX 3611 BFD_RELOC_M32R_GOTPC_LO 3612 ENUMDOC 3613 For PIC. 3614 3615 3616 ENUM 3617 BFD_RELOC_V850_9_PCREL 3618 ENUMDOC 3619 This is a 9-bit reloc 3620 ENUM 3621 BFD_RELOC_V850_22_PCREL 3622 ENUMDOC 3623 This is a 22-bit reloc 3624 3625 ENUM 3626 BFD_RELOC_V850_SDA_16_16_OFFSET 3627 ENUMDOC 3628 This is a 16 bit offset from the short data area pointer. 3629 ENUM 3630 BFD_RELOC_V850_SDA_15_16_OFFSET 3631 ENUMDOC 3632 This is a 16 bit offset (of which only 15 bits are used) from the 3633 short data area pointer. 3634 ENUM 3635 BFD_RELOC_V850_ZDA_16_16_OFFSET 3636 ENUMDOC 3637 This is a 16 bit offset from the zero data area pointer. 3638 ENUM 3639 BFD_RELOC_V850_ZDA_15_16_OFFSET 3640 ENUMDOC 3641 This is a 16 bit offset (of which only 15 bits are used) from the 3642 zero data area pointer. 3643 ENUM 3644 BFD_RELOC_V850_TDA_6_8_OFFSET 3645 ENUMDOC 3646 This is an 8 bit offset (of which only 6 bits are used) from the 3647 tiny data area pointer. 3648 ENUM 3649 BFD_RELOC_V850_TDA_7_8_OFFSET 3650 ENUMDOC 3651 This is an 8bit offset (of which only 7 bits are used) from the tiny 3652 data area pointer. 3653 ENUM 3654 BFD_RELOC_V850_TDA_7_7_OFFSET 3655 ENUMDOC 3656 This is a 7 bit offset from the tiny data area pointer. 3657 ENUM 3658 BFD_RELOC_V850_TDA_16_16_OFFSET 3659 ENUMDOC 3660 This is a 16 bit offset from the tiny data area pointer. 3661 COMMENT 3662 ENUM 3663 BFD_RELOC_V850_TDA_4_5_OFFSET 3664 ENUMDOC 3665 This is a 5 bit offset (of which only 4 bits are used) from the tiny 3666 data area pointer. 3667 ENUM 3668 BFD_RELOC_V850_TDA_4_4_OFFSET 3669 ENUMDOC 3670 This is a 4 bit offset from the tiny data area pointer. 3671 ENUM 3672 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET 3673 ENUMDOC 3674 This is a 16 bit offset from the short data area pointer, with the 3675 bits placed non-contiguously in the instruction. 3676 ENUM 3677 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET 3678 ENUMDOC 3679 This is a 16 bit offset from the zero data area pointer, with the 3680 bits placed non-contiguously in the instruction. 3681 ENUM 3682 BFD_RELOC_V850_CALLT_6_7_OFFSET 3683 ENUMDOC 3684 This is a 6 bit offset from the call table base pointer. 3685 ENUM 3686 BFD_RELOC_V850_CALLT_16_16_OFFSET 3687 ENUMDOC 3688 This is a 16 bit offset from the call table base pointer. 3689 ENUM 3690 BFD_RELOC_V850_LONGCALL 3691 ENUMDOC 3692 Used for relaxing indirect function calls. 3693 ENUM 3694 BFD_RELOC_V850_LONGJUMP 3695 ENUMDOC 3696 Used for relaxing indirect jumps. 3697 ENUM 3698 BFD_RELOC_V850_ALIGN 3699 ENUMDOC 3700 Used to maintain alignment whilst relaxing. 3701 ENUM 3702 BFD_RELOC_V850_LO16_SPLIT_OFFSET 3703 ENUMDOC 3704 This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu 3705 instructions. 3706 ENUM 3707 BFD_RELOC_MN10300_32_PCREL 3708 ENUMDOC 3709 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the 3710 instruction. 3711 ENUM 3712 BFD_RELOC_MN10300_16_PCREL 3713 ENUMDOC 3714 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the 3715 instruction. 3716 3717 ENUM 3718 BFD_RELOC_TIC30_LDP 3719 ENUMDOC 3720 This is a 8bit DP reloc for the tms320c30, where the most 3721 significant 8 bits of a 24 bit word are placed into the least 3722 significant 8 bits of the opcode. 3723 3724 ENUM 3725 BFD_RELOC_TIC54X_PARTLS7 3726 ENUMDOC 3727 This is a 7bit reloc for the tms320c54x, where the least 3728 significant 7 bits of a 16 bit word are placed into the least 3729 significant 7 bits of the opcode. 3730 3731 ENUM 3732 BFD_RELOC_TIC54X_PARTMS9 3733 ENUMDOC 3734 This is a 9bit DP reloc for the tms320c54x, where the most 3735 significant 9 bits of a 16 bit word are placed into the least 3736 significant 9 bits of the opcode. 3737 3738 ENUM 3739 BFD_RELOC_TIC54X_23 3740 ENUMDOC 3741 This is an extended address 23-bit reloc for the tms320c54x. 3742 3743 ENUM 3744 BFD_RELOC_TIC54X_16_OF_23 3745 ENUMDOC 3746 This is a 16-bit reloc for the tms320c54x, where the least 3747 significant 16 bits of a 23-bit extended address are placed into 3748 the opcode. 3749 3750 ENUM 3751 BFD_RELOC_TIC54X_MS7_OF_23 3752 ENUMDOC 3753 This is a reloc for the tms320c54x, where the most 3754 significant 7 bits of a 23-bit extended address are placed into 3755 the opcode. 3756 3757 ENUM 3758 BFD_RELOC_FR30_48 3759 ENUMDOC 3760 This is a 48 bit reloc for the FR30 that stores 32 bits. 3761 ENUM 3762 BFD_RELOC_FR30_20 3763 ENUMDOC 3764 This is a 32 bit reloc for the FR30 that stores 20 bits split up into 3765 two sections. 3766 ENUM 3767 BFD_RELOC_FR30_6_IN_4 3768 ENUMDOC 3769 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in 3770 4 bits. 3771 ENUM 3772 BFD_RELOC_FR30_8_IN_8 3773 ENUMDOC 3774 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset 3775 into 8 bits. 3776 ENUM 3777 BFD_RELOC_FR30_9_IN_8 3778 ENUMDOC 3779 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset 3780 into 8 bits. 3781 ENUM 3782 BFD_RELOC_FR30_10_IN_8 3783 ENUMDOC 3784 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset 3785 into 8 bits. 3786 ENUM 3787 BFD_RELOC_FR30_9_PCREL 3788 ENUMDOC 3789 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative 3790 short offset into 8 bits. 3791 ENUM 3792 BFD_RELOC_FR30_12_PCREL 3793 ENUMDOC 3794 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative 3795 short offset into 11 bits. 3796 3797 ENUM 3798 BFD_RELOC_MCORE_PCREL_IMM8BY4 3799 ENUMX 3800 BFD_RELOC_MCORE_PCREL_IMM11BY2 3801 ENUMX 3802 BFD_RELOC_MCORE_PCREL_IMM4BY2 3803 ENUMX 3804 BFD_RELOC_MCORE_PCREL_32 3805 ENUMX 3806 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2 3807 ENUMX 3808 BFD_RELOC_MCORE_RVA 3809 ENUMDOC 3810 Motorola Mcore relocations. 3811 3812 ENUM 3813 BFD_RELOC_MEP_8 3814 ENUMX 3815 BFD_RELOC_MEP_16 3816 ENUMX 3817 BFD_RELOC_MEP_32 3818 ENUMX 3819 BFD_RELOC_MEP_PCREL8A2 3820 ENUMX 3821 BFD_RELOC_MEP_PCREL12A2 3822 ENUMX 3823 BFD_RELOC_MEP_PCREL17A2 3824 ENUMX 3825 BFD_RELOC_MEP_PCREL24A2 3826 ENUMX 3827 BFD_RELOC_MEP_PCABS24A2 3828 ENUMX 3829 BFD_RELOC_MEP_LOW16 3830 ENUMX 3831 BFD_RELOC_MEP_HI16U 3832 ENUMX 3833 BFD_RELOC_MEP_HI16S 3834 ENUMX 3835 BFD_RELOC_MEP_GPREL 3836 ENUMX 3837 BFD_RELOC_MEP_TPREL 3838 ENUMX 3839 BFD_RELOC_MEP_TPREL7 3840 ENUMX 3841 BFD_RELOC_MEP_TPREL7A2 3842 ENUMX 3843 BFD_RELOC_MEP_TPREL7A4 3844 ENUMX 3845 BFD_RELOC_MEP_UIMM24 3846 ENUMX 3847 BFD_RELOC_MEP_ADDR24A4 3848 ENUMX 3849 BFD_RELOC_MEP_GNU_VTINHERIT 3850 ENUMX 3851 BFD_RELOC_MEP_GNU_VTENTRY 3852 ENUMDOC 3853 Toshiba Media Processor Relocations. 3854 COMMENT 3855 3856 ENUM 3857 BFD_RELOC_MMIX_GETA 3858 ENUMX 3859 BFD_RELOC_MMIX_GETA_1 3860 ENUMX 3861 BFD_RELOC_MMIX_GETA_2 3862 ENUMX 3863 BFD_RELOC_MMIX_GETA_3 3864 ENUMDOC 3865 These are relocations for the GETA instruction. 3866 ENUM 3867 BFD_RELOC_MMIX_CBRANCH 3868 ENUMX 3869 BFD_RELOC_MMIX_CBRANCH_J 3870 ENUMX 3871 BFD_RELOC_MMIX_CBRANCH_1 3872 ENUMX 3873 BFD_RELOC_MMIX_CBRANCH_2 3874 ENUMX 3875 BFD_RELOC_MMIX_CBRANCH_3 3876 ENUMDOC 3877 These are relocations for a conditional branch instruction. 3878 ENUM 3879 BFD_RELOC_MMIX_PUSHJ 3880 ENUMX 3881 BFD_RELOC_MMIX_PUSHJ_1 3882 ENUMX 3883 BFD_RELOC_MMIX_PUSHJ_2 3884 ENUMX 3885 BFD_RELOC_MMIX_PUSHJ_3 3886 ENUMX 3887 BFD_RELOC_MMIX_PUSHJ_STUBBABLE 3888 ENUMDOC 3889 These are relocations for the PUSHJ instruction. 3890 ENUM 3891 BFD_RELOC_MMIX_JMP 3892 ENUMX 3893 BFD_RELOC_MMIX_JMP_1 3894 ENUMX 3895 BFD_RELOC_MMIX_JMP_2 3896 ENUMX 3897 BFD_RELOC_MMIX_JMP_3 3898 ENUMDOC 3899 These are relocations for the JMP instruction. 3900 ENUM 3901 BFD_RELOC_MMIX_ADDR19 3902 ENUMDOC 3903 This is a relocation for a relative address as in a GETA instruction or 3904 a branch. 3905 ENUM 3906 BFD_RELOC_MMIX_ADDR27 3907 ENUMDOC 3908 This is a relocation for a relative address as in a JMP instruction. 3909 ENUM 3910 BFD_RELOC_MMIX_REG_OR_BYTE 3911 ENUMDOC 3912 This is a relocation for an instruction field that may be a general 3913 register or a value 0..255. 3914 ENUM 3915 BFD_RELOC_MMIX_REG 3916 ENUMDOC 3917 This is a relocation for an instruction field that may be a general 3918 register. 3919 ENUM 3920 BFD_RELOC_MMIX_BASE_PLUS_OFFSET 3921 ENUMDOC 3922 This is a relocation for two instruction fields holding a register and 3923 an offset, the equivalent of the relocation. 3924 ENUM 3925 BFD_RELOC_MMIX_LOCAL 3926 ENUMDOC 3927 This relocation is an assertion that the expression is not allocated as 3928 a global register. It does not modify contents. 3929 3930 ENUM 3931 BFD_RELOC_AVR_7_PCREL 3932 ENUMDOC 3933 This is a 16 bit reloc for the AVR that stores 8 bit pc relative 3934 short offset into 7 bits. 3935 ENUM 3936 BFD_RELOC_AVR_13_PCREL 3937 ENUMDOC 3938 This is a 16 bit reloc for the AVR that stores 13 bit pc relative 3939 short offset into 12 bits. 3940 ENUM 3941 BFD_RELOC_AVR_16_PM 3942 ENUMDOC 3943 This is a 16 bit reloc for the AVR that stores 17 bit value (usually 3944 program memory address) into 16 bits. 3945 ENUM 3946 BFD_RELOC_AVR_LO8_LDI 3947 ENUMDOC 3948 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 3949 data memory address) into 8 bit immediate value of LDI insn. 3950 ENUM 3951 BFD_RELOC_AVR_HI8_LDI 3952 ENUMDOC 3953 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 3954 of data memory address) into 8 bit immediate value of LDI insn. 3955 ENUM 3956 BFD_RELOC_AVR_HH8_LDI 3957 ENUMDOC 3958 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 3959 of program memory address) into 8 bit immediate value of LDI insn. 3960 ENUM 3961 BFD_RELOC_AVR_MS8_LDI 3962 ENUMDOC 3963 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 3964 of 32 bit value) into 8 bit immediate value of LDI insn. 3965 ENUM 3966 BFD_RELOC_AVR_LO8_LDI_NEG 3967 ENUMDOC 3968 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3969 (usually data memory address) into 8 bit immediate value of SUBI insn. 3970 ENUM 3971 BFD_RELOC_AVR_HI8_LDI_NEG 3972 ENUMDOC 3973 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3974 (high 8 bit of data memory address) into 8 bit immediate value of 3975 SUBI insn. 3976 ENUM 3977 BFD_RELOC_AVR_HH8_LDI_NEG 3978 ENUMDOC 3979 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3980 (most high 8 bit of program memory address) into 8 bit immediate value 3981 of LDI or SUBI insn. 3982 ENUM 3983 BFD_RELOC_AVR_MS8_LDI_NEG 3984 ENUMDOC 3985 This is a 16 bit reloc for the AVR that stores negated 8 bit value (msb 3986 of 32 bit value) into 8 bit immediate value of LDI insn. 3987 ENUM 3988 BFD_RELOC_AVR_LO8_LDI_PM 3989 ENUMDOC 3990 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 3991 command address) into 8 bit immediate value of LDI insn. 3992 ENUM 3993 BFD_RELOC_AVR_LO8_LDI_GS 3994 ENUMDOC 3995 This is a 16 bit reloc for the AVR that stores 8 bit value 3996 (command address) into 8 bit immediate value of LDI insn. If the address 3997 is beyond the 128k boundary, the linker inserts a jump stub for this reloc 3998 in the lower 128k. 3999 ENUM 4000 BFD_RELOC_AVR_HI8_LDI_PM 4001 ENUMDOC 4002 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 4003 of command address) into 8 bit immediate value of LDI insn. 4004 ENUM 4005 BFD_RELOC_AVR_HI8_LDI_GS 4006 ENUMDOC 4007 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 4008 of command address) into 8 bit immediate value of LDI insn. If the address 4009 is beyond the 128k boundary, the linker inserts a jump stub for this reloc 4010 below 128k. 4011 ENUM 4012 BFD_RELOC_AVR_HH8_LDI_PM 4013 ENUMDOC 4014 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 4015 of command address) into 8 bit immediate value of LDI insn. 4016 ENUM 4017 BFD_RELOC_AVR_LO8_LDI_PM_NEG 4018 ENUMDOC 4019 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4020 (usually command address) into 8 bit immediate value of SUBI insn. 4021 ENUM 4022 BFD_RELOC_AVR_HI8_LDI_PM_NEG 4023 ENUMDOC 4024 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4025 (high 8 bit of 16 bit command address) into 8 bit immediate value 4026 of SUBI insn. 4027 ENUM 4028 BFD_RELOC_AVR_HH8_LDI_PM_NEG 4029 ENUMDOC 4030 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4031 (high 6 bit of 22 bit command address) into 8 bit immediate 4032 value of SUBI insn. 4033 ENUM 4034 BFD_RELOC_AVR_CALL 4035 ENUMDOC 4036 This is a 32 bit reloc for the AVR that stores 23 bit value 4037 into 22 bits. 4038 ENUM 4039 BFD_RELOC_AVR_LDI 4040 ENUMDOC 4041 This is a 16 bit reloc for the AVR that stores all needed bits 4042 for absolute addressing with ldi with overflow check to linktime 4043 ENUM 4044 BFD_RELOC_AVR_6 4045 ENUMDOC 4046 This is a 6 bit reloc for the AVR that stores offset for ldd/std 4047 instructions 4048 ENUM 4049 BFD_RELOC_AVR_6_ADIW 4050 ENUMDOC 4051 This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw 4052 instructions 4053 4054 ENUM 4055 BFD_RELOC_390_12 4056 ENUMDOC 4057 Direct 12 bit. 4058 ENUM 4059 BFD_RELOC_390_GOT12 4060 ENUMDOC 4061 12 bit GOT offset. 4062 ENUM 4063 BFD_RELOC_390_PLT32 4064 ENUMDOC 4065 32 bit PC relative PLT address. 4066 ENUM 4067 BFD_RELOC_390_COPY 4068 ENUMDOC 4069 Copy symbol at runtime. 4070 ENUM 4071 BFD_RELOC_390_GLOB_DAT 4072 ENUMDOC 4073 Create GOT entry. 4074 ENUM 4075 BFD_RELOC_390_JMP_SLOT 4076 ENUMDOC 4077 Create PLT entry. 4078 ENUM 4079 BFD_RELOC_390_RELATIVE 4080 ENUMDOC 4081 Adjust by program base. 4082 ENUM 4083 BFD_RELOC_390_GOTPC 4084 ENUMDOC 4085 32 bit PC relative offset to GOT. 4086 ENUM 4087 BFD_RELOC_390_GOT16 4088 ENUMDOC 4089 16 bit GOT offset. 4090 ENUM 4091 BFD_RELOC_390_PC16DBL 4092 ENUMDOC 4093 PC relative 16 bit shifted by 1. 4094 ENUM 4095 BFD_RELOC_390_PLT16DBL 4096 ENUMDOC 4097 16 bit PC rel. PLT shifted by 1. 4098 ENUM 4099 BFD_RELOC_390_PC32DBL 4100 ENUMDOC 4101 PC relative 32 bit shifted by 1. 4102 ENUM 4103 BFD_RELOC_390_PLT32DBL 4104 ENUMDOC 4105 32 bit PC rel. PLT shifted by 1. 4106 ENUM 4107 BFD_RELOC_390_GOTPCDBL 4108 ENUMDOC 4109 32 bit PC rel. GOT shifted by 1. 4110 ENUM 4111 BFD_RELOC_390_GOT64 4112 ENUMDOC 4113 64 bit GOT offset. 4114 ENUM 4115 BFD_RELOC_390_PLT64 4116 ENUMDOC 4117 64 bit PC relative PLT address. 4118 ENUM 4119 BFD_RELOC_390_GOTENT 4120 ENUMDOC 4121 32 bit rel. offset to GOT entry. 4122 ENUM 4123 BFD_RELOC_390_GOTOFF64 4124 ENUMDOC 4125 64 bit offset to GOT. 4126 ENUM 4127 BFD_RELOC_390_GOTPLT12 4128 ENUMDOC 4129 12-bit offset to symbol-entry within GOT, with PLT handling. 4130 ENUM 4131 BFD_RELOC_390_GOTPLT16 4132 ENUMDOC 4133 16-bit offset to symbol-entry within GOT, with PLT handling. 4134 ENUM 4135 BFD_RELOC_390_GOTPLT32 4136 ENUMDOC 4137 32-bit offset to symbol-entry within GOT, with PLT handling. 4138 ENUM 4139 BFD_RELOC_390_GOTPLT64 4140 ENUMDOC 4141 64-bit offset to symbol-entry within GOT, with PLT handling. 4142 ENUM 4143 BFD_RELOC_390_GOTPLTENT 4144 ENUMDOC 4145 32-bit rel. offset to symbol-entry within GOT, with PLT handling. 4146 ENUM 4147 BFD_RELOC_390_PLTOFF16 4148 ENUMDOC 4149 16-bit rel. offset from the GOT to a PLT entry. 4150 ENUM 4151 BFD_RELOC_390_PLTOFF32 4152 ENUMDOC 4153 32-bit rel. offset from the GOT to a PLT entry. 4154 ENUM 4155 BFD_RELOC_390_PLTOFF64 4156 ENUMDOC 4157 64-bit rel. offset from the GOT to a PLT entry. 4158 4159 ENUM 4160 BFD_RELOC_390_TLS_LOAD 4161 ENUMX 4162 BFD_RELOC_390_TLS_GDCALL 4163 ENUMX 4164 BFD_RELOC_390_TLS_LDCALL 4165 ENUMX 4166 BFD_RELOC_390_TLS_GD32 4167 ENUMX 4168 BFD_RELOC_390_TLS_GD64 4169 ENUMX 4170 BFD_RELOC_390_TLS_GOTIE12 4171 ENUMX 4172 BFD_RELOC_390_TLS_GOTIE32 4173 ENUMX 4174 BFD_RELOC_390_TLS_GOTIE64 4175 ENUMX 4176 BFD_RELOC_390_TLS_LDM32 4177 ENUMX 4178 BFD_RELOC_390_TLS_LDM64 4179 ENUMX 4180 BFD_RELOC_390_TLS_IE32 4181 ENUMX 4182 BFD_RELOC_390_TLS_IE64 4183 ENUMX 4184 BFD_RELOC_390_TLS_IEENT 4185 ENUMX 4186 BFD_RELOC_390_TLS_LE32 4187 ENUMX 4188 BFD_RELOC_390_TLS_LE64 4189 ENUMX 4190 BFD_RELOC_390_TLS_LDO32 4191 ENUMX 4192 BFD_RELOC_390_TLS_LDO64 4193 ENUMX 4194 BFD_RELOC_390_TLS_DTPMOD 4195 ENUMX 4196 BFD_RELOC_390_TLS_DTPOFF 4197 ENUMX 4198 BFD_RELOC_390_TLS_TPOFF 4199 ENUMDOC 4200 s390 tls relocations. 4201 4202 ENUM 4203 BFD_RELOC_390_20 4204 ENUMX 4205 BFD_RELOC_390_GOT20 4206 ENUMX 4207 BFD_RELOC_390_GOTPLT20 4208 ENUMX 4209 BFD_RELOC_390_TLS_GOTIE20 4210 ENUMDOC 4211 Long displacement extension. 4212 4213 ENUM 4214 BFD_RELOC_SCORE_GPREL15 4215 ENUMDOC 4216 Score relocations 4217 Low 16 bit for load/store 4218 ENUM 4219 BFD_RELOC_SCORE_DUMMY2 4220 ENUMX 4221 BFD_RELOC_SCORE_JMP 4222 ENUMDOC 4223 This is a 24-bit reloc with the right 1 bit assumed to be 0 4224 ENUM 4225 BFD_RELOC_SCORE_BRANCH 4226 ENUMDOC 4227 This is a 19-bit reloc with the right 1 bit assumed to be 0 4228 ENUM 4229 BFD_RELOC_SCORE_IMM30 4230 ENUMDOC 4231 This is a 32-bit reloc for 48-bit instructions. 4232 ENUM 4233 BFD_RELOC_SCORE_IMM32 4234 ENUMDOC 4235 This is a 32-bit reloc for 48-bit instructions. 4236 ENUM 4237 BFD_RELOC_SCORE16_JMP 4238 ENUMDOC 4239 This is a 11-bit reloc with the right 1 bit assumed to be 0 4240 ENUM 4241 BFD_RELOC_SCORE16_BRANCH 4242 ENUMDOC 4243 This is a 8-bit reloc with the right 1 bit assumed to be 0 4244 ENUM 4245 BFD_RELOC_SCORE_BCMP 4246 ENUMDOC 4247 This is a 9-bit reloc with the right 1 bit assumed to be 0 4248 ENUM 4249 BFD_RELOC_SCORE_GOT15 4250 ENUMX 4251 BFD_RELOC_SCORE_GOT_LO16 4252 ENUMX 4253 BFD_RELOC_SCORE_CALL15 4254 ENUMX 4255 BFD_RELOC_SCORE_DUMMY_HI16 4256 ENUMDOC 4257 Undocumented Score relocs 4258 4259 ENUM 4260 BFD_RELOC_IP2K_FR9 4261 ENUMDOC 4262 Scenix IP2K - 9-bit register number / data address 4263 ENUM 4264 BFD_RELOC_IP2K_BANK 4265 ENUMDOC 4266 Scenix IP2K - 4-bit register/data bank number 4267 ENUM 4268 BFD_RELOC_IP2K_ADDR16CJP 4269 ENUMDOC 4270 Scenix IP2K - low 13 bits of instruction word address 4271 ENUM 4272 BFD_RELOC_IP2K_PAGE3 4273 ENUMDOC 4274 Scenix IP2K - high 3 bits of instruction word address 4275 ENUM 4276 BFD_RELOC_IP2K_LO8DATA 4277 ENUMX 4278 BFD_RELOC_IP2K_HI8DATA 4279 ENUMX 4280 BFD_RELOC_IP2K_EX8DATA 4281 ENUMDOC 4282 Scenix IP2K - ext/low/high 8 bits of data address 4283 ENUM 4284 BFD_RELOC_IP2K_LO8INSN 4285 ENUMX 4286 BFD_RELOC_IP2K_HI8INSN 4287 ENUMDOC 4288 Scenix IP2K - low/high 8 bits of instruction word address 4289 ENUM 4290 BFD_RELOC_IP2K_PC_SKIP 4291 ENUMDOC 4292 Scenix IP2K - even/odd PC modifier to modify snb pcl.0 4293 ENUM 4294 BFD_RELOC_IP2K_TEXT 4295 ENUMDOC 4296 Scenix IP2K - 16 bit word address in text section. 4297 ENUM 4298 BFD_RELOC_IP2K_FR_OFFSET 4299 ENUMDOC 4300 Scenix IP2K - 7-bit sp or dp offset 4301 ENUM 4302 BFD_RELOC_VPE4KMATH_DATA 4303 ENUMX 4304 BFD_RELOC_VPE4KMATH_INSN 4305 ENUMDOC 4306 Scenix VPE4K coprocessor - data/insn-space addressing 4307 4308 ENUM 4309 BFD_RELOC_VTABLE_INHERIT 4310 ENUMX 4311 BFD_RELOC_VTABLE_ENTRY 4312 ENUMDOC 4313 These two relocations are used by the linker to determine which of 4314 the entries in a C++ virtual function table are actually used. When 4315 the --gc-sections option is given, the linker will zero out the entries 4316 that are not used, so that the code for those functions need not be 4317 included in the output. 4318 4319 VTABLE_INHERIT is a zero-space relocation used to describe to the 4320 linker the inheritance tree of a C++ virtual function table. The 4321 relocation's symbol should be the parent class' vtable, and the 4322 relocation should be located at the child vtable. 4323 4324 VTABLE_ENTRY is a zero-space relocation that describes the use of a 4325 virtual function table entry. The reloc's symbol should refer to the 4326 table of the class mentioned in the code. Off of that base, an offset 4327 describes the entry that is being used. For Rela hosts, this offset 4328 is stored in the reloc's addend. For Rel hosts, we are forced to put 4329 this offset in the reloc's section offset. 4330 4331 ENUM 4332 BFD_RELOC_IA64_IMM14 4333 ENUMX 4334 BFD_RELOC_IA64_IMM22 4335 ENUMX 4336 BFD_RELOC_IA64_IMM64 4337 ENUMX 4338 BFD_RELOC_IA64_DIR32MSB 4339 ENUMX 4340 BFD_RELOC_IA64_DIR32LSB 4341 ENUMX 4342 BFD_RELOC_IA64_DIR64MSB 4343 ENUMX 4344 BFD_RELOC_IA64_DIR64LSB 4345 ENUMX 4346 BFD_RELOC_IA64_GPREL22 4347 ENUMX 4348 BFD_RELOC_IA64_GPREL64I 4349 ENUMX 4350 BFD_RELOC_IA64_GPREL32MSB 4351 ENUMX 4352 BFD_RELOC_IA64_GPREL32LSB 4353 ENUMX 4354 BFD_RELOC_IA64_GPREL64MSB 4355 ENUMX 4356 BFD_RELOC_IA64_GPREL64LSB 4357 ENUMX 4358 BFD_RELOC_IA64_LTOFF22 4359 ENUMX 4360 BFD_RELOC_IA64_LTOFF64I 4361 ENUMX 4362 BFD_RELOC_IA64_PLTOFF22 4363 ENUMX 4364 BFD_RELOC_IA64_PLTOFF64I 4365 ENUMX 4366 BFD_RELOC_IA64_PLTOFF64MSB 4367 ENUMX 4368 BFD_RELOC_IA64_PLTOFF64LSB 4369 ENUMX 4370 BFD_RELOC_IA64_FPTR64I 4371 ENUMX 4372 BFD_RELOC_IA64_FPTR32MSB 4373 ENUMX 4374 BFD_RELOC_IA64_FPTR32LSB 4375 ENUMX 4376 BFD_RELOC_IA64_FPTR64MSB 4377 ENUMX 4378 BFD_RELOC_IA64_FPTR64LSB 4379 ENUMX 4380 BFD_RELOC_IA64_PCREL21B 4381 ENUMX 4382 BFD_RELOC_IA64_PCREL21BI 4383 ENUMX 4384 BFD_RELOC_IA64_PCREL21M 4385 ENUMX 4386 BFD_RELOC_IA64_PCREL21F 4387 ENUMX 4388 BFD_RELOC_IA64_PCREL22 4389 ENUMX 4390 BFD_RELOC_IA64_PCREL60B 4391 ENUMX 4392 BFD_RELOC_IA64_PCREL64I 4393 ENUMX 4394 BFD_RELOC_IA64_PCREL32MSB 4395 ENUMX 4396 BFD_RELOC_IA64_PCREL32LSB 4397 ENUMX 4398 BFD_RELOC_IA64_PCREL64MSB 4399 ENUMX 4400 BFD_RELOC_IA64_PCREL64LSB 4401 ENUMX 4402 BFD_RELOC_IA64_LTOFF_FPTR22 4403 ENUMX 4404 BFD_RELOC_IA64_LTOFF_FPTR64I 4405 ENUMX 4406 BFD_RELOC_IA64_LTOFF_FPTR32MSB 4407 ENUMX 4408 BFD_RELOC_IA64_LTOFF_FPTR32LSB 4409 ENUMX 4410 BFD_RELOC_IA64_LTOFF_FPTR64MSB 4411 ENUMX 4412 BFD_RELOC_IA64_LTOFF_FPTR64LSB 4413 ENUMX 4414 BFD_RELOC_IA64_SEGREL32MSB 4415 ENUMX 4416 BFD_RELOC_IA64_SEGREL32LSB 4417 ENUMX 4418 BFD_RELOC_IA64_SEGREL64MSB 4419 ENUMX 4420 BFD_RELOC_IA64_SEGREL64LSB 4421 ENUMX 4422 BFD_RELOC_IA64_SECREL32MSB 4423 ENUMX 4424 BFD_RELOC_IA64_SECREL32LSB 4425 ENUMX 4426 BFD_RELOC_IA64_SECREL64MSB 4427 ENUMX 4428 BFD_RELOC_IA64_SECREL64LSB 4429 ENUMX 4430 BFD_RELOC_IA64_REL32MSB 4431 ENUMX 4432 BFD_RELOC_IA64_REL32LSB 4433 ENUMX 4434 BFD_RELOC_IA64_REL64MSB 4435 ENUMX 4436 BFD_RELOC_IA64_REL64LSB 4437 ENUMX 4438 BFD_RELOC_IA64_LTV32MSB 4439 ENUMX 4440 BFD_RELOC_IA64_LTV32LSB 4441 ENUMX 4442 BFD_RELOC_IA64_LTV64MSB 4443 ENUMX 4444 BFD_RELOC_IA64_LTV64LSB 4445 ENUMX 4446 BFD_RELOC_IA64_IPLTMSB 4447 ENUMX 4448 BFD_RELOC_IA64_IPLTLSB 4449 ENUMX 4450 BFD_RELOC_IA64_COPY 4451 ENUMX 4452 BFD_RELOC_IA64_LTOFF22X 4453 ENUMX 4454 BFD_RELOC_IA64_LDXMOV 4455 ENUMX 4456 BFD_RELOC_IA64_TPREL14 4457 ENUMX 4458 BFD_RELOC_IA64_TPREL22 4459 ENUMX 4460 BFD_RELOC_IA64_TPREL64I 4461 ENUMX 4462 BFD_RELOC_IA64_TPREL64MSB 4463 ENUMX 4464 BFD_RELOC_IA64_TPREL64LSB 4465 ENUMX 4466 BFD_RELOC_IA64_LTOFF_TPREL22 4467 ENUMX 4468 BFD_RELOC_IA64_DTPMOD64MSB 4469 ENUMX 4470 BFD_RELOC_IA64_DTPMOD64LSB 4471 ENUMX 4472 BFD_RELOC_IA64_LTOFF_DTPMOD22 4473 ENUMX 4474 BFD_RELOC_IA64_DTPREL14 4475 ENUMX 4476 BFD_RELOC_IA64_DTPREL22 4477 ENUMX 4478 BFD_RELOC_IA64_DTPREL64I 4479 ENUMX 4480 BFD_RELOC_IA64_DTPREL32MSB 4481 ENUMX 4482 BFD_RELOC_IA64_DTPREL32LSB 4483 ENUMX 4484 BFD_RELOC_IA64_DTPREL64MSB 4485 ENUMX 4486 BFD_RELOC_IA64_DTPREL64LSB 4487 ENUMX 4488 BFD_RELOC_IA64_LTOFF_DTPREL22 4489 ENUMDOC 4490 Intel IA64 Relocations. 4491 4492 ENUM 4493 BFD_RELOC_M68HC11_HI8 4494 ENUMDOC 4495 Motorola 68HC11 reloc. 4496 This is the 8 bit high part of an absolute address. 4497 ENUM 4498 BFD_RELOC_M68HC11_LO8 4499 ENUMDOC 4500 Motorola 68HC11 reloc. 4501 This is the 8 bit low part of an absolute address. 4502 ENUM 4503 BFD_RELOC_M68HC11_3B 4504 ENUMDOC 4505 Motorola 68HC11 reloc. 4506 This is the 3 bit of a value. 4507 ENUM 4508 BFD_RELOC_M68HC11_RL_JUMP 4509 ENUMDOC 4510 Motorola 68HC11 reloc. 4511 This reloc marks the beginning of a jump/call instruction. 4512 It is used for linker relaxation to correctly identify beginning 4513 of instruction and change some branches to use PC-relative 4514 addressing mode. 4515 ENUM 4516 BFD_RELOC_M68HC11_RL_GROUP 4517 ENUMDOC 4518 Motorola 68HC11 reloc. 4519 This reloc marks a group of several instructions that gcc generates 4520 and for which the linker relaxation pass can modify and/or remove 4521 some of them. 4522 ENUM 4523 BFD_RELOC_M68HC11_LO16 4524 ENUMDOC 4525 Motorola 68HC11 reloc. 4526 This is the 16-bit lower part of an address. It is used for 'call' 4527 instruction to specify the symbol address without any special 4528 transformation (due to memory bank window). 4529 ENUM 4530 BFD_RELOC_M68HC11_PAGE 4531 ENUMDOC 4532 Motorola 68HC11 reloc. 4533 This is a 8-bit reloc that specifies the page number of an address. 4534 It is used by 'call' instruction to specify the page number of 4535 the symbol. 4536 ENUM 4537 BFD_RELOC_M68HC11_24 4538 ENUMDOC 4539 Motorola 68HC11 reloc. 4540 This is a 24-bit reloc that represents the address with a 16-bit 4541 value and a 8-bit page number. The symbol address is transformed 4542 to follow the 16K memory bank of 68HC12 (seen as mapped in the window). 4543 ENUM 4544 BFD_RELOC_M68HC12_5B 4545 ENUMDOC 4546 Motorola 68HC12 reloc. 4547 This is the 5 bits of a value. 4548 4549 ENUM 4550 BFD_RELOC_16C_NUM08 4551 ENUMX 4552 BFD_RELOC_16C_NUM08_C 4553 ENUMX 4554 BFD_RELOC_16C_NUM16 4555 ENUMX 4556 BFD_RELOC_16C_NUM16_C 4557 ENUMX 4558 BFD_RELOC_16C_NUM32 4559 ENUMX 4560 BFD_RELOC_16C_NUM32_C 4561 ENUMX 4562 BFD_RELOC_16C_DISP04 4563 ENUMX 4564 BFD_RELOC_16C_DISP04_C 4565 ENUMX 4566 BFD_RELOC_16C_DISP08 4567 ENUMX 4568 BFD_RELOC_16C_DISP08_C 4569 ENUMX 4570 BFD_RELOC_16C_DISP16 4571 ENUMX 4572 BFD_RELOC_16C_DISP16_C 4573 ENUMX 4574 BFD_RELOC_16C_DISP24 4575 ENUMX 4576 BFD_RELOC_16C_DISP24_C 4577 ENUMX 4578 BFD_RELOC_16C_DISP24a 4579 ENUMX 4580 BFD_RELOC_16C_DISP24a_C 4581 ENUMX 4582 BFD_RELOC_16C_REG04 4583 ENUMX 4584 BFD_RELOC_16C_REG04_C 4585 ENUMX 4586 BFD_RELOC_16C_REG04a 4587 ENUMX 4588 BFD_RELOC_16C_REG04a_C 4589 ENUMX 4590 BFD_RELOC_16C_REG14 4591 ENUMX 4592 BFD_RELOC_16C_REG14_C 4593 ENUMX 4594 BFD_RELOC_16C_REG16 4595 ENUMX 4596 BFD_RELOC_16C_REG16_C 4597 ENUMX 4598 BFD_RELOC_16C_REG20 4599 ENUMX 4600 BFD_RELOC_16C_REG20_C 4601 ENUMX 4602 BFD_RELOC_16C_ABS20 4603 ENUMX 4604 BFD_RELOC_16C_ABS20_C 4605 ENUMX 4606 BFD_RELOC_16C_ABS24 4607 ENUMX 4608 BFD_RELOC_16C_ABS24_C 4609 ENUMX 4610 BFD_RELOC_16C_IMM04 4611 ENUMX 4612 BFD_RELOC_16C_IMM04_C 4613 ENUMX 4614 BFD_RELOC_16C_IMM16 4615 ENUMX 4616 BFD_RELOC_16C_IMM16_C 4617 ENUMX 4618 BFD_RELOC_16C_IMM20 4619 ENUMX 4620 BFD_RELOC_16C_IMM20_C 4621 ENUMX 4622 BFD_RELOC_16C_IMM24 4623 ENUMX 4624 BFD_RELOC_16C_IMM24_C 4625 ENUMX 4626 BFD_RELOC_16C_IMM32 4627 ENUMX 4628 BFD_RELOC_16C_IMM32_C 4629 ENUMDOC 4630 NS CR16C Relocations. 4631 4632 ENUM 4633 BFD_RELOC_CR16_NUM8 4634 ENUMX 4635 BFD_RELOC_CR16_NUM16 4636 ENUMX 4637 BFD_RELOC_CR16_NUM32 4638 ENUMX 4639 BFD_RELOC_CR16_NUM32a 4640 ENUMX 4641 BFD_RELOC_CR16_REGREL0 4642 ENUMX 4643 BFD_RELOC_CR16_REGREL4 4644 ENUMX 4645 BFD_RELOC_CR16_REGREL4a 4646 ENUMX 4647 BFD_RELOC_CR16_REGREL14 4648 ENUMX 4649 BFD_RELOC_CR16_REGREL14a 4650 ENUMX 4651 BFD_RELOC_CR16_REGREL16 4652 ENUMX 4653 BFD_RELOC_CR16_REGREL20 4654 ENUMX 4655 BFD_RELOC_CR16_REGREL20a 4656 ENUMX 4657 BFD_RELOC_CR16_ABS20 4658 ENUMX 4659 BFD_RELOC_CR16_ABS24 4660 ENUMX 4661 BFD_RELOC_CR16_IMM4 4662 ENUMX 4663 BFD_RELOC_CR16_IMM8 4664 ENUMX 4665 BFD_RELOC_CR16_IMM16 4666 ENUMX 4667 BFD_RELOC_CR16_IMM20 4668 ENUMX 4669 BFD_RELOC_CR16_IMM24 4670 ENUMX 4671 BFD_RELOC_CR16_IMM32 4672 ENUMX 4673 BFD_RELOC_CR16_IMM32a 4674 ENUMX 4675 BFD_RELOC_CR16_DISP4 4676 ENUMX 4677 BFD_RELOC_CR16_DISP8 4678 ENUMX 4679 BFD_RELOC_CR16_DISP16 4680 ENUMX 4681 BFD_RELOC_CR16_DISP20 4682 ENUMX 4683 BFD_RELOC_CR16_DISP24 4684 ENUMX 4685 BFD_RELOC_CR16_DISP24a 4686 ENUMX 4687 BFD_RELOC_CR16_SWITCH8 4688 ENUMX 4689 BFD_RELOC_CR16_SWITCH16 4690 ENUMX 4691 BFD_RELOC_CR16_SWITCH32 4692 ENUMX 4693 BFD_RELOC_CR16_GOT_REGREL20 4694 ENUMX 4695 BFD_RELOC_CR16_GOTC_REGREL20 4696 ENUMX 4697 BFD_RELOC_CR16_GLOB_DAT 4698 ENUMDOC 4699 NS CR16 Relocations. 4700 4701 ENUM 4702 BFD_RELOC_CRX_REL4 4703 ENUMX 4704 BFD_RELOC_CRX_REL8 4705 ENUMX 4706 BFD_RELOC_CRX_REL8_CMP 4707 ENUMX 4708 BFD_RELOC_CRX_REL16 4709 ENUMX 4710 BFD_RELOC_CRX_REL24 4711 ENUMX 4712 BFD_RELOC_CRX_REL32 4713 ENUMX 4714 BFD_RELOC_CRX_REGREL12 4715 ENUMX 4716 BFD_RELOC_CRX_REGREL22 4717 ENUMX 4718 BFD_RELOC_CRX_REGREL28 4719 ENUMX 4720 BFD_RELOC_CRX_REGREL32 4721 ENUMX 4722 BFD_RELOC_CRX_ABS16 4723 ENUMX 4724 BFD_RELOC_CRX_ABS32 4725 ENUMX 4726 BFD_RELOC_CRX_NUM8 4727 ENUMX 4728 BFD_RELOC_CRX_NUM16 4729 ENUMX 4730 BFD_RELOC_CRX_NUM32 4731 ENUMX 4732 BFD_RELOC_CRX_IMM16 4733 ENUMX 4734 BFD_RELOC_CRX_IMM32 4735 ENUMX 4736 BFD_RELOC_CRX_SWITCH8 4737 ENUMX 4738 BFD_RELOC_CRX_SWITCH16 4739 ENUMX 4740 BFD_RELOC_CRX_SWITCH32 4741 ENUMDOC 4742 NS CRX Relocations. 4743 4744 ENUM 4745 BFD_RELOC_CRIS_BDISP8 4746 ENUMX 4747 BFD_RELOC_CRIS_UNSIGNED_5 4748 ENUMX 4749 BFD_RELOC_CRIS_SIGNED_6 4750 ENUMX 4751 BFD_RELOC_CRIS_UNSIGNED_6 4752 ENUMX 4753 BFD_RELOC_CRIS_SIGNED_8 4754 ENUMX 4755 BFD_RELOC_CRIS_UNSIGNED_8 4756 ENUMX 4757 BFD_RELOC_CRIS_SIGNED_16 4758 ENUMX 4759 BFD_RELOC_CRIS_UNSIGNED_16 4760 ENUMX 4761 BFD_RELOC_CRIS_LAPCQ_OFFSET 4762 ENUMX 4763 BFD_RELOC_CRIS_UNSIGNED_4 4764 ENUMDOC 4765 These relocs are only used within the CRIS assembler. They are not 4766 (at present) written to any object files. 4767 ENUM 4768 BFD_RELOC_CRIS_COPY 4769 ENUMX 4770 BFD_RELOC_CRIS_GLOB_DAT 4771 ENUMX 4772 BFD_RELOC_CRIS_JUMP_SLOT 4773 ENUMX 4774 BFD_RELOC_CRIS_RELATIVE 4775 ENUMDOC 4776 Relocs used in ELF shared libraries for CRIS. 4777 ENUM 4778 BFD_RELOC_CRIS_32_GOT 4779 ENUMDOC 4780 32-bit offset to symbol-entry within GOT. 4781 ENUM 4782 BFD_RELOC_CRIS_16_GOT 4783 ENUMDOC 4784 16-bit offset to symbol-entry within GOT. 4785 ENUM 4786 BFD_RELOC_CRIS_32_GOTPLT 4787 ENUMDOC 4788 32-bit offset to symbol-entry within GOT, with PLT handling. 4789 ENUM 4790 BFD_RELOC_CRIS_16_GOTPLT 4791 ENUMDOC 4792 16-bit offset to symbol-entry within GOT, with PLT handling. 4793 ENUM 4794 BFD_RELOC_CRIS_32_GOTREL 4795 ENUMDOC 4796 32-bit offset to symbol, relative to GOT. 4797 ENUM 4798 BFD_RELOC_CRIS_32_PLT_GOTREL 4799 ENUMDOC 4800 32-bit offset to symbol with PLT entry, relative to GOT. 4801 ENUM 4802 BFD_RELOC_CRIS_32_PLT_PCREL 4803 ENUMDOC 4804 32-bit offset to symbol with PLT entry, relative to this relocation. 4805 4806 ENUM 4807 BFD_RELOC_CRIS_32_GOT_GD 4808 ENUMX 4809 BFD_RELOC_CRIS_16_GOT_GD 4810 ENUMX 4811 BFD_RELOC_CRIS_32_GD 4812 ENUMX 4813 BFD_RELOC_CRIS_DTP 4814 ENUMX 4815 BFD_RELOC_CRIS_32_DTPREL 4816 ENUMX 4817 BFD_RELOC_CRIS_16_DTPREL 4818 ENUMX 4819 BFD_RELOC_CRIS_32_GOT_TPREL 4820 ENUMX 4821 BFD_RELOC_CRIS_16_GOT_TPREL 4822 ENUMX 4823 BFD_RELOC_CRIS_32_TPREL 4824 ENUMX 4825 BFD_RELOC_CRIS_16_TPREL 4826 ENUMX 4827 BFD_RELOC_CRIS_DTPMOD 4828 ENUMX 4829 BFD_RELOC_CRIS_32_IE 4830 ENUMDOC 4831 Relocs used in TLS code for CRIS. 4832 4833 ENUM 4834 BFD_RELOC_860_COPY 4835 ENUMX 4836 BFD_RELOC_860_GLOB_DAT 4837 ENUMX 4838 BFD_RELOC_860_JUMP_SLOT 4839 ENUMX 4840 BFD_RELOC_860_RELATIVE 4841 ENUMX 4842 BFD_RELOC_860_PC26 4843 ENUMX 4844 BFD_RELOC_860_PLT26 4845 ENUMX 4846 BFD_RELOC_860_PC16 4847 ENUMX 4848 BFD_RELOC_860_LOW0 4849 ENUMX 4850 BFD_RELOC_860_SPLIT0 4851 ENUMX 4852 BFD_RELOC_860_LOW1 4853 ENUMX 4854 BFD_RELOC_860_SPLIT1 4855 ENUMX 4856 BFD_RELOC_860_LOW2 4857 ENUMX 4858 BFD_RELOC_860_SPLIT2 4859 ENUMX 4860 BFD_RELOC_860_LOW3 4861 ENUMX 4862 BFD_RELOC_860_LOGOT0 4863 ENUMX 4864 BFD_RELOC_860_SPGOT0 4865 ENUMX 4866 BFD_RELOC_860_LOGOT1 4867 ENUMX 4868 BFD_RELOC_860_SPGOT1 4869 ENUMX 4870 BFD_RELOC_860_LOGOTOFF0 4871 ENUMX 4872 BFD_RELOC_860_SPGOTOFF0 4873 ENUMX 4874 BFD_RELOC_860_LOGOTOFF1 4875 ENUMX 4876 BFD_RELOC_860_SPGOTOFF1 4877 ENUMX 4878 BFD_RELOC_860_LOGOTOFF2 4879 ENUMX 4880 BFD_RELOC_860_LOGOTOFF3 4881 ENUMX 4882 BFD_RELOC_860_LOPC 4883 ENUMX 4884 BFD_RELOC_860_HIGHADJ 4885 ENUMX 4886 BFD_RELOC_860_HAGOT 4887 ENUMX 4888 BFD_RELOC_860_HAGOTOFF 4889 ENUMX 4890 BFD_RELOC_860_HAPC 4891 ENUMX 4892 BFD_RELOC_860_HIGH 4893 ENUMX 4894 BFD_RELOC_860_HIGOT 4895 ENUMX 4896 BFD_RELOC_860_HIGOTOFF 4897 ENUMDOC 4898 Intel i860 Relocations. 4899 4900 ENUM 4901 BFD_RELOC_OPENRISC_ABS_26 4902 ENUMX 4903 BFD_RELOC_OPENRISC_REL_26 4904 ENUMDOC 4905 OpenRISC Relocations. 4906 4907 ENUM 4908 BFD_RELOC_H8_DIR16A8 4909 ENUMX 4910 BFD_RELOC_H8_DIR16R8 4911 ENUMX 4912 BFD_RELOC_H8_DIR24A8 4913 ENUMX 4914 BFD_RELOC_H8_DIR24R8 4915 ENUMX 4916 BFD_RELOC_H8_DIR32A16 4917 ENUMDOC 4918 H8 elf Relocations. 4919 4920 ENUM 4921 BFD_RELOC_XSTORMY16_REL_12 4922 ENUMX 4923 BFD_RELOC_XSTORMY16_12 4924 ENUMX 4925 BFD_RELOC_XSTORMY16_24 4926 ENUMX 4927 BFD_RELOC_XSTORMY16_FPTR16 4928 ENUMDOC 4929 Sony Xstormy16 Relocations. 4930 4931 ENUM 4932 BFD_RELOC_RELC 4933 ENUMDOC 4934 Self-describing complex relocations. 4935 COMMENT 4936 4937 ENUM 4938 BFD_RELOC_XC16X_PAG 4939 ENUMX 4940 BFD_RELOC_XC16X_POF 4941 ENUMX 4942 BFD_RELOC_XC16X_SEG 4943 ENUMX 4944 BFD_RELOC_XC16X_SOF 4945 ENUMDOC 4946 Infineon Relocations. 4947 4948 ENUM 4949 BFD_RELOC_VAX_GLOB_DAT 4950 ENUMX 4951 BFD_RELOC_VAX_JMP_SLOT 4952 ENUMX 4953 BFD_RELOC_VAX_RELATIVE 4954 ENUMDOC 4955 Relocations used by VAX ELF. 4956 4957 ENUM 4958 BFD_RELOC_MT_PC16 4959 ENUMDOC 4960 Morpho MT - 16 bit immediate relocation. 4961 ENUM 4962 BFD_RELOC_MT_HI16 4963 ENUMDOC 4964 Morpho MT - Hi 16 bits of an address. 4965 ENUM 4966 BFD_RELOC_MT_LO16 4967 ENUMDOC 4968 Morpho MT - Low 16 bits of an address. 4969 ENUM 4970 BFD_RELOC_MT_GNU_VTINHERIT 4971 ENUMDOC 4972 Morpho MT - Used to tell the linker which vtable entries are used. 4973 ENUM 4974 BFD_RELOC_MT_GNU_VTENTRY 4975 ENUMDOC 4976 Morpho MT - Used to tell the linker which vtable entries are used. 4977 ENUM 4978 BFD_RELOC_MT_PCINSN8 4979 ENUMDOC 4980 Morpho MT - 8 bit immediate relocation. 4981 4982 ENUM 4983 BFD_RELOC_MSP430_10_PCREL 4984 ENUMX 4985 BFD_RELOC_MSP430_16_PCREL 4986 ENUMX 4987 BFD_RELOC_MSP430_16 4988 ENUMX 4989 BFD_RELOC_MSP430_16_PCREL_BYTE 4990 ENUMX 4991 BFD_RELOC_MSP430_16_BYTE 4992 ENUMX 4993 BFD_RELOC_MSP430_2X_PCREL 4994 ENUMX 4995 BFD_RELOC_MSP430_RL_PCREL 4996 ENUMDOC 4997 msp430 specific relocation codes 4998 4999 ENUM 5000 BFD_RELOC_IQ2000_OFFSET_16 5001 ENUMX 5002 BFD_RELOC_IQ2000_OFFSET_21 5003 ENUMX 5004 BFD_RELOC_IQ2000_UHI16 5005 ENUMDOC 5006 IQ2000 Relocations. 5007 5008 ENUM 5009 BFD_RELOC_XTENSA_RTLD 5010 ENUMDOC 5011 Special Xtensa relocation used only by PLT entries in ELF shared 5012 objects to indicate that the runtime linker should set the value 5013 to one of its own internal functions or data structures. 5014 ENUM 5015 BFD_RELOC_XTENSA_GLOB_DAT 5016 ENUMX 5017 BFD_RELOC_XTENSA_JMP_SLOT 5018 ENUMX 5019 BFD_RELOC_XTENSA_RELATIVE 5020 ENUMDOC 5021 Xtensa relocations for ELF shared objects. 5022 ENUM 5023 BFD_RELOC_XTENSA_PLT 5024 ENUMDOC 5025 Xtensa relocation used in ELF object files for symbols that may require 5026 PLT entries. Otherwise, this is just a generic 32-bit relocation. 5027 ENUM 5028 BFD_RELOC_XTENSA_DIFF8 5029 ENUMX 5030 BFD_RELOC_XTENSA_DIFF16 5031 ENUMX 5032 BFD_RELOC_XTENSA_DIFF32 5033 ENUMDOC 5034 Xtensa relocations to mark the difference of two local symbols. 5035 These are only needed to support linker relaxation and can be ignored 5036 when not relaxing. The field is set to the value of the difference 5037 assuming no relaxation. The relocation encodes the position of the 5038 first symbol so the linker can determine whether to adjust the field 5039 value. 5040 ENUM 5041 BFD_RELOC_XTENSA_SLOT0_OP 5042 ENUMX 5043 BFD_RELOC_XTENSA_SLOT1_OP 5044 ENUMX 5045 BFD_RELOC_XTENSA_SLOT2_OP 5046 ENUMX 5047 BFD_RELOC_XTENSA_SLOT3_OP 5048 ENUMX 5049 BFD_RELOC_XTENSA_SLOT4_OP 5050 ENUMX 5051 BFD_RELOC_XTENSA_SLOT5_OP 5052 ENUMX 5053 BFD_RELOC_XTENSA_SLOT6_OP 5054 ENUMX 5055 BFD_RELOC_XTENSA_SLOT7_OP 5056 ENUMX 5057 BFD_RELOC_XTENSA_SLOT8_OP 5058 ENUMX 5059 BFD_RELOC_XTENSA_SLOT9_OP 5060 ENUMX 5061 BFD_RELOC_XTENSA_SLOT10_OP 5062 ENUMX 5063 BFD_RELOC_XTENSA_SLOT11_OP 5064 ENUMX 5065 BFD_RELOC_XTENSA_SLOT12_OP 5066 ENUMX 5067 BFD_RELOC_XTENSA_SLOT13_OP 5068 ENUMX 5069 BFD_RELOC_XTENSA_SLOT14_OP 5070 ENUMDOC 5071 Generic Xtensa relocations for instruction operands. Only the slot 5072 number is encoded in the relocation. The relocation applies to the 5073 last PC-relative immediate operand, or if there are no PC-relative 5074 immediates, to the last immediate operand. 5075 ENUM 5076 BFD_RELOC_XTENSA_SLOT0_ALT 5077 ENUMX 5078 BFD_RELOC_XTENSA_SLOT1_ALT 5079 ENUMX 5080 BFD_RELOC_XTENSA_SLOT2_ALT 5081 ENUMX 5082 BFD_RELOC_XTENSA_SLOT3_ALT 5083 ENUMX 5084 BFD_RELOC_XTENSA_SLOT4_ALT 5085 ENUMX 5086 BFD_RELOC_XTENSA_SLOT5_ALT 5087 ENUMX 5088 BFD_RELOC_XTENSA_SLOT6_ALT 5089 ENUMX 5090 BFD_RELOC_XTENSA_SLOT7_ALT 5091 ENUMX 5092 BFD_RELOC_XTENSA_SLOT8_ALT 5093 ENUMX 5094 BFD_RELOC_XTENSA_SLOT9_ALT 5095 ENUMX 5096 BFD_RELOC_XTENSA_SLOT10_ALT 5097 ENUMX 5098 BFD_RELOC_XTENSA_SLOT11_ALT 5099 ENUMX 5100 BFD_RELOC_XTENSA_SLOT12_ALT 5101 ENUMX 5102 BFD_RELOC_XTENSA_SLOT13_ALT 5103 ENUMX 5104 BFD_RELOC_XTENSA_SLOT14_ALT 5105 ENUMDOC 5106 Alternate Xtensa relocations. Only the slot is encoded in the 5107 relocation. The meaning of these relocations is opcode-specific. 5108 ENUM 5109 BFD_RELOC_XTENSA_OP0 5110 ENUMX 5111 BFD_RELOC_XTENSA_OP1 5112 ENUMX 5113 BFD_RELOC_XTENSA_OP2 5114 ENUMDOC 5115 Xtensa relocations for backward compatibility. These have all been 5116 replaced by BFD_RELOC_XTENSA_SLOT0_OP. 5117 ENUM 5118 BFD_RELOC_XTENSA_ASM_EXPAND 5119 ENUMDOC 5120 Xtensa relocation to mark that the assembler expanded the 5121 instructions from an original target. The expansion size is 5122 encoded in the reloc size. 5123 ENUM 5124 BFD_RELOC_XTENSA_ASM_SIMPLIFY 5125 ENUMDOC 5126 Xtensa relocation to mark that the linker should simplify 5127 assembler-expanded instructions. This is commonly used 5128 internally by the linker after analysis of a 5129 BFD_RELOC_XTENSA_ASM_EXPAND. 5130 ENUM 5131 BFD_RELOC_XTENSA_TLSDESC_FN 5132 ENUMX 5133 BFD_RELOC_XTENSA_TLSDESC_ARG 5134 ENUMX 5135 BFD_RELOC_XTENSA_TLS_DTPOFF 5136 ENUMX 5137 BFD_RELOC_XTENSA_TLS_TPOFF 5138 ENUMX 5139 BFD_RELOC_XTENSA_TLS_FUNC 5140 ENUMX 5141 BFD_RELOC_XTENSA_TLS_ARG 5142 ENUMX 5143 BFD_RELOC_XTENSA_TLS_CALL 5144 ENUMDOC 5145 Xtensa TLS relocations. 5146 5147 ENUM 5148 BFD_RELOC_Z80_DISP8 5149 ENUMDOC 5150 8 bit signed offset in (ix+d) or (iy+d). 5151 5152 ENUM 5153 BFD_RELOC_Z8K_DISP7 5154 ENUMDOC 5155 DJNZ offset. 5156 ENUM 5157 BFD_RELOC_Z8K_CALLR 5158 ENUMDOC 5159 CALR offset. 5160 ENUM 5161 BFD_RELOC_Z8K_IMM4L 5162 ENUMDOC 5163 4 bit value. 5164 5165 ENUM 5166 BFD_RELOC_LM32_CALL 5167 ENUMX 5168 BFD_RELOC_LM32_BRANCH 5169 ENUMX 5170 BFD_RELOC_LM32_16_GOT 5171 ENUMX 5172 BFD_RELOC_LM32_GOTOFF_HI16 5173 ENUMX 5174 BFD_RELOC_LM32_GOTOFF_LO16 5175 ENUMX 5176 BFD_RELOC_LM32_COPY 5177 ENUMX 5178 BFD_RELOC_LM32_GLOB_DAT 5179 ENUMX 5180 BFD_RELOC_LM32_JMP_SLOT 5181 ENUMX 5182 BFD_RELOC_LM32_RELATIVE 5183 ENUMDOC 5184 Lattice Mico32 relocations. 5185 5186 ENUM 5187 BFD_RELOC_MACH_O_SECTDIFF 5188 ENUMDOC 5189 Difference between two section addreses. Must be followed by a 5190 BFD_RELOC_MACH_O_PAIR. 5191 ENUM 5192 BFD_RELOC_MACH_O_PAIR 5193 ENUMDOC 5194 Mach-O generic relocations. 5195 5196 ENUM 5197 BFD_RELOC_MICROBLAZE_32_LO 5198 ENUMDOC 5199 This is a 32 bit reloc for the microblaze that stores the 5200 low 16 bits of a value 5201 ENUM 5202 BFD_RELOC_MICROBLAZE_32_LO_PCREL 5203 ENUMDOC 5204 This is a 32 bit pc-relative reloc for the microblaze that 5205 stores the low 16 bits of a value 5206 ENUM 5207 BFD_RELOC_MICROBLAZE_32_ROSDA 5208 ENUMDOC 5209 This is a 32 bit reloc for the microblaze that stores a 5210 value relative to the read-only small data area anchor 5211 ENUM 5212 BFD_RELOC_MICROBLAZE_32_RWSDA 5213 ENUMDOC 5214 This is a 32 bit reloc for the microblaze that stores a 5215 value relative to the read-write small data area anchor 5216 ENUM 5217 BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM 5218 ENUMDOC 5219 This is a 32 bit reloc for the microblaze to handle 5220 expressions of the form "Symbol Op Symbol" 5221 ENUM 5222 BFD_RELOC_MICROBLAZE_64_NONE 5223 ENUMDOC 5224 This is a 64 bit reloc that stores the 32 bit pc relative 5225 value in two words (with an imm instruction). No relocation is 5226 done here - only used for relaxing 5227 ENUM 5228 BFD_RELOC_MICROBLAZE_64_GOTPC 5229 ENUMDOC 5230 This is a 64 bit reloc that stores the 32 bit pc relative 5231 value in two words (with an imm instruction). The relocation is 5232 PC-relative GOT offset 5233 ENUM 5234 BFD_RELOC_MICROBLAZE_64_GOT 5235 ENUMDOC 5236 This is a 64 bit reloc that stores the 32 bit pc relative 5237 value in two words (with an imm instruction). The relocation is 5238 GOT offset 5239 ENUM 5240 BFD_RELOC_MICROBLAZE_64_PLT 5241 ENUMDOC 5242 This is a 64 bit reloc that stores the 32 bit pc relative 5243 value in two words (with an imm instruction). The relocation is 5244 PC-relative offset into PLT 5245 ENUM 5246 BFD_RELOC_MICROBLAZE_64_GOTOFF 5247 ENUMDOC 5248 This is a 64 bit reloc that stores the 32 bit GOT relative 5249 value in two words (with an imm instruction). The relocation is 5250 relative offset from _GLOBAL_OFFSET_TABLE_ 5251 ENUM 5252 BFD_RELOC_MICROBLAZE_32_GOTOFF 5253 ENUMDOC 5254 This is a 32 bit reloc that stores the 32 bit GOT relative 5255 value in a word. The relocation is relative offset from 5256 _GLOBAL_OFFSET_TABLE_ 5257 ENUM 5258 BFD_RELOC_MICROBLAZE_COPY 5259 ENUMDOC 5260 This is used to tell the dynamic linker to copy the value out of 5261 the dynamic object into the runtime process image. 5262 5263 5264 ENDSENUM 5265 BFD_RELOC_UNUSED 5266 CODE_FRAGMENT 5267 . 5268 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; 5269 */ 5270 5271 /* 5272 FUNCTION 5273 bfd_reloc_type_lookup 5274 bfd_reloc_name_lookup 5275 5276 SYNOPSIS 5277 reloc_howto_type *bfd_reloc_type_lookup 5278 (bfd *abfd, bfd_reloc_code_real_type code); 5279 reloc_howto_type *bfd_reloc_name_lookup 5280 (bfd *abfd, const char *reloc_name); 5281 5282 DESCRIPTION 5283 Return a pointer to a howto structure which, when 5284 invoked, will perform the relocation @var{code} on data from the 5285 architecture noted. 5286 5287 */ 5288 5289 reloc_howto_type * 5290 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 5291 { 5292 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code)); 5293 } 5294 5295 reloc_howto_type * 5296 bfd_reloc_name_lookup (bfd *abfd, const char *reloc_name) 5297 { 5298 return BFD_SEND (abfd, reloc_name_lookup, (abfd, reloc_name)); 5299 } 5300 5301 static reloc_howto_type bfd_howto_32 = 5302 HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_dont, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE); 5303 5304 /* 5305 INTERNAL_FUNCTION 5306 bfd_default_reloc_type_lookup 5307 5308 SYNOPSIS 5309 reloc_howto_type *bfd_default_reloc_type_lookup 5310 (bfd *abfd, bfd_reloc_code_real_type code); 5311 5312 DESCRIPTION 5313 Provides a default relocation lookup routine for any architecture. 5314 5315 */ 5316 5317 reloc_howto_type * 5318 bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 5319 { 5320 switch (code) 5321 { 5322 case BFD_RELOC_CTOR: 5323 /* The type of reloc used in a ctor, which will be as wide as the 5324 address - so either a 64, 32, or 16 bitter. */ 5325 switch (bfd_get_arch_info (abfd)->bits_per_address) 5326 { 5327 case 64: 5328 BFD_FAIL (); 5329 case 32: 5330 return &bfd_howto_32; 5331 case 16: 5332 BFD_FAIL (); 5333 default: 5334 BFD_FAIL (); 5335 } 5336 default: 5337 BFD_FAIL (); 5338 } 5339 return NULL; 5340 } 5341 5342 /* 5343 FUNCTION 5344 bfd_get_reloc_code_name 5345 5346 SYNOPSIS 5347 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); 5348 5349 DESCRIPTION 5350 Provides a printable name for the supplied relocation code. 5351 Useful mainly for printing error messages. 5352 */ 5353 5354 const char * 5355 bfd_get_reloc_code_name (bfd_reloc_code_real_type code) 5356 { 5357 if (code > BFD_RELOC_UNUSED) 5358 return 0; 5359 return bfd_reloc_code_real_names[code]; 5360 } 5361 5362 /* 5363 INTERNAL_FUNCTION 5364 bfd_generic_relax_section 5365 5366 SYNOPSIS 5367 bfd_boolean bfd_generic_relax_section 5368 (bfd *abfd, 5369 asection *section, 5370 struct bfd_link_info *, 5371 bfd_boolean *); 5372 5373 DESCRIPTION 5374 Provides default handling for relaxing for back ends which 5375 don't do relaxing. 5376 */ 5377 5378 bfd_boolean 5379 bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, 5380 asection *section ATTRIBUTE_UNUSED, 5381 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 5382 bfd_boolean *again) 5383 { 5384 if (link_info->relocatable) 5385 (*link_info->callbacks->einfo) 5386 (_("%P%F: --relax and -r may not be used together\n")); 5387 5388 *again = FALSE; 5389 return TRUE; 5390 } 5391 5392 /* 5393 INTERNAL_FUNCTION 5394 bfd_generic_gc_sections 5395 5396 SYNOPSIS 5397 bfd_boolean bfd_generic_gc_sections 5398 (bfd *, struct bfd_link_info *); 5399 5400 DESCRIPTION 5401 Provides default handling for relaxing for back ends which 5402 don't do section gc -- i.e., does nothing. 5403 */ 5404 5405 bfd_boolean 5406 bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, 5407 struct bfd_link_info *info ATTRIBUTE_UNUSED) 5408 { 5409 return TRUE; 5410 } 5411 5412 /* 5413 INTERNAL_FUNCTION 5414 bfd_generic_merge_sections 5415 5416 SYNOPSIS 5417 bfd_boolean bfd_generic_merge_sections 5418 (bfd *, struct bfd_link_info *); 5419 5420 DESCRIPTION 5421 Provides default handling for SEC_MERGE section merging for back ends 5422 which don't have SEC_MERGE support -- i.e., does nothing. 5423 */ 5424 5425 bfd_boolean 5426 bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, 5427 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 5428 { 5429 return TRUE; 5430 } 5431 5432 /* 5433 INTERNAL_FUNCTION 5434 bfd_generic_get_relocated_section_contents 5435 5436 SYNOPSIS 5437 bfd_byte *bfd_generic_get_relocated_section_contents 5438 (bfd *abfd, 5439 struct bfd_link_info *link_info, 5440 struct bfd_link_order *link_order, 5441 bfd_byte *data, 5442 bfd_boolean relocatable, 5443 asymbol **symbols); 5444 5445 DESCRIPTION 5446 Provides default handling of relocation effort for back ends 5447 which can't be bothered to do it efficiently. 5448 5449 */ 5450 5451 bfd_byte * 5452 bfd_generic_get_relocated_section_contents (bfd *abfd, 5453 struct bfd_link_info *link_info, 5454 struct bfd_link_order *link_order, 5455 bfd_byte *data, 5456 bfd_boolean relocatable, 5457 asymbol **symbols) 5458 { 5459 bfd *input_bfd = link_order->u.indirect.section->owner; 5460 asection *input_section = link_order->u.indirect.section; 5461 long reloc_size; 5462 arelent **reloc_vector; 5463 long reloc_count; 5464 bfd_size_type sz; 5465 5466 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 5467 if (reloc_size < 0) 5468 return NULL; 5469 5470 /* Read in the section. */ 5471 sz = input_section->rawsize ? input_section->rawsize : input_section->size; 5472 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz)) 5473 return NULL; 5474 5475 if (reloc_size == 0) 5476 return data; 5477 5478 reloc_vector = (arelent **) bfd_malloc (reloc_size); 5479 if (reloc_vector == NULL) 5480 return NULL; 5481 5482 reloc_count = bfd_canonicalize_reloc (input_bfd, 5483 input_section, 5484 reloc_vector, 5485 symbols); 5486 if (reloc_count < 0) 5487 goto error_return; 5488 5489 if (reloc_count > 0) 5490 { 5491 arelent **parent; 5492 for (parent = reloc_vector; *parent != NULL; parent++) 5493 { 5494 char *error_message = NULL; 5495 asymbol *symbol; 5496 bfd_reloc_status_type r; 5497 5498 symbol = *(*parent)->sym_ptr_ptr; 5499 if (symbol->section && elf_discarded_section (symbol->section)) 5500 { 5501 bfd_byte *p; 5502 static reloc_howto_type none_howto 5503 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, 5504 "unused", FALSE, 0, 0, FALSE); 5505 5506 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd); 5507 _bfd_clear_contents ((*parent)->howto, input_bfd, p); 5508 (*parent)->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr; 5509 (*parent)->addend = 0; 5510 (*parent)->howto = &none_howto; 5511 r = bfd_reloc_ok; 5512 } 5513 else 5514 r = bfd_perform_relocation (input_bfd, 5515 *parent, 5516 data, 5517 input_section, 5518 relocatable ? abfd : NULL, 5519 &error_message); 5520 5521 if (relocatable) 5522 { 5523 asection *os = input_section->output_section; 5524 5525 /* A partial link, so keep the relocs. */ 5526 os->orelocation[os->reloc_count] = *parent; 5527 os->reloc_count++; 5528 } 5529 5530 if (r != bfd_reloc_ok) 5531 { 5532 switch (r) 5533 { 5534 case bfd_reloc_undefined: 5535 if (!((*link_info->callbacks->undefined_symbol) 5536 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 5537 input_bfd, input_section, (*parent)->address, 5538 TRUE))) 5539 goto error_return; 5540 break; 5541 case bfd_reloc_dangerous: 5542 BFD_ASSERT (error_message != NULL); 5543 if (!((*link_info->callbacks->reloc_dangerous) 5544 (link_info, error_message, input_bfd, input_section, 5545 (*parent)->address))) 5546 goto error_return; 5547 break; 5548 case bfd_reloc_overflow: 5549 if (!((*link_info->callbacks->reloc_overflow) 5550 (link_info, NULL, 5551 bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 5552 (*parent)->howto->name, (*parent)->addend, 5553 input_bfd, input_section, (*parent)->address))) 5554 goto error_return; 5555 break; 5556 case bfd_reloc_outofrange: 5557 default: 5558 abort (); 5559 break; 5560 } 5561 5562 } 5563 } 5564 } 5565 5566 free (reloc_vector); 5567 return data; 5568 5569 error_return: 5570 free (reloc_vector); 5571 return NULL; 5572 } 5573