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