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
620 && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0)
623 /* For m68k-coff, the addend was being subtracted twice during
624 relocation with -r. Removing the line below this comment
625 fixes that problem; see PR 2953.
627 However, Ian wrote the following, regarding removing the line below,
628 which explains why it is still enabled: --djm
630 If you put a patch like that into BFD you need to check all the COFF
631 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
632 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
633 problem in a different way. There may very well be a reason that the
634 code works as it does.
636 Hmmm. The first obvious point is that bfd_perform_relocation should
637 not have any tests that depend upon the flavour. It's seem like
638 entirely the wrong place for such a thing. The second obvious point
639 is that the current code ignores the reloc addend when producing
640 relocateable output for COFF. That's peculiar. In fact, I really
641 have no idea what the point of the line you want to remove is.
643 A typical COFF reloc subtracts the old value of the symbol and adds in
644 the new value to the location in the object file (if it's a pc
645 relative reloc it adds the difference between the symbol value and the
646 location). When relocating we need to preserve that property.
648 BFD handles this by setting the addend to the negative of the old
649 value of the symbol. Unfortunately it handles common symbols in a
650 non-standard way (it doesn't subtract the old value) but that's a
651 different story (we can't change it without losing backward
652 compatibility with old object files) (coff-i386 does subtract the old
653 value, to be compatible with existing coff-i386 targets, like SCO).
655 So everything works fine when not producing relocateable output. When
656 we are producing relocateable output, logically we should do exactly
657 what we do when not producing relocateable output. Therefore, your
658 patch is correct. In fact, it should probably always just set
659 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
660 add the value into the object file. This won't hurt the COFF code,
661 which doesn't use the addend; I'm not sure what it will do to other
662 formats (the thing to check for would be whether any formats both use
663 the addend and set partial_inplace).
665 When I wanted to make coff-i386 produce relocateable output, I ran
666 into the problem that you are running into: I wanted to remove that
667 line. Rather than risk it, I made the coff-i386 relocs use a special
668 function; it's coff_i386_reloc in coff-i386.c. The function
669 specifically adds the addend field into the object file, knowing that
670 bfd_perform_relocation is not going to. If you remove that line, then
671 coff-i386.c will wind up adding the addend field in twice. It's
672 trivial to fix; it just needs to be done.
674 The problem with removing the line is just that it may break some
675 working code. With BFD it's hard to be sure of anything. The right
676 way to deal with this is simply to build and test at least all the
677 supported COFF targets. It should be straightforward if time and disk
678 space consuming. For each target:
680 2) generate some executable, and link it using -r (I would
681 probably use paranoia.o and link against newlib/libc.a, which
682 for all the supported targets would be available in
683 /usr/cygnus/progressive/H-host/target/lib/libc.a).
684 3) make the change to reloc.c
685 4) rebuild the linker
687 6) if the resulting object files are the same, you have at least
689 7) if they are different you have to figure out which version is
692 relocation -= reloc_entry->addend;
694 reloc_entry->addend = 0;
698 reloc_entry->addend = relocation;
704 reloc_entry->addend = 0;
707 /* FIXME: This overflow checking is incomplete, because the value
708 might have overflowed before we get here. For a correct check we
709 need to compute the value in a size larger than bitsize, but we
710 can't reasonably do that for a reloc the same size as a host
712 FIXME: We should also do overflow checking on the result after
713 adding in the value contained in the object file. */
714 if (howto->complain_on_overflow != complain_overflow_dont)
718 /* Get the value that will be used for the relocation, but
719 starting at bit position zero. */
720 if (howto->rightshift > howto->bitpos)
721 check = relocation >> (howto->rightshift - howto->bitpos);
723 check = relocation << (howto->bitpos - howto->rightshift);
724 switch (howto->complain_on_overflow)
726 case complain_overflow_signed:
728 /* Assumes two's complement. */
729 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
730 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
732 /* The above right shift is incorrect for a signed value.
733 Fix it up by forcing on the upper bits. */
734 if (howto->rightshift > howto->bitpos
735 && (bfd_signed_vma) relocation < 0)
736 check |= ((bfd_vma) -1
738 >> (howto->rightshift - howto->bitpos)));
739 if ((bfd_signed_vma) check > reloc_signed_max
740 || (bfd_signed_vma) check < reloc_signed_min)
741 flag = bfd_reloc_overflow;
744 case complain_overflow_unsigned:
746 /* Assumes two's complement. This expression avoids
747 overflow if howto->bitsize is the number of bits in
749 bfd_vma reloc_unsigned_max =
750 (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
752 if ((bfd_vma) check > reloc_unsigned_max)
753 flag = bfd_reloc_overflow;
756 case complain_overflow_bitfield:
758 /* Assumes two's complement. This expression avoids
759 overflow if howto->bitsize is the number of bits in
761 bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
763 if (((bfd_vma) check &~ reloc_bits) != 0
764 && ((bfd_vma) check &~ reloc_bits) != (-1 &~ reloc_bits))
766 /* The above right shift is incorrect for a signed
767 value. See if turning on the upper bits fixes the
769 if (howto->rightshift > howto->bitpos
770 && (bfd_signed_vma) relocation < 0)
772 check |= ((bfd_vma) -1
774 >> (howto->rightshift - howto->bitpos)));
775 if (((bfd_vma) check &~ reloc_bits) != (-1 &~ reloc_bits))
776 flag = bfd_reloc_overflow;
779 flag = bfd_reloc_overflow;
789 Either we are relocating all the way, or we don't want to apply
790 the relocation to the reloc entry (probably because there isn't
791 any room in the output format to describe addends to relocs)
794 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
795 (OSF version 1.3, compiler version 3.11). It miscompiles the
809 x <<= (unsigned long) s.i0;
813 printf ("succeeded (%lx)\n", x);
817 relocation >>= (bfd_vma) howto->rightshift;
819 /* Shift everything up to where it's going to be used */
821 relocation <<= (bfd_vma) howto->bitpos;
823 /* Wait for the day when all have the mask in them */
826 i instruction to be left alone
827 o offset within instruction
828 r relocation offset to apply
837 i i i i i o o o o o from bfd_get<size>
838 and S S S S S to get the size offset we want
839 + r r r r r r r r r r to get the final value to place
840 and D D D D D to chop to right size
841 -----------------------
844 ... i i i i i o o o o o from bfd_get<size>
845 and N N N N N get instruction
846 -----------------------
852 -----------------------
853 R R R R R R R R R R put into bfd_put<size>
857 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
863 char x = bfd_get_8(abfd, (char *)data + addr);
865 bfd_put_8(abfd,x, (unsigned char *) data + addr);
872 short x = bfd_get_16(abfd, (bfd_byte *)data + addr);
874 bfd_put_16(abfd, x, (unsigned char *)data + addr);
880 long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
882 bfd_put_32 (abfd, x, (bfd_byte *)data + addr);
887 long x = bfd_get_32(abfd, (bfd_byte *) data + addr);
888 relocation = -relocation;
890 bfd_put_32(abfd,x, (bfd_byte *)data + addr);
902 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + addr);
904 bfd_put_64 (abfd, x, (bfd_byte *) data + addr);
911 return bfd_reloc_other;
917 /* This relocation routine is used by some of the backend linkers.
918 They do not construct asymbol or arelent structures, so there is no
919 reason for them to use bfd_perform_relocation. Also,
920 bfd_perform_relocation is so hacked up it is easier to write a new
921 function than to try to deal with it.
923 This routine does a final relocation. It should not be used when
924 generating relocateable output.
926 FIXME: This routine ignores any special_function in the HOWTO,
927 since the existing special_function values have been written for
928 bfd_perform_relocation.
930 HOWTO is the reloc howto information.
931 INPUT_BFD is the BFD which the reloc applies to.
932 INPUT_SECTION is the section which the reloc applies to.
933 CONTENTS is the contents of the section.
934 ADDRESS is the address of the reloc within INPUT_SECTION.
935 VALUE is the value of the symbol the reloc refers to.
936 ADDEND is the addend of the reloc. */
938 bfd_reloc_status_type
939 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
941 const reloc_howto_type *howto;
943 asection *input_section;
951 /* Sanity check the address. */
952 if (address > input_section->_cooked_size)
953 return bfd_reloc_outofrange;
955 /* This function assumes that we are dealing with a basic relocation
956 against a symbol. We want to compute the value of the symbol to
957 relocate to. This is just VALUE, the value of the symbol, plus
958 ADDEND, any addend associated with the reloc. */
959 relocation = value + addend;
961 /* If the relocation is PC relative, we want to set RELOCATION to
962 the distance between the symbol (currently in RELOCATION) and the
963 location we are relocating. Some targets (e.g., i386-aout)
964 arrange for the contents of the section to be the negative of the
965 offset of the location within the section; for such targets
966 pcrel_offset is false. Other targets (e.g., m88kbcs or ELF)
967 simply leave the contents of the section as zero; for such
968 targets pcrel_offset is true. If pcrel_offset is false we do not
969 need to subtract out the offset of the location within the
970 section (which is just ADDRESS). */
971 if (howto->pc_relative)
973 relocation -= (input_section->output_section->vma
974 + input_section->output_offset);
975 if (howto->pcrel_offset)
976 relocation -= address;
979 return _bfd_relocate_contents (howto, input_bfd, relocation,
983 /* Relocate a given location using a given value and howto. */
985 bfd_reloc_status_type
986 _bfd_relocate_contents (howto, input_bfd, relocation, location)
987 const reloc_howto_type *howto;
996 /* If the size is negative, negate RELOCATION. This isn't very
999 relocation = - relocation;
1001 /* Get the value we are going to relocate. */
1002 size = bfd_get_reloc_size (howto);
1009 x = bfd_get_8 (input_bfd, location);
1012 x = bfd_get_16 (input_bfd, location);
1015 x = bfd_get_32 (input_bfd, location);
1019 x = bfd_get_64 (input_bfd, location);
1026 /* Check for overflow. FIXME: We may drop bits during the addition
1027 which we don't check for. We must either check at every single
1028 operation, which would be tedious, or we must do the computations
1029 in a type larger than bfd_vma, which would be inefficient. */
1031 if (howto->complain_on_overflow != complain_overflow_dont)
1034 bfd_signed_vma signed_check;
1036 bfd_signed_vma signed_add;
1038 if (howto->rightshift == 0)
1041 signed_check = (bfd_signed_vma) relocation;
1045 /* Drop unwanted bits from the value we are relocating to. */
1046 check = relocation >> howto->rightshift;
1048 /* If this is a signed value, the rightshift just dropped
1049 leading 1 bits (assuming twos complement). */
1050 if ((bfd_signed_vma) relocation >= 0)
1051 signed_check = check;
1053 signed_check = (check
1055 &~ ((bfd_vma) -1 >> howto->rightshift)));
1058 /* Get the value from the object file. */
1059 add = x & howto->src_mask;
1061 /* Get the value from the object file with an appropriate sign.
1062 The expression involving howto->src_mask isolates the upper
1063 bit of src_mask. If that bit is set in the value we are
1064 adding, it is negative, and we subtract out that number times
1065 two. If src_mask includes the highest possible bit, then we
1066 can not get the upper bit, but that does not matter since
1067 signed_add needs no adjustment to become negative in that
1070 if ((add & (((~ howto->src_mask) >> 1) & howto->src_mask)) != 0)
1071 signed_add -= (((~ howto->src_mask) >> 1) & howto->src_mask) << 1;
1073 /* Add the value from the object file, shifted so that it is a
1075 if (howto->bitpos == 0)
1078 signed_check += signed_add;
1082 check += add >> howto->bitpos;
1084 /* For the signed case we use ADD, rather than SIGNED_ADD,
1085 to avoid warnings from SVR4 cc. This is OK since we
1086 explictly handle the sign bits. */
1087 if (signed_add >= 0)
1088 signed_check += add >> howto->bitpos;
1090 signed_check += ((add >> howto->bitpos)
1092 &~ ((bfd_vma) -1 >> howto->bitpos)));
1095 switch (howto->complain_on_overflow)
1097 case complain_overflow_signed:
1099 /* Assumes two's complement. */
1100 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1101 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1103 if (signed_check > reloc_signed_max
1104 || signed_check < reloc_signed_min)
1108 case complain_overflow_unsigned:
1110 /* Assumes two's complement. This expression avoids
1111 overflow if howto->bitsize is the number of bits in
1113 bfd_vma reloc_unsigned_max =
1114 (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1116 if (check > reloc_unsigned_max)
1120 case complain_overflow_bitfield:
1122 /* Assumes two's complement. This expression avoids
1123 overflow if howto->bitsize is the number of bits in
1125 bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1127 if ((check &~ reloc_bits) != 0
1128 && (((bfd_vma) signed_check &~ reloc_bits)
1129 != (-1 &~ reloc_bits)))
1138 /* Put RELOCATION in the right bits. */
1139 relocation >>= (bfd_vma) howto->rightshift;
1140 relocation <<= (bfd_vma) howto->bitpos;
1142 /* Add RELOCATION to the right bits of X. */
1143 x = ((x &~ howto->dst_mask)
1144 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1146 /* Put the relocated value back in the object file. */
1153 bfd_put_8 (input_bfd, x, location);
1156 bfd_put_16 (input_bfd, x, location);
1159 bfd_put_32 (input_bfd, x, location);
1163 bfd_put_64 (input_bfd, x, location);
1170 return overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1176 howto manager, , typedef arelent, Relocations
1181 When an application wants to create a relocation, but doesn't
1182 know what the target machine might call it, it can find out by
1183 using this bit of code.
1192 The insides of a reloc code. The idea is that, eventually, there
1193 will be one enumerator for every type of relocation we ever do.
1194 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1195 return a howto pointer.
1197 This does mean that the application must determine the correct
1198 enumerator value; you can't get a howto pointer from a random set
1203 .typedef enum bfd_reloc_code_real
1205 . {* Basic absolute relocations *}
1212 . {* PC-relative relocations *}
1213 . BFD_RELOC_64_PCREL,
1214 . BFD_RELOC_32_PCREL,
1215 . BFD_RELOC_24_PCREL, {* used by i960 *}
1216 . BFD_RELOC_16_PCREL,
1217 . BFD_RELOC_8_PCREL,
1219 . {* Linkage-table relative *}
1220 . BFD_RELOC_32_BASEREL,
1221 . BFD_RELOC_16_BASEREL,
1222 . BFD_RELOC_8_BASEREL,
1224 . {* The type of reloc used to build a contructor table - at the moment
1225 . probably a 32 bit wide abs address, but the cpu can choose. *}
1228 . {* 8 bits wide, but used to form an address like 0xffnn *}
1231 . {* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit
1232 . word displacement, e.g. for SPARC) *}
1233 . BFD_RELOC_32_PCREL_S2,
1234 . {* signed 16-bit pc-relative, shifted right 2 bits (e.g. for MIPS) *}
1235 . BFD_RELOC_16_PCREL_S2,
1236 . {* this is used on the Alpha *}
1237 . BFD_RELOC_23_PCREL_S2,
1239 . {* High 22 bits of 32-bit value, placed into lower 22 bits of
1240 . target word; simple reloc. *}
1242 . {* Low 10 bits. *}
1245 . {* For systems that allocate a Global Pointer register, these are
1246 . displacements off that register. These relocation types are
1247 . handled specially, because the value the register will have is
1248 . decided relatively late. *}
1249 . BFD_RELOC_GPREL16,
1250 . BFD_RELOC_GPREL32,
1252 . {* Reloc types used for i960/b.out. *}
1253 . BFD_RELOC_I960_CALLJ,
1255 . {* now for the sparc/elf codes *}
1256 . BFD_RELOC_NONE, {* actually used *}
1257 . BFD_RELOC_SPARC_WDISP22,
1258 . BFD_RELOC_SPARC22,
1259 . BFD_RELOC_SPARC13,
1260 . BFD_RELOC_SPARC_GOT10,
1261 . BFD_RELOC_SPARC_GOT13,
1262 . BFD_RELOC_SPARC_GOT22,
1263 . BFD_RELOC_SPARC_PC10,
1264 . BFD_RELOC_SPARC_PC22,
1265 . BFD_RELOC_SPARC_WPLT30,
1266 . BFD_RELOC_SPARC_COPY,
1267 . BFD_RELOC_SPARC_GLOB_DAT,
1268 . BFD_RELOC_SPARC_JMP_SLOT,
1269 . BFD_RELOC_SPARC_RELATIVE,
1270 . BFD_RELOC_SPARC_UA32,
1272 . {* these are a.out specific? *}
1273 . BFD_RELOC_SPARC_BASE13,
1274 . BFD_RELOC_SPARC_BASE22,
1276 . {* start-sanitize-v9 *}
1277 . BFD_RELOC_SPARC_10,
1278 . BFD_RELOC_SPARC_11,
1279 .#define BFD_RELOC_SPARC_64 BFD_RELOC_64
1280 . BFD_RELOC_SPARC_OLO10,
1281 . BFD_RELOC_SPARC_HH22,
1282 . BFD_RELOC_SPARC_HM10,
1283 . BFD_RELOC_SPARC_LM22,
1284 . BFD_RELOC_SPARC_PC_HH22,
1285 . BFD_RELOC_SPARC_PC_HM10,
1286 . BFD_RELOC_SPARC_PC_LM22,
1287 . BFD_RELOC_SPARC_WDISP16,
1288 . BFD_RELOC_SPARC_WDISP19,
1289 . BFD_RELOC_SPARC_GLOB_JMP,
1290 . BFD_RELOC_SPARC_LO7,
1291 . {* end-sanitize-v9 *}
1293 . {* Alpha ECOFF relocations. Some of these treat the symbol or "addend"
1294 . in some special way. *}
1295 . {* For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1296 . writing; when reading, it will be the absolute section symbol. The
1297 . addend is the displacement in bytes of the "lda" instruction from
1298 . the "ldah" instruction (which is at the address of this reloc). *}
1299 . BFD_RELOC_ALPHA_GPDISP_HI16,
1300 . {* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1301 . with GPDISP_HI16 relocs. The addend is ignored when writing the
1302 . relocations out, and is filled in with the file's GP value on
1303 . reading, for convenience. *}
1304 . BFD_RELOC_ALPHA_GPDISP_LO16,
1306 . {* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1307 . the assembler turns it into a LDQ instruction to load the address of
1308 . the symbol, and then fills in a register in the real instruction.
1310 . The LITERAL reloc, at the LDQ instruction, refers to the .lita
1311 . section symbol. The addend is ignored when writing, but is filled
1312 . in with the file's GP value on reading, for convenience, as with the
1313 . GPDISP_LO16 reloc.
1315 . The LITUSE reloc, on the instruction using the loaded address, gives
1316 . information to the linker that it might be able to use to optimize
1317 . away some literal section references. The symbol is ignored (read
1318 . as the absolute section symbol), and the "addend" indicates the type
1319 . of instruction using the register:
1320 . 1 - "memory" fmt insn
1321 . 2 - byte-manipulation (byte offset reg)
1322 . 3 - jsr (target of branch)
1324 . The GNU linker currently doesn't do any of this optimizing. *}
1325 . BFD_RELOC_ALPHA_LITERAL,
1326 . BFD_RELOC_ALPHA_LITUSE,
1328 . {* The HINT relocation indicates a value that should be filled into the
1329 . "hint" field of a jmp/jsr/ret instruction, for possible branch-
1330 . prediction logic which may be provided on some processors. *}
1331 . BFD_RELOC_ALPHA_HINT,
1333 . {* Bits 27..2 of the relocation address shifted right 2 bits;
1334 . simple reloc otherwise. *}
1335 . BFD_RELOC_MIPS_JMP,
1337 . {* High 16 bits of 32-bit value; simple reloc. *}
1339 . {* High 16 bits of 32-bit value but the low 16 bits will be sign
1340 . extended and added to form the final result. If the low 16
1341 . bits form a negative number, we need to add one to the high value
1342 . to compensate for the borrow when the low bits are added. *}
1344 . {* Low 16 bits. *}
1347 . {* relocation relative to the global pointer. *}
1348 .#define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16
1350 . {* Relocation against a MIPS literal section. *}
1351 . BFD_RELOC_MIPS_LITERAL,
1353 . {* MIPS ELF relocations. *}
1354 . BFD_RELOC_MIPS_GOT16,
1355 . BFD_RELOC_MIPS_CALL16,
1356 .#define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32
1358 . {* These are, so far, specific to HPPA processors. I'm not sure that some
1359 . don't duplicate other reloc types, such as BFD_RELOC_32 and _32_PCREL.
1360 . Also, many more were in the list I got that don't fit in well in the
1361 . model BFD uses, so I've omitted them for now. If we do make this reloc
1362 . type get used for code that really does implement the funky reloc types,
1363 . they'll have to be added to this list. *}
1364 . BFD_RELOC_HPPA_32,
1365 . BFD_RELOC_HPPA_11,
1366 . BFD_RELOC_HPPA_14,
1367 . BFD_RELOC_HPPA_17,
1369 . BFD_RELOC_HPPA_L21,
1370 . BFD_RELOC_HPPA_R11,
1371 . BFD_RELOC_HPPA_R14,
1372 . BFD_RELOC_HPPA_R17,
1373 . BFD_RELOC_HPPA_LS21,
1374 . BFD_RELOC_HPPA_RS11,
1375 . BFD_RELOC_HPPA_RS14,
1376 . BFD_RELOC_HPPA_RS17,
1377 . BFD_RELOC_HPPA_LD21,
1378 . BFD_RELOC_HPPA_RD11,
1379 . BFD_RELOC_HPPA_RD14,
1380 . BFD_RELOC_HPPA_RD17,
1381 . BFD_RELOC_HPPA_LR21,
1382 . BFD_RELOC_HPPA_RR14,
1383 . BFD_RELOC_HPPA_RR17,
1385 . BFD_RELOC_HPPA_GOTOFF_11,
1386 . BFD_RELOC_HPPA_GOTOFF_14,
1387 . BFD_RELOC_HPPA_GOTOFF_L21,
1388 . BFD_RELOC_HPPA_GOTOFF_R11,
1389 . BFD_RELOC_HPPA_GOTOFF_R14,
1390 . BFD_RELOC_HPPA_GOTOFF_LS21,
1391 . BFD_RELOC_HPPA_GOTOFF_RS11,
1392 . BFD_RELOC_HPPA_GOTOFF_RS14,
1393 . BFD_RELOC_HPPA_GOTOFF_LD21,
1394 . BFD_RELOC_HPPA_GOTOFF_RD11,
1395 . BFD_RELOC_HPPA_GOTOFF_RD14,
1396 . BFD_RELOC_HPPA_GOTOFF_LR21,
1397 . BFD_RELOC_HPPA_GOTOFF_RR14,
1399 . BFD_RELOC_HPPA_DLT_32,
1400 . BFD_RELOC_HPPA_DLT_11,
1401 . BFD_RELOC_HPPA_DLT_14,
1402 . BFD_RELOC_HPPA_DLT_L21,
1403 . BFD_RELOC_HPPA_DLT_R11,
1404 . BFD_RELOC_HPPA_DLT_R14,
1406 . BFD_RELOC_HPPA_ABS_CALL_11,
1407 . BFD_RELOC_HPPA_ABS_CALL_14,
1408 . BFD_RELOC_HPPA_ABS_CALL_17,
1409 . BFD_RELOC_HPPA_ABS_CALL_L21,
1410 . BFD_RELOC_HPPA_ABS_CALL_R11,
1411 . BFD_RELOC_HPPA_ABS_CALL_R14,
1412 . BFD_RELOC_HPPA_ABS_CALL_R17,
1413 . BFD_RELOC_HPPA_ABS_CALL_LS21,
1414 . BFD_RELOC_HPPA_ABS_CALL_RS11,
1415 . BFD_RELOC_HPPA_ABS_CALL_RS14,
1416 . BFD_RELOC_HPPA_ABS_CALL_RS17,
1417 . BFD_RELOC_HPPA_ABS_CALL_LD21,
1418 . BFD_RELOC_HPPA_ABS_CALL_RD11,
1419 . BFD_RELOC_HPPA_ABS_CALL_RD14,
1420 . BFD_RELOC_HPPA_ABS_CALL_RD17,
1421 . BFD_RELOC_HPPA_ABS_CALL_LR21,
1422 . BFD_RELOC_HPPA_ABS_CALL_RR14,
1423 . BFD_RELOC_HPPA_ABS_CALL_RR17,
1425 . BFD_RELOC_HPPA_PCREL_CALL_11,
1426 . BFD_RELOC_HPPA_PCREL_CALL_12,
1427 . BFD_RELOC_HPPA_PCREL_CALL_14,
1428 . BFD_RELOC_HPPA_PCREL_CALL_17,
1429 . BFD_RELOC_HPPA_PCREL_CALL_L21,
1430 . BFD_RELOC_HPPA_PCREL_CALL_R11,
1431 . BFD_RELOC_HPPA_PCREL_CALL_R14,
1432 . BFD_RELOC_HPPA_PCREL_CALL_R17,
1433 . BFD_RELOC_HPPA_PCREL_CALL_LS21,
1434 . BFD_RELOC_HPPA_PCREL_CALL_RS11,
1435 . BFD_RELOC_HPPA_PCREL_CALL_RS14,
1436 . BFD_RELOC_HPPA_PCREL_CALL_RS17,
1437 . BFD_RELOC_HPPA_PCREL_CALL_LD21,
1438 . BFD_RELOC_HPPA_PCREL_CALL_RD11,
1439 . BFD_RELOC_HPPA_PCREL_CALL_RD14,
1440 . BFD_RELOC_HPPA_PCREL_CALL_RD17,
1441 . BFD_RELOC_HPPA_PCREL_CALL_LR21,
1442 . BFD_RELOC_HPPA_PCREL_CALL_RR14,
1443 . BFD_RELOC_HPPA_PCREL_CALL_RR17,
1445 . BFD_RELOC_HPPA_PLABEL_32,
1446 . BFD_RELOC_HPPA_PLABEL_11,
1447 . BFD_RELOC_HPPA_PLABEL_14,
1448 . BFD_RELOC_HPPA_PLABEL_L21,
1449 . BFD_RELOC_HPPA_PLABEL_R11,
1450 . BFD_RELOC_HPPA_PLABEL_R14,
1452 . BFD_RELOC_HPPA_UNWIND_ENTRY,
1453 . BFD_RELOC_HPPA_UNWIND_ENTRIES,
1455 . {* i386/elf relocations *}
1456 . BFD_RELOC_386_GOT32,
1457 . BFD_RELOC_386_PLT32,
1458 . BFD_RELOC_386_COPY,
1459 . BFD_RELOC_386_GLOB_DAT,
1460 . BFD_RELOC_386_JUMP_SLOT,
1461 . BFD_RELOC_386_RELATIVE,
1462 . BFD_RELOC_386_GOTOFF,
1463 . BFD_RELOC_386_GOTPC,
1465 . {* PowerPC/POWER (RS/6000) relocs. *}
1466 . {* 26 bit relative branch. Low two bits must be zero. High 24
1467 . bits installed in bits 6 through 29 of instruction. *}
1468 . BFD_RELOC_PPC_B26,
1469 . {* 26 bit absolute branch, like BFD_RELOC_PPC_B26 but absolute. *}
1470 . BFD_RELOC_PPC_BA26,
1471 . {* 16 bit TOC relative reference. *}
1472 . BFD_RELOC_PPC_TOC16,
1474 . {* this must be the highest numeric value *}
1476 . } bfd_reloc_code_real_type;
1482 bfd_reloc_type_lookup
1485 const struct reloc_howto_struct *
1486 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
1489 Return a pointer to a howto structure which, when
1490 invoked, will perform the relocation @var{code} on data from the
1496 const struct reloc_howto_struct *
1497 DEFUN(bfd_reloc_type_lookup,(abfd, code),
1499 bfd_reloc_code_real_type code)
1501 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
1504 static reloc_howto_type bfd_howto_32 =
1505 HOWTO(0, 00,2,32,false,0,complain_overflow_bitfield,0,"VRT32", false,0xffffffff,0xffffffff,true);
1510 bfd_default_reloc_type_lookup
1513 const struct reloc_howto_struct *bfd_default_reloc_type_lookup
1515 bfd_reloc_code_real_type code);
1518 Provides a default relocation lookup routine for any architecture.
1523 const struct reloc_howto_struct *
1524 DEFUN(bfd_default_reloc_type_lookup, (abfd, code),
1526 bfd_reloc_code_real_type code)
1530 case BFD_RELOC_CTOR:
1531 /* The type of reloc used in a ctor, which will be as wide as the
1532 address - so either a 64, 32, or 16 bitter. */
1533 switch (bfd_get_arch_info (abfd)->bits_per_address) {
1537 return &bfd_howto_32;
1546 return (const struct reloc_howto_struct *)NULL;
1552 bfd_generic_relax_section
1555 boolean bfd_generic_relax_section
1558 struct bfd_link_info *,
1562 Provides default handling for relaxing for back ends which
1563 don't do relaxing -- i.e., does nothing.
1568 bfd_generic_relax_section (abfd, section, link_info, symbols)
1571 struct bfd_link_info *link_info;
1579 bfd_generic_get_relocated_section_contents
1583 bfd_generic_get_relocated_section_contents (bfd *abfd,
1584 struct bfd_link_info *link_info,
1585 struct bfd_link_order *link_order,
1587 boolean relocateable,
1591 Provides default handling of relocation effort for back ends
1592 which can't be bothered to do it efficiently.
1597 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
1598 relocateable, symbols)
1600 struct bfd_link_info *link_info;
1601 struct bfd_link_order *link_order;
1603 boolean relocateable;
1606 /* Get enough memory to hold the stuff */
1607 bfd *input_bfd = link_order->u.indirect.section->owner;
1608 asection *input_section = link_order->u.indirect.section;
1612 size_t reloc_size = bfd_get_reloc_upper_bound(input_bfd, input_section);
1613 arelent **reloc_vector = (arelent **) alloca(reloc_size);
1615 /* read in the section */
1616 bfd_get_section_contents(input_bfd,
1620 input_section->_raw_size);
1622 /* We're not relaxing the section, so just copy the size info */
1623 input_section->_cooked_size = input_section->_raw_size;
1624 input_section->reloc_done = true;
1627 if (bfd_canonicalize_reloc(input_bfd,
1633 for (parent = reloc_vector; * parent != (arelent *)NULL;
1636 char *error_message = (char *) NULL;
1637 bfd_reloc_status_type r=
1638 bfd_perform_relocation(input_bfd,
1642 relocateable ? abfd : (bfd *) NULL,
1647 asection *os = input_section->output_section;
1649 /* A partial link, so keep the relocs */
1650 os->orelocation[os->reloc_count] = *parent;
1654 if (r != bfd_reloc_ok)
1658 case bfd_reloc_undefined:
1659 if (! ((*link_info->callbacks->undefined_symbol)
1660 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
1661 input_bfd, input_section, (*parent)->address)))
1664 case bfd_reloc_dangerous:
1665 BFD_ASSERT (error_message != (char *) NULL);
1666 if (! ((*link_info->callbacks->reloc_dangerous)
1667 (link_info, error_message, input_bfd, input_section,
1668 (*parent)->address)))
1671 case bfd_reloc_overflow:
1672 if (! ((*link_info->callbacks->reloc_overflow)
1673 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
1674 (*parent)->howto->name, (*parent)->addend,
1675 input_bfd, input_section, (*parent)->address)))
1678 case bfd_reloc_outofrange: