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 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 22 23 /* 24 SECTION 25 Relocations 26 27 BFD maintains relocations in much the same way it maintains 28 symbols: they are left alone until required, then read in 29 en-masse and translated into an internal form. A common 30 routine <<bfd_perform_relocation>> acts upon the 31 canonical form to do the fixup. 32 33 Relocations are maintained on a per section basis, 34 while symbols are maintained on a per BFD basis. 35 36 All that a back end has to do to fit the BFD interface is to create 37 a <<struct reloc_cache_entry>> for each relocation 38 in a particular section, and fill in the right bits of the structures. 39 40 @menu 41 @* typedef arelent:: 42 @* howto manager:: 43 @end menu 44 45 */ 46 47 /* DO compile in the reloc_code name table from libbfd.h. */ 48 #define _BFD_MAKE_TABLE_bfd_reloc_code_real 49 50 #include "bfd.h" 51 #include "sysdep.h" 52 #include "bfdlink.h" 53 #include "libbfd.h" 54 /* 55 DOCDD 56 INODE 57 typedef arelent, howto manager, Relocations, Relocations 58 59 SUBSECTION 60 typedef arelent 61 62 This is the structure of a relocation entry: 63 64 CODE_FRAGMENT 65 . 66 .typedef enum bfd_reloc_status 67 .{ 68 . {* No errors detected. *} 69 . bfd_reloc_ok, 70 . 71 . {* The relocation was performed, but there was an overflow. *} 72 . bfd_reloc_overflow, 73 . 74 . {* The address to relocate was not within the section supplied. *} 75 . bfd_reloc_outofrange, 76 . 77 . {* Used by special functions. *} 78 . bfd_reloc_continue, 79 . 80 . {* Unsupported relocation size requested. *} 81 . bfd_reloc_notsupported, 82 . 83 . {* Unused. *} 84 . bfd_reloc_other, 85 . 86 . {* The symbol to relocate against was undefined. *} 87 . bfd_reloc_undefined, 88 . 89 . {* The relocation was performed, but may not be ok - presently 90 . generated only when linking i960 coff files with i960 b.out 91 . symbols. If this type is returned, the error_message argument 92 . to bfd_perform_relocation will be set. *} 93 . bfd_reloc_dangerous 94 . } 95 . bfd_reloc_status_type; 96 . 97 . 98 .typedef struct reloc_cache_entry 99 .{ 100 . {* A pointer into the canonical table of pointers. *} 101 . struct bfd_symbol **sym_ptr_ptr; 102 . 103 . {* offset in section. *} 104 . bfd_size_type address; 105 . 106 . {* addend for relocation value. *} 107 . bfd_vma addend; 108 . 109 . {* Pointer to how to perform the required relocation. *} 110 . reloc_howto_type *howto; 111 . 112 .} 113 .arelent; 114 . 115 */ 116 117 /* 118 DESCRIPTION 119 120 Here is a description of each of the fields within an <<arelent>>: 121 122 o <<sym_ptr_ptr>> 123 124 The symbol table pointer points to a pointer to the symbol 125 associated with the relocation request. It is the pointer 126 into the table returned by the back end's 127 <<canonicalize_symtab>> action. @xref{Symbols}. The symbol is 128 referenced through a pointer to a pointer so that tools like 129 the linker can fix up all the symbols of the same name by 130 modifying only one pointer. The relocation routine looks in 131 the symbol and uses the base of the section the symbol is 132 attached to and the value of the symbol as the initial 133 relocation offset. If the symbol pointer is zero, then the 134 section provided is looked up. 135 136 o <<address>> 137 138 The <<address>> field gives the offset in bytes from the base of 139 the section data which owns the relocation record to the first 140 byte of relocatable information. The actual data relocated 141 will be relative to this point; for example, a relocation 142 type which modifies the bottom two bytes of a four byte word 143 would not touch the first byte pointed to in a big endian 144 world. 145 146 o <<addend>> 147 148 The <<addend>> is a value provided by the back end to be added (!) 149 to the relocation offset. Its interpretation is dependent upon 150 the howto. For example, on the 68k the code: 151 152 | char foo[]; 153 | main() 154 | { 155 | return foo[0x12345678]; 156 | } 157 158 Could be compiled into: 159 160 | linkw fp,#-4 161 | moveb @@#12345678,d0 162 | extbl d0 163 | unlk fp 164 | rts 165 166 This could create a reloc pointing to <<foo>>, but leave the 167 offset in the data, something like: 168 169 |RELOCATION RECORDS FOR [.text]: 170 |offset type value 171 |00000006 32 _foo 172 | 173 |00000000 4e56 fffc ; linkw fp,#-4 174 |00000004 1039 1234 5678 ; moveb @@#12345678,d0 175 |0000000a 49c0 ; extbl d0 176 |0000000c 4e5e ; unlk fp 177 |0000000e 4e75 ; rts 178 179 Using coff and an 88k, some instructions don't have enough 180 space in them to represent the full address range, and 181 pointers have to be loaded in two parts. So you'd get something like: 182 183 | or.u r13,r0,hi16(_foo+0x12345678) 184 | ld.b r2,r13,lo16(_foo+0x12345678) 185 | jmp r1 186 187 This should create two relocs, both pointing to <<_foo>>, and with 188 0x12340000 in their addend field. The data would consist of: 189 190 |RELOCATION RECORDS FOR [.text]: 191 |offset type value 192 |00000002 HVRT16 _foo+0x12340000 193 |00000006 LVRT16 _foo+0x12340000 194 | 195 |00000000 5da05678 ; or.u r13,r0,0x5678 196 |00000004 1c4d5678 ; ld.b r2,r13,0x5678 197 |00000008 f400c001 ; jmp r1 198 199 The relocation routine digs out the value from the data, adds 200 it to the addend to get the original offset, and then adds the 201 value of <<_foo>>. Note that all 32 bits have to be kept around 202 somewhere, to cope with carry from bit 15 to bit 16. 203 204 One further example is the sparc and the a.out format. The 205 sparc has a similar problem to the 88k, in that some 206 instructions don't have room for an entire offset, but on the 207 sparc the parts are created in odd sized lumps. The designers of 208 the a.out format chose to not use the data within the section 209 for storing part of the offset; all the offset is kept within 210 the reloc. Anything in the data should be ignored. 211 212 | save %sp,-112,%sp 213 | sethi %hi(_foo+0x12345678),%g2 214 | ldsb [%g2+%lo(_foo+0x12345678)],%i0 215 | ret 216 | restore 217 218 Both relocs contain a pointer to <<foo>>, and the offsets 219 contain junk. 220 221 |RELOCATION RECORDS FOR [.text]: 222 |offset type value 223 |00000004 HI22 _foo+0x12345678 224 |00000008 LO10 _foo+0x12345678 225 | 226 |00000000 9de3bf90 ; save %sp,-112,%sp 227 |00000004 05000000 ; sethi %hi(_foo+0),%g2 228 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0 229 |0000000c 81c7e008 ; ret 230 |00000010 81e80000 ; restore 231 232 o <<howto>> 233 234 The <<howto>> field can be imagined as a 235 relocation instruction. It is a pointer to a structure which 236 contains information on what to do with all of the other 237 information in the reloc record and data section. A back end 238 would normally have a relocation instruction set and turn 239 relocations into pointers to the correct structure on input - 240 but it would be possible to create each howto field on demand. 241 242 */ 243 244 /* 245 SUBSUBSECTION 246 <<enum complain_overflow>> 247 248 Indicates what sort of overflow checking should be done when 249 performing a relocation. 250 251 CODE_FRAGMENT 252 . 253 .enum complain_overflow 254 .{ 255 . {* Do not complain on overflow. *} 256 . complain_overflow_dont, 257 . 258 . {* Complain if the bitfield overflows, whether it is considered 259 . as signed or unsigned. *} 260 . complain_overflow_bitfield, 261 . 262 . {* Complain if the value overflows when considered as signed 263 . number. *} 264 . complain_overflow_signed, 265 . 266 . {* Complain if the value overflows when considered as an 267 . unsigned number. *} 268 . complain_overflow_unsigned 269 .}; 270 271 */ 272 273 /* 274 SUBSUBSECTION 275 <<reloc_howto_type>> 276 277 The <<reloc_howto_type>> is a structure which contains all the 278 information that libbfd needs to know to tie up a back end's data. 279 280 CODE_FRAGMENT 281 .struct bfd_symbol; {* Forward declaration. *} 282 . 283 .struct reloc_howto_struct 284 .{ 285 . {* The type field has mainly a documentary use - the back end can 286 . do what it wants with it, though normally the back end's 287 . external idea of what a reloc number is stored 288 . in this field. For example, a PC relative word relocation 289 . in a coff environment has the type 023 - because that's 290 . what the outside world calls a R_PCRWORD reloc. *} 291 . unsigned int type; 292 . 293 . {* The value the final relocation is shifted right by. This drops 294 . unwanted data from the relocation. *} 295 . unsigned int rightshift; 296 . 297 . {* The size of the item to be relocated. This is *not* a 298 . power-of-two measure. To get the number of bytes operated 299 . on by a type of relocation, use bfd_get_reloc_size. *} 300 . int size; 301 . 302 . {* The number of bits in the item to be relocated. This is used 303 . when doing overflow checking. *} 304 . unsigned int bitsize; 305 . 306 . {* Notes that the relocation is relative to the location in the 307 . data section of the addend. The relocation function will 308 . subtract from the relocation value the address of the location 309 . 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 a = relocation; 500 501 /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not, 502 we'll be permissive: extra bits in the field mask will 503 automatically extend the address mask for purposes of the 504 overflow check. */ 505 fieldmask = N_ONES (bitsize); 506 addrmask = N_ONES (addrsize) | fieldmask; 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 a = (a & addrmask) >> rightshift; 517 signmask = ~ (fieldmask >> 1); 518 ss = a & signmask; 519 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask)) 520 flag = bfd_reloc_overflow; 521 break; 522 523 case complain_overflow_unsigned: 524 /* We have an overflow if the address does not fit in the field. */ 525 a = (a & addrmask) >> rightshift; 526 if ((a & ~ fieldmask) != 0) 527 flag = bfd_reloc_overflow; 528 break; 529 530 case complain_overflow_bitfield: 531 /* Bitfields are sometimes signed, sometimes unsigned. We 532 explicitly allow an address wrap too, which means a bitfield 533 of n bits is allowed to store -2**n to 2**n-1. Thus overflow 534 if the value has some, but not all, bits set outside the 535 field. */ 536 a >>= rightshift; 537 ss = a & ~ fieldmask; 538 if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & ~ fieldmask)) 539 flag = bfd_reloc_overflow; 540 break; 541 542 default: 543 abort (); 544 } 545 546 return flag; 547 } 548 549 /* 550 FUNCTION 551 bfd_perform_relocation 552 553 SYNOPSIS 554 bfd_reloc_status_type bfd_perform_relocation 555 (bfd *abfd, 556 arelent *reloc_entry, 557 void *data, 558 asection *input_section, 559 bfd *output_bfd, 560 char **error_message); 561 562 DESCRIPTION 563 If @var{output_bfd} is supplied to this function, the 564 generated image will be relocatable; the relocations are 565 copied to the output file after they have been changed to 566 reflect the new state of the world. There are two ways of 567 reflecting the results of partial linkage in an output file: 568 by modifying the output data in place, and by modifying the 569 relocation record. Some native formats (e.g., basic a.out and 570 basic coff) have no way of specifying an addend in the 571 relocation type, so the addend has to go in the output data. 572 This is no big deal since in these formats the output data 573 slot will always be big enough for the addend. Complex reloc 574 types with addends were invented to solve just this problem. 575 The @var{error_message} argument is set to an error message if 576 this return @code{bfd_reloc_dangerous}. 577 578 */ 579 580 bfd_reloc_status_type 581 bfd_perform_relocation (bfd *abfd, 582 arelent *reloc_entry, 583 void *data, 584 asection *input_section, 585 bfd *output_bfd, 586 char **error_message) 587 { 588 bfd_vma relocation; 589 bfd_reloc_status_type flag = bfd_reloc_ok; 590 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd); 591 bfd_vma output_base = 0; 592 reloc_howto_type *howto = reloc_entry->howto; 593 asection *reloc_target_output_section; 594 asymbol *symbol; 595 596 symbol = *(reloc_entry->sym_ptr_ptr); 597 if (bfd_is_abs_section (symbol->section) 598 && output_bfd != NULL) 599 { 600 reloc_entry->address += input_section->output_offset; 601 return bfd_reloc_ok; 602 } 603 604 /* If we are not producing relocatable output, return an error if 605 the symbol is not defined. An undefined weak symbol is 606 considered to have a value of zero (SVR4 ABI, p. 4-27). */ 607 if (bfd_is_und_section (symbol->section) 608 && (symbol->flags & BSF_WEAK) == 0 609 && output_bfd == NULL) 610 flag = bfd_reloc_undefined; 611 612 /* If there is a function supplied to handle this relocation type, 613 call it. It'll return `bfd_reloc_continue' if further processing 614 can be done. */ 615 if (howto->special_function) 616 { 617 bfd_reloc_status_type cont; 618 cont = howto->special_function (abfd, reloc_entry, symbol, data, 619 input_section, output_bfd, 620 error_message); 621 if (cont != bfd_reloc_continue) 622 return cont; 623 } 624 625 /* Is the address of the relocation really within the section? */ 626 if (reloc_entry->address > (input_section->_cooked_size 627 / bfd_octets_per_byte (abfd))) 628 return bfd_reloc_outofrange; 629 630 /* Work out which section the relocation is targeted at and the 631 initial relocation command value. */ 632 633 /* Get symbol value. (Common symbols are special.) */ 634 if (bfd_is_com_section (symbol->section)) 635 relocation = 0; 636 else 637 relocation = symbol->value; 638 639 reloc_target_output_section = symbol->section->output_section; 640 641 /* Convert input-section-relative symbol value to absolute. */ 642 if ((output_bfd && ! howto->partial_inplace) 643 || reloc_target_output_section == NULL) 644 output_base = 0; 645 else 646 output_base = reloc_target_output_section->vma; 647 648 relocation += output_base + symbol->section->output_offset; 649 650 /* Add in supplied addend. */ 651 relocation += reloc_entry->addend; 652 653 /* Here the variable relocation holds the final address of the 654 symbol we are relocating against, plus any addend. */ 655 656 if (howto->pc_relative) 657 { 658 /* This is a PC relative relocation. We want to set RELOCATION 659 to the distance between the address of the symbol and the 660 location. RELOCATION is already the address of the symbol. 661 662 We start by subtracting the address of the section containing 663 the location. 664 665 If pcrel_offset is set, we must further subtract the position 666 of the location within the section. Some targets arrange for 667 the addend to be the negative of the position of the location 668 within the section; for example, i386-aout does this. For 669 i386-aout, pcrel_offset is FALSE. Some other targets do not 670 include the position of the location; for example, m88kbcs, 671 or ELF. For those targets, pcrel_offset is TRUE. 672 673 If we are producing relocatable output, then we must ensure 674 that this reloc will be correctly computed when the final 675 relocation is done. If pcrel_offset is FALSE we want to wind 676 up with the negative of the location within the section, 677 which means we must adjust the existing addend by the change 678 in the location within the section. If pcrel_offset is TRUE 679 we do not want to adjust the existing addend at all. 680 681 FIXME: This seems logical to me, but for the case of 682 producing relocatable output it is not what the code 683 actually does. I don't want to change it, because it seems 684 far too likely that something will break. */ 685 686 relocation -= 687 input_section->output_section->vma + input_section->output_offset; 688 689 if (howto->pcrel_offset) 690 relocation -= reloc_entry->address; 691 } 692 693 if (output_bfd != NULL) 694 { 695 if (! howto->partial_inplace) 696 { 697 /* This is a partial relocation, and we want to apply the relocation 698 to the reloc entry rather than the raw data. Modify the reloc 699 inplace to reflect what we now know. */ 700 reloc_entry->addend = relocation; 701 reloc_entry->address += input_section->output_offset; 702 return flag; 703 } 704 else 705 { 706 /* This is a partial relocation, but inplace, so modify the 707 reloc record a bit. 708 709 If we've relocated with a symbol with a section, change 710 into a ref to the section belonging to the symbol. */ 711 712 reloc_entry->address += input_section->output_offset; 713 714 /* WTF?? */ 715 if (abfd->xvec->flavour == bfd_target_coff_flavour 716 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0 717 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0) 718 { 719 #if 1 720 /* For m68k-coff, the addend was being subtracted twice during 721 relocation with -r. Removing the line below this comment 722 fixes that problem; see PR 2953. 723 724 However, Ian wrote the following, regarding removing the line below, 725 which explains why it is still enabled: --djm 726 727 If you put a patch like that into BFD you need to check all the COFF 728 linkers. I am fairly certain that patch will break coff-i386 (e.g., 729 SCO); see coff_i386_reloc in coff-i386.c where I worked around the 730 problem in a different way. There may very well be a reason that the 731 code works as it does. 732 733 Hmmm. The first obvious point is that bfd_perform_relocation should 734 not have any tests that depend upon the flavour. It's seem like 735 entirely the wrong place for such a thing. The second obvious point 736 is that the current code ignores the reloc addend when producing 737 relocatable output for COFF. That's peculiar. In fact, I really 738 have no idea what the point of the line you want to remove is. 739 740 A typical COFF reloc subtracts the old value of the symbol and adds in 741 the new value to the location in the object file (if it's a pc 742 relative reloc it adds the difference between the symbol value and the 743 location). When relocating we need to preserve that property. 744 745 BFD handles this by setting the addend to the negative of the old 746 value of the symbol. Unfortunately it handles common symbols in a 747 non-standard way (it doesn't subtract the old value) but that's a 748 different story (we can't change it without losing backward 749 compatibility with old object files) (coff-i386 does subtract the old 750 value, to be compatible with existing coff-i386 targets, like SCO). 751 752 So everything works fine when not producing relocatable output. When 753 we are producing relocatable output, logically we should do exactly 754 what we do when not producing relocatable output. Therefore, your 755 patch is correct. In fact, it should probably always just set 756 reloc_entry->addend to 0 for all cases, since it is, in fact, going to 757 add the value into the object file. This won't hurt the COFF code, 758 which doesn't use the addend; I'm not sure what it will do to other 759 formats (the thing to check for would be whether any formats both use 760 the addend and set partial_inplace). 761 762 When I wanted to make coff-i386 produce relocatable output, I ran 763 into the problem that you are running into: I wanted to remove that 764 line. Rather than risk it, I made the coff-i386 relocs use a special 765 function; it's coff_i386_reloc in coff-i386.c. The function 766 specifically adds the addend field into the object file, knowing that 767 bfd_perform_relocation is not going to. If you remove that line, then 768 coff-i386.c will wind up adding the addend field in twice. It's 769 trivial to fix; it just needs to be done. 770 771 The problem with removing the line is just that it may break some 772 working code. With BFD it's hard to be sure of anything. The right 773 way to deal with this is simply to build and test at least all the 774 supported COFF targets. It should be straightforward if time and disk 775 space consuming. For each target: 776 1) build the linker 777 2) generate some executable, and link it using -r (I would 778 probably use paranoia.o and link against newlib/libc.a, which 779 for all the supported targets would be available in 780 /usr/cygnus/progressive/H-host/target/lib/libc.a). 781 3) make the change to reloc.c 782 4) rebuild the linker 783 5) repeat step 2 784 6) if the resulting object files are the same, you have at least 785 made it no worse 786 7) if they are different you have to figure out which version is 787 right 788 */ 789 relocation -= reloc_entry->addend; 790 #endif 791 reloc_entry->addend = 0; 792 } 793 else 794 { 795 reloc_entry->addend = relocation; 796 } 797 } 798 } 799 else 800 { 801 reloc_entry->addend = 0; 802 } 803 804 /* FIXME: This overflow checking is incomplete, because the value 805 might have overflowed before we get here. For a correct check we 806 need to compute the value in a size larger than bitsize, but we 807 can't reasonably do that for a reloc the same size as a host 808 machine word. 809 FIXME: We should also do overflow checking on the result after 810 adding in the value contained in the object file. */ 811 if (howto->complain_on_overflow != complain_overflow_dont 812 && flag == bfd_reloc_ok) 813 flag = bfd_check_overflow (howto->complain_on_overflow, 814 howto->bitsize, 815 howto->rightshift, 816 bfd_arch_bits_per_address (abfd), 817 relocation); 818 819 /* Either we are relocating all the way, or we don't want to apply 820 the relocation to the reloc entry (probably because there isn't 821 any room in the output format to describe addends to relocs). */ 822 823 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler 824 (OSF version 1.3, compiler version 3.11). It miscompiles the 825 following program: 826 827 struct str 828 { 829 unsigned int i0; 830 } s = { 0 }; 831 832 int 833 main () 834 { 835 unsigned long x; 836 837 x = 0x100000000; 838 x <<= (unsigned long) s.i0; 839 if (x == 0) 840 printf ("failed\n"); 841 else 842 printf ("succeeded (%lx)\n", x); 843 } 844 */ 845 846 relocation >>= (bfd_vma) howto->rightshift; 847 848 /* Shift everything up to where it's going to be used. */ 849 relocation <<= (bfd_vma) howto->bitpos; 850 851 /* Wait for the day when all have the mask in them. */ 852 853 /* What we do: 854 i instruction to be left alone 855 o offset within instruction 856 r relocation offset to apply 857 S src mask 858 D dst mask 859 N ~dst mask 860 A part 1 861 B part 2 862 R result 863 864 Do this: 865 (( i i i i i o o o o o from bfd_get<size> 866 and S S S S S) to get the size offset we want 867 + r r r r r r r r r r) to get the final value to place 868 and D D D D D to chop to right size 869 ----------------------- 870 = A A A A A 871 And this: 872 ( i i i i i o o o o o from bfd_get<size> 873 and N N N N N ) get instruction 874 ----------------------- 875 = B B B B B 876 877 And then: 878 ( B B B B B 879 or A A A A A) 880 ----------------------- 881 = R R R R R R R R R R put into bfd_put<size> 882 */ 883 884 #define DOIT(x) \ 885 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask)) 886 887 switch (howto->size) 888 { 889 case 0: 890 { 891 char x = bfd_get_8 (abfd, (char *) data + octets); 892 DOIT (x); 893 bfd_put_8 (abfd, x, (unsigned char *) data + octets); 894 } 895 break; 896 897 case 1: 898 { 899 short x = bfd_get_16 (abfd, (bfd_byte *) data + octets); 900 DOIT (x); 901 bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets); 902 } 903 break; 904 case 2: 905 { 906 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets); 907 DOIT (x); 908 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 909 } 910 break; 911 case -2: 912 { 913 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets); 914 relocation = -relocation; 915 DOIT (x); 916 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 917 } 918 break; 919 920 case -1: 921 { 922 long x = bfd_get_16 (abfd, (bfd_byte *) data + octets); 923 relocation = -relocation; 924 DOIT (x); 925 bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets); 926 } 927 break; 928 929 case 3: 930 /* Do nothing */ 931 break; 932 933 case 4: 934 #ifdef BFD64 935 { 936 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets); 937 DOIT (x); 938 bfd_put_64 (abfd, x, (bfd_byte *) data + octets); 939 } 940 #else 941 abort (); 942 #endif 943 break; 944 default: 945 return bfd_reloc_other; 946 } 947 948 return flag; 949 } 950 951 /* 952 FUNCTION 953 bfd_install_relocation 954 955 SYNOPSIS 956 bfd_reloc_status_type bfd_install_relocation 957 (bfd *abfd, 958 arelent *reloc_entry, 959 void *data, bfd_vma data_start, 960 asection *input_section, 961 char **error_message); 962 963 DESCRIPTION 964 This looks remarkably like <<bfd_perform_relocation>>, except it 965 does not expect that the section contents have been filled in. 966 I.e., it's suitable for use when creating, rather than applying 967 a relocation. 968 969 For now, this function should be considered reserved for the 970 assembler. 971 */ 972 973 bfd_reloc_status_type 974 bfd_install_relocation (bfd *abfd, 975 arelent *reloc_entry, 976 void *data_start, 977 bfd_vma data_start_offset, 978 asection *input_section, 979 char **error_message) 980 { 981 bfd_vma relocation; 982 bfd_reloc_status_type flag = bfd_reloc_ok; 983 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd); 984 bfd_vma output_base = 0; 985 reloc_howto_type *howto = reloc_entry->howto; 986 asection *reloc_target_output_section; 987 asymbol *symbol; 988 bfd_byte *data; 989 990 symbol = *(reloc_entry->sym_ptr_ptr); 991 if (bfd_is_abs_section (symbol->section)) 992 { 993 reloc_entry->address += input_section->output_offset; 994 return bfd_reloc_ok; 995 } 996 997 /* If there is a function supplied to handle this relocation type, 998 call it. It'll return `bfd_reloc_continue' if further processing 999 can be done. */ 1000 if (howto->special_function) 1001 { 1002 bfd_reloc_status_type cont; 1003 1004 /* XXX - The special_function calls haven't been fixed up to deal 1005 with creating new relocations and section contents. */ 1006 cont = howto->special_function (abfd, reloc_entry, symbol, 1007 /* XXX - Non-portable! */ 1008 ((bfd_byte *) data_start 1009 - data_start_offset), 1010 input_section, abfd, error_message); 1011 if (cont != bfd_reloc_continue) 1012 return cont; 1013 } 1014 1015 /* Is the address of the relocation really within the section? */ 1016 if (reloc_entry->address > (input_section->_cooked_size 1017 / bfd_octets_per_byte (abfd))) 1018 return bfd_reloc_outofrange; 1019 1020 /* Work out which section the relocation is targeted at and the 1021 initial relocation command value. */ 1022 1023 /* Get symbol value. (Common symbols are special.) */ 1024 if (bfd_is_com_section (symbol->section)) 1025 relocation = 0; 1026 else 1027 relocation = symbol->value; 1028 1029 reloc_target_output_section = symbol->section->output_section; 1030 1031 /* Convert input-section-relative symbol value to absolute. */ 1032 if (! howto->partial_inplace) 1033 output_base = 0; 1034 else 1035 output_base = reloc_target_output_section->vma; 1036 1037 relocation += output_base + symbol->section->output_offset; 1038 1039 /* Add in supplied addend. */ 1040 relocation += reloc_entry->addend; 1041 1042 /* Here the variable relocation holds the final address of the 1043 symbol we are relocating against, plus any addend. */ 1044 1045 if (howto->pc_relative) 1046 { 1047 /* This is a PC relative relocation. We want to set RELOCATION 1048 to the distance between the address of the symbol and the 1049 location. RELOCATION is already the address of the symbol. 1050 1051 We start by subtracting the address of the section containing 1052 the location. 1053 1054 If pcrel_offset is set, we must further subtract the position 1055 of the location within the section. Some targets arrange for 1056 the addend to be the negative of the position of the location 1057 within the section; for example, i386-aout does this. For 1058 i386-aout, pcrel_offset is FALSE. Some other targets do not 1059 include the position of the location; for example, m88kbcs, 1060 or ELF. For those targets, pcrel_offset is TRUE. 1061 1062 If we are producing relocatable output, then we must ensure 1063 that this reloc will be correctly computed when the final 1064 relocation is done. If pcrel_offset is FALSE we want to wind 1065 up with the negative of the location within the section, 1066 which means we must adjust the existing addend by the change 1067 in the location within the section. If pcrel_offset is TRUE 1068 we do not want to adjust the existing addend at all. 1069 1070 FIXME: This seems logical to me, but for the case of 1071 producing relocatable output it is not what the code 1072 actually does. I don't want to change it, because it seems 1073 far too likely that something will break. */ 1074 1075 relocation -= 1076 input_section->output_section->vma + input_section->output_offset; 1077 1078 if (howto->pcrel_offset && howto->partial_inplace) 1079 relocation -= reloc_entry->address; 1080 } 1081 1082 if (! howto->partial_inplace) 1083 { 1084 /* This is a partial relocation, and we want to apply the relocation 1085 to the reloc entry rather than the raw data. Modify the reloc 1086 inplace to reflect what we now know. */ 1087 reloc_entry->addend = relocation; 1088 reloc_entry->address += input_section->output_offset; 1089 return flag; 1090 } 1091 else 1092 { 1093 /* This is a partial relocation, but inplace, so modify the 1094 reloc record a bit. 1095 1096 If we've relocated with a symbol with a section, change 1097 into a ref to the section belonging to the symbol. */ 1098 reloc_entry->address += input_section->output_offset; 1099 1100 /* WTF?? */ 1101 if (abfd->xvec->flavour == bfd_target_coff_flavour 1102 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0 1103 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0) 1104 { 1105 #if 1 1106 /* For m68k-coff, the addend was being subtracted twice during 1107 relocation with -r. Removing the line below this comment 1108 fixes that problem; see PR 2953. 1109 1110 However, Ian wrote the following, regarding removing the line below, 1111 which explains why it is still enabled: --djm 1112 1113 If you put a patch like that into BFD you need to check all the COFF 1114 linkers. I am fairly certain that patch will break coff-i386 (e.g., 1115 SCO); see coff_i386_reloc in coff-i386.c where I worked around the 1116 problem in a different way. There may very well be a reason that the 1117 code works as it does. 1118 1119 Hmmm. The first obvious point is that bfd_install_relocation should 1120 not have any tests that depend upon the flavour. It's seem like 1121 entirely the wrong place for such a thing. The second obvious point 1122 is that the current code ignores the reloc addend when producing 1123 relocatable output for COFF. That's peculiar. In fact, I really 1124 have no idea what the point of the line you want to remove is. 1125 1126 A typical COFF reloc subtracts the old value of the symbol and adds in 1127 the new value to the location in the object file (if it's a pc 1128 relative reloc it adds the difference between the symbol value and the 1129 location). When relocating we need to preserve that property. 1130 1131 BFD handles this by setting the addend to the negative of the old 1132 value of the symbol. Unfortunately it handles common symbols in a 1133 non-standard way (it doesn't subtract the old value) but that's a 1134 different story (we can't change it without losing backward 1135 compatibility with old object files) (coff-i386 does subtract the old 1136 value, to be compatible with existing coff-i386 targets, like SCO). 1137 1138 So everything works fine when not producing relocatable output. When 1139 we are producing relocatable output, logically we should do exactly 1140 what we do when not producing relocatable output. Therefore, your 1141 patch is correct. In fact, it should probably always just set 1142 reloc_entry->addend to 0 for all cases, since it is, in fact, going to 1143 add the value into the object file. This won't hurt the COFF code, 1144 which doesn't use the addend; I'm not sure what it will do to other 1145 formats (the thing to check for would be whether any formats both use 1146 the addend and set partial_inplace). 1147 1148 When I wanted to make coff-i386 produce relocatable output, I ran 1149 into the problem that you are running into: I wanted to remove that 1150 line. Rather than risk it, I made the coff-i386 relocs use a special 1151 function; it's coff_i386_reloc in coff-i386.c. The function 1152 specifically adds the addend field into the object file, knowing that 1153 bfd_install_relocation is not going to. If you remove that line, then 1154 coff-i386.c will wind up adding the addend field in twice. It's 1155 trivial to fix; it just needs to be done. 1156 1157 The problem with removing the line is just that it may break some 1158 working code. With BFD it's hard to be sure of anything. The right 1159 way to deal with this is simply to build and test at least all the 1160 supported COFF targets. It should be straightforward if time and disk 1161 space consuming. For each target: 1162 1) build the linker 1163 2) generate some executable, and link it using -r (I would 1164 probably use paranoia.o and link against newlib/libc.a, which 1165 for all the supported targets would be available in 1166 /usr/cygnus/progressive/H-host/target/lib/libc.a). 1167 3) make the change to reloc.c 1168 4) rebuild the linker 1169 5) repeat step 2 1170 6) if the resulting object files are the same, you have at least 1171 made it no worse 1172 7) if they are different you have to figure out which version is 1173 right. */ 1174 relocation -= reloc_entry->addend; 1175 #endif 1176 reloc_entry->addend = 0; 1177 } 1178 else 1179 { 1180 reloc_entry->addend = relocation; 1181 } 1182 } 1183 1184 /* FIXME: This overflow checking is incomplete, because the value 1185 might have overflowed before we get here. For a correct check we 1186 need to compute the value in a size larger than bitsize, but we 1187 can't reasonably do that for a reloc the same size as a host 1188 machine word. 1189 FIXME: We should also do overflow checking on the result after 1190 adding in the value contained in the object file. */ 1191 if (howto->complain_on_overflow != complain_overflow_dont) 1192 flag = bfd_check_overflow (howto->complain_on_overflow, 1193 howto->bitsize, 1194 howto->rightshift, 1195 bfd_arch_bits_per_address (abfd), 1196 relocation); 1197 1198 /* Either we are relocating all the way, or we don't want to apply 1199 the relocation to the reloc entry (probably because there isn't 1200 any room in the output format to describe addends to relocs). */ 1201 1202 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler 1203 (OSF version 1.3, compiler version 3.11). It miscompiles the 1204 following program: 1205 1206 struct str 1207 { 1208 unsigned int i0; 1209 } s = { 0 }; 1210 1211 int 1212 main () 1213 { 1214 unsigned long x; 1215 1216 x = 0x100000000; 1217 x <<= (unsigned long) s.i0; 1218 if (x == 0) 1219 printf ("failed\n"); 1220 else 1221 printf ("succeeded (%lx)\n", x); 1222 } 1223 */ 1224 1225 relocation >>= (bfd_vma) howto->rightshift; 1226 1227 /* Shift everything up to where it's going to be used. */ 1228 relocation <<= (bfd_vma) howto->bitpos; 1229 1230 /* Wait for the day when all have the mask in them. */ 1231 1232 /* What we do: 1233 i instruction to be left alone 1234 o offset within instruction 1235 r relocation offset to apply 1236 S src mask 1237 D dst mask 1238 N ~dst mask 1239 A part 1 1240 B part 2 1241 R result 1242 1243 Do this: 1244 (( i i i i i o o o o o from bfd_get<size> 1245 and S S S S S) to get the size offset we want 1246 + r r r r r r r r r r) to get the final value to place 1247 and D D D D D to chop to right size 1248 ----------------------- 1249 = A A A A A 1250 And this: 1251 ( i i i i i o o o o o from bfd_get<size> 1252 and N N N N N ) get instruction 1253 ----------------------- 1254 = B B B B B 1255 1256 And then: 1257 ( B B B B B 1258 or A A A A A) 1259 ----------------------- 1260 = R R R R R R R R R R put into bfd_put<size> 1261 */ 1262 1263 #define DOIT(x) \ 1264 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask)) 1265 1266 data = (bfd_byte *) data_start + (octets - data_start_offset); 1267 1268 switch (howto->size) 1269 { 1270 case 0: 1271 { 1272 char x = bfd_get_8 (abfd, data); 1273 DOIT (x); 1274 bfd_put_8 (abfd, x, data); 1275 } 1276 break; 1277 1278 case 1: 1279 { 1280 short x = bfd_get_16 (abfd, data); 1281 DOIT (x); 1282 bfd_put_16 (abfd, (bfd_vma) x, data); 1283 } 1284 break; 1285 case 2: 1286 { 1287 long x = bfd_get_32 (abfd, data); 1288 DOIT (x); 1289 bfd_put_32 (abfd, (bfd_vma) x, data); 1290 } 1291 break; 1292 case -2: 1293 { 1294 long x = bfd_get_32 (abfd, data); 1295 relocation = -relocation; 1296 DOIT (x); 1297 bfd_put_32 (abfd, (bfd_vma) x, data); 1298 } 1299 break; 1300 1301 case 3: 1302 /* Do nothing */ 1303 break; 1304 1305 case 4: 1306 { 1307 bfd_vma x = bfd_get_64 (abfd, data); 1308 DOIT (x); 1309 bfd_put_64 (abfd, x, data); 1310 } 1311 break; 1312 default: 1313 return bfd_reloc_other; 1314 } 1315 1316 return flag; 1317 } 1318 1319 /* This relocation routine is used by some of the backend linkers. 1320 They do not construct asymbol or arelent structures, so there is no 1321 reason for them to use bfd_perform_relocation. Also, 1322 bfd_perform_relocation is so hacked up it is easier to write a new 1323 function than to try to deal with it. 1324 1325 This routine does a final relocation. Whether it is useful for a 1326 relocatable link depends upon how the object format defines 1327 relocations. 1328 1329 FIXME: This routine ignores any special_function in the HOWTO, 1330 since the existing special_function values have been written for 1331 bfd_perform_relocation. 1332 1333 HOWTO is the reloc howto information. 1334 INPUT_BFD is the BFD which the reloc applies to. 1335 INPUT_SECTION is the section which the reloc applies to. 1336 CONTENTS is the contents of the section. 1337 ADDRESS is the address of the reloc within INPUT_SECTION. 1338 VALUE is the value of the symbol the reloc refers to. 1339 ADDEND is the addend of the reloc. */ 1340 1341 bfd_reloc_status_type 1342 _bfd_final_link_relocate (reloc_howto_type *howto, 1343 bfd *input_bfd, 1344 asection *input_section, 1345 bfd_byte *contents, 1346 bfd_vma address, 1347 bfd_vma value, 1348 bfd_vma addend) 1349 { 1350 bfd_vma relocation; 1351 1352 /* Sanity check the address. */ 1353 if (address > input_section->_raw_size) 1354 return bfd_reloc_outofrange; 1355 1356 /* This function assumes that we are dealing with a basic relocation 1357 against a symbol. We want to compute the value of the symbol to 1358 relocate to. This is just VALUE, the value of the symbol, plus 1359 ADDEND, any addend associated with the reloc. */ 1360 relocation = value + addend; 1361 1362 /* If the relocation is PC relative, we want to set RELOCATION to 1363 the distance between the symbol (currently in RELOCATION) and the 1364 location we are relocating. Some targets (e.g., i386-aout) 1365 arrange for the contents of the section to be the negative of the 1366 offset of the location within the section; for such targets 1367 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF) 1368 simply leave the contents of the section as zero; for such 1369 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not 1370 need to subtract out the offset of the location within the 1371 section (which is just ADDRESS). */ 1372 if (howto->pc_relative) 1373 { 1374 relocation -= (input_section->output_section->vma 1375 + input_section->output_offset); 1376 if (howto->pcrel_offset) 1377 relocation -= address; 1378 } 1379 1380 return _bfd_relocate_contents (howto, input_bfd, relocation, 1381 contents + address); 1382 } 1383 1384 /* Relocate a given location using a given value and howto. */ 1385 1386 bfd_reloc_status_type 1387 _bfd_relocate_contents (reloc_howto_type *howto, 1388 bfd *input_bfd, 1389 bfd_vma relocation, 1390 bfd_byte *location) 1391 { 1392 int size; 1393 bfd_vma x = 0; 1394 bfd_reloc_status_type flag; 1395 unsigned int rightshift = howto->rightshift; 1396 unsigned int bitpos = howto->bitpos; 1397 1398 /* If the size is negative, negate RELOCATION. This isn't very 1399 general. */ 1400 if (howto->size < 0) 1401 relocation = -relocation; 1402 1403 /* Get the value we are going to relocate. */ 1404 size = bfd_get_reloc_size (howto); 1405 switch (size) 1406 { 1407 default: 1408 case 0: 1409 abort (); 1410 case 1: 1411 x = bfd_get_8 (input_bfd, location); 1412 break; 1413 case 2: 1414 x = bfd_get_16 (input_bfd, location); 1415 break; 1416 case 4: 1417 x = bfd_get_32 (input_bfd, location); 1418 break; 1419 case 8: 1420 #ifdef BFD64 1421 x = bfd_get_64 (input_bfd, location); 1422 #else 1423 abort (); 1424 #endif 1425 break; 1426 } 1427 1428 /* Check for overflow. FIXME: We may drop bits during the addition 1429 which we don't check for. We must either check at every single 1430 operation, which would be tedious, or we must do the computations 1431 in a type larger than bfd_vma, which would be inefficient. */ 1432 flag = bfd_reloc_ok; 1433 if (howto->complain_on_overflow != complain_overflow_dont) 1434 { 1435 bfd_vma addrmask, fieldmask, signmask, ss; 1436 bfd_vma a, b, sum; 1437 1438 /* Get the values to be added together. For signed and unsigned 1439 relocations, we assume that all values should be truncated to 1440 the size of an address. For bitfields, all the bits matter. 1441 See also bfd_check_overflow. */ 1442 fieldmask = N_ONES (howto->bitsize); 1443 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask; 1444 a = relocation; 1445 b = x & howto->src_mask; 1446 1447 switch (howto->complain_on_overflow) 1448 { 1449 case complain_overflow_signed: 1450 a = (a & addrmask) >> rightshift; 1451 1452 /* If any sign bits are set, all sign bits must be set. 1453 That is, A must be a valid negative address after 1454 shifting. */ 1455 signmask = ~ (fieldmask >> 1); 1456 ss = a & signmask; 1457 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask)) 1458 flag = bfd_reloc_overflow; 1459 1460 /* We only need this next bit of code if the sign bit of B 1461 is below the sign bit of A. This would only happen if 1462 SRC_MASK had fewer bits than BITSIZE. Note that if 1463 SRC_MASK has more bits than BITSIZE, we can get into 1464 trouble; we would need to verify that B is in range, as 1465 we do for A above. */ 1466 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask; 1467 1468 /* Set all the bits above the sign bit. */ 1469 b = (b ^ signmask) - signmask; 1470 1471 b = (b & addrmask) >> bitpos; 1472 1473 /* Now we can do the addition. */ 1474 sum = a + b; 1475 1476 /* See if the result has the correct sign. Bits above the 1477 sign bit are junk now; ignore them. If the sum is 1478 positive, make sure we did not have all negative inputs; 1479 if the sum is negative, make sure we did not have all 1480 positive inputs. The test below looks only at the sign 1481 bits, and it really just 1482 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM) 1483 */ 1484 signmask = (fieldmask >> 1) + 1; 1485 if (((~ (a ^ b)) & (a ^ sum)) & signmask) 1486 flag = bfd_reloc_overflow; 1487 1488 break; 1489 1490 case complain_overflow_unsigned: 1491 /* Checking for an unsigned overflow is relatively easy: 1492 trim the addresses and add, and trim the result as well. 1493 Overflow is normally indicated when the result does not 1494 fit in the field. However, we also need to consider the 1495 case when, e.g., fieldmask is 0x7fffffff or smaller, an 1496 input is 0x80000000, and bfd_vma is only 32 bits; then we 1497 will get sum == 0, but there is an overflow, since the 1498 inputs did not fit in the field. Instead of doing a 1499 separate test, we can check for this by or-ing in the 1500 operands when testing for the sum overflowing its final 1501 field. */ 1502 a = (a & addrmask) >> rightshift; 1503 b = (b & addrmask) >> bitpos; 1504 sum = (a + b) & addrmask; 1505 if ((a | b | sum) & ~ fieldmask) 1506 flag = bfd_reloc_overflow; 1507 1508 break; 1509 1510 case complain_overflow_bitfield: 1511 /* Much like the signed check, but for a field one bit 1512 wider, and no trimming inputs with addrmask. We allow a 1513 bitfield to represent numbers in the range -2**n to 1514 2**n-1, where n is the number of bits in the field. 1515 Note that when bfd_vma is 32 bits, a 32-bit reloc can't 1516 overflow, which is exactly what we want. */ 1517 a >>= rightshift; 1518 1519 signmask = ~ fieldmask; 1520 ss = a & signmask; 1521 if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & signmask)) 1522 flag = bfd_reloc_overflow; 1523 1524 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask; 1525 b = (b ^ signmask) - signmask; 1526 1527 b >>= bitpos; 1528 1529 sum = a + b; 1530 1531 /* We mask with addrmask here to explicitly allow an address 1532 wrap-around. The Linux kernel relies on it, and it is 1533 the only way to write assembler code which can run when 1534 loaded at a location 0x80000000 away from the location at 1535 which it is linked. */ 1536 signmask = fieldmask + 1; 1537 if (((~ (a ^ b)) & (a ^ sum)) & signmask & addrmask) 1538 flag = bfd_reloc_overflow; 1539 1540 break; 1541 1542 default: 1543 abort (); 1544 } 1545 } 1546 1547 /* Put RELOCATION in the right bits. */ 1548 relocation >>= (bfd_vma) rightshift; 1549 relocation <<= (bfd_vma) bitpos; 1550 1551 /* Add RELOCATION to the right bits of X. */ 1552 x = ((x & ~howto->dst_mask) 1553 | (((x & howto->src_mask) + relocation) & howto->dst_mask)); 1554 1555 /* Put the relocated value back in the object file. */ 1556 switch (size) 1557 { 1558 default: 1559 case 0: 1560 abort (); 1561 case 1: 1562 bfd_put_8 (input_bfd, x, location); 1563 break; 1564 case 2: 1565 bfd_put_16 (input_bfd, x, location); 1566 break; 1567 case 4: 1568 bfd_put_32 (input_bfd, x, location); 1569 break; 1570 case 8: 1571 #ifdef BFD64 1572 bfd_put_64 (input_bfd, x, location); 1573 #else 1574 abort (); 1575 #endif 1576 break; 1577 } 1578 1579 return flag; 1580 } 1581 1582 /* 1583 DOCDD 1584 INODE 1585 howto manager, , typedef arelent, Relocations 1586 1587 SECTION 1588 The howto manager 1589 1590 When an application wants to create a relocation, but doesn't 1591 know what the target machine might call it, it can find out by 1592 using this bit of code. 1593 1594 */ 1595 1596 /* 1597 TYPEDEF 1598 bfd_reloc_code_type 1599 1600 DESCRIPTION 1601 The insides of a reloc code. The idea is that, eventually, there 1602 will be one enumerator for every type of relocation we ever do. 1603 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll 1604 return a howto pointer. 1605 1606 This does mean that the application must determine the correct 1607 enumerator value; you can't get a howto pointer from a random set 1608 of attributes. 1609 1610 SENUM 1611 bfd_reloc_code_real 1612 1613 ENUM 1614 BFD_RELOC_64 1615 ENUMX 1616 BFD_RELOC_32 1617 ENUMX 1618 BFD_RELOC_26 1619 ENUMX 1620 BFD_RELOC_24 1621 ENUMX 1622 BFD_RELOC_16 1623 ENUMX 1624 BFD_RELOC_14 1625 ENUMX 1626 BFD_RELOC_8 1627 ENUMDOC 1628 Basic absolute relocations of N bits. 1629 1630 ENUM 1631 BFD_RELOC_64_PCREL 1632 ENUMX 1633 BFD_RELOC_32_PCREL 1634 ENUMX 1635 BFD_RELOC_24_PCREL 1636 ENUMX 1637 BFD_RELOC_16_PCREL 1638 ENUMX 1639 BFD_RELOC_12_PCREL 1640 ENUMX 1641 BFD_RELOC_8_PCREL 1642 ENUMDOC 1643 PC-relative relocations. Sometimes these are relative to the address 1644 of the relocation itself; sometimes they are relative to the start of 1645 the section containing the relocation. It depends on the specific target. 1646 1647 The 24-bit relocation is used in some Intel 960 configurations. 1648 1649 ENUM 1650 BFD_RELOC_32_GOT_PCREL 1651 ENUMX 1652 BFD_RELOC_16_GOT_PCREL 1653 ENUMX 1654 BFD_RELOC_8_GOT_PCREL 1655 ENUMX 1656 BFD_RELOC_32_GOTOFF 1657 ENUMX 1658 BFD_RELOC_16_GOTOFF 1659 ENUMX 1660 BFD_RELOC_LO16_GOTOFF 1661 ENUMX 1662 BFD_RELOC_HI16_GOTOFF 1663 ENUMX 1664 BFD_RELOC_HI16_S_GOTOFF 1665 ENUMX 1666 BFD_RELOC_8_GOTOFF 1667 ENUMX 1668 BFD_RELOC_64_PLT_PCREL 1669 ENUMX 1670 BFD_RELOC_32_PLT_PCREL 1671 ENUMX 1672 BFD_RELOC_24_PLT_PCREL 1673 ENUMX 1674 BFD_RELOC_16_PLT_PCREL 1675 ENUMX 1676 BFD_RELOC_8_PLT_PCREL 1677 ENUMX 1678 BFD_RELOC_64_PLTOFF 1679 ENUMX 1680 BFD_RELOC_32_PLTOFF 1681 ENUMX 1682 BFD_RELOC_16_PLTOFF 1683 ENUMX 1684 BFD_RELOC_LO16_PLTOFF 1685 ENUMX 1686 BFD_RELOC_HI16_PLTOFF 1687 ENUMX 1688 BFD_RELOC_HI16_S_PLTOFF 1689 ENUMX 1690 BFD_RELOC_8_PLTOFF 1691 ENUMDOC 1692 For ELF. 1693 1694 ENUM 1695 BFD_RELOC_68K_GLOB_DAT 1696 ENUMX 1697 BFD_RELOC_68K_JMP_SLOT 1698 ENUMX 1699 BFD_RELOC_68K_RELATIVE 1700 ENUMDOC 1701 Relocations used by 68K ELF. 1702 1703 ENUM 1704 BFD_RELOC_32_BASEREL 1705 ENUMX 1706 BFD_RELOC_16_BASEREL 1707 ENUMX 1708 BFD_RELOC_LO16_BASEREL 1709 ENUMX 1710 BFD_RELOC_HI16_BASEREL 1711 ENUMX 1712 BFD_RELOC_HI16_S_BASEREL 1713 ENUMX 1714 BFD_RELOC_8_BASEREL 1715 ENUMX 1716 BFD_RELOC_RVA 1717 ENUMDOC 1718 Linkage-table relative. 1719 1720 ENUM 1721 BFD_RELOC_8_FFnn 1722 ENUMDOC 1723 Absolute 8-bit relocation, but used to form an address like 0xFFnn. 1724 1725 ENUM 1726 BFD_RELOC_32_PCREL_S2 1727 ENUMX 1728 BFD_RELOC_16_PCREL_S2 1729 ENUMX 1730 BFD_RELOC_23_PCREL_S2 1731 ENUMX 1732 BFD_RELOC_18_PCREL_S2 1733 ENUMX 1734 BFD_RELOC_28_PCREL_S2 1735 ENUMDOC 1736 These PC-relative relocations are stored as word displacements -- 1737 i.e., byte displacements shifted right two bits. The 30-bit word 1738 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the 1739 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The 1740 signed 16-bit displacement is used on the MIPS, and the 23-bit 1741 displacement is used on the Alpha. 1742 1743 ENUM 1744 BFD_RELOC_HI22 1745 ENUMX 1746 BFD_RELOC_LO10 1747 ENUMDOC 1748 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of 1749 the target word. These are used on the SPARC. 1750 1751 ENUM 1752 BFD_RELOC_GPREL16 1753 ENUMX 1754 BFD_RELOC_GPREL32 1755 ENUMDOC 1756 For systems that allocate a Global Pointer register, these are 1757 displacements off that register. These relocation types are 1758 handled specially, because the value the register will have is 1759 decided relatively late. 1760 1761 ENUM 1762 BFD_RELOC_I960_CALLJ 1763 ENUMDOC 1764 Reloc types used for i960/b.out. 1765 1766 ENUM 1767 BFD_RELOC_NONE 1768 ENUMX 1769 BFD_RELOC_SPARC_WDISP22 1770 ENUMX 1771 BFD_RELOC_SPARC22 1772 ENUMX 1773 BFD_RELOC_SPARC13 1774 ENUMX 1775 BFD_RELOC_SPARC_GOT10 1776 ENUMX 1777 BFD_RELOC_SPARC_GOT13 1778 ENUMX 1779 BFD_RELOC_SPARC_GOT22 1780 ENUMX 1781 BFD_RELOC_SPARC_PC10 1782 ENUMX 1783 BFD_RELOC_SPARC_PC22 1784 ENUMX 1785 BFD_RELOC_SPARC_WPLT30 1786 ENUMX 1787 BFD_RELOC_SPARC_COPY 1788 ENUMX 1789 BFD_RELOC_SPARC_GLOB_DAT 1790 ENUMX 1791 BFD_RELOC_SPARC_JMP_SLOT 1792 ENUMX 1793 BFD_RELOC_SPARC_RELATIVE 1794 ENUMX 1795 BFD_RELOC_SPARC_UA16 1796 ENUMX 1797 BFD_RELOC_SPARC_UA32 1798 ENUMX 1799 BFD_RELOC_SPARC_UA64 1800 ENUMDOC 1801 SPARC ELF relocations. There is probably some overlap with other 1802 relocation types already defined. 1803 1804 ENUM 1805 BFD_RELOC_SPARC_BASE13 1806 ENUMX 1807 BFD_RELOC_SPARC_BASE22 1808 ENUMDOC 1809 I think these are specific to SPARC a.out (e.g., Sun 4). 1810 1811 ENUMEQ 1812 BFD_RELOC_SPARC_64 1813 BFD_RELOC_64 1814 ENUMX 1815 BFD_RELOC_SPARC_10 1816 ENUMX 1817 BFD_RELOC_SPARC_11 1818 ENUMX 1819 BFD_RELOC_SPARC_OLO10 1820 ENUMX 1821 BFD_RELOC_SPARC_HH22 1822 ENUMX 1823 BFD_RELOC_SPARC_HM10 1824 ENUMX 1825 BFD_RELOC_SPARC_LM22 1826 ENUMX 1827 BFD_RELOC_SPARC_PC_HH22 1828 ENUMX 1829 BFD_RELOC_SPARC_PC_HM10 1830 ENUMX 1831 BFD_RELOC_SPARC_PC_LM22 1832 ENUMX 1833 BFD_RELOC_SPARC_WDISP16 1834 ENUMX 1835 BFD_RELOC_SPARC_WDISP19 1836 ENUMX 1837 BFD_RELOC_SPARC_7 1838 ENUMX 1839 BFD_RELOC_SPARC_6 1840 ENUMX 1841 BFD_RELOC_SPARC_5 1842 ENUMEQX 1843 BFD_RELOC_SPARC_DISP64 1844 BFD_RELOC_64_PCREL 1845 ENUMX 1846 BFD_RELOC_SPARC_PLT32 1847 ENUMX 1848 BFD_RELOC_SPARC_PLT64 1849 ENUMX 1850 BFD_RELOC_SPARC_HIX22 1851 ENUMX 1852 BFD_RELOC_SPARC_LOX10 1853 ENUMX 1854 BFD_RELOC_SPARC_H44 1855 ENUMX 1856 BFD_RELOC_SPARC_M44 1857 ENUMX 1858 BFD_RELOC_SPARC_L44 1859 ENUMX 1860 BFD_RELOC_SPARC_REGISTER 1861 ENUMDOC 1862 SPARC64 relocations 1863 1864 ENUM 1865 BFD_RELOC_SPARC_REV32 1866 ENUMDOC 1867 SPARC little endian relocation 1868 ENUM 1869 BFD_RELOC_SPARC_TLS_GD_HI22 1870 ENUMX 1871 BFD_RELOC_SPARC_TLS_GD_LO10 1872 ENUMX 1873 BFD_RELOC_SPARC_TLS_GD_ADD 1874 ENUMX 1875 BFD_RELOC_SPARC_TLS_GD_CALL 1876 ENUMX 1877 BFD_RELOC_SPARC_TLS_LDM_HI22 1878 ENUMX 1879 BFD_RELOC_SPARC_TLS_LDM_LO10 1880 ENUMX 1881 BFD_RELOC_SPARC_TLS_LDM_ADD 1882 ENUMX 1883 BFD_RELOC_SPARC_TLS_LDM_CALL 1884 ENUMX 1885 BFD_RELOC_SPARC_TLS_LDO_HIX22 1886 ENUMX 1887 BFD_RELOC_SPARC_TLS_LDO_LOX10 1888 ENUMX 1889 BFD_RELOC_SPARC_TLS_LDO_ADD 1890 ENUMX 1891 BFD_RELOC_SPARC_TLS_IE_HI22 1892 ENUMX 1893 BFD_RELOC_SPARC_TLS_IE_LO10 1894 ENUMX 1895 BFD_RELOC_SPARC_TLS_IE_LD 1896 ENUMX 1897 BFD_RELOC_SPARC_TLS_IE_LDX 1898 ENUMX 1899 BFD_RELOC_SPARC_TLS_IE_ADD 1900 ENUMX 1901 BFD_RELOC_SPARC_TLS_LE_HIX22 1902 ENUMX 1903 BFD_RELOC_SPARC_TLS_LE_LOX10 1904 ENUMX 1905 BFD_RELOC_SPARC_TLS_DTPMOD32 1906 ENUMX 1907 BFD_RELOC_SPARC_TLS_DTPMOD64 1908 ENUMX 1909 BFD_RELOC_SPARC_TLS_DTPOFF32 1910 ENUMX 1911 BFD_RELOC_SPARC_TLS_DTPOFF64 1912 ENUMX 1913 BFD_RELOC_SPARC_TLS_TPOFF32 1914 ENUMX 1915 BFD_RELOC_SPARC_TLS_TPOFF64 1916 ENUMDOC 1917 SPARC TLS relocations 1918 1919 ENUM 1920 BFD_RELOC_ALPHA_GPDISP_HI16 1921 ENUMDOC 1922 Alpha ECOFF and ELF relocations. Some of these treat the symbol or 1923 "addend" in some special way. 1924 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when 1925 writing; when reading, it will be the absolute section symbol. The 1926 addend is the displacement in bytes of the "lda" instruction from 1927 the "ldah" instruction (which is at the address of this reloc). 1928 ENUM 1929 BFD_RELOC_ALPHA_GPDISP_LO16 1930 ENUMDOC 1931 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as 1932 with GPDISP_HI16 relocs. The addend is ignored when writing the 1933 relocations out, and is filled in with the file's GP value on 1934 reading, for convenience. 1935 1936 ENUM 1937 BFD_RELOC_ALPHA_GPDISP 1938 ENUMDOC 1939 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 1940 relocation except that there is no accompanying GPDISP_LO16 1941 relocation. 1942 1943 ENUM 1944 BFD_RELOC_ALPHA_LITERAL 1945 ENUMX 1946 BFD_RELOC_ALPHA_ELF_LITERAL 1947 ENUMX 1948 BFD_RELOC_ALPHA_LITUSE 1949 ENUMDOC 1950 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; 1951 the assembler turns it into a LDQ instruction to load the address of 1952 the symbol, and then fills in a register in the real instruction. 1953 1954 The LITERAL reloc, at the LDQ instruction, refers to the .lita 1955 section symbol. The addend is ignored when writing, but is filled 1956 in with the file's GP value on reading, for convenience, as with the 1957 GPDISP_LO16 reloc. 1958 1959 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16. 1960 It should refer to the symbol to be referenced, as with 16_GOTOFF, 1961 but it generates output not based on the position within the .got 1962 section, but relative to the GP value chosen for the file during the 1963 final link stage. 1964 1965 The LITUSE reloc, on the instruction using the loaded address, gives 1966 information to the linker that it might be able to use to optimize 1967 away some literal section references. The symbol is ignored (read 1968 as the absolute section symbol), and the "addend" indicates the type 1969 of instruction using the register: 1970 1 - "memory" fmt insn 1971 2 - byte-manipulation (byte offset reg) 1972 3 - jsr (target of branch) 1973 1974 ENUM 1975 BFD_RELOC_ALPHA_HINT 1976 ENUMDOC 1977 The HINT relocation indicates a value that should be filled into the 1978 "hint" field of a jmp/jsr/ret instruction, for possible branch- 1979 prediction logic which may be provided on some processors. 1980 1981 ENUM 1982 BFD_RELOC_ALPHA_LINKAGE 1983 ENUMDOC 1984 The LINKAGE relocation outputs a linkage pair in the object file, 1985 which is filled by the linker. 1986 1987 ENUM 1988 BFD_RELOC_ALPHA_CODEADDR 1989 ENUMDOC 1990 The CODEADDR relocation outputs a STO_CA in the object file, 1991 which is filled by the linker. 1992 1993 ENUM 1994 BFD_RELOC_ALPHA_GPREL_HI16 1995 ENUMX 1996 BFD_RELOC_ALPHA_GPREL_LO16 1997 ENUMDOC 1998 The GPREL_HI/LO relocations together form a 32-bit offset from the 1999 GP register. 2000 2001 ENUM 2002 BFD_RELOC_ALPHA_BRSGP 2003 ENUMDOC 2004 Like BFD_RELOC_23_PCREL_S2, except that the source and target must 2005 share a common GP, and the target address is adjusted for 2006 STO_ALPHA_STD_GPLOAD. 2007 2008 ENUM 2009 BFD_RELOC_ALPHA_TLSGD 2010 ENUMX 2011 BFD_RELOC_ALPHA_TLSLDM 2012 ENUMX 2013 BFD_RELOC_ALPHA_DTPMOD64 2014 ENUMX 2015 BFD_RELOC_ALPHA_GOTDTPREL16 2016 ENUMX 2017 BFD_RELOC_ALPHA_DTPREL64 2018 ENUMX 2019 BFD_RELOC_ALPHA_DTPREL_HI16 2020 ENUMX 2021 BFD_RELOC_ALPHA_DTPREL_LO16 2022 ENUMX 2023 BFD_RELOC_ALPHA_DTPREL16 2024 ENUMX 2025 BFD_RELOC_ALPHA_GOTTPREL16 2026 ENUMX 2027 BFD_RELOC_ALPHA_TPREL64 2028 ENUMX 2029 BFD_RELOC_ALPHA_TPREL_HI16 2030 ENUMX 2031 BFD_RELOC_ALPHA_TPREL_LO16 2032 ENUMX 2033 BFD_RELOC_ALPHA_TPREL16 2034 ENUMDOC 2035 Alpha thread-local storage relocations. 2036 2037 ENUM 2038 BFD_RELOC_MIPS_JMP 2039 ENUMDOC 2040 Bits 27..2 of the relocation address shifted right 2 bits; 2041 simple reloc otherwise. 2042 2043 ENUM 2044 BFD_RELOC_MIPS16_JMP 2045 ENUMDOC 2046 The MIPS16 jump instruction. 2047 2048 ENUM 2049 BFD_RELOC_MIPS16_GPREL 2050 ENUMDOC 2051 MIPS16 GP relative reloc. 2052 2053 ENUM 2054 BFD_RELOC_HI16 2055 ENUMDOC 2056 High 16 bits of 32-bit value; simple reloc. 2057 ENUM 2058 BFD_RELOC_HI16_S 2059 ENUMDOC 2060 High 16 bits of 32-bit value but the low 16 bits will be sign 2061 extended and added to form the final result. If the low 16 2062 bits form a negative number, we need to add one to the high value 2063 to compensate for the borrow when the low bits are added. 2064 ENUM 2065 BFD_RELOC_LO16 2066 ENUMDOC 2067 Low 16 bits. 2068 ENUM 2069 BFD_RELOC_PCREL_HI16_S 2070 ENUMDOC 2071 Like BFD_RELOC_HI16_S, but PC relative. 2072 ENUM 2073 BFD_RELOC_PCREL_LO16 2074 ENUMDOC 2075 Like BFD_RELOC_LO16, but PC relative. 2076 2077 ENUM 2078 BFD_RELOC_MIPS_LITERAL 2079 ENUMDOC 2080 Relocation against a MIPS literal section. 2081 2082 ENUM 2083 BFD_RELOC_MIPS_GOT16 2084 ENUMX 2085 BFD_RELOC_MIPS_CALL16 2086 ENUMX 2087 BFD_RELOC_MIPS_GOT_HI16 2088 ENUMX 2089 BFD_RELOC_MIPS_GOT_LO16 2090 ENUMX 2091 BFD_RELOC_MIPS_CALL_HI16 2092 ENUMX 2093 BFD_RELOC_MIPS_CALL_LO16 2094 ENUMX 2095 BFD_RELOC_MIPS_SUB 2096 ENUMX 2097 BFD_RELOC_MIPS_GOT_PAGE 2098 ENUMX 2099 BFD_RELOC_MIPS_GOT_OFST 2100 ENUMX 2101 BFD_RELOC_MIPS_GOT_DISP 2102 ENUMX 2103 BFD_RELOC_MIPS_SHIFT5 2104 ENUMX 2105 BFD_RELOC_MIPS_SHIFT6 2106 ENUMX 2107 BFD_RELOC_MIPS_INSERT_A 2108 ENUMX 2109 BFD_RELOC_MIPS_INSERT_B 2110 ENUMX 2111 BFD_RELOC_MIPS_DELETE 2112 ENUMX 2113 BFD_RELOC_MIPS_HIGHEST 2114 ENUMX 2115 BFD_RELOC_MIPS_HIGHER 2116 ENUMX 2117 BFD_RELOC_MIPS_SCN_DISP 2118 ENUMX 2119 BFD_RELOC_MIPS_REL16 2120 ENUMX 2121 BFD_RELOC_MIPS_RELGOT 2122 ENUMX 2123 BFD_RELOC_MIPS_JALR 2124 ENUMDOC 2125 MIPS ELF relocations. 2126 COMMENT 2127 2128 ENUM 2129 BFD_RELOC_FRV_LABEL16 2130 ENUMX 2131 BFD_RELOC_FRV_LABEL24 2132 ENUMX 2133 BFD_RELOC_FRV_LO16 2134 ENUMX 2135 BFD_RELOC_FRV_HI16 2136 ENUMX 2137 BFD_RELOC_FRV_GPREL12 2138 ENUMX 2139 BFD_RELOC_FRV_GPRELU12 2140 ENUMX 2141 BFD_RELOC_FRV_GPREL32 2142 ENUMX 2143 BFD_RELOC_FRV_GPRELHI 2144 ENUMX 2145 BFD_RELOC_FRV_GPRELLO 2146 ENUMX 2147 BFD_RELOC_FRV_GOT12 2148 ENUMX 2149 BFD_RELOC_FRV_GOTHI 2150 ENUMX 2151 BFD_RELOC_FRV_GOTLO 2152 ENUMX 2153 BFD_RELOC_FRV_FUNCDESC 2154 ENUMX 2155 BFD_RELOC_FRV_FUNCDESC_GOT12 2156 ENUMX 2157 BFD_RELOC_FRV_FUNCDESC_GOTHI 2158 ENUMX 2159 BFD_RELOC_FRV_FUNCDESC_GOTLO 2160 ENUMX 2161 BFD_RELOC_FRV_FUNCDESC_VALUE 2162 ENUMX 2163 BFD_RELOC_FRV_FUNCDESC_GOTOFF12 2164 ENUMX 2165 BFD_RELOC_FRV_FUNCDESC_GOTOFFHI 2166 ENUMX 2167 BFD_RELOC_FRV_FUNCDESC_GOTOFFLO 2168 ENUMX 2169 BFD_RELOC_FRV_GOTOFF12 2170 ENUMX 2171 BFD_RELOC_FRV_GOTOFFHI 2172 ENUMX 2173 BFD_RELOC_FRV_GOTOFFLO 2174 ENUMDOC 2175 Fujitsu Frv Relocations. 2176 COMMENT 2177 2178 ENUM 2179 BFD_RELOC_MN10300_GOTOFF24 2180 ENUMDOC 2181 This is a 24bit GOT-relative reloc for the mn10300. 2182 ENUM 2183 BFD_RELOC_MN10300_GOT32 2184 ENUMDOC 2185 This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes 2186 in the instruction. 2187 ENUM 2188 BFD_RELOC_MN10300_GOT24 2189 ENUMDOC 2190 This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes 2191 in the instruction. 2192 ENUM 2193 BFD_RELOC_MN10300_GOT16 2194 ENUMDOC 2195 This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes 2196 in the instruction. 2197 ENUM 2198 BFD_RELOC_MN10300_COPY 2199 ENUMDOC 2200 Copy symbol at runtime. 2201 ENUM 2202 BFD_RELOC_MN10300_GLOB_DAT 2203 ENUMDOC 2204 Create GOT entry. 2205 ENUM 2206 BFD_RELOC_MN10300_JMP_SLOT 2207 ENUMDOC 2208 Create PLT entry. 2209 ENUM 2210 BFD_RELOC_MN10300_RELATIVE 2211 ENUMDOC 2212 Adjust by program base. 2213 COMMENT 2214 2215 ENUM 2216 BFD_RELOC_386_GOT32 2217 ENUMX 2218 BFD_RELOC_386_PLT32 2219 ENUMX 2220 BFD_RELOC_386_COPY 2221 ENUMX 2222 BFD_RELOC_386_GLOB_DAT 2223 ENUMX 2224 BFD_RELOC_386_JUMP_SLOT 2225 ENUMX 2226 BFD_RELOC_386_RELATIVE 2227 ENUMX 2228 BFD_RELOC_386_GOTOFF 2229 ENUMX 2230 BFD_RELOC_386_GOTPC 2231 ENUMX 2232 BFD_RELOC_386_TLS_TPOFF 2233 ENUMX 2234 BFD_RELOC_386_TLS_IE 2235 ENUMX 2236 BFD_RELOC_386_TLS_GOTIE 2237 ENUMX 2238 BFD_RELOC_386_TLS_LE 2239 ENUMX 2240 BFD_RELOC_386_TLS_GD 2241 ENUMX 2242 BFD_RELOC_386_TLS_LDM 2243 ENUMX 2244 BFD_RELOC_386_TLS_LDO_32 2245 ENUMX 2246 BFD_RELOC_386_TLS_IE_32 2247 ENUMX 2248 BFD_RELOC_386_TLS_LE_32 2249 ENUMX 2250 BFD_RELOC_386_TLS_DTPMOD32 2251 ENUMX 2252 BFD_RELOC_386_TLS_DTPOFF32 2253 ENUMX 2254 BFD_RELOC_386_TLS_TPOFF32 2255 ENUMDOC 2256 i386/elf relocations 2257 2258 ENUM 2259 BFD_RELOC_X86_64_GOT32 2260 ENUMX 2261 BFD_RELOC_X86_64_PLT32 2262 ENUMX 2263 BFD_RELOC_X86_64_COPY 2264 ENUMX 2265 BFD_RELOC_X86_64_GLOB_DAT 2266 ENUMX 2267 BFD_RELOC_X86_64_JUMP_SLOT 2268 ENUMX 2269 BFD_RELOC_X86_64_RELATIVE 2270 ENUMX 2271 BFD_RELOC_X86_64_GOTPCREL 2272 ENUMX 2273 BFD_RELOC_X86_64_32S 2274 ENUMX 2275 BFD_RELOC_X86_64_DTPMOD64 2276 ENUMX 2277 BFD_RELOC_X86_64_DTPOFF64 2278 ENUMX 2279 BFD_RELOC_X86_64_TPOFF64 2280 ENUMX 2281 BFD_RELOC_X86_64_TLSGD 2282 ENUMX 2283 BFD_RELOC_X86_64_TLSLD 2284 ENUMX 2285 BFD_RELOC_X86_64_DTPOFF32 2286 ENUMX 2287 BFD_RELOC_X86_64_GOTTPOFF 2288 ENUMX 2289 BFD_RELOC_X86_64_TPOFF32 2290 ENUMDOC 2291 x86-64/elf relocations 2292 2293 ENUM 2294 BFD_RELOC_NS32K_IMM_8 2295 ENUMX 2296 BFD_RELOC_NS32K_IMM_16 2297 ENUMX 2298 BFD_RELOC_NS32K_IMM_32 2299 ENUMX 2300 BFD_RELOC_NS32K_IMM_8_PCREL 2301 ENUMX 2302 BFD_RELOC_NS32K_IMM_16_PCREL 2303 ENUMX 2304 BFD_RELOC_NS32K_IMM_32_PCREL 2305 ENUMX 2306 BFD_RELOC_NS32K_DISP_8 2307 ENUMX 2308 BFD_RELOC_NS32K_DISP_16 2309 ENUMX 2310 BFD_RELOC_NS32K_DISP_32 2311 ENUMX 2312 BFD_RELOC_NS32K_DISP_8_PCREL 2313 ENUMX 2314 BFD_RELOC_NS32K_DISP_16_PCREL 2315 ENUMX 2316 BFD_RELOC_NS32K_DISP_32_PCREL 2317 ENUMDOC 2318 ns32k relocations 2319 2320 ENUM 2321 BFD_RELOC_PDP11_DISP_8_PCREL 2322 ENUMX 2323 BFD_RELOC_PDP11_DISP_6_PCREL 2324 ENUMDOC 2325 PDP11 relocations 2326 2327 ENUM 2328 BFD_RELOC_PJ_CODE_HI16 2329 ENUMX 2330 BFD_RELOC_PJ_CODE_LO16 2331 ENUMX 2332 BFD_RELOC_PJ_CODE_DIR16 2333 ENUMX 2334 BFD_RELOC_PJ_CODE_DIR32 2335 ENUMX 2336 BFD_RELOC_PJ_CODE_REL16 2337 ENUMX 2338 BFD_RELOC_PJ_CODE_REL32 2339 ENUMDOC 2340 Picojava relocs. Not all of these appear in object files. 2341 2342 ENUM 2343 BFD_RELOC_PPC_B26 2344 ENUMX 2345 BFD_RELOC_PPC_BA26 2346 ENUMX 2347 BFD_RELOC_PPC_TOC16 2348 ENUMX 2349 BFD_RELOC_PPC_B16 2350 ENUMX 2351 BFD_RELOC_PPC_B16_BRTAKEN 2352 ENUMX 2353 BFD_RELOC_PPC_B16_BRNTAKEN 2354 ENUMX 2355 BFD_RELOC_PPC_BA16 2356 ENUMX 2357 BFD_RELOC_PPC_BA16_BRTAKEN 2358 ENUMX 2359 BFD_RELOC_PPC_BA16_BRNTAKEN 2360 ENUMX 2361 BFD_RELOC_PPC_COPY 2362 ENUMX 2363 BFD_RELOC_PPC_GLOB_DAT 2364 ENUMX 2365 BFD_RELOC_PPC_JMP_SLOT 2366 ENUMX 2367 BFD_RELOC_PPC_RELATIVE 2368 ENUMX 2369 BFD_RELOC_PPC_LOCAL24PC 2370 ENUMX 2371 BFD_RELOC_PPC_EMB_NADDR32 2372 ENUMX 2373 BFD_RELOC_PPC_EMB_NADDR16 2374 ENUMX 2375 BFD_RELOC_PPC_EMB_NADDR16_LO 2376 ENUMX 2377 BFD_RELOC_PPC_EMB_NADDR16_HI 2378 ENUMX 2379 BFD_RELOC_PPC_EMB_NADDR16_HA 2380 ENUMX 2381 BFD_RELOC_PPC_EMB_SDAI16 2382 ENUMX 2383 BFD_RELOC_PPC_EMB_SDA2I16 2384 ENUMX 2385 BFD_RELOC_PPC_EMB_SDA2REL 2386 ENUMX 2387 BFD_RELOC_PPC_EMB_SDA21 2388 ENUMX 2389 BFD_RELOC_PPC_EMB_MRKREF 2390 ENUMX 2391 BFD_RELOC_PPC_EMB_RELSEC16 2392 ENUMX 2393 BFD_RELOC_PPC_EMB_RELST_LO 2394 ENUMX 2395 BFD_RELOC_PPC_EMB_RELST_HI 2396 ENUMX 2397 BFD_RELOC_PPC_EMB_RELST_HA 2398 ENUMX 2399 BFD_RELOC_PPC_EMB_BIT_FLD 2400 ENUMX 2401 BFD_RELOC_PPC_EMB_RELSDA 2402 ENUMX 2403 BFD_RELOC_PPC64_HIGHER 2404 ENUMX 2405 BFD_RELOC_PPC64_HIGHER_S 2406 ENUMX 2407 BFD_RELOC_PPC64_HIGHEST 2408 ENUMX 2409 BFD_RELOC_PPC64_HIGHEST_S 2410 ENUMX 2411 BFD_RELOC_PPC64_TOC16_LO 2412 ENUMX 2413 BFD_RELOC_PPC64_TOC16_HI 2414 ENUMX 2415 BFD_RELOC_PPC64_TOC16_HA 2416 ENUMX 2417 BFD_RELOC_PPC64_TOC 2418 ENUMX 2419 BFD_RELOC_PPC64_PLTGOT16 2420 ENUMX 2421 BFD_RELOC_PPC64_PLTGOT16_LO 2422 ENUMX 2423 BFD_RELOC_PPC64_PLTGOT16_HI 2424 ENUMX 2425 BFD_RELOC_PPC64_PLTGOT16_HA 2426 ENUMX 2427 BFD_RELOC_PPC64_ADDR16_DS 2428 ENUMX 2429 BFD_RELOC_PPC64_ADDR16_LO_DS 2430 ENUMX 2431 BFD_RELOC_PPC64_GOT16_DS 2432 ENUMX 2433 BFD_RELOC_PPC64_GOT16_LO_DS 2434 ENUMX 2435 BFD_RELOC_PPC64_PLT16_LO_DS 2436 ENUMX 2437 BFD_RELOC_PPC64_SECTOFF_DS 2438 ENUMX 2439 BFD_RELOC_PPC64_SECTOFF_LO_DS 2440 ENUMX 2441 BFD_RELOC_PPC64_TOC16_DS 2442 ENUMX 2443 BFD_RELOC_PPC64_TOC16_LO_DS 2444 ENUMX 2445 BFD_RELOC_PPC64_PLTGOT16_DS 2446 ENUMX 2447 BFD_RELOC_PPC64_PLTGOT16_LO_DS 2448 ENUMDOC 2449 Power(rs6000) and PowerPC relocations. 2450 2451 ENUM 2452 BFD_RELOC_PPC_TLS 2453 ENUMX 2454 BFD_RELOC_PPC_DTPMOD 2455 ENUMX 2456 BFD_RELOC_PPC_TPREL16 2457 ENUMX 2458 BFD_RELOC_PPC_TPREL16_LO 2459 ENUMX 2460 BFD_RELOC_PPC_TPREL16_HI 2461 ENUMX 2462 BFD_RELOC_PPC_TPREL16_HA 2463 ENUMX 2464 BFD_RELOC_PPC_TPREL 2465 ENUMX 2466 BFD_RELOC_PPC_DTPREL16 2467 ENUMX 2468 BFD_RELOC_PPC_DTPREL16_LO 2469 ENUMX 2470 BFD_RELOC_PPC_DTPREL16_HI 2471 ENUMX 2472 BFD_RELOC_PPC_DTPREL16_HA 2473 ENUMX 2474 BFD_RELOC_PPC_DTPREL 2475 ENUMX 2476 BFD_RELOC_PPC_GOT_TLSGD16 2477 ENUMX 2478 BFD_RELOC_PPC_GOT_TLSGD16_LO 2479 ENUMX 2480 BFD_RELOC_PPC_GOT_TLSGD16_HI 2481 ENUMX 2482 BFD_RELOC_PPC_GOT_TLSGD16_HA 2483 ENUMX 2484 BFD_RELOC_PPC_GOT_TLSLD16 2485 ENUMX 2486 BFD_RELOC_PPC_GOT_TLSLD16_LO 2487 ENUMX 2488 BFD_RELOC_PPC_GOT_TLSLD16_HI 2489 ENUMX 2490 BFD_RELOC_PPC_GOT_TLSLD16_HA 2491 ENUMX 2492 BFD_RELOC_PPC_GOT_TPREL16 2493 ENUMX 2494 BFD_RELOC_PPC_GOT_TPREL16_LO 2495 ENUMX 2496 BFD_RELOC_PPC_GOT_TPREL16_HI 2497 ENUMX 2498 BFD_RELOC_PPC_GOT_TPREL16_HA 2499 ENUMX 2500 BFD_RELOC_PPC_GOT_DTPREL16 2501 ENUMX 2502 BFD_RELOC_PPC_GOT_DTPREL16_LO 2503 ENUMX 2504 BFD_RELOC_PPC_GOT_DTPREL16_HI 2505 ENUMX 2506 BFD_RELOC_PPC_GOT_DTPREL16_HA 2507 ENUMX 2508 BFD_RELOC_PPC64_TPREL16_DS 2509 ENUMX 2510 BFD_RELOC_PPC64_TPREL16_LO_DS 2511 ENUMX 2512 BFD_RELOC_PPC64_TPREL16_HIGHER 2513 ENUMX 2514 BFD_RELOC_PPC64_TPREL16_HIGHERA 2515 ENUMX 2516 BFD_RELOC_PPC64_TPREL16_HIGHEST 2517 ENUMX 2518 BFD_RELOC_PPC64_TPREL16_HIGHESTA 2519 ENUMX 2520 BFD_RELOC_PPC64_DTPREL16_DS 2521 ENUMX 2522 BFD_RELOC_PPC64_DTPREL16_LO_DS 2523 ENUMX 2524 BFD_RELOC_PPC64_DTPREL16_HIGHER 2525 ENUMX 2526 BFD_RELOC_PPC64_DTPREL16_HIGHERA 2527 ENUMX 2528 BFD_RELOC_PPC64_DTPREL16_HIGHEST 2529 ENUMX 2530 BFD_RELOC_PPC64_DTPREL16_HIGHESTA 2531 ENUMDOC 2532 PowerPC and PowerPC64 thread-local storage relocations. 2533 2534 ENUM 2535 BFD_RELOC_I370_D12 2536 ENUMDOC 2537 IBM 370/390 relocations 2538 2539 ENUM 2540 BFD_RELOC_CTOR 2541 ENUMDOC 2542 The type of reloc used to build a constructor table - at the moment 2543 probably a 32 bit wide absolute relocation, but the target can choose. 2544 It generally does map to one of the other relocation types. 2545 2546 ENUM 2547 BFD_RELOC_ARM_PCREL_BRANCH 2548 ENUMDOC 2549 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are 2550 not stored in the instruction. 2551 ENUM 2552 BFD_RELOC_ARM_PCREL_BLX 2553 ENUMDOC 2554 ARM 26 bit pc-relative branch. The lowest bit must be zero and is 2555 not stored in the instruction. The 2nd lowest bit comes from a 1 bit 2556 field in the instruction. 2557 ENUM 2558 BFD_RELOC_THUMB_PCREL_BLX 2559 ENUMDOC 2560 Thumb 22 bit pc-relative branch. The lowest bit must be zero and is 2561 not stored in the instruction. The 2nd lowest bit comes from a 1 bit 2562 field in the instruction. 2563 ENUM 2564 BFD_RELOC_ARM_IMMEDIATE 2565 ENUMX 2566 BFD_RELOC_ARM_ADRL_IMMEDIATE 2567 ENUMX 2568 BFD_RELOC_ARM_OFFSET_IMM 2569 ENUMX 2570 BFD_RELOC_ARM_SHIFT_IMM 2571 ENUMX 2572 BFD_RELOC_ARM_SWI 2573 ENUMX 2574 BFD_RELOC_ARM_MULTI 2575 ENUMX 2576 BFD_RELOC_ARM_CP_OFF_IMM 2577 ENUMX 2578 BFD_RELOC_ARM_CP_OFF_IMM_S2 2579 ENUMX 2580 BFD_RELOC_ARM_ADR_IMM 2581 ENUMX 2582 BFD_RELOC_ARM_LDR_IMM 2583 ENUMX 2584 BFD_RELOC_ARM_LITERAL 2585 ENUMX 2586 BFD_RELOC_ARM_IN_POOL 2587 ENUMX 2588 BFD_RELOC_ARM_OFFSET_IMM8 2589 ENUMX 2590 BFD_RELOC_ARM_HWLITERAL 2591 ENUMX 2592 BFD_RELOC_ARM_THUMB_ADD 2593 ENUMX 2594 BFD_RELOC_ARM_THUMB_IMM 2595 ENUMX 2596 BFD_RELOC_ARM_THUMB_SHIFT 2597 ENUMX 2598 BFD_RELOC_ARM_THUMB_OFFSET 2599 ENUMX 2600 BFD_RELOC_ARM_GOT12 2601 ENUMX 2602 BFD_RELOC_ARM_GOT32 2603 ENUMX 2604 BFD_RELOC_ARM_JUMP_SLOT 2605 ENUMX 2606 BFD_RELOC_ARM_COPY 2607 ENUMX 2608 BFD_RELOC_ARM_GLOB_DAT 2609 ENUMX 2610 BFD_RELOC_ARM_PLT32 2611 ENUMX 2612 BFD_RELOC_ARM_RELATIVE 2613 ENUMX 2614 BFD_RELOC_ARM_GOTOFF 2615 ENUMX 2616 BFD_RELOC_ARM_GOTPC 2617 ENUMDOC 2618 These relocs are only used within the ARM assembler. They are not 2619 (at present) written to any object files. 2620 2621 ENUM 2622 BFD_RELOC_SH_PCDISP8BY2 2623 ENUMX 2624 BFD_RELOC_SH_PCDISP12BY2 2625 ENUMX 2626 BFD_RELOC_SH_IMM4 2627 ENUMX 2628 BFD_RELOC_SH_IMM4BY2 2629 ENUMX 2630 BFD_RELOC_SH_IMM4BY4 2631 ENUMX 2632 BFD_RELOC_SH_IMM8 2633 ENUMX 2634 BFD_RELOC_SH_IMM8BY2 2635 ENUMX 2636 BFD_RELOC_SH_IMM8BY4 2637 ENUMX 2638 BFD_RELOC_SH_PCRELIMM8BY2 2639 ENUMX 2640 BFD_RELOC_SH_PCRELIMM8BY4 2641 ENUMX 2642 BFD_RELOC_SH_SWITCH16 2643 ENUMX 2644 BFD_RELOC_SH_SWITCH32 2645 ENUMX 2646 BFD_RELOC_SH_USES 2647 ENUMX 2648 BFD_RELOC_SH_COUNT 2649 ENUMX 2650 BFD_RELOC_SH_ALIGN 2651 ENUMX 2652 BFD_RELOC_SH_CODE 2653 ENUMX 2654 BFD_RELOC_SH_DATA 2655 ENUMX 2656 BFD_RELOC_SH_LABEL 2657 ENUMX 2658 BFD_RELOC_SH_LOOP_START 2659 ENUMX 2660 BFD_RELOC_SH_LOOP_END 2661 ENUMX 2662 BFD_RELOC_SH_COPY 2663 ENUMX 2664 BFD_RELOC_SH_GLOB_DAT 2665 ENUMX 2666 BFD_RELOC_SH_JMP_SLOT 2667 ENUMX 2668 BFD_RELOC_SH_RELATIVE 2669 ENUMX 2670 BFD_RELOC_SH_GOTPC 2671 ENUMX 2672 BFD_RELOC_SH_GOT_LOW16 2673 ENUMX 2674 BFD_RELOC_SH_GOT_MEDLOW16 2675 ENUMX 2676 BFD_RELOC_SH_GOT_MEDHI16 2677 ENUMX 2678 BFD_RELOC_SH_GOT_HI16 2679 ENUMX 2680 BFD_RELOC_SH_GOTPLT_LOW16 2681 ENUMX 2682 BFD_RELOC_SH_GOTPLT_MEDLOW16 2683 ENUMX 2684 BFD_RELOC_SH_GOTPLT_MEDHI16 2685 ENUMX 2686 BFD_RELOC_SH_GOTPLT_HI16 2687 ENUMX 2688 BFD_RELOC_SH_PLT_LOW16 2689 ENUMX 2690 BFD_RELOC_SH_PLT_MEDLOW16 2691 ENUMX 2692 BFD_RELOC_SH_PLT_MEDHI16 2693 ENUMX 2694 BFD_RELOC_SH_PLT_HI16 2695 ENUMX 2696 BFD_RELOC_SH_GOTOFF_LOW16 2697 ENUMX 2698 BFD_RELOC_SH_GOTOFF_MEDLOW16 2699 ENUMX 2700 BFD_RELOC_SH_GOTOFF_MEDHI16 2701 ENUMX 2702 BFD_RELOC_SH_GOTOFF_HI16 2703 ENUMX 2704 BFD_RELOC_SH_GOTPC_LOW16 2705 ENUMX 2706 BFD_RELOC_SH_GOTPC_MEDLOW16 2707 ENUMX 2708 BFD_RELOC_SH_GOTPC_MEDHI16 2709 ENUMX 2710 BFD_RELOC_SH_GOTPC_HI16 2711 ENUMX 2712 BFD_RELOC_SH_COPY64 2713 ENUMX 2714 BFD_RELOC_SH_GLOB_DAT64 2715 ENUMX 2716 BFD_RELOC_SH_JMP_SLOT64 2717 ENUMX 2718 BFD_RELOC_SH_RELATIVE64 2719 ENUMX 2720 BFD_RELOC_SH_GOT10BY4 2721 ENUMX 2722 BFD_RELOC_SH_GOT10BY8 2723 ENUMX 2724 BFD_RELOC_SH_GOTPLT10BY4 2725 ENUMX 2726 BFD_RELOC_SH_GOTPLT10BY8 2727 ENUMX 2728 BFD_RELOC_SH_GOTPLT32 2729 ENUMX 2730 BFD_RELOC_SH_SHMEDIA_CODE 2731 ENUMX 2732 BFD_RELOC_SH_IMMU5 2733 ENUMX 2734 BFD_RELOC_SH_IMMS6 2735 ENUMX 2736 BFD_RELOC_SH_IMMS6BY32 2737 ENUMX 2738 BFD_RELOC_SH_IMMU6 2739 ENUMX 2740 BFD_RELOC_SH_IMMS10 2741 ENUMX 2742 BFD_RELOC_SH_IMMS10BY2 2743 ENUMX 2744 BFD_RELOC_SH_IMMS10BY4 2745 ENUMX 2746 BFD_RELOC_SH_IMMS10BY8 2747 ENUMX 2748 BFD_RELOC_SH_IMMS16 2749 ENUMX 2750 BFD_RELOC_SH_IMMU16 2751 ENUMX 2752 BFD_RELOC_SH_IMM_LOW16 2753 ENUMX 2754 BFD_RELOC_SH_IMM_LOW16_PCREL 2755 ENUMX 2756 BFD_RELOC_SH_IMM_MEDLOW16 2757 ENUMX 2758 BFD_RELOC_SH_IMM_MEDLOW16_PCREL 2759 ENUMX 2760 BFD_RELOC_SH_IMM_MEDHI16 2761 ENUMX 2762 BFD_RELOC_SH_IMM_MEDHI16_PCREL 2763 ENUMX 2764 BFD_RELOC_SH_IMM_HI16 2765 ENUMX 2766 BFD_RELOC_SH_IMM_HI16_PCREL 2767 ENUMX 2768 BFD_RELOC_SH_PT_16 2769 ENUMX 2770 BFD_RELOC_SH_TLS_GD_32 2771 ENUMX 2772 BFD_RELOC_SH_TLS_LD_32 2773 ENUMX 2774 BFD_RELOC_SH_TLS_LDO_32 2775 ENUMX 2776 BFD_RELOC_SH_TLS_IE_32 2777 ENUMX 2778 BFD_RELOC_SH_TLS_LE_32 2779 ENUMX 2780 BFD_RELOC_SH_TLS_DTPMOD32 2781 ENUMX 2782 BFD_RELOC_SH_TLS_DTPOFF32 2783 ENUMX 2784 BFD_RELOC_SH_TLS_TPOFF32 2785 ENUMDOC 2786 Renesas / SuperH SH relocs. Not all of these appear in object files. 2787 2788 ENUM 2789 BFD_RELOC_THUMB_PCREL_BRANCH9 2790 ENUMX 2791 BFD_RELOC_THUMB_PCREL_BRANCH12 2792 ENUMX 2793 BFD_RELOC_THUMB_PCREL_BRANCH23 2794 ENUMDOC 2795 Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must 2796 be zero and is not stored in the instruction. 2797 2798 ENUM 2799 BFD_RELOC_ARC_B22_PCREL 2800 ENUMDOC 2801 ARC Cores relocs. 2802 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are 2803 not stored in the instruction. The high 20 bits are installed in bits 26 2804 through 7 of the instruction. 2805 ENUM 2806 BFD_RELOC_ARC_B26 2807 ENUMDOC 2808 ARC 26 bit absolute branch. The lowest two bits must be zero and are not 2809 stored in the instruction. The high 24 bits are installed in bits 23 2810 through 0. 2811 2812 ENUM 2813 BFD_RELOC_D10V_10_PCREL_R 2814 ENUMDOC 2815 Mitsubishi D10V relocs. 2816 This is a 10-bit reloc with the right 2 bits 2817 assumed to be 0. 2818 ENUM 2819 BFD_RELOC_D10V_10_PCREL_L 2820 ENUMDOC 2821 Mitsubishi D10V relocs. 2822 This is a 10-bit reloc with the right 2 bits 2823 assumed to be 0. This is the same as the previous reloc 2824 except it is in the left container, i.e., 2825 shifted left 15 bits. 2826 ENUM 2827 BFD_RELOC_D10V_18 2828 ENUMDOC 2829 This is an 18-bit reloc with the right 2 bits 2830 assumed to be 0. 2831 ENUM 2832 BFD_RELOC_D10V_18_PCREL 2833 ENUMDOC 2834 This is an 18-bit reloc with the right 2 bits 2835 assumed to be 0. 2836 2837 ENUM 2838 BFD_RELOC_D30V_6 2839 ENUMDOC 2840 Mitsubishi D30V relocs. 2841 This is a 6-bit absolute reloc. 2842 ENUM 2843 BFD_RELOC_D30V_9_PCREL 2844 ENUMDOC 2845 This is a 6-bit pc-relative reloc with 2846 the right 3 bits assumed to be 0. 2847 ENUM 2848 BFD_RELOC_D30V_9_PCREL_R 2849 ENUMDOC 2850 This is a 6-bit pc-relative reloc with 2851 the right 3 bits assumed to be 0. Same 2852 as the previous reloc but on the right side 2853 of the container. 2854 ENUM 2855 BFD_RELOC_D30V_15 2856 ENUMDOC 2857 This is a 12-bit absolute reloc with the 2858 right 3 bitsassumed to be 0. 2859 ENUM 2860 BFD_RELOC_D30V_15_PCREL 2861 ENUMDOC 2862 This is a 12-bit pc-relative reloc with 2863 the right 3 bits assumed to be 0. 2864 ENUM 2865 BFD_RELOC_D30V_15_PCREL_R 2866 ENUMDOC 2867 This is a 12-bit pc-relative reloc with 2868 the right 3 bits assumed to be 0. Same 2869 as the previous reloc but on the right side 2870 of the container. 2871 ENUM 2872 BFD_RELOC_D30V_21 2873 ENUMDOC 2874 This is an 18-bit absolute reloc with 2875 the right 3 bits assumed to be 0. 2876 ENUM 2877 BFD_RELOC_D30V_21_PCREL 2878 ENUMDOC 2879 This is an 18-bit pc-relative reloc with 2880 the right 3 bits assumed to be 0. 2881 ENUM 2882 BFD_RELOC_D30V_21_PCREL_R 2883 ENUMDOC 2884 This is an 18-bit pc-relative reloc with 2885 the right 3 bits assumed to be 0. Same 2886 as the previous reloc but on the right side 2887 of the container. 2888 ENUM 2889 BFD_RELOC_D30V_32 2890 ENUMDOC 2891 This is a 32-bit absolute reloc. 2892 ENUM 2893 BFD_RELOC_D30V_32_PCREL 2894 ENUMDOC 2895 This is a 32-bit pc-relative reloc. 2896 2897 ENUM 2898 BFD_RELOC_DLX_HI16_S 2899 ENUMDOC 2900 DLX relocs 2901 ENUM 2902 BFD_RELOC_DLX_LO16 2903 ENUMDOC 2904 DLX relocs 2905 ENUM 2906 BFD_RELOC_DLX_JMP26 2907 ENUMDOC 2908 DLX relocs 2909 2910 ENUM 2911 BFD_RELOC_M32R_24 2912 ENUMDOC 2913 Renesas M32R (formerly Mitsubishi M32R) relocs. 2914 This is a 24 bit absolute address. 2915 ENUM 2916 BFD_RELOC_M32R_10_PCREL 2917 ENUMDOC 2918 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. 2919 ENUM 2920 BFD_RELOC_M32R_18_PCREL 2921 ENUMDOC 2922 This is an 18-bit reloc with the right 2 bits assumed to be 0. 2923 ENUM 2924 BFD_RELOC_M32R_26_PCREL 2925 ENUMDOC 2926 This is a 26-bit reloc with the right 2 bits assumed to be 0. 2927 ENUM 2928 BFD_RELOC_M32R_HI16_ULO 2929 ENUMDOC 2930 This is a 16-bit reloc containing the high 16 bits of an address 2931 used when the lower 16 bits are treated as unsigned. 2932 ENUM 2933 BFD_RELOC_M32R_HI16_SLO 2934 ENUMDOC 2935 This is a 16-bit reloc containing the high 16 bits of an address 2936 used when the lower 16 bits are treated as signed. 2937 ENUM 2938 BFD_RELOC_M32R_LO16 2939 ENUMDOC 2940 This is a 16-bit reloc containing the lower 16 bits of an address. 2941 ENUM 2942 BFD_RELOC_M32R_SDA16 2943 ENUMDOC 2944 This is a 16-bit reloc containing the small data area offset for use in 2945 add3, load, and store instructions. 2946 ENUM 2947 BFD_RELOC_M32R_GOT24 2948 ENUMX 2949 BFD_RELOC_M32R_26_PLTREL 2950 ENUMX 2951 BFD_RELOC_M32R_COPY 2952 ENUMX 2953 BFD_RELOC_M32R_GLOB_DAT 2954 ENUMX 2955 BFD_RELOC_M32R_JMP_SLOT 2956 ENUMX 2957 BFD_RELOC_M32R_RELATIVE 2958 ENUMX 2959 BFD_RELOC_M32R_GOTOFF 2960 ENUMX 2961 BFD_RELOC_M32R_GOTPC24 2962 ENUMX 2963 BFD_RELOC_M32R_GOT16_HI_ULO 2964 ENUMX 2965 BFD_RELOC_M32R_GOT16_HI_SLO 2966 ENUMX 2967 BFD_RELOC_M32R_GOT16_LO 2968 ENUMX 2969 BFD_RELOC_M32R_GOTPC_HI_ULO 2970 ENUMX 2971 BFD_RELOC_M32R_GOTPC_HI_SLO 2972 ENUMX 2973 BFD_RELOC_M32R_GOTPC_LO 2974 ENUMDOC 2975 For PIC. 2976 2977 2978 ENUM 2979 BFD_RELOC_V850_9_PCREL 2980 ENUMDOC 2981 This is a 9-bit reloc 2982 ENUM 2983 BFD_RELOC_V850_22_PCREL 2984 ENUMDOC 2985 This is a 22-bit reloc 2986 2987 ENUM 2988 BFD_RELOC_V850_SDA_16_16_OFFSET 2989 ENUMDOC 2990 This is a 16 bit offset from the short data area pointer. 2991 ENUM 2992 BFD_RELOC_V850_SDA_15_16_OFFSET 2993 ENUMDOC 2994 This is a 16 bit offset (of which only 15 bits are used) from the 2995 short data area pointer. 2996 ENUM 2997 BFD_RELOC_V850_ZDA_16_16_OFFSET 2998 ENUMDOC 2999 This is a 16 bit offset from the zero data area pointer. 3000 ENUM 3001 BFD_RELOC_V850_ZDA_15_16_OFFSET 3002 ENUMDOC 3003 This is a 16 bit offset (of which only 15 bits are used) from the 3004 zero data area pointer. 3005 ENUM 3006 BFD_RELOC_V850_TDA_6_8_OFFSET 3007 ENUMDOC 3008 This is an 8 bit offset (of which only 6 bits are used) from the 3009 tiny data area pointer. 3010 ENUM 3011 BFD_RELOC_V850_TDA_7_8_OFFSET 3012 ENUMDOC 3013 This is an 8bit offset (of which only 7 bits are used) from the tiny 3014 data area pointer. 3015 ENUM 3016 BFD_RELOC_V850_TDA_7_7_OFFSET 3017 ENUMDOC 3018 This is a 7 bit offset from the tiny data area pointer. 3019 ENUM 3020 BFD_RELOC_V850_TDA_16_16_OFFSET 3021 ENUMDOC 3022 This is a 16 bit offset from the tiny data area pointer. 3023 COMMENT 3024 ENUM 3025 BFD_RELOC_V850_TDA_4_5_OFFSET 3026 ENUMDOC 3027 This is a 5 bit offset (of which only 4 bits are used) from the tiny 3028 data area pointer. 3029 ENUM 3030 BFD_RELOC_V850_TDA_4_4_OFFSET 3031 ENUMDOC 3032 This is a 4 bit offset from the tiny data area pointer. 3033 ENUM 3034 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET 3035 ENUMDOC 3036 This is a 16 bit offset from the short data area pointer, with the 3037 bits placed non-contiguously in the instruction. 3038 ENUM 3039 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET 3040 ENUMDOC 3041 This is a 16 bit offset from the zero data area pointer, with the 3042 bits placed non-contiguously in the instruction. 3043 ENUM 3044 BFD_RELOC_V850_CALLT_6_7_OFFSET 3045 ENUMDOC 3046 This is a 6 bit offset from the call table base pointer. 3047 ENUM 3048 BFD_RELOC_V850_CALLT_16_16_OFFSET 3049 ENUMDOC 3050 This is a 16 bit offset from the call table base pointer. 3051 ENUM 3052 BFD_RELOC_V850_LONGCALL 3053 ENUMDOC 3054 Used for relaxing indirect function calls. 3055 ENUM 3056 BFD_RELOC_V850_LONGJUMP 3057 ENUMDOC 3058 Used for relaxing indirect jumps. 3059 ENUM 3060 BFD_RELOC_V850_ALIGN 3061 ENUMDOC 3062 Used to maintain alignment whilst relaxing. 3063 ENUM 3064 BFD_RELOC_MN10300_32_PCREL 3065 ENUMDOC 3066 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the 3067 instruction. 3068 ENUM 3069 BFD_RELOC_MN10300_16_PCREL 3070 ENUMDOC 3071 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the 3072 instruction. 3073 3074 ENUM 3075 BFD_RELOC_TIC30_LDP 3076 ENUMDOC 3077 This is a 8bit DP reloc for the tms320c30, where the most 3078 significant 8 bits of a 24 bit word are placed into the least 3079 significant 8 bits of the opcode. 3080 3081 ENUM 3082 BFD_RELOC_TIC54X_PARTLS7 3083 ENUMDOC 3084 This is a 7bit reloc for the tms320c54x, where the least 3085 significant 7 bits of a 16 bit word are placed into the least 3086 significant 7 bits of the opcode. 3087 3088 ENUM 3089 BFD_RELOC_TIC54X_PARTMS9 3090 ENUMDOC 3091 This is a 9bit DP reloc for the tms320c54x, where the most 3092 significant 9 bits of a 16 bit word are placed into the least 3093 significant 9 bits of the opcode. 3094 3095 ENUM 3096 BFD_RELOC_TIC54X_23 3097 ENUMDOC 3098 This is an extended address 23-bit reloc for the tms320c54x. 3099 3100 ENUM 3101 BFD_RELOC_TIC54X_16_OF_23 3102 ENUMDOC 3103 This is a 16-bit reloc for the tms320c54x, where the least 3104 significant 16 bits of a 23-bit extended address are placed into 3105 the opcode. 3106 3107 ENUM 3108 BFD_RELOC_TIC54X_MS7_OF_23 3109 ENUMDOC 3110 This is a reloc for the tms320c54x, where the most 3111 significant 7 bits of a 23-bit extended address are placed into 3112 the opcode. 3113 3114 ENUM 3115 BFD_RELOC_FR30_48 3116 ENUMDOC 3117 This is a 48 bit reloc for the FR30 that stores 32 bits. 3118 ENUM 3119 BFD_RELOC_FR30_20 3120 ENUMDOC 3121 This is a 32 bit reloc for the FR30 that stores 20 bits split up into 3122 two sections. 3123 ENUM 3124 BFD_RELOC_FR30_6_IN_4 3125 ENUMDOC 3126 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in 3127 4 bits. 3128 ENUM 3129 BFD_RELOC_FR30_8_IN_8 3130 ENUMDOC 3131 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset 3132 into 8 bits. 3133 ENUM 3134 BFD_RELOC_FR30_9_IN_8 3135 ENUMDOC 3136 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset 3137 into 8 bits. 3138 ENUM 3139 BFD_RELOC_FR30_10_IN_8 3140 ENUMDOC 3141 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset 3142 into 8 bits. 3143 ENUM 3144 BFD_RELOC_FR30_9_PCREL 3145 ENUMDOC 3146 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative 3147 short offset into 8 bits. 3148 ENUM 3149 BFD_RELOC_FR30_12_PCREL 3150 ENUMDOC 3151 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative 3152 short offset into 11 bits. 3153 3154 ENUM 3155 BFD_RELOC_MCORE_PCREL_IMM8BY4 3156 ENUMX 3157 BFD_RELOC_MCORE_PCREL_IMM11BY2 3158 ENUMX 3159 BFD_RELOC_MCORE_PCREL_IMM4BY2 3160 ENUMX 3161 BFD_RELOC_MCORE_PCREL_32 3162 ENUMX 3163 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2 3164 ENUMX 3165 BFD_RELOC_MCORE_RVA 3166 ENUMDOC 3167 Motorola Mcore relocations. 3168 3169 ENUM 3170 BFD_RELOC_MMIX_GETA 3171 ENUMX 3172 BFD_RELOC_MMIX_GETA_1 3173 ENUMX 3174 BFD_RELOC_MMIX_GETA_2 3175 ENUMX 3176 BFD_RELOC_MMIX_GETA_3 3177 ENUMDOC 3178 These are relocations for the GETA instruction. 3179 ENUM 3180 BFD_RELOC_MMIX_CBRANCH 3181 ENUMX 3182 BFD_RELOC_MMIX_CBRANCH_J 3183 ENUMX 3184 BFD_RELOC_MMIX_CBRANCH_1 3185 ENUMX 3186 BFD_RELOC_MMIX_CBRANCH_2 3187 ENUMX 3188 BFD_RELOC_MMIX_CBRANCH_3 3189 ENUMDOC 3190 These are relocations for a conditional branch instruction. 3191 ENUM 3192 BFD_RELOC_MMIX_PUSHJ 3193 ENUMX 3194 BFD_RELOC_MMIX_PUSHJ_1 3195 ENUMX 3196 BFD_RELOC_MMIX_PUSHJ_2 3197 ENUMX 3198 BFD_RELOC_MMIX_PUSHJ_3 3199 ENUMX 3200 BFD_RELOC_MMIX_PUSHJ_STUBBABLE 3201 ENUMDOC 3202 These are relocations for the PUSHJ instruction. 3203 ENUM 3204 BFD_RELOC_MMIX_JMP 3205 ENUMX 3206 BFD_RELOC_MMIX_JMP_1 3207 ENUMX 3208 BFD_RELOC_MMIX_JMP_2 3209 ENUMX 3210 BFD_RELOC_MMIX_JMP_3 3211 ENUMDOC 3212 These are relocations for the JMP instruction. 3213 ENUM 3214 BFD_RELOC_MMIX_ADDR19 3215 ENUMDOC 3216 This is a relocation for a relative address as in a GETA instruction or 3217 a branch. 3218 ENUM 3219 BFD_RELOC_MMIX_ADDR27 3220 ENUMDOC 3221 This is a relocation for a relative address as in a JMP instruction. 3222 ENUM 3223 BFD_RELOC_MMIX_REG_OR_BYTE 3224 ENUMDOC 3225 This is a relocation for an instruction field that may be a general 3226 register or a value 0..255. 3227 ENUM 3228 BFD_RELOC_MMIX_REG 3229 ENUMDOC 3230 This is a relocation for an instruction field that may be a general 3231 register. 3232 ENUM 3233 BFD_RELOC_MMIX_BASE_PLUS_OFFSET 3234 ENUMDOC 3235 This is a relocation for two instruction fields holding a register and 3236 an offset, the equivalent of the relocation. 3237 ENUM 3238 BFD_RELOC_MMIX_LOCAL 3239 ENUMDOC 3240 This relocation is an assertion that the expression is not allocated as 3241 a global register. It does not modify contents. 3242 3243 ENUM 3244 BFD_RELOC_AVR_7_PCREL 3245 ENUMDOC 3246 This is a 16 bit reloc for the AVR that stores 8 bit pc relative 3247 short offset into 7 bits. 3248 ENUM 3249 BFD_RELOC_AVR_13_PCREL 3250 ENUMDOC 3251 This is a 16 bit reloc for the AVR that stores 13 bit pc relative 3252 short offset into 12 bits. 3253 ENUM 3254 BFD_RELOC_AVR_16_PM 3255 ENUMDOC 3256 This is a 16 bit reloc for the AVR that stores 17 bit value (usually 3257 program memory address) into 16 bits. 3258 ENUM 3259 BFD_RELOC_AVR_LO8_LDI 3260 ENUMDOC 3261 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 3262 data memory address) into 8 bit immediate value of LDI insn. 3263 ENUM 3264 BFD_RELOC_AVR_HI8_LDI 3265 ENUMDOC 3266 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 3267 of data memory address) into 8 bit immediate value of LDI insn. 3268 ENUM 3269 BFD_RELOC_AVR_HH8_LDI 3270 ENUMDOC 3271 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 3272 of program memory address) into 8 bit immediate value of LDI insn. 3273 ENUM 3274 BFD_RELOC_AVR_LO8_LDI_NEG 3275 ENUMDOC 3276 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3277 (usually data memory address) into 8 bit immediate value of SUBI insn. 3278 ENUM 3279 BFD_RELOC_AVR_HI8_LDI_NEG 3280 ENUMDOC 3281 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3282 (high 8 bit of data memory address) into 8 bit immediate value of 3283 SUBI insn. 3284 ENUM 3285 BFD_RELOC_AVR_HH8_LDI_NEG 3286 ENUMDOC 3287 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3288 (most high 8 bit of program memory address) into 8 bit immediate value 3289 of LDI or SUBI insn. 3290 ENUM 3291 BFD_RELOC_AVR_LO8_LDI_PM 3292 ENUMDOC 3293 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 3294 command address) into 8 bit immediate value of LDI insn. 3295 ENUM 3296 BFD_RELOC_AVR_HI8_LDI_PM 3297 ENUMDOC 3298 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit 3299 of command address) into 8 bit immediate value of LDI insn. 3300 ENUM 3301 BFD_RELOC_AVR_HH8_LDI_PM 3302 ENUMDOC 3303 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit 3304 of command address) into 8 bit immediate value of LDI insn. 3305 ENUM 3306 BFD_RELOC_AVR_LO8_LDI_PM_NEG 3307 ENUMDOC 3308 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3309 (usually command address) into 8 bit immediate value of SUBI insn. 3310 ENUM 3311 BFD_RELOC_AVR_HI8_LDI_PM_NEG 3312 ENUMDOC 3313 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3314 (high 8 bit of 16 bit command address) into 8 bit immediate value 3315 of SUBI insn. 3316 ENUM 3317 BFD_RELOC_AVR_HH8_LDI_PM_NEG 3318 ENUMDOC 3319 This is a 16 bit reloc for the AVR that stores negated 8 bit value 3320 (high 6 bit of 22 bit command address) into 8 bit immediate 3321 value of SUBI insn. 3322 ENUM 3323 BFD_RELOC_AVR_CALL 3324 ENUMDOC 3325 This is a 32 bit reloc for the AVR that stores 23 bit value 3326 into 22 bits. 3327 3328 ENUM 3329 BFD_RELOC_390_12 3330 ENUMDOC 3331 Direct 12 bit. 3332 ENUM 3333 BFD_RELOC_390_GOT12 3334 ENUMDOC 3335 12 bit GOT offset. 3336 ENUM 3337 BFD_RELOC_390_PLT32 3338 ENUMDOC 3339 32 bit PC relative PLT address. 3340 ENUM 3341 BFD_RELOC_390_COPY 3342 ENUMDOC 3343 Copy symbol at runtime. 3344 ENUM 3345 BFD_RELOC_390_GLOB_DAT 3346 ENUMDOC 3347 Create GOT entry. 3348 ENUM 3349 BFD_RELOC_390_JMP_SLOT 3350 ENUMDOC 3351 Create PLT entry. 3352 ENUM 3353 BFD_RELOC_390_RELATIVE 3354 ENUMDOC 3355 Adjust by program base. 3356 ENUM 3357 BFD_RELOC_390_GOTPC 3358 ENUMDOC 3359 32 bit PC relative offset to GOT. 3360 ENUM 3361 BFD_RELOC_390_GOT16 3362 ENUMDOC 3363 16 bit GOT offset. 3364 ENUM 3365 BFD_RELOC_390_PC16DBL 3366 ENUMDOC 3367 PC relative 16 bit shifted by 1. 3368 ENUM 3369 BFD_RELOC_390_PLT16DBL 3370 ENUMDOC 3371 16 bit PC rel. PLT shifted by 1. 3372 ENUM 3373 BFD_RELOC_390_PC32DBL 3374 ENUMDOC 3375 PC relative 32 bit shifted by 1. 3376 ENUM 3377 BFD_RELOC_390_PLT32DBL 3378 ENUMDOC 3379 32 bit PC rel. PLT shifted by 1. 3380 ENUM 3381 BFD_RELOC_390_GOTPCDBL 3382 ENUMDOC 3383 32 bit PC rel. GOT shifted by 1. 3384 ENUM 3385 BFD_RELOC_390_GOT64 3386 ENUMDOC 3387 64 bit GOT offset. 3388 ENUM 3389 BFD_RELOC_390_PLT64 3390 ENUMDOC 3391 64 bit PC relative PLT address. 3392 ENUM 3393 BFD_RELOC_390_GOTENT 3394 ENUMDOC 3395 32 bit rel. offset to GOT entry. 3396 ENUM 3397 BFD_RELOC_390_GOTOFF64 3398 ENUMDOC 3399 64 bit offset to GOT. 3400 ENUM 3401 BFD_RELOC_390_GOTPLT12 3402 ENUMDOC 3403 12-bit offset to symbol-entry within GOT, with PLT handling. 3404 ENUM 3405 BFD_RELOC_390_GOTPLT16 3406 ENUMDOC 3407 16-bit offset to symbol-entry within GOT, with PLT handling. 3408 ENUM 3409 BFD_RELOC_390_GOTPLT32 3410 ENUMDOC 3411 32-bit offset to symbol-entry within GOT, with PLT handling. 3412 ENUM 3413 BFD_RELOC_390_GOTPLT64 3414 ENUMDOC 3415 64-bit offset to symbol-entry within GOT, with PLT handling. 3416 ENUM 3417 BFD_RELOC_390_GOTPLTENT 3418 ENUMDOC 3419 32-bit rel. offset to symbol-entry within GOT, with PLT handling. 3420 ENUM 3421 BFD_RELOC_390_PLTOFF16 3422 ENUMDOC 3423 16-bit rel. offset from the GOT to a PLT entry. 3424 ENUM 3425 BFD_RELOC_390_PLTOFF32 3426 ENUMDOC 3427 32-bit rel. offset from the GOT to a PLT entry. 3428 ENUM 3429 BFD_RELOC_390_PLTOFF64 3430 ENUMDOC 3431 64-bit rel. offset from the GOT to a PLT entry. 3432 3433 ENUM 3434 BFD_RELOC_390_TLS_LOAD 3435 ENUMX 3436 BFD_RELOC_390_TLS_GDCALL 3437 ENUMX 3438 BFD_RELOC_390_TLS_LDCALL 3439 ENUMX 3440 BFD_RELOC_390_TLS_GD32 3441 ENUMX 3442 BFD_RELOC_390_TLS_GD64 3443 ENUMX 3444 BFD_RELOC_390_TLS_GOTIE12 3445 ENUMX 3446 BFD_RELOC_390_TLS_GOTIE32 3447 ENUMX 3448 BFD_RELOC_390_TLS_GOTIE64 3449 ENUMX 3450 BFD_RELOC_390_TLS_LDM32 3451 ENUMX 3452 BFD_RELOC_390_TLS_LDM64 3453 ENUMX 3454 BFD_RELOC_390_TLS_IE32 3455 ENUMX 3456 BFD_RELOC_390_TLS_IE64 3457 ENUMX 3458 BFD_RELOC_390_TLS_IEENT 3459 ENUMX 3460 BFD_RELOC_390_TLS_LE32 3461 ENUMX 3462 BFD_RELOC_390_TLS_LE64 3463 ENUMX 3464 BFD_RELOC_390_TLS_LDO32 3465 ENUMX 3466 BFD_RELOC_390_TLS_LDO64 3467 ENUMX 3468 BFD_RELOC_390_TLS_DTPMOD 3469 ENUMX 3470 BFD_RELOC_390_TLS_DTPOFF 3471 ENUMX 3472 BFD_RELOC_390_TLS_TPOFF 3473 ENUMDOC 3474 s390 tls relocations. 3475 3476 ENUM 3477 BFD_RELOC_390_20 3478 ENUMX 3479 BFD_RELOC_390_GOT20 3480 ENUMX 3481 BFD_RELOC_390_GOTPLT20 3482 ENUMX 3483 BFD_RELOC_390_TLS_GOTIE20 3484 ENUMDOC 3485 Long displacement extension. 3486 3487 ENUM 3488 BFD_RELOC_IP2K_FR9 3489 ENUMDOC 3490 Scenix IP2K - 9-bit register number / data address 3491 ENUM 3492 BFD_RELOC_IP2K_BANK 3493 ENUMDOC 3494 Scenix IP2K - 4-bit register/data bank number 3495 ENUM 3496 BFD_RELOC_IP2K_ADDR16CJP 3497 ENUMDOC 3498 Scenix IP2K - low 13 bits of instruction word address 3499 ENUM 3500 BFD_RELOC_IP2K_PAGE3 3501 ENUMDOC 3502 Scenix IP2K - high 3 bits of instruction word address 3503 ENUM 3504 BFD_RELOC_IP2K_LO8DATA 3505 ENUMX 3506 BFD_RELOC_IP2K_HI8DATA 3507 ENUMX 3508 BFD_RELOC_IP2K_EX8DATA 3509 ENUMDOC 3510 Scenix IP2K - ext/low/high 8 bits of data address 3511 ENUM 3512 BFD_RELOC_IP2K_LO8INSN 3513 ENUMX 3514 BFD_RELOC_IP2K_HI8INSN 3515 ENUMDOC 3516 Scenix IP2K - low/high 8 bits of instruction word address 3517 ENUM 3518 BFD_RELOC_IP2K_PC_SKIP 3519 ENUMDOC 3520 Scenix IP2K - even/odd PC modifier to modify snb pcl.0 3521 ENUM 3522 BFD_RELOC_IP2K_TEXT 3523 ENUMDOC 3524 Scenix IP2K - 16 bit word address in text section. 3525 ENUM 3526 BFD_RELOC_IP2K_FR_OFFSET 3527 ENUMDOC 3528 Scenix IP2K - 7-bit sp or dp offset 3529 ENUM 3530 BFD_RELOC_VPE4KMATH_DATA 3531 ENUMX 3532 BFD_RELOC_VPE4KMATH_INSN 3533 ENUMDOC 3534 Scenix VPE4K coprocessor - data/insn-space addressing 3535 3536 ENUM 3537 BFD_RELOC_VTABLE_INHERIT 3538 ENUMX 3539 BFD_RELOC_VTABLE_ENTRY 3540 ENUMDOC 3541 These two relocations are used by the linker to determine which of 3542 the entries in a C++ virtual function table are actually used. When 3543 the --gc-sections option is given, the linker will zero out the entries 3544 that are not used, so that the code for those functions need not be 3545 included in the output. 3546 3547 VTABLE_INHERIT is a zero-space relocation used to describe to the 3548 linker the inheritance tree of a C++ virtual function table. The 3549 relocation's symbol should be the parent class' vtable, and the 3550 relocation should be located at the child vtable. 3551 3552 VTABLE_ENTRY is a zero-space relocation that describes the use of a 3553 virtual function table entry. The reloc's symbol should refer to the 3554 table of the class mentioned in the code. Off of that base, an offset 3555 describes the entry that is being used. For Rela hosts, this offset 3556 is stored in the reloc's addend. For Rel hosts, we are forced to put 3557 this offset in the reloc's section offset. 3558 3559 ENUM 3560 BFD_RELOC_IA64_IMM14 3561 ENUMX 3562 BFD_RELOC_IA64_IMM22 3563 ENUMX 3564 BFD_RELOC_IA64_IMM64 3565 ENUMX 3566 BFD_RELOC_IA64_DIR32MSB 3567 ENUMX 3568 BFD_RELOC_IA64_DIR32LSB 3569 ENUMX 3570 BFD_RELOC_IA64_DIR64MSB 3571 ENUMX 3572 BFD_RELOC_IA64_DIR64LSB 3573 ENUMX 3574 BFD_RELOC_IA64_GPREL22 3575 ENUMX 3576 BFD_RELOC_IA64_GPREL64I 3577 ENUMX 3578 BFD_RELOC_IA64_GPREL32MSB 3579 ENUMX 3580 BFD_RELOC_IA64_GPREL32LSB 3581 ENUMX 3582 BFD_RELOC_IA64_GPREL64MSB 3583 ENUMX 3584 BFD_RELOC_IA64_GPREL64LSB 3585 ENUMX 3586 BFD_RELOC_IA64_LTOFF22 3587 ENUMX 3588 BFD_RELOC_IA64_LTOFF64I 3589 ENUMX 3590 BFD_RELOC_IA64_PLTOFF22 3591 ENUMX 3592 BFD_RELOC_IA64_PLTOFF64I 3593 ENUMX 3594 BFD_RELOC_IA64_PLTOFF64MSB 3595 ENUMX 3596 BFD_RELOC_IA64_PLTOFF64LSB 3597 ENUMX 3598 BFD_RELOC_IA64_FPTR64I 3599 ENUMX 3600 BFD_RELOC_IA64_FPTR32MSB 3601 ENUMX 3602 BFD_RELOC_IA64_FPTR32LSB 3603 ENUMX 3604 BFD_RELOC_IA64_FPTR64MSB 3605 ENUMX 3606 BFD_RELOC_IA64_FPTR64LSB 3607 ENUMX 3608 BFD_RELOC_IA64_PCREL21B 3609 ENUMX 3610 BFD_RELOC_IA64_PCREL21BI 3611 ENUMX 3612 BFD_RELOC_IA64_PCREL21M 3613 ENUMX 3614 BFD_RELOC_IA64_PCREL21F 3615 ENUMX 3616 BFD_RELOC_IA64_PCREL22 3617 ENUMX 3618 BFD_RELOC_IA64_PCREL60B 3619 ENUMX 3620 BFD_RELOC_IA64_PCREL64I 3621 ENUMX 3622 BFD_RELOC_IA64_PCREL32MSB 3623 ENUMX 3624 BFD_RELOC_IA64_PCREL32LSB 3625 ENUMX 3626 BFD_RELOC_IA64_PCREL64MSB 3627 ENUMX 3628 BFD_RELOC_IA64_PCREL64LSB 3629 ENUMX 3630 BFD_RELOC_IA64_LTOFF_FPTR22 3631 ENUMX 3632 BFD_RELOC_IA64_LTOFF_FPTR64I 3633 ENUMX 3634 BFD_RELOC_IA64_LTOFF_FPTR32MSB 3635 ENUMX 3636 BFD_RELOC_IA64_LTOFF_FPTR32LSB 3637 ENUMX 3638 BFD_RELOC_IA64_LTOFF_FPTR64MSB 3639 ENUMX 3640 BFD_RELOC_IA64_LTOFF_FPTR64LSB 3641 ENUMX 3642 BFD_RELOC_IA64_SEGREL32MSB 3643 ENUMX 3644 BFD_RELOC_IA64_SEGREL32LSB 3645 ENUMX 3646 BFD_RELOC_IA64_SEGREL64MSB 3647 ENUMX 3648 BFD_RELOC_IA64_SEGREL64LSB 3649 ENUMX 3650 BFD_RELOC_IA64_SECREL32MSB 3651 ENUMX 3652 BFD_RELOC_IA64_SECREL32LSB 3653 ENUMX 3654 BFD_RELOC_IA64_SECREL64MSB 3655 ENUMX 3656 BFD_RELOC_IA64_SECREL64LSB 3657 ENUMX 3658 BFD_RELOC_IA64_REL32MSB 3659 ENUMX 3660 BFD_RELOC_IA64_REL32LSB 3661 ENUMX 3662 BFD_RELOC_IA64_REL64MSB 3663 ENUMX 3664 BFD_RELOC_IA64_REL64LSB 3665 ENUMX 3666 BFD_RELOC_IA64_LTV32MSB 3667 ENUMX 3668 BFD_RELOC_IA64_LTV32LSB 3669 ENUMX 3670 BFD_RELOC_IA64_LTV64MSB 3671 ENUMX 3672 BFD_RELOC_IA64_LTV64LSB 3673 ENUMX 3674 BFD_RELOC_IA64_IPLTMSB 3675 ENUMX 3676 BFD_RELOC_IA64_IPLTLSB 3677 ENUMX 3678 BFD_RELOC_IA64_COPY 3679 ENUMX 3680 BFD_RELOC_IA64_LTOFF22X 3681 ENUMX 3682 BFD_RELOC_IA64_LDXMOV 3683 ENUMX 3684 BFD_RELOC_IA64_TPREL14 3685 ENUMX 3686 BFD_RELOC_IA64_TPREL22 3687 ENUMX 3688 BFD_RELOC_IA64_TPREL64I 3689 ENUMX 3690 BFD_RELOC_IA64_TPREL64MSB 3691 ENUMX 3692 BFD_RELOC_IA64_TPREL64LSB 3693 ENUMX 3694 BFD_RELOC_IA64_LTOFF_TPREL22 3695 ENUMX 3696 BFD_RELOC_IA64_DTPMOD64MSB 3697 ENUMX 3698 BFD_RELOC_IA64_DTPMOD64LSB 3699 ENUMX 3700 BFD_RELOC_IA64_LTOFF_DTPMOD22 3701 ENUMX 3702 BFD_RELOC_IA64_DTPREL14 3703 ENUMX 3704 BFD_RELOC_IA64_DTPREL22 3705 ENUMX 3706 BFD_RELOC_IA64_DTPREL64I 3707 ENUMX 3708 BFD_RELOC_IA64_DTPREL32MSB 3709 ENUMX 3710 BFD_RELOC_IA64_DTPREL32LSB 3711 ENUMX 3712 BFD_RELOC_IA64_DTPREL64MSB 3713 ENUMX 3714 BFD_RELOC_IA64_DTPREL64LSB 3715 ENUMX 3716 BFD_RELOC_IA64_LTOFF_DTPREL22 3717 ENUMDOC 3718 Intel IA64 Relocations. 3719 3720 ENUM 3721 BFD_RELOC_M68HC11_HI8 3722 ENUMDOC 3723 Motorola 68HC11 reloc. 3724 This is the 8 bit high part of an absolute address. 3725 ENUM 3726 BFD_RELOC_M68HC11_LO8 3727 ENUMDOC 3728 Motorola 68HC11 reloc. 3729 This is the 8 bit low part of an absolute address. 3730 ENUM 3731 BFD_RELOC_M68HC11_3B 3732 ENUMDOC 3733 Motorola 68HC11 reloc. 3734 This is the 3 bit of a value. 3735 ENUM 3736 BFD_RELOC_M68HC11_RL_JUMP 3737 ENUMDOC 3738 Motorola 68HC11 reloc. 3739 This reloc marks the beginning of a jump/call instruction. 3740 It is used for linker relaxation to correctly identify beginning 3741 of instruction and change some branches to use PC-relative 3742 addressing mode. 3743 ENUM 3744 BFD_RELOC_M68HC11_RL_GROUP 3745 ENUMDOC 3746 Motorola 68HC11 reloc. 3747 This reloc marks a group of several instructions that gcc generates 3748 and for which the linker relaxation pass can modify and/or remove 3749 some of them. 3750 ENUM 3751 BFD_RELOC_M68HC11_LO16 3752 ENUMDOC 3753 Motorola 68HC11 reloc. 3754 This is the 16-bit lower part of an address. It is used for 'call' 3755 instruction to specify the symbol address without any special 3756 transformation (due to memory bank window). 3757 ENUM 3758 BFD_RELOC_M68HC11_PAGE 3759 ENUMDOC 3760 Motorola 68HC11 reloc. 3761 This is a 8-bit reloc that specifies the page number of an address. 3762 It is used by 'call' instruction to specify the page number of 3763 the symbol. 3764 ENUM 3765 BFD_RELOC_M68HC11_24 3766 ENUMDOC 3767 Motorola 68HC11 reloc. 3768 This is a 24-bit reloc that represents the address with a 16-bit 3769 value and a 8-bit page number. The symbol address is transformed 3770 to follow the 16K memory bank of 68HC12 (seen as mapped in the window). 3771 ENUM 3772 BFD_RELOC_M68HC12_5B 3773 ENUMDOC 3774 Motorola 68HC12 reloc. 3775 This is the 5 bits of a value. 3776 3777 ENUM 3778 BFD_RELOC_CRIS_BDISP8 3779 ENUMX 3780 BFD_RELOC_CRIS_UNSIGNED_5 3781 ENUMX 3782 BFD_RELOC_CRIS_SIGNED_6 3783 ENUMX 3784 BFD_RELOC_CRIS_UNSIGNED_6 3785 ENUMX 3786 BFD_RELOC_CRIS_UNSIGNED_4 3787 ENUMDOC 3788 These relocs are only used within the CRIS assembler. They are not 3789 (at present) written to any object files. 3790 ENUM 3791 BFD_RELOC_CRIS_COPY 3792 ENUMX 3793 BFD_RELOC_CRIS_GLOB_DAT 3794 ENUMX 3795 BFD_RELOC_CRIS_JUMP_SLOT 3796 ENUMX 3797 BFD_RELOC_CRIS_RELATIVE 3798 ENUMDOC 3799 Relocs used in ELF shared libraries for CRIS. 3800 ENUM 3801 BFD_RELOC_CRIS_32_GOT 3802 ENUMDOC 3803 32-bit offset to symbol-entry within GOT. 3804 ENUM 3805 BFD_RELOC_CRIS_16_GOT 3806 ENUMDOC 3807 16-bit offset to symbol-entry within GOT. 3808 ENUM 3809 BFD_RELOC_CRIS_32_GOTPLT 3810 ENUMDOC 3811 32-bit offset to symbol-entry within GOT, with PLT handling. 3812 ENUM 3813 BFD_RELOC_CRIS_16_GOTPLT 3814 ENUMDOC 3815 16-bit offset to symbol-entry within GOT, with PLT handling. 3816 ENUM 3817 BFD_RELOC_CRIS_32_GOTREL 3818 ENUMDOC 3819 32-bit offset to symbol, relative to GOT. 3820 ENUM 3821 BFD_RELOC_CRIS_32_PLT_GOTREL 3822 ENUMDOC 3823 32-bit offset to symbol with PLT entry, relative to GOT. 3824 ENUM 3825 BFD_RELOC_CRIS_32_PLT_PCREL 3826 ENUMDOC 3827 32-bit offset to symbol with PLT entry, relative to this relocation. 3828 3829 ENUM 3830 BFD_RELOC_860_COPY 3831 ENUMX 3832 BFD_RELOC_860_GLOB_DAT 3833 ENUMX 3834 BFD_RELOC_860_JUMP_SLOT 3835 ENUMX 3836 BFD_RELOC_860_RELATIVE 3837 ENUMX 3838 BFD_RELOC_860_PC26 3839 ENUMX 3840 BFD_RELOC_860_PLT26 3841 ENUMX 3842 BFD_RELOC_860_PC16 3843 ENUMX 3844 BFD_RELOC_860_LOW0 3845 ENUMX 3846 BFD_RELOC_860_SPLIT0 3847 ENUMX 3848 BFD_RELOC_860_LOW1 3849 ENUMX 3850 BFD_RELOC_860_SPLIT1 3851 ENUMX 3852 BFD_RELOC_860_LOW2 3853 ENUMX 3854 BFD_RELOC_860_SPLIT2 3855 ENUMX 3856 BFD_RELOC_860_LOW3 3857 ENUMX 3858 BFD_RELOC_860_LOGOT0 3859 ENUMX 3860 BFD_RELOC_860_SPGOT0 3861 ENUMX 3862 BFD_RELOC_860_LOGOT1 3863 ENUMX 3864 BFD_RELOC_860_SPGOT1 3865 ENUMX 3866 BFD_RELOC_860_LOGOTOFF0 3867 ENUMX 3868 BFD_RELOC_860_SPGOTOFF0 3869 ENUMX 3870 BFD_RELOC_860_LOGOTOFF1 3871 ENUMX 3872 BFD_RELOC_860_SPGOTOFF1 3873 ENUMX 3874 BFD_RELOC_860_LOGOTOFF2 3875 ENUMX 3876 BFD_RELOC_860_LOGOTOFF3 3877 ENUMX 3878 BFD_RELOC_860_LOPC 3879 ENUMX 3880 BFD_RELOC_860_HIGHADJ 3881 ENUMX 3882 BFD_RELOC_860_HAGOT 3883 ENUMX 3884 BFD_RELOC_860_HAGOTOFF 3885 ENUMX 3886 BFD_RELOC_860_HAPC 3887 ENUMX 3888 BFD_RELOC_860_HIGH 3889 ENUMX 3890 BFD_RELOC_860_HIGOT 3891 ENUMX 3892 BFD_RELOC_860_HIGOTOFF 3893 ENUMDOC 3894 Intel i860 Relocations. 3895 3896 ENUM 3897 BFD_RELOC_OPENRISC_ABS_26 3898 ENUMX 3899 BFD_RELOC_OPENRISC_REL_26 3900 ENUMDOC 3901 OpenRISC Relocations. 3902 3903 ENUM 3904 BFD_RELOC_H8_DIR16A8 3905 ENUMX 3906 BFD_RELOC_H8_DIR16R8 3907 ENUMX 3908 BFD_RELOC_H8_DIR24A8 3909 ENUMX 3910 BFD_RELOC_H8_DIR24R8 3911 ENUMX 3912 BFD_RELOC_H8_DIR32A16 3913 ENUMDOC 3914 H8 elf Relocations. 3915 3916 ENUM 3917 BFD_RELOC_XSTORMY16_REL_12 3918 ENUMX 3919 BFD_RELOC_XSTORMY16_12 3920 ENUMX 3921 BFD_RELOC_XSTORMY16_24 3922 ENUMX 3923 BFD_RELOC_XSTORMY16_FPTR16 3924 ENUMDOC 3925 Sony Xstormy16 Relocations. 3926 3927 ENUM 3928 BFD_RELOC_VAX_GLOB_DAT 3929 ENUMX 3930 BFD_RELOC_VAX_JMP_SLOT 3931 ENUMX 3932 BFD_RELOC_VAX_RELATIVE 3933 ENUMDOC 3934 Relocations used by VAX ELF. 3935 3936 ENUM 3937 BFD_RELOC_MSP430_10_PCREL 3938 ENUMX 3939 BFD_RELOC_MSP430_16_PCREL 3940 ENUMX 3941 BFD_RELOC_MSP430_16 3942 ENUMX 3943 BFD_RELOC_MSP430_16_PCREL_BYTE 3944 ENUMX 3945 BFD_RELOC_MSP430_16_BYTE 3946 ENUMDOC 3947 msp430 specific relocation codes 3948 3949 ENUM 3950 BFD_RELOC_IQ2000_OFFSET_16 3951 ENUMX 3952 BFD_RELOC_IQ2000_OFFSET_21 3953 ENUMX 3954 BFD_RELOC_IQ2000_UHI16 3955 ENUMDOC 3956 IQ2000 Relocations. 3957 3958 ENUM 3959 BFD_RELOC_XTENSA_RTLD 3960 ENUMDOC 3961 Special Xtensa relocation used only by PLT entries in ELF shared 3962 objects to indicate that the runtime linker should set the value 3963 to one of its own internal functions or data structures. 3964 ENUM 3965 BFD_RELOC_XTENSA_GLOB_DAT 3966 ENUMX 3967 BFD_RELOC_XTENSA_JMP_SLOT 3968 ENUMX 3969 BFD_RELOC_XTENSA_RELATIVE 3970 ENUMDOC 3971 Xtensa relocations for ELF shared objects. 3972 ENUM 3973 BFD_RELOC_XTENSA_PLT 3974 ENUMDOC 3975 Xtensa relocation used in ELF object files for symbols that may require 3976 PLT entries. Otherwise, this is just a generic 32-bit relocation. 3977 ENUM 3978 BFD_RELOC_XTENSA_OP0 3979 ENUMX 3980 BFD_RELOC_XTENSA_OP1 3981 ENUMX 3982 BFD_RELOC_XTENSA_OP2 3983 ENUMDOC 3984 Generic Xtensa relocations. Only the operand number is encoded 3985 in the relocation. The details are determined by extracting the 3986 instruction opcode. 3987 ENUM 3988 BFD_RELOC_XTENSA_ASM_EXPAND 3989 ENUMDOC 3990 Xtensa relocation to mark that the assembler expanded the 3991 instructions from an original target. The expansion size is 3992 encoded in the reloc size. 3993 ENUM 3994 BFD_RELOC_XTENSA_ASM_SIMPLIFY 3995 ENUMDOC 3996 Xtensa relocation to mark that the linker should simplify 3997 assembler-expanded instructions. This is commonly used 3998 internally by the linker after analysis of a 3999 BFD_RELOC_XTENSA_ASM_EXPAND. 4000 4001 ENDSENUM 4002 BFD_RELOC_UNUSED 4003 CODE_FRAGMENT 4004 . 4005 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; 4006 */ 4007 4008 /* 4009 FUNCTION 4010 bfd_reloc_type_lookup 4011 4012 SYNOPSIS 4013 reloc_howto_type *bfd_reloc_type_lookup 4014 (bfd *abfd, bfd_reloc_code_real_type code); 4015 4016 DESCRIPTION 4017 Return a pointer to a howto structure which, when 4018 invoked, will perform the relocation @var{code} on data from the 4019 architecture noted. 4020 4021 */ 4022 4023 reloc_howto_type * 4024 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 4025 { 4026 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code)); 4027 } 4028 4029 static reloc_howto_type bfd_howto_32 = 4030 HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE); 4031 4032 /* 4033 INTERNAL_FUNCTION 4034 bfd_default_reloc_type_lookup 4035 4036 SYNOPSIS 4037 reloc_howto_type *bfd_default_reloc_type_lookup 4038 (bfd *abfd, bfd_reloc_code_real_type code); 4039 4040 DESCRIPTION 4041 Provides a default relocation lookup routine for any architecture. 4042 4043 */ 4044 4045 reloc_howto_type * 4046 bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 4047 { 4048 switch (code) 4049 { 4050 case BFD_RELOC_CTOR: 4051 /* The type of reloc used in a ctor, which will be as wide as the 4052 address - so either a 64, 32, or 16 bitter. */ 4053 switch (bfd_get_arch_info (abfd)->bits_per_address) 4054 { 4055 case 64: 4056 BFD_FAIL (); 4057 case 32: 4058 return &bfd_howto_32; 4059 case 16: 4060 BFD_FAIL (); 4061 default: 4062 BFD_FAIL (); 4063 } 4064 default: 4065 BFD_FAIL (); 4066 } 4067 return NULL; 4068 } 4069 4070 /* 4071 FUNCTION 4072 bfd_get_reloc_code_name 4073 4074 SYNOPSIS 4075 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); 4076 4077 DESCRIPTION 4078 Provides a printable name for the supplied relocation code. 4079 Useful mainly for printing error messages. 4080 */ 4081 4082 const char * 4083 bfd_get_reloc_code_name (bfd_reloc_code_real_type code) 4084 { 4085 if (code > BFD_RELOC_UNUSED) 4086 return 0; 4087 return bfd_reloc_code_real_names[code]; 4088 } 4089 4090 /* 4091 INTERNAL_FUNCTION 4092 bfd_generic_relax_section 4093 4094 SYNOPSIS 4095 bfd_boolean bfd_generic_relax_section 4096 (bfd *abfd, 4097 asection *section, 4098 struct bfd_link_info *, 4099 bfd_boolean *); 4100 4101 DESCRIPTION 4102 Provides default handling for relaxing for back ends which 4103 don't do relaxing -- i.e., does nothing except make sure that the 4104 final size of the section is set. 4105 */ 4106 4107 bfd_boolean 4108 bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, 4109 asection *section ATTRIBUTE_UNUSED, 4110 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 4111 bfd_boolean *again) 4112 { 4113 /* We're not relaxing the section, so just copy the size info if it's 4114 zero. Someone else, like bfd_merge_sections, might have set it, so 4115 don't overwrite a non-zero value. */ 4116 if (section->_cooked_size == 0) 4117 section->_cooked_size = section->_raw_size; 4118 *again = FALSE; 4119 return TRUE; 4120 } 4121 4122 /* 4123 INTERNAL_FUNCTION 4124 bfd_generic_gc_sections 4125 4126 SYNOPSIS 4127 bfd_boolean bfd_generic_gc_sections 4128 (bfd *, struct bfd_link_info *); 4129 4130 DESCRIPTION 4131 Provides default handling for relaxing for back ends which 4132 don't do section gc -- i.e., does nothing. 4133 */ 4134 4135 bfd_boolean 4136 bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, 4137 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 4138 { 4139 return TRUE; 4140 } 4141 4142 /* 4143 INTERNAL_FUNCTION 4144 bfd_generic_merge_sections 4145 4146 SYNOPSIS 4147 bfd_boolean bfd_generic_merge_sections 4148 (bfd *, struct bfd_link_info *); 4149 4150 DESCRIPTION 4151 Provides default handling for SEC_MERGE section merging for back ends 4152 which don't have SEC_MERGE support -- i.e., does nothing. 4153 */ 4154 4155 bfd_boolean 4156 bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED, 4157 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 4158 { 4159 return TRUE; 4160 } 4161 4162 /* 4163 INTERNAL_FUNCTION 4164 bfd_generic_get_relocated_section_contents 4165 4166 SYNOPSIS 4167 bfd_byte *bfd_generic_get_relocated_section_contents 4168 (bfd *abfd, 4169 struct bfd_link_info *link_info, 4170 struct bfd_link_order *link_order, 4171 bfd_byte *data, 4172 bfd_boolean relocatable, 4173 asymbol **symbols); 4174 4175 DESCRIPTION 4176 Provides default handling of relocation effort for back ends 4177 which can't be bothered to do it efficiently. 4178 4179 */ 4180 4181 bfd_byte * 4182 bfd_generic_get_relocated_section_contents (bfd *abfd, 4183 struct bfd_link_info *link_info, 4184 struct bfd_link_order *link_order, 4185 bfd_byte *data, 4186 bfd_boolean relocatable, 4187 asymbol **symbols) 4188 { 4189 /* Get enough memory to hold the stuff. */ 4190 bfd *input_bfd = link_order->u.indirect.section->owner; 4191 asection *input_section = link_order->u.indirect.section; 4192 4193 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 4194 arelent **reloc_vector = NULL; 4195 long reloc_count; 4196 4197 if (reloc_size < 0) 4198 goto error_return; 4199 4200 reloc_vector = bfd_malloc (reloc_size); 4201 if (reloc_vector == NULL && reloc_size != 0) 4202 goto error_return; 4203 4204 /* Read in the section. */ 4205 if (!bfd_get_section_contents (input_bfd, 4206 input_section, 4207 data, 4208 0, 4209 input_section->_raw_size)) 4210 goto error_return; 4211 4212 /* Don't set input_section->_cooked_size here. The caller has set 4213 _cooked_size or called bfd_relax_section, which sets _cooked_size. 4214 Despite using this generic relocation function, some targets perform 4215 target-specific relaxation or string merging, which happens before 4216 this function is called. We do not want to clobber the _cooked_size 4217 they computed. */ 4218 4219 input_section->reloc_done = TRUE; 4220 4221 reloc_count = bfd_canonicalize_reloc (input_bfd, 4222 input_section, 4223 reloc_vector, 4224 symbols); 4225 if (reloc_count < 0) 4226 goto error_return; 4227 4228 if (reloc_count > 0) 4229 { 4230 arelent **parent; 4231 for (parent = reloc_vector; *parent != NULL; parent++) 4232 { 4233 char *error_message = NULL; 4234 bfd_reloc_status_type r = 4235 bfd_perform_relocation (input_bfd, 4236 *parent, 4237 data, 4238 input_section, 4239 relocatable ? abfd : NULL, 4240 &error_message); 4241 4242 if (relocatable) 4243 { 4244 asection *os = input_section->output_section; 4245 4246 /* A partial link, so keep the relocs. */ 4247 os->orelocation[os->reloc_count] = *parent; 4248 os->reloc_count++; 4249 } 4250 4251 if (r != bfd_reloc_ok) 4252 { 4253 switch (r) 4254 { 4255 case bfd_reloc_undefined: 4256 if (!((*link_info->callbacks->undefined_symbol) 4257 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 4258 input_bfd, input_section, (*parent)->address, 4259 TRUE))) 4260 goto error_return; 4261 break; 4262 case bfd_reloc_dangerous: 4263 BFD_ASSERT (error_message != NULL); 4264 if (!((*link_info->callbacks->reloc_dangerous) 4265 (link_info, error_message, input_bfd, input_section, 4266 (*parent)->address))) 4267 goto error_return; 4268 break; 4269 case bfd_reloc_overflow: 4270 if (!((*link_info->callbacks->reloc_overflow) 4271 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 4272 (*parent)->howto->name, (*parent)->addend, 4273 input_bfd, input_section, (*parent)->address))) 4274 goto error_return; 4275 break; 4276 case bfd_reloc_outofrange: 4277 default: 4278 abort (); 4279 break; 4280 } 4281 4282 } 4283 } 4284 } 4285 if (reloc_vector != NULL) 4286 free (reloc_vector); 4287 return data; 4288 4289 error_return: 4290 if (reloc_vector != NULL) 4291 free (reloc_vector); 4292 return NULL; 4293 } 4294