1 /* BFD support for handling relocation entries.
2 Copyright (C) 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 BFD maintains relocations in much the same way it maintains
26 symbols: they are left alone until required, then read in
27 en-mass and translated into an internal form. A common
28 routine <<bfd_perform_relocation>> acts upon the
29 canonical form to do the fixup.
31 Relocations are maintained on a per section basis,
32 while symbols are maintained on a per BFD basis.
34 All that a back end has to do to fit the BFD interface is to create
35 a <<struct reloc_cache_entry>> for each relocation
36 in a particular section, and fill in the right bits of the structures.
45 /* DO compile in the reloc_code name table from libbfd.h. */
46 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
55 typedef arelent, howto manager, Relocations, Relocations
60 This is the structure of a relocation entry:
64 .typedef enum bfd_reloc_status
66 . {* No errors detected *}
69 . {* The relocation was performed, but there was an overflow. *}
72 . {* The address to relocate was not within the section supplied. *}
73 . bfd_reloc_outofrange,
75 . {* Used by special functions *}
78 . {* Unsupported relocation size requested. *}
79 . bfd_reloc_notsupported,
84 . {* The symbol to relocate against was undefined. *}
85 . bfd_reloc_undefined,
87 . {* The relocation was performed, but may not be ok - presently
88 . generated only when linking i960 coff files with i960 b.out
89 . symbols. If this type is returned, the error_message argument
90 . to bfd_perform_relocation will be set. *}
93 . bfd_reloc_status_type;
96 .typedef struct reloc_cache_entry
98 . {* A pointer into the canonical table of pointers *}
99 . struct symbol_cache_entry **sym_ptr_ptr;
101 . {* offset in section *}
102 . bfd_size_type address;
104 . {* addend for relocation value *}
107 . {* Pointer to how to perform the required relocation *}
108 . reloc_howto_type *howto;
117 Here is a description of each of the fields within an <<arelent>>:
121 The symbol table pointer points to a pointer to the symbol
122 associated with the relocation request. It is
123 the pointer into the table returned by the back end's
124 <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
125 through a pointer to a pointer so that tools like the linker
126 can fix up all the symbols of the same name by modifying only
127 one pointer. The relocation routine looks in the symbol and
128 uses the base of the section the symbol is attached to and the
129 value of the symbol as the initial relocation offset. If the
130 symbol pointer is zero, then the section provided is looked up.
134 The <<address>> field gives the offset in bytes from the base of
135 the section data which owns the relocation record to the first
136 byte of relocatable information. The actual data relocated
137 will be relative to this point; for example, a relocation
138 type which modifies the bottom two bytes of a four byte word
139 would not touch the first byte pointed to in a big endian
144 The <<addend>> is a value provided by the back end to be added (!)
145 to the relocation offset. Its interpretation is dependent upon
146 the howto. For example, on the 68k the code:
152 | return foo[0x12345678];
155 Could be compiled into:
158 | moveb @@#12345678,d0
164 This could create a reloc pointing to <<foo>>, but leave the
165 offset in the data, something like:
168 |RELOCATION RECORDS FOR [.text]:
172 |00000000 4e56 fffc ; linkw fp,#-4
173 |00000004 1039 1234 5678 ; moveb @@#12345678,d0
174 |0000000a 49c0 ; extbl d0
175 |0000000c 4e5e ; unlk fp
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:
184 | or.u r13,r0,hi16(_foo+0x12345678)
185 | ld.b r2,r13,lo16(_foo+0x12345678)
189 This should create two relocs, both pointing to <<_foo>>, and with
190 0x12340000 in their addend field. The data would consist of:
193 |RELOCATION RECORDS FOR [.text]:
195 |00000002 HVRT16 _foo+0x12340000
196 |00000006 LVRT16 _foo+0x12340000
198 |00000000 5da05678 ; or.u r13,r0,0x5678
199 |00000004 1c4d5678 ; ld.b r2,r13,0x5678
200 |00000008 f400c001 ; jmp r1
203 The relocation routine digs out the value from the data, adds
204 it to the addend to get the original offset, and then adds the
205 value of <<_foo>>. Note that all 32 bits have to be kept around
206 somewhere, to cope with carry from bit 15 to bit 16.
208 One further example is the sparc and the a.out format. The
209 sparc has a similar problem to the 88k, in that some
210 instructions don't have room for an entire offset, but on the
211 sparc the parts are created in odd sized lumps. The designers of
212 the a.out format chose to not use the data within the section
213 for storing part of the offset; all the offset is kept within
214 the reloc. Anything in the data should be ignored.
217 | sethi %hi(_foo+0x12345678),%g2
218 | ldsb [%g2+%lo(_foo+0x12345678)],%i0
222 Both relocs contain a pointer to <<foo>>, and the offsets
226 |RELOCATION RECORDS FOR [.text]:
228 |00000004 HI22 _foo+0x12345678
229 |00000008 LO10 _foo+0x12345678
231 |00000000 9de3bf90 ; save %sp,-112,%sp
232 |00000004 05000000 ; sethi %hi(_foo+0),%g2
233 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0
234 |0000000c 81c7e008 ; ret
235 |00000010 81e80000 ; restore
240 The <<howto>> field can be imagined as a
241 relocation instruction. It is a pointer to a structure which
242 contains information on what to do with all of the other
243 information in the reloc record and data section. A back end
244 would normally have a relocation instruction set and turn
245 relocations into pointers to the correct structure on input -
246 but it would be possible to create each howto field on demand.
252 <<enum complain_overflow>>
254 Indicates what sort of overflow checking should be done when
255 performing a relocation.
259 .enum complain_overflow
261 . {* Do not complain on overflow. *}
262 . complain_overflow_dont,
264 . {* Complain if the bitfield overflows, whether it is considered
265 . as signed or unsigned. *}
266 . complain_overflow_bitfield,
268 . {* Complain if the value overflows when considered as signed
270 . complain_overflow_signed,
272 . {* Complain if the value overflows when considered as an
273 . unsigned number. *}
274 . complain_overflow_unsigned
283 The <<reloc_howto_type>> is a structure which contains all the
284 information that libbfd needs to know to tie up a back end's data.
287 .struct symbol_cache_entry; {* Forward declaration *}
289 .struct reloc_howto_struct
291 . {* The type field has mainly a documetary use - the back end can
292 . do what it wants with it, though normally the back end's
293 . external idea of what a reloc number is stored
294 . in this field. For example, a PC relative word relocation
295 . in a coff environment has the type 023 - because that's
296 . what the outside world calls a R_PCRWORD reloc. *}
299 . {* The value the final relocation is shifted right by. This drops
300 . unwanted data from the relocation. *}
301 . unsigned int rightshift;
303 . {* The size of the item to be relocated. This is *not* a
304 . power-of-two measure. To get the number of bytes operated
305 . on by a type of relocation, use bfd_get_reloc_size. *}
308 . {* The number of bits in the item to be relocated. This is used
309 . when doing overflow checking. *}
310 . unsigned int bitsize;
312 . {* Notes that the relocation is relative to the location in the
313 . data section of the addend. The relocation function will
314 . subtract from the relocation value the address of the location
315 . being relocated. *}
316 . boolean pc_relative;
318 . {* The bit position of the reloc value in the destination.
319 . The relocated value is left shifted by this amount. *}
320 . unsigned int bitpos;
322 . {* What type of overflow error should be checked for when
324 . enum complain_overflow complain_on_overflow;
326 . {* If this field is non null, then the supplied function is
327 . called rather than the normal function. This allows really
328 . strange relocation methods to be accomodated (e.g., i960 callj
330 . bfd_reloc_status_type (*special_function)
331 . PARAMS ((bfd *abfd,
332 . arelent *reloc_entry,
333 . struct symbol_cache_entry *symbol,
335 . asection *input_section,
337 . char **error_message));
339 . {* The textual name of the relocation type. *}
342 . {* When performing a partial link, some formats must modify the
343 . relocations rather than the data - this flag signals this.*}
344 . boolean partial_inplace;
346 . {* The src_mask selects which parts of the read in data
347 . are to be used in the relocation sum. E.g., if this was an 8 bit
348 . bit of data which we read and relocated, this would be
349 . 0x000000ff. When we have relocs which have an addend, such as
350 . sun4 extended relocs, the value in the offset part of a
351 . relocating field is garbage so we never use it. In this case
352 . the mask would be 0x00000000. *}
355 . {* The dst_mask selects which parts of the instruction are replaced
356 . into the instruction. In most cases src_mask == dst_mask,
357 . except in the above special case, where dst_mask would be
358 . 0x000000ff, and src_mask would be 0x00000000. *}
361 . {* When some formats create PC relative instructions, they leave
362 . the value of the pc of the place being relocated in the offset
363 . slot of the instruction, so that a PC relative relocation can
364 . be made just by adding in an ordinary offset (e.g., sun3 a.out).
365 . Some formats leave the displacement part of an instruction
366 . empty (e.g., m88k bcs); this flag signals the fact.*}
367 . boolean pcrel_offset;
378 The HOWTO define is horrible and will go away.
381 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
382 . {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
385 And will be replaced with the totally magic way. But for the
386 moment, we are compatible, so do it this way.
389 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
392 Helper routine to turn a symbol into a relocation value.
394 .#define HOWTO_PREPARE(relocation, symbol) \
396 . if (symbol != (asymbol *)NULL) { \
397 . if (bfd_is_com_section (symbol->section)) { \
401 . relocation = symbol->value; \
413 int bfd_get_reloc_size (reloc_howto_type *);
416 For a reloc_howto_type that operates on a fixed number of bytes,
417 this returns the number of bytes operated on.
421 bfd_get_reloc_size (howto
)
422 reloc_howto_type
*howto
;
442 How relocs are tied together in an <<asection>>:
444 .typedef struct relent_chain {
446 . struct relent_chain *next;
455 bfd_perform_relocation
458 bfd_reloc_status_type
459 bfd_perform_relocation
461 arelent *reloc_entry,
463 asection *input_section,
465 char **error_message);
468 If @var{output_bfd} is supplied to this function, the
469 generated image will be relocatable; the relocations are
470 copied to the output file after they have been changed to
471 reflect the new state of the world. There are two ways of
472 reflecting the results of partial linkage in an output file:
473 by modifying the output data in place, and by modifying the
474 relocation record. Some native formats (e.g., basic a.out and
475 basic coff) have no way of specifying an addend in the
476 relocation type, so the addend has to go in the output data.
477 This is no big deal since in these formats the output data
478 slot will always be big enough for the addend. Complex reloc
479 types with addends were invented to solve just this problem.
480 The @var{error_message} argument is set to an error message if
481 this return @code{bfd_reloc_dangerous}.
486 bfd_reloc_status_type
487 bfd_perform_relocation (abfd
, reloc_entry
, data
, input_section
, output_bfd
,
490 arelent
*reloc_entry
;
492 asection
*input_section
;
494 char **error_message
;
497 bfd_reloc_status_type flag
= bfd_reloc_ok
;
498 bfd_size_type addr
= reloc_entry
->address
;
499 bfd_vma output_base
= 0;
500 reloc_howto_type
*howto
= reloc_entry
->howto
;
501 asection
*reloc_target_output_section
;
504 symbol
= *(reloc_entry
->sym_ptr_ptr
);
505 if (bfd_is_abs_section (symbol
->section
)
506 && output_bfd
!= (bfd
*) NULL
)
508 reloc_entry
->address
+= input_section
->output_offset
;
512 /* If we are not producing relocateable output, return an error if
513 the symbol is not defined. An undefined weak symbol is
514 considered to have a value of zero (SVR4 ABI, p. 4-27). */
515 if (bfd_is_und_section (symbol
->section
)
516 && (symbol
->flags
& BSF_WEAK
) == 0
517 && output_bfd
== (bfd
*) NULL
)
518 flag
= bfd_reloc_undefined
;
520 /* If there is a function supplied to handle this relocation type,
521 call it. It'll return `bfd_reloc_continue' if further processing
523 if (howto
->special_function
)
525 bfd_reloc_status_type cont
;
526 cont
= howto
->special_function (abfd
, reloc_entry
, symbol
, data
,
527 input_section
, output_bfd
,
529 if (cont
!= bfd_reloc_continue
)
533 /* Is the address of the relocation really within the section? */
534 if (reloc_entry
->address
> input_section
->_cooked_size
)
535 return bfd_reloc_outofrange
;
537 /* Work out which section the relocation is targetted at and the
538 initial relocation command value. */
540 /* Get symbol value. (Common symbols are special.) */
541 if (bfd_is_com_section (symbol
->section
))
544 relocation
= symbol
->value
;
547 reloc_target_output_section
= symbol
->section
->output_section
;
549 /* Convert input-section-relative symbol value to absolute. */
550 if (output_bfd
&& howto
->partial_inplace
== false)
553 output_base
= reloc_target_output_section
->vma
;
555 relocation
+= output_base
+ symbol
->section
->output_offset
;
557 /* Add in supplied addend. */
558 relocation
+= reloc_entry
->addend
;
560 /* Here the variable relocation holds the final address of the
561 symbol we are relocating against, plus any addend. */
563 if (howto
->pc_relative
== true)
565 /* This is a PC relative relocation. We want to set RELOCATION
566 to the distance between the address of the symbol and the
567 location. RELOCATION is already the address of the symbol.
569 We start by subtracting the address of the section containing
572 If pcrel_offset is set, we must further subtract the position
573 of the location within the section. Some targets arrange for
574 the addend to be the negative of the position of the location
575 within the section; for example, i386-aout does this. For
576 i386-aout, pcrel_offset is false. Some other targets do not
577 include the position of the location; for example, m88kbcs,
578 or ELF. For those targets, pcrel_offset is true.
580 If we are producing relocateable output, then we must ensure
581 that this reloc will be correctly computed when the final
582 relocation is done. If pcrel_offset is false we want to wind
583 up with the negative of the location within the section,
584 which means we must adjust the existing addend by the change
585 in the location within the section. If pcrel_offset is true
586 we do not want to adjust the existing addend at all.
588 FIXME: This seems logical to me, but for the case of
589 producing relocateable output it is not what the code
590 actually does. I don't want to change it, because it seems
591 far too likely that something will break. */
594 input_section
->output_section
->vma
+ input_section
->output_offset
;
596 if (howto
->pcrel_offset
== true)
597 relocation
-= reloc_entry
->address
;
600 if (output_bfd
!= (bfd
*) NULL
)
602 if (howto
->partial_inplace
== false)
604 /* This is a partial relocation, and we want to apply the relocation
605 to the reloc entry rather than the raw data. Modify the reloc
606 inplace to reflect what we now know. */
607 reloc_entry
->addend
= relocation
;
608 reloc_entry
->address
+= input_section
->output_offset
;
613 /* This is a partial relocation, but inplace, so modify the
616 If we've relocated with a symbol with a section, change
617 into a ref to the section belonging to the symbol. */
619 reloc_entry
->address
+= input_section
->output_offset
;
622 if (abfd
->xvec
->flavour
== bfd_target_coff_flavour
623 && strcmp (abfd
->xvec
->name
, "aixcoff-rs6000") != 0
624 && strcmp (abfd
->xvec
->name
, "xcoff-powermac") != 0
625 && strcmp (abfd
->xvec
->name
, "coff-Intel-little") != 0
626 && strcmp (abfd
->xvec
->name
, "coff-Intel-big") != 0)
629 /* For m68k-coff, the addend was being subtracted twice during
630 relocation with -r. Removing the line below this comment
631 fixes that problem; see PR 2953.
633 However, Ian wrote the following, regarding removing the line below,
634 which explains why it is still enabled: --djm
636 If you put a patch like that into BFD you need to check all the COFF
637 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
638 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
639 problem in a different way. There may very well be a reason that the
640 code works as it does.
642 Hmmm. The first obvious point is that bfd_perform_relocation should
643 not have any tests that depend upon the flavour. It's seem like
644 entirely the wrong place for such a thing. The second obvious point
645 is that the current code ignores the reloc addend when producing
646 relocateable output for COFF. That's peculiar. In fact, I really
647 have no idea what the point of the line you want to remove is.
649 A typical COFF reloc subtracts the old value of the symbol and adds in
650 the new value to the location in the object file (if it's a pc
651 relative reloc it adds the difference between the symbol value and the
652 location). When relocating we need to preserve that property.
654 BFD handles this by setting the addend to the negative of the old
655 value of the symbol. Unfortunately it handles common symbols in a
656 non-standard way (it doesn't subtract the old value) but that's a
657 different story (we can't change it without losing backward
658 compatibility with old object files) (coff-i386 does subtract the old
659 value, to be compatible with existing coff-i386 targets, like SCO).
661 So everything works fine when not producing relocateable output. When
662 we are producing relocateable output, logically we should do exactly
663 what we do when not producing relocateable output. Therefore, your
664 patch is correct. In fact, it should probably always just set
665 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
666 add the value into the object file. This won't hurt the COFF code,
667 which doesn't use the addend; I'm not sure what it will do to other
668 formats (the thing to check for would be whether any formats both use
669 the addend and set partial_inplace).
671 When I wanted to make coff-i386 produce relocateable output, I ran
672 into the problem that you are running into: I wanted to remove that
673 line. Rather than risk it, I made the coff-i386 relocs use a special
674 function; it's coff_i386_reloc in coff-i386.c. The function
675 specifically adds the addend field into the object file, knowing that
676 bfd_perform_relocation is not going to. If you remove that line, then
677 coff-i386.c will wind up adding the addend field in twice. It's
678 trivial to fix; it just needs to be done.
680 The problem with removing the line is just that it may break some
681 working code. With BFD it's hard to be sure of anything. The right
682 way to deal with this is simply to build and test at least all the
683 supported COFF targets. It should be straightforward if time and disk
684 space consuming. For each target:
686 2) generate some executable, and link it using -r (I would
687 probably use paranoia.o and link against newlib/libc.a, which
688 for all the supported targets would be available in
689 /usr/cygnus/progressive/H-host/target/lib/libc.a).
690 3) make the change to reloc.c
691 4) rebuild the linker
693 6) if the resulting object files are the same, you have at least
695 7) if they are different you have to figure out which version is
698 relocation
-= reloc_entry
->addend
;
700 reloc_entry
->addend
= 0;
704 reloc_entry
->addend
= relocation
;
710 reloc_entry
->addend
= 0;
713 /* FIXME: This overflow checking is incomplete, because the value
714 might have overflowed before we get here. For a correct check we
715 need to compute the value in a size larger than bitsize, but we
716 can't reasonably do that for a reloc the same size as a host
718 FIXME: We should also do overflow checking on the result after
719 adding in the value contained in the object file. */
720 if (howto
->complain_on_overflow
!= complain_overflow_dont
721 && flag
== bfd_reloc_ok
)
725 /* Get the value that will be used for the relocation, but
726 starting at bit position zero. */
727 check
= relocation
>> howto
->rightshift
;
728 switch (howto
->complain_on_overflow
)
730 case complain_overflow_signed
:
732 /* Assumes two's complement. */
733 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
734 bfd_signed_vma reloc_signed_min
= ~reloc_signed_max
;
736 /* The above right shift is incorrect for a signed value.
737 Fix it up by forcing on the upper bits. */
738 if (howto
->rightshift
> 0
739 && (bfd_signed_vma
) relocation
< 0)
740 check
|= ((bfd_vma
) - 1
742 >> howto
->rightshift
));
743 if ((bfd_signed_vma
) check
> reloc_signed_max
744 || (bfd_signed_vma
) check
< reloc_signed_min
)
745 flag
= bfd_reloc_overflow
;
748 case complain_overflow_unsigned
:
750 /* Assumes two's complement. This expression avoids
751 overflow if howto->bitsize is the number of bits in
753 bfd_vma reloc_unsigned_max
=
754 (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
756 if ((bfd_vma
) check
> reloc_unsigned_max
)
757 flag
= bfd_reloc_overflow
;
760 case complain_overflow_bitfield
:
762 /* Assumes two's complement. This expression avoids
763 overflow if howto->bitsize is the number of bits in
765 bfd_vma reloc_bits
= (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
767 if (((bfd_vma
) check
& ~reloc_bits
) != 0
768 && ((bfd_vma
) check
& ~reloc_bits
) != (-1 & ~reloc_bits
))
770 /* The above right shift is incorrect for a signed
771 value. See if turning on the upper bits fixes the
773 if (howto
->rightshift
> 0
774 && (bfd_signed_vma
) relocation
< 0)
776 check
|= ((bfd_vma
) - 1
778 >> howto
->rightshift
));
779 if (((bfd_vma
) check
& ~reloc_bits
) != (-1 & ~reloc_bits
))
780 flag
= bfd_reloc_overflow
;
783 flag
= bfd_reloc_overflow
;
793 Either we are relocating all the way, or we don't want to apply
794 the relocation to the reloc entry (probably because there isn't
795 any room in the output format to describe addends to relocs)
798 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
799 (OSF version 1.3, compiler version 3.11). It miscompiles the
813 x <<= (unsigned long) s.i0;
817 printf ("succeeded (%lx)\n", x);
821 relocation
>>= (bfd_vma
) howto
->rightshift
;
823 /* Shift everything up to where it's going to be used */
825 relocation
<<= (bfd_vma
) howto
->bitpos
;
827 /* Wait for the day when all have the mask in them */
830 i instruction to be left alone
831 o offset within instruction
832 r relocation offset to apply
841 i i i i i o o o o o from bfd_get<size>
842 and S S S S S to get the size offset we want
843 + r r r r r r r r r r to get the final value to place
844 and D D D D D to chop to right size
845 -----------------------
848 ... i i i i i o o o o o from bfd_get<size>
849 and N N N N N get instruction
850 -----------------------
856 -----------------------
857 R R R R R R R R R R put into bfd_put<size>
861 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
867 char x
= bfd_get_8 (abfd
, (char *) data
+ addr
);
869 bfd_put_8 (abfd
, x
, (unsigned char *) data
+ addr
);
876 short x
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ addr
);
878 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
);
884 long x
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ addr
);
886 bfd_put_32 (abfd
, x
, (bfd_byte
*) data
+ addr
);
891 long x
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ addr
);
892 relocation
= -relocation
;
894 bfd_put_32 (abfd
, x
, (bfd_byte
*) data
+ addr
);
900 long x
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ addr
);
901 relocation
= -relocation
;
903 bfd_put_16 (abfd
, x
, (bfd_byte
*) data
+ addr
);
915 bfd_vma x
= bfd_get_64 (abfd
, (bfd_byte
*) data
+ addr
);
917 bfd_put_64 (abfd
, x
, (bfd_byte
*) data
+ addr
);
924 return bfd_reloc_other
;
932 bfd_install_relocation
935 bfd_reloc_status_type
936 bfd_install_relocation
938 arelent *reloc_entry,
939 PTR data, bfd_vma data_start,
940 asection *input_section,
941 char **error_message);
944 This looks remarkably like <<bfd_perform_relocation>>, except it
945 does not expect that the section contents have been filled in.
946 I.e., it's suitable for use when creating, rather than applying
949 For now, this function should be considered reserved for the
955 bfd_reloc_status_type
956 bfd_install_relocation (abfd
, reloc_entry
, data_start
, data_start_offset
,
957 input_section
, error_message
)
959 arelent
*reloc_entry
;
961 bfd_vma data_start_offset
;
962 asection
*input_section
;
963 char **error_message
;
966 bfd_reloc_status_type flag
= bfd_reloc_ok
;
967 bfd_size_type addr
= reloc_entry
->address
;
968 bfd_vma output_base
= 0;
969 reloc_howto_type
*howto
= reloc_entry
->howto
;
970 asection
*reloc_target_output_section
;
974 symbol
= *(reloc_entry
->sym_ptr_ptr
);
975 if (bfd_is_abs_section (symbol
->section
))
977 reloc_entry
->address
+= input_section
->output_offset
;
981 /* If there is a function supplied to handle this relocation type,
982 call it. It'll return `bfd_reloc_continue' if further processing
984 if (howto
->special_function
)
986 bfd_reloc_status_type cont
;
987 /* XXX - The special_function calls haven't been fixed up to deal
988 with creating new relocations and section contents. */
989 cont
= howto
->special_function (abfd
, reloc_entry
, symbol
,
990 /* XXX - Non-portable! */
991 ((bfd_byte
*) data_start
992 - data_start_offset
),
993 input_section
, abfd
, error_message
);
994 if (cont
!= bfd_reloc_continue
)
998 /* Is the address of the relocation really within the section? */
999 if (reloc_entry
->address
> input_section
->_cooked_size
)
1000 return bfd_reloc_outofrange
;
1002 /* Work out which section the relocation is targetted at and the
1003 initial relocation command value. */
1005 /* Get symbol value. (Common symbols are special.) */
1006 if (bfd_is_com_section (symbol
->section
))
1009 relocation
= symbol
->value
;
1012 reloc_target_output_section
= symbol
->section
->output_section
;
1014 /* Convert input-section-relative symbol value to absolute. */
1015 if (howto
->partial_inplace
== false)
1018 output_base
= reloc_target_output_section
->vma
;
1020 relocation
+= output_base
+ symbol
->section
->output_offset
;
1022 /* Add in supplied addend. */
1023 relocation
+= reloc_entry
->addend
;
1025 /* Here the variable relocation holds the final address of the
1026 symbol we are relocating against, plus any addend. */
1028 if (howto
->pc_relative
== true)
1030 /* This is a PC relative relocation. We want to set RELOCATION
1031 to the distance between the address of the symbol and the
1032 location. RELOCATION is already the address of the symbol.
1034 We start by subtracting the address of the section containing
1037 If pcrel_offset is set, we must further subtract the position
1038 of the location within the section. Some targets arrange for
1039 the addend to be the negative of the position of the location
1040 within the section; for example, i386-aout does this. For
1041 i386-aout, pcrel_offset is false. Some other targets do not
1042 include the position of the location; for example, m88kbcs,
1043 or ELF. For those targets, pcrel_offset is true.
1045 If we are producing relocateable output, then we must ensure
1046 that this reloc will be correctly computed when the final
1047 relocation is done. If pcrel_offset is false we want to wind
1048 up with the negative of the location within the section,
1049 which means we must adjust the existing addend by the change
1050 in the location within the section. If pcrel_offset is true
1051 we do not want to adjust the existing addend at all.
1053 FIXME: This seems logical to me, but for the case of
1054 producing relocateable output it is not what the code
1055 actually does. I don't want to change it, because it seems
1056 far too likely that something will break. */
1059 input_section
->output_section
->vma
+ input_section
->output_offset
;
1061 if (howto
->pcrel_offset
== true && howto
->partial_inplace
== true)
1062 relocation
-= reloc_entry
->address
;
1065 if (howto
->partial_inplace
== false)
1067 /* This is a partial relocation, and we want to apply the relocation
1068 to the reloc entry rather than the raw data. Modify the reloc
1069 inplace to reflect what we now know. */
1070 reloc_entry
->addend
= relocation
;
1071 reloc_entry
->address
+= input_section
->output_offset
;
1076 /* This is a partial relocation, but inplace, so modify the
1079 If we've relocated with a symbol with a section, change
1080 into a ref to the section belonging to the symbol. */
1082 reloc_entry
->address
+= input_section
->output_offset
;
1085 if (abfd
->xvec
->flavour
== bfd_target_coff_flavour
1086 && strcmp (abfd
->xvec
->name
, "aixcoff-rs6000") != 0
1087 && strcmp (abfd
->xvec
->name
, "xcoff-powermac") != 0
1088 && strcmp (abfd
->xvec
->name
, "coff-Intel-little") != 0
1089 && strcmp (abfd
->xvec
->name
, "coff-Intel-big") != 0)
1092 /* For m68k-coff, the addend was being subtracted twice during
1093 relocation with -r. Removing the line below this comment
1094 fixes that problem; see PR 2953.
1096 However, Ian wrote the following, regarding removing the line below,
1097 which explains why it is still enabled: --djm
1099 If you put a patch like that into BFD you need to check all the COFF
1100 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
1101 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1102 problem in a different way. There may very well be a reason that the
1103 code works as it does.
1105 Hmmm. The first obvious point is that bfd_install_relocation should
1106 not have any tests that depend upon the flavour. It's seem like
1107 entirely the wrong place for such a thing. The second obvious point
1108 is that the current code ignores the reloc addend when producing
1109 relocateable output for COFF. That's peculiar. In fact, I really
1110 have no idea what the point of the line you want to remove is.
1112 A typical COFF reloc subtracts the old value of the symbol and adds in
1113 the new value to the location in the object file (if it's a pc
1114 relative reloc it adds the difference between the symbol value and the
1115 location). When relocating we need to preserve that property.
1117 BFD handles this by setting the addend to the negative of the old
1118 value of the symbol. Unfortunately it handles common symbols in a
1119 non-standard way (it doesn't subtract the old value) but that's a
1120 different story (we can't change it without losing backward
1121 compatibility with old object files) (coff-i386 does subtract the old
1122 value, to be compatible with existing coff-i386 targets, like SCO).
1124 So everything works fine when not producing relocateable output. When
1125 we are producing relocateable output, logically we should do exactly
1126 what we do when not producing relocateable output. Therefore, your
1127 patch is correct. In fact, it should probably always just set
1128 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1129 add the value into the object file. This won't hurt the COFF code,
1130 which doesn't use the addend; I'm not sure what it will do to other
1131 formats (the thing to check for would be whether any formats both use
1132 the addend and set partial_inplace).
1134 When I wanted to make coff-i386 produce relocateable output, I ran
1135 into the problem that you are running into: I wanted to remove that
1136 line. Rather than risk it, I made the coff-i386 relocs use a special
1137 function; it's coff_i386_reloc in coff-i386.c. The function
1138 specifically adds the addend field into the object file, knowing that
1139 bfd_install_relocation is not going to. If you remove that line, then
1140 coff-i386.c will wind up adding the addend field in twice. It's
1141 trivial to fix; it just needs to be done.
1143 The problem with removing the line is just that it may break some
1144 working code. With BFD it's hard to be sure of anything. The right
1145 way to deal with this is simply to build and test at least all the
1146 supported COFF targets. It should be straightforward if time and disk
1147 space consuming. For each target:
1149 2) generate some executable, and link it using -r (I would
1150 probably use paranoia.o and link against newlib/libc.a, which
1151 for all the supported targets would be available in
1152 /usr/cygnus/progressive/H-host/target/lib/libc.a).
1153 3) make the change to reloc.c
1154 4) rebuild the linker
1156 6) if the resulting object files are the same, you have at least
1158 7) if they are different you have to figure out which version is
1161 relocation
-= reloc_entry
->addend
;
1163 reloc_entry
->addend
= 0;
1167 reloc_entry
->addend
= relocation
;
1171 /* FIXME: This overflow checking is incomplete, because the value
1172 might have overflowed before we get here. For a correct check we
1173 need to compute the value in a size larger than bitsize, but we
1174 can't reasonably do that for a reloc the same size as a host
1177 FIXME: We should also do overflow checking on the result after
1178 adding in the value contained in the object file. */
1179 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
1183 /* Get the value that will be used for the relocation, but
1184 starting at bit position zero. */
1185 check
= relocation
>> howto
->rightshift
;
1186 switch (howto
->complain_on_overflow
)
1188 case complain_overflow_signed
:
1190 /* Assumes two's complement. */
1191 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1192 bfd_signed_vma reloc_signed_min
= ~reloc_signed_max
;
1194 /* The above right shift is incorrect for a signed value.
1195 Fix it up by forcing on the upper bits. */
1196 if (howto
->rightshift
> 0
1197 && (bfd_signed_vma
) relocation
< 0)
1198 check
|= ((bfd_vma
) - 1
1200 >> howto
->rightshift
));
1201 if ((bfd_signed_vma
) check
> reloc_signed_max
1202 || (bfd_signed_vma
) check
< reloc_signed_min
)
1203 flag
= bfd_reloc_overflow
;
1206 case complain_overflow_unsigned
:
1208 /* Assumes two's complement. This expression avoids
1209 overflow if howto->bitsize is the number of bits in
1211 bfd_vma reloc_unsigned_max
=
1212 (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
1214 if ((bfd_vma
) check
> reloc_unsigned_max
)
1215 flag
= bfd_reloc_overflow
;
1218 case complain_overflow_bitfield
:
1220 /* Assumes two's complement. This expression avoids
1221 overflow if howto->bitsize is the number of bits in
1223 bfd_vma reloc_bits
= (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
1225 if (((bfd_vma
) check
& ~reloc_bits
) != 0
1226 && ((bfd_vma
) check
& ~reloc_bits
) != (-1 & ~reloc_bits
))
1228 /* The above right shift is incorrect for a signed
1229 value. See if turning on the upper bits fixes the
1231 if (howto
->rightshift
> 0
1232 && (bfd_signed_vma
) relocation
< 0)
1234 check
|= ((bfd_vma
) - 1
1236 >> howto
->rightshift
));
1237 if (((bfd_vma
) check
& ~reloc_bits
) != (-1 & ~reloc_bits
))
1238 flag
= bfd_reloc_overflow
;
1241 flag
= bfd_reloc_overflow
;
1251 Either we are relocating all the way, or we don't want to apply
1252 the relocation to the reloc entry (probably because there isn't
1253 any room in the output format to describe addends to relocs)
1256 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1257 (OSF version 1.3, compiler version 3.11). It miscompiles the
1271 x <<= (unsigned long) s.i0;
1273 printf ("failed\n");
1275 printf ("succeeded (%lx)\n", x);
1279 relocation
>>= (bfd_vma
) howto
->rightshift
;
1281 /* Shift everything up to where it's going to be used */
1283 relocation
<<= (bfd_vma
) howto
->bitpos
;
1285 /* Wait for the day when all have the mask in them */
1288 i instruction to be left alone
1289 o offset within instruction
1290 r relocation offset to apply
1299 i i i i i o o o o o from bfd_get<size>
1300 and S S S S S to get the size offset we want
1301 + r r r r r r r r r r to get the final value to place
1302 and D D D D D to chop to right size
1303 -----------------------
1306 ... i i i i i o o o o o from bfd_get<size>
1307 and N N N N N get instruction
1308 -----------------------
1314 -----------------------
1315 R R R R R R R R R R put into bfd_put<size>
1319 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
1321 data
= (bfd_byte
*) data_start
+ (addr
- data_start_offset
);
1323 switch (howto
->size
)
1327 char x
= bfd_get_8 (abfd
, (char *) data
);
1329 bfd_put_8 (abfd
, x
, (unsigned char *) data
);
1336 short x
= bfd_get_16 (abfd
, (bfd_byte
*) data
);
1338 bfd_put_16 (abfd
, x
, (unsigned char *) data
);
1344 long x
= bfd_get_32 (abfd
, (bfd_byte
*) data
);
1346 bfd_put_32 (abfd
, x
, (bfd_byte
*) data
);
1351 long x
= bfd_get_32 (abfd
, (bfd_byte
*) data
);
1352 relocation
= -relocation
;
1354 bfd_put_32 (abfd
, x
, (bfd_byte
*) data
);
1365 bfd_vma x
= bfd_get_64 (abfd
, (bfd_byte
*) data
);
1367 bfd_put_64 (abfd
, x
, (bfd_byte
*) data
);
1371 return bfd_reloc_other
;
1377 /* This relocation routine is used by some of the backend linkers.
1378 They do not construct asymbol or arelent structures, so there is no
1379 reason for them to use bfd_perform_relocation. Also,
1380 bfd_perform_relocation is so hacked up it is easier to write a new
1381 function than to try to deal with it.
1383 This routine does a final relocation. It should not be used when
1384 generating relocateable output.
1386 FIXME: This routine ignores any special_function in the HOWTO,
1387 since the existing special_function values have been written for
1388 bfd_perform_relocation.
1390 HOWTO is the reloc howto information.
1391 INPUT_BFD is the BFD which the reloc applies to.
1392 INPUT_SECTION is the section which the reloc applies to.
1393 CONTENTS is the contents of the section.
1394 ADDRESS is the address of the reloc within INPUT_SECTION.
1395 VALUE is the value of the symbol the reloc refers to.
1396 ADDEND is the addend of the reloc. */
1398 bfd_reloc_status_type
1399 _bfd_final_link_relocate (howto
, input_bfd
, input_section
, contents
, address
,
1401 reloc_howto_type
*howto
;
1403 asection
*input_section
;
1411 /* Sanity check the address. */
1412 if (address
> input_section
->_raw_size
)
1413 return bfd_reloc_outofrange
;
1415 /* This function assumes that we are dealing with a basic relocation
1416 against a symbol. We want to compute the value of the symbol to
1417 relocate to. This is just VALUE, the value of the symbol, plus
1418 ADDEND, any addend associated with the reloc. */
1419 relocation
= value
+ addend
;
1421 /* If the relocation is PC relative, we want to set RELOCATION to
1422 the distance between the symbol (currently in RELOCATION) and the
1423 location we are relocating. Some targets (e.g., i386-aout)
1424 arrange for the contents of the section to be the negative of the
1425 offset of the location within the section; for such targets
1426 pcrel_offset is false. Other targets (e.g., m88kbcs or ELF)
1427 simply leave the contents of the section as zero; for such
1428 targets pcrel_offset is true. If pcrel_offset is false we do not
1429 need to subtract out the offset of the location within the
1430 section (which is just ADDRESS). */
1431 if (howto
->pc_relative
)
1433 relocation
-= (input_section
->output_section
->vma
1434 + input_section
->output_offset
);
1435 if (howto
->pcrel_offset
)
1436 relocation
-= address
;
1439 return _bfd_relocate_contents (howto
, input_bfd
, relocation
,
1440 contents
+ address
);
1443 /* Relocate a given location using a given value and howto. */
1445 bfd_reloc_status_type
1446 _bfd_relocate_contents (howto
, input_bfd
, relocation
, location
)
1447 reloc_howto_type
*howto
;
1456 /* If the size is negative, negate RELOCATION. This isn't very
1458 if (howto
->size
< 0)
1459 relocation
= -relocation
;
1461 /* Get the value we are going to relocate. */
1462 size
= bfd_get_reloc_size (howto
);
1469 x
= bfd_get_8 (input_bfd
, location
);
1472 x
= bfd_get_16 (input_bfd
, location
);
1475 x
= bfd_get_32 (input_bfd
, location
);
1479 x
= bfd_get_64 (input_bfd
, location
);
1486 /* Check for overflow. FIXME: We may drop bits during the addition
1487 which we don't check for. We must either check at every single
1488 operation, which would be tedious, or we must do the computations
1489 in a type larger than bfd_vma, which would be inefficient. */
1491 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
1494 bfd_signed_vma signed_check
;
1496 bfd_signed_vma signed_add
;
1498 if (howto
->rightshift
== 0)
1501 signed_check
= (bfd_signed_vma
) relocation
;
1505 /* Drop unwanted bits from the value we are relocating to. */
1506 check
= relocation
>> howto
->rightshift
;
1508 /* If this is a signed value, the rightshift just dropped
1509 leading 1 bits (assuming twos complement). */
1510 if ((bfd_signed_vma
) relocation
>= 0)
1511 signed_check
= check
;
1513 signed_check
= (check
1515 & ~((bfd_vma
) - 1 >> howto
->rightshift
)));
1518 /* Get the value from the object file. */
1519 add
= x
& howto
->src_mask
;
1521 /* Get the value from the object file with an appropriate sign.
1522 The expression involving howto->src_mask isolates the upper
1523 bit of src_mask. If that bit is set in the value we are
1524 adding, it is negative, and we subtract out that number times
1525 two. If src_mask includes the highest possible bit, then we
1526 can not get the upper bit, but that does not matter since
1527 signed_add needs no adjustment to become negative in that
1530 if ((add
& (((~howto
->src_mask
) >> 1) & howto
->src_mask
)) != 0)
1531 signed_add
-= (((~howto
->src_mask
) >> 1) & howto
->src_mask
) << 1;
1533 /* Add the value from the object file, shifted so that it is a
1535 if (howto
->bitpos
== 0)
1538 signed_check
+= signed_add
;
1542 check
+= add
>> howto
->bitpos
;
1544 /* For the signed case we use ADD, rather than SIGNED_ADD,
1545 to avoid warnings from SVR4 cc. This is OK since we
1546 explictly handle the sign bits. */
1547 if (signed_add
>= 0)
1548 signed_check
+= add
>> howto
->bitpos
;
1550 signed_check
+= ((add
>> howto
->bitpos
)
1552 & ~((bfd_vma
) - 1 >> howto
->bitpos
)));
1555 switch (howto
->complain_on_overflow
)
1557 case complain_overflow_signed
:
1559 /* Assumes two's complement. */
1560 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1561 bfd_signed_vma reloc_signed_min
= ~reloc_signed_max
;
1563 if (signed_check
> reloc_signed_max
1564 || signed_check
< reloc_signed_min
)
1568 case complain_overflow_unsigned
:
1570 /* Assumes two's complement. This expression avoids
1571 overflow if howto->bitsize is the number of bits in
1573 bfd_vma reloc_unsigned_max
=
1574 (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
1576 if (check
> reloc_unsigned_max
)
1580 case complain_overflow_bitfield
:
1582 /* Assumes two's complement. This expression avoids
1583 overflow if howto->bitsize is the number of bits in
1585 bfd_vma reloc_bits
= (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
1587 if ((check
& ~reloc_bits
) != 0
1588 && (((bfd_vma
) signed_check
& ~reloc_bits
)
1589 != (-1 & ~reloc_bits
)))
1598 /* Put RELOCATION in the right bits. */
1599 relocation
>>= (bfd_vma
) howto
->rightshift
;
1600 relocation
<<= (bfd_vma
) howto
->bitpos
;
1602 /* Add RELOCATION to the right bits of X. */
1603 x
= ((x
& ~howto
->dst_mask
)
1604 | (((x
& howto
->src_mask
) + relocation
) & howto
->dst_mask
));
1606 /* Put the relocated value back in the object file. */
1613 bfd_put_8 (input_bfd
, x
, location
);
1616 bfd_put_16 (input_bfd
, x
, location
);
1619 bfd_put_32 (input_bfd
, x
, location
);
1623 bfd_put_64 (input_bfd
, x
, location
);
1630 return overflow
? bfd_reloc_overflow
: bfd_reloc_ok
;
1636 howto manager, , typedef arelent, Relocations
1641 When an application wants to create a relocation, but doesn't
1642 know what the target machine might call it, it can find out by
1643 using this bit of code.
1652 The insides of a reloc code. The idea is that, eventually, there
1653 will be one enumerator for every type of relocation we ever do.
1654 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1655 return a howto pointer.
1657 This does mean that the application must determine the correct
1658 enumerator value; you can't get a howto pointer from a random set
1677 Basic absolute relocations of N bits.
1692 PC-relative relocations. Sometimes these are relative to the address
1693 of the relocation itself; sometimes they are relative to the start of
1694 the section containing the relocation. It depends on the specific target.
1696 The 24-bit relocation is used in some Intel 960 configurations.
1699 BFD_RELOC_32_GOT_PCREL
1701 BFD_RELOC_16_GOT_PCREL
1703 BFD_RELOC_8_GOT_PCREL
1709 BFD_RELOC_LO16_GOTOFF
1711 BFD_RELOC_HI16_GOTOFF
1713 BFD_RELOC_HI16_S_GOTOFF
1717 BFD_RELOC_32_PLT_PCREL
1719 BFD_RELOC_24_PLT_PCREL
1721 BFD_RELOC_16_PLT_PCREL
1723 BFD_RELOC_8_PLT_PCREL
1729 BFD_RELOC_LO16_PLTOFF
1731 BFD_RELOC_HI16_PLTOFF
1733 BFD_RELOC_HI16_S_PLTOFF
1740 BFD_RELOC_68K_GLOB_DAT
1742 BFD_RELOC_68K_JMP_SLOT
1744 BFD_RELOC_68K_RELATIVE
1746 Relocations used by 68K ELF.
1749 BFD_RELOC_32_BASEREL
1751 BFD_RELOC_16_BASEREL
1753 BFD_RELOC_LO16_BASEREL
1755 BFD_RELOC_HI16_BASEREL
1757 BFD_RELOC_HI16_S_BASEREL
1763 Linkage-table relative.
1768 Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1771 BFD_RELOC_32_PCREL_S2
1773 BFD_RELOC_16_PCREL_S2
1775 BFD_RELOC_23_PCREL_S2
1777 These PC-relative relocations are stored as word displacements --
1778 i.e., byte displacements shifted right two bits. The 30-bit word
1779 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1780 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The
1781 signed 16-bit displacement is used on the MIPS, and the 23-bit
1782 displacement is used on the Alpha.
1789 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1790 the target word. These are used on the SPARC.
1797 For systems that allocate a Global Pointer register, these are
1798 displacements off that register. These relocation types are
1799 handled specially, because the value the register will have is
1800 decided relatively late.
1808 For openVMS/Alpha systems, these are displacements for switch
1813 BFD_RELOC_I960_CALLJ
1815 Reloc types used for i960/b.out.
1820 BFD_RELOC_SPARC_WDISP22
1826 BFD_RELOC_SPARC_GOT10
1828 BFD_RELOC_SPARC_GOT13
1830 BFD_RELOC_SPARC_GOT22
1832 BFD_RELOC_SPARC_PC10
1834 BFD_RELOC_SPARC_PC22
1836 BFD_RELOC_SPARC_WPLT30
1838 BFD_RELOC_SPARC_COPY
1840 BFD_RELOC_SPARC_GLOB_DAT
1842 BFD_RELOC_SPARC_JMP_SLOT
1844 BFD_RELOC_SPARC_RELATIVE
1846 BFD_RELOC_SPARC_UA32
1848 SPARC ELF relocations. There is probably some overlap with other
1849 relocation types already defined.
1852 BFD_RELOC_SPARC_BASE13
1854 BFD_RELOC_SPARC_BASE22
1856 I think these are specific to SPARC a.out (e.g., Sun 4).
1866 BFD_RELOC_SPARC_OLO10
1868 BFD_RELOC_SPARC_HH22
1870 BFD_RELOC_SPARC_HM10
1872 BFD_RELOC_SPARC_LM22
1874 BFD_RELOC_SPARC_PC_HH22
1876 BFD_RELOC_SPARC_PC_HM10
1878 BFD_RELOC_SPARC_PC_LM22
1880 BFD_RELOC_SPARC_WDISP16
1882 BFD_RELOC_SPARC_WDISP19
1884 BFD_RELOC_SPARC_GLOB_JMP
1892 Some relocations we're using for SPARC V9 -- subject to change.
1895 BFD_RELOC_ALPHA_GPDISP_HI16
1897 Alpha ECOFF and ELF relocations. Some of these treat the symbol or
1898 "addend" in some special way.
1899 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1900 writing; when reading, it will be the absolute section symbol. The
1901 addend is the displacement in bytes of the "lda" instruction from
1902 the "ldah" instruction (which is at the address of this reloc).
1904 BFD_RELOC_ALPHA_GPDISP_LO16
1906 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1907 with GPDISP_HI16 relocs. The addend is ignored when writing the
1908 relocations out, and is filled in with the file's GP value on
1909 reading, for convenience.
1912 BFD_RELOC_ALPHA_GPDISP
1914 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1915 relocation except that there is no accompanying GPDISP_LO16
1919 BFD_RELOC_ALPHA_LITERAL
1921 BFD_RELOC_ALPHA_LITUSE
1923 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1924 the assembler turns it into a LDQ instruction to load the address of
1925 the symbol, and then fills in a register in the real instruction.
1927 The LITERAL reloc, at the LDQ instruction, refers to the .lita
1928 section symbol. The addend is ignored when writing, but is filled
1929 in with the file's GP value on reading, for convenience, as with 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_HINT
1946 The HINT relocation indicates a value that should be filled into the
1947 "hint" field of a jmp/jsr/ret instruction, for possible branch-
1948 prediction logic which may be provided on some processors.
1951 BFD_RELOC_ALPHA_LINKAGE
1953 The LINKAGE relocation outputs a special code in the object file,
1954 the rest is handled by the linker.
1957 BFD_RELOC_ALPHA_BASEREG
1959 The BASEREG relocation calculates differences to basereg.
1964 Bits 27..2 of the relocation address shifted right 2 bits;
1965 simple reloc otherwise.
1970 High 16 bits of 32-bit value; simple reloc.
1974 High 16 bits of 32-bit value but the low 16 bits will be sign
1975 extended and added to form the final result. If the low 16
1976 bits form a negative number, we need to add one to the high value
1977 to compensate for the borrow when the low bits are added.
1983 BFD_RELOC_PCREL_HI16_S
1985 Like BFD_RELOC_HI16_S, but PC relative.
1987 BFD_RELOC_PCREL_LO16
1989 Like BFD_RELOC_LO16, but PC relative.
1992 BFD_RELOC_MIPS_GPREL
1995 Relocation relative to the global pointer.
1998 BFD_RELOC_MIPS_LITERAL
2000 Relocation against a MIPS literal section.
2003 BFD_RELOC_MIPS_GOT16
2005 BFD_RELOC_MIPS_CALL16
2007 BFD_RELOC_MIPS_GPREL32
2010 BFD_RELOC_MIPS_GOT_HI16
2012 BFD_RELOC_MIPS_GOT_LO16
2014 BFD_RELOC_MIPS_CALL_HI16
2016 BFD_RELOC_MIPS_CALL_LO16
2018 MIPS ELF relocations.
2027 BFD_RELOC_386_GLOB_DAT
2029 BFD_RELOC_386_JUMP_SLOT
2031 BFD_RELOC_386_RELATIVE
2033 BFD_RELOC_386_GOTOFF
2037 i386/elf relocations
2040 BFD_RELOC_NS32K_IMM_8
2042 BFD_RELOC_NS32K_IMM_16
2044 BFD_RELOC_NS32K_IMM_32
2046 BFD_RELOC_NS32K_IMM_8_PCREL
2048 BFD_RELOC_NS32K_IMM_16_PCREL
2050 BFD_RELOC_NS32K_IMM_32_PCREL
2052 BFD_RELOC_NS32K_DISP_8
2054 BFD_RELOC_NS32K_DISP_16
2056 BFD_RELOC_NS32K_DISP_32
2058 BFD_RELOC_NS32K_DISP_8_PCREL
2060 BFD_RELOC_NS32K_DISP_16_PCREL
2062 BFD_RELOC_NS32K_DISP_32_PCREL
2075 BFD_RELOC_PPC_B16_BRTAKEN
2077 BFD_RELOC_PPC_B16_BRNTAKEN
2081 BFD_RELOC_PPC_BA16_BRTAKEN
2083 BFD_RELOC_PPC_BA16_BRNTAKEN
2087 BFD_RELOC_PPC_GLOB_DAT
2089 BFD_RELOC_PPC_JMP_SLOT
2091 BFD_RELOC_PPC_RELATIVE
2093 BFD_RELOC_PPC_LOCAL24PC
2095 BFD_RELOC_PPC_EMB_NADDR32
2097 BFD_RELOC_PPC_EMB_NADDR16
2099 BFD_RELOC_PPC_EMB_NADDR16_LO
2101 BFD_RELOC_PPC_EMB_NADDR16_HI
2103 BFD_RELOC_PPC_EMB_NADDR16_HA
2105 BFD_RELOC_PPC_EMB_SDAI16
2107 BFD_RELOC_PPC_EMB_SDA2I16
2109 BFD_RELOC_PPC_EMB_SDA2REL
2111 BFD_RELOC_PPC_EMB_SDA21
2113 BFD_RELOC_PPC_EMB_MRKREF
2115 BFD_RELOC_PPC_EMB_RELSEC16
2117 BFD_RELOC_PPC_EMB_RELST_LO
2119 BFD_RELOC_PPC_EMB_RELST_HI
2121 BFD_RELOC_PPC_EMB_RELST_HA
2123 BFD_RELOC_PPC_EMB_BIT_FLD
2125 BFD_RELOC_PPC_EMB_RELSDA
2127 Power(rs6000) and PowerPC relocations.
2132 The type of reloc used to build a contructor table - at the moment
2133 probably a 32 bit wide absolute relocation, but the target can choose.
2134 It generally does map to one of the other relocation types.
2137 BFD_RELOC_ARM_PCREL_BRANCH
2139 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
2140 not stored in the instruction.
2142 BFD_RELOC_ARM_IMMEDIATE
2144 BFD_RELOC_ARM_OFFSET_IMM
2146 BFD_RELOC_ARM_SHIFT_IMM
2152 BFD_RELOC_ARM_CP_OFF_IMM
2154 BFD_RELOC_ARM_ADR_IMM
2156 BFD_RELOC_ARM_LDR_IMM
2158 BFD_RELOC_ARM_LITERAL
2160 BFD_RELOC_ARM_IN_POOL
2162 These relocs are only used within the ARM assembler. They are not
2163 (at present) written to any object files.
2166 {* start-sanitize-arc *}
2168 BFD_RELOC_ARC_B22_PCREL
2170 Argonaut RISC Core (ARC) relocs.
2171 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
2172 not stored in the instruction. The high 20 bits are installed in bits 26
2173 through 7 of the instruction.
2177 ARC 26 bit absolute branch. The lowest two bits must be zero and are not
2178 stored in the instruction. The high 24 bits are installed in bits 23
2181 {* end-sanitize-arc *}
2184 {* start-sanitize-d10v *}
2186 BFD_RELOC_D10V_10_PCREL_R
2188 Mitsubishi D10V relocs.
2189 This is a 10-bit reloc with the right 2 bits
2192 BFD_RELOC_D10V_10_PCREL_L
2194 Mitsubishi D10V relocs.
2195 This is a 10-bit reloc with the right 2 bits
2196 assumed to be 0. This is the same as the previous reloc
2197 except it is in the left container, i.e.,
2198 shifted left 15 bits.
2202 This is an 18-bit reloc with the right 2 bits
2205 BFD_RELOC_D10V_18_PCREL
2207 This is an 18-bit reloc with the right 2 bits
2210 {* end-sanitize-d10v *}
2216 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2222 bfd_reloc_type_lookup
2226 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
2229 Return a pointer to a howto structure which, when
2230 invoked, will perform the relocation @var{code} on data from the
2237 bfd_reloc_type_lookup (abfd
, code
)
2239 bfd_reloc_code_real_type code
;
2241 return BFD_SEND (abfd
, reloc_type_lookup
, (abfd
, code
));
2244 static reloc_howto_type bfd_howto_32
=
2245 HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield
, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
2250 bfd_default_reloc_type_lookup
2253 reloc_howto_type *bfd_default_reloc_type_lookup
2254 (bfd *abfd, bfd_reloc_code_real_type code);
2257 Provides a default relocation lookup routine for any architecture.
2263 bfd_default_reloc_type_lookup (abfd
, code
)
2265 bfd_reloc_code_real_type code
;
2269 case BFD_RELOC_CTOR
:
2270 /* The type of reloc used in a ctor, which will be as wide as the
2271 address - so either a 64, 32, or 16 bitter. */
2272 switch (bfd_get_arch_info (abfd
)->bits_per_address
)
2277 return &bfd_howto_32
;
2286 return (reloc_howto_type
*) NULL
;
2291 bfd_get_reloc_code_name
2294 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
2297 Provides a printable name for the supplied relocation code.
2298 Useful mainly for printing error messages.
2302 bfd_get_reloc_code_name (code
)
2303 bfd_reloc_code_real_type code
;
2305 if (code
> BFD_RELOC_UNUSED
)
2307 return bfd_reloc_code_real_names
[(int)code
];
2312 bfd_generic_relax_section
2315 boolean bfd_generic_relax_section
2318 struct bfd_link_info *,
2322 Provides default handling for relaxing for back ends which
2323 don't do relaxing -- i.e., does nothing.
2328 bfd_generic_relax_section (abfd
, section
, link_info
, again
)
2331 struct bfd_link_info
*link_info
;
2340 bfd_generic_get_relocated_section_contents
2344 bfd_generic_get_relocated_section_contents (bfd *abfd,
2345 struct bfd_link_info *link_info,
2346 struct bfd_link_order *link_order,
2348 boolean relocateable,
2352 Provides default handling of relocation effort for back ends
2353 which can't be bothered to do it efficiently.
2358 bfd_generic_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
2359 relocateable
, symbols
)
2361 struct bfd_link_info
*link_info
;
2362 struct bfd_link_order
*link_order
;
2364 boolean relocateable
;
2367 /* Get enough memory to hold the stuff */
2368 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
2369 asection
*input_section
= link_order
->u
.indirect
.section
;
2371 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
2372 arelent
**reloc_vector
= NULL
;
2378 reloc_vector
= (arelent
**) bfd_malloc ((size_t) reloc_size
);
2379 if (reloc_vector
== NULL
&& reloc_size
!= 0)
2382 /* read in the section */
2383 if (!bfd_get_section_contents (input_bfd
,
2387 input_section
->_raw_size
))
2390 /* We're not relaxing the section, so just copy the size info */
2391 input_section
->_cooked_size
= input_section
->_raw_size
;
2392 input_section
->reloc_done
= true;
2394 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
2398 if (reloc_count
< 0)
2401 if (reloc_count
> 0)
2404 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
2407 char *error_message
= (char *) NULL
;
2408 bfd_reloc_status_type r
=
2409 bfd_perform_relocation (input_bfd
,
2413 relocateable
? abfd
: (bfd
*) NULL
,
2418 asection
*os
= input_section
->output_section
;
2420 /* A partial link, so keep the relocs */
2421 os
->orelocation
[os
->reloc_count
] = *parent
;
2425 if (r
!= bfd_reloc_ok
)
2429 case bfd_reloc_undefined
:
2430 if (!((*link_info
->callbacks
->undefined_symbol
)
2431 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
2432 input_bfd
, input_section
, (*parent
)->address
)))
2435 case bfd_reloc_dangerous
:
2436 BFD_ASSERT (error_message
!= (char *) NULL
);
2437 if (!((*link_info
->callbacks
->reloc_dangerous
)
2438 (link_info
, error_message
, input_bfd
, input_section
,
2439 (*parent
)->address
)))
2442 case bfd_reloc_overflow
:
2443 if (!((*link_info
->callbacks
->reloc_overflow
)
2444 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
2445 (*parent
)->howto
->name
, (*parent
)->addend
,
2446 input_bfd
, input_section
, (*parent
)->address
)))
2449 case bfd_reloc_outofrange
:
2458 if (reloc_vector
!= NULL
)
2459 free (reloc_vector
);
2463 if (reloc_vector
!= NULL
)
2464 free (reloc_vector
);