1 /* BFD support for handling relocation entries.
2 Copyright (C) 1990, 1991, 1992, 1993 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., 675 Mass Ave, Cambridge, MA 02139, 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.
51 typedef arelent, howto manager, Relocations, Relocations
56 This is the structure of a relocation entry:
60 .typedef enum bfd_reloc_status
62 . {* No errors detected *}
65 . {* The relocation was performed, but there was an overflow. *}
68 . {* The address to relocate was not within the section supplied. *}
69 . bfd_reloc_outofrange,
71 . {* Used by special functions *}
74 . {* Unsupported relocation size requested. *}
75 . bfd_reloc_notsupported,
80 . {* The symbol to relocate against was undefined. *}
81 . bfd_reloc_undefined,
83 . {* The relocation was performed, but may not be ok - presently
84 . generated only when linking i960 coff files with i960 b.out
85 . symbols. If this type is returned, the error_message argument
86 . to bfd_perform_relocation will be set. *}
89 . bfd_reloc_status_type;
92 .typedef struct reloc_cache_entry
94 . {* A pointer into the canonical table of pointers *}
95 . struct symbol_cache_entry **sym_ptr_ptr;
97 . {* offset in section *}
98 . bfd_size_type address;
100 . {* addend for relocation value *}
103 . {* Pointer to how to perform the required relocation *}
104 . const struct reloc_howto_struct *howto;
113 Here is a description of each of the fields within an <<arelent>>:
117 The symbol table pointer points to a pointer to the symbol
118 associated with the relocation request. It is
119 the pointer into the table returned by the back end's
120 <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
121 through a pointer to a pointer so that tools like the linker
122 can fix up all the symbols of the same name by modifying only
123 one pointer. The relocation routine looks in the symbol and
124 uses the base of the section the symbol is attached to and the
125 value of the symbol as the initial relocation offset. If the
126 symbol pointer is zero, then the section provided is looked up.
130 The <<address>> field gives the offset in bytes from the base of
131 the section data which owns the relocation record to the first
132 byte of relocatable information. The actual data relocated
133 will be relative to this point; for example, a relocation
134 type which modifies the bottom two bytes of a four byte word
135 would not touch the first byte pointed to in a big endian
140 The <<addend>> is a value provided by the back end to be added (!)
141 to the relocation offset. Its interpretation is dependent upon
142 the howto. For example, on the 68k the code:
148 | return foo[0x12345678];
151 Could be compiled into:
154 | moveb @@#12345678,d0
160 This could create a reloc pointing to <<foo>>, but leave the
161 offset in the data, something like:
164 |RELOCATION RECORDS FOR [.text]:
168 |00000000 4e56 fffc ; linkw fp,#-4
169 |00000004 1039 1234 5678 ; moveb @@#12345678,d0
170 |0000000a 49c0 ; extbl d0
171 |0000000c 4e5e ; unlk fp
175 Using coff and an 88k, some instructions don't have enough
176 space in them to represent the full address range, and
177 pointers have to be loaded in two parts. So you'd get something like:
180 | or.u r13,r0,hi16(_foo+0x12345678)
181 | ld.b r2,r13,lo16(_foo+0x12345678)
185 This should create two relocs, both pointing to <<_foo>>, and with
186 0x12340000 in their addend field. The data would consist of:
189 |RELOCATION RECORDS FOR [.text]:
191 |00000002 HVRT16 _foo+0x12340000
192 |00000006 LVRT16 _foo+0x12340000
194 |00000000 5da05678 ; or.u r13,r0,0x5678
195 |00000004 1c4d5678 ; ld.b r2,r13,0x5678
196 |00000008 f400c001 ; jmp r1
199 The relocation routine digs out the value from the data, adds
200 it to the addend to get the original offset, and then adds the
201 value of <<_foo>>. Note that all 32 bits have to be kept around
202 somewhere, to cope with carry from bit 15 to bit 16.
204 One further example is the sparc and the a.out format. The
205 sparc has a similar problem to the 88k, in that some
206 instructions don't have room for an entire offset, but on the
207 sparc the parts are created in odd sized lumps. The designers of
208 the a.out format chose to not use the data within the section
209 for storing part of the offset; all the offset is kept within
210 the reloc. Anything in the data should be ignored.
213 | sethi %hi(_foo+0x12345678),%g2
214 | ldsb [%g2+%lo(_foo+0x12345678)],%i0
218 Both relocs contain a pointer to <<foo>>, and the offsets
222 |RELOCATION RECORDS FOR [.text]:
224 |00000004 HI22 _foo+0x12345678
225 |00000008 LO10 _foo+0x12345678
227 |00000000 9de3bf90 ; save %sp,-112,%sp
228 |00000004 05000000 ; sethi %hi(_foo+0),%g2
229 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0
230 |0000000c 81c7e008 ; ret
231 |00000010 81e80000 ; restore
236 The <<howto>> field can be imagined as a
237 relocation instruction. It is a pointer to a structure which
238 contains information on what to do with all of the other
239 information in the reloc record and data section. A back end
240 would normally have a relocation instruction set and turn
241 relocations into pointers to the correct structure on input -
242 but it would be possible to create each howto field on demand.
248 <<enum complain_overflow>>
250 Indicates what sort of overflow checking should be done when
251 performing a relocation.
255 .enum complain_overflow
257 . {* Do not complain on overflow. *}
258 . complain_overflow_dont,
260 . {* Complain if the bitfield overflows, whether it is considered
261 . as signed or unsigned. *}
262 . complain_overflow_bitfield,
264 . {* Complain if the value overflows when considered as signed
266 . complain_overflow_signed,
268 . {* Complain if the value overflows when considered as an
269 . unsigned number. *}
270 . complain_overflow_unsigned
279 The <<reloc_howto_type>> is a structure which contains all the
280 information that libbfd needs to know to tie up a back end's data.
283 .struct symbol_cache_entry; {* Forward declaration *}
285 .typedef struct reloc_howto_struct
287 . {* The type field has mainly a documetary use - the back end can
288 . do what it wants with it, though normally the back end's
289 . external idea of what a reloc number is stored
290 . in this field. For example, a PC relative word relocation
291 . in a coff environment has the type 023 - because that's
292 . what the outside world calls a R_PCRWORD reloc. *}
295 . {* The value the final relocation is shifted right by. This drops
296 . unwanted data from the relocation. *}
297 . unsigned int rightshift;
299 . {* The size of the item to be relocated. This is *not* a
300 . power-of-two measure. To get the number of bytes operated
301 . on by a type of relocation, use bfd_get_reloc_size. *}
304 . {* The number of bits in the item to be relocated. This is used
305 . when doing overflow checking. *}
306 . unsigned int bitsize;
308 . {* Notes that the relocation is relative to the location in the
309 . data section of the addend. The relocation function will
310 . subtract from the relocation value the address of the location
311 . being relocated. *}
312 . boolean pc_relative;
314 . {* The bit position of the reloc value in the destination.
315 . The relocated value is left shifted by this amount. *}
316 . unsigned int bitpos;
318 . {* What type of overflow error should be checked for when
320 . enum complain_overflow complain_on_overflow;
322 . {* If this field is non null, then the supplied function is
323 . called rather than the normal function. This allows really
324 . strange relocation methods to be accomodated (e.g., i960 callj
326 . bfd_reloc_status_type (*special_function)
327 . PARAMS ((bfd *abfd,
328 . arelent *reloc_entry,
329 . struct symbol_cache_entry *symbol,
331 . asection *input_section,
333 . char **error_message));
335 . {* The textual name of the relocation type. *}
338 . {* When performing a partial link, some formats must modify the
339 . relocations rather than the data - this flag signals this.*}
340 . boolean partial_inplace;
342 . {* The src_mask selects which parts of the read in data
343 . are to be used in the relocation sum. E.g., if this was an 8 bit
344 . bit of data which we read and relocated, this would be
345 . 0x000000ff. When we have relocs which have an addend, such as
346 . sun4 extended relocs, the value in the offset part of a
347 . relocating field is garbage so we never use it. In this case
348 . the mask would be 0x00000000. *}
351 . {* The dst_mask selects which parts of the instruction are replaced
352 . into the instruction. In most cases src_mask == dst_mask,
353 . except in the above special case, where dst_mask would be
354 . 0x000000ff, and src_mask would be 0x00000000. *}
357 . {* When some formats create PC relative instructions, they leave
358 . the value of the pc of the place being relocated in the offset
359 . slot of the instruction, so that a PC relative relocation can
360 . be made just by adding in an ordinary offset (e.g., sun3 a.out).
361 . Some formats leave the displacement part of an instruction
362 . empty (e.g., m88k bcs); this flag signals the fact.*}
363 . boolean pcrel_offset;
374 The HOWTO define is horrible and will go away.
377 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
378 . {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
381 And will be replaced with the totally magic way. But for the
382 moment, we are compatible, so do it this way.
385 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
388 Helper routine to turn a symbol into a relocation value.
390 .#define HOWTO_PREPARE(relocation, symbol) \
392 . if (symbol != (asymbol *)NULL) { \
393 . if (bfd_is_com_section (symbol->section)) { \
397 . relocation = symbol->value; \
409 int bfd_get_reloc_size (const reloc_howto_type *);
412 For a reloc_howto_type that operates on a fixed number of bytes,
413 this returns the number of bytes operated on.
417 bfd_get_reloc_size (howto)
418 const reloc_howto_type *howto;
420 switch (howto->size) {
437 How relocs are tied together in an <<asection>>:
439 .typedef unsigned char bfd_byte;
441 .typedef struct relent_chain {
443 . struct relent_chain *next;
452 bfd_perform_relocation
455 bfd_reloc_status_type
456 bfd_perform_relocation
458 arelent *reloc_entry,
460 asection *input_section,
462 char **error_message);
465 If @var{output_bfd} is supplied to this function, the
466 generated image will be relocatable; the relocations are
467 copied to the output file after they have been changed to
468 reflect the new state of the world. There are two ways of
469 reflecting the results of partial linkage in an output file:
470 by modifying the output data in place, and by modifying the
471 relocation record. Some native formats (e.g., basic a.out and
472 basic coff) have no way of specifying an addend in the
473 relocation type, so the addend has to go in the output data.
474 This is no big deal since in these formats the output data
475 slot will always be big enough for the addend. Complex reloc
476 types with addends were invented to solve just this problem.
477 The @var{error_message} argument is set to an error message if
478 this return @code{bfd_reloc_dangerous}.
483 bfd_reloc_status_type
484 bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
487 arelent *reloc_entry;
489 asection *input_section;
491 char **error_message;
494 bfd_reloc_status_type flag = bfd_reloc_ok;
495 bfd_size_type addr = reloc_entry->address ;
496 bfd_vma output_base = 0;
497 const reloc_howto_type *howto = reloc_entry->howto;
498 asection *reloc_target_output_section;
501 symbol = *(reloc_entry->sym_ptr_ptr);
502 if ((symbol->section == &bfd_abs_section)
503 && output_bfd != (bfd *)NULL)
505 reloc_entry->address += input_section->output_offset;
509 /* If we are not producing relocateable output, return an error if
510 the symbol is not defined. An undefined weak symbol is
511 considered to have a value of zero (SVR4 ABI, p. 4-27). */
512 if (symbol->section == &bfd_und_section
513 && (symbol->flags & BSF_WEAK) == 0
514 && output_bfd == (bfd *) NULL)
515 flag = bfd_reloc_undefined;
517 /* If there is a function supplied to handle this relocation type,
518 call it. It'll return `bfd_reloc_continue' if further processing
520 if (howto->special_function)
522 bfd_reloc_status_type cont;
523 cont = howto->special_function (abfd, reloc_entry, symbol, data,
524 input_section, output_bfd,
526 if (cont != bfd_reloc_continue)
530 /* Is the address of the relocation really within the section? */
531 if (reloc_entry->address > input_section->_cooked_size)
532 return bfd_reloc_outofrange;
534 /* Work out which section the relocation is targetted at and the
535 initial relocation command value. */
537 /* Get symbol value. (Common symbols are special.) */
538 if (bfd_is_com_section (symbol->section))
541 relocation = symbol->value;
544 reloc_target_output_section = symbol->section->output_section;
546 /* Convert input-section-relative symbol value to absolute. */
547 if (output_bfd && howto->partial_inplace==false)
550 output_base = reloc_target_output_section->vma;
552 relocation += output_base + symbol->section->output_offset;
554 /* Add in supplied addend. */
555 relocation += reloc_entry->addend;
557 /* Here the variable relocation holds the final address of the
558 symbol we are relocating against, plus any addend. */
560 if (howto->pc_relative == true)
562 /* This is a PC relative relocation. We want to set RELOCATION
563 to the distance between the address of the symbol and the
564 location. RELOCATION is already the address of the symbol.
566 We start by subtracting the address of the section containing
569 If pcrel_offset is set, we must further subtract the position
570 of the location within the section. Some targets arrange for
571 the addend to be the negative of the position of the location
572 within the section; for example, i386-aout does this. For
573 i386-aout, pcrel_offset is false. Some other targets do not
574 include the position of the location; for example, m88kbcs,
575 or ELF. For those targets, pcrel_offset is true.
577 If we are producing relocateable output, then we must ensure
578 that this reloc will be correctly computed when the final
579 relocation is done. If pcrel_offset is false we want to wind
580 up with the negative of the location within the section,
581 which means we must adjust the existing addend by the change
582 in the location within the section. If pcrel_offset is true
583 we do not want to adjust the existing addend at all.
585 FIXME: This seems logical to me, but for the case of
586 producing relocateable output it is not what the code
587 actually does. I don't want to change it, because it seems
588 far too likely that something will break. */
591 input_section->output_section->vma + input_section->output_offset;
593 if (howto->pcrel_offset == true)
594 relocation -= reloc_entry->address;
597 if (output_bfd!= (bfd *)NULL)
599 if ( howto->partial_inplace == false)
601 /* This is a partial relocation, and we want to apply the relocation
602 to the reloc entry rather than the raw data. Modify the reloc
603 inplace to reflect what we now know. */
604 reloc_entry->addend = relocation;
605 reloc_entry->address += input_section->output_offset;
610 /* This is a partial relocation, but inplace, so modify the
613 If we've relocated with a symbol with a section, change
614 into a ref to the section belonging to the symbol. */
616 reloc_entry->address += input_section->output_offset;
619 if (abfd->xvec->flavour == bfd_target_coff_flavour)
622 /* For m68k-coff, the addend was being subtracted twice during
623 relocation with -r. Removing the line below this comment
624 fixes that problem; see PR 2953.
626 However, Ian wrote the following, regarding removing the line below,
627 which explains why it is still enabled: --djm
629 If you put a patch like that into BFD you need to check all the COFF
630 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
631 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
632 problem in a different way. There may very well be a reason that the
633 code works as it does.
635 Hmmm. The first obvious point is that bfd_perform_relocation should
636 not have any tests that depend upon the flavour. It's seem like
637 entirely the wrong place for such a thing. The second obvious point
638 is that the current code ignores the reloc addend when producing
639 relocateable output for COFF. That's peculiar. In fact, I really
640 have no idea what the point of the line you want to remove is.
642 A typical COFF reloc subtracts the old value of the symbol and adds in
643 the new value to the location in the object file (if it's a pc
644 relative reloc it adds the difference between the symbol value and the
645 location). When relocating we need to preserve that property.
647 BFD handles this by setting the addend to the negative of the old
648 value of the symbol. Unfortunately it handles common symbols in a
649 non-standard way (it doesn't subtract the old value) but that's a
650 different story (we can't change it without losing backward
651 compatibility with old object files) (coff-i386 does subtract the old
652 value, to be compatible with existing coff-i386 targets, like SCO).
654 So everything works fine when not producing relocateable output. When
655 we are producing relocateable output, logically we should do exactly
656 what we do when not producing relocateable output. Therefore, your
657 patch is correct. In fact, it should probably always just set
658 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
659 add the value into the object file. This won't hurt the COFF code,
660 which doesn't use the addend; I'm not sure what it will do to other
661 formats (the thing to check for would be whether any formats both use
662 the addend and set partial_inplace).
664 When I wanted to make coff-i386 produce relocateable output, I ran
665 into the problem that you are running into: I wanted to remove that
666 line. Rather than risk it, I made the coff-i386 relocs use a special
667 function; it's coff_i386_reloc in coff-i386.c. The function
668 specifically adds the addend field into the object file, knowing that
669 bfd_perform_relocation is not going to. If you remove that line, then
670 coff-i386.c will wind up adding the addend field in twice. It's
671 trivial to fix; it just needs to be done.
673 The problem with removing the line is just that it may break some
674 working code. With BFD it's hard to be sure of anything. The right
675 way to deal with this is simply to build and test at least all the
676 supported COFF targets. It should be straightforward if time and disk
677 space consuming. For each target:
679 2) generate some executable, and link it using -r (I would
680 probably use paranoia.o and link against newlib/libc.a, which
681 for all the supported targets would be available in
682 /usr/cygnus/progressive/H-host/target/lib/libc.a).
683 3) make the change to reloc.c
684 4) rebuild the linker
686 6) if the resulting object files are the same, you have at least
688 7) if they are different you have to figure out which version is
691 relocation -= reloc_entry->addend;
693 reloc_entry->addend = 0;
697 reloc_entry->addend = relocation;
703 reloc_entry->addend = 0;
706 /* FIXME: This overflow checking is incomplete, because the value
707 might have overflowed before we get here. For a correct check we
708 need to compute the value in a size larger than bitsize, but we
709 can't reasonably do that for a reloc the same size as a host
711 FIXME: We should also do overflow checking on the result after
712 adding in the value contained in the object file. */
713 if (howto->complain_on_overflow != complain_overflow_dont)
717 /* Get the value that will be used for the relocation, but
718 starting at bit position zero. */
719 if (howto->rightshift > howto->bitpos)
720 check = relocation >> (howto->rightshift - howto->bitpos);
722 check = relocation << (howto->bitpos - howto->rightshift);
723 switch (howto->complain_on_overflow)
725 case complain_overflow_signed:
727 /* Assumes two's complement. */
728 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
729 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
731 /* The above right shift is incorrect for a signed value.
732 Fix it up by forcing on the upper bits. */
733 if (howto->rightshift > howto->bitpos
734 && (bfd_signed_vma) relocation < 0)
735 check |= ((bfd_vma) -1
737 >> (howto->rightshift - howto->bitpos)));
738 if ((bfd_signed_vma) check > reloc_signed_max
739 || (bfd_signed_vma) check < reloc_signed_min)
740 flag = bfd_reloc_overflow;
743 case complain_overflow_unsigned:
745 /* Assumes two's complement. This expression avoids
746 overflow if howto->bitsize is the number of bits in
748 bfd_vma reloc_unsigned_max =
749 (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
751 if ((bfd_vma) check > reloc_unsigned_max)
752 flag = bfd_reloc_overflow;
755 case complain_overflow_bitfield:
757 /* Assumes two's complement. This expression avoids
758 overflow if howto->bitsize is the number of bits in
760 bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
762 if (((bfd_vma) check &~ reloc_bits) != 0
763 && ((bfd_vma) check &~ reloc_bits) != (-1 &~ reloc_bits))
765 /* The above right shift is incorrect for a signed
766 value. See if turning on the upper bits fixes the
768 if (howto->rightshift > howto->bitpos
769 && (bfd_signed_vma) relocation < 0)
771 check |= ((bfd_vma) -1
773 >> (howto->rightshift - howto->bitpos)));
774 if (((bfd_vma) check &~ reloc_bits) != (-1 &~ reloc_bits))
775 flag = bfd_reloc_overflow;
778 flag = bfd_reloc_overflow;
788 Either we are relocating all the way, or we don't want to apply
789 the relocation to the reloc entry (probably because there isn't
790 any room in the output format to describe addends to relocs)
793 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
794 (OSF version 1.3, compiler version 3.11). It miscompiles the
808 x <<= (unsigned long) s.i0;
812 printf ("succeeded (%lx)\n", x);
816 relocation >>= (bfd_vma) howto->rightshift;
818 /* Shift everything up to where it's going to be used */
820 relocation <<= (bfd_vma) howto->bitpos;
822 /* Wait for the day when all have the mask in them */
825 i instruction to be left alone
826 o offset within instruction
827 r relocation offset to apply
836 i i i i i o o o o o from bfd_get<size>
837 and S S S S S to get the size offset we want
838 + r r r r r r r r r r to get the final value to place
839 and D D D D D to chop to right size
840 -----------------------
843 ... i i i i i o o o o o from bfd_get<size>
844 and N N N N N get instruction
845 -----------------------
851 -----------------------
852 R R R R R R R R R R put into bfd_put<size>
856 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
862 char x = bfd_get_8(abfd, (char *)data + addr);
864 bfd_put_8(abfd,x, (unsigned char *) data + addr);
871 short x = bfd_get_16(abfd, (bfd_byte *)data + addr);
873 bfd_put_16(abfd, x, (unsigned char *)data + addr);
879 long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
881 bfd_put_32 (abfd, x, (bfd_byte *)data + addr);
886 long x = bfd_get_32(abfd, (bfd_byte *) data + addr);
887 relocation = -relocation;
889 bfd_put_32(abfd,x, (bfd_byte *)data + addr);
901 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + addr);
903 bfd_put_64 (abfd, x, (bfd_byte *) data + addr);
910 return bfd_reloc_other;
916 /* This relocation routine is used by some of the backend linkers.
917 They do not construct asymbol or arelent structures, so there is no
918 reason for them to use bfd_perform_relocation. Also,
919 bfd_perform_relocation is so hacked up it is easier to write a new
920 function than to try to deal with it.
922 This routine does a final relocation. It should not be used when
923 generating relocateable output.
925 FIXME: This routine ignores any special_function in the HOWTO,
926 since the existing special_function values have been written for
927 bfd_perform_relocation.
929 HOWTO is the reloc howto information.
930 INPUT_BFD is the BFD which the reloc applies to.
931 INPUT_SECTION is the section which the reloc applies to.
932 CONTENTS is the contents of the section.
933 ADDRESS is the address of the reloc within INPUT_SECTION.
934 VALUE is the value of the symbol the reloc refers to.
935 ADDEND is the addend of the reloc. */
937 bfd_reloc_status_type
938 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
940 const reloc_howto_type *howto;
942 asection *input_section;
950 /* Sanity check the address. */
951 if (address > input_section->_cooked_size)
952 return bfd_reloc_outofrange;
954 /* This function assumes that we are dealing with a basic relocation
955 against a symbol. We want to compute the value of the symbol to
956 relocate to. This is just VALUE, the value of the symbol, plus
957 ADDEND, any addend associated with the reloc. */
958 relocation = value + addend;
960 /* If the relocation is PC relative, we want to set RELOCATION to
961 the distance between the symbol (currently in RELOCATION) and the
962 location we are relocating. Some targets (e.g., i386-aout)
963 arrange for the contents of the section to be the negative of the
964 offset of the location within the section; for such targets
965 pcrel_offset is false. Other targets (e.g., m88kbcs or ELF)
966 simply leave the contents of the section as zero; for such
967 targets pcrel_offset is true. If pcrel_offset is false we do not
968 need to subtract out the offset of the location within the
969 section (which is just ADDRESS). */
970 if (howto->pc_relative)
972 relocation -= (input_section->output_section->vma
973 + input_section->output_offset);
974 if (howto->pcrel_offset)
975 relocation -= address;
978 return _bfd_relocate_contents (howto, input_bfd, relocation,
982 /* Relocate a given location using a given value and howto. */
984 bfd_reloc_status_type
985 _bfd_relocate_contents (howto, input_bfd, relocation, location)
986 const reloc_howto_type *howto;
995 /* If the size is negative, negate RELOCATION. This isn't very
998 relocation = - relocation;
1000 /* Get the value we are going to relocate. */
1001 size = bfd_get_reloc_size (howto);
1008 x = bfd_get_8 (input_bfd, location);
1011 x = bfd_get_16 (input_bfd, location);
1014 x = bfd_get_32 (input_bfd, location);
1018 x = bfd_get_64 (input_bfd, location);
1025 /* Check for overflow. FIXME: We may drop bits during the addition
1026 which we don't check for. We must either check at every single
1027 operation, which would be tedious, or we must do the computations
1028 in a type larger than bfd_vma, which would be inefficient. */
1030 if (howto->complain_on_overflow != complain_overflow_dont)
1033 bfd_signed_vma signed_check;
1035 bfd_signed_vma signed_add;
1037 if (howto->rightshift == 0)
1040 signed_check = (bfd_signed_vma) relocation;
1044 /* Drop unwanted bits from the value we are relocating to. */
1045 check = relocation >> howto->rightshift;
1047 /* If this is a signed value, the rightshift just dropped
1048 leading 1 bits (assuming twos complement). */
1049 if ((bfd_signed_vma) relocation >= 0)
1050 signed_check = check;
1052 signed_check = (check
1054 &~ ((bfd_vma) -1 >> howto->rightshift)));
1057 /* Add in the value from the object file, shifted down so that
1058 it is a straight number. */
1059 add = x & howto->src_mask;
1060 if ((add & (((~ howto->src_mask) >> 1) & howto->src_mask)) == 0)
1063 signed_add = add | ((bfd_vma) -1 &~ howto->src_mask);
1064 if (howto->bitpos == 0)
1067 signed_check += signed_add;
1071 check += add >> howto->bitpos;
1072 if (signed_add >= 0)
1073 signed_check += signed_add >> howto->bitpos;
1075 signed_check += ((signed_add >> howto->bitpos)
1077 &~ ((bfd_vma) -1 >> howto->bitpos)));
1080 switch (howto->complain_on_overflow)
1082 case complain_overflow_signed:
1084 /* Assumes two's complement. */
1085 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1086 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1088 if (signed_check > reloc_signed_max
1089 || signed_check < reloc_signed_min)
1093 case complain_overflow_unsigned:
1095 /* Assumes two's complement. This expression avoids
1096 overflow if howto->bitsize is the number of bits in
1098 bfd_vma reloc_unsigned_max =
1099 (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1101 if (check > reloc_unsigned_max)
1105 case complain_overflow_bitfield:
1107 /* Assumes two's complement. This expression avoids
1108 overflow if howto->bitsize is the number of bits in
1110 bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1112 if ((check &~ reloc_bits) != 0
1113 && (((bfd_vma) signed_check &~ reloc_bits)
1114 != (-1 &~ reloc_bits)))
1123 /* Put RELOCATION in the right bits. */
1124 relocation >>= (bfd_vma) howto->rightshift;
1125 relocation <<= (bfd_vma) howto->bitpos;
1127 /* Add RELOCATION to the right bits of X. */
1128 x = ((x &~ howto->dst_mask)
1129 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1131 /* Put the relocated value back in the object file. */
1138 bfd_put_8 (input_bfd, x, location);
1141 bfd_put_16 (input_bfd, x, location);
1144 bfd_put_32 (input_bfd, x, location);
1148 bfd_put_64 (input_bfd, x, location);
1155 return overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1161 howto manager, , typedef arelent, Relocations
1166 When an application wants to create a relocation, but doesn't
1167 know what the target machine might call it, it can find out by
1168 using this bit of code.
1177 The insides of a reloc code. The idea is that, eventually, there
1178 will be one enumerator for every type of relocation we ever do.
1179 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1180 return a howto pointer.
1182 This does mean that the application must determine the correct
1183 enumerator value; you can't get a howto pointer from a random set
1188 .typedef enum bfd_reloc_code_real
1190 . {* Basic absolute relocations *}
1197 . {* PC-relative relocations *}
1198 . BFD_RELOC_64_PCREL,
1199 . BFD_RELOC_32_PCREL,
1200 . BFD_RELOC_24_PCREL, {* used by i960 *}
1201 . BFD_RELOC_16_PCREL,
1202 . BFD_RELOC_8_PCREL,
1204 . {* Linkage-table relative *}
1205 . BFD_RELOC_32_BASEREL,
1206 . BFD_RELOC_16_BASEREL,
1207 . BFD_RELOC_8_BASEREL,
1209 . {* The type of reloc used to build a contructor table - at the moment
1210 . probably a 32 bit wide abs address, but the cpu can choose. *}
1213 . {* 8 bits wide, but used to form an address like 0xffnn *}
1216 . {* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit
1217 . word displacement, e.g. for SPARC) *}
1218 . BFD_RELOC_32_PCREL_S2,
1219 . {* signed 16-bit pc-relative, shifted right 2 bits (e.g. for MIPS) *}
1220 . BFD_RELOC_16_PCREL_S2,
1221 . {* this is used on the Alpha *}
1222 . BFD_RELOC_23_PCREL_S2,
1224 . {* High 22 bits of 32-bit value, placed into lower 22 bits of
1225 . target word; simple reloc. *}
1227 . {* Low 10 bits. *}
1230 . {* For systems that allocate a Global Pointer register, these are
1231 . displacements off that register. These relocation types are
1232 . handled specially, because the value the register will have is
1233 . decided relatively late. *}
1234 . BFD_RELOC_GPREL16,
1235 . BFD_RELOC_GPREL32,
1237 . {* Reloc types used for i960/b.out. *}
1238 . BFD_RELOC_I960_CALLJ,
1240 . {* now for the sparc/elf codes *}
1241 . BFD_RELOC_NONE, {* actually used *}
1242 . BFD_RELOC_SPARC_WDISP22,
1243 . BFD_RELOC_SPARC22,
1244 . BFD_RELOC_SPARC13,
1245 . BFD_RELOC_SPARC_GOT10,
1246 . BFD_RELOC_SPARC_GOT13,
1247 . BFD_RELOC_SPARC_GOT22,
1248 . BFD_RELOC_SPARC_PC10,
1249 . BFD_RELOC_SPARC_PC22,
1250 . BFD_RELOC_SPARC_WPLT30,
1251 . BFD_RELOC_SPARC_COPY,
1252 . BFD_RELOC_SPARC_GLOB_DAT,
1253 . BFD_RELOC_SPARC_JMP_SLOT,
1254 . BFD_RELOC_SPARC_RELATIVE,
1255 . BFD_RELOC_SPARC_UA32,
1257 . {* these are a.out specific? *}
1258 . BFD_RELOC_SPARC_BASE13,
1259 . BFD_RELOC_SPARC_BASE22,
1261 . {* start-sanitize-v9 *}
1262 . BFD_RELOC_SPARC_10,
1263 . BFD_RELOC_SPARC_11,
1264 .#define BFD_RELOC_SPARC_64 BFD_RELOC_64
1265 . BFD_RELOC_SPARC_OLO10,
1266 . BFD_RELOC_SPARC_HH22,
1267 . BFD_RELOC_SPARC_HM10,
1268 . BFD_RELOC_SPARC_LM22,
1269 . BFD_RELOC_SPARC_PC_HH22,
1270 . BFD_RELOC_SPARC_PC_HM10,
1271 . BFD_RELOC_SPARC_PC_LM22,
1272 . BFD_RELOC_SPARC_WDISP16,
1273 . BFD_RELOC_SPARC_WDISP19,
1274 . BFD_RELOC_SPARC_GLOB_JMP,
1275 . BFD_RELOC_SPARC_LO7,
1276 . {* end-sanitize-v9 *}
1278 . {* Alpha ECOFF relocations. Some of these treat the symbol or "addend"
1279 . in some special way. *}
1280 . {* For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1281 . writing; when reading, it will be the absolute section symbol. The
1282 . addend is the displacement in bytes of the "lda" instruction from
1283 . the "ldah" instruction (which is at the address of this reloc). *}
1284 . BFD_RELOC_ALPHA_GPDISP_HI16,
1285 . {* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1286 . with GPDISP_HI16 relocs. The addend is ignored when writing the
1287 . relocations out, and is filled in with the file's GP value on
1288 . reading, for convenience. *}
1289 . BFD_RELOC_ALPHA_GPDISP_LO16,
1291 . {* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1292 . the assembler turns it into a LDQ instruction to load the address of
1293 . the symbol, and then fills in a register in the real instruction.
1295 . The LITERAL reloc, at the LDQ instruction, refers to the .lita
1296 . section symbol. The addend is ignored when writing, but is filled
1297 . in with the file's GP value on reading, for convenience, as with the
1298 . GPDISP_LO16 reloc.
1300 . The LITUSE reloc, on the instruction using the loaded address, gives
1301 . information to the linker that it might be able to use to optimize
1302 . away some literal section references. The symbol is ignored (read
1303 . as the absolute section symbol), and the "addend" indicates the type
1304 . of instruction using the register:
1305 . 1 - "memory" fmt insn
1306 . 2 - byte-manipulation (byte offset reg)
1307 . 3 - jsr (target of branch)
1309 . The GNU linker currently doesn't do any of this optimizing. *}
1310 . BFD_RELOC_ALPHA_LITERAL,
1311 . BFD_RELOC_ALPHA_LITUSE,
1313 . {* The HINT relocation indicates a value that should be filled into the
1314 . "hint" field of a jmp/jsr/ret instruction, for possible branch-
1315 . prediction logic which may be provided on some processors. *}
1316 . BFD_RELOC_ALPHA_HINT,
1318 . {* Bits 27..2 of the relocation address shifted right 2 bits;
1319 . simple reloc otherwise. *}
1320 . BFD_RELOC_MIPS_JMP,
1322 . {* High 16 bits of 32-bit value; simple reloc. *}
1324 . {* High 16 bits of 32-bit value but the low 16 bits will be sign
1325 . extended and added to form the final result. If the low 16
1326 . bits form a negative number, we need to add one to the high value
1327 . to compensate for the borrow when the low bits are added. *}
1329 . {* Low 16 bits. *}
1332 . {* relocation relative to the global pointer. *}
1333 .#define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16
1335 . {* Relocation against a MIPS literal section. *}
1336 . BFD_RELOC_MIPS_LITERAL,
1338 . {* MIPS ELF relocations. *}
1339 . BFD_RELOC_MIPS_GOT16,
1340 . BFD_RELOC_MIPS_CALL16,
1341 .#define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32
1343 . {* These are, so far, specific to HPPA processors. I'm not sure that some
1344 . don't duplicate other reloc types, such as BFD_RELOC_32 and _32_PCREL.
1345 . Also, many more were in the list I got that don't fit in well in the
1346 . model BFD uses, so I've omitted them for now. If we do make this reloc
1347 . type get used for code that really does implement the funky reloc types,
1348 . they'll have to be added to this list. *}
1349 . BFD_RELOC_HPPA_32,
1350 . BFD_RELOC_HPPA_11,
1351 . BFD_RELOC_HPPA_14,
1352 . BFD_RELOC_HPPA_17,
1354 . BFD_RELOC_HPPA_L21,
1355 . BFD_RELOC_HPPA_R11,
1356 . BFD_RELOC_HPPA_R14,
1357 . BFD_RELOC_HPPA_R17,
1358 . BFD_RELOC_HPPA_LS21,
1359 . BFD_RELOC_HPPA_RS11,
1360 . BFD_RELOC_HPPA_RS14,
1361 . BFD_RELOC_HPPA_RS17,
1362 . BFD_RELOC_HPPA_LD21,
1363 . BFD_RELOC_HPPA_RD11,
1364 . BFD_RELOC_HPPA_RD14,
1365 . BFD_RELOC_HPPA_RD17,
1366 . BFD_RELOC_HPPA_LR21,
1367 . BFD_RELOC_HPPA_RR14,
1368 . BFD_RELOC_HPPA_RR17,
1370 . BFD_RELOC_HPPA_GOTOFF_11,
1371 . BFD_RELOC_HPPA_GOTOFF_14,
1372 . BFD_RELOC_HPPA_GOTOFF_L21,
1373 . BFD_RELOC_HPPA_GOTOFF_R11,
1374 . BFD_RELOC_HPPA_GOTOFF_R14,
1375 . BFD_RELOC_HPPA_GOTOFF_LS21,
1376 . BFD_RELOC_HPPA_GOTOFF_RS11,
1377 . BFD_RELOC_HPPA_GOTOFF_RS14,
1378 . BFD_RELOC_HPPA_GOTOFF_LD21,
1379 . BFD_RELOC_HPPA_GOTOFF_RD11,
1380 . BFD_RELOC_HPPA_GOTOFF_RD14,
1381 . BFD_RELOC_HPPA_GOTOFF_LR21,
1382 . BFD_RELOC_HPPA_GOTOFF_RR14,
1384 . BFD_RELOC_HPPA_DLT_32,
1385 . BFD_RELOC_HPPA_DLT_11,
1386 . BFD_RELOC_HPPA_DLT_14,
1387 . BFD_RELOC_HPPA_DLT_L21,
1388 . BFD_RELOC_HPPA_DLT_R11,
1389 . BFD_RELOC_HPPA_DLT_R14,
1391 . BFD_RELOC_HPPA_ABS_CALL_11,
1392 . BFD_RELOC_HPPA_ABS_CALL_14,
1393 . BFD_RELOC_HPPA_ABS_CALL_17,
1394 . BFD_RELOC_HPPA_ABS_CALL_L21,
1395 . BFD_RELOC_HPPA_ABS_CALL_R11,
1396 . BFD_RELOC_HPPA_ABS_CALL_R14,
1397 . BFD_RELOC_HPPA_ABS_CALL_R17,
1398 . BFD_RELOC_HPPA_ABS_CALL_LS21,
1399 . BFD_RELOC_HPPA_ABS_CALL_RS11,
1400 . BFD_RELOC_HPPA_ABS_CALL_RS14,
1401 . BFD_RELOC_HPPA_ABS_CALL_RS17,
1402 . BFD_RELOC_HPPA_ABS_CALL_LD21,
1403 . BFD_RELOC_HPPA_ABS_CALL_RD11,
1404 . BFD_RELOC_HPPA_ABS_CALL_RD14,
1405 . BFD_RELOC_HPPA_ABS_CALL_RD17,
1406 . BFD_RELOC_HPPA_ABS_CALL_LR21,
1407 . BFD_RELOC_HPPA_ABS_CALL_RR14,
1408 . BFD_RELOC_HPPA_ABS_CALL_RR17,
1410 . BFD_RELOC_HPPA_PCREL_CALL_11,
1411 . BFD_RELOC_HPPA_PCREL_CALL_12,
1412 . BFD_RELOC_HPPA_PCREL_CALL_14,
1413 . BFD_RELOC_HPPA_PCREL_CALL_17,
1414 . BFD_RELOC_HPPA_PCREL_CALL_L21,
1415 . BFD_RELOC_HPPA_PCREL_CALL_R11,
1416 . BFD_RELOC_HPPA_PCREL_CALL_R14,
1417 . BFD_RELOC_HPPA_PCREL_CALL_R17,
1418 . BFD_RELOC_HPPA_PCREL_CALL_LS21,
1419 . BFD_RELOC_HPPA_PCREL_CALL_RS11,
1420 . BFD_RELOC_HPPA_PCREL_CALL_RS14,
1421 . BFD_RELOC_HPPA_PCREL_CALL_RS17,
1422 . BFD_RELOC_HPPA_PCREL_CALL_LD21,
1423 . BFD_RELOC_HPPA_PCREL_CALL_RD11,
1424 . BFD_RELOC_HPPA_PCREL_CALL_RD14,
1425 . BFD_RELOC_HPPA_PCREL_CALL_RD17,
1426 . BFD_RELOC_HPPA_PCREL_CALL_LR21,
1427 . BFD_RELOC_HPPA_PCREL_CALL_RR14,
1428 . BFD_RELOC_HPPA_PCREL_CALL_RR17,
1430 . BFD_RELOC_HPPA_PLABEL_32,
1431 . BFD_RELOC_HPPA_PLABEL_11,
1432 . BFD_RELOC_HPPA_PLABEL_14,
1433 . BFD_RELOC_HPPA_PLABEL_L21,
1434 . BFD_RELOC_HPPA_PLABEL_R11,
1435 . BFD_RELOC_HPPA_PLABEL_R14,
1437 . BFD_RELOC_HPPA_UNWIND_ENTRY,
1438 . BFD_RELOC_HPPA_UNWIND_ENTRIES,
1440 . {* i386/elf relocations *}
1441 . BFD_RELOC_386_GOT32,
1442 . BFD_RELOC_386_PLT32,
1443 . BFD_RELOC_386_COPY,
1444 . BFD_RELOC_386_GLOB_DAT,
1445 . BFD_RELOC_386_JUMP_SLOT,
1446 . BFD_RELOC_386_RELATIVE,
1447 . BFD_RELOC_386_GOTOFF,
1448 . BFD_RELOC_386_GOTPC,
1450 . {* this must be the highest numeric value *}
1452 . } bfd_reloc_code_real_type;
1458 bfd_reloc_type_lookup
1461 const struct reloc_howto_struct *
1462 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
1465 Return a pointer to a howto structure which, when
1466 invoked, will perform the relocation @var{code} on data from the
1472 const struct reloc_howto_struct *
1473 DEFUN(bfd_reloc_type_lookup,(abfd, code),
1475 bfd_reloc_code_real_type code)
1477 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
1480 static reloc_howto_type bfd_howto_32 =
1481 HOWTO(0, 00,2,32,false,0,complain_overflow_bitfield,0,"VRT32", false,0xffffffff,0xffffffff,true);
1486 bfd_default_reloc_type_lookup
1489 const struct reloc_howto_struct *bfd_default_reloc_type_lookup
1491 bfd_reloc_code_real_type code);
1494 Provides a default relocation lookup routine for any architecture.
1499 const struct reloc_howto_struct *
1500 DEFUN(bfd_default_reloc_type_lookup, (abfd, code),
1502 bfd_reloc_code_real_type code)
1506 case BFD_RELOC_CTOR:
1507 /* The type of reloc used in a ctor, which will be as wide as the
1508 address - so either a 64, 32, or 16 bitter. */
1509 switch (bfd_get_arch_info (abfd)->bits_per_address) {
1513 return &bfd_howto_32;
1522 return (const struct reloc_howto_struct *)NULL;
1528 bfd_generic_relax_section
1531 boolean bfd_generic_relax_section
1534 struct bfd_link_info *,
1538 Provides default handling for relaxing for back ends which
1539 don't do relaxing -- i.e., does nothing.
1544 bfd_generic_relax_section (abfd, section, link_info, symbols)
1547 struct bfd_link_info *link_info;
1555 bfd_generic_get_relocated_section_contents
1559 bfd_generic_get_relocated_section_contents (bfd *abfd,
1560 struct bfd_link_info *link_info,
1561 struct bfd_link_order *link_order,
1563 boolean relocateable,
1567 Provides default handling of relocation effort for back ends
1568 which can't be bothered to do it efficiently.
1573 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
1574 relocateable, symbols)
1576 struct bfd_link_info *link_info;
1577 struct bfd_link_order *link_order;
1579 boolean relocateable;
1582 /* Get enough memory to hold the stuff */
1583 bfd *input_bfd = link_order->u.indirect.section->owner;
1584 asection *input_section = link_order->u.indirect.section;
1588 size_t reloc_size = bfd_get_reloc_upper_bound(input_bfd, input_section);
1589 arelent **reloc_vector = (arelent **) alloca(reloc_size);
1591 /* read in the section */
1592 bfd_get_section_contents(input_bfd,
1596 input_section->_raw_size);
1598 /* We're not relaxing the section, so just copy the size info */
1599 input_section->_cooked_size = input_section->_raw_size;
1600 input_section->reloc_done = true;
1603 if (bfd_canonicalize_reloc(input_bfd,
1609 for (parent = reloc_vector; * parent != (arelent *)NULL;
1612 char *error_message = (char *) NULL;
1613 bfd_reloc_status_type r=
1614 bfd_perform_relocation(input_bfd,
1618 relocateable ? abfd : (bfd *) NULL,
1623 asection *os = input_section->output_section;
1625 /* A partial link, so keep the relocs */
1626 os->orelocation[os->reloc_count] = *parent;
1630 if (r != bfd_reloc_ok)
1634 case bfd_reloc_undefined:
1635 if (! ((*link_info->callbacks->undefined_symbol)
1636 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
1637 input_bfd, input_section, (*parent)->address)))
1640 case bfd_reloc_dangerous:
1641 BFD_ASSERT (error_message != (char *) NULL);
1642 if (! ((*link_info->callbacks->reloc_dangerous)
1643 (link_info, error_message, input_bfd, input_section,
1644 (*parent)->address)))
1647 case bfd_reloc_overflow:
1648 if (! ((*link_info->callbacks->reloc_overflow)
1649 (link_info, input_bfd, input_section, (*parent)->address)))
1652 case bfd_reloc_outofrange: