reloc.c revision 104834
1104476Ssam/* BFD support for handling relocation entries.
2104476Ssam   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3139825Simp   2000, 2001, 2002
4104476Ssam   Free Software Foundation, Inc.
5167755Ssam   Written by Cygnus Support.
6104476Ssam
7104476SsamThis file is part of BFD, the Binary File Descriptor library.
8104476Ssam
9104476SsamThis program is free software; you can redistribute it and/or modify
10104476Ssamit under the terms of the GNU General Public License as published by
11104476Ssamthe Free Software Foundation; either version 2 of the License, or
12104476Ssam(at your option) any later version.
13104476Ssam
14104476SsamThis program is distributed in the hope that it will be useful,
15104476Ssambut WITHOUT ANY WARRANTY; without even the implied warranty of
16104476SsamMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17104476SsamGNU General Public License for more details.
18104476Ssam
19104476SsamYou should have received a copy of the GNU General Public License
20104476Ssamalong with this program; if not, write to the Free Software
21104476SsamFoundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
22104476Ssam
23104476Ssam/*
24104476SsamSECTION
25116191Sobrien	Relocations
26116191Sobrien
27116191Sobrien	BFD maintains relocations in much the same way it maintains
28104476Ssam	symbols: they are left alone until required, then read in
29104476Ssam	en-masse and translated into an internal form.  A common
30104476Ssam	routine <<bfd_perform_relocation>> acts upon the
31104476Ssam	canonical form to do the fixup.
32167755Ssam
33104476Ssam	Relocations are maintained on a per section basis,
34104476Ssam	while symbols are maintained on a per BFD basis.
35104476Ssam
36104476Ssam	All that a back end has to do to fit the BFD interface is to create
37104476Ssam	a <<struct reloc_cache_entry>> for each relocation
38104476Ssam	in a particular section, and fill in the right bits of the structures.
39104476Ssam
40104476Ssam@menu
41104476Ssam@* typedef arelent::
42143406Sume@* howto manager::
43104476Ssam@end menu
44104476Ssam
45104476Ssam*/
46104476Ssam
47104476Ssam/* DO compile in the reloc_code name table from libbfd.h.  */
48104476Ssam#define _BFD_MAKE_TABLE_bfd_reloc_code_real
49104476Ssam
50167755Ssam#include "bfd.h"
51167755Ssam#include "sysdep.h"
52167755Ssam#include "bfdlink.h"
53104476Ssam#include "libbfd.h"
54167755Ssam/*
55167755SsamDOCDD
56167755SsamINODE
57104476Ssam	typedef arelent, howto manager, Relocations, Relocations
58167755Ssam
59167755SsamSUBSECTION
60167755Ssam	typedef arelent
61104476Ssam
62159242Spjd	This is the structure of a relocation entry:
63104476Ssam
64167755SsamCODE_FRAGMENT
65104476Ssam.
66104476Ssam.typedef enum bfd_reloc_status
67104476Ssam.{
68104476Ssam.  {* No errors detected.  *}
69104476Ssam.  bfd_reloc_ok,
70104476Ssam.
71159242Spjd.  {* The relocation was performed, but there was an overflow.  *}
72104476Ssam.  bfd_reloc_overflow,
73104476Ssam.
74104476Ssam.  {* The address to relocate was not within the section supplied.  *}
75104476Ssam.  bfd_reloc_outofrange,
76104476Ssam.
77104476Ssam.  {* Used by special functions.  *}
78104476Ssam.  bfd_reloc_continue,
79104476Ssam.
80104476Ssam.  {* Unsupported relocation size requested.  *}
81104476Ssam.  bfd_reloc_notsupported,
82104476Ssam.
83104476Ssam.  {* Unused.  *}
84104476Ssam.  bfd_reloc_other,
85104476Ssam.
86104476Ssam.  {* The symbol to relocate against was undefined.  *}
87104476Ssam.  bfd_reloc_undefined,
88104476Ssam.
89104476Ssam.  {* The relocation was performed, but may not be ok - presently
90157637Spjd.     generated only when linking i960 coff files with i960 b.out
91157637Spjd.     symbols.  If this type is returned, the error_message argument
92104476Ssam.     to bfd_perform_relocation will be set.  *}
93104476Ssam.  bfd_reloc_dangerous
94159242Spjd. }
95159242Spjd. bfd_reloc_status_type;
96104476Ssam.
97104476Ssam.
98104476Ssam.typedef struct reloc_cache_entry
99104476Ssam.{
100104476Ssam.  {* A pointer into the canonical table of pointers.  *}
101104476Ssam.  struct symbol_cache_entry **sym_ptr_ptr;
102104476Ssam.
103159242Spjd.  {* offset in section.  *}
104104476Ssam.  bfd_size_type address;
105104476Ssam.
106104476Ssam.  {* addend for relocation value.  *}
107125330Sphk.  bfd_vma addend;
108125330Sphk.
109125330Sphk.  {* Pointer to how to perform the required relocation.  *}
110125330Sphk.  reloc_howto_type *howto;
111125330Sphk.
112125330Sphk.}
113125330Sphk.arelent;
114125330Sphk.
115125330Sphk*/
116125330Sphk
117104476Ssam/*
118104476SsamDESCRIPTION
119159242Spjd
120104476Ssam        Here is a description of each of the fields within an <<arelent>>:
121104476Ssam
122104476Ssam        o <<sym_ptr_ptr>>
123104476Ssam
124104476Ssam        The symbol table pointer points to a pointer to the symbol
125104476Ssam        associated with the relocation request.  It is
126104476Ssam        the pointer into the table returned by the back end's
127104476Ssam        <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
128104476Ssam        through a pointer to a pointer so that tools like the linker
129104476Ssam        can fix up all the symbols of the same name by modifying only
130104476Ssam        one pointer. The relocation routine looks in the symbol and
131104476Ssam        uses the base of the section the symbol is attached to and the
132104476Ssam        value of the symbol as the initial relocation offset. If the
133104476Ssam        symbol pointer is zero, then the section provided is looked up.
134104476Ssam
135104476Ssam        o <<address>>
136104476Ssam
137104476Ssam        The <<address>> field gives the offset in bytes from the base of
138104476Ssam        the section data which owns the relocation record to the first
139104476Ssam        byte of relocatable information. The actual data relocated
140104476Ssam        will be relative to this point; for example, a relocation
141104476Ssam        type which modifies the bottom two bytes of a four byte word
142104476Ssam        would not touch the first byte pointed to in a big endian
143104476Ssam        world.
144104476Ssam
145104476Ssam	o <<addend>>
146104476Ssam
147104476Ssam	The <<addend>> is a value provided by the back end to be added (!)
148104476Ssam	to the relocation offset. Its interpretation is dependent upon
149104476Ssam	the howto. For example, on the 68k the code:
150104476Ssam
151104476Ssam|        char foo[];
152104476Ssam|        main()
153104476Ssam|                {
154104476Ssam|                return foo[0x12345678];
155104476Ssam|                }
156104476Ssam
157104476Ssam        Could be compiled into:
158104476Ssam
159104476Ssam|        linkw fp,#-4
160104476Ssam|        moveb @@#12345678,d0
161104476Ssam|        extbl d0
162104476Ssam|        unlk fp
163104476Ssam|        rts
164104476Ssam
165104476Ssam        This could create a reloc pointing to <<foo>>, but leave the
166104476Ssam        offset in the data, something like:
167104476Ssam
168104476Ssam|RELOCATION RECORDS FOR [.text]:
169104476Ssam|offset   type      value
170104476Ssam|00000006 32        _foo
171104476Ssam|
172104476Ssam|00000000 4e56 fffc          ; linkw fp,#-4
173104476Ssam|00000004 1039 1234 5678     ; moveb @@#12345678,d0
174104476Ssam|0000000a 49c0               ; extbl d0
175104476Ssam|0000000c 4e5e               ; unlk fp
176104476Ssam|0000000e 4e75               ; rts
177104476Ssam
178104476Ssam        Using coff and an 88k, some instructions don't have enough
179104476Ssam        space in them to represent the full address range, and
180104476Ssam        pointers have to be loaded in two parts. So you'd get something like:
181104476Ssam
182104476Ssam|        or.u     r13,r0,hi16(_foo+0x12345678)
183104476Ssam|        ld.b     r2,r13,lo16(_foo+0x12345678)
184104476Ssam|        jmp      r1
185104476Ssam
186104476Ssam        This should create two relocs, both pointing to <<_foo>>, and with
187104476Ssam        0x12340000 in their addend field. The data would consist of:
188104476Ssam
189104476Ssam|RELOCATION RECORDS FOR [.text]:
190104476Ssam|offset   type      value
191104476Ssam|00000002 HVRT16    _foo+0x12340000
192104476Ssam|00000006 LVRT16    _foo+0x12340000
193104476Ssam|
194104476Ssam|00000000 5da05678           ; or.u r13,r0,0x5678
195104476Ssam|00000004 1c4d5678           ; ld.b r2,r13,0x5678
196104476Ssam|00000008 f400c001           ; jmp r1
197104476Ssam
198104476Ssam        The relocation routine digs out the value from the data, adds
199104476Ssam        it to the addend to get the original offset, and then adds the
200104476Ssam        value of <<_foo>>. Note that all 32 bits have to be kept around
201104476Ssam        somewhere, to cope with carry from bit 15 to bit 16.
202104476Ssam
203104476Ssam        One further example is the sparc and the a.out format. The
204104476Ssam        sparc has a similar problem to the 88k, in that some
205104476Ssam        instructions don't have room for an entire offset, but on the
206104476Ssam        sparc the parts are created in odd sized lumps. The designers of
207104476Ssam        the a.out format chose to not use the data within the section
208104476Ssam        for storing part of the offset; all the offset is kept within
209104476Ssam        the reloc. Anything in the data should be ignored.
210104476Ssam
211104476Ssam|        save %sp,-112,%sp
212104476Ssam|        sethi %hi(_foo+0x12345678),%g2
213104476Ssam|        ldsb [%g2+%lo(_foo+0x12345678)],%i0
214104476Ssam|        ret
215104476Ssam|        restore
216104476Ssam
217104476Ssam        Both relocs contain a pointer to <<foo>>, and the offsets
218104476Ssam        contain junk.
219104476Ssam
220104476Ssam|RELOCATION RECORDS FOR [.text]:
221104476Ssam|offset   type      value
222104476Ssam|00000004 HI22      _foo+0x12345678
223104476Ssam|00000008 LO10      _foo+0x12345678
224104476Ssam|
225104476Ssam|00000000 9de3bf90     ; save %sp,-112,%sp
226104476Ssam|00000004 05000000     ; sethi %hi(_foo+0),%g2
227104476Ssam|00000008 f048a000     ; ldsb [%g2+%lo(_foo+0)],%i0
228104476Ssam|0000000c 81c7e008     ; ret
229104476Ssam|00000010 81e80000     ; restore
230104476Ssam
231104476Ssam        o <<howto>>
232104476Ssam
233104476Ssam        The <<howto>> field can be imagined as a
234104476Ssam        relocation instruction. It is a pointer to a structure which
235104476Ssam        contains information on what to do with all of the other
236104476Ssam        information in the reloc record and data section. A back end
237104476Ssam        would normally have a relocation instruction set and turn
238104476Ssam        relocations into pointers to the correct structure on input -
239104476Ssam        but it would be possible to create each howto field on demand.
240104476Ssam
241104476Ssam*/
242104476Ssam
243104476Ssam/*
244159242SpjdSUBSUBSECTION
245104476Ssam	<<enum complain_overflow>>
246104476Ssam
247104476Ssam	Indicates what sort of overflow checking should be done when
248104476Ssam	performing a relocation.
249104476Ssam
250104476SsamCODE_FRAGMENT
251104476Ssam.
252104476Ssam.enum complain_overflow
253104476Ssam.{
254104476Ssam.  {* Do not complain on overflow.  *}
255104476Ssam.  complain_overflow_dont,
256104476Ssam.
257104476Ssam.  {* Complain if the bitfield overflows, whether it is considered
258104476Ssam.     as signed or unsigned.  *}
259104476Ssam.  complain_overflow_bitfield,
260104476Ssam.
261104476Ssam.  {* Complain if the value overflows when considered as signed
262104476Ssam.     number.  *}
263104476Ssam.  complain_overflow_signed,
264104476Ssam.
265104476Ssam.  {* Complain if the value overflows when considered as an
266104476Ssam.     unsigned number.  *}
267104476Ssam.  complain_overflow_unsigned
268104476Ssam.};
269104476Ssam
270104476Ssam*/
271104476Ssam
272104476Ssam/*
273104476SsamSUBSUBSECTION
274104476Ssam        <<reloc_howto_type>>
275104476Ssam
276104476Ssam        The <<reloc_howto_type>> is a structure which contains all the
277104476Ssam        information that libbfd needs to know to tie up a back end's data.
278104476Ssam
279104476SsamCODE_FRAGMENT
280104476Ssam.struct symbol_cache_entry;		{* Forward declaration.  *}
281104476Ssam.
282104476Ssam.struct reloc_howto_struct
283104476Ssam.{
284104476Ssam.  {*  The type field has mainly a documentary use - the back end can
285104476Ssam.      do what it wants with it, though normally the back end's
286104476Ssam.      external idea of what a reloc number is stored
287104476Ssam.      in this field.  For example, a PC relative word relocation
288104476Ssam.      in a coff environment has the type 023 - because that's
289104476Ssam.      what the outside world calls a R_PCRWORD reloc.  *}
290104476Ssam.  unsigned int type;
291104476Ssam.
292104476Ssam.  {*  The value the final relocation is shifted right by.  This drops
293104476Ssam.      unwanted data from the relocation.  *}
294104476Ssam.  unsigned int rightshift;
295104476Ssam.
296104476Ssam.  {*  The size of the item to be relocated.  This is *not* a
297104476Ssam.      power-of-two measure.  To get the number of bytes operated
298104476Ssam.      on by a type of relocation, use bfd_get_reloc_size.  *}
299104476Ssam.  int size;
300104476Ssam.
301104476Ssam.  {*  The number of bits in the item to be relocated.  This is used
302104476Ssam.      when doing overflow checking.  *}
303104476Ssam.  unsigned int bitsize;
304104476Ssam.
305104476Ssam.  {*  Notes that the relocation is relative to the location in the
306104476Ssam.      data section of the addend.  The relocation function will
307104476Ssam.      subtract from the relocation value the address of the location
308104476Ssam.      being relocated.  *}
309104476Ssam.  boolean pc_relative;
310104476Ssam.
311104476Ssam.  {*  The bit position of the reloc value in the destination.
312104476Ssam.      The relocated value is left shifted by this amount.  *}
313104476Ssam.  unsigned int bitpos;
314104476Ssam.
315104476Ssam.  {* What type of overflow error should be checked for when
316104476Ssam.     relocating.  *}
317104476Ssam.  enum complain_overflow complain_on_overflow;
318104476Ssam.
319104908Smike.  {* If this field is non null, then the supplied function is
320104476Ssam.     called rather than the normal function.  This allows really
321104476Ssam.     strange relocation methods to be accomodated (e.g., i960 callj
322104476Ssam.     instructions).  *}
323104476Ssam.  bfd_reloc_status_type (*special_function)
324104476Ssam.    PARAMS ((bfd *, arelent *, struct symbol_cache_entry *, PTR, asection *,
325104476Ssam.             bfd *, char **));
326104476Ssam.
327104476Ssam.  {* The textual name of the relocation type.  *}
328104476Ssam.  char *name;
329104476Ssam.
330104476Ssam.  {* Some formats record a relocation addend in the section contents
331104476Ssam.     rather than with the relocation.  For ELF formats this is the
332104476Ssam.     distinction between USE_REL and USE_RELA (though the code checks
333104476Ssam.     for USE_REL == 1/0).  The value of this field is TRUE if the
334104476Ssam.     addend is recorded with the section contents; when performing a
335104476Ssam.     partial link (ld -r) the section contents (the data) will be
336104476Ssam.     modified.  The value of this field is FALSE if addends are
337104476Ssam.     recorded with the relocation (in arelent.addend); when performing
338104476Ssam.     a partial link the relocation will be modified.
339104476Ssam.     All relocations for all ELF USE_RELA targets should set this field
340104476Ssam.     to FALSE (values of TRUE should be looked on with suspicion).
341104476Ssam.     However, the converse is not true: not all relocations of all ELF
342104476Ssam.     USE_REL targets set this field to TRUE.  Why this is so is peculiar
343104476Ssam.     to each particular target.  For relocs that aren't used in partial
344104476Ssam.     links (e.g. GOT stuff) it doesn't matter what this is set to.  *}
345104476Ssam.  boolean partial_inplace;
346104476Ssam.
347104476Ssam.  {* The src_mask selects which parts of the read in data
348104476Ssam.     are to be used in the relocation sum.  E.g., if this was an 8 bit
349104476Ssam.     byte of data which we read and relocated, this would be
350104476Ssam.     0x000000ff.  When we have relocs which have an addend, such as
351104476Ssam.     sun4 extended relocs, the value in the offset part of a
352104476Ssam.     relocating field is garbage so we never use it.  In this case
353104476Ssam.     the mask would be 0x00000000.  *}
354104476Ssam.  bfd_vma src_mask;
355184477Sdfr.
356184477Sdfr.  {* The dst_mask selects which parts of the instruction are replaced
357184477Sdfr.     into the instruction.  In most cases src_mask == dst_mask,
358184477Sdfr.     except in the above special case, where dst_mask would be
359104476Ssam.     0x000000ff, and src_mask would be 0x00000000.  *}
360104476Ssam.  bfd_vma dst_mask;
361158703Spjd.
362159242Spjd.  {* When some formats create PC relative instructions, they leave
363159242Spjd.     the value of the pc of the place being relocated in the offset
364159242Spjd.     slot of the instruction, so that a PC relative relocation can
365159242Spjd.     be made just by adding in an ordinary offset (e.g., sun3 a.out).
366159242Spjd.     Some formats leave the displacement part of an instruction
367159242Spjd.     empty (e.g., m88k bcs); this flag signals the fact.  *}
368159242Spjd.  boolean pcrel_offset;
369159242Spjd.};
370159242Spjd.
371159242Spjd*/
372159242Spjd
373159242Spjd/*
374159242SpjdFUNCTION
375159242Spjd	The HOWTO Macro
376159242Spjd
377159242SpjdDESCRIPTION
378159242Spjd	The HOWTO define is horrible and will go away.
379159242Spjd
380159242Spjd.#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
381159242Spjd.  { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }
382159242Spjd
383159242SpjdDESCRIPTION
384159242Spjd	And will be replaced with the totally magic way. But for the
385159242Spjd	moment, we are compatible, so do it this way.
386159242Spjd
387159242Spjd.#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \
388159242Spjd.  HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \
389159242Spjd.         NAME, false, 0, 0, IN)
390159242Spjd.
391159242Spjd
392159242SpjdDESCRIPTION
393159242Spjd	This is used to fill in an empty howto entry in an array.
394159242Spjd
395104476Ssam.#define EMPTY_HOWTO(C) \
396104476Ssam.  HOWTO ((C), 0, 0, 0, false, 0, complain_overflow_dont, NULL, \
397104476Ssam.         NULL, false, 0, 0, false)
398104476Ssam.
399104476Ssam
400104476SsamDESCRIPTION
401158703Spjd	Helper routine to turn a symbol into a relocation value.
402158703Spjd
403158703Spjd.#define HOWTO_PREPARE(relocation, symbol)               \
404158703Spjd.  {                                                     \
405158703Spjd.    if (symbol != (asymbol *) NULL)                     \
406158703Spjd.      {                                                 \
407158703Spjd.        if (bfd_is_com_section (symbol->section))       \
408158703Spjd.          {                                             \
409158703Spjd.            relocation = 0;                             \
410158703Spjd.          }                                             \
411158703Spjd.        else                                            \
412158703Spjd.          {                                             \
413158703Spjd.            relocation = symbol->value;                 \
414158703Spjd.          }                                             \
415158703Spjd.      }                                                 \
416158703Spjd.  }
417158703Spjd.
418158703Spjd*/
419158703Spjd
420158703Spjd/*
421158703SpjdFUNCTION
422158703Spjd	bfd_get_reloc_size
423158703Spjd
424158703SpjdSYNOPSIS
425158703Spjd	unsigned int bfd_get_reloc_size (reloc_howto_type *);
426158703Spjd
427158703SpjdDESCRIPTION
428158703Spjd	For a reloc_howto_type that operates on a fixed number of bytes,
429158703Spjd	this returns the number of bytes operated on.
430158703Spjd */
431158703Spjd
432158703Spjdunsigned int
433158703Spjdbfd_get_reloc_size (howto)
434158703Spjd     reloc_howto_type *howto;
435158703Spjd{
436187826Sbz  switch (howto->size)
437187826Sbz    {
438187826Sbz    case 0: return 1;
439187826Sbz    case 1: return 2;
440158703Spjd    case 2: return 4;
441158703Spjd    case 3: return 0;
442158703Spjd    case 4: return 8;
443158703Spjd    case 8: return 16;
444187826Sbz    case -2: return 4;
445158703Spjd    default: abort ();
446187826Sbz    }
447158703Spjd}
448158703Spjd
449158703Spjd/*
450158703SpjdTYPEDEF
451158703Spjd	arelent_chain
452158703Spjd
453104476SsamDESCRIPTION
454104476Ssam
455104476Ssam	How relocs are tied together in an <<asection>>:
456104476Ssam
457159223Spjd.typedef struct relent_chain
458159242Spjd.{
459104476Ssam.  arelent relent;
460159228Spjd.  struct relent_chain *next;
461104476Ssam.}
462104476Ssam.arelent_chain;
463104476Ssam.
464104476Ssam*/
465104476Ssam
466104476Ssam/* N_ONES produces N one bits, without overflowing machine arithmetic.  */
467104476Ssam#define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
468104476Ssam
469104476Ssam/*
470158703SpjdFUNCTION
471158703Spjd	bfd_check_overflow
472158703Spjd
473104476SsamSYNOPSIS
474104476Ssam	bfd_reloc_status_type
475159242Spjd		bfd_check_overflow
476159242Spjd			(enum complain_overflow how,
477159242Spjd			 unsigned int bitsize,
478159242Spjd			 unsigned int rightshift,
479104476Ssam			 unsigned int addrsize,
480104476Ssam			 bfd_vma relocation);
481104476Ssam
482104476SsamDESCRIPTION
483158703Spjd	Perform overflow checking on @var{relocation} which has
484158703Spjd	@var{bitsize} significant bits and will be shifted right by
485158703Spjd	@var{rightshift} bits, on a machine with addresses containing
486104476Ssam	@var{addrsize} significant bits.  The result is either of
487104476Ssam	@code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
488104476Ssam
489104476Ssam*/
490104476Ssam
491104476Ssambfd_reloc_status_type
492104476Ssambfd_check_overflow (how, bitsize, rightshift, addrsize, relocation)
493104476Ssam     enum complain_overflow how;
494104476Ssam     unsigned int bitsize;
495104476Ssam     unsigned int rightshift;
496104476Ssam     unsigned int addrsize;
497104476Ssam     bfd_vma relocation;
498104476Ssam{
499104476Ssam  bfd_vma fieldmask, addrmask, signmask, ss, a;
500104476Ssam  bfd_reloc_status_type flag = bfd_reloc_ok;
501104476Ssam
502104476Ssam  a = relocation;
503104476Ssam
504104476Ssam  /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
505104476Ssam     we'll be permissive: extra bits in the field mask will
506104476Ssam     automatically extend the address mask for purposes of the
507104476Ssam     overflow check.  */
508104476Ssam  fieldmask = N_ONES (bitsize);
509104476Ssam  addrmask = N_ONES (addrsize) | fieldmask;
510104476Ssam
511159242Spjd  switch (how)
512158703Spjd    {
513104476Ssam    case complain_overflow_dont:
514104476Ssam      break;
515104476Ssam
516104476Ssam    case complain_overflow_signed:
517104476Ssam      /* If any sign bits are set, all sign bits must be set.  That
518104476Ssam         is, A must be a valid negative address after shifting.  */
519104476Ssam      a = (a & addrmask) >> rightshift;
520104476Ssam      signmask = ~ (fieldmask >> 1);
521159242Spjd      ss = a & signmask;
522104476Ssam      if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
523104476Ssam	flag = bfd_reloc_overflow;
524104476Ssam      break;
525104476Ssam
526104476Ssam    case complain_overflow_unsigned:
527104476Ssam      /* We have an overflow if the address does not fit in the field.  */
528104476Ssam      a = (a & addrmask) >> rightshift;
529104476Ssam      if ((a & ~ fieldmask) != 0)
530104476Ssam	flag = bfd_reloc_overflow;
531104476Ssam      break;
532104476Ssam
533104476Ssam    case complain_overflow_bitfield:
534104476Ssam      /* Bitfields are sometimes signed, sometimes unsigned.  We
535184205Sdes	 explicitly allow an address wrap too, which means a bitfield
536104476Ssam	 of n bits is allowed to store -2**n to 2**n-1.  Thus overflow
537104476Ssam	 if the value has some, but not all, bits set outside the
538159242Spjd	 field.  */
539104476Ssam      a >>= rightshift;
540104476Ssam      ss = a & ~ fieldmask;
541104476Ssam      if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & ~ fieldmask))
542104476Ssam	flag = bfd_reloc_overflow;
543104476Ssam      break;
544104476Ssam
545184205Sdes    default:
546104476Ssam      abort ();
547104476Ssam    }
548104476Ssam
549104476Ssam  return flag;
550104476Ssam}
551104476Ssam
552104476Ssam/*
553104476SsamFUNCTION
554104476Ssam	bfd_perform_relocation
555104476Ssam
556104476SsamSYNOPSIS
557184205Sdes	bfd_reloc_status_type
558104476Ssam                bfd_perform_relocation
559104476Ssam                        (bfd *abfd,
560104476Ssam                         arelent *reloc_entry,
561104476Ssam                         PTR data,
562159242Spjd                         asection *input_section,
563104476Ssam                         bfd *output_bfd,
564104476Ssam			 char **error_message);
565159242Spjd
566104476SsamDESCRIPTION
567104476Ssam	If @var{output_bfd} is supplied to this function, the
568159242Spjd	generated image will be relocatable; the relocations are
569104476Ssam	copied to the output file after they have been changed to
570104476Ssam	reflect the new state of the world. There are two ways of
571104476Ssam	reflecting the results of partial linkage in an output file:
572104476Ssam	by modifying the output data in place, and by modifying the
573104476Ssam	relocation record.  Some native formats (e.g., basic a.out and
574104476Ssam	basic coff) have no way of specifying an addend in the
575104476Ssam	relocation type, so the addend has to go in the output data.
576104476Ssam	This is no big deal since in these formats the output data
577104476Ssam	slot will always be big enough for the addend. Complex reloc
578104476Ssam	types with addends were invented to solve just this problem.
579104476Ssam	The @var{error_message} argument is set to an error message if
580104476Ssam	this return @code{bfd_reloc_dangerous}.
581104476Ssam
582104476Ssam*/
583104476Ssam
584104476Ssambfd_reloc_status_type
585104476Ssambfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
586104476Ssam			error_message)
587104476Ssam     bfd *abfd;
588184205Sdes     arelent *reloc_entry;
589104476Ssam     PTR data;
590104476Ssam     asection *input_section;
591104476Ssam     bfd *output_bfd;
592104476Ssam     char **error_message;
593104476Ssam{
594104476Ssam  bfd_vma relocation;
595104476Ssam  bfd_reloc_status_type flag = bfd_reloc_ok;
596167755Ssam  bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
597104476Ssam  bfd_vma output_base = 0;
598104476Ssam  reloc_howto_type *howto = reloc_entry->howto;
599104476Ssam  asection *reloc_target_output_section;
600104476Ssam  asymbol *symbol;
601104476Ssam
602104476Ssam  symbol = *(reloc_entry->sym_ptr_ptr);
603158703Spjd  if (bfd_is_abs_section (symbol->section)
604104476Ssam      && output_bfd != (bfd *) NULL)
605104476Ssam    {
606104476Ssam      reloc_entry->address += input_section->output_offset;
607104476Ssam      return bfd_reloc_ok;
608104476Ssam    }
609104476Ssam
610104476Ssam  /* If we are not producing relocateable output, return an error if
611104476Ssam     the symbol is not defined.  An undefined weak symbol is
612104476Ssam     considered to have a value of zero (SVR4 ABI, p. 4-27).  */
613104476Ssam  if (bfd_is_und_section (symbol->section)
614104476Ssam      && (symbol->flags & BSF_WEAK) == 0
615104476Ssam      && output_bfd == (bfd *) NULL)
616104476Ssam    flag = bfd_reloc_undefined;
617104476Ssam
618104476Ssam  /* If there is a function supplied to handle this relocation type,
619104476Ssam     call it.  It'll return `bfd_reloc_continue' if further processing
620104476Ssam     can be done.  */
621104476Ssam  if (howto->special_function)
622104476Ssam    {
623104476Ssam      bfd_reloc_status_type cont;
624104476Ssam      cont = howto->special_function (abfd, reloc_entry, symbol, data,
625104476Ssam				      input_section, output_bfd,
626104476Ssam				      error_message);
627104476Ssam      if (cont != bfd_reloc_continue)
628104476Ssam	return cont;
629104476Ssam    }
630104476Ssam
631104476Ssam  /* Is the address of the relocation really within the section?  */
632104476Ssam  if (reloc_entry->address > (input_section->_cooked_size
633104476Ssam			      / bfd_octets_per_byte (abfd)))
634167755Ssam    return bfd_reloc_outofrange;
635104476Ssam
636104476Ssam  /* Work out which section the relocation is targetted at and the
637104476Ssam     initial relocation command value.  */
638104476Ssam
639104476Ssam  /* Get symbol value.  (Common symbols are special.)  */
640104476Ssam  if (bfd_is_com_section (symbol->section))
641104476Ssam    relocation = 0;
642104476Ssam  else
643104476Ssam    relocation = symbol->value;
644104476Ssam
645104476Ssam  reloc_target_output_section = symbol->section->output_section;
646104476Ssam
647184205Sdes  /* Convert input-section-relative symbol value to absolute.  */
648104476Ssam  if (output_bfd && ! howto->partial_inplace)
649104476Ssam    output_base = 0;
650167755Ssam  else
651104476Ssam    output_base = reloc_target_output_section->vma;
652104476Ssam
653104476Ssam  relocation += output_base + symbol->section->output_offset;
654104476Ssam
655104476Ssam  /* Add in supplied addend.  */
656104476Ssam  relocation += reloc_entry->addend;
657104476Ssam
658104476Ssam  /* Here the variable relocation holds the final address of the
659104476Ssam     symbol we are relocating against, plus any addend.  */
660104476Ssam
661104476Ssam  if (howto->pc_relative)
662104476Ssam    {
663104476Ssam      /* This is a PC relative relocation.  We want to set RELOCATION
664104476Ssam	 to the distance between the address of the symbol and the
665104476Ssam	 location.  RELOCATION is already the address of the symbol.
666104476Ssam
667104476Ssam	 We start by subtracting the address of the section containing
668104476Ssam	 the location.
669104476Ssam
670104476Ssam	 If pcrel_offset is set, we must further subtract the position
671104476Ssam	 of the location within the section.  Some targets arrange for
672104476Ssam	 the addend to be the negative of the position of the location
673169425Sgnn	 within the section; for example, i386-aout does this.  For
674169425Sgnn	 i386-aout, pcrel_offset is false.  Some other targets do not
675169425Sgnn	 include the position of the location; for example, m88kbcs,
676104476Ssam	 or ELF.  For those targets, pcrel_offset is true.
677104476Ssam
678104476Ssam	 If we are producing relocateable output, then we must ensure
679104476Ssam	 that this reloc will be correctly computed when the final
680158703Spjd	 relocation is done.  If pcrel_offset is false we want to wind
681158703Spjd	 up with the negative of the location within the section,
682158703Spjd	 which means we must adjust the existing addend by the change
683158703Spjd	 in the location within the section.  If pcrel_offset is true
684167755Ssam	 we do not want to adjust the existing addend at all.
685158703Spjd
686158703Spjd	 FIXME: This seems logical to me, but for the case of
687104476Ssam	 producing relocateable output it is not what the code
688104476Ssam	 actually does.  I don't want to change it, because it seems
689104476Ssam	 far too likely that something will break.  */
690104476Ssam
691104476Ssam      relocation -=
692158703Spjd	input_section->output_section->vma + input_section->output_offset;
693104476Ssam
694104476Ssam      if (howto->pcrel_offset)
695158703Spjd	relocation -= reloc_entry->address;
696104476Ssam    }
697158703Spjd
698158703Spjd  if (output_bfd != (bfd *) NULL)
699104476Ssam    {
700158703Spjd      if (! howto->partial_inplace)
701158703Spjd	{
702158703Spjd	  /* This is a partial relocation, and we want to apply the relocation
703158703Spjd	     to the reloc entry rather than the raw data. Modify the reloc
704158703Spjd	     inplace to reflect what we now know.  */
705158703Spjd	  reloc_entry->addend = relocation;
706104476Ssam	  reloc_entry->address += input_section->output_offset;
707104476Ssam	  return flag;
708104476Ssam	}
709104476Ssam      else
710158703Spjd	{
711104476Ssam	  /* This is a partial relocation, but inplace, so modify the
712104476Ssam	     reloc record a bit.
713104476Ssam
714104476Ssam	     If we've relocated with a symbol with a section, change
715167755Ssam	     into a ref to the section belonging to the symbol.  */
716104476Ssam
717104476Ssam	  reloc_entry->address += input_section->output_offset;
718104476Ssam
719104476Ssam	  /* WTF?? */
720104476Ssam	  if (abfd->xvec->flavour == bfd_target_coff_flavour
721104476Ssam	      && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
722167755Ssam	      && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
723104476Ssam	    {
724104476Ssam#if 1
725158703Spjd	      /* For m68k-coff, the addend was being subtracted twice during
726158703Spjd		 relocation with -r.  Removing the line below this comment
727158703Spjd		 fixes that problem; see PR 2953.
728158703Spjd
729158703SpjdHowever, Ian wrote the following, regarding removing the line below,
730158703Spjdwhich explains why it is still enabled:  --djm
731158703Spjd
732104476SsamIf you put a patch like that into BFD you need to check all the COFF
733104476Ssamlinkers.  I am fairly certain that patch will break coff-i386 (e.g.,
734104476SsamSCO); see coff_i386_reloc in coff-i386.c where I worked around the
735104476Ssamproblem in a different way.  There may very well be a reason that the
736104476Ssamcode works as it does.
737104476Ssam
738104476SsamHmmm.  The first obvious point is that bfd_perform_relocation should
739104476Ssamnot have any tests that depend upon the flavour.  It's seem like
740104476Ssamentirely the wrong place for such a thing.  The second obvious point
741104476Ssamis that the current code ignores the reloc addend when producing
742104476Ssamrelocateable output for COFF.  That's peculiar.  In fact, I really
743104476Ssamhave no idea what the point of the line you want to remove is.
744104476Ssam
745167755SsamA typical COFF reloc subtracts the old value of the symbol and adds in
746104476Ssamthe new value to the location in the object file (if it's a pc
747104476Ssamrelative reloc it adds the difference between the symbol value and the
748104476Ssamlocation).  When relocating we need to preserve that property.
749158703Spjd
750158703SpjdBFD handles this by setting the addend to the negative of the old
751104476Ssamvalue of the symbol.  Unfortunately it handles common symbols in a
752167755Ssamnon-standard way (it doesn't subtract the old value) but that's a
753104476Ssamdifferent story (we can't change it without losing backward
754104476Ssamcompatibility with old object files) (coff-i386 does subtract the old
755158703Spjdvalue, to be compatible with existing coff-i386 targets, like SCO).
756158703Spjd
757158703SpjdSo everything works fine when not producing relocateable output.  When
758158703Spjdwe are producing relocateable output, logically we should do exactly
759158703Spjdwhat we do when not producing relocateable output.  Therefore, your
760158703Spjdpatch is correct.  In fact, it should probably always just set
761158703Spjdreloc_entry->addend to 0 for all cases, since it is, in fact, going to
762158703Spjdadd the value into the object file.  This won't hurt the COFF code,
763104476Ssamwhich doesn't use the addend; I'm not sure what it will do to other
764104476Ssamformats (the thing to check for would be whether any formats both use
765104476Ssamthe addend and set partial_inplace).
766104476Ssam
767104476SsamWhen I wanted to make coff-i386 produce relocateable output, I ran
768104476Ssaminto the problem that you are running into: I wanted to remove that
769104476Ssamline.  Rather than risk it, I made the coff-i386 relocs use a special
770104476Ssamfunction; it's coff_i386_reloc in coff-i386.c.  The function
771104476Ssamspecifically adds the addend field into the object file, knowing that
772104476Ssambfd_perform_relocation is not going to.  If you remove that line, then
773104476Ssamcoff-i386.c will wind up adding the addend field in twice.  It's
774104476Ssamtrivial to fix; it just needs to be done.
775104476Ssam
776167755SsamThe problem with removing the line is just that it may break some
777104476Ssamworking code.  With BFD it's hard to be sure of anything.  The right
778104476Ssamway to deal with this is simply to build and test at least all the
779104476Ssamsupported COFF targets.  It should be straightforward if time and disk
780104476Ssamspace consuming.  For each target:
781158703Spjd    1) build the linker
782104476Ssam    2) generate some executable, and link it using -r (I would
783104476Ssam       probably use paranoia.o and link against newlib/libc.a, which
784104476Ssam       for all the supported targets would be available in
785104476Ssam       /usr/cygnus/progressive/H-host/target/lib/libc.a).
786104476Ssam    3) make the change to reloc.c
787104476Ssam    4) rebuild the linker
788104476Ssam    5) repeat step 2
789104476Ssam    6) if the resulting object files are the same, you have at least
790167755Ssam       made it no worse
791104476Ssam    7) if they are different you have to figure out which version is
792104476Ssam       right
793104476Ssam*/
794104476Ssam	      relocation -= reloc_entry->addend;
795104476Ssam#endif
796104476Ssam	      reloc_entry->addend = 0;
797104476Ssam	    }
798104476Ssam	  else
799104476Ssam	    {
800104476Ssam	      reloc_entry->addend = relocation;
801104476Ssam	    }
802104476Ssam	}
803104476Ssam    }
804104476Ssam  else
805167755Ssam    {
806104476Ssam      reloc_entry->addend = 0;
807104476Ssam    }
808104476Ssam
809104476Ssam  /* FIXME: This overflow checking is incomplete, because the value
810104476Ssam     might have overflowed before we get here.  For a correct check we
811116924Ssam     need to compute the value in a size larger than bitsize, but we
812104476Ssam     can't reasonably do that for a reloc the same size as a host
813104476Ssam     machine word.
814104476Ssam     FIXME: We should also do overflow checking on the result after
815104476Ssam     adding in the value contained in the object file.  */
816104476Ssam  if (howto->complain_on_overflow != complain_overflow_dont
817104476Ssam      && flag == bfd_reloc_ok)
818104476Ssam    flag = bfd_check_overflow (howto->complain_on_overflow,
819104476Ssam			       howto->bitsize,
820104476Ssam			       howto->rightshift,
821104476Ssam			       bfd_arch_bits_per_address (abfd),
822104476Ssam			       relocation);
823104476Ssam
824104476Ssam  /* Either we are relocating all the way, or we don't want to apply
825104476Ssam     the relocation to the reloc entry (probably because there isn't
826104476Ssam     any room in the output format to describe addends to relocs).  */
827104476Ssam
828104476Ssam  /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
829104476Ssam     (OSF version 1.3, compiler version 3.11).  It miscompiles the
830104476Ssam     following program:
831169425Sgnn
832104476Ssam     struct str
833104476Ssam     {
834104476Ssam       unsigned int i0;
835104476Ssam     } s = { 0 };
836104476Ssam
837104476Ssam     int
838104476Ssam     main ()
839104476Ssam     {
840104476Ssam       unsigned long x;
841158703Spjd
842158703Spjd       x = 0x100000000;
843158703Spjd       x <<= (unsigned long) s.i0;
844104476Ssam       if (x == 0)
845104476Ssam	 printf ("failed\n");
846104476Ssam       else
847104476Ssam	 printf ("succeeded (%lx)\n", x);
848104476Ssam     }
849104476Ssam     */
850104476Ssam
851104476Ssam  relocation >>= (bfd_vma) howto->rightshift;
852104476Ssam
853104476Ssam  /* Shift everything up to where it's going to be used.  */
854104476Ssam  relocation <<= (bfd_vma) howto->bitpos;
855104476Ssam
856104476Ssam  /* Wait for the day when all have the mask in them.  */
857104476Ssam
858104476Ssam  /* What we do:
859104476Ssam     i instruction to be left alone
860104476Ssam     o offset within instruction
861104476Ssam     r relocation offset to apply
862104476Ssam     S src mask
863104476Ssam     D dst mask
864104476Ssam     N ~dst mask
865104476Ssam     A part 1
866104476Ssam     B part 2
867104476Ssam     R result
868104476Ssam
869104476Ssam     Do this:
870104476Ssam     ((  i i i i i o o o o o  from bfd_get<size>
871104476Ssam     and           S S S S S) to get the size offset we want
872104476Ssam     +   r r r r r r r r r r) to get the final value to place
873104476Ssam     and           D D D D D  to chop to right size
874104476Ssam     -----------------------
875104476Ssam     =             A A A A A
876104476Ssam     And this:
877104476Ssam     (   i i i i i o o o o o  from bfd_get<size>
878104476Ssam     and N N N N N          ) get instruction
879104476Ssam     -----------------------
880104476Ssam     =   B B B B B
881104476Ssam
882104476Ssam     And then:
883104476Ssam     (   B B B B B
884104476Ssam     or            A A A A A)
885184205Sdes     -----------------------
886104476Ssam     =   R R R R R R R R R R  put into bfd_put<size>
887104476Ssam     */
888104476Ssam
889104476Ssam#define DOIT(x) \
890104476Ssam  x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
891104476Ssam
892104476Ssam  switch (howto->size)
893104476Ssam    {
894167755Ssam    case 0:
895104476Ssam      {
896104476Ssam	char x = bfd_get_8 (abfd, (char *) data + octets);
897104476Ssam	DOIT (x);
898104476Ssam	bfd_put_8 (abfd, x, (unsigned char *) data + octets);
899104476Ssam      }
900104476Ssam      break;
901104476Ssam
902104476Ssam    case 1:
903104476Ssam      {
904104476Ssam	short x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
905104476Ssam	DOIT (x);
906104476Ssam	bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets);
907104476Ssam      }
908104476Ssam      break;
909104476Ssam    case 2:
910104476Ssam      {
911104476Ssam	long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
912104476Ssam	DOIT (x);
913104476Ssam	bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
914104476Ssam      }
915104476Ssam      break;
916104476Ssam    case -2:
917104476Ssam      {
918104476Ssam	long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
919104476Ssam	relocation = -relocation;
920104476Ssam	DOIT (x);
921104476Ssam	bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
922104476Ssam      }
923104476Ssam      break;
924104476Ssam
925104476Ssam    case -1:
926104476Ssam      {
927104476Ssam	long x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
928104476Ssam	relocation = -relocation;
929104476Ssam	DOIT (x);
930104476Ssam	bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
931104476Ssam      }
932104476Ssam      break;
933104476Ssam
934104476Ssam    case 3:
935104476Ssam      /* Do nothing */
936104476Ssam      break;
937104476Ssam
938104476Ssam    case 4:
939104476Ssam#ifdef BFD64
940104476Ssam      {
941104476Ssam	bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets);
942104476Ssam	DOIT (x);
943104476Ssam	bfd_put_64 (abfd, x, (bfd_byte *) data + octets);
944169425Sgnn      }
945104476Ssam#else
946159242Spjd      abort ();
947104476Ssam#endif
948104476Ssam      break;
949104476Ssam    default:
950104476Ssam      return bfd_reloc_other;
951104476Ssam    }
952104476Ssam
953104476Ssam  return flag;
954158703Spjd}
955158703Spjd
956158703Spjd/*
957104476SsamFUNCTION
958104476Ssam	bfd_install_relocation
959104476Ssam
960104476SsamSYNOPSIS
961104476Ssam	bfd_reloc_status_type
962104476Ssam                bfd_install_relocation
963159223Spjd                        (bfd *abfd,
964159242Spjd                         arelent *reloc_entry,
965104476Ssam                         PTR data, bfd_vma data_start,
966104476Ssam                         asection *input_section,
967104476Ssam			 char **error_message);
968104476Ssam
969104476SsamDESCRIPTION
970159242Spjd	This looks remarkably like <<bfd_perform_relocation>>, except it
971104476Ssam	does not expect that the section contents have been filled in.
972104476Ssam	I.e., it's suitable for use when creating, rather than applying
973104476Ssam	a relocation.
974104476Ssam
975104476Ssam	For now, this function should be considered reserved for the
976104476Ssam	assembler.
977104476Ssam*/
978104476Ssam
979104476Ssambfd_reloc_status_type
980104476Ssambfd_install_relocation (abfd, reloc_entry, data_start, data_start_offset,
981104476Ssam			input_section, error_message)
982104476Ssam     bfd *abfd;
983104476Ssam     arelent *reloc_entry;
984104476Ssam     PTR data_start;
985104476Ssam     bfd_vma data_start_offset;
986104476Ssam     asection *input_section;
987104476Ssam     char **error_message;
988104476Ssam{
989188154Simp  bfd_vma relocation;
990104476Ssam  bfd_reloc_status_type flag = bfd_reloc_ok;
991167755Ssam  bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
992167755Ssam  bfd_vma output_base = 0;
993167755Ssam  reloc_howto_type *howto = reloc_entry->howto;
994167755Ssam  asection *reloc_target_output_section;
995167755Ssam  asymbol *symbol;
996158703Spjd  bfd_byte *data;
997167755Ssam
998167755Ssam  symbol = *(reloc_entry->sym_ptr_ptr);
999167755Ssam  if (bfd_is_abs_section (symbol->section))
1000167755Ssam    {
1001167755Ssam      reloc_entry->address += input_section->output_offset;
1002167755Ssam      return bfd_reloc_ok;
1003158703Spjd    }
1004167755Ssam
1005167755Ssam  /* If there is a function supplied to handle this relocation type,
1006167755Ssam     call it.  It'll return `bfd_reloc_continue' if further processing
1007167755Ssam     can be done.  */
1008167755Ssam  if (howto->special_function)
1009167755Ssam    {
1010167755Ssam      bfd_reloc_status_type cont;
1011167755Ssam
1012167755Ssam      /* XXX - The special_function calls haven't been fixed up to deal
1013167755Ssam	 with creating new relocations and section contents.  */
1014167755Ssam      cont = howto->special_function (abfd, reloc_entry, symbol,
1015167755Ssam				      /* XXX - Non-portable! */
1016104476Ssam				      ((bfd_byte *) data_start
1017167755Ssam				       - data_start_offset),
1018167755Ssam				      input_section, abfd, error_message);
1019104476Ssam      if (cont != bfd_reloc_continue)
1020104476Ssam	return cont;
1021104476Ssam    }
1022104476Ssam
1023104476Ssam  /* Is the address of the relocation really within the section?  */
1024104476Ssam  if (reloc_entry->address > (input_section->_cooked_size
1025104476Ssam			      / bfd_octets_per_byte (abfd)))
1026158703Spjd    return bfd_reloc_outofrange;
1027158703Spjd
1028158703Spjd  /* Work out which section the relocation is targetted at and the
1029104476Ssam     initial relocation command value.  */
1030104476Ssam
1031104476Ssam  /* Get symbol value.  (Common symbols are special.)  */
1032104476Ssam  if (bfd_is_com_section (symbol->section))
1033104476Ssam    relocation = 0;
1034104476Ssam  else
1035104476Ssam    relocation = symbol->value;
1036169425Sgnn
1037104476Ssam  reloc_target_output_section = symbol->section->output_section;
1038104476Ssam
1039167755Ssam  /* Convert input-section-relative symbol value to absolute.  */
1040167755Ssam  if (! howto->partial_inplace)
1041104476Ssam    output_base = 0;
1042157205Spjd  else
1043188154Simp    output_base = reloc_target_output_section->vma;
1044167755Ssam
1045157205Spjd  relocation += output_base + symbol->section->output_offset;
1046167755Ssam
1047157205Spjd  /* Add in supplied addend.  */
1048184205Sdes  relocation += reloc_entry->addend;
1049188154Simp
1050157205Spjd  /* Here the variable relocation holds the final address of the
1051167755Ssam     symbol we are relocating against, plus any addend.  */
1052167755Ssam
1053167755Ssam  if (howto->pc_relative)
1054167755Ssam    {
1055167755Ssam      /* This is a PC relative relocation.  We want to set RELOCATION
1056167755Ssam	 to the distance between the address of the symbol and the
1057167755Ssam	 location.  RELOCATION is already the address of the symbol.
1058167755Ssam
1059167755Ssam	 We start by subtracting the address of the section containing
1060167755Ssam	 the location.
1061167755Ssam
1062167755Ssam	 If pcrel_offset is set, we must further subtract the position
1063167755Ssam	 of the location within the section.  Some targets arrange for
1064167755Ssam	 the addend to be the negative of the position of the location
1065167755Ssam	 within the section; for example, i386-aout does this.  For
1066167755Ssam	 i386-aout, pcrel_offset is false.  Some other targets do not
1067167755Ssam	 include the position of the location; for example, m88kbcs,
1068167755Ssam	 or ELF.  For those targets, pcrel_offset is true.
1069167755Ssam
1070167755Ssam	 If we are producing relocateable output, then we must ensure
1071167755Ssam	 that this reloc will be correctly computed when the final
1072167755Ssam	 relocation is done.  If pcrel_offset is false we want to wind
1073167755Ssam	 up with the negative of the location within the section,
1074167755Ssam	 which means we must adjust the existing addend by the change
1075167755Ssam	 in the location within the section.  If pcrel_offset is true
1076167755Ssam	 we do not want to adjust the existing addend at all.
1077167755Ssam
1078167755Ssam	 FIXME: This seems logical to me, but for the case of
1079167755Ssam	 producing relocateable output it is not what the code
1080167755Ssam	 actually does.  I don't want to change it, because it seems
1081167755Ssam	 far too likely that something will break.  */
1082167755Ssam
1083167755Ssam      relocation -=
1084	input_section->output_section->vma + input_section->output_offset;
1085
1086      if (howto->pcrel_offset && howto->partial_inplace)
1087	relocation -= reloc_entry->address;
1088    }
1089
1090  if (! howto->partial_inplace)
1091    {
1092      /* This is a partial relocation, and we want to apply the relocation
1093	 to the reloc entry rather than the raw data. Modify the reloc
1094	 inplace to reflect what we now know.  */
1095      reloc_entry->addend = relocation;
1096      reloc_entry->address += input_section->output_offset;
1097      return flag;
1098    }
1099  else
1100    {
1101      /* This is a partial relocation, but inplace, so modify the
1102	 reloc record a bit.
1103
1104	 If we've relocated with a symbol with a section, change
1105	 into a ref to the section belonging to the symbol.  */
1106      reloc_entry->address += input_section->output_offset;
1107
1108      /* WTF?? */
1109      if (abfd->xvec->flavour == bfd_target_coff_flavour
1110	  && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1111	  && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1112	{
1113#if 1
1114/* For m68k-coff, the addend was being subtracted twice during
1115   relocation with -r.  Removing the line below this comment
1116   fixes that problem; see PR 2953.
1117
1118However, Ian wrote the following, regarding removing the line below,
1119which explains why it is still enabled:  --djm
1120
1121If you put a patch like that into BFD you need to check all the COFF
1122linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
1123SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1124problem in a different way.  There may very well be a reason that the
1125code works as it does.
1126
1127Hmmm.  The first obvious point is that bfd_install_relocation should
1128not have any tests that depend upon the flavour.  It's seem like
1129entirely the wrong place for such a thing.  The second obvious point
1130is that the current code ignores the reloc addend when producing
1131relocateable output for COFF.  That's peculiar.  In fact, I really
1132have no idea what the point of the line you want to remove is.
1133
1134A typical COFF reloc subtracts the old value of the symbol and adds in
1135the new value to the location in the object file (if it's a pc
1136relative reloc it adds the difference between the symbol value and the
1137location).  When relocating we need to preserve that property.
1138
1139BFD handles this by setting the addend to the negative of the old
1140value of the symbol.  Unfortunately it handles common symbols in a
1141non-standard way (it doesn't subtract the old value) but that's a
1142different story (we can't change it without losing backward
1143compatibility with old object files) (coff-i386 does subtract the old
1144value, to be compatible with existing coff-i386 targets, like SCO).
1145
1146So everything works fine when not producing relocateable output.  When
1147we are producing relocateable output, logically we should do exactly
1148what we do when not producing relocateable output.  Therefore, your
1149patch is correct.  In fact, it should probably always just set
1150reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1151add the value into the object file.  This won't hurt the COFF code,
1152which doesn't use the addend; I'm not sure what it will do to other
1153formats (the thing to check for would be whether any formats both use
1154the addend and set partial_inplace).
1155
1156When I wanted to make coff-i386 produce relocateable output, I ran
1157into the problem that you are running into: I wanted to remove that
1158line.  Rather than risk it, I made the coff-i386 relocs use a special
1159function; it's coff_i386_reloc in coff-i386.c.  The function
1160specifically adds the addend field into the object file, knowing that
1161bfd_install_relocation is not going to.  If you remove that line, then
1162coff-i386.c will wind up adding the addend field in twice.  It's
1163trivial to fix; it just needs to be done.
1164
1165The problem with removing the line is just that it may break some
1166working code.  With BFD it's hard to be sure of anything.  The right
1167way to deal with this is simply to build and test at least all the
1168supported COFF targets.  It should be straightforward if time and disk
1169space consuming.  For each target:
1170    1) build the linker
1171    2) generate some executable, and link it using -r (I would
1172       probably use paranoia.o and link against newlib/libc.a, which
1173       for all the supported targets would be available in
1174       /usr/cygnus/progressive/H-host/target/lib/libc.a).
1175    3) make the change to reloc.c
1176    4) rebuild the linker
1177    5) repeat step 2
1178    6) if the resulting object files are the same, you have at least
1179       made it no worse
1180    7) if they are different you have to figure out which version is
1181       right.  */
1182	  relocation -= reloc_entry->addend;
1183#endif
1184	  reloc_entry->addend = 0;
1185	}
1186      else
1187	{
1188	  reloc_entry->addend = relocation;
1189	}
1190    }
1191
1192  /* FIXME: This overflow checking is incomplete, because the value
1193     might have overflowed before we get here.  For a correct check we
1194     need to compute the value in a size larger than bitsize, but we
1195     can't reasonably do that for a reloc the same size as a host
1196     machine word.
1197     FIXME: We should also do overflow checking on the result after
1198     adding in the value contained in the object file.  */
1199  if (howto->complain_on_overflow != complain_overflow_dont)
1200    flag = bfd_check_overflow (howto->complain_on_overflow,
1201			       howto->bitsize,
1202			       howto->rightshift,
1203			       bfd_arch_bits_per_address (abfd),
1204			       relocation);
1205
1206  /* Either we are relocating all the way, or we don't want to apply
1207     the relocation to the reloc entry (probably because there isn't
1208     any room in the output format to describe addends to relocs).  */
1209
1210  /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1211     (OSF version 1.3, compiler version 3.11).  It miscompiles the
1212     following program:
1213
1214     struct str
1215     {
1216       unsigned int i0;
1217     } s = { 0 };
1218
1219     int
1220     main ()
1221     {
1222       unsigned long x;
1223
1224       x = 0x100000000;
1225       x <<= (unsigned long) s.i0;
1226       if (x == 0)
1227	 printf ("failed\n");
1228       else
1229	 printf ("succeeded (%lx)\n", x);
1230     }
1231     */
1232
1233  relocation >>= (bfd_vma) howto->rightshift;
1234
1235  /* Shift everything up to where it's going to be used.  */
1236  relocation <<= (bfd_vma) howto->bitpos;
1237
1238  /* Wait for the day when all have the mask in them.  */
1239
1240  /* What we do:
1241     i instruction to be left alone
1242     o offset within instruction
1243     r relocation offset to apply
1244     S src mask
1245     D dst mask
1246     N ~dst mask
1247     A part 1
1248     B part 2
1249     R result
1250
1251     Do this:
1252     ((  i i i i i o o o o o  from bfd_get<size>
1253     and           S S S S S) to get the size offset we want
1254     +   r r r r r r r r r r) to get the final value to place
1255     and           D D D D D  to chop to right size
1256     -----------------------
1257     =             A A A A A
1258     And this:
1259     (   i i i i i o o o o o  from bfd_get<size>
1260     and N N N N N          ) get instruction
1261     -----------------------
1262     =   B B B B B
1263
1264     And then:
1265     (   B B B B B
1266     or            A A A A A)
1267     -----------------------
1268     =   R R R R R R R R R R  put into bfd_put<size>
1269     */
1270
1271#define DOIT(x) \
1272  x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
1273
1274  data = (bfd_byte *) data_start + (octets - data_start_offset);
1275
1276  switch (howto->size)
1277    {
1278    case 0:
1279      {
1280	char x = bfd_get_8 (abfd, (char *) data);
1281	DOIT (x);
1282	bfd_put_8 (abfd, x, (unsigned char *) data);
1283      }
1284      break;
1285
1286    case 1:
1287      {
1288	short x = bfd_get_16 (abfd, (bfd_byte *) data);
1289	DOIT (x);
1290	bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data);
1291      }
1292      break;
1293    case 2:
1294      {
1295	long x = bfd_get_32 (abfd, (bfd_byte *) data);
1296	DOIT (x);
1297	bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data);
1298      }
1299      break;
1300    case -2:
1301      {
1302	long x = bfd_get_32 (abfd, (bfd_byte *) data);
1303	relocation = -relocation;
1304	DOIT (x);
1305	bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data);
1306      }
1307      break;
1308
1309    case 3:
1310      /* Do nothing */
1311      break;
1312
1313    case 4:
1314      {
1315	bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
1316	DOIT (x);
1317	bfd_put_64 (abfd, x, (bfd_byte *) data);
1318      }
1319      break;
1320    default:
1321      return bfd_reloc_other;
1322    }
1323
1324  return flag;
1325}
1326
1327/* This relocation routine is used by some of the backend linkers.
1328   They do not construct asymbol or arelent structures, so there is no
1329   reason for them to use bfd_perform_relocation.  Also,
1330   bfd_perform_relocation is so hacked up it is easier to write a new
1331   function than to try to deal with it.
1332
1333   This routine does a final relocation.  Whether it is useful for a
1334   relocateable link depends upon how the object format defines
1335   relocations.
1336
1337   FIXME: This routine ignores any special_function in the HOWTO,
1338   since the existing special_function values have been written for
1339   bfd_perform_relocation.
1340
1341   HOWTO is the reloc howto information.
1342   INPUT_BFD is the BFD which the reloc applies to.
1343   INPUT_SECTION is the section which the reloc applies to.
1344   CONTENTS is the contents of the section.
1345   ADDRESS is the address of the reloc within INPUT_SECTION.
1346   VALUE is the value of the symbol the reloc refers to.
1347   ADDEND is the addend of the reloc.  */
1348
1349bfd_reloc_status_type
1350_bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
1351			  value, addend)
1352     reloc_howto_type *howto;
1353     bfd *input_bfd;
1354     asection *input_section;
1355     bfd_byte *contents;
1356     bfd_vma address;
1357     bfd_vma value;
1358     bfd_vma addend;
1359{
1360  bfd_vma relocation;
1361
1362  /* Sanity check the address.  */
1363  if (address > input_section->_raw_size)
1364    return bfd_reloc_outofrange;
1365
1366  /* This function assumes that we are dealing with a basic relocation
1367     against a symbol.  We want to compute the value of the symbol to
1368     relocate to.  This is just VALUE, the value of the symbol, plus
1369     ADDEND, any addend associated with the reloc.  */
1370  relocation = value + addend;
1371
1372  /* If the relocation is PC relative, we want to set RELOCATION to
1373     the distance between the symbol (currently in RELOCATION) and the
1374     location we are relocating.  Some targets (e.g., i386-aout)
1375     arrange for the contents of the section to be the negative of the
1376     offset of the location within the section; for such targets
1377     pcrel_offset is false.  Other targets (e.g., m88kbcs or ELF)
1378     simply leave the contents of the section as zero; for such
1379     targets pcrel_offset is true.  If pcrel_offset is false we do not
1380     need to subtract out the offset of the location within the
1381     section (which is just ADDRESS).  */
1382  if (howto->pc_relative)
1383    {
1384      relocation -= (input_section->output_section->vma
1385		     + input_section->output_offset);
1386      if (howto->pcrel_offset)
1387	relocation -= address;
1388    }
1389
1390  return _bfd_relocate_contents (howto, input_bfd, relocation,
1391				 contents + address);
1392}
1393
1394/* Relocate a given location using a given value and howto.  */
1395
1396bfd_reloc_status_type
1397_bfd_relocate_contents (howto, input_bfd, relocation, location)
1398     reloc_howto_type *howto;
1399     bfd *input_bfd;
1400     bfd_vma relocation;
1401     bfd_byte *location;
1402{
1403  int size;
1404  bfd_vma x = 0;
1405  bfd_reloc_status_type flag;
1406  unsigned int rightshift = howto->rightshift;
1407  unsigned int bitpos = howto->bitpos;
1408
1409  /* If the size is negative, negate RELOCATION.  This isn't very
1410     general.  */
1411  if (howto->size < 0)
1412    relocation = -relocation;
1413
1414  /* Get the value we are going to relocate.  */
1415  size = bfd_get_reloc_size (howto);
1416  switch (size)
1417    {
1418    default:
1419    case 0:
1420      abort ();
1421    case 1:
1422      x = bfd_get_8 (input_bfd, location);
1423      break;
1424    case 2:
1425      x = bfd_get_16 (input_bfd, location);
1426      break;
1427    case 4:
1428      x = bfd_get_32 (input_bfd, location);
1429      break;
1430    case 8:
1431#ifdef BFD64
1432      x = bfd_get_64 (input_bfd, location);
1433#else
1434      abort ();
1435#endif
1436      break;
1437    }
1438
1439  /* Check for overflow.  FIXME: We may drop bits during the addition
1440     which we don't check for.  We must either check at every single
1441     operation, which would be tedious, or we must do the computations
1442     in a type larger than bfd_vma, which would be inefficient.  */
1443  flag = bfd_reloc_ok;
1444  if (howto->complain_on_overflow != complain_overflow_dont)
1445    {
1446      bfd_vma addrmask, fieldmask, signmask, ss;
1447      bfd_vma a, b, sum;
1448
1449      /* Get the values to be added together.  For signed and unsigned
1450         relocations, we assume that all values should be truncated to
1451         the size of an address.  For bitfields, all the bits matter.
1452         See also bfd_check_overflow.  */
1453      fieldmask = N_ONES (howto->bitsize);
1454      addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
1455      a = relocation;
1456      b = x & howto->src_mask;
1457
1458      switch (howto->complain_on_overflow)
1459	{
1460	case complain_overflow_signed:
1461	  a = (a & addrmask) >> rightshift;
1462
1463	  /* If any sign bits are set, all sign bits must be set.
1464	     That is, A must be a valid negative address after
1465	     shifting.  */
1466	  signmask = ~ (fieldmask >> 1);
1467	  ss = a & signmask;
1468	  if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
1469	    flag = bfd_reloc_overflow;
1470
1471	  /* We only need this next bit of code if the sign bit of B
1472             is below the sign bit of A.  This would only happen if
1473             SRC_MASK had fewer bits than BITSIZE.  Note that if
1474             SRC_MASK has more bits than BITSIZE, we can get into
1475             trouble; we would need to verify that B is in range, as
1476             we do for A above.  */
1477	  signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1478
1479	  /* Set all the bits above the sign bit.  */
1480	  b = (b ^ signmask) - signmask;
1481
1482	  b = (b & addrmask) >> bitpos;
1483
1484	  /* Now we can do the addition.  */
1485	  sum = a + b;
1486
1487	  /* See if the result has the correct sign.  Bits above the
1488             sign bit are junk now; ignore them.  If the sum is
1489             positive, make sure we did not have all negative inputs;
1490             if the sum is negative, make sure we did not have all
1491             positive inputs.  The test below looks only at the sign
1492             bits, and it really just
1493	         SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1494	     */
1495	  signmask = (fieldmask >> 1) + 1;
1496	  if (((~ (a ^ b)) & (a ^ sum)) & signmask)
1497	    flag = bfd_reloc_overflow;
1498
1499	  break;
1500
1501	case complain_overflow_unsigned:
1502	  /* Checking for an unsigned overflow is relatively easy:
1503             trim the addresses and add, and trim the result as well.
1504             Overflow is normally indicated when the result does not
1505             fit in the field.  However, we also need to consider the
1506             case when, e.g., fieldmask is 0x7fffffff or smaller, an
1507             input is 0x80000000, and bfd_vma is only 32 bits; then we
1508             will get sum == 0, but there is an overflow, since the
1509             inputs did not fit in the field.  Instead of doing a
1510             separate test, we can check for this by or-ing in the
1511             operands when testing for the sum overflowing its final
1512             field.  */
1513	  a = (a & addrmask) >> rightshift;
1514	  b = (b & addrmask) >> bitpos;
1515	  sum = (a + b) & addrmask;
1516	  if ((a | b | sum) & ~ fieldmask)
1517	    flag = bfd_reloc_overflow;
1518
1519	  break;
1520
1521	case complain_overflow_bitfield:
1522	  /* Much like the signed check, but for a field one bit
1523	     wider, and no trimming inputs with addrmask.  We allow a
1524	     bitfield to represent numbers in the range -2**n to
1525	     2**n-1, where n is the number of bits in the field.
1526	     Note that when bfd_vma is 32 bits, a 32-bit reloc can't
1527	     overflow, which is exactly what we want.  */
1528	  a >>= rightshift;
1529
1530	  signmask = ~ fieldmask;
1531	  ss = a & signmask;
1532	  if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & signmask))
1533	    flag = bfd_reloc_overflow;
1534
1535	  signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1536	  b = (b ^ signmask) - signmask;
1537
1538	  b >>= bitpos;
1539
1540	  sum = a + b;
1541
1542	  /* We mask with addrmask here to explicitly allow an address
1543	     wrap-around.  The Linux kernel relies on it, and it is
1544	     the only way to write assembler code which can run when
1545	     loaded at a location 0x80000000 away from the location at
1546	     which it is linked.  */
1547	  signmask = fieldmask + 1;
1548	  if (((~ (a ^ b)) & (a ^ sum)) & signmask & addrmask)
1549	    flag = bfd_reloc_overflow;
1550
1551	  break;
1552
1553	default:
1554	  abort ();
1555	}
1556    }
1557
1558  /* Put RELOCATION in the right bits.  */
1559  relocation >>= (bfd_vma) rightshift;
1560  relocation <<= (bfd_vma) bitpos;
1561
1562  /* Add RELOCATION to the right bits of X.  */
1563  x = ((x & ~howto->dst_mask)
1564       | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1565
1566  /* Put the relocated value back in the object file.  */
1567  switch (size)
1568    {
1569    default:
1570    case 0:
1571      abort ();
1572    case 1:
1573      bfd_put_8 (input_bfd, x, location);
1574      break;
1575    case 2:
1576      bfd_put_16 (input_bfd, x, location);
1577      break;
1578    case 4:
1579      bfd_put_32 (input_bfd, x, location);
1580      break;
1581    case 8:
1582#ifdef BFD64
1583      bfd_put_64 (input_bfd, x, location);
1584#else
1585      abort ();
1586#endif
1587      break;
1588    }
1589
1590  return flag;
1591}
1592
1593/*
1594DOCDD
1595INODE
1596	howto manager,  , typedef arelent, Relocations
1597
1598SECTION
1599	The howto manager
1600
1601	When an application wants to create a relocation, but doesn't
1602	know what the target machine might call it, it can find out by
1603	using this bit of code.
1604
1605*/
1606
1607/*
1608TYPEDEF
1609	bfd_reloc_code_type
1610
1611DESCRIPTION
1612	The insides of a reloc code.  The idea is that, eventually, there
1613	will be one enumerator for every type of relocation we ever do.
1614	Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1615	return a howto pointer.
1616
1617	This does mean that the application must determine the correct
1618	enumerator value; you can't get a howto pointer from a random set
1619	of attributes.
1620
1621SENUM
1622   bfd_reloc_code_real
1623
1624ENUM
1625  BFD_RELOC_64
1626ENUMX
1627  BFD_RELOC_32
1628ENUMX
1629  BFD_RELOC_26
1630ENUMX
1631  BFD_RELOC_24
1632ENUMX
1633  BFD_RELOC_16
1634ENUMX
1635  BFD_RELOC_14
1636ENUMX
1637  BFD_RELOC_8
1638ENUMDOC
1639  Basic absolute relocations of N bits.
1640
1641ENUM
1642  BFD_RELOC_64_PCREL
1643ENUMX
1644  BFD_RELOC_32_PCREL
1645ENUMX
1646  BFD_RELOC_24_PCREL
1647ENUMX
1648  BFD_RELOC_16_PCREL
1649ENUMX
1650  BFD_RELOC_12_PCREL
1651ENUMX
1652  BFD_RELOC_8_PCREL
1653ENUMDOC
1654  PC-relative relocations.  Sometimes these are relative to the address
1655of the relocation itself; sometimes they are relative to the start of
1656the section containing the relocation.  It depends on the specific target.
1657
1658The 24-bit relocation is used in some Intel 960 configurations.
1659
1660ENUM
1661  BFD_RELOC_32_GOT_PCREL
1662ENUMX
1663  BFD_RELOC_16_GOT_PCREL
1664ENUMX
1665  BFD_RELOC_8_GOT_PCREL
1666ENUMX
1667  BFD_RELOC_32_GOTOFF
1668ENUMX
1669  BFD_RELOC_16_GOTOFF
1670ENUMX
1671  BFD_RELOC_LO16_GOTOFF
1672ENUMX
1673  BFD_RELOC_HI16_GOTOFF
1674ENUMX
1675  BFD_RELOC_HI16_S_GOTOFF
1676ENUMX
1677  BFD_RELOC_8_GOTOFF
1678ENUMX
1679  BFD_RELOC_64_PLT_PCREL
1680ENUMX
1681  BFD_RELOC_32_PLT_PCREL
1682ENUMX
1683  BFD_RELOC_24_PLT_PCREL
1684ENUMX
1685  BFD_RELOC_16_PLT_PCREL
1686ENUMX
1687  BFD_RELOC_8_PLT_PCREL
1688ENUMX
1689  BFD_RELOC_64_PLTOFF
1690ENUMX
1691  BFD_RELOC_32_PLTOFF
1692ENUMX
1693  BFD_RELOC_16_PLTOFF
1694ENUMX
1695  BFD_RELOC_LO16_PLTOFF
1696ENUMX
1697  BFD_RELOC_HI16_PLTOFF
1698ENUMX
1699  BFD_RELOC_HI16_S_PLTOFF
1700ENUMX
1701  BFD_RELOC_8_PLTOFF
1702ENUMDOC
1703  For ELF.
1704
1705ENUM
1706  BFD_RELOC_68K_GLOB_DAT
1707ENUMX
1708  BFD_RELOC_68K_JMP_SLOT
1709ENUMX
1710  BFD_RELOC_68K_RELATIVE
1711ENUMDOC
1712  Relocations used by 68K ELF.
1713
1714ENUM
1715  BFD_RELOC_32_BASEREL
1716ENUMX
1717  BFD_RELOC_16_BASEREL
1718ENUMX
1719  BFD_RELOC_LO16_BASEREL
1720ENUMX
1721  BFD_RELOC_HI16_BASEREL
1722ENUMX
1723  BFD_RELOC_HI16_S_BASEREL
1724ENUMX
1725  BFD_RELOC_8_BASEREL
1726ENUMX
1727  BFD_RELOC_RVA
1728ENUMDOC
1729  Linkage-table relative.
1730
1731ENUM
1732  BFD_RELOC_8_FFnn
1733ENUMDOC
1734  Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1735
1736ENUM
1737  BFD_RELOC_32_PCREL_S2
1738ENUMX
1739  BFD_RELOC_16_PCREL_S2
1740ENUMX
1741  BFD_RELOC_23_PCREL_S2
1742ENUMDOC
1743  These PC-relative relocations are stored as word displacements --
1744i.e., byte displacements shifted right two bits.  The 30-bit word
1745displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1746SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
1747signed 16-bit displacement is used on the MIPS, and the 23-bit
1748displacement is used on the Alpha.
1749
1750ENUM
1751  BFD_RELOC_HI22
1752ENUMX
1753  BFD_RELOC_LO10
1754ENUMDOC
1755  High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1756the target word.  These are used on the SPARC.
1757
1758ENUM
1759  BFD_RELOC_GPREL16
1760ENUMX
1761  BFD_RELOC_GPREL32
1762ENUMDOC
1763  For systems that allocate a Global Pointer register, these are
1764displacements off that register.  These relocation types are
1765handled specially, because the value the register will have is
1766decided relatively late.
1767
1768ENUM
1769  BFD_RELOC_I960_CALLJ
1770ENUMDOC
1771  Reloc types used for i960/b.out.
1772
1773ENUM
1774  BFD_RELOC_NONE
1775ENUMX
1776  BFD_RELOC_SPARC_WDISP22
1777ENUMX
1778  BFD_RELOC_SPARC22
1779ENUMX
1780  BFD_RELOC_SPARC13
1781ENUMX
1782  BFD_RELOC_SPARC_GOT10
1783ENUMX
1784  BFD_RELOC_SPARC_GOT13
1785ENUMX
1786  BFD_RELOC_SPARC_GOT22
1787ENUMX
1788  BFD_RELOC_SPARC_PC10
1789ENUMX
1790  BFD_RELOC_SPARC_PC22
1791ENUMX
1792  BFD_RELOC_SPARC_WPLT30
1793ENUMX
1794  BFD_RELOC_SPARC_COPY
1795ENUMX
1796  BFD_RELOC_SPARC_GLOB_DAT
1797ENUMX
1798  BFD_RELOC_SPARC_JMP_SLOT
1799ENUMX
1800  BFD_RELOC_SPARC_RELATIVE
1801ENUMX
1802  BFD_RELOC_SPARC_UA16
1803ENUMX
1804  BFD_RELOC_SPARC_UA32
1805ENUMX
1806  BFD_RELOC_SPARC_UA64
1807ENUMDOC
1808  SPARC ELF relocations.  There is probably some overlap with other
1809  relocation types already defined.
1810
1811ENUM
1812  BFD_RELOC_SPARC_BASE13
1813ENUMX
1814  BFD_RELOC_SPARC_BASE22
1815ENUMDOC
1816  I think these are specific to SPARC a.out (e.g., Sun 4).
1817
1818ENUMEQ
1819  BFD_RELOC_SPARC_64
1820  BFD_RELOC_64
1821ENUMX
1822  BFD_RELOC_SPARC_10
1823ENUMX
1824  BFD_RELOC_SPARC_11
1825ENUMX
1826  BFD_RELOC_SPARC_OLO10
1827ENUMX
1828  BFD_RELOC_SPARC_HH22
1829ENUMX
1830  BFD_RELOC_SPARC_HM10
1831ENUMX
1832  BFD_RELOC_SPARC_LM22
1833ENUMX
1834  BFD_RELOC_SPARC_PC_HH22
1835ENUMX
1836  BFD_RELOC_SPARC_PC_HM10
1837ENUMX
1838  BFD_RELOC_SPARC_PC_LM22
1839ENUMX
1840  BFD_RELOC_SPARC_WDISP16
1841ENUMX
1842  BFD_RELOC_SPARC_WDISP19
1843ENUMX
1844  BFD_RELOC_SPARC_7
1845ENUMX
1846  BFD_RELOC_SPARC_6
1847ENUMX
1848  BFD_RELOC_SPARC_5
1849ENUMEQX
1850  BFD_RELOC_SPARC_DISP64
1851  BFD_RELOC_64_PCREL
1852ENUMX
1853  BFD_RELOC_SPARC_PLT32
1854ENUMX
1855  BFD_RELOC_SPARC_PLT64
1856ENUMX
1857  BFD_RELOC_SPARC_HIX22
1858ENUMX
1859  BFD_RELOC_SPARC_LOX10
1860ENUMX
1861  BFD_RELOC_SPARC_H44
1862ENUMX
1863  BFD_RELOC_SPARC_M44
1864ENUMX
1865  BFD_RELOC_SPARC_L44
1866ENUMX
1867  BFD_RELOC_SPARC_REGISTER
1868ENUMDOC
1869  SPARC64 relocations
1870
1871ENUM
1872  BFD_RELOC_SPARC_REV32
1873ENUMDOC
1874  SPARC little endian relocation
1875
1876ENUM
1877  BFD_RELOC_ALPHA_GPDISP_HI16
1878ENUMDOC
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).
1885ENUM
1886  BFD_RELOC_ALPHA_GPDISP_LO16
1887ENUMDOC
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.
1892
1893ENUM
1894  BFD_RELOC_ALPHA_GPDISP
1895ENUMDOC
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.
1899
1900ENUM
1901  BFD_RELOC_ALPHA_LITERAL
1902ENUMX
1903  BFD_RELOC_ALPHA_ELF_LITERAL
1904ENUMX
1905  BFD_RELOC_ALPHA_LITUSE
1906ENUMDOC
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.
1910
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.
1915
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.
1921
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)
1930
1931ENUM
1932  BFD_RELOC_ALPHA_HINT
1933ENUMDOC
1934  The HINT relocation indicates a value that should be filled into the
1935     "hint" field of a jmp/jsr/ret instruction, for possible branch-
1936     prediction logic which may be provided on some processors.
1937
1938ENUM
1939  BFD_RELOC_ALPHA_LINKAGE
1940ENUMDOC
1941  The LINKAGE relocation outputs a linkage pair in the object file,
1942     which is filled by the linker.
1943
1944ENUM
1945  BFD_RELOC_ALPHA_CODEADDR
1946ENUMDOC
1947  The CODEADDR relocation outputs a STO_CA in the object file,
1948     which is filled by the linker.
1949
1950ENUM
1951  BFD_RELOC_ALPHA_GPREL_HI16
1952ENUMX
1953  BFD_RELOC_ALPHA_GPREL_LO16
1954ENUMDOC
1955  The GPREL_HI/LO relocations together form a 32-bit offset from the
1956     GP register.
1957
1958ENUM
1959  BFD_RELOC_ALPHA_BRSGP
1960ENUMDOC
1961  Like BFD_RELOC_23_PCREL_S2, except that the source and target must
1962  share a common GP, and the target address is adjusted for
1963  STO_ALPHA_STD_GPLOAD.
1964
1965ENUM
1966  BFD_RELOC_ALPHA_TLSGD
1967ENUMX
1968  BFD_RELOC_ALPHA_TLSLDM
1969ENUMX
1970  BFD_RELOC_ALPHA_DTPMOD64
1971ENUMX
1972  BFD_RELOC_ALPHA_GOTDTPREL16
1973ENUMX
1974  BFD_RELOC_ALPHA_DTPREL64
1975ENUMX
1976  BFD_RELOC_ALPHA_DTPREL_HI16
1977ENUMX
1978  BFD_RELOC_ALPHA_DTPREL_LO16
1979ENUMX
1980  BFD_RELOC_ALPHA_DTPREL16
1981ENUMX
1982  BFD_RELOC_ALPHA_GOTTPREL16
1983ENUMX
1984  BFD_RELOC_ALPHA_TPREL64
1985ENUMX
1986  BFD_RELOC_ALPHA_TPREL_HI16
1987ENUMX
1988  BFD_RELOC_ALPHA_TPREL_LO16
1989ENUMX
1990  BFD_RELOC_ALPHA_TPREL16
1991ENUMDOC
1992  Alpha thread-local storage relocations.
1993
1994ENUM
1995  BFD_RELOC_MIPS_JMP
1996ENUMDOC
1997  Bits 27..2 of the relocation address shifted right 2 bits;
1998     simple reloc otherwise.
1999
2000ENUM
2001  BFD_RELOC_MIPS16_JMP
2002ENUMDOC
2003  The MIPS16 jump instruction.
2004
2005ENUM
2006  BFD_RELOC_MIPS16_GPREL
2007ENUMDOC
2008  MIPS16 GP relative reloc.
2009
2010ENUM
2011  BFD_RELOC_HI16
2012ENUMDOC
2013  High 16 bits of 32-bit value; simple reloc.
2014ENUM
2015  BFD_RELOC_HI16_S
2016ENUMDOC
2017  High 16 bits of 32-bit value but the low 16 bits will be sign
2018     extended and added to form the final result.  If the low 16
2019     bits form a negative number, we need to add one to the high value
2020     to compensate for the borrow when the low bits are added.
2021ENUM
2022  BFD_RELOC_LO16
2023ENUMDOC
2024  Low 16 bits.
2025ENUM
2026  BFD_RELOC_PCREL_HI16_S
2027ENUMDOC
2028  Like BFD_RELOC_HI16_S, but PC relative.
2029ENUM
2030  BFD_RELOC_PCREL_LO16
2031ENUMDOC
2032  Like BFD_RELOC_LO16, but PC relative.
2033
2034ENUM
2035  BFD_RELOC_MIPS_LITERAL
2036ENUMDOC
2037  Relocation against a MIPS literal section.
2038
2039ENUM
2040  BFD_RELOC_MIPS_GOT16
2041ENUMX
2042  BFD_RELOC_MIPS_CALL16
2043ENUMX
2044  BFD_RELOC_MIPS_GOT_HI16
2045ENUMX
2046  BFD_RELOC_MIPS_GOT_LO16
2047ENUMX
2048  BFD_RELOC_MIPS_CALL_HI16
2049ENUMX
2050  BFD_RELOC_MIPS_CALL_LO16
2051ENUMX
2052  BFD_RELOC_MIPS_SUB
2053ENUMX
2054  BFD_RELOC_MIPS_GOT_PAGE
2055ENUMX
2056  BFD_RELOC_MIPS_GOT_OFST
2057ENUMX
2058  BFD_RELOC_MIPS_GOT_DISP
2059ENUMX
2060  BFD_RELOC_MIPS_SHIFT5
2061ENUMX
2062  BFD_RELOC_MIPS_SHIFT6
2063ENUMX
2064  BFD_RELOC_MIPS_INSERT_A
2065ENUMX
2066  BFD_RELOC_MIPS_INSERT_B
2067ENUMX
2068  BFD_RELOC_MIPS_DELETE
2069ENUMX
2070  BFD_RELOC_MIPS_HIGHEST
2071ENUMX
2072  BFD_RELOC_MIPS_HIGHER
2073ENUMX
2074  BFD_RELOC_MIPS_SCN_DISP
2075ENUMX
2076  BFD_RELOC_MIPS_REL16
2077ENUMX
2078  BFD_RELOC_MIPS_RELGOT
2079ENUMX
2080  BFD_RELOC_MIPS_JALR
2081COMMENT
2082ENUM
2083  BFD_RELOC_FRV_LABEL16
2084ENUMX
2085  BFD_RELOC_FRV_LABEL24
2086ENUMX
2087  BFD_RELOC_FRV_LO16
2088ENUMX
2089  BFD_RELOC_FRV_HI16
2090ENUMX
2091  BFD_RELOC_FRV_GPREL12
2092ENUMX
2093  BFD_RELOC_FRV_GPRELU12
2094ENUMX
2095  BFD_RELOC_FRV_GPREL32
2096ENUMX
2097  BFD_RELOC_FRV_GPRELHI
2098ENUMX
2099  BFD_RELOC_FRV_GPRELLO
2100ENUMDOC
2101  Fujitsu Frv Relocations.
2102COMMENT
2103COMMENT
2104ENUMDOC
2105  MIPS ELF relocations.
2106
2107COMMENT
2108
2109ENUM
2110  BFD_RELOC_386_GOT32
2111ENUMX
2112  BFD_RELOC_386_PLT32
2113ENUMX
2114  BFD_RELOC_386_COPY
2115ENUMX
2116  BFD_RELOC_386_GLOB_DAT
2117ENUMX
2118  BFD_RELOC_386_JUMP_SLOT
2119ENUMX
2120  BFD_RELOC_386_RELATIVE
2121ENUMX
2122  BFD_RELOC_386_GOTOFF
2123ENUMX
2124  BFD_RELOC_386_GOTPC
2125ENUMX
2126  BFD_RELOC_386_TLS_TPOFF
2127ENUMX
2128  BFD_RELOC_386_TLS_IE
2129ENUMX
2130  BFD_RELOC_386_TLS_GOTIE
2131ENUMX
2132  BFD_RELOC_386_TLS_LE
2133ENUMX
2134  BFD_RELOC_386_TLS_GD
2135ENUMX
2136  BFD_RELOC_386_TLS_LDM
2137ENUMX
2138  BFD_RELOC_386_TLS_LDO_32
2139ENUMX
2140  BFD_RELOC_386_TLS_IE_32
2141ENUMX
2142  BFD_RELOC_386_TLS_LE_32
2143ENUMX
2144  BFD_RELOC_386_TLS_DTPMOD32
2145ENUMX
2146  BFD_RELOC_386_TLS_DTPOFF32
2147ENUMX
2148  BFD_RELOC_386_TLS_TPOFF32
2149ENUMDOC
2150  i386/elf relocations
2151
2152ENUM
2153  BFD_RELOC_X86_64_GOT32
2154ENUMX
2155  BFD_RELOC_X86_64_PLT32
2156ENUMX
2157  BFD_RELOC_X86_64_COPY
2158ENUMX
2159  BFD_RELOC_X86_64_GLOB_DAT
2160ENUMX
2161  BFD_RELOC_X86_64_JUMP_SLOT
2162ENUMX
2163  BFD_RELOC_X86_64_RELATIVE
2164ENUMX
2165  BFD_RELOC_X86_64_GOTPCREL
2166ENUMX
2167  BFD_RELOC_X86_64_32S
2168ENUMDOC
2169  x86-64/elf relocations
2170
2171ENUM
2172  BFD_RELOC_NS32K_IMM_8
2173ENUMX
2174  BFD_RELOC_NS32K_IMM_16
2175ENUMX
2176  BFD_RELOC_NS32K_IMM_32
2177ENUMX
2178  BFD_RELOC_NS32K_IMM_8_PCREL
2179ENUMX
2180  BFD_RELOC_NS32K_IMM_16_PCREL
2181ENUMX
2182  BFD_RELOC_NS32K_IMM_32_PCREL
2183ENUMX
2184  BFD_RELOC_NS32K_DISP_8
2185ENUMX
2186  BFD_RELOC_NS32K_DISP_16
2187ENUMX
2188  BFD_RELOC_NS32K_DISP_32
2189ENUMX
2190  BFD_RELOC_NS32K_DISP_8_PCREL
2191ENUMX
2192  BFD_RELOC_NS32K_DISP_16_PCREL
2193ENUMX
2194  BFD_RELOC_NS32K_DISP_32_PCREL
2195ENUMDOC
2196  ns32k relocations
2197
2198ENUM
2199  BFD_RELOC_PDP11_DISP_8_PCREL
2200ENUMX
2201  BFD_RELOC_PDP11_DISP_6_PCREL
2202ENUMDOC
2203  PDP11 relocations
2204
2205ENUM
2206  BFD_RELOC_PJ_CODE_HI16
2207ENUMX
2208  BFD_RELOC_PJ_CODE_LO16
2209ENUMX
2210  BFD_RELOC_PJ_CODE_DIR16
2211ENUMX
2212  BFD_RELOC_PJ_CODE_DIR32
2213ENUMX
2214  BFD_RELOC_PJ_CODE_REL16
2215ENUMX
2216  BFD_RELOC_PJ_CODE_REL32
2217ENUMDOC
2218  Picojava relocs.  Not all of these appear in object files.
2219
2220ENUM
2221  BFD_RELOC_PPC_B26
2222ENUMX
2223  BFD_RELOC_PPC_BA26
2224ENUMX
2225  BFD_RELOC_PPC_TOC16
2226ENUMX
2227  BFD_RELOC_PPC_B16
2228ENUMX
2229  BFD_RELOC_PPC_B16_BRTAKEN
2230ENUMX
2231  BFD_RELOC_PPC_B16_BRNTAKEN
2232ENUMX
2233  BFD_RELOC_PPC_BA16
2234ENUMX
2235  BFD_RELOC_PPC_BA16_BRTAKEN
2236ENUMX
2237  BFD_RELOC_PPC_BA16_BRNTAKEN
2238ENUMX
2239  BFD_RELOC_PPC_COPY
2240ENUMX
2241  BFD_RELOC_PPC_GLOB_DAT
2242ENUMX
2243  BFD_RELOC_PPC_JMP_SLOT
2244ENUMX
2245  BFD_RELOC_PPC_RELATIVE
2246ENUMX
2247  BFD_RELOC_PPC_LOCAL24PC
2248ENUMX
2249  BFD_RELOC_PPC_EMB_NADDR32
2250ENUMX
2251  BFD_RELOC_PPC_EMB_NADDR16
2252ENUMX
2253  BFD_RELOC_PPC_EMB_NADDR16_LO
2254ENUMX
2255  BFD_RELOC_PPC_EMB_NADDR16_HI
2256ENUMX
2257  BFD_RELOC_PPC_EMB_NADDR16_HA
2258ENUMX
2259  BFD_RELOC_PPC_EMB_SDAI16
2260ENUMX
2261  BFD_RELOC_PPC_EMB_SDA2I16
2262ENUMX
2263  BFD_RELOC_PPC_EMB_SDA2REL
2264ENUMX
2265  BFD_RELOC_PPC_EMB_SDA21
2266ENUMX
2267  BFD_RELOC_PPC_EMB_MRKREF
2268ENUMX
2269  BFD_RELOC_PPC_EMB_RELSEC16
2270ENUMX
2271  BFD_RELOC_PPC_EMB_RELST_LO
2272ENUMX
2273  BFD_RELOC_PPC_EMB_RELST_HI
2274ENUMX
2275  BFD_RELOC_PPC_EMB_RELST_HA
2276ENUMX
2277  BFD_RELOC_PPC_EMB_BIT_FLD
2278ENUMX
2279  BFD_RELOC_PPC_EMB_RELSDA
2280ENUMX
2281  BFD_RELOC_PPC64_HIGHER
2282ENUMX
2283  BFD_RELOC_PPC64_HIGHER_S
2284ENUMX
2285  BFD_RELOC_PPC64_HIGHEST
2286ENUMX
2287  BFD_RELOC_PPC64_HIGHEST_S
2288ENUMX
2289  BFD_RELOC_PPC64_TOC16_LO
2290ENUMX
2291  BFD_RELOC_PPC64_TOC16_HI
2292ENUMX
2293  BFD_RELOC_PPC64_TOC16_HA
2294ENUMX
2295  BFD_RELOC_PPC64_TOC
2296ENUMX
2297  BFD_RELOC_PPC64_PLTGOT16
2298ENUMX
2299  BFD_RELOC_PPC64_PLTGOT16_LO
2300ENUMX
2301  BFD_RELOC_PPC64_PLTGOT16_HI
2302ENUMX
2303  BFD_RELOC_PPC64_PLTGOT16_HA
2304ENUMX
2305  BFD_RELOC_PPC64_ADDR16_DS
2306ENUMX
2307  BFD_RELOC_PPC64_ADDR16_LO_DS
2308ENUMX
2309  BFD_RELOC_PPC64_GOT16_DS
2310ENUMX
2311  BFD_RELOC_PPC64_GOT16_LO_DS
2312ENUMX
2313  BFD_RELOC_PPC64_PLT16_LO_DS
2314ENUMX
2315  BFD_RELOC_PPC64_SECTOFF_DS
2316ENUMX
2317  BFD_RELOC_PPC64_SECTOFF_LO_DS
2318ENUMX
2319  BFD_RELOC_PPC64_TOC16_DS
2320ENUMX
2321  BFD_RELOC_PPC64_TOC16_LO_DS
2322ENUMX
2323  BFD_RELOC_PPC64_PLTGOT16_DS
2324ENUMX
2325  BFD_RELOC_PPC64_PLTGOT16_LO_DS
2326ENUMDOC
2327  Power(rs6000) and PowerPC relocations.
2328
2329ENUM
2330  BFD_RELOC_I370_D12
2331ENUMDOC
2332  IBM 370/390 relocations
2333
2334ENUM
2335  BFD_RELOC_CTOR
2336ENUMDOC
2337  The type of reloc used to build a contructor table - at the moment
2338  probably a 32 bit wide absolute relocation, but the target can choose.
2339  It generally does map to one of the other relocation types.
2340
2341ENUM
2342  BFD_RELOC_ARM_PCREL_BRANCH
2343ENUMDOC
2344  ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
2345  not stored in the instruction.
2346ENUM
2347  BFD_RELOC_ARM_PCREL_BLX
2348ENUMDOC
2349  ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
2350  not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2351  field in the instruction.
2352ENUM
2353  BFD_RELOC_THUMB_PCREL_BLX
2354ENUMDOC
2355  Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
2356  not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2357  field in the instruction.
2358ENUM
2359  BFD_RELOC_ARM_IMMEDIATE
2360ENUMX
2361  BFD_RELOC_ARM_ADRL_IMMEDIATE
2362ENUMX
2363  BFD_RELOC_ARM_OFFSET_IMM
2364ENUMX
2365  BFD_RELOC_ARM_SHIFT_IMM
2366ENUMX
2367  BFD_RELOC_ARM_SWI
2368ENUMX
2369  BFD_RELOC_ARM_MULTI
2370ENUMX
2371  BFD_RELOC_ARM_CP_OFF_IMM
2372ENUMX
2373  BFD_RELOC_ARM_ADR_IMM
2374ENUMX
2375  BFD_RELOC_ARM_LDR_IMM
2376ENUMX
2377  BFD_RELOC_ARM_LITERAL
2378ENUMX
2379  BFD_RELOC_ARM_IN_POOL
2380ENUMX
2381  BFD_RELOC_ARM_OFFSET_IMM8
2382ENUMX
2383  BFD_RELOC_ARM_HWLITERAL
2384ENUMX
2385  BFD_RELOC_ARM_THUMB_ADD
2386ENUMX
2387  BFD_RELOC_ARM_THUMB_IMM
2388ENUMX
2389  BFD_RELOC_ARM_THUMB_SHIFT
2390ENUMX
2391  BFD_RELOC_ARM_THUMB_OFFSET
2392ENUMX
2393  BFD_RELOC_ARM_GOT12
2394ENUMX
2395  BFD_RELOC_ARM_GOT32
2396ENUMX
2397  BFD_RELOC_ARM_JUMP_SLOT
2398ENUMX
2399  BFD_RELOC_ARM_COPY
2400ENUMX
2401  BFD_RELOC_ARM_GLOB_DAT
2402ENUMX
2403  BFD_RELOC_ARM_PLT32
2404ENUMX
2405  BFD_RELOC_ARM_RELATIVE
2406ENUMX
2407  BFD_RELOC_ARM_GOTOFF
2408ENUMX
2409  BFD_RELOC_ARM_GOTPC
2410ENUMDOC
2411  These relocs are only used within the ARM assembler.  They are not
2412  (at present) written to any object files.
2413
2414ENUM
2415  BFD_RELOC_SH_PCDISP8BY2
2416ENUMX
2417  BFD_RELOC_SH_PCDISP12BY2
2418ENUMX
2419  BFD_RELOC_SH_IMM4
2420ENUMX
2421  BFD_RELOC_SH_IMM4BY2
2422ENUMX
2423  BFD_RELOC_SH_IMM4BY4
2424ENUMX
2425  BFD_RELOC_SH_IMM8
2426ENUMX
2427  BFD_RELOC_SH_IMM8BY2
2428ENUMX
2429  BFD_RELOC_SH_IMM8BY4
2430ENUMX
2431  BFD_RELOC_SH_PCRELIMM8BY2
2432ENUMX
2433  BFD_RELOC_SH_PCRELIMM8BY4
2434ENUMX
2435  BFD_RELOC_SH_SWITCH16
2436ENUMX
2437  BFD_RELOC_SH_SWITCH32
2438ENUMX
2439  BFD_RELOC_SH_USES
2440ENUMX
2441  BFD_RELOC_SH_COUNT
2442ENUMX
2443  BFD_RELOC_SH_ALIGN
2444ENUMX
2445  BFD_RELOC_SH_CODE
2446ENUMX
2447  BFD_RELOC_SH_DATA
2448ENUMX
2449  BFD_RELOC_SH_LABEL
2450ENUMX
2451  BFD_RELOC_SH_LOOP_START
2452ENUMX
2453  BFD_RELOC_SH_LOOP_END
2454ENUMX
2455  BFD_RELOC_SH_COPY
2456ENUMX
2457  BFD_RELOC_SH_GLOB_DAT
2458ENUMX
2459  BFD_RELOC_SH_JMP_SLOT
2460ENUMX
2461  BFD_RELOC_SH_RELATIVE
2462ENUMX
2463  BFD_RELOC_SH_GOTPC
2464ENUMX
2465  BFD_RELOC_SH_GOT_LOW16
2466ENUMX
2467  BFD_RELOC_SH_GOT_MEDLOW16
2468ENUMX
2469  BFD_RELOC_SH_GOT_MEDHI16
2470ENUMX
2471  BFD_RELOC_SH_GOT_HI16
2472ENUMX
2473  BFD_RELOC_SH_GOTPLT_LOW16
2474ENUMX
2475  BFD_RELOC_SH_GOTPLT_MEDLOW16
2476ENUMX
2477  BFD_RELOC_SH_GOTPLT_MEDHI16
2478ENUMX
2479  BFD_RELOC_SH_GOTPLT_HI16
2480ENUMX
2481  BFD_RELOC_SH_PLT_LOW16
2482ENUMX
2483  BFD_RELOC_SH_PLT_MEDLOW16
2484ENUMX
2485  BFD_RELOC_SH_PLT_MEDHI16
2486ENUMX
2487  BFD_RELOC_SH_PLT_HI16
2488ENUMX
2489  BFD_RELOC_SH_GOTOFF_LOW16
2490ENUMX
2491  BFD_RELOC_SH_GOTOFF_MEDLOW16
2492ENUMX
2493  BFD_RELOC_SH_GOTOFF_MEDHI16
2494ENUMX
2495  BFD_RELOC_SH_GOTOFF_HI16
2496ENUMX
2497  BFD_RELOC_SH_GOTPC_LOW16
2498ENUMX
2499  BFD_RELOC_SH_GOTPC_MEDLOW16
2500ENUMX
2501  BFD_RELOC_SH_GOTPC_MEDHI16
2502ENUMX
2503  BFD_RELOC_SH_GOTPC_HI16
2504ENUMX
2505  BFD_RELOC_SH_COPY64
2506ENUMX
2507  BFD_RELOC_SH_GLOB_DAT64
2508ENUMX
2509  BFD_RELOC_SH_JMP_SLOT64
2510ENUMX
2511  BFD_RELOC_SH_RELATIVE64
2512ENUMX
2513  BFD_RELOC_SH_GOT10BY4
2514ENUMX
2515  BFD_RELOC_SH_GOT10BY8
2516ENUMX
2517  BFD_RELOC_SH_GOTPLT10BY4
2518ENUMX
2519  BFD_RELOC_SH_GOTPLT10BY8
2520ENUMX
2521  BFD_RELOC_SH_GOTPLT32
2522ENUMX
2523  BFD_RELOC_SH_SHMEDIA_CODE
2524ENUMX
2525  BFD_RELOC_SH_IMMU5
2526ENUMX
2527  BFD_RELOC_SH_IMMS6
2528ENUMX
2529  BFD_RELOC_SH_IMMS6BY32
2530ENUMX
2531  BFD_RELOC_SH_IMMU6
2532ENUMX
2533  BFD_RELOC_SH_IMMS10
2534ENUMX
2535  BFD_RELOC_SH_IMMS10BY2
2536ENUMX
2537  BFD_RELOC_SH_IMMS10BY4
2538ENUMX
2539  BFD_RELOC_SH_IMMS10BY8
2540ENUMX
2541  BFD_RELOC_SH_IMMS16
2542ENUMX
2543  BFD_RELOC_SH_IMMU16
2544ENUMX
2545  BFD_RELOC_SH_IMM_LOW16
2546ENUMX
2547  BFD_RELOC_SH_IMM_LOW16_PCREL
2548ENUMX
2549  BFD_RELOC_SH_IMM_MEDLOW16
2550ENUMX
2551  BFD_RELOC_SH_IMM_MEDLOW16_PCREL
2552ENUMX
2553  BFD_RELOC_SH_IMM_MEDHI16
2554ENUMX
2555  BFD_RELOC_SH_IMM_MEDHI16_PCREL
2556ENUMX
2557  BFD_RELOC_SH_IMM_HI16
2558ENUMX
2559  BFD_RELOC_SH_IMM_HI16_PCREL
2560ENUMX
2561  BFD_RELOC_SH_PT_16
2562ENUMDOC
2563  Hitachi SH relocs.  Not all of these appear in object files.
2564
2565ENUM
2566  BFD_RELOC_THUMB_PCREL_BRANCH9
2567ENUMX
2568  BFD_RELOC_THUMB_PCREL_BRANCH12
2569ENUMX
2570  BFD_RELOC_THUMB_PCREL_BRANCH23
2571ENUMDOC
2572  Thumb 23-, 12- and 9-bit pc-relative branches.  The lowest bit must
2573  be zero and is not stored in the instruction.
2574
2575ENUM
2576  BFD_RELOC_ARC_B22_PCREL
2577ENUMDOC
2578  ARC Cores relocs.
2579  ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
2580  not stored in the instruction.  The high 20 bits are installed in bits 26
2581  through 7 of the instruction.
2582ENUM
2583  BFD_RELOC_ARC_B26
2584ENUMDOC
2585  ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
2586  stored in the instruction.  The high 24 bits are installed in bits 23
2587  through 0.
2588
2589ENUM
2590  BFD_RELOC_D10V_10_PCREL_R
2591ENUMDOC
2592  Mitsubishi D10V relocs.
2593  This is a 10-bit reloc with the right 2 bits
2594  assumed to be 0.
2595ENUM
2596  BFD_RELOC_D10V_10_PCREL_L
2597ENUMDOC
2598  Mitsubishi D10V relocs.
2599  This is a 10-bit reloc with the right 2 bits
2600  assumed to be 0.  This is the same as the previous reloc
2601  except it is in the left container, i.e.,
2602  shifted left 15 bits.
2603ENUM
2604  BFD_RELOC_D10V_18
2605ENUMDOC
2606  This is an 18-bit reloc with the right 2 bits
2607  assumed to be 0.
2608ENUM
2609  BFD_RELOC_D10V_18_PCREL
2610ENUMDOC
2611  This is an 18-bit reloc with the right 2 bits
2612  assumed to be 0.
2613
2614ENUM
2615  BFD_RELOC_D30V_6
2616ENUMDOC
2617  Mitsubishi D30V relocs.
2618  This is a 6-bit absolute reloc.
2619ENUM
2620  BFD_RELOC_D30V_9_PCREL
2621ENUMDOC
2622  This is a 6-bit pc-relative reloc with
2623  the right 3 bits assumed to be 0.
2624ENUM
2625  BFD_RELOC_D30V_9_PCREL_R
2626ENUMDOC
2627  This is a 6-bit pc-relative reloc with
2628  the right 3 bits assumed to be 0. Same
2629  as the previous reloc but on the right side
2630  of the container.
2631ENUM
2632  BFD_RELOC_D30V_15
2633ENUMDOC
2634  This is a 12-bit absolute reloc with the
2635  right 3 bitsassumed to be 0.
2636ENUM
2637  BFD_RELOC_D30V_15_PCREL
2638ENUMDOC
2639  This is a 12-bit pc-relative reloc with
2640  the right 3 bits assumed to be 0.
2641ENUM
2642  BFD_RELOC_D30V_15_PCREL_R
2643ENUMDOC
2644  This is a 12-bit pc-relative reloc with
2645  the right 3 bits assumed to be 0. Same
2646  as the previous reloc but on the right side
2647  of the container.
2648ENUM
2649  BFD_RELOC_D30V_21
2650ENUMDOC
2651  This is an 18-bit absolute reloc with
2652  the right 3 bits assumed to be 0.
2653ENUM
2654  BFD_RELOC_D30V_21_PCREL
2655ENUMDOC
2656  This is an 18-bit pc-relative reloc with
2657  the right 3 bits assumed to be 0.
2658ENUM
2659  BFD_RELOC_D30V_21_PCREL_R
2660ENUMDOC
2661  This is an 18-bit pc-relative reloc with
2662  the right 3 bits assumed to be 0. Same
2663  as the previous reloc but on the right side
2664  of the container.
2665ENUM
2666  BFD_RELOC_D30V_32
2667ENUMDOC
2668  This is a 32-bit absolute reloc.
2669ENUM
2670  BFD_RELOC_D30V_32_PCREL
2671ENUMDOC
2672  This is a 32-bit pc-relative reloc.
2673
2674ENUM
2675  BFD_RELOC_DLX_HI16_S
2676ENUMDOC
2677  DLX relocs
2678ENUM
2679  BFD_RELOC_DLX_LO16
2680ENUMDOC
2681  DLX relocs
2682ENUM
2683  BFD_RELOC_DLX_JMP26
2684ENUMDOC
2685  DLX relocs
2686
2687ENUM
2688  BFD_RELOC_M32R_24
2689ENUMDOC
2690  Mitsubishi M32R relocs.
2691  This is a 24 bit absolute address.
2692ENUM
2693  BFD_RELOC_M32R_10_PCREL
2694ENUMDOC
2695  This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
2696ENUM
2697  BFD_RELOC_M32R_18_PCREL
2698ENUMDOC
2699  This is an 18-bit reloc with the right 2 bits assumed to be 0.
2700ENUM
2701  BFD_RELOC_M32R_26_PCREL
2702ENUMDOC
2703  This is a 26-bit reloc with the right 2 bits assumed to be 0.
2704ENUM
2705  BFD_RELOC_M32R_HI16_ULO
2706ENUMDOC
2707  This is a 16-bit reloc containing the high 16 bits of an address
2708  used when the lower 16 bits are treated as unsigned.
2709ENUM
2710  BFD_RELOC_M32R_HI16_SLO
2711ENUMDOC
2712  This is a 16-bit reloc containing the high 16 bits of an address
2713  used when the lower 16 bits are treated as signed.
2714ENUM
2715  BFD_RELOC_M32R_LO16
2716ENUMDOC
2717  This is a 16-bit reloc containing the lower 16 bits of an address.
2718ENUM
2719  BFD_RELOC_M32R_SDA16
2720ENUMDOC
2721  This is a 16-bit reloc containing the small data area offset for use in
2722  add3, load, and store instructions.
2723
2724ENUM
2725  BFD_RELOC_V850_9_PCREL
2726ENUMDOC
2727  This is a 9-bit reloc
2728ENUM
2729  BFD_RELOC_V850_22_PCREL
2730ENUMDOC
2731  This is a 22-bit reloc
2732
2733ENUM
2734  BFD_RELOC_V850_SDA_16_16_OFFSET
2735ENUMDOC
2736  This is a 16 bit offset from the short data area pointer.
2737ENUM
2738  BFD_RELOC_V850_SDA_15_16_OFFSET
2739ENUMDOC
2740  This is a 16 bit offset (of which only 15 bits are used) from the
2741  short data area pointer.
2742ENUM
2743  BFD_RELOC_V850_ZDA_16_16_OFFSET
2744ENUMDOC
2745  This is a 16 bit offset from the zero data area pointer.
2746ENUM
2747  BFD_RELOC_V850_ZDA_15_16_OFFSET
2748ENUMDOC
2749  This is a 16 bit offset (of which only 15 bits are used) from the
2750  zero data area pointer.
2751ENUM
2752  BFD_RELOC_V850_TDA_6_8_OFFSET
2753ENUMDOC
2754  This is an 8 bit offset (of which only 6 bits are used) from the
2755  tiny data area pointer.
2756ENUM
2757  BFD_RELOC_V850_TDA_7_8_OFFSET
2758ENUMDOC
2759  This is an 8bit offset (of which only 7 bits are used) from the tiny
2760  data area pointer.
2761ENUM
2762  BFD_RELOC_V850_TDA_7_7_OFFSET
2763ENUMDOC
2764  This is a 7 bit offset from the tiny data area pointer.
2765ENUM
2766  BFD_RELOC_V850_TDA_16_16_OFFSET
2767ENUMDOC
2768  This is a 16 bit offset from the tiny data area pointer.
2769COMMENT
2770ENUM
2771  BFD_RELOC_V850_TDA_4_5_OFFSET
2772ENUMDOC
2773  This is a 5 bit offset (of which only 4 bits are used) from the tiny
2774  data area pointer.
2775ENUM
2776  BFD_RELOC_V850_TDA_4_4_OFFSET
2777ENUMDOC
2778  This is a 4 bit offset from the tiny data area pointer.
2779ENUM
2780  BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
2781ENUMDOC
2782  This is a 16 bit offset from the short data area pointer, with the
2783  bits placed non-contigously in the instruction.
2784ENUM
2785  BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
2786ENUMDOC
2787  This is a 16 bit offset from the zero data area pointer, with the
2788  bits placed non-contigously in the instruction.
2789ENUM
2790  BFD_RELOC_V850_CALLT_6_7_OFFSET
2791ENUMDOC
2792  This is a 6 bit offset from the call table base pointer.
2793ENUM
2794  BFD_RELOC_V850_CALLT_16_16_OFFSET
2795ENUMDOC
2796  This is a 16 bit offset from the call table base pointer.
2797COMMENT
2798
2799ENUM
2800  BFD_RELOC_MN10300_32_PCREL
2801ENUMDOC
2802  This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2803  instruction.
2804ENUM
2805  BFD_RELOC_MN10300_16_PCREL
2806ENUMDOC
2807  This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2808  instruction.
2809
2810ENUM
2811  BFD_RELOC_TIC30_LDP
2812ENUMDOC
2813  This is a 8bit DP reloc for the tms320c30, where the most
2814  significant 8 bits of a 24 bit word are placed into the least
2815  significant 8 bits of the opcode.
2816
2817ENUM
2818  BFD_RELOC_TIC54X_PARTLS7
2819ENUMDOC
2820  This is a 7bit reloc for the tms320c54x, where the least
2821  significant 7 bits of a 16 bit word are placed into the least
2822  significant 7 bits of the opcode.
2823
2824ENUM
2825  BFD_RELOC_TIC54X_PARTMS9
2826ENUMDOC
2827  This is a 9bit DP reloc for the tms320c54x, where the most
2828  significant 9 bits of a 16 bit word are placed into the least
2829  significant 9 bits of the opcode.
2830
2831ENUM
2832  BFD_RELOC_TIC54X_23
2833ENUMDOC
2834  This is an extended address 23-bit reloc for the tms320c54x.
2835
2836ENUM
2837  BFD_RELOC_TIC54X_16_OF_23
2838ENUMDOC
2839  This is a 16-bit reloc for the tms320c54x, where the least
2840  significant 16 bits of a 23-bit extended address are placed into
2841  the opcode.
2842
2843ENUM
2844  BFD_RELOC_TIC54X_MS7_OF_23
2845ENUMDOC
2846  This is a reloc for the tms320c54x, where the most
2847  significant 7 bits of a 23-bit extended address are placed into
2848  the opcode.
2849
2850ENUM
2851  BFD_RELOC_FR30_48
2852ENUMDOC
2853  This is a 48 bit reloc for the FR30 that stores 32 bits.
2854ENUM
2855  BFD_RELOC_FR30_20
2856ENUMDOC
2857  This is a 32 bit reloc for the FR30 that stores 20 bits split up into
2858  two sections.
2859ENUM
2860  BFD_RELOC_FR30_6_IN_4
2861ENUMDOC
2862  This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
2863  4 bits.
2864ENUM
2865  BFD_RELOC_FR30_8_IN_8
2866ENUMDOC
2867  This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
2868  into 8 bits.
2869ENUM
2870  BFD_RELOC_FR30_9_IN_8
2871ENUMDOC
2872  This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
2873  into 8 bits.
2874ENUM
2875  BFD_RELOC_FR30_10_IN_8
2876ENUMDOC
2877  This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
2878  into 8 bits.
2879ENUM
2880  BFD_RELOC_FR30_9_PCREL
2881ENUMDOC
2882  This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
2883  short offset into 8 bits.
2884ENUM
2885  BFD_RELOC_FR30_12_PCREL
2886ENUMDOC
2887  This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
2888  short offset into 11 bits.
2889
2890ENUM
2891  BFD_RELOC_MCORE_PCREL_IMM8BY4
2892ENUMX
2893  BFD_RELOC_MCORE_PCREL_IMM11BY2
2894ENUMX
2895  BFD_RELOC_MCORE_PCREL_IMM4BY2
2896ENUMX
2897  BFD_RELOC_MCORE_PCREL_32
2898ENUMX
2899  BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
2900ENUMX
2901  BFD_RELOC_MCORE_RVA
2902ENUMDOC
2903  Motorola Mcore relocations.
2904
2905ENUM
2906  BFD_RELOC_MMIX_GETA
2907ENUMX
2908  BFD_RELOC_MMIX_GETA_1
2909ENUMX
2910  BFD_RELOC_MMIX_GETA_2
2911ENUMX
2912  BFD_RELOC_MMIX_GETA_3
2913ENUMDOC
2914  These are relocations for the GETA instruction.
2915ENUM
2916  BFD_RELOC_MMIX_CBRANCH
2917ENUMX
2918  BFD_RELOC_MMIX_CBRANCH_J
2919ENUMX
2920  BFD_RELOC_MMIX_CBRANCH_1
2921ENUMX
2922  BFD_RELOC_MMIX_CBRANCH_2
2923ENUMX
2924  BFD_RELOC_MMIX_CBRANCH_3
2925ENUMDOC
2926  These are relocations for a conditional branch instruction.
2927ENUM
2928  BFD_RELOC_MMIX_PUSHJ
2929ENUMX
2930  BFD_RELOC_MMIX_PUSHJ_1
2931ENUMX
2932  BFD_RELOC_MMIX_PUSHJ_2
2933ENUMX
2934  BFD_RELOC_MMIX_PUSHJ_3
2935ENUMDOC
2936  These are relocations for the PUSHJ instruction.
2937ENUM
2938  BFD_RELOC_MMIX_JMP
2939ENUMX
2940  BFD_RELOC_MMIX_JMP_1
2941ENUMX
2942  BFD_RELOC_MMIX_JMP_2
2943ENUMX
2944  BFD_RELOC_MMIX_JMP_3
2945ENUMDOC
2946  These are relocations for the JMP instruction.
2947ENUM
2948  BFD_RELOC_MMIX_ADDR19
2949ENUMDOC
2950  This is a relocation for a relative address as in a GETA instruction or
2951  a branch.
2952ENUM
2953  BFD_RELOC_MMIX_ADDR27
2954ENUMDOC
2955  This is a relocation for a relative address as in a JMP instruction.
2956ENUM
2957  BFD_RELOC_MMIX_REG_OR_BYTE
2958ENUMDOC
2959  This is a relocation for an instruction field that may be a general
2960  register or a value 0..255.
2961ENUM
2962  BFD_RELOC_MMIX_REG
2963ENUMDOC
2964  This is a relocation for an instruction field that may be a general
2965  register.
2966ENUM
2967  BFD_RELOC_MMIX_BASE_PLUS_OFFSET
2968ENUMDOC
2969  This is a relocation for two instruction fields holding a register and
2970  an offset, the equivalent of the relocation.
2971ENUM
2972  BFD_RELOC_MMIX_LOCAL
2973ENUMDOC
2974  This relocation is an assertion that the expression is not allocated as
2975  a global register.  It does not modify contents.
2976
2977ENUM
2978  BFD_RELOC_AVR_7_PCREL
2979ENUMDOC
2980  This is a 16 bit reloc for the AVR that stores 8 bit pc relative
2981  short offset into 7 bits.
2982ENUM
2983  BFD_RELOC_AVR_13_PCREL
2984ENUMDOC
2985  This is a 16 bit reloc for the AVR that stores 13 bit pc relative
2986  short offset into 12 bits.
2987ENUM
2988  BFD_RELOC_AVR_16_PM
2989ENUMDOC
2990  This is a 16 bit reloc for the AVR that stores 17 bit value (usually
2991  program memory address) into 16 bits.
2992ENUM
2993  BFD_RELOC_AVR_LO8_LDI
2994ENUMDOC
2995  This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2996  data memory address) into 8 bit immediate value of LDI insn.
2997ENUM
2998  BFD_RELOC_AVR_HI8_LDI
2999ENUMDOC
3000  This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
3001  of data memory address) into 8 bit immediate value of LDI insn.
3002ENUM
3003  BFD_RELOC_AVR_HH8_LDI
3004ENUMDOC
3005  This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
3006  of program memory address) into 8 bit immediate value of LDI insn.
3007ENUM
3008  BFD_RELOC_AVR_LO8_LDI_NEG
3009ENUMDOC
3010  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3011  (usually data memory address) into 8 bit immediate value of SUBI insn.
3012ENUM
3013  BFD_RELOC_AVR_HI8_LDI_NEG
3014ENUMDOC
3015  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3016  (high 8 bit of data memory address) into 8 bit immediate value of
3017  SUBI insn.
3018ENUM
3019  BFD_RELOC_AVR_HH8_LDI_NEG
3020ENUMDOC
3021  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3022  (most high 8 bit of program memory address) into 8 bit immediate value
3023  of LDI or SUBI insn.
3024ENUM
3025  BFD_RELOC_AVR_LO8_LDI_PM
3026ENUMDOC
3027  This is a 16 bit reloc for the AVR that stores 8 bit value (usually
3028  command address) into 8 bit immediate value of LDI insn.
3029ENUM
3030  BFD_RELOC_AVR_HI8_LDI_PM
3031ENUMDOC
3032  This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
3033  of command address) into 8 bit immediate value of LDI insn.
3034ENUM
3035  BFD_RELOC_AVR_HH8_LDI_PM
3036ENUMDOC
3037  This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
3038  of command address) into 8 bit immediate value of LDI insn.
3039ENUM
3040  BFD_RELOC_AVR_LO8_LDI_PM_NEG
3041ENUMDOC
3042  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3043  (usually command address) into 8 bit immediate value of SUBI insn.
3044ENUM
3045  BFD_RELOC_AVR_HI8_LDI_PM_NEG
3046ENUMDOC
3047  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3048  (high 8 bit of 16 bit command address) into 8 bit immediate value
3049  of SUBI insn.
3050ENUM
3051  BFD_RELOC_AVR_HH8_LDI_PM_NEG
3052ENUMDOC
3053  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3054  (high 6 bit of 22 bit command address) into 8 bit immediate
3055  value of SUBI insn.
3056ENUM
3057  BFD_RELOC_AVR_CALL
3058ENUMDOC
3059  This is a 32 bit reloc for the AVR that stores 23 bit value
3060  into 22 bits.
3061
3062ENUM
3063  BFD_RELOC_390_12
3064ENUMDOC
3065   Direct 12 bit.
3066ENUM
3067  BFD_RELOC_390_GOT12
3068ENUMDOC
3069  12 bit GOT offset.
3070ENUM
3071  BFD_RELOC_390_PLT32
3072ENUMDOC
3073  32 bit PC relative PLT address.
3074ENUM
3075  BFD_RELOC_390_COPY
3076ENUMDOC
3077  Copy symbol at runtime.
3078ENUM
3079  BFD_RELOC_390_GLOB_DAT
3080ENUMDOC
3081  Create GOT entry.
3082ENUM
3083  BFD_RELOC_390_JMP_SLOT
3084ENUMDOC
3085  Create PLT entry.
3086ENUM
3087  BFD_RELOC_390_RELATIVE
3088ENUMDOC
3089  Adjust by program base.
3090ENUM
3091  BFD_RELOC_390_GOTPC
3092ENUMDOC
3093  32 bit PC relative offset to GOT.
3094ENUM
3095  BFD_RELOC_390_GOT16
3096ENUMDOC
3097  16 bit GOT offset.
3098ENUM
3099  BFD_RELOC_390_PC16DBL
3100ENUMDOC
3101  PC relative 16 bit shifted by 1.
3102ENUM
3103  BFD_RELOC_390_PLT16DBL
3104ENUMDOC
3105  16 bit PC rel. PLT shifted by 1.
3106ENUM
3107  BFD_RELOC_390_PC32DBL
3108ENUMDOC
3109  PC relative 32 bit shifted by 1.
3110ENUM
3111  BFD_RELOC_390_PLT32DBL
3112ENUMDOC
3113  32 bit PC rel. PLT shifted by 1.
3114ENUM
3115  BFD_RELOC_390_GOTPCDBL
3116ENUMDOC
3117  32 bit PC rel. GOT shifted by 1.
3118ENUM
3119  BFD_RELOC_390_GOT64
3120ENUMDOC
3121  64 bit GOT offset.
3122ENUM
3123  BFD_RELOC_390_PLT64
3124ENUMDOC
3125  64 bit PC relative PLT address.
3126ENUM
3127  BFD_RELOC_390_GOTENT
3128ENUMDOC
3129  32 bit rel. offset to GOT entry.
3130
3131ENUM
3132  BFD_RELOC_VTABLE_INHERIT
3133ENUMX
3134  BFD_RELOC_VTABLE_ENTRY
3135ENUMDOC
3136  These two relocations are used by the linker to determine which of
3137  the entries in a C++ virtual function table are actually used.  When
3138  the --gc-sections option is given, the linker will zero out the entries
3139  that are not used, so that the code for those functions need not be
3140  included in the output.
3141
3142  VTABLE_INHERIT is a zero-space relocation used to describe to the
3143  linker the inheritence tree of a C++ virtual function table.  The
3144  relocation's symbol should be the parent class' vtable, and the
3145  relocation should be located at the child vtable.
3146
3147  VTABLE_ENTRY is a zero-space relocation that describes the use of a
3148  virtual function table entry.  The reloc's symbol should refer to the
3149  table of the class mentioned in the code.  Off of that base, an offset
3150  describes the entry that is being used.  For Rela hosts, this offset
3151  is stored in the reloc's addend.  For Rel hosts, we are forced to put
3152  this offset in the reloc's section offset.
3153
3154ENUM
3155  BFD_RELOC_IA64_IMM14
3156ENUMX
3157  BFD_RELOC_IA64_IMM22
3158ENUMX
3159  BFD_RELOC_IA64_IMM64
3160ENUMX
3161  BFD_RELOC_IA64_DIR32MSB
3162ENUMX
3163  BFD_RELOC_IA64_DIR32LSB
3164ENUMX
3165  BFD_RELOC_IA64_DIR64MSB
3166ENUMX
3167  BFD_RELOC_IA64_DIR64LSB
3168ENUMX
3169  BFD_RELOC_IA64_GPREL22
3170ENUMX
3171  BFD_RELOC_IA64_GPREL64I
3172ENUMX
3173  BFD_RELOC_IA64_GPREL32MSB
3174ENUMX
3175  BFD_RELOC_IA64_GPREL32LSB
3176ENUMX
3177  BFD_RELOC_IA64_GPREL64MSB
3178ENUMX
3179  BFD_RELOC_IA64_GPREL64LSB
3180ENUMX
3181  BFD_RELOC_IA64_LTOFF22
3182ENUMX
3183  BFD_RELOC_IA64_LTOFF64I
3184ENUMX
3185  BFD_RELOC_IA64_PLTOFF22
3186ENUMX
3187  BFD_RELOC_IA64_PLTOFF64I
3188ENUMX
3189  BFD_RELOC_IA64_PLTOFF64MSB
3190ENUMX
3191  BFD_RELOC_IA64_PLTOFF64LSB
3192ENUMX
3193  BFD_RELOC_IA64_FPTR64I
3194ENUMX
3195  BFD_RELOC_IA64_FPTR32MSB
3196ENUMX
3197  BFD_RELOC_IA64_FPTR32LSB
3198ENUMX
3199  BFD_RELOC_IA64_FPTR64MSB
3200ENUMX
3201  BFD_RELOC_IA64_FPTR64LSB
3202ENUMX
3203  BFD_RELOC_IA64_PCREL21B
3204ENUMX
3205  BFD_RELOC_IA64_PCREL21BI
3206ENUMX
3207  BFD_RELOC_IA64_PCREL21M
3208ENUMX
3209  BFD_RELOC_IA64_PCREL21F
3210ENUMX
3211  BFD_RELOC_IA64_PCREL22
3212ENUMX
3213  BFD_RELOC_IA64_PCREL60B
3214ENUMX
3215  BFD_RELOC_IA64_PCREL64I
3216ENUMX
3217  BFD_RELOC_IA64_PCREL32MSB
3218ENUMX
3219  BFD_RELOC_IA64_PCREL32LSB
3220ENUMX
3221  BFD_RELOC_IA64_PCREL64MSB
3222ENUMX
3223  BFD_RELOC_IA64_PCREL64LSB
3224ENUMX
3225  BFD_RELOC_IA64_LTOFF_FPTR22
3226ENUMX
3227  BFD_RELOC_IA64_LTOFF_FPTR64I
3228ENUMX
3229  BFD_RELOC_IA64_LTOFF_FPTR32MSB
3230ENUMX
3231  BFD_RELOC_IA64_LTOFF_FPTR32LSB
3232ENUMX
3233  BFD_RELOC_IA64_LTOFF_FPTR64MSB
3234ENUMX
3235  BFD_RELOC_IA64_LTOFF_FPTR64LSB
3236ENUMX
3237  BFD_RELOC_IA64_SEGREL32MSB
3238ENUMX
3239  BFD_RELOC_IA64_SEGREL32LSB
3240ENUMX
3241  BFD_RELOC_IA64_SEGREL64MSB
3242ENUMX
3243  BFD_RELOC_IA64_SEGREL64LSB
3244ENUMX
3245  BFD_RELOC_IA64_SECREL32MSB
3246ENUMX
3247  BFD_RELOC_IA64_SECREL32LSB
3248ENUMX
3249  BFD_RELOC_IA64_SECREL64MSB
3250ENUMX
3251  BFD_RELOC_IA64_SECREL64LSB
3252ENUMX
3253  BFD_RELOC_IA64_REL32MSB
3254ENUMX
3255  BFD_RELOC_IA64_REL32LSB
3256ENUMX
3257  BFD_RELOC_IA64_REL64MSB
3258ENUMX
3259  BFD_RELOC_IA64_REL64LSB
3260ENUMX
3261  BFD_RELOC_IA64_LTV32MSB
3262ENUMX
3263  BFD_RELOC_IA64_LTV32LSB
3264ENUMX
3265  BFD_RELOC_IA64_LTV64MSB
3266ENUMX
3267  BFD_RELOC_IA64_LTV64LSB
3268ENUMX
3269  BFD_RELOC_IA64_IPLTMSB
3270ENUMX
3271  BFD_RELOC_IA64_IPLTLSB
3272ENUMX
3273  BFD_RELOC_IA64_COPY
3274ENUMX
3275  BFD_RELOC_IA64_LTOFF22X
3276ENUMX
3277  BFD_RELOC_IA64_LDXMOV
3278ENUMX
3279  BFD_RELOC_IA64_TPREL14
3280ENUMX
3281  BFD_RELOC_IA64_TPREL22
3282ENUMX
3283  BFD_RELOC_IA64_TPREL64I
3284ENUMX
3285  BFD_RELOC_IA64_TPREL64MSB
3286ENUMX
3287  BFD_RELOC_IA64_TPREL64LSB
3288ENUMX
3289  BFD_RELOC_IA64_LTOFF_TPREL22
3290ENUMX
3291  BFD_RELOC_IA64_DTPMOD64MSB
3292ENUMX
3293  BFD_RELOC_IA64_DTPMOD64LSB
3294ENUMX
3295  BFD_RELOC_IA64_LTOFF_DTPMOD22
3296ENUMX
3297  BFD_RELOC_IA64_DTPREL14
3298ENUMX
3299  BFD_RELOC_IA64_DTPREL22
3300ENUMX
3301  BFD_RELOC_IA64_DTPREL64I
3302ENUMX
3303  BFD_RELOC_IA64_DTPREL32MSB
3304ENUMX
3305  BFD_RELOC_IA64_DTPREL32LSB
3306ENUMX
3307  BFD_RELOC_IA64_DTPREL64MSB
3308ENUMX
3309  BFD_RELOC_IA64_DTPREL64LSB
3310ENUMX
3311  BFD_RELOC_IA64_LTOFF_DTPREL22
3312ENUMDOC
3313  Intel IA64 Relocations.
3314
3315ENUM
3316  BFD_RELOC_M68HC11_HI8
3317ENUMDOC
3318  Motorola 68HC11 reloc.
3319  This is the 8 bits high part of an absolute address.
3320ENUM
3321  BFD_RELOC_M68HC11_LO8
3322ENUMDOC
3323  Motorola 68HC11 reloc.
3324  This is the 8 bits low part of an absolute address.
3325ENUM
3326  BFD_RELOC_M68HC11_3B
3327ENUMDOC
3328  Motorola 68HC11 reloc.
3329  This is the 3 bits of a value.
3330
3331ENUM
3332  BFD_RELOC_CRIS_BDISP8
3333ENUMX
3334  BFD_RELOC_CRIS_UNSIGNED_5
3335ENUMX
3336  BFD_RELOC_CRIS_SIGNED_6
3337ENUMX
3338  BFD_RELOC_CRIS_UNSIGNED_6
3339ENUMX
3340  BFD_RELOC_CRIS_UNSIGNED_4
3341ENUMDOC
3342  These relocs are only used within the CRIS assembler.  They are not
3343  (at present) written to any object files.
3344ENUM
3345  BFD_RELOC_CRIS_COPY
3346ENUMX
3347  BFD_RELOC_CRIS_GLOB_DAT
3348ENUMX
3349  BFD_RELOC_CRIS_JUMP_SLOT
3350ENUMX
3351  BFD_RELOC_CRIS_RELATIVE
3352ENUMDOC
3353  Relocs used in ELF shared libraries for CRIS.
3354ENUM
3355  BFD_RELOC_CRIS_32_GOT
3356ENUMDOC
3357  32-bit offset to symbol-entry within GOT.
3358ENUM
3359  BFD_RELOC_CRIS_16_GOT
3360ENUMDOC
3361  16-bit offset to symbol-entry within GOT.
3362ENUM
3363  BFD_RELOC_CRIS_32_GOTPLT
3364ENUMDOC
3365  32-bit offset to symbol-entry within GOT, with PLT handling.
3366ENUM
3367  BFD_RELOC_CRIS_16_GOTPLT
3368ENUMDOC
3369  16-bit offset to symbol-entry within GOT, with PLT handling.
3370ENUM
3371  BFD_RELOC_CRIS_32_GOTREL
3372ENUMDOC
3373  32-bit offset to symbol, relative to GOT.
3374ENUM
3375  BFD_RELOC_CRIS_32_PLT_GOTREL
3376ENUMDOC
3377  32-bit offset to symbol with PLT entry, relative to GOT.
3378ENUM
3379  BFD_RELOC_CRIS_32_PLT_PCREL
3380ENUMDOC
3381  32-bit offset to symbol with PLT entry, relative to this relocation.
3382
3383ENUM
3384  BFD_RELOC_860_COPY
3385ENUMX
3386  BFD_RELOC_860_GLOB_DAT
3387ENUMX
3388  BFD_RELOC_860_JUMP_SLOT
3389ENUMX
3390  BFD_RELOC_860_RELATIVE
3391ENUMX
3392  BFD_RELOC_860_PC26
3393ENUMX
3394  BFD_RELOC_860_PLT26
3395ENUMX
3396  BFD_RELOC_860_PC16
3397ENUMX
3398  BFD_RELOC_860_LOW0
3399ENUMX
3400  BFD_RELOC_860_SPLIT0
3401ENUMX
3402  BFD_RELOC_860_LOW1
3403ENUMX
3404  BFD_RELOC_860_SPLIT1
3405ENUMX
3406  BFD_RELOC_860_LOW2
3407ENUMX
3408  BFD_RELOC_860_SPLIT2
3409ENUMX
3410  BFD_RELOC_860_LOW3
3411ENUMX
3412  BFD_RELOC_860_LOGOT0
3413ENUMX
3414  BFD_RELOC_860_SPGOT0
3415ENUMX
3416  BFD_RELOC_860_LOGOT1
3417ENUMX
3418  BFD_RELOC_860_SPGOT1
3419ENUMX
3420  BFD_RELOC_860_LOGOTOFF0
3421ENUMX
3422  BFD_RELOC_860_SPGOTOFF0
3423ENUMX
3424  BFD_RELOC_860_LOGOTOFF1
3425ENUMX
3426  BFD_RELOC_860_SPGOTOFF1
3427ENUMX
3428  BFD_RELOC_860_LOGOTOFF2
3429ENUMX
3430  BFD_RELOC_860_LOGOTOFF3
3431ENUMX
3432  BFD_RELOC_860_LOPC
3433ENUMX
3434  BFD_RELOC_860_HIGHADJ
3435ENUMX
3436  BFD_RELOC_860_HAGOT
3437ENUMX
3438  BFD_RELOC_860_HAGOTOFF
3439ENUMX
3440  BFD_RELOC_860_HAPC
3441ENUMX
3442  BFD_RELOC_860_HIGH
3443ENUMX
3444  BFD_RELOC_860_HIGOT
3445ENUMX
3446  BFD_RELOC_860_HIGOTOFF
3447ENUMDOC
3448  Intel i860 Relocations.
3449
3450ENUM
3451  BFD_RELOC_OPENRISC_ABS_26
3452ENUMX
3453  BFD_RELOC_OPENRISC_REL_26
3454ENUMDOC
3455  OpenRISC Relocations.
3456
3457ENUM
3458  BFD_RELOC_H8_DIR16A8
3459ENUMX
3460  BFD_RELOC_H8_DIR16R8
3461ENUMX
3462  BFD_RELOC_H8_DIR24A8
3463ENUMX
3464  BFD_RELOC_H8_DIR24R8
3465ENUMX
3466  BFD_RELOC_H8_DIR32A16
3467ENUMDOC
3468  H8 elf Relocations.
3469
3470ENUM
3471  BFD_RELOC_XSTORMY16_REL_12
3472ENUMX
3473  BFD_RELOC_XSTORMY16_24
3474ENUMX
3475  BFD_RELOC_XSTORMY16_FPTR16
3476ENUMDOC
3477  Sony Xstormy16 Relocations.
3478
3479ENUM
3480  BFD_RELOC_VAX_GLOB_DAT
3481ENUMX
3482  BFD_RELOC_VAX_JMP_SLOT
3483ENUMX
3484  BFD_RELOC_VAX_RELATIVE
3485ENUMDOC
3486  Relocations used by VAX ELF.
3487
3488ENDSENUM
3489  BFD_RELOC_UNUSED
3490CODE_FRAGMENT
3491.
3492.typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
3493*/
3494
3495/*
3496FUNCTION
3497	bfd_reloc_type_lookup
3498
3499SYNOPSIS
3500	reloc_howto_type *
3501	bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
3502
3503DESCRIPTION
3504	Return a pointer to a howto structure which, when
3505	invoked, will perform the relocation @var{code} on data from the
3506	architecture noted.
3507
3508*/
3509
3510reloc_howto_type *
3511bfd_reloc_type_lookup (abfd, code)
3512     bfd *abfd;
3513     bfd_reloc_code_real_type code;
3514{
3515  return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
3516}
3517
3518static reloc_howto_type bfd_howto_32 =
3519HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
3520
3521/*
3522INTERNAL_FUNCTION
3523	bfd_default_reloc_type_lookup
3524
3525SYNOPSIS
3526	reloc_howto_type *bfd_default_reloc_type_lookup
3527	(bfd *abfd, bfd_reloc_code_real_type  code);
3528
3529DESCRIPTION
3530	Provides a default relocation lookup routine for any architecture.
3531
3532*/
3533
3534reloc_howto_type *
3535bfd_default_reloc_type_lookup (abfd, code)
3536     bfd *abfd;
3537     bfd_reloc_code_real_type code;
3538{
3539  switch (code)
3540    {
3541    case BFD_RELOC_CTOR:
3542      /* The type of reloc used in a ctor, which will be as wide as the
3543	 address - so either a 64, 32, or 16 bitter.  */
3544      switch (bfd_get_arch_info (abfd)->bits_per_address)
3545	{
3546	case 64:
3547	  BFD_FAIL ();
3548	case 32:
3549	  return &bfd_howto_32;
3550	case 16:
3551	  BFD_FAIL ();
3552	default:
3553	  BFD_FAIL ();
3554	}
3555    default:
3556      BFD_FAIL ();
3557    }
3558  return (reloc_howto_type *) NULL;
3559}
3560
3561/*
3562FUNCTION
3563	bfd_get_reloc_code_name
3564
3565SYNOPSIS
3566	const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
3567
3568DESCRIPTION
3569	Provides a printable name for the supplied relocation code.
3570	Useful mainly for printing error messages.
3571*/
3572
3573const char *
3574bfd_get_reloc_code_name (code)
3575     bfd_reloc_code_real_type code;
3576{
3577  if (code > BFD_RELOC_UNUSED)
3578    return 0;
3579  return bfd_reloc_code_real_names[(int)code];
3580}
3581
3582/*
3583INTERNAL_FUNCTION
3584	bfd_generic_relax_section
3585
3586SYNOPSIS
3587	boolean bfd_generic_relax_section
3588	 (bfd *abfd,
3589	  asection *section,
3590	  struct bfd_link_info *,
3591	  boolean *);
3592
3593DESCRIPTION
3594	Provides default handling for relaxing for back ends which
3595	don't do relaxing -- i.e., does nothing.
3596*/
3597
3598boolean
3599bfd_generic_relax_section (abfd, section, link_info, again)
3600     bfd *abfd ATTRIBUTE_UNUSED;
3601     asection *section ATTRIBUTE_UNUSED;
3602     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3603     boolean *again;
3604{
3605  *again = false;
3606  return true;
3607}
3608
3609/*
3610INTERNAL_FUNCTION
3611	bfd_generic_gc_sections
3612
3613SYNOPSIS
3614	boolean bfd_generic_gc_sections
3615	 (bfd *, struct bfd_link_info *);
3616
3617DESCRIPTION
3618	Provides default handling for relaxing for back ends which
3619	don't do section gc -- i.e., does nothing.
3620*/
3621
3622boolean
3623bfd_generic_gc_sections (abfd, link_info)
3624     bfd *abfd ATTRIBUTE_UNUSED;
3625     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3626{
3627  return true;
3628}
3629
3630/*
3631INTERNAL_FUNCTION
3632	bfd_generic_merge_sections
3633
3634SYNOPSIS
3635	boolean bfd_generic_merge_sections
3636	 (bfd *, struct bfd_link_info *);
3637
3638DESCRIPTION
3639	Provides default handling for SEC_MERGE section merging for back ends
3640	which don't have SEC_MERGE support -- i.e., does nothing.
3641*/
3642
3643boolean
3644bfd_generic_merge_sections (abfd, link_info)
3645     bfd *abfd ATTRIBUTE_UNUSED;
3646     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3647{
3648  return true;
3649}
3650
3651/*
3652INTERNAL_FUNCTION
3653	bfd_generic_get_relocated_section_contents
3654
3655SYNOPSIS
3656	bfd_byte *
3657	   bfd_generic_get_relocated_section_contents (bfd *abfd,
3658	     struct bfd_link_info *link_info,
3659	     struct bfd_link_order *link_order,
3660	     bfd_byte *data,
3661	     boolean relocateable,
3662	     asymbol **symbols);
3663
3664DESCRIPTION
3665	Provides default handling of relocation effort for back ends
3666	which can't be bothered to do it efficiently.
3667
3668*/
3669
3670bfd_byte *
3671bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
3672					    relocateable, symbols)
3673     bfd *abfd;
3674     struct bfd_link_info *link_info;
3675     struct bfd_link_order *link_order;
3676     bfd_byte *data;
3677     boolean relocateable;
3678     asymbol **symbols;
3679{
3680  /* Get enough memory to hold the stuff.  */
3681  bfd *input_bfd = link_order->u.indirect.section->owner;
3682  asection *input_section = link_order->u.indirect.section;
3683
3684  long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
3685  arelent **reloc_vector = NULL;
3686  long reloc_count;
3687
3688  if (reloc_size < 0)
3689    goto error_return;
3690
3691  reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
3692  if (reloc_vector == NULL && reloc_size != 0)
3693    goto error_return;
3694
3695  /* Read in the section.  */
3696  if (!bfd_get_section_contents (input_bfd,
3697				 input_section,
3698				 (PTR) data,
3699				 (bfd_vma) 0,
3700				 input_section->_raw_size))
3701    goto error_return;
3702
3703  /* We're not relaxing the section, so just copy the size info.  */
3704  input_section->_cooked_size = input_section->_raw_size;
3705  input_section->reloc_done = true;
3706
3707  reloc_count = bfd_canonicalize_reloc (input_bfd,
3708					input_section,
3709					reloc_vector,
3710					symbols);
3711  if (reloc_count < 0)
3712    goto error_return;
3713
3714  if (reloc_count > 0)
3715    {
3716      arelent **parent;
3717      for (parent = reloc_vector; *parent != (arelent *) NULL;
3718	   parent++)
3719	{
3720	  char *error_message = (char *) NULL;
3721	  bfd_reloc_status_type r =
3722	    bfd_perform_relocation (input_bfd,
3723				    *parent,
3724				    (PTR) data,
3725				    input_section,
3726				    relocateable ? abfd : (bfd *) NULL,
3727				    &error_message);
3728
3729	  if (relocateable)
3730	    {
3731	      asection *os = input_section->output_section;
3732
3733	      /* A partial link, so keep the relocs.  */
3734	      os->orelocation[os->reloc_count] = *parent;
3735	      os->reloc_count++;
3736	    }
3737
3738	  if (r != bfd_reloc_ok)
3739	    {
3740	      switch (r)
3741		{
3742		case bfd_reloc_undefined:
3743		  if (!((*link_info->callbacks->undefined_symbol)
3744			(link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
3745			 input_bfd, input_section, (*parent)->address,
3746			 true)))
3747		    goto error_return;
3748		  break;
3749		case bfd_reloc_dangerous:
3750		  BFD_ASSERT (error_message != (char *) NULL);
3751		  if (!((*link_info->callbacks->reloc_dangerous)
3752			(link_info, error_message, input_bfd, input_section,
3753			 (*parent)->address)))
3754		    goto error_return;
3755		  break;
3756		case bfd_reloc_overflow:
3757		  if (!((*link_info->callbacks->reloc_overflow)
3758			(link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
3759			 (*parent)->howto->name, (*parent)->addend,
3760			 input_bfd, input_section, (*parent)->address)))
3761		    goto error_return;
3762		  break;
3763		case bfd_reloc_outofrange:
3764		default:
3765		  abort ();
3766		  break;
3767		}
3768
3769	    }
3770	}
3771    }
3772  if (reloc_vector != NULL)
3773    free (reloc_vector);
3774  return data;
3775
3776error_return:
3777  if (reloc_vector != NULL)
3778    free (reloc_vector);
3779  return NULL;
3780}
3781