projects / deliverable / binutils-gdb.git / blob
? search:


7ca3cfdf995589da6a2071d1a571f4aaeca69b3e
[deliverable/binutils-gdb.git] / bfd / reloc.c
1 /* BFD support for handling relocation entries.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3 Written by Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 /*
23 SECTION
24 Relocations
25
26 BFD maintains relocations in much the same way it maintains
27 symbols: they are left alone until required, then read in
28 en-masse and translated into an internal form. A common
29 routine <<bfd_perform_relocation>> acts upon the
30 canonical form to do the fixup.
31
32 Relocations are maintained on a per section basis,
33 while symbols are maintained on a per BFD basis.
34
35 All that a back end has to do to fit the BFD interface is to create
36 a <<struct reloc_cache_entry>> for each relocation
37 in a particular section, and fill in the right bits of the structures.
38
39 @menu
40 @* typedef arelent::
41 @* howto manager::
42 @end menu
43
44 */
45
46 /* DO compile in the reloc_code name table from libbfd.h. */
47 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
48
49 #include "sysdep.h"
50 #include "bfd.h"
51 #include "bfdlink.h"
52 #include "libbfd.h"
53 /*
54 DOCDD
55 INODE
56 typedef arelent, howto manager, Relocations, Relocations
57
58 SUBSECTION
59 typedef arelent
60
61 This is the structure of a relocation entry:
62
63 CODE_FRAGMENT
64 .
65 .typedef enum bfd_reloc_status
66 .{
67 . {* No errors detected. *}
68 . bfd_reloc_ok,
69 .
70 . {* The relocation was performed, but there was an overflow. *}
71 . bfd_reloc_overflow,
72 .
73 . {* The address to relocate was not within the section supplied. *}
74 . bfd_reloc_outofrange,
75 .
76 . {* Used by special functions. *}
77 . bfd_reloc_continue,
78 .
79 . {* Unsupported relocation size requested. *}
80 . bfd_reloc_notsupported,
81 .
82 . {* Unused. *}
83 . bfd_reloc_other,
84 .
85 . {* The symbol to relocate against was undefined. *}
86 . bfd_reloc_undefined,
87 .
88 . {* The relocation was performed, but may not be ok - presently
89 . generated only when linking i960 coff files with i960 b.out
90 . symbols. If this type is returned, the error_message argument
91 . to bfd_perform_relocation will be set. *}
92 . bfd_reloc_dangerous
93 . }
94 . bfd_reloc_status_type;
95 .
96 .
97 .typedef struct reloc_cache_entry
98 .{
99 . {* A pointer into the canonical table of pointers. *}
100 . struct bfd_symbol **sym_ptr_ptr;
101 .
102 . {* offset in section. *}
103 . bfd_size_type address;
104 .
105 . {* addend for relocation value. *}
106 . bfd_vma addend;
107 .
108 . {* Pointer to how to perform the required relocation. *}
109 . reloc_howto_type *howto;
110 .
111 .}
112 .arelent;
113 .
114 */
115
116 /*
117 DESCRIPTION
118
119 Here is a description of each of the fields within an <<arelent>>:
120
121 o <<sym_ptr_ptr>>
122
123 The symbol table pointer points to a pointer to the symbol
124 associated with the relocation request. It is the pointer
125 into the table returned by the back end's
126 <<canonicalize_symtab>> action. @xref{Symbols}. The symbol is
127 referenced through a pointer to a pointer so that tools like
128 the linker can fix up all the symbols of the same name by
129 modifying only one pointer. The relocation routine looks in
130 the symbol and uses the base of the section the symbol is
131 attached to and the value of the symbol as the initial
132 relocation offset. If the symbol pointer is zero, then the
133 section provided is looked up.
134
135 o <<address>>
136
137 The <<address>> field gives the offset in bytes from the base of
138 the section data which owns the relocation record to the first
139 byte of relocatable information. The actual data relocated
140 will be relative to this point; for example, a relocation
141 type which modifies the bottom two bytes of a four byte word
142 would not touch the first byte pointed to in a big endian
143 world.
144
145 o <<addend>>
146
147 The <<addend>> is a value provided by the back end to be added (!)
148 to the relocation offset. Its interpretation is dependent upon
149 the howto. For example, on the 68k the code:
150
151 | char foo[];
152 | main()
153 | {
154 | return foo[0x12345678];
155 | }
156
157 Could be compiled into:
158
159 | linkw fp,#-4
160 | moveb @@#12345678,d0
161 | extbl d0
162 | unlk fp
163 | rts
164
165 This could create a reloc pointing to <<foo>>, but leave the
166 offset in the data, something like:
167
168 |RELOCATION RECORDS FOR [.text]:
169 |offset type value
170 |00000006 32 _foo
171 |
172 |00000000 4e56 fffc ; linkw fp,#-4
173 |00000004 1039 1234 5678 ; moveb @@#12345678,d0
174 |0000000a 49c0 ; extbl d0
175 |0000000c 4e5e ; unlk fp
176 |0000000e 4e75 ; rts
177
178 Using coff and an 88k, some instructions don't have enough
179 space in them to represent the full address range, and
180 pointers have to be loaded in two parts. So you'd get something like:
181
182 | or.u r13,r0,hi16(_foo+0x12345678)
183 | ld.b r2,r13,lo16(_foo+0x12345678)
184 | jmp r1
185
186 This should create two relocs, both pointing to <<_foo>>, and with
187 0x12340000 in their addend field. The data would consist of:
188
189 |RELOCATION RECORDS FOR [.text]:
190 |offset type value
191 |00000002 HVRT16 _foo+0x12340000
192 |00000006 LVRT16 _foo+0x12340000
193 |
194 |00000000 5da05678 ; or.u r13,r0,0x5678
195 |00000004 1c4d5678 ; ld.b r2,r13,0x5678
196 |00000008 f400c001 ; jmp r1
197
198 The relocation routine digs out the value from the data, adds
199 it to the addend to get the original offset, and then adds the
200 value of <<_foo>>. Note that all 32 bits have to be kept around
201 somewhere, to cope with carry from bit 15 to bit 16.
202
203 One further example is the sparc and the a.out format. The
204 sparc has a similar problem to the 88k, in that some
205 instructions don't have room for an entire offset, but on the
206 sparc the parts are created in odd sized lumps. The designers of
207 the a.out format chose to not use the data within the section
208 for storing part of the offset; all the offset is kept within
209 the reloc. Anything in the data should be ignored.
210
211 | save %sp,-112,%sp
212 | sethi %hi(_foo+0x12345678),%g2
213 | ldsb [%g2+%lo(_foo+0x12345678)],%i0
214 | ret
215 | restore
216
217 Both relocs contain a pointer to <<foo>>, and the offsets
218 contain junk.
219
220 |RELOCATION RECORDS FOR [.text]:
221 |offset type value
222 |00000004 HI22 _foo+0x12345678
223 |00000008 LO10 _foo+0x12345678
224 |
225 |00000000 9de3bf90 ; save %sp,-112,%sp
226 |00000004 05000000 ; sethi %hi(_foo+0),%g2
227 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0
228 |0000000c 81c7e008 ; ret
229 |00000010 81e80000 ; restore
230
231 o <<howto>>
232
233 The <<howto>> field can be imagined as a
234 relocation instruction. It is a pointer to a structure which
235 contains information on what to do with all of the other
236 information in the reloc record and data section. A back end
237 would normally have a relocation instruction set and turn
238 relocations into pointers to the correct structure on input -
239 but it would be possible to create each howto field on demand.
240
241 */
242
243 /*
244 SUBSUBSECTION
245 <<enum complain_overflow>>
246
247 Indicates what sort of overflow checking should be done when
248 performing a relocation.
249
250 CODE_FRAGMENT
251 .
252 .enum complain_overflow
253 .{
254 . {* Do not complain on overflow. *}
255 . complain_overflow_dont,
256 .
257 . {* Complain if the value overflows when considered as a signed
258 . number one bit larger than the field. ie. A bitfield of N bits
259 . is allowed to represent -2**n to 2**n-1. *}
260 . complain_overflow_bitfield,
261 .
262 . {* Complain if the value overflows when considered as a signed
263 . number. *}
264 . complain_overflow_signed,
265 .
266 . {* Complain if the value overflows when considered as an
267 . unsigned number. *}
268 . complain_overflow_unsigned
269 .};
270
271 */
272
273 /*
274 SUBSUBSECTION
275 <<reloc_howto_type>>
276
277 The <<reloc_howto_type>> is a structure which contains all the
278 information that libbfd needs to know to tie up a back end's data.
279
280 CODE_FRAGMENT
281 .struct bfd_symbol; {* Forward declaration. *}
282 .
283 .struct reloc_howto_struct
284 .{
285 . {* The type field has mainly a documentary use - the back end can
286 . do what it wants with it, though normally the back end's
287 . external idea of what a reloc number is stored
288 . in this field. For example, a PC relative word relocation
289 . in a coff environment has the type 023 - because that's
290 . what the outside world calls a R_PCRWORD reloc. *}
291 . unsigned int type;
292 .
293 . {* The value the final relocation is shifted right by. This drops
294 . unwanted data from the relocation. *}
295 . unsigned int rightshift;
296 .
297 . {* The size of the item to be relocated. This is *not* a
298 . power-of-two measure. To get the number of bytes operated
299 . on by a type of relocation, use bfd_get_reloc_size. *}
300 . int size;
301 .
302 . {* The number of bits in the item to be relocated. This is used
303 . when doing overflow checking. *}
304 . unsigned int bitsize;
305 .
306 . {* The relocation is relative to the field being relocated. *}
307 . bfd_boolean pc_relative;
308 .
309 . {* The bit position of the reloc value in the destination.
310 . The relocated value is left shifted by this amount. *}
311 . unsigned int bitpos;
312 .
313 . {* What type of overflow error should be checked for when
314 . relocating. *}
315 . enum complain_overflow complain_on_overflow;
316 .
317 . {* If this field is non null, then the supplied function is
318 . called rather than the normal function. This allows really
319 . strange relocation methods to be accommodated (e.g., i960 callj
320 . instructions). *}
321 . bfd_reloc_status_type (*special_function)
322 . (bfd *, arelent *, struct bfd_symbol *, void *, asection *,
323 . bfd *, char **);
324 .
325 . {* The textual name of the relocation type. *}
326 . char *name;
327 .
328 . {* Some formats record a relocation addend in the section contents
329 . rather than with the relocation. For ELF formats this is the
330 . distinction between USE_REL and USE_RELA (though the code checks
331 . for USE_REL == 1/0). The value of this field is TRUE if the
332 . addend is recorded with the section contents; when performing a
333 . partial link (ld -r) the section contents (the data) will be
334 . modified. The value of this field is FALSE if addends are
335 . recorded with the relocation (in arelent.addend); when performing
336 . a partial link the relocation will be modified.
337 . All relocations for all ELF USE_RELA targets should set this field
338 . to FALSE (values of TRUE should be looked on with suspicion).
339 . However, the converse is not true: not all relocations of all ELF
340 . USE_REL targets set this field to TRUE. Why this is so is peculiar
341 . to each particular target. For relocs that aren't used in partial
342 . links (e.g. GOT stuff) it doesn't matter what this is set to. *}
343 . bfd_boolean partial_inplace;
344 .
345 . {* src_mask selects the part of the instruction (or data) to be used
346 . in the relocation sum. If the target relocations don't have an
347 . addend in the reloc, eg. ELF USE_REL, src_mask will normally equal
348 . dst_mask to extract the addend from the section contents. If
349 . relocations do have an addend in the reloc, eg. ELF USE_RELA, this
350 . field should be zero. Non-zero values for ELF USE_RELA targets are
351 . bogus as in those cases the value in the dst_mask part of the
352 . section contents should be treated as garbage. *}
353 . bfd_vma src_mask;
354 .
355 . {* dst_mask selects which parts of the instruction (or data) are
356 . replaced with a relocated value. *}
357 . bfd_vma dst_mask;
358 .
359 . {* When some formats create PC relative instructions, they leave
360 . the value of the pc of the place being relocated in the offset
361 . slot of the instruction, so that a PC relative relocation can
362 . be made just by adding in an ordinary offset (e.g., sun3 a.out).
363 . Some formats leave the displacement part of an instruction
364 . empty (e.g., m88k bcs); this flag signals the fact. *}
365 . bfd_boolean pcrel_offset;
366 .};
367 .
368 */
369
370 /*
371 FUNCTION
372 The HOWTO Macro
373
374 DESCRIPTION
375 The HOWTO define is horrible and will go away.
376
377 .#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
378 . { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }
379
380 DESCRIPTION
381 And will be replaced with the totally magic way. But for the
382 moment, we are compatible, so do it this way.
383
384 .#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \
385 . HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \
386 . NAME, FALSE, 0, 0, IN)
387 .
388
389 DESCRIPTION
390 This is used to fill in an empty howto entry in an array.
391
392 .#define EMPTY_HOWTO(C) \
393 . HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \
394 . NULL, FALSE, 0, 0, FALSE)
395 .
396
397 DESCRIPTION
398 Helper routine to turn a symbol into a relocation value.
399
400 .#define HOWTO_PREPARE(relocation, symbol) \
401 . { \
402 . if (symbol != NULL) \
403 . { \
404 . if (bfd_is_com_section (symbol->section)) \
405 . { \
406 . relocation = 0; \
407 . } \
408 . else \
409 . { \
410 . relocation = symbol->value; \
411 . } \
412 . } \
413 . }
414 .
415 */
416
417 /*
418 FUNCTION
419 bfd_get_reloc_size
420
421 SYNOPSIS
422 unsigned int bfd_get_reloc_size (reloc_howto_type *);
423
424 DESCRIPTION
425 For a reloc_howto_type that operates on a fixed number of bytes,
426 this returns the number of bytes operated on.
427 */
428
429 unsigned int
430 bfd_get_reloc_size (reloc_howto_type *howto)
431 {
432 switch (howto->size)
433 {
434 case 0: return 1;
435 case 1: return 2;
436 case 2: return 4;
437 case 3: return 0;
438 case 4: return 8;
439 case 8: return 16;
440 case -2: return 4;
441 default: abort ();
442 }
443 }
444
445 /*
446 TYPEDEF
447 arelent_chain
448
449 DESCRIPTION
450
451 How relocs are tied together in an <<asection>>:
452
453 .typedef struct relent_chain
454 .{
455 . arelent relent;
456 . struct relent_chain *next;
457 .}
458 .arelent_chain;
459 .
460 */
461
462 /* N_ONES produces N one bits, without overflowing machine arithmetic. */
463 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
464
465 /*
466 FUNCTION
467 bfd_check_overflow
468
469 SYNOPSIS
470 bfd_reloc_status_type bfd_check_overflow
471 (enum complain_overflow how,
472 unsigned int bitsize,
473 unsigned int rightshift,
474 unsigned int addrsize,
475 bfd_vma relocation);
476
477 DESCRIPTION
478 Perform overflow checking on @var{relocation} which has
479 @var{bitsize} significant bits and will be shifted right by
480 @var{rightshift} bits, on a machine with addresses containing
481 @var{addrsize} significant bits. The result is either of
482 @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
483
484 */
485
486 bfd_reloc_status_type
487 bfd_check_overflow (enum complain_overflow how,
488 unsigned int bitsize,
489 unsigned int rightshift,
490 unsigned int addrsize,
491 bfd_vma relocation)
492 {
493 bfd_vma fieldmask, addrmask, signmask, ss, a;
494 bfd_reloc_status_type flag = bfd_reloc_ok;
495
496 /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
497 we'll be permissive: extra bits in the field mask will
498 automatically extend the address mask for purposes of the
499 overflow check. */
500 fieldmask = N_ONES (bitsize);
501 signmask = ~fieldmask;
502 addrmask = N_ONES (addrsize) | (fieldmask << rightshift);
503 a = (relocation & addrmask) >> rightshift;
504
505 switch (how)
506 {
507 case complain_overflow_dont:
508 break;
509
510 case complain_overflow_signed:
511 /* If any sign bits are set, all sign bits must be set. That
512 is, A must be a valid negative address after shifting. */
513 signmask = ~ (fieldmask >> 1);
514 /* Fall thru */
515
516 case complain_overflow_bitfield:
517 /* Bitfields are sometimes signed, sometimes unsigned. We
518 explicitly allow an address wrap too, which means a bitfield
519 of n bits is allowed to store -2**n to 2**n-1. Thus overflow
520 if the value has some, but not all, bits set outside the
521 field. */
522 ss = a & signmask;
523 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
524 flag = bfd_reloc_overflow;
525 break;
526
527 case complain_overflow_unsigned:
528 /* We have an overflow if the address does not fit in the field. */
529 if ((a & signmask) != 0)
530 flag = bfd_reloc_overflow;
531 break;
532
533 default:
534 abort ();
535 }
536
537 return flag;
538 }
539
540 /*
541 FUNCTION
542 bfd_perform_relocation
543
544 SYNOPSIS
545 bfd_reloc_status_type bfd_perform_relocation
546 (bfd *abfd,
547 arelent *reloc_entry,
548 void *data,
549 asection *input_section,
550 bfd *output_bfd,
551 char **error_message);
552
553 DESCRIPTION
554 If @var{output_bfd} is supplied to this function, the
555 generated image will be relocatable; the relocations are
556 copied to the output file after they have been changed to
557 reflect the new state of the world. There are two ways of
558 reflecting the results of partial linkage in an output file:
559 by modifying the output data in place, and by modifying the
560 relocation record. Some native formats (e.g., basic a.out and
561 basic coff) have no way of specifying an addend in the
562 relocation type, so the addend has to go in the output data.
563 This is no big deal since in these formats the output data
564 slot will always be big enough for the addend. Complex reloc
565 types with addends were invented to solve just this problem.
566 The @var{error_message} argument is set to an error message if
567 this return @code{bfd_reloc_dangerous}.
568
569 */
570
571 bfd_reloc_status_type
572 bfd_perform_relocation (bfd *abfd,
573 arelent *reloc_entry,
574 void *data,
575 asection *input_section,
576 bfd *output_bfd,
577 char **error_message)
578 {
579 bfd_vma relocation;
580 bfd_reloc_status_type flag = bfd_reloc_ok;
581 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
582 bfd_vma output_base = 0;
583 reloc_howto_type *howto = reloc_entry->howto;
584 asection *reloc_target_output_section;
585 asymbol *symbol;
586
587 symbol = *(reloc_entry->sym_ptr_ptr);
588 if (bfd_is_abs_section (symbol->section)
589 && output_bfd != NULL)
590 {
591 reloc_entry->address += input_section->output_offset;
592 return bfd_reloc_ok;
593 }
594
595 /* If we are not producing relocatable output, return an error if
596 the symbol is not defined. An undefined weak symbol is
597 considered to have a value of zero (SVR4 ABI, p. 4-27). */
598 if (bfd_is_und_section (symbol->section)
599 && (symbol->flags & BSF_WEAK) == 0
600 && output_bfd == NULL)
601 flag = bfd_reloc_undefined;
602
603 /* If there is a function supplied to handle this relocation type,
604 call it. It'll return `bfd_reloc_continue' if further processing
605 can be done. */
606 if (howto->special_function)
607 {
608 bfd_reloc_status_type cont;
609 cont = howto->special_function (abfd, reloc_entry, symbol, data,
610 input_section, output_bfd,
611 error_message);
612 if (cont != bfd_reloc_continue)
613 return cont;
614 }
615
616 /* Is the address of the relocation really within the section? */
617 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
618 return bfd_reloc_outofrange;
619
620 /* Work out which section the relocation is targeted at and the
621 initial relocation command value. */
622
623 /* Get symbol value. (Common symbols are special.) */
624 if (bfd_is_com_section (symbol->section))
625 relocation = 0;
626 else
627 relocation = symbol->value;
628
629 reloc_target_output_section = symbol->section->output_section;
630
631 /* Convert input-section-relative symbol value to absolute. */
632 if ((output_bfd && ! howto->partial_inplace)
633 || reloc_target_output_section == NULL)
634 output_base = 0;
635 else
636 output_base = reloc_target_output_section->vma;
637
638 relocation += output_base + symbol->section->output_offset;
639
640 /* Add in supplied addend. */
641 relocation += reloc_entry->addend;
642
643 /* Here the variable relocation holds the final address of the
644 symbol we are relocating against, plus any addend. */
645
646 if (howto->pc_relative)
647 {
648 /* This is a PC relative relocation. We want to set RELOCATION
649 to the distance between the address of the symbol and the
650 location. RELOCATION is already the address of the symbol.
651
652 We start by subtracting the address of the section containing
653 the location.
654
655 If pcrel_offset is set, we must further subtract the position
656 of the location within the section. Some targets arrange for
657 the addend to be the negative of the position of the location
658 within the section; for example, i386-aout does this. For
659 i386-aout, pcrel_offset is FALSE. Some other targets do not
660 include the position of the location; for example, m88kbcs,
661 or ELF. For those targets, pcrel_offset is TRUE.
662
663 If we are producing relocatable output, then we must ensure
664 that this reloc will be correctly computed when the final
665 relocation is done. If pcrel_offset is FALSE we want to wind
666 up with the negative of the location within the section,
667 which means we must adjust the existing addend by the change
668 in the location within the section. If pcrel_offset is TRUE
669 we do not want to adjust the existing addend at all.
670
671 FIXME: This seems logical to me, but for the case of
672 producing relocatable output it is not what the code
673 actually does. I don't want to change it, because it seems
674 far too likely that something will break. */
675
676 relocation -=
677 input_section->output_section->vma + input_section->output_offset;
678
679 if (howto->pcrel_offset)
680 relocation -= reloc_entry->address;
681 }
682
683 if (output_bfd != NULL)
684 {
685 if (! howto->partial_inplace)
686 {
687 /* This is a partial relocation, and we want to apply the relocation
688 to the reloc entry rather than the raw data. Modify the reloc
689 inplace to reflect what we now know. */
690 reloc_entry->addend = relocation;
691 reloc_entry->address += input_section->output_offset;
692 return flag;
693 }
694 else
695 {
696 /* This is a partial relocation, but inplace, so modify the
697 reloc record a bit.
698
699 If we've relocated with a symbol with a section, change
700 into a ref to the section belonging to the symbol. */
701
702 reloc_entry->address += input_section->output_offset;
703
704 /* WTF?? */
705 if (abfd->xvec->flavour == bfd_target_coff_flavour
706 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
707 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
708 {
709 /* For m68k-coff, the addend was being subtracted twice during
710 relocation with -r. Removing the line below this comment
711 fixes that problem; see PR 2953.
712
713 However, Ian wrote the following, regarding removing the line below,
714 which explains why it is still enabled: --djm
715
716 If you put a patch like that into BFD you need to check all the COFF
717 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
718 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
719 problem in a different way. There may very well be a reason that the
720 code works as it does.
721
722 Hmmm. The first obvious point is that bfd_perform_relocation should
723 not have any tests that depend upon the flavour. It's seem like
724 entirely the wrong place for such a thing. The second obvious point
725 is that the current code ignores the reloc addend when producing
726 relocatable output for COFF. That's peculiar. In fact, I really
727 have no idea what the point of the line you want to remove is.
728
729 A typical COFF reloc subtracts the old value of the symbol and adds in
730 the new value to the location in the object file (if it's a pc
731 relative reloc it adds the difference between the symbol value and the
732 location). When relocating we need to preserve that property.
733
734 BFD handles this by setting the addend to the negative of the old
735 value of the symbol. Unfortunately it handles common symbols in a
736 non-standard way (it doesn't subtract the old value) but that's a
737 different story (we can't change it without losing backward
738 compatibility with old object files) (coff-i386 does subtract the old
739 value, to be compatible with existing coff-i386 targets, like SCO).
740
741 So everything works fine when not producing relocatable output. When
742 we are producing relocatable output, logically we should do exactly
743 what we do when not producing relocatable output. Therefore, your
744 patch is correct. In fact, it should probably always just set
745 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
746 add the value into the object file. This won't hurt the COFF code,
747 which doesn't use the addend; I'm not sure what it will do to other
748 formats (the thing to check for would be whether any formats both use
749 the addend and set partial_inplace).
750
751 When I wanted to make coff-i386 produce relocatable output, I ran
752 into the problem that you are running into: I wanted to remove that
753 line. Rather than risk it, I made the coff-i386 relocs use a special
754 function; it's coff_i386_reloc in coff-i386.c. The function
755 specifically adds the addend field into the object file, knowing that
756 bfd_perform_relocation is not going to. If you remove that line, then
757 coff-i386.c will wind up adding the addend field in twice. It's
758 trivial to fix; it just needs to be done.
759
760 The problem with removing the line is just that it may break some
761 working code. With BFD it's hard to be sure of anything. The right
762 way to deal with this is simply to build and test at least all the
763 supported COFF targets. It should be straightforward if time and disk
764 space consuming. For each target:
765 1) build the linker
766 2) generate some executable, and link it using -r (I would
767 probably use paranoia.o and link against newlib/libc.a, which
768 for all the supported targets would be available in
769 /usr/cygnus/progressive/H-host/target/lib/libc.a).
770 3) make the change to reloc.c
771 4) rebuild the linker
772 5) repeat step 2
773 6) if the resulting object files are the same, you have at least
774 made it no worse
775 7) if they are different you have to figure out which version is
776 right
777 */
778 relocation -= reloc_entry->addend;
779 reloc_entry->addend = 0;
780 }
781 else
782 {
783 reloc_entry->addend = relocation;
784 }
785 }
786 }
787 else
788 {
789 reloc_entry->addend = 0;
790 }
791
792 /* FIXME: This overflow checking is incomplete, because the value
793 might have overflowed before we get here. For a correct check we
794 need to compute the value in a size larger than bitsize, but we
795 can't reasonably do that for a reloc the same size as a host
796 machine word.
797 FIXME: We should also do overflow checking on the result after
798 adding in the value contained in the object file. */
799 if (howto->complain_on_overflow != complain_overflow_dont
800 && flag == bfd_reloc_ok)
801 flag = bfd_check_overflow (howto->complain_on_overflow,
802 howto->bitsize,
803 howto->rightshift,
804 bfd_arch_bits_per_address (abfd),
805 relocation);
806
807 /* Either we are relocating all the way, or we don't want to apply
808 the relocation to the reloc entry (probably because there isn't
809 any room in the output format to describe addends to relocs). */
810
811 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
812 (OSF version 1.3, compiler version 3.11). It miscompiles the
813 following program:
814
815 struct str
816 {
817 unsigned int i0;
818 } s = { 0 };
819
820 int
821 main ()
822 {
823 unsigned long x;
824
825 x = 0x100000000;
826 x <<= (unsigned long) s.i0;
827 if (x == 0)
828 printf ("failed\n");
829 else
830 printf ("succeeded (%lx)\n", x);
831 }
832 */
833
834 relocation >>= (bfd_vma) howto->rightshift;
835
836 /* Shift everything up to where it's going to be used. */
837 relocation <<= (bfd_vma) howto->bitpos;
838
839 /* Wait for the day when all have the mask in them. */
840
841 /* What we do:
842 i instruction to be left alone
843 o offset within instruction
844 r relocation offset to apply
845 S src mask
846 D dst mask
847 N ~dst mask
848 A part 1
849 B part 2
850 R result
851
852 Do this:
853 (( i i i i i o o o o o from bfd_get<size>
854 and S S S S S) to get the size offset we want
855 + r r r r r r r r r r) to get the final value to place
856 and D D D D D to chop to right size
857 -----------------------
858 = A A A A A
859 And this:
860 ( i i i i i o o o o o from bfd_get<size>
861 and N N N N N ) get instruction
862 -----------------------
863 = B B B B B
864
865 And then:
866 ( B B B B B
867 or A A A A A)
868 -----------------------
869 = R R R R R R R R R R put into bfd_put<size>
870 */
871
872 #define DOIT(x) \
873 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
874
875 switch (howto->size)
876 {
877 case 0:
878 {
879 char x = bfd_get_8 (abfd, (char *) data + octets);
880 DOIT (x);
881 bfd_put_8 (abfd, x, (unsigned char *) data + octets);
882 }
883 break;
884
885 case 1:
886 {
887 short x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
888 DOIT (x);
889 bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets);
890 }
891 break;
892 case 2:
893 {
894 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
895 DOIT (x);
896 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
897 }
898 break;
899 case -2:
900 {
901 long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
902 relocation = -relocation;
903 DOIT (x);
904 bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
905 }
906 break;
907
908 case -1:
909 {
910 long x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
911 relocation = -relocation;
912 DOIT (x);
913 bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
914 }
915 break;
916
917 case 3:
918 /* Do nothing */
919 break;
920
921 case 4:
922 #ifdef BFD64
923 {
924 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets);
925 DOIT (x);
926 bfd_put_64 (abfd, x, (bfd_byte *) data + octets);
927 }
928 #else
929 abort ();
930 #endif
931 break;
932 default:
933 return bfd_reloc_other;
934 }
935
936 return flag;
937 }
938
939 /*
940 FUNCTION
941 bfd_install_relocation
942
943 SYNOPSIS
944 bfd_reloc_status_type bfd_install_relocation
945 (bfd *abfd,
946 arelent *reloc_entry,
947 void *data, bfd_vma data_start,
948 asection *input_section,
949 char **error_message);
950
951 DESCRIPTION
952 This looks remarkably like <<bfd_perform_relocation>>, except it
953 does not expect that the section contents have been filled in.
954 I.e., it's suitable for use when creating, rather than applying
955 a relocation.
956
957 For now, this function should be considered reserved for the
958 assembler.
959 */
960
961 bfd_reloc_status_type
962 bfd_install_relocation (bfd *abfd,
963 arelent *reloc_entry,
964 void *data_start,
965 bfd_vma data_start_offset,
966 asection *input_section,
967 char **error_message)
968 {
969 bfd_vma relocation;
970 bfd_reloc_status_type flag = bfd_reloc_ok;
971 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
972 bfd_vma output_base = 0;
973 reloc_howto_type *howto = reloc_entry->howto;
974 asection *reloc_target_output_section;
975 asymbol *symbol;
976 bfd_byte *data;
977
978 symbol = *(reloc_entry->sym_ptr_ptr);
979 if (bfd_is_abs_section (symbol->section))
980 {
981 reloc_entry->address += input_section->output_offset;
982 return bfd_reloc_ok;
983 }
984
985 /* If there is a function supplied to handle this relocation type,
986 call it. It'll return `bfd_reloc_continue' if further processing
987 can be done. */
988 if (howto->special_function)
989 {
990 bfd_reloc_status_type cont;
991
992 /* XXX - The special_function calls haven't been fixed up to deal
993 with creating new relocations and section contents. */
994 cont = howto->special_function (abfd, reloc_entry, symbol,
995 /* XXX - Non-portable! */
996 ((bfd_byte *) data_start
997 - data_start_offset),
998 input_section, abfd, error_message);
999 if (cont != bfd_reloc_continue)
1000 return cont;
1001 }
1002
1003 /* Is the address of the relocation really within the section? */
1004 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1005 return bfd_reloc_outofrange;
1006
1007 /* Work out which section the relocation is targeted at and the
1008 initial relocation command value. */
1009
1010 /* Get symbol value. (Common symbols are special.) */
1011 if (bfd_is_com_section (symbol->section))
1012 relocation = 0;
1013 else
1014 relocation = symbol->value;
1015
1016 reloc_target_output_section = symbol->section->output_section;
1017
1018 /* Convert input-section-relative symbol value to absolute. */
1019 if (! howto->partial_inplace)
1020 output_base = 0;
1021 else
1022 output_base = reloc_target_output_section->vma;
1023
1024 relocation += output_base + symbol->section->output_offset;
1025
1026 /* Add in supplied addend. */
1027 relocation += reloc_entry->addend;
1028
1029 /* Here the variable relocation holds the final address of the
1030 symbol we are relocating against, plus any addend. */
1031
1032 if (howto->pc_relative)
1033 {
1034 /* This is a PC relative relocation. We want to set RELOCATION
1035 to the distance between the address of the symbol and the
1036 location. RELOCATION is already the address of the symbol.
1037
1038 We start by subtracting the address of the section containing
1039 the location.
1040
1041 If pcrel_offset is set, we must further subtract the position
1042 of the location within the section. Some targets arrange for
1043 the addend to be the negative of the position of the location
1044 within the section; for example, i386-aout does this. For
1045 i386-aout, pcrel_offset is FALSE. Some other targets do not
1046 include the position of the location; for example, m88kbcs,
1047 or ELF. For those targets, pcrel_offset is TRUE.
1048
1049 If we are producing relocatable output, then we must ensure
1050 that this reloc will be correctly computed when the final
1051 relocation is done. If pcrel_offset is FALSE we want to wind
1052 up with the negative of the location within the section,
1053 which means we must adjust the existing addend by the change
1054 in the location within the section. If pcrel_offset is TRUE
1055 we do not want to adjust the existing addend at all.
1056
1057 FIXME: This seems logical to me, but for the case of
1058 producing relocatable output it is not what the code
1059 actually does. I don't want to change it, because it seems
1060 far too likely that something will break. */
1061
1062 relocation -=
1063 input_section->output_section->vma + input_section->output_offset;
1064
1065 if (howto->pcrel_offset && howto->partial_inplace)
1066 relocation -= reloc_entry->address;
1067 }
1068
1069 if (! howto->partial_inplace)
1070 {
1071 /* This is a partial relocation, and we want to apply the relocation
1072 to the reloc entry rather than the raw data. Modify the reloc
1073 inplace to reflect what we now know. */
1074 reloc_entry->addend = relocation;
1075 reloc_entry->address += input_section->output_offset;
1076 return flag;
1077 }
1078 else
1079 {
1080 /* This is a partial relocation, but inplace, so modify the
1081 reloc record a bit.
1082
1083 If we've relocated with a symbol with a section, change
1084 into a ref to the section belonging to the symbol. */
1085 reloc_entry->address += input_section->output_offset;
1086
1087 /* WTF?? */
1088 if (abfd->xvec->flavour == bfd_target_coff_flavour
1089 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1090 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1091 {
1092
1093 /* For m68k-coff, the addend was being subtracted twice during
1094 relocation with -r. Removing the line below this comment
1095 fixes that problem; see PR 2953.
1096
1097 However, Ian wrote the following, regarding removing the line below,
1098 which explains why it is still enabled: --djm
1099
1100 If you put a patch like that into BFD you need to check all the COFF
1101 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
1102 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1103 problem in a different way. There may very well be a reason that the
1104 code works as it does.
1105
1106 Hmmm. The first obvious point is that bfd_install_relocation should
1107 not have any tests that depend upon the flavour. It's seem like
1108 entirely the wrong place for such a thing. The second obvious point
1109 is that the current code ignores the reloc addend when producing
1110 relocatable output for COFF. That's peculiar. In fact, I really
1111 have no idea what the point of the line you want to remove is.
1112
1113 A typical COFF reloc subtracts the old value of the symbol and adds in
1114 the new value to the location in the object file (if it's a pc
1115 relative reloc it adds the difference between the symbol value and the
1116 location). When relocating we need to preserve that property.
1117
1118 BFD handles this by setting the addend to the negative of the old
1119 value of the symbol. Unfortunately it handles common symbols in a
1120 non-standard way (it doesn't subtract the old value) but that's a
1121 different story (we can't change it without losing backward
1122 compatibility with old object files) (coff-i386 does subtract the old
1123 value, to be compatible with existing coff-i386 targets, like SCO).
1124
1125 So everything works fine when not producing relocatable output. When
1126 we are producing relocatable output, logically we should do exactly
1127 what we do when not producing relocatable output. Therefore, your
1128 patch is correct. In fact, it should probably always just set
1129 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1130 add the value into the object file. This won't hurt the COFF code,
1131 which doesn't use the addend; I'm not sure what it will do to other
1132 formats (the thing to check for would be whether any formats both use
1133 the addend and set partial_inplace).
1134
1135 When I wanted to make coff-i386 produce relocatable output, I ran
1136 into the problem that you are running into: I wanted to remove that
1137 line. Rather than risk it, I made the coff-i386 relocs use a special
1138 function; it's coff_i386_reloc in coff-i386.c. The function
1139 specifically adds the addend field into the object file, knowing that
1140 bfd_install_relocation is not going to. If you remove that line, then
1141 coff-i386.c will wind up adding the addend field in twice. It's
1142 trivial to fix; it just needs to be done.
1143
1144 The problem with removing the line is just that it may break some
1145 working code. With BFD it's hard to be sure of anything. The right
1146 way to deal with this is simply to build and test at least all the
1147 supported COFF targets. It should be straightforward if time and disk
1148 space consuming. For each target:
1149 1) build the linker
1150 2) generate some executable, and link it using -r (I would
1151 probably use paranoia.o and link against newlib/libc.a, which
1152 for all the supported targets would be available in
1153 /usr/cygnus/progressive/H-host/target/lib/libc.a).
1154 3) make the change to reloc.c
1155 4) rebuild the linker
1156 5) repeat step 2
1157 6) if the resulting object files are the same, you have at least
1158 made it no worse
1159 7) if they are different you have to figure out which version is
1160 right. */
1161 relocation -= reloc_entry->addend;
1162 /* FIXME: There should be no target specific code here... */
1163 if (strcmp (abfd->xvec->name, "coff-z8k") != 0)
1164 reloc_entry->addend = 0;
1165 }
1166 else
1167 {
1168 reloc_entry->addend = relocation;
1169 }
1170 }
1171
1172 /* FIXME: This overflow checking is incomplete, because the value
1173 might have overflowed before we get here. For a correct check we
1174 need to compute the value in a size larger than bitsize, but we
1175 can't reasonably do that for a reloc the same size as a host
1176 machine word.
1177 FIXME: We should also do overflow checking on the result after
1178 adding in the value contained in the object file. */
1179 if (howto->complain_on_overflow != complain_overflow_dont)
1180 flag = bfd_check_overflow (howto->complain_on_overflow,
1181 howto->bitsize,
1182 howto->rightshift,
1183 bfd_arch_bits_per_address (abfd),
1184 relocation);
1185
1186 /* Either we are relocating all the way, or we don't want to apply
1187 the relocation to the reloc entry (probably because there isn't
1188 any room in the output format to describe addends to relocs). */
1189
1190 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1191 (OSF version 1.3, compiler version 3.11). It miscompiles the
1192 following program:
1193
1194 struct str
1195 {
1196 unsigned int i0;
1197 } s = { 0 };
1198
1199 int
1200 main ()
1201 {
1202 unsigned long x;
1203
1204 x = 0x100000000;
1205 x <<= (unsigned long) s.i0;
1206 if (x == 0)
1207 printf ("failed\n");
1208 else
1209 printf ("succeeded (%lx)\n", x);
1210 }
1211 */
1212
1213 relocation >>= (bfd_vma) howto->rightshift;
1214
1215 /* Shift everything up to where it's going to be used. */
1216 relocation <<= (bfd_vma) howto->bitpos;
1217
1218 /* Wait for the day when all have the mask in them. */
1219
1220 /* What we do:
1221 i instruction to be left alone
1222 o offset within instruction
1223 r relocation offset to apply
1224 S src mask
1225 D dst mask
1226 N ~dst mask
1227 A part 1
1228 B part 2
1229 R result
1230
1231 Do this:
1232 (( i i i i i o o o o o from bfd_get<size>
1233 and S S S S S) to get the size offset we want
1234 + r r r r r r r r r r) to get the final value to place
1235 and D D D D D to chop to right size
1236 -----------------------
1237 = A A A A A
1238 And this:
1239 ( i i i i i o o o o o from bfd_get<size>
1240 and N N N N N ) get instruction
1241 -----------------------
1242 = B B B B B
1243
1244 And then:
1245 ( B B B B B
1246 or A A A A A)
1247 -----------------------
1248 = R R R R R R R R R R put into bfd_put<size>
1249 */
1250
1251 #define DOIT(x) \
1252 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
1253
1254 data = (bfd_byte *) data_start + (octets - data_start_offset);
1255
1256 switch (howto->size)
1257 {
1258 case 0:
1259 {
1260 char x = bfd_get_8 (abfd, data);
1261 DOIT (x);
1262 bfd_put_8 (abfd, x, data);
1263 }
1264 break;
1265
1266 case 1:
1267 {
1268 short x = bfd_get_16 (abfd, data);
1269 DOIT (x);
1270 bfd_put_16 (abfd, (bfd_vma) x, data);
1271 }
1272 break;
1273 case 2:
1274 {
1275 long x = bfd_get_32 (abfd, data);
1276 DOIT (x);
1277 bfd_put_32 (abfd, (bfd_vma) x, data);
1278 }
1279 break;
1280 case -2:
1281 {
1282 long x = bfd_get_32 (abfd, data);
1283 relocation = -relocation;
1284 DOIT (x);
1285 bfd_put_32 (abfd, (bfd_vma) x, data);
1286 }
1287 break;
1288
1289 case 3:
1290 /* Do nothing */
1291 break;
1292
1293 case 4:
1294 {
1295 bfd_vma x = bfd_get_64 (abfd, data);
1296 DOIT (x);
1297 bfd_put_64 (abfd, x, data);
1298 }
1299 break;
1300 default:
1301 return bfd_reloc_other;
1302 }
1303
1304 return flag;
1305 }
1306
1307 /* This relocation routine is used by some of the backend linkers.
1308 They do not construct asymbol or arelent structures, so there is no
1309 reason for them to use bfd_perform_relocation. Also,
1310 bfd_perform_relocation is so hacked up it is easier to write a new
1311 function than to try to deal with it.
1312
1313 This routine does a final relocation. Whether it is useful for a
1314 relocatable link depends upon how the object format defines
1315 relocations.
1316
1317 FIXME: This routine ignores any special_function in the HOWTO,
1318 since the existing special_function values have been written for
1319 bfd_perform_relocation.
1320
1321 HOWTO is the reloc howto information.
1322 INPUT_BFD is the BFD which the reloc applies to.
1323 INPUT_SECTION is the section which the reloc applies to.
1324 CONTENTS is the contents of the section.
1325 ADDRESS is the address of the reloc within INPUT_SECTION.
1326 VALUE is the value of the symbol the reloc refers to.
1327 ADDEND is the addend of the reloc. */
1328
1329 bfd_reloc_status_type
1330 _bfd_final_link_relocate (reloc_howto_type *howto,
1331 bfd *input_bfd,
1332 asection *input_section,
1333 bfd_byte *contents,
1334 bfd_vma address,
1335 bfd_vma value,
1336 bfd_vma addend)
1337 {
1338 bfd_vma relocation;
1339
1340 /* Sanity check the address. */
1341 if (address > bfd_get_section_limit (input_bfd, input_section))
1342 return bfd_reloc_outofrange;
1343
1344 /* This function assumes that we are dealing with a basic relocation
1345 against a symbol. We want to compute the value of the symbol to
1346 relocate to. This is just VALUE, the value of the symbol, plus
1347 ADDEND, any addend associated with the reloc. */
1348 relocation = value + addend;
1349
1350 /* If the relocation is PC relative, we want to set RELOCATION to
1351 the distance between the symbol (currently in RELOCATION) and the
1352 location we are relocating. Some targets (e.g., i386-aout)
1353 arrange for the contents of the section to be the negative of the
1354 offset of the location within the section; for such targets
1355 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
1356 simply leave the contents of the section as zero; for such
1357 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
1358 need to subtract out the offset of the location within the
1359 section (which is just ADDRESS). */
1360 if (howto->pc_relative)
1361 {
1362 relocation -= (input_section->output_section->vma
1363 + input_section->output_offset);
1364 if (howto->pcrel_offset)
1365 relocation -= address;
1366 }
1367
1368 return _bfd_relocate_contents (howto, input_bfd, relocation,
1369 contents + address);
1370 }
1371
1372 /* Relocate a given location using a given value and howto. */
1373
1374 bfd_reloc_status_type
1375 _bfd_relocate_contents (reloc_howto_type *howto,
1376 bfd *input_bfd,
1377 bfd_vma relocation,
1378 bfd_byte *location)
1379 {
1380 int size;
1381 bfd_vma x = 0;
1382 bfd_reloc_status_type flag;
1383 unsigned int rightshift = howto->rightshift;
1384 unsigned int bitpos = howto->bitpos;
1385
1386 /* If the size is negative, negate RELOCATION. This isn't very
1387 general. */
1388 if (howto->size < 0)
1389 relocation = -relocation;
1390
1391 /* Get the value we are going to relocate. */
1392 size = bfd_get_reloc_size (howto);
1393 switch (size)
1394 {
1395 default:
1396 case 0:
1397 abort ();
1398 case 1:
1399 x = bfd_get_8 (input_bfd, location);
1400 break;
1401 case 2:
1402 x = bfd_get_16 (input_bfd, location);
1403 break;
1404 case 4:
1405 x = bfd_get_32 (input_bfd, location);
1406 break;
1407 case 8:
1408 #ifdef BFD64
1409 x = bfd_get_64 (input_bfd, location);
1410 #else
1411 abort ();
1412 #endif
1413 break;
1414 }
1415
1416 /* Check for overflow. FIXME: We may drop bits during the addition
1417 which we don't check for. We must either check at every single
1418 operation, which would be tedious, or we must do the computations
1419 in a type larger than bfd_vma, which would be inefficient. */
1420 flag = bfd_reloc_ok;
1421 if (howto->complain_on_overflow != complain_overflow_dont)
1422 {
1423 bfd_vma addrmask, fieldmask, signmask, ss;
1424 bfd_vma a, b, sum;
1425
1426 /* Get the values to be added together. For signed and unsigned
1427 relocations, we assume that all values should be truncated to
1428 the size of an address. For bitfields, all the bits matter.
1429 See also bfd_check_overflow. */
1430 fieldmask = N_ONES (howto->bitsize);
1431 signmask = ~fieldmask;
1432 addrmask = (N_ONES (bfd_arch_bits_per_address (input_bfd))
1433 | (fieldmask << rightshift));
1434 a = (relocation & addrmask) >> rightshift;
1435 b = (x & howto->src_mask & addrmask) >> bitpos;
1436 addrmask >>= rightshift;
1437
1438 switch (howto->complain_on_overflow)
1439 {
1440 case complain_overflow_signed:
1441 /* If any sign bits are set, all sign bits must be set.
1442 That is, A must be a valid negative address after
1443 shifting. */
1444 signmask = ~(fieldmask >> 1);
1445 /* Fall thru */
1446
1447 case complain_overflow_bitfield:
1448 /* Much like the signed check, but for a field one bit
1449 wider. We allow a bitfield to represent numbers in the
1450 range -2**n to 2**n-1, where n is the number of bits in the
1451 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
1452 can't overflow, which is exactly what we want. */
1453 ss = a & signmask;
1454 if (ss != 0 && ss != (addrmask & signmask))
1455 flag = bfd_reloc_overflow;
1456
1457 /* We only need this next bit of code if the sign bit of B
1458 is below the sign bit of A. This would only happen if
1459 SRC_MASK had fewer bits than BITSIZE. Note that if
1460 SRC_MASK has more bits than BITSIZE, we can get into
1461 trouble; we would need to verify that B is in range, as
1462 we do for A above. */
1463 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
1464 ss >>= bitpos;
1465
1466 /* Set all the bits above the sign bit. */
1467 b = (b ^ ss) - ss;
1468
1469 /* Now we can do the addition. */
1470 sum = a + b;
1471
1472 /* See if the result has the correct sign. Bits above the
1473 sign bit are junk now; ignore them. If the sum is
1474 positive, make sure we did not have all negative inputs;
1475 if the sum is negative, make sure we did not have all
1476 positive inputs. The test below looks only at the sign
1477 bits, and it really just
1478 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1479
1480 We mask with addrmask here to explicitly allow an address
1481 wrap-around. The Linux kernel relies on it, and it is
1482 the only way to write assembler code which can run when
1483 loaded at a location 0x80000000 away from the location at
1484 which it is linked. */
1485 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
1486 flag = bfd_reloc_overflow;
1487 break;
1488
1489 case complain_overflow_unsigned:
1490 /* Checking for an unsigned overflow is relatively easy:
1491 trim the addresses and add, and trim the result as well.
1492 Overflow is normally indicated when the result does not
1493 fit in the field. However, we also need to consider the
1494 case when, e.g., fieldmask is 0x7fffffff or smaller, an
1495 input is 0x80000000, and bfd_vma is only 32 bits; then we
1496 will get sum == 0, but there is an overflow, since the
1497 inputs did not fit in the field. Instead of doing a
1498 separate test, we can check for this by or-ing in the
1499 operands when testing for the sum overflowing its final
1500 field. */
1501 sum = (a + b) & addrmask;
1502 if ((a | b | sum) & signmask)
1503 flag = bfd_reloc_overflow;
1504 break;
1505
1506 default:
1507 abort ();
1508 }
1509 }
1510
1511 /* Put RELOCATION in the right bits. */
1512 relocation >>= (bfd_vma) rightshift;
1513 relocation <<= (bfd_vma) bitpos;
1514
1515 /* Add RELOCATION to the right bits of X. */
1516 x = ((x & ~howto->dst_mask)
1517 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1518
1519 /* Put the relocated value back in the object file. */
1520 switch (size)
1521 {
1522 default:
1523 abort ();
1524 case 1:
1525 bfd_put_8 (input_bfd, x, location);
1526 break;
1527 case 2:
1528 bfd_put_16 (input_bfd, x, location);
1529 break;
1530 case 4:
1531 bfd_put_32 (input_bfd, x, location);
1532 break;
1533 case 8:
1534 #ifdef BFD64
1535 bfd_put_64 (input_bfd, x, location);
1536 #else
1537 abort ();
1538 #endif
1539 break;
1540 }
1541
1542 return flag;
1543 }
1544
1545 /* Clear a given location using a given howto, by applying a fixed relocation
1546 value and discarding any in-place addend. This is used for fixed-up
1547 relocations against discarded symbols, to make ignorable debug or unwind
1548 information more obvious. */
1549
1550 void
1551 _bfd_clear_contents (reloc_howto_type *howto,
1552 bfd *input_bfd,
1553 asection *input_section,
1554 bfd_byte *location)
1555 {
1556 int size;
1557 bfd_vma x = 0;
1558
1559 /* Get the value we are going to relocate. */
1560 size = bfd_get_reloc_size (howto);
1561 switch (size)
1562 {
1563 default:
1564 case 0:
1565 abort ();
1566 case 1:
1567 x = bfd_get_8 (input_bfd, location);
1568 break;
1569 case 2:
1570 x = bfd_get_16 (input_bfd, location);
1571 break;
1572 case 4:
1573 x = bfd_get_32 (input_bfd, location);
1574 break;
1575 case 8:
1576 #ifdef BFD64
1577 x = bfd_get_64 (input_bfd, location);
1578 #else
1579 abort ();
1580 #endif
1581 break;
1582 }
1583
1584 /* Zero out the unwanted bits of X. */
1585 x &= ~howto->dst_mask;
1586
1587 /* For a range list, use 1 instead of 0 as placeholder. 0
1588 would terminate the list, hiding any later entries. */
1589 if (strcmp (bfd_get_section_name (input_bfd, input_section),
1590 ".debug_ranges") == 0
1591 && (howto->dst_mask & 1) != 0)
1592 x |= 1;
1593
1594 /* Put the relocated value back in the object file. */
1595 switch (size)
1596 {
1597 default:
1598 case 0:
1599 abort ();
1600 case 1:
1601 bfd_put_8 (input_bfd, x, location);
1602 break;
1603 case 2:
1604 bfd_put_16 (input_bfd, x, location);
1605 break;
1606 case 4:
1607 bfd_put_32 (input_bfd, x, location);
1608 break;
1609 case 8:
1610 #ifdef BFD64
1611 bfd_put_64 (input_bfd, x, location);
1612 #else
1613 abort ();
1614 #endif
1615 break;
1616 }
1617 }
1618
1619 /*
1620 DOCDD
1621 INODE
1622 howto manager, , typedef arelent, Relocations
1623
1624 SUBSECTION
1625 The howto manager
1626
1627 When an application wants to create a relocation, but doesn't
1628 know what the target machine might call it, it can find out by
1629 using this bit of code.
1630
1631 */
1632
1633 /*
1634 TYPEDEF
1635 bfd_reloc_code_type
1636
1637 DESCRIPTION
1638 The insides of a reloc code. The idea is that, eventually, there
1639 will be one enumerator for every type of relocation we ever do.
1640 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1641 return a howto pointer.
1642
1643 This does mean that the application must determine the correct
1644 enumerator value; you can't get a howto pointer from a random set
1645 of attributes.
1646
1647 SENUM
1648 bfd_reloc_code_real
1649
1650 ENUM
1651 BFD_RELOC_64
1652 ENUMX
1653 BFD_RELOC_32
1654 ENUMX
1655 BFD_RELOC_26
1656 ENUMX
1657 BFD_RELOC_24
1658 ENUMX
1659 BFD_RELOC_16
1660 ENUMX
1661 BFD_RELOC_14
1662 ENUMX
1663 BFD_RELOC_8
1664 ENUMDOC
1665 Basic absolute relocations of N bits.
1666
1667 ENUM
1668 BFD_RELOC_64_PCREL
1669 ENUMX
1670 BFD_RELOC_32_PCREL
1671 ENUMX
1672 BFD_RELOC_24_PCREL
1673 ENUMX
1674 BFD_RELOC_16_PCREL
1675 ENUMX
1676 BFD_RELOC_12_PCREL
1677 ENUMX
1678 BFD_RELOC_8_PCREL
1679 ENUMDOC
1680 PC-relative relocations. Sometimes these are relative to the address
1681 of the relocation itself; sometimes they are relative to the start of
1682 the section containing the relocation. It depends on the specific target.
1683
1684 The 24-bit relocation is used in some Intel 960 configurations.
1685
1686 ENUM
1687 BFD_RELOC_32_SECREL
1688 ENUMDOC
1689 Section relative relocations. Some targets need this for DWARF2.
1690
1691 ENUM
1692 BFD_RELOC_32_GOT_PCREL
1693 ENUMX
1694 BFD_RELOC_16_GOT_PCREL
1695 ENUMX
1696 BFD_RELOC_8_GOT_PCREL
1697 ENUMX
1698 BFD_RELOC_32_GOTOFF
1699 ENUMX
1700 BFD_RELOC_16_GOTOFF
1701 ENUMX
1702 BFD_RELOC_LO16_GOTOFF
1703 ENUMX
1704 BFD_RELOC_HI16_GOTOFF
1705 ENUMX
1706 BFD_RELOC_HI16_S_GOTOFF
1707 ENUMX
1708 BFD_RELOC_8_GOTOFF
1709 ENUMX
1710 BFD_RELOC_64_PLT_PCREL
1711 ENUMX
1712 BFD_RELOC_32_PLT_PCREL
1713 ENUMX
1714 BFD_RELOC_24_PLT_PCREL
1715 ENUMX
1716 BFD_RELOC_16_PLT_PCREL
1717 ENUMX
1718 BFD_RELOC_8_PLT_PCREL
1719 ENUMX
1720 BFD_RELOC_64_PLTOFF
1721 ENUMX
1722 BFD_RELOC_32_PLTOFF
1723 ENUMX
1724 BFD_RELOC_16_PLTOFF
1725 ENUMX
1726 BFD_RELOC_LO16_PLTOFF
1727 ENUMX
1728 BFD_RELOC_HI16_PLTOFF
1729 ENUMX
1730 BFD_RELOC_HI16_S_PLTOFF
1731 ENUMX
1732 BFD_RELOC_8_PLTOFF
1733 ENUMDOC
1734 For ELF.
1735
1736 ENUM
1737 BFD_RELOC_SIZE32
1738 ENUMX
1739 BFD_RELOC_SIZE64
1740 ENUMDOC
1741 Size relocations.
1742
1743 ENUM
1744 BFD_RELOC_68K_GLOB_DAT
1745 ENUMX
1746 BFD_RELOC_68K_JMP_SLOT
1747 ENUMX
1748 BFD_RELOC_68K_RELATIVE
1749 ENUMX
1750 BFD_RELOC_68K_TLS_GD32
1751 ENUMX
1752 BFD_RELOC_68K_TLS_GD16
1753 ENUMX
1754 BFD_RELOC_68K_TLS_GD8
1755 ENUMX
1756 BFD_RELOC_68K_TLS_LDM32
1757 ENUMX
1758 BFD_RELOC_68K_TLS_LDM16
1759 ENUMX
1760 BFD_RELOC_68K_TLS_LDM8
1761 ENUMX
1762 BFD_RELOC_68K_TLS_LDO32
1763 ENUMX
1764 BFD_RELOC_68K_TLS_LDO16
1765 ENUMX
1766 BFD_RELOC_68K_TLS_LDO8
1767 ENUMX
1768 BFD_RELOC_68K_TLS_IE32
1769 ENUMX
1770 BFD_RELOC_68K_TLS_IE16
1771 ENUMX
1772 BFD_RELOC_68K_TLS_IE8
1773 ENUMX
1774 BFD_RELOC_68K_TLS_LE32
1775 ENUMX
1776 BFD_RELOC_68K_TLS_LE16
1777 ENUMX
1778 BFD_RELOC_68K_TLS_LE8
1779 ENUMDOC
1780 Relocations used by 68K ELF.
1781
1782 ENUM
1783 BFD_RELOC_32_BASEREL
1784 ENUMX
1785 BFD_RELOC_16_BASEREL
1786 ENUMX
1787 BFD_RELOC_LO16_BASEREL
1788 ENUMX
1789 BFD_RELOC_HI16_BASEREL
1790 ENUMX
1791 BFD_RELOC_HI16_S_BASEREL
1792 ENUMX
1793 BFD_RELOC_8_BASEREL
1794 ENUMX
1795 BFD_RELOC_RVA
1796 ENUMDOC
1797 Linkage-table relative.
1798
1799 ENUM
1800 BFD_RELOC_8_FFnn
1801 ENUMDOC
1802 Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1803
1804 ENUM
1805 BFD_RELOC_32_PCREL_S2
1806 ENUMX
1807 BFD_RELOC_16_PCREL_S2
1808 ENUMX
1809 BFD_RELOC_23_PCREL_S2
1810 ENUMDOC
1811 These PC-relative relocations are stored as word displacements --
1812 i.e., byte displacements shifted right two bits. The 30-bit word
1813 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1814 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The
1815 signed 16-bit displacement is used on the MIPS, and the 23-bit
1816 displacement is used on the Alpha.
1817
1818 ENUM
1819 BFD_RELOC_HI22
1820 ENUMX
1821 BFD_RELOC_LO10
1822 ENUMDOC
1823 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1824 the target word. These are used on the SPARC.
1825
1826 ENUM
1827 BFD_RELOC_GPREL16
1828 ENUMX
1829 BFD_RELOC_GPREL32
1830 ENUMDOC
1831 For systems that allocate a Global Pointer register, these are
1832 displacements off that register. These relocation types are
1833 handled specially, because the value the register will have is
1834 decided relatively late.
1835
1836 ENUM
1837 BFD_RELOC_I960_CALLJ
1838 ENUMDOC
1839 Reloc types used for i960/b.out.
1840
1841 ENUM
1842 BFD_RELOC_NONE
1843 ENUMX
1844 BFD_RELOC_SPARC_WDISP22
1845 ENUMX
1846 BFD_RELOC_SPARC22
1847 ENUMX
1848 BFD_RELOC_SPARC13
1849 ENUMX
1850 BFD_RELOC_SPARC_GOT10
1851 ENUMX
1852 BFD_RELOC_SPARC_GOT13
1853 ENUMX
1854 BFD_RELOC_SPARC_GOT22
1855 ENUMX
1856 BFD_RELOC_SPARC_PC10
1857 ENUMX
1858 BFD_RELOC_SPARC_PC22
1859 ENUMX
1860 BFD_RELOC_SPARC_WPLT30
1861 ENUMX
1862 BFD_RELOC_SPARC_COPY
1863 ENUMX
1864 BFD_RELOC_SPARC_GLOB_DAT
1865 ENUMX
1866 BFD_RELOC_SPARC_JMP_SLOT
1867 ENUMX
1868 BFD_RELOC_SPARC_RELATIVE
1869 ENUMX
1870 BFD_RELOC_SPARC_UA16
1871 ENUMX
1872 BFD_RELOC_SPARC_UA32
1873 ENUMX
1874 BFD_RELOC_SPARC_UA64
1875 ENUMX
1876 BFD_RELOC_SPARC_GOTDATA_HIX22
1877 ENUMX
1878 BFD_RELOC_SPARC_GOTDATA_LOX10
1879 ENUMX
1880 BFD_RELOC_SPARC_GOTDATA_OP_HIX22
1881 ENUMX
1882 BFD_RELOC_SPARC_GOTDATA_OP_LOX10
1883 ENUMX
1884 BFD_RELOC_SPARC_GOTDATA_OP
1885 ENUMX
1886 BFD_RELOC_SPARC_JMP_IREL
1887 ENUMX
1888 BFD_RELOC_SPARC_IRELATIVE
1889 ENUMDOC
1890 SPARC ELF relocations. There is probably some overlap with other
1891 relocation types already defined.
1892
1893 ENUM
1894 BFD_RELOC_SPARC_BASE13
1895 ENUMX
1896 BFD_RELOC_SPARC_BASE22
1897 ENUMDOC
1898 I think these are specific to SPARC a.out (e.g., Sun 4).
1899
1900 ENUMEQ
1901 BFD_RELOC_SPARC_64
1902 BFD_RELOC_64
1903 ENUMX
1904 BFD_RELOC_SPARC_10
1905 ENUMX
1906 BFD_RELOC_SPARC_11
1907 ENUMX
1908 BFD_RELOC_SPARC_OLO10
1909 ENUMX
1910 BFD_RELOC_SPARC_HH22
1911 ENUMX
1912 BFD_RELOC_SPARC_HM10
1913 ENUMX
1914 BFD_RELOC_SPARC_LM22
1915 ENUMX
1916 BFD_RELOC_SPARC_PC_HH22
1917 ENUMX
1918 BFD_RELOC_SPARC_PC_HM10
1919 ENUMX
1920 BFD_RELOC_SPARC_PC_LM22
1921 ENUMX
1922 BFD_RELOC_SPARC_WDISP16
1923 ENUMX
1924 BFD_RELOC_SPARC_WDISP19
1925 ENUMX
1926 BFD_RELOC_SPARC_7
1927 ENUMX
1928 BFD_RELOC_SPARC_6
1929 ENUMX
1930 BFD_RELOC_SPARC_5
1931 ENUMEQX
1932 BFD_RELOC_SPARC_DISP64
1933 BFD_RELOC_64_PCREL
1934 ENUMX
1935 BFD_RELOC_SPARC_PLT32
1936 ENUMX
1937 BFD_RELOC_SPARC_PLT64
1938 ENUMX
1939 BFD_RELOC_SPARC_HIX22
1940 ENUMX
1941 BFD_RELOC_SPARC_LOX10
1942 ENUMX
1943 BFD_RELOC_SPARC_H44
1944 ENUMX
1945 BFD_RELOC_SPARC_M44
1946 ENUMX
1947 BFD_RELOC_SPARC_L44
1948 ENUMX
1949 BFD_RELOC_SPARC_REGISTER
1950 ENUMX
1951 BFD_RELOC_SPARC_H34
1952 ENUMX
1953 BFD_RELOC_SPARC_SIZE32
1954 ENUMX
1955 BFD_RELOC_SPARC_SIZE64
1956 ENUMX
1957 BFD_RELOC_SPARC_WDISP10
1958 ENUMDOC
1959 SPARC64 relocations
1960
1961 ENUM
1962 BFD_RELOC_SPARC_REV32
1963 ENUMDOC
1964 SPARC little endian relocation
1965 ENUM
1966 BFD_RELOC_SPARC_TLS_GD_HI22
1967 ENUMX
1968 BFD_RELOC_SPARC_TLS_GD_LO10
1969 ENUMX
1970 BFD_RELOC_SPARC_TLS_GD_ADD
1971 ENUMX
1972 BFD_RELOC_SPARC_TLS_GD_CALL
1973 ENUMX
1974 BFD_RELOC_SPARC_TLS_LDM_HI22
1975 ENUMX
1976 BFD_RELOC_SPARC_TLS_LDM_LO10
1977 ENUMX
1978 BFD_RELOC_SPARC_TLS_LDM_ADD
1979 ENUMX
1980 BFD_RELOC_SPARC_TLS_LDM_CALL
1981 ENUMX
1982 BFD_RELOC_SPARC_TLS_LDO_HIX22
1983 ENUMX
1984 BFD_RELOC_SPARC_TLS_LDO_LOX10
1985 ENUMX
1986 BFD_RELOC_SPARC_TLS_LDO_ADD
1987 ENUMX
1988 BFD_RELOC_SPARC_TLS_IE_HI22
1989 ENUMX
1990 BFD_RELOC_SPARC_TLS_IE_LO10
1991 ENUMX
1992 BFD_RELOC_SPARC_TLS_IE_LD
1993 ENUMX
1994 BFD_RELOC_SPARC_TLS_IE_LDX
1995 ENUMX
1996 BFD_RELOC_SPARC_TLS_IE_ADD
1997 ENUMX
1998 BFD_RELOC_SPARC_TLS_LE_HIX22
1999 ENUMX
2000 BFD_RELOC_SPARC_TLS_LE_LOX10
2001 ENUMX
2002 BFD_RELOC_SPARC_TLS_DTPMOD32
2003 ENUMX
2004 BFD_RELOC_SPARC_TLS_DTPMOD64
2005 ENUMX
2006 BFD_RELOC_SPARC_TLS_DTPOFF32
2007 ENUMX
2008 BFD_RELOC_SPARC_TLS_DTPOFF64
2009 ENUMX
2010 BFD_RELOC_SPARC_TLS_TPOFF32
2011 ENUMX
2012 BFD_RELOC_SPARC_TLS_TPOFF64
2013 ENUMDOC
2014 SPARC TLS relocations
2015
2016 ENUM
2017 BFD_RELOC_SPU_IMM7
2018 ENUMX
2019 BFD_RELOC_SPU_IMM8
2020 ENUMX
2021 BFD_RELOC_SPU_IMM10
2022 ENUMX
2023 BFD_RELOC_SPU_IMM10W
2024 ENUMX
2025 BFD_RELOC_SPU_IMM16
2026 ENUMX
2027 BFD_RELOC_SPU_IMM16W
2028 ENUMX
2029 BFD_RELOC_SPU_IMM18
2030 ENUMX
2031 BFD_RELOC_SPU_PCREL9a
2032 ENUMX
2033 BFD_RELOC_SPU_PCREL9b
2034 ENUMX
2035 BFD_RELOC_SPU_PCREL16
2036 ENUMX
2037 BFD_RELOC_SPU_LO16
2038 ENUMX
2039 BFD_RELOC_SPU_HI16
2040 ENUMX
2041 BFD_RELOC_SPU_PPU32
2042 ENUMX
2043 BFD_RELOC_SPU_PPU64
2044 ENUMX
2045 BFD_RELOC_SPU_ADD_PIC
2046 ENUMDOC
2047 SPU Relocations.
2048
2049 ENUM
2050 BFD_RELOC_ALPHA_GPDISP_HI16
2051 ENUMDOC
2052 Alpha ECOFF and ELF relocations. Some of these treat the symbol or
2053 "addend" in some special way.
2054 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
2055 writing; when reading, it will be the absolute section symbol. The
2056 addend is the displacement in bytes of the "lda" instruction from
2057 the "ldah" instruction (which is at the address of this reloc).
2058 ENUM
2059 BFD_RELOC_ALPHA_GPDISP_LO16
2060 ENUMDOC
2061 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
2062 with GPDISP_HI16 relocs. The addend is ignored when writing the
2063 relocations out, and is filled in with the file's GP value on
2064 reading, for convenience.
2065
2066 ENUM
2067 BFD_RELOC_ALPHA_GPDISP
2068 ENUMDOC
2069 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
2070 relocation except that there is no accompanying GPDISP_LO16
2071 relocation.
2072
2073 ENUM
2074 BFD_RELOC_ALPHA_LITERAL
2075 ENUMX
2076 BFD_RELOC_ALPHA_ELF_LITERAL
2077 ENUMX
2078 BFD_RELOC_ALPHA_LITUSE
2079 ENUMDOC
2080 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
2081 the assembler turns it into a LDQ instruction to load the address of
2082 the symbol, and then fills in a register in the real instruction.
2083
2084 The LITERAL reloc, at the LDQ instruction, refers to the .lita
2085 section symbol. The addend is ignored when writing, but is filled
2086 in with the file's GP value on reading, for convenience, as with the
2087 GPDISP_LO16 reloc.
2088
2089 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
2090 It should refer to the symbol to be referenced, as with 16_GOTOFF,
2091 but it generates output not based on the position within the .got
2092 section, but relative to the GP value chosen for the file during the
2093 final link stage.
2094
2095 The LITUSE reloc, on the instruction using the loaded address, gives
2096 information to the linker that it might be able to use to optimize
2097 away some literal section references. The symbol is ignored (read
2098 as the absolute section symbol), and the "addend" indicates the type
2099 of instruction using the register:
2100 1 - "memory" fmt insn
2101 2 - byte-manipulation (byte offset reg)
2102 3 - jsr (target of branch)
2103
2104 ENUM
2105 BFD_RELOC_ALPHA_HINT
2106 ENUMDOC
2107 The HINT relocation indicates a value that should be filled into the
2108 "hint" field of a jmp/jsr/ret instruction, for possible branch-
2109 prediction logic which may be provided on some processors.
2110
2111 ENUM
2112 BFD_RELOC_ALPHA_LINKAGE
2113 ENUMDOC
2114 The LINKAGE relocation outputs a linkage pair in the object file,
2115 which is filled by the linker.
2116
2117 ENUM
2118 BFD_RELOC_ALPHA_CODEADDR
2119 ENUMDOC
2120 The CODEADDR relocation outputs a STO_CA in the object file,
2121 which is filled by the linker.
2122
2123 ENUM
2124 BFD_RELOC_ALPHA_GPREL_HI16
2125 ENUMX
2126 BFD_RELOC_ALPHA_GPREL_LO16
2127 ENUMDOC
2128 The GPREL_HI/LO relocations together form a 32-bit offset from the
2129 GP register.
2130
2131 ENUM
2132 BFD_RELOC_ALPHA_BRSGP
2133 ENUMDOC
2134 Like BFD_RELOC_23_PCREL_S2, except that the source and target must
2135 share a common GP, and the target address is adjusted for
2136 STO_ALPHA_STD_GPLOAD.
2137
2138 ENUM
2139 BFD_RELOC_ALPHA_NOP
2140 ENUMDOC
2141 The NOP relocation outputs a NOP if the longword displacement
2142 between two procedure entry points is < 2^21.
2143
2144 ENUM
2145 BFD_RELOC_ALPHA_BSR
2146 ENUMDOC
2147 The BSR relocation outputs a BSR if the longword displacement
2148 between two procedure entry points is < 2^21.
2149
2150 ENUM
2151 BFD_RELOC_ALPHA_LDA
2152 ENUMDOC
2153 The LDA relocation outputs a LDA if the longword displacement
2154 between two procedure entry points is < 2^16.
2155
2156 ENUM
2157 BFD_RELOC_ALPHA_BOH
2158 ENUMDOC
2159 The BOH relocation outputs a BSR if the longword displacement
2160 between two procedure entry points is < 2^21, or else a hint.
2161
2162 ENUM
2163 BFD_RELOC_ALPHA_TLSGD
2164 ENUMX
2165 BFD_RELOC_ALPHA_TLSLDM
2166 ENUMX
2167 BFD_RELOC_ALPHA_DTPMOD64
2168 ENUMX
2169 BFD_RELOC_ALPHA_GOTDTPREL16
2170 ENUMX
2171 BFD_RELOC_ALPHA_DTPREL64
2172 ENUMX
2173 BFD_RELOC_ALPHA_DTPREL_HI16
2174 ENUMX
2175 BFD_RELOC_ALPHA_DTPREL_LO16
2176 ENUMX
2177 BFD_RELOC_ALPHA_DTPREL16
2178 ENUMX
2179 BFD_RELOC_ALPHA_GOTTPREL16
2180 ENUMX
2181 BFD_RELOC_ALPHA_TPREL64
2182 ENUMX
2183 BFD_RELOC_ALPHA_TPREL_HI16
2184 ENUMX
2185 BFD_RELOC_ALPHA_TPREL_LO16
2186 ENUMX
2187 BFD_RELOC_ALPHA_TPREL16
2188 ENUMDOC
2189 Alpha thread-local storage relocations.
2190
2191 ENUM
2192 BFD_RELOC_MIPS_JMP
2193 ENUMX
2194 BFD_RELOC_MICROMIPS_JMP
2195 ENUMDOC
2196 The MIPS jump instruction.
2197
2198 ENUM
2199 BFD_RELOC_MIPS16_JMP
2200 ENUMDOC
2201 The MIPS16 jump instruction.
2202
2203 ENUM
2204 BFD_RELOC_MIPS16_GPREL
2205 ENUMDOC
2206 MIPS16 GP relative reloc.
2207
2208 ENUM
2209 BFD_RELOC_HI16
2210 ENUMDOC
2211 High 16 bits of 32-bit value; simple reloc.
2212
2213 ENUM
2214 BFD_RELOC_HI16_S
2215 ENUMDOC
2216 High 16 bits of 32-bit value but the low 16 bits will be sign
2217 extended and added to form the final result. If the low 16
2218 bits form a negative number, we need to add one to the high value
2219 to compensate for the borrow when the low bits are added.
2220
2221 ENUM
2222 BFD_RELOC_LO16
2223 ENUMDOC
2224 Low 16 bits.
2225
2226 ENUM
2227 BFD_RELOC_HI16_PCREL
2228 ENUMDOC
2229 High 16 bits of 32-bit pc-relative value
2230 ENUM
2231 BFD_RELOC_HI16_S_PCREL
2232 ENUMDOC
2233 High 16 bits of 32-bit pc-relative value, adjusted
2234 ENUM
2235 BFD_RELOC_LO16_PCREL
2236 ENUMDOC
2237 Low 16 bits of pc-relative value
2238
2239 ENUM
2240 BFD_RELOC_MIPS16_GOT16
2241 ENUMX
2242 BFD_RELOC_MIPS16_CALL16
2243 ENUMDOC
2244 Equivalent of BFD_RELOC_MIPS_*, but with the MIPS16 layout of
2245 16-bit immediate fields
2246 ENUM
2247 BFD_RELOC_MIPS16_HI16
2248 ENUMDOC
2249 MIPS16 high 16 bits of 32-bit value.
2250 ENUM
2251 BFD_RELOC_MIPS16_HI16_S
2252 ENUMDOC
2253 MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign
2254 extended and added to form the final result. If the low 16
2255 bits form a negative number, we need to add one to the high value
2256 to compensate for the borrow when the low bits are added.
2257 ENUM
2258 BFD_RELOC_MIPS16_LO16
2259 ENUMDOC
2260 MIPS16 low 16 bits.
2261
2262 ENUM
2263 BFD_RELOC_MIPS16_TLS_GD
2264 ENUMX
2265 BFD_RELOC_MIPS16_TLS_LDM
2266 ENUMX
2267 BFD_RELOC_MIPS16_TLS_DTPREL_HI16
2268 ENUMX
2269 BFD_RELOC_MIPS16_TLS_DTPREL_LO16
2270 ENUMX
2271 BFD_RELOC_MIPS16_TLS_GOTTPREL
2272 ENUMX
2273 BFD_RELOC_MIPS16_TLS_TPREL_HI16
2274 ENUMX
2275 BFD_RELOC_MIPS16_TLS_TPREL_LO16
2276 ENUMDOC
2277 MIPS16 TLS relocations
2278
2279 ENUM
2280 BFD_RELOC_MIPS_LITERAL
2281 ENUMX
2282 BFD_RELOC_MICROMIPS_LITERAL
2283 ENUMDOC
2284 Relocation against a MIPS literal section.
2285
2286 ENUM
2287 BFD_RELOC_MICROMIPS_7_PCREL_S1
2288 ENUMX
2289 BFD_RELOC_MICROMIPS_10_PCREL_S1
2290 ENUMX
2291 BFD_RELOC_MICROMIPS_16_PCREL_S1
2292 ENUMDOC
2293 microMIPS PC-relative relocations.
2294
2295 ENUM
2296 BFD_RELOC_MICROMIPS_GPREL16
2297 ENUMX
2298 BFD_RELOC_MICROMIPS_HI16
2299 ENUMX
2300 BFD_RELOC_MICROMIPS_HI16_S
2301 ENUMX
2302 BFD_RELOC_MICROMIPS_LO16
2303 ENUMDOC
2304 microMIPS versions of generic BFD relocs.
2305
2306 ENUM
2307 BFD_RELOC_MIPS_GOT16
2308 ENUMX
2309 BFD_RELOC_MICROMIPS_GOT16
2310 ENUMX
2311 BFD_RELOC_MIPS_CALL16
2312 ENUMX
2313 BFD_RELOC_MICROMIPS_CALL16
2314 ENUMX
2315 BFD_RELOC_MIPS_GOT_HI16
2316 ENUMX
2317 BFD_RELOC_MICROMIPS_GOT_HI16
2318 ENUMX
2319 BFD_RELOC_MIPS_GOT_LO16
2320 ENUMX
2321 BFD_RELOC_MICROMIPS_GOT_LO16
2322 ENUMX
2323 BFD_RELOC_MIPS_CALL_HI16
2324 ENUMX
2325 BFD_RELOC_MICROMIPS_CALL_HI16
2326 ENUMX
2327 BFD_RELOC_MIPS_CALL_LO16
2328 ENUMX
2329 BFD_RELOC_MICROMIPS_CALL_LO16
2330 ENUMX
2331 BFD_RELOC_MIPS_SUB
2332 ENUMX
2333 BFD_RELOC_MICROMIPS_SUB
2334 ENUMX
2335 BFD_RELOC_MIPS_GOT_PAGE
2336 ENUMX
2337 BFD_RELOC_MICROMIPS_GOT_PAGE
2338 ENUMX
2339 BFD_RELOC_MIPS_GOT_OFST
2340 ENUMX
2341 BFD_RELOC_MICROMIPS_GOT_OFST
2342 ENUMX
2343 BFD_RELOC_MIPS_GOT_DISP
2344 ENUMX
2345 BFD_RELOC_MICROMIPS_GOT_DISP
2346 ENUMX
2347 BFD_RELOC_MIPS_SHIFT5
2348 ENUMX
2349 BFD_RELOC_MIPS_SHIFT6
2350 ENUMX
2351 BFD_RELOC_MIPS_INSERT_A
2352 ENUMX
2353 BFD_RELOC_MIPS_INSERT_B
2354 ENUMX
2355 BFD_RELOC_MIPS_DELETE
2356 ENUMX
2357 BFD_RELOC_MIPS_HIGHEST
2358 ENUMX
2359 BFD_RELOC_MICROMIPS_HIGHEST
2360 ENUMX
2361 BFD_RELOC_MIPS_HIGHER
2362 ENUMX
2363 BFD_RELOC_MICROMIPS_HIGHER
2364 ENUMX
2365 BFD_RELOC_MIPS_SCN_DISP
2366 ENUMX
2367 BFD_RELOC_MICROMIPS_SCN_DISP
2368 ENUMX
2369 BFD_RELOC_MIPS_REL16
2370 ENUMX
2371 BFD_RELOC_MIPS_RELGOT
2372 ENUMX
2373 BFD_RELOC_MIPS_JALR
2374 ENUMX
2375 BFD_RELOC_MICROMIPS_JALR
2376 ENUMX
2377 BFD_RELOC_MIPS_TLS_DTPMOD32
2378 ENUMX
2379 BFD_RELOC_MIPS_TLS_DTPREL32
2380 ENUMX
2381 BFD_RELOC_MIPS_TLS_DTPMOD64
2382 ENUMX
2383 BFD_RELOC_MIPS_TLS_DTPREL64
2384 ENUMX
2385 BFD_RELOC_MIPS_TLS_GD
2386 ENUMX
2387 BFD_RELOC_MICROMIPS_TLS_GD
2388 ENUMX
2389 BFD_RELOC_MIPS_TLS_LDM
2390 ENUMX
2391 BFD_RELOC_MICROMIPS_TLS_LDM
2392 ENUMX
2393 BFD_RELOC_MIPS_TLS_DTPREL_HI16
2394 ENUMX
2395 BFD_RELOC_MICROMIPS_TLS_DTPREL_HI16
2396 ENUMX
2397 BFD_RELOC_MIPS_TLS_DTPREL_LO16
2398 ENUMX
2399 BFD_RELOC_MICROMIPS_TLS_DTPREL_LO16
2400 ENUMX
2401 BFD_RELOC_MIPS_TLS_GOTTPREL
2402 ENUMX
2403 BFD_RELOC_MICROMIPS_TLS_GOTTPREL
2404 ENUMX
2405 BFD_RELOC_MIPS_TLS_TPREL32
2406 ENUMX
2407 BFD_RELOC_MIPS_TLS_TPREL64
2408 ENUMX
2409 BFD_RELOC_MIPS_TLS_TPREL_HI16
2410 ENUMX
2411 BFD_RELOC_MICROMIPS_TLS_TPREL_HI16
2412 ENUMX
2413 BFD_RELOC_MIPS_TLS_TPREL_LO16
2414 ENUMX
2415 BFD_RELOC_MICROMIPS_TLS_TPREL_LO16
2416 ENUMX
2417 BFD_RELOC_MIPS_EH
2418 ENUMDOC
2419 MIPS ELF relocations.
2420 COMMENT
2421
2422 ENUM
2423 BFD_RELOC_MIPS_COPY
2424 ENUMX
2425 BFD_RELOC_MIPS_JUMP_SLOT
2426 ENUMDOC
2427 MIPS ELF relocations (VxWorks and PLT extensions).
2428 COMMENT
2429
2430 ENUM
2431 BFD_RELOC_MOXIE_10_PCREL
2432 ENUMDOC
2433 Moxie ELF relocations.
2434 COMMENT
2435
2436 ENUM
2437 BFD_RELOC_FRV_LABEL16
2438 ENUMX
2439 BFD_RELOC_FRV_LABEL24
2440 ENUMX
2441 BFD_RELOC_FRV_LO16
2442 ENUMX
2443 BFD_RELOC_FRV_HI16
2444 ENUMX
2445 BFD_RELOC_FRV_GPREL12
2446 ENUMX
2447 BFD_RELOC_FRV_GPRELU12
2448 ENUMX
2449 BFD_RELOC_FRV_GPREL32
2450 ENUMX
2451 BFD_RELOC_FRV_GPRELHI
2452 ENUMX
2453 BFD_RELOC_FRV_GPRELLO
2454 ENUMX
2455 BFD_RELOC_FRV_GOT12
2456 ENUMX
2457 BFD_RELOC_FRV_GOTHI
2458 ENUMX
2459 BFD_RELOC_FRV_GOTLO
2460 ENUMX
2461 BFD_RELOC_FRV_FUNCDESC
2462 ENUMX
2463 BFD_RELOC_FRV_FUNCDESC_GOT12
2464 ENUMX
2465 BFD_RELOC_FRV_FUNCDESC_GOTHI
2466 ENUMX
2467 BFD_RELOC_FRV_FUNCDESC_GOTLO
2468 ENUMX
2469 BFD_RELOC_FRV_FUNCDESC_VALUE
2470 ENUMX
2471 BFD_RELOC_FRV_FUNCDESC_GOTOFF12
2472 ENUMX
2473 BFD_RELOC_FRV_FUNCDESC_GOTOFFHI
2474 ENUMX
2475 BFD_RELOC_FRV_FUNCDESC_GOTOFFLO
2476 ENUMX
2477 BFD_RELOC_FRV_GOTOFF12
2478 ENUMX
2479 BFD_RELOC_FRV_GOTOFFHI
2480 ENUMX
2481 BFD_RELOC_FRV_GOTOFFLO
2482 ENUMX
2483 BFD_RELOC_FRV_GETTLSOFF
2484 ENUMX
2485 BFD_RELOC_FRV_TLSDESC_VALUE
2486 ENUMX
2487 BFD_RELOC_FRV_GOTTLSDESC12
2488 ENUMX
2489 BFD_RELOC_FRV_GOTTLSDESCHI
2490 ENUMX
2491 BFD_RELOC_FRV_GOTTLSDESCLO
2492 ENUMX
2493 BFD_RELOC_FRV_TLSMOFF12
2494 ENUMX
2495 BFD_RELOC_FRV_TLSMOFFHI
2496 ENUMX
2497 BFD_RELOC_FRV_TLSMOFFLO
2498 ENUMX
2499 BFD_RELOC_FRV_GOTTLSOFF12
2500 ENUMX
2501 BFD_RELOC_FRV_GOTTLSOFFHI
2502 ENUMX
2503 BFD_RELOC_FRV_GOTTLSOFFLO
2504 ENUMX
2505 BFD_RELOC_FRV_TLSOFF
2506 ENUMX
2507 BFD_RELOC_FRV_TLSDESC_RELAX
2508 ENUMX
2509 BFD_RELOC_FRV_GETTLSOFF_RELAX
2510 ENUMX
2511 BFD_RELOC_FRV_TLSOFF_RELAX
2512 ENUMX
2513 BFD_RELOC_FRV_TLSMOFF
2514 ENUMDOC
2515 Fujitsu Frv Relocations.
2516 COMMENT
2517
2518 ENUM
2519 BFD_RELOC_MN10300_GOTOFF24
2520 ENUMDOC
2521 This is a 24bit GOT-relative reloc for the mn10300.
2522 ENUM
2523 BFD_RELOC_MN10300_GOT32
2524 ENUMDOC
2525 This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes
2526 in the instruction.
2527 ENUM
2528 BFD_RELOC_MN10300_GOT24
2529 ENUMDOC
2530 This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes
2531 in the instruction.
2532 ENUM
2533 BFD_RELOC_MN10300_GOT16
2534 ENUMDOC
2535 This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes
2536 in the instruction.
2537 ENUM
2538 BFD_RELOC_MN10300_COPY
2539 ENUMDOC
2540 Copy symbol at runtime.
2541 ENUM
2542 BFD_RELOC_MN10300_GLOB_DAT
2543 ENUMDOC
2544 Create GOT entry.
2545 ENUM
2546 BFD_RELOC_MN10300_JMP_SLOT
2547 ENUMDOC
2548 Create PLT entry.
2549 ENUM
2550 BFD_RELOC_MN10300_RELATIVE
2551 ENUMDOC
2552 Adjust by program base.
2553 ENUM
2554 BFD_RELOC_MN10300_SYM_DIFF
2555 ENUMDOC
2556 Together with another reloc targeted at the same location,
2557 allows for a value that is the difference of two symbols
2558 in the same section.
2559 ENUM
2560 BFD_RELOC_MN10300_ALIGN
2561 ENUMDOC
2562 The addend of this reloc is an alignment power that must
2563 be honoured at the offset's location, regardless of linker
2564 relaxation.
2565 ENUM
2566 BFD_RELOC_MN10300_TLS_GD
2567 ENUMX
2568 BFD_RELOC_MN10300_TLS_LD
2569 ENUMX
2570 BFD_RELOC_MN10300_TLS_LDO
2571 ENUMX
2572 BFD_RELOC_MN10300_TLS_GOTIE
2573 ENUMX
2574 BFD_RELOC_MN10300_TLS_IE
2575 ENUMX
2576 BFD_RELOC_MN10300_TLS_LE
2577 ENUMX
2578 BFD_RELOC_MN10300_TLS_DTPMOD
2579 ENUMX
2580 BFD_RELOC_MN10300_TLS_DTPOFF
2581 ENUMX
2582 BFD_RELOC_MN10300_TLS_TPOFF
2583 ENUMDOC
2584 Various TLS-related relocations.
2585 ENUM
2586 BFD_RELOC_MN10300_32_PCREL
2587 ENUMDOC
2588 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2589 instruction.
2590 ENUM
2591 BFD_RELOC_MN10300_16_PCREL
2592 ENUMDOC
2593 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2594 instruction.
2595 COMMENT
2596
2597 ENUM
2598 BFD_RELOC_386_GOT32
2599 ENUMX
2600 BFD_RELOC_386_PLT32
2601 ENUMX
2602 BFD_RELOC_386_COPY
2603 ENUMX
2604 BFD_RELOC_386_GLOB_DAT
2605 ENUMX
2606 BFD_RELOC_386_JUMP_SLOT
2607 ENUMX
2608 BFD_RELOC_386_RELATIVE
2609 ENUMX
2610 BFD_RELOC_386_GOTOFF
2611 ENUMX
2612 BFD_RELOC_386_GOTPC
2613 ENUMX
2614 BFD_RELOC_386_TLS_TPOFF
2615 ENUMX
2616 BFD_RELOC_386_TLS_IE
2617 ENUMX
2618 BFD_RELOC_386_TLS_GOTIE
2619 ENUMX
2620 BFD_RELOC_386_TLS_LE
2621 ENUMX
2622 BFD_RELOC_386_TLS_GD
2623 ENUMX
2624 BFD_RELOC_386_TLS_LDM
2625 ENUMX
2626 BFD_RELOC_386_TLS_LDO_32
2627 ENUMX
2628 BFD_RELOC_386_TLS_IE_32
2629 ENUMX
2630 BFD_RELOC_386_TLS_LE_32
2631 ENUMX
2632 BFD_RELOC_386_TLS_DTPMOD32
2633 ENUMX
2634 BFD_RELOC_386_TLS_DTPOFF32
2635 ENUMX
2636 BFD_RELOC_386_TLS_TPOFF32
2637 ENUMX
2638 BFD_RELOC_386_TLS_GOTDESC
2639 ENUMX
2640 BFD_RELOC_386_TLS_DESC_CALL
2641 ENUMX
2642 BFD_RELOC_386_TLS_DESC
2643 ENUMX
2644 BFD_RELOC_386_IRELATIVE
2645 ENUMDOC
2646 i386/elf relocations
2647
2648 ENUM
2649 BFD_RELOC_X86_64_GOT32
2650 ENUMX
2651 BFD_RELOC_X86_64_PLT32
2652 ENUMX
2653 BFD_RELOC_X86_64_COPY
2654 ENUMX
2655 BFD_RELOC_X86_64_GLOB_DAT
2656 ENUMX
2657 BFD_RELOC_X86_64_JUMP_SLOT
2658 ENUMX
2659 BFD_RELOC_X86_64_RELATIVE
2660 ENUMX
2661 BFD_RELOC_X86_64_GOTPCREL
2662 ENUMX
2663 BFD_RELOC_X86_64_32S
2664 ENUMX
2665 BFD_RELOC_X86_64_DTPMOD64
2666 ENUMX
2667 BFD_RELOC_X86_64_DTPOFF64
2668 ENUMX
2669 BFD_RELOC_X86_64_TPOFF64
2670 ENUMX
2671 BFD_RELOC_X86_64_TLSGD
2672 ENUMX
2673 BFD_RELOC_X86_64_TLSLD
2674 ENUMX
2675 BFD_RELOC_X86_64_DTPOFF32
2676 ENUMX
2677 BFD_RELOC_X86_64_GOTTPOFF
2678 ENUMX
2679 BFD_RELOC_X86_64_TPOFF32
2680 ENUMX
2681 BFD_RELOC_X86_64_GOTOFF64
2682 ENUMX
2683 BFD_RELOC_X86_64_GOTPC32
2684 ENUMX
2685 BFD_RELOC_X86_64_GOT64
2686 ENUMX
2687 BFD_RELOC_X86_64_GOTPCREL64
2688 ENUMX
2689 BFD_RELOC_X86_64_GOTPC64
2690 ENUMX
2691 BFD_RELOC_X86_64_GOTPLT64
2692 ENUMX
2693 BFD_RELOC_X86_64_PLTOFF64
2694 ENUMX
2695 BFD_RELOC_X86_64_GOTPC32_TLSDESC
2696 ENUMX
2697 BFD_RELOC_X86_64_TLSDESC_CALL
2698 ENUMX
2699 BFD_RELOC_X86_64_TLSDESC
2700 ENUMX
2701 BFD_RELOC_X86_64_IRELATIVE
2702 ENUMX
2703 BFD_RELOC_X86_64_PC32_BND
2704 ENUMX
2705 BFD_RELOC_X86_64_PLT32_BND
2706 ENUMDOC
2707 x86-64/elf relocations
2708
2709 ENUM
2710 BFD_RELOC_NS32K_IMM_8
2711 ENUMX
2712 BFD_RELOC_NS32K_IMM_16
2713 ENUMX
2714 BFD_RELOC_NS32K_IMM_32
2715 ENUMX
2716 BFD_RELOC_NS32K_IMM_8_PCREL
2717 ENUMX
2718 BFD_RELOC_NS32K_IMM_16_PCREL
2719 ENUMX
2720 BFD_RELOC_NS32K_IMM_32_PCREL
2721 ENUMX
2722 BFD_RELOC_NS32K_DISP_8
2723 ENUMX
2724 BFD_RELOC_NS32K_DISP_16
2725 ENUMX
2726 BFD_RELOC_NS32K_DISP_32
2727 ENUMX
2728 BFD_RELOC_NS32K_DISP_8_PCREL
2729 ENUMX
2730 BFD_RELOC_NS32K_DISP_16_PCREL
2731 ENUMX
2732 BFD_RELOC_NS32K_DISP_32_PCREL
2733 ENUMDOC
2734 ns32k relocations
2735
2736 ENUM
2737 BFD_RELOC_PDP11_DISP_8_PCREL
2738 ENUMX
2739 BFD_RELOC_PDP11_DISP_6_PCREL
2740 ENUMDOC
2741 PDP11 relocations
2742
2743 ENUM
2744 BFD_RELOC_PJ_CODE_HI16
2745 ENUMX
2746 BFD_RELOC_PJ_CODE_LO16
2747 ENUMX
2748 BFD_RELOC_PJ_CODE_DIR16
2749 ENUMX
2750 BFD_RELOC_PJ_CODE_DIR32
2751 ENUMX
2752 BFD_RELOC_PJ_CODE_REL16
2753 ENUMX
2754 BFD_RELOC_PJ_CODE_REL32
2755 ENUMDOC
2756 Picojava relocs. Not all of these appear in object files.
2757
2758 ENUM
2759 BFD_RELOC_PPC_B26
2760 ENUMX
2761 BFD_RELOC_PPC_BA26
2762 ENUMX
2763 BFD_RELOC_PPC_TOC16
2764 ENUMX
2765 BFD_RELOC_PPC_B16
2766 ENUMX
2767 BFD_RELOC_PPC_B16_BRTAKEN
2768 ENUMX
2769 BFD_RELOC_PPC_B16_BRNTAKEN
2770 ENUMX
2771 BFD_RELOC_PPC_BA16
2772 ENUMX
2773 BFD_RELOC_PPC_BA16_BRTAKEN
2774 ENUMX
2775 BFD_RELOC_PPC_BA16_BRNTAKEN
2776 ENUMX
2777 BFD_RELOC_PPC_COPY
2778 ENUMX
2779 BFD_RELOC_PPC_GLOB_DAT
2780 ENUMX
2781 BFD_RELOC_PPC_JMP_SLOT
2782 ENUMX
2783 BFD_RELOC_PPC_RELATIVE
2784 ENUMX
2785 BFD_RELOC_PPC_LOCAL24PC
2786 ENUMX
2787 BFD_RELOC_PPC_EMB_NADDR32
2788 ENUMX
2789 BFD_RELOC_PPC_EMB_NADDR16
2790 ENUMX
2791 BFD_RELOC_PPC_EMB_NADDR16_LO
2792 ENUMX
2793 BFD_RELOC_PPC_EMB_NADDR16_HI
2794 ENUMX
2795 BFD_RELOC_PPC_EMB_NADDR16_HA
2796 ENUMX
2797 BFD_RELOC_PPC_EMB_SDAI16
2798 ENUMX
2799 BFD_RELOC_PPC_EMB_SDA2I16
2800 ENUMX
2801 BFD_RELOC_PPC_EMB_SDA2REL
2802 ENUMX
2803 BFD_RELOC_PPC_EMB_SDA21
2804 ENUMX
2805 BFD_RELOC_PPC_EMB_MRKREF
2806 ENUMX
2807 BFD_RELOC_PPC_EMB_RELSEC16
2808 ENUMX
2809 BFD_RELOC_PPC_EMB_RELST_LO
2810 ENUMX
2811 BFD_RELOC_PPC_EMB_RELST_HI
2812 ENUMX
2813 BFD_RELOC_PPC_EMB_RELST_HA
2814 ENUMX
2815 BFD_RELOC_PPC_EMB_BIT_FLD
2816 ENUMX
2817 BFD_RELOC_PPC_EMB_RELSDA
2818 ENUMX
2819 BFD_RELOC_PPC_VLE_REL8
2820 ENUMX
2821 BFD_RELOC_PPC_VLE_REL15
2822 ENUMX
2823 BFD_RELOC_PPC_VLE_REL24
2824 ENUMX
2825 BFD_RELOC_PPC_VLE_LO16A
2826 ENUMX
2827 BFD_RELOC_PPC_VLE_LO16D
2828 ENUMX
2829 BFD_RELOC_PPC_VLE_HI16A
2830 ENUMX
2831 BFD_RELOC_PPC_VLE_HI16D
2832 ENUMX
2833 BFD_RELOC_PPC_VLE_HA16A
2834 ENUMX
2835 BFD_RELOC_PPC_VLE_HA16D
2836 ENUMX
2837 BFD_RELOC_PPC_VLE_SDA21
2838 ENUMX
2839 BFD_RELOC_PPC_VLE_SDA21_LO
2840 ENUMX
2841 BFD_RELOC_PPC_VLE_SDAREL_LO16A
2842 ENUMX
2843 BFD_RELOC_PPC_VLE_SDAREL_LO16D
2844 ENUMX
2845 BFD_RELOC_PPC_VLE_SDAREL_HI16A
2846 ENUMX
2847 BFD_RELOC_PPC_VLE_SDAREL_HI16D
2848 ENUMX
2849 BFD_RELOC_PPC_VLE_SDAREL_HA16A
2850 ENUMX
2851 BFD_RELOC_PPC_VLE_SDAREL_HA16D
2852 ENUMX
2853 BFD_RELOC_PPC64_HIGHER
2854 ENUMX
2855 BFD_RELOC_PPC64_HIGHER_S
2856 ENUMX
2857 BFD_RELOC_PPC64_HIGHEST
2858 ENUMX
2859 BFD_RELOC_PPC64_HIGHEST_S
2860 ENUMX
2861 BFD_RELOC_PPC64_TOC16_LO
2862 ENUMX
2863 BFD_RELOC_PPC64_TOC16_HI
2864 ENUMX
2865 BFD_RELOC_PPC64_TOC16_HA
2866 ENUMX
2867 BFD_RELOC_PPC64_TOC
2868 ENUMX
2869 BFD_RELOC_PPC64_PLTGOT16
2870 ENUMX
2871 BFD_RELOC_PPC64_PLTGOT16_LO
2872 ENUMX
2873 BFD_RELOC_PPC64_PLTGOT16_HI
2874 ENUMX
2875 BFD_RELOC_PPC64_PLTGOT16_HA
2876 ENUMX
2877 BFD_RELOC_PPC64_ADDR16_DS
2878 ENUMX
2879 BFD_RELOC_PPC64_ADDR16_LO_DS
2880 ENUMX
2881 BFD_RELOC_PPC64_GOT16_DS
2882 ENUMX
2883 BFD_RELOC_PPC64_GOT16_LO_DS
2884 ENUMX
2885 BFD_RELOC_PPC64_PLT16_LO_DS
2886 ENUMX
2887 BFD_RELOC_PPC64_SECTOFF_DS
2888 ENUMX
2889 BFD_RELOC_PPC64_SECTOFF_LO_DS
2890 ENUMX
2891 BFD_RELOC_PPC64_TOC16_DS
2892 ENUMX
2893 BFD_RELOC_PPC64_TOC16_LO_DS
2894 ENUMX
2895 BFD_RELOC_PPC64_PLTGOT16_DS
2896 ENUMX
2897 BFD_RELOC_PPC64_PLTGOT16_LO_DS
2898 ENUMX
2899 BFD_RELOC_PPC64_ADDR16_HIGH
2900 ENUMX
2901 BFD_RELOC_PPC64_ADDR16_HIGHA
2902 ENUMX
2903 BFD_RELOC_PPC64_ADDR64_LOCAL
2904 ENUMDOC
2905 Power(rs6000) and PowerPC relocations.
2906
2907 ENUM
2908 BFD_RELOC_PPC_TLS
2909 ENUMX
2910 BFD_RELOC_PPC_TLSGD
2911 ENUMX
2912 BFD_RELOC_PPC_TLSLD
2913 ENUMX
2914 BFD_RELOC_PPC_DTPMOD
2915 ENUMX
2916 BFD_RELOC_PPC_TPREL16
2917 ENUMX
2918 BFD_RELOC_PPC_TPREL16_LO
2919 ENUMX
2920 BFD_RELOC_PPC_TPREL16_HI
2921 ENUMX
2922 BFD_RELOC_PPC_TPREL16_HA
2923 ENUMX
2924 BFD_RELOC_PPC_TPREL
2925 ENUMX
2926 BFD_RELOC_PPC_DTPREL16
2927 ENUMX
2928 BFD_RELOC_PPC_DTPREL16_LO
2929 ENUMX
2930 BFD_RELOC_PPC_DTPREL16_HI
2931 ENUMX
2932 BFD_RELOC_PPC_DTPREL16_HA
2933 ENUMX
2934 BFD_RELOC_PPC_DTPREL
2935 ENUMX
2936 BFD_RELOC_PPC_GOT_TLSGD16
2937 ENUMX
2938 BFD_RELOC_PPC_GOT_TLSGD16_LO
2939 ENUMX
2940 BFD_RELOC_PPC_GOT_TLSGD16_HI
2941 ENUMX
2942 BFD_RELOC_PPC_GOT_TLSGD16_HA
2943 ENUMX
2944 BFD_RELOC_PPC_GOT_TLSLD16
2945 ENUMX
2946 BFD_RELOC_PPC_GOT_TLSLD16_LO
2947 ENUMX
2948 BFD_RELOC_PPC_GOT_TLSLD16_HI
2949 ENUMX
2950 BFD_RELOC_PPC_GOT_TLSLD16_HA
2951 ENUMX
2952 BFD_RELOC_PPC_GOT_TPREL16
2953 ENUMX
2954 BFD_RELOC_PPC_GOT_TPREL16_LO
2955 ENUMX
2956 BFD_RELOC_PPC_GOT_TPREL16_HI
2957 ENUMX
2958 BFD_RELOC_PPC_GOT_TPREL16_HA
2959 ENUMX
2960 BFD_RELOC_PPC_GOT_DTPREL16
2961 ENUMX
2962 BFD_RELOC_PPC_GOT_DTPREL16_LO
2963 ENUMX
2964 BFD_RELOC_PPC_GOT_DTPREL16_HI
2965 ENUMX
2966 BFD_RELOC_PPC_GOT_DTPREL16_HA
2967 ENUMX
2968 BFD_RELOC_PPC64_TPREL16_DS
2969 ENUMX
2970 BFD_RELOC_PPC64_TPREL16_LO_DS
2971 ENUMX
2972 BFD_RELOC_PPC64_TPREL16_HIGHER
2973 ENUMX
2974 BFD_RELOC_PPC64_TPREL16_HIGHERA
2975 ENUMX
2976 BFD_RELOC_PPC64_TPREL16_HIGHEST
2977 ENUMX
2978 BFD_RELOC_PPC64_TPREL16_HIGHESTA
2979 ENUMX
2980 BFD_RELOC_PPC64_DTPREL16_DS
2981 ENUMX
2982 BFD_RELOC_PPC64_DTPREL16_LO_DS
2983 ENUMX
2984 BFD_RELOC_PPC64_DTPREL16_HIGHER
2985 ENUMX
2986 BFD_RELOC_PPC64_DTPREL16_HIGHERA
2987 ENUMX
2988 BFD_RELOC_PPC64_DTPREL16_HIGHEST
2989 ENUMX
2990 BFD_RELOC_PPC64_DTPREL16_HIGHESTA
2991 ENUMX
2992 BFD_RELOC_PPC64_TPREL16_HIGH
2993 ENUMX
2994 BFD_RELOC_PPC64_TPREL16_HIGHA
2995 ENUMX
2996 BFD_RELOC_PPC64_DTPREL16_HIGH
2997 ENUMX
2998 BFD_RELOC_PPC64_DTPREL16_HIGHA
2999 ENUMDOC
3000 PowerPC and PowerPC64 thread-local storage relocations.
3001
3002 ENUM
3003 BFD_RELOC_I370_D12
3004 ENUMDOC
3005 IBM 370/390 relocations
3006
3007 ENUM
3008 BFD_RELOC_CTOR
3009 ENUMDOC
3010 The type of reloc used to build a constructor table - at the moment
3011 probably a 32 bit wide absolute relocation, but the target can choose.
3012 It generally does map to one of the other relocation types.
3013
3014 ENUM
3015 BFD_RELOC_ARM_PCREL_BRANCH
3016 ENUMDOC
3017 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
3018 not stored in the instruction.
3019 ENUM
3020 BFD_RELOC_ARM_PCREL_BLX
3021 ENUMDOC
3022 ARM 26 bit pc-relative branch. The lowest bit must be zero and is
3023 not stored in the instruction. The 2nd lowest bit comes from a 1 bit
3024 field in the instruction.
3025 ENUM
3026 BFD_RELOC_THUMB_PCREL_BLX
3027 ENUMDOC
3028 Thumb 22 bit pc-relative branch. The lowest bit must be zero and is
3029 not stored in the instruction. The 2nd lowest bit comes from a 1 bit
3030 field in the instruction.
3031 ENUM
3032 BFD_RELOC_ARM_PCREL_CALL
3033 ENUMDOC
3034 ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction.
3035 ENUM
3036 BFD_RELOC_ARM_PCREL_JUMP
3037 ENUMDOC
3038 ARM 26-bit pc-relative branch for B or conditional BL instruction.
3039
3040 ENUM
3041 BFD_RELOC_THUMB_PCREL_BRANCH7
3042 ENUMX
3043 BFD_RELOC_THUMB_PCREL_BRANCH9
3044 ENUMX
3045 BFD_RELOC_THUMB_PCREL_BRANCH12
3046 ENUMX
3047 BFD_RELOC_THUMB_PCREL_BRANCH20
3048 ENUMX
3049 BFD_RELOC_THUMB_PCREL_BRANCH23
3050 ENUMX
3051 BFD_RELOC_THUMB_PCREL_BRANCH25
3052 ENUMDOC
3053 Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches.
3054 The lowest bit must be zero and is not stored in the instruction.
3055 Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an
3056 "nn" one smaller in all cases. Note further that BRANCH23
3057 corresponds to R_ARM_THM_CALL.
3058
3059 ENUM
3060 BFD_RELOC_ARM_OFFSET_IMM
3061 ENUMDOC
3062 12-bit immediate offset, used in ARM-format ldr and str instructions.
3063
3064 ENUM
3065 BFD_RELOC_ARM_THUMB_OFFSET
3066 ENUMDOC
3067 5-bit immediate offset, used in Thumb-format ldr and str instructions.
3068
3069 ENUM
3070 BFD_RELOC_ARM_TARGET1
3071 ENUMDOC
3072 Pc-relative or absolute relocation depending on target. Used for
3073 entries in .init_array sections.
3074 ENUM
3075 BFD_RELOC_ARM_ROSEGREL32
3076 ENUMDOC
3077 Read-only segment base relative address.
3078 ENUM
3079 BFD_RELOC_ARM_SBREL32
3080 ENUMDOC
3081 Data segment base relative address.
3082 ENUM
3083 BFD_RELOC_ARM_TARGET2
3084 ENUMDOC
3085 This reloc is used for references to RTTI data from exception handling
3086 tables. The actual definition depends on the target. It may be a
3087 pc-relative or some form of GOT-indirect relocation.
3088 ENUM
3089 BFD_RELOC_ARM_PREL31
3090 ENUMDOC
3091 31-bit PC relative address.
3092 ENUM
3093 BFD_RELOC_ARM_MOVW
3094 ENUMX
3095 BFD_RELOC_ARM_MOVT
3096 ENUMX
3097 BFD_RELOC_ARM_MOVW_PCREL
3098 ENUMX
3099 BFD_RELOC_ARM_MOVT_PCREL
3100 ENUMX
3101 BFD_RELOC_ARM_THUMB_MOVW
3102 ENUMX
3103 BFD_RELOC_ARM_THUMB_MOVT
3104 ENUMX
3105 BFD_RELOC_ARM_THUMB_MOVW_PCREL
3106 ENUMX
3107 BFD_RELOC_ARM_THUMB_MOVT_PCREL
3108 ENUMDOC
3109 Low and High halfword relocations for MOVW and MOVT instructions.
3110
3111 ENUM
3112 BFD_RELOC_ARM_JUMP_SLOT
3113 ENUMX
3114 BFD_RELOC_ARM_GLOB_DAT
3115 ENUMX
3116 BFD_RELOC_ARM_GOT32
3117 ENUMX
3118 BFD_RELOC_ARM_PLT32
3119 ENUMX
3120 BFD_RELOC_ARM_RELATIVE
3121 ENUMX
3122 BFD_RELOC_ARM_GOTOFF
3123 ENUMX
3124 BFD_RELOC_ARM_GOTPC
3125 ENUMX
3126 BFD_RELOC_ARM_GOT_PREL
3127 ENUMDOC
3128 Relocations for setting up GOTs and PLTs for shared libraries.
3129
3130 ENUM
3131 BFD_RELOC_ARM_TLS_GD32
3132 ENUMX
3133 BFD_RELOC_ARM_TLS_LDO32
3134 ENUMX
3135 BFD_RELOC_ARM_TLS_LDM32
3136 ENUMX
3137 BFD_RELOC_ARM_TLS_DTPOFF32
3138 ENUMX
3139 BFD_RELOC_ARM_TLS_DTPMOD32
3140 ENUMX
3141 BFD_RELOC_ARM_TLS_TPOFF32
3142 ENUMX
3143 BFD_RELOC_ARM_TLS_IE32
3144 ENUMX
3145 BFD_RELOC_ARM_TLS_LE32
3146 ENUMX
3147 BFD_RELOC_ARM_TLS_GOTDESC
3148 ENUMX
3149 BFD_RELOC_ARM_TLS_CALL
3150 ENUMX
3151 BFD_RELOC_ARM_THM_TLS_CALL
3152 ENUMX
3153 BFD_RELOC_ARM_TLS_DESCSEQ
3154 ENUMX
3155 BFD_RELOC_ARM_THM_TLS_DESCSEQ
3156 ENUMX
3157 BFD_RELOC_ARM_TLS_DESC
3158 ENUMDOC
3159 ARM thread-local storage relocations.
3160
3161 ENUM
3162 BFD_RELOC_ARM_ALU_PC_G0_NC
3163 ENUMX
3164 BFD_RELOC_ARM_ALU_PC_G0
3165 ENUMX
3166 BFD_RELOC_ARM_ALU_PC_G1_NC
3167 ENUMX
3168 BFD_RELOC_ARM_ALU_PC_G1
3169 ENUMX
3170 BFD_RELOC_ARM_ALU_PC_G2
3171 ENUMX
3172 BFD_RELOC_ARM_LDR_PC_G0
3173 ENUMX
3174 BFD_RELOC_ARM_LDR_PC_G1
3175 ENUMX
3176 BFD_RELOC_ARM_LDR_PC_G2
3177 ENUMX
3178 BFD_RELOC_ARM_LDRS_PC_G0
3179 ENUMX
3180 BFD_RELOC_ARM_LDRS_PC_G1
3181 ENUMX
3182 BFD_RELOC_ARM_LDRS_PC_G2
3183 ENUMX
3184 BFD_RELOC_ARM_LDC_PC_G0
3185 ENUMX
3186 BFD_RELOC_ARM_LDC_PC_G1
3187 ENUMX
3188 BFD_RELOC_ARM_LDC_PC_G2
3189 ENUMX
3190 BFD_RELOC_ARM_ALU_SB_G0_NC
3191 ENUMX
3192 BFD_RELOC_ARM_ALU_SB_G0
3193 ENUMX
3194 BFD_RELOC_ARM_ALU_SB_G1_NC
3195 ENUMX
3196 BFD_RELOC_ARM_ALU_SB_G1
3197 ENUMX
3198 BFD_RELOC_ARM_ALU_SB_G2
3199 ENUMX
3200 BFD_RELOC_ARM_LDR_SB_G0
3201 ENUMX
3202 BFD_RELOC_ARM_LDR_SB_G1
3203 ENUMX
3204 BFD_RELOC_ARM_LDR_SB_G2
3205 ENUMX
3206 BFD_RELOC_ARM_LDRS_SB_G0
3207 ENUMX
3208 BFD_RELOC_ARM_LDRS_SB_G1
3209 ENUMX
3210 BFD_RELOC_ARM_LDRS_SB_G2
3211 ENUMX
3212 BFD_RELOC_ARM_LDC_SB_G0
3213 ENUMX
3214 BFD_RELOC_ARM_LDC_SB_G1
3215 ENUMX
3216 BFD_RELOC_ARM_LDC_SB_G2
3217 ENUMDOC
3218 ARM group relocations.
3219
3220 ENUM
3221 BFD_RELOC_ARM_V4BX
3222 ENUMDOC
3223 Annotation of BX instructions.
3224
3225 ENUM
3226 BFD_RELOC_ARM_IRELATIVE
3227 ENUMDOC
3228 ARM support for STT_GNU_IFUNC.
3229
3230 ENUM
3231 BFD_RELOC_ARM_IMMEDIATE
3232 ENUMX
3233 BFD_RELOC_ARM_ADRL_IMMEDIATE
3234 ENUMX
3235 BFD_RELOC_ARM_T32_IMMEDIATE
3236 ENUMX
3237 BFD_RELOC_ARM_T32_ADD_IMM
3238 ENUMX
3239 BFD_RELOC_ARM_T32_IMM12
3240 ENUMX
3241 BFD_RELOC_ARM_T32_ADD_PC12
3242 ENUMX
3243 BFD_RELOC_ARM_SHIFT_IMM
3244 ENUMX
3245 BFD_RELOC_ARM_SMC
3246 ENUMX
3247 BFD_RELOC_ARM_HVC
3248 ENUMX
3249 BFD_RELOC_ARM_SWI
3250 ENUMX
3251 BFD_RELOC_ARM_MULTI
3252 ENUMX
3253 BFD_RELOC_ARM_CP_OFF_IMM
3254 ENUMX
3255 BFD_RELOC_ARM_CP_OFF_IMM_S2
3256 ENUMX
3257 BFD_RELOC_ARM_T32_CP_OFF_IMM
3258 ENUMX
3259 BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
3260 ENUMX
3261 BFD_RELOC_ARM_ADR_IMM
3262 ENUMX
3263 BFD_RELOC_ARM_LDR_IMM
3264 ENUMX
3265 BFD_RELOC_ARM_LITERAL
3266 ENUMX
3267 BFD_RELOC_ARM_IN_POOL
3268 ENUMX
3269 BFD_RELOC_ARM_OFFSET_IMM8
3270 ENUMX
3271 BFD_RELOC_ARM_T32_OFFSET_U8
3272 ENUMX
3273 BFD_RELOC_ARM_T32_OFFSET_IMM
3274 ENUMX
3275 BFD_RELOC_ARM_HWLITERAL
3276 ENUMX
3277 BFD_RELOC_ARM_THUMB_ADD
3278 ENUMX
3279 BFD_RELOC_ARM_THUMB_IMM
3280 ENUMX
3281 BFD_RELOC_ARM_THUMB_SHIFT
3282 ENUMDOC
3283 These relocs are only used within the ARM assembler. They are not
3284 (at present) written to any object files.
3285
3286 ENUM
3287 BFD_RELOC_SH_PCDISP8BY2
3288 ENUMX
3289 BFD_RELOC_SH_PCDISP12BY2
3290 ENUMX
3291 BFD_RELOC_SH_IMM3
3292 ENUMX
3293 BFD_RELOC_SH_IMM3U
3294 ENUMX
3295 BFD_RELOC_SH_DISP12
3296 ENUMX
3297 BFD_RELOC_SH_DISP12BY2
3298 ENUMX
3299 BFD_RELOC_SH_DISP12BY4
3300 ENUMX
3301 BFD_RELOC_SH_DISP12BY8
3302 ENUMX
3303 BFD_RELOC_SH_DISP20
3304 ENUMX
3305 BFD_RELOC_SH_DISP20BY8
3306 ENUMX
3307 BFD_RELOC_SH_IMM4
3308 ENUMX
3309 BFD_RELOC_SH_IMM4BY2
3310 ENUMX
3311 BFD_RELOC_SH_IMM4BY4
3312 ENUMX
3313 BFD_RELOC_SH_IMM8
3314 ENUMX
3315 BFD_RELOC_SH_IMM8BY2
3316 ENUMX
3317 BFD_RELOC_SH_IMM8BY4
3318 ENUMX
3319 BFD_RELOC_SH_PCRELIMM8BY2
3320 ENUMX
3321 BFD_RELOC_SH_PCRELIMM8BY4
3322 ENUMX
3323 BFD_RELOC_SH_SWITCH16
3324 ENUMX
3325 BFD_RELOC_SH_SWITCH32
3326 ENUMX
3327 BFD_RELOC_SH_USES
3328 ENUMX
3329 BFD_RELOC_SH_COUNT
3330 ENUMX
3331 BFD_RELOC_SH_ALIGN
3332 ENUMX
3333 BFD_RELOC_SH_CODE
3334 ENUMX
3335 BFD_RELOC_SH_DATA
3336 ENUMX
3337 BFD_RELOC_SH_LABEL
3338 ENUMX
3339 BFD_RELOC_SH_LOOP_START
3340 ENUMX
3341 BFD_RELOC_SH_LOOP_END
3342 ENUMX
3343 BFD_RELOC_SH_COPY
3344 ENUMX
3345 BFD_RELOC_SH_GLOB_DAT
3346 ENUMX
3347 BFD_RELOC_SH_JMP_SLOT
3348 ENUMX
3349 BFD_RELOC_SH_RELATIVE
3350 ENUMX
3351 BFD_RELOC_SH_GOTPC
3352 ENUMX
3353 BFD_RELOC_SH_GOT_LOW16
3354 ENUMX
3355 BFD_RELOC_SH_GOT_MEDLOW16
3356 ENUMX
3357 BFD_RELOC_SH_GOT_MEDHI16
3358 ENUMX
3359 BFD_RELOC_SH_GOT_HI16
3360 ENUMX
3361 BFD_RELOC_SH_GOTPLT_LOW16
3362 ENUMX
3363 BFD_RELOC_SH_GOTPLT_MEDLOW16
3364 ENUMX
3365 BFD_RELOC_SH_GOTPLT_MEDHI16
3366 ENUMX
3367 BFD_RELOC_SH_GOTPLT_HI16
3368 ENUMX
3369 BFD_RELOC_SH_PLT_LOW16
3370 ENUMX
3371 BFD_RELOC_SH_PLT_MEDLOW16
3372 ENUMX
3373 BFD_RELOC_SH_PLT_MEDHI16
3374 ENUMX
3375 BFD_RELOC_SH_PLT_HI16
3376 ENUMX
3377 BFD_RELOC_SH_GOTOFF_LOW16
3378 ENUMX
3379 BFD_RELOC_SH_GOTOFF_MEDLOW16
3380 ENUMX
3381 BFD_RELOC_SH_GOTOFF_MEDHI16
3382 ENUMX
3383 BFD_RELOC_SH_GOTOFF_HI16
3384 ENUMX
3385 BFD_RELOC_SH_GOTPC_LOW16
3386 ENUMX
3387 BFD_RELOC_SH_GOTPC_MEDLOW16
3388 ENUMX
3389 BFD_RELOC_SH_GOTPC_MEDHI16
3390 ENUMX
3391 BFD_RELOC_SH_GOTPC_HI16
3392 ENUMX
3393 BFD_RELOC_SH_COPY64
3394 ENUMX
3395 BFD_RELOC_SH_GLOB_DAT64
3396 ENUMX
3397 BFD_RELOC_SH_JMP_SLOT64
3398 ENUMX
3399 BFD_RELOC_SH_RELATIVE64
3400 ENUMX
3401 BFD_RELOC_SH_GOT10BY4
3402 ENUMX
3403 BFD_RELOC_SH_GOT10BY8
3404 ENUMX
3405 BFD_RELOC_SH_GOTPLT10BY4
3406 ENUMX
3407 BFD_RELOC_SH_GOTPLT10BY8
3408 ENUMX
3409 BFD_RELOC_SH_GOTPLT32
3410 ENUMX
3411 BFD_RELOC_SH_SHMEDIA_CODE
3412 ENUMX
3413 BFD_RELOC_SH_IMMU5
3414 ENUMX
3415 BFD_RELOC_SH_IMMS6
3416 ENUMX
3417 BFD_RELOC_SH_IMMS6BY32
3418 ENUMX
3419 BFD_RELOC_SH_IMMU6
3420 ENUMX
3421 BFD_RELOC_SH_IMMS10
3422 ENUMX
3423 BFD_RELOC_SH_IMMS10BY2
3424 ENUMX
3425 BFD_RELOC_SH_IMMS10BY4
3426 ENUMX
3427 BFD_RELOC_SH_IMMS10BY8
3428 ENUMX
3429 BFD_RELOC_SH_IMMS16
3430 ENUMX
3431 BFD_RELOC_SH_IMMU16
3432 ENUMX
3433 BFD_RELOC_SH_IMM_LOW16
3434 ENUMX
3435 BFD_RELOC_SH_IMM_LOW16_PCREL
3436 ENUMX
3437 BFD_RELOC_SH_IMM_MEDLOW16
3438 ENUMX
3439 BFD_RELOC_SH_IMM_MEDLOW16_PCREL
3440 ENUMX
3441 BFD_RELOC_SH_IMM_MEDHI16
3442 ENUMX
3443 BFD_RELOC_SH_IMM_MEDHI16_PCREL
3444 ENUMX
3445 BFD_RELOC_SH_IMM_HI16
3446 ENUMX
3447 BFD_RELOC_SH_IMM_HI16_PCREL
3448 ENUMX
3449 BFD_RELOC_SH_PT_16
3450 ENUMX
3451 BFD_RELOC_SH_TLS_GD_32
3452 ENUMX
3453 BFD_RELOC_SH_TLS_LD_32
3454 ENUMX
3455 BFD_RELOC_SH_TLS_LDO_32
3456 ENUMX
3457 BFD_RELOC_SH_TLS_IE_32
3458 ENUMX
3459 BFD_RELOC_SH_TLS_LE_32
3460 ENUMX
3461 BFD_RELOC_SH_TLS_DTPMOD32
3462 ENUMX
3463 BFD_RELOC_SH_TLS_DTPOFF32
3464 ENUMX
3465 BFD_RELOC_SH_TLS_TPOFF32
3466 ENUMX
3467 BFD_RELOC_SH_GOT20
3468 ENUMX
3469 BFD_RELOC_SH_GOTOFF20
3470 ENUMX
3471 BFD_RELOC_SH_GOTFUNCDESC
3472 ENUMX
3473 BFD_RELOC_SH_GOTFUNCDESC20
3474 ENUMX
3475 BFD_RELOC_SH_GOTOFFFUNCDESC
3476 ENUMX
3477 BFD_RELOC_SH_GOTOFFFUNCDESC20
3478 ENUMX
3479 BFD_RELOC_SH_FUNCDESC
3480 ENUMDOC
3481 Renesas / SuperH SH relocs. Not all of these appear in object files.
3482
3483 ENUM
3484 BFD_RELOC_ARC_B22_PCREL
3485 ENUMDOC
3486 ARC Cores relocs.
3487 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
3488 not stored in the instruction. The high 20 bits are installed in bits 26
3489 through 7 of the instruction.
3490 ENUM
3491 BFD_RELOC_ARC_B26
3492 ENUMDOC
3493 ARC 26 bit absolute branch. The lowest two bits must be zero and are not
3494 stored in the instruction. The high 24 bits are installed in bits 23
3495 through 0.
3496
3497 ENUM
3498 BFD_RELOC_BFIN_16_IMM
3499 ENUMDOC
3500 ADI Blackfin 16 bit immediate absolute reloc.
3501 ENUM
3502 BFD_RELOC_BFIN_16_HIGH
3503 ENUMDOC
3504 ADI Blackfin 16 bit immediate absolute reloc higher 16 bits.
3505 ENUM
3506 BFD_RELOC_BFIN_4_PCREL
3507 ENUMDOC
3508 ADI Blackfin 'a' part of LSETUP.
3509 ENUM
3510 BFD_RELOC_BFIN_5_PCREL
3511 ENUMDOC
3512 ADI Blackfin.
3513 ENUM
3514 BFD_RELOC_BFIN_16_LOW
3515 ENUMDOC
3516 ADI Blackfin 16 bit immediate absolute reloc lower 16 bits.
3517 ENUM
3518 BFD_RELOC_BFIN_10_PCREL
3519 ENUMDOC
3520 ADI Blackfin.
3521 ENUM
3522 BFD_RELOC_BFIN_11_PCREL
3523 ENUMDOC
3524 ADI Blackfin 'b' part of LSETUP.
3525 ENUM
3526 BFD_RELOC_BFIN_12_PCREL_JUMP
3527 ENUMDOC
3528 ADI Blackfin.
3529 ENUM
3530 BFD_RELOC_BFIN_12_PCREL_JUMP_S
3531 ENUMDOC
3532 ADI Blackfin Short jump, pcrel.
3533 ENUM
3534 BFD_RELOC_BFIN_24_PCREL_CALL_X
3535 ENUMDOC
3536 ADI Blackfin Call.x not implemented.
3537 ENUM
3538 BFD_RELOC_BFIN_24_PCREL_JUMP_L
3539 ENUMDOC
3540 ADI Blackfin Long Jump pcrel.
3541 ENUM
3542 BFD_RELOC_BFIN_GOT17M4
3543 ENUMX
3544 BFD_RELOC_BFIN_GOTHI
3545 ENUMX
3546 BFD_RELOC_BFIN_GOTLO
3547 ENUMX
3548 BFD_RELOC_BFIN_FUNCDESC
3549 ENUMX
3550 BFD_RELOC_BFIN_FUNCDESC_GOT17M4
3551 ENUMX
3552 BFD_RELOC_BFIN_FUNCDESC_GOTHI
3553 ENUMX
3554 BFD_RELOC_BFIN_FUNCDESC_GOTLO
3555 ENUMX
3556 BFD_RELOC_BFIN_FUNCDESC_VALUE
3557 ENUMX
3558 BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4
3559 ENUMX
3560 BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI
3561 ENUMX
3562 BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO
3563 ENUMX
3564 BFD_RELOC_BFIN_GOTOFF17M4
3565 ENUMX
3566 BFD_RELOC_BFIN_GOTOFFHI
3567 ENUMX
3568 BFD_RELOC_BFIN_GOTOFFLO
3569 ENUMDOC
3570 ADI Blackfin FD-PIC relocations.
3571 ENUM
3572 BFD_RELOC_BFIN_GOT
3573 ENUMDOC
3574 ADI Blackfin GOT relocation.
3575 ENUM
3576 BFD_RELOC_BFIN_PLTPC
3577 ENUMDOC
3578 ADI Blackfin PLTPC relocation.
3579 ENUM
3580 BFD_ARELOC_BFIN_PUSH
3581 ENUMDOC
3582 ADI Blackfin arithmetic relocation.
3583 ENUM
3584 BFD_ARELOC_BFIN_CONST
3585 ENUMDOC
3586 ADI Blackfin arithmetic relocation.
3587 ENUM
3588 BFD_ARELOC_BFIN_ADD
3589 ENUMDOC
3590 ADI Blackfin arithmetic relocation.
3591 ENUM
3592 BFD_ARELOC_BFIN_SUB
3593 ENUMDOC
3594 ADI Blackfin arithmetic relocation.
3595 ENUM
3596 BFD_ARELOC_BFIN_MULT
3597 ENUMDOC
3598 ADI Blackfin arithmetic relocation.
3599 ENUM
3600 BFD_ARELOC_BFIN_DIV
3601 ENUMDOC
3602 ADI Blackfin arithmetic relocation.
3603 ENUM
3604 BFD_ARELOC_BFIN_MOD
3605 ENUMDOC
3606 ADI Blackfin arithmetic relocation.
3607 ENUM
3608 BFD_ARELOC_BFIN_LSHIFT
3609 ENUMDOC
3610 ADI Blackfin arithmetic relocation.
3611 ENUM
3612 BFD_ARELOC_BFIN_RSHIFT
3613 ENUMDOC
3614 ADI Blackfin arithmetic relocation.
3615 ENUM
3616 BFD_ARELOC_BFIN_AND
3617 ENUMDOC
3618 ADI Blackfin arithmetic relocation.
3619 ENUM
3620 BFD_ARELOC_BFIN_OR
3621 ENUMDOC
3622 ADI Blackfin arithmetic relocation.
3623 ENUM
3624 BFD_ARELOC_BFIN_XOR
3625 ENUMDOC
3626 ADI Blackfin arithmetic relocation.
3627 ENUM
3628 BFD_ARELOC_BFIN_LAND
3629 ENUMDOC
3630 ADI Blackfin arithmetic relocation.
3631 ENUM
3632 BFD_ARELOC_BFIN_LOR
3633 ENUMDOC
3634 ADI Blackfin arithmetic relocation.
3635 ENUM
3636 BFD_ARELOC_BFIN_LEN
3637 ENUMDOC
3638 ADI Blackfin arithmetic relocation.
3639 ENUM
3640 BFD_ARELOC_BFIN_NEG
3641 ENUMDOC
3642 ADI Blackfin arithmetic relocation.
3643 ENUM
3644 BFD_ARELOC_BFIN_COMP
3645 ENUMDOC
3646 ADI Blackfin arithmetic relocation.
3647 ENUM
3648 BFD_ARELOC_BFIN_PAGE
3649 ENUMDOC
3650 ADI Blackfin arithmetic relocation.
3651 ENUM
3652 BFD_ARELOC_BFIN_HWPAGE
3653 ENUMDOC
3654 ADI Blackfin arithmetic relocation.
3655 ENUM
3656 BFD_ARELOC_BFIN_ADDR
3657 ENUMDOC
3658 ADI Blackfin arithmetic relocation.
3659
3660 ENUM
3661 BFD_RELOC_D10V_10_PCREL_R
3662 ENUMDOC
3663 Mitsubishi D10V relocs.
3664 This is a 10-bit reloc with the right 2 bits
3665 assumed to be 0.
3666 ENUM
3667 BFD_RELOC_D10V_10_PCREL_L
3668 ENUMDOC
3669 Mitsubishi D10V relocs.
3670 This is a 10-bit reloc with the right 2 bits
3671 assumed to be 0. This is the same as the previous reloc
3672 except it is in the left container, i.e.,
3673 shifted left 15 bits.
3674 ENUM
3675 BFD_RELOC_D10V_18
3676 ENUMDOC
3677 This is an 18-bit reloc with the right 2 bits
3678 assumed to be 0.
3679 ENUM
3680 BFD_RELOC_D10V_18_PCREL
3681 ENUMDOC
3682 This is an 18-bit reloc with the right 2 bits
3683 assumed to be 0.
3684
3685 ENUM
3686 BFD_RELOC_D30V_6
3687 ENUMDOC
3688 Mitsubishi D30V relocs.
3689 This is a 6-bit absolute reloc.
3690 ENUM
3691 BFD_RELOC_D30V_9_PCREL
3692 ENUMDOC
3693 This is a 6-bit pc-relative reloc with
3694 the right 3 bits assumed to be 0.
3695 ENUM
3696 BFD_RELOC_D30V_9_PCREL_R
3697 ENUMDOC
3698 This is a 6-bit pc-relative reloc with
3699 the right 3 bits assumed to be 0. Same
3700 as the previous reloc but on the right side
3701 of the container.
3702 ENUM
3703 BFD_RELOC_D30V_15
3704 ENUMDOC
3705 This is a 12-bit absolute reloc with the
3706 right 3 bitsassumed to be 0.
3707 ENUM
3708 BFD_RELOC_D30V_15_PCREL
3709 ENUMDOC
3710 This is a 12-bit pc-relative reloc with
3711 the right 3 bits assumed to be 0.
3712 ENUM
3713 BFD_RELOC_D30V_15_PCREL_R
3714 ENUMDOC
3715 This is a 12-bit pc-relative reloc with
3716 the right 3 bits assumed to be 0. Same
3717 as the previous reloc but on the right side
3718 of the container.
3719 ENUM
3720 BFD_RELOC_D30V_21
3721 ENUMDOC
3722 This is an 18-bit absolute reloc with
3723 the right 3 bits assumed to be 0.
3724 ENUM
3725 BFD_RELOC_D30V_21_PCREL
3726 ENUMDOC
3727 This is an 18-bit pc-relative reloc with
3728 the right 3 bits assumed to be 0.
3729 ENUM
3730 BFD_RELOC_D30V_21_PCREL_R
3731 ENUMDOC
3732 This is an 18-bit pc-relative reloc with
3733 the right 3 bits assumed to be 0. Same
3734 as the previous reloc but on the right side
3735 of the container.
3736 ENUM
3737 BFD_RELOC_D30V_32
3738 ENUMDOC
3739 This is a 32-bit absolute reloc.
3740 ENUM
3741 BFD_RELOC_D30V_32_PCREL
3742 ENUMDOC
3743 This is a 32-bit pc-relative reloc.
3744
3745 ENUM
3746 BFD_RELOC_DLX_HI16_S
3747 ENUMDOC
3748 DLX relocs
3749 ENUM
3750 BFD_RELOC_DLX_LO16
3751 ENUMDOC
3752 DLX relocs
3753 ENUM
3754 BFD_RELOC_DLX_JMP26
3755 ENUMDOC
3756 DLX relocs
3757
3758 ENUM
3759 BFD_RELOC_M32C_HI8
3760 ENUMX
3761 BFD_RELOC_M32C_RL_JUMP
3762 ENUMX
3763 BFD_RELOC_M32C_RL_1ADDR
3764 ENUMX
3765 BFD_RELOC_M32C_RL_2ADDR
3766 ENUMDOC
3767 Renesas M16C/M32C Relocations.
3768
3769 ENUM
3770 BFD_RELOC_M32R_24
3771 ENUMDOC
3772 Renesas M32R (formerly Mitsubishi M32R) relocs.
3773 This is a 24 bit absolute address.
3774 ENUM
3775 BFD_RELOC_M32R_10_PCREL
3776 ENUMDOC
3777 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
3778 ENUM
3779 BFD_RELOC_M32R_18_PCREL
3780 ENUMDOC
3781 This is an 18-bit reloc with the right 2 bits assumed to be 0.
3782 ENUM
3783 BFD_RELOC_M32R_26_PCREL
3784 ENUMDOC
3785 This is a 26-bit reloc with the right 2 bits assumed to be 0.
3786 ENUM
3787 BFD_RELOC_M32R_HI16_ULO
3788 ENUMDOC
3789 This is a 16-bit reloc containing the high 16 bits of an address
3790 used when the lower 16 bits are treated as unsigned.
3791 ENUM
3792 BFD_RELOC_M32R_HI16_SLO
3793 ENUMDOC
3794 This is a 16-bit reloc containing the high 16 bits of an address
3795 used when the lower 16 bits are treated as signed.
3796 ENUM
3797 BFD_RELOC_M32R_LO16
3798 ENUMDOC
3799 This is a 16-bit reloc containing the lower 16 bits of an address.
3800 ENUM
3801 BFD_RELOC_M32R_SDA16
3802 ENUMDOC
3803 This is a 16-bit reloc containing the small data area offset for use in
3804 add3, load, and store instructions.
3805 ENUM
3806 BFD_RELOC_M32R_GOT24
3807 ENUMX
3808 BFD_RELOC_M32R_26_PLTREL
3809 ENUMX
3810 BFD_RELOC_M32R_COPY
3811 ENUMX
3812 BFD_RELOC_M32R_GLOB_DAT
3813 ENUMX
3814 BFD_RELOC_M32R_JMP_SLOT
3815 ENUMX
3816 BFD_RELOC_M32R_RELATIVE
3817 ENUMX
3818 BFD_RELOC_M32R_GOTOFF
3819 ENUMX
3820 BFD_RELOC_M32R_GOTOFF_HI_ULO
3821 ENUMX
3822 BFD_RELOC_M32R_GOTOFF_HI_SLO
3823 ENUMX
3824 BFD_RELOC_M32R_GOTOFF_LO
3825 ENUMX
3826 BFD_RELOC_M32R_GOTPC24
3827 ENUMX
3828 BFD_RELOC_M32R_GOT16_HI_ULO
3829 ENUMX
3830 BFD_RELOC_M32R_GOT16_HI_SLO
3831 ENUMX
3832 BFD_RELOC_M32R_GOT16_LO
3833 ENUMX
3834 BFD_RELOC_M32R_GOTPC_HI_ULO
3835 ENUMX
3836 BFD_RELOC_M32R_GOTPC_HI_SLO
3837 ENUMX
3838 BFD_RELOC_M32R_GOTPC_LO
3839 ENUMDOC
3840 For PIC.
3841
3842
3843 ENUM
3844 BFD_RELOC_NDS32_20
3845 ENUMDOC
3846 NDS32 relocs.
3847 This is a 20 bit absolute address.
3848 ENUM
3849 BFD_RELOC_NDS32_9_PCREL
3850 ENUMDOC
3851 This is a 9-bit pc-relative reloc with the right 1 bit assumed to be 0.
3852 ENUM
3853 BFD_RELOC_NDS32_WORD_9_PCREL
3854 ENUMDOC
3855 This is a 9-bit pc-relative reloc with the right 1 bit assumed to be 0.
3856 ENUM
3857 BFD_RELOC_NDS32_15_PCREL
3858 ENUMDOC
3859 This is an 15-bit reloc with the right 1 bit assumed to be 0.
3860 ENUM
3861 BFD_RELOC_NDS32_17_PCREL
3862 ENUMDOC
3863 This is an 17-bit reloc with the right 1 bit assumed to be 0.
3864 ENUM
3865 BFD_RELOC_NDS32_25_PCREL
3866 ENUMDOC
3867 This is a 25-bit reloc with the right 1 bit assumed to be 0.
3868 ENUM
3869 BFD_RELOC_NDS32_HI20
3870 ENUMDOC
3871 This is a 20-bit reloc containing the high 20 bits of an address
3872 used with the lower 12 bits
3873 ENUM
3874 BFD_RELOC_NDS32_LO12S3
3875 ENUMDOC
3876 This is a 12-bit reloc containing the lower 12 bits of an address
3877 then shift right by 3. This is used with ldi,sdi...
3878 ENUM
3879 BFD_RELOC_NDS32_LO12S2
3880 ENUMDOC
3881 This is a 12-bit reloc containing the lower 12 bits of an address
3882 then shift left by 2. This is used with lwi,swi...
3883 ENUM
3884 BFD_RELOC_NDS32_LO12S1
3885 ENUMDOC
3886 This is a 12-bit reloc containing the lower 12 bits of an address
3887 then shift left by 1. This is used with lhi,shi...
3888 ENUM
3889 BFD_RELOC_NDS32_LO12S0
3890 ENUMDOC
3891 This is a 12-bit reloc containing the lower 12 bits of an address
3892 then shift left by 0. This is used with lbisbi...
3893 ENUM
3894 BFD_RELOC_NDS32_LO12S0_ORI
3895 ENUMDOC
3896 This is a 12-bit reloc containing the lower 12 bits of an address
3897 then shift left by 0. This is only used with branch relaxations
3898 ENUM
3899 BFD_RELOC_NDS32_SDA15S3
3900 ENUMDOC
3901 This is a 15-bit reloc containing the small data area 18-bit signed offset
3902 and shift left by 3 for use in ldi, sdi...
3903 ENUM
3904 BFD_RELOC_NDS32_SDA15S2
3905 ENUMDOC
3906 This is a 15-bit reloc containing the small data area 17-bit signed offset
3907 and shift left by 2 for use in lwi, swi...
3908 ENUM
3909 BFD_RELOC_NDS32_SDA15S1
3910 ENUMDOC
3911 This is a 15-bit reloc containing the small data area 16-bit signed offset
3912 and shift left by 1 for use in lhi, shi...
3913 ENUM
3914 BFD_RELOC_NDS32_SDA15S0
3915 ENUMDOC
3916 This is a 15-bit reloc containing the small data area 15-bit signed offset
3917 and shift left by 0 for use in lbi, sbi...
3918 ENUM
3919 BFD_RELOC_NDS32_SDA16S3
3920 ENUMDOC
3921 This is a 16-bit reloc containing the small data area 16-bit signed offset
3922 and shift left by 3
3923 ENUM
3924 BFD_RELOC_NDS32_SDA17S2
3925 ENUMDOC
3926 This is a 17-bit reloc containing the small data area 17-bit signed offset
3927 and shift left by 2 for use in lwi.gp, swi.gp...
3928 ENUM
3929 BFD_RELOC_NDS32_SDA18S1
3930 ENUMDOC
3931 This is a 18-bit reloc containing the small data area 18-bit signed offset
3932 and shift left by 1 for use in lhi.gp, shi.gp...
3933 ENUM
3934 BFD_RELOC_NDS32_SDA19S0
3935 ENUMDOC
3936 This is a 19-bit reloc containing the small data area 19-bit signed offset
3937 and shift left by 0 for use in lbi.gp, sbi.gp...
3938 ENUM
3939 BFD_RELOC_NDS32_GOT20
3940 ENUMX
3941 BFD_RELOC_NDS32_9_PLTREL
3942 ENUMX
3943 BFD_RELOC_NDS32_25_PLTREL
3944 ENUMX
3945 BFD_RELOC_NDS32_COPY
3946 ENUMX
3947 BFD_RELOC_NDS32_GLOB_DAT
3948 ENUMX
3949 BFD_RELOC_NDS32_JMP_SLOT
3950 ENUMX
3951 BFD_RELOC_NDS32_RELATIVE
3952 ENUMX
3953 BFD_RELOC_NDS32_GOTOFF
3954 ENUMX
3955 BFD_RELOC_NDS32_GOTOFF_HI20
3956 ENUMX
3957 BFD_RELOC_NDS32_GOTOFF_LO12
3958 ENUMX
3959 BFD_RELOC_NDS32_GOTPC20
3960 ENUMX
3961 BFD_RELOC_NDS32_GOT_HI20
3962 ENUMX
3963 BFD_RELOC_NDS32_GOT_LO12
3964 ENUMX
3965 BFD_RELOC_NDS32_GOTPC_HI20
3966 ENUMX
3967 BFD_RELOC_NDS32_GOTPC_LO12
3968 ENUMDOC
3969 for PIC
3970 ENUM
3971 BFD_RELOC_NDS32_INSN16
3972 ENUMX
3973 BFD_RELOC_NDS32_LABEL
3974 ENUMX
3975 BFD_RELOC_NDS32_LONGCALL1
3976 ENUMX
3977 BFD_RELOC_NDS32_LONGCALL2
3978 ENUMX
3979 BFD_RELOC_NDS32_LONGCALL3
3980 ENUMX
3981 BFD_RELOC_NDS32_LONGJUMP1
3982 ENUMX
3983 BFD_RELOC_NDS32_LONGJUMP2
3984 ENUMX
3985 BFD_RELOC_NDS32_LONGJUMP3
3986 ENUMX
3987 BFD_RELOC_NDS32_LOADSTORE
3988 ENUMX
3989 BFD_RELOC_NDS32_9_FIXED
3990 ENUMX
3991 BFD_RELOC_NDS32_15_FIXED
3992 ENUMX
3993 BFD_RELOC_NDS32_17_FIXED
3994 ENUMX
3995 BFD_RELOC_NDS32_25_FIXED
3996 ENUMDOC
3997 for relax
3998 ENUM
3999 BFD_RELOC_NDS32_PLTREL_HI20
4000 ENUMX
4001 BFD_RELOC_NDS32_PLTREL_LO12
4002 ENUMX
4003 BFD_RELOC_NDS32_PLT_GOTREL_HI20
4004 ENUMX
4005 BFD_RELOC_NDS32_PLT_GOTREL_LO12
4006 ENUMDOC
4007 for PIC
4008 ENUM
4009 BFD_RELOC_NDS32_SDA12S2_DP
4010 ENUMX
4011 BFD_RELOC_NDS32_SDA12S2_SP
4012 ENUMX
4013 BFD_RELOC_NDS32_LO12S2_DP
4014 ENUMX
4015 BFD_RELOC_NDS32_LO12S2_SP
4016 ENUMDOC
4017 for floating point
4018 ENUM
4019 BFD_RELOC_NDS32_DWARF2_OP1
4020 ENUMX
4021 BFD_RELOC_NDS32_DWARF2_OP2
4022 ENUMX
4023 BFD_RELOC_NDS32_DWARF2_LEB
4024 ENUMDOC
4025 for dwarf2 debug_line.
4026 ENUM
4027 BFD_RELOC_NDS32_UPDATE_TA
4028 ENUMDOC
4029 for eliminate 16-bit instructions
4030 ENUM
4031 BFD_RELOC_NDS32_PLT_GOTREL_LO20
4032 ENUMX
4033 BFD_RELOC_NDS32_PLT_GOTREL_LO15
4034 ENUMX
4035 BFD_RELOC_NDS32_PLT_GOTREL_LO19
4036 ENUMX
4037 BFD_RELOC_NDS32_GOT_LO15
4038 ENUMX
4039 BFD_RELOC_NDS32_GOT_LO19
4040 ENUMX
4041 BFD_RELOC_NDS32_GOTOFF_LO15
4042 ENUMX
4043 BFD_RELOC_NDS32_GOTOFF_LO19
4044 ENUMX
4045 BFD_RELOC_NDS32_GOT15S2
4046 ENUMX
4047 BFD_RELOC_NDS32_GOT17S2
4048 ENUMDOC
4049 for PIC object relaxation
4050 ENUM
4051 BFD_RELOC_NDS32_5
4052 ENUMDOC
4053 NDS32 relocs.
4054 This is a 5 bit absolute address.
4055 ENUM
4056 BFD_RELOC_NDS32_10_UPCREL
4057 ENUMDOC
4058 This is a 10-bit unsigned pc-relative reloc with the right 1 bit assumed to be 0.
4059 ENUM
4060 BFD_RELOC_NDS32_SDA_FP7U2_RELA
4061 ENUMDOC
4062 If fp were omitted, fp can used as another gp.
4063 ENUM
4064 BFD_RELOC_NDS32_RELAX_ENTRY
4065 ENUMX
4066 BFD_RELOC_NDS32_GOT_SUFF
4067 ENUMX
4068 BFD_RELOC_NDS32_GOTOFF_SUFF
4069 ENUMX
4070 BFD_RELOC_NDS32_PLT_GOT_SUFF
4071 ENUMX
4072 BFD_RELOC_NDS32_MULCALL_SUFF
4073 ENUMX
4074 BFD_RELOC_NDS32_PTR
4075 ENUMX
4076 BFD_RELOC_NDS32_PTR_COUNT
4077 ENUMX
4078 BFD_RELOC_NDS32_PTR_RESOLVED
4079 ENUMX
4080 BFD_RELOC_NDS32_PLTBLOCK
4081 ENUMX
4082 BFD_RELOC_NDS32_RELAX_REGION_BEGIN
4083 ENUMX
4084 BFD_RELOC_NDS32_RELAX_REGION_END
4085 ENUMX
4086 BFD_RELOC_NDS32_MINUEND
4087 ENUMX
4088 BFD_RELOC_NDS32_SUBTRAHEND
4089 ENUMX
4090 BFD_RELOC_NDS32_DIFF8
4091 ENUMX
4092 BFD_RELOC_NDS32_DIFF16
4093 ENUMX
4094 BFD_RELOC_NDS32_DIFF32
4095 ENUMX
4096 BFD_RELOC_NDS32_DIFF_ULEB128
4097 ENUMX
4098 BFD_RELOC_NDS32_25_ABS
4099 ENUMX
4100 BFD_RELOC_NDS32_DATA
4101 ENUMX
4102 BFD_RELOC_NDS32_TRAN
4103 ENUMX
4104 BFD_RELOC_NDS32_17IFC_PCREL
4105 ENUMX
4106 BFD_RELOC_NDS32_10IFCU_PCREL
4107 ENUMDOC
4108 relaxation relative relocation types
4109
4110
4111 ENUM
4112 BFD_RELOC_V850_9_PCREL
4113 ENUMDOC
4114 This is a 9-bit reloc
4115 ENUM
4116 BFD_RELOC_V850_22_PCREL
4117 ENUMDOC
4118 This is a 22-bit reloc
4119
4120 ENUM
4121 BFD_RELOC_V850_SDA_16_16_OFFSET
4122 ENUMDOC
4123 This is a 16 bit offset from the short data area pointer.
4124 ENUM
4125 BFD_RELOC_V850_SDA_15_16_OFFSET
4126 ENUMDOC
4127 This is a 16 bit offset (of which only 15 bits are used) from the
4128 short data area pointer.
4129 ENUM
4130 BFD_RELOC_V850_ZDA_16_16_OFFSET
4131 ENUMDOC
4132 This is a 16 bit offset from the zero data area pointer.
4133 ENUM
4134 BFD_RELOC_V850_ZDA_15_16_OFFSET
4135 ENUMDOC
4136 This is a 16 bit offset (of which only 15 bits are used) from the
4137 zero data area pointer.
4138 ENUM
4139 BFD_RELOC_V850_TDA_6_8_OFFSET
4140 ENUMDOC
4141 This is an 8 bit offset (of which only 6 bits are used) from the
4142 tiny data area pointer.
4143 ENUM
4144 BFD_RELOC_V850_TDA_7_8_OFFSET
4145 ENUMDOC
4146 This is an 8bit offset (of which only 7 bits are used) from the tiny
4147 data area pointer.
4148 ENUM
4149 BFD_RELOC_V850_TDA_7_7_OFFSET
4150 ENUMDOC
4151 This is a 7 bit offset from the tiny data area pointer.
4152 ENUM
4153 BFD_RELOC_V850_TDA_16_16_OFFSET
4154 ENUMDOC
4155 This is a 16 bit offset from the tiny data area pointer.
4156 COMMENT
4157 ENUM
4158 BFD_RELOC_V850_TDA_4_5_OFFSET
4159 ENUMDOC
4160 This is a 5 bit offset (of which only 4 bits are used) from the tiny
4161 data area pointer.
4162 ENUM
4163 BFD_RELOC_V850_TDA_4_4_OFFSET
4164 ENUMDOC
4165 This is a 4 bit offset from the tiny data area pointer.
4166 ENUM
4167 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
4168 ENUMDOC
4169 This is a 16 bit offset from the short data area pointer, with the
4170 bits placed non-contiguously in the instruction.
4171 ENUM
4172 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
4173 ENUMDOC
4174 This is a 16 bit offset from the zero data area pointer, with the
4175 bits placed non-contiguously in the instruction.
4176 ENUM
4177 BFD_RELOC_V850_CALLT_6_7_OFFSET
4178 ENUMDOC
4179 This is a 6 bit offset from the call table base pointer.
4180 ENUM
4181 BFD_RELOC_V850_CALLT_16_16_OFFSET
4182 ENUMDOC
4183 This is a 16 bit offset from the call table base pointer.
4184 ENUM
4185 BFD_RELOC_V850_LONGCALL
4186 ENUMDOC
4187 Used for relaxing indirect function calls.
4188 ENUM
4189 BFD_RELOC_V850_LONGJUMP
4190 ENUMDOC
4191 Used for relaxing indirect jumps.
4192 ENUM
4193 BFD_RELOC_V850_ALIGN
4194 ENUMDOC
4195 Used to maintain alignment whilst relaxing.
4196 ENUM
4197 BFD_RELOC_V850_LO16_SPLIT_OFFSET
4198 ENUMDOC
4199 This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu
4200 instructions.
4201 ENUM
4202 BFD_RELOC_V850_16_PCREL
4203 ENUMDOC
4204 This is a 16-bit reloc.
4205 ENUM
4206 BFD_RELOC_V850_17_PCREL
4207 ENUMDOC
4208 This is a 17-bit reloc.
4209 ENUM
4210 BFD_RELOC_V850_23
4211 ENUMDOC
4212 This is a 23-bit reloc.
4213 ENUM
4214 BFD_RELOC_V850_32_PCREL
4215 ENUMDOC
4216 This is a 32-bit reloc.
4217 ENUM
4218 BFD_RELOC_V850_32_ABS
4219 ENUMDOC
4220 This is a 32-bit reloc.
4221 ENUM
4222 BFD_RELOC_V850_16_SPLIT_OFFSET
4223 ENUMDOC
4224 This is a 16-bit reloc.
4225 ENUM
4226 BFD_RELOC_V850_16_S1
4227 ENUMDOC
4228 This is a 16-bit reloc.
4229 ENUM
4230 BFD_RELOC_V850_LO16_S1
4231 ENUMDOC
4232 Low 16 bits. 16 bit shifted by 1.
4233 ENUM
4234 BFD_RELOC_V850_CALLT_15_16_OFFSET
4235 ENUMDOC
4236 This is a 16 bit offset from the call table base pointer.
4237 ENUM
4238 BFD_RELOC_V850_32_GOTPCREL
4239 ENUMDOC
4240 DSO relocations.
4241 ENUM
4242 BFD_RELOC_V850_16_GOT
4243 ENUMDOC
4244 DSO relocations.
4245 ENUM
4246 BFD_RELOC_V850_32_GOT
4247 ENUMDOC
4248 DSO relocations.
4249 ENUM
4250 BFD_RELOC_V850_22_PLT_PCREL
4251 ENUMDOC
4252 DSO relocations.
4253 ENUM
4254 BFD_RELOC_V850_32_PLT_PCREL
4255 ENUMDOC
4256 DSO relocations.
4257 ENUM
4258 BFD_RELOC_V850_COPY
4259 ENUMDOC
4260 DSO relocations.
4261 ENUM
4262 BFD_RELOC_V850_GLOB_DAT
4263 ENUMDOC
4264 DSO relocations.
4265 ENUM
4266 BFD_RELOC_V850_JMP_SLOT
4267 ENUMDOC
4268 DSO relocations.
4269 ENUM
4270 BFD_RELOC_V850_RELATIVE
4271 ENUMDOC
4272 DSO relocations.
4273 ENUM
4274 BFD_RELOC_V850_16_GOTOFF
4275 ENUMDOC
4276 DSO relocations.
4277 ENUM
4278 BFD_RELOC_V850_32_GOTOFF
4279 ENUMDOC
4280 DSO relocations.
4281 ENUM
4282 BFD_RELOC_V850_CODE
4283 ENUMDOC
4284 start code.
4285 ENUM
4286 BFD_RELOC_V850_DATA
4287 ENUMDOC
4288 start data in text.
4289
4290 ENUM
4291 BFD_RELOC_TIC30_LDP
4292 ENUMDOC
4293 This is a 8bit DP reloc for the tms320c30, where the most
4294 significant 8 bits of a 24 bit word are placed into the least
4295 significant 8 bits of the opcode.
4296
4297 ENUM
4298 BFD_RELOC_TIC54X_PARTLS7
4299 ENUMDOC
4300 This is a 7bit reloc for the tms320c54x, where the least
4301 significant 7 bits of a 16 bit word are placed into the least
4302 significant 7 bits of the opcode.
4303
4304 ENUM
4305 BFD_RELOC_TIC54X_PARTMS9
4306 ENUMDOC
4307 This is a 9bit DP reloc for the tms320c54x, where the most
4308 significant 9 bits of a 16 bit word are placed into the least
4309 significant 9 bits of the opcode.
4310
4311 ENUM
4312 BFD_RELOC_TIC54X_23
4313 ENUMDOC
4314 This is an extended address 23-bit reloc for the tms320c54x.
4315
4316 ENUM
4317 BFD_RELOC_TIC54X_16_OF_23
4318 ENUMDOC
4319 This is a 16-bit reloc for the tms320c54x, where the least
4320 significant 16 bits of a 23-bit extended address are placed into
4321 the opcode.
4322
4323 ENUM
4324 BFD_RELOC_TIC54X_MS7_OF_23
4325 ENUMDOC
4326 This is a reloc for the tms320c54x, where the most
4327 significant 7 bits of a 23-bit extended address are placed into
4328 the opcode.
4329
4330 ENUM
4331 BFD_RELOC_C6000_PCR_S21
4332 ENUMX
4333 BFD_RELOC_C6000_PCR_S12
4334 ENUMX
4335 BFD_RELOC_C6000_PCR_S10
4336 ENUMX
4337 BFD_RELOC_C6000_PCR_S7
4338 ENUMX
4339 BFD_RELOC_C6000_ABS_S16
4340 ENUMX
4341 BFD_RELOC_C6000_ABS_L16
4342 ENUMX
4343 BFD_RELOC_C6000_ABS_H16
4344 ENUMX
4345 BFD_RELOC_C6000_SBR_U15_B
4346 ENUMX
4347 BFD_RELOC_C6000_SBR_U15_H
4348 ENUMX
4349 BFD_RELOC_C6000_SBR_U15_W
4350 ENUMX
4351 BFD_RELOC_C6000_SBR_S16
4352 ENUMX
4353 BFD_RELOC_C6000_SBR_L16_B
4354 ENUMX
4355 BFD_RELOC_C6000_SBR_L16_H
4356 ENUMX
4357 BFD_RELOC_C6000_SBR_L16_W
4358 ENUMX
4359 BFD_RELOC_C6000_SBR_H16_B
4360 ENUMX
4361 BFD_RELOC_C6000_SBR_H16_H
4362 ENUMX
4363 BFD_RELOC_C6000_SBR_H16_W
4364 ENUMX
4365 BFD_RELOC_C6000_SBR_GOT_U15_W
4366 ENUMX
4367 BFD_RELOC_C6000_SBR_GOT_L16_W
4368 ENUMX
4369 BFD_RELOC_C6000_SBR_GOT_H16_W
4370 ENUMX
4371 BFD_RELOC_C6000_DSBT_INDEX
4372 ENUMX
4373 BFD_RELOC_C6000_PREL31
4374 ENUMX
4375 BFD_RELOC_C6000_COPY
4376 ENUMX
4377 BFD_RELOC_C6000_JUMP_SLOT
4378 ENUMX
4379 BFD_RELOC_C6000_EHTYPE
4380 ENUMX
4381 BFD_RELOC_C6000_PCR_H16
4382 ENUMX
4383 BFD_RELOC_C6000_PCR_L16
4384 ENUMX
4385 BFD_RELOC_C6000_ALIGN
4386 ENUMX
4387 BFD_RELOC_C6000_FPHEAD
4388 ENUMX
4389 BFD_RELOC_C6000_NOCMP
4390 ENUMDOC
4391 TMS320C6000 relocations.
4392
4393 ENUM
4394 BFD_RELOC_FR30_48
4395 ENUMDOC
4396 This is a 48 bit reloc for the FR30 that stores 32 bits.
4397 ENUM
4398 BFD_RELOC_FR30_20
4399 ENUMDOC
4400 This is a 32 bit reloc for the FR30 that stores 20 bits split up into
4401 two sections.
4402 ENUM
4403 BFD_RELOC_FR30_6_IN_4
4404 ENUMDOC
4405 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
4406 4 bits.
4407 ENUM
4408 BFD_RELOC_FR30_8_IN_8
4409 ENUMDOC
4410 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
4411 into 8 bits.
4412 ENUM
4413 BFD_RELOC_FR30_9_IN_8
4414 ENUMDOC
4415 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
4416 into 8 bits.
4417 ENUM
4418 BFD_RELOC_FR30_10_IN_8
4419 ENUMDOC
4420 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
4421 into 8 bits.
4422 ENUM
4423 BFD_RELOC_FR30_9_PCREL
4424 ENUMDOC
4425 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
4426 short offset into 8 bits.
4427 ENUM
4428 BFD_RELOC_FR30_12_PCREL
4429 ENUMDOC
4430 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
4431 short offset into 11 bits.
4432
4433 ENUM
4434 BFD_RELOC_MCORE_PCREL_IMM8BY4
4435 ENUMX
4436 BFD_RELOC_MCORE_PCREL_IMM11BY2
4437 ENUMX
4438 BFD_RELOC_MCORE_PCREL_IMM4BY2
4439 ENUMX
4440 BFD_RELOC_MCORE_PCREL_32
4441 ENUMX
4442 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
4443 ENUMX
4444 BFD_RELOC_MCORE_RVA
4445 ENUMDOC
4446 Motorola Mcore relocations.
4447
4448 ENUM
4449 BFD_RELOC_MEP_8
4450 ENUMX
4451 BFD_RELOC_MEP_16
4452 ENUMX
4453 BFD_RELOC_MEP_32
4454 ENUMX
4455 BFD_RELOC_MEP_PCREL8A2
4456 ENUMX
4457 BFD_RELOC_MEP_PCREL12A2
4458 ENUMX
4459 BFD_RELOC_MEP_PCREL17A2
4460 ENUMX
4461 BFD_RELOC_MEP_PCREL24A2
4462 ENUMX
4463 BFD_RELOC_MEP_PCABS24A2
4464 ENUMX
4465 BFD_RELOC_MEP_LOW16
4466 ENUMX
4467 BFD_RELOC_MEP_HI16U
4468 ENUMX
4469 BFD_RELOC_MEP_HI16S
4470 ENUMX
4471 BFD_RELOC_MEP_GPREL
4472 ENUMX
4473 BFD_RELOC_MEP_TPREL
4474 ENUMX
4475 BFD_RELOC_MEP_TPREL7
4476 ENUMX
4477 BFD_RELOC_MEP_TPREL7A2
4478 ENUMX
4479 BFD_RELOC_MEP_TPREL7A4
4480 ENUMX
4481 BFD_RELOC_MEP_UIMM24
4482 ENUMX
4483 BFD_RELOC_MEP_ADDR24A4
4484 ENUMX
4485 BFD_RELOC_MEP_GNU_VTINHERIT
4486 ENUMX
4487 BFD_RELOC_MEP_GNU_VTENTRY
4488 ENUMDOC
4489 Toshiba Media Processor Relocations.
4490 COMMENT
4491
4492 ENUM
4493 BFD_RELOC_METAG_HIADDR16
4494 ENUMX
4495 BFD_RELOC_METAG_LOADDR16
4496 ENUMX
4497 BFD_RELOC_METAG_RELBRANCH
4498 ENUMX
4499 BFD_RELOC_METAG_GETSETOFF
4500 ENUMX
4501 BFD_RELOC_METAG_HIOG
4502 ENUMX
4503 BFD_RELOC_METAG_LOOG
4504 ENUMX
4505 BFD_RELOC_METAG_REL8
4506 ENUMX
4507 BFD_RELOC_METAG_REL16
4508 ENUMX
4509 BFD_RELOC_METAG_HI16_GOTOFF
4510 ENUMX
4511 BFD_RELOC_METAG_LO16_GOTOFF
4512 ENUMX
4513 BFD_RELOC_METAG_GETSET_GOTOFF
4514 ENUMX
4515 BFD_RELOC_METAG_GETSET_GOT
4516 ENUMX
4517 BFD_RELOC_METAG_HI16_GOTPC
4518 ENUMX
4519 BFD_RELOC_METAG_LO16_GOTPC
4520 ENUMX
4521 BFD_RELOC_METAG_HI16_PLT
4522 ENUMX
4523 BFD_RELOC_METAG_LO16_PLT
4524 ENUMX
4525 BFD_RELOC_METAG_RELBRANCH_PLT
4526 ENUMX
4527 BFD_RELOC_METAG_GOTOFF
4528 ENUMX
4529 BFD_RELOC_METAG_PLT
4530 ENUMX
4531 BFD_RELOC_METAG_COPY
4532 ENUMX
4533 BFD_RELOC_METAG_JMP_SLOT
4534 ENUMX
4535 BFD_RELOC_METAG_RELATIVE
4536 ENUMX
4537 BFD_RELOC_METAG_GLOB_DAT
4538 ENUMX
4539 BFD_RELOC_METAG_TLS_GD
4540 ENUMX
4541 BFD_RELOC_METAG_TLS_LDM
4542 ENUMX
4543 BFD_RELOC_METAG_TLS_LDO_HI16
4544 ENUMX
4545 BFD_RELOC_METAG_TLS_LDO_LO16
4546 ENUMX
4547 BFD_RELOC_METAG_TLS_LDO
4548 ENUMX
4549 BFD_RELOC_METAG_TLS_IE
4550 ENUMX
4551 BFD_RELOC_METAG_TLS_IENONPIC
4552 ENUMX
4553 BFD_RELOC_METAG_TLS_IENONPIC_HI16
4554 ENUMX
4555 BFD_RELOC_METAG_TLS_IENONPIC_LO16
4556 ENUMX
4557 BFD_RELOC_METAG_TLS_TPOFF
4558 ENUMX
4559 BFD_RELOC_METAG_TLS_DTPMOD
4560 ENUMX
4561 BFD_RELOC_METAG_TLS_DTPOFF
4562 ENUMX
4563 BFD_RELOC_METAG_TLS_LE
4564 ENUMX
4565 BFD_RELOC_METAG_TLS_LE_HI16
4566 ENUMX
4567 BFD_RELOC_METAG_TLS_LE_LO16
4568 ENUMDOC
4569 Imagination Technologies Meta relocations.
4570
4571 ENUM
4572 BFD_RELOC_MMIX_GETA
4573 ENUMX
4574 BFD_RELOC_MMIX_GETA_1
4575 ENUMX
4576 BFD_RELOC_MMIX_GETA_2
4577 ENUMX
4578 BFD_RELOC_MMIX_GETA_3
4579 ENUMDOC
4580 These are relocations for the GETA instruction.
4581 ENUM
4582 BFD_RELOC_MMIX_CBRANCH
4583 ENUMX
4584 BFD_RELOC_MMIX_CBRANCH_J
4585 ENUMX
4586 BFD_RELOC_MMIX_CBRANCH_1
4587 ENUMX
4588 BFD_RELOC_MMIX_CBRANCH_2
4589 ENUMX
4590 BFD_RELOC_MMIX_CBRANCH_3
4591 ENUMDOC
4592 These are relocations for a conditional branch instruction.
4593 ENUM
4594 BFD_RELOC_MMIX_PUSHJ
4595 ENUMX
4596 BFD_RELOC_MMIX_PUSHJ_1
4597 ENUMX
4598 BFD_RELOC_MMIX_PUSHJ_2
4599 ENUMX
4600 BFD_RELOC_MMIX_PUSHJ_3
4601 ENUMX
4602 BFD_RELOC_MMIX_PUSHJ_STUBBABLE
4603 ENUMDOC
4604 These are relocations for the PUSHJ instruction.
4605 ENUM
4606 BFD_RELOC_MMIX_JMP
4607 ENUMX
4608 BFD_RELOC_MMIX_JMP_1
4609 ENUMX
4610 BFD_RELOC_MMIX_JMP_2
4611 ENUMX
4612 BFD_RELOC_MMIX_JMP_3
4613 ENUMDOC
4614 These are relocations for the JMP instruction.
4615 ENUM
4616 BFD_RELOC_MMIX_ADDR19
4617 ENUMDOC
4618 This is a relocation for a relative address as in a GETA instruction or
4619 a branch.
4620 ENUM
4621 BFD_RELOC_MMIX_ADDR27
4622 ENUMDOC
4623 This is a relocation for a relative address as in a JMP instruction.
4624 ENUM
4625 BFD_RELOC_MMIX_REG_OR_BYTE
4626 ENUMDOC
4627 This is a relocation for an instruction field that may be a general
4628 register or a value 0..255.
4629 ENUM
4630 BFD_RELOC_MMIX_REG
4631 ENUMDOC
4632 This is a relocation for an instruction field that may be a general
4633 register.
4634 ENUM
4635 BFD_RELOC_MMIX_BASE_PLUS_OFFSET
4636 ENUMDOC
4637 This is a relocation for two instruction fields holding a register and
4638 an offset, the equivalent of the relocation.
4639 ENUM
4640 BFD_RELOC_MMIX_LOCAL
4641 ENUMDOC
4642 This relocation is an assertion that the expression is not allocated as
4643 a global register. It does not modify contents.
4644
4645 ENUM
4646 BFD_RELOC_AVR_7_PCREL
4647 ENUMDOC
4648 This is a 16 bit reloc for the AVR that stores 8 bit pc relative
4649 short offset into 7 bits.
4650 ENUM
4651 BFD_RELOC_AVR_13_PCREL
4652 ENUMDOC
4653 This is a 16 bit reloc for the AVR that stores 13 bit pc relative
4654 short offset into 12 bits.
4655 ENUM
4656 BFD_RELOC_AVR_16_PM
4657 ENUMDOC
4658 This is a 16 bit reloc for the AVR that stores 17 bit value (usually
4659 program memory address) into 16 bits.
4660 ENUM
4661 BFD_RELOC_AVR_LO8_LDI
4662 ENUMDOC
4663 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
4664 data memory address) into 8 bit immediate value of LDI insn.
4665 ENUM
4666 BFD_RELOC_AVR_HI8_LDI
4667 ENUMDOC
4668 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4669 of data memory address) into 8 bit immediate value of LDI insn.
4670 ENUM
4671 BFD_RELOC_AVR_HH8_LDI
4672 ENUMDOC
4673 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4674 of program memory address) into 8 bit immediate value of LDI insn.
4675 ENUM
4676 BFD_RELOC_AVR_MS8_LDI
4677 ENUMDOC
4678 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4679 of 32 bit value) into 8 bit immediate value of LDI insn.
4680 ENUM
4681 BFD_RELOC_AVR_LO8_LDI_NEG
4682 ENUMDOC
4683 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4684 (usually data memory address) into 8 bit immediate value of SUBI insn.
4685 ENUM
4686 BFD_RELOC_AVR_HI8_LDI_NEG
4687 ENUMDOC
4688 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4689 (high 8 bit of data memory address) into 8 bit immediate value of
4690 SUBI insn.
4691 ENUM
4692 BFD_RELOC_AVR_HH8_LDI_NEG
4693 ENUMDOC
4694 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4695 (most high 8 bit of program memory address) into 8 bit immediate value
4696 of LDI or SUBI insn.
4697 ENUM
4698 BFD_RELOC_AVR_MS8_LDI_NEG
4699 ENUMDOC
4700 This is a 16 bit reloc for the AVR that stores negated 8 bit value (msb
4701 of 32 bit value) into 8 bit immediate value of LDI insn.
4702 ENUM
4703 BFD_RELOC_AVR_LO8_LDI_PM
4704 ENUMDOC
4705 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
4706 command address) into 8 bit immediate value of LDI insn.
4707 ENUM
4708 BFD_RELOC_AVR_LO8_LDI_GS
4709 ENUMDOC
4710 This is a 16 bit reloc for the AVR that stores 8 bit value
4711 (command address) into 8 bit immediate value of LDI insn. If the address
4712 is beyond the 128k boundary, the linker inserts a jump stub for this reloc
4713 in the lower 128k.
4714 ENUM
4715 BFD_RELOC_AVR_HI8_LDI_PM
4716 ENUMDOC
4717 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4718 of command address) into 8 bit immediate value of LDI insn.
4719 ENUM
4720 BFD_RELOC_AVR_HI8_LDI_GS
4721 ENUMDOC
4722 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4723 of command address) into 8 bit immediate value of LDI insn. If the address
4724 is beyond the 128k boundary, the linker inserts a jump stub for this reloc
4725 below 128k.
4726 ENUM
4727 BFD_RELOC_AVR_HH8_LDI_PM
4728 ENUMDOC
4729 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4730 of command address) into 8 bit immediate value of LDI insn.
4731 ENUM
4732 BFD_RELOC_AVR_LO8_LDI_PM_NEG
4733 ENUMDOC
4734 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4735 (usually command address) into 8 bit immediate value of SUBI insn.
4736 ENUM
4737 BFD_RELOC_AVR_HI8_LDI_PM_NEG
4738 ENUMDOC
4739 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4740 (high 8 bit of 16 bit command address) into 8 bit immediate value
4741 of SUBI insn.
4742 ENUM
4743 BFD_RELOC_AVR_HH8_LDI_PM_NEG
4744 ENUMDOC
4745 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4746 (high 6 bit of 22 bit command address) into 8 bit immediate
4747 value of SUBI insn.
4748 ENUM
4749 BFD_RELOC_AVR_CALL
4750 ENUMDOC
4751 This is a 32 bit reloc for the AVR that stores 23 bit value
4752 into 22 bits.
4753 ENUM
4754 BFD_RELOC_AVR_LDI
4755 ENUMDOC
4756 This is a 16 bit reloc for the AVR that stores all needed bits
4757 for absolute addressing with ldi with overflow check to linktime
4758 ENUM
4759 BFD_RELOC_AVR_6
4760 ENUMDOC
4761 This is a 6 bit reloc for the AVR that stores offset for ldd/std
4762 instructions
4763 ENUM
4764 BFD_RELOC_AVR_6_ADIW
4765 ENUMDOC
4766 This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw
4767 instructions
4768 ENUM
4769 BFD_RELOC_AVR_8_LO
4770 ENUMDOC
4771 This is a 8 bit reloc for the AVR that stores bits 0..7 of a symbol
4772 in .byte lo8(symbol)
4773 ENUM
4774 BFD_RELOC_AVR_8_HI
4775 ENUMDOC
4776 This is a 8 bit reloc for the AVR that stores bits 8..15 of a symbol
4777 in .byte hi8(symbol)
4778 ENUM
4779 BFD_RELOC_AVR_8_HLO
4780 ENUMDOC
4781 This is a 8 bit reloc for the AVR that stores bits 16..23 of a symbol
4782 in .byte hlo8(symbol)
4783 ENUM
4784 BFD_RELOC_AVR_DIFF8
4785 ENUMX
4786 BFD_RELOC_AVR_DIFF16
4787 ENUMX
4788 BFD_RELOC_AVR_DIFF32
4789 ENUMDOC
4790 AVR relocations to mark the difference of two local symbols.
4791 These are only needed to support linker relaxation and can be ignored
4792 when not relaxing. The field is set to the value of the difference
4793 assuming no relaxation. The relocation encodes the position of the
4794 second symbol so the linker can determine whether to adjust the field
4795 value.
4796 ENUM
4797 BFD_RELOC_RL78_NEG8
4798 ENUMX
4799 BFD_RELOC_RL78_NEG16
4800 ENUMX
4801 BFD_RELOC_RL78_NEG24
4802 ENUMX
4803 BFD_RELOC_RL78_NEG32
4804 ENUMX
4805 BFD_RELOC_RL78_16_OP
4806 ENUMX
4807 BFD_RELOC_RL78_24_OP
4808 ENUMX
4809 BFD_RELOC_RL78_32_OP
4810 ENUMX
4811 BFD_RELOC_RL78_8U
4812 ENUMX
4813 BFD_RELOC_RL78_16U
4814 ENUMX
4815 BFD_RELOC_RL78_24U
4816 ENUMX
4817 BFD_RELOC_RL78_DIR3U_PCREL
4818 ENUMX
4819 BFD_RELOC_RL78_DIFF
4820 ENUMX
4821 BFD_RELOC_RL78_GPRELB
4822 ENUMX
4823 BFD_RELOC_RL78_GPRELW
4824 ENUMX
4825 BFD_RELOC_RL78_GPRELL
4826 ENUMX
4827 BFD_RELOC_RL78_SYM
4828 ENUMX
4829 BFD_RELOC_RL78_OP_SUBTRACT
4830 ENUMX
4831 BFD_RELOC_RL78_OP_NEG
4832 ENUMX
4833 BFD_RELOC_RL78_OP_AND
4834 ENUMX
4835 BFD_RELOC_RL78_OP_SHRA
4836 ENUMX
4837 BFD_RELOC_RL78_ABS8
4838 ENUMX
4839 BFD_RELOC_RL78_ABS16
4840 ENUMX
4841 BFD_RELOC_RL78_ABS16_REV
4842 ENUMX
4843 BFD_RELOC_RL78_ABS32
4844 ENUMX
4845 BFD_RELOC_RL78_ABS32_REV
4846 ENUMX
4847 BFD_RELOC_RL78_ABS16U
4848 ENUMX
4849 BFD_RELOC_RL78_ABS16UW
4850 ENUMX
4851 BFD_RELOC_RL78_ABS16UL
4852 ENUMX
4853 BFD_RELOC_RL78_RELAX
4854 ENUMX
4855 BFD_RELOC_RL78_HI16
4856 ENUMX
4857 BFD_RELOC_RL78_HI8
4858 ENUMX
4859 BFD_RELOC_RL78_LO16
4860 ENUMX
4861 BFD_RELOC_RL78_CODE
4862 ENUMDOC
4863 Renesas RL78 Relocations.
4864
4865 ENUM
4866 BFD_RELOC_RX_NEG8
4867 ENUMX
4868 BFD_RELOC_RX_NEG16
4869 ENUMX
4870 BFD_RELOC_RX_NEG24
4871 ENUMX
4872 BFD_RELOC_RX_NEG32
4873 ENUMX
4874 BFD_RELOC_RX_16_OP
4875 ENUMX
4876 BFD_RELOC_RX_24_OP
4877 ENUMX
4878 BFD_RELOC_RX_32_OP
4879 ENUMX
4880 BFD_RELOC_RX_8U
4881 ENUMX
4882 BFD_RELOC_RX_16U
4883 ENUMX
4884 BFD_RELOC_RX_24U
4885 ENUMX
4886 BFD_RELOC_RX_DIR3U_PCREL
4887 ENUMX
4888 BFD_RELOC_RX_DIFF
4889 ENUMX
4890 BFD_RELOC_RX_GPRELB
4891 ENUMX
4892 BFD_RELOC_RX_GPRELW
4893 ENUMX
4894 BFD_RELOC_RX_GPRELL
4895 ENUMX
4896 BFD_RELOC_RX_SYM
4897 ENUMX
4898 BFD_RELOC_RX_OP_SUBTRACT
4899 ENUMX
4900 BFD_RELOC_RX_OP_NEG
4901 ENUMX
4902 BFD_RELOC_RX_ABS8
4903 ENUMX
4904 BFD_RELOC_RX_ABS16
4905 ENUMX
4906 BFD_RELOC_RX_ABS16_REV
4907 ENUMX
4908 BFD_RELOC_RX_ABS32
4909 ENUMX
4910 BFD_RELOC_RX_ABS32_REV
4911 ENUMX
4912 BFD_RELOC_RX_ABS16U
4913 ENUMX
4914 BFD_RELOC_RX_ABS16UW
4915 ENUMX
4916 BFD_RELOC_RX_ABS16UL
4917 ENUMX
4918 BFD_RELOC_RX_RELAX
4919 ENUMDOC
4920 Renesas RX Relocations.
4921
4922 ENUM
4923 BFD_RELOC_390_12
4924 ENUMDOC
4925 Direct 12 bit.
4926 ENUM
4927 BFD_RELOC_390_GOT12
4928 ENUMDOC
4929 12 bit GOT offset.
4930 ENUM
4931 BFD_RELOC_390_PLT32
4932 ENUMDOC
4933 32 bit PC relative PLT address.
4934 ENUM
4935 BFD_RELOC_390_COPY
4936 ENUMDOC
4937 Copy symbol at runtime.
4938 ENUM
4939 BFD_RELOC_390_GLOB_DAT
4940 ENUMDOC
4941 Create GOT entry.
4942 ENUM
4943 BFD_RELOC_390_JMP_SLOT
4944 ENUMDOC
4945 Create PLT entry.
4946 ENUM
4947 BFD_RELOC_390_RELATIVE
4948 ENUMDOC
4949 Adjust by program base.
4950 ENUM
4951 BFD_RELOC_390_GOTPC
4952 ENUMDOC
4953 32 bit PC relative offset to GOT.
4954 ENUM
4955 BFD_RELOC_390_GOT16
4956 ENUMDOC
4957 16 bit GOT offset.
4958 ENUM
4959 BFD_RELOC_390_PC12DBL
4960 ENUMDOC
4961 PC relative 12 bit shifted by 1.
4962 ENUM
4963 BFD_RELOC_390_PLT12DBL
4964 ENUMDOC
4965 12 bit PC rel. PLT shifted by 1.
4966 ENUM
4967 BFD_RELOC_390_PC16DBL
4968 ENUMDOC
4969 PC relative 16 bit shifted by 1.
4970 ENUM
4971 BFD_RELOC_390_PLT16DBL
4972 ENUMDOC
4973 16 bit PC rel. PLT shifted by 1.
4974 ENUM
4975 BFD_RELOC_390_PC24DBL
4976 ENUMDOC
4977 PC relative 24 bit shifted by 1.
4978 ENUM
4979 BFD_RELOC_390_PLT24DBL
4980 ENUMDOC
4981 24 bit PC rel. PLT shifted by 1.
4982 ENUM
4983 BFD_RELOC_390_PC32DBL
4984 ENUMDOC
4985 PC relative 32 bit shifted by 1.
4986 ENUM
4987 BFD_RELOC_390_PLT32DBL
4988 ENUMDOC
4989 32 bit PC rel. PLT shifted by 1.
4990 ENUM
4991 BFD_RELOC_390_GOTPCDBL
4992 ENUMDOC
4993 32 bit PC rel. GOT shifted by 1.
4994 ENUM
4995 BFD_RELOC_390_GOT64
4996 ENUMDOC
4997 64 bit GOT offset.
4998 ENUM
4999 BFD_RELOC_390_PLT64
5000 ENUMDOC
5001 64 bit PC relative PLT address.
5002 ENUM
5003 BFD_RELOC_390_GOTENT
5004 ENUMDOC
5005 32 bit rel. offset to GOT entry.
5006 ENUM
5007 BFD_RELOC_390_GOTOFF64
5008 ENUMDOC
5009 64 bit offset to GOT.
5010 ENUM
5011 BFD_RELOC_390_GOTPLT12
5012 ENUMDOC
5013 12-bit offset to symbol-entry within GOT, with PLT handling.
5014 ENUM
5015 BFD_RELOC_390_GOTPLT16
5016 ENUMDOC
5017 16-bit offset to symbol-entry within GOT, with PLT handling.
5018 ENUM
5019 BFD_RELOC_390_GOTPLT32
5020 ENUMDOC
5021 32-bit offset to symbol-entry within GOT, with PLT handling.
5022 ENUM
5023 BFD_RELOC_390_GOTPLT64
5024 ENUMDOC
5025 64-bit offset to symbol-entry within GOT, with PLT handling.
5026 ENUM
5027 BFD_RELOC_390_GOTPLTENT
5028 ENUMDOC
5029 32-bit rel. offset to symbol-entry within GOT, with PLT handling.
5030 ENUM
5031 BFD_RELOC_390_PLTOFF16
5032 ENUMDOC
5033 16-bit rel. offset from the GOT to a PLT entry.
5034 ENUM
5035 BFD_RELOC_390_PLTOFF32
5036 ENUMDOC
5037 32-bit rel. offset from the GOT to a PLT entry.
5038 ENUM
5039 BFD_RELOC_390_PLTOFF64
5040 ENUMDOC
5041 64-bit rel. offset from the GOT to a PLT entry.
5042
5043 ENUM
5044 BFD_RELOC_390_TLS_LOAD
5045 ENUMX
5046 BFD_RELOC_390_TLS_GDCALL
5047 ENUMX
5048 BFD_RELOC_390_TLS_LDCALL
5049 ENUMX
5050 BFD_RELOC_390_TLS_GD32
5051 ENUMX
5052 BFD_RELOC_390_TLS_GD64
5053 ENUMX
5054 BFD_RELOC_390_TLS_GOTIE12
5055 ENUMX
5056 BFD_RELOC_390_TLS_GOTIE32
5057 ENUMX
5058 BFD_RELOC_390_TLS_GOTIE64
5059 ENUMX
5060 BFD_RELOC_390_TLS_LDM32
5061 ENUMX
5062 BFD_RELOC_390_TLS_LDM64
5063 ENUMX
5064 BFD_RELOC_390_TLS_IE32
5065 ENUMX
5066 BFD_RELOC_390_TLS_IE64
5067 ENUMX
5068 BFD_RELOC_390_TLS_IEENT
5069 ENUMX
5070 BFD_RELOC_390_TLS_LE32
5071 ENUMX
5072 BFD_RELOC_390_TLS_LE64
5073 ENUMX
5074 BFD_RELOC_390_TLS_LDO32
5075 ENUMX
5076 BFD_RELOC_390_TLS_LDO64
5077 ENUMX
5078 BFD_RELOC_390_TLS_DTPMOD
5079 ENUMX
5080 BFD_RELOC_390_TLS_DTPOFF
5081 ENUMX
5082 BFD_RELOC_390_TLS_TPOFF
5083 ENUMDOC
5084 s390 tls relocations.
5085
5086 ENUM
5087 BFD_RELOC_390_20
5088 ENUMX
5089 BFD_RELOC_390_GOT20
5090 ENUMX
5091 BFD_RELOC_390_GOTPLT20
5092 ENUMX
5093 BFD_RELOC_390_TLS_GOTIE20
5094 ENUMDOC
5095 Long displacement extension.
5096
5097 ENUM
5098 BFD_RELOC_390_IRELATIVE
5099 ENUMDOC
5100 STT_GNU_IFUNC relocation.
5101
5102 ENUM
5103 BFD_RELOC_SCORE_GPREL15
5104 ENUMDOC
5105 Score relocations
5106 Low 16 bit for load/store
5107 ENUM
5108 BFD_RELOC_SCORE_DUMMY2
5109 ENUMX
5110 BFD_RELOC_SCORE_JMP
5111 ENUMDOC
5112 This is a 24-bit reloc with the right 1 bit assumed to be 0
5113 ENUM
5114 BFD_RELOC_SCORE_BRANCH
5115 ENUMDOC
5116 This is a 19-bit reloc with the right 1 bit assumed to be 0
5117 ENUM
5118 BFD_RELOC_SCORE_IMM30
5119 ENUMDOC
5120 This is a 32-bit reloc for 48-bit instructions.
5121 ENUM
5122 BFD_RELOC_SCORE_IMM32
5123 ENUMDOC
5124 This is a 32-bit reloc for 48-bit instructions.
5125 ENUM
5126 BFD_RELOC_SCORE16_JMP
5127 ENUMDOC
5128 This is a 11-bit reloc with the right 1 bit assumed to be 0
5129 ENUM
5130 BFD_RELOC_SCORE16_BRANCH
5131 ENUMDOC
5132 This is a 8-bit reloc with the right 1 bit assumed to be 0
5133 ENUM
5134 BFD_RELOC_SCORE_BCMP
5135 ENUMDOC
5136 This is a 9-bit reloc with the right 1 bit assumed to be 0
5137 ENUM
5138 BFD_RELOC_SCORE_GOT15
5139 ENUMX
5140 BFD_RELOC_SCORE_GOT_LO16
5141 ENUMX
5142 BFD_RELOC_SCORE_CALL15
5143 ENUMX
5144 BFD_RELOC_SCORE_DUMMY_HI16
5145 ENUMDOC
5146 Undocumented Score relocs
5147
5148 ENUM
5149 BFD_RELOC_IP2K_FR9
5150 ENUMDOC
5151 Scenix IP2K - 9-bit register number / data address
5152 ENUM
5153 BFD_RELOC_IP2K_BANK
5154 ENUMDOC
5155 Scenix IP2K - 4-bit register/data bank number
5156 ENUM
5157 BFD_RELOC_IP2K_ADDR16CJP
5158 ENUMDOC
5159 Scenix IP2K - low 13 bits of instruction word address
5160 ENUM
5161 BFD_RELOC_IP2K_PAGE3
5162 ENUMDOC
5163 Scenix IP2K - high 3 bits of instruction word address
5164 ENUM
5165 BFD_RELOC_IP2K_LO8DATA
5166 ENUMX
5167 BFD_RELOC_IP2K_HI8DATA
5168 ENUMX
5169 BFD_RELOC_IP2K_EX8DATA
5170 ENUMDOC
5171 Scenix IP2K - ext/low/high 8 bits of data address
5172 ENUM
5173 BFD_RELOC_IP2K_LO8INSN
5174 ENUMX
5175 BFD_RELOC_IP2K_HI8INSN
5176 ENUMDOC
5177 Scenix IP2K - low/high 8 bits of instruction word address
5178 ENUM
5179 BFD_RELOC_IP2K_PC_SKIP
5180 ENUMDOC
5181 Scenix IP2K - even/odd PC modifier to modify snb pcl.0
5182 ENUM
5183 BFD_RELOC_IP2K_TEXT
5184 ENUMDOC
5185 Scenix IP2K - 16 bit word address in text section.
5186 ENUM
5187 BFD_RELOC_IP2K_FR_OFFSET
5188 ENUMDOC
5189 Scenix IP2K - 7-bit sp or dp offset
5190 ENUM
5191 BFD_RELOC_VPE4KMATH_DATA
5192 ENUMX
5193 BFD_RELOC_VPE4KMATH_INSN
5194 ENUMDOC
5195 Scenix VPE4K coprocessor - data/insn-space addressing
5196
5197 ENUM
5198 BFD_RELOC_VTABLE_INHERIT
5199 ENUMX
5200 BFD_RELOC_VTABLE_ENTRY
5201 ENUMDOC
5202 These two relocations are used by the linker to determine which of
5203 the entries in a C++ virtual function table are actually used. When
5204 the --gc-sections option is given, the linker will zero out the entries
5205 that are not used, so that the code for those functions need not be
5206 included in the output.
5207
5208 VTABLE_INHERIT is a zero-space relocation used to describe to the
5209 linker the inheritance tree of a C++ virtual function table. The
5210 relocation's symbol should be the parent class' vtable, and the
5211 relocation should be located at the child vtable.
5212
5213 VTABLE_ENTRY is a zero-space relocation that describes the use of a
5214 virtual function table entry. The reloc's symbol should refer to the
5215 table of the class mentioned in the code. Off of that base, an offset
5216 describes the entry that is being used. For Rela hosts, this offset
5217 is stored in the reloc's addend. For Rel hosts, we are forced to put
5218 this offset in the reloc's section offset.
5219
5220 ENUM
5221 BFD_RELOC_IA64_IMM14
5222 ENUMX
5223 BFD_RELOC_IA64_IMM22
5224 ENUMX
5225 BFD_RELOC_IA64_IMM64
5226 ENUMX
5227 BFD_RELOC_IA64_DIR32MSB
5228 ENUMX
5229 BFD_RELOC_IA64_DIR32LSB
5230 ENUMX
5231 BFD_RELOC_IA64_DIR64MSB
5232 ENUMX
5233 BFD_RELOC_IA64_DIR64LSB
5234 ENUMX
5235 BFD_RELOC_IA64_GPREL22
5236 ENUMX
5237 BFD_RELOC_IA64_GPREL64I
5238 ENUMX
5239 BFD_RELOC_IA64_GPREL32MSB
5240 ENUMX
5241 BFD_RELOC_IA64_GPREL32LSB
5242 ENUMX
5243 BFD_RELOC_IA64_GPREL64MSB
5244 ENUMX
5245 BFD_RELOC_IA64_GPREL64LSB
5246 ENUMX
5247 BFD_RELOC_IA64_LTOFF22
5248 ENUMX
5249 BFD_RELOC_IA64_LTOFF64I
5250 ENUMX
5251 BFD_RELOC_IA64_PLTOFF22
5252 ENUMX
5253 BFD_RELOC_IA64_PLTOFF64I
5254 ENUMX
5255 BFD_RELOC_IA64_PLTOFF64MSB
5256 ENUMX
5257 BFD_RELOC_IA64_PLTOFF64LSB
5258 ENUMX
5259 BFD_RELOC_IA64_FPTR64I
5260 ENUMX
5261 BFD_RELOC_IA64_FPTR32MSB
5262 ENUMX
5263 BFD_RELOC_IA64_FPTR32LSB
5264 ENUMX
5265 BFD_RELOC_IA64_FPTR64MSB
5266 ENUMX
5267 BFD_RELOC_IA64_FPTR64LSB
5268 ENUMX
5269 BFD_RELOC_IA64_PCREL21B
5270 ENUMX
5271 BFD_RELOC_IA64_PCREL21BI
5272 ENUMX
5273 BFD_RELOC_IA64_PCREL21M
5274 ENUMX
5275 BFD_RELOC_IA64_PCREL21F
5276 ENUMX
5277 BFD_RELOC_IA64_PCREL22
5278 ENUMX
5279 BFD_RELOC_IA64_PCREL60B
5280 ENUMX
5281 BFD_RELOC_IA64_PCREL64I
5282 ENUMX
5283 BFD_RELOC_IA64_PCREL32MSB
5284 ENUMX
5285 BFD_RELOC_IA64_PCREL32LSB
5286 ENUMX
5287 BFD_RELOC_IA64_PCREL64MSB
5288 ENUMX
5289 BFD_RELOC_IA64_PCREL64LSB
5290 ENUMX
5291 BFD_RELOC_IA64_LTOFF_FPTR22
5292 ENUMX
5293 BFD_RELOC_IA64_LTOFF_FPTR64I
5294 ENUMX
5295 BFD_RELOC_IA64_LTOFF_FPTR32MSB
5296 ENUMX
5297 BFD_RELOC_IA64_LTOFF_FPTR32LSB
5298 ENUMX
5299 BFD_RELOC_IA64_LTOFF_FPTR64MSB
5300 ENUMX
5301 BFD_RELOC_IA64_LTOFF_FPTR64LSB
5302 ENUMX
5303 BFD_RELOC_IA64_SEGREL32MSB
5304 ENUMX
5305 BFD_RELOC_IA64_SEGREL32LSB
5306 ENUMX
5307 BFD_RELOC_IA64_SEGREL64MSB
5308 ENUMX
5309 BFD_RELOC_IA64_SEGREL64LSB
5310 ENUMX
5311 BFD_RELOC_IA64_SECREL32MSB
5312 ENUMX
5313 BFD_RELOC_IA64_SECREL32LSB
5314 ENUMX
5315 BFD_RELOC_IA64_SECREL64MSB
5316 ENUMX
5317 BFD_RELOC_IA64_SECREL64LSB
5318 ENUMX
5319 BFD_RELOC_IA64_REL32MSB
5320 ENUMX
5321 BFD_RELOC_IA64_REL32LSB
5322 ENUMX
5323 BFD_RELOC_IA64_REL64MSB
5324 ENUMX
5325 BFD_RELOC_IA64_REL64LSB
5326 ENUMX
5327 BFD_RELOC_IA64_LTV32MSB
5328 ENUMX
5329 BFD_RELOC_IA64_LTV32LSB
5330 ENUMX
5331 BFD_RELOC_IA64_LTV64MSB
5332 ENUMX
5333 BFD_RELOC_IA64_LTV64LSB
5334 ENUMX
5335 BFD_RELOC_IA64_IPLTMSB
5336 ENUMX
5337 BFD_RELOC_IA64_IPLTLSB
5338 ENUMX
5339 BFD_RELOC_IA64_COPY
5340 ENUMX
5341 BFD_RELOC_IA64_LTOFF22X
5342 ENUMX
5343 BFD_RELOC_IA64_LDXMOV
5344 ENUMX
5345 BFD_RELOC_IA64_TPREL14
5346 ENUMX
5347 BFD_RELOC_IA64_TPREL22
5348 ENUMX
5349 BFD_RELOC_IA64_TPREL64I
5350 ENUMX
5351 BFD_RELOC_IA64_TPREL64MSB
5352 ENUMX
5353 BFD_RELOC_IA64_TPREL64LSB
5354 ENUMX
5355 BFD_RELOC_IA64_LTOFF_TPREL22
5356 ENUMX
5357 BFD_RELOC_IA64_DTPMOD64MSB
5358 ENUMX
5359 BFD_RELOC_IA64_DTPMOD64LSB
5360 ENUMX
5361 BFD_RELOC_IA64_LTOFF_DTPMOD22
5362 ENUMX
5363 BFD_RELOC_IA64_DTPREL14
5364 ENUMX
5365 BFD_RELOC_IA64_DTPREL22
5366 ENUMX
5367 BFD_RELOC_IA64_DTPREL64I
5368 ENUMX
5369 BFD_RELOC_IA64_DTPREL32MSB
5370 ENUMX
5371 BFD_RELOC_IA64_DTPREL32LSB
5372 ENUMX
5373 BFD_RELOC_IA64_DTPREL64MSB
5374 ENUMX
5375 BFD_RELOC_IA64_DTPREL64LSB
5376 ENUMX
5377 BFD_RELOC_IA64_LTOFF_DTPREL22
5378 ENUMDOC
5379 Intel IA64 Relocations.
5380
5381 ENUM
5382 BFD_RELOC_M68HC11_HI8
5383 ENUMDOC
5384 Motorola 68HC11 reloc.
5385 This is the 8 bit high part of an absolute address.
5386 ENUM
5387 BFD_RELOC_M68HC11_LO8
5388 ENUMDOC
5389 Motorola 68HC11 reloc.
5390 This is the 8 bit low part of an absolute address.
5391 ENUM
5392 BFD_RELOC_M68HC11_3B
5393 ENUMDOC
5394 Motorola 68HC11 reloc.
5395 This is the 3 bit of a value.
5396 ENUM
5397 BFD_RELOC_M68HC11_RL_JUMP
5398 ENUMDOC
5399 Motorola 68HC11 reloc.
5400 This reloc marks the beginning of a jump/call instruction.
5401 It is used for linker relaxation to correctly identify beginning
5402 of instruction and change some branches to use PC-relative
5403 addressing mode.
5404 ENUM
5405 BFD_RELOC_M68HC11_RL_GROUP
5406 ENUMDOC
5407 Motorola 68HC11 reloc.
5408 This reloc marks a group of several instructions that gcc generates
5409 and for which the linker relaxation pass can modify and/or remove
5410 some of them.
5411 ENUM
5412 BFD_RELOC_M68HC11_LO16
5413 ENUMDOC
5414 Motorola 68HC11 reloc.
5415 This is the 16-bit lower part of an address. It is used for 'call'
5416 instruction to specify the symbol address without any special
5417 transformation (due to memory bank window).
5418 ENUM
5419 BFD_RELOC_M68HC11_PAGE
5420 ENUMDOC
5421 Motorola 68HC11 reloc.
5422 This is a 8-bit reloc that specifies the page number of an address.
5423 It is used by 'call' instruction to specify the page number of
5424 the symbol.
5425 ENUM
5426 BFD_RELOC_M68HC11_24
5427 ENUMDOC
5428 Motorola 68HC11 reloc.
5429 This is a 24-bit reloc that represents the address with a 16-bit
5430 value and a 8-bit page number. The symbol address is transformed
5431 to follow the 16K memory bank of 68HC12 (seen as mapped in the window).
5432 ENUM
5433 BFD_RELOC_M68HC12_5B
5434 ENUMDOC
5435 Motorola 68HC12 reloc.
5436 This is the 5 bits of a value.
5437 ENUM
5438 BFD_RELOC_XGATE_RL_JUMP
5439 ENUMDOC
5440 Freescale XGATE reloc.
5441 This reloc marks the beginning of a bra/jal instruction.
5442 ENUM
5443 BFD_RELOC_XGATE_RL_GROUP
5444 ENUMDOC
5445 Freescale XGATE reloc.
5446 This reloc marks a group of several instructions that gcc generates
5447 and for which the linker relaxation pass can modify and/or remove
5448 some of them.
5449 ENUM
5450 BFD_RELOC_XGATE_LO16
5451 ENUMDOC
5452 Freescale XGATE reloc.
5453 This is the 16-bit lower part of an address. It is used for the '16-bit'
5454 instructions.
5455 ENUM
5456 BFD_RELOC_XGATE_GPAGE
5457 ENUMDOC
5458 Freescale XGATE reloc.
5459 ENUM
5460 BFD_RELOC_XGATE_24
5461 ENUMDOC
5462 Freescale XGATE reloc.
5463 ENUM
5464 BFD_RELOC_XGATE_PCREL_9
5465 ENUMDOC
5466 Freescale XGATE reloc.
5467 This is a 9-bit pc-relative reloc.
5468 ENUM
5469 BFD_RELOC_XGATE_PCREL_10
5470 ENUMDOC
5471 Freescale XGATE reloc.
5472 This is a 10-bit pc-relative reloc.
5473 ENUM
5474 BFD_RELOC_XGATE_IMM8_LO
5475 ENUMDOC
5476 Freescale XGATE reloc.
5477 This is the 16-bit lower part of an address. It is used for the '16-bit'
5478 instructions.
5479 ENUM
5480 BFD_RELOC_XGATE_IMM8_HI
5481 ENUMDOC
5482 Freescale XGATE reloc.
5483 This is the 16-bit higher part of an address. It is used for the '16-bit'
5484 instructions.
5485 ENUM
5486 BFD_RELOC_XGATE_IMM3
5487 ENUMDOC
5488 Freescale XGATE reloc.
5489 This is a 3-bit pc-relative reloc.
5490 ENUM
5491 BFD_RELOC_XGATE_IMM4
5492 ENUMDOC
5493 Freescale XGATE reloc.
5494 This is a 4-bit pc-relative reloc.
5495 ENUM
5496 BFD_RELOC_XGATE_IMM5
5497 ENUMDOC
5498 Freescale XGATE reloc.
5499 This is a 5-bit pc-relative reloc.
5500 ENUM
5501 BFD_RELOC_M68HC12_9B
5502 ENUMDOC
5503 Motorola 68HC12 reloc.
5504 This is the 9 bits of a value.
5505 ENUM
5506 BFD_RELOC_M68HC12_16B
5507 ENUMDOC
5508 Motorola 68HC12 reloc.
5509 This is the 16 bits of a value.
5510 ENUM
5511 BFD_RELOC_M68HC12_9_PCREL
5512 ENUMDOC
5513 Motorola 68HC12/XGATE reloc.
5514 This is a PCREL9 branch.
5515 ENUM
5516 BFD_RELOC_M68HC12_10_PCREL
5517 ENUMDOC
5518 Motorola 68HC12/XGATE reloc.
5519 This is a PCREL10 branch.
5520 ENUM
5521 BFD_RELOC_M68HC12_LO8XG
5522 ENUMDOC
5523 Motorola 68HC12/XGATE reloc.
5524 This is the 8 bit low part of an absolute address and immediately precedes
5525 a matching HI8XG part.
5526 ENUM
5527 BFD_RELOC_M68HC12_HI8XG
5528 ENUMDOC
5529 Motorola 68HC12/XGATE reloc.
5530 This is the 8 bit high part of an absolute address and immediately follows
5531 a matching LO8XG part.
5532 ENUM
5533 BFD_RELOC_16C_NUM08
5534 ENUMX
5535 BFD_RELOC_16C_NUM08_C
5536 ENUMX
5537 BFD_RELOC_16C_NUM16
5538 ENUMX
5539 BFD_RELOC_16C_NUM16_C
5540 ENUMX
5541 BFD_RELOC_16C_NUM32
5542 ENUMX
5543 BFD_RELOC_16C_NUM32_C
5544 ENUMX
5545 BFD_RELOC_16C_DISP04
5546 ENUMX
5547 BFD_RELOC_16C_DISP04_C
5548 ENUMX
5549 BFD_RELOC_16C_DISP08
5550 ENUMX
5551 BFD_RELOC_16C_DISP08_C
5552 ENUMX
5553 BFD_RELOC_16C_DISP16
5554 ENUMX
5555 BFD_RELOC_16C_DISP16_C
5556 ENUMX
5557 BFD_RELOC_16C_DISP24
5558 ENUMX
5559 BFD_RELOC_16C_DISP24_C
5560 ENUMX
5561 BFD_RELOC_16C_DISP24a
5562 ENUMX
5563 BFD_RELOC_16C_DISP24a_C
5564 ENUMX
5565 BFD_RELOC_16C_REG04
5566 ENUMX
5567 BFD_RELOC_16C_REG04_C
5568 ENUMX
5569 BFD_RELOC_16C_REG04a
5570 ENUMX
5571 BFD_RELOC_16C_REG04a_C
5572 ENUMX
5573 BFD_RELOC_16C_REG14
5574 ENUMX
5575 BFD_RELOC_16C_REG14_C
5576 ENUMX
5577 BFD_RELOC_16C_REG16
5578 ENUMX
5579 BFD_RELOC_16C_REG16_C
5580 ENUMX
5581 BFD_RELOC_16C_REG20
5582 ENUMX
5583 BFD_RELOC_16C_REG20_C
5584 ENUMX
5585 BFD_RELOC_16C_ABS20
5586 ENUMX
5587 BFD_RELOC_16C_ABS20_C
5588 ENUMX
5589 BFD_RELOC_16C_ABS24
5590 ENUMX
5591 BFD_RELOC_16C_ABS24_C
5592 ENUMX
5593 BFD_RELOC_16C_IMM04
5594 ENUMX
5595 BFD_RELOC_16C_IMM04_C
5596 ENUMX
5597 BFD_RELOC_16C_IMM16
5598 ENUMX
5599 BFD_RELOC_16C_IMM16_C
5600 ENUMX
5601 BFD_RELOC_16C_IMM20
5602 ENUMX
5603 BFD_RELOC_16C_IMM20_C
5604 ENUMX
5605 BFD_RELOC_16C_IMM24
5606 ENUMX
5607 BFD_RELOC_16C_IMM24_C
5608 ENUMX
5609 BFD_RELOC_16C_IMM32
5610 ENUMX
5611 BFD_RELOC_16C_IMM32_C
5612 ENUMDOC
5613 NS CR16C Relocations.
5614
5615 ENUM
5616 BFD_RELOC_CR16_NUM8
5617 ENUMX
5618 BFD_RELOC_CR16_NUM16
5619 ENUMX
5620 BFD_RELOC_CR16_NUM32
5621 ENUMX
5622 BFD_RELOC_CR16_NUM32a
5623 ENUMX
5624 BFD_RELOC_CR16_REGREL0
5625 ENUMX
5626 BFD_RELOC_CR16_REGREL4
5627 ENUMX
5628 BFD_RELOC_CR16_REGREL4a
5629 ENUMX
5630 BFD_RELOC_CR16_REGREL14
5631 ENUMX
5632 BFD_RELOC_CR16_REGREL14a
5633 ENUMX
5634 BFD_RELOC_CR16_REGREL16
5635 ENUMX
5636 BFD_RELOC_CR16_REGREL20
5637 ENUMX
5638 BFD_RELOC_CR16_REGREL20a
5639 ENUMX
5640 BFD_RELOC_CR16_ABS20
5641 ENUMX
5642 BFD_RELOC_CR16_ABS24
5643 ENUMX
5644 BFD_RELOC_CR16_IMM4
5645 ENUMX
5646 BFD_RELOC_CR16_IMM8
5647 ENUMX
5648 BFD_RELOC_CR16_IMM16
5649 ENUMX
5650 BFD_RELOC_CR16_IMM20
5651 ENUMX
5652 BFD_RELOC_CR16_IMM24
5653 ENUMX
5654 BFD_RELOC_CR16_IMM32
5655 ENUMX
5656 BFD_RELOC_CR16_IMM32a
5657 ENUMX
5658 BFD_RELOC_CR16_DISP4
5659 ENUMX
5660 BFD_RELOC_CR16_DISP8
5661 ENUMX
5662 BFD_RELOC_CR16_DISP16
5663 ENUMX
5664 BFD_RELOC_CR16_DISP20
5665 ENUMX
5666 BFD_RELOC_CR16_DISP24
5667 ENUMX
5668 BFD_RELOC_CR16_DISP24a
5669 ENUMX
5670 BFD_RELOC_CR16_SWITCH8
5671 ENUMX
5672 BFD_RELOC_CR16_SWITCH16
5673 ENUMX
5674 BFD_RELOC_CR16_SWITCH32
5675 ENUMX
5676 BFD_RELOC_CR16_GOT_REGREL20
5677 ENUMX
5678 BFD_RELOC_CR16_GOTC_REGREL20
5679 ENUMX
5680 BFD_RELOC_CR16_GLOB_DAT
5681 ENUMDOC
5682 NS CR16 Relocations.
5683
5684 ENUM
5685 BFD_RELOC_CRX_REL4
5686 ENUMX
5687 BFD_RELOC_CRX_REL8
5688 ENUMX
5689 BFD_RELOC_CRX_REL8_CMP
5690 ENUMX
5691 BFD_RELOC_CRX_REL16
5692 ENUMX
5693 BFD_RELOC_CRX_REL24
5694 ENUMX
5695 BFD_RELOC_CRX_REL32
5696 ENUMX
5697 BFD_RELOC_CRX_REGREL12
5698 ENUMX
5699 BFD_RELOC_CRX_REGREL22
5700 ENUMX
5701 BFD_RELOC_CRX_REGREL28
5702 ENUMX
5703 BFD_RELOC_CRX_REGREL32
5704 ENUMX
5705 BFD_RELOC_CRX_ABS16
5706 ENUMX
5707 BFD_RELOC_CRX_ABS32
5708 ENUMX
5709 BFD_RELOC_CRX_NUM8
5710 ENUMX
5711 BFD_RELOC_CRX_NUM16
5712 ENUMX
5713 BFD_RELOC_CRX_NUM32
5714 ENUMX
5715 BFD_RELOC_CRX_IMM16
5716 ENUMX
5717 BFD_RELOC_CRX_IMM32
5718 ENUMX
5719 BFD_RELOC_CRX_SWITCH8
5720 ENUMX
5721 BFD_RELOC_CRX_SWITCH16
5722 ENUMX
5723 BFD_RELOC_CRX_SWITCH32
5724 ENUMDOC
5725 NS CRX Relocations.
5726
5727 ENUM
5728 BFD_RELOC_CRIS_BDISP8
5729 ENUMX
5730 BFD_RELOC_CRIS_UNSIGNED_5
5731 ENUMX
5732 BFD_RELOC_CRIS_SIGNED_6
5733 ENUMX
5734 BFD_RELOC_CRIS_UNSIGNED_6
5735 ENUMX
5736 BFD_RELOC_CRIS_SIGNED_8
5737 ENUMX
5738 BFD_RELOC_CRIS_UNSIGNED_8
5739 ENUMX
5740 BFD_RELOC_CRIS_SIGNED_16
5741 ENUMX
5742 BFD_RELOC_CRIS_UNSIGNED_16
5743 ENUMX
5744 BFD_RELOC_CRIS_LAPCQ_OFFSET
5745 ENUMX
5746 BFD_RELOC_CRIS_UNSIGNED_4
5747 ENUMDOC
5748 These relocs are only used within the CRIS assembler. They are not
5749 (at present) written to any object files.
5750 ENUM
5751 BFD_RELOC_CRIS_COPY
5752 ENUMX
5753 BFD_RELOC_CRIS_GLOB_DAT
5754 ENUMX
5755 BFD_RELOC_CRIS_JUMP_SLOT
5756 ENUMX
5757 BFD_RELOC_CRIS_RELATIVE
5758 ENUMDOC
5759 Relocs used in ELF shared libraries for CRIS.
5760 ENUM
5761 BFD_RELOC_CRIS_32_GOT
5762 ENUMDOC
5763 32-bit offset to symbol-entry within GOT.
5764 ENUM
5765 BFD_RELOC_CRIS_16_GOT
5766 ENUMDOC
5767 16-bit offset to symbol-entry within GOT.
5768 ENUM
5769 BFD_RELOC_CRIS_32_GOTPLT
5770 ENUMDOC
5771 32-bit offset to symbol-entry within GOT, with PLT handling.
5772 ENUM
5773 BFD_RELOC_CRIS_16_GOTPLT
5774 ENUMDOC
5775 16-bit offset to symbol-entry within GOT, with PLT handling.
5776 ENUM
5777 BFD_RELOC_CRIS_32_GOTREL
5778 ENUMDOC
5779 32-bit offset to symbol, relative to GOT.
5780 ENUM
5781 BFD_RELOC_CRIS_32_PLT_GOTREL
5782 ENUMDOC
5783 32-bit offset to symbol with PLT entry, relative to GOT.
5784 ENUM
5785 BFD_RELOC_CRIS_32_PLT_PCREL
5786 ENUMDOC
5787 32-bit offset to symbol with PLT entry, relative to this relocation.
5788
5789 ENUM
5790 BFD_RELOC_CRIS_32_GOT_GD
5791 ENUMX
5792 BFD_RELOC_CRIS_16_GOT_GD
5793 ENUMX
5794 BFD_RELOC_CRIS_32_GD
5795 ENUMX
5796 BFD_RELOC_CRIS_DTP
5797 ENUMX
5798 BFD_RELOC_CRIS_32_DTPREL
5799 ENUMX
5800 BFD_RELOC_CRIS_16_DTPREL
5801 ENUMX
5802 BFD_RELOC_CRIS_32_GOT_TPREL
5803 ENUMX
5804 BFD_RELOC_CRIS_16_GOT_TPREL
5805 ENUMX
5806 BFD_RELOC_CRIS_32_TPREL
5807 ENUMX
5808 BFD_RELOC_CRIS_16_TPREL
5809 ENUMX
5810 BFD_RELOC_CRIS_DTPMOD
5811 ENUMX
5812 BFD_RELOC_CRIS_32_IE
5813 ENUMDOC
5814 Relocs used in TLS code for CRIS.
5815
5816 ENUM
5817 BFD_RELOC_860_COPY
5818 ENUMX
5819 BFD_RELOC_860_GLOB_DAT
5820 ENUMX
5821 BFD_RELOC_860_JUMP_SLOT
5822 ENUMX
5823 BFD_RELOC_860_RELATIVE
5824 ENUMX
5825 BFD_RELOC_860_PC26
5826 ENUMX
5827 BFD_RELOC_860_PLT26
5828 ENUMX
5829 BFD_RELOC_860_PC16
5830 ENUMX
5831 BFD_RELOC_860_LOW0
5832 ENUMX
5833 BFD_RELOC_860_SPLIT0
5834 ENUMX
5835 BFD_RELOC_860_LOW1
5836 ENUMX
5837 BFD_RELOC_860_SPLIT1
5838 ENUMX
5839 BFD_RELOC_860_LOW2
5840 ENUMX
5841 BFD_RELOC_860_SPLIT2
5842 ENUMX
5843 BFD_RELOC_860_LOW3
5844 ENUMX
5845 BFD_RELOC_860_LOGOT0
5846 ENUMX
5847 BFD_RELOC_860_SPGOT0
5848 ENUMX
5849 BFD_RELOC_860_LOGOT1
5850 ENUMX
5851 BFD_RELOC_860_SPGOT1
5852 ENUMX
5853 BFD_RELOC_860_LOGOTOFF0
5854 ENUMX
5855 BFD_RELOC_860_SPGOTOFF0
5856 ENUMX
5857 BFD_RELOC_860_LOGOTOFF1
5858 ENUMX
5859 BFD_RELOC_860_SPGOTOFF1
5860 ENUMX
5861 BFD_RELOC_860_LOGOTOFF2
5862 ENUMX
5863 BFD_RELOC_860_LOGOTOFF3
5864 ENUMX
5865 BFD_RELOC_860_LOPC
5866 ENUMX
5867 BFD_RELOC_860_HIGHADJ
5868 ENUMX
5869 BFD_RELOC_860_HAGOT
5870 ENUMX
5871 BFD_RELOC_860_HAGOTOFF
5872 ENUMX
5873 BFD_RELOC_860_HAPC
5874 ENUMX
5875 BFD_RELOC_860_HIGH
5876 ENUMX
5877 BFD_RELOC_860_HIGOT
5878 ENUMX
5879 BFD_RELOC_860_HIGOTOFF
5880 ENUMDOC
5881 Intel i860 Relocations.
5882
5883 ENUM
5884 BFD_RELOC_OPENRISC_ABS_26
5885 ENUMX
5886 BFD_RELOC_OPENRISC_REL_26
5887 ENUMDOC
5888 OpenRISC Relocations.
5889
5890 ENUM
5891 BFD_RELOC_H8_DIR16A8
5892 ENUMX
5893 BFD_RELOC_H8_DIR16R8
5894 ENUMX
5895 BFD_RELOC_H8_DIR24A8
5896 ENUMX
5897 BFD_RELOC_H8_DIR24R8
5898 ENUMX
5899 BFD_RELOC_H8_DIR32A16
5900 ENUMX
5901 BFD_RELOC_H8_DISP32A16
5902 ENUMDOC
5903 H8 elf Relocations.
5904
5905 ENUM
5906 BFD_RELOC_XSTORMY16_REL_12
5907 ENUMX
5908 BFD_RELOC_XSTORMY16_12
5909 ENUMX
5910 BFD_RELOC_XSTORMY16_24
5911 ENUMX
5912 BFD_RELOC_XSTORMY16_FPTR16
5913 ENUMDOC
5914 Sony Xstormy16 Relocations.
5915
5916 ENUM
5917 BFD_RELOC_RELC
5918 ENUMDOC
5919 Self-describing complex relocations.
5920 COMMENT
5921
5922 ENUM
5923 BFD_RELOC_XC16X_PAG
5924 ENUMX
5925 BFD_RELOC_XC16X_POF
5926 ENUMX
5927 BFD_RELOC_XC16X_SEG
5928 ENUMX
5929 BFD_RELOC_XC16X_SOF
5930 ENUMDOC
5931 Infineon Relocations.
5932
5933 ENUM
5934 BFD_RELOC_VAX_GLOB_DAT
5935 ENUMX
5936 BFD_RELOC_VAX_JMP_SLOT
5937 ENUMX
5938 BFD_RELOC_VAX_RELATIVE
5939 ENUMDOC
5940 Relocations used by VAX ELF.
5941
5942 ENUM
5943 BFD_RELOC_MT_PC16
5944 ENUMDOC
5945 Morpho MT - 16 bit immediate relocation.
5946 ENUM
5947 BFD_RELOC_MT_HI16
5948 ENUMDOC
5949 Morpho MT - Hi 16 bits of an address.
5950 ENUM
5951 BFD_RELOC_MT_LO16
5952 ENUMDOC
5953 Morpho MT - Low 16 bits of an address.
5954 ENUM
5955 BFD_RELOC_MT_GNU_VTINHERIT
5956 ENUMDOC
5957 Morpho MT - Used to tell the linker which vtable entries are used.
5958 ENUM
5959 BFD_RELOC_MT_GNU_VTENTRY
5960 ENUMDOC
5961 Morpho MT - Used to tell the linker which vtable entries are used.
5962 ENUM
5963 BFD_RELOC_MT_PCINSN8
5964 ENUMDOC
5965 Morpho MT - 8 bit immediate relocation.
5966
5967 ENUM
5968 BFD_RELOC_MSP430_10_PCREL
5969 ENUMX
5970 BFD_RELOC_MSP430_16_PCREL
5971 ENUMX
5972 BFD_RELOC_MSP430_16
5973 ENUMX
5974 BFD_RELOC_MSP430_16_PCREL_BYTE
5975 ENUMX
5976 BFD_RELOC_MSP430_16_BYTE
5977 ENUMX
5978 BFD_RELOC_MSP430_2X_PCREL
5979 ENUMX
5980 BFD_RELOC_MSP430_RL_PCREL
5981 ENUMX
5982 BFD_RELOC_MSP430_ABS8
5983 ENUMX
5984 BFD_RELOC_MSP430X_PCR20_EXT_SRC
5985 ENUMX
5986 BFD_RELOC_MSP430X_PCR20_EXT_DST
5987 ENUMX
5988 BFD_RELOC_MSP430X_PCR20_EXT_ODST
5989 ENUMX
5990 BFD_RELOC_MSP430X_ABS20_EXT_SRC
5991 ENUMX
5992 BFD_RELOC_MSP430X_ABS20_EXT_DST
5993 ENUMX
5994 BFD_RELOC_MSP430X_ABS20_EXT_ODST
5995 ENUMX
5996 BFD_RELOC_MSP430X_ABS20_ADR_SRC
5997 ENUMX
5998 BFD_RELOC_MSP430X_ABS20_ADR_DST
5999 ENUMX
6000 BFD_RELOC_MSP430X_PCR16
6001 ENUMX
6002 BFD_RELOC_MSP430X_PCR20_CALL
6003 ENUMX
6004 BFD_RELOC_MSP430X_ABS16
6005 ENUMX
6006 BFD_RELOC_MSP430_ABS_HI16
6007 ENUMX
6008 BFD_RELOC_MSP430_PREL31
6009 ENUMX
6010 BFD_RELOC_MSP430_SYM_DIFF
6011 ENUMDOC
6012 msp430 specific relocation codes
6013
6014 ENUM
6015 BFD_RELOC_NIOS2_S16
6016 ENUMX
6017 BFD_RELOC_NIOS2_U16
6018 ENUMX
6019 BFD_RELOC_NIOS2_CALL26
6020 ENUMX
6021 BFD_RELOC_NIOS2_IMM5
6022 ENUMX
6023 BFD_RELOC_NIOS2_CACHE_OPX
6024 ENUMX
6025 BFD_RELOC_NIOS2_IMM6
6026 ENUMX
6027 BFD_RELOC_NIOS2_IMM8
6028 ENUMX
6029 BFD_RELOC_NIOS2_HI16
6030 ENUMX
6031 BFD_RELOC_NIOS2_LO16
6032 ENUMX
6033 BFD_RELOC_NIOS2_HIADJ16
6034 ENUMX
6035 BFD_RELOC_NIOS2_GPREL
6036 ENUMX
6037 BFD_RELOC_NIOS2_UJMP
6038 ENUMX
6039 BFD_RELOC_NIOS2_CJMP
6040 ENUMX
6041 BFD_RELOC_NIOS2_CALLR
6042 ENUMX
6043 BFD_RELOC_NIOS2_ALIGN
6044 ENUMX
6045 BFD_RELOC_NIOS2_GOT16
6046 ENUMX
6047 BFD_RELOC_NIOS2_CALL16
6048 ENUMX
6049 BFD_RELOC_NIOS2_GOTOFF_LO
6050 ENUMX
6051 BFD_RELOC_NIOS2_GOTOFF_HA
6052 ENUMX
6053 BFD_RELOC_NIOS2_PCREL_LO
6054 ENUMX
6055 BFD_RELOC_NIOS2_PCREL_HA
6056 ENUMX
6057 BFD_RELOC_NIOS2_TLS_GD16
6058 ENUMX
6059 BFD_RELOC_NIOS2_TLS_LDM16
6060 ENUMX
6061 BFD_RELOC_NIOS2_TLS_LDO16
6062 ENUMX
6063 BFD_RELOC_NIOS2_TLS_IE16
6064 ENUMX
6065 BFD_RELOC_NIOS2_TLS_LE16
6066 ENUMX
6067 BFD_RELOC_NIOS2_TLS_DTPMOD
6068 ENUMX
6069 BFD_RELOC_NIOS2_TLS_DTPREL
6070 ENUMX
6071 BFD_RELOC_NIOS2_TLS_TPREL
6072 ENUMX
6073 BFD_RELOC_NIOS2_COPY
6074 ENUMX
6075 BFD_RELOC_NIOS2_GLOB_DAT
6076 ENUMX
6077 BFD_RELOC_NIOS2_JUMP_SLOT
6078 ENUMX
6079 BFD_RELOC_NIOS2_RELATIVE
6080 ENUMX
6081 BFD_RELOC_NIOS2_GOTOFF
6082 ENUMX
6083 BFD_RELOC_NIOS2_CALL26_NOAT
6084 ENUMX
6085 BFD_RELOC_NIOS2_GOT_LO
6086 ENUMX
6087 BFD_RELOC_NIOS2_GOT_HA
6088 ENUMX
6089 BFD_RELOC_NIOS2_CALL_LO
6090 ENUMX
6091 BFD_RELOC_NIOS2_CALL_HA
6092 ENUMDOC
6093 Relocations used by the Altera Nios II core.
6094
6095 ENUM
6096 BFD_RELOC_IQ2000_OFFSET_16
6097 ENUMX
6098 BFD_RELOC_IQ2000_OFFSET_21
6099 ENUMX
6100 BFD_RELOC_IQ2000_UHI16
6101 ENUMDOC
6102 IQ2000 Relocations.
6103
6104 ENUM
6105 BFD_RELOC_XTENSA_RTLD
6106 ENUMDOC
6107 Special Xtensa relocation used only by PLT entries in ELF shared
6108 objects to indicate that the runtime linker should set the value
6109 to one of its own internal functions or data structures.
6110 ENUM
6111 BFD_RELOC_XTENSA_GLOB_DAT
6112 ENUMX
6113 BFD_RELOC_XTENSA_JMP_SLOT
6114 ENUMX
6115 BFD_RELOC_XTENSA_RELATIVE
6116 ENUMDOC
6117 Xtensa relocations for ELF shared objects.
6118 ENUM
6119 BFD_RELOC_XTENSA_PLT
6120 ENUMDOC
6121 Xtensa relocation used in ELF object files for symbols that may require
6122 PLT entries. Otherwise, this is just a generic 32-bit relocation.
6123 ENUM
6124 BFD_RELOC_XTENSA_DIFF8
6125 ENUMX
6126 BFD_RELOC_XTENSA_DIFF16
6127 ENUMX
6128 BFD_RELOC_XTENSA_DIFF32
6129 ENUMDOC
6130 Xtensa relocations to mark the difference of two local symbols.
6131 These are only needed to support linker relaxation and can be ignored
6132 when not relaxing. The field is set to the value of the difference
6133 assuming no relaxation. The relocation encodes the position of the
6134 first symbol so the linker can determine whether to adjust the field
6135 value.
6136 ENUM
6137 BFD_RELOC_XTENSA_SLOT0_OP
6138 ENUMX
6139 BFD_RELOC_XTENSA_SLOT1_OP
6140 ENUMX
6141 BFD_RELOC_XTENSA_SLOT2_OP
6142 ENUMX
6143 BFD_RELOC_XTENSA_SLOT3_OP
6144 ENUMX
6145 BFD_RELOC_XTENSA_SLOT4_OP
6146 ENUMX
6147 BFD_RELOC_XTENSA_SLOT5_OP
6148 ENUMX
6149 BFD_RELOC_XTENSA_SLOT6_OP
6150 ENUMX
6151 BFD_RELOC_XTENSA_SLOT7_OP
6152 ENUMX
6153 BFD_RELOC_XTENSA_SLOT8_OP
6154 ENUMX
6155 BFD_RELOC_XTENSA_SLOT9_OP
6156 ENUMX
6157 BFD_RELOC_XTENSA_SLOT10_OP
6158 ENUMX
6159 BFD_RELOC_XTENSA_SLOT11_OP
6160 ENUMX
6161 BFD_RELOC_XTENSA_SLOT12_OP
6162 ENUMX
6163 BFD_RELOC_XTENSA_SLOT13_OP
6164 ENUMX
6165 BFD_RELOC_XTENSA_SLOT14_OP
6166 ENUMDOC
6167 Generic Xtensa relocations for instruction operands. Only the slot
6168 number is encoded in the relocation. The relocation applies to the
6169 last PC-relative immediate operand, or if there are no PC-relative
6170 immediates, to the last immediate operand.
6171 ENUM
6172 BFD_RELOC_XTENSA_SLOT0_ALT
6173 ENUMX
6174 BFD_RELOC_XTENSA_SLOT1_ALT
6175 ENUMX
6176 BFD_RELOC_XTENSA_SLOT2_ALT
6177 ENUMX
6178 BFD_RELOC_XTENSA_SLOT3_ALT
6179 ENUMX
6180 BFD_RELOC_XTENSA_SLOT4_ALT
6181 ENUMX
6182 BFD_RELOC_XTENSA_SLOT5_ALT
6183 ENUMX
6184 BFD_RELOC_XTENSA_SLOT6_ALT
6185 ENUMX
6186 BFD_RELOC_XTENSA_SLOT7_ALT
6187 ENUMX
6188 BFD_RELOC_XTENSA_SLOT8_ALT
6189 ENUMX
6190 BFD_RELOC_XTENSA_SLOT9_ALT
6191 ENUMX
6192 BFD_RELOC_XTENSA_SLOT10_ALT
6193 ENUMX
6194 BFD_RELOC_XTENSA_SLOT11_ALT
6195 ENUMX
6196 BFD_RELOC_XTENSA_SLOT12_ALT
6197 ENUMX
6198 BFD_RELOC_XTENSA_SLOT13_ALT
6199 ENUMX
6200 BFD_RELOC_XTENSA_SLOT14_ALT
6201 ENUMDOC
6202 Alternate Xtensa relocations. Only the slot is encoded in the
6203 relocation. The meaning of these relocations is opcode-specific.
6204 ENUM
6205 BFD_RELOC_XTENSA_OP0
6206 ENUMX
6207 BFD_RELOC_XTENSA_OP1
6208 ENUMX
6209 BFD_RELOC_XTENSA_OP2
6210 ENUMDOC
6211 Xtensa relocations for backward compatibility. These have all been
6212 replaced by BFD_RELOC_XTENSA_SLOT0_OP.
6213 ENUM
6214 BFD_RELOC_XTENSA_ASM_EXPAND
6215 ENUMDOC
6216 Xtensa relocation to mark that the assembler expanded the
6217 instructions from an original target. The expansion size is
6218 encoded in the reloc size.
6219 ENUM
6220 BFD_RELOC_XTENSA_ASM_SIMPLIFY
6221 ENUMDOC
6222 Xtensa relocation to mark that the linker should simplify
6223 assembler-expanded instructions. This is commonly used
6224 internally by the linker after analysis of a
6225 BFD_RELOC_XTENSA_ASM_EXPAND.
6226 ENUM
6227 BFD_RELOC_XTENSA_TLSDESC_FN
6228 ENUMX
6229 BFD_RELOC_XTENSA_TLSDESC_ARG
6230 ENUMX
6231 BFD_RELOC_XTENSA_TLS_DTPOFF
6232 ENUMX
6233 BFD_RELOC_XTENSA_TLS_TPOFF
6234 ENUMX
6235 BFD_RELOC_XTENSA_TLS_FUNC
6236 ENUMX
6237 BFD_RELOC_XTENSA_TLS_ARG
6238 ENUMX
6239 BFD_RELOC_XTENSA_TLS_CALL
6240 ENUMDOC
6241 Xtensa TLS relocations.
6242
6243 ENUM
6244 BFD_RELOC_Z80_DISP8
6245 ENUMDOC
6246 8 bit signed offset in (ix+d) or (iy+d).
6247
6248 ENUM
6249 BFD_RELOC_Z8K_DISP7
6250 ENUMDOC
6251 DJNZ offset.
6252 ENUM
6253 BFD_RELOC_Z8K_CALLR
6254 ENUMDOC
6255 CALR offset.
6256 ENUM
6257 BFD_RELOC_Z8K_IMM4L
6258 ENUMDOC
6259 4 bit value.
6260
6261 ENUM
6262 BFD_RELOC_LM32_CALL
6263 ENUMX
6264 BFD_RELOC_LM32_BRANCH
6265 ENUMX
6266 BFD_RELOC_LM32_16_GOT
6267 ENUMX
6268 BFD_RELOC_LM32_GOTOFF_HI16
6269 ENUMX
6270 BFD_RELOC_LM32_GOTOFF_LO16
6271 ENUMX
6272 BFD_RELOC_LM32_COPY
6273 ENUMX
6274 BFD_RELOC_LM32_GLOB_DAT
6275 ENUMX
6276 BFD_RELOC_LM32_JMP_SLOT
6277 ENUMX
6278 BFD_RELOC_LM32_RELATIVE
6279 ENUMDOC
6280 Lattice Mico32 relocations.
6281
6282 ENUM
6283 BFD_RELOC_MACH_O_SECTDIFF
6284 ENUMDOC
6285 Difference between two section addreses. Must be followed by a
6286 BFD_RELOC_MACH_O_PAIR.
6287 ENUM
6288 BFD_RELOC_MACH_O_LOCAL_SECTDIFF
6289 ENUMDOC
6290 Like BFD_RELOC_MACH_O_SECTDIFF but with a local symbol.
6291 ENUM
6292 BFD_RELOC_MACH_O_PAIR
6293 ENUMDOC
6294 Pair of relocation. Contains the first symbol.
6295
6296 ENUM
6297 BFD_RELOC_MACH_O_X86_64_BRANCH32
6298 ENUMX
6299 BFD_RELOC_MACH_O_X86_64_BRANCH8
6300 ENUMDOC
6301 PCREL relocations. They are marked as branch to create PLT entry if
6302 required.
6303 ENUM
6304 BFD_RELOC_MACH_O_X86_64_GOT
6305 ENUMDOC
6306 Used when referencing a GOT entry.
6307 ENUM
6308 BFD_RELOC_MACH_O_X86_64_GOT_LOAD
6309 ENUMDOC
6310 Used when loading a GOT entry with movq. It is specially marked so that
6311 the linker could optimize the movq to a leaq if possible.
6312 ENUM
6313 BFD_RELOC_MACH_O_X86_64_SUBTRACTOR32
6314 ENUMDOC
6315 Symbol will be substracted. Must be followed by a BFD_RELOC_64.
6316 ENUM
6317 BFD_RELOC_MACH_O_X86_64_SUBTRACTOR64
6318 ENUMDOC
6319 Symbol will be substracted. Must be followed by a BFD_RELOC_64.
6320 ENUM
6321 BFD_RELOC_MACH_O_X86_64_PCREL32_1
6322 ENUMDOC
6323 Same as BFD_RELOC_32_PCREL but with an implicit -1 addend.
6324 ENUM
6325 BFD_RELOC_MACH_O_X86_64_PCREL32_2
6326 ENUMDOC
6327 Same as BFD_RELOC_32_PCREL but with an implicit -2 addend.
6328 ENUM
6329 BFD_RELOC_MACH_O_X86_64_PCREL32_4
6330 ENUMDOC
6331 Same as BFD_RELOC_32_PCREL but with an implicit -4 addend.
6332
6333 ENUM
6334 BFD_RELOC_MICROBLAZE_32_LO
6335 ENUMDOC
6336 This is a 32 bit reloc for the microblaze that stores the
6337 low 16 bits of a value
6338 ENUM
6339 BFD_RELOC_MICROBLAZE_32_LO_PCREL
6340 ENUMDOC
6341 This is a 32 bit pc-relative reloc for the microblaze that
6342 stores the low 16 bits of a value
6343 ENUM
6344 BFD_RELOC_MICROBLAZE_32_ROSDA
6345 ENUMDOC
6346 This is a 32 bit reloc for the microblaze that stores a
6347 value relative to the read-only small data area anchor
6348 ENUM
6349 BFD_RELOC_MICROBLAZE_32_RWSDA
6350 ENUMDOC
6351 This is a 32 bit reloc for the microblaze that stores a
6352 value relative to the read-write small data area anchor
6353 ENUM
6354 BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM
6355 ENUMDOC
6356 This is a 32 bit reloc for the microblaze to handle
6357 expressions of the form "Symbol Op Symbol"
6358 ENUM
6359 BFD_RELOC_MICROBLAZE_64_NONE
6360 ENUMDOC
6361 This is a 64 bit reloc that stores the 32 bit pc relative
6362 value in two words (with an imm instruction). No relocation is
6363 done here - only used for relaxing
6364 ENUM
6365 BFD_RELOC_MICROBLAZE_64_GOTPC
6366 ENUMDOC
6367 This is a 64 bit reloc that stores the 32 bit pc relative
6368 value in two words (with an imm instruction). The relocation is
6369 PC-relative GOT offset
6370 ENUM
6371 BFD_RELOC_MICROBLAZE_64_GOT
6372 ENUMDOC
6373 This is a 64 bit reloc that stores the 32 bit pc relative
6374 value in two words (with an imm instruction). The relocation is
6375 GOT offset
6376 ENUM
6377 BFD_RELOC_MICROBLAZE_64_PLT
6378 ENUMDOC
6379 This is a 64 bit reloc that stores the 32 bit pc relative
6380 value in two words (with an imm instruction). The relocation is
6381 PC-relative offset into PLT
6382 ENUM
6383 BFD_RELOC_MICROBLAZE_64_GOTOFF
6384 ENUMDOC
6385 This is a 64 bit reloc that stores the 32 bit GOT relative
6386 value in two words (with an imm instruction). The relocation is
6387 relative offset from _GLOBAL_OFFSET_TABLE_
6388 ENUM
6389 BFD_RELOC_MICROBLAZE_32_GOTOFF
6390 ENUMDOC
6391 This is a 32 bit reloc that stores the 32 bit GOT relative
6392 value in a word. The relocation is relative offset from
6393 _GLOBAL_OFFSET_TABLE_
6394 ENUM
6395 BFD_RELOC_MICROBLAZE_COPY
6396 ENUMDOC
6397 This is used to tell the dynamic linker to copy the value out of
6398 the dynamic object into the runtime process image.
6399 ENUM
6400 BFD_RELOC_MICROBLAZE_64_TLS
6401 ENUMDOC
6402 Unused Reloc
6403 ENUM
6404 BFD_RELOC_MICROBLAZE_64_TLSGD
6405 ENUMDOC
6406 This is a 64 bit reloc that stores the 32 bit GOT relative value
6407 of the GOT TLS GD info entry in two words (with an imm instruction). The
6408 relocation is GOT offset.
6409 ENUM
6410 BFD_RELOC_MICROBLAZE_64_TLSLD
6411 ENUMDOC
6412 This is a 64 bit reloc that stores the 32 bit GOT relative value
6413 of the GOT TLS LD info entry in two words (with an imm instruction). The
6414 relocation is GOT offset.
6415 ENUM
6416 BFD_RELOC_MICROBLAZE_32_TLSDTPMOD
6417 ENUMDOC
6418 This is a 32 bit reloc that stores the Module ID to GOT(n).
6419 ENUM
6420 BFD_RELOC_MICROBLAZE_32_TLSDTPREL
6421 ENUMDOC
6422 This is a 32 bit reloc that stores TLS offset to GOT(n+1).
6423 ENUM
6424 BFD_RELOC_MICROBLAZE_64_TLSDTPREL
6425 ENUMDOC
6426 This is a 32 bit reloc for storing TLS offset to two words (uses imm
6427 instruction)
6428 ENUM
6429 BFD_RELOC_MICROBLAZE_64_TLSGOTTPREL
6430 ENUMDOC
6431 This is a 64 bit reloc that stores 32-bit thread pointer relative offset
6432 to two words (uses imm instruction).
6433 ENUM
6434 BFD_RELOC_MICROBLAZE_64_TLSTPREL
6435 ENUMDOC
6436 This is a 64 bit reloc that stores 32-bit thread pointer relative offset
6437 to two words (uses imm instruction).
6438
6439 ENUM
6440 BFD_RELOC_AARCH64_RELOC_START
6441 ENUMDOC
6442 AArch64 pseudo relocation code to mark the start of the AArch64
6443 relocation enumerators. N.B. the order of the enumerators is
6444 important as several tables in the AArch64 bfd backend are indexed
6445 by these enumerators; make sure they are all synced.
6446 ENUM
6447 BFD_RELOC_AARCH64_NONE
6448 ENUMDOC
6449 AArch64 null relocation code.
6450 ENUM
6451 BFD_RELOC_AARCH64_64
6452 ENUMX
6453 BFD_RELOC_AARCH64_32
6454 ENUMX
6455 BFD_RELOC_AARCH64_16
6456 ENUMDOC
6457 Basic absolute relocations of N bits. These are equivalent to
6458 BFD_RELOC_N and they were added to assist the indexing of the howto
6459 table.
6460 ENUM
6461 BFD_RELOC_AARCH64_64_PCREL
6462 ENUMX
6463 BFD_RELOC_AARCH64_32_PCREL
6464 ENUMX
6465 BFD_RELOC_AARCH64_16_PCREL
6466 ENUMDOC
6467 PC-relative relocations. These are equivalent to BFD_RELOC_N_PCREL
6468 and they were added to assist the indexing of the howto table.
6469 ENUM
6470 BFD_RELOC_AARCH64_MOVW_G0
6471 ENUMDOC
6472 AArch64 MOV[NZK] instruction with most significant bits 0 to 15
6473 of an unsigned address/value.
6474 ENUM
6475 BFD_RELOC_AARCH64_MOVW_G0_NC
6476 ENUMDOC
6477 AArch64 MOV[NZK] instruction with less significant bits 0 to 15 of
6478 an address/value. No overflow checking.
6479 ENUM
6480 BFD_RELOC_AARCH64_MOVW_G1
6481 ENUMDOC
6482 AArch64 MOV[NZK] instruction with most significant bits 16 to 31
6483 of an unsigned address/value.
6484 ENUM
6485 BFD_RELOC_AARCH64_MOVW_G1_NC
6486 ENUMDOC
6487 AArch64 MOV[NZK] instruction with less significant bits 16 to 31
6488 of an address/value. No overflow checking.
6489 ENUM
6490 BFD_RELOC_AARCH64_MOVW_G2
6491 ENUMDOC
6492 AArch64 MOV[NZK] instruction with most significant bits 32 to 47
6493 of an unsigned address/value.
6494 ENUM
6495 BFD_RELOC_AARCH64_MOVW_G2_NC
6496 ENUMDOC
6497 AArch64 MOV[NZK] instruction with less significant bits 32 to 47
6498 of an address/value. No overflow checking.
6499 ENUM
6500 BFD_RELOC_AARCH64_MOVW_G3
6501 ENUMDOC
6502 AArch64 MOV[NZK] instruction with most signficant bits 48 to 64
6503 of a signed or unsigned address/value.
6504 ENUM
6505 BFD_RELOC_AARCH64_MOVW_G0_S
6506 ENUMDOC
6507 AArch64 MOV[NZ] instruction with most significant bits 0 to 15
6508 of a signed value. Changes instruction to MOVZ or MOVN depending on the
6509 value's sign.
6510 ENUM
6511 BFD_RELOC_AARCH64_MOVW_G1_S
6512 ENUMDOC
6513 AArch64 MOV[NZ] instruction with most significant bits 16 to 31
6514 of a signed value. Changes instruction to MOVZ or MOVN depending on the
6515 value's sign.
6516 ENUM
6517 BFD_RELOC_AARCH64_MOVW_G2_S
6518 ENUMDOC
6519 AArch64 MOV[NZ] instruction with most significant bits 32 to 47
6520 of a signed value. Changes instruction to MOVZ or MOVN depending on the
6521 value's sign.
6522 ENUM
6523 BFD_RELOC_AARCH64_LD_LO19_PCREL
6524 ENUMDOC
6525 AArch64 Load Literal instruction, holding a 19 bit pc-relative word
6526 offset. The lowest two bits must be zero and are not stored in the
6527 instruction, giving a 21 bit signed byte offset.
6528 ENUM
6529 BFD_RELOC_AARCH64_ADR_LO21_PCREL
6530 ENUMDOC
6531 AArch64 ADR instruction, holding a simple 21 bit pc-relative byte offset.
6532 ENUM
6533 BFD_RELOC_AARCH64_ADR_HI21_PCREL
6534 ENUMDOC
6535 AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page
6536 offset, giving a 4KB aligned page base address.
6537 ENUM
6538 BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL
6539 ENUMDOC
6540 AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page
6541 offset, giving a 4KB aligned page base address, but with no overflow
6542 checking.
6543 ENUM
6544 BFD_RELOC_AARCH64_ADD_LO12
6545 ENUMDOC
6546 AArch64 ADD immediate instruction, holding bits 0 to 11 of the address.
6547 Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6548 ENUM
6549 BFD_RELOC_AARCH64_LDST8_LO12
6550 ENUMDOC
6551 AArch64 8-bit load/store instruction, holding bits 0 to 11 of the
6552 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6553 ENUM
6554 BFD_RELOC_AARCH64_TSTBR14
6555 ENUMDOC
6556 AArch64 14 bit pc-relative test bit and branch.
6557 The lowest two bits must be zero and are not stored in the instruction,
6558 giving a 16 bit signed byte offset.
6559 ENUM
6560 BFD_RELOC_AARCH64_BRANCH19
6561 ENUMDOC
6562 AArch64 19 bit pc-relative conditional branch and compare & branch.
6563 The lowest two bits must be zero and are not stored in the instruction,
6564 giving a 21 bit signed byte offset.
6565 ENUM
6566 BFD_RELOC_AARCH64_JUMP26
6567 ENUMDOC
6568 AArch64 26 bit pc-relative unconditional branch.
6569 The lowest two bits must be zero and are not stored in the instruction,
6570 giving a 28 bit signed byte offset.
6571 ENUM
6572 BFD_RELOC_AARCH64_CALL26
6573 ENUMDOC
6574 AArch64 26 bit pc-relative unconditional branch and link.
6575 The lowest two bits must be zero and are not stored in the instruction,
6576 giving a 28 bit signed byte offset.
6577 ENUM
6578 BFD_RELOC_AARCH64_LDST16_LO12
6579 ENUMDOC
6580 AArch64 16-bit load/store instruction, holding bits 0 to 11 of the
6581 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6582 ENUM
6583 BFD_RELOC_AARCH64_LDST32_LO12
6584 ENUMDOC
6585 AArch64 32-bit load/store instruction, holding bits 0 to 11 of the
6586 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6587 ENUM
6588 BFD_RELOC_AARCH64_LDST64_LO12
6589 ENUMDOC
6590 AArch64 64-bit load/store instruction, holding bits 0 to 11 of the
6591 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6592 ENUM
6593 BFD_RELOC_AARCH64_LDST128_LO12
6594 ENUMDOC
6595 AArch64 128-bit load/store instruction, holding bits 0 to 11 of the
6596 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6597 ENUM
6598 BFD_RELOC_AARCH64_GOT_LD_PREL19
6599 ENUMDOC
6600 AArch64 Load Literal instruction, holding a 19 bit PC relative word
6601 offset of the global offset table entry for a symbol. The lowest two
6602 bits must be zero and are not stored in the instruction, giving a 21
6603 bit signed byte offset. This relocation type requires signed overflow
6604 checking.
6605 ENUM
6606 BFD_RELOC_AARCH64_ADR_GOT_PAGE
6607 ENUMDOC
6608 Get to the page base of the global offset table entry for a symbol as
6609 part of an ADRP instruction using a 21 bit PC relative value.Used in
6610 conjunction with BFD_RELOC_AARCH64_LD64_GOT_LO12_NC.
6611 ENUM
6612 BFD_RELOC_AARCH64_LD64_GOT_LO12_NC
6613 ENUMDOC
6614 Unsigned 12 bit byte offset for 64 bit load/store from the page of
6615 the GOT entry for this symbol. Used in conjunction with
6616 BFD_RELOC_AARCH64_ADR_GOTPAGE. Valid in LP64 ABI only.
6617 ENUM
6618 BFD_RELOC_AARCH64_LD32_GOT_LO12_NC
6619 ENUMDOC
6620 Unsigned 12 bit byte offset for 32 bit load/store from the page of
6621 the GOT entry for this symbol. Used in conjunction with
6622 BFD_RELOC_AARCH64_ADR_GOTPAGE. Valid in ILP32 ABI only.
6623 ENUM
6624 BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21
6625 ENUMDOC
6626 Get to the page base of the global offset table entry for a symbols
6627 tls_index structure as part of an adrp instruction using a 21 bit PC
6628 relative value. Used in conjunction with
6629 BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC.
6630 ENUM
6631 BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC
6632 ENUMDOC
6633 Unsigned 12 bit byte offset to global offset table entry for a symbols
6634 tls_index structure. Used in conjunction with
6635 BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21.
6636 ENUM
6637 BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1
6638 ENUMDOC
6639 AArch64 TLS INITIAL EXEC relocation.
6640 ENUM
6641 BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC
6642 ENUMDOC
6643 AArch64 TLS INITIAL EXEC relocation.
6644 ENUM
6645 BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21
6646 ENUMDOC
6647 AArch64 TLS INITIAL EXEC relocation.
6648 ENUM
6649 BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC
6650 ENUMDOC
6651 AArch64 TLS INITIAL EXEC relocation.
6652 ENUM
6653 BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC
6654 ENUMDOC
6655 AArch64 TLS INITIAL EXEC relocation.
6656 ENUM
6657 BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19
6658 ENUMDOC
6659 AArch64 TLS INITIAL EXEC relocation.
6660 ENUM
6661 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2
6662 ENUMDOC
6663 AArch64 TLS LOCAL EXEC relocation.
6664 ENUM
6665 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1
6666 ENUMDOC
6667 AArch64 TLS LOCAL EXEC relocation.
6668 ENUM
6669 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC
6670 ENUMDOC
6671 AArch64 TLS LOCAL EXEC relocation.
6672 ENUM
6673 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0
6674 ENUMDOC
6675 AArch64 TLS LOCAL EXEC relocation.
6676 ENUM
6677 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC
6678 ENUMDOC
6679 AArch64 TLS LOCAL EXEC relocation.
6680 ENUM
6681 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12
6682 ENUMDOC
6683 AArch64 TLS LOCAL EXEC relocation.
6684 ENUM
6685 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12
6686 ENUMDOC
6687 AArch64 TLS LOCAL EXEC relocation.
6688 ENUM
6689 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC
6690 ENUMDOC
6691 AArch64 TLS LOCAL EXEC relocation.
6692 ENUM
6693 BFD_RELOC_AARCH64_TLSDESC_LD_PREL19
6694 ENUMDOC
6695 AArch64 TLS DESC relocation.
6696 ENUM
6697 BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21
6698 ENUMDOC
6699 AArch64 TLS DESC relocation.
6700 ENUM
6701 BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21
6702 ENUMDOC
6703 AArch64 TLS DESC relocation.
6704 ENUM
6705 BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC
6706 ENUMDOC
6707 AArch64 TLS DESC relocation.
6708 ENUM
6709 BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC
6710 ENUMDOC
6711 AArch64 TLS DESC relocation.
6712 ENUM
6713 BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC
6714 ENUMDOC
6715 AArch64 TLS DESC relocation.
6716 ENUM
6717 BFD_RELOC_AARCH64_TLSDESC_OFF_G1
6718 ENUMDOC
6719 AArch64 TLS DESC relocation.
6720 ENUM
6721 BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC
6722 ENUMDOC
6723 AArch64 TLS DESC relocation.
6724 ENUM
6725 BFD_RELOC_AARCH64_TLSDESC_LDR
6726 ENUMDOC
6727 AArch64 TLS DESC relocation.
6728 ENUM
6729 BFD_RELOC_AARCH64_TLSDESC_ADD
6730 ENUMDOC
6731 AArch64 TLS DESC relocation.
6732 ENUM
6733 BFD_RELOC_AARCH64_TLSDESC_CALL
6734 ENUMDOC
6735 AArch64 TLS DESC relocation.
6736 ENUM
6737 BFD_RELOC_AARCH64_COPY
6738 ENUMDOC
6739 AArch64 TLS relocation.
6740 ENUM
6741 BFD_RELOC_AARCH64_GLOB_DAT
6742 ENUMDOC
6743 AArch64 TLS relocation.
6744 ENUM
6745 BFD_RELOC_AARCH64_JUMP_SLOT
6746 ENUMDOC
6747 AArch64 TLS relocation.
6748 ENUM
6749 BFD_RELOC_AARCH64_RELATIVE
6750 ENUMDOC
6751 AArch64 TLS relocation.
6752 ENUM
6753 BFD_RELOC_AARCH64_TLS_DTPMOD
6754 ENUMDOC
6755 AArch64 TLS relocation.
6756 ENUM
6757 BFD_RELOC_AARCH64_TLS_DTPREL
6758 ENUMDOC
6759 AArch64 TLS relocation.
6760 ENUM
6761 BFD_RELOC_AARCH64_TLS_TPREL
6762 ENUMDOC
6763 AArch64 TLS relocation.
6764 ENUM
6765 BFD_RELOC_AARCH64_TLSDESC
6766 ENUMDOC
6767 AArch64 TLS relocation.
6768 ENUM
6769 BFD_RELOC_AARCH64_IRELATIVE
6770 ENUMDOC
6771 AArch64 support for STT_GNU_IFUNC.
6772 ENUM
6773 BFD_RELOC_AARCH64_RELOC_END
6774 ENUMDOC
6775 AArch64 pseudo relocation code to mark the end of the AArch64
6776 relocation enumerators that have direct mapping to ELF reloc codes.
6777 There are a few more enumerators after this one; those are mainly
6778 used by the AArch64 assembler for the internal fixup or to select
6779 one of the above enumerators.
6780 ENUM
6781 BFD_RELOC_AARCH64_GAS_INTERNAL_FIXUP
6782 ENUMDOC
6783 AArch64 pseudo relocation code to be used internally by the AArch64
6784 assembler and not (currently) written to any object files.
6785 ENUM
6786 BFD_RELOC_AARCH64_LDST_LO12
6787 ENUMDOC
6788 AArch64 unspecified load/store instruction, holding bits 0 to 11 of the
6789 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6790 ENUM
6791 BFD_RELOC_AARCH64_LD_GOT_LO12_NC
6792 ENUMDOC
6793 AArch64 pseudo relocation code to be used internally by the AArch64
6794 assembler and not (currently) written to any object files.
6795 ENUM
6796 BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_LO12_NC
6797 ENUMDOC
6798 AArch64 pseudo relocation code to be used internally by the AArch64
6799 assembler and not (currently) written to any object files.
6800 ENUM
6801 BFD_RELOC_AARCH64_TLSDESC_LD_LO12_NC
6802 ENUMDOC
6803 AArch64 pseudo relocation code to be used internally by the AArch64
6804 assembler and not (currently) written to any object files.
6805
6806 ENUM
6807 BFD_RELOC_TILEPRO_COPY
6808 ENUMX
6809 BFD_RELOC_TILEPRO_GLOB_DAT
6810 ENUMX
6811 BFD_RELOC_TILEPRO_JMP_SLOT
6812 ENUMX
6813 BFD_RELOC_TILEPRO_RELATIVE
6814 ENUMX
6815 BFD_RELOC_TILEPRO_BROFF_X1
6816 ENUMX
6817 BFD_RELOC_TILEPRO_JOFFLONG_X1
6818 ENUMX
6819 BFD_RELOC_TILEPRO_JOFFLONG_X1_PLT
6820 ENUMX
6821 BFD_RELOC_TILEPRO_IMM8_X0
6822 ENUMX
6823 BFD_RELOC_TILEPRO_IMM8_Y0
6824 ENUMX
6825 BFD_RELOC_TILEPRO_IMM8_X1
6826 ENUMX
6827 BFD_RELOC_TILEPRO_IMM8_Y1
6828 ENUMX
6829 BFD_RELOC_TILEPRO_DEST_IMM8_X1
6830 ENUMX
6831 BFD_RELOC_TILEPRO_MT_IMM15_X1
6832 ENUMX
6833 BFD_RELOC_TILEPRO_MF_IMM15_X1
6834 ENUMX
6835 BFD_RELOC_TILEPRO_IMM16_X0
6836 ENUMX
6837 BFD_RELOC_TILEPRO_IMM16_X1
6838 ENUMX
6839 BFD_RELOC_TILEPRO_IMM16_X0_LO
6840 ENUMX
6841 BFD_RELOC_TILEPRO_IMM16_X1_LO
6842 ENUMX
6843 BFD_RELOC_TILEPRO_IMM16_X0_HI
6844 ENUMX
6845 BFD_RELOC_TILEPRO_IMM16_X1_HI
6846 ENUMX
6847 BFD_RELOC_TILEPRO_IMM16_X0_HA
6848 ENUMX
6849 BFD_RELOC_TILEPRO_IMM16_X1_HA
6850 ENUMX
6851 BFD_RELOC_TILEPRO_IMM16_X0_PCREL
6852 ENUMX
6853 BFD_RELOC_TILEPRO_IMM16_X1_PCREL
6854 ENUMX
6855 BFD_RELOC_TILEPRO_IMM16_X0_LO_PCREL
6856 ENUMX
6857 BFD_RELOC_TILEPRO_IMM16_X1_LO_PCREL
6858 ENUMX
6859 BFD_RELOC_TILEPRO_IMM16_X0_HI_PCREL
6860 ENUMX
6861 BFD_RELOC_TILEPRO_IMM16_X1_HI_PCREL
6862 ENUMX
6863 BFD_RELOC_TILEPRO_IMM16_X0_HA_PCREL
6864 ENUMX
6865 BFD_RELOC_TILEPRO_IMM16_X1_HA_PCREL
6866 ENUMX
6867 BFD_RELOC_TILEPRO_IMM16_X0_GOT
6868 ENUMX
6869 BFD_RELOC_TILEPRO_IMM16_X1_GOT
6870 ENUMX
6871 BFD_RELOC_TILEPRO_IMM16_X0_GOT_LO
6872 ENUMX
6873 BFD_RELOC_TILEPRO_IMM16_X1_GOT_LO
6874 ENUMX
6875 BFD_RELOC_TILEPRO_IMM16_X0_GOT_HI
6876 ENUMX
6877 BFD_RELOC_TILEPRO_IMM16_X1_GOT_HI
6878 ENUMX
6879 BFD_RELOC_TILEPRO_IMM16_X0_GOT_HA
6880 ENUMX
6881 BFD_RELOC_TILEPRO_IMM16_X1_GOT_HA
6882 ENUMX
6883 BFD_RELOC_TILEPRO_MMSTART_X0
6884 ENUMX
6885 BFD_RELOC_TILEPRO_MMEND_X0
6886 ENUMX
6887 BFD_RELOC_TILEPRO_MMSTART_X1
6888 ENUMX
6889 BFD_RELOC_TILEPRO_MMEND_X1
6890 ENUMX
6891 BFD_RELOC_TILEPRO_SHAMT_X0
6892 ENUMX
6893 BFD_RELOC_TILEPRO_SHAMT_X1
6894 ENUMX
6895 BFD_RELOC_TILEPRO_SHAMT_Y0
6896 ENUMX
6897 BFD_RELOC_TILEPRO_SHAMT_Y1
6898 ENUMX
6899 BFD_RELOC_TILEPRO_TLS_GD_CALL
6900 ENUMX
6901 BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD
6902 ENUMX
6903 BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD
6904 ENUMX
6905 BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD
6906 ENUMX
6907 BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD
6908 ENUMX
6909 BFD_RELOC_TILEPRO_TLS_IE_LOAD
6910 ENUMX
6911 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD
6912 ENUMX
6913 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD
6914 ENUMX
6915 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO
6916 ENUMX
6917 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_LO
6918 ENUMX
6919 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HI
6920 ENUMX
6921 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HI
6922 ENUMX
6923 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HA
6924 ENUMX
6925 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HA
6926 ENUMX
6927 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE
6928 ENUMX
6929 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE
6930 ENUMX
6931 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_LO
6932 ENUMX
6933 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_LO
6934 ENUMX
6935 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HI
6936 ENUMX
6937 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HI
6938 ENUMX
6939 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HA
6940 ENUMX
6941 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HA
6942 ENUMX
6943 BFD_RELOC_TILEPRO_TLS_DTPMOD32
6944 ENUMX
6945 BFD_RELOC_TILEPRO_TLS_DTPOFF32
6946 ENUMX
6947 BFD_RELOC_TILEPRO_TLS_TPOFF32
6948 ENUMX
6949 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE
6950 ENUMX
6951 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE
6952 ENUMX
6953 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_LO
6954 ENUMX
6955 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_LO
6956 ENUMX
6957 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HI
6958 ENUMX
6959 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HI
6960 ENUMX
6961 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HA
6962 ENUMX
6963 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HA
6964 ENUMDOC
6965 Tilera TILEPro Relocations.
6966 ENUM
6967 BFD_RELOC_TILEGX_HW0
6968 ENUMX
6969 BFD_RELOC_TILEGX_HW1
6970 ENUMX
6971 BFD_RELOC_TILEGX_HW2
6972 ENUMX
6973 BFD_RELOC_TILEGX_HW3
6974 ENUMX
6975 BFD_RELOC_TILEGX_HW0_LAST
6976 ENUMX
6977 BFD_RELOC_TILEGX_HW1_LAST
6978 ENUMX
6979 BFD_RELOC_TILEGX_HW2_LAST
6980 ENUMX
6981 BFD_RELOC_TILEGX_COPY
6982 ENUMX
6983 BFD_RELOC_TILEGX_GLOB_DAT
6984 ENUMX
6985 BFD_RELOC_TILEGX_JMP_SLOT
6986 ENUMX
6987 BFD_RELOC_TILEGX_RELATIVE
6988 ENUMX
6989 BFD_RELOC_TILEGX_BROFF_X1
6990 ENUMX
6991 BFD_RELOC_TILEGX_JUMPOFF_X1
6992 ENUMX
6993 BFD_RELOC_TILEGX_JUMPOFF_X1_PLT
6994 ENUMX
6995 BFD_RELOC_TILEGX_IMM8_X0
6996 ENUMX
6997 BFD_RELOC_TILEGX_IMM8_Y0
6998 ENUMX
6999 BFD_RELOC_TILEGX_IMM8_X1
7000 ENUMX
7001 BFD_RELOC_TILEGX_IMM8_Y1
7002 ENUMX
7003 BFD_RELOC_TILEGX_DEST_IMM8_X1
7004 ENUMX
7005 BFD_RELOC_TILEGX_MT_IMM14_X1
7006 ENUMX
7007 BFD_RELOC_TILEGX_MF_IMM14_X1
7008 ENUMX
7009 BFD_RELOC_TILEGX_MMSTART_X0
7010 ENUMX
7011 BFD_RELOC_TILEGX_MMEND_X0
7012 ENUMX
7013 BFD_RELOC_TILEGX_SHAMT_X0
7014 ENUMX
7015 BFD_RELOC_TILEGX_SHAMT_X1
7016 ENUMX
7017 BFD_RELOC_TILEGX_SHAMT_Y0
7018 ENUMX
7019 BFD_RELOC_TILEGX_SHAMT_Y1
7020 ENUMX
7021 BFD_RELOC_TILEGX_IMM16_X0_HW0
7022 ENUMX
7023 BFD_RELOC_TILEGX_IMM16_X1_HW0
7024 ENUMX
7025 BFD_RELOC_TILEGX_IMM16_X0_HW1
7026 ENUMX
7027 BFD_RELOC_TILEGX_IMM16_X1_HW1
7028 ENUMX
7029 BFD_RELOC_TILEGX_IMM16_X0_HW2
7030 ENUMX
7031 BFD_RELOC_TILEGX_IMM16_X1_HW2
7032 ENUMX
7033 BFD_RELOC_TILEGX_IMM16_X0_HW3
7034 ENUMX
7035 BFD_RELOC_TILEGX_IMM16_X1_HW3
7036 ENUMX
7037 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST
7038 ENUMX
7039 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST
7040 ENUMX
7041 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST
7042 ENUMX
7043 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST
7044 ENUMX
7045 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST
7046 ENUMX
7047 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST
7048 ENUMX
7049 BFD_RELOC_TILEGX_IMM16_X0_HW0_PCREL
7050 ENUMX
7051 BFD_RELOC_TILEGX_IMM16_X1_HW0_PCREL
7052 ENUMX
7053 BFD_RELOC_TILEGX_IMM16_X0_HW1_PCREL
7054 ENUMX
7055 BFD_RELOC_TILEGX_IMM16_X1_HW1_PCREL
7056 ENUMX
7057 BFD_RELOC_TILEGX_IMM16_X0_HW2_PCREL
7058 ENUMX
7059 BFD_RELOC_TILEGX_IMM16_X1_HW2_PCREL
7060 ENUMX
7061 BFD_RELOC_TILEGX_IMM16_X0_HW3_PCREL
7062 ENUMX
7063 BFD_RELOC_TILEGX_IMM16_X1_HW3_PCREL
7064 ENUMX
7065 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PCREL
7066 ENUMX
7067 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PCREL
7068 ENUMX
7069 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PCREL
7070 ENUMX
7071 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PCREL
7072 ENUMX
7073 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PCREL
7074 ENUMX
7075 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PCREL
7076 ENUMX
7077 BFD_RELOC_TILEGX_IMM16_X0_HW0_GOT
7078 ENUMX
7079 BFD_RELOC_TILEGX_IMM16_X1_HW0_GOT
7080 ENUMX
7081 BFD_RELOC_TILEGX_IMM16_X0_HW0_PLT_PCREL
7082 ENUMX
7083 BFD_RELOC_TILEGX_IMM16_X1_HW0_PLT_PCREL
7084 ENUMX
7085 BFD_RELOC_TILEGX_IMM16_X0_HW1_PLT_PCREL
7086 ENUMX
7087 BFD_RELOC_TILEGX_IMM16_X1_HW1_PLT_PCREL
7088 ENUMX
7089 BFD_RELOC_TILEGX_IMM16_X0_HW2_PLT_PCREL
7090 ENUMX
7091 BFD_RELOC_TILEGX_IMM16_X1_HW2_PLT_PCREL
7092 ENUMX
7093 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_GOT
7094 ENUMX
7095 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_GOT
7096 ENUMX
7097 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_GOT
7098 ENUMX
7099 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_GOT
7100 ENUMX
7101 BFD_RELOC_TILEGX_IMM16_X0_HW3_PLT_PCREL
7102 ENUMX
7103 BFD_RELOC_TILEGX_IMM16_X1_HW3_PLT_PCREL
7104 ENUMX
7105 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_GD
7106 ENUMX
7107 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_GD
7108 ENUMX
7109 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_LE
7110 ENUMX
7111 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_LE
7112 ENUMX
7113 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
7114 ENUMX
7115 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
7116 ENUMX
7117 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
7118 ENUMX
7119 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
7120 ENUMX
7121 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
7122 ENUMX
7123 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
7124 ENUMX
7125 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
7126 ENUMX
7127 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
7128 ENUMX
7129 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_IE
7130 ENUMX
7131 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_IE
7132 ENUMX
7133 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
7134 ENUMX
7135 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
7136 ENUMX
7137 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
7138 ENUMX
7139 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
7140 ENUMX
7141 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
7142 ENUMX
7143 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
7144 ENUMX
7145 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
7146 ENUMX
7147 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
7148 ENUMX
7149 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
7150 ENUMX
7151 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
7152 ENUMX
7153 BFD_RELOC_TILEGX_TLS_DTPMOD64
7154 ENUMX
7155 BFD_RELOC_TILEGX_TLS_DTPOFF64
7156 ENUMX
7157 BFD_RELOC_TILEGX_TLS_TPOFF64
7158 ENUMX
7159 BFD_RELOC_TILEGX_TLS_DTPMOD32
7160 ENUMX
7161 BFD_RELOC_TILEGX_TLS_DTPOFF32
7162 ENUMX
7163 BFD_RELOC_TILEGX_TLS_TPOFF32
7164 ENUMX
7165 BFD_RELOC_TILEGX_TLS_GD_CALL
7166 ENUMX
7167 BFD_RELOC_TILEGX_IMM8_X0_TLS_GD_ADD
7168 ENUMX
7169 BFD_RELOC_TILEGX_IMM8_X1_TLS_GD_ADD
7170 ENUMX
7171 BFD_RELOC_TILEGX_IMM8_Y0_TLS_GD_ADD
7172 ENUMX
7173 BFD_RELOC_TILEGX_IMM8_Y1_TLS_GD_ADD
7174 ENUMX
7175 BFD_RELOC_TILEGX_TLS_IE_LOAD
7176 ENUMX
7177 BFD_RELOC_TILEGX_IMM8_X0_TLS_ADD
7178 ENUMX
7179 BFD_RELOC_TILEGX_IMM8_X1_TLS_ADD
7180 ENUMX
7181 BFD_RELOC_TILEGX_IMM8_Y0_TLS_ADD
7182 ENUMX
7183 BFD_RELOC_TILEGX_IMM8_Y1_TLS_ADD
7184 ENUMDOC
7185 Tilera TILE-Gx Relocations.
7186 ENUM
7187 BFD_RELOC_EPIPHANY_SIMM8
7188 ENUMDOC
7189 Adapteva EPIPHANY - 8 bit signed pc-relative displacement
7190 ENUM
7191 BFD_RELOC_EPIPHANY_SIMM24
7192 ENUMDOC
7193 Adapteva EPIPHANY - 24 bit signed pc-relative displacement
7194 ENUM
7195 BFD_RELOC_EPIPHANY_HIGH
7196 ENUMDOC
7197 Adapteva EPIPHANY - 16 most-significant bits of absolute address
7198 ENUM
7199 BFD_RELOC_EPIPHANY_LOW
7200 ENUMDOC
7201 Adapteva EPIPHANY - 16 least-significant bits of absolute address
7202 ENUM
7203 BFD_RELOC_EPIPHANY_SIMM11
7204 ENUMDOC
7205 Adapteva EPIPHANY - 11 bit signed number - add/sub immediate
7206 ENUM
7207 BFD_RELOC_EPIPHANY_IMM11
7208 ENUMDOC
7209 Adapteva EPIPHANY - 11 bit sign-magnitude number (ld/st displacement)
7210 ENUM
7211 BFD_RELOC_EPIPHANY_IMM8
7212 ENUMDOC
7213 Adapteva EPIPHANY - 8 bit immediate for 16 bit mov instruction.
7214
7215
7216 ENDSENUM
7217 BFD_RELOC_UNUSED
7218 CODE_FRAGMENT
7219 .
7220 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
7221 */
7222
7223 /*
7224 FUNCTION
7225 bfd_reloc_type_lookup
7226 bfd_reloc_name_lookup
7227
7228 SYNOPSIS
7229 reloc_howto_type *bfd_reloc_type_lookup
7230 (bfd *abfd, bfd_reloc_code_real_type code);
7231 reloc_howto_type *bfd_reloc_name_lookup
7232 (bfd *abfd, const char *reloc_name);
7233
7234 DESCRIPTION
7235 Return a pointer to a howto structure which, when
7236 invoked, will perform the relocation @var{code} on data from the
7237 architecture noted.
7238
7239 */
7240
7241 reloc_howto_type *
7242 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
7243 {
7244 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
7245 }
7246
7247 reloc_howto_type *
7248 bfd_reloc_name_lookup (bfd *abfd, const char *reloc_name)
7249 {
7250 return BFD_SEND (abfd, reloc_name_lookup, (abfd, reloc_name));
7251 }
7252
7253 static reloc_howto_type bfd_howto_32 =
7254 HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_dont, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE);
7255
7256 /*
7257 INTERNAL_FUNCTION
7258 bfd_default_reloc_type_lookup
7259
7260 SYNOPSIS
7261 reloc_howto_type *bfd_default_reloc_type_lookup
7262 (bfd *abfd, bfd_reloc_code_real_type code);
7263
7264 DESCRIPTION
7265 Provides a default relocation lookup routine for any architecture.
7266
7267 */
7268
7269 reloc_howto_type *
7270 bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
7271 {
7272 switch (code)
7273 {
7274 case BFD_RELOC_CTOR:
7275 /* The type of reloc used in a ctor, which will be as wide as the
7276 address - so either a 64, 32, or 16 bitter. */
7277 switch (bfd_arch_bits_per_address (abfd))
7278 {
7279 case 64:
7280 BFD_FAIL ();
7281 case 32:
7282 return &bfd_howto_32;
7283 case 16:
7284 BFD_FAIL ();
7285 default:
7286 BFD_FAIL ();
7287 }
7288 default:
7289 BFD_FAIL ();
7290 }
7291 return NULL;
7292 }
7293
7294 /*
7295 FUNCTION
7296 bfd_get_reloc_code_name
7297
7298 SYNOPSIS
7299 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
7300
7301 DESCRIPTION
7302 Provides a printable name for the supplied relocation code.
7303 Useful mainly for printing error messages.
7304 */
7305
7306 const char *
7307 bfd_get_reloc_code_name (bfd_reloc_code_real_type code)
7308 {
7309 if (code > BFD_RELOC_UNUSED)
7310 return 0;
7311 return bfd_reloc_code_real_names[code];
7312 }
7313
7314 /*
7315 INTERNAL_FUNCTION
7316 bfd_generic_relax_section
7317
7318 SYNOPSIS
7319 bfd_boolean bfd_generic_relax_section
7320 (bfd *abfd,
7321 asection *section,
7322 struct bfd_link_info *,
7323 bfd_boolean *);
7324
7325 DESCRIPTION
7326 Provides default handling for relaxing for back ends which
7327 don't do relaxing.
7328 */
7329
7330 bfd_boolean
7331 bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
7332 asection *section ATTRIBUTE_UNUSED,
7333 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
7334 bfd_boolean *again)
7335 {
7336 if (link_info->relocatable)
7337 (*link_info->callbacks->einfo)
7338 (_("%P%F: --relax and -r may not be used together\n"));
7339
7340 *again = FALSE;
7341 return TRUE;
7342 }
7343
7344 /*
7345 INTERNAL_FUNCTION
7346 bfd_generic_gc_sections
7347
7348 SYNOPSIS
7349 bfd_boolean bfd_generic_gc_sections
7350 (bfd *, struct bfd_link_info *);
7351
7352 DESCRIPTION
7353 Provides default handling for relaxing for back ends which
7354 don't do section gc -- i.e., does nothing.
7355 */
7356
7357 bfd_boolean
7358 bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED,
7359 struct bfd_link_info *info ATTRIBUTE_UNUSED)
7360 {
7361 return TRUE;
7362 }
7363
7364 /*
7365 INTERNAL_FUNCTION
7366 bfd_generic_lookup_section_flags
7367
7368 SYNOPSIS
7369 bfd_boolean bfd_generic_lookup_section_flags
7370 (struct bfd_link_info *, struct flag_info *, asection *);
7371
7372 DESCRIPTION
7373 Provides default handling for section flags lookup
7374 -- i.e., does nothing.
7375 Returns FALSE if the section should be omitted, otherwise TRUE.
7376 */
7377
7378 bfd_boolean
7379 bfd_generic_lookup_section_flags (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7380 struct flag_info *flaginfo,
7381 asection *section ATTRIBUTE_UNUSED)
7382 {
7383 if (flaginfo != NULL)
7384 {
7385 (*_bfd_error_handler) (_("INPUT_SECTION_FLAGS are not supported.\n"));
7386 return FALSE;
7387 }
7388 return TRUE;
7389 }
7390
7391 /*
7392 INTERNAL_FUNCTION
7393 bfd_generic_merge_sections
7394
7395 SYNOPSIS
7396 bfd_boolean bfd_generic_merge_sections
7397 (bfd *, struct bfd_link_info *);
7398
7399 DESCRIPTION
7400 Provides default handling for SEC_MERGE section merging for back ends
7401 which don't have SEC_MERGE support -- i.e., does nothing.
7402 */
7403
7404 bfd_boolean
7405 bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED,
7406 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
7407 {
7408 return TRUE;
7409 }
7410
7411 /*
7412 INTERNAL_FUNCTION
7413 bfd_generic_get_relocated_section_contents
7414
7415 SYNOPSIS
7416 bfd_byte *bfd_generic_get_relocated_section_contents
7417 (bfd *abfd,
7418 struct bfd_link_info *link_info,
7419 struct bfd_link_order *link_order,
7420 bfd_byte *data,
7421 bfd_boolean relocatable,
7422 asymbol **symbols);
7423
7424 DESCRIPTION
7425 Provides default handling of relocation effort for back ends
7426 which can't be bothered to do it efficiently.
7427
7428 */
7429
7430 bfd_byte *
7431 bfd_generic_get_relocated_section_contents (bfd *abfd,
7432 struct bfd_link_info *link_info,
7433 struct bfd_link_order *link_order,
7434 bfd_byte *data,
7435 bfd_boolean relocatable,
7436 asymbol **symbols)
7437 {
7438 bfd *input_bfd = link_order->u.indirect.section->owner;
7439 asection *input_section = link_order->u.indirect.section;
7440 long reloc_size;
7441 arelent **reloc_vector;
7442 long reloc_count;
7443
7444 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
7445 if (reloc_size < 0)
7446 return NULL;
7447
7448 /* Read in the section. */
7449 if (!bfd_get_full_section_contents (input_bfd, input_section, &data))
7450 return NULL;
7451
7452 if (reloc_size == 0)
7453 return data;
7454
7455 reloc_vector = (arelent **) bfd_malloc (reloc_size);
7456 if (reloc_vector == NULL)
7457 return NULL;
7458
7459 reloc_count = bfd_canonicalize_reloc (input_bfd,
7460 input_section,
7461 reloc_vector,
7462 symbols);
7463 if (reloc_count < 0)
7464 goto error_return;
7465
7466 if (reloc_count > 0)
7467 {
7468 arelent **parent;
7469 for (parent = reloc_vector; *parent != NULL; parent++)
7470 {
7471 char *error_message = NULL;
7472 asymbol *symbol;
7473 bfd_reloc_status_type r;
7474
7475 symbol = *(*parent)->sym_ptr_ptr;
7476 if (symbol->section && discarded_section (symbol->section))
7477 {
7478 bfd_byte *p;
7479 static reloc_howto_type none_howto
7480 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
7481 "unused", FALSE, 0, 0, FALSE);
7482
7483 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
7484 _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
7485 p);
7486 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
7487 (*parent)->addend = 0;
7488 (*parent)->howto = &none_howto;
7489 r = bfd_reloc_ok;
7490 }
7491 else
7492 r = bfd_perform_relocation (input_bfd,
7493 *parent,
7494 data,
7495 input_section,
7496 relocatable ? abfd : NULL,
7497 &error_message);
7498
7499 if (relocatable)
7500 {
7501 asection *os = input_section->output_section;
7502
7503 /* A partial link, so keep the relocs. */
7504 os->orelocation[os->reloc_count] = *parent;
7505 os->reloc_count++;
7506 }
7507
7508 if (r != bfd_reloc_ok)
7509 {
7510 switch (r)
7511 {
7512 case bfd_reloc_undefined:
7513 if (!((*link_info->callbacks->undefined_symbol)
7514 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
7515 input_bfd, input_section, (*parent)->address,
7516 TRUE)))
7517 goto error_return;
7518 break;
7519 case bfd_reloc_dangerous:
7520 BFD_ASSERT (error_message != NULL);
7521 if (!((*link_info->callbacks->reloc_dangerous)
7522 (link_info, error_message, input_bfd, input_section,
7523 (*parent)->address)))
7524 goto error_return;
7525 break;
7526 case bfd_reloc_overflow:
7527 if (!((*link_info->callbacks->reloc_overflow)
7528 (link_info, NULL,
7529 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
7530 (*parent)->howto->name, (*parent)->addend,
7531 input_bfd, input_section, (*parent)->address)))
7532 goto error_return;
7533 break;
7534 case bfd_reloc_outofrange:
7535 /* PR ld/13730:
7536 This error can result when processing some partially
7537 complete binaries. Do not abort, but issue an error
7538 message instead. */
7539 link_info->callbacks->einfo
7540 (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
7541 abfd, input_section, * parent);
7542 goto error_return;
7543
7544 default:
7545 abort ();
7546 break;
7547 }
7548
7549 }
7550 }
7551 }
7552
7553 free (reloc_vector);
7554 return data;
7555
7556 error_return:
7557 free (reloc_vector);
7558 return NULL;
7559 }
GDB Binutils - Deliverables
This page took 0.191019 seconds and 3 git commands to generate.