1 /* BFD support for handling relocation entries.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 BFD maintains relocations in much the same way it maintains
27 symbols: they are left alone until required, then read in
28 en-masse and translated into an internal form. A common
29 routine <<bfd_perform_relocation>> acts upon the
30 canonical form to do the fixup.
32 Relocations are maintained on a per section basis,
33 while symbols are maintained on a per BFD basis.
35 All that a back end has to do to fit the BFD interface is to create
36 a <<struct reloc_cache_entry>> for each relocation
37 in a particular section, and fill in the right bits of the structures.
46 /* DO compile in the reloc_code name table from libbfd.h. */
47 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
56 typedef arelent, howto manager, Relocations, Relocations
61 This is the structure of a relocation entry:
65 .typedef enum bfd_reloc_status
67 . {* No errors detected *}
70 . {* The relocation was performed, but there was an overflow. *}
73 . {* The address to relocate was not within the section supplied. *}
74 . bfd_reloc_outofrange,
76 . {* Used by special functions *}
79 . {* Unsupported relocation size requested. *}
80 . bfd_reloc_notsupported,
85 . {* The symbol to relocate against was undefined. *}
86 . bfd_reloc_undefined,
88 . {* The relocation was performed, but may not be ok - presently
89 . generated only when linking i960 coff files with i960 b.out
90 . symbols. If this type is returned, the error_message argument
91 . to bfd_perform_relocation will be set. *}
94 . bfd_reloc_status_type;
97 .typedef struct reloc_cache_entry
99 . {* A pointer into the canonical table of pointers *}
100 . struct symbol_cache_entry **sym_ptr_ptr;
102 . {* offset in section *}
103 . bfd_size_type address;
105 . {* addend for relocation value *}
108 . {* Pointer to how to perform the required relocation *}
109 . reloc_howto_type *howto;
118 Here is a description of each of the fields within an <<arelent>>:
122 The symbol table pointer points to a pointer to the symbol
123 associated with the relocation request. It is
124 the pointer into the table returned by the back end's
125 <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
126 through a pointer to a pointer so that tools like the linker
127 can fix up all the symbols of the same name by modifying only
128 one pointer. The relocation routine looks in the symbol and
129 uses the base of the section the symbol is attached to and the
130 value of the symbol as the initial relocation offset. If the
131 symbol pointer is zero, then the section provided is looked up.
135 The <<address>> field gives the offset in bytes from the base of
136 the section data which owns the relocation record to the first
137 byte of relocatable information. The actual data relocated
138 will be relative to this point; for example, a relocation
139 type which modifies the bottom two bytes of a four byte word
140 would not touch the first byte pointed to in a big endian
145 The <<addend>> is a value provided by the back end to be added (!)
146 to the relocation offset. Its interpretation is dependent upon
147 the howto. For example, on the 68k the code:
153 | return foo[0x12345678];
156 Could be compiled into:
159 | moveb @@#12345678,d0
165 This could create a reloc pointing to <<foo>>, but leave the
166 offset in the data, something like:
169 |RELOCATION RECORDS FOR [.text]:
173 |00000000 4e56 fffc ; linkw fp,#-4
174 |00000004 1039 1234 5678 ; moveb @@#12345678,d0
175 |0000000a 49c0 ; extbl d0
176 |0000000c 4e5e ; unlk fp
180 Using coff and an 88k, some instructions don't have enough
181 space in them to represent the full address range, and
182 pointers have to be loaded in two parts. So you'd get something like:
185 | or.u r13,r0,hi16(_foo+0x12345678)
186 | ld.b r2,r13,lo16(_foo+0x12345678)
190 This should create two relocs, both pointing to <<_foo>>, and with
191 0x12340000 in their addend field. The data would consist of:
194 |RELOCATION RECORDS FOR [.text]:
196 |00000002 HVRT16 _foo+0x12340000
197 |00000006 LVRT16 _foo+0x12340000
199 |00000000 5da05678 ; or.u r13,r0,0x5678
200 |00000004 1c4d5678 ; ld.b r2,r13,0x5678
201 |00000008 f400c001 ; jmp r1
204 The relocation routine digs out the value from the data, adds
205 it to the addend to get the original offset, and then adds the
206 value of <<_foo>>. Note that all 32 bits have to be kept around
207 somewhere, to cope with carry from bit 15 to bit 16.
209 One further example is the sparc and the a.out format. The
210 sparc has a similar problem to the 88k, in that some
211 instructions don't have room for an entire offset, but on the
212 sparc the parts are created in odd sized lumps. The designers of
213 the a.out format chose to not use the data within the section
214 for storing part of the offset; all the offset is kept within
215 the reloc. Anything in the data should be ignored.
218 | sethi %hi(_foo+0x12345678),%g2
219 | ldsb [%g2+%lo(_foo+0x12345678)],%i0
223 Both relocs contain a pointer to <<foo>>, and the offsets
227 |RELOCATION RECORDS FOR [.text]:
229 |00000004 HI22 _foo+0x12345678
230 |00000008 LO10 _foo+0x12345678
232 |00000000 9de3bf90 ; save %sp,-112,%sp
233 |00000004 05000000 ; sethi %hi(_foo+0),%g2
234 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0
235 |0000000c 81c7e008 ; ret
236 |00000010 81e80000 ; restore
241 The <<howto>> field can be imagined as a
242 relocation instruction. It is a pointer to a structure which
243 contains information on what to do with all of the other
244 information in the reloc record and data section. A back end
245 would normally have a relocation instruction set and turn
246 relocations into pointers to the correct structure on input -
247 but it would be possible to create each howto field on demand.
253 <<enum complain_overflow>>
255 Indicates what sort of overflow checking should be done when
256 performing a relocation.
260 .enum complain_overflow
262 . {* Do not complain on overflow. *}
263 . complain_overflow_dont,
265 . {* Complain if the bitfield overflows, whether it is considered
266 . as signed or unsigned. *}
267 . complain_overflow_bitfield,
269 . {* Complain if the value overflows when considered as signed
271 . complain_overflow_signed,
273 . {* Complain if the value overflows when considered as an
274 . unsigned number. *}
275 . complain_overflow_unsigned
284 The <<reloc_howto_type>> is a structure which contains all the
285 information that libbfd needs to know to tie up a back end's data.
288 .struct symbol_cache_entry; {* Forward declaration *}
290 .struct reloc_howto_struct
292 . {* The type field has mainly a documentary use - the back end can
293 . do what it wants with it, though normally the back end's
294 . external idea of what a reloc number is stored
295 . in this field. For example, a PC relative word relocation
296 . in a coff environment has the type 023 - because that's
297 . what the outside world calls a R_PCRWORD reloc. *}
300 . {* The value the final relocation is shifted right by. This drops
301 . unwanted data from the relocation. *}
302 . unsigned int rightshift;
304 . {* The size of the item to be relocated. This is *not* a
305 . power-of-two measure. To get the number of bytes operated
306 . on by a type of relocation, use bfd_get_reloc_size. *}
309 . {* The number of bits in the item to be relocated. This is used
310 . when doing overflow checking. *}
311 . unsigned int bitsize;
313 . {* Notes that the relocation is relative to the location in the
314 . data section of the addend. The relocation function will
315 . subtract from the relocation value the address of the location
316 . being relocated. *}
317 . boolean pc_relative;
319 . {* The bit position of the reloc value in the destination.
320 . The relocated value is left shifted by this amount. *}
321 . unsigned int bitpos;
323 . {* What type of overflow error should be checked for when
325 . enum complain_overflow complain_on_overflow;
327 . {* If this field is non null, then the supplied function is
328 . called rather than the normal function. This allows really
329 . strange relocation methods to be accomodated (e.g., i960 callj
331 . bfd_reloc_status_type (*special_function)
332 . PARAMS ((bfd *abfd,
333 . arelent *reloc_entry,
334 . struct symbol_cache_entry *symbol,
336 . asection *input_section,
338 . char **error_message));
340 . {* The textual name of the relocation type. *}
343 . {* Some formats record a relocation addend in the section contents
344 . rather than with the relocation. For ELF formats this is the
345 . distinction between USE_REL and USE_RELA (though the code checks
346 . for USE_REL == 1/0). The value of this field is TRUE if the
347 . addend is recorded with the section contents; when performing a
348 . partial link (ld -r) the section contents (the data) will be
349 . modified. The value of this field is FALSE if addends are
350 . recorded with the relocation (in arelent.addend); when performing
351 . a partial link the relocation will be modified.
352 . All relocations for all ELF USE_RELA targets should set this field
353 . to FALSE (values of TRUE should be looked on with suspicion).
354 . However, the converse is not true: not all relocations of all ELF
355 . USE_REL targets set this field to TRUE. Why this is so is peculiar
356 . to each particular target. For relocs that aren't used in partial
357 . links (e.g. GOT stuff) it doesn't matter what this is set to. *}
358 . boolean partial_inplace;
360 . {* The src_mask selects which parts of the read in data
361 . are to be used in the relocation sum. E.g., if this was an 8 bit
362 . byte of data which we read and relocated, this would be
363 . 0x000000ff. When we have relocs which have an addend, such as
364 . sun4 extended relocs, the value in the offset part of a
365 . relocating field is garbage so we never use it. In this case
366 . the mask would be 0x00000000. *}
369 . {* The dst_mask selects which parts of the instruction are replaced
370 . into the instruction. In most cases src_mask == dst_mask,
371 . except in the above special case, where dst_mask would be
372 . 0x000000ff, and src_mask would be 0x00000000. *}
375 . {* When some formats create PC relative instructions, they leave
376 . the value of the pc of the place being relocated in the offset
377 . slot of the instruction, so that a PC relative relocation can
378 . be made just by adding in an ordinary offset (e.g., sun3 a.out).
379 . Some formats leave the displacement part of an instruction
380 . empty (e.g., m88k bcs); this flag signals the fact.*}
381 . boolean pcrel_offset;
392 The HOWTO define is horrible and will go away.
395 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
396 . {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
399 And will be replaced with the totally magic way. But for the
400 moment, we are compatible, so do it this way.
403 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
407 This is used to fill in an empty howto entry in an array.
409 .#define EMPTY_HOWTO(C) \
410 . HOWTO((C),0,0,0,false,0,complain_overflow_dont,NULL,NULL,false,0,0,false)
414 Helper routine to turn a symbol into a relocation value.
416 .#define HOWTO_PREPARE(relocation, symbol) \
418 . if (symbol != (asymbol *)NULL) { \
419 . if (bfd_is_com_section (symbol->section)) { \
423 . relocation = symbol->value; \
435 unsigned int bfd_get_reloc_size (reloc_howto_type *);
438 For a reloc_howto_type that operates on a fixed number of bytes,
439 this returns the number of bytes operated on.
443 bfd_get_reloc_size (howto)
444 reloc_howto_type *howto;
465 How relocs are tied together in an <<asection>>:
467 .typedef struct relent_chain {
469 . struct relent_chain *next;
474 /* N_ONES produces N one bits, without overflowing machine arithmetic. */
475 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
482 bfd_reloc_status_type
484 (enum complain_overflow how,
485 unsigned int bitsize,
486 unsigned int rightshift,
487 unsigned int addrsize,
491 Perform overflow checking on @var{relocation} which has
492 @var{bitsize} significant bits and will be shifted right by
493 @var{rightshift} bits, on a machine with addresses containing
494 @var{addrsize} significant bits. The result is either of
495 @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
499 bfd_reloc_status_type
500 bfd_check_overflow (how, bitsize, rightshift, addrsize, relocation)
501 enum complain_overflow how;
502 unsigned int bitsize;
503 unsigned int rightshift;
504 unsigned int addrsize;
507 bfd_vma fieldmask, addrmask, signmask, ss, a;
508 bfd_reloc_status_type flag = bfd_reloc_ok;
512 /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
513 we'll be permissive: extra bits in the field mask will
514 automatically extend the address mask for purposes of the
516 fieldmask = N_ONES (bitsize);
517 addrmask = N_ONES (addrsize) | fieldmask;
521 case complain_overflow_dont:
524 case complain_overflow_signed:
525 /* If any sign bits are set, all sign bits must be set. That
526 is, A must be a valid negative address after shifting. */
527 a = (a & addrmask) >> rightshift;
528 signmask = ~ (fieldmask >> 1);
530 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
531 flag = bfd_reloc_overflow;
534 case complain_overflow_unsigned:
535 /* We have an overflow if the address does not fit in the field. */
536 a = (a & addrmask) >> rightshift;
537 if ((a & ~ fieldmask) != 0)
538 flag = bfd_reloc_overflow;
541 case complain_overflow_bitfield:
542 /* Bitfields are sometimes signed, sometimes unsigned. We
543 explicitly allow an address wrap too, which means a bitfield
544 of n bits is allowed to store -2**n to 2**n-1. Thus overflow
545 if the value has some, but not all, bits set outside the
548 ss = a & ~ fieldmask;
549 if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & ~ fieldmask))
550 flag = bfd_reloc_overflow;
562 bfd_perform_relocation
565 bfd_reloc_status_type
566 bfd_perform_relocation
568 arelent *reloc_entry,
570 asection *input_section,
572 char **error_message);
575 If @var{output_bfd} is supplied to this function, the
576 generated image will be relocatable; the relocations are
577 copied to the output file after they have been changed to
578 reflect the new state of the world. There are two ways of
579 reflecting the results of partial linkage in an output file:
580 by modifying the output data in place, and by modifying the
581 relocation record. Some native formats (e.g., basic a.out and
582 basic coff) have no way of specifying an addend in the
583 relocation type, so the addend has to go in the output data.
584 This is no big deal since in these formats the output data
585 slot will always be big enough for the addend. Complex reloc
586 types with addends were invented to solve just this problem.
587 The @var{error_message} argument is set to an error message if
588 this return @code{bfd_reloc_dangerous}.
593 bfd_reloc_status_type
594 bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
597 arelent *reloc_entry;
599 asection *input_section;
601 char **error_message;
604 bfd_reloc_status_type flag = bfd_reloc_ok;
605 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
606 bfd_vma output_base = 0;
607 reloc_howto_type *howto = reloc_entry->howto;
608 asection *reloc_target_output_section;
611 symbol = *(reloc_entry->sym_ptr_ptr);
612 if (bfd_is_abs_section (symbol->section)
613 && output_bfd != (bfd *) NULL)
615 reloc_entry->address += input_section->output_offset;
619 /* If we are not producing relocateable output, return an error if
620 the symbol is not defined. An undefined weak symbol is
621 considered to have a value of zero (SVR4 ABI, p. 4-27). */
622 if (bfd_is_und_section (symbol->section)
623 && (symbol->flags & BSF_WEAK) == 0
624 && output_bfd == (bfd *) NULL)
625 flag = bfd_reloc_undefined;
627 /* If there is a function supplied to handle this relocation type,
628 call it. It'll return `bfd_reloc_continue' if further processing
630 if (howto->special_function)
632 bfd_reloc_status_type cont;
633 cont = howto->special_function (abfd, reloc_entry, symbol, data,
634 input_section, output_bfd,
636 if (cont != bfd_reloc_continue)
640 /* Is the address of the relocation really within the section? */
641 if (reloc_entry->address > input_section->_cooked_size /
642 bfd_octets_per_byte (abfd))
643 return bfd_reloc_outofrange;
645 /* Work out which section the relocation is targetted at and the
646 initial relocation command value. */
648 /* Get symbol value. (Common symbols are special.) */
649 if (bfd_is_com_section (symbol->section))
652 relocation = symbol->value;
655 reloc_target_output_section = symbol->section->output_section;
657 /* Convert input-section-relative symbol value to absolute. */
658 if (output_bfd && howto->partial_inplace == false)
661 output_base = reloc_target_output_section->vma;
663 relocation += output_base + symbol->section->output_offset;
665 /* Add in supplied addend. */
666 relocation += reloc_entry->addend;
668 /* Here the variable relocation holds the final address of the
669 symbol we are relocating against, plus any addend. */
671 if (howto->pc_relative == true)
673 /* This is a PC relative relocation. We want to set RELOCATION
674 to the distance between the address of the symbol and the
675 location. RELOCATION is already the address of the symbol.
677 We start by subtracting the address of the section containing
680 If pcrel_offset is set, we must further subtract the position
681 of the location within the section. Some targets arrange for
682 the addend to be the negative of the position of the location
683 within the section; for example, i386-aout does this. For
684 i386-aout, pcrel_offset is false. Some other targets do not
685 include the position of the location; for example, m88kbcs,
686 or ELF. For those targets, pcrel_offset is true.
688 If we are producing relocateable output, then we must ensure
689 that this reloc will be correctly computed when the final
690 relocation is done. If pcrel_offset is false we want to wind
691 up with the negative of the location within the section,
692 which means we must adjust the existing addend by the change
693 in the location within the section. If pcrel_offset is true
694 we do not want to adjust the existing addend at all.
696 FIXME: This seems logical to me, but for the case of
697 producing relocateable output it is not what the code
698 actually does. I don't want to change it, because it seems
699 far too likely that something will break. */
702 input_section->output_section->vma + input_section->output_offset;
704 if (howto->pcrel_offset == true)
705 relocation -= reloc_entry->address;
708 if (output_bfd != (bfd *) NULL)
710 if (howto->partial_inplace == false)
712 /* This is a partial relocation, and we want to apply the relocation
713 to the reloc entry rather than the raw data. Modify the reloc
714 inplace to reflect what we now know. */
715 reloc_entry->addend = relocation;
716 reloc_entry->address += input_section->output_offset;
721 /* This is a partial relocation, but inplace, so modify the
724 If we've relocated with a symbol with a section, change
725 into a ref to the section belonging to the symbol. */
727 reloc_entry->address += input_section->output_offset;
730 if (abfd->xvec->flavour == bfd_target_coff_flavour
731 && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
732 && strcmp (abfd->xvec->name, "xcoff-powermac") != 0
733 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
734 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
737 /* For m68k-coff, the addend was being subtracted twice during
738 relocation with -r. Removing the line below this comment
739 fixes that problem; see PR 2953.
741 However, Ian wrote the following, regarding removing the line below,
742 which explains why it is still enabled: --djm
744 If you put a patch like that into BFD you need to check all the COFF
745 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
746 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
747 problem in a different way. There may very well be a reason that the
748 code works as it does.
750 Hmmm. The first obvious point is that bfd_perform_relocation should
751 not have any tests that depend upon the flavour. It's seem like
752 entirely the wrong place for such a thing. The second obvious point
753 is that the current code ignores the reloc addend when producing
754 relocateable output for COFF. That's peculiar. In fact, I really
755 have no idea what the point of the line you want to remove is.
757 A typical COFF reloc subtracts the old value of the symbol and adds in
758 the new value to the location in the object file (if it's a pc
759 relative reloc it adds the difference between the symbol value and the
760 location). When relocating we need to preserve that property.
762 BFD handles this by setting the addend to the negative of the old
763 value of the symbol. Unfortunately it handles common symbols in a
764 non-standard way (it doesn't subtract the old value) but that's a
765 different story (we can't change it without losing backward
766 compatibility with old object files) (coff-i386 does subtract the old
767 value, to be compatible with existing coff-i386 targets, like SCO).
769 So everything works fine when not producing relocateable output. When
770 we are producing relocateable output, logically we should do exactly
771 what we do when not producing relocateable output. Therefore, your
772 patch is correct. In fact, it should probably always just set
773 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
774 add the value into the object file. This won't hurt the COFF code,
775 which doesn't use the addend; I'm not sure what it will do to other
776 formats (the thing to check for would be whether any formats both use
777 the addend and set partial_inplace).
779 When I wanted to make coff-i386 produce relocateable output, I ran
780 into the problem that you are running into: I wanted to remove that
781 line. Rather than risk it, I made the coff-i386 relocs use a special
782 function; it's coff_i386_reloc in coff-i386.c. The function
783 specifically adds the addend field into the object file, knowing that
784 bfd_perform_relocation is not going to. If you remove that line, then
785 coff-i386.c will wind up adding the addend field in twice. It's
786 trivial to fix; it just needs to be done.
788 The problem with removing the line is just that it may break some
789 working code. With BFD it's hard to be sure of anything. The right
790 way to deal with this is simply to build and test at least all the
791 supported COFF targets. It should be straightforward if time and disk
792 space consuming. For each target:
794 2) generate some executable, and link it using -r (I would
795 probably use paranoia.o and link against newlib/libc.a, which
796 for all the supported targets would be available in
797 /usr/cygnus/progressive/H-host/target/lib/libc.a).
798 3) make the change to reloc.c
799 4) rebuild the linker
801 6) if the resulting object files are the same, you have at least
803 7) if they are different you have to figure out which version is
806 relocation -= reloc_entry->addend;
808 reloc_entry->addend = 0;
812 reloc_entry->addend = relocation;
818 reloc_entry->addend = 0;
821 /* FIXME: This overflow checking is incomplete, because the value
822 might have overflowed before we get here. For a correct check we
823 need to compute the value in a size larger than bitsize, but we
824 can't reasonably do that for a reloc the same size as a host
826 FIXME: We should also do overflow checking on the result after
827 adding in the value contained in the object file. */
828 if (howto->complain_on_overflow != complain_overflow_dont
829 && flag == bfd_reloc_ok)
830 flag = bfd_check_overflow (howto->complain_on_overflow,
833 bfd_arch_bits_per_address (abfd),
837 Either we are relocating all the way, or we don't want to apply
838 the relocation to the reloc entry (probably because there isn't
839 any room in the output format to describe addends to relocs)
842 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
843 (OSF version 1.3, compiler version 3.11). It miscompiles the
857 x <<= (unsigned long) s.i0;
861 printf ("succeeded (%lx)\n", x);
865 relocation >>= (bfd_vma) howto->rightshift;
867 /* Shift everything up to where it's going to be used */
869 relocation <<= (bfd_vma) howto->bitpos;
871 /* Wait for the day when all have the mask in them */
874 i instruction to be left alone
875 o offset within instruction
876 r relocation offset to apply
885 (( i i i i i o o o o o from bfd_get<size>
886 and S S S S S) to get the size offset we want
887 + r r r r r r r r r r) to get the final value to place
888 and D D D D D to chop to right size
889 -----------------------
892 ( i i i i i o o o o o from bfd_get<size>
893 and N N N N N ) get instruction
894 -----------------------
900 -----------------------
901 = R R R R R R R R R R put into bfd_put<size>
905 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
911 char x = bfd_get_8 (abfd, (char *) data + octets);
913 bfd_put_8 (abfd, x, (unsigned char *) data + octets);
919 short x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
921 bfd_put_16 (abfd, x, (unsigned char *) data + octets);
926 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
928 bfd_put_32 (abfd, x, (bfd_byte *) data + octets);
933 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
934 relocation = -relocation;
936 bfd_put_32 (abfd, x, (bfd_byte *) data + octets);
942 long x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
943 relocation = -relocation;
945 bfd_put_16 (abfd, x, (bfd_byte *) data + octets);
956 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets);
958 bfd_put_64 (abfd, x, (bfd_byte *) data + octets);
965 return bfd_reloc_other;
973 bfd_install_relocation
976 bfd_reloc_status_type
977 bfd_install_relocation
979 arelent *reloc_entry,
980 PTR data, bfd_vma data_start,
981 asection *input_section,
982 char **error_message);
985 This looks remarkably like <<bfd_perform_relocation>>, except it
986 does not expect that the section contents have been filled in.
987 I.e., it's suitable for use when creating, rather than applying
990 For now, this function should be considered reserved for the
996 bfd_reloc_status_type
997 bfd_install_relocation (abfd, reloc_entry, data_start, data_start_offset,
998 input_section, error_message)
1000 arelent *reloc_entry;
1002 bfd_vma data_start_offset;
1003 asection *input_section;
1004 char **error_message;
1007 bfd_reloc_status_type flag = bfd_reloc_ok;
1008 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1009 bfd_vma output_base = 0;
1010 reloc_howto_type *howto = reloc_entry->howto;
1011 asection *reloc_target_output_section;
1015 symbol = *(reloc_entry->sym_ptr_ptr);
1016 if (bfd_is_abs_section (symbol->section))
1018 reloc_entry->address += input_section->output_offset;
1019 return bfd_reloc_ok;
1022 /* If there is a function supplied to handle this relocation type,
1023 call it. It'll return `bfd_reloc_continue' if further processing
1025 if (howto->special_function)
1027 bfd_reloc_status_type cont;
1029 /* XXX - The special_function calls haven't been fixed up to deal
1030 with creating new relocations and section contents. */
1031 cont = howto->special_function (abfd, reloc_entry, symbol,
1032 /* XXX - Non-portable! */
1033 ((bfd_byte *) data_start
1034 - data_start_offset),
1035 input_section, abfd, error_message);
1036 if (cont != bfd_reloc_continue)
1040 /* Is the address of the relocation really within the section? */
1041 if (reloc_entry->address > input_section->_cooked_size)
1042 return bfd_reloc_outofrange;
1044 /* Work out which section the relocation is targetted at and the
1045 initial relocation command value. */
1047 /* Get symbol value. (Common symbols are special.) */
1048 if (bfd_is_com_section (symbol->section))
1051 relocation = symbol->value;
1053 reloc_target_output_section = symbol->section->output_section;
1055 /* Convert input-section-relative symbol value to absolute. */
1056 if (howto->partial_inplace == false)
1059 output_base = reloc_target_output_section->vma;
1061 relocation += output_base + symbol->section->output_offset;
1063 /* Add in supplied addend. */
1064 relocation += reloc_entry->addend;
1066 /* Here the variable relocation holds the final address of the
1067 symbol we are relocating against, plus any addend. */
1069 if (howto->pc_relative == true)
1071 /* This is a PC relative relocation. We want to set RELOCATION
1072 to the distance between the address of the symbol and the
1073 location. RELOCATION is already the address of the symbol.
1075 We start by subtracting the address of the section containing
1078 If pcrel_offset is set, we must further subtract the position
1079 of the location within the section. Some targets arrange for
1080 the addend to be the negative of the position of the location
1081 within the section; for example, i386-aout does this. For
1082 i386-aout, pcrel_offset is false. Some other targets do not
1083 include the position of the location; for example, m88kbcs,
1084 or ELF. For those targets, pcrel_offset is true.
1086 If we are producing relocateable output, then we must ensure
1087 that this reloc will be correctly computed when the final
1088 relocation is done. If pcrel_offset is false we want to wind
1089 up with the negative of the location within the section,
1090 which means we must adjust the existing addend by the change
1091 in the location within the section. If pcrel_offset is true
1092 we do not want to adjust the existing addend at all.
1094 FIXME: This seems logical to me, but for the case of
1095 producing relocateable output it is not what the code
1096 actually does. I don't want to change it, because it seems
1097 far too likely that something will break. */
1100 input_section->output_section->vma + input_section->output_offset;
1102 if (howto->pcrel_offset == true && howto->partial_inplace == true)
1103 relocation -= reloc_entry->address;
1106 if (howto->partial_inplace == false)
1108 /* This is a partial relocation, and we want to apply the relocation
1109 to the reloc entry rather than the raw data. Modify the reloc
1110 inplace to reflect what we now know. */
1111 reloc_entry->addend = relocation;
1112 reloc_entry->address += input_section->output_offset;
1117 /* This is a partial relocation, but inplace, so modify the
1120 If we've relocated with a symbol with a section, change
1121 into a ref to the section belonging to the symbol. */
1123 reloc_entry->address += input_section->output_offset;
1126 if (abfd->xvec->flavour == bfd_target_coff_flavour
1127 && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
1128 && strcmp (abfd->xvec->name, "xcoff-powermac") != 0
1129 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1130 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1133 /* For m68k-coff, the addend was being subtracted twice during
1134 relocation with -r. Removing the line below this comment
1135 fixes that problem; see PR 2953.
1137 However, Ian wrote the following, regarding removing the line below,
1138 which explains why it is still enabled: --djm
1140 If you put a patch like that into BFD you need to check all the COFF
1141 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
1142 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1143 problem in a different way. There may very well be a reason that the
1144 code works as it does.
1146 Hmmm. The first obvious point is that bfd_install_relocation should
1147 not have any tests that depend upon the flavour. It's seem like
1148 entirely the wrong place for such a thing. The second obvious point
1149 is that the current code ignores the reloc addend when producing
1150 relocateable output for COFF. That's peculiar. In fact, I really
1151 have no idea what the point of the line you want to remove is.
1153 A typical COFF reloc subtracts the old value of the symbol and adds in
1154 the new value to the location in the object file (if it's a pc
1155 relative reloc it adds the difference between the symbol value and the
1156 location). When relocating we need to preserve that property.
1158 BFD handles this by setting the addend to the negative of the old
1159 value of the symbol. Unfortunately it handles common symbols in a
1160 non-standard way (it doesn't subtract the old value) but that's a
1161 different story (we can't change it without losing backward
1162 compatibility with old object files) (coff-i386 does subtract the old
1163 value, to be compatible with existing coff-i386 targets, like SCO).
1165 So everything works fine when not producing relocateable output. When
1166 we are producing relocateable output, logically we should do exactly
1167 what we do when not producing relocateable output. Therefore, your
1168 patch is correct. In fact, it should probably always just set
1169 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1170 add the value into the object file. This won't hurt the COFF code,
1171 which doesn't use the addend; I'm not sure what it will do to other
1172 formats (the thing to check for would be whether any formats both use
1173 the addend and set partial_inplace).
1175 When I wanted to make coff-i386 produce relocateable output, I ran
1176 into the problem that you are running into: I wanted to remove that
1177 line. Rather than risk it, I made the coff-i386 relocs use a special
1178 function; it's coff_i386_reloc in coff-i386.c. The function
1179 specifically adds the addend field into the object file, knowing that
1180 bfd_install_relocation is not going to. If you remove that line, then
1181 coff-i386.c will wind up adding the addend field in twice. It's
1182 trivial to fix; it just needs to be done.
1184 The problem with removing the line is just that it may break some
1185 working code. With BFD it's hard to be sure of anything. The right
1186 way to deal with this is simply to build and test at least all the
1187 supported COFF targets. It should be straightforward if time and disk
1188 space consuming. For each target:
1190 2) generate some executable, and link it using -r (I would
1191 probably use paranoia.o and link against newlib/libc.a, which
1192 for all the supported targets would be available in
1193 /usr/cygnus/progressive/H-host/target/lib/libc.a).
1194 3) make the change to reloc.c
1195 4) rebuild the linker
1197 6) if the resulting object files are the same, you have at least
1199 7) if they are different you have to figure out which version is
1202 relocation -= reloc_entry->addend;
1204 reloc_entry->addend = 0;
1208 reloc_entry->addend = relocation;
1212 /* FIXME: This overflow checking is incomplete, because the value
1213 might have overflowed before we get here. For a correct check we
1214 need to compute the value in a size larger than bitsize, but we
1215 can't reasonably do that for a reloc the same size as a host
1217 FIXME: We should also do overflow checking on the result after
1218 adding in the value contained in the object file. */
1219 if (howto->complain_on_overflow != complain_overflow_dont)
1220 flag = bfd_check_overflow (howto->complain_on_overflow,
1223 bfd_arch_bits_per_address (abfd),
1227 Either we are relocating all the way, or we don't want to apply
1228 the relocation to the reloc entry (probably because there isn't
1229 any room in the output format to describe addends to relocs)
1232 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1233 (OSF version 1.3, compiler version 3.11). It miscompiles the
1247 x <<= (unsigned long) s.i0;
1249 printf ("failed\n");
1251 printf ("succeeded (%lx)\n", x);
1255 relocation >>= (bfd_vma) howto->rightshift;
1257 /* Shift everything up to where it's going to be used */
1259 relocation <<= (bfd_vma) howto->bitpos;
1261 /* Wait for the day when all have the mask in them */
1264 i instruction to be left alone
1265 o offset within instruction
1266 r relocation offset to apply
1275 (( i i i i i o o o o o from bfd_get<size>
1276 and S S S S S) to get the size offset we want
1277 + r r r r r r r r r r) to get the final value to place
1278 and D D D D D to chop to right size
1279 -----------------------
1282 ( i i i i i o o o o o from bfd_get<size>
1283 and N N N N N ) get instruction
1284 -----------------------
1290 -----------------------
1291 = R R R R R R R R R R put into bfd_put<size>
1295 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
1297 data = (bfd_byte *) data_start + (octets - data_start_offset);
1299 switch (howto->size)
1303 char x = bfd_get_8 (abfd, (char *) data);
1305 bfd_put_8 (abfd, x, (unsigned char *) data);
1311 short x = bfd_get_16 (abfd, (bfd_byte *) data);
1313 bfd_put_16 (abfd, x, (unsigned char *) data);
1318 long x = bfd_get_32 (abfd, (bfd_byte *) data);
1320 bfd_put_32 (abfd, x, (bfd_byte *) data);
1325 long x = bfd_get_32 (abfd, (bfd_byte *) data);
1326 relocation = -relocation;
1328 bfd_put_32 (abfd, x, (bfd_byte *) data);
1338 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
1340 bfd_put_64 (abfd, x, (bfd_byte *) data);
1344 return bfd_reloc_other;
1350 /* This relocation routine is used by some of the backend linkers.
1351 They do not construct asymbol or arelent structures, so there is no
1352 reason for them to use bfd_perform_relocation. Also,
1353 bfd_perform_relocation is so hacked up it is easier to write a new
1354 function than to try to deal with it.
1356 This routine does a final relocation. Whether it is useful for a
1357 relocateable link depends upon how the object format defines
1360 FIXME: This routine ignores any special_function in the HOWTO,
1361 since the existing special_function values have been written for
1362 bfd_perform_relocation.
1364 HOWTO is the reloc howto information.
1365 INPUT_BFD is the BFD which the reloc applies to.
1366 INPUT_SECTION is the section which the reloc applies to.
1367 CONTENTS is the contents of the section.
1368 ADDRESS is the address of the reloc within INPUT_SECTION.
1369 VALUE is the value of the symbol the reloc refers to.
1370 ADDEND is the addend of the reloc. */
1372 bfd_reloc_status_type
1373 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
1375 reloc_howto_type *howto;
1377 asection *input_section;
1385 /* Sanity check the address. */
1386 if (address > input_section->_raw_size)
1387 return bfd_reloc_outofrange;
1389 /* This function assumes that we are dealing with a basic relocation
1390 against a symbol. We want to compute the value of the symbol to
1391 relocate to. This is just VALUE, the value of the symbol, plus
1392 ADDEND, any addend associated with the reloc. */
1393 relocation = value + addend;
1395 /* If the relocation is PC relative, we want to set RELOCATION to
1396 the distance between the symbol (currently in RELOCATION) and the
1397 location we are relocating. Some targets (e.g., i386-aout)
1398 arrange for the contents of the section to be the negative of the
1399 offset of the location within the section; for such targets
1400 pcrel_offset is false. Other targets (e.g., m88kbcs or ELF)
1401 simply leave the contents of the section as zero; for such
1402 targets pcrel_offset is true. If pcrel_offset is false we do not
1403 need to subtract out the offset of the location within the
1404 section (which is just ADDRESS). */
1405 if (howto->pc_relative)
1407 relocation -= (input_section->output_section->vma
1408 + input_section->output_offset);
1409 if (howto->pcrel_offset)
1410 relocation -= address;
1413 return _bfd_relocate_contents (howto, input_bfd, relocation,
1414 contents + address);
1417 /* Relocate a given location using a given value and howto. */
1419 bfd_reloc_status_type
1420 _bfd_relocate_contents (howto, input_bfd, relocation, location)
1421 reloc_howto_type *howto;
1428 bfd_reloc_status_type flag;
1429 unsigned int rightshift = howto->rightshift;
1430 unsigned int bitpos = howto->bitpos;
1432 /* If the size is negative, negate RELOCATION. This isn't very
1434 if (howto->size < 0)
1435 relocation = -relocation;
1437 /* Get the value we are going to relocate. */
1438 size = bfd_get_reloc_size (howto);
1445 x = bfd_get_8 (input_bfd, location);
1448 x = bfd_get_16 (input_bfd, location);
1451 x = bfd_get_32 (input_bfd, location);
1455 x = bfd_get_64 (input_bfd, location);
1462 /* Check for overflow. FIXME: We may drop bits during the addition
1463 which we don't check for. We must either check at every single
1464 operation, which would be tedious, or we must do the computations
1465 in a type larger than bfd_vma, which would be inefficient. */
1466 flag = bfd_reloc_ok;
1467 if (howto->complain_on_overflow != complain_overflow_dont)
1469 bfd_vma addrmask, fieldmask, signmask, ss;
1472 /* Get the values to be added together. For signed and unsigned
1473 relocations, we assume that all values should be truncated to
1474 the size of an address. For bitfields, all the bits matter.
1475 See also bfd_check_overflow. */
1476 fieldmask = N_ONES (howto->bitsize);
1477 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
1479 b = x & howto->src_mask;
1481 switch (howto->complain_on_overflow)
1483 case complain_overflow_signed:
1484 a = (a & addrmask) >> rightshift;
1486 /* If any sign bits are set, all sign bits must be set.
1487 That is, A must be a valid negative address after
1489 signmask = ~ (fieldmask >> 1);
1491 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
1492 flag = bfd_reloc_overflow;
1494 /* We only need this next bit of code if the sign bit of B
1495 is below the sign bit of A. This would only happen if
1496 SRC_MASK had fewer bits than BITSIZE. Note that if
1497 SRC_MASK has more bits than BITSIZE, we can get into
1498 trouble; we would need to verify that B is in range, as
1499 we do for A above. */
1500 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1501 if ((b & signmask) != 0)
1503 /* Set all the bits above the sign bit. */
1507 b = (b & addrmask) >> bitpos;
1509 /* Now we can do the addition. */
1512 /* See if the result has the correct sign. Bits above the
1513 sign bit are junk now; ignore them. If the sum is
1514 positive, make sure we did not have all negative inputs;
1515 if the sum is negative, make sure we did not have all
1516 positive inputs. The test below looks only at the sign
1517 bits, and it really just
1518 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1520 signmask = (fieldmask >> 1) + 1;
1521 if (((~ (a ^ b)) & (a ^ sum)) & signmask)
1522 flag = bfd_reloc_overflow;
1526 case complain_overflow_unsigned:
1527 /* Checking for an unsigned overflow is relatively easy:
1528 trim the addresses and add, and trim the result as well.
1529 Overflow is normally indicated when the result does not
1530 fit in the field. However, we also need to consider the
1531 case when, e.g., fieldmask is 0x7fffffff or smaller, an
1532 input is 0x80000000, and bfd_vma is only 32 bits; then we
1533 will get sum == 0, but there is an overflow, since the
1534 inputs did not fit in the field. Instead of doing a
1535 separate test, we can check for this by or-ing in the
1536 operands when testing for the sum overflowing its final
1538 a = (a & addrmask) >> rightshift;
1539 b = (b & addrmask) >> bitpos;
1540 sum = (a + b) & addrmask;
1541 if ((a | b | sum) & ~ fieldmask)
1542 flag = bfd_reloc_overflow;
1546 case complain_overflow_bitfield:
1547 /* Much like the signed check, but for a field one bit
1548 wider, and no trimming with addrmask. We allow a
1549 bitfield to represent numbers in the range -2**n to
1550 2**n-1, where n is the number of bits in the field.
1551 Note that when bfd_vma is 32 bits, a 32-bit reloc can't
1552 overflow, which is exactly what we want. */
1555 signmask = ~ fieldmask;
1557 if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & signmask))
1558 flag = bfd_reloc_overflow;
1560 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1561 if ((b & signmask) != 0)
1568 signmask = fieldmask + 1;
1569 if (((~ (a ^ b)) & (a ^ sum)) & signmask)
1570 flag = bfd_reloc_overflow;
1579 /* Put RELOCATION in the right bits. */
1580 relocation >>= (bfd_vma) rightshift;
1581 relocation <<= (bfd_vma) bitpos;
1583 /* Add RELOCATION to the right bits of X. */
1584 x = ((x & ~howto->dst_mask)
1585 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1587 /* Put the relocated value back in the object file. */
1594 bfd_put_8 (input_bfd, x, location);
1597 bfd_put_16 (input_bfd, x, location);
1600 bfd_put_32 (input_bfd, x, location);
1604 bfd_put_64 (input_bfd, x, location);
1617 howto manager, , typedef arelent, Relocations
1622 When an application wants to create a relocation, but doesn't
1623 know what the target machine might call it, it can find out by
1624 using this bit of code.
1633 The insides of a reloc code. The idea is that, eventually, there
1634 will be one enumerator for every type of relocation we ever do.
1635 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1636 return a howto pointer.
1638 This does mean that the application must determine the correct
1639 enumerator value; you can't get a howto pointer from a random set
1660 Basic absolute relocations of N bits.
1675 PC-relative relocations. Sometimes these are relative to the address
1676 of the relocation itself; sometimes they are relative to the start of
1677 the section containing the relocation. It depends on the specific target.
1679 The 24-bit relocation is used in some Intel 960 configurations.
1682 BFD_RELOC_32_GOT_PCREL
1684 BFD_RELOC_16_GOT_PCREL
1686 BFD_RELOC_8_GOT_PCREL
1692 BFD_RELOC_LO16_GOTOFF
1694 BFD_RELOC_HI16_GOTOFF
1696 BFD_RELOC_HI16_S_GOTOFF
1700 BFD_RELOC_32_PLT_PCREL
1702 BFD_RELOC_24_PLT_PCREL
1704 BFD_RELOC_16_PLT_PCREL
1706 BFD_RELOC_8_PLT_PCREL
1712 BFD_RELOC_LO16_PLTOFF
1714 BFD_RELOC_HI16_PLTOFF
1716 BFD_RELOC_HI16_S_PLTOFF
1723 BFD_RELOC_68K_GLOB_DAT
1725 BFD_RELOC_68K_JMP_SLOT
1727 BFD_RELOC_68K_RELATIVE
1729 Relocations used by 68K ELF.
1732 BFD_RELOC_32_BASEREL
1734 BFD_RELOC_16_BASEREL
1736 BFD_RELOC_LO16_BASEREL
1738 BFD_RELOC_HI16_BASEREL
1740 BFD_RELOC_HI16_S_BASEREL
1746 Linkage-table relative.
1751 Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1754 BFD_RELOC_32_PCREL_S2
1756 BFD_RELOC_16_PCREL_S2
1758 BFD_RELOC_23_PCREL_S2
1760 These PC-relative relocations are stored as word displacements --
1761 i.e., byte displacements shifted right two bits. The 30-bit word
1762 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1763 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The
1764 signed 16-bit displacement is used on the MIPS, and the 23-bit
1765 displacement is used on the Alpha.
1772 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1773 the target word. These are used on the SPARC.
1780 For systems that allocate a Global Pointer register, these are
1781 displacements off that register. These relocation types are
1782 handled specially, because the value the register will have is
1783 decided relatively late.
1787 BFD_RELOC_I960_CALLJ
1789 Reloc types used for i960/b.out.
1794 BFD_RELOC_SPARC_WDISP22
1800 BFD_RELOC_SPARC_GOT10
1802 BFD_RELOC_SPARC_GOT13
1804 BFD_RELOC_SPARC_GOT22
1806 BFD_RELOC_SPARC_PC10
1808 BFD_RELOC_SPARC_PC22
1810 BFD_RELOC_SPARC_WPLT30
1812 BFD_RELOC_SPARC_COPY
1814 BFD_RELOC_SPARC_GLOB_DAT
1816 BFD_RELOC_SPARC_JMP_SLOT
1818 BFD_RELOC_SPARC_RELATIVE
1820 BFD_RELOC_SPARC_UA32
1822 SPARC ELF relocations. There is probably some overlap with other
1823 relocation types already defined.
1826 BFD_RELOC_SPARC_BASE13
1828 BFD_RELOC_SPARC_BASE22
1830 I think these are specific to SPARC a.out (e.g., Sun 4).
1840 BFD_RELOC_SPARC_OLO10
1842 BFD_RELOC_SPARC_HH22
1844 BFD_RELOC_SPARC_HM10
1846 BFD_RELOC_SPARC_LM22
1848 BFD_RELOC_SPARC_PC_HH22
1850 BFD_RELOC_SPARC_PC_HM10
1852 BFD_RELOC_SPARC_PC_LM22
1854 BFD_RELOC_SPARC_WDISP16
1856 BFD_RELOC_SPARC_WDISP19
1864 BFD_RELOC_SPARC_DISP64
1867 BFD_RELOC_SPARC_PLT64
1869 BFD_RELOC_SPARC_HIX22
1871 BFD_RELOC_SPARC_LOX10
1879 BFD_RELOC_SPARC_REGISTER
1884 BFD_RELOC_SPARC_REV32
1886 SPARC little endian relocation
1889 BFD_RELOC_ALPHA_GPDISP_HI16
1891 Alpha ECOFF and ELF relocations. Some of these treat the symbol or
1892 "addend" in some special way.
1893 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1894 writing; when reading, it will be the absolute section symbol. The
1895 addend is the displacement in bytes of the "lda" instruction from
1896 the "ldah" instruction (which is at the address of this reloc).
1898 BFD_RELOC_ALPHA_GPDISP_LO16
1900 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1901 with GPDISP_HI16 relocs. The addend is ignored when writing the
1902 relocations out, and is filled in with the file's GP value on
1903 reading, for convenience.
1906 BFD_RELOC_ALPHA_GPDISP
1908 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1909 relocation except that there is no accompanying GPDISP_LO16
1913 BFD_RELOC_ALPHA_LITERAL
1915 BFD_RELOC_ALPHA_ELF_LITERAL
1917 BFD_RELOC_ALPHA_LITUSE
1919 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1920 the assembler turns it into a LDQ instruction to load the address of
1921 the symbol, and then fills in a register in the real instruction.
1923 The LITERAL reloc, at the LDQ instruction, refers to the .lita
1924 section symbol. The addend is ignored when writing, but is filled
1925 in with the file's GP value on reading, for convenience, as with the
1928 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1929 It should refer to the symbol to be referenced, as with 16_GOTOFF,
1930 but it generates output not based on the position within the .got
1931 section, but relative to the GP value chosen for the file during the
1934 The LITUSE reloc, on the instruction using the loaded address, gives
1935 information to the linker that it might be able to use to optimize
1936 away some literal section references. The symbol is ignored (read
1937 as the absolute section symbol), and the "addend" indicates the type
1938 of instruction using the register:
1939 1 - "memory" fmt insn
1940 2 - byte-manipulation (byte offset reg)
1941 3 - jsr (target of branch)
1943 The GNU linker currently doesn't do any of this optimizing.
1946 BFD_RELOC_ALPHA_USER_LITERAL
1948 BFD_RELOC_ALPHA_USER_LITUSE_BASE
1950 BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF
1952 BFD_RELOC_ALPHA_USER_LITUSE_JSR
1954 BFD_RELOC_ALPHA_USER_GPDISP
1956 BFD_RELOC_ALPHA_USER_GPRELHIGH
1958 BFD_RELOC_ALPHA_USER_GPRELLOW
1960 The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to
1961 process the explicit !<reloc>!sequence relocations, and are mapped
1962 into the normal relocations at the end of processing.
1965 BFD_RELOC_ALPHA_HINT
1967 The HINT relocation indicates a value that should be filled into the
1968 "hint" field of a jmp/jsr/ret instruction, for possible branch-
1969 prediction logic which may be provided on some processors.
1972 BFD_RELOC_ALPHA_LINKAGE
1974 The LINKAGE relocation outputs a linkage pair in the object file,
1975 which is filled by the linker.
1978 BFD_RELOC_ALPHA_CODEADDR
1980 The CODEADDR relocation outputs a STO_CA in the object file,
1981 which is filled by the linker.
1986 Bits 27..2 of the relocation address shifted right 2 bits;
1987 simple reloc otherwise.
1990 BFD_RELOC_MIPS16_JMP
1992 The MIPS16 jump instruction.
1995 BFD_RELOC_MIPS16_GPREL
1997 MIPS16 GP relative reloc.
2002 High 16 bits of 32-bit value; simple reloc.
2006 High 16 bits of 32-bit value but the low 16 bits will be sign
2007 extended and added to form the final result. If the low 16
2008 bits form a negative number, we need to add one to the high value
2009 to compensate for the borrow when the low bits are added.
2015 BFD_RELOC_PCREL_HI16_S
2017 Like BFD_RELOC_HI16_S, but PC relative.
2019 BFD_RELOC_PCREL_LO16
2021 Like BFD_RELOC_LO16, but PC relative.
2024 BFD_RELOC_MIPS_GPREL
2027 Relocation relative to the global pointer.
2030 BFD_RELOC_MIPS_LITERAL
2032 Relocation against a MIPS literal section.
2035 BFD_RELOC_MIPS_GOT16
2037 BFD_RELOC_MIPS_CALL16
2039 BFD_RELOC_MIPS_GPREL32
2042 BFD_RELOC_MIPS_GOT_HI16
2044 BFD_RELOC_MIPS_GOT_LO16
2046 BFD_RELOC_MIPS_CALL_HI16
2048 BFD_RELOC_MIPS_CALL_LO16
2052 BFD_RELOC_MIPS_GOT_PAGE
2054 BFD_RELOC_MIPS_GOT_OFST
2056 BFD_RELOC_MIPS_GOT_DISP
2059 MIPS ELF relocations.
2070 BFD_RELOC_386_GLOB_DAT
2072 BFD_RELOC_386_JUMP_SLOT
2074 BFD_RELOC_386_RELATIVE
2076 BFD_RELOC_386_GOTOFF
2080 i386/elf relocations
2083 BFD_RELOC_NS32K_IMM_8
2085 BFD_RELOC_NS32K_IMM_16
2087 BFD_RELOC_NS32K_IMM_32
2089 BFD_RELOC_NS32K_IMM_8_PCREL
2091 BFD_RELOC_NS32K_IMM_16_PCREL
2093 BFD_RELOC_NS32K_IMM_32_PCREL
2095 BFD_RELOC_NS32K_DISP_8
2097 BFD_RELOC_NS32K_DISP_16
2099 BFD_RELOC_NS32K_DISP_32
2101 BFD_RELOC_NS32K_DISP_8_PCREL
2103 BFD_RELOC_NS32K_DISP_16_PCREL
2105 BFD_RELOC_NS32K_DISP_32_PCREL
2110 BFD_RELOC_PJ_CODE_HI16
2112 BFD_RELOC_PJ_CODE_LO16
2114 BFD_RELOC_PJ_CODE_DIR16
2116 BFD_RELOC_PJ_CODE_DIR32
2118 BFD_RELOC_PJ_CODE_REL16
2120 BFD_RELOC_PJ_CODE_REL32
2122 Picojava relocs. Not all of these appear in object files.
2133 BFD_RELOC_PPC_B16_BRTAKEN
2135 BFD_RELOC_PPC_B16_BRNTAKEN
2139 BFD_RELOC_PPC_BA16_BRTAKEN
2141 BFD_RELOC_PPC_BA16_BRNTAKEN
2145 BFD_RELOC_PPC_GLOB_DAT
2147 BFD_RELOC_PPC_JMP_SLOT
2149 BFD_RELOC_PPC_RELATIVE
2151 BFD_RELOC_PPC_LOCAL24PC
2153 BFD_RELOC_PPC_EMB_NADDR32
2155 BFD_RELOC_PPC_EMB_NADDR16
2157 BFD_RELOC_PPC_EMB_NADDR16_LO
2159 BFD_RELOC_PPC_EMB_NADDR16_HI
2161 BFD_RELOC_PPC_EMB_NADDR16_HA
2163 BFD_RELOC_PPC_EMB_SDAI16
2165 BFD_RELOC_PPC_EMB_SDA2I16
2167 BFD_RELOC_PPC_EMB_SDA2REL
2169 BFD_RELOC_PPC_EMB_SDA21
2171 BFD_RELOC_PPC_EMB_MRKREF
2173 BFD_RELOC_PPC_EMB_RELSEC16
2175 BFD_RELOC_PPC_EMB_RELST_LO
2177 BFD_RELOC_PPC_EMB_RELST_HI
2179 BFD_RELOC_PPC_EMB_RELST_HA
2181 BFD_RELOC_PPC_EMB_BIT_FLD
2183 BFD_RELOC_PPC_EMB_RELSDA
2185 Power(rs6000) and PowerPC relocations.
2190 IBM 370/390 relocations
2195 The type of reloc used to build a contructor table - at the moment
2196 probably a 32 bit wide absolute relocation, but the target can choose.
2197 It generally does map to one of the other relocation types.
2200 BFD_RELOC_ARM_PCREL_BRANCH
2202 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
2203 not stored in the instruction.
2205 BFD_RELOC_ARM_IMMEDIATE
2207 BFD_RELOC_ARM_ADRL_IMMEDIATE
2209 BFD_RELOC_ARM_OFFSET_IMM
2211 BFD_RELOC_ARM_SHIFT_IMM
2217 BFD_RELOC_ARM_CP_OFF_IMM
2219 BFD_RELOC_ARM_ADR_IMM
2221 BFD_RELOC_ARM_LDR_IMM
2223 BFD_RELOC_ARM_LITERAL
2225 BFD_RELOC_ARM_IN_POOL
2227 BFD_RELOC_ARM_OFFSET_IMM8
2229 BFD_RELOC_ARM_HWLITERAL
2231 BFD_RELOC_ARM_THUMB_ADD
2233 BFD_RELOC_ARM_THUMB_IMM
2235 BFD_RELOC_ARM_THUMB_SHIFT
2237 BFD_RELOC_ARM_THUMB_OFFSET
2243 BFD_RELOC_ARM_JUMP_SLOT
2247 BFD_RELOC_ARM_GLOB_DAT
2251 BFD_RELOC_ARM_RELATIVE
2253 BFD_RELOC_ARM_GOTOFF
2257 These relocs are only used within the ARM assembler. They are not
2258 (at present) written to any object files.
2261 BFD_RELOC_SH_PCDISP8BY2
2263 BFD_RELOC_SH_PCDISP12BY2
2267 BFD_RELOC_SH_IMM4BY2
2269 BFD_RELOC_SH_IMM4BY4
2273 BFD_RELOC_SH_IMM8BY2
2275 BFD_RELOC_SH_IMM8BY4
2277 BFD_RELOC_SH_PCRELIMM8BY2
2279 BFD_RELOC_SH_PCRELIMM8BY4
2281 BFD_RELOC_SH_SWITCH16
2283 BFD_RELOC_SH_SWITCH32
2297 BFD_RELOC_SH_LOOP_START
2299 BFD_RELOC_SH_LOOP_END
2301 Hitachi SH relocs. Not all of these appear in object files.
2304 BFD_RELOC_THUMB_PCREL_BRANCH9
2306 BFD_RELOC_THUMB_PCREL_BRANCH12
2308 BFD_RELOC_THUMB_PCREL_BRANCH23
2310 Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must
2311 be zero and is not stored in the instruction.
2314 BFD_RELOC_ARC_B22_PCREL
2316 Argonaut RISC Core (ARC) relocs.
2317 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
2318 not stored in the instruction. The high 20 bits are installed in bits 26
2319 through 7 of the instruction.
2323 ARC 26 bit absolute branch. The lowest two bits must be zero and are not
2324 stored in the instruction. The high 24 bits are installed in bits 23
2328 BFD_RELOC_D10V_10_PCREL_R
2330 Mitsubishi D10V relocs.
2331 This is a 10-bit reloc with the right 2 bits
2334 BFD_RELOC_D10V_10_PCREL_L
2336 Mitsubishi D10V relocs.
2337 This is a 10-bit reloc with the right 2 bits
2338 assumed to be 0. This is the same as the previous reloc
2339 except it is in the left container, i.e.,
2340 shifted left 15 bits.
2344 This is an 18-bit reloc with the right 2 bits
2347 BFD_RELOC_D10V_18_PCREL
2349 This is an 18-bit reloc with the right 2 bits
2355 Mitsubishi D30V relocs.
2356 This is a 6-bit absolute reloc.
2358 BFD_RELOC_D30V_9_PCREL
2360 This is a 6-bit pc-relative reloc with
2361 the right 3 bits assumed to be 0.
2363 BFD_RELOC_D30V_9_PCREL_R
2365 This is a 6-bit pc-relative reloc with
2366 the right 3 bits assumed to be 0. Same
2367 as the previous reloc but on the right side
2372 This is a 12-bit absolute reloc with the
2373 right 3 bitsassumed to be 0.
2375 BFD_RELOC_D30V_15_PCREL
2377 This is a 12-bit pc-relative reloc with
2378 the right 3 bits assumed to be 0.
2380 BFD_RELOC_D30V_15_PCREL_R
2382 This is a 12-bit pc-relative reloc with
2383 the right 3 bits assumed to be 0. Same
2384 as the previous reloc but on the right side
2389 This is an 18-bit absolute reloc with
2390 the right 3 bits assumed to be 0.
2392 BFD_RELOC_D30V_21_PCREL
2394 This is an 18-bit pc-relative reloc with
2395 the right 3 bits assumed to be 0.
2397 BFD_RELOC_D30V_21_PCREL_R
2399 This is an 18-bit pc-relative reloc with
2400 the right 3 bits assumed to be 0. Same
2401 as the previous reloc but on the right side
2406 This is a 32-bit absolute reloc.
2408 BFD_RELOC_D30V_32_PCREL
2410 This is a 32-bit pc-relative reloc.
2415 Mitsubishi M32R relocs.
2416 This is a 24 bit absolute address.
2418 BFD_RELOC_M32R_10_PCREL
2420 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
2422 BFD_RELOC_M32R_18_PCREL
2424 This is an 18-bit reloc with the right 2 bits assumed to be 0.
2426 BFD_RELOC_M32R_26_PCREL
2428 This is a 26-bit reloc with the right 2 bits assumed to be 0.
2430 BFD_RELOC_M32R_HI16_ULO
2432 This is a 16-bit reloc containing the high 16 bits of an address
2433 used when the lower 16 bits are treated as unsigned.
2435 BFD_RELOC_M32R_HI16_SLO
2437 This is a 16-bit reloc containing the high 16 bits of an address
2438 used when the lower 16 bits are treated as signed.
2442 This is a 16-bit reloc containing the lower 16 bits of an address.
2444 BFD_RELOC_M32R_SDA16
2446 This is a 16-bit reloc containing the small data area offset for use in
2447 add3, load, and store instructions.
2450 BFD_RELOC_V850_9_PCREL
2452 This is a 9-bit reloc
2454 BFD_RELOC_V850_22_PCREL
2456 This is a 22-bit reloc
2459 BFD_RELOC_V850_SDA_16_16_OFFSET
2461 This is a 16 bit offset from the short data area pointer.
2463 BFD_RELOC_V850_SDA_15_16_OFFSET
2465 This is a 16 bit offset (of which only 15 bits are used) from the
2466 short data area pointer.
2468 BFD_RELOC_V850_ZDA_16_16_OFFSET
2470 This is a 16 bit offset from the zero data area pointer.
2472 BFD_RELOC_V850_ZDA_15_16_OFFSET
2474 This is a 16 bit offset (of which only 15 bits are used) from the
2475 zero data area pointer.
2477 BFD_RELOC_V850_TDA_6_8_OFFSET
2479 This is an 8 bit offset (of which only 6 bits are used) from the
2480 tiny data area pointer.
2482 BFD_RELOC_V850_TDA_7_8_OFFSET
2484 This is an 8bit offset (of which only 7 bits are used) from the tiny
2487 BFD_RELOC_V850_TDA_7_7_OFFSET
2489 This is a 7 bit offset from the tiny data area pointer.
2491 BFD_RELOC_V850_TDA_16_16_OFFSET
2493 This is a 16 bit offset from the tiny data area pointer.
2496 BFD_RELOC_V850_TDA_4_5_OFFSET
2498 This is a 5 bit offset (of which only 4 bits are used) from the tiny
2501 BFD_RELOC_V850_TDA_4_4_OFFSET
2503 This is a 4 bit offset from the tiny data area pointer.
2505 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
2507 This is a 16 bit offset from the short data area pointer, with the
2508 bits placed non-contigously in the instruction.
2510 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
2512 This is a 16 bit offset from the zero data area pointer, with the
2513 bits placed non-contigously in the instruction.
2515 BFD_RELOC_V850_CALLT_6_7_OFFSET
2517 This is a 6 bit offset from the call table base pointer.
2519 BFD_RELOC_V850_CALLT_16_16_OFFSET
2521 This is a 16 bit offset from the call table base pointer.
2525 BFD_RELOC_MN10300_32_PCREL
2527 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2530 BFD_RELOC_MN10300_16_PCREL
2532 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2538 This is a 8bit DP reloc for the tms320c30, where the most
2539 significant 8 bits of a 24 bit word are placed into the least
2540 significant 8 bits of the opcode.
2544 BFD_RELOC_TIC54X_PARTLS7
2546 This is a 7bit reloc for the tms320c54x, where the least
2547 significant 7 bits of a 16 bit word are placed into the least
2548 significant 7 bits of the opcode.
2551 BFD_RELOC_TIC54X_PARTMS9
2553 This is a 9bit DP reloc for the tms320c54x, where the most
2554 significant 9 bits of a 16 bit word are placed into the least
2555 significant 9 bits of the opcode.
2560 This is an extended address 23-bit reloc for the tms320c54x.
2563 BFD_RELOC_TIC54X_16_OF_23
2565 This is a 16-bit reloc for the tms320c54x, where the least
2566 significant 16 bits of a 23-bit extended address are placed into
2570 BFD_RELOC_TIC54X_MS7_OF_23
2572 This is a reloc for the tms320c54x, where the most
2573 significant 7 bits of a 23-bit extended address are placed into
2580 This is a 48 bit reloc for the FR30 that stores 32 bits.
2584 This is a 32 bit reloc for the FR30 that stores 20 bits split up into
2587 BFD_RELOC_FR30_6_IN_4
2589 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
2592 BFD_RELOC_FR30_8_IN_8
2594 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
2597 BFD_RELOC_FR30_9_IN_8
2599 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
2602 BFD_RELOC_FR30_10_IN_8
2604 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
2607 BFD_RELOC_FR30_9_PCREL
2609 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
2610 short offset into 8 bits.
2612 BFD_RELOC_FR30_12_PCREL
2614 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
2615 short offset into 11 bits.
2618 BFD_RELOC_MCORE_PCREL_IMM8BY4
2620 BFD_RELOC_MCORE_PCREL_IMM11BY2
2622 BFD_RELOC_MCORE_PCREL_IMM4BY2
2624 BFD_RELOC_MCORE_PCREL_32
2626 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
2630 Motorola Mcore relocations.
2633 BFD_RELOC_AVR_7_PCREL
2635 This is a 16 bit reloc for the AVR that stores 8 bit pc relative
2636 short offset into 7 bits.
2638 BFD_RELOC_AVR_13_PCREL
2640 This is a 16 bit reloc for the AVR that stores 13 bit pc relative
2641 short offset into 12 bits.
2645 This is a 16 bit reloc for the AVR that stores 17 bit value (usually
2646 program memory address) into 16 bits.
2648 BFD_RELOC_AVR_LO8_LDI
2650 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2651 data memory address) into 8 bit immediate value of LDI insn.
2653 BFD_RELOC_AVR_HI8_LDI
2655 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2656 of data memory address) into 8 bit immediate value of LDI insn.
2658 BFD_RELOC_AVR_HH8_LDI
2660 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2661 of program memory address) into 8 bit immediate value of LDI insn.
2663 BFD_RELOC_AVR_LO8_LDI_NEG
2665 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2666 (usually data memory address) into 8 bit immediate value of SUBI insn.
2668 BFD_RELOC_AVR_HI8_LDI_NEG
2670 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2671 (high 8 bit of data memory address) into 8 bit immediate value of
2674 BFD_RELOC_AVR_HH8_LDI_NEG
2676 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2677 (most high 8 bit of program memory address) into 8 bit immediate value
2678 of LDI or SUBI insn.
2680 BFD_RELOC_AVR_LO8_LDI_PM
2682 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2683 command address) into 8 bit immediate value of LDI insn.
2685 BFD_RELOC_AVR_HI8_LDI_PM
2687 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2688 of command address) into 8 bit immediate value of LDI insn.
2690 BFD_RELOC_AVR_HH8_LDI_PM
2692 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2693 of command address) into 8 bit immediate value of LDI insn.
2695 BFD_RELOC_AVR_LO8_LDI_PM_NEG
2697 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2698 (usually command address) into 8 bit immediate value of SUBI insn.
2700 BFD_RELOC_AVR_HI8_LDI_PM_NEG
2702 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2703 (high 8 bit of 16 bit command address) into 8 bit immediate value
2706 BFD_RELOC_AVR_HH8_LDI_PM_NEG
2708 This is a 16 bit reloc for the AVR that stores negated 8 bit value
2709 (high 6 bit of 22 bit command address) into 8 bit immediate
2714 This is a 32 bit reloc for the AVR that stores 23 bit value
2718 BFD_RELOC_VTABLE_INHERIT
2720 BFD_RELOC_VTABLE_ENTRY
2722 These two relocations are used by the linker to determine which of
2723 the entries in a C++ virtual function table are actually used. When
2724 the --gc-sections option is given, the linker will zero out the entries
2725 that are not used, so that the code for those functions need not be
2726 included in the output.
2728 VTABLE_INHERIT is a zero-space relocation used to describe to the
2729 linker the inheritence tree of a C++ virtual function table. The
2730 relocation's symbol should be the parent class' vtable, and the
2731 relocation should be located at the child vtable.
2733 VTABLE_ENTRY is a zero-space relocation that describes the use of a
2734 virtual function table entry. The reloc's symbol should refer to the
2735 table of the class mentioned in the code. Off of that base, an offset
2736 describes the entry that is being used. For Rela hosts, this offset
2737 is stored in the reloc's addend. For Rel hosts, we are forced to put
2738 this offset in the reloc's section offset.
2744 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2750 bfd_reloc_type_lookup
2754 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
2757 Return a pointer to a howto structure which, when
2758 invoked, will perform the relocation @var{code} on data from the
2765 bfd_reloc_type_lookup (abfd, code)
2767 bfd_reloc_code_real_type code;
2769 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
2772 static reloc_howto_type bfd_howto_32 =
2773 HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
2778 bfd_default_reloc_type_lookup
2781 reloc_howto_type *bfd_default_reloc_type_lookup
2782 (bfd *abfd, bfd_reloc_code_real_type code);
2785 Provides a default relocation lookup routine for any architecture.
2791 bfd_default_reloc_type_lookup (abfd, code)
2793 bfd_reloc_code_real_type code;
2797 case BFD_RELOC_CTOR:
2798 /* The type of reloc used in a ctor, which will be as wide as the
2799 address - so either a 64, 32, or 16 bitter. */
2800 switch (bfd_get_arch_info (abfd)->bits_per_address)
2805 return &bfd_howto_32;
2814 return (reloc_howto_type *) NULL;
2819 bfd_get_reloc_code_name
2822 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
2825 Provides a printable name for the supplied relocation code.
2826 Useful mainly for printing error messages.
2830 bfd_get_reloc_code_name (code)
2831 bfd_reloc_code_real_type code;
2833 if (code > BFD_RELOC_UNUSED)
2835 return bfd_reloc_code_real_names[(int)code];
2840 bfd_generic_relax_section
2843 boolean bfd_generic_relax_section
2846 struct bfd_link_info *,
2850 Provides default handling for relaxing for back ends which
2851 don't do relaxing -- i.e., does nothing.
2856 bfd_generic_relax_section (abfd, section, link_info, again)
2857 bfd *abfd ATTRIBUTE_UNUSED;
2858 asection *section ATTRIBUTE_UNUSED;
2859 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
2868 bfd_generic_gc_sections
2871 boolean bfd_generic_gc_sections
2872 (bfd *, struct bfd_link_info *);
2875 Provides default handling for relaxing for back ends which
2876 don't do section gc -- i.e., does nothing.
2881 bfd_generic_gc_sections (abfd, link_info)
2882 bfd *abfd ATTRIBUTE_UNUSED;
2883 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
2890 bfd_generic_get_relocated_section_contents
2894 bfd_generic_get_relocated_section_contents (bfd *abfd,
2895 struct bfd_link_info *link_info,
2896 struct bfd_link_order *link_order,
2898 boolean relocateable,
2902 Provides default handling of relocation effort for back ends
2903 which can't be bothered to do it efficiently.
2908 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
2909 relocateable, symbols)
2911 struct bfd_link_info *link_info;
2912 struct bfd_link_order *link_order;
2914 boolean relocateable;
2917 /* Get enough memory to hold the stuff */
2918 bfd *input_bfd = link_order->u.indirect.section->owner;
2919 asection *input_section = link_order->u.indirect.section;
2921 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
2922 arelent **reloc_vector = NULL;
2928 reloc_vector = (arelent **) bfd_malloc ((size_t) reloc_size);
2929 if (reloc_vector == NULL && reloc_size != 0)
2932 /* read in the section */
2933 if (!bfd_get_section_contents (input_bfd,
2937 input_section->_raw_size))
2940 /* We're not relaxing the section, so just copy the size info */
2941 input_section->_cooked_size = input_section->_raw_size;
2942 input_section->reloc_done = true;
2944 reloc_count = bfd_canonicalize_reloc (input_bfd,
2948 if (reloc_count < 0)
2951 if (reloc_count > 0)
2954 for (parent = reloc_vector; *parent != (arelent *) NULL;
2957 char *error_message = (char *) NULL;
2958 bfd_reloc_status_type r =
2959 bfd_perform_relocation (input_bfd,
2963 relocateable ? abfd : (bfd *) NULL,
2968 asection *os = input_section->output_section;
2970 /* A partial link, so keep the relocs */
2971 os->orelocation[os->reloc_count] = *parent;
2975 if (r != bfd_reloc_ok)
2979 case bfd_reloc_undefined:
2980 if (!((*link_info->callbacks->undefined_symbol)
2981 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2982 input_bfd, input_section, (*parent)->address,
2986 case bfd_reloc_dangerous:
2987 BFD_ASSERT (error_message != (char *) NULL);
2988 if (!((*link_info->callbacks->reloc_dangerous)
2989 (link_info, error_message, input_bfd, input_section,
2990 (*parent)->address)))
2993 case bfd_reloc_overflow:
2994 if (!((*link_info->callbacks->reloc_overflow)
2995 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2996 (*parent)->howto->name, (*parent)->addend,
2997 input_bfd, input_section, (*parent)->address)))
3000 case bfd_reloc_outofrange:
3009 if (reloc_vector != NULL)
3010 free (reloc_vector);
3014 if (reloc_vector != NULL)
3015 free (reloc_vector);