| blob | 78a92416e8122807eac262636f6d7e8729110a3d |
1 /* BFD support for handling relocation entries.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 1998
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. */
22 /*
23 SECTION
24 Relocations
26 BFD maintains relocations in much the same way it maintains
27 symbols: they are left alone until required, then read in
28 en-mass 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.
39 @menu
40 @* typedef arelent::
41 @* howto manager::
42 @end menu
44 */
46 /* DO compile in the reloc_code name table from libbfd.h. */
47 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
53 /*
54 DOCDD
55 INODE
56 typedef arelent, howto manager, Relocations, Relocations
58 SUBSECTION
59 typedef arelent
61 This is the structure of a relocation entry:
63 CODE_FRAGMENT
64 .
65 .typedef enum bfd_reloc_status
66 .{
67 . {* No errors detected *}
68 . bfd_reloc_ok,
69 .
70 . {* The relocation was performed, but there was an overflow. *}
71 . bfd_reloc_overflow,
72 .
73 . {* The address to relocate was not within the section supplied. *}
74 . bfd_reloc_outofrange,
75 .
76 . {* Used by special functions *}
77 . bfd_reloc_continue,
78 .
79 . {* Unsupported relocation size requested. *}
80 . bfd_reloc_notsupported,
81 .
82 . {* Unused *}
83 . bfd_reloc_other,
84 .
85 . {* The symbol to relocate against was undefined. *}
86 . bfd_reloc_undefined,
87 .
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. *}
92 . bfd_reloc_dangerous
93 . }
94 . bfd_reloc_status_type;
95 .
96 .
97 .typedef struct reloc_cache_entry
98 .{
99 . {* A pointer into the canonical table of pointers *}
100 . struct symbol_cache_entry **sym_ptr_ptr;
101 .
102 . {* offset in section *}
103 . bfd_size_type address;
104 .
105 . {* addend for relocation value *}
106 . bfd_vma addend;
107 .
108 . {* Pointer to how to perform the required relocation *}
109 . reloc_howto_type *howto;
110 .
111 .} arelent;
113 */
115 /*
116 DESCRIPTION
118 Here is a description of each of the fields within an <<arelent>>:
120 o <<sym_ptr_ptr>>
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.
133 o <<address>>
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
141 world.
143 o <<addend>>
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:
150 | char foo[];
151 | main()
152 | {
153 | return foo[0x12345678];
154 | }
156 Could be compiled into:
158 | linkw fp,#-4
159 | moveb @@#12345678,d0
160 | extbl d0
161 | unlk fp
162 | rts
165 This could create a reloc pointing to <<foo>>, but leave the
166 offset in the data, something like:
169 |RELOCATION RECORDS FOR [.text]:
170 |offset type value
171 |00000006 32 _foo
172 |
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
177 |0000000e 4e75 ; rts
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)
187 | jmp r1
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]:
195 |offset type value
196 |00000002 HVRT16 _foo+0x12340000
197 |00000006 LVRT16 _foo+0x12340000
198 |
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.
217 | save %sp,-112,%sp
218 | sethi %hi(_foo+0x12345678),%g2
219 | ldsb [%g2+%lo(_foo+0x12345678)],%i0
220 | ret
221 | restore
223 Both relocs contain a pointer to <<foo>>, and the offsets
224 contain junk.
227 |RELOCATION RECORDS FOR [.text]:
228 |offset type value
229 |00000004 HI22 _foo+0x12345678
230 |00000008 LO10 _foo+0x12345678
231 |
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
239 o <<howto>>
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.
249 */
251 /*
252 SUBSUBSECTION
253 <<enum complain_overflow>>
255 Indicates what sort of overflow checking should be done when
256 performing a relocation.
258 CODE_FRAGMENT
259 .
260 .enum complain_overflow
261 .{
262 . {* Do not complain on overflow. *}
263 . complain_overflow_dont,
264 .
265 . {* Complain if the bitfield overflows, whether it is considered
266 . as signed or unsigned. *}
267 . complain_overflow_bitfield,
268 .
269 . {* Complain if the value overflows when considered as signed
270 . number. *}
271 . complain_overflow_signed,
272 .
273 . {* Complain if the value overflows when considered as an
274 . unsigned number. *}
275 . complain_overflow_unsigned
276 .};
278 */
280 /*
281 SUBSUBSECTION
282 <<reloc_howto_type>>
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.
287 CODE_FRAGMENT
288 .struct symbol_cache_entry; {* Forward declaration *}
289 .
290 .struct reloc_howto_struct
291 .{
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. *}
298 . unsigned int type;
299 .
300 . {* The value the final relocation is shifted right by. This drops
301 . unwanted data from the relocation. *}
302 . unsigned int rightshift;
303 .
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. *}
307 . int size;
308 .
309 . {* The number of bits in the item to be relocated. This is used
310 . when doing overflow checking. *}
311 . unsigned int bitsize;
312 .
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;
318 .
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;
322 .
323 . {* What type of overflow error should be checked for when
324 . relocating. *}
325 . enum complain_overflow complain_on_overflow;
326 .
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
330 . instructions). *}
331 . bfd_reloc_status_type (*special_function)
332 . PARAMS ((bfd *abfd,
333 . arelent *reloc_entry,
334 . struct symbol_cache_entry *symbol,
335 . PTR data,
336 . asection *input_section,
337 . bfd *output_bfd,
338 . char **error_message));
339 .
340 . {* The textual name of the relocation type. *}
341 . char *name;
342 .
343 . {* When performing a partial link, some formats must modify the
344 . relocations rather than the data - this flag signals this.*}
345 . boolean partial_inplace;
346 .
347 . {* The src_mask selects which parts of the read in data
348 . are to be used in the relocation sum. E.g., if this was an 8 bit
349 . bit of data which we read and relocated, this would be
350 . 0x000000ff. When we have relocs which have an addend, such as
351 . sun4 extended relocs, the value in the offset part of a
352 . relocating field is garbage so we never use it. In this case
353 . the mask would be 0x00000000. *}
354 . bfd_vma src_mask;
355 .
356 . {* The dst_mask selects which parts of the instruction are replaced
357 . into the instruction. In most cases src_mask == dst_mask,
358 . except in the above special case, where dst_mask would be
359 . 0x000000ff, and src_mask would be 0x00000000. *}
360 . bfd_vma dst_mask;
361 .
362 . {* When some formats create PC relative instructions, they leave
363 . the value of the pc of the place being relocated in the offset
364 . slot of the instruction, so that a PC relative relocation can
365 . be made just by adding in an ordinary offset (e.g., sun3 a.out).
366 . Some formats leave the displacement part of an instruction
367 . empty (e.g., m88k bcs); this flag signals the fact.*}
368 . boolean pcrel_offset;
369 .
370 .};
372 */
374 /*
375 FUNCTION
376 The HOWTO Macro
378 DESCRIPTION
379 The HOWTO define is horrible and will go away.
382 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
383 . {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
385 DESCRIPTION
386 And will be replaced with the totally magic way. But for the
387 moment, we are compatible, so do it this way.
390 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
391 .
392 DESCRIPTION
393 Helper routine to turn a symbol into a relocation value.
395 .#define HOWTO_PREPARE(relocation, symbol) \
396 . { \
397 . if (symbol != (asymbol *)NULL) { \
398 . if (bfd_is_com_section (symbol->section)) { \
399 . relocation = 0; \
400 . } \
401 . else { \
402 . relocation = symbol->value; \
403 . } \
404 . } \
405 .}
407 */
409 /*
410 FUNCTION
411 bfd_get_reloc_size
413 SYNOPSIS
414 unsigned int bfd_get_reloc_size (reloc_howto_type *);
416 DESCRIPTION
417 For a reloc_howto_type that operates on a fixed number of bytes,
418 this returns the number of bytes operated on.
419 */
421 unsigned int
424 {
426 {
435 }
436 }
438 /*
439 TYPEDEF
440 arelent_chain
442 DESCRIPTION
444 How relocs are tied together in an <<asection>>:
446 .typedef struct relent_chain {
447 . arelent relent;
448 . struct relent_chain *next;
449 .} arelent_chain;
451 */
454 /*
455 FUNCTION
456 bfd_check_overflow
458 SYNOPSIS
459 bfd_reloc_status_type
460 bfd_check_overflow
461 (enum complain_overflow how,
462 unsigned int bitsize,
463 unsigned int rightshift,
464 bfd_vma relocation);
466 DESCRIPTION
467 Perform overflow checking on @var{relocation} which has @var{bitsize}
468 significant bits and will be shifted right by @var{rightshift} bits.
469 The result is either of @code{bfd_reloc_ok} or
470 @code{bfd_reloc_overflow}.
472 */
474 bfd_reloc_status_type
478 bfd_vma relocation;
479 {
480 bfd_vma check;
483 /* Get the value that will be used for the relocation, but
484 starting at bit position zero. */
488 {
493 {
494 /* Assumes two's complement. */
495 bfd_signed_vma reloc_signed_max =
499 /* The above right shift is incorrect for a signed value.
500 Fix it up by forcing on the upper bits. */
509 }
513 {
514 /* Assumes two's complement. This expression avoids
515 overflow if `bitsize' is the number of bits in
516 bfd_vma. */
517 bfd_vma reloc_unsigned_max =
522 }
526 {
527 /* Assumes two's complement. This expression avoids
528 overflow if `bitsize' is the number of bits in
529 bfd_vma. */
534 {
535 /* The above right shift is incorrect for a signed
536 value. See if turning on the upper bits fixes the
537 overflow. */
540 {
546 }
547 else
549 }
550 }
555 }
558 }
561 /*
562 FUNCTION
563 bfd_perform_relocation
565 SYNOPSIS
566 bfd_reloc_status_type
567 bfd_perform_relocation
568 (bfd *abfd,
569 arelent *reloc_entry,
570 PTR data,
571 asection *input_section,
572 bfd *output_bfd,
573 char **error_message);
575 DESCRIPTION
576 If @var{output_bfd} is supplied to this function, the
577 generated image will be relocatable; the relocations are
578 copied to the output file after they have been changed to
579 reflect the new state of the world. There are two ways of
580 reflecting the results of partial linkage in an output file:
581 by modifying the output data in place, and by modifying the
582 relocation record. Some native formats (e.g., basic a.out and
583 basic coff) have no way of specifying an addend in the
584 relocation type, so the addend has to go in the output data.
585 This is no big deal since in these formats the output data
586 slot will always be big enough for the addend. Complex reloc
587 types with addends were invented to solve just this problem.
588 The @var{error_message} argument is set to an error message if
589 this return @code{bfd_reloc_dangerous}.
591 */
594 bfd_reloc_status_type
596 error_message)
599 PTR data;
603 {
604 bfd_vma relocation;
615 {
618 }
620 /* If we are not producing relocateable output, return an error if
621 the symbol is not defined. An undefined weak symbol is
622 considered to have a value of zero (SVR4 ABI, p. 4-27). */
628 /* If there is a function supplied to handle this relocation type,
629 call it. It'll return `bfd_reloc_continue' if further processing
630 can be done. */
632 {
633 bfd_reloc_status_type cont;
636 error_message);
639 }
641 /* Is the address of the relocation really within the section? */
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.) */
651 else
657 /* Convert input-section-relative symbol value to absolute. */
660 else
665 /* Add in supplied addend. */
668 /* Here the variable relocation holds the final address of the
669 symbol we are relocating against, plus any addend. */
672 {
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
678 the location.
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. */
701 relocation -=
706 }
709 {
711 {
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. */
718 }
719 else
720 {
721 /* This is a partial relocation, but inplace, so modify the
722 reloc record a bit.
724 If we've relocated with a symbol with a section, change
725 into a ref to the section belonging to the symbol. */
729 /* WTF?? */
735 {
736 #if 1
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:
793 1) build the linker
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
800 5) repeat step 2
801 6) if the resulting object files are the same, you have at least
802 made it no worse
803 7) if they are different you have to figure out which version is
804 right
805 */
807 #endif
809 }
810 else
811 {
813 }
814 }
815 }
816 else
817 {
819 }
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
825 machine word.
826 FIXME: We should also do overflow checking on the result after
827 adding in the value contained in the object file. */
833 /*
834 Either we are relocating all the way, or we don't want to apply
835 the relocation to the reloc entry (probably because there isn't
836 any room in the output format to describe addends to relocs)
837 */
839 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
840 (OSF version 1.3, compiler version 3.11). It miscompiles the
841 following program:
843 struct str
844 {
845 unsigned int i0;
846 } s = { 0 };
848 int
849 main ()
850 {
851 unsigned long x;
853 x = 0x100000000;
854 x <<= (unsigned long) s.i0;
855 if (x == 0)
856 printf ("failed\n");
857 else
858 printf ("succeeded (%lx)\n", x);
859 }
860 */
864 /* Shift everything up to where it's going to be used */
868 /* Wait for the day when all have the mask in them */
870 /* What we do:
871 i instruction to be left alone
872 o offset within instruction
873 r relocation offset to apply
874 S src mask
875 D dst mask
876 N ~dst mask
877 A part 1
878 B part 2
879 R result
881 Do this:
882 i i i i i o o o o o from bfd_get<size>
883 and S S S S S to get the size offset we want
884 + r r r r r r r r r r to get the final value to place
885 and D D D D D to chop to right size
886 -----------------------
887 A A A A A
888 And this:
889 ... i i i i i o o o o o from bfd_get<size>
890 and N N N N N get instruction
891 -----------------------
892 ... B B B B B
894 And then:
895 B B B B B
896 or A A A A A
897 -----------------------
898 R R R R R R R R R R put into bfd_put<size>
899 */
901 #define DOIT(x) \
902 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
905 {
907 {
911 }
915 {
919 }
922 {
926 }
929 {
934 }
938 {
943 }
947 /* Do nothing */
951 #ifdef BFD64
952 {
956 }
957 #else
959 #endif
963 }
966 }
968 /*
969 FUNCTION
970 bfd_install_relocation
972 SYNOPSIS
973 bfd_reloc_status_type
974 bfd_install_relocation
975 (bfd *abfd,
976 arelent *reloc_entry,
977 PTR data, bfd_vma data_start,
978 asection *input_section,
979 char **error_message);
981 DESCRIPTION
982 This looks remarkably like <<bfd_perform_relocation>>, except it
983 does not expect that the section contents have been filled in.
984 I.e., it's suitable for use when creating, rather than applying
985 a relocation.
987 For now, this function should be considered reserved for the
988 assembler.
990 */
993 bfd_reloc_status_type
998 PTR data_start;
999 bfd_vma data_start_offset;
1002 {
1003 bfd_vma relocation;
1014 {
1017 }
1019 /* If there is a function supplied to handle this relocation type,
1020 call it. It'll return `bfd_reloc_continue' if further processing
1021 can be done. */
1023 {
1024 bfd_reloc_status_type cont;
1026 /* XXX - The special_function calls haven't been fixed up to deal
1027 with creating new relocations and section contents. */
1029 /* XXX - Non-portable! */
1035 }
1037 /* Is the address of the relocation really within the section? */
1041 /* Work out which section the relocation is targetted at and the
1042 initial relocation command value. */
1044 /* Get symbol value. (Common symbols are special.) */
1047 else
1052 /* Convert input-section-relative symbol value to absolute. */
1055 else
1060 /* Add in supplied addend. */
1063 /* Here the variable relocation holds the final address of the
1064 symbol we are relocating against, plus any addend. */
1067 {
1068 /* This is a PC relative relocation. We want to set RELOCATION
1069 to the distance between the address of the symbol and the
1070 location. RELOCATION is already the address of the symbol.
1072 We start by subtracting the address of the section containing
1073 the location.
1075 If pcrel_offset is set, we must further subtract the position
1076 of the location within the section. Some targets arrange for
1077 the addend to be the negative of the position of the location
1078 within the section; for example, i386-aout does this. For
1079 i386-aout, pcrel_offset is false. Some other targets do not
1080 include the position of the location; for example, m88kbcs,
1081 or ELF. For those targets, pcrel_offset is true.
1083 If we are producing relocateable output, then we must ensure
1084 that this reloc will be correctly computed when the final
1085 relocation is done. If pcrel_offset is false we want to wind
1086 up with the negative of the location within the section,
1087 which means we must adjust the existing addend by the change
1088 in the location within the section. If pcrel_offset is true
1089 we do not want to adjust the existing addend at all.
1091 FIXME: This seems logical to me, but for the case of
1092 producing relocateable output it is not what the code
1093 actually does. I don't want to change it, because it seems
1094 far too likely that something will break. */
1096 relocation -=
1101 }
1104 {
1105 /* This is a partial relocation, and we want to apply the relocation
1106 to the reloc entry rather than the raw data. Modify the reloc
1107 inplace to reflect what we now know. */
1111 }
1112 else
1113 {
1114 /* This is a partial relocation, but inplace, so modify the
1115 reloc record a bit.
1117 If we've relocated with a symbol with a section, change
1118 into a ref to the section belonging to the symbol. */
1122 /* WTF?? */
1128 {
1129 #if 1
1130 /* For m68k-coff, the addend was being subtracted twice during
1131 relocation with -r. Removing the line below this comment
1132 fixes that problem; see PR 2953.
1134 However, Ian wrote the following, regarding removing the line below,
1135 which explains why it is still enabled: --djm
1137 If you put a patch like that into BFD you need to check all the COFF
1138 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
1139 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1140 problem in a different way. There may very well be a reason that the
1141 code works as it does.
1143 Hmmm. The first obvious point is that bfd_install_relocation should
1144 not have any tests that depend upon the flavour. It's seem like
1145 entirely the wrong place for such a thing. The second obvious point
1146 is that the current code ignores the reloc addend when producing
1147 relocateable output for COFF. That's peculiar. In fact, I really
1148 have no idea what the point of the line you want to remove is.
1150 A typical COFF reloc subtracts the old value of the symbol and adds in
1151 the new value to the location in the object file (if it's a pc
1152 relative reloc it adds the difference between the symbol value and the
1153 location). When relocating we need to preserve that property.
1155 BFD handles this by setting the addend to the negative of the old
1156 value of the symbol. Unfortunately it handles common symbols in a
1157 non-standard way (it doesn't subtract the old value) but that's a
1158 different story (we can't change it without losing backward
1159 compatibility with old object files) (coff-i386 does subtract the old
1160 value, to be compatible with existing coff-i386 targets, like SCO).
1162 So everything works fine when not producing relocateable output. When
1163 we are producing relocateable output, logically we should do exactly
1164 what we do when not producing relocateable output. Therefore, your
1165 patch is correct. In fact, it should probably always just set
1166 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1167 add the value into the object file. This won't hurt the COFF code,
1168 which doesn't use the addend; I'm not sure what it will do to other
1169 formats (the thing to check for would be whether any formats both use
1170 the addend and set partial_inplace).
1172 When I wanted to make coff-i386 produce relocateable output, I ran
1173 into the problem that you are running into: I wanted to remove that
1174 line. Rather than risk it, I made the coff-i386 relocs use a special
1175 function; it's coff_i386_reloc in coff-i386.c. The function
1176 specifically adds the addend field into the object file, knowing that
1177 bfd_install_relocation is not going to. If you remove that line, then
1178 coff-i386.c will wind up adding the addend field in twice. It's
1179 trivial to fix; it just needs to be done.
1181 The problem with removing the line is just that it may break some
1182 working code. With BFD it's hard to be sure of anything. The right
1183 way to deal with this is simply to build and test at least all the
1184 supported COFF targets. It should be straightforward if time and disk
1185 space consuming. For each target:
1186 1) build the linker
1187 2) generate some executable, and link it using -r (I would
1188 probably use paranoia.o and link against newlib/libc.a, which
1189 for all the supported targets would be available in
1190 /usr/cygnus/progressive/H-host/target/lib/libc.a).
1191 3) make the change to reloc.c
1192 4) rebuild the linker
1193 5) repeat step 2
1194 6) if the resulting object files are the same, you have at least
1195 made it no worse
1196 7) if they are different you have to figure out which version is
1197 right
1198 */
1200 #endif
1202 }
1203 else
1204 {
1206 }
1207 }
1209 /* FIXME: This overflow checking is incomplete, because the value
1210 might have overflowed before we get here. For a correct check we
1211 need to compute the value in a size larger than bitsize, but we
1212 can't reasonably do that for a reloc the same size as a host
1213 machine word.
1214 FIXME: We should also do overflow checking on the result after
1215 adding in the value contained in the object file. */
1220 /*
1221 Either we are relocating all the way, or we don't want to apply
1222 the relocation to the reloc entry (probably because there isn't
1223 any room in the output format to describe addends to relocs)
1224 */
1226 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1227 (OSF version 1.3, compiler version 3.11). It miscompiles the
1228 following program:
1230 struct str
1231 {
1232 unsigned int i0;
1233 } s = { 0 };
1235 int
1236 main ()
1237 {
1238 unsigned long x;
1240 x = 0x100000000;
1241 x <<= (unsigned long) s.i0;
1242 if (x == 0)
1243 printf ("failed\n");
1244 else
1245 printf ("succeeded (%lx)\n", x);
1246 }
1247 */
1251 /* Shift everything up to where it's going to be used */
1255 /* Wait for the day when all have the mask in them */
1257 /* What we do:
1258 i instruction to be left alone
1259 o offset within instruction
1260 r relocation offset to apply
1261 S src mask
1262 D dst mask
1263 N ~dst mask
1264 A part 1
1265 B part 2
1266 R result
1268 Do this:
1269 i i i i i o o o o o from bfd_get<size>
1270 and S S S S S to get the size offset we want
1271 + r r r r r r r r r r to get the final value to place
1272 and D D D D D to chop to right size
1273 -----------------------
1274 A A A A A
1275 And this:
1276 ... i i i i i o o o o o from bfd_get<size>
1277 and N N N N N get instruction
1278 -----------------------
1279 ... B B B B B
1281 And then:
1282 B B B B B
1283 or A A A A A
1284 -----------------------
1285 R R R R R R R R R R put into bfd_put<size>
1286 */
1288 #define DOIT(x) \
1289 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
1294 {
1296 {
1300 }
1304 {
1308 }
1311 {
1315 }
1318 {
1323 }
1327 /* Do nothing */
1331 {
1335 }
1339 }
1342 }
1344 /* This relocation routine is used by some of the backend linkers.
1345 They do not construct asymbol or arelent structures, so there is no
1346 reason for them to use bfd_perform_relocation. Also,
1347 bfd_perform_relocation is so hacked up it is easier to write a new
1348 function than to try to deal with it.
1350 This routine does a final relocation. Whether it is useful for a
1351 relocateable link depends upon how the object format defines
1352 relocations.
1354 FIXME: This routine ignores any special_function in the HOWTO,
1355 since the existing special_function values have been written for
1356 bfd_perform_relocation.
1358 HOWTO is the reloc howto information.
1359 INPUT_BFD is the BFD which the reloc applies to.
1360 INPUT_SECTION is the section which the reloc applies to.
1361 CONTENTS is the contents of the section.
1362 ADDRESS is the address of the reloc within INPUT_SECTION.
1363 VALUE is the value of the symbol the reloc refers to.
1364 ADDEND is the addend of the reloc. */
1366 bfd_reloc_status_type
1373 bfd_vma address;
1374 bfd_vma value;
1375 bfd_vma addend;
1376 {
1377 bfd_vma relocation;
1379 /* Sanity check the address. */
1383 /* This function assumes that we are dealing with a basic relocation
1384 against a symbol. We want to compute the value of the symbol to
1385 relocate to. This is just VALUE, the value of the symbol, plus
1386 ADDEND, any addend associated with the reloc. */
1389 /* If the relocation is PC relative, we want to set RELOCATION to
1390 the distance between the symbol (currently in RELOCATION) and the
1391 location we are relocating. Some targets (e.g., i386-aout)
1392 arrange for the contents of the section to be the negative of the
1393 offset of the location within the section; for such targets
1394 pcrel_offset is false. Other targets (e.g., m88kbcs or ELF)
1395 simply leave the contents of the section as zero; for such
1396 targets pcrel_offset is true. If pcrel_offset is false we do not
1397 need to subtract out the offset of the location within the
1398 section (which is just ADDRESS). */
1400 {
1405 }
1409 }
1411 /* Relocate a given location using a given value and howto. */
1413 bfd_reloc_status_type
1417 bfd_vma relocation;
1419 {
1421 bfd_vma x;
1422 boolean overflow;
1424 /* If the size is negative, negate RELOCATION. This isn't very
1425 general. */
1429 /* Get the value we are going to relocate. */
1432 {
1446 #ifdef BFD64
1448 #else
1450 #endif
1452 }
1454 /* Check for overflow. FIXME: We may drop bits during the addition
1455 which we don't check for. We must either check at every single
1456 operation, which would be tedious, or we must do the computations
1457 in a type larger than bfd_vma, which would be inefficient. */
1460 {
1461 bfd_vma check;
1462 bfd_signed_vma signed_check;
1463 bfd_vma add;
1464 bfd_signed_vma signed_add;
1467 {
1470 }
1471 else
1472 {
1473 /* Drop unwanted bits from the value we are relocating to. */
1476 /* If this is a signed value, the rightshift just dropped
1477 leading 1 bits (assuming twos complement). */
1480 else
1481 signed_check = (check
1484 }
1486 /* Get the value from the object file. */
1489 /* Get the value from the object file with an appropriate sign.
1490 The expression involving howto->src_mask isolates the upper
1491 bit of src_mask. If that bit is set in the value we are
1492 adding, it is negative, and we subtract out that number times
1493 two. If src_mask includes the highest possible bit, then we
1494 can not get the upper bit, but that does not matter since
1495 signed_add needs no adjustment to become negative in that
1496 case. */
1501 /* Add the value from the object file, shifted so that it is a
1502 straight number. */
1504 {
1507 }
1508 else
1509 {
1512 /* For the signed case we use ADD, rather than SIGNED_ADD,
1513 to avoid warnings from SVR4 cc. This is OK since we
1514 explictly handle the sign bits. */
1517 else
1521 }
1524 {
1526 {
1527 /* Assumes two's complement. */
1528 bfd_signed_vma reloc_signed_max =
1535 }
1538 {
1539 /* Assumes two's complement. This expression avoids
1540 overflow if howto->bitsize is the number of bits in
1541 bfd_vma. */
1542 bfd_vma reloc_unsigned_max =
1547 }
1550 {
1551 /* Assumes two's complement. This expression avoids
1552 overflow if howto->bitsize is the number of bits in
1553 bfd_vma. */
1560 }
1564 }
1565 }
1567 /* Put RELOCATION in the right bits. */
1571 /* Add RELOCATION to the right bits of X. */
1575 /* Put the relocated value back in the object file. */
1577 {
1591 #ifdef BFD64
1593 #else
1595 #endif
1597 }
1600 }
1602 /*
1603 DOCDD
1604 INODE
1605 howto manager, , typedef arelent, Relocations
1607 SECTION
1608 The howto manager
1610 When an application wants to create a relocation, but doesn't
1611 know what the target machine might call it, it can find out by
1612 using this bit of code.
1614 */
1616 /*
1617 TYPEDEF
1618 bfd_reloc_code_type
1620 DESCRIPTION
1621 The insides of a reloc code. The idea is that, eventually, there
1622 will be one enumerator for every type of relocation we ever do.
1623 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1624 return a howto pointer.
1626 This does mean that the application must determine the correct
1627 enumerator value; you can't get a howto pointer from a random set
1628 of attributes.
1630 SENUM
1631 bfd_reloc_code_real
1633 ENUM
1634 BFD_RELOC_64
1635 ENUMX
1636 BFD_RELOC_32
1637 ENUMX
1638 BFD_RELOC_26
1639 ENUMX
1640 BFD_RELOC_24
1641 ENUMX
1642 BFD_RELOC_16
1643 ENUMX
1644 BFD_RELOC_14
1645 ENUMX
1646 BFD_RELOC_8
1647 ENUMDOC
1648 Basic absolute relocations of N bits.
1650 ENUM
1651 BFD_RELOC_64_PCREL
1652 ENUMX
1653 BFD_RELOC_32_PCREL
1654 ENUMX
1655 BFD_RELOC_24_PCREL
1656 ENUMX
1657 BFD_RELOC_16_PCREL
1658 ENUMX
1659 BFD_RELOC_12_PCREL
1660 ENUMX
1661 BFD_RELOC_8_PCREL
1662 ENUMDOC
1663 PC-relative relocations. Sometimes these are relative to the address
1664 of the relocation itself; sometimes they are relative to the start of
1665 the section containing the relocation. It depends on the specific target.
1667 The 24-bit relocation is used in some Intel 960 configurations.
1669 ENUM
1670 BFD_RELOC_32_GOT_PCREL
1671 ENUMX
1672 BFD_RELOC_16_GOT_PCREL
1673 ENUMX
1674 BFD_RELOC_8_GOT_PCREL
1675 ENUMX
1676 BFD_RELOC_32_GOTOFF
1677 ENUMX
1678 BFD_RELOC_16_GOTOFF
1679 ENUMX
1680 BFD_RELOC_LO16_GOTOFF
1681 ENUMX
1682 BFD_RELOC_HI16_GOTOFF
1683 ENUMX
1684 BFD_RELOC_HI16_S_GOTOFF
1685 ENUMX
1686 BFD_RELOC_8_GOTOFF
1687 ENUMX
1688 BFD_RELOC_32_PLT_PCREL
1689 ENUMX
1690 BFD_RELOC_24_PLT_PCREL
1691 ENUMX
1692 BFD_RELOC_16_PLT_PCREL
1693 ENUMX
1694 BFD_RELOC_8_PLT_PCREL
1695 ENUMX
1696 BFD_RELOC_32_PLTOFF
1697 ENUMX
1698 BFD_RELOC_16_PLTOFF
1699 ENUMX
1700 BFD_RELOC_LO16_PLTOFF
1701 ENUMX
1702 BFD_RELOC_HI16_PLTOFF
1703 ENUMX
1704 BFD_RELOC_HI16_S_PLTOFF
1705 ENUMX
1706 BFD_RELOC_8_PLTOFF
1707 ENUMDOC
1708 For ELF.
1710 ENUM
1711 BFD_RELOC_68K_GLOB_DAT
1712 ENUMX
1713 BFD_RELOC_68K_JMP_SLOT
1714 ENUMX
1715 BFD_RELOC_68K_RELATIVE
1716 ENUMDOC
1717 Relocations used by 68K ELF.
1719 ENUM
1720 BFD_RELOC_32_BASEREL
1721 ENUMX
1722 BFD_RELOC_16_BASEREL
1723 ENUMX
1724 BFD_RELOC_LO16_BASEREL
1725 ENUMX
1726 BFD_RELOC_HI16_BASEREL
1727 ENUMX
1728 BFD_RELOC_HI16_S_BASEREL
1729 ENUMX
1730 BFD_RELOC_8_BASEREL
1731 ENUMX
1732 BFD_RELOC_RVA
1733 ENUMDOC
1734 Linkage-table relative.
1736 ENUM
1737 BFD_RELOC_8_FFnn
1738 ENUMDOC
1739 Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1741 ENUM
1742 BFD_RELOC_32_PCREL_S2
1743 ENUMX
1744 BFD_RELOC_16_PCREL_S2
1745 ENUMX
1746 BFD_RELOC_23_PCREL_S2
1747 ENUMDOC
1748 These PC-relative relocations are stored as word displacements --
1749 i.e., byte displacements shifted right two bits. The 30-bit word
1750 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1751 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The
1752 signed 16-bit displacement is used on the MIPS, and the 23-bit
1753 displacement is used on the Alpha.
1755 ENUM
1756 BFD_RELOC_HI22
1757 ENUMX
1758 BFD_RELOC_LO10
1759 ENUMDOC
1760 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1761 the target word. These are used on the SPARC.
1763 ENUM
1764 BFD_RELOC_GPREL16
1765 ENUMX
1766 BFD_RELOC_GPREL32
1767 ENUMDOC
1768 For systems that allocate a Global Pointer register, these are
1769 displacements off that register. These relocation types are
1770 handled specially, because the value the register will have is
1771 decided relatively late.
1774 ENUM
1775 BFD_RELOC_I960_CALLJ
1776 ENUMDOC
1777 Reloc types used for i960/b.out.
1779 ENUM
1780 BFD_RELOC_NONE
1781 ENUMX
1782 BFD_RELOC_SPARC_WDISP22
1783 ENUMX
1784 BFD_RELOC_SPARC22
1785 ENUMX
1786 BFD_RELOC_SPARC13
1787 ENUMX
1788 BFD_RELOC_SPARC_GOT10
1789 ENUMX
1790 BFD_RELOC_SPARC_GOT13
1791 ENUMX
1792 BFD_RELOC_SPARC_GOT22
1793 ENUMX
1794 BFD_RELOC_SPARC_PC10
1795 ENUMX
1796 BFD_RELOC_SPARC_PC22
1797 ENUMX
1798 BFD_RELOC_SPARC_WPLT30
1799 ENUMX
1800 BFD_RELOC_SPARC_COPY
1801 ENUMX
1802 BFD_RELOC_SPARC_GLOB_DAT
1803 ENUMX
1804 BFD_RELOC_SPARC_JMP_SLOT
1805 ENUMX
1806 BFD_RELOC_SPARC_RELATIVE
1807 ENUMX
1808 BFD_RELOC_SPARC_UA32
1809 ENUMDOC
1810 SPARC ELF relocations. There is probably some overlap with other
1811 relocation types already defined.
1813 ENUM
1814 BFD_RELOC_SPARC_BASE13
1815 ENUMX
1816 BFD_RELOC_SPARC_BASE22
1817 ENUMDOC
1818 I think these are specific to SPARC a.out (e.g., Sun 4).
1820 ENUMEQ
1821 BFD_RELOC_SPARC_64
1822 BFD_RELOC_64
1823 ENUMX
1824 BFD_RELOC_SPARC_10
1825 ENUMX
1826 BFD_RELOC_SPARC_11
1827 ENUMX
1828 BFD_RELOC_SPARC_OLO10
1829 ENUMX
1830 BFD_RELOC_SPARC_HH22
1831 ENUMX
1832 BFD_RELOC_SPARC_HM10
1833 ENUMX
1834 BFD_RELOC_SPARC_LM22
1835 ENUMX
1836 BFD_RELOC_SPARC_PC_HH22
1837 ENUMX
1838 BFD_RELOC_SPARC_PC_HM10
1839 ENUMX
1840 BFD_RELOC_SPARC_PC_LM22
1841 ENUMX
1842 BFD_RELOC_SPARC_WDISP16
1843 ENUMX
1844 BFD_RELOC_SPARC_WDISP19
1845 ENUMX
1846 BFD_RELOC_SPARC_7
1847 ENUMX
1848 BFD_RELOC_SPARC_6
1849 ENUMX
1850 BFD_RELOC_SPARC_5
1851 ENUMEQX
1852 BFD_RELOC_SPARC_DISP64
1853 BFD_RELOC_64_PCREL
1854 ENUMX
1855 BFD_RELOC_SPARC_PLT64
1856 ENUMX
1857 BFD_RELOC_SPARC_HIX22
1858 ENUMX
1859 BFD_RELOC_SPARC_LOX10
1860 ENUMX
1861 BFD_RELOC_SPARC_H44
1862 ENUMX
1863 BFD_RELOC_SPARC_M44
1864 ENUMX
1865 BFD_RELOC_SPARC_L44
1866 ENUMX
1867 BFD_RELOC_SPARC_REGISTER
1868 ENUMDOC
1869 SPARC64 relocations
1871 ENUM
1872 BFD_RELOC_SPARC_32LE
1873 ENUMDOC
1874 SPARC little endian relocation
1876 ENUM
1877 BFD_RELOC_ALPHA_GPDISP_HI16
1878 ENUMDOC
1879 Alpha ECOFF and ELF relocations. Some of these treat the symbol or
1880 "addend" in some special way.
1881 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1882 writing; when reading, it will be the absolute section symbol. The
1883 addend is the displacement in bytes of the "lda" instruction from
1884 the "ldah" instruction (which is at the address of this reloc).
1885 ENUM
1886 BFD_RELOC_ALPHA_GPDISP_LO16
1887 ENUMDOC
1888 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1889 with GPDISP_HI16 relocs. The addend is ignored when writing the
1890 relocations out, and is filled in with the file's GP value on
1891 reading, for convenience.
1893 ENUM
1894 BFD_RELOC_ALPHA_GPDISP
1895 ENUMDOC
1896 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1897 relocation except that there is no accompanying GPDISP_LO16
1898 relocation.
1900 ENUM
1901 BFD_RELOC_ALPHA_LITERAL
1902 ENUMX
1903 BFD_RELOC_ALPHA_ELF_LITERAL
1904 ENUMX
1905 BFD_RELOC_ALPHA_LITUSE
1906 ENUMDOC
1907 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1908 the assembler turns it into a LDQ instruction to load the address of
1909 the symbol, and then fills in a register in the real instruction.
1911 The LITERAL reloc, at the LDQ instruction, refers to the .lita
1912 section symbol. The addend is ignored when writing, but is filled
1913 in with the file's GP value on reading, for convenience, as with the
1914 GPDISP_LO16 reloc.
1916 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1917 It should refer to the symbol to be referenced, as with 16_GOTOFF,
1918 but it generates output not based on the position within the .got
1919 section, but relative to the GP value chosen for the file during the
1920 final link stage.
1922 The LITUSE reloc, on the instruction using the loaded address, gives
1923 information to the linker that it might be able to use to optimize
1924 away some literal section references. The symbol is ignored (read
1925 as the absolute section symbol), and the "addend" indicates the type
1926 of instruction using the register:
1927 1 - "memory" fmt insn
1928 2 - byte-manipulation (byte offset reg)
1929 3 - jsr (target of branch)
1931 The GNU linker currently doesn't do any of this optimizing.
1933 ENUM
1934 BFD_RELOC_ALPHA_HINT
1935 ENUMDOC
1936 The HINT relocation indicates a value that should be filled into the
1937 "hint" field of a jmp/jsr/ret instruction, for possible branch-
1938 prediction logic which may be provided on some processors.
1940 ENUM
1941 BFD_RELOC_ALPHA_LINKAGE
1942 ENUMDOC
1943 The LINKAGE relocation outputs a linkage pair in the object file,
1944 which is filled by the linker.
1946 ENUM
1947 BFD_RELOC_ALPHA_CODEADDR
1948 ENUMDOC
1949 The CODEADDR relocation outputs a STO_CA in the object file,
1950 which is filled by the linker.
1952 ENUM
1953 BFD_RELOC_MIPS_JMP
1954 ENUMDOC
1955 Bits 27..2 of the relocation address shifted right 2 bits;
1956 simple reloc otherwise.
1958 ENUM
1959 BFD_RELOC_MIPS16_JMP
1960 ENUMDOC
1961 The MIPS16 jump instruction.
1963 ENUM
1964 BFD_RELOC_MIPS16_GPREL
1965 ENUMDOC
1966 MIPS16 GP relative reloc.
1968 ENUM
1969 BFD_RELOC_HI16
1970 ENUMDOC
1971 High 16 bits of 32-bit value; simple reloc.
1972 ENUM
1973 BFD_RELOC_HI16_S
1974 ENUMDOC
1975 High 16 bits of 32-bit value but the low 16 bits will be sign
1976 extended and added to form the final result. If the low 16
1977 bits form a negative number, we need to add one to the high value
1978 to compensate for the borrow when the low bits are added.
1979 ENUM
1980 BFD_RELOC_LO16
1981 ENUMDOC
1982 Low 16 bits.
1983 ENUM
1984 BFD_RELOC_PCREL_HI16_S
1985 ENUMDOC
1986 Like BFD_RELOC_HI16_S, but PC relative.
1987 ENUM
1988 BFD_RELOC_PCREL_LO16
1989 ENUMDOC
1990 Like BFD_RELOC_LO16, but PC relative.
1992 ENUMEQ
1993 BFD_RELOC_MIPS_GPREL
1994 BFD_RELOC_GPREL16
1995 ENUMDOC
1996 Relocation relative to the global pointer.
1998 ENUM
1999 BFD_RELOC_MIPS_LITERAL
2000 ENUMDOC
2001 Relocation against a MIPS literal section.
2003 ENUM
2004 BFD_RELOC_MIPS_GOT16
2005 ENUMX
2006 BFD_RELOC_MIPS_CALL16
2007 ENUMEQX
2008 BFD_RELOC_MIPS_GPREL32
2009 BFD_RELOC_GPREL32
2010 ENUMX
2011 BFD_RELOC_MIPS_GOT_HI16
2012 ENUMX
2013 BFD_RELOC_MIPS_GOT_LO16
2014 ENUMX
2015 BFD_RELOC_MIPS_CALL_HI16
2016 ENUMX
2017 BFD_RELOC_MIPS_CALL_LO16
2018 COMMENT
2019 {* start-sanitize-r5900 *}
2020 ENUMX
2021 BFD_RELOC_MIPS15_S3
2022 COMMENT
2023 {* end-sanitize-r5900 *}
2024 ENUMDOC
2025 MIPS ELF relocations.
2027 COMMENT
2028 {* start-sanitize-sky *}
2029 ENUM
2030 BFD_RELOC_MIPS_DVP_11_PCREL
2031 ENUMDOC
2032 MIPS DVP Relocations.
2033 This is an 11-bit pc relative reloc. The recorded address is for the
2034 lower instruction word, and the value is in 128 bit units.
2035 ENUM
2036 BFD_RELOC_MIPS_DVP_27_S4
2037 ENUMDOC
2038 This is a 27 bit address left shifted by 4.
2039 ENUM
2040 BFD_RELOC_MIPS_DVP_11_S4
2041 ENUMDOC
2042 This is the 11 bit offset operand of ilw/stw instructions
2043 left shifted by 4.
2044 ENUM
2045 BFD_RELOC_MIPS_DVP_U15_S3
2046 ENUMDOC
2047 This is the 15 bit unsigned immediate operand of the iaddiu instruction
2048 left shifted by 3.
2049 COMMENT
2050 {* end-sanitize-sky *}
2052 ENUM
2053 BFD_RELOC_386_GOT32
2054 ENUMX
2055 BFD_RELOC_386_PLT32
2056 ENUMX
2057 BFD_RELOC_386_COPY
2058 ENUMX
2059 BFD_RELOC_386_GLOB_DAT
2060 ENUMX
2061 BFD_RELOC_386_JUMP_SLOT
2062 ENUMX
2063 BFD_RELOC_386_RELATIVE
2064 ENUMX
2065 BFD_RELOC_386_GOTOFF
2066 ENUMX
2067 BFD_RELOC_386_GOTPC
2068 ENUMDOC
2069 i386/elf relocations
2071 ENUM
2072 BFD_RELOC_NS32K_IMM_8
2073 ENUMX
2074 BFD_RELOC_NS32K_IMM_16
2075 ENUMX
2076 BFD_RELOC_NS32K_IMM_32
2077 ENUMX
2078 BFD_RELOC_NS32K_IMM_8_PCREL
2079 ENUMX
2080 BFD_RELOC_NS32K_IMM_16_PCREL
2081 ENUMX
2082 BFD_RELOC_NS32K_IMM_32_PCREL
2083 ENUMX
2084 BFD_RELOC_NS32K_DISP_8
2085 ENUMX
2086 BFD_RELOC_NS32K_DISP_16
2087 ENUMX
2088 BFD_RELOC_NS32K_DISP_32
2089 ENUMX
2090 BFD_RELOC_NS32K_DISP_8_PCREL
2091 ENUMX
2092 BFD_RELOC_NS32K_DISP_16_PCREL
2093 ENUMX
2094 BFD_RELOC_NS32K_DISP_32_PCREL
2095 ENUMDOC
2096 ns32k relocations
2098 ENUM
2099 BFD_RELOC_PPC_B26
2100 ENUMX
2101 BFD_RELOC_PPC_BA26
2102 ENUMX
2103 BFD_RELOC_PPC_TOC16
2104 ENUMX
2105 BFD_RELOC_PPC_B16
2106 ENUMX
2107 BFD_RELOC_PPC_B16_BRTAKEN
2108 ENUMX
2109 BFD_RELOC_PPC_B16_BRNTAKEN
2110 ENUMX
2111 BFD_RELOC_PPC_BA16
2112 ENUMX
2113 BFD_RELOC_PPC_BA16_BRTAKEN
2114 ENUMX
2115 BFD_RELOC_PPC_BA16_BRNTAKEN
2116 ENUMX
2117 BFD_RELOC_PPC_COPY
2118 ENUMX
2119 BFD_RELOC_PPC_GLOB_DAT
2120 ENUMX
2121 BFD_RELOC_PPC_JMP_SLOT
2122 ENUMX
2123 BFD_RELOC_PPC_RELATIVE
2124 ENUMX
2125 BFD_RELOC_PPC_LOCAL24PC
2126 ENUMX
2127 BFD_RELOC_PPC_EMB_NADDR32
2128 ENUMX
2129 BFD_RELOC_PPC_EMB_NADDR16
2130 ENUMX
2131 BFD_RELOC_PPC_EMB_NADDR16_LO
2132 ENUMX
2133 BFD_RELOC_PPC_EMB_NADDR16_HI
2134 ENUMX
2135 BFD_RELOC_PPC_EMB_NADDR16_HA
2136 ENUMX
2137 BFD_RELOC_PPC_EMB_SDAI16
2138 ENUMX
2139 BFD_RELOC_PPC_EMB_SDA2I16
2140 ENUMX
2141 BFD_RELOC_PPC_EMB_SDA2REL
2142 ENUMX
2143 BFD_RELOC_PPC_EMB_SDA21
2144 ENUMX
2145 BFD_RELOC_PPC_EMB_MRKREF
2146 ENUMX
2147 BFD_RELOC_PPC_EMB_RELSEC16
2148 ENUMX
2149 BFD_RELOC_PPC_EMB_RELST_LO
2150 ENUMX
2151 BFD_RELOC_PPC_EMB_RELST_HI
2152 ENUMX
2153 BFD_RELOC_PPC_EMB_RELST_HA
2154 ENUMX
2155 BFD_RELOC_PPC_EMB_BIT_FLD
2156 ENUMX
2157 BFD_RELOC_PPC_EMB_RELSDA
2158 ENUMDOC
2159 Power(rs6000) and PowerPC relocations.
2161 ENUM
2162 BFD_RELOC_CTOR
2163 ENUMDOC
2164 The type of reloc used to build a contructor table - at the moment
2165 probably a 32 bit wide absolute relocation, but the target can choose.
2166 It generally does map to one of the other relocation types.
2168 ENUM
2169 BFD_RELOC_ARM_PCREL_BRANCH
2170 ENUMDOC
2171 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
2172 not stored in the instruction.
2173 ENUM
2174 BFD_RELOC_ARM_IMMEDIATE
2175 ENUMX
2176 BFD_RELOC_ARM_OFFSET_IMM
2177 ENUMX
2178 BFD_RELOC_ARM_SHIFT_IMM
2179 ENUMX
2180 BFD_RELOC_ARM_SWI
2181 ENUMX
2182 BFD_RELOC_ARM_MULTI
2183 ENUMX
2184 BFD_RELOC_ARM_CP_OFF_IMM
2185 ENUMX
2186 BFD_RELOC_ARM_ADR_IMM
2187 ENUMX
2188 BFD_RELOC_ARM_LDR_IMM
2189 ENUMX
2190 BFD_RELOC_ARM_LITERAL
2191 ENUMX
2192 BFD_RELOC_ARM_IN_POOL
2193 ENUMX
2194 BFD_RELOC_ARM_OFFSET_IMM8
2195 ENUMX
2196 BFD_RELOC_ARM_HWLITERAL
2197 ENUMX
2198 BFD_RELOC_ARM_THUMB_ADD
2199 ENUMX
2200 BFD_RELOC_ARM_THUMB_IMM
2201 ENUMX
2202 BFD_RELOC_ARM_THUMB_SHIFT
2203 ENUMX
2204 BFD_RELOC_ARM_THUMB_OFFSET
2205 ENUMDOC
2206 These relocs are only used within the ARM assembler. They are not
2207 (at present) written to any object files.
2209 ENUM
2210 BFD_RELOC_SH_PCDISP8BY2
2211 ENUMX
2212 BFD_RELOC_SH_PCDISP12BY2
2213 ENUMX
2214 BFD_RELOC_SH_IMM4
2215 ENUMX
2216 BFD_RELOC_SH_IMM4BY2
2217 ENUMX
2218 BFD_RELOC_SH_IMM4BY4
2219 ENUMX
2220 BFD_RELOC_SH_IMM8
2221 ENUMX
2222 BFD_RELOC_SH_IMM8BY2
2223 ENUMX
2224 BFD_RELOC_SH_IMM8BY4
2225 ENUMX
2226 BFD_RELOC_SH_PCRELIMM8BY2
2227 ENUMX
2228 BFD_RELOC_SH_PCRELIMM8BY4
2229 ENUMX
2230 BFD_RELOC_SH_SWITCH16
2231 ENUMX
2232 BFD_RELOC_SH_SWITCH32
2233 ENUMX
2234 BFD_RELOC_SH_USES
2235 ENUMX
2236 BFD_RELOC_SH_COUNT
2237 ENUMX
2238 BFD_RELOC_SH_ALIGN
2239 ENUMX
2240 BFD_RELOC_SH_CODE
2241 ENUMX
2242 BFD_RELOC_SH_DATA
2243 ENUMX
2244 BFD_RELOC_SH_LABEL
2245 ENUMDOC
2246 Hitachi SH relocs. Not all of these appear in object files.
2248 ENUM
2249 BFD_RELOC_THUMB_PCREL_BRANCH9
2250 ENUMX
2251 BFD_RELOC_THUMB_PCREL_BRANCH12
2252 ENUMX
2253 BFD_RELOC_THUMB_PCREL_BRANCH23
2254 ENUMDOC
2255 Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must
2256 be zero and is not stored in the instruction.
2258 ENUM
2259 BFD_RELOC_ARC_B22_PCREL
2260 ENUMDOC
2261 Argonaut RISC Core (ARC) relocs.
2262 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
2263 not stored in the instruction. The high 20 bits are installed in bits 26
2264 through 7 of the instruction.
2265 ENUM
2266 BFD_RELOC_ARC_B26
2267 ENUMDOC
2268 ARC 26 bit absolute branch. The lowest two bits must be zero and are not
2269 stored in the instruction. The high 24 bits are installed in bits 23
2270 through 0.
2272 ENUM
2273 BFD_RELOC_D10V_10_PCREL_R
2274 ENUMDOC
2275 Mitsubishi D10V relocs.
2276 This is a 10-bit reloc with the right 2 bits
2277 assumed to be 0.
2278 ENUM
2279 BFD_RELOC_D10V_10_PCREL_L
2280 ENUMDOC
2281 Mitsubishi D10V relocs.
2282 This is a 10-bit reloc with the right 2 bits
2283 assumed to be 0. This is the same as the previous reloc
2284 except it is in the left container, i.e.,
2285 shifted left 15 bits.
2286 ENUM
2287 BFD_RELOC_D10V_18
2288 ENUMDOC
2289 This is an 18-bit reloc with the right 2 bits
2290 assumed to be 0.
2291 ENUM
2292 BFD_RELOC_D10V_18_PCREL
2293 ENUMDOC
2294 This is an 18-bit reloc with the right 2 bits
2295 assumed to be 0.
2297 ENUM
2298 BFD_RELOC_D30V_6
2299 ENUMDOC
2300 Mitsubishi D30V relocs.
2301 This is a 6-bit absolute reloc.
2302 ENUM
2303 BFD_RELOC_D30V_9_PCREL
2304 ENUMDOC
2305 This is a 6-bit pc-relative reloc with
2306 the right 3 bits assumed to be 0.
2307 ENUM
2308 BFD_RELOC_D30V_9_PCREL_R
2309 ENUMDOC
2310 This is a 6-bit pc-relative reloc with
2311 the right 3 bits assumed to be 0. Same
2312 as the previous reloc but on the right side
2313 of the container.
2314 ENUM
2315 BFD_RELOC_D30V_15
2316 ENUMDOC
2317 This is a 12-bit absolute reloc with the
2318 right 3 bitsassumed to be 0.
2319 ENUM
2320 BFD_RELOC_D30V_15_PCREL
2321 ENUMDOC
2322 This is a 12-bit pc-relative reloc with
2323 the right 3 bits assumed to be 0.
2324 ENUM
2325 BFD_RELOC_D30V_15_PCREL_R
2326 ENUMDOC
2327 This is a 12-bit pc-relative reloc with
2328 the right 3 bits assumed to be 0. Same
2329 as the previous reloc but on the right side
2330 of the container.
2331 ENUM
2332 BFD_RELOC_D30V_21
2333 ENUMDOC
2334 This is an 18-bit absolute reloc with
2335 the right 3 bits assumed to be 0.
2336 ENUM
2337 BFD_RELOC_D30V_21_PCREL
2338 ENUMDOC
2339 This is an 18-bit pc-relative reloc with
2340 the right 3 bits assumed to be 0.
2341 ENUM
2342 BFD_RELOC_D30V_21_PCREL_R
2343 ENUMDOC
2344 This is an 18-bit pc-relative reloc with
2345 the right 3 bits assumed to be 0. Same
2346 as the previous reloc but on the right side
2347 of the container.
2348 ENUM
2349 BFD_RELOC_D30V_32
2350 ENUMDOC
2351 This is a 32-bit absolute reloc.
2352 ENUM
2353 BFD_RELOC_D30V_32_PCREL
2354 ENUMDOC
2355 This is a 32-bit pc-relative reloc.
2357 ENUM
2358 BFD_RELOC_M32R_24
2359 ENUMDOC
2360 Mitsubishi M32R relocs.
2361 This is a 24 bit absolute address.
2362 ENUM
2363 BFD_RELOC_M32R_10_PCREL
2364 ENUMDOC
2365 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
2366 ENUM
2367 BFD_RELOC_M32R_18_PCREL
2368 ENUMDOC
2369 This is an 18-bit reloc with the right 2 bits assumed to be 0.
2370 ENUM
2371 BFD_RELOC_M32R_26_PCREL
2372 ENUMDOC
2373 This is a 26-bit reloc with the right 2 bits assumed to be 0.
2374 ENUM
2375 BFD_RELOC_M32R_HI16_ULO
2376 ENUMDOC
2377 This is a 16-bit reloc containing the high 16 bits of an address
2378 used when the lower 16 bits are treated as unsigned.
2379 ENUM
2380 BFD_RELOC_M32R_HI16_SLO
2381 ENUMDOC
2382 This is a 16-bit reloc containing the high 16 bits of an address
2383 used when the lower 16 bits are treated as signed.
2384 ENUM
2385 BFD_RELOC_M32R_LO16
2386 ENUMDOC
2387 This is a 16-bit reloc containing the lower 16 bits of an address.
2388 ENUM
2389 BFD_RELOC_M32R_SDA16
2390 ENUMDOC
2391 This is a 16-bit reloc containing the small data area offset for use in
2392 add3, load, and store instructions.
2394 ENUM
2395 BFD_RELOC_V850_9_PCREL
2396 ENUMDOC
2397 This is a 9-bit reloc
2398 ENUM
2399 BFD_RELOC_V850_22_PCREL
2400 ENUMDOC
2401 This is a 22-bit reloc
2403 ENUM
2404 BFD_RELOC_V850_SDA_16_16_OFFSET
2405 ENUMDOC
2406 This is a 16 bit offset from the short data area pointer.
2407 ENUM
2408 BFD_RELOC_V850_SDA_15_16_OFFSET
2409 ENUMDOC
2410 This is a 16 bit offset (of which only 15 bits are used) from the
2411 short data area pointer.
2412 ENUM
2413 BFD_RELOC_V850_ZDA_16_16_OFFSET
2414 ENUMDOC
2415 This is a 16 bit offset from the zero data area pointer.
2416 ENUM
2417 BFD_RELOC_V850_ZDA_15_16_OFFSET
2418 ENUMDOC
2419 This is a 16 bit offset (of which only 15 bits are used) from the
2420 zero data area pointer.
2421 ENUM
2422 BFD_RELOC_V850_TDA_6_8_OFFSET
2423 ENUMDOC
2424 This is an 8 bit offset (of which only 6 bits are used) from the
2425 tiny data area pointer.
2426 ENUM
2427 BFD_RELOC_V850_TDA_7_8_OFFSET
2428 ENUMDOC
2429 This is an 8bit offset (of which only 7 bits are used) from the tiny
2430 data area pointer.
2431 ENUM
2432 BFD_RELOC_V850_TDA_7_7_OFFSET
2433 ENUMDOC
2434 This is a 7 bit offset from the tiny data area pointer.
2435 ENUM
2436 BFD_RELOC_V850_TDA_16_16_OFFSET
2437 ENUMDOC
2438 This is a 16 bit offset from the tiny data area pointer.
2439 COMMENT
2440 {* start-sanitize-v850e *}
2441 ENUM
2442 BFD_RELOC_V850_TDA_4_5_OFFSET
2443 ENUMDOC
2444 This is a 5 bit offset (of which only 4 bits are used) from the tiny
2445 data area pointer.
2446 ENUM
2447 BFD_RELOC_V850_TDA_4_4_OFFSET
2448 ENUMDOC
2449 This is a 4 bit offset from the tiny data area pointer.
2450 ENUM
2451 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
2452 ENUMDOC
2453 This is a 16 bit offset from the short data area pointer, with the
2454 bits placed non-contigously in the instruction.
2455 ENUM
2456 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
2457 ENUMDOC
2458 This is a 16 bit offset from the zero data area pointer, with the
2459 bits placed non-contigously in the instruction.
2460 ENUM
2461 BFD_RELOC_V850_CALLT_6_7_OFFSET
2462 ENUMDOC
2463 This is a 6 bit offset from the call table base pointer.
2464 ENUM
2465 BFD_RELOC_V850_CALLT_16_16_OFFSET
2466 ENUMDOC
2467 This is a 16 bit offset from the call table base pointer.
2468 COMMENT
2469 {* end-sanitize-v850e *}
2471 ENUM
2472 BFD_RELOC_MN10300_32_PCREL
2473 ENUMDOC
2474 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2475 instruction.
2476 ENUM
2477 BFD_RELOC_MN10300_16_PCREL
2478 ENUMDOC
2479 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2480 instruction.
2482 ENUM
2483 BFD_RELOC_TIC30_LDP
2484 ENUMDOC
2485 This is a 8bit DP reloc for the tms320c30, where the most
2486 significant 8 bits of a 24 bit word are placed into the least
2487 significant 8 bits of the opcode.
2489 ENUM
2490 BFD_RELOC_VTABLE_INHERIT
2491 ENUMX
2492 BFD_RELOC_VTABLE_ENTRY
2493 ENUMDOC
2494 These two relocations are used by the linker to determine which of
2495 the entries in a C++ virtual function table are actually used. When
2496 the --gc-sections option is given, the linker will zero out the entries
2497 that are not used, so that the code for those functions need not be
2498 included in the output.
2500 VTABLE_INHERIT is a zero-space relocation used to describe to the
2501 linker the inheritence tree of a C++ virtual function table. The
2502 relocation's symbol should be the parent class' vtable, and the
2503 relocation should be located at the child vtable.
2505 VTABLE_ENTRY is a zero-space relocation that describes the use of a
2506 virtual function table entry. The reloc's symbol should refer to the
2507 table of the class mentioned in the code. Off of that base, an offset
2508 describes the entry that is being used. For Rela hosts, this offset
2509 is stored in the reloc's addend. For Rel hosts, we are forced to put
2510 this offset in the reloc's section offset.
2512 ENDSENUM
2513 BFD_RELOC_UNUSED
2514 CODE_FRAGMENT
2515 .
2516 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2517 */
2520 /*
2521 FUNCTION
2522 bfd_reloc_type_lookup
2524 SYNOPSIS
2525 reloc_howto_type *
2526 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
2528 DESCRIPTION
2529 Return a pointer to a howto structure which, when
2530 invoked, will perform the relocation @var{code} on data from the
2531 architecture noted.
2533 */
2536 reloc_howto_type *
2539 bfd_reloc_code_real_type code;
2540 {
2542 }
2545 HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
2548 /*
2549 INTERNAL_FUNCTION
2550 bfd_default_reloc_type_lookup
2552 SYNOPSIS
2553 reloc_howto_type *bfd_default_reloc_type_lookup
2554 (bfd *abfd, bfd_reloc_code_real_type code);
2556 DESCRIPTION
2557 Provides a default relocation lookup routine for any architecture.
2560 */
2562 reloc_howto_type *
2565 bfd_reloc_code_real_type code;
2566 {
2568 {
2570 /* The type of reloc used in a ctor, which will be as wide as the
2571 address - so either a 64, 32, or 16 bitter. */
2573 {
2582 }
2585 }
2587 }
2589 /*
2590 FUNCTION
2591 bfd_get_reloc_code_name
2593 SYNOPSIS
2594 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
2596 DESCRIPTION
2597 Provides a printable name for the supplied relocation code.
2598 Useful mainly for printing error messages.
2599 */
2603 bfd_reloc_code_real_type code;
2604 {
2608 }
2610 /*
2611 INTERNAL_FUNCTION
2612 bfd_generic_relax_section
2614 SYNOPSIS
2615 boolean bfd_generic_relax_section
2616 (bfd *abfd,
2617 asection *section,
2618 struct bfd_link_info *,
2619 boolean *);
2621 DESCRIPTION
2622 Provides default handling for relaxing for back ends which
2623 don't do relaxing -- i.e., does nothing.
2624 */
2626 /*ARGSUSED*/
2627 boolean
2633 {
2636 }
2638 /*
2639 INTERNAL_FUNCTION
2640 bfd_generic_gc_sections
2642 SYNOPSIS
2643 boolean bfd_generic_gc_sections
2644 (bfd *, struct bfd_link_info *);
2646 DESCRIPTION
2647 Provides default handling for relaxing for back ends which
2648 don't do section gc -- i.e., does nothing.
2649 */
2651 /*ARGSUSED*/
2652 boolean
2656 {
2658 }
2660 /*
2661 INTERNAL_FUNCTION
2662 bfd_generic_get_relocated_section_contents
2664 SYNOPSIS
2665 bfd_byte *
2666 bfd_generic_get_relocated_section_contents (bfd *abfd,
2667 struct bfd_link_info *link_info,
2668 struct bfd_link_order *link_order,
2669 bfd_byte *data,
2670 boolean relocateable,
2671 asymbol **symbols);
2673 DESCRIPTION
2674 Provides default handling of relocation effort for back ends
2675 which can't be bothered to do it efficiently.
2677 */
2679 bfd_byte *
2686 boolean relocateable;
2688 {
2689 /* Get enough memory to hold the stuff */
2704 /* read in the section */
2706 input_section,
2712 /* We're not relaxing the section, so just copy the size info */
2717 input_section,
2718 reloc_vector,
2719 symbols);
2724 {
2727 parent++)
2728 {
2730 bfd_reloc_status_type r =
2734 input_section,
2739 {
2742 /* A partial link, so keep the relocs */
2745 }
2748 {
2750 {
2775 }
2777 }
2778 }
2779 }
2784 error_return:
2788 }