Add missing files.
[binutils.git] / bfd / reloc.c
blobe7210eba9a4249b705e28bbb29f08b9dd9dce2ae
1 /* BFD support for handling relocation entries.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
25 SECTION
26 Relocations
28 BFD maintains relocations in much the same way it maintains
29 symbols: they are left alone until required, then read in
30 en-masse and translated into an internal form. A common
31 routine <<bfd_perform_relocation>> acts upon the
32 canonical form to do the fixup.
34 Relocations are maintained on a per section basis,
35 while symbols are maintained on a per BFD basis.
37 All that a back end has to do to fit the BFD interface is to create
38 a <<struct reloc_cache_entry>> for each relocation
39 in a particular section, and fill in the right bits of the structures.
41 @menu
42 @* typedef arelent::
43 @* howto manager::
44 @end menu
48 /* DO compile in the reloc_code name table from libbfd.h. */
49 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
51 #include "sysdep.h"
52 #include "bfd.h"
53 #include "bfdlink.h"
54 #include "libbfd.h"
56 DOCDD
57 INODE
58 typedef arelent, howto manager, Relocations, Relocations
60 SUBSECTION
61 typedef arelent
63 This is the structure of a relocation entry:
65 CODE_FRAGMENT
67 .typedef enum bfd_reloc_status
69 . {* No errors detected. *}
70 . bfd_reloc_ok,
72 . {* The relocation was performed, but there was an overflow. *}
73 . bfd_reloc_overflow,
75 . {* The address to relocate was not within the section supplied. *}
76 . bfd_reloc_outofrange,
78 . {* Used by special functions. *}
79 . bfd_reloc_continue,
81 . {* Unsupported relocation size requested. *}
82 . bfd_reloc_notsupported,
84 . {* Unused. *}
85 . bfd_reloc_other,
87 . {* The symbol to relocate against was undefined. *}
88 . bfd_reloc_undefined,
90 . {* The relocation was performed, but may not be ok - presently
91 . generated only when linking i960 coff files with i960 b.out
92 . symbols. If this type is returned, the error_message argument
93 . to bfd_perform_relocation will be set. *}
94 . bfd_reloc_dangerous
95 . }
96 . bfd_reloc_status_type;
99 .typedef struct reloc_cache_entry
101 . {* A pointer into the canonical table of pointers. *}
102 . struct bfd_symbol **sym_ptr_ptr;
104 . {* offset in section. *}
105 . bfd_size_type address;
107 . {* addend for relocation value. *}
108 . bfd_vma addend;
110 . {* Pointer to how to perform the required relocation. *}
111 . reloc_howto_type *howto;
114 .arelent;
119 DESCRIPTION
121 Here is a description of each of the fields within an <<arelent>>:
123 o <<sym_ptr_ptr>>
125 The symbol table pointer points to a pointer to the symbol
126 associated with the relocation request. It is the pointer
127 into the table returned by the back end's
128 <<canonicalize_symtab>> action. @xref{Symbols}. The symbol is
129 referenced through a pointer to a pointer so that tools like
130 the linker can fix up all the symbols of the same name by
131 modifying only one pointer. The relocation routine looks in
132 the symbol and uses the base of the section the symbol is
133 attached to and the value of the symbol as the initial
134 relocation offset. If the symbol pointer is zero, then the
135 section provided is looked up.
137 o <<address>>
139 The <<address>> field gives the offset in bytes from the base of
140 the section data which owns the relocation record to the first
141 byte of relocatable information. The actual data relocated
142 will be relative to this point; for example, a relocation
143 type which modifies the bottom two bytes of a four byte word
144 would not touch the first byte pointed to in a big endian
145 world.
147 o <<addend>>
149 The <<addend>> is a value provided by the back end to be added (!)
150 to the relocation offset. Its interpretation is dependent upon
151 the howto. For example, on the 68k the code:
153 | char foo[];
154 | main()
156 | return foo[0x12345678];
159 Could be compiled into:
161 | linkw fp,#-4
162 | moveb @@#12345678,d0
163 | extbl d0
164 | unlk fp
165 | rts
167 This could create a reloc pointing to <<foo>>, but leave the
168 offset in the data, something like:
170 |RELOCATION RECORDS FOR [.text]:
171 |offset type value
172 |00000006 32 _foo
174 |00000000 4e56 fffc ; linkw fp,#-4
175 |00000004 1039 1234 5678 ; moveb @@#12345678,d0
176 |0000000a 49c0 ; extbl d0
177 |0000000c 4e5e ; unlk fp
178 |0000000e 4e75 ; rts
180 Using coff and an 88k, some instructions don't have enough
181 space in them to represent the full address range, and
182 pointers have to be loaded in two parts. So you'd get something like:
184 | or.u r13,r0,hi16(_foo+0x12345678)
185 | ld.b r2,r13,lo16(_foo+0x12345678)
186 | jmp r1
188 This should create two relocs, both pointing to <<_foo>>, and with
189 0x12340000 in their addend field. The data would consist of:
191 |RELOCATION RECORDS FOR [.text]:
192 |offset type value
193 |00000002 HVRT16 _foo+0x12340000
194 |00000006 LVRT16 _foo+0x12340000
196 |00000000 5da05678 ; or.u r13,r0,0x5678
197 |00000004 1c4d5678 ; ld.b r2,r13,0x5678
198 |00000008 f400c001 ; jmp r1
200 The relocation routine digs out the value from the data, adds
201 it to the addend to get the original offset, and then adds the
202 value of <<_foo>>. Note that all 32 bits have to be kept around
203 somewhere, to cope with carry from bit 15 to bit 16.
205 One further example is the sparc and the a.out format. The
206 sparc has a similar problem to the 88k, in that some
207 instructions don't have room for an entire offset, but on the
208 sparc the parts are created in odd sized lumps. The designers of
209 the a.out format chose to not use the data within the section
210 for storing part of the offset; all the offset is kept within
211 the reloc. Anything in the data should be ignored.
213 | save %sp,-112,%sp
214 | sethi %hi(_foo+0x12345678),%g2
215 | ldsb [%g2+%lo(_foo+0x12345678)],%i0
216 | ret
217 | restore
219 Both relocs contain a pointer to <<foo>>, and the offsets
220 contain junk.
222 |RELOCATION RECORDS FOR [.text]:
223 |offset type value
224 |00000004 HI22 _foo+0x12345678
225 |00000008 LO10 _foo+0x12345678
227 |00000000 9de3bf90 ; save %sp,-112,%sp
228 |00000004 05000000 ; sethi %hi(_foo+0),%g2
229 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0
230 |0000000c 81c7e008 ; ret
231 |00000010 81e80000 ; restore
233 o <<howto>>
235 The <<howto>> field can be imagined as a
236 relocation instruction. It is a pointer to a structure which
237 contains information on what to do with all of the other
238 information in the reloc record and data section. A back end
239 would normally have a relocation instruction set and turn
240 relocations into pointers to the correct structure on input -
241 but it would be possible to create each howto field on demand.
246 SUBSUBSECTION
247 <<enum complain_overflow>>
249 Indicates what sort of overflow checking should be done when
250 performing a relocation.
252 CODE_FRAGMENT
254 .enum complain_overflow
256 . {* Do not complain on overflow. *}
257 . complain_overflow_dont,
259 . {* Complain if the value overflows when considered as a signed
260 . number one bit larger than the field. ie. A bitfield of N bits
261 . is allowed to represent -2**n to 2**n-1. *}
262 . complain_overflow_bitfield,
264 . {* Complain if the value overflows when considered as a signed
265 . number. *}
266 . complain_overflow_signed,
268 . {* Complain if the value overflows when considered as an
269 . unsigned number. *}
270 . complain_overflow_unsigned
276 SUBSUBSECTION
277 <<reloc_howto_type>>
279 The <<reloc_howto_type>> is a structure which contains all the
280 information that libbfd needs to know to tie up a back end's data.
282 CODE_FRAGMENT
283 .struct bfd_symbol; {* Forward declaration. *}
285 .struct reloc_howto_struct
287 . {* The type field has mainly a documentary use - the back end can
288 . do what it wants with it, though normally the back end's
289 . external idea of what a reloc number is stored
290 . in this field. For example, a PC relative word relocation
291 . in a coff environment has the type 023 - because that's
292 . what the outside world calls a R_PCRWORD reloc. *}
293 . unsigned int type;
295 . {* The value the final relocation is shifted right by. This drops
296 . unwanted data from the relocation. *}
297 . unsigned int rightshift;
299 . {* The size of the item to be relocated. This is *not* a
300 . power-of-two measure. To get the number of bytes operated
301 . on by a type of relocation, use bfd_get_reloc_size. *}
302 . int size;
304 . {* The number of bits in the item to be relocated. This is used
305 . when doing overflow checking. *}
306 . unsigned int bitsize;
308 . {* The relocation is relative to the field being relocated. *}
309 . bfd_boolean pc_relative;
311 . {* The bit position of the reloc value in the destination.
312 . The relocated value is left shifted by this amount. *}
313 . unsigned int bitpos;
315 . {* What type of overflow error should be checked for when
316 . relocating. *}
317 . enum complain_overflow complain_on_overflow;
319 . {* If this field is non null, then the supplied function is
320 . called rather than the normal function. This allows really
321 . strange relocation methods to be accommodated (e.g., i960 callj
322 . instructions). *}
323 . bfd_reloc_status_type (*special_function)
324 . (bfd *, arelent *, struct bfd_symbol *, void *, asection *,
325 . bfd *, char **);
327 . {* The textual name of the relocation type. *}
328 . char *name;
330 . {* Some formats record a relocation addend in the section contents
331 . rather than with the relocation. For ELF formats this is the
332 . distinction between USE_REL and USE_RELA (though the code checks
333 . for USE_REL == 1/0). The value of this field is TRUE if the
334 . addend is recorded with the section contents; when performing a
335 . partial link (ld -r) the section contents (the data) will be
336 . modified. The value of this field is FALSE if addends are
337 . recorded with the relocation (in arelent.addend); when performing
338 . a partial link the relocation will be modified.
339 . All relocations for all ELF USE_RELA targets should set this field
340 . to FALSE (values of TRUE should be looked on with suspicion).
341 . However, the converse is not true: not all relocations of all ELF
342 . USE_REL targets set this field to TRUE. Why this is so is peculiar
343 . to each particular target. For relocs that aren't used in partial
344 . links (e.g. GOT stuff) it doesn't matter what this is set to. *}
345 . bfd_boolean partial_inplace;
347 . {* src_mask selects the part of the instruction (or data) to be used
348 . in the relocation sum. If the target relocations don't have an
349 . addend in the reloc, eg. ELF USE_REL, src_mask will normally equal
350 . dst_mask to extract the addend from the section contents. If
351 . relocations do have an addend in the reloc, eg. ELF USE_RELA, this
352 . field should be zero. Non-zero values for ELF USE_RELA targets are
353 . bogus as in those cases the value in the dst_mask part of the
354 . section contents should be treated as garbage. *}
355 . bfd_vma src_mask;
357 . {* dst_mask selects which parts of the instruction (or data) are
358 . replaced with a relocated value. *}
359 . bfd_vma dst_mask;
361 . {* When some formats create PC relative instructions, they leave
362 . the value of the pc of the place being relocated in the offset
363 . slot of the instruction, so that a PC relative relocation can
364 . be made just by adding in an ordinary offset (e.g., sun3 a.out).
365 . Some formats leave the displacement part of an instruction
366 . empty (e.g., m88k bcs); this flag signals the fact. *}
367 . bfd_boolean pcrel_offset;
373 FUNCTION
374 The HOWTO Macro
376 DESCRIPTION
377 The HOWTO define is horrible and will go away.
379 .#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
380 . { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }
382 DESCRIPTION
383 And will be replaced with the totally magic way. But for the
384 moment, we are compatible, so do it this way.
386 .#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \
387 . HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \
388 . NAME, FALSE, 0, 0, IN)
391 DESCRIPTION
392 This is used to fill in an empty howto entry in an array.
394 .#define EMPTY_HOWTO(C) \
395 . HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \
396 . NULL, FALSE, 0, 0, FALSE)
399 DESCRIPTION
400 Helper routine to turn a symbol into a relocation value.
402 .#define HOWTO_PREPARE(relocation, symbol) \
403 . { \
404 . if (symbol != NULL) \
405 . { \
406 . if (bfd_is_com_section (symbol->section)) \
407 . { \
408 . relocation = 0; \
409 . } \
410 . else \
411 . { \
412 . relocation = symbol->value; \
413 . } \
414 . } \
420 FUNCTION
421 bfd_get_reloc_size
423 SYNOPSIS
424 unsigned int bfd_get_reloc_size (reloc_howto_type *);
426 DESCRIPTION
427 For a reloc_howto_type that operates on a fixed number of bytes,
428 this returns the number of bytes operated on.
431 unsigned int
432 bfd_get_reloc_size (reloc_howto_type *howto)
434 switch (howto->size)
436 case 0: return 1;
437 case 1: return 2;
438 case 2: return 4;
439 case 3: return 0;
440 case 4: return 8;
441 case 8: return 16;
442 case -2: return 4;
443 default: abort ();
448 TYPEDEF
449 arelent_chain
451 DESCRIPTION
453 How relocs are tied together in an <<asection>>:
455 .typedef struct relent_chain
457 . arelent relent;
458 . struct relent_chain *next;
460 .arelent_chain;
464 /* N_ONES produces N one bits, without overflowing machine arithmetic. */
465 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
468 FUNCTION
469 bfd_check_overflow
471 SYNOPSIS
472 bfd_reloc_status_type bfd_check_overflow
473 (enum complain_overflow how,
474 unsigned int bitsize,
475 unsigned int rightshift,
476 unsigned int addrsize,
477 bfd_vma relocation);
479 DESCRIPTION
480 Perform overflow checking on @var{relocation} which has
481 @var{bitsize} significant bits and will be shifted right by
482 @var{rightshift} bits, on a machine with addresses containing
483 @var{addrsize} significant bits. The result is either of
484 @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
488 bfd_reloc_status_type
489 bfd_check_overflow (enum complain_overflow how,
490 unsigned int bitsize,
491 unsigned int rightshift,
492 unsigned int addrsize,
493 bfd_vma relocation)
495 bfd_vma fieldmask, addrmask, signmask, ss, a;
496 bfd_reloc_status_type flag = bfd_reloc_ok;
498 /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
499 we'll be permissive: extra bits in the field mask will
500 automatically extend the address mask for purposes of the
501 overflow check. */
502 fieldmask = N_ONES (bitsize);
503 signmask = ~fieldmask;
504 addrmask = N_ONES (addrsize) | (fieldmask << rightshift);
505 a = (relocation & addrmask) >> rightshift;;
507 switch (how)
509 case complain_overflow_dont:
510 break;
512 case complain_overflow_signed:
513 /* If any sign bits are set, all sign bits must be set. That
514 is, A must be a valid negative address after shifting. */
515 signmask = ~ (fieldmask >> 1);
516 /* Fall thru */
518 case complain_overflow_bitfield:
519 /* Bitfields are sometimes signed, sometimes unsigned. We
520 explicitly allow an address wrap too, which means a bitfield
521 of n bits is allowed to store -2**n to 2**n-1. Thus overflow
522 if the value has some, but not all, bits set outside the
523 field. */
524 ss = a & signmask;
525 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
526 flag = bfd_reloc_overflow;
527 break;
529 case complain_overflow_unsigned:
530 /* We have an overflow if the address does not fit in the field. */
531 if ((a & signmask) != 0)
532 flag = bfd_reloc_overflow;
533 break;
535 default:
536 abort ();
539 return flag;
543 FUNCTION
544 bfd_perform_relocation
546 SYNOPSIS
547 bfd_reloc_status_type bfd_perform_relocation
548 (bfd *abfd,
549 arelent *reloc_entry,
550 void *data,
551 asection *input_section,
552 bfd *output_bfd,
553 char **error_message);
555 DESCRIPTION
556 If @var{output_bfd} is supplied to this function, the
557 generated image will be relocatable; the relocations are
558 copied to the output file after they have been changed to
559 reflect the new state of the world. There are two ways of
560 reflecting the results of partial linkage in an output file:
561 by modifying the output data in place, and by modifying the
562 relocation record. Some native formats (e.g., basic a.out and
563 basic coff) have no way of specifying an addend in the
564 relocation type, so the addend has to go in the output data.
565 This is no big deal since in these formats the output data
566 slot will always be big enough for the addend. Complex reloc
567 types with addends were invented to solve just this problem.
568 The @var{error_message} argument is set to an error message if
569 this return @code{bfd_reloc_dangerous}.
573 bfd_reloc_status_type
574 bfd_perform_relocation (bfd *abfd,
575 arelent *reloc_entry,
576 void *data,
577 asection *input_section,
578 bfd *output_bfd,
579 char **error_message)
581 bfd_vma relocation;
582 bfd_reloc_status_type flag = bfd_reloc_ok;
583 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
584 bfd_vma output_base = 0;
585 reloc_howto_type *howto = reloc_entry->howto;
586 asection *reloc_target_output_section;
587 asymbol *symbol;
589 symbol = *(reloc_entry->sym_ptr_ptr);
590 if (bfd_is_abs_section (symbol->section)
591 && output_bfd != NULL)
593 reloc_entry->address += input_section->output_offset;
594 return bfd_reloc_ok;
597 /* If we are not producing relocatable output, return an error if
598 the symbol is not defined. An undefined weak symbol is
599 considered to have a value of zero (SVR4 ABI, p. 4-27). */
600 if (bfd_is_und_section (symbol->section)
601 && (symbol->flags & BSF_WEAK) == 0
602 && output_bfd == NULL)
603 flag = bfd_reloc_undefined;
605 /* If there is a function supplied to handle this relocation type,
606 call it. It'll return `bfd_reloc_continue' if further processing
607 can be done. */
608 if (howto->special_function)
610 bfd_reloc_status_type cont;
611 cont = howto->special_function (abfd, reloc_entry, symbol, data,
612 input_section, output_bfd,
613 error_message);
614 if (cont != bfd_reloc_continue)
615 return cont;
618 /* Is the address of the relocation really within the section? */
619 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
620 return bfd_reloc_outofrange;
622 /* Work out which section the relocation is targeted at and the
623 initial relocation command value. */
625 /* Get symbol value. (Common symbols are special.) */
626 if (bfd_is_com_section (symbol->section))
627 relocation = 0;
628 else
629 relocation = symbol->value;
631 reloc_target_output_section = symbol->section->output_section;
633 /* Convert input-section-relative symbol value to absolute. */
634 if ((output_bfd && ! howto->partial_inplace)
635 || reloc_target_output_section == NULL)
636 output_base = 0;
637 else
638 output_base = reloc_target_output_section->vma;
640 relocation += output_base + symbol->section->output_offset;
642 /* Add in supplied addend. */
643 relocation += reloc_entry->addend;
645 /* Here the variable relocation holds the final address of the
646 symbol we are relocating against, plus any addend. */
648 if (howto->pc_relative)
650 /* This is a PC relative relocation. We want to set RELOCATION
651 to the distance between the address of the symbol and the
652 location. RELOCATION is already the address of the symbol.
654 We start by subtracting the address of the section containing
655 the location.
657 If pcrel_offset is set, we must further subtract the position
658 of the location within the section. Some targets arrange for
659 the addend to be the negative of the position of the location
660 within the section; for example, i386-aout does this. For
661 i386-aout, pcrel_offset is FALSE. Some other targets do not
662 include the position of the location; for example, m88kbcs,
663 or ELF. For those targets, pcrel_offset is TRUE.
665 If we are producing relocatable output, then we must ensure
666 that this reloc will be correctly computed when the final
667 relocation is done. If pcrel_offset is FALSE we want to wind
668 up with the negative of the location within the section,
669 which means we must adjust the existing addend by the change
670 in the location within the section. If pcrel_offset is TRUE
671 we do not want to adjust the existing addend at all.
673 FIXME: This seems logical to me, but for the case of
674 producing relocatable output it is not what the code
675 actually does. I don't want to change it, because it seems
676 far too likely that something will break. */
678 relocation -=
679 input_section->output_section->vma + input_section->output_offset;
681 if (howto->pcrel_offset)
682 relocation -= reloc_entry->address;
685 if (output_bfd != NULL)
687 if (! howto->partial_inplace)
689 /* This is a partial relocation, and we want to apply the relocation
690 to the reloc entry rather than the raw data. Modify the reloc
691 inplace to reflect what we now know. */
692 reloc_entry->addend = relocation;
693 reloc_entry->address += input_section->output_offset;
694 return flag;
696 else
698 /* This is a partial relocation, but inplace, so modify the
699 reloc record a bit.
701 If we've relocated with a symbol with a section, change
702 into a ref to the section belonging to the symbol. */
704 reloc_entry->address += input_section->output_offset;
706 /* WTF?? */
707 if (abfd->xvec->flavour == bfd_target_coff_flavour
708 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
709 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
711 /* For m68k-coff, the addend was being subtracted twice during
712 relocation with -r. Removing the line below this comment
713 fixes that problem; see PR 2953.
715 However, Ian wrote the following, regarding removing the line below,
716 which explains why it is still enabled: --djm
718 If you put a patch like that into BFD you need to check all the COFF
719 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
720 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
721 problem in a different way. There may very well be a reason that the
722 code works as it does.
724 Hmmm. The first obvious point is that bfd_perform_relocation should
725 not have any tests that depend upon the flavour. It's seem like
726 entirely the wrong place for such a thing. The second obvious point
727 is that the current code ignores the reloc addend when producing
728 relocatable output for COFF. That's peculiar. In fact, I really
729 have no idea what the point of the line you want to remove is.
731 A typical COFF reloc subtracts the old value of the symbol and adds in
732 the new value to the location in the object file (if it's a pc
733 relative reloc it adds the difference between the symbol value and the
734 location). When relocating we need to preserve that property.
736 BFD handles this by setting the addend to the negative of the old
737 value of the symbol. Unfortunately it handles common symbols in a
738 non-standard way (it doesn't subtract the old value) but that's a
739 different story (we can't change it without losing backward
740 compatibility with old object files) (coff-i386 does subtract the old
741 value, to be compatible with existing coff-i386 targets, like SCO).
743 So everything works fine when not producing relocatable output. When
744 we are producing relocatable output, logically we should do exactly
745 what we do when not producing relocatable output. Therefore, your
746 patch is correct. In fact, it should probably always just set
747 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
748 add the value into the object file. This won't hurt the COFF code,
749 which doesn't use the addend; I'm not sure what it will do to other
750 formats (the thing to check for would be whether any formats both use
751 the addend and set partial_inplace).
753 When I wanted to make coff-i386 produce relocatable output, I ran
754 into the problem that you are running into: I wanted to remove that
755 line. Rather than risk it, I made the coff-i386 relocs use a special
756 function; it's coff_i386_reloc in coff-i386.c. The function
757 specifically adds the addend field into the object file, knowing that
758 bfd_perform_relocation is not going to. If you remove that line, then
759 coff-i386.c will wind up adding the addend field in twice. It's
760 trivial to fix; it just needs to be done.
762 The problem with removing the line is just that it may break some
763 working code. With BFD it's hard to be sure of anything. The right
764 way to deal with this is simply to build and test at least all the
765 supported COFF targets. It should be straightforward if time and disk
766 space consuming. For each target:
767 1) build the linker
768 2) generate some executable, and link it using -r (I would
769 probably use paranoia.o and link against newlib/libc.a, which
770 for all the supported targets would be available in
771 /usr/cygnus/progressive/H-host/target/lib/libc.a).
772 3) make the change to reloc.c
773 4) rebuild the linker
774 5) repeat step 2
775 6) if the resulting object files are the same, you have at least
776 made it no worse
777 7) if they are different you have to figure out which version is
778 right
780 relocation -= reloc_entry->addend;
781 reloc_entry->addend = 0;
783 else
785 reloc_entry->addend = relocation;
789 else
791 reloc_entry->addend = 0;
794 /* FIXME: This overflow checking is incomplete, because the value
795 might have overflowed before we get here. For a correct check we
796 need to compute the value in a size larger than bitsize, but we
797 can't reasonably do that for a reloc the same size as a host
798 machine word.
799 FIXME: We should also do overflow checking on the result after
800 adding in the value contained in the object file. */
801 if (howto->complain_on_overflow != complain_overflow_dont
802 && flag == bfd_reloc_ok)
803 flag = bfd_check_overflow (howto->complain_on_overflow,
804 howto->bitsize,
805 howto->rightshift,
806 bfd_arch_bits_per_address (abfd),
807 relocation);
809 /* Either we are relocating all the way, or we don't want to apply
810 the relocation to the reloc entry (probably because there isn't
811 any room in the output format to describe addends to relocs). */
813 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
814 (OSF version 1.3, compiler version 3.11). It miscompiles the
815 following program:
817 struct str
819 unsigned int i0;
820 } s = { 0 };
823 main ()
825 unsigned long x;
827 x = 0x100000000;
828 x <<= (unsigned long) s.i0;
829 if (x == 0)
830 printf ("failed\n");
831 else
832 printf ("succeeded (%lx)\n", x);
836 relocation >>= (bfd_vma) howto->rightshift;
838 /* Shift everything up to where it's going to be used. */
839 relocation <<= (bfd_vma) howto->bitpos;
841 /* Wait for the day when all have the mask in them. */
843 /* What we do:
844 i instruction to be left alone
845 o offset within instruction
846 r relocation offset to apply
847 S src mask
848 D dst mask
849 N ~dst mask
850 A part 1
851 B part 2
852 R result
854 Do this:
855 (( i i i i i o o o o o from bfd_get<size>
856 and S S S S S) to get the size offset we want
857 + r r r r r r r r r r) to get the final value to place
858 and D D D D D to chop to right size
859 -----------------------
860 = A A A A A
861 And this:
862 ( i i i i i o o o o o from bfd_get<size>
863 and N N N N N ) get instruction
864 -----------------------
865 = B B B B B
867 And then:
868 ( B B B B B
869 or A A A A A)
870 -----------------------
871 = R R R R R R R R R R put into bfd_put<size>
874 #define DOIT(x) \
875 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
877 switch (howto->size)
879 case 0:
881 char x = bfd_get_8 (abfd, (char *) data + octets);
882 DOIT (x);
883 bfd_put_8 (abfd, x, (unsigned char *) data + octets);
885 break;
887 case 1:
889 short x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
890 DOIT (x);
891 bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets);
893 break;
894 case 2:
896 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
897 DOIT (x);
898 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
900 break;
901 case -2:
903 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
904 relocation = -relocation;
905 DOIT (x);
906 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
908 break;
910 case -1:
912 long x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
913 relocation = -relocation;
914 DOIT (x);
915 bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
917 break;
919 case 3:
920 /* Do nothing */
921 break;
923 case 4:
924 #ifdef BFD64
926 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets);
927 DOIT (x);
928 bfd_put_64 (abfd, x, (bfd_byte *) data + octets);
930 #else
931 abort ();
932 #endif
933 break;
934 default:
935 return bfd_reloc_other;
938 return flag;
942 FUNCTION
943 bfd_install_relocation
945 SYNOPSIS
946 bfd_reloc_status_type bfd_install_relocation
947 (bfd *abfd,
948 arelent *reloc_entry,
949 void *data, bfd_vma data_start,
950 asection *input_section,
951 char **error_message);
953 DESCRIPTION
954 This looks remarkably like <<bfd_perform_relocation>>, except it
955 does not expect that the section contents have been filled in.
956 I.e., it's suitable for use when creating, rather than applying
957 a relocation.
959 For now, this function should be considered reserved for the
960 assembler.
963 bfd_reloc_status_type
964 bfd_install_relocation (bfd *abfd,
965 arelent *reloc_entry,
966 void *data_start,
967 bfd_vma data_start_offset,
968 asection *input_section,
969 char **error_message)
971 bfd_vma relocation;
972 bfd_reloc_status_type flag = bfd_reloc_ok;
973 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
974 bfd_vma output_base = 0;
975 reloc_howto_type *howto = reloc_entry->howto;
976 asection *reloc_target_output_section;
977 asymbol *symbol;
978 bfd_byte *data;
980 symbol = *(reloc_entry->sym_ptr_ptr);
981 if (bfd_is_abs_section (symbol->section))
983 reloc_entry->address += input_section->output_offset;
984 return bfd_reloc_ok;
987 /* If there is a function supplied to handle this relocation type,
988 call it. It'll return `bfd_reloc_continue' if further processing
989 can be done. */
990 if (howto->special_function)
992 bfd_reloc_status_type cont;
994 /* XXX - The special_function calls haven't been fixed up to deal
995 with creating new relocations and section contents. */
996 cont = howto->special_function (abfd, reloc_entry, symbol,
997 /* XXX - Non-portable! */
998 ((bfd_byte *) data_start
999 - data_start_offset),
1000 input_section, abfd, error_message);
1001 if (cont != bfd_reloc_continue)
1002 return cont;
1005 /* Is the address of the relocation really within the section? */
1006 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1007 return bfd_reloc_outofrange;
1009 /* Work out which section the relocation is targeted at and the
1010 initial relocation command value. */
1012 /* Get symbol value. (Common symbols are special.) */
1013 if (bfd_is_com_section (symbol->section))
1014 relocation = 0;
1015 else
1016 relocation = symbol->value;
1018 reloc_target_output_section = symbol->section->output_section;
1020 /* Convert input-section-relative symbol value to absolute. */
1021 if (! howto->partial_inplace)
1022 output_base = 0;
1023 else
1024 output_base = reloc_target_output_section->vma;
1026 relocation += output_base + symbol->section->output_offset;
1028 /* Add in supplied addend. */
1029 relocation += reloc_entry->addend;
1031 /* Here the variable relocation holds the final address of the
1032 symbol we are relocating against, plus any addend. */
1034 if (howto->pc_relative)
1036 /* This is a PC relative relocation. We want to set RELOCATION
1037 to the distance between the address of the symbol and the
1038 location. RELOCATION is already the address of the symbol.
1040 We start by subtracting the address of the section containing
1041 the location.
1043 If pcrel_offset is set, we must further subtract the position
1044 of the location within the section. Some targets arrange for
1045 the addend to be the negative of the position of the location
1046 within the section; for example, i386-aout does this. For
1047 i386-aout, pcrel_offset is FALSE. Some other targets do not
1048 include the position of the location; for example, m88kbcs,
1049 or ELF. For those targets, pcrel_offset is TRUE.
1051 If we are producing relocatable output, then we must ensure
1052 that this reloc will be correctly computed when the final
1053 relocation is done. If pcrel_offset is FALSE we want to wind
1054 up with the negative of the location within the section,
1055 which means we must adjust the existing addend by the change
1056 in the location within the section. If pcrel_offset is TRUE
1057 we do not want to adjust the existing addend at all.
1059 FIXME: This seems logical to me, but for the case of
1060 producing relocatable output it is not what the code
1061 actually does. I don't want to change it, because it seems
1062 far too likely that something will break. */
1064 relocation -=
1065 input_section->output_section->vma + input_section->output_offset;
1067 if (howto->pcrel_offset && howto->partial_inplace)
1068 relocation -= reloc_entry->address;
1071 if (! howto->partial_inplace)
1073 /* This is a partial relocation, and we want to apply the relocation
1074 to the reloc entry rather than the raw data. Modify the reloc
1075 inplace to reflect what we now know. */
1076 reloc_entry->addend = relocation;
1077 reloc_entry->address += input_section->output_offset;
1078 return flag;
1080 else
1082 /* This is a partial relocation, but inplace, so modify the
1083 reloc record a bit.
1085 If we've relocated with a symbol with a section, change
1086 into a ref to the section belonging to the symbol. */
1087 reloc_entry->address += input_section->output_offset;
1089 /* WTF?? */
1090 if (abfd->xvec->flavour == bfd_target_coff_flavour
1091 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1092 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1095 /* For m68k-coff, the addend was being subtracted twice during
1096 relocation with -r. Removing the line below this comment
1097 fixes that problem; see PR 2953.
1099 However, Ian wrote the following, regarding removing the line below,
1100 which explains why it is still enabled: --djm
1102 If you put a patch like that into BFD you need to check all the COFF
1103 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
1104 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1105 problem in a different way. There may very well be a reason that the
1106 code works as it does.
1108 Hmmm. The first obvious point is that bfd_install_relocation should
1109 not have any tests that depend upon the flavour. It's seem like
1110 entirely the wrong place for such a thing. The second obvious point
1111 is that the current code ignores the reloc addend when producing
1112 relocatable output for COFF. That's peculiar. In fact, I really
1113 have no idea what the point of the line you want to remove is.
1115 A typical COFF reloc subtracts the old value of the symbol and adds in
1116 the new value to the location in the object file (if it's a pc
1117 relative reloc it adds the difference between the symbol value and the
1118 location). When relocating we need to preserve that property.
1120 BFD handles this by setting the addend to the negative of the old
1121 value of the symbol. Unfortunately it handles common symbols in a
1122 non-standard way (it doesn't subtract the old value) but that's a
1123 different story (we can't change it without losing backward
1124 compatibility with old object files) (coff-i386 does subtract the old
1125 value, to be compatible with existing coff-i386 targets, like SCO).
1127 So everything works fine when not producing relocatable output. When
1128 we are producing relocatable output, logically we should do exactly
1129 what we do when not producing relocatable output. Therefore, your
1130 patch is correct. In fact, it should probably always just set
1131 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1132 add the value into the object file. This won't hurt the COFF code,
1133 which doesn't use the addend; I'm not sure what it will do to other
1134 formats (the thing to check for would be whether any formats both use
1135 the addend and set partial_inplace).
1137 When I wanted to make coff-i386 produce relocatable output, I ran
1138 into the problem that you are running into: I wanted to remove that
1139 line. Rather than risk it, I made the coff-i386 relocs use a special
1140 function; it's coff_i386_reloc in coff-i386.c. The function
1141 specifically adds the addend field into the object file, knowing that
1142 bfd_install_relocation is not going to. If you remove that line, then
1143 coff-i386.c will wind up adding the addend field in twice. It's
1144 trivial to fix; it just needs to be done.
1146 The problem with removing the line is just that it may break some
1147 working code. With BFD it's hard to be sure of anything. The right
1148 way to deal with this is simply to build and test at least all the
1149 supported COFF targets. It should be straightforward if time and disk
1150 space consuming. For each target:
1151 1) build the linker
1152 2) generate some executable, and link it using -r (I would
1153 probably use paranoia.o and link against newlib/libc.a, which
1154 for all the supported targets would be available in
1155 /usr/cygnus/progressive/H-host/target/lib/libc.a).
1156 3) make the change to reloc.c
1157 4) rebuild the linker
1158 5) repeat step 2
1159 6) if the resulting object files are the same, you have at least
1160 made it no worse
1161 7) if they are different you have to figure out which version is
1162 right. */
1163 relocation -= reloc_entry->addend;
1164 /* FIXME: There should be no target specific code here... */
1165 if (strcmp (abfd->xvec->name, "coff-z8k") != 0)
1166 reloc_entry->addend = 0;
1168 else
1170 reloc_entry->addend = relocation;
1174 /* FIXME: This overflow checking is incomplete, because the value
1175 might have overflowed before we get here. For a correct check we
1176 need to compute the value in a size larger than bitsize, but we
1177 can't reasonably do that for a reloc the same size as a host
1178 machine word.
1179 FIXME: We should also do overflow checking on the result after
1180 adding in the value contained in the object file. */
1181 if (howto->complain_on_overflow != complain_overflow_dont)
1182 flag = bfd_check_overflow (howto->complain_on_overflow,
1183 howto->bitsize,
1184 howto->rightshift,
1185 bfd_arch_bits_per_address (abfd),
1186 relocation);
1188 /* Either we are relocating all the way, or we don't want to apply
1189 the relocation to the reloc entry (probably because there isn't
1190 any room in the output format to describe addends to relocs). */
1192 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1193 (OSF version 1.3, compiler version 3.11). It miscompiles the
1194 following program:
1196 struct str
1198 unsigned int i0;
1199 } s = { 0 };
1202 main ()
1204 unsigned long x;
1206 x = 0x100000000;
1207 x <<= (unsigned long) s.i0;
1208 if (x == 0)
1209 printf ("failed\n");
1210 else
1211 printf ("succeeded (%lx)\n", x);
1215 relocation >>= (bfd_vma) howto->rightshift;
1217 /* Shift everything up to where it's going to be used. */
1218 relocation <<= (bfd_vma) howto->bitpos;
1220 /* Wait for the day when all have the mask in them. */
1222 /* What we do:
1223 i instruction to be left alone
1224 o offset within instruction
1225 r relocation offset to apply
1226 S src mask
1227 D dst mask
1228 N ~dst mask
1229 A part 1
1230 B part 2
1231 R result
1233 Do this:
1234 (( i i i i i o o o o o from bfd_get<size>
1235 and S S S S S) to get the size offset we want
1236 + r r r r r r r r r r) to get the final value to place
1237 and D D D D D to chop to right size
1238 -----------------------
1239 = A A A A A
1240 And this:
1241 ( i i i i i o o o o o from bfd_get<size>
1242 and N N N N N ) get instruction
1243 -----------------------
1244 = B B B B B
1246 And then:
1247 ( B B B B B
1248 or A A A A A)
1249 -----------------------
1250 = R R R R R R R R R R put into bfd_put<size>
1253 #define DOIT(x) \
1254 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
1256 data = (bfd_byte *) data_start + (octets - data_start_offset);
1258 switch (howto->size)
1260 case 0:
1262 char x = bfd_get_8 (abfd, data);
1263 DOIT (x);
1264 bfd_put_8 (abfd, x, data);
1266 break;
1268 case 1:
1270 short x = bfd_get_16 (abfd, data);
1271 DOIT (x);
1272 bfd_put_16 (abfd, (bfd_vma) x, data);
1274 break;
1275 case 2:
1277 long x = bfd_get_32 (abfd, data);
1278 DOIT (x);
1279 bfd_put_32 (abfd, (bfd_vma) x, data);
1281 break;
1282 case -2:
1284 long x = bfd_get_32 (abfd, data);
1285 relocation = -relocation;
1286 DOIT (x);
1287 bfd_put_32 (abfd, (bfd_vma) x, data);
1289 break;
1291 case 3:
1292 /* Do nothing */
1293 break;
1295 case 4:
1297 bfd_vma x = bfd_get_64 (abfd, data);
1298 DOIT (x);
1299 bfd_put_64 (abfd, x, data);
1301 break;
1302 default:
1303 return bfd_reloc_other;
1306 return flag;
1309 /* This relocation routine is used by some of the backend linkers.
1310 They do not construct asymbol or arelent structures, so there is no
1311 reason for them to use bfd_perform_relocation. Also,
1312 bfd_perform_relocation is so hacked up it is easier to write a new
1313 function than to try to deal with it.
1315 This routine does a final relocation. Whether it is useful for a
1316 relocatable link depends upon how the object format defines
1317 relocations.
1319 FIXME: This routine ignores any special_function in the HOWTO,
1320 since the existing special_function values have been written for
1321 bfd_perform_relocation.
1323 HOWTO is the reloc howto information.
1324 INPUT_BFD is the BFD which the reloc applies to.
1325 INPUT_SECTION is the section which the reloc applies to.
1326 CONTENTS is the contents of the section.
1327 ADDRESS is the address of the reloc within INPUT_SECTION.
1328 VALUE is the value of the symbol the reloc refers to.
1329 ADDEND is the addend of the reloc. */
1331 bfd_reloc_status_type
1332 _bfd_final_link_relocate (reloc_howto_type *howto,
1333 bfd *input_bfd,
1334 asection *input_section,
1335 bfd_byte *contents,
1336 bfd_vma address,
1337 bfd_vma value,
1338 bfd_vma addend)
1340 bfd_vma relocation;
1342 /* Sanity check the address. */
1343 if (address > bfd_get_section_limit (input_bfd, input_section))
1344 return bfd_reloc_outofrange;
1346 /* This function assumes that we are dealing with a basic relocation
1347 against a symbol. We want to compute the value of the symbol to
1348 relocate to. This is just VALUE, the value of the symbol, plus
1349 ADDEND, any addend associated with the reloc. */
1350 relocation = value + addend;
1352 /* If the relocation is PC relative, we want to set RELOCATION to
1353 the distance between the symbol (currently in RELOCATION) and the
1354 location we are relocating. Some targets (e.g., i386-aout)
1355 arrange for the contents of the section to be the negative of the
1356 offset of the location within the section; for such targets
1357 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
1358 simply leave the contents of the section as zero; for such
1359 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
1360 need to subtract out the offset of the location within the
1361 section (which is just ADDRESS). */
1362 if (howto->pc_relative)
1364 relocation -= (input_section->output_section->vma
1365 + input_section->output_offset);
1366 if (howto->pcrel_offset)
1367 relocation -= address;
1370 return _bfd_relocate_contents (howto, input_bfd, relocation,
1371 contents + address);
1374 /* Relocate a given location using a given value and howto. */
1376 bfd_reloc_status_type
1377 _bfd_relocate_contents (reloc_howto_type *howto,
1378 bfd *input_bfd,
1379 bfd_vma relocation,
1380 bfd_byte *location)
1382 int size;
1383 bfd_vma x = 0;
1384 bfd_reloc_status_type flag;
1385 unsigned int rightshift = howto->rightshift;
1386 unsigned int bitpos = howto->bitpos;
1388 /* If the size is negative, negate RELOCATION. This isn't very
1389 general. */
1390 if (howto->size < 0)
1391 relocation = -relocation;
1393 /* Get the value we are going to relocate. */
1394 size = bfd_get_reloc_size (howto);
1395 switch (size)
1397 default:
1398 case 0:
1399 abort ();
1400 case 1:
1401 x = bfd_get_8 (input_bfd, location);
1402 break;
1403 case 2:
1404 x = bfd_get_16 (input_bfd, location);
1405 break;
1406 case 4:
1407 x = bfd_get_32 (input_bfd, location);
1408 break;
1409 case 8:
1410 #ifdef BFD64
1411 x = bfd_get_64 (input_bfd, location);
1412 #else
1413 abort ();
1414 #endif
1415 break;
1418 /* Check for overflow. FIXME: We may drop bits during the addition
1419 which we don't check for. We must either check at every single
1420 operation, which would be tedious, or we must do the computations
1421 in a type larger than bfd_vma, which would be inefficient. */
1422 flag = bfd_reloc_ok;
1423 if (howto->complain_on_overflow != complain_overflow_dont)
1425 bfd_vma addrmask, fieldmask, signmask, ss;
1426 bfd_vma a, b, sum;
1428 /* Get the values to be added together. For signed and unsigned
1429 relocations, we assume that all values should be truncated to
1430 the size of an address. For bitfields, all the bits matter.
1431 See also bfd_check_overflow. */
1432 fieldmask = N_ONES (howto->bitsize);
1433 signmask = ~fieldmask;
1434 addrmask = (N_ONES (bfd_arch_bits_per_address (input_bfd))
1435 | (fieldmask << rightshift));
1436 a = (relocation & addrmask) >> rightshift;
1437 b = (x & howto->src_mask & addrmask) >> bitpos;
1438 addrmask >>= rightshift;
1440 switch (howto->complain_on_overflow)
1442 case complain_overflow_signed:
1443 /* If any sign bits are set, all sign bits must be set.
1444 That is, A must be a valid negative address after
1445 shifting. */
1446 signmask = ~(fieldmask >> 1);
1447 /* Fall thru */
1449 case complain_overflow_bitfield:
1450 /* Much like the signed check, but for a field one bit
1451 wider. We allow a bitfield to represent numbers in the
1452 range -2**n to 2**n-1, where n is the number of bits in the
1453 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
1454 can't overflow, which is exactly what we want. */
1455 ss = a & signmask;
1456 if (ss != 0 && ss != (addrmask & signmask))
1457 flag = bfd_reloc_overflow;
1459 /* We only need this next bit of code if the sign bit of B
1460 is below the sign bit of A. This would only happen if
1461 SRC_MASK had fewer bits than BITSIZE. Note that if
1462 SRC_MASK has more bits than BITSIZE, we can get into
1463 trouble; we would need to verify that B is in range, as
1464 we do for A above. */
1465 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
1466 ss >>= bitpos;
1468 /* Set all the bits above the sign bit. */
1469 b = (b ^ ss) - ss;
1471 /* Now we can do the addition. */
1472 sum = a + b;
1474 /* See if the result has the correct sign. Bits above the
1475 sign bit are junk now; ignore them. If the sum is
1476 positive, make sure we did not have all negative inputs;
1477 if the sum is negative, make sure we did not have all
1478 positive inputs. The test below looks only at the sign
1479 bits, and it really just
1480 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1482 We mask with addrmask here to explicitly allow an address
1483 wrap-around. The Linux kernel relies on it, and it is
1484 the only way to write assembler code which can run when
1485 loaded at a location 0x80000000 away from the location at
1486 which it is linked. */
1487 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
1488 flag = bfd_reloc_overflow;
1489 break;
1491 case complain_overflow_unsigned:
1492 /* Checking for an unsigned overflow is relatively easy:
1493 trim the addresses and add, and trim the result as well.
1494 Overflow is normally indicated when the result does not
1495 fit in the field. However, we also need to consider the
1496 case when, e.g., fieldmask is 0x7fffffff or smaller, an
1497 input is 0x80000000, and bfd_vma is only 32 bits; then we
1498 will get sum == 0, but there is an overflow, since the
1499 inputs did not fit in the field. Instead of doing a
1500 separate test, we can check for this by or-ing in the
1501 operands when testing for the sum overflowing its final
1502 field. */
1503 sum = (a + b) & addrmask;
1504 if ((a | b | sum) & signmask)
1505 flag = bfd_reloc_overflow;
1506 break;
1508 default:
1509 abort ();
1513 /* Put RELOCATION in the right bits. */
1514 relocation >>= (bfd_vma) rightshift;
1515 relocation <<= (bfd_vma) bitpos;
1517 /* Add RELOCATION to the right bits of X. */
1518 x = ((x & ~howto->dst_mask)
1519 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1521 /* Put the relocated value back in the object file. */
1522 switch (size)
1524 default:
1525 abort ();
1526 case 1:
1527 bfd_put_8 (input_bfd, x, location);
1528 break;
1529 case 2:
1530 bfd_put_16 (input_bfd, x, location);
1531 break;
1532 case 4:
1533 bfd_put_32 (input_bfd, x, location);
1534 break;
1535 case 8:
1536 #ifdef BFD64
1537 bfd_put_64 (input_bfd, x, location);
1538 #else
1539 abort ();
1540 #endif
1541 break;
1544 return flag;
1547 /* Clear a given location using a given howto, by applying a relocation value
1548 of zero and discarding any in-place addend. This is used for fixed-up
1549 relocations against discarded symbols, to make ignorable debug or unwind
1550 information more obvious. */
1552 void
1553 _bfd_clear_contents (reloc_howto_type *howto,
1554 bfd *input_bfd,
1555 bfd_byte *location)
1557 int size;
1558 bfd_vma x = 0;
1560 /* Get the value we are going to relocate. */
1561 size = bfd_get_reloc_size (howto);
1562 switch (size)
1564 default:
1565 case 0:
1566 abort ();
1567 case 1:
1568 x = bfd_get_8 (input_bfd, location);
1569 break;
1570 case 2:
1571 x = bfd_get_16 (input_bfd, location);
1572 break;
1573 case 4:
1574 x = bfd_get_32 (input_bfd, location);
1575 break;
1576 case 8:
1577 #ifdef BFD64
1578 x = bfd_get_64 (input_bfd, location);
1579 #else
1580 abort ();
1581 #endif
1582 break;
1585 /* Zero out the unwanted bits of X. */
1586 x &= ~howto->dst_mask;
1588 /* Put the relocated value back in the object file. */
1589 switch (size)
1591 default:
1592 case 0:
1593 abort ();
1594 case 1:
1595 bfd_put_8 (input_bfd, x, location);
1596 break;
1597 case 2:
1598 bfd_put_16 (input_bfd, x, location);
1599 break;
1600 case 4:
1601 bfd_put_32 (input_bfd, x, location);
1602 break;
1603 case 8:
1604 #ifdef BFD64
1605 bfd_put_64 (input_bfd, x, location);
1606 #else
1607 abort ();
1608 #endif
1609 break;
1614 DOCDD
1615 INODE
1616 howto manager, , typedef arelent, Relocations
1618 SUBSECTION
1619 The howto manager
1621 When an application wants to create a relocation, but doesn't
1622 know what the target machine might call it, it can find out by
1623 using this bit of code.
1628 TYPEDEF
1629 bfd_reloc_code_type
1631 DESCRIPTION
1632 The insides of a reloc code. The idea is that, eventually, there
1633 will be one enumerator for every type of relocation we ever do.
1634 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1635 return a howto pointer.
1637 This does mean that the application must determine the correct
1638 enumerator value; you can't get a howto pointer from a random set
1639 of attributes.
1641 SENUM
1642 bfd_reloc_code_real
1644 ENUM
1645 BFD_RELOC_64
1646 ENUMX
1647 BFD_RELOC_32
1648 ENUMX
1649 BFD_RELOC_26
1650 ENUMX
1651 BFD_RELOC_24
1652 ENUMX
1653 BFD_RELOC_16
1654 ENUMX
1655 BFD_RELOC_14
1656 ENUMX
1657 BFD_RELOC_8
1658 ENUMDOC
1659 Basic absolute relocations of N bits.
1661 ENUM
1662 BFD_RELOC_64_PCREL
1663 ENUMX
1664 BFD_RELOC_32_PCREL
1665 ENUMX
1666 BFD_RELOC_24_PCREL
1667 ENUMX
1668 BFD_RELOC_16_PCREL
1669 ENUMX
1670 BFD_RELOC_12_PCREL
1671 ENUMX
1672 BFD_RELOC_8_PCREL
1673 ENUMDOC
1674 PC-relative relocations. Sometimes these are relative to the address
1675 of the relocation itself; sometimes they are relative to the start of
1676 the section containing the relocation. It depends on the specific target.
1678 The 24-bit relocation is used in some Intel 960 configurations.
1680 ENUM
1681 BFD_RELOC_32_SECREL
1682 ENUMDOC
1683 Section relative relocations. Some targets need this for DWARF2.
1685 ENUM
1686 BFD_RELOC_32_GOT_PCREL
1687 ENUMX
1688 BFD_RELOC_16_GOT_PCREL
1689 ENUMX
1690 BFD_RELOC_8_GOT_PCREL
1691 ENUMX
1692 BFD_RELOC_32_GOTOFF
1693 ENUMX
1694 BFD_RELOC_16_GOTOFF
1695 ENUMX
1696 BFD_RELOC_LO16_GOTOFF
1697 ENUMX
1698 BFD_RELOC_HI16_GOTOFF
1699 ENUMX
1700 BFD_RELOC_HI16_S_GOTOFF
1701 ENUMX
1702 BFD_RELOC_8_GOTOFF
1703 ENUMX
1704 BFD_RELOC_64_PLT_PCREL
1705 ENUMX
1706 BFD_RELOC_32_PLT_PCREL
1707 ENUMX
1708 BFD_RELOC_24_PLT_PCREL
1709 ENUMX
1710 BFD_RELOC_16_PLT_PCREL
1711 ENUMX
1712 BFD_RELOC_8_PLT_PCREL
1713 ENUMX
1714 BFD_RELOC_64_PLTOFF
1715 ENUMX
1716 BFD_RELOC_32_PLTOFF
1717 ENUMX
1718 BFD_RELOC_16_PLTOFF
1719 ENUMX
1720 BFD_RELOC_LO16_PLTOFF
1721 ENUMX
1722 BFD_RELOC_HI16_PLTOFF
1723 ENUMX
1724 BFD_RELOC_HI16_S_PLTOFF
1725 ENUMX
1726 BFD_RELOC_8_PLTOFF
1727 ENUMDOC
1728 For ELF.
1730 ENUM
1731 BFD_RELOC_68K_GLOB_DAT
1732 ENUMX
1733 BFD_RELOC_68K_JMP_SLOT
1734 ENUMX
1735 BFD_RELOC_68K_RELATIVE
1736 ENUMX
1737 BFD_RELOC_68K_TLS_GD32
1738 ENUMX
1739 BFD_RELOC_68K_TLS_GD16
1740 ENUMX
1741 BFD_RELOC_68K_TLS_GD8
1742 ENUMX
1743 BFD_RELOC_68K_TLS_LDM32
1744 ENUMX
1745 BFD_RELOC_68K_TLS_LDM16
1746 ENUMX
1747 BFD_RELOC_68K_TLS_LDM8
1748 ENUMX
1749 BFD_RELOC_68K_TLS_LDO32
1750 ENUMX
1751 BFD_RELOC_68K_TLS_LDO16
1752 ENUMX
1753 BFD_RELOC_68K_TLS_LDO8
1754 ENUMX
1755 BFD_RELOC_68K_TLS_IE32
1756 ENUMX
1757 BFD_RELOC_68K_TLS_IE16
1758 ENUMX
1759 BFD_RELOC_68K_TLS_IE8
1760 ENUMX
1761 BFD_RELOC_68K_TLS_LE32
1762 ENUMX
1763 BFD_RELOC_68K_TLS_LE16
1764 ENUMX
1765 BFD_RELOC_68K_TLS_LE8
1766 ENUMDOC
1767 Relocations used by 68K ELF.
1769 ENUM
1770 BFD_RELOC_32_BASEREL
1771 ENUMX
1772 BFD_RELOC_16_BASEREL
1773 ENUMX
1774 BFD_RELOC_LO16_BASEREL
1775 ENUMX
1776 BFD_RELOC_HI16_BASEREL
1777 ENUMX
1778 BFD_RELOC_HI16_S_BASEREL
1779 ENUMX
1780 BFD_RELOC_8_BASEREL
1781 ENUMX
1782 BFD_RELOC_RVA
1783 ENUMDOC
1784 Linkage-table relative.
1786 ENUM
1787 BFD_RELOC_8_FFnn
1788 ENUMDOC
1789 Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1791 ENUM
1792 BFD_RELOC_32_PCREL_S2
1793 ENUMX
1794 BFD_RELOC_16_PCREL_S2
1795 ENUMX
1796 BFD_RELOC_23_PCREL_S2
1797 ENUMDOC
1798 These PC-relative relocations are stored as word displacements --
1799 i.e., byte displacements shifted right two bits. The 30-bit word
1800 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1801 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The
1802 signed 16-bit displacement is used on the MIPS, and the 23-bit
1803 displacement is used on the Alpha.
1805 ENUM
1806 BFD_RELOC_HI22
1807 ENUMX
1808 BFD_RELOC_LO10
1809 ENUMDOC
1810 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1811 the target word. These are used on the SPARC.
1813 ENUM
1814 BFD_RELOC_GPREL16
1815 ENUMX
1816 BFD_RELOC_GPREL32
1817 ENUMDOC
1818 For systems that allocate a Global Pointer register, these are
1819 displacements off that register. These relocation types are
1820 handled specially, because the value the register will have is
1821 decided relatively late.
1823 ENUM
1824 BFD_RELOC_I960_CALLJ
1825 ENUMDOC
1826 Reloc types used for i960/b.out.
1828 ENUM
1829 BFD_RELOC_NONE
1830 ENUMX
1831 BFD_RELOC_SPARC_WDISP22
1832 ENUMX
1833 BFD_RELOC_SPARC22
1834 ENUMX
1835 BFD_RELOC_SPARC13
1836 ENUMX
1837 BFD_RELOC_SPARC_GOT10
1838 ENUMX
1839 BFD_RELOC_SPARC_GOT13
1840 ENUMX
1841 BFD_RELOC_SPARC_GOT22
1842 ENUMX
1843 BFD_RELOC_SPARC_PC10
1844 ENUMX
1845 BFD_RELOC_SPARC_PC22
1846 ENUMX
1847 BFD_RELOC_SPARC_WPLT30
1848 ENUMX
1849 BFD_RELOC_SPARC_COPY
1850 ENUMX
1851 BFD_RELOC_SPARC_GLOB_DAT
1852 ENUMX
1853 BFD_RELOC_SPARC_JMP_SLOT
1854 ENUMX
1855 BFD_RELOC_SPARC_RELATIVE
1856 ENUMX
1857 BFD_RELOC_SPARC_UA16
1858 ENUMX
1859 BFD_RELOC_SPARC_UA32
1860 ENUMX
1861 BFD_RELOC_SPARC_UA64
1862 ENUMX
1863 BFD_RELOC_SPARC_GOTDATA_HIX22
1864 ENUMX
1865 BFD_RELOC_SPARC_GOTDATA_LOX10
1866 ENUMX
1867 BFD_RELOC_SPARC_GOTDATA_OP_HIX22
1868 ENUMX
1869 BFD_RELOC_SPARC_GOTDATA_OP_LOX10
1870 ENUMX
1871 BFD_RELOC_SPARC_GOTDATA_OP
1872 ENUMX
1873 BFD_RELOC_SPARC_JMP_IREL
1874 ENUMX
1875 BFD_RELOC_SPARC_IRELATIVE
1876 ENUMDOC
1877 SPARC ELF relocations. There is probably some overlap with other
1878 relocation types already defined.
1880 ENUM
1881 BFD_RELOC_SPARC_BASE13
1882 ENUMX
1883 BFD_RELOC_SPARC_BASE22
1884 ENUMDOC
1885 I think these are specific to SPARC a.out (e.g., Sun 4).
1887 ENUMEQ
1888 BFD_RELOC_SPARC_64
1889 BFD_RELOC_64
1890 ENUMX
1891 BFD_RELOC_SPARC_10
1892 ENUMX
1893 BFD_RELOC_SPARC_11
1894 ENUMX
1895 BFD_RELOC_SPARC_OLO10
1896 ENUMX
1897 BFD_RELOC_SPARC_HH22
1898 ENUMX
1899 BFD_RELOC_SPARC_HM10
1900 ENUMX
1901 BFD_RELOC_SPARC_LM22
1902 ENUMX
1903 BFD_RELOC_SPARC_PC_HH22
1904 ENUMX
1905 BFD_RELOC_SPARC_PC_HM10
1906 ENUMX
1907 BFD_RELOC_SPARC_PC_LM22
1908 ENUMX
1909 BFD_RELOC_SPARC_WDISP16
1910 ENUMX
1911 BFD_RELOC_SPARC_WDISP19
1912 ENUMX
1913 BFD_RELOC_SPARC_7
1914 ENUMX
1915 BFD_RELOC_SPARC_6
1916 ENUMX
1917 BFD_RELOC_SPARC_5
1918 ENUMEQX
1919 BFD_RELOC_SPARC_DISP64
1920 BFD_RELOC_64_PCREL
1921 ENUMX
1922 BFD_RELOC_SPARC_PLT32
1923 ENUMX
1924 BFD_RELOC_SPARC_PLT64
1925 ENUMX
1926 BFD_RELOC_SPARC_HIX22
1927 ENUMX
1928 BFD_RELOC_SPARC_LOX10
1929 ENUMX
1930 BFD_RELOC_SPARC_H44
1931 ENUMX
1932 BFD_RELOC_SPARC_M44
1933 ENUMX
1934 BFD_RELOC_SPARC_L44
1935 ENUMX
1936 BFD_RELOC_SPARC_REGISTER
1937 ENUMDOC
1938 SPARC64 relocations
1940 ENUM
1941 BFD_RELOC_SPARC_REV32
1942 ENUMDOC
1943 SPARC little endian relocation
1944 ENUM
1945 BFD_RELOC_SPARC_TLS_GD_HI22
1946 ENUMX
1947 BFD_RELOC_SPARC_TLS_GD_LO10
1948 ENUMX
1949 BFD_RELOC_SPARC_TLS_GD_ADD
1950 ENUMX
1951 BFD_RELOC_SPARC_TLS_GD_CALL
1952 ENUMX
1953 BFD_RELOC_SPARC_TLS_LDM_HI22
1954 ENUMX
1955 BFD_RELOC_SPARC_TLS_LDM_LO10
1956 ENUMX
1957 BFD_RELOC_SPARC_TLS_LDM_ADD
1958 ENUMX
1959 BFD_RELOC_SPARC_TLS_LDM_CALL
1960 ENUMX
1961 BFD_RELOC_SPARC_TLS_LDO_HIX22
1962 ENUMX
1963 BFD_RELOC_SPARC_TLS_LDO_LOX10
1964 ENUMX
1965 BFD_RELOC_SPARC_TLS_LDO_ADD
1966 ENUMX
1967 BFD_RELOC_SPARC_TLS_IE_HI22
1968 ENUMX
1969 BFD_RELOC_SPARC_TLS_IE_LO10
1970 ENUMX
1971 BFD_RELOC_SPARC_TLS_IE_LD
1972 ENUMX
1973 BFD_RELOC_SPARC_TLS_IE_LDX
1974 ENUMX
1975 BFD_RELOC_SPARC_TLS_IE_ADD
1976 ENUMX
1977 BFD_RELOC_SPARC_TLS_LE_HIX22
1978 ENUMX
1979 BFD_RELOC_SPARC_TLS_LE_LOX10
1980 ENUMX
1981 BFD_RELOC_SPARC_TLS_DTPMOD32
1982 ENUMX
1983 BFD_RELOC_SPARC_TLS_DTPMOD64
1984 ENUMX
1985 BFD_RELOC_SPARC_TLS_DTPOFF32
1986 ENUMX
1987 BFD_RELOC_SPARC_TLS_DTPOFF64
1988 ENUMX
1989 BFD_RELOC_SPARC_TLS_TPOFF32
1990 ENUMX
1991 BFD_RELOC_SPARC_TLS_TPOFF64
1992 ENUMDOC
1993 SPARC TLS relocations
1995 ENUM
1996 BFD_RELOC_SPU_IMM7
1997 ENUMX
1998 BFD_RELOC_SPU_IMM8
1999 ENUMX
2000 BFD_RELOC_SPU_IMM10
2001 ENUMX
2002 BFD_RELOC_SPU_IMM10W
2003 ENUMX
2004 BFD_RELOC_SPU_IMM16
2005 ENUMX
2006 BFD_RELOC_SPU_IMM16W
2007 ENUMX
2008 BFD_RELOC_SPU_IMM18
2009 ENUMX
2010 BFD_RELOC_SPU_PCREL9a
2011 ENUMX
2012 BFD_RELOC_SPU_PCREL9b
2013 ENUMX
2014 BFD_RELOC_SPU_PCREL16
2015 ENUMX
2016 BFD_RELOC_SPU_LO16
2017 ENUMX
2018 BFD_RELOC_SPU_HI16
2019 ENUMX
2020 BFD_RELOC_SPU_PPU32
2021 ENUMX
2022 BFD_RELOC_SPU_PPU64
2023 ENUMX
2024 BFD_RELOC_SPU_ADD_PIC
2025 ENUMDOC
2026 SPU Relocations.
2028 ENUM
2029 BFD_RELOC_ALPHA_GPDISP_HI16
2030 ENUMDOC
2031 Alpha ECOFF and ELF relocations. Some of these treat the symbol or
2032 "addend" in some special way.
2033 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
2034 writing; when reading, it will be the absolute section symbol. The
2035 addend is the displacement in bytes of the "lda" instruction from
2036 the "ldah" instruction (which is at the address of this reloc).
2037 ENUM
2038 BFD_RELOC_ALPHA_GPDISP_LO16
2039 ENUMDOC
2040 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
2041 with GPDISP_HI16 relocs. The addend is ignored when writing the
2042 relocations out, and is filled in with the file's GP value on
2043 reading, for convenience.
2045 ENUM
2046 BFD_RELOC_ALPHA_GPDISP
2047 ENUMDOC
2048 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
2049 relocation except that there is no accompanying GPDISP_LO16
2050 relocation.
2052 ENUM
2053 BFD_RELOC_ALPHA_LITERAL
2054 ENUMX
2055 BFD_RELOC_ALPHA_ELF_LITERAL
2056 ENUMX
2057 BFD_RELOC_ALPHA_LITUSE
2058 ENUMDOC
2059 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
2060 the assembler turns it into a LDQ instruction to load the address of
2061 the symbol, and then fills in a register in the real instruction.
2063 The LITERAL reloc, at the LDQ instruction, refers to the .lita
2064 section symbol. The addend is ignored when writing, but is filled
2065 in with the file's GP value on reading, for convenience, as with the
2066 GPDISP_LO16 reloc.
2068 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
2069 It should refer to the symbol to be referenced, as with 16_GOTOFF,
2070 but it generates output not based on the position within the .got
2071 section, but relative to the GP value chosen for the file during the
2072 final link stage.
2074 The LITUSE reloc, on the instruction using the loaded address, gives
2075 information to the linker that it might be able to use to optimize
2076 away some literal section references. The symbol is ignored (read
2077 as the absolute section symbol), and the "addend" indicates the type
2078 of instruction using the register:
2079 1 - "memory" fmt insn
2080 2 - byte-manipulation (byte offset reg)
2081 3 - jsr (target of branch)
2083 ENUM
2084 BFD_RELOC_ALPHA_HINT
2085 ENUMDOC
2086 The HINT relocation indicates a value that should be filled into the
2087 "hint" field of a jmp/jsr/ret instruction, for possible branch-
2088 prediction logic which may be provided on some processors.
2090 ENUM
2091 BFD_RELOC_ALPHA_LINKAGE
2092 ENUMDOC
2093 The LINKAGE relocation outputs a linkage pair in the object file,
2094 which is filled by the linker.
2096 ENUM
2097 BFD_RELOC_ALPHA_CODEADDR
2098 ENUMDOC
2099 The CODEADDR relocation outputs a STO_CA in the object file,
2100 which is filled by the linker.
2102 ENUM
2103 BFD_RELOC_ALPHA_GPREL_HI16
2104 ENUMX
2105 BFD_RELOC_ALPHA_GPREL_LO16
2106 ENUMDOC
2107 The GPREL_HI/LO relocations together form a 32-bit offset from the
2108 GP register.
2110 ENUM
2111 BFD_RELOC_ALPHA_BRSGP
2112 ENUMDOC
2113 Like BFD_RELOC_23_PCREL_S2, except that the source and target must
2114 share a common GP, and the target address is adjusted for
2115 STO_ALPHA_STD_GPLOAD.
2117 ENUM
2118 BFD_RELOC_ALPHA_NOP
2119 ENUMDOC
2120 The NOP relocation outputs a NOP if the longword displacement
2121 between two procedure entry points is < 2^21.
2123 ENUM
2124 BFD_RELOC_ALPHA_BSR
2125 ENUMDOC
2126 The BSR relocation outputs a BSR if the longword displacement
2127 between two procedure entry points is < 2^21.
2129 ENUM
2130 BFD_RELOC_ALPHA_LDA
2131 ENUMDOC
2132 The LDA relocation outputs a LDA if the longword displacement
2133 between two procedure entry points is < 2^16.
2135 ENUM
2136 BFD_RELOC_ALPHA_BOH
2137 ENUMDOC
2138 The BOH relocation outputs a BSR if the longword displacement
2139 between two procedure entry points is < 2^21, or else a hint.
2141 ENUM
2142 BFD_RELOC_ALPHA_TLSGD
2143 ENUMX
2144 BFD_RELOC_ALPHA_TLSLDM
2145 ENUMX
2146 BFD_RELOC_ALPHA_DTPMOD64
2147 ENUMX
2148 BFD_RELOC_ALPHA_GOTDTPREL16
2149 ENUMX
2150 BFD_RELOC_ALPHA_DTPREL64
2151 ENUMX
2152 BFD_RELOC_ALPHA_DTPREL_HI16
2153 ENUMX
2154 BFD_RELOC_ALPHA_DTPREL_LO16
2155 ENUMX
2156 BFD_RELOC_ALPHA_DTPREL16
2157 ENUMX
2158 BFD_RELOC_ALPHA_GOTTPREL16
2159 ENUMX
2160 BFD_RELOC_ALPHA_TPREL64
2161 ENUMX
2162 BFD_RELOC_ALPHA_TPREL_HI16
2163 ENUMX
2164 BFD_RELOC_ALPHA_TPREL_LO16
2165 ENUMX
2166 BFD_RELOC_ALPHA_TPREL16
2167 ENUMDOC
2168 Alpha thread-local storage relocations.
2170 ENUM
2171 BFD_RELOC_MIPS_JMP
2172 ENUMDOC
2173 Bits 27..2 of the relocation address shifted right 2 bits;
2174 simple reloc otherwise.
2176 ENUM
2177 BFD_RELOC_MIPS16_JMP
2178 ENUMDOC
2179 The MIPS16 jump instruction.
2181 ENUM
2182 BFD_RELOC_MIPS16_GPREL
2183 ENUMDOC
2184 MIPS16 GP relative reloc.
2186 ENUM
2187 BFD_RELOC_HI16
2188 ENUMDOC
2189 High 16 bits of 32-bit value; simple reloc.
2190 ENUM
2191 BFD_RELOC_HI16_S
2192 ENUMDOC
2193 High 16 bits of 32-bit value but the low 16 bits will be sign
2194 extended and added to form the final result. If the low 16
2195 bits form a negative number, we need to add one to the high value
2196 to compensate for the borrow when the low bits are added.
2197 ENUM
2198 BFD_RELOC_LO16
2199 ENUMDOC
2200 Low 16 bits.
2202 ENUM
2203 BFD_RELOC_HI16_PCREL
2204 ENUMDOC
2205 High 16 bits of 32-bit pc-relative value
2206 ENUM
2207 BFD_RELOC_HI16_S_PCREL
2208 ENUMDOC
2209 High 16 bits of 32-bit pc-relative value, adjusted
2210 ENUM
2211 BFD_RELOC_LO16_PCREL
2212 ENUMDOC
2213 Low 16 bits of pc-relative value
2215 ENUM
2216 BFD_RELOC_MIPS16_GOT16
2217 ENUMX
2218 BFD_RELOC_MIPS16_CALL16
2219 ENUMDOC
2220 Equivalent of BFD_RELOC_MIPS_*, but with the MIPS16 layout of
2221 16-bit immediate fields
2222 ENUM
2223 BFD_RELOC_MIPS16_HI16
2224 ENUMDOC
2225 MIPS16 high 16 bits of 32-bit value.
2226 ENUM
2227 BFD_RELOC_MIPS16_HI16_S
2228 ENUMDOC
2229 MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign
2230 extended and added to form the final result. If the low 16
2231 bits form a negative number, we need to add one to the high value
2232 to compensate for the borrow when the low bits are added.
2233 ENUM
2234 BFD_RELOC_MIPS16_LO16
2235 ENUMDOC
2236 MIPS16 low 16 bits.
2238 ENUM
2239 BFD_RELOC_MIPS_LITERAL
2240 ENUMDOC
2241 Relocation against a MIPS literal section.
2243 ENUM
2244 BFD_RELOC_MIPS_GOT16
2245 ENUMX
2246 BFD_RELOC_MIPS_CALL16
2247 ENUMX
2248 BFD_RELOC_MIPS_GOT_HI16
2249 ENUMX
2250 BFD_RELOC_MIPS_GOT_LO16
2251 ENUMX
2252 BFD_RELOC_MIPS_CALL_HI16
2253 ENUMX
2254 BFD_RELOC_MIPS_CALL_LO16
2255 ENUMX
2256 BFD_RELOC_MIPS_SUB
2257 ENUMX
2258 BFD_RELOC_MIPS_GOT_PAGE
2259 ENUMX
2260 BFD_RELOC_MIPS_GOT_OFST
2261 ENUMX
2262 BFD_RELOC_MIPS_GOT_DISP
2263 ENUMX
2264 BFD_RELOC_MIPS_SHIFT5
2265 ENUMX
2266 BFD_RELOC_MIPS_SHIFT6
2267 ENUMX
2268 BFD_RELOC_MIPS_INSERT_A
2269 ENUMX
2270 BFD_RELOC_MIPS_INSERT_B
2271 ENUMX
2272 BFD_RELOC_MIPS_DELETE
2273 ENUMX
2274 BFD_RELOC_MIPS_HIGHEST
2275 ENUMX
2276 BFD_RELOC_MIPS_HIGHER
2277 ENUMX
2278 BFD_RELOC_MIPS_SCN_DISP
2279 ENUMX
2280 BFD_RELOC_MIPS_REL16
2281 ENUMX
2282 BFD_RELOC_MIPS_RELGOT
2283 ENUMX
2284 BFD_RELOC_MIPS_JALR
2285 ENUMX
2286 BFD_RELOC_MIPS_TLS_DTPMOD32
2287 ENUMX
2288 BFD_RELOC_MIPS_TLS_DTPREL32
2289 ENUMX
2290 BFD_RELOC_MIPS_TLS_DTPMOD64
2291 ENUMX
2292 BFD_RELOC_MIPS_TLS_DTPREL64
2293 ENUMX
2294 BFD_RELOC_MIPS_TLS_GD
2295 ENUMX
2296 BFD_RELOC_MIPS_TLS_LDM
2297 ENUMX
2298 BFD_RELOC_MIPS_TLS_DTPREL_HI16
2299 ENUMX
2300 BFD_RELOC_MIPS_TLS_DTPREL_LO16
2301 ENUMX
2302 BFD_RELOC_MIPS_TLS_GOTTPREL
2303 ENUMX
2304 BFD_RELOC_MIPS_TLS_TPREL32
2305 ENUMX
2306 BFD_RELOC_MIPS_TLS_TPREL64
2307 ENUMX
2308 BFD_RELOC_MIPS_TLS_TPREL_HI16
2309 ENUMX
2310 BFD_RELOC_MIPS_TLS_TPREL_LO16
2311 ENUMDOC
2312 MIPS ELF relocations.
2313 COMMENT
2315 ENUM
2316 BFD_RELOC_MIPS_COPY
2317 ENUMX
2318 BFD_RELOC_MIPS_JUMP_SLOT
2319 ENUMDOC
2320 MIPS ELF relocations (VxWorks and PLT extensions).
2321 COMMENT
2323 ENUM
2324 BFD_RELOC_MOXIE_10_PCREL
2325 ENUMDOC
2326 Moxie ELF relocations.
2327 COMMENT
2329 ENUM
2330 BFD_RELOC_FRV_LABEL16
2331 ENUMX
2332 BFD_RELOC_FRV_LABEL24
2333 ENUMX
2334 BFD_RELOC_FRV_LO16
2335 ENUMX
2336 BFD_RELOC_FRV_HI16
2337 ENUMX
2338 BFD_RELOC_FRV_GPREL12
2339 ENUMX
2340 BFD_RELOC_FRV_GPRELU12
2341 ENUMX
2342 BFD_RELOC_FRV_GPREL32
2343 ENUMX
2344 BFD_RELOC_FRV_GPRELHI
2345 ENUMX
2346 BFD_RELOC_FRV_GPRELLO
2347 ENUMX
2348 BFD_RELOC_FRV_GOT12
2349 ENUMX
2350 BFD_RELOC_FRV_GOTHI
2351 ENUMX
2352 BFD_RELOC_FRV_GOTLO
2353 ENUMX
2354 BFD_RELOC_FRV_FUNCDESC
2355 ENUMX
2356 BFD_RELOC_FRV_FUNCDESC_GOT12
2357 ENUMX
2358 BFD_RELOC_FRV_FUNCDESC_GOTHI
2359 ENUMX
2360 BFD_RELOC_FRV_FUNCDESC_GOTLO
2361 ENUMX
2362 BFD_RELOC_FRV_FUNCDESC_VALUE
2363 ENUMX
2364 BFD_RELOC_FRV_FUNCDESC_GOTOFF12
2365 ENUMX
2366 BFD_RELOC_FRV_FUNCDESC_GOTOFFHI
2367 ENUMX
2368 BFD_RELOC_FRV_FUNCDESC_GOTOFFLO
2369 ENUMX
2370 BFD_RELOC_FRV_GOTOFF12
2371 ENUMX
2372 BFD_RELOC_FRV_GOTOFFHI
2373 ENUMX
2374 BFD_RELOC_FRV_GOTOFFLO
2375 ENUMX
2376 BFD_RELOC_FRV_GETTLSOFF
2377 ENUMX
2378 BFD_RELOC_FRV_TLSDESC_VALUE
2379 ENUMX
2380 BFD_RELOC_FRV_GOTTLSDESC12
2381 ENUMX
2382 BFD_RELOC_FRV_GOTTLSDESCHI
2383 ENUMX
2384 BFD_RELOC_FRV_GOTTLSDESCLO
2385 ENUMX
2386 BFD_RELOC_FRV_TLSMOFF12
2387 ENUMX
2388 BFD_RELOC_FRV_TLSMOFFHI
2389 ENUMX
2390 BFD_RELOC_FRV_TLSMOFFLO
2391 ENUMX
2392 BFD_RELOC_FRV_GOTTLSOFF12
2393 ENUMX
2394 BFD_RELOC_FRV_GOTTLSOFFHI
2395 ENUMX
2396 BFD_RELOC_FRV_GOTTLSOFFLO
2397 ENUMX
2398 BFD_RELOC_FRV_TLSOFF
2399 ENUMX
2400 BFD_RELOC_FRV_TLSDESC_RELAX
2401 ENUMX
2402 BFD_RELOC_FRV_GETTLSOFF_RELAX
2403 ENUMX
2404 BFD_RELOC_FRV_TLSOFF_RELAX
2405 ENUMX
2406 BFD_RELOC_FRV_TLSMOFF
2407 ENUMDOC
2408 Fujitsu Frv Relocations.
2409 COMMENT
2411 ENUM
2412 BFD_RELOC_MN10300_GOTOFF24
2413 ENUMDOC
2414 This is a 24bit GOT-relative reloc for the mn10300.
2415 ENUM
2416 BFD_RELOC_MN10300_GOT32
2417 ENUMDOC
2418 This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes
2419 in the instruction.
2420 ENUM
2421 BFD_RELOC_MN10300_GOT24
2422 ENUMDOC
2423 This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes
2424 in the instruction.
2425 ENUM
2426 BFD_RELOC_MN10300_GOT16
2427 ENUMDOC
2428 This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes
2429 in the instruction.
2430 ENUM
2431 BFD_RELOC_MN10300_COPY
2432 ENUMDOC
2433 Copy symbol at runtime.
2434 ENUM
2435 BFD_RELOC_MN10300_GLOB_DAT
2436 ENUMDOC
2437 Create GOT entry.
2438 ENUM
2439 BFD_RELOC_MN10300_JMP_SLOT
2440 ENUMDOC
2441 Create PLT entry.
2442 ENUM
2443 BFD_RELOC_MN10300_RELATIVE
2444 ENUMDOC
2445 Adjust by program base.
2446 ENUM
2447 BFD_RELOC_MN10300_SYM_DIFF
2448 ENUMDOC
2449 Together with another reloc targeted at the same location,
2450 allows for a value that is the difference of two symbols
2451 in the same section.
2452 ENUM
2453 BFD_RELOC_MN10300_ALIGN
2454 ENUMDOC
2455 The addend of this reloc is an alignment power that must
2456 be honoured at the offset's location, regardless of linker
2457 relaxation.
2458 COMMENT
2460 ENUM
2461 BFD_RELOC_386_GOT32
2462 ENUMX
2463 BFD_RELOC_386_PLT32
2464 ENUMX
2465 BFD_RELOC_386_COPY
2466 ENUMX
2467 BFD_RELOC_386_GLOB_DAT
2468 ENUMX
2469 BFD_RELOC_386_JUMP_SLOT
2470 ENUMX
2471 BFD_RELOC_386_RELATIVE
2472 ENUMX
2473 BFD_RELOC_386_GOTOFF
2474 ENUMX
2475 BFD_RELOC_386_GOTPC
2476 ENUMX
2477 BFD_RELOC_386_TLS_TPOFF
2478 ENUMX
2479 BFD_RELOC_386_TLS_IE
2480 ENUMX
2481 BFD_RELOC_386_TLS_GOTIE
2482 ENUMX
2483 BFD_RELOC_386_TLS_LE
2484 ENUMX
2485 BFD_RELOC_386_TLS_GD
2486 ENUMX
2487 BFD_RELOC_386_TLS_LDM
2488 ENUMX
2489 BFD_RELOC_386_TLS_LDO_32
2490 ENUMX
2491 BFD_RELOC_386_TLS_IE_32
2492 ENUMX
2493 BFD_RELOC_386_TLS_LE_32
2494 ENUMX
2495 BFD_RELOC_386_TLS_DTPMOD32
2496 ENUMX
2497 BFD_RELOC_386_TLS_DTPOFF32
2498 ENUMX
2499 BFD_RELOC_386_TLS_TPOFF32
2500 ENUMX
2501 BFD_RELOC_386_TLS_GOTDESC
2502 ENUMX
2503 BFD_RELOC_386_TLS_DESC_CALL
2504 ENUMX
2505 BFD_RELOC_386_TLS_DESC
2506 ENUMX
2507 BFD_RELOC_386_IRELATIVE
2508 ENUMDOC
2509 i386/elf relocations
2511 ENUM
2512 BFD_RELOC_X86_64_GOT32
2513 ENUMX
2514 BFD_RELOC_X86_64_PLT32
2515 ENUMX
2516 BFD_RELOC_X86_64_COPY
2517 ENUMX
2518 BFD_RELOC_X86_64_GLOB_DAT
2519 ENUMX
2520 BFD_RELOC_X86_64_JUMP_SLOT
2521 ENUMX
2522 BFD_RELOC_X86_64_RELATIVE
2523 ENUMX
2524 BFD_RELOC_X86_64_GOTPCREL
2525 ENUMX
2526 BFD_RELOC_X86_64_32S
2527 ENUMX
2528 BFD_RELOC_X86_64_DTPMOD64
2529 ENUMX
2530 BFD_RELOC_X86_64_DTPOFF64
2531 ENUMX
2532 BFD_RELOC_X86_64_TPOFF64
2533 ENUMX
2534 BFD_RELOC_X86_64_TLSGD
2535 ENUMX
2536 BFD_RELOC_X86_64_TLSLD
2537 ENUMX
2538 BFD_RELOC_X86_64_DTPOFF32
2539 ENUMX
2540 BFD_RELOC_X86_64_GOTTPOFF
2541 ENUMX
2542 BFD_RELOC_X86_64_TPOFF32
2543 ENUMX
2544 BFD_RELOC_X86_64_GOTOFF64
2545 ENUMX
2546 BFD_RELOC_X86_64_GOTPC32
2547 ENUMX
2548 BFD_RELOC_X86_64_GOT64
2549 ENUMX
2550 BFD_RELOC_X86_64_GOTPCREL64
2551 ENUMX
2552 BFD_RELOC_X86_64_GOTPC64
2553 ENUMX
2554 BFD_RELOC_X86_64_GOTPLT64
2555 ENUMX
2556 BFD_RELOC_X86_64_PLTOFF64
2557 ENUMX
2558 BFD_RELOC_X86_64_GOTPC32_TLSDESC
2559 ENUMX
2560 BFD_RELOC_X86_64_TLSDESC_CALL
2561 ENUMX
2562 BFD_RELOC_X86_64_TLSDESC
2563 ENUMX
2564 BFD_RELOC_X86_64_IRELATIVE
2565 ENUMDOC
2566 x86-64/elf relocations
2568 ENUM
2569 BFD_RELOC_NS32K_IMM_8
2570 ENUMX
2571 BFD_RELOC_NS32K_IMM_16
2572 ENUMX
2573 BFD_RELOC_NS32K_IMM_32
2574 ENUMX
2575 BFD_RELOC_NS32K_IMM_8_PCREL
2576 ENUMX
2577 BFD_RELOC_NS32K_IMM_16_PCREL
2578 ENUMX
2579 BFD_RELOC_NS32K_IMM_32_PCREL
2580 ENUMX
2581 BFD_RELOC_NS32K_DISP_8
2582 ENUMX
2583 BFD_RELOC_NS32K_DISP_16
2584 ENUMX
2585 BFD_RELOC_NS32K_DISP_32
2586 ENUMX
2587 BFD_RELOC_NS32K_DISP_8_PCREL
2588 ENUMX
2589 BFD_RELOC_NS32K_DISP_16_PCREL
2590 ENUMX
2591 BFD_RELOC_NS32K_DISP_32_PCREL
2592 ENUMDOC
2593 ns32k relocations
2595 ENUM
2596 BFD_RELOC_PDP11_DISP_8_PCREL
2597 ENUMX
2598 BFD_RELOC_PDP11_DISP_6_PCREL
2599 ENUMDOC
2600 PDP11 relocations
2602 ENUM
2603 BFD_RELOC_PJ_CODE_HI16
2604 ENUMX
2605 BFD_RELOC_PJ_CODE_LO16
2606 ENUMX
2607 BFD_RELOC_PJ_CODE_DIR16
2608 ENUMX
2609 BFD_RELOC_PJ_CODE_DIR32
2610 ENUMX
2611 BFD_RELOC_PJ_CODE_REL16
2612 ENUMX
2613 BFD_RELOC_PJ_CODE_REL32
2614 ENUMDOC
2615 Picojava relocs. Not all of these appear in object files.
2617 ENUM
2618 BFD_RELOC_PPC_B26
2619 ENUMX
2620 BFD_RELOC_PPC_BA26
2621 ENUMX
2622 BFD_RELOC_PPC_TOC16
2623 ENUMX
2624 BFD_RELOC_PPC_B16
2625 ENUMX
2626 BFD_RELOC_PPC_B16_BRTAKEN
2627 ENUMX
2628 BFD_RELOC_PPC_B16_BRNTAKEN
2629 ENUMX
2630 BFD_RELOC_PPC_BA16
2631 ENUMX
2632 BFD_RELOC_PPC_BA16_BRTAKEN
2633 ENUMX
2634 BFD_RELOC_PPC_BA16_BRNTAKEN
2635 ENUMX
2636 BFD_RELOC_PPC_COPY
2637 ENUMX
2638 BFD_RELOC_PPC_GLOB_DAT
2639 ENUMX
2640 BFD_RELOC_PPC_JMP_SLOT
2641 ENUMX
2642 BFD_RELOC_PPC_RELATIVE
2643 ENUMX
2644 BFD_RELOC_PPC_LOCAL24PC
2645 ENUMX
2646 BFD_RELOC_PPC_EMB_NADDR32
2647 ENUMX
2648 BFD_RELOC_PPC_EMB_NADDR16
2649 ENUMX
2650 BFD_RELOC_PPC_EMB_NADDR16_LO
2651 ENUMX
2652 BFD_RELOC_PPC_EMB_NADDR16_HI
2653 ENUMX
2654 BFD_RELOC_PPC_EMB_NADDR16_HA
2655 ENUMX
2656 BFD_RELOC_PPC_EMB_SDAI16
2657 ENUMX
2658 BFD_RELOC_PPC_EMB_SDA2I16
2659 ENUMX
2660 BFD_RELOC_PPC_EMB_SDA2REL
2661 ENUMX
2662 BFD_RELOC_PPC_EMB_SDA21
2663 ENUMX
2664 BFD_RELOC_PPC_EMB_MRKREF
2665 ENUMX
2666 BFD_RELOC_PPC_EMB_RELSEC16
2667 ENUMX
2668 BFD_RELOC_PPC_EMB_RELST_LO
2669 ENUMX
2670 BFD_RELOC_PPC_EMB_RELST_HI
2671 ENUMX
2672 BFD_RELOC_PPC_EMB_RELST_HA
2673 ENUMX
2674 BFD_RELOC_PPC_EMB_BIT_FLD
2675 ENUMX
2676 BFD_RELOC_PPC_EMB_RELSDA
2677 ENUMX
2678 BFD_RELOC_PPC64_HIGHER
2679 ENUMX
2680 BFD_RELOC_PPC64_HIGHER_S
2681 ENUMX
2682 BFD_RELOC_PPC64_HIGHEST
2683 ENUMX
2684 BFD_RELOC_PPC64_HIGHEST_S
2685 ENUMX
2686 BFD_RELOC_PPC64_TOC16_LO
2687 ENUMX
2688 BFD_RELOC_PPC64_TOC16_HI
2689 ENUMX
2690 BFD_RELOC_PPC64_TOC16_HA
2691 ENUMX
2692 BFD_RELOC_PPC64_TOC
2693 ENUMX
2694 BFD_RELOC_PPC64_PLTGOT16
2695 ENUMX
2696 BFD_RELOC_PPC64_PLTGOT16_LO
2697 ENUMX
2698 BFD_RELOC_PPC64_PLTGOT16_HI
2699 ENUMX
2700 BFD_RELOC_PPC64_PLTGOT16_HA
2701 ENUMX
2702 BFD_RELOC_PPC64_ADDR16_DS
2703 ENUMX
2704 BFD_RELOC_PPC64_ADDR16_LO_DS
2705 ENUMX
2706 BFD_RELOC_PPC64_GOT16_DS
2707 ENUMX
2708 BFD_RELOC_PPC64_GOT16_LO_DS
2709 ENUMX
2710 BFD_RELOC_PPC64_PLT16_LO_DS
2711 ENUMX
2712 BFD_RELOC_PPC64_SECTOFF_DS
2713 ENUMX
2714 BFD_RELOC_PPC64_SECTOFF_LO_DS
2715 ENUMX
2716 BFD_RELOC_PPC64_TOC16_DS
2717 ENUMX
2718 BFD_RELOC_PPC64_TOC16_LO_DS
2719 ENUMX
2720 BFD_RELOC_PPC64_PLTGOT16_DS
2721 ENUMX
2722 BFD_RELOC_PPC64_PLTGOT16_LO_DS
2723 ENUMDOC
2724 Power(rs6000) and PowerPC relocations.
2726 ENUM
2727 BFD_RELOC_PPC_TLS
2728 ENUMX
2729 BFD_RELOC_PPC_TLSGD
2730 ENUMX
2731 BFD_RELOC_PPC_TLSLD
2732 ENUMX
2733 BFD_RELOC_PPC_DTPMOD
2734 ENUMX
2735 BFD_RELOC_PPC_TPREL16
2736 ENUMX
2737 BFD_RELOC_PPC_TPREL16_LO
2738 ENUMX
2739 BFD_RELOC_PPC_TPREL16_HI
2740 ENUMX
2741 BFD_RELOC_PPC_TPREL16_HA
2742 ENUMX
2743 BFD_RELOC_PPC_TPREL
2744 ENUMX
2745 BFD_RELOC_PPC_DTPREL16
2746 ENUMX
2747 BFD_RELOC_PPC_DTPREL16_LO
2748 ENUMX
2749 BFD_RELOC_PPC_DTPREL16_HI
2750 ENUMX
2751 BFD_RELOC_PPC_DTPREL16_HA
2752 ENUMX
2753 BFD_RELOC_PPC_DTPREL
2754 ENUMX
2755 BFD_RELOC_PPC_GOT_TLSGD16
2756 ENUMX
2757 BFD_RELOC_PPC_GOT_TLSGD16_LO
2758 ENUMX
2759 BFD_RELOC_PPC_GOT_TLSGD16_HI
2760 ENUMX
2761 BFD_RELOC_PPC_GOT_TLSGD16_HA
2762 ENUMX
2763 BFD_RELOC_PPC_GOT_TLSLD16
2764 ENUMX
2765 BFD_RELOC_PPC_GOT_TLSLD16_LO
2766 ENUMX
2767 BFD_RELOC_PPC_GOT_TLSLD16_HI
2768 ENUMX
2769 BFD_RELOC_PPC_GOT_TLSLD16_HA
2770 ENUMX
2771 BFD_RELOC_PPC_GOT_TPREL16
2772 ENUMX
2773 BFD_RELOC_PPC_GOT_TPREL16_LO
2774 ENUMX
2775 BFD_RELOC_PPC_GOT_TPREL16_HI
2776 ENUMX
2777 BFD_RELOC_PPC_GOT_TPREL16_HA
2778 ENUMX
2779 BFD_RELOC_PPC_GOT_DTPREL16
2780 ENUMX
2781 BFD_RELOC_PPC_GOT_DTPREL16_LO
2782 ENUMX
2783 BFD_RELOC_PPC_GOT_DTPREL16_HI
2784 ENUMX
2785 BFD_RELOC_PPC_GOT_DTPREL16_HA
2786 ENUMX
2787 BFD_RELOC_PPC64_TPREL16_DS
2788 ENUMX
2789 BFD_RELOC_PPC64_TPREL16_LO_DS
2790 ENUMX
2791 BFD_RELOC_PPC64_TPREL16_HIGHER
2792 ENUMX
2793 BFD_RELOC_PPC64_TPREL16_HIGHERA
2794 ENUMX
2795 BFD_RELOC_PPC64_TPREL16_HIGHEST
2796 ENUMX
2797 BFD_RELOC_PPC64_TPREL16_HIGHESTA
2798 ENUMX
2799 BFD_RELOC_PPC64_DTPREL16_DS
2800 ENUMX
2801 BFD_RELOC_PPC64_DTPREL16_LO_DS
2802 ENUMX
2803 BFD_RELOC_PPC64_DTPREL16_HIGHER
2804 ENUMX
2805 BFD_RELOC_PPC64_DTPREL16_HIGHERA
2806 ENUMX
2807 BFD_RELOC_PPC64_DTPREL16_HIGHEST
2808 ENUMX
2809 BFD_RELOC_PPC64_DTPREL16_HIGHESTA
2810 ENUMDOC
2811 PowerPC and PowerPC64 thread-local storage relocations.
2813 ENUM
2814 BFD_RELOC_I370_D12
2815 ENUMDOC
2816 IBM 370/390 relocations
2818 ENUM
2819 BFD_RELOC_CTOR
2820 ENUMDOC
2821 The type of reloc used to build a constructor table - at the moment
2822 probably a 32 bit wide absolute relocation, but the target can choose.
2823 It generally does map to one of the other relocation types.
2825 ENUM
2826 BFD_RELOC_ARM_PCREL_BRANCH
2827 ENUMDOC
2828 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
2829 not stored in the instruction.
2830 ENUM
2831 BFD_RELOC_ARM_PCREL_BLX
2832 ENUMDOC
2833 ARM 26 bit pc-relative branch. The lowest bit must be zero and is
2834 not stored in the instruction. The 2nd lowest bit comes from a 1 bit
2835 field in the instruction.
2836 ENUM
2837 BFD_RELOC_THUMB_PCREL_BLX
2838 ENUMDOC
2839 Thumb 22 bit pc-relative branch. The lowest bit must be zero and is
2840 not stored in the instruction. The 2nd lowest bit comes from a 1 bit
2841 field in the instruction.
2842 ENUM
2843 BFD_RELOC_ARM_PCREL_CALL
2844 ENUMDOC
2845 ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction.
2846 ENUM
2847 BFD_RELOC_ARM_PCREL_JUMP
2848 ENUMDOC
2849 ARM 26-bit pc-relative branch for B or conditional BL instruction.
2851 ENUM
2852 BFD_RELOC_THUMB_PCREL_BRANCH7
2853 ENUMX
2854 BFD_RELOC_THUMB_PCREL_BRANCH9
2855 ENUMX
2856 BFD_RELOC_THUMB_PCREL_BRANCH12
2857 ENUMX
2858 BFD_RELOC_THUMB_PCREL_BRANCH20
2859 ENUMX
2860 BFD_RELOC_THUMB_PCREL_BRANCH23
2861 ENUMX
2862 BFD_RELOC_THUMB_PCREL_BRANCH25
2863 ENUMDOC
2864 Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches.
2865 The lowest bit must be zero and is not stored in the instruction.
2866 Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an
2867 "nn" one smaller in all cases. Note further that BRANCH23
2868 corresponds to R_ARM_THM_CALL.
2870 ENUM
2871 BFD_RELOC_ARM_OFFSET_IMM
2872 ENUMDOC
2873 12-bit immediate offset, used in ARM-format ldr and str instructions.
2875 ENUM
2876 BFD_RELOC_ARM_THUMB_OFFSET
2877 ENUMDOC
2878 5-bit immediate offset, used in Thumb-format ldr and str instructions.
2880 ENUM
2881 BFD_RELOC_ARM_TARGET1
2882 ENUMDOC
2883 Pc-relative or absolute relocation depending on target. Used for
2884 entries in .init_array sections.
2885 ENUM
2886 BFD_RELOC_ARM_ROSEGREL32
2887 ENUMDOC
2888 Read-only segment base relative address.
2889 ENUM
2890 BFD_RELOC_ARM_SBREL32
2891 ENUMDOC
2892 Data segment base relative address.
2893 ENUM
2894 BFD_RELOC_ARM_TARGET2
2895 ENUMDOC
2896 This reloc is used for references to RTTI data from exception handling
2897 tables. The actual definition depends on the target. It may be a
2898 pc-relative or some form of GOT-indirect relocation.
2899 ENUM
2900 BFD_RELOC_ARM_PREL31
2901 ENUMDOC
2902 31-bit PC relative address.
2903 ENUM
2904 BFD_RELOC_ARM_MOVW
2905 ENUMX
2906 BFD_RELOC_ARM_MOVT
2907 ENUMX
2908 BFD_RELOC_ARM_MOVW_PCREL
2909 ENUMX
2910 BFD_RELOC_ARM_MOVT_PCREL
2911 ENUMX
2912 BFD_RELOC_ARM_THUMB_MOVW
2913 ENUMX
2914 BFD_RELOC_ARM_THUMB_MOVT
2915 ENUMX
2916 BFD_RELOC_ARM_THUMB_MOVW_PCREL
2917 ENUMX
2918 BFD_RELOC_ARM_THUMB_MOVT_PCREL
2919 ENUMDOC
2920 Low and High halfword relocations for MOVW and MOVT instructions.
2922 ENUM
2923 BFD_RELOC_ARM_JUMP_SLOT
2924 ENUMX
2925 BFD_RELOC_ARM_GLOB_DAT
2926 ENUMX
2927 BFD_RELOC_ARM_GOT32
2928 ENUMX
2929 BFD_RELOC_ARM_PLT32
2930 ENUMX
2931 BFD_RELOC_ARM_RELATIVE
2932 ENUMX
2933 BFD_RELOC_ARM_GOTOFF
2934 ENUMX
2935 BFD_RELOC_ARM_GOTPC
2936 ENUMX
2937 BFD_RELOC_ARM_GOT_PREL
2938 ENUMDOC
2939 Relocations for setting up GOTs and PLTs for shared libraries.
2941 ENUM
2942 BFD_RELOC_ARM_TLS_GD32
2943 ENUMX
2944 BFD_RELOC_ARM_TLS_LDO32
2945 ENUMX
2946 BFD_RELOC_ARM_TLS_LDM32
2947 ENUMX
2948 BFD_RELOC_ARM_TLS_DTPOFF32
2949 ENUMX
2950 BFD_RELOC_ARM_TLS_DTPMOD32
2951 ENUMX
2952 BFD_RELOC_ARM_TLS_TPOFF32
2953 ENUMX
2954 BFD_RELOC_ARM_TLS_IE32
2955 ENUMX
2956 BFD_RELOC_ARM_TLS_LE32
2957 ENUMDOC
2958 ARM thread-local storage relocations.
2960 ENUM
2961 BFD_RELOC_ARM_ALU_PC_G0_NC
2962 ENUMX
2963 BFD_RELOC_ARM_ALU_PC_G0
2964 ENUMX
2965 BFD_RELOC_ARM_ALU_PC_G1_NC
2966 ENUMX
2967 BFD_RELOC_ARM_ALU_PC_G1
2968 ENUMX
2969 BFD_RELOC_ARM_ALU_PC_G2
2970 ENUMX
2971 BFD_RELOC_ARM_LDR_PC_G0
2972 ENUMX
2973 BFD_RELOC_ARM_LDR_PC_G1
2974 ENUMX
2975 BFD_RELOC_ARM_LDR_PC_G2
2976 ENUMX
2977 BFD_RELOC_ARM_LDRS_PC_G0
2978 ENUMX
2979 BFD_RELOC_ARM_LDRS_PC_G1
2980 ENUMX
2981 BFD_RELOC_ARM_LDRS_PC_G2
2982 ENUMX
2983 BFD_RELOC_ARM_LDC_PC_G0
2984 ENUMX
2985 BFD_RELOC_ARM_LDC_PC_G1
2986 ENUMX
2987 BFD_RELOC_ARM_LDC_PC_G2
2988 ENUMX
2989 BFD_RELOC_ARM_ALU_SB_G0_NC
2990 ENUMX
2991 BFD_RELOC_ARM_ALU_SB_G0
2992 ENUMX
2993 BFD_RELOC_ARM_ALU_SB_G1_NC
2994 ENUMX
2995 BFD_RELOC_ARM_ALU_SB_G1
2996 ENUMX
2997 BFD_RELOC_ARM_ALU_SB_G2
2998 ENUMX
2999 BFD_RELOC_ARM_LDR_SB_G0
3000 ENUMX
3001 BFD_RELOC_ARM_LDR_SB_G1
3002 ENUMX
3003 BFD_RELOC_ARM_LDR_SB_G2
3004 ENUMX
3005 BFD_RELOC_ARM_LDRS_SB_G0
3006 ENUMX
3007 BFD_RELOC_ARM_LDRS_SB_G1
3008 ENUMX
3009 BFD_RELOC_ARM_LDRS_SB_G2
3010 ENUMX
3011 BFD_RELOC_ARM_LDC_SB_G0
3012 ENUMX
3013 BFD_RELOC_ARM_LDC_SB_G1
3014 ENUMX
3015 BFD_RELOC_ARM_LDC_SB_G2
3016 ENUMDOC
3017 ARM group relocations.
3019 ENUM
3020 BFD_RELOC_ARM_V4BX
3021 ENUMDOC
3022 Annotation of BX instructions.
3024 ENUM
3025 BFD_RELOC_ARM_IMMEDIATE
3026 ENUMX
3027 BFD_RELOC_ARM_ADRL_IMMEDIATE
3028 ENUMX
3029 BFD_RELOC_ARM_T32_IMMEDIATE
3030 ENUMX
3031 BFD_RELOC_ARM_T32_ADD_IMM
3032 ENUMX
3033 BFD_RELOC_ARM_T32_IMM12
3034 ENUMX
3035 BFD_RELOC_ARM_T32_ADD_PC12
3036 ENUMX
3037 BFD_RELOC_ARM_SHIFT_IMM
3038 ENUMX
3039 BFD_RELOC_ARM_SMC
3040 ENUMX
3041 BFD_RELOC_ARM_SWI
3042 ENUMX
3043 BFD_RELOC_ARM_MULTI
3044 ENUMX
3045 BFD_RELOC_ARM_CP_OFF_IMM
3046 ENUMX
3047 BFD_RELOC_ARM_CP_OFF_IMM_S2
3048 ENUMX
3049 BFD_RELOC_ARM_T32_CP_OFF_IMM
3050 ENUMX
3051 BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
3052 ENUMX
3053 BFD_RELOC_ARM_ADR_IMM
3054 ENUMX
3055 BFD_RELOC_ARM_LDR_IMM
3056 ENUMX
3057 BFD_RELOC_ARM_LITERAL
3058 ENUMX
3059 BFD_RELOC_ARM_IN_POOL
3060 ENUMX
3061 BFD_RELOC_ARM_OFFSET_IMM8
3062 ENUMX
3063 BFD_RELOC_ARM_T32_OFFSET_U8
3064 ENUMX
3065 BFD_RELOC_ARM_T32_OFFSET_IMM
3066 ENUMX
3067 BFD_RELOC_ARM_HWLITERAL
3068 ENUMX
3069 BFD_RELOC_ARM_THUMB_ADD
3070 ENUMX
3071 BFD_RELOC_ARM_THUMB_IMM
3072 ENUMX
3073 BFD_RELOC_ARM_THUMB_SHIFT
3074 ENUMDOC
3075 These relocs are only used within the ARM assembler. They are not
3076 (at present) written to any object files.
3078 ENUM
3079 BFD_RELOC_SH_PCDISP8BY2
3080 ENUMX
3081 BFD_RELOC_SH_PCDISP12BY2
3082 ENUMX
3083 BFD_RELOC_SH_IMM3
3084 ENUMX
3085 BFD_RELOC_SH_IMM3U
3086 ENUMX
3087 BFD_RELOC_SH_DISP12
3088 ENUMX
3089 BFD_RELOC_SH_DISP12BY2
3090 ENUMX
3091 BFD_RELOC_SH_DISP12BY4
3092 ENUMX
3093 BFD_RELOC_SH_DISP12BY8
3094 ENUMX
3095 BFD_RELOC_SH_DISP20
3096 ENUMX
3097 BFD_RELOC_SH_DISP20BY8
3098 ENUMX
3099 BFD_RELOC_SH_IMM4
3100 ENUMX
3101 BFD_RELOC_SH_IMM4BY2
3102 ENUMX
3103 BFD_RELOC_SH_IMM4BY4
3104 ENUMX
3105 BFD_RELOC_SH_IMM8
3106 ENUMX
3107 BFD_RELOC_SH_IMM8BY2
3108 ENUMX
3109 BFD_RELOC_SH_IMM8BY4
3110 ENUMX
3111 BFD_RELOC_SH_PCRELIMM8BY2
3112 ENUMX
3113 BFD_RELOC_SH_PCRELIMM8BY4
3114 ENUMX
3115 BFD_RELOC_SH_SWITCH16
3116 ENUMX
3117 BFD_RELOC_SH_SWITCH32
3118 ENUMX
3119 BFD_RELOC_SH_USES
3120 ENUMX
3121 BFD_RELOC_SH_COUNT
3122 ENUMX
3123 BFD_RELOC_SH_ALIGN
3124 ENUMX
3125 BFD_RELOC_SH_CODE
3126 ENUMX
3127 BFD_RELOC_SH_DATA
3128 ENUMX
3129 BFD_RELOC_SH_LABEL
3130 ENUMX
3131 BFD_RELOC_SH_LOOP_START
3132 ENUMX
3133 BFD_RELOC_SH_LOOP_END
3134 ENUMX
3135 BFD_RELOC_SH_COPY
3136 ENUMX
3137 BFD_RELOC_SH_GLOB_DAT
3138 ENUMX
3139 BFD_RELOC_SH_JMP_SLOT
3140 ENUMX
3141 BFD_RELOC_SH_RELATIVE
3142 ENUMX
3143 BFD_RELOC_SH_GOTPC
3144 ENUMX
3145 BFD_RELOC_SH_GOT_LOW16
3146 ENUMX
3147 BFD_RELOC_SH_GOT_MEDLOW16
3148 ENUMX
3149 BFD_RELOC_SH_GOT_MEDHI16
3150 ENUMX
3151 BFD_RELOC_SH_GOT_HI16
3152 ENUMX
3153 BFD_RELOC_SH_GOTPLT_LOW16
3154 ENUMX
3155 BFD_RELOC_SH_GOTPLT_MEDLOW16
3156 ENUMX
3157 BFD_RELOC_SH_GOTPLT_MEDHI16
3158 ENUMX
3159 BFD_RELOC_SH_GOTPLT_HI16
3160 ENUMX
3161 BFD_RELOC_SH_PLT_LOW16
3162 ENUMX
3163 BFD_RELOC_SH_PLT_MEDLOW16
3164 ENUMX
3165 BFD_RELOC_SH_PLT_MEDHI16
3166 ENUMX
3167 BFD_RELOC_SH_PLT_HI16
3168 ENUMX
3169 BFD_RELOC_SH_GOTOFF_LOW16
3170 ENUMX
3171 BFD_RELOC_SH_GOTOFF_MEDLOW16
3172 ENUMX
3173 BFD_RELOC_SH_GOTOFF_MEDHI16
3174 ENUMX
3175 BFD_RELOC_SH_GOTOFF_HI16
3176 ENUMX
3177 BFD_RELOC_SH_GOTPC_LOW16
3178 ENUMX
3179 BFD_RELOC_SH_GOTPC_MEDLOW16
3180 ENUMX
3181 BFD_RELOC_SH_GOTPC_MEDHI16
3182 ENUMX
3183 BFD_RELOC_SH_GOTPC_HI16
3184 ENUMX
3185 BFD_RELOC_SH_COPY64
3186 ENUMX
3187 BFD_RELOC_SH_GLOB_DAT64
3188 ENUMX
3189 BFD_RELOC_SH_JMP_SLOT64
3190 ENUMX
3191 BFD_RELOC_SH_RELATIVE64
3192 ENUMX
3193 BFD_RELOC_SH_GOT10BY4
3194 ENUMX
3195 BFD_RELOC_SH_GOT10BY8
3196 ENUMX
3197 BFD_RELOC_SH_GOTPLT10BY4
3198 ENUMX
3199 BFD_RELOC_SH_GOTPLT10BY8
3200 ENUMX
3201 BFD_RELOC_SH_GOTPLT32
3202 ENUMX
3203 BFD_RELOC_SH_SHMEDIA_CODE
3204 ENUMX
3205 BFD_RELOC_SH_IMMU5
3206 ENUMX
3207 BFD_RELOC_SH_IMMS6
3208 ENUMX
3209 BFD_RELOC_SH_IMMS6BY32
3210 ENUMX
3211 BFD_RELOC_SH_IMMU6
3212 ENUMX
3213 BFD_RELOC_SH_IMMS10
3214 ENUMX
3215 BFD_RELOC_SH_IMMS10BY2
3216 ENUMX
3217 BFD_RELOC_SH_IMMS10BY4
3218 ENUMX
3219 BFD_RELOC_SH_IMMS10BY8
3220 ENUMX
3221 BFD_RELOC_SH_IMMS16
3222 ENUMX
3223 BFD_RELOC_SH_IMMU16
3224 ENUMX
3225 BFD_RELOC_SH_IMM_LOW16
3226 ENUMX
3227 BFD_RELOC_SH_IMM_LOW16_PCREL
3228 ENUMX
3229 BFD_RELOC_SH_IMM_MEDLOW16
3230 ENUMX
3231 BFD_RELOC_SH_IMM_MEDLOW16_PCREL
3232 ENUMX
3233 BFD_RELOC_SH_IMM_MEDHI16
3234 ENUMX
3235 BFD_RELOC_SH_IMM_MEDHI16_PCREL
3236 ENUMX
3237 BFD_RELOC_SH_IMM_HI16
3238 ENUMX
3239 BFD_RELOC_SH_IMM_HI16_PCREL
3240 ENUMX
3241 BFD_RELOC_SH_PT_16
3242 ENUMX
3243 BFD_RELOC_SH_TLS_GD_32
3244 ENUMX
3245 BFD_RELOC_SH_TLS_LD_32
3246 ENUMX
3247 BFD_RELOC_SH_TLS_LDO_32
3248 ENUMX
3249 BFD_RELOC_SH_TLS_IE_32
3250 ENUMX
3251 BFD_RELOC_SH_TLS_LE_32
3252 ENUMX
3253 BFD_RELOC_SH_TLS_DTPMOD32
3254 ENUMX
3255 BFD_RELOC_SH_TLS_DTPOFF32
3256 ENUMX
3257 BFD_RELOC_SH_TLS_TPOFF32
3258 ENUMX
3259 BFD_RELOC_SH_GOT20
3260 ENUMX
3261 BFD_RELOC_SH_GOTOFF20
3262 ENUMX
3263 BFD_RELOC_SH_GOTFUNCDESC
3264 ENUMX
3265 BFD_RELOC_SH_GOTFUNCDESC20
3266 ENUMX
3267 BFD_RELOC_SH_GOTOFFFUNCDESC
3268 ENUMX
3269 BFD_RELOC_SH_GOTOFFFUNCDESC20
3270 ENUMX
3271 BFD_RELOC_SH_FUNCDESC
3272 ENUMDOC
3273 Renesas / SuperH SH relocs. Not all of these appear in object files.
3275 ENUM
3276 BFD_RELOC_ARC_B22_PCREL
3277 ENUMDOC
3278 ARC Cores relocs.
3279 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
3280 not stored in the instruction. The high 20 bits are installed in bits 26
3281 through 7 of the instruction.
3282 ENUM
3283 BFD_RELOC_ARC_B26
3284 ENUMDOC
3285 ARC 26 bit absolute branch. The lowest two bits must be zero and are not
3286 stored in the instruction. The high 24 bits are installed in bits 23
3287 through 0.
3289 ENUM
3290 BFD_RELOC_BFIN_16_IMM
3291 ENUMDOC
3292 ADI Blackfin 16 bit immediate absolute reloc.
3293 ENUM
3294 BFD_RELOC_BFIN_16_HIGH
3295 ENUMDOC
3296 ADI Blackfin 16 bit immediate absolute reloc higher 16 bits.
3297 ENUM
3298 BFD_RELOC_BFIN_4_PCREL
3299 ENUMDOC
3300 ADI Blackfin 'a' part of LSETUP.
3301 ENUM
3302 BFD_RELOC_BFIN_5_PCREL
3303 ENUMDOC
3304 ADI Blackfin.
3305 ENUM
3306 BFD_RELOC_BFIN_16_LOW
3307 ENUMDOC
3308 ADI Blackfin 16 bit immediate absolute reloc lower 16 bits.
3309 ENUM
3310 BFD_RELOC_BFIN_10_PCREL
3311 ENUMDOC
3312 ADI Blackfin.
3313 ENUM
3314 BFD_RELOC_BFIN_11_PCREL
3315 ENUMDOC
3316 ADI Blackfin 'b' part of LSETUP.
3317 ENUM
3318 BFD_RELOC_BFIN_12_PCREL_JUMP
3319 ENUMDOC
3320 ADI Blackfin.
3321 ENUM
3322 BFD_RELOC_BFIN_12_PCREL_JUMP_S
3323 ENUMDOC
3324 ADI Blackfin Short jump, pcrel.
3325 ENUM
3326 BFD_RELOC_BFIN_24_PCREL_CALL_X
3327 ENUMDOC
3328 ADI Blackfin Call.x not implemented.
3329 ENUM
3330 BFD_RELOC_BFIN_24_PCREL_JUMP_L
3331 ENUMDOC
3332 ADI Blackfin Long Jump pcrel.
3333 ENUM
3334 BFD_RELOC_BFIN_GOT17M4
3335 ENUMX
3336 BFD_RELOC_BFIN_GOTHI
3337 ENUMX
3338 BFD_RELOC_BFIN_GOTLO
3339 ENUMX
3340 BFD_RELOC_BFIN_FUNCDESC
3341 ENUMX
3342 BFD_RELOC_BFIN_FUNCDESC_GOT17M4
3343 ENUMX
3344 BFD_RELOC_BFIN_FUNCDESC_GOTHI
3345 ENUMX
3346 BFD_RELOC_BFIN_FUNCDESC_GOTLO
3347 ENUMX
3348 BFD_RELOC_BFIN_FUNCDESC_VALUE
3349 ENUMX
3350 BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4
3351 ENUMX
3352 BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI
3353 ENUMX
3354 BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO
3355 ENUMX
3356 BFD_RELOC_BFIN_GOTOFF17M4
3357 ENUMX
3358 BFD_RELOC_BFIN_GOTOFFHI
3359 ENUMX
3360 BFD_RELOC_BFIN_GOTOFFLO
3361 ENUMDOC
3362 ADI Blackfin FD-PIC relocations.
3363 ENUM
3364 BFD_RELOC_BFIN_GOT
3365 ENUMDOC
3366 ADI Blackfin GOT relocation.
3367 ENUM
3368 BFD_RELOC_BFIN_PLTPC
3369 ENUMDOC
3370 ADI Blackfin PLTPC relocation.
3371 ENUM
3372 BFD_ARELOC_BFIN_PUSH
3373 ENUMDOC
3374 ADI Blackfin arithmetic relocation.
3375 ENUM
3376 BFD_ARELOC_BFIN_CONST
3377 ENUMDOC
3378 ADI Blackfin arithmetic relocation.
3379 ENUM
3380 BFD_ARELOC_BFIN_ADD
3381 ENUMDOC
3382 ADI Blackfin arithmetic relocation.
3383 ENUM
3384 BFD_ARELOC_BFIN_SUB
3385 ENUMDOC
3386 ADI Blackfin arithmetic relocation.
3387 ENUM
3388 BFD_ARELOC_BFIN_MULT
3389 ENUMDOC
3390 ADI Blackfin arithmetic relocation.
3391 ENUM
3392 BFD_ARELOC_BFIN_DIV
3393 ENUMDOC
3394 ADI Blackfin arithmetic relocation.
3395 ENUM
3396 BFD_ARELOC_BFIN_MOD
3397 ENUMDOC
3398 ADI Blackfin arithmetic relocation.
3399 ENUM
3400 BFD_ARELOC_BFIN_LSHIFT
3401 ENUMDOC
3402 ADI Blackfin arithmetic relocation.
3403 ENUM
3404 BFD_ARELOC_BFIN_RSHIFT
3405 ENUMDOC
3406 ADI Blackfin arithmetic relocation.
3407 ENUM
3408 BFD_ARELOC_BFIN_AND
3409 ENUMDOC
3410 ADI Blackfin arithmetic relocation.
3411 ENUM
3412 BFD_ARELOC_BFIN_OR
3413 ENUMDOC
3414 ADI Blackfin arithmetic relocation.
3415 ENUM
3416 BFD_ARELOC_BFIN_XOR
3417 ENUMDOC
3418 ADI Blackfin arithmetic relocation.
3419 ENUM
3420 BFD_ARELOC_BFIN_LAND
3421 ENUMDOC
3422 ADI Blackfin arithmetic relocation.
3423 ENUM
3424 BFD_ARELOC_BFIN_LOR
3425 ENUMDOC
3426 ADI Blackfin arithmetic relocation.
3427 ENUM
3428 BFD_ARELOC_BFIN_LEN
3429 ENUMDOC
3430 ADI Blackfin arithmetic relocation.
3431 ENUM
3432 BFD_ARELOC_BFIN_NEG
3433 ENUMDOC
3434 ADI Blackfin arithmetic relocation.
3435 ENUM
3436 BFD_ARELOC_BFIN_COMP
3437 ENUMDOC
3438 ADI Blackfin arithmetic relocation.
3439 ENUM
3440 BFD_ARELOC_BFIN_PAGE
3441 ENUMDOC
3442 ADI Blackfin arithmetic relocation.
3443 ENUM
3444 BFD_ARELOC_BFIN_HWPAGE
3445 ENUMDOC
3446 ADI Blackfin arithmetic relocation.
3447 ENUM
3448 BFD_ARELOC_BFIN_ADDR
3449 ENUMDOC
3450 ADI Blackfin arithmetic relocation.
3452 ENUM
3453 BFD_RELOC_D10V_10_PCREL_R
3454 ENUMDOC
3455 Mitsubishi D10V relocs.
3456 This is a 10-bit reloc with the right 2 bits
3457 assumed to be 0.
3458 ENUM
3459 BFD_RELOC_D10V_10_PCREL_L
3460 ENUMDOC
3461 Mitsubishi D10V relocs.
3462 This is a 10-bit reloc with the right 2 bits
3463 assumed to be 0. This is the same as the previous reloc
3464 except it is in the left container, i.e.,
3465 shifted left 15 bits.
3466 ENUM
3467 BFD_RELOC_D10V_18
3468 ENUMDOC
3469 This is an 18-bit reloc with the right 2 bits
3470 assumed to be 0.
3471 ENUM
3472 BFD_RELOC_D10V_18_PCREL
3473 ENUMDOC
3474 This is an 18-bit reloc with the right 2 bits
3475 assumed to be 0.
3477 ENUM
3478 BFD_RELOC_D30V_6
3479 ENUMDOC
3480 Mitsubishi D30V relocs.
3481 This is a 6-bit absolute reloc.
3482 ENUM
3483 BFD_RELOC_D30V_9_PCREL
3484 ENUMDOC
3485 This is a 6-bit pc-relative reloc with
3486 the right 3 bits assumed to be 0.
3487 ENUM
3488 BFD_RELOC_D30V_9_PCREL_R
3489 ENUMDOC
3490 This is a 6-bit pc-relative reloc with
3491 the right 3 bits assumed to be 0. Same
3492 as the previous reloc but on the right side
3493 of the container.
3494 ENUM
3495 BFD_RELOC_D30V_15
3496 ENUMDOC
3497 This is a 12-bit absolute reloc with the
3498 right 3 bitsassumed to be 0.
3499 ENUM
3500 BFD_RELOC_D30V_15_PCREL
3501 ENUMDOC
3502 This is a 12-bit pc-relative reloc with
3503 the right 3 bits assumed to be 0.
3504 ENUM
3505 BFD_RELOC_D30V_15_PCREL_R
3506 ENUMDOC
3507 This is a 12-bit pc-relative reloc with
3508 the right 3 bits assumed to be 0. Same
3509 as the previous reloc but on the right side
3510 of the container.
3511 ENUM
3512 BFD_RELOC_D30V_21
3513 ENUMDOC
3514 This is an 18-bit absolute reloc with
3515 the right 3 bits assumed to be 0.
3516 ENUM
3517 BFD_RELOC_D30V_21_PCREL
3518 ENUMDOC
3519 This is an 18-bit pc-relative reloc with
3520 the right 3 bits assumed to be 0.
3521 ENUM
3522 BFD_RELOC_D30V_21_PCREL_R
3523 ENUMDOC
3524 This is an 18-bit pc-relative reloc with
3525 the right 3 bits assumed to be 0. Same
3526 as the previous reloc but on the right side
3527 of the container.
3528 ENUM
3529 BFD_RELOC_D30V_32
3530 ENUMDOC
3531 This is a 32-bit absolute reloc.
3532 ENUM
3533 BFD_RELOC_D30V_32_PCREL
3534 ENUMDOC
3535 This is a 32-bit pc-relative reloc.
3537 ENUM
3538 BFD_RELOC_DLX_HI16_S
3539 ENUMDOC
3540 DLX relocs
3541 ENUM
3542 BFD_RELOC_DLX_LO16
3543 ENUMDOC
3544 DLX relocs
3545 ENUM
3546 BFD_RELOC_DLX_JMP26
3547 ENUMDOC
3548 DLX relocs
3550 ENUM
3551 BFD_RELOC_M32C_HI8
3552 ENUMX
3553 BFD_RELOC_M32C_RL_JUMP
3554 ENUMX
3555 BFD_RELOC_M32C_RL_1ADDR
3556 ENUMX
3557 BFD_RELOC_M32C_RL_2ADDR
3558 ENUMDOC
3559 Renesas M16C/M32C Relocations.
3561 ENUM
3562 BFD_RELOC_M32R_24
3563 ENUMDOC
3564 Renesas M32R (formerly Mitsubishi M32R) relocs.
3565 This is a 24 bit absolute address.
3566 ENUM
3567 BFD_RELOC_M32R_10_PCREL
3568 ENUMDOC
3569 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
3570 ENUM
3571 BFD_RELOC_M32R_18_PCREL
3572 ENUMDOC
3573 This is an 18-bit reloc with the right 2 bits assumed to be 0.
3574 ENUM
3575 BFD_RELOC_M32R_26_PCREL
3576 ENUMDOC
3577 This is a 26-bit reloc with the right 2 bits assumed to be 0.
3578 ENUM
3579 BFD_RELOC_M32R_HI16_ULO
3580 ENUMDOC
3581 This is a 16-bit reloc containing the high 16 bits of an address
3582 used when the lower 16 bits are treated as unsigned.
3583 ENUM
3584 BFD_RELOC_M32R_HI16_SLO
3585 ENUMDOC
3586 This is a 16-bit reloc containing the high 16 bits of an address
3587 used when the lower 16 bits are treated as signed.
3588 ENUM
3589 BFD_RELOC_M32R_LO16
3590 ENUMDOC
3591 This is a 16-bit reloc containing the lower 16 bits of an address.
3592 ENUM
3593 BFD_RELOC_M32R_SDA16
3594 ENUMDOC
3595 This is a 16-bit reloc containing the small data area offset for use in
3596 add3, load, and store instructions.
3597 ENUM
3598 BFD_RELOC_M32R_GOT24
3599 ENUMX
3600 BFD_RELOC_M32R_26_PLTREL
3601 ENUMX
3602 BFD_RELOC_M32R_COPY
3603 ENUMX
3604 BFD_RELOC_M32R_GLOB_DAT
3605 ENUMX
3606 BFD_RELOC_M32R_JMP_SLOT
3607 ENUMX
3608 BFD_RELOC_M32R_RELATIVE
3609 ENUMX
3610 BFD_RELOC_M32R_GOTOFF
3611 ENUMX
3612 BFD_RELOC_M32R_GOTOFF_HI_ULO
3613 ENUMX
3614 BFD_RELOC_M32R_GOTOFF_HI_SLO
3615 ENUMX
3616 BFD_RELOC_M32R_GOTOFF_LO
3617 ENUMX
3618 BFD_RELOC_M32R_GOTPC24
3619 ENUMX
3620 BFD_RELOC_M32R_GOT16_HI_ULO
3621 ENUMX
3622 BFD_RELOC_M32R_GOT16_HI_SLO
3623 ENUMX
3624 BFD_RELOC_M32R_GOT16_LO
3625 ENUMX
3626 BFD_RELOC_M32R_GOTPC_HI_ULO
3627 ENUMX
3628 BFD_RELOC_M32R_GOTPC_HI_SLO
3629 ENUMX
3630 BFD_RELOC_M32R_GOTPC_LO
3631 ENUMDOC
3632 For PIC.
3635 ENUM
3636 BFD_RELOC_V850_9_PCREL
3637 ENUMDOC
3638 This is a 9-bit reloc
3639 ENUM
3640 BFD_RELOC_V850_22_PCREL
3641 ENUMDOC
3642 This is a 22-bit reloc
3644 ENUM
3645 BFD_RELOC_V850_SDA_16_16_OFFSET
3646 ENUMDOC
3647 This is a 16 bit offset from the short data area pointer.
3648 ENUM
3649 BFD_RELOC_V850_SDA_15_16_OFFSET
3650 ENUMDOC
3651 This is a 16 bit offset (of which only 15 bits are used) from the
3652 short data area pointer.
3653 ENUM
3654 BFD_RELOC_V850_ZDA_16_16_OFFSET
3655 ENUMDOC
3656 This is a 16 bit offset from the zero data area pointer.
3657 ENUM
3658 BFD_RELOC_V850_ZDA_15_16_OFFSET
3659 ENUMDOC
3660 This is a 16 bit offset (of which only 15 bits are used) from the
3661 zero data area pointer.
3662 ENUM
3663 BFD_RELOC_V850_TDA_6_8_OFFSET
3664 ENUMDOC
3665 This is an 8 bit offset (of which only 6 bits are used) from the
3666 tiny data area pointer.
3667 ENUM
3668 BFD_RELOC_V850_TDA_7_8_OFFSET
3669 ENUMDOC
3670 This is an 8bit offset (of which only 7 bits are used) from the tiny
3671 data area pointer.
3672 ENUM
3673 BFD_RELOC_V850_TDA_7_7_OFFSET
3674 ENUMDOC
3675 This is a 7 bit offset from the tiny data area pointer.
3676 ENUM
3677 BFD_RELOC_V850_TDA_16_16_OFFSET
3678 ENUMDOC
3679 This is a 16 bit offset from the tiny data area pointer.
3680 COMMENT
3681 ENUM
3682 BFD_RELOC_V850_TDA_4_5_OFFSET
3683 ENUMDOC
3684 This is a 5 bit offset (of which only 4 bits are used) from the tiny
3685 data area pointer.
3686 ENUM
3687 BFD_RELOC_V850_TDA_4_4_OFFSET
3688 ENUMDOC
3689 This is a 4 bit offset from the tiny data area pointer.
3690 ENUM
3691 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
3692 ENUMDOC
3693 This is a 16 bit offset from the short data area pointer, with the
3694 bits placed non-contiguously in the instruction.
3695 ENUM
3696 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
3697 ENUMDOC
3698 This is a 16 bit offset from the zero data area pointer, with the
3699 bits placed non-contiguously in the instruction.
3700 ENUM
3701 BFD_RELOC_V850_CALLT_6_7_OFFSET
3702 ENUMDOC
3703 This is a 6 bit offset from the call table base pointer.
3704 ENUM
3705 BFD_RELOC_V850_CALLT_16_16_OFFSET
3706 ENUMDOC
3707 This is a 16 bit offset from the call table base pointer.
3708 ENUM
3709 BFD_RELOC_V850_LONGCALL
3710 ENUMDOC
3711 Used for relaxing indirect function calls.
3712 ENUM
3713 BFD_RELOC_V850_LONGJUMP
3714 ENUMDOC
3715 Used for relaxing indirect jumps.
3716 ENUM
3717 BFD_RELOC_V850_ALIGN
3718 ENUMDOC
3719 Used to maintain alignment whilst relaxing.
3720 ENUM
3721 BFD_RELOC_V850_LO16_SPLIT_OFFSET
3722 ENUMDOC
3723 This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu
3724 instructions.
3725 ENUM
3726 BFD_RELOC_V850_16_PCREL
3727 ENUMDOC
3728 This is a 16-bit reloc.
3729 ENUM
3730 BFD_RELOC_V850_17_PCREL
3731 ENUMDOC
3732 This is a 17-bit reloc.
3733 ENUM
3734 BFD_RELOC_V850_23
3735 ENUMDOC
3736 This is a 23-bit reloc.
3737 ENUM
3738 BFD_RELOC_V850_32_PCREL
3739 ENUMDOC
3740 This is a 32-bit reloc.
3741 ENUM
3742 BFD_RELOC_V850_32_ABS
3743 ENUMDOC
3744 This is a 32-bit reloc.
3745 ENUM
3746 BFD_RELOC_V850_16_SPLIT_OFFSET
3747 ENUMDOC
3748 This is a 16-bit reloc.
3749 ENUM
3750 BFD_RELOC_V850_16_S1
3751 ENUMDOC
3752 This is a 16-bit reloc.
3753 ENUM
3754 BFD_RELOC_V850_LO16_S1
3755 ENUMDOC
3756 Low 16 bits. 16 bit shifted by 1.
3757 ENUM
3758 BFD_RELOC_V850_CALLT_15_16_OFFSET
3759 ENUMDOC
3760 This is a 16 bit offset from the call table base pointer.
3761 ENUM
3762 BFD_RELOC_V850_32_GOTPCREL
3763 ENUMDOC
3764 DSO relocations.
3765 ENUM
3766 BFD_RELOC_V850_16_GOT
3767 ENUMDOC
3768 DSO relocations.
3769 ENUM
3770 BFD_RELOC_V850_32_GOT
3771 ENUMDOC
3772 DSO relocations.
3773 ENUM
3774 BFD_RELOC_V850_22_PLT_PCREL
3775 ENUMDOC
3776 DSO relocations.
3777 ENUM
3778 BFD_RELOC_V850_32_PLT_PCREL
3779 ENUMDOC
3780 DSO relocations.
3781 ENUM
3782 BFD_RELOC_V850_COPY
3783 ENUMDOC
3784 DSO relocations.
3785 ENUM
3786 BFD_RELOC_V850_GLOB_DAT
3787 ENUMDOC
3788 DSO relocations.
3789 ENUM
3790 BFD_RELOC_V850_JMP_SLOT
3791 ENUMDOC
3792 DSO relocations.
3793 ENUM
3794 BFD_RELOC_V850_RELATIVE
3795 ENUMDOC
3796 DSO relocations.
3797 ENUM
3798 BFD_RELOC_V850_16_GOTOFF
3799 ENUMDOC
3800 DSO relocations.
3801 ENUM
3802 BFD_RELOC_V850_32_GOTOFF
3803 ENUMDOC
3804 DSO relocations.
3805 ENUM
3806 BFD_RELOC_V850_CODE
3807 ENUMDOC
3808 start code.
3809 ENUM
3810 BFD_RELOC_V850_DATA
3811 ENUMDOC
3812 start data in text.
3813 ENUM
3814 BFD_RELOC_MN10300_32_PCREL
3815 ENUMDOC
3816 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
3817 instruction.
3818 ENUM
3819 BFD_RELOC_MN10300_16_PCREL
3820 ENUMDOC
3821 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
3822 instruction.
3824 ENUM
3825 BFD_RELOC_TIC30_LDP
3826 ENUMDOC
3827 This is a 8bit DP reloc for the tms320c30, where the most
3828 significant 8 bits of a 24 bit word are placed into the least
3829 significant 8 bits of the opcode.
3831 ENUM
3832 BFD_RELOC_TIC54X_PARTLS7
3833 ENUMDOC
3834 This is a 7bit reloc for the tms320c54x, where the least
3835 significant 7 bits of a 16 bit word are placed into the least
3836 significant 7 bits of the opcode.
3838 ENUM
3839 BFD_RELOC_TIC54X_PARTMS9
3840 ENUMDOC
3841 This is a 9bit DP reloc for the tms320c54x, where the most
3842 significant 9 bits of a 16 bit word are placed into the least
3843 significant 9 bits of the opcode.
3845 ENUM
3846 BFD_RELOC_TIC54X_23
3847 ENUMDOC
3848 This is an extended address 23-bit reloc for the tms320c54x.
3850 ENUM
3851 BFD_RELOC_TIC54X_16_OF_23
3852 ENUMDOC
3853 This is a 16-bit reloc for the tms320c54x, where the least
3854 significant 16 bits of a 23-bit extended address are placed into
3855 the opcode.
3857 ENUM
3858 BFD_RELOC_TIC54X_MS7_OF_23
3859 ENUMDOC
3860 This is a reloc for the tms320c54x, where the most
3861 significant 7 bits of a 23-bit extended address are placed into
3862 the opcode.
3864 ENUM
3865 BFD_RELOC_C6000_PCR_S21
3866 ENUMX
3867 BFD_RELOC_C6000_PCR_S12
3868 ENUMX
3869 BFD_RELOC_C6000_PCR_S10
3870 ENUMX
3871 BFD_RELOC_C6000_PCR_S7
3872 ENUMX
3873 BFD_RELOC_C6000_ABS_S16
3874 ENUMX
3875 BFD_RELOC_C6000_ABS_L16
3876 ENUMX
3877 BFD_RELOC_C6000_ABS_H16
3878 ENUMX
3879 BFD_RELOC_C6000_SBR_U15_B
3880 ENUMX
3881 BFD_RELOC_C6000_SBR_U15_H
3882 ENUMX
3883 BFD_RELOC_C6000_SBR_U15_W
3884 ENUMX
3885 BFD_RELOC_C6000_SBR_S16
3886 ENUMX
3887 BFD_RELOC_C6000_SBR_L16_B
3888 ENUMX
3889 BFD_RELOC_C6000_SBR_L16_H
3890 ENUMX
3891 BFD_RELOC_C6000_SBR_L16_W
3892 ENUMX
3893 BFD_RELOC_C6000_SBR_H16_B
3894 ENUMX
3895 BFD_RELOC_C6000_SBR_H16_H
3896 ENUMX
3897 BFD_RELOC_C6000_SBR_H16_W
3898 ENUMX
3899 BFD_RELOC_C6000_SBR_GOT_U15_W
3900 ENUMX
3901 BFD_RELOC_C6000_SBR_GOT_L16_W
3902 ENUMX
3903 BFD_RELOC_C6000_SBR_GOT_H16_W
3904 ENUMX
3905 BFD_RELOC_C6000_DSBT_INDEX
3906 ENUMX
3907 BFD_RELOC_C6000_PREL31
3908 ENUMX
3909 BFD_RELOC_C6000_COPY
3910 ENUMX
3911 BFD_RELOC_C6000_ALIGN
3912 ENUMX
3913 BFD_RELOC_C6000_FPHEAD
3914 ENUMX
3915 BFD_RELOC_C6000_NOCMP
3916 ENUMDOC
3917 TMS320C6000 relocations.
3919 ENUM
3920 BFD_RELOC_FR30_48
3921 ENUMDOC
3922 This is a 48 bit reloc for the FR30 that stores 32 bits.
3923 ENUM
3924 BFD_RELOC_FR30_20
3925 ENUMDOC
3926 This is a 32 bit reloc for the FR30 that stores 20 bits split up into
3927 two sections.
3928 ENUM
3929 BFD_RELOC_FR30_6_IN_4
3930 ENUMDOC
3931 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
3932 4 bits.
3933 ENUM
3934 BFD_RELOC_FR30_8_IN_8
3935 ENUMDOC
3936 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
3937 into 8 bits.
3938 ENUM
3939 BFD_RELOC_FR30_9_IN_8
3940 ENUMDOC
3941 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
3942 into 8 bits.
3943 ENUM
3944 BFD_RELOC_FR30_10_IN_8
3945 ENUMDOC
3946 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
3947 into 8 bits.
3948 ENUM
3949 BFD_RELOC_FR30_9_PCREL
3950 ENUMDOC
3951 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
3952 short offset into 8 bits.
3953 ENUM
3954 BFD_RELOC_FR30_12_PCREL
3955 ENUMDOC
3956 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
3957 short offset into 11 bits.
3959 ENUM
3960 BFD_RELOC_MCORE_PCREL_IMM8BY4
3961 ENUMX
3962 BFD_RELOC_MCORE_PCREL_IMM11BY2
3963 ENUMX
3964 BFD_RELOC_MCORE_PCREL_IMM4BY2
3965 ENUMX
3966 BFD_RELOC_MCORE_PCREL_32
3967 ENUMX
3968 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
3969 ENUMX
3970 BFD_RELOC_MCORE_RVA
3971 ENUMDOC
3972 Motorola Mcore relocations.
3974 ENUM
3975 BFD_RELOC_MEP_8
3976 ENUMX
3977 BFD_RELOC_MEP_16
3978 ENUMX
3979 BFD_RELOC_MEP_32
3980 ENUMX
3981 BFD_RELOC_MEP_PCREL8A2
3982 ENUMX
3983 BFD_RELOC_MEP_PCREL12A2
3984 ENUMX
3985 BFD_RELOC_MEP_PCREL17A2
3986 ENUMX
3987 BFD_RELOC_MEP_PCREL24A2
3988 ENUMX
3989 BFD_RELOC_MEP_PCABS24A2
3990 ENUMX
3991 BFD_RELOC_MEP_LOW16
3992 ENUMX
3993 BFD_RELOC_MEP_HI16U
3994 ENUMX
3995 BFD_RELOC_MEP_HI16S
3996 ENUMX
3997 BFD_RELOC_MEP_GPREL
3998 ENUMX
3999 BFD_RELOC_MEP_TPREL
4000 ENUMX
4001 BFD_RELOC_MEP_TPREL7
4002 ENUMX
4003 BFD_RELOC_MEP_TPREL7A2
4004 ENUMX
4005 BFD_RELOC_MEP_TPREL7A4
4006 ENUMX
4007 BFD_RELOC_MEP_UIMM24
4008 ENUMX
4009 BFD_RELOC_MEP_ADDR24A4
4010 ENUMX
4011 BFD_RELOC_MEP_GNU_VTINHERIT
4012 ENUMX
4013 BFD_RELOC_MEP_GNU_VTENTRY
4014 ENUMDOC
4015 Toshiba Media Processor Relocations.
4016 COMMENT
4018 ENUM
4019 BFD_RELOC_MMIX_GETA
4020 ENUMX
4021 BFD_RELOC_MMIX_GETA_1
4022 ENUMX
4023 BFD_RELOC_MMIX_GETA_2
4024 ENUMX
4025 BFD_RELOC_MMIX_GETA_3
4026 ENUMDOC
4027 These are relocations for the GETA instruction.
4028 ENUM
4029 BFD_RELOC_MMIX_CBRANCH
4030 ENUMX
4031 BFD_RELOC_MMIX_CBRANCH_J
4032 ENUMX
4033 BFD_RELOC_MMIX_CBRANCH_1
4034 ENUMX
4035 BFD_RELOC_MMIX_CBRANCH_2
4036 ENUMX
4037 BFD_RELOC_MMIX_CBRANCH_3
4038 ENUMDOC
4039 These are relocations for a conditional branch instruction.
4040 ENUM
4041 BFD_RELOC_MMIX_PUSHJ
4042 ENUMX
4043 BFD_RELOC_MMIX_PUSHJ_1
4044 ENUMX
4045 BFD_RELOC_MMIX_PUSHJ_2
4046 ENUMX
4047 BFD_RELOC_MMIX_PUSHJ_3
4048 ENUMX
4049 BFD_RELOC_MMIX_PUSHJ_STUBBABLE
4050 ENUMDOC
4051 These are relocations for the PUSHJ instruction.
4052 ENUM
4053 BFD_RELOC_MMIX_JMP
4054 ENUMX
4055 BFD_RELOC_MMIX_JMP_1
4056 ENUMX
4057 BFD_RELOC_MMIX_JMP_2
4058 ENUMX
4059 BFD_RELOC_MMIX_JMP_3
4060 ENUMDOC
4061 These are relocations for the JMP instruction.
4062 ENUM
4063 BFD_RELOC_MMIX_ADDR19
4064 ENUMDOC
4065 This is a relocation for a relative address as in a GETA instruction or
4066 a branch.
4067 ENUM
4068 BFD_RELOC_MMIX_ADDR27
4069 ENUMDOC
4070 This is a relocation for a relative address as in a JMP instruction.
4071 ENUM
4072 BFD_RELOC_MMIX_REG_OR_BYTE
4073 ENUMDOC
4074 This is a relocation for an instruction field that may be a general
4075 register or a value 0..255.
4076 ENUM
4077 BFD_RELOC_MMIX_REG
4078 ENUMDOC
4079 This is a relocation for an instruction field that may be a general
4080 register.
4081 ENUM
4082 BFD_RELOC_MMIX_BASE_PLUS_OFFSET
4083 ENUMDOC
4084 This is a relocation for two instruction fields holding a register and
4085 an offset, the equivalent of the relocation.
4086 ENUM
4087 BFD_RELOC_MMIX_LOCAL
4088 ENUMDOC
4089 This relocation is an assertion that the expression is not allocated as
4090 a global register. It does not modify contents.
4092 ENUM
4093 BFD_RELOC_AVR_7_PCREL
4094 ENUMDOC
4095 This is a 16 bit reloc for the AVR that stores 8 bit pc relative
4096 short offset into 7 bits.
4097 ENUM
4098 BFD_RELOC_AVR_13_PCREL
4099 ENUMDOC
4100 This is a 16 bit reloc for the AVR that stores 13 bit pc relative
4101 short offset into 12 bits.
4102 ENUM
4103 BFD_RELOC_AVR_16_PM
4104 ENUMDOC
4105 This is a 16 bit reloc for the AVR that stores 17 bit value (usually
4106 program memory address) into 16 bits.
4107 ENUM
4108 BFD_RELOC_AVR_LO8_LDI
4109 ENUMDOC
4110 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
4111 data memory address) into 8 bit immediate value of LDI insn.
4112 ENUM
4113 BFD_RELOC_AVR_HI8_LDI
4114 ENUMDOC
4115 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4116 of data memory address) into 8 bit immediate value of LDI insn.
4117 ENUM
4118 BFD_RELOC_AVR_HH8_LDI
4119 ENUMDOC
4120 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4121 of program memory address) into 8 bit immediate value of LDI insn.
4122 ENUM
4123 BFD_RELOC_AVR_MS8_LDI
4124 ENUMDOC
4125 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4126 of 32 bit value) into 8 bit immediate value of LDI insn.
4127 ENUM
4128 BFD_RELOC_AVR_LO8_LDI_NEG
4129 ENUMDOC
4130 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4131 (usually data memory address) into 8 bit immediate value of SUBI insn.
4132 ENUM
4133 BFD_RELOC_AVR_HI8_LDI_NEG
4134 ENUMDOC
4135 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4136 (high 8 bit of data memory address) into 8 bit immediate value of
4137 SUBI insn.
4138 ENUM
4139 BFD_RELOC_AVR_HH8_LDI_NEG
4140 ENUMDOC
4141 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4142 (most high 8 bit of program memory address) into 8 bit immediate value
4143 of LDI or SUBI insn.
4144 ENUM
4145 BFD_RELOC_AVR_MS8_LDI_NEG
4146 ENUMDOC
4147 This is a 16 bit reloc for the AVR that stores negated 8 bit value (msb
4148 of 32 bit value) into 8 bit immediate value of LDI insn.
4149 ENUM
4150 BFD_RELOC_AVR_LO8_LDI_PM
4151 ENUMDOC
4152 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
4153 command address) into 8 bit immediate value of LDI insn.
4154 ENUM
4155 BFD_RELOC_AVR_LO8_LDI_GS
4156 ENUMDOC
4157 This is a 16 bit reloc for the AVR that stores 8 bit value
4158 (command address) into 8 bit immediate value of LDI insn. If the address
4159 is beyond the 128k boundary, the linker inserts a jump stub for this reloc
4160 in the lower 128k.
4161 ENUM
4162 BFD_RELOC_AVR_HI8_LDI_PM
4163 ENUMDOC
4164 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4165 of command address) into 8 bit immediate value of LDI insn.
4166 ENUM
4167 BFD_RELOC_AVR_HI8_LDI_GS
4168 ENUMDOC
4169 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4170 of command address) into 8 bit immediate value of LDI insn. If the address
4171 is beyond the 128k boundary, the linker inserts a jump stub for this reloc
4172 below 128k.
4173 ENUM
4174 BFD_RELOC_AVR_HH8_LDI_PM
4175 ENUMDOC
4176 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4177 of command address) into 8 bit immediate value of LDI insn.
4178 ENUM
4179 BFD_RELOC_AVR_LO8_LDI_PM_NEG
4180 ENUMDOC
4181 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4182 (usually command address) into 8 bit immediate value of SUBI insn.
4183 ENUM
4184 BFD_RELOC_AVR_HI8_LDI_PM_NEG
4185 ENUMDOC
4186 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4187 (high 8 bit of 16 bit command address) into 8 bit immediate value
4188 of SUBI insn.
4189 ENUM
4190 BFD_RELOC_AVR_HH8_LDI_PM_NEG
4191 ENUMDOC
4192 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4193 (high 6 bit of 22 bit command address) into 8 bit immediate
4194 value of SUBI insn.
4195 ENUM
4196 BFD_RELOC_AVR_CALL
4197 ENUMDOC
4198 This is a 32 bit reloc for the AVR that stores 23 bit value
4199 into 22 bits.
4200 ENUM
4201 BFD_RELOC_AVR_LDI
4202 ENUMDOC
4203 This is a 16 bit reloc for the AVR that stores all needed bits
4204 for absolute addressing with ldi with overflow check to linktime
4205 ENUM
4206 BFD_RELOC_AVR_6
4207 ENUMDOC
4208 This is a 6 bit reloc for the AVR that stores offset for ldd/std
4209 instructions
4210 ENUM
4211 BFD_RELOC_AVR_6_ADIW
4212 ENUMDOC
4213 This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw
4214 instructions
4216 ENUM
4217 BFD_RELOC_RX_NEG8
4218 ENUMX
4219 BFD_RELOC_RX_NEG16
4220 ENUMX
4221 BFD_RELOC_RX_NEG24
4222 ENUMX
4223 BFD_RELOC_RX_NEG32
4224 ENUMX
4225 BFD_RELOC_RX_16_OP
4226 ENUMX
4227 BFD_RELOC_RX_24_OP
4228 ENUMX
4229 BFD_RELOC_RX_32_OP
4230 ENUMX
4231 BFD_RELOC_RX_8U
4232 ENUMX
4233 BFD_RELOC_RX_16U
4234 ENUMX
4235 BFD_RELOC_RX_24U
4236 ENUMX
4237 BFD_RELOC_RX_DIR3U_PCREL
4238 ENUMX
4239 BFD_RELOC_RX_DIFF
4240 ENUMX
4241 BFD_RELOC_RX_GPRELB
4242 ENUMX
4243 BFD_RELOC_RX_GPRELW
4244 ENUMX
4245 BFD_RELOC_RX_GPRELL
4246 ENUMX
4247 BFD_RELOC_RX_SYM
4248 ENUMX
4249 BFD_RELOC_RX_OP_SUBTRACT
4250 ENUMX
4251 BFD_RELOC_RX_ABS8
4252 ENUMX
4253 BFD_RELOC_RX_ABS16
4254 ENUMX
4255 BFD_RELOC_RX_ABS32
4256 ENUMX
4257 BFD_RELOC_RX_ABS16U
4258 ENUMX
4259 BFD_RELOC_RX_ABS16UW
4260 ENUMX
4261 BFD_RELOC_RX_ABS16UL
4262 ENUMX
4263 BFD_RELOC_RX_RELAX
4264 ENUMDOC
4265 Renesas RX Relocations.
4267 ENUM
4268 BFD_RELOC_390_12
4269 ENUMDOC
4270 Direct 12 bit.
4271 ENUM
4272 BFD_RELOC_390_GOT12
4273 ENUMDOC
4274 12 bit GOT offset.
4275 ENUM
4276 BFD_RELOC_390_PLT32
4277 ENUMDOC
4278 32 bit PC relative PLT address.
4279 ENUM
4280 BFD_RELOC_390_COPY
4281 ENUMDOC
4282 Copy symbol at runtime.
4283 ENUM
4284 BFD_RELOC_390_GLOB_DAT
4285 ENUMDOC
4286 Create GOT entry.
4287 ENUM
4288 BFD_RELOC_390_JMP_SLOT
4289 ENUMDOC
4290 Create PLT entry.
4291 ENUM
4292 BFD_RELOC_390_RELATIVE
4293 ENUMDOC
4294 Adjust by program base.
4295 ENUM
4296 BFD_RELOC_390_GOTPC
4297 ENUMDOC
4298 32 bit PC relative offset to GOT.
4299 ENUM
4300 BFD_RELOC_390_GOT16
4301 ENUMDOC
4302 16 bit GOT offset.
4303 ENUM
4304 BFD_RELOC_390_PC16DBL
4305 ENUMDOC
4306 PC relative 16 bit shifted by 1.
4307 ENUM
4308 BFD_RELOC_390_PLT16DBL
4309 ENUMDOC
4310 16 bit PC rel. PLT shifted by 1.
4311 ENUM
4312 BFD_RELOC_390_PC32DBL
4313 ENUMDOC
4314 PC relative 32 bit shifted by 1.
4315 ENUM
4316 BFD_RELOC_390_PLT32DBL
4317 ENUMDOC
4318 32 bit PC rel. PLT shifted by 1.
4319 ENUM
4320 BFD_RELOC_390_GOTPCDBL
4321 ENUMDOC
4322 32 bit PC rel. GOT shifted by 1.
4323 ENUM
4324 BFD_RELOC_390_GOT64
4325 ENUMDOC
4326 64 bit GOT offset.
4327 ENUM
4328 BFD_RELOC_390_PLT64
4329 ENUMDOC
4330 64 bit PC relative PLT address.
4331 ENUM
4332 BFD_RELOC_390_GOTENT
4333 ENUMDOC
4334 32 bit rel. offset to GOT entry.
4335 ENUM
4336 BFD_RELOC_390_GOTOFF64
4337 ENUMDOC
4338 64 bit offset to GOT.
4339 ENUM
4340 BFD_RELOC_390_GOTPLT12
4341 ENUMDOC
4342 12-bit offset to symbol-entry within GOT, with PLT handling.
4343 ENUM
4344 BFD_RELOC_390_GOTPLT16
4345 ENUMDOC
4346 16-bit offset to symbol-entry within GOT, with PLT handling.
4347 ENUM
4348 BFD_RELOC_390_GOTPLT32
4349 ENUMDOC
4350 32-bit offset to symbol-entry within GOT, with PLT handling.
4351 ENUM
4352 BFD_RELOC_390_GOTPLT64
4353 ENUMDOC
4354 64-bit offset to symbol-entry within GOT, with PLT handling.
4355 ENUM
4356 BFD_RELOC_390_GOTPLTENT
4357 ENUMDOC
4358 32-bit rel. offset to symbol-entry within GOT, with PLT handling.
4359 ENUM
4360 BFD_RELOC_390_PLTOFF16
4361 ENUMDOC
4362 16-bit rel. offset from the GOT to a PLT entry.
4363 ENUM
4364 BFD_RELOC_390_PLTOFF32
4365 ENUMDOC
4366 32-bit rel. offset from the GOT to a PLT entry.
4367 ENUM
4368 BFD_RELOC_390_PLTOFF64
4369 ENUMDOC
4370 64-bit rel. offset from the GOT to a PLT entry.
4372 ENUM
4373 BFD_RELOC_390_TLS_LOAD
4374 ENUMX
4375 BFD_RELOC_390_TLS_GDCALL
4376 ENUMX
4377 BFD_RELOC_390_TLS_LDCALL
4378 ENUMX
4379 BFD_RELOC_390_TLS_GD32
4380 ENUMX
4381 BFD_RELOC_390_TLS_GD64
4382 ENUMX
4383 BFD_RELOC_390_TLS_GOTIE12
4384 ENUMX
4385 BFD_RELOC_390_TLS_GOTIE32
4386 ENUMX
4387 BFD_RELOC_390_TLS_GOTIE64
4388 ENUMX
4389 BFD_RELOC_390_TLS_LDM32
4390 ENUMX
4391 BFD_RELOC_390_TLS_LDM64
4392 ENUMX
4393 BFD_RELOC_390_TLS_IE32
4394 ENUMX
4395 BFD_RELOC_390_TLS_IE64
4396 ENUMX
4397 BFD_RELOC_390_TLS_IEENT
4398 ENUMX
4399 BFD_RELOC_390_TLS_LE32
4400 ENUMX
4401 BFD_RELOC_390_TLS_LE64
4402 ENUMX
4403 BFD_RELOC_390_TLS_LDO32
4404 ENUMX
4405 BFD_RELOC_390_TLS_LDO64
4406 ENUMX
4407 BFD_RELOC_390_TLS_DTPMOD
4408 ENUMX
4409 BFD_RELOC_390_TLS_DTPOFF
4410 ENUMX
4411 BFD_RELOC_390_TLS_TPOFF
4412 ENUMDOC
4413 s390 tls relocations.
4415 ENUM
4416 BFD_RELOC_390_20
4417 ENUMX
4418 BFD_RELOC_390_GOT20
4419 ENUMX
4420 BFD_RELOC_390_GOTPLT20
4421 ENUMX
4422 BFD_RELOC_390_TLS_GOTIE20
4423 ENUMDOC
4424 Long displacement extension.
4426 ENUM
4427 BFD_RELOC_SCORE_GPREL15
4428 ENUMDOC
4429 Score relocations
4430 Low 16 bit for load/store
4431 ENUM
4432 BFD_RELOC_SCORE_DUMMY2
4433 ENUMX
4434 BFD_RELOC_SCORE_JMP
4435 ENUMDOC
4436 This is a 24-bit reloc with the right 1 bit assumed to be 0
4437 ENUM
4438 BFD_RELOC_SCORE_BRANCH
4439 ENUMDOC
4440 This is a 19-bit reloc with the right 1 bit assumed to be 0
4441 ENUM
4442 BFD_RELOC_SCORE_IMM30
4443 ENUMDOC
4444 This is a 32-bit reloc for 48-bit instructions.
4445 ENUM
4446 BFD_RELOC_SCORE_IMM32
4447 ENUMDOC
4448 This is a 32-bit reloc for 48-bit instructions.
4449 ENUM
4450 BFD_RELOC_SCORE16_JMP
4451 ENUMDOC
4452 This is a 11-bit reloc with the right 1 bit assumed to be 0
4453 ENUM
4454 BFD_RELOC_SCORE16_BRANCH
4455 ENUMDOC
4456 This is a 8-bit reloc with the right 1 bit assumed to be 0
4457 ENUM
4458 BFD_RELOC_SCORE_BCMP
4459 ENUMDOC
4460 This is a 9-bit reloc with the right 1 bit assumed to be 0
4461 ENUM
4462 BFD_RELOC_SCORE_GOT15
4463 ENUMX
4464 BFD_RELOC_SCORE_GOT_LO16
4465 ENUMX
4466 BFD_RELOC_SCORE_CALL15
4467 ENUMX
4468 BFD_RELOC_SCORE_DUMMY_HI16
4469 ENUMDOC
4470 Undocumented Score relocs
4472 ENUM
4473 BFD_RELOC_IP2K_FR9
4474 ENUMDOC
4475 Scenix IP2K - 9-bit register number / data address
4476 ENUM
4477 BFD_RELOC_IP2K_BANK
4478 ENUMDOC
4479 Scenix IP2K - 4-bit register/data bank number
4480 ENUM
4481 BFD_RELOC_IP2K_ADDR16CJP
4482 ENUMDOC
4483 Scenix IP2K - low 13 bits of instruction word address
4484 ENUM
4485 BFD_RELOC_IP2K_PAGE3
4486 ENUMDOC
4487 Scenix IP2K - high 3 bits of instruction word address
4488 ENUM
4489 BFD_RELOC_IP2K_LO8DATA
4490 ENUMX
4491 BFD_RELOC_IP2K_HI8DATA
4492 ENUMX
4493 BFD_RELOC_IP2K_EX8DATA
4494 ENUMDOC
4495 Scenix IP2K - ext/low/high 8 bits of data address
4496 ENUM
4497 BFD_RELOC_IP2K_LO8INSN
4498 ENUMX
4499 BFD_RELOC_IP2K_HI8INSN
4500 ENUMDOC
4501 Scenix IP2K - low/high 8 bits of instruction word address
4502 ENUM
4503 BFD_RELOC_IP2K_PC_SKIP
4504 ENUMDOC
4505 Scenix IP2K - even/odd PC modifier to modify snb pcl.0
4506 ENUM
4507 BFD_RELOC_IP2K_TEXT
4508 ENUMDOC
4509 Scenix IP2K - 16 bit word address in text section.
4510 ENUM
4511 BFD_RELOC_IP2K_FR_OFFSET
4512 ENUMDOC
4513 Scenix IP2K - 7-bit sp or dp offset
4514 ENUM
4515 BFD_RELOC_VPE4KMATH_DATA
4516 ENUMX
4517 BFD_RELOC_VPE4KMATH_INSN
4518 ENUMDOC
4519 Scenix VPE4K coprocessor - data/insn-space addressing
4521 ENUM
4522 BFD_RELOC_VTABLE_INHERIT
4523 ENUMX
4524 BFD_RELOC_VTABLE_ENTRY
4525 ENUMDOC
4526 These two relocations are used by the linker to determine which of
4527 the entries in a C++ virtual function table are actually used. When
4528 the --gc-sections option is given, the linker will zero out the entries
4529 that are not used, so that the code for those functions need not be
4530 included in the output.
4532 VTABLE_INHERIT is a zero-space relocation used to describe to the
4533 linker the inheritance tree of a C++ virtual function table. The
4534 relocation's symbol should be the parent class' vtable, and the
4535 relocation should be located at the child vtable.
4537 VTABLE_ENTRY is a zero-space relocation that describes the use of a
4538 virtual function table entry. The reloc's symbol should refer to the
4539 table of the class mentioned in the code. Off of that base, an offset
4540 describes the entry that is being used. For Rela hosts, this offset
4541 is stored in the reloc's addend. For Rel hosts, we are forced to put
4542 this offset in the reloc's section offset.
4544 ENUM
4545 BFD_RELOC_IA64_IMM14
4546 ENUMX
4547 BFD_RELOC_IA64_IMM22
4548 ENUMX
4549 BFD_RELOC_IA64_IMM64
4550 ENUMX
4551 BFD_RELOC_IA64_DIR32MSB
4552 ENUMX
4553 BFD_RELOC_IA64_DIR32LSB
4554 ENUMX
4555 BFD_RELOC_IA64_DIR64MSB
4556 ENUMX
4557 BFD_RELOC_IA64_DIR64LSB
4558 ENUMX
4559 BFD_RELOC_IA64_GPREL22
4560 ENUMX
4561 BFD_RELOC_IA64_GPREL64I
4562 ENUMX
4563 BFD_RELOC_IA64_GPREL32MSB
4564 ENUMX
4565 BFD_RELOC_IA64_GPREL32LSB
4566 ENUMX
4567 BFD_RELOC_IA64_GPREL64MSB
4568 ENUMX
4569 BFD_RELOC_IA64_GPREL64LSB
4570 ENUMX
4571 BFD_RELOC_IA64_LTOFF22
4572 ENUMX
4573 BFD_RELOC_IA64_LTOFF64I
4574 ENUMX
4575 BFD_RELOC_IA64_PLTOFF22
4576 ENUMX
4577 BFD_RELOC_IA64_PLTOFF64I
4578 ENUMX
4579 BFD_RELOC_IA64_PLTOFF64MSB
4580 ENUMX
4581 BFD_RELOC_IA64_PLTOFF64LSB
4582 ENUMX
4583 BFD_RELOC_IA64_FPTR64I
4584 ENUMX
4585 BFD_RELOC_IA64_FPTR32MSB
4586 ENUMX
4587 BFD_RELOC_IA64_FPTR32LSB
4588 ENUMX
4589 BFD_RELOC_IA64_FPTR64MSB
4590 ENUMX
4591 BFD_RELOC_IA64_FPTR64LSB
4592 ENUMX
4593 BFD_RELOC_IA64_PCREL21B
4594 ENUMX
4595 BFD_RELOC_IA64_PCREL21BI
4596 ENUMX
4597 BFD_RELOC_IA64_PCREL21M
4598 ENUMX
4599 BFD_RELOC_IA64_PCREL21F
4600 ENUMX
4601 BFD_RELOC_IA64_PCREL22
4602 ENUMX
4603 BFD_RELOC_IA64_PCREL60B
4604 ENUMX
4605 BFD_RELOC_IA64_PCREL64I
4606 ENUMX
4607 BFD_RELOC_IA64_PCREL32MSB
4608 ENUMX
4609 BFD_RELOC_IA64_PCREL32LSB
4610 ENUMX
4611 BFD_RELOC_IA64_PCREL64MSB
4612 ENUMX
4613 BFD_RELOC_IA64_PCREL64LSB
4614 ENUMX
4615 BFD_RELOC_IA64_LTOFF_FPTR22
4616 ENUMX
4617 BFD_RELOC_IA64_LTOFF_FPTR64I
4618 ENUMX
4619 BFD_RELOC_IA64_LTOFF_FPTR32MSB
4620 ENUMX
4621 BFD_RELOC_IA64_LTOFF_FPTR32LSB
4622 ENUMX
4623 BFD_RELOC_IA64_LTOFF_FPTR64MSB
4624 ENUMX
4625 BFD_RELOC_IA64_LTOFF_FPTR64LSB
4626 ENUMX
4627 BFD_RELOC_IA64_SEGREL32MSB
4628 ENUMX
4629 BFD_RELOC_IA64_SEGREL32LSB
4630 ENUMX
4631 BFD_RELOC_IA64_SEGREL64MSB
4632 ENUMX
4633 BFD_RELOC_IA64_SEGREL64LSB
4634 ENUMX
4635 BFD_RELOC_IA64_SECREL32MSB
4636 ENUMX
4637 BFD_RELOC_IA64_SECREL32LSB
4638 ENUMX
4639 BFD_RELOC_IA64_SECREL64MSB
4640 ENUMX
4641 BFD_RELOC_IA64_SECREL64LSB
4642 ENUMX
4643 BFD_RELOC_IA64_REL32MSB
4644 ENUMX
4645 BFD_RELOC_IA64_REL32LSB
4646 ENUMX
4647 BFD_RELOC_IA64_REL64MSB
4648 ENUMX
4649 BFD_RELOC_IA64_REL64LSB
4650 ENUMX
4651 BFD_RELOC_IA64_LTV32MSB
4652 ENUMX
4653 BFD_RELOC_IA64_LTV32LSB
4654 ENUMX
4655 BFD_RELOC_IA64_LTV64MSB
4656 ENUMX
4657 BFD_RELOC_IA64_LTV64LSB
4658 ENUMX
4659 BFD_RELOC_IA64_IPLTMSB
4660 ENUMX
4661 BFD_RELOC_IA64_IPLTLSB
4662 ENUMX
4663 BFD_RELOC_IA64_COPY
4664 ENUMX
4665 BFD_RELOC_IA64_LTOFF22X
4666 ENUMX
4667 BFD_RELOC_IA64_LDXMOV
4668 ENUMX
4669 BFD_RELOC_IA64_TPREL14
4670 ENUMX
4671 BFD_RELOC_IA64_TPREL22
4672 ENUMX
4673 BFD_RELOC_IA64_TPREL64I
4674 ENUMX
4675 BFD_RELOC_IA64_TPREL64MSB
4676 ENUMX
4677 BFD_RELOC_IA64_TPREL64LSB
4678 ENUMX
4679 BFD_RELOC_IA64_LTOFF_TPREL22
4680 ENUMX
4681 BFD_RELOC_IA64_DTPMOD64MSB
4682 ENUMX
4683 BFD_RELOC_IA64_DTPMOD64LSB
4684 ENUMX
4685 BFD_RELOC_IA64_LTOFF_DTPMOD22
4686 ENUMX
4687 BFD_RELOC_IA64_DTPREL14
4688 ENUMX
4689 BFD_RELOC_IA64_DTPREL22
4690 ENUMX
4691 BFD_RELOC_IA64_DTPREL64I
4692 ENUMX
4693 BFD_RELOC_IA64_DTPREL32MSB
4694 ENUMX
4695 BFD_RELOC_IA64_DTPREL32LSB
4696 ENUMX
4697 BFD_RELOC_IA64_DTPREL64MSB
4698 ENUMX
4699 BFD_RELOC_IA64_DTPREL64LSB
4700 ENUMX
4701 BFD_RELOC_IA64_LTOFF_DTPREL22
4702 ENUMDOC
4703 Intel IA64 Relocations.
4705 ENUM
4706 BFD_RELOC_M68HC11_HI8
4707 ENUMDOC
4708 Motorola 68HC11 reloc.
4709 This is the 8 bit high part of an absolute address.
4710 ENUM
4711 BFD_RELOC_M68HC11_LO8
4712 ENUMDOC
4713 Motorola 68HC11 reloc.
4714 This is the 8 bit low part of an absolute address.
4715 ENUM
4716 BFD_RELOC_M68HC11_3B
4717 ENUMDOC
4718 Motorola 68HC11 reloc.
4719 This is the 3 bit of a value.
4720 ENUM
4721 BFD_RELOC_M68HC11_RL_JUMP
4722 ENUMDOC
4723 Motorola 68HC11 reloc.
4724 This reloc marks the beginning of a jump/call instruction.
4725 It is used for linker relaxation to correctly identify beginning
4726 of instruction and change some branches to use PC-relative
4727 addressing mode.
4728 ENUM
4729 BFD_RELOC_M68HC11_RL_GROUP
4730 ENUMDOC
4731 Motorola 68HC11 reloc.
4732 This reloc marks a group of several instructions that gcc generates
4733 and for which the linker relaxation pass can modify and/or remove
4734 some of them.
4735 ENUM
4736 BFD_RELOC_M68HC11_LO16
4737 ENUMDOC
4738 Motorola 68HC11 reloc.
4739 This is the 16-bit lower part of an address. It is used for 'call'
4740 instruction to specify the symbol address without any special
4741 transformation (due to memory bank window).
4742 ENUM
4743 BFD_RELOC_M68HC11_PAGE
4744 ENUMDOC
4745 Motorola 68HC11 reloc.
4746 This is a 8-bit reloc that specifies the page number of an address.
4747 It is used by 'call' instruction to specify the page number of
4748 the symbol.
4749 ENUM
4750 BFD_RELOC_M68HC11_24
4751 ENUMDOC
4752 Motorola 68HC11 reloc.
4753 This is a 24-bit reloc that represents the address with a 16-bit
4754 value and a 8-bit page number. The symbol address is transformed
4755 to follow the 16K memory bank of 68HC12 (seen as mapped in the window).
4756 ENUM
4757 BFD_RELOC_M68HC12_5B
4758 ENUMDOC
4759 Motorola 68HC12 reloc.
4760 This is the 5 bits of a value.
4762 ENUM
4763 BFD_RELOC_16C_NUM08
4764 ENUMX
4765 BFD_RELOC_16C_NUM08_C
4766 ENUMX
4767 BFD_RELOC_16C_NUM16
4768 ENUMX
4769 BFD_RELOC_16C_NUM16_C
4770 ENUMX
4771 BFD_RELOC_16C_NUM32
4772 ENUMX
4773 BFD_RELOC_16C_NUM32_C
4774 ENUMX
4775 BFD_RELOC_16C_DISP04
4776 ENUMX
4777 BFD_RELOC_16C_DISP04_C
4778 ENUMX
4779 BFD_RELOC_16C_DISP08
4780 ENUMX
4781 BFD_RELOC_16C_DISP08_C
4782 ENUMX
4783 BFD_RELOC_16C_DISP16
4784 ENUMX
4785 BFD_RELOC_16C_DISP16_C
4786 ENUMX
4787 BFD_RELOC_16C_DISP24
4788 ENUMX
4789 BFD_RELOC_16C_DISP24_C
4790 ENUMX
4791 BFD_RELOC_16C_DISP24a
4792 ENUMX
4793 BFD_RELOC_16C_DISP24a_C
4794 ENUMX
4795 BFD_RELOC_16C_REG04
4796 ENUMX
4797 BFD_RELOC_16C_REG04_C
4798 ENUMX
4799 BFD_RELOC_16C_REG04a
4800 ENUMX
4801 BFD_RELOC_16C_REG04a_C
4802 ENUMX
4803 BFD_RELOC_16C_REG14
4804 ENUMX
4805 BFD_RELOC_16C_REG14_C
4806 ENUMX
4807 BFD_RELOC_16C_REG16
4808 ENUMX
4809 BFD_RELOC_16C_REG16_C
4810 ENUMX
4811 BFD_RELOC_16C_REG20
4812 ENUMX
4813 BFD_RELOC_16C_REG20_C
4814 ENUMX
4815 BFD_RELOC_16C_ABS20
4816 ENUMX
4817 BFD_RELOC_16C_ABS20_C
4818 ENUMX
4819 BFD_RELOC_16C_ABS24
4820 ENUMX
4821 BFD_RELOC_16C_ABS24_C
4822 ENUMX
4823 BFD_RELOC_16C_IMM04
4824 ENUMX
4825 BFD_RELOC_16C_IMM04_C
4826 ENUMX
4827 BFD_RELOC_16C_IMM16
4828 ENUMX
4829 BFD_RELOC_16C_IMM16_C
4830 ENUMX
4831 BFD_RELOC_16C_IMM20
4832 ENUMX
4833 BFD_RELOC_16C_IMM20_C
4834 ENUMX
4835 BFD_RELOC_16C_IMM24
4836 ENUMX
4837 BFD_RELOC_16C_IMM24_C
4838 ENUMX
4839 BFD_RELOC_16C_IMM32
4840 ENUMX
4841 BFD_RELOC_16C_IMM32_C
4842 ENUMDOC
4843 NS CR16C Relocations.
4845 ENUM
4846 BFD_RELOC_CR16_NUM8
4847 ENUMX
4848 BFD_RELOC_CR16_NUM16
4849 ENUMX
4850 BFD_RELOC_CR16_NUM32
4851 ENUMX
4852 BFD_RELOC_CR16_NUM32a
4853 ENUMX
4854 BFD_RELOC_CR16_REGREL0
4855 ENUMX
4856 BFD_RELOC_CR16_REGREL4
4857 ENUMX
4858 BFD_RELOC_CR16_REGREL4a
4859 ENUMX
4860 BFD_RELOC_CR16_REGREL14
4861 ENUMX
4862 BFD_RELOC_CR16_REGREL14a
4863 ENUMX
4864 BFD_RELOC_CR16_REGREL16
4865 ENUMX
4866 BFD_RELOC_CR16_REGREL20
4867 ENUMX
4868 BFD_RELOC_CR16_REGREL20a
4869 ENUMX
4870 BFD_RELOC_CR16_ABS20
4871 ENUMX
4872 BFD_RELOC_CR16_ABS24
4873 ENUMX
4874 BFD_RELOC_CR16_IMM4
4875 ENUMX
4876 BFD_RELOC_CR16_IMM8
4877 ENUMX
4878 BFD_RELOC_CR16_IMM16
4879 ENUMX
4880 BFD_RELOC_CR16_IMM20
4881 ENUMX
4882 BFD_RELOC_CR16_IMM24
4883 ENUMX
4884 BFD_RELOC_CR16_IMM32
4885 ENUMX
4886 BFD_RELOC_CR16_IMM32a
4887 ENUMX
4888 BFD_RELOC_CR16_DISP4
4889 ENUMX
4890 BFD_RELOC_CR16_DISP8
4891 ENUMX
4892 BFD_RELOC_CR16_DISP16
4893 ENUMX
4894 BFD_RELOC_CR16_DISP20
4895 ENUMX
4896 BFD_RELOC_CR16_DISP24
4897 ENUMX
4898 BFD_RELOC_CR16_DISP24a
4899 ENUMX
4900 BFD_RELOC_CR16_SWITCH8
4901 ENUMX
4902 BFD_RELOC_CR16_SWITCH16
4903 ENUMX
4904 BFD_RELOC_CR16_SWITCH32
4905 ENUMX
4906 BFD_RELOC_CR16_GOT_REGREL20
4907 ENUMX
4908 BFD_RELOC_CR16_GOTC_REGREL20
4909 ENUMX
4910 BFD_RELOC_CR16_GLOB_DAT
4911 ENUMDOC
4912 NS CR16 Relocations.
4914 ENUM
4915 BFD_RELOC_CRX_REL4
4916 ENUMX
4917 BFD_RELOC_CRX_REL8
4918 ENUMX
4919 BFD_RELOC_CRX_REL8_CMP
4920 ENUMX
4921 BFD_RELOC_CRX_REL16
4922 ENUMX
4923 BFD_RELOC_CRX_REL24
4924 ENUMX
4925 BFD_RELOC_CRX_REL32
4926 ENUMX
4927 BFD_RELOC_CRX_REGREL12
4928 ENUMX
4929 BFD_RELOC_CRX_REGREL22
4930 ENUMX
4931 BFD_RELOC_CRX_REGREL28
4932 ENUMX
4933 BFD_RELOC_CRX_REGREL32
4934 ENUMX
4935 BFD_RELOC_CRX_ABS16
4936 ENUMX
4937 BFD_RELOC_CRX_ABS32
4938 ENUMX
4939 BFD_RELOC_CRX_NUM8
4940 ENUMX
4941 BFD_RELOC_CRX_NUM16
4942 ENUMX
4943 BFD_RELOC_CRX_NUM32
4944 ENUMX
4945 BFD_RELOC_CRX_IMM16
4946 ENUMX
4947 BFD_RELOC_CRX_IMM32
4948 ENUMX
4949 BFD_RELOC_CRX_SWITCH8
4950 ENUMX
4951 BFD_RELOC_CRX_SWITCH16
4952 ENUMX
4953 BFD_RELOC_CRX_SWITCH32
4954 ENUMDOC
4955 NS CRX Relocations.
4957 ENUM
4958 BFD_RELOC_CRIS_BDISP8
4959 ENUMX
4960 BFD_RELOC_CRIS_UNSIGNED_5
4961 ENUMX
4962 BFD_RELOC_CRIS_SIGNED_6
4963 ENUMX
4964 BFD_RELOC_CRIS_UNSIGNED_6
4965 ENUMX
4966 BFD_RELOC_CRIS_SIGNED_8
4967 ENUMX
4968 BFD_RELOC_CRIS_UNSIGNED_8
4969 ENUMX
4970 BFD_RELOC_CRIS_SIGNED_16
4971 ENUMX
4972 BFD_RELOC_CRIS_UNSIGNED_16
4973 ENUMX
4974 BFD_RELOC_CRIS_LAPCQ_OFFSET
4975 ENUMX
4976 BFD_RELOC_CRIS_UNSIGNED_4
4977 ENUMDOC
4978 These relocs are only used within the CRIS assembler. They are not
4979 (at present) written to any object files.
4980 ENUM
4981 BFD_RELOC_CRIS_COPY
4982 ENUMX
4983 BFD_RELOC_CRIS_GLOB_DAT
4984 ENUMX
4985 BFD_RELOC_CRIS_JUMP_SLOT
4986 ENUMX
4987 BFD_RELOC_CRIS_RELATIVE
4988 ENUMDOC
4989 Relocs used in ELF shared libraries for CRIS.
4990 ENUM
4991 BFD_RELOC_CRIS_32_GOT
4992 ENUMDOC
4993 32-bit offset to symbol-entry within GOT.
4994 ENUM
4995 BFD_RELOC_CRIS_16_GOT
4996 ENUMDOC
4997 16-bit offset to symbol-entry within GOT.
4998 ENUM
4999 BFD_RELOC_CRIS_32_GOTPLT
5000 ENUMDOC
5001 32-bit offset to symbol-entry within GOT, with PLT handling.
5002 ENUM
5003 BFD_RELOC_CRIS_16_GOTPLT
5004 ENUMDOC
5005 16-bit offset to symbol-entry within GOT, with PLT handling.
5006 ENUM
5007 BFD_RELOC_CRIS_32_GOTREL
5008 ENUMDOC
5009 32-bit offset to symbol, relative to GOT.
5010 ENUM
5011 BFD_RELOC_CRIS_32_PLT_GOTREL
5012 ENUMDOC
5013 32-bit offset to symbol with PLT entry, relative to GOT.
5014 ENUM
5015 BFD_RELOC_CRIS_32_PLT_PCREL
5016 ENUMDOC
5017 32-bit offset to symbol with PLT entry, relative to this relocation.
5019 ENUM
5020 BFD_RELOC_CRIS_32_GOT_GD
5021 ENUMX
5022 BFD_RELOC_CRIS_16_GOT_GD
5023 ENUMX
5024 BFD_RELOC_CRIS_32_GD
5025 ENUMX
5026 BFD_RELOC_CRIS_DTP
5027 ENUMX
5028 BFD_RELOC_CRIS_32_DTPREL
5029 ENUMX
5030 BFD_RELOC_CRIS_16_DTPREL
5031 ENUMX
5032 BFD_RELOC_CRIS_32_GOT_TPREL
5033 ENUMX
5034 BFD_RELOC_CRIS_16_GOT_TPREL
5035 ENUMX
5036 BFD_RELOC_CRIS_32_TPREL
5037 ENUMX
5038 BFD_RELOC_CRIS_16_TPREL
5039 ENUMX
5040 BFD_RELOC_CRIS_DTPMOD
5041 ENUMX
5042 BFD_RELOC_CRIS_32_IE
5043 ENUMDOC
5044 Relocs used in TLS code for CRIS.
5046 ENUM
5047 BFD_RELOC_860_COPY
5048 ENUMX
5049 BFD_RELOC_860_GLOB_DAT
5050 ENUMX
5051 BFD_RELOC_860_JUMP_SLOT
5052 ENUMX
5053 BFD_RELOC_860_RELATIVE
5054 ENUMX
5055 BFD_RELOC_860_PC26
5056 ENUMX
5057 BFD_RELOC_860_PLT26
5058 ENUMX
5059 BFD_RELOC_860_PC16
5060 ENUMX
5061 BFD_RELOC_860_LOW0
5062 ENUMX
5063 BFD_RELOC_860_SPLIT0
5064 ENUMX
5065 BFD_RELOC_860_LOW1
5066 ENUMX
5067 BFD_RELOC_860_SPLIT1
5068 ENUMX
5069 BFD_RELOC_860_LOW2
5070 ENUMX
5071 BFD_RELOC_860_SPLIT2
5072 ENUMX
5073 BFD_RELOC_860_LOW3
5074 ENUMX
5075 BFD_RELOC_860_LOGOT0
5076 ENUMX
5077 BFD_RELOC_860_SPGOT0
5078 ENUMX
5079 BFD_RELOC_860_LOGOT1
5080 ENUMX
5081 BFD_RELOC_860_SPGOT1
5082 ENUMX
5083 BFD_RELOC_860_LOGOTOFF0
5084 ENUMX
5085 BFD_RELOC_860_SPGOTOFF0
5086 ENUMX
5087 BFD_RELOC_860_LOGOTOFF1
5088 ENUMX
5089 BFD_RELOC_860_SPGOTOFF1
5090 ENUMX
5091 BFD_RELOC_860_LOGOTOFF2
5092 ENUMX
5093 BFD_RELOC_860_LOGOTOFF3
5094 ENUMX
5095 BFD_RELOC_860_LOPC
5096 ENUMX
5097 BFD_RELOC_860_HIGHADJ
5098 ENUMX
5099 BFD_RELOC_860_HAGOT
5100 ENUMX
5101 BFD_RELOC_860_HAGOTOFF
5102 ENUMX
5103 BFD_RELOC_860_HAPC
5104 ENUMX
5105 BFD_RELOC_860_HIGH
5106 ENUMX
5107 BFD_RELOC_860_HIGOT
5108 ENUMX
5109 BFD_RELOC_860_HIGOTOFF
5110 ENUMDOC
5111 Intel i860 Relocations.
5113 ENUM
5114 BFD_RELOC_OPENRISC_ABS_26
5115 ENUMX
5116 BFD_RELOC_OPENRISC_REL_26
5117 ENUMDOC
5118 OpenRISC Relocations.
5120 ENUM
5121 BFD_RELOC_H8_DIR16A8
5122 ENUMX
5123 BFD_RELOC_H8_DIR16R8
5124 ENUMX
5125 BFD_RELOC_H8_DIR24A8
5126 ENUMX
5127 BFD_RELOC_H8_DIR24R8
5128 ENUMX
5129 BFD_RELOC_H8_DIR32A16
5130 ENUMDOC
5131 H8 elf Relocations.
5133 ENUM
5134 BFD_RELOC_XSTORMY16_REL_12
5135 ENUMX
5136 BFD_RELOC_XSTORMY16_12
5137 ENUMX
5138 BFD_RELOC_XSTORMY16_24
5139 ENUMX
5140 BFD_RELOC_XSTORMY16_FPTR16
5141 ENUMDOC
5142 Sony Xstormy16 Relocations.
5144 ENUM
5145 BFD_RELOC_RELC
5146 ENUMDOC
5147 Self-describing complex relocations.
5148 COMMENT
5150 ENUM
5151 BFD_RELOC_XC16X_PAG
5152 ENUMX
5153 BFD_RELOC_XC16X_POF
5154 ENUMX
5155 BFD_RELOC_XC16X_SEG
5156 ENUMX
5157 BFD_RELOC_XC16X_SOF
5158 ENUMDOC
5159 Infineon Relocations.
5161 ENUM
5162 BFD_RELOC_VAX_GLOB_DAT
5163 ENUMX
5164 BFD_RELOC_VAX_JMP_SLOT
5165 ENUMX
5166 BFD_RELOC_VAX_RELATIVE
5167 ENUMDOC
5168 Relocations used by VAX ELF.
5170 ENUM
5171 BFD_RELOC_MT_PC16
5172 ENUMDOC
5173 Morpho MT - 16 bit immediate relocation.
5174 ENUM
5175 BFD_RELOC_MT_HI16
5176 ENUMDOC
5177 Morpho MT - Hi 16 bits of an address.
5178 ENUM
5179 BFD_RELOC_MT_LO16
5180 ENUMDOC
5181 Morpho MT - Low 16 bits of an address.
5182 ENUM
5183 BFD_RELOC_MT_GNU_VTINHERIT
5184 ENUMDOC
5185 Morpho MT - Used to tell the linker which vtable entries are used.
5186 ENUM
5187 BFD_RELOC_MT_GNU_VTENTRY
5188 ENUMDOC
5189 Morpho MT - Used to tell the linker which vtable entries are used.
5190 ENUM
5191 BFD_RELOC_MT_PCINSN8
5192 ENUMDOC
5193 Morpho MT - 8 bit immediate relocation.
5195 ENUM
5196 BFD_RELOC_MSP430_10_PCREL
5197 ENUMX
5198 BFD_RELOC_MSP430_16_PCREL
5199 ENUMX
5200 BFD_RELOC_MSP430_16
5201 ENUMX
5202 BFD_RELOC_MSP430_16_PCREL_BYTE
5203 ENUMX
5204 BFD_RELOC_MSP430_16_BYTE
5205 ENUMX
5206 BFD_RELOC_MSP430_2X_PCREL
5207 ENUMX
5208 BFD_RELOC_MSP430_RL_PCREL
5209 ENUMDOC
5210 msp430 specific relocation codes
5212 ENUM
5213 BFD_RELOC_IQ2000_OFFSET_16
5214 ENUMX
5215 BFD_RELOC_IQ2000_OFFSET_21
5216 ENUMX
5217 BFD_RELOC_IQ2000_UHI16
5218 ENUMDOC
5219 IQ2000 Relocations.
5221 ENUM
5222 BFD_RELOC_XTENSA_RTLD
5223 ENUMDOC
5224 Special Xtensa relocation used only by PLT entries in ELF shared
5225 objects to indicate that the runtime linker should set the value
5226 to one of its own internal functions or data structures.
5227 ENUM
5228 BFD_RELOC_XTENSA_GLOB_DAT
5229 ENUMX
5230 BFD_RELOC_XTENSA_JMP_SLOT
5231 ENUMX
5232 BFD_RELOC_XTENSA_RELATIVE
5233 ENUMDOC
5234 Xtensa relocations for ELF shared objects.
5235 ENUM
5236 BFD_RELOC_XTENSA_PLT
5237 ENUMDOC
5238 Xtensa relocation used in ELF object files for symbols that may require
5239 PLT entries. Otherwise, this is just a generic 32-bit relocation.
5240 ENUM
5241 BFD_RELOC_XTENSA_DIFF8
5242 ENUMX
5243 BFD_RELOC_XTENSA_DIFF16
5244 ENUMX
5245 BFD_RELOC_XTENSA_DIFF32
5246 ENUMDOC
5247 Xtensa relocations to mark the difference of two local symbols.
5248 These are only needed to support linker relaxation and can be ignored
5249 when not relaxing. The field is set to the value of the difference
5250 assuming no relaxation. The relocation encodes the position of the
5251 first symbol so the linker can determine whether to adjust the field
5252 value.
5253 ENUM
5254 BFD_RELOC_XTENSA_SLOT0_OP
5255 ENUMX
5256 BFD_RELOC_XTENSA_SLOT1_OP
5257 ENUMX
5258 BFD_RELOC_XTENSA_SLOT2_OP
5259 ENUMX
5260 BFD_RELOC_XTENSA_SLOT3_OP
5261 ENUMX
5262 BFD_RELOC_XTENSA_SLOT4_OP
5263 ENUMX
5264 BFD_RELOC_XTENSA_SLOT5_OP
5265 ENUMX
5266 BFD_RELOC_XTENSA_SLOT6_OP
5267 ENUMX
5268 BFD_RELOC_XTENSA_SLOT7_OP
5269 ENUMX
5270 BFD_RELOC_XTENSA_SLOT8_OP
5271 ENUMX
5272 BFD_RELOC_XTENSA_SLOT9_OP
5273 ENUMX
5274 BFD_RELOC_XTENSA_SLOT10_OP
5275 ENUMX
5276 BFD_RELOC_XTENSA_SLOT11_OP
5277 ENUMX
5278 BFD_RELOC_XTENSA_SLOT12_OP
5279 ENUMX
5280 BFD_RELOC_XTENSA_SLOT13_OP
5281 ENUMX
5282 BFD_RELOC_XTENSA_SLOT14_OP
5283 ENUMDOC
5284 Generic Xtensa relocations for instruction operands. Only the slot
5285 number is encoded in the relocation. The relocation applies to the
5286 last PC-relative immediate operand, or if there are no PC-relative
5287 immediates, to the last immediate operand.
5288 ENUM
5289 BFD_RELOC_XTENSA_SLOT0_ALT
5290 ENUMX
5291 BFD_RELOC_XTENSA_SLOT1_ALT
5292 ENUMX
5293 BFD_RELOC_XTENSA_SLOT2_ALT
5294 ENUMX
5295 BFD_RELOC_XTENSA_SLOT3_ALT
5296 ENUMX
5297 BFD_RELOC_XTENSA_SLOT4_ALT
5298 ENUMX
5299 BFD_RELOC_XTENSA_SLOT5_ALT
5300 ENUMX
5301 BFD_RELOC_XTENSA_SLOT6_ALT
5302 ENUMX
5303 BFD_RELOC_XTENSA_SLOT7_ALT
5304 ENUMX
5305 BFD_RELOC_XTENSA_SLOT8_ALT
5306 ENUMX
5307 BFD_RELOC_XTENSA_SLOT9_ALT
5308 ENUMX
5309 BFD_RELOC_XTENSA_SLOT10_ALT
5310 ENUMX
5311 BFD_RELOC_XTENSA_SLOT11_ALT
5312 ENUMX
5313 BFD_RELOC_XTENSA_SLOT12_ALT
5314 ENUMX
5315 BFD_RELOC_XTENSA_SLOT13_ALT
5316 ENUMX
5317 BFD_RELOC_XTENSA_SLOT14_ALT
5318 ENUMDOC
5319 Alternate Xtensa relocations. Only the slot is encoded in the
5320 relocation. The meaning of these relocations is opcode-specific.
5321 ENUM
5322 BFD_RELOC_XTENSA_OP0
5323 ENUMX
5324 BFD_RELOC_XTENSA_OP1
5325 ENUMX
5326 BFD_RELOC_XTENSA_OP2
5327 ENUMDOC
5328 Xtensa relocations for backward compatibility. These have all been
5329 replaced by BFD_RELOC_XTENSA_SLOT0_OP.
5330 ENUM
5331 BFD_RELOC_XTENSA_ASM_EXPAND
5332 ENUMDOC
5333 Xtensa relocation to mark that the assembler expanded the
5334 instructions from an original target. The expansion size is
5335 encoded in the reloc size.
5336 ENUM
5337 BFD_RELOC_XTENSA_ASM_SIMPLIFY
5338 ENUMDOC
5339 Xtensa relocation to mark that the linker should simplify
5340 assembler-expanded instructions. This is commonly used
5341 internally by the linker after analysis of a
5342 BFD_RELOC_XTENSA_ASM_EXPAND.
5343 ENUM
5344 BFD_RELOC_XTENSA_TLSDESC_FN
5345 ENUMX
5346 BFD_RELOC_XTENSA_TLSDESC_ARG
5347 ENUMX
5348 BFD_RELOC_XTENSA_TLS_DTPOFF
5349 ENUMX
5350 BFD_RELOC_XTENSA_TLS_TPOFF
5351 ENUMX
5352 BFD_RELOC_XTENSA_TLS_FUNC
5353 ENUMX
5354 BFD_RELOC_XTENSA_TLS_ARG
5355 ENUMX
5356 BFD_RELOC_XTENSA_TLS_CALL
5357 ENUMDOC
5358 Xtensa TLS relocations.
5360 ENUM
5361 BFD_RELOC_Z80_DISP8
5362 ENUMDOC
5363 8 bit signed offset in (ix+d) or (iy+d).
5365 ENUM
5366 BFD_RELOC_Z8K_DISP7
5367 ENUMDOC
5368 DJNZ offset.
5369 ENUM
5370 BFD_RELOC_Z8K_CALLR
5371 ENUMDOC
5372 CALR offset.
5373 ENUM
5374 BFD_RELOC_Z8K_IMM4L
5375 ENUMDOC
5376 4 bit value.
5378 ENUM
5379 BFD_RELOC_LM32_CALL
5380 ENUMX
5381 BFD_RELOC_LM32_BRANCH
5382 ENUMX
5383 BFD_RELOC_LM32_16_GOT
5384 ENUMX
5385 BFD_RELOC_LM32_GOTOFF_HI16
5386 ENUMX
5387 BFD_RELOC_LM32_GOTOFF_LO16
5388 ENUMX
5389 BFD_RELOC_LM32_COPY
5390 ENUMX
5391 BFD_RELOC_LM32_GLOB_DAT
5392 ENUMX
5393 BFD_RELOC_LM32_JMP_SLOT
5394 ENUMX
5395 BFD_RELOC_LM32_RELATIVE
5396 ENUMDOC
5397 Lattice Mico32 relocations.
5399 ENUM
5400 BFD_RELOC_MACH_O_SECTDIFF
5401 ENUMDOC
5402 Difference between two section addreses. Must be followed by a
5403 BFD_RELOC_MACH_O_PAIR.
5404 ENUM
5405 BFD_RELOC_MACH_O_PAIR
5406 ENUMDOC
5407 Pair of relocation. Contains the first symbol.
5409 ENUM
5410 BFD_RELOC_MACH_O_X86_64_BRANCH32
5411 ENUMX
5412 BFD_RELOC_MACH_O_X86_64_BRANCH8
5413 ENUMDOC
5414 PCREL relocations. They are marked as branch to create PLT entry if
5415 required.
5416 ENUM
5417 BFD_RELOC_MACH_O_X86_64_GOT
5418 ENUMDOC
5419 Used when referencing a GOT entry.
5420 ENUM
5421 BFD_RELOC_MACH_O_X86_64_GOT_LOAD
5422 ENUMDOC
5423 Used when loading a GOT entry with movq. It is specially marked so that
5424 the linker could optimize the movq to a leaq if possible.
5425 ENUM
5426 BFD_RELOC_MACH_O_X86_64_SUBTRACTOR32
5427 ENUMDOC
5428 Symbol will be substracted. Must be followed by a BFD_RELOC_64.
5429 ENUM
5430 BFD_RELOC_MACH_O_X86_64_SUBTRACTOR64
5431 ENUMDOC
5432 Symbol will be substracted. Must be followed by a BFD_RELOC_64.
5433 ENUM
5434 BFD_RELOC_MACH_O_X86_64_PCREL32_1
5435 ENUMDOC
5436 Same as BFD_RELOC_32_PCREL but with an implicit -1 addend.
5437 ENUM
5438 BFD_RELOC_MACH_O_X86_64_PCREL32_2
5439 ENUMDOC
5440 Same as BFD_RELOC_32_PCREL but with an implicit -2 addend.
5441 ENUM
5442 BFD_RELOC_MACH_O_X86_64_PCREL32_4
5443 ENUMDOC
5444 Same as BFD_RELOC_32_PCREL but with an implicit -4 addend.
5446 ENUM
5447 BFD_RELOC_MICROBLAZE_32_LO
5448 ENUMDOC
5449 This is a 32 bit reloc for the microblaze that stores the
5450 low 16 bits of a value
5451 ENUM
5452 BFD_RELOC_MICROBLAZE_32_LO_PCREL
5453 ENUMDOC
5454 This is a 32 bit pc-relative reloc for the microblaze that
5455 stores the low 16 bits of a value
5456 ENUM
5457 BFD_RELOC_MICROBLAZE_32_ROSDA
5458 ENUMDOC
5459 This is a 32 bit reloc for the microblaze that stores a
5460 value relative to the read-only small data area anchor
5461 ENUM
5462 BFD_RELOC_MICROBLAZE_32_RWSDA
5463 ENUMDOC
5464 This is a 32 bit reloc for the microblaze that stores a
5465 value relative to the read-write small data area anchor
5466 ENUM
5467 BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM
5468 ENUMDOC
5469 This is a 32 bit reloc for the microblaze to handle
5470 expressions of the form "Symbol Op Symbol"
5471 ENUM
5472 BFD_RELOC_MICROBLAZE_64_NONE
5473 ENUMDOC
5474 This is a 64 bit reloc that stores the 32 bit pc relative
5475 value in two words (with an imm instruction). No relocation is
5476 done here - only used for relaxing
5477 ENUM
5478 BFD_RELOC_MICROBLAZE_64_GOTPC
5479 ENUMDOC
5480 This is a 64 bit reloc that stores the 32 bit pc relative
5481 value in two words (with an imm instruction). The relocation is
5482 PC-relative GOT offset
5483 ENUM
5484 BFD_RELOC_MICROBLAZE_64_GOT
5485 ENUMDOC
5486 This is a 64 bit reloc that stores the 32 bit pc relative
5487 value in two words (with an imm instruction). The relocation is
5488 GOT offset
5489 ENUM
5490 BFD_RELOC_MICROBLAZE_64_PLT
5491 ENUMDOC
5492 This is a 64 bit reloc that stores the 32 bit pc relative
5493 value in two words (with an imm instruction). The relocation is
5494 PC-relative offset into PLT
5495 ENUM
5496 BFD_RELOC_MICROBLAZE_64_GOTOFF
5497 ENUMDOC
5498 This is a 64 bit reloc that stores the 32 bit GOT relative
5499 value in two words (with an imm instruction). The relocation is
5500 relative offset from _GLOBAL_OFFSET_TABLE_
5501 ENUM
5502 BFD_RELOC_MICROBLAZE_32_GOTOFF
5503 ENUMDOC
5504 This is a 32 bit reloc that stores the 32 bit GOT relative
5505 value in a word. The relocation is relative offset from
5506 _GLOBAL_OFFSET_TABLE_
5507 ENUM
5508 BFD_RELOC_MICROBLAZE_COPY
5509 ENUMDOC
5510 This is used to tell the dynamic linker to copy the value out of
5511 the dynamic object into the runtime process image.
5514 ENDSENUM
5515 BFD_RELOC_UNUSED
5516 CODE_FRAGMENT
5518 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
5522 FUNCTION
5523 bfd_reloc_type_lookup
5524 bfd_reloc_name_lookup
5526 SYNOPSIS
5527 reloc_howto_type *bfd_reloc_type_lookup
5528 (bfd *abfd, bfd_reloc_code_real_type code);
5529 reloc_howto_type *bfd_reloc_name_lookup
5530 (bfd *abfd, const char *reloc_name);
5532 DESCRIPTION
5533 Return a pointer to a howto structure which, when
5534 invoked, will perform the relocation @var{code} on data from the
5535 architecture noted.
5539 reloc_howto_type *
5540 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
5542 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
5545 reloc_howto_type *
5546 bfd_reloc_name_lookup (bfd *abfd, const char *reloc_name)
5548 return BFD_SEND (abfd, reloc_name_lookup, (abfd, reloc_name));
5551 static reloc_howto_type bfd_howto_32 =
5552 HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_dont, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE);
5555 INTERNAL_FUNCTION
5556 bfd_default_reloc_type_lookup
5558 SYNOPSIS
5559 reloc_howto_type *bfd_default_reloc_type_lookup
5560 (bfd *abfd, bfd_reloc_code_real_type code);
5562 DESCRIPTION
5563 Provides a default relocation lookup routine for any architecture.
5567 reloc_howto_type *
5568 bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
5570 switch (code)
5572 case BFD_RELOC_CTOR:
5573 /* The type of reloc used in a ctor, which will be as wide as the
5574 address - so either a 64, 32, or 16 bitter. */
5575 switch (bfd_arch_bits_per_address (abfd))
5577 case 64:
5578 BFD_FAIL ();
5579 case 32:
5580 return &bfd_howto_32;
5581 case 16:
5582 BFD_FAIL ();
5583 default:
5584 BFD_FAIL ();
5586 default:
5587 BFD_FAIL ();
5589 return NULL;
5593 FUNCTION
5594 bfd_get_reloc_code_name
5596 SYNOPSIS
5597 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
5599 DESCRIPTION
5600 Provides a printable name for the supplied relocation code.
5601 Useful mainly for printing error messages.
5604 const char *
5605 bfd_get_reloc_code_name (bfd_reloc_code_real_type code)
5607 if (code > BFD_RELOC_UNUSED)
5608 return 0;
5609 return bfd_reloc_code_real_names[code];
5613 INTERNAL_FUNCTION
5614 bfd_generic_relax_section
5616 SYNOPSIS
5617 bfd_boolean bfd_generic_relax_section
5618 (bfd *abfd,
5619 asection *section,
5620 struct bfd_link_info *,
5621 bfd_boolean *);
5623 DESCRIPTION
5624 Provides default handling for relaxing for back ends which
5625 don't do relaxing.
5628 bfd_boolean
5629 bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
5630 asection *section ATTRIBUTE_UNUSED,
5631 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5632 bfd_boolean *again)
5634 if (link_info->relocatable)
5635 (*link_info->callbacks->einfo)
5636 (_("%P%F: --relax and -r may not be used together\n"));
5638 *again = FALSE;
5639 return TRUE;
5643 INTERNAL_FUNCTION
5644 bfd_generic_gc_sections
5646 SYNOPSIS
5647 bfd_boolean bfd_generic_gc_sections
5648 (bfd *, struct bfd_link_info *);
5650 DESCRIPTION
5651 Provides default handling for relaxing for back ends which
5652 don't do section gc -- i.e., does nothing.
5655 bfd_boolean
5656 bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED,
5657 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5659 return TRUE;
5663 INTERNAL_FUNCTION
5664 bfd_generic_merge_sections
5666 SYNOPSIS
5667 bfd_boolean bfd_generic_merge_sections
5668 (bfd *, struct bfd_link_info *);
5670 DESCRIPTION
5671 Provides default handling for SEC_MERGE section merging for back ends
5672 which don't have SEC_MERGE support -- i.e., does nothing.
5675 bfd_boolean
5676 bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED,
5677 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
5679 return TRUE;
5683 INTERNAL_FUNCTION
5684 bfd_generic_get_relocated_section_contents
5686 SYNOPSIS
5687 bfd_byte *bfd_generic_get_relocated_section_contents
5688 (bfd *abfd,
5689 struct bfd_link_info *link_info,
5690 struct bfd_link_order *link_order,
5691 bfd_byte *data,
5692 bfd_boolean relocatable,
5693 asymbol **symbols);
5695 DESCRIPTION
5696 Provides default handling of relocation effort for back ends
5697 which can't be bothered to do it efficiently.
5701 bfd_byte *
5702 bfd_generic_get_relocated_section_contents (bfd *abfd,
5703 struct bfd_link_info *link_info,
5704 struct bfd_link_order *link_order,
5705 bfd_byte *data,
5706 bfd_boolean relocatable,
5707 asymbol **symbols)
5709 bfd *input_bfd = link_order->u.indirect.section->owner;
5710 asection *input_section = link_order->u.indirect.section;
5711 long reloc_size;
5712 arelent **reloc_vector;
5713 long reloc_count;
5714 bfd_size_type sz;
5716 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
5717 if (reloc_size < 0)
5718 return NULL;
5720 /* Read in the section. */
5721 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
5722 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
5723 return NULL;
5725 if (reloc_size == 0)
5726 return data;
5728 reloc_vector = (arelent **) bfd_malloc (reloc_size);
5729 if (reloc_vector == NULL)
5730 return NULL;
5732 reloc_count = bfd_canonicalize_reloc (input_bfd,
5733 input_section,
5734 reloc_vector,
5735 symbols);
5736 if (reloc_count < 0)
5737 goto error_return;
5739 if (reloc_count > 0)
5741 arelent **parent;
5742 for (parent = reloc_vector; *parent != NULL; parent++)
5744 char *error_message = NULL;
5745 asymbol *symbol;
5746 bfd_reloc_status_type r;
5748 symbol = *(*parent)->sym_ptr_ptr;
5749 if (symbol->section && elf_discarded_section (symbol->section))
5751 bfd_byte *p;
5752 static reloc_howto_type none_howto
5753 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
5754 "unused", FALSE, 0, 0, FALSE);
5756 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
5757 _bfd_clear_contents ((*parent)->howto, input_bfd, p);
5758 (*parent)->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
5759 (*parent)->addend = 0;
5760 (*parent)->howto = &none_howto;
5761 r = bfd_reloc_ok;
5763 else
5764 r = bfd_perform_relocation (input_bfd,
5765 *parent,
5766 data,
5767 input_section,
5768 relocatable ? abfd : NULL,
5769 &error_message);
5771 if (relocatable)
5773 asection *os = input_section->output_section;
5775 /* A partial link, so keep the relocs. */
5776 os->orelocation[os->reloc_count] = *parent;
5777 os->reloc_count++;
5780 if (r != bfd_reloc_ok)
5782 switch (r)
5784 case bfd_reloc_undefined:
5785 if (!((*link_info->callbacks->undefined_symbol)
5786 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
5787 input_bfd, input_section, (*parent)->address,
5788 TRUE)))
5789 goto error_return;
5790 break;
5791 case bfd_reloc_dangerous:
5792 BFD_ASSERT (error_message != NULL);
5793 if (!((*link_info->callbacks->reloc_dangerous)
5794 (link_info, error_message, input_bfd, input_section,
5795 (*parent)->address)))
5796 goto error_return;
5797 break;
5798 case bfd_reloc_overflow:
5799 if (!((*link_info->callbacks->reloc_overflow)
5800 (link_info, NULL,
5801 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
5802 (*parent)->howto->name, (*parent)->addend,
5803 input_bfd, input_section, (*parent)->address)))
5804 goto error_return;
5805 break;
5806 case bfd_reloc_outofrange:
5807 default:
5808 abort ();
5809 break;
5816 free (reloc_vector);
5817 return data;
5819 error_return:
5820 free (reloc_vector);
5821 return NULL;