1 /* BFD support for handling relocation entries.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 BFD maintains relocations in much the same way it maintains
27 symbols: they are left alone until required, then read in
28 en-masse and translated into an internal form. A common
29 routine <<bfd_perform_relocation>> acts upon the
30 canonical form to do the fixup.
32 Relocations are maintained on a per section basis,
33 while symbols are maintained on a per BFD basis.
35 All that a back end has to do to fit the BFD interface is to create
36 a <<struct reloc_cache_entry>> for each relocation
37 in a particular section, and fill in the right bits of the structures.
46 /* DO compile in the reloc_code name table from libbfd.h. */
47 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
56 typedef arelent, howto manager, Relocations, Relocations
61 This is the structure of a relocation entry:
65 .typedef enum bfd_reloc_status
67 . {* No errors detected *}
70 . {* The relocation was performed, but there was an overflow. *}
73 . {* The address to relocate was not within the section supplied. *}
74 . bfd_reloc_outofrange,
76 . {* Used by special functions *}
79 . {* Unsupported relocation size requested. *}
80 . bfd_reloc_notsupported,
85 . {* The symbol to relocate against was undefined. *}
86 . bfd_reloc_undefined,
88 . {* The relocation was performed, but may not be ok - presently
89 . generated only when linking i960 coff files with i960 b.out
90 . symbols. If this type is returned, the error_message argument
91 . to bfd_perform_relocation will be set. *}
94 . bfd_reloc_status_type;
97 .typedef struct reloc_cache_entry
99 . {* A pointer into the canonical table of pointers *}
100 . struct symbol_cache_entry **sym_ptr_ptr;
102 . {* offset in section *}
103 . bfd_size_type address;
105 . {* addend for relocation value *}
108 . {* Pointer to how to perform the required relocation *}
109 . reloc_howto_type *howto;
118 Here is a description of each of the fields within an <<arelent>>:
122 The symbol table pointer points to a pointer to the symbol
123 associated with the relocation request. It is
124 the pointer into the table returned by the back end's
125 <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
126 through a pointer to a pointer so that tools like the linker
127 can fix up all the symbols of the same name by modifying only
128 one pointer. The relocation routine looks in the symbol and
129 uses the base of the section the symbol is attached to and the
130 value of the symbol as the initial relocation offset. If the
131 symbol pointer is zero, then the section provided is looked up.
135 The <<address>> field gives the offset in bytes from the base of
136 the section data which owns the relocation record to the first
137 byte of relocatable information. The actual data relocated
138 will be relative to this point; for example, a relocation
139 type which modifies the bottom two bytes of a four byte word
140 would not touch the first byte pointed to in a big endian
145 The <<addend>> is a value provided by the back end to be added (!)
146 to the relocation offset. Its interpretation is dependent upon
147 the howto. For example, on the 68k the code:
153 | return foo[0x12345678];
156 Could be compiled into:
159 | moveb @@#12345678,d0
165 This could create a reloc pointing to <<foo>>, but leave the
166 offset in the data, something like:
169 |RELOCATION RECORDS FOR [.text]:
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
180 Using coff and an 88k, some instructions don't have enough
181 space in them to represent the full address range, and
182 pointers have to be loaded in two parts. So you'd get something like:
185 | or.u r13,r0,hi16(_foo+0x12345678)
186 | ld.b r2,r13,lo16(_foo+0x12345678)
190 This should create two relocs, both pointing to <<_foo>>, and with
191 0x12340000 in their addend field. The data would consist of:
194 |RELOCATION RECORDS FOR [.text]:
196 |00000002 HVRT16 _foo+0x12340000
197 |00000006 LVRT16 _foo+0x12340000
199 |00000000 5da05678 ; or.u r13,r0,0x5678
200 |00000004 1c4d5678 ; ld.b r2,r13,0x5678
201 |00000008 f400c001 ; jmp r1
204 The relocation routine digs out the value from the data, adds
205 it to the addend to get the original offset, and then adds the
206 value of <<_foo>>. Note that all 32 bits have to be kept around
207 somewhere, to cope with carry from bit 15 to bit 16.
209 One further example is the sparc and the a.out format. The
210 sparc has a similar problem to the 88k, in that some
211 instructions don't have room for an entire offset, but on the
212 sparc the parts are created in odd sized lumps. The designers of
213 the a.out format chose to not use the data within the section
214 for storing part of the offset; all the offset is kept within
215 the reloc. Anything in the data should be ignored.
218 | sethi %hi(_foo+0x12345678),%g2
219 | ldsb [%g2+%lo(_foo+0x12345678)],%i0
223 Both relocs contain a pointer to <<foo>>, and the offsets
227 |RELOCATION RECORDS FOR [.text]:
229 |00000004 HI22 _foo+0x12345678
230 |00000008 LO10 _foo+0x12345678
232 |00000000 9de3bf90 ; save %sp,-112,%sp
233 |00000004 05000000 ; sethi %hi(_foo+0),%g2
234 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0
235 |0000000c 81c7e008 ; ret
236 |00000010 81e80000 ; restore
241 The <<howto>> field can be imagined as a
242 relocation instruction. It is a pointer to a structure which
243 contains information on what to do with all of the other
244 information in the reloc record and data section. A back end
245 would normally have a relocation instruction set and turn
246 relocations into pointers to the correct structure on input -
247 but it would be possible to create each howto field on demand.
253 <<enum complain_overflow>>
255 Indicates what sort of overflow checking should be done when
256 performing a relocation.
260 .enum complain_overflow
262 . {* Do not complain on overflow. *}
263 . complain_overflow_dont,
265 . {* Complain if the bitfield overflows, whether it is considered
266 . as signed or unsigned. *}
267 . complain_overflow_bitfield,
269 . {* Complain if the value overflows when considered as signed
271 . complain_overflow_signed,
273 . {* Complain if the value overflows when considered as an
274 . unsigned number. *}
275 . complain_overflow_unsigned
284 The <<reloc_howto_type>> is a structure which contains all the
285 information that libbfd needs to know to tie up a back end's data.
288 .struct symbol_cache_entry; {* Forward declaration *}
290 .struct reloc_howto_struct
292 . {* The type field has mainly a documentary use - the back end can
293 . do what it wants with it, though normally the back end's
294 . external idea of what a reloc number is stored
295 . in this field. For example, a PC relative word relocation
296 . in a coff environment has the type 023 - because that's
297 . what the outside world calls a R_PCRWORD reloc. *}
300 . {* The value the final relocation is shifted right by. This drops
301 . unwanted data from the relocation. *}
302 . unsigned int rightshift;
304 . {* The size of the item to be relocated. This is *not* a
305 . power-of-two measure. To get the number of bytes operated
306 . on by a type of relocation, use bfd_get_reloc_size. *}
309 . {* The number of bits in the item to be relocated. This is used
310 . when doing overflow checking. *}
311 . unsigned int bitsize;
313 . {* Notes that the relocation is relative to the location in the
314 . data section of the addend. The relocation function will
315 . subtract from the relocation value the address of the location
316 . being relocated. *}
317 . boolean pc_relative;
319 . {* The bit position of the reloc value in the destination.
320 . The relocated value is left shifted by this amount. *}
321 . unsigned int bitpos;
323 . {* What type of overflow error should be checked for when
325 . enum complain_overflow complain_on_overflow;
327 . {* If this field is non null, then the supplied function is
328 . called rather than the normal function. This allows really
329 . strange relocation methods to be accomodated (e.g., i960 callj
331 . bfd_reloc_status_type (*special_function)
332 . PARAMS ((bfd *abfd,
333 . arelent *reloc_entry,
334 . struct symbol_cache_entry *symbol,
336 . asection *input_section,
338 . char **error_message));
340 . {* The textual name of the relocation type. *}
343 . {* Some formats record a relocation addend in the section contents
344 . rather than with the relocation. For ELF formats this is the
345 . distinction between USE_REL and USE_RELA (though the code checks
346 . for USE_REL == 1/0). The value of this field is TRUE if the
347 . addend is recorded with the section contents; when performing a
348 . partial link (ld -r) the section contents (the data) will be
349 . modified. The value of this field is FALSE if addends are
350 . recorded with the relocation (in arelent.addend); when performing
351 . a partial link the relocation will be modified.
352 . All relocations for all ELF USE_RELA targets should set this field
353 . to FALSE (values of TRUE should be looked on with suspicion).
354 . However, the converse is not true: not all relocations of all ELF
355 . USE_REL targets set this field to TRUE. Why this is so is peculiar
356 . to each particular target. For relocs that aren't used in partial
357 . links (e.g. GOT stuff) it doesn't matter what this is set to. *}
358 . boolean partial_inplace;
360 . {* The src_mask selects which parts of the read in data
361 . are to be used in the relocation sum. E.g., if this was an 8 bit
362 . byte of data which we read and relocated, this would be
363 . 0x000000ff. When we have relocs which have an addend, such as
364 . sun4 extended relocs, the value in the offset part of a
365 . relocating field is garbage so we never use it. In this case
366 . the mask would be 0x00000000. *}
369 . {* The dst_mask selects which parts of the instruction are replaced
370 . into the instruction. In most cases src_mask == dst_mask,
371 . except in the above special case, where dst_mask would be
372 . 0x000000ff, and src_mask would be 0x00000000. *}
375 . {* When some formats create PC relative instructions, they leave
376 . the value of the pc of the place being relocated in the offset
377 . slot of the instruction, so that a PC relative relocation can
378 . be made just by adding in an ordinary offset (e.g., sun3 a.out).
379 . Some formats leave the displacement part of an instruction
380 . empty (e.g., m88k bcs); this flag signals the fact.*}
381 . boolean pcrel_offset;
392 The HOWTO define is horrible and will go away.
395 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
396 . {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
399 And will be replaced with the totally magic way. But for the
400 moment, we are compatible, so do it this way.
403 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
407 This is used to fill in an empty howto entry in an array.
409 .#define EMPTY_HOWTO(C) \
410 . HOWTO((C),0,0,0,false,0,complain_overflow_dont,NULL,NULL,false,0,0,false)
414 Helper routine to turn a symbol into a relocation value.
416 .#define HOWTO_PREPARE(relocation, symbol) \
418 . if (symbol != (asymbol *)NULL) { \
419 . if (bfd_is_com_section (symbol->section)) { \
423 . relocation = symbol->value; \
435 unsigned int bfd_get_reloc_size (reloc_howto_type *);
438 For a reloc_howto_type that operates on a fixed number of bytes,
439 this returns the number of bytes operated on.
443 bfd_get_reloc_size (howto)
444 reloc_howto_type *howto;
465 How relocs are tied together in an <<asection>>:
467 .typedef struct relent_chain {
469 . struct relent_chain *next;
474 /* N_ONES produces N one bits, without overflowing machine arithmetic. */
475 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
482 bfd_reloc_status_type
484 (enum complain_overflow how,
485 unsigned int bitsize,
486 unsigned int rightshift,
487 unsigned int addrsize,
491 Perform overflow checking on @var{relocation} which has
492 @var{bitsize} significant bits and will be shifted right by
493 @var{rightshift} bits, on a machine with addresses containing
494 @var{addrsize} significant bits. The result is either of
495 @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
499 bfd_reloc_status_type
500 bfd_check_overflow (how, bitsize, rightshift, addrsize, relocation)
501 enum complain_overflow how;
502 unsigned int bitsize;
503 unsigned int rightshift;
504 unsigned int addrsize;
507 bfd_vma fieldmask, addrmask, signmask, ss, a;
508 bfd_reloc_status_type flag = bfd_reloc_ok;
512 /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
513 we'll be permissive: extra bits in the field mask will
514 automatically extend the address mask for purposes of the
516 fieldmask = N_ONES (bitsize);
517 addrmask = N_ONES (addrsize) | fieldmask;
521 case complain_overflow_dont:
524 case complain_overflow_signed:
525 /* If any sign bits are set, all sign bits must be set. That
526 is, A must be a valid negative address after shifting. */
527 a = (a & addrmask) >> rightshift;
528 signmask = ~ (fieldmask >> 1);
530 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
531 flag = bfd_reloc_overflow;
534 case complain_overflow_unsigned:
535 /* We have an overflow if the address does not fit in the field. */
536 a = (a & addrmask) >> rightshift;
537 if ((a & ~ fieldmask) != 0)
538 flag = bfd_reloc_overflow;
541 case complain_overflow_bitfield:
542 /* Bitfields are sometimes signed, sometimes unsigned. We
543 explicitly allow an address wrap too, which means a bitfield
544 of n bits is allowed to store -2**n to 2**n-1. Thus overflow
545 if the value has some, but not all, bits set outside the
548 ss = a & ~ fieldmask;
549 if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & ~ fieldmask))
550 flag = bfd_reloc_overflow;
562 bfd_perform_relocation
565 bfd_reloc_status_type
566 bfd_perform_relocation
568 arelent *reloc_entry,
570 asection *input_section,
572 char **error_message);
575 If @var{output_bfd} is supplied to this function, the
576 generated image will be relocatable; the relocations are
577 copied to the output file after they have been changed to
578 reflect the new state of the world. There are two ways of
579 reflecting the results of partial linkage in an output file:
580 by modifying the output data in place, and by modifying the
581 relocation record. Some native formats (e.g., basic a.out and
582 basic coff) have no way of specifying an addend in the
583 relocation type, so the addend has to go in the output data.
584 This is no big deal since in these formats the output data
585 slot will always be big enough for the addend. Complex reloc
586 types with addends were invented to solve just this problem.
587 The @var{error_message} argument is set to an error message if
588 this return @code{bfd_reloc_dangerous}.
593 bfd_reloc_status_type
594 bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
597 arelent *reloc_entry;
599 asection *input_section;
601 char **error_message;
604 bfd_reloc_status_type flag = bfd_reloc_ok;
605 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
606 bfd_vma output_base = 0;
607 reloc_howto_type *howto = reloc_entry->howto;
608 asection *reloc_target_output_section;
611 symbol = *(reloc_entry->sym_ptr_ptr);
612 if (bfd_is_abs_section (symbol->section)
613 && output_bfd != (bfd *) NULL)
615 reloc_entry->address += input_section->output_offset;
619 /* If we are not producing relocateable output, return an error if
620 the symbol is not defined. An undefined weak symbol is
621 considered to have a value of zero (SVR4 ABI, p. 4-27). */
622 if (bfd_is_und_section (symbol->section)
623 && (symbol->flags & BSF_WEAK) == 0
624 && output_bfd == (bfd *) NULL)
625 flag = bfd_reloc_undefined;
627 /* If there is a function supplied to handle this relocation type,
628 call it. It'll return `bfd_reloc_continue' if further processing
630 if (howto->special_function)
632 bfd_reloc_status_type cont;
633 cont = howto->special_function (abfd, reloc_entry, symbol, data,
634 input_section, output_bfd,
636 if (cont != bfd_reloc_continue)
640 /* Is the address of the relocation really within the section? */
641 if (reloc_entry->address > input_section->_cooked_size /
642 bfd_octets_per_byte (abfd))
643 return bfd_reloc_outofrange;
645 /* Work out which section the relocation is targetted at and the
646 initial relocation command value. */
648 /* Get symbol value. (Common symbols are special.) */
649 if (bfd_is_com_section (symbol->section))
652 relocation = symbol->value;
655 reloc_target_output_section = symbol->section->output_section;
657 /* Convert input-section-relative symbol value to absolute. */
658 if (output_bfd && howto->partial_inplace == false)
661 output_base = reloc_target_output_section->vma;
663 relocation += output_base + symbol->section->output_offset;
665 /* Add in supplied addend. */
666 relocation += reloc_entry->addend;
668 /* Here the variable relocation holds the final address of the
669 symbol we are relocating against, plus any addend. */
671 if (howto->pc_relative == true)
673 /* This is a PC relative relocation. We want to set RELOCATION
674 to the distance between the address of the symbol and the
675 location. RELOCATION is already the address of the symbol.
677 We start by subtracting the address of the section containing
680 If pcrel_offset is set, we must further subtract the position
681 of the location within the section. Some targets arrange for
682 the addend to be the negative of the position of the location
683 within the section; for example, i386-aout does this. For
684 i386-aout, pcrel_offset is false. Some other targets do not
685 include the position of the location; for example, m88kbcs,
686 or ELF. For those targets, pcrel_offset is true.
688 If we are producing relocateable output, then we must ensure
689 that this reloc will be correctly computed when the final
690 relocation is done. If pcrel_offset is false we want to wind
691 up with the negative of the location within the section,
692 which means we must adjust the existing addend by the change
693 in the location within the section. If pcrel_offset is true
694 we do not want to adjust the existing addend at all.
696 FIXME: This seems logical to me, but for the case of
697 producing relocateable output it is not what the code
698 actually does. I don't want to change it, because it seems
699 far too likely that something will break. */
702 input_section->output_section->vma + input_section->output_offset;
704 if (howto->pcrel_offset == true)
705 relocation -= reloc_entry->address;
708 if (output_bfd != (bfd *) NULL)
710 if (howto->partial_inplace == false)
712 /* This is a partial relocation, and we want to apply the relocation
713 to the reloc entry rather than the raw data. Modify the reloc
714 inplace to reflect what we now know. */
715 reloc_entry->addend = relocation;
716 reloc_entry->address += input_section->output_offset;
721 /* This is a partial relocation, but inplace, so modify the
724 If we've relocated with a symbol with a section, change
725 into a ref to the section belonging to the symbol. */
727 reloc_entry->address += input_section->output_offset;
730 if (abfd->xvec->flavour == bfd_target_coff_flavour
731 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
732 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
735 /* For m68k-coff, the addend was being subtracted twice during
736 relocation with -r. Removing the line below this comment
737 fixes that problem; see PR 2953.
739 However, Ian wrote the following, regarding removing the line below,
740 which explains why it is still enabled: --djm
742 If you put a patch like that into BFD you need to check all the COFF
743 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
744 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
745 problem in a different way. There may very well be a reason that the
746 code works as it does.
748 Hmmm. The first obvious point is that bfd_perform_relocation should
749 not have any tests that depend upon the flavour. It's seem like
750 entirely the wrong place for such a thing. The second obvious point
751 is that the current code ignores the reloc addend when producing
752 relocateable output for COFF. That's peculiar. In fact, I really
753 have no idea what the point of the line you want to remove is.
755 A typical COFF reloc subtracts the old value of the symbol and adds in
756 the new value to the location in the object file (if it's a pc
757 relative reloc it adds the difference between the symbol value and the
758 location). When relocating we need to preserve that property.
760 BFD handles this by setting the addend to the negative of the old
761 value of the symbol. Unfortunately it handles common symbols in a
762 non-standard way (it doesn't subtract the old value) but that's a
763 different story (we can't change it without losing backward
764 compatibility with old object files) (coff-i386 does subtract the old
765 value, to be compatible with existing coff-i386 targets, like SCO).
767 So everything works fine when not producing relocateable output. When
768 we are producing relocateable output, logically we should do exactly
769 what we do when not producing relocateable output. Therefore, your
770 patch is correct. In fact, it should probably always just set
771 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
772 add the value into the object file. This won't hurt the COFF code,
773 which doesn't use the addend; I'm not sure what it will do to other
774 formats (the thing to check for would be whether any formats both use
775 the addend and set partial_inplace).
777 When I wanted to make coff-i386 produce relocateable output, I ran
778 into the problem that you are running into: I wanted to remove that
779 line. Rather than risk it, I made the coff-i386 relocs use a special
780 function; it's coff_i386_reloc in coff-i386.c. The function
781 specifically adds the addend field into the object file, knowing that
782 bfd_perform_relocation is not going to. If you remove that line, then
783 coff-i386.c will wind up adding the addend field in twice. It's
784 trivial to fix; it just needs to be done.
786 The problem with removing the line is just that it may break some
787 working code. With BFD it's hard to be sure of anything. The right
788 way to deal with this is simply to build and test at least all the
789 supported COFF targets. It should be straightforward if time and disk
790 space consuming. For each target:
792 2) generate some executable, and link it using -r (I would
793 probably use paranoia.o and link against newlib/libc.a, which
794 for all the supported targets would be available in
795 /usr/cygnus/progressive/H-host/target/lib/libc.a).
796 3) make the change to reloc.c
797 4) rebuild the linker
799 6) if the resulting object files are the same, you have at least
801 7) if they are different you have to figure out which version is
804 relocation -= reloc_entry->addend;
806 reloc_entry->addend = 0;
810 reloc_entry->addend = relocation;
816 reloc_entry->addend = 0;
819 /* FIXME: This overflow checking is incomplete, because the value
820 might have overflowed before we get here. For a correct check we
821 need to compute the value in a size larger than bitsize, but we
822 can't reasonably do that for a reloc the same size as a host
824 FIXME: We should also do overflow checking on the result after
825 adding in the value contained in the object file. */
826 if (howto->complain_on_overflow != complain_overflow_dont
827 && flag == bfd_reloc_ok)
828 flag = bfd_check_overflow (howto->complain_on_overflow,
831 bfd_arch_bits_per_address (abfd),
835 Either we are relocating all the way, or we don't want to apply
836 the relocation to the reloc entry (probably because there isn't
837 any room in the output format to describe addends to relocs)
840 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
841 (OSF version 1.3, compiler version 3.11). It miscompiles the
855 x <<= (unsigned long) s.i0;
859 printf ("succeeded (%lx)\n", x);
863 relocation >>= (bfd_vma) howto->rightshift;
865 /* Shift everything up to where it's going to be used */
867 relocation <<= (bfd_vma) howto->bitpos;
869 /* Wait for the day when all have the mask in them */
872 i instruction to be left alone
873 o offset within instruction
874 r relocation offset to apply
883 (( i i i i i o o o o o from bfd_get<size>
884 and S S S S S) to get the size offset we want
885 + r r r r r r r r r r) to get the final value to place
886 and D D D D D to chop to right size
887 -----------------------
890 ( i i i i i o o o o o from bfd_get<size>
891 and N N N N N ) get instruction
892 -----------------------
898 -----------------------
899 = R R R R R R R R R R put into bfd_put<size>
903 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
909 char x = bfd_get_8 (abfd, (char *) data + octets);
911 bfd_put_8 (abfd, x, (unsigned char *) data + octets);
917 short x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
919 bfd_put_16 (abfd, x, (unsigned char *) data + octets);
924 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
926 bfd_put_32 (abfd, x, (bfd_byte *) data + octets);
931 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
932 relocation = -relocation;
934 bfd_put_32 (abfd, x, (bfd_byte *) data + octets);
940 long x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
941 relocation = -relocation;
943 bfd_put_16 (abfd, x, (bfd_byte *) data + octets);
954 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets);
956 bfd_put_64 (abfd, x, (bfd_byte *) data + octets);
963 return bfd_reloc_other;
971 bfd_install_relocation
974 bfd_reloc_status_type
975 bfd_install_relocation
977 arelent *reloc_entry,
978 PTR data, bfd_vma data_start,
979 asection *input_section,
980 char **error_message);
983 This looks remarkably like <<bfd_perform_relocation>>, except it
984 does not expect that the section contents have been filled in.
985 I.e., it's suitable for use when creating, rather than applying
988 For now, this function should be considered reserved for the
994 bfd_reloc_status_type
995 bfd_install_relocation (abfd, reloc_entry, data_start, data_start_offset,
996 input_section, error_message)
998 arelent *reloc_entry;
1000 bfd_vma data_start_offset;
1001 asection *input_section;
1002 char **error_message;
1005 bfd_reloc_status_type flag = bfd_reloc_ok;
1006 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1007 bfd_vma output_base = 0;
1008 reloc_howto_type *howto = reloc_entry->howto;
1009 asection *reloc_target_output_section;
1013 symbol = *(reloc_entry->sym_ptr_ptr);
1014 if (bfd_is_abs_section (symbol->section))
1016 reloc_entry->address += input_section->output_offset;
1017 return bfd_reloc_ok;
1020 /* If there is a function supplied to handle this relocation type,
1021 call it. It'll return `bfd_reloc_continue' if further processing
1023 if (howto->special_function)
1025 bfd_reloc_status_type cont;
1027 /* XXX - The special_function calls haven't been fixed up to deal
1028 with creating new relocations and section contents. */
1029 cont = howto->special_function (abfd, reloc_entry, symbol,
1030 /* XXX - Non-portable! */
1031 ((bfd_byte *) data_start
1032 - data_start_offset),
1033 input_section, abfd, error_message);
1034 if (cont != bfd_reloc_continue)
1038 /* Is the address of the relocation really within the section? */
1039 if (reloc_entry->address > input_section->_cooked_size)
1040 return bfd_reloc_outofrange;
1042 /* Work out which section the relocation is targetted at and the
1043 initial relocation command value. */
1045 /* Get symbol value. (Common symbols are special.) */
1046 if (bfd_is_com_section (symbol->section))
1049 relocation = symbol->value;
1051 reloc_target_output_section = symbol->section->output_section;
1053 /* Convert input-section-relative symbol value to absolute. */
1054 if (howto->partial_inplace == false)
1057 output_base = reloc_target_output_section->vma;
1059 relocation += output_base + symbol->section->output_offset;
1061 /* Add in supplied addend. */
1062 relocation += reloc_entry->addend;
1064 /* Here the variable relocation holds the final address of the
1065 symbol we are relocating against, plus any addend. */
1067 if (howto->pc_relative == true)
1069 /* This is a PC relative relocation. We want to set RELOCATION
1070 to the distance between the address of the symbol and the
1071 location. RELOCATION is already the address of the symbol.
1073 We start by subtracting the address of the section containing
1076 If pcrel_offset is set, we must further subtract the position
1077 of the location within the section. Some targets arrange for
1078 the addend to be the negative of the position of the location
1079 within the section; for example, i386-aout does this. For
1080 i386-aout, pcrel_offset is false. Some other targets do not
1081 include the position of the location; for example, m88kbcs,
1082 or ELF. For those targets, pcrel_offset is true.
1084 If we are producing relocateable output, then we must ensure
1085 that this reloc will be correctly computed when the final
1086 relocation is done. If pcrel_offset is false we want to wind
1087 up with the negative of the location within the section,
1088 which means we must adjust the existing addend by the change
1089 in the location within the section. If pcrel_offset is true
1090 we do not want to adjust the existing addend at all.
1092 FIXME: This seems logical to me, but for the case of
1093 producing relocateable output it is not what the code
1094 actually does. I don't want to change it, because it seems
1095 far too likely that something will break. */
1098 input_section->output_section->vma + input_section->output_offset;
1100 if (howto->pcrel_offset == true && howto->partial_inplace == true)
1101 relocation -= reloc_entry->address;
1104 if (howto->partial_inplace == false)
1106 /* This is a partial relocation, and we want to apply the relocation
1107 to the reloc entry rather than the raw data. Modify the reloc
1108 inplace to reflect what we now know. */
1109 reloc_entry->addend = relocation;
1110 reloc_entry->address += input_section->output_offset;
1115 /* This is a partial relocation, but inplace, so modify the
1118 If we've relocated with a symbol with a section, change
1119 into a ref to the section belonging to the symbol. */
1121 reloc_entry->address += input_section->output_offset;
1124 if (abfd->xvec->flavour == bfd_target_coff_flavour
1125 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1126 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1129 /* For m68k-coff, the addend was being subtracted twice during
1130 relocation with -r. Removing the line below this comment
1131 fixes that problem; see PR 2953.
1133 However, Ian wrote the following, regarding removing the line below,
1134 which explains why it is still enabled: --djm
1136 If you put a patch like that into BFD you need to check all the COFF
1137 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
1138 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1139 problem in a different way. There may very well be a reason that the
1140 code works as it does.
1142 Hmmm. The first obvious point is that bfd_install_relocation should
1143 not have any tests that depend upon the flavour. It's seem like
1144 entirely the wrong place for such a thing. The second obvious point
1145 is that the current code ignores the reloc addend when producing
1146 relocateable output for COFF. That's peculiar. In fact, I really
1147 have no idea what the point of the line you want to remove is.
1149 A typical COFF reloc subtracts the old value of the symbol and adds in
1150 the new value to the location in the object file (if it's a pc
1151 relative reloc it adds the difference between the symbol value and the
1152 location). When relocating we need to preserve that property.
1154 BFD handles this by setting the addend to the negative of the old
1155 value of the symbol. Unfortunately it handles common symbols in a
1156 non-standard way (it doesn't subtract the old value) but that's a
1157 different story (we can't change it without losing backward
1158 compatibility with old object files) (coff-i386 does subtract the old
1159 value, to be compatible with existing coff-i386 targets, like SCO).
1161 So everything works fine when not producing relocateable output. When
1162 we are producing relocateable output, logically we should do exactly
1163 what we do when not producing relocateable output. Therefore, your
1164 patch is correct. In fact, it should probably always just set
1165 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1166 add the value into the object file. This won't hurt the COFF code,
1167 which doesn't use the addend; I'm not sure what it will do to other
1168 formats (the thing to check for would be whether any formats both use
1169 the addend and set partial_inplace).
1171 When I wanted to make coff-i386 produce relocateable output, I ran
1172 into the problem that you are running into: I wanted to remove that
1173 line. Rather than risk it, I made the coff-i386 relocs use a special
1174 function; it's coff_i386_reloc in coff-i386.c. The function
1175 specifically adds the addend field into the object file, knowing that
1176 bfd_install_relocation is not going to. If you remove that line, then
1177 coff-i386.c will wind up adding the addend field in twice. It's
1178 trivial to fix; it just needs to be done.
1180 The problem with removing the line is just that it may break some
1181 working code. With BFD it's hard to be sure of anything. The right
1182 way to deal with this is simply to build and test at least all the
1183 supported COFF targets. It should be straightforward if time and disk
1184 space consuming. For each target:
1186 2) generate some executable, and link it using -r (I would
1187 probably use paranoia.o and link against newlib/libc.a, which
1188 for all the supported targets would be available in
1189 /usr/cygnus/progressive/H-host/target/lib/libc.a).
1190 3) make the change to reloc.c
1191 4) rebuild the linker
1193 6) if the resulting object files are the same, you have at least
1195 7) if they are different you have to figure out which version is
1198 relocation -= reloc_entry->addend;
1200 reloc_entry->addend = 0;
1204 reloc_entry->addend = relocation;
1208 /* FIXME: This overflow checking is incomplete, because the value
1209 might have overflowed before we get here. For a correct check we
1210 need to compute the value in a size larger than bitsize, but we
1211 can't reasonably do that for a reloc the same size as a host
1213 FIXME: We should also do overflow checking on the result after
1214 adding in the value contained in the object file. */
1215 if (howto->complain_on_overflow != complain_overflow_dont)
1216 flag = bfd_check_overflow (howto->complain_on_overflow,
1219 bfd_arch_bits_per_address (abfd),
1223 Either we are relocating all the way, or we don't want to apply
1224 the relocation to the reloc entry (probably because there isn't
1225 any room in the output format to describe addends to relocs)
1228 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1229 (OSF version 1.3, compiler version 3.11). It miscompiles the
1243 x <<= (unsigned long) s.i0;
1245 printf ("failed\n");
1247 printf ("succeeded (%lx)\n", x);
1251 relocation >>= (bfd_vma) howto->rightshift;
1253 /* Shift everything up to where it's going to be used */
1255 relocation <<= (bfd_vma) howto->bitpos;
1257 /* Wait for the day when all have the mask in them */
1260 i instruction to be left alone
1261 o offset within instruction
1262 r relocation offset to apply
1271 (( i i i i i o o o o o from bfd_get<size>
1272 and S S S S S) to get the size offset we want
1273 + r r r r r r r r r r) to get the final value to place
1274 and D D D D D to chop to right size
1275 -----------------------
1278 ( i i i i i o o o o o from bfd_get<size>
1279 and N N N N N ) get instruction
1280 -----------------------
1286 -----------------------
1287 = R R R R R R R R R R put into bfd_put<size>
1291 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
1293 data = (bfd_byte *) data_start + (octets - data_start_offset);
1295 switch (howto->size)
1299 char x = bfd_get_8 (abfd, (char *) data);
1301 bfd_put_8 (abfd, x, (unsigned char *) data);
1307 short x = bfd_get_16 (abfd, (bfd_byte *) data);
1309 bfd_put_16 (abfd, x, (unsigned char *) data);
1314 long x = bfd_get_32 (abfd, (bfd_byte *) data);
1316 bfd_put_32 (abfd, x, (bfd_byte *) data);
1321 long x = bfd_get_32 (abfd, (bfd_byte *) data);
1322 relocation = -relocation;
1324 bfd_put_32 (abfd, x, (bfd_byte *) data);
1334 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
1336 bfd_put_64 (abfd, x, (bfd_byte *) data);
1340 return bfd_reloc_other;
1346 /* This relocation routine is used by some of the backend linkers.
1347 They do not construct asymbol or arelent structures, so there is no
1348 reason for them to use bfd_perform_relocation. Also,
1349 bfd_perform_relocation is so hacked up it is easier to write a new
1350 function than to try to deal with it.
1352 This routine does a final relocation. Whether it is useful for a
1353 relocateable link depends upon how the object format defines
1356 FIXME: This routine ignores any special_function in the HOWTO,
1357 since the existing special_function values have been written for
1358 bfd_perform_relocation.
1360 HOWTO is the reloc howto information.
1361 INPUT_BFD is the BFD which the reloc applies to.
1362 INPUT_SECTION is the section which the reloc applies to.
1363 CONTENTS is the contents of the section.
1364 ADDRESS is the address of the reloc within INPUT_SECTION.
1365 VALUE is the value of the symbol the reloc refers to.
1366 ADDEND is the addend of the reloc. */
1368 bfd_reloc_status_type
1369 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
1371 reloc_howto_type *howto;
1373 asection *input_section;
1381 /* Sanity check the address. */
1382 if (address > input_section->_raw_size)
1383 return bfd_reloc_outofrange;
1385 /* This function assumes that we are dealing with a basic relocation
1386 against a symbol. We want to compute the value of the symbol to
1387 relocate to. This is just VALUE, the value of the symbol, plus
1388 ADDEND, any addend associated with the reloc. */
1389 relocation = value + addend;
1391 /* If the relocation is PC relative, we want to set RELOCATION to
1392 the distance between the symbol (currently in RELOCATION) and the
1393 location we are relocating. Some targets (e.g., i386-aout)
1394 arrange for the contents of the section to be the negative of the
1395 offset of the location within the section; for such targets
1396 pcrel_offset is false. Other targets (e.g., m88kbcs or ELF)
1397 simply leave the contents of the section as zero; for such
1398 targets pcrel_offset is true. If pcrel_offset is false we do not
1399 need to subtract out the offset of the location within the
1400 section (which is just ADDRESS). */
1401 if (howto->pc_relative)
1403 relocation -= (input_section->output_section->vma
1404 + input_section->output_offset);
1405 if (howto->pcrel_offset)
1406 relocation -= address;
1409 return _bfd_relocate_contents (howto, input_bfd, relocation,
1410 contents + address);
1413 /* Relocate a given location using a given value and howto. */
1415 bfd_reloc_status_type
1416 _bfd_relocate_contents (howto, input_bfd, relocation, location)
1417 reloc_howto_type *howto;
1424 bfd_reloc_status_type flag;
1425 unsigned int rightshift = howto->rightshift;
1426 unsigned int bitpos = howto->bitpos;
1428 /* If the size is negative, negate RELOCATION. This isn't very
1430 if (howto->size < 0)
1431 relocation = -relocation;
1433 /* Get the value we are going to relocate. */
1434 size = bfd_get_reloc_size (howto);
1441 x = bfd_get_8 (input_bfd, location);
1444 x = bfd_get_16 (input_bfd, location);
1447 x = bfd_get_32 (input_bfd, location);
1451 x = bfd_get_64 (input_bfd, location);
1458 /* Check for overflow. FIXME: We may drop bits during the addition
1459 which we don't check for. We must either check at every single
1460 operation, which would be tedious, or we must do the computations
1461 in a type larger than bfd_vma, which would be inefficient. */
1462 flag = bfd_reloc_ok;
1463 if (howto->complain_on_overflow != complain_overflow_dont)
1465 bfd_vma addrmask, fieldmask, signmask, ss;
1468 /* Get the values to be added together. For signed and unsigned
1469 relocations, we assume that all values should be truncated to
1470 the size of an address. For bitfields, all the bits matter.
1471 See also bfd_check_overflow. */
1472 fieldmask = N_ONES (howto->bitsize);
1473 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
1475 b = x & howto->src_mask;
1477 switch (howto->complain_on_overflow)
1479 case complain_overflow_signed:
1480 a = (a & addrmask) >> rightshift;
1482 /* If any sign bits are set, all sign bits must be set.
1483 That is, A must be a valid negative address after
1485 signmask = ~ (fieldmask >> 1);
1487 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
1488 flag = bfd_reloc_overflow;
1490 /* We only need this next bit of code if the sign bit of B
1491 is below the sign bit of A. This would only happen if
1492 SRC_MASK had fewer bits than BITSIZE. Note that if
1493 SRC_MASK has more bits than BITSIZE, we can get into
1494 trouble; we would need to verify that B is in range, as
1495 we do for A above. */
1496 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1498 /* Set all the bits above the sign bit. */
1499 b = (b ^ signmask) - signmask;
1501 b = (b & addrmask) >> bitpos;
1503 /* Now we can do the addition. */
1506 /* See if the result has the correct sign. Bits above the
1507 sign bit are junk now; ignore them. If the sum is
1508 positive, make sure we did not have all negative inputs;
1509 if the sum is negative, make sure we did not have all
1510 positive inputs. The test below looks only at the sign
1511 bits, and it really just
1512 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1514 signmask = (fieldmask >> 1) + 1;
1515 if (((~ (a ^ b)) & (a ^ sum)) & signmask)
1516 flag = bfd_reloc_overflow;
1520 case complain_overflow_unsigned:
1521 /* Checking for an unsigned overflow is relatively easy:
1522 trim the addresses and add, and trim the result as well.
1523 Overflow is normally indicated when the result does not
1524 fit in the field. However, we also need to consider the
1525 case when, e.g., fieldmask is 0x7fffffff or smaller, an
1526 input is 0x80000000, and bfd_vma is only 32 bits; then we
1527 will get sum == 0, but there is an overflow, since the
1528 inputs did not fit in the field. Instead of doing a
1529 separate test, we can check for this by or-ing in the
1530 operands when testing for the sum overflowing its final
1532 a = (a & addrmask) >> rightshift;
1533 b = (b & addrmask) >> bitpos;
1534 sum = (a + b) & addrmask;
1535 if ((a | b | sum) & ~ fieldmask)
1536 flag = bfd_reloc_overflow;
1540 case complain_overflow_bitfield:
1541 /* Much like the signed check, but for a field one bit
1542 wider, and no trimming inputs with addrmask. We allow a
1543 bitfield to represent numbers in the range -2**n to
1544 2**n-1, where n is the number of bits in the field.
1545 Note that when bfd_vma is 32 bits, a 32-bit reloc can't
1546 overflow, which is exactly what we want. */
1549 signmask = ~ fieldmask;
1551 if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & signmask))
1552 flag = bfd_reloc_overflow;
1554 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1555 b = (b ^ signmask) - signmask;
1561 /* We mask with addrmask here to explicitly allow an address
1562 wrap-around. The Linux kernel relies on it, and it is
1563 the only way to write assembler code which can run when
1564 loaded at a location 0x80000000 away from the location at
1565 which it is linked. */
1566 signmask = fieldmask + 1;
1567 if (((~ (a ^ b)) & (a ^ sum)) & signmask & addrmask)
1568 flag = bfd_reloc_overflow;
1577 /* Put RELOCATION in the right bits. */
1578 relocation >>= (bfd_vma) rightshift;
1579 relocation <<= (bfd_vma) bitpos;
1581 /* Add RELOCATION to the right bits of X. */
1582 x = ((x & ~howto->dst_mask)
1583 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1585 /* Put the relocated value back in the object file. */
1592 bfd_put_8 (input_bfd, x, location);
1595 bfd_put_16 (input_bfd, x, location);
1598 bfd_put_32 (input_bfd, x, location);
1602 bfd_put_64 (input_bfd, x, location);
1615 howto manager, , typedef arelent, Relocations
1620 When an application wants to create a relocation, but doesn't
1621 know what the target machine might call it, it can find out by
1622 using this bit of code.
1631 The insides of a reloc code. The idea is that, eventually, there
1632 will be one enumerator for every type of relocation we ever do.
1633 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1634 return a howto pointer.
1636 This does mean that the application must determine the correct
1637 enumerator value; you can't get a howto pointer from a random set
1658 Basic absolute relocations of N bits.
1673 PC-relative relocations. Sometimes these are relative to the address
1674 of the relocation itself; sometimes they are relative to the start of
1675 the section containing the relocation. It depends on the specific target.
1677 The 24-bit relocation is used in some Intel 960 configurations.
1680 BFD_RELOC_32_GOT_PCREL
1682 BFD_RELOC_16_GOT_PCREL
1684 BFD_RELOC_8_GOT_PCREL
1690 BFD_RELOC_LO16_GOTOFF
1692 BFD_RELOC_HI16_GOTOFF
1694 BFD_RELOC_HI16_S_GOTOFF
1698 BFD_RELOC_32_PLT_PCREL
1700 BFD_RELOC_24_PLT_PCREL
1702 BFD_RELOC_16_PLT_PCREL
1704 BFD_RELOC_8_PLT_PCREL
1710 BFD_RELOC_LO16_PLTOFF
1712 BFD_RELOC_HI16_PLTOFF
1714 BFD_RELOC_HI16_S_PLTOFF
1721 BFD_RELOC_68K_GLOB_DAT
1723 BFD_RELOC_68K_JMP_SLOT
1725 BFD_RELOC_68K_RELATIVE
1727 Relocations used by 68K ELF.
1730 BFD_RELOC_32_BASEREL
1732 BFD_RELOC_16_BASEREL
1734 BFD_RELOC_LO16_BASEREL
1736 BFD_RELOC_HI16_BASEREL
1738 BFD_RELOC_HI16_S_BASEREL
1744 Linkage-table relative.
1749 Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1752 BFD_RELOC_32_PCREL_S2
1754 BFD_RELOC_16_PCREL_S2
1756 BFD_RELOC_23_PCREL_S2
1758 These PC-relative relocations are stored as word displacements --
1759 i.e., byte displacements shifted right two bits. The 30-bit word
1760 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1761 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The
1762 signed 16-bit displacement is used on the MIPS, and the 23-bit
1763 displacement is used on the Alpha.
1770 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1771 the target word. These are used on the SPARC.
1778 For systems that allocate a Global Pointer register, these are
1779 displacements off that register. These relocation types are
1780 handled specially, because the value the register will have is
1781 decided relatively late.
1785 BFD_RELOC_I960_CALLJ
1787 Reloc types used for i960/b.out.
1792 BFD_RELOC_SPARC_WDISP22
1798 BFD_RELOC_SPARC_GOT10
1800 BFD_RELOC_SPARC_GOT13
1802 BFD_RELOC_SPARC_GOT22
1804 BFD_RELOC_SPARC_PC10
1806 BFD_RELOC_SPARC_PC22
1808 BFD_RELOC_SPARC_WPLT30
1810 BFD_RELOC_SPARC_COPY
1812 BFD_RELOC_SPARC_GLOB_DAT
1814 BFD_RELOC_SPARC_JMP_SLOT
1816 BFD_RELOC_SPARC_RELATIVE
1818 BFD_RELOC_SPARC_UA32
1820 SPARC ELF relocations. There is probably some overlap with other
1821 relocation types already defined.
1824 BFD_RELOC_SPARC_BASE13
1826 BFD_RELOC_SPARC_BASE22
1828 I think these are specific to SPARC a.out (e.g., Sun 4).
1838 BFD_RELOC_SPARC_OLO10
1840 BFD_RELOC_SPARC_HH22
1842 BFD_RELOC_SPARC_HM10
1844 BFD_RELOC_SPARC_LM22
1846 BFD_RELOC_SPARC_PC_HH22
1848 BFD_RELOC_SPARC_PC_HM10
1850 BFD_RELOC_SPARC_PC_LM22
1852 BFD_RELOC_SPARC_WDISP16
1854 BFD_RELOC_SPARC_WDISP19
1862 BFD_RELOC_SPARC_DISP64
1865 BFD_RELOC_SPARC_PLT64
1867 BFD_RELOC_SPARC_HIX22
1869 BFD_RELOC_SPARC_LOX10
1877 BFD_RELOC_SPARC_REGISTER
1882 BFD_RELOC_SPARC_REV32
1884 SPARC little endian relocation
1887 BFD_RELOC_ALPHA_GPDISP_HI16
1889 Alpha ECOFF and ELF relocations. Some of these treat the symbol or
1890 "addend" in some special way.
1891 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1892 writing; when reading, it will be the absolute section symbol. The
1893 addend is the displacement in bytes of the "lda" instruction from
1894 the "ldah" instruction (which is at the address of this reloc).
1896 BFD_RELOC_ALPHA_GPDISP_LO16
1898 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1899 with GPDISP_HI16 relocs. The addend is ignored when writing the
1900 relocations out, and is filled in with the file's GP value on
1901 reading, for convenience.
1904 BFD_RELOC_ALPHA_GPDISP
1906 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1907 relocation except that there is no accompanying GPDISP_LO16
1911 BFD_RELOC_ALPHA_LITERAL
1913 BFD_RELOC_ALPHA_ELF_LITERAL
1915 BFD_RELOC_ALPHA_LITUSE
1917 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1918 the assembler turns it into a LDQ instruction to load the address of
1919 the symbol, and then fills in a register in the real instruction.
1921 The LITERAL reloc, at the LDQ instruction, refers to the .lita
1922 section symbol. The addend is ignored when writing, but is filled
1923 in with the file's GP value on reading, for convenience, as with the
1926 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1927 It should refer to the symbol to be referenced, as with 16_GOTOFF,
1928 but it generates output not based on the position within the .got
1929 section, but relative to the GP value chosen for the file during the
1932 The LITUSE reloc, on the instruction using the loaded address, gives
1933 information to the linker that it might be able to use to optimize
1934 away some literal section references. The symbol is ignored (read
1935 as the absolute section symbol), and the "addend" indicates the type
1936 of instruction using the register:
1937 1 - "memory" fmt insn
1938 2 - byte-manipulation (byte offset reg)
1939 3 - jsr (target of branch)
1941 The GNU linker currently doesn't do any of this optimizing.
1944 BFD_RELOC_ALPHA_USER_LITERAL
1946 BFD_RELOC_ALPHA_USER_LITUSE_BASE
1948 BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF
1950 BFD_RELOC_ALPHA_USER_LITUSE_JSR
1952 BFD_RELOC_ALPHA_USER_GPDISP
1954 BFD_RELOC_ALPHA_USER_GPRELHIGH
1956 BFD_RELOC_ALPHA_USER_GPRELLOW
1958 The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to
1959 process the explicit !<reloc>!sequence relocations, and are mapped
1960 into the normal relocations at the end of processing.
1963 BFD_RELOC_ALPHA_HINT
1965 The HINT relocation indicates a value that should be filled into the
1966 "hint" field of a jmp/jsr/ret instruction, for possible branch-
1967 prediction logic which may be provided on some processors.
1970 BFD_RELOC_ALPHA_LINKAGE
1972 The LINKAGE relocation outputs a linkage pair in the object file,
1973 which is filled by the linker.
1976 BFD_RELOC_ALPHA_CODEADDR
1978 The CODEADDR relocation outputs a STO_CA in the object file,
1979 which is filled by the linker.
1984 Bits 27..2 of the relocation address shifted right 2 bits;
1985 simple reloc otherwise.
1988 BFD_RELOC_MIPS16_JMP
1990 The MIPS16 jump instruction.
1993 BFD_RELOC_MIPS16_GPREL
1995 MIPS16 GP relative reloc.
2000 High 16 bits of 32-bit value; simple reloc.
2004 High 16 bits of 32-bit value but the low 16 bits will be sign
2005 extended and added to form the final result. If the low 16
2006 bits form a negative number, we need to add one to the high value
2007 to compensate for the borrow when the low bits are added.
2013 BFD_RELOC_PCREL_HI16_S
2015 Like BFD_RELOC_HI16_S, but PC relative.
2017 BFD_RELOC_PCREL_LO16
2019 Like BFD_RELOC_LO16, but PC relative.
2022 BFD_RELOC_MIPS_GPREL
2025 Relocation relative to the global pointer.
2028 BFD_RELOC_MIPS_LITERAL
2030 Relocation against a MIPS literal section.
2033 BFD_RELOC_MIPS_GOT16
2035 BFD_RELOC_MIPS_CALL16
2037 BFD_RELOC_MIPS_GPREL32
2040 BFD_RELOC_MIPS_GOT_HI16
2042 BFD_RELOC_MIPS_GOT_LO16
2044 BFD_RELOC_MIPS_CALL_HI16
2046 BFD_RELOC_MIPS_CALL_LO16
2050 BFD_RELOC_MIPS_GOT_PAGE
2052 BFD_RELOC_MIPS_GOT_OFST
2054 BFD_RELOC_MIPS_GOT_DISP
2059 BFD_RELOC_SH_GLOB_DAT
2061 BFD_RELOC_SH_JMP_SLOT
2063 BFD_RELOC_SH_RELATIVE
2068 MIPS ELF relocations.
2079 BFD_RELOC_386_GLOB_DAT
2081 BFD_RELOC_386_JUMP_SLOT
2083 BFD_RELOC_386_RELATIVE
2085 BFD_RELOC_386_GOTOFF
2089 i386/elf relocations
2092 BFD_RELOC_NS32K_IMM_8
2094 BFD_RELOC_NS32K_IMM_16
2096 BFD_RELOC_NS32K_IMM_32
2098 BFD_RELOC_NS32K_IMM_8_PCREL
2100 BFD_RELOC_NS32K_IMM_16_PCREL
2102 BFD_RELOC_NS32K_IMM_32_PCREL
2104 BFD_RELOC_NS32K_DISP_8
2106 BFD_RELOC_NS32K_DISP_16
2108 BFD_RELOC_NS32K_DISP_32
2110 BFD_RELOC_NS32K_DISP_8_PCREL
2112 BFD_RELOC_NS32K_DISP_16_PCREL
2114 BFD_RELOC_NS32K_DISP_32_PCREL
2119 BFD_RELOC_PJ_CODE_HI16
2121 BFD_RELOC_PJ_CODE_LO16
2123 BFD_RELOC_PJ_CODE_DIR16
2125 BFD_RELOC_PJ_CODE_DIR32
2127 BFD_RELOC_PJ_CODE_REL16
2129 BFD_RELOC_PJ_CODE_REL32
2131 Picojava relocs. Not all of these appear in object files.
2142 BFD_RELOC_PPC_B16_BRTAKEN
2144 BFD_RELOC_PPC_B16_BRNTAKEN
2148 BFD_RELOC_PPC_BA16_BRTAKEN
2150 BFD_RELOC_PPC_BA16_BRNTAKEN
2154 BFD_RELOC_PPC_GLOB_DAT
2156 BFD_RELOC_PPC_JMP_SLOT
2158 BFD_RELOC_PPC_RELATIVE
2160 BFD_RELOC_PPC_LOCAL24PC
2162 BFD_RELOC_PPC_EMB_NADDR32
2164 BFD_RELOC_PPC_EMB_NADDR16
2166 BFD_RELOC_PPC_EMB_NADDR16_LO
2168 BFD_RELOC_PPC_EMB_NADDR16_HI
2170 BFD_RELOC_PPC_EMB_NADDR16_HA
2172 BFD_RELOC_PPC_EMB_SDAI16
2174 BFD_RELOC_PPC_EMB_SDA2I16
2176 BFD_RELOC_PPC_EMB_SDA2REL
2178 BFD_RELOC_PPC_EMB_SDA21
2180 BFD_RELOC_PPC_EMB_MRKREF
2182 BFD_RELOC_PPC_EMB_RELSEC16
2184 BFD_RELOC_PPC_EMB_RELST_LO
2186 BFD_RELOC_PPC_EMB_RELST_HI
2188 BFD_RELOC_PPC_EMB_RELST_HA
2190 BFD_RELOC_PPC_EMB_BIT_FLD
2192 BFD_RELOC_PPC_EMB_RELSDA
2194 Power(rs6000) and PowerPC relocations.
2199 IBM 370/390 relocations
2204 The type of reloc used to build a contructor table - at the moment
2205 probably a 32 bit wide absolute relocation, but the target can choose.
2206 It generally does map to one of the other relocation types.
2209 BFD_RELOC_ARM_PCREL_BRANCH
2211 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
2212 not stored in the instruction.
2214 BFD_RELOC_ARM_PCREL_BLX
2216 ARM 26 bit pc-relative branch. The lowest bit must be zero and is
2217 not stored in the instruction. The 2nd lowest bit comes from a 1 bit
2218 field in the instruction.
2220 BFD_RELOC_THUMB_PCREL_BLX
2222 Thumb 22 bit pc-relative branch. The lowest bit must be zero and is
2223 not stored in the instruction. The 2nd lowest bit comes from a 1 bit
2224 field in the instruction.
2226 BFD_RELOC_ARM_IMMEDIATE
2228 BFD_RELOC_ARM_ADRL_IMMEDIATE
2230 BFD_RELOC_ARM_OFFSET_IMM
2232 BFD_RELOC_ARM_SHIFT_IMM
2238 BFD_RELOC_ARM_CP_OFF_IMM
2240 BFD_RELOC_ARM_ADR_IMM
2242 BFD_RELOC_ARM_LDR_IMM
2244 BFD_RELOC_ARM_LITERAL
2246 BFD_RELOC_ARM_IN_POOL
2248 BFD_RELOC_ARM_OFFSET_IMM8
2250 BFD_RELOC_ARM_HWLITERAL
2252 BFD_RELOC_ARM_THUMB_ADD
2254 BFD_RELOC_ARM_THUMB_IMM
2256 BFD_RELOC_ARM_THUMB_SHIFT
2258 BFD_RELOC_ARM_THUMB_OFFSET
2264 BFD_RELOC_ARM_JUMP_SLOT
2268 BFD_RELOC_ARM_GLOB_DAT
2272 BFD_RELOC_ARM_RELATIVE
2274 BFD_RELOC_ARM_GOTOFF
2278 These relocs are only used within the ARM assembler. They are not
2279 (at present) written to any object files.
2282 BFD_RELOC_SH_PCDISP8BY2
2284 BFD_RELOC_SH_PCDISP12BY2
2288 BFD_RELOC_SH_IMM4BY2
2290 BFD_RELOC_SH_IMM4BY4
2294 BFD_RELOC_SH_IMM8BY2
2296 BFD_RELOC_SH_IMM8BY4
2298 BFD_RELOC_SH_PCRELIMM8BY2
2300 BFD_RELOC_SH_PCRELIMM8BY4
2302 BFD_RELOC_SH_SWITCH16
2304 BFD_RELOC_SH_SWITCH32
2318 BFD_RELOC_SH_LOOP_START
2320 BFD_RELOC_SH_LOOP_END
2322 Hitachi SH relocs. Not all of these appear in object files.
2325 BFD_RELOC_THUMB_PCREL_BRANCH9
2327 BFD_RELOC_THUMB_PCREL_BRANCH12
2329 BFD_RELOC_THUMB_PCREL_BRANCH23
2331 Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must
2332 be zero and is not stored in the instruction.
2335 BFD_RELOC_ARC_B22_PCREL
2337 Argonaut RISC Core (ARC) relocs.
2338 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
2339 not stored in the instruction. The high 20 bits are installed in bits 26
2340 through 7 of the instruction.
2344 ARC 26 bit absolute branch. The lowest two bits must be zero and are not
2345 stored in the instruction. The high 24 bits are installed in bits 23
2349 BFD_RELOC_D10V_10_PCREL_R
2351 Mitsubishi D10V relocs.
2352 This is a 10-bit reloc with the right 2 bits
2355 BFD_RELOC_D10V_10_PCREL_L
2357 Mitsubishi D10V relocs.
2358 This is a 10-bit reloc with the right 2 bits
2359 assumed to be 0. This is the same as the previous reloc
2360 except it is in the left container, i.e.,
2361 shifted left 15 bits.
2365 This is an 18-bit reloc with the right 2 bits
2368 BFD_RELOC_D10V_18_PCREL
2370 This is an 18-bit reloc with the right 2 bits
2376 Mitsubishi D30V relocs.
2377 This is a 6-bit absolute reloc.
2379 BFD_RELOC_D30V_9_PCREL
2381 This is a 6-bit pc-relative reloc with
2382 the right 3 bits assumed to be 0.
2384 BFD_RELOC_D30V_9_PCREL_R
2386 This is a 6-bit pc-relative reloc with
2387 the right 3 bits assumed to be 0. Same
2388 as the previous reloc but on the right side
2393 This is a 12-bit absolute reloc with the
2394 right 3 bitsassumed to be 0.
2396 BFD_RELOC_D30V_15_PCREL
2398 This is a 12-bit pc-relative reloc with
2399 the right 3 bits assumed to be 0.
2401 BFD_RELOC_D30V_15_PCREL_R
2403 This is a 12-bit pc-relative reloc with
2404 the right 3 bits assumed to be 0. Same
2405 as the previous reloc but on the right side
2410 This is an 18-bit absolute reloc with
2411 the right 3 bits assumed to be 0.
2413 BFD_RELOC_D30V_21_PCREL
2415 This is an 18-bit pc-relative reloc with
2416 the right 3 bits assumed to be 0.
2418 BFD_RELOC_D30V_21_PCREL_R
2420 This is an 18-bit pc-relative reloc with
2421 the right 3 bits assumed to be 0. Same
2422 as the previous reloc but on the right side
2427 This is a 32-bit absolute reloc.
2429 BFD_RELOC_D30V_32_PCREL
2431 This is a 32-bit pc-relative reloc.
2436 Mitsubishi M32R relocs.
2437 This is a 24 bit absolute address.
2439 BFD_RELOC_M32R_10_PCREL
2441 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
2443 BFD_RELOC_M32R_18_PCREL
2445 This is an 18-bit reloc with the right 2 bits assumed to be 0.
2447 BFD_RELOC_M32R_26_PCREL
2449 This is a 26-bit reloc with the right 2 bits assumed to be 0.
2451 BFD_RELOC_M32R_HI16_ULO
2453 This is a 16-bit reloc containing the high 16 bits of an address
2454 used when the lower 16 bits are treated as unsigned.
2456 BFD_RELOC_M32R_HI16_SLO
2458 This is a 16-bit reloc containing the high 16 bits of an address
2459 used when the lower 16 bits are treated as signed.
2463 This is a 16-bit reloc containing the lower 16 bits of an address.
2465 BFD_RELOC_M32R_SDA16
2467 This is a 16-bit reloc containing the small data area offset for use in
2468 add3, load, and store instructions.
2471 BFD_RELOC_V850_9_PCREL
2473 This is a 9-bit reloc
2475 BFD_RELOC_V850_22_PCREL
2477 This is a 22-bit reloc
2480 BFD_RELOC_V850_SDA_16_16_OFFSET
2482 This is a 16 bit offset from the short data area pointer.
2484 BFD_RELOC_V850_SDA_15_16_OFFSET
2486 This is a 16 bit offset (of which only 15 bits are used) from the
2487 short data area pointer.
2489 BFD_RELOC_V850_ZDA_16_16_OFFSET
2491 This is a 16 bit offset from the zero data area pointer.
2493 BFD_RELOC_V850_ZDA_15_16_OFFSET
2495 This is a 16 bit offset (of which only 15 bits are used) from the
2496 zero data area pointer.
2498 BFD_RELOC_V850_TDA_6_8_OFFSET
2500 This is an 8 bit offset (of which only 6 bits are used) from the
2501 tiny data area pointer.
2503 BFD_RELOC_V850_TDA_7_8_OFFSET
2505 This is an 8bit offset (of which only 7 bits are used) from the tiny
2508 BFD_RELOC_V850_TDA_7_7_OFFSET
2510 This is a 7 bit offset from the tiny data area pointer.
2512 BFD_RELOC_V850_TDA_16_16_OFFSET
2514 This is a 16 bit offset from the tiny data area pointer.
2517 BFD_RELOC_V850_TDA_4_5_OFFSET
2519 This is a 5 bit offset (of which only 4 bits are used) from the tiny
2522 BFD_RELOC_V850_TDA_4_4_OFFSET
2524 This is a 4 bit offset from the tiny data area pointer.
2526 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
2528 This is a 16 bit offset from the short data area pointer, with the
2529 bits placed non-contigously in the instruction.
2531 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
2533 This is a 16 bit offset from the zero data area pointer, with the
2534 bits placed non-contigously in the instruction.
2536 BFD_RELOC_V850_CALLT_6_7_OFFSET
2538 This is a 6 bit offset from the call table base pointer.
2540 BFD_RELOC_V850_CALLT_16_16_OFFSET
2542 This is a 16 bit offset from the call table base pointer.
2546 BFD_RELOC_MN10300_32_PCREL
2548 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2551 BFD_RELOC_MN10300_16_PCREL
2553 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2559 This is a 8bit DP reloc for the tms320c30, where the most
2560 significant 8 bits of a 24 bit word are placed into the least
2561 significant 8 bits of the opcode.
2564 BFD_RELOC_TIC54X_PARTLS7
2566 This is a 7bit reloc for the tms320c54x, where the least
2567 significant 7 bits of a 16 bit word are placed into the least
2568 significant 7 bits of the opcode.
2571 BFD_RELOC_TIC54X_PARTMS9
2573 This is a 9bit DP reloc for the tms320c54x, where the most
2574 significant 9 bits of a 16 bit word are placed into the least
2575 significant 9 bits of the opcode.
2580 This is an extended address 23-bit reloc for the tms320c54x.
2583 BFD_RELOC_TIC54X_16_OF_23
2585 This is a 16-bit reloc for the tms320c54x, where the least
2586 significant 16 bits of a 23-bit extended address are placed into
2590 BFD_RELOC_TIC54X_MS7_OF_23
2592 This is a reloc for the tms320c54x, where the most
2593 significant 7 bits of a 23-bit extended address are placed into
2599 This is a 48 bit reloc for the FR30 that stores 32 bits.
2603 This is a 32 bit reloc for the FR30 that stores 20 bits split up into
2606 BFD_RELOC_FR30_6_IN_4
2608 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
2611 BFD_RELOC_FR30_8_IN_8
2613 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
2616 BFD_RELOC_FR30_9_IN_8
2618 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
2621 BFD_RELOC_FR30_10_IN_8
2623 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
2626 BFD_RELOC_FR30_9_PCREL
2628 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
2629 short offset into 8 bits.
2631 BFD_RELOC_FR30_12_PCREL
2633 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
2634 short offset into 11 bits.
2637 BFD_RELOC_MCORE_PCREL_IMM8BY4
2639 BFD_RELOC_MCORE_PCREL_IMM11BY2
2641 BFD_RELOC_MCORE_PCREL_IMM4BY2
2643 BFD_RELOC_MCORE_PCREL_32
2645 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
2649 Motorola Mcore relocations.
2652 BFD_RELOC_AVR_7_PCREL
2654 This is a 16 bit reloc for the AVR that stores 8 bit pc relative
2655 short offset into 7 bits.
2657 BFD_RELOC_AVR_13_PCREL
2659 This is a 16 bit reloc for the AVR that stores 13 bit pc relative
2660 short offset into 12 bits.
2664 This is a 16 bit reloc for the AVR that stores 17 bit value (usually
2665 program memory address) into 16 bits.
2667 BFD_RELOC_AVR_LO8_LDI
2669 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2670 data memory address) into 8 bit immediate value of LDI insn.
2672 BFD_RELOC_AVR_HI8_LDI
2674 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2675 of data memory address) into 8 bit immediate value of LDI insn.
2677 BFD_RELOC_AVR_HH8_LDI
2679 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2680 of program memory address) into 8 bit immediate value of LDI insn.
2682 BFD_RELOC_AVR_LO8_LDI_NEG
2684 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2685 (usually data memory address) into 8 bit immediate value of SUBI insn.
2687 BFD_RELOC_AVR_HI8_LDI_NEG
2689 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2690 (high 8 bit of data memory address) into 8 bit immediate value of
2693 BFD_RELOC_AVR_HH8_LDI_NEG
2695 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2696 (most high 8 bit of program memory address) into 8 bit immediate value
2697 of LDI or SUBI insn.
2699 BFD_RELOC_AVR_LO8_LDI_PM
2701 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2702 command address) into 8 bit immediate value of LDI insn.
2704 BFD_RELOC_AVR_HI8_LDI_PM
2706 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2707 of command address) into 8 bit immediate value of LDI insn.
2709 BFD_RELOC_AVR_HH8_LDI_PM
2711 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2712 of command address) into 8 bit immediate value of LDI insn.
2714 BFD_RELOC_AVR_LO8_LDI_PM_NEG
2716 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2717 (usually command address) into 8 bit immediate value of SUBI insn.
2719 BFD_RELOC_AVR_HI8_LDI_PM_NEG
2721 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2722 (high 8 bit of 16 bit command address) into 8 bit immediate value
2725 BFD_RELOC_AVR_HH8_LDI_PM_NEG
2727 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2728 (high 6 bit of 22 bit command address) into 8 bit immediate
2733 This is a 32 bit reloc for the AVR that stores 23 bit value
2737 BFD_RELOC_VTABLE_INHERIT
2739 BFD_RELOC_VTABLE_ENTRY
2741 These two relocations are used by the linker to determine which of
2742 the entries in a C++ virtual function table are actually used. When
2743 the --gc-sections option is given, the linker will zero out the entries
2744 that are not used, so that the code for those functions need not be
2745 included in the output.
2747 VTABLE_INHERIT is a zero-space relocation used to describe to the
2748 linker the inheritence tree of a C++ virtual function table. The
2749 relocation's symbol should be the parent class' vtable, and the
2750 relocation should be located at the child vtable.
2752 VTABLE_ENTRY is a zero-space relocation that describes the use of a
2753 virtual function table entry. The reloc's symbol should refer to the
2754 table of the class mentioned in the code. Off of that base, an offset
2755 describes the entry that is being used. For Rela hosts, this offset
2756 is stored in the reloc's addend. For Rel hosts, we are forced to put
2757 this offset in the reloc's section offset.
2760 BFD_RELOC_IA64_IMM14
2762 BFD_RELOC_IA64_IMM22
2764 BFD_RELOC_IA64_IMM64
2766 BFD_RELOC_IA64_DIR32MSB
2768 BFD_RELOC_IA64_DIR32LSB
2770 BFD_RELOC_IA64_DIR64MSB
2772 BFD_RELOC_IA64_DIR64LSB
2774 BFD_RELOC_IA64_GPREL22
2776 BFD_RELOC_IA64_GPREL64I
2778 BFD_RELOC_IA64_GPREL32MSB
2780 BFD_RELOC_IA64_GPREL32LSB
2782 BFD_RELOC_IA64_GPREL64MSB
2784 BFD_RELOC_IA64_GPREL64LSB
2786 BFD_RELOC_IA64_LTOFF22
2788 BFD_RELOC_IA64_LTOFF64I
2790 BFD_RELOC_IA64_PLTOFF22
2792 BFD_RELOC_IA64_PLTOFF64I
2794 BFD_RELOC_IA64_PLTOFF64MSB
2796 BFD_RELOC_IA64_PLTOFF64LSB
2798 BFD_RELOC_IA64_FPTR64I
2800 BFD_RELOC_IA64_FPTR32MSB
2802 BFD_RELOC_IA64_FPTR32LSB
2804 BFD_RELOC_IA64_FPTR64MSB
2806 BFD_RELOC_IA64_FPTR64LSB
2808 BFD_RELOC_IA64_PCREL21B
2810 BFD_RELOC_IA64_PCREL21BI
2812 BFD_RELOC_IA64_PCREL21M
2814 BFD_RELOC_IA64_PCREL21F
2816 BFD_RELOC_IA64_PCREL22
2818 BFD_RELOC_IA64_PCREL60B
2820 BFD_RELOC_IA64_PCREL64I
2822 BFD_RELOC_IA64_PCREL32MSB
2824 BFD_RELOC_IA64_PCREL32LSB
2826 BFD_RELOC_IA64_PCREL64MSB
2828 BFD_RELOC_IA64_PCREL64LSB
2830 BFD_RELOC_IA64_LTOFF_FPTR22
2832 BFD_RELOC_IA64_LTOFF_FPTR64I
2834 BFD_RELOC_IA64_LTOFF_FPTR64MSB
2836 BFD_RELOC_IA64_LTOFF_FPTR64LSB
2838 BFD_RELOC_IA64_SEGBASE
2840 BFD_RELOC_IA64_SEGREL32MSB
2842 BFD_RELOC_IA64_SEGREL32LSB
2844 BFD_RELOC_IA64_SEGREL64MSB
2846 BFD_RELOC_IA64_SEGREL64LSB
2848 BFD_RELOC_IA64_SECREL32MSB
2850 BFD_RELOC_IA64_SECREL32LSB
2852 BFD_RELOC_IA64_SECREL64MSB
2854 BFD_RELOC_IA64_SECREL64LSB
2856 BFD_RELOC_IA64_REL32MSB
2858 BFD_RELOC_IA64_REL32LSB
2860 BFD_RELOC_IA64_REL64MSB
2862 BFD_RELOC_IA64_REL64LSB
2864 BFD_RELOC_IA64_LTV32MSB
2866 BFD_RELOC_IA64_LTV32LSB
2868 BFD_RELOC_IA64_LTV64MSB
2870 BFD_RELOC_IA64_LTV64LSB
2872 BFD_RELOC_IA64_IPLTMSB
2874 BFD_RELOC_IA64_IPLTLSB
2876 BFD_RELOC_IA64_EPLTMSB
2878 BFD_RELOC_IA64_EPLTLSB
2882 BFD_RELOC_IA64_TPREL22
2884 BFD_RELOC_IA64_TPREL64MSB
2886 BFD_RELOC_IA64_TPREL64LSB
2888 BFD_RELOC_IA64_LTOFF_TP22
2890 BFD_RELOC_IA64_LTOFF22X
2892 BFD_RELOC_IA64_LDXMOV
2894 Intel IA64 Relocations.
2897 BFD_RELOC_M68HC11_HI8
2899 Motorola 68HC11 reloc.
2900 This is the 8 bits high part of an absolute address.
2902 BFD_RELOC_M68HC11_LO8
2904 Motorola 68HC11 reloc.
2905 This is the 8 bits low part of an absolute address.
2907 BFD_RELOC_M68HC11_3B
2909 Motorola 68HC11 reloc.
2910 This is the 3 bits of a value.
2913 BFD_RELOC_CRIS_BDISP8
2915 BFD_RELOC_CRIS_UNSIGNED_5
2917 BFD_RELOC_CRIS_SIGNED_6
2919 BFD_RELOC_CRIS_UNSIGNED_6
2921 BFD_RELOC_CRIS_UNSIGNED_4
2923 These relocs are only used within the CRIS assembler. They are not
2924 (at present) written to any object files.
2929 BFD_RELOC_860_GLOB_DAT
2931 BFD_RELOC_860_JUMP_SLOT
2933 BFD_RELOC_860_RELATIVE
2943 BFD_RELOC_860_SPLIT0
2947 BFD_RELOC_860_SPLIT1
2951 BFD_RELOC_860_SPLIT2
2955 BFD_RELOC_860_LOGOT0
2957 BFD_RELOC_860_SPGOT0
2959 BFD_RELOC_860_LOGOT1
2961 BFD_RELOC_860_SPGOT1
2963 BFD_RELOC_860_LOGOTOFF0
2965 BFD_RELOC_860_SPGOTOFF0
2967 BFD_RELOC_860_LOGOTOFF1
2969 BFD_RELOC_860_SPGOTOFF1
2971 BFD_RELOC_860_LOGOTOFF2
2973 BFD_RELOC_860_LOGOTOFF3
2977 BFD_RELOC_860_HIGHADJ
2981 BFD_RELOC_860_HAGOTOFF
2989 BFD_RELOC_860_HIGOTOFF
2991 Intel i860 Relocations.
2997 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
3003 bfd_reloc_type_lookup
3007 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
3010 Return a pointer to a howto structure which, when
3011 invoked, will perform the relocation @var{code} on data from the
3018 bfd_reloc_type_lookup (abfd, code)
3020 bfd_reloc_code_real_type code;
3022 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
3025 static reloc_howto_type bfd_howto_32 =
3026 HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
3031 bfd_default_reloc_type_lookup
3034 reloc_howto_type *bfd_default_reloc_type_lookup
3035 (bfd *abfd, bfd_reloc_code_real_type code);
3038 Provides a default relocation lookup routine for any architecture.
3044 bfd_default_reloc_type_lookup (abfd, code)
3046 bfd_reloc_code_real_type code;
3050 case BFD_RELOC_CTOR:
3051 /* The type of reloc used in a ctor, which will be as wide as the
3052 address - so either a 64, 32, or 16 bitter. */
3053 switch (bfd_get_arch_info (abfd)->bits_per_address)
3058 return &bfd_howto_32;
3067 return (reloc_howto_type *) NULL;
3072 bfd_get_reloc_code_name
3075 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
3078 Provides a printable name for the supplied relocation code.
3079 Useful mainly for printing error messages.
3083 bfd_get_reloc_code_name (code)
3084 bfd_reloc_code_real_type code;
3086 if (code > BFD_RELOC_UNUSED)
3088 return bfd_reloc_code_real_names[(int)code];
3093 bfd_generic_relax_section
3096 boolean bfd_generic_relax_section
3099 struct bfd_link_info *,
3103 Provides default handling for relaxing for back ends which
3104 don't do relaxing -- i.e., does nothing.
3109 bfd_generic_relax_section (abfd, section, link_info, again)
3110 bfd *abfd ATTRIBUTE_UNUSED;
3111 asection *section ATTRIBUTE_UNUSED;
3112 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3121 bfd_generic_gc_sections
3124 boolean bfd_generic_gc_sections
3125 (bfd *, struct bfd_link_info *);
3128 Provides default handling for relaxing for back ends which
3129 don't do section gc -- i.e., does nothing.
3134 bfd_generic_gc_sections (abfd, link_info)
3135 bfd *abfd ATTRIBUTE_UNUSED;
3136 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3143 bfd_generic_get_relocated_section_contents
3147 bfd_generic_get_relocated_section_contents (bfd *abfd,
3148 struct bfd_link_info *link_info,
3149 struct bfd_link_order *link_order,
3151 boolean relocateable,
3155 Provides default handling of relocation effort for back ends
3156 which can't be bothered to do it efficiently.
3161 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
3162 relocateable, symbols)
3164 struct bfd_link_info *link_info;
3165 struct bfd_link_order *link_order;
3167 boolean relocateable;
3170 /* Get enough memory to hold the stuff */
3171 bfd *input_bfd = link_order->u.indirect.section->owner;
3172 asection *input_section = link_order->u.indirect.section;
3174 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
3175 arelent **reloc_vector = NULL;
3181 reloc_vector = (arelent **) bfd_malloc ((size_t) reloc_size);
3182 if (reloc_vector == NULL && reloc_size != 0)
3185 /* read in the section */
3186 if (!bfd_get_section_contents (input_bfd,
3190 input_section->_raw_size))
3193 /* We're not relaxing the section, so just copy the size info */
3194 input_section->_cooked_size = input_section->_raw_size;
3195 input_section->reloc_done = true;
3197 reloc_count = bfd_canonicalize_reloc (input_bfd,
3201 if (reloc_count < 0)
3204 if (reloc_count > 0)
3207 for (parent = reloc_vector; *parent != (arelent *) NULL;
3210 char *error_message = (char *) NULL;
3211 bfd_reloc_status_type r =
3212 bfd_perform_relocation (input_bfd,
3216 relocateable ? abfd : (bfd *) NULL,
3221 asection *os = input_section->output_section;
3223 /* A partial link, so keep the relocs */
3224 os->orelocation[os->reloc_count] = *parent;
3228 if (r != bfd_reloc_ok)
3232 case bfd_reloc_undefined:
3233 if (!((*link_info->callbacks->undefined_symbol)
3234 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
3235 input_bfd, input_section, (*parent)->address,
3239 case bfd_reloc_dangerous:
3240 BFD_ASSERT (error_message != (char *) NULL);
3241 if (!((*link_info->callbacks->reloc_dangerous)
3242 (link_info, error_message, input_bfd, input_section,
3243 (*parent)->address)))
3246 case bfd_reloc_overflow:
3247 if (!((*link_info->callbacks->reloc_overflow)
3248 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
3249 (*parent)->howto->name, (*parent)->addend,
3250 input_bfd, input_section, (*parent)->address)))
3253 case bfd_reloc_outofrange:
3262 if (reloc_vector != NULL)
3263 free (reloc_vector);
3267 if (reloc_vector != NULL)
3268 free (reloc_vector);