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


77a04f8c0ca1882d098cf0998233c5feaf8662a8
[deliverable/binutils-gdb.git] / bfd / reloc.c
1 /* BFD support for handling relocation entries.
2 Copyright 1990-2013 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 ENUMDOC
2903 Power(rs6000) and PowerPC relocations.
2904
2905 ENUM
2906 BFD_RELOC_PPC_TLS
2907 ENUMX
2908 BFD_RELOC_PPC_TLSGD
2909 ENUMX
2910 BFD_RELOC_PPC_TLSLD
2911 ENUMX
2912 BFD_RELOC_PPC_DTPMOD
2913 ENUMX
2914 BFD_RELOC_PPC_TPREL16
2915 ENUMX
2916 BFD_RELOC_PPC_TPREL16_LO
2917 ENUMX
2918 BFD_RELOC_PPC_TPREL16_HI
2919 ENUMX
2920 BFD_RELOC_PPC_TPREL16_HA
2921 ENUMX
2922 BFD_RELOC_PPC_TPREL
2923 ENUMX
2924 BFD_RELOC_PPC_DTPREL16
2925 ENUMX
2926 BFD_RELOC_PPC_DTPREL16_LO
2927 ENUMX
2928 BFD_RELOC_PPC_DTPREL16_HI
2929 ENUMX
2930 BFD_RELOC_PPC_DTPREL16_HA
2931 ENUMX
2932 BFD_RELOC_PPC_DTPREL
2933 ENUMX
2934 BFD_RELOC_PPC_GOT_TLSGD16
2935 ENUMX
2936 BFD_RELOC_PPC_GOT_TLSGD16_LO
2937 ENUMX
2938 BFD_RELOC_PPC_GOT_TLSGD16_HI
2939 ENUMX
2940 BFD_RELOC_PPC_GOT_TLSGD16_HA
2941 ENUMX
2942 BFD_RELOC_PPC_GOT_TLSLD16
2943 ENUMX
2944 BFD_RELOC_PPC_GOT_TLSLD16_LO
2945 ENUMX
2946 BFD_RELOC_PPC_GOT_TLSLD16_HI
2947 ENUMX
2948 BFD_RELOC_PPC_GOT_TLSLD16_HA
2949 ENUMX
2950 BFD_RELOC_PPC_GOT_TPREL16
2951 ENUMX
2952 BFD_RELOC_PPC_GOT_TPREL16_LO
2953 ENUMX
2954 BFD_RELOC_PPC_GOT_TPREL16_HI
2955 ENUMX
2956 BFD_RELOC_PPC_GOT_TPREL16_HA
2957 ENUMX
2958 BFD_RELOC_PPC_GOT_DTPREL16
2959 ENUMX
2960 BFD_RELOC_PPC_GOT_DTPREL16_LO
2961 ENUMX
2962 BFD_RELOC_PPC_GOT_DTPREL16_HI
2963 ENUMX
2964 BFD_RELOC_PPC_GOT_DTPREL16_HA
2965 ENUMX
2966 BFD_RELOC_PPC64_TPREL16_DS
2967 ENUMX
2968 BFD_RELOC_PPC64_TPREL16_LO_DS
2969 ENUMX
2970 BFD_RELOC_PPC64_TPREL16_HIGHER
2971 ENUMX
2972 BFD_RELOC_PPC64_TPREL16_HIGHERA
2973 ENUMX
2974 BFD_RELOC_PPC64_TPREL16_HIGHEST
2975 ENUMX
2976 BFD_RELOC_PPC64_TPREL16_HIGHESTA
2977 ENUMX
2978 BFD_RELOC_PPC64_DTPREL16_DS
2979 ENUMX
2980 BFD_RELOC_PPC64_DTPREL16_LO_DS
2981 ENUMX
2982 BFD_RELOC_PPC64_DTPREL16_HIGHER
2983 ENUMX
2984 BFD_RELOC_PPC64_DTPREL16_HIGHERA
2985 ENUMX
2986 BFD_RELOC_PPC64_DTPREL16_HIGHEST
2987 ENUMX
2988 BFD_RELOC_PPC64_DTPREL16_HIGHESTA
2989 ENUMX
2990 BFD_RELOC_PPC64_TPREL16_HIGH
2991 ENUMX
2992 BFD_RELOC_PPC64_TPREL16_HIGHA
2993 ENUMX
2994 BFD_RELOC_PPC64_DTPREL16_HIGH
2995 ENUMX
2996 BFD_RELOC_PPC64_DTPREL16_HIGHA
2997 ENUMDOC
2998 PowerPC and PowerPC64 thread-local storage relocations.
2999
3000 ENUM
3001 BFD_RELOC_I370_D12
3002 ENUMDOC
3003 IBM 370/390 relocations
3004
3005 ENUM
3006 BFD_RELOC_CTOR
3007 ENUMDOC
3008 The type of reloc used to build a constructor table - at the moment
3009 probably a 32 bit wide absolute relocation, but the target can choose.
3010 It generally does map to one of the other relocation types.
3011
3012 ENUM
3013 BFD_RELOC_ARM_PCREL_BRANCH
3014 ENUMDOC
3015 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
3016 not stored in the instruction.
3017 ENUM
3018 BFD_RELOC_ARM_PCREL_BLX
3019 ENUMDOC
3020 ARM 26 bit pc-relative branch. The lowest bit must be zero and is
3021 not stored in the instruction. The 2nd lowest bit comes from a 1 bit
3022 field in the instruction.
3023 ENUM
3024 BFD_RELOC_THUMB_PCREL_BLX
3025 ENUMDOC
3026 Thumb 22 bit pc-relative branch. The lowest bit must be zero and is
3027 not stored in the instruction. The 2nd lowest bit comes from a 1 bit
3028 field in the instruction.
3029 ENUM
3030 BFD_RELOC_ARM_PCREL_CALL
3031 ENUMDOC
3032 ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction.
3033 ENUM
3034 BFD_RELOC_ARM_PCREL_JUMP
3035 ENUMDOC
3036 ARM 26-bit pc-relative branch for B or conditional BL instruction.
3037
3038 ENUM
3039 BFD_RELOC_THUMB_PCREL_BRANCH7
3040 ENUMX
3041 BFD_RELOC_THUMB_PCREL_BRANCH9
3042 ENUMX
3043 BFD_RELOC_THUMB_PCREL_BRANCH12
3044 ENUMX
3045 BFD_RELOC_THUMB_PCREL_BRANCH20
3046 ENUMX
3047 BFD_RELOC_THUMB_PCREL_BRANCH23
3048 ENUMX
3049 BFD_RELOC_THUMB_PCREL_BRANCH25
3050 ENUMDOC
3051 Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches.
3052 The lowest bit must be zero and is not stored in the instruction.
3053 Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an
3054 "nn" one smaller in all cases. Note further that BRANCH23
3055 corresponds to R_ARM_THM_CALL.
3056
3057 ENUM
3058 BFD_RELOC_ARM_OFFSET_IMM
3059 ENUMDOC
3060 12-bit immediate offset, used in ARM-format ldr and str instructions.
3061
3062 ENUM
3063 BFD_RELOC_ARM_THUMB_OFFSET
3064 ENUMDOC
3065 5-bit immediate offset, used in Thumb-format ldr and str instructions.
3066
3067 ENUM
3068 BFD_RELOC_ARM_TARGET1
3069 ENUMDOC
3070 Pc-relative or absolute relocation depending on target. Used for
3071 entries in .init_array sections.
3072 ENUM
3073 BFD_RELOC_ARM_ROSEGREL32
3074 ENUMDOC
3075 Read-only segment base relative address.
3076 ENUM
3077 BFD_RELOC_ARM_SBREL32
3078 ENUMDOC
3079 Data segment base relative address.
3080 ENUM
3081 BFD_RELOC_ARM_TARGET2
3082 ENUMDOC
3083 This reloc is used for references to RTTI data from exception handling
3084 tables. The actual definition depends on the target. It may be a
3085 pc-relative or some form of GOT-indirect relocation.
3086 ENUM
3087 BFD_RELOC_ARM_PREL31
3088 ENUMDOC
3089 31-bit PC relative address.
3090 ENUM
3091 BFD_RELOC_ARM_MOVW
3092 ENUMX
3093 BFD_RELOC_ARM_MOVT
3094 ENUMX
3095 BFD_RELOC_ARM_MOVW_PCREL
3096 ENUMX
3097 BFD_RELOC_ARM_MOVT_PCREL
3098 ENUMX
3099 BFD_RELOC_ARM_THUMB_MOVW
3100 ENUMX
3101 BFD_RELOC_ARM_THUMB_MOVT
3102 ENUMX
3103 BFD_RELOC_ARM_THUMB_MOVW_PCREL
3104 ENUMX
3105 BFD_RELOC_ARM_THUMB_MOVT_PCREL
3106 ENUMDOC
3107 Low and High halfword relocations for MOVW and MOVT instructions.
3108
3109 ENUM
3110 BFD_RELOC_ARM_JUMP_SLOT
3111 ENUMX
3112 BFD_RELOC_ARM_GLOB_DAT
3113 ENUMX
3114 BFD_RELOC_ARM_GOT32
3115 ENUMX
3116 BFD_RELOC_ARM_PLT32
3117 ENUMX
3118 BFD_RELOC_ARM_RELATIVE
3119 ENUMX
3120 BFD_RELOC_ARM_GOTOFF
3121 ENUMX
3122 BFD_RELOC_ARM_GOTPC
3123 ENUMX
3124 BFD_RELOC_ARM_GOT_PREL
3125 ENUMDOC
3126 Relocations for setting up GOTs and PLTs for shared libraries.
3127
3128 ENUM
3129 BFD_RELOC_ARM_TLS_GD32
3130 ENUMX
3131 BFD_RELOC_ARM_TLS_LDO32
3132 ENUMX
3133 BFD_RELOC_ARM_TLS_LDM32
3134 ENUMX
3135 BFD_RELOC_ARM_TLS_DTPOFF32
3136 ENUMX
3137 BFD_RELOC_ARM_TLS_DTPMOD32
3138 ENUMX
3139 BFD_RELOC_ARM_TLS_TPOFF32
3140 ENUMX
3141 BFD_RELOC_ARM_TLS_IE32
3142 ENUMX
3143 BFD_RELOC_ARM_TLS_LE32
3144 ENUMX
3145 BFD_RELOC_ARM_TLS_GOTDESC
3146 ENUMX
3147 BFD_RELOC_ARM_TLS_CALL
3148 ENUMX
3149 BFD_RELOC_ARM_THM_TLS_CALL
3150 ENUMX
3151 BFD_RELOC_ARM_TLS_DESCSEQ
3152 ENUMX
3153 BFD_RELOC_ARM_THM_TLS_DESCSEQ
3154 ENUMX
3155 BFD_RELOC_ARM_TLS_DESC
3156 ENUMDOC
3157 ARM thread-local storage relocations.
3158
3159 ENUM
3160 BFD_RELOC_ARM_ALU_PC_G0_NC
3161 ENUMX
3162 BFD_RELOC_ARM_ALU_PC_G0
3163 ENUMX
3164 BFD_RELOC_ARM_ALU_PC_G1_NC
3165 ENUMX
3166 BFD_RELOC_ARM_ALU_PC_G1
3167 ENUMX
3168 BFD_RELOC_ARM_ALU_PC_G2
3169 ENUMX
3170 BFD_RELOC_ARM_LDR_PC_G0
3171 ENUMX
3172 BFD_RELOC_ARM_LDR_PC_G1
3173 ENUMX
3174 BFD_RELOC_ARM_LDR_PC_G2
3175 ENUMX
3176 BFD_RELOC_ARM_LDRS_PC_G0
3177 ENUMX
3178 BFD_RELOC_ARM_LDRS_PC_G1
3179 ENUMX
3180 BFD_RELOC_ARM_LDRS_PC_G2
3181 ENUMX
3182 BFD_RELOC_ARM_LDC_PC_G0
3183 ENUMX
3184 BFD_RELOC_ARM_LDC_PC_G1
3185 ENUMX
3186 BFD_RELOC_ARM_LDC_PC_G2
3187 ENUMX
3188 BFD_RELOC_ARM_ALU_SB_G0_NC
3189 ENUMX
3190 BFD_RELOC_ARM_ALU_SB_G0
3191 ENUMX
3192 BFD_RELOC_ARM_ALU_SB_G1_NC
3193 ENUMX
3194 BFD_RELOC_ARM_ALU_SB_G1
3195 ENUMX
3196 BFD_RELOC_ARM_ALU_SB_G2
3197 ENUMX
3198 BFD_RELOC_ARM_LDR_SB_G0
3199 ENUMX
3200 BFD_RELOC_ARM_LDR_SB_G1
3201 ENUMX
3202 BFD_RELOC_ARM_LDR_SB_G2
3203 ENUMX
3204 BFD_RELOC_ARM_LDRS_SB_G0
3205 ENUMX
3206 BFD_RELOC_ARM_LDRS_SB_G1
3207 ENUMX
3208 BFD_RELOC_ARM_LDRS_SB_G2
3209 ENUMX
3210 BFD_RELOC_ARM_LDC_SB_G0
3211 ENUMX
3212 BFD_RELOC_ARM_LDC_SB_G1
3213 ENUMX
3214 BFD_RELOC_ARM_LDC_SB_G2
3215 ENUMDOC
3216 ARM group relocations.
3217
3218 ENUM
3219 BFD_RELOC_ARM_V4BX
3220 ENUMDOC
3221 Annotation of BX instructions.
3222
3223 ENUM
3224 BFD_RELOC_ARM_IRELATIVE
3225 ENUMDOC
3226 ARM support for STT_GNU_IFUNC.
3227
3228 ENUM
3229 BFD_RELOC_ARM_IMMEDIATE
3230 ENUMX
3231 BFD_RELOC_ARM_ADRL_IMMEDIATE
3232 ENUMX
3233 BFD_RELOC_ARM_T32_IMMEDIATE
3234 ENUMX
3235 BFD_RELOC_ARM_T32_ADD_IMM
3236 ENUMX
3237 BFD_RELOC_ARM_T32_IMM12
3238 ENUMX
3239 BFD_RELOC_ARM_T32_ADD_PC12
3240 ENUMX
3241 BFD_RELOC_ARM_SHIFT_IMM
3242 ENUMX
3243 BFD_RELOC_ARM_SMC
3244 ENUMX
3245 BFD_RELOC_ARM_HVC
3246 ENUMX
3247 BFD_RELOC_ARM_SWI
3248 ENUMX
3249 BFD_RELOC_ARM_MULTI
3250 ENUMX
3251 BFD_RELOC_ARM_CP_OFF_IMM
3252 ENUMX
3253 BFD_RELOC_ARM_CP_OFF_IMM_S2
3254 ENUMX
3255 BFD_RELOC_ARM_T32_CP_OFF_IMM
3256 ENUMX
3257 BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
3258 ENUMX
3259 BFD_RELOC_ARM_ADR_IMM
3260 ENUMX
3261 BFD_RELOC_ARM_LDR_IMM
3262 ENUMX
3263 BFD_RELOC_ARM_LITERAL
3264 ENUMX
3265 BFD_RELOC_ARM_IN_POOL
3266 ENUMX
3267 BFD_RELOC_ARM_OFFSET_IMM8
3268 ENUMX
3269 BFD_RELOC_ARM_T32_OFFSET_U8
3270 ENUMX
3271 BFD_RELOC_ARM_T32_OFFSET_IMM
3272 ENUMX
3273 BFD_RELOC_ARM_HWLITERAL
3274 ENUMX
3275 BFD_RELOC_ARM_THUMB_ADD
3276 ENUMX
3277 BFD_RELOC_ARM_THUMB_IMM
3278 ENUMX
3279 BFD_RELOC_ARM_THUMB_SHIFT
3280 ENUMDOC
3281 These relocs are only used within the ARM assembler. They are not
3282 (at present) written to any object files.
3283
3284 ENUM
3285 BFD_RELOC_SH_PCDISP8BY2
3286 ENUMX
3287 BFD_RELOC_SH_PCDISP12BY2
3288 ENUMX
3289 BFD_RELOC_SH_IMM3
3290 ENUMX
3291 BFD_RELOC_SH_IMM3U
3292 ENUMX
3293 BFD_RELOC_SH_DISP12
3294 ENUMX
3295 BFD_RELOC_SH_DISP12BY2
3296 ENUMX
3297 BFD_RELOC_SH_DISP12BY4
3298 ENUMX
3299 BFD_RELOC_SH_DISP12BY8
3300 ENUMX
3301 BFD_RELOC_SH_DISP20
3302 ENUMX
3303 BFD_RELOC_SH_DISP20BY8
3304 ENUMX
3305 BFD_RELOC_SH_IMM4
3306 ENUMX
3307 BFD_RELOC_SH_IMM4BY2
3308 ENUMX
3309 BFD_RELOC_SH_IMM4BY4
3310 ENUMX
3311 BFD_RELOC_SH_IMM8
3312 ENUMX
3313 BFD_RELOC_SH_IMM8BY2
3314 ENUMX
3315 BFD_RELOC_SH_IMM8BY4
3316 ENUMX
3317 BFD_RELOC_SH_PCRELIMM8BY2
3318 ENUMX
3319 BFD_RELOC_SH_PCRELIMM8BY4
3320 ENUMX
3321 BFD_RELOC_SH_SWITCH16
3322 ENUMX
3323 BFD_RELOC_SH_SWITCH32
3324 ENUMX
3325 BFD_RELOC_SH_USES
3326 ENUMX
3327 BFD_RELOC_SH_COUNT
3328 ENUMX
3329 BFD_RELOC_SH_ALIGN
3330 ENUMX
3331 BFD_RELOC_SH_CODE
3332 ENUMX
3333 BFD_RELOC_SH_DATA
3334 ENUMX
3335 BFD_RELOC_SH_LABEL
3336 ENUMX
3337 BFD_RELOC_SH_LOOP_START
3338 ENUMX
3339 BFD_RELOC_SH_LOOP_END
3340 ENUMX
3341 BFD_RELOC_SH_COPY
3342 ENUMX
3343 BFD_RELOC_SH_GLOB_DAT
3344 ENUMX
3345 BFD_RELOC_SH_JMP_SLOT
3346 ENUMX
3347 BFD_RELOC_SH_RELATIVE
3348 ENUMX
3349 BFD_RELOC_SH_GOTPC
3350 ENUMX
3351 BFD_RELOC_SH_GOT_LOW16
3352 ENUMX
3353 BFD_RELOC_SH_GOT_MEDLOW16
3354 ENUMX
3355 BFD_RELOC_SH_GOT_MEDHI16
3356 ENUMX
3357 BFD_RELOC_SH_GOT_HI16
3358 ENUMX
3359 BFD_RELOC_SH_GOTPLT_LOW16
3360 ENUMX
3361 BFD_RELOC_SH_GOTPLT_MEDLOW16
3362 ENUMX
3363 BFD_RELOC_SH_GOTPLT_MEDHI16
3364 ENUMX
3365 BFD_RELOC_SH_GOTPLT_HI16
3366 ENUMX
3367 BFD_RELOC_SH_PLT_LOW16
3368 ENUMX
3369 BFD_RELOC_SH_PLT_MEDLOW16
3370 ENUMX
3371 BFD_RELOC_SH_PLT_MEDHI16
3372 ENUMX
3373 BFD_RELOC_SH_PLT_HI16
3374 ENUMX
3375 BFD_RELOC_SH_GOTOFF_LOW16
3376 ENUMX
3377 BFD_RELOC_SH_GOTOFF_MEDLOW16
3378 ENUMX
3379 BFD_RELOC_SH_GOTOFF_MEDHI16
3380 ENUMX
3381 BFD_RELOC_SH_GOTOFF_HI16
3382 ENUMX
3383 BFD_RELOC_SH_GOTPC_LOW16
3384 ENUMX
3385 BFD_RELOC_SH_GOTPC_MEDLOW16
3386 ENUMX
3387 BFD_RELOC_SH_GOTPC_MEDHI16
3388 ENUMX
3389 BFD_RELOC_SH_GOTPC_HI16
3390 ENUMX
3391 BFD_RELOC_SH_COPY64
3392 ENUMX
3393 BFD_RELOC_SH_GLOB_DAT64
3394 ENUMX
3395 BFD_RELOC_SH_JMP_SLOT64
3396 ENUMX
3397 BFD_RELOC_SH_RELATIVE64
3398 ENUMX
3399 BFD_RELOC_SH_GOT10BY4
3400 ENUMX
3401 BFD_RELOC_SH_GOT10BY8
3402 ENUMX
3403 BFD_RELOC_SH_GOTPLT10BY4
3404 ENUMX
3405 BFD_RELOC_SH_GOTPLT10BY8
3406 ENUMX
3407 BFD_RELOC_SH_GOTPLT32
3408 ENUMX
3409 BFD_RELOC_SH_SHMEDIA_CODE
3410 ENUMX
3411 BFD_RELOC_SH_IMMU5
3412 ENUMX
3413 BFD_RELOC_SH_IMMS6
3414 ENUMX
3415 BFD_RELOC_SH_IMMS6BY32
3416 ENUMX
3417 BFD_RELOC_SH_IMMU6
3418 ENUMX
3419 BFD_RELOC_SH_IMMS10
3420 ENUMX
3421 BFD_RELOC_SH_IMMS10BY2
3422 ENUMX
3423 BFD_RELOC_SH_IMMS10BY4
3424 ENUMX
3425 BFD_RELOC_SH_IMMS10BY8
3426 ENUMX
3427 BFD_RELOC_SH_IMMS16
3428 ENUMX
3429 BFD_RELOC_SH_IMMU16
3430 ENUMX
3431 BFD_RELOC_SH_IMM_LOW16
3432 ENUMX
3433 BFD_RELOC_SH_IMM_LOW16_PCREL
3434 ENUMX
3435 BFD_RELOC_SH_IMM_MEDLOW16
3436 ENUMX
3437 BFD_RELOC_SH_IMM_MEDLOW16_PCREL
3438 ENUMX
3439 BFD_RELOC_SH_IMM_MEDHI16
3440 ENUMX
3441 BFD_RELOC_SH_IMM_MEDHI16_PCREL
3442 ENUMX
3443 BFD_RELOC_SH_IMM_HI16
3444 ENUMX
3445 BFD_RELOC_SH_IMM_HI16_PCREL
3446 ENUMX
3447 BFD_RELOC_SH_PT_16
3448 ENUMX
3449 BFD_RELOC_SH_TLS_GD_32
3450 ENUMX
3451 BFD_RELOC_SH_TLS_LD_32
3452 ENUMX
3453 BFD_RELOC_SH_TLS_LDO_32
3454 ENUMX
3455 BFD_RELOC_SH_TLS_IE_32
3456 ENUMX
3457 BFD_RELOC_SH_TLS_LE_32
3458 ENUMX
3459 BFD_RELOC_SH_TLS_DTPMOD32
3460 ENUMX
3461 BFD_RELOC_SH_TLS_DTPOFF32
3462 ENUMX
3463 BFD_RELOC_SH_TLS_TPOFF32
3464 ENUMX
3465 BFD_RELOC_SH_GOT20
3466 ENUMX
3467 BFD_RELOC_SH_GOTOFF20
3468 ENUMX
3469 BFD_RELOC_SH_GOTFUNCDESC
3470 ENUMX
3471 BFD_RELOC_SH_GOTFUNCDESC20
3472 ENUMX
3473 BFD_RELOC_SH_GOTOFFFUNCDESC
3474 ENUMX
3475 BFD_RELOC_SH_GOTOFFFUNCDESC20
3476 ENUMX
3477 BFD_RELOC_SH_FUNCDESC
3478 ENUMDOC
3479 Renesas / SuperH SH relocs. Not all of these appear in object files.
3480
3481 ENUM
3482 BFD_RELOC_ARC_B22_PCREL
3483 ENUMDOC
3484 ARC Cores relocs.
3485 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
3486 not stored in the instruction. The high 20 bits are installed in bits 26
3487 through 7 of the instruction.
3488 ENUM
3489 BFD_RELOC_ARC_B26
3490 ENUMDOC
3491 ARC 26 bit absolute branch. The lowest two bits must be zero and are not
3492 stored in the instruction. The high 24 bits are installed in bits 23
3493 through 0.
3494
3495 ENUM
3496 BFD_RELOC_BFIN_16_IMM
3497 ENUMDOC
3498 ADI Blackfin 16 bit immediate absolute reloc.
3499 ENUM
3500 BFD_RELOC_BFIN_16_HIGH
3501 ENUMDOC
3502 ADI Blackfin 16 bit immediate absolute reloc higher 16 bits.
3503 ENUM
3504 BFD_RELOC_BFIN_4_PCREL
3505 ENUMDOC
3506 ADI Blackfin 'a' part of LSETUP.
3507 ENUM
3508 BFD_RELOC_BFIN_5_PCREL
3509 ENUMDOC
3510 ADI Blackfin.
3511 ENUM
3512 BFD_RELOC_BFIN_16_LOW
3513 ENUMDOC
3514 ADI Blackfin 16 bit immediate absolute reloc lower 16 bits.
3515 ENUM
3516 BFD_RELOC_BFIN_10_PCREL
3517 ENUMDOC
3518 ADI Blackfin.
3519 ENUM
3520 BFD_RELOC_BFIN_11_PCREL
3521 ENUMDOC
3522 ADI Blackfin 'b' part of LSETUP.
3523 ENUM
3524 BFD_RELOC_BFIN_12_PCREL_JUMP
3525 ENUMDOC
3526 ADI Blackfin.
3527 ENUM
3528 BFD_RELOC_BFIN_12_PCREL_JUMP_S
3529 ENUMDOC
3530 ADI Blackfin Short jump, pcrel.
3531 ENUM
3532 BFD_RELOC_BFIN_24_PCREL_CALL_X
3533 ENUMDOC
3534 ADI Blackfin Call.x not implemented.
3535 ENUM
3536 BFD_RELOC_BFIN_24_PCREL_JUMP_L
3537 ENUMDOC
3538 ADI Blackfin Long Jump pcrel.
3539 ENUM
3540 BFD_RELOC_BFIN_GOT17M4
3541 ENUMX
3542 BFD_RELOC_BFIN_GOTHI
3543 ENUMX
3544 BFD_RELOC_BFIN_GOTLO
3545 ENUMX
3546 BFD_RELOC_BFIN_FUNCDESC
3547 ENUMX
3548 BFD_RELOC_BFIN_FUNCDESC_GOT17M4
3549 ENUMX
3550 BFD_RELOC_BFIN_FUNCDESC_GOTHI
3551 ENUMX
3552 BFD_RELOC_BFIN_FUNCDESC_GOTLO
3553 ENUMX
3554 BFD_RELOC_BFIN_FUNCDESC_VALUE
3555 ENUMX
3556 BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4
3557 ENUMX
3558 BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI
3559 ENUMX
3560 BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO
3561 ENUMX
3562 BFD_RELOC_BFIN_GOTOFF17M4
3563 ENUMX
3564 BFD_RELOC_BFIN_GOTOFFHI
3565 ENUMX
3566 BFD_RELOC_BFIN_GOTOFFLO
3567 ENUMDOC
3568 ADI Blackfin FD-PIC relocations.
3569 ENUM
3570 BFD_RELOC_BFIN_GOT
3571 ENUMDOC
3572 ADI Blackfin GOT relocation.
3573 ENUM
3574 BFD_RELOC_BFIN_PLTPC
3575 ENUMDOC
3576 ADI Blackfin PLTPC relocation.
3577 ENUM
3578 BFD_ARELOC_BFIN_PUSH
3579 ENUMDOC
3580 ADI Blackfin arithmetic relocation.
3581 ENUM
3582 BFD_ARELOC_BFIN_CONST
3583 ENUMDOC
3584 ADI Blackfin arithmetic relocation.
3585 ENUM
3586 BFD_ARELOC_BFIN_ADD
3587 ENUMDOC
3588 ADI Blackfin arithmetic relocation.
3589 ENUM
3590 BFD_ARELOC_BFIN_SUB
3591 ENUMDOC
3592 ADI Blackfin arithmetic relocation.
3593 ENUM
3594 BFD_ARELOC_BFIN_MULT
3595 ENUMDOC
3596 ADI Blackfin arithmetic relocation.
3597 ENUM
3598 BFD_ARELOC_BFIN_DIV
3599 ENUMDOC
3600 ADI Blackfin arithmetic relocation.
3601 ENUM
3602 BFD_ARELOC_BFIN_MOD
3603 ENUMDOC
3604 ADI Blackfin arithmetic relocation.
3605 ENUM
3606 BFD_ARELOC_BFIN_LSHIFT
3607 ENUMDOC
3608 ADI Blackfin arithmetic relocation.
3609 ENUM
3610 BFD_ARELOC_BFIN_RSHIFT
3611 ENUMDOC
3612 ADI Blackfin arithmetic relocation.
3613 ENUM
3614 BFD_ARELOC_BFIN_AND
3615 ENUMDOC
3616 ADI Blackfin arithmetic relocation.
3617 ENUM
3618 BFD_ARELOC_BFIN_OR
3619 ENUMDOC
3620 ADI Blackfin arithmetic relocation.
3621 ENUM
3622 BFD_ARELOC_BFIN_XOR
3623 ENUMDOC
3624 ADI Blackfin arithmetic relocation.
3625 ENUM
3626 BFD_ARELOC_BFIN_LAND
3627 ENUMDOC
3628 ADI Blackfin arithmetic relocation.
3629 ENUM
3630 BFD_ARELOC_BFIN_LOR
3631 ENUMDOC
3632 ADI Blackfin arithmetic relocation.
3633 ENUM
3634 BFD_ARELOC_BFIN_LEN
3635 ENUMDOC
3636 ADI Blackfin arithmetic relocation.
3637 ENUM
3638 BFD_ARELOC_BFIN_NEG
3639 ENUMDOC
3640 ADI Blackfin arithmetic relocation.
3641 ENUM
3642 BFD_ARELOC_BFIN_COMP
3643 ENUMDOC
3644 ADI Blackfin arithmetic relocation.
3645 ENUM
3646 BFD_ARELOC_BFIN_PAGE
3647 ENUMDOC
3648 ADI Blackfin arithmetic relocation.
3649 ENUM
3650 BFD_ARELOC_BFIN_HWPAGE
3651 ENUMDOC
3652 ADI Blackfin arithmetic relocation.
3653 ENUM
3654 BFD_ARELOC_BFIN_ADDR
3655 ENUMDOC
3656 ADI Blackfin arithmetic relocation.
3657
3658 ENUM
3659 BFD_RELOC_D10V_10_PCREL_R
3660 ENUMDOC
3661 Mitsubishi D10V relocs.
3662 This is a 10-bit reloc with the right 2 bits
3663 assumed to be 0.
3664 ENUM
3665 BFD_RELOC_D10V_10_PCREL_L
3666 ENUMDOC
3667 Mitsubishi D10V relocs.
3668 This is a 10-bit reloc with the right 2 bits
3669 assumed to be 0. This is the same as the previous reloc
3670 except it is in the left container, i.e.,
3671 shifted left 15 bits.
3672 ENUM
3673 BFD_RELOC_D10V_18
3674 ENUMDOC
3675 This is an 18-bit reloc with the right 2 bits
3676 assumed to be 0.
3677 ENUM
3678 BFD_RELOC_D10V_18_PCREL
3679 ENUMDOC
3680 This is an 18-bit reloc with the right 2 bits
3681 assumed to be 0.
3682
3683 ENUM
3684 BFD_RELOC_D30V_6
3685 ENUMDOC
3686 Mitsubishi D30V relocs.
3687 This is a 6-bit absolute reloc.
3688 ENUM
3689 BFD_RELOC_D30V_9_PCREL
3690 ENUMDOC
3691 This is a 6-bit pc-relative reloc with
3692 the right 3 bits assumed to be 0.
3693 ENUM
3694 BFD_RELOC_D30V_9_PCREL_R
3695 ENUMDOC
3696 This is a 6-bit pc-relative reloc with
3697 the right 3 bits assumed to be 0. Same
3698 as the previous reloc but on the right side
3699 of the container.
3700 ENUM
3701 BFD_RELOC_D30V_15
3702 ENUMDOC
3703 This is a 12-bit absolute reloc with the
3704 right 3 bitsassumed to be 0.
3705 ENUM
3706 BFD_RELOC_D30V_15_PCREL
3707 ENUMDOC
3708 This is a 12-bit pc-relative reloc with
3709 the right 3 bits assumed to be 0.
3710 ENUM
3711 BFD_RELOC_D30V_15_PCREL_R
3712 ENUMDOC
3713 This is a 12-bit pc-relative reloc with
3714 the right 3 bits assumed to be 0. Same
3715 as the previous reloc but on the right side
3716 of the container.
3717 ENUM
3718 BFD_RELOC_D30V_21
3719 ENUMDOC
3720 This is an 18-bit absolute reloc with
3721 the right 3 bits assumed to be 0.
3722 ENUM
3723 BFD_RELOC_D30V_21_PCREL
3724 ENUMDOC
3725 This is an 18-bit pc-relative reloc with
3726 the right 3 bits assumed to be 0.
3727 ENUM
3728 BFD_RELOC_D30V_21_PCREL_R
3729 ENUMDOC
3730 This is an 18-bit pc-relative reloc with
3731 the right 3 bits assumed to be 0. Same
3732 as the previous reloc but on the right side
3733 of the container.
3734 ENUM
3735 BFD_RELOC_D30V_32
3736 ENUMDOC
3737 This is a 32-bit absolute reloc.
3738 ENUM
3739 BFD_RELOC_D30V_32_PCREL
3740 ENUMDOC
3741 This is a 32-bit pc-relative reloc.
3742
3743 ENUM
3744 BFD_RELOC_DLX_HI16_S
3745 ENUMDOC
3746 DLX relocs
3747 ENUM
3748 BFD_RELOC_DLX_LO16
3749 ENUMDOC
3750 DLX relocs
3751 ENUM
3752 BFD_RELOC_DLX_JMP26
3753 ENUMDOC
3754 DLX relocs
3755
3756 ENUM
3757 BFD_RELOC_M32C_HI8
3758 ENUMX
3759 BFD_RELOC_M32C_RL_JUMP
3760 ENUMX
3761 BFD_RELOC_M32C_RL_1ADDR
3762 ENUMX
3763 BFD_RELOC_M32C_RL_2ADDR
3764 ENUMDOC
3765 Renesas M16C/M32C Relocations.
3766
3767 ENUM
3768 BFD_RELOC_M32R_24
3769 ENUMDOC
3770 Renesas M32R (formerly Mitsubishi M32R) relocs.
3771 This is a 24 bit absolute address.
3772 ENUM
3773 BFD_RELOC_M32R_10_PCREL
3774 ENUMDOC
3775 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
3776 ENUM
3777 BFD_RELOC_M32R_18_PCREL
3778 ENUMDOC
3779 This is an 18-bit reloc with the right 2 bits assumed to be 0.
3780 ENUM
3781 BFD_RELOC_M32R_26_PCREL
3782 ENUMDOC
3783 This is a 26-bit reloc with the right 2 bits assumed to be 0.
3784 ENUM
3785 BFD_RELOC_M32R_HI16_ULO
3786 ENUMDOC
3787 This is a 16-bit reloc containing the high 16 bits of an address
3788 used when the lower 16 bits are treated as unsigned.
3789 ENUM
3790 BFD_RELOC_M32R_HI16_SLO
3791 ENUMDOC
3792 This is a 16-bit reloc containing the high 16 bits of an address
3793 used when the lower 16 bits are treated as signed.
3794 ENUM
3795 BFD_RELOC_M32R_LO16
3796 ENUMDOC
3797 This is a 16-bit reloc containing the lower 16 bits of an address.
3798 ENUM
3799 BFD_RELOC_M32R_SDA16
3800 ENUMDOC
3801 This is a 16-bit reloc containing the small data area offset for use in
3802 add3, load, and store instructions.
3803 ENUM
3804 BFD_RELOC_M32R_GOT24
3805 ENUMX
3806 BFD_RELOC_M32R_26_PLTREL
3807 ENUMX
3808 BFD_RELOC_M32R_COPY
3809 ENUMX
3810 BFD_RELOC_M32R_GLOB_DAT
3811 ENUMX
3812 BFD_RELOC_M32R_JMP_SLOT
3813 ENUMX
3814 BFD_RELOC_M32R_RELATIVE
3815 ENUMX
3816 BFD_RELOC_M32R_GOTOFF
3817 ENUMX
3818 BFD_RELOC_M32R_GOTOFF_HI_ULO
3819 ENUMX
3820 BFD_RELOC_M32R_GOTOFF_HI_SLO
3821 ENUMX
3822 BFD_RELOC_M32R_GOTOFF_LO
3823 ENUMX
3824 BFD_RELOC_M32R_GOTPC24
3825 ENUMX
3826 BFD_RELOC_M32R_GOT16_HI_ULO
3827 ENUMX
3828 BFD_RELOC_M32R_GOT16_HI_SLO
3829 ENUMX
3830 BFD_RELOC_M32R_GOT16_LO
3831 ENUMX
3832 BFD_RELOC_M32R_GOTPC_HI_ULO
3833 ENUMX
3834 BFD_RELOC_M32R_GOTPC_HI_SLO
3835 ENUMX
3836 BFD_RELOC_M32R_GOTPC_LO
3837 ENUMDOC
3838 For PIC.
3839
3840
3841 ENUM
3842 BFD_RELOC_V850_9_PCREL
3843 ENUMDOC
3844 This is a 9-bit reloc
3845 ENUM
3846 BFD_RELOC_V850_22_PCREL
3847 ENUMDOC
3848 This is a 22-bit reloc
3849
3850 ENUM
3851 BFD_RELOC_V850_SDA_16_16_OFFSET
3852 ENUMDOC
3853 This is a 16 bit offset from the short data area pointer.
3854 ENUM
3855 BFD_RELOC_V850_SDA_15_16_OFFSET
3856 ENUMDOC
3857 This is a 16 bit offset (of which only 15 bits are used) from the
3858 short data area pointer.
3859 ENUM
3860 BFD_RELOC_V850_ZDA_16_16_OFFSET
3861 ENUMDOC
3862 This is a 16 bit offset from the zero data area pointer.
3863 ENUM
3864 BFD_RELOC_V850_ZDA_15_16_OFFSET
3865 ENUMDOC
3866 This is a 16 bit offset (of which only 15 bits are used) from the
3867 zero data area pointer.
3868 ENUM
3869 BFD_RELOC_V850_TDA_6_8_OFFSET
3870 ENUMDOC
3871 This is an 8 bit offset (of which only 6 bits are used) from the
3872 tiny data area pointer.
3873 ENUM
3874 BFD_RELOC_V850_TDA_7_8_OFFSET
3875 ENUMDOC
3876 This is an 8bit offset (of which only 7 bits are used) from the tiny
3877 data area pointer.
3878 ENUM
3879 BFD_RELOC_V850_TDA_7_7_OFFSET
3880 ENUMDOC
3881 This is a 7 bit offset from the tiny data area pointer.
3882 ENUM
3883 BFD_RELOC_V850_TDA_16_16_OFFSET
3884 ENUMDOC
3885 This is a 16 bit offset from the tiny data area pointer.
3886 COMMENT
3887 ENUM
3888 BFD_RELOC_V850_TDA_4_5_OFFSET
3889 ENUMDOC
3890 This is a 5 bit offset (of which only 4 bits are used) from the tiny
3891 data area pointer.
3892 ENUM
3893 BFD_RELOC_V850_TDA_4_4_OFFSET
3894 ENUMDOC
3895 This is a 4 bit offset from the tiny data area pointer.
3896 ENUM
3897 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
3898 ENUMDOC
3899 This is a 16 bit offset from the short data area pointer, with the
3900 bits placed non-contiguously in the instruction.
3901 ENUM
3902 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
3903 ENUMDOC
3904 This is a 16 bit offset from the zero data area pointer, with the
3905 bits placed non-contiguously in the instruction.
3906 ENUM
3907 BFD_RELOC_V850_CALLT_6_7_OFFSET
3908 ENUMDOC
3909 This is a 6 bit offset from the call table base pointer.
3910 ENUM
3911 BFD_RELOC_V850_CALLT_16_16_OFFSET
3912 ENUMDOC
3913 This is a 16 bit offset from the call table base pointer.
3914 ENUM
3915 BFD_RELOC_V850_LONGCALL
3916 ENUMDOC
3917 Used for relaxing indirect function calls.
3918 ENUM
3919 BFD_RELOC_V850_LONGJUMP
3920 ENUMDOC
3921 Used for relaxing indirect jumps.
3922 ENUM
3923 BFD_RELOC_V850_ALIGN
3924 ENUMDOC
3925 Used to maintain alignment whilst relaxing.
3926 ENUM
3927 BFD_RELOC_V850_LO16_SPLIT_OFFSET
3928 ENUMDOC
3929 This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu
3930 instructions.
3931 ENUM
3932 BFD_RELOC_V850_16_PCREL
3933 ENUMDOC
3934 This is a 16-bit reloc.
3935 ENUM
3936 BFD_RELOC_V850_17_PCREL
3937 ENUMDOC
3938 This is a 17-bit reloc.
3939 ENUM
3940 BFD_RELOC_V850_23
3941 ENUMDOC
3942 This is a 23-bit reloc.
3943 ENUM
3944 BFD_RELOC_V850_32_PCREL
3945 ENUMDOC
3946 This is a 32-bit reloc.
3947 ENUM
3948 BFD_RELOC_V850_32_ABS
3949 ENUMDOC
3950 This is a 32-bit reloc.
3951 ENUM
3952 BFD_RELOC_V850_16_SPLIT_OFFSET
3953 ENUMDOC
3954 This is a 16-bit reloc.
3955 ENUM
3956 BFD_RELOC_V850_16_S1
3957 ENUMDOC
3958 This is a 16-bit reloc.
3959 ENUM
3960 BFD_RELOC_V850_LO16_S1
3961 ENUMDOC
3962 Low 16 bits. 16 bit shifted by 1.
3963 ENUM
3964 BFD_RELOC_V850_CALLT_15_16_OFFSET
3965 ENUMDOC
3966 This is a 16 bit offset from the call table base pointer.
3967 ENUM
3968 BFD_RELOC_V850_32_GOTPCREL
3969 ENUMDOC
3970 DSO relocations.
3971 ENUM
3972 BFD_RELOC_V850_16_GOT
3973 ENUMDOC
3974 DSO relocations.
3975 ENUM
3976 BFD_RELOC_V850_32_GOT
3977 ENUMDOC
3978 DSO relocations.
3979 ENUM
3980 BFD_RELOC_V850_22_PLT_PCREL
3981 ENUMDOC
3982 DSO relocations.
3983 ENUM
3984 BFD_RELOC_V850_32_PLT_PCREL
3985 ENUMDOC
3986 DSO relocations.
3987 ENUM
3988 BFD_RELOC_V850_COPY
3989 ENUMDOC
3990 DSO relocations.
3991 ENUM
3992 BFD_RELOC_V850_GLOB_DAT
3993 ENUMDOC
3994 DSO relocations.
3995 ENUM
3996 BFD_RELOC_V850_JMP_SLOT
3997 ENUMDOC
3998 DSO relocations.
3999 ENUM
4000 BFD_RELOC_V850_RELATIVE
4001 ENUMDOC
4002 DSO relocations.
4003 ENUM
4004 BFD_RELOC_V850_16_GOTOFF
4005 ENUMDOC
4006 DSO relocations.
4007 ENUM
4008 BFD_RELOC_V850_32_GOTOFF
4009 ENUMDOC
4010 DSO relocations.
4011 ENUM
4012 BFD_RELOC_V850_CODE
4013 ENUMDOC
4014 start code.
4015 ENUM
4016 BFD_RELOC_V850_DATA
4017 ENUMDOC
4018 start data in text.
4019
4020 ENUM
4021 BFD_RELOC_TIC30_LDP
4022 ENUMDOC
4023 This is a 8bit DP reloc for the tms320c30, where the most
4024 significant 8 bits of a 24 bit word are placed into the least
4025 significant 8 bits of the opcode.
4026
4027 ENUM
4028 BFD_RELOC_TIC54X_PARTLS7
4029 ENUMDOC
4030 This is a 7bit reloc for the tms320c54x, where the least
4031 significant 7 bits of a 16 bit word are placed into the least
4032 significant 7 bits of the opcode.
4033
4034 ENUM
4035 BFD_RELOC_TIC54X_PARTMS9
4036 ENUMDOC
4037 This is a 9bit DP reloc for the tms320c54x, where the most
4038 significant 9 bits of a 16 bit word are placed into the least
4039 significant 9 bits of the opcode.
4040
4041 ENUM
4042 BFD_RELOC_TIC54X_23
4043 ENUMDOC
4044 This is an extended address 23-bit reloc for the tms320c54x.
4045
4046 ENUM
4047 BFD_RELOC_TIC54X_16_OF_23
4048 ENUMDOC
4049 This is a 16-bit reloc for the tms320c54x, where the least
4050 significant 16 bits of a 23-bit extended address are placed into
4051 the opcode.
4052
4053 ENUM
4054 BFD_RELOC_TIC54X_MS7_OF_23
4055 ENUMDOC
4056 This is a reloc for the tms320c54x, where the most
4057 significant 7 bits of a 23-bit extended address are placed into
4058 the opcode.
4059
4060 ENUM
4061 BFD_RELOC_C6000_PCR_S21
4062 ENUMX
4063 BFD_RELOC_C6000_PCR_S12
4064 ENUMX
4065 BFD_RELOC_C6000_PCR_S10
4066 ENUMX
4067 BFD_RELOC_C6000_PCR_S7
4068 ENUMX
4069 BFD_RELOC_C6000_ABS_S16
4070 ENUMX
4071 BFD_RELOC_C6000_ABS_L16
4072 ENUMX
4073 BFD_RELOC_C6000_ABS_H16
4074 ENUMX
4075 BFD_RELOC_C6000_SBR_U15_B
4076 ENUMX
4077 BFD_RELOC_C6000_SBR_U15_H
4078 ENUMX
4079 BFD_RELOC_C6000_SBR_U15_W
4080 ENUMX
4081 BFD_RELOC_C6000_SBR_S16
4082 ENUMX
4083 BFD_RELOC_C6000_SBR_L16_B
4084 ENUMX
4085 BFD_RELOC_C6000_SBR_L16_H
4086 ENUMX
4087 BFD_RELOC_C6000_SBR_L16_W
4088 ENUMX
4089 BFD_RELOC_C6000_SBR_H16_B
4090 ENUMX
4091 BFD_RELOC_C6000_SBR_H16_H
4092 ENUMX
4093 BFD_RELOC_C6000_SBR_H16_W
4094 ENUMX
4095 BFD_RELOC_C6000_SBR_GOT_U15_W
4096 ENUMX
4097 BFD_RELOC_C6000_SBR_GOT_L16_W
4098 ENUMX
4099 BFD_RELOC_C6000_SBR_GOT_H16_W
4100 ENUMX
4101 BFD_RELOC_C6000_DSBT_INDEX
4102 ENUMX
4103 BFD_RELOC_C6000_PREL31
4104 ENUMX
4105 BFD_RELOC_C6000_COPY
4106 ENUMX
4107 BFD_RELOC_C6000_JUMP_SLOT
4108 ENUMX
4109 BFD_RELOC_C6000_EHTYPE
4110 ENUMX
4111 BFD_RELOC_C6000_PCR_H16
4112 ENUMX
4113 BFD_RELOC_C6000_PCR_L16
4114 ENUMX
4115 BFD_RELOC_C6000_ALIGN
4116 ENUMX
4117 BFD_RELOC_C6000_FPHEAD
4118 ENUMX
4119 BFD_RELOC_C6000_NOCMP
4120 ENUMDOC
4121 TMS320C6000 relocations.
4122
4123 ENUM
4124 BFD_RELOC_FR30_48
4125 ENUMDOC
4126 This is a 48 bit reloc for the FR30 that stores 32 bits.
4127 ENUM
4128 BFD_RELOC_FR30_20
4129 ENUMDOC
4130 This is a 32 bit reloc for the FR30 that stores 20 bits split up into
4131 two sections.
4132 ENUM
4133 BFD_RELOC_FR30_6_IN_4
4134 ENUMDOC
4135 This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
4136 4 bits.
4137 ENUM
4138 BFD_RELOC_FR30_8_IN_8
4139 ENUMDOC
4140 This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
4141 into 8 bits.
4142 ENUM
4143 BFD_RELOC_FR30_9_IN_8
4144 ENUMDOC
4145 This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
4146 into 8 bits.
4147 ENUM
4148 BFD_RELOC_FR30_10_IN_8
4149 ENUMDOC
4150 This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
4151 into 8 bits.
4152 ENUM
4153 BFD_RELOC_FR30_9_PCREL
4154 ENUMDOC
4155 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
4156 short offset into 8 bits.
4157 ENUM
4158 BFD_RELOC_FR30_12_PCREL
4159 ENUMDOC
4160 This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
4161 short offset into 11 bits.
4162
4163 ENUM
4164 BFD_RELOC_MCORE_PCREL_IMM8BY4
4165 ENUMX
4166 BFD_RELOC_MCORE_PCREL_IMM11BY2
4167 ENUMX
4168 BFD_RELOC_MCORE_PCREL_IMM4BY2
4169 ENUMX
4170 BFD_RELOC_MCORE_PCREL_32
4171 ENUMX
4172 BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
4173 ENUMX
4174 BFD_RELOC_MCORE_RVA
4175 ENUMDOC
4176 Motorola Mcore relocations.
4177
4178 ENUM
4179 BFD_RELOC_MEP_8
4180 ENUMX
4181 BFD_RELOC_MEP_16
4182 ENUMX
4183 BFD_RELOC_MEP_32
4184 ENUMX
4185 BFD_RELOC_MEP_PCREL8A2
4186 ENUMX
4187 BFD_RELOC_MEP_PCREL12A2
4188 ENUMX
4189 BFD_RELOC_MEP_PCREL17A2
4190 ENUMX
4191 BFD_RELOC_MEP_PCREL24A2
4192 ENUMX
4193 BFD_RELOC_MEP_PCABS24A2
4194 ENUMX
4195 BFD_RELOC_MEP_LOW16
4196 ENUMX
4197 BFD_RELOC_MEP_HI16U
4198 ENUMX
4199 BFD_RELOC_MEP_HI16S
4200 ENUMX
4201 BFD_RELOC_MEP_GPREL
4202 ENUMX
4203 BFD_RELOC_MEP_TPREL
4204 ENUMX
4205 BFD_RELOC_MEP_TPREL7
4206 ENUMX
4207 BFD_RELOC_MEP_TPREL7A2
4208 ENUMX
4209 BFD_RELOC_MEP_TPREL7A4
4210 ENUMX
4211 BFD_RELOC_MEP_UIMM24
4212 ENUMX
4213 BFD_RELOC_MEP_ADDR24A4
4214 ENUMX
4215 BFD_RELOC_MEP_GNU_VTINHERIT
4216 ENUMX
4217 BFD_RELOC_MEP_GNU_VTENTRY
4218 ENUMDOC
4219 Toshiba Media Processor Relocations.
4220 COMMENT
4221
4222 ENUM
4223 BFD_RELOC_METAG_HIADDR16
4224 ENUMX
4225 BFD_RELOC_METAG_LOADDR16
4226 ENUMX
4227 BFD_RELOC_METAG_RELBRANCH
4228 ENUMX
4229 BFD_RELOC_METAG_GETSETOFF
4230 ENUMX
4231 BFD_RELOC_METAG_HIOG
4232 ENUMX
4233 BFD_RELOC_METAG_LOOG
4234 ENUMX
4235 BFD_RELOC_METAG_REL8
4236 ENUMX
4237 BFD_RELOC_METAG_REL16
4238 ENUMX
4239 BFD_RELOC_METAG_HI16_GOTOFF
4240 ENUMX
4241 BFD_RELOC_METAG_LO16_GOTOFF
4242 ENUMX
4243 BFD_RELOC_METAG_GETSET_GOTOFF
4244 ENUMX
4245 BFD_RELOC_METAG_GETSET_GOT
4246 ENUMX
4247 BFD_RELOC_METAG_HI16_GOTPC
4248 ENUMX
4249 BFD_RELOC_METAG_LO16_GOTPC
4250 ENUMX
4251 BFD_RELOC_METAG_HI16_PLT
4252 ENUMX
4253 BFD_RELOC_METAG_LO16_PLT
4254 ENUMX
4255 BFD_RELOC_METAG_RELBRANCH_PLT
4256 ENUMX
4257 BFD_RELOC_METAG_GOTOFF
4258 ENUMX
4259 BFD_RELOC_METAG_PLT
4260 ENUMX
4261 BFD_RELOC_METAG_COPY
4262 ENUMX
4263 BFD_RELOC_METAG_JMP_SLOT
4264 ENUMX
4265 BFD_RELOC_METAG_RELATIVE
4266 ENUMX
4267 BFD_RELOC_METAG_GLOB_DAT
4268 ENUMX
4269 BFD_RELOC_METAG_TLS_GD
4270 ENUMX
4271 BFD_RELOC_METAG_TLS_LDM
4272 ENUMX
4273 BFD_RELOC_METAG_TLS_LDO_HI16
4274 ENUMX
4275 BFD_RELOC_METAG_TLS_LDO_LO16
4276 ENUMX
4277 BFD_RELOC_METAG_TLS_LDO
4278 ENUMX
4279 BFD_RELOC_METAG_TLS_IE
4280 ENUMX
4281 BFD_RELOC_METAG_TLS_IENONPIC
4282 ENUMX
4283 BFD_RELOC_METAG_TLS_IENONPIC_HI16
4284 ENUMX
4285 BFD_RELOC_METAG_TLS_IENONPIC_LO16
4286 ENUMX
4287 BFD_RELOC_METAG_TLS_TPOFF
4288 ENUMX
4289 BFD_RELOC_METAG_TLS_DTPMOD
4290 ENUMX
4291 BFD_RELOC_METAG_TLS_DTPOFF
4292 ENUMX
4293 BFD_RELOC_METAG_TLS_LE
4294 ENUMX
4295 BFD_RELOC_METAG_TLS_LE_HI16
4296 ENUMX
4297 BFD_RELOC_METAG_TLS_LE_LO16
4298 ENUMDOC
4299 Imagination Technologies Meta relocations.
4300
4301 ENUM
4302 BFD_RELOC_MMIX_GETA
4303 ENUMX
4304 BFD_RELOC_MMIX_GETA_1
4305 ENUMX
4306 BFD_RELOC_MMIX_GETA_2
4307 ENUMX
4308 BFD_RELOC_MMIX_GETA_3
4309 ENUMDOC
4310 These are relocations for the GETA instruction.
4311 ENUM
4312 BFD_RELOC_MMIX_CBRANCH
4313 ENUMX
4314 BFD_RELOC_MMIX_CBRANCH_J
4315 ENUMX
4316 BFD_RELOC_MMIX_CBRANCH_1
4317 ENUMX
4318 BFD_RELOC_MMIX_CBRANCH_2
4319 ENUMX
4320 BFD_RELOC_MMIX_CBRANCH_3
4321 ENUMDOC
4322 These are relocations for a conditional branch instruction.
4323 ENUM
4324 BFD_RELOC_MMIX_PUSHJ
4325 ENUMX
4326 BFD_RELOC_MMIX_PUSHJ_1
4327 ENUMX
4328 BFD_RELOC_MMIX_PUSHJ_2
4329 ENUMX
4330 BFD_RELOC_MMIX_PUSHJ_3
4331 ENUMX
4332 BFD_RELOC_MMIX_PUSHJ_STUBBABLE
4333 ENUMDOC
4334 These are relocations for the PUSHJ instruction.
4335 ENUM
4336 BFD_RELOC_MMIX_JMP
4337 ENUMX
4338 BFD_RELOC_MMIX_JMP_1
4339 ENUMX
4340 BFD_RELOC_MMIX_JMP_2
4341 ENUMX
4342 BFD_RELOC_MMIX_JMP_3
4343 ENUMDOC
4344 These are relocations for the JMP instruction.
4345 ENUM
4346 BFD_RELOC_MMIX_ADDR19
4347 ENUMDOC
4348 This is a relocation for a relative address as in a GETA instruction or
4349 a branch.
4350 ENUM
4351 BFD_RELOC_MMIX_ADDR27
4352 ENUMDOC
4353 This is a relocation for a relative address as in a JMP instruction.
4354 ENUM
4355 BFD_RELOC_MMIX_REG_OR_BYTE
4356 ENUMDOC
4357 This is a relocation for an instruction field that may be a general
4358 register or a value 0..255.
4359 ENUM
4360 BFD_RELOC_MMIX_REG
4361 ENUMDOC
4362 This is a relocation for an instruction field that may be a general
4363 register.
4364 ENUM
4365 BFD_RELOC_MMIX_BASE_PLUS_OFFSET
4366 ENUMDOC
4367 This is a relocation for two instruction fields holding a register and
4368 an offset, the equivalent of the relocation.
4369 ENUM
4370 BFD_RELOC_MMIX_LOCAL
4371 ENUMDOC
4372 This relocation is an assertion that the expression is not allocated as
4373 a global register. It does not modify contents.
4374
4375 ENUM
4376 BFD_RELOC_AVR_7_PCREL
4377 ENUMDOC
4378 This is a 16 bit reloc for the AVR that stores 8 bit pc relative
4379 short offset into 7 bits.
4380 ENUM
4381 BFD_RELOC_AVR_13_PCREL
4382 ENUMDOC
4383 This is a 16 bit reloc for the AVR that stores 13 bit pc relative
4384 short offset into 12 bits.
4385 ENUM
4386 BFD_RELOC_AVR_16_PM
4387 ENUMDOC
4388 This is a 16 bit reloc for the AVR that stores 17 bit value (usually
4389 program memory address) into 16 bits.
4390 ENUM
4391 BFD_RELOC_AVR_LO8_LDI
4392 ENUMDOC
4393 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
4394 data memory address) into 8 bit immediate value of LDI insn.
4395 ENUM
4396 BFD_RELOC_AVR_HI8_LDI
4397 ENUMDOC
4398 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4399 of data memory address) into 8 bit immediate value of LDI insn.
4400 ENUM
4401 BFD_RELOC_AVR_HH8_LDI
4402 ENUMDOC
4403 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4404 of program memory address) into 8 bit immediate value of LDI insn.
4405 ENUM
4406 BFD_RELOC_AVR_MS8_LDI
4407 ENUMDOC
4408 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4409 of 32 bit value) into 8 bit immediate value of LDI insn.
4410 ENUM
4411 BFD_RELOC_AVR_LO8_LDI_NEG
4412 ENUMDOC
4413 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4414 (usually data memory address) into 8 bit immediate value of SUBI insn.
4415 ENUM
4416 BFD_RELOC_AVR_HI8_LDI_NEG
4417 ENUMDOC
4418 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4419 (high 8 bit of data memory address) into 8 bit immediate value of
4420 SUBI insn.
4421 ENUM
4422 BFD_RELOC_AVR_HH8_LDI_NEG
4423 ENUMDOC
4424 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4425 (most high 8 bit of program memory address) into 8 bit immediate value
4426 of LDI or SUBI insn.
4427 ENUM
4428 BFD_RELOC_AVR_MS8_LDI_NEG
4429 ENUMDOC
4430 This is a 16 bit reloc for the AVR that stores negated 8 bit value (msb
4431 of 32 bit value) into 8 bit immediate value of LDI insn.
4432 ENUM
4433 BFD_RELOC_AVR_LO8_LDI_PM
4434 ENUMDOC
4435 This is a 16 bit reloc for the AVR that stores 8 bit value (usually
4436 command address) into 8 bit immediate value of LDI insn.
4437 ENUM
4438 BFD_RELOC_AVR_LO8_LDI_GS
4439 ENUMDOC
4440 This is a 16 bit reloc for the AVR that stores 8 bit value
4441 (command address) into 8 bit immediate value of LDI insn. If the address
4442 is beyond the 128k boundary, the linker inserts a jump stub for this reloc
4443 in the lower 128k.
4444 ENUM
4445 BFD_RELOC_AVR_HI8_LDI_PM
4446 ENUMDOC
4447 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4448 of command address) into 8 bit immediate value of LDI insn.
4449 ENUM
4450 BFD_RELOC_AVR_HI8_LDI_GS
4451 ENUMDOC
4452 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4453 of command address) into 8 bit immediate value of LDI insn. If the address
4454 is beyond the 128k boundary, the linker inserts a jump stub for this reloc
4455 below 128k.
4456 ENUM
4457 BFD_RELOC_AVR_HH8_LDI_PM
4458 ENUMDOC
4459 This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
4460 of command address) into 8 bit immediate value of LDI insn.
4461 ENUM
4462 BFD_RELOC_AVR_LO8_LDI_PM_NEG
4463 ENUMDOC
4464 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4465 (usually command address) into 8 bit immediate value of SUBI insn.
4466 ENUM
4467 BFD_RELOC_AVR_HI8_LDI_PM_NEG
4468 ENUMDOC
4469 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4470 (high 8 bit of 16 bit command address) into 8 bit immediate value
4471 of SUBI insn.
4472 ENUM
4473 BFD_RELOC_AVR_HH8_LDI_PM_NEG
4474 ENUMDOC
4475 This is a 16 bit reloc for the AVR that stores negated 8 bit value
4476 (high 6 bit of 22 bit command address) into 8 bit immediate
4477 value of SUBI insn.
4478 ENUM
4479 BFD_RELOC_AVR_CALL
4480 ENUMDOC
4481 This is a 32 bit reloc for the AVR that stores 23 bit value
4482 into 22 bits.
4483 ENUM
4484 BFD_RELOC_AVR_LDI
4485 ENUMDOC
4486 This is a 16 bit reloc for the AVR that stores all needed bits
4487 for absolute addressing with ldi with overflow check to linktime
4488 ENUM
4489 BFD_RELOC_AVR_6
4490 ENUMDOC
4491 This is a 6 bit reloc for the AVR that stores offset for ldd/std
4492 instructions
4493 ENUM
4494 BFD_RELOC_AVR_6_ADIW
4495 ENUMDOC
4496 This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw
4497 instructions
4498 ENUM
4499 BFD_RELOC_AVR_8_LO
4500 ENUMDOC
4501 This is a 8 bit reloc for the AVR that stores bits 0..7 of a symbol
4502 in .byte lo8(symbol)
4503 ENUM
4504 BFD_RELOC_AVR_8_HI
4505 ENUMDOC
4506 This is a 8 bit reloc for the AVR that stores bits 8..15 of a symbol
4507 in .byte hi8(symbol)
4508 ENUM
4509 BFD_RELOC_AVR_8_HLO
4510 ENUMDOC
4511 This is a 8 bit reloc for the AVR that stores bits 16..23 of a symbol
4512 in .byte hlo8(symbol)
4513
4514 ENUM
4515 BFD_RELOC_RL78_NEG8
4516 ENUMX
4517 BFD_RELOC_RL78_NEG16
4518 ENUMX
4519 BFD_RELOC_RL78_NEG24
4520 ENUMX
4521 BFD_RELOC_RL78_NEG32
4522 ENUMX
4523 BFD_RELOC_RL78_16_OP
4524 ENUMX
4525 BFD_RELOC_RL78_24_OP
4526 ENUMX
4527 BFD_RELOC_RL78_32_OP
4528 ENUMX
4529 BFD_RELOC_RL78_8U
4530 ENUMX
4531 BFD_RELOC_RL78_16U
4532 ENUMX
4533 BFD_RELOC_RL78_24U
4534 ENUMX
4535 BFD_RELOC_RL78_DIR3U_PCREL
4536 ENUMX
4537 BFD_RELOC_RL78_DIFF
4538 ENUMX
4539 BFD_RELOC_RL78_GPRELB
4540 ENUMX
4541 BFD_RELOC_RL78_GPRELW
4542 ENUMX
4543 BFD_RELOC_RL78_GPRELL
4544 ENUMX
4545 BFD_RELOC_RL78_SYM
4546 ENUMX
4547 BFD_RELOC_RL78_OP_SUBTRACT
4548 ENUMX
4549 BFD_RELOC_RL78_OP_NEG
4550 ENUMX
4551 BFD_RELOC_RL78_OP_AND
4552 ENUMX
4553 BFD_RELOC_RL78_OP_SHRA
4554 ENUMX
4555 BFD_RELOC_RL78_ABS8
4556 ENUMX
4557 BFD_RELOC_RL78_ABS16
4558 ENUMX
4559 BFD_RELOC_RL78_ABS16_REV
4560 ENUMX
4561 BFD_RELOC_RL78_ABS32
4562 ENUMX
4563 BFD_RELOC_RL78_ABS32_REV
4564 ENUMX
4565 BFD_RELOC_RL78_ABS16U
4566 ENUMX
4567 BFD_RELOC_RL78_ABS16UW
4568 ENUMX
4569 BFD_RELOC_RL78_ABS16UL
4570 ENUMX
4571 BFD_RELOC_RL78_RELAX
4572 ENUMX
4573 BFD_RELOC_RL78_HI16
4574 ENUMX
4575 BFD_RELOC_RL78_HI8
4576 ENUMX
4577 BFD_RELOC_RL78_LO16
4578 ENUMX
4579 BFD_RELOC_RL78_CODE
4580 ENUMDOC
4581 Renesas RL78 Relocations.
4582
4583 ENUM
4584 BFD_RELOC_RX_NEG8
4585 ENUMX
4586 BFD_RELOC_RX_NEG16
4587 ENUMX
4588 BFD_RELOC_RX_NEG24
4589 ENUMX
4590 BFD_RELOC_RX_NEG32
4591 ENUMX
4592 BFD_RELOC_RX_16_OP
4593 ENUMX
4594 BFD_RELOC_RX_24_OP
4595 ENUMX
4596 BFD_RELOC_RX_32_OP
4597 ENUMX
4598 BFD_RELOC_RX_8U
4599 ENUMX
4600 BFD_RELOC_RX_16U
4601 ENUMX
4602 BFD_RELOC_RX_24U
4603 ENUMX
4604 BFD_RELOC_RX_DIR3U_PCREL
4605 ENUMX
4606 BFD_RELOC_RX_DIFF
4607 ENUMX
4608 BFD_RELOC_RX_GPRELB
4609 ENUMX
4610 BFD_RELOC_RX_GPRELW
4611 ENUMX
4612 BFD_RELOC_RX_GPRELL
4613 ENUMX
4614 BFD_RELOC_RX_SYM
4615 ENUMX
4616 BFD_RELOC_RX_OP_SUBTRACT
4617 ENUMX
4618 BFD_RELOC_RX_OP_NEG
4619 ENUMX
4620 BFD_RELOC_RX_ABS8
4621 ENUMX
4622 BFD_RELOC_RX_ABS16
4623 ENUMX
4624 BFD_RELOC_RX_ABS16_REV
4625 ENUMX
4626 BFD_RELOC_RX_ABS32
4627 ENUMX
4628 BFD_RELOC_RX_ABS32_REV
4629 ENUMX
4630 BFD_RELOC_RX_ABS16U
4631 ENUMX
4632 BFD_RELOC_RX_ABS16UW
4633 ENUMX
4634 BFD_RELOC_RX_ABS16UL
4635 ENUMX
4636 BFD_RELOC_RX_RELAX
4637 ENUMDOC
4638 Renesas RX Relocations.
4639
4640 ENUM
4641 BFD_RELOC_390_12
4642 ENUMDOC
4643 Direct 12 bit.
4644 ENUM
4645 BFD_RELOC_390_GOT12
4646 ENUMDOC
4647 12 bit GOT offset.
4648 ENUM
4649 BFD_RELOC_390_PLT32
4650 ENUMDOC
4651 32 bit PC relative PLT address.
4652 ENUM
4653 BFD_RELOC_390_COPY
4654 ENUMDOC
4655 Copy symbol at runtime.
4656 ENUM
4657 BFD_RELOC_390_GLOB_DAT
4658 ENUMDOC
4659 Create GOT entry.
4660 ENUM
4661 BFD_RELOC_390_JMP_SLOT
4662 ENUMDOC
4663 Create PLT entry.
4664 ENUM
4665 BFD_RELOC_390_RELATIVE
4666 ENUMDOC
4667 Adjust by program base.
4668 ENUM
4669 BFD_RELOC_390_GOTPC
4670 ENUMDOC
4671 32 bit PC relative offset to GOT.
4672 ENUM
4673 BFD_RELOC_390_GOT16
4674 ENUMDOC
4675 16 bit GOT offset.
4676 ENUM
4677 BFD_RELOC_390_PC12DBL
4678 ENUMDOC
4679 PC relative 12 bit shifted by 1.
4680 ENUM
4681 BFD_RELOC_390_PLT12DBL
4682 ENUMDOC
4683 12 bit PC rel. PLT shifted by 1.
4684 ENUM
4685 BFD_RELOC_390_PC16DBL
4686 ENUMDOC
4687 PC relative 16 bit shifted by 1.
4688 ENUM
4689 BFD_RELOC_390_PLT16DBL
4690 ENUMDOC
4691 16 bit PC rel. PLT shifted by 1.
4692 ENUM
4693 BFD_RELOC_390_PC24DBL
4694 ENUMDOC
4695 PC relative 24 bit shifted by 1.
4696 ENUM
4697 BFD_RELOC_390_PLT24DBL
4698 ENUMDOC
4699 24 bit PC rel. PLT shifted by 1.
4700 ENUM
4701 BFD_RELOC_390_PC32DBL
4702 ENUMDOC
4703 PC relative 32 bit shifted by 1.
4704 ENUM
4705 BFD_RELOC_390_PLT32DBL
4706 ENUMDOC
4707 32 bit PC rel. PLT shifted by 1.
4708 ENUM
4709 BFD_RELOC_390_GOTPCDBL
4710 ENUMDOC
4711 32 bit PC rel. GOT shifted by 1.
4712 ENUM
4713 BFD_RELOC_390_GOT64
4714 ENUMDOC
4715 64 bit GOT offset.
4716 ENUM
4717 BFD_RELOC_390_PLT64
4718 ENUMDOC
4719 64 bit PC relative PLT address.
4720 ENUM
4721 BFD_RELOC_390_GOTENT
4722 ENUMDOC
4723 32 bit rel. offset to GOT entry.
4724 ENUM
4725 BFD_RELOC_390_GOTOFF64
4726 ENUMDOC
4727 64 bit offset to GOT.
4728 ENUM
4729 BFD_RELOC_390_GOTPLT12
4730 ENUMDOC
4731 12-bit offset to symbol-entry within GOT, with PLT handling.
4732 ENUM
4733 BFD_RELOC_390_GOTPLT16
4734 ENUMDOC
4735 16-bit offset to symbol-entry within GOT, with PLT handling.
4736 ENUM
4737 BFD_RELOC_390_GOTPLT32
4738 ENUMDOC
4739 32-bit offset to symbol-entry within GOT, with PLT handling.
4740 ENUM
4741 BFD_RELOC_390_GOTPLT64
4742 ENUMDOC
4743 64-bit offset to symbol-entry within GOT, with PLT handling.
4744 ENUM
4745 BFD_RELOC_390_GOTPLTENT
4746 ENUMDOC
4747 32-bit rel. offset to symbol-entry within GOT, with PLT handling.
4748 ENUM
4749 BFD_RELOC_390_PLTOFF16
4750 ENUMDOC
4751 16-bit rel. offset from the GOT to a PLT entry.
4752 ENUM
4753 BFD_RELOC_390_PLTOFF32
4754 ENUMDOC
4755 32-bit rel. offset from the GOT to a PLT entry.
4756 ENUM
4757 BFD_RELOC_390_PLTOFF64
4758 ENUMDOC
4759 64-bit rel. offset from the GOT to a PLT entry.
4760
4761 ENUM
4762 BFD_RELOC_390_TLS_LOAD
4763 ENUMX
4764 BFD_RELOC_390_TLS_GDCALL
4765 ENUMX
4766 BFD_RELOC_390_TLS_LDCALL
4767 ENUMX
4768 BFD_RELOC_390_TLS_GD32
4769 ENUMX
4770 BFD_RELOC_390_TLS_GD64
4771 ENUMX
4772 BFD_RELOC_390_TLS_GOTIE12
4773 ENUMX
4774 BFD_RELOC_390_TLS_GOTIE32
4775 ENUMX
4776 BFD_RELOC_390_TLS_GOTIE64
4777 ENUMX
4778 BFD_RELOC_390_TLS_LDM32
4779 ENUMX
4780 BFD_RELOC_390_TLS_LDM64
4781 ENUMX
4782 BFD_RELOC_390_TLS_IE32
4783 ENUMX
4784 BFD_RELOC_390_TLS_IE64
4785 ENUMX
4786 BFD_RELOC_390_TLS_IEENT
4787 ENUMX
4788 BFD_RELOC_390_TLS_LE32
4789 ENUMX
4790 BFD_RELOC_390_TLS_LE64
4791 ENUMX
4792 BFD_RELOC_390_TLS_LDO32
4793 ENUMX
4794 BFD_RELOC_390_TLS_LDO64
4795 ENUMX
4796 BFD_RELOC_390_TLS_DTPMOD
4797 ENUMX
4798 BFD_RELOC_390_TLS_DTPOFF
4799 ENUMX
4800 BFD_RELOC_390_TLS_TPOFF
4801 ENUMDOC
4802 s390 tls relocations.
4803
4804 ENUM
4805 BFD_RELOC_390_20
4806 ENUMX
4807 BFD_RELOC_390_GOT20
4808 ENUMX
4809 BFD_RELOC_390_GOTPLT20
4810 ENUMX
4811 BFD_RELOC_390_TLS_GOTIE20
4812 ENUMDOC
4813 Long displacement extension.
4814
4815 ENUM
4816 BFD_RELOC_390_IRELATIVE
4817 ENUMDOC
4818 STT_GNU_IFUNC relocation.
4819
4820 ENUM
4821 BFD_RELOC_SCORE_GPREL15
4822 ENUMDOC
4823 Score relocations
4824 Low 16 bit for load/store
4825 ENUM
4826 BFD_RELOC_SCORE_DUMMY2
4827 ENUMX
4828 BFD_RELOC_SCORE_JMP
4829 ENUMDOC
4830 This is a 24-bit reloc with the right 1 bit assumed to be 0
4831 ENUM
4832 BFD_RELOC_SCORE_BRANCH
4833 ENUMDOC
4834 This is a 19-bit reloc with the right 1 bit assumed to be 0
4835 ENUM
4836 BFD_RELOC_SCORE_IMM30
4837 ENUMDOC
4838 This is a 32-bit reloc for 48-bit instructions.
4839 ENUM
4840 BFD_RELOC_SCORE_IMM32
4841 ENUMDOC
4842 This is a 32-bit reloc for 48-bit instructions.
4843 ENUM
4844 BFD_RELOC_SCORE16_JMP
4845 ENUMDOC
4846 This is a 11-bit reloc with the right 1 bit assumed to be 0
4847 ENUM
4848 BFD_RELOC_SCORE16_BRANCH
4849 ENUMDOC
4850 This is a 8-bit reloc with the right 1 bit assumed to be 0
4851 ENUM
4852 BFD_RELOC_SCORE_BCMP
4853 ENUMDOC
4854 This is a 9-bit reloc with the right 1 bit assumed to be 0
4855 ENUM
4856 BFD_RELOC_SCORE_GOT15
4857 ENUMX
4858 BFD_RELOC_SCORE_GOT_LO16
4859 ENUMX
4860 BFD_RELOC_SCORE_CALL15
4861 ENUMX
4862 BFD_RELOC_SCORE_DUMMY_HI16
4863 ENUMDOC
4864 Undocumented Score relocs
4865
4866 ENUM
4867 BFD_RELOC_IP2K_FR9
4868 ENUMDOC
4869 Scenix IP2K - 9-bit register number / data address
4870 ENUM
4871 BFD_RELOC_IP2K_BANK
4872 ENUMDOC
4873 Scenix IP2K - 4-bit register/data bank number
4874 ENUM
4875 BFD_RELOC_IP2K_ADDR16CJP
4876 ENUMDOC
4877 Scenix IP2K - low 13 bits of instruction word address
4878 ENUM
4879 BFD_RELOC_IP2K_PAGE3
4880 ENUMDOC
4881 Scenix IP2K - high 3 bits of instruction word address
4882 ENUM
4883 BFD_RELOC_IP2K_LO8DATA
4884 ENUMX
4885 BFD_RELOC_IP2K_HI8DATA
4886 ENUMX
4887 BFD_RELOC_IP2K_EX8DATA
4888 ENUMDOC
4889 Scenix IP2K - ext/low/high 8 bits of data address
4890 ENUM
4891 BFD_RELOC_IP2K_LO8INSN
4892 ENUMX
4893 BFD_RELOC_IP2K_HI8INSN
4894 ENUMDOC
4895 Scenix IP2K - low/high 8 bits of instruction word address
4896 ENUM
4897 BFD_RELOC_IP2K_PC_SKIP
4898 ENUMDOC
4899 Scenix IP2K - even/odd PC modifier to modify snb pcl.0
4900 ENUM
4901 BFD_RELOC_IP2K_TEXT
4902 ENUMDOC
4903 Scenix IP2K - 16 bit word address in text section.
4904 ENUM
4905 BFD_RELOC_IP2K_FR_OFFSET
4906 ENUMDOC
4907 Scenix IP2K - 7-bit sp or dp offset
4908 ENUM
4909 BFD_RELOC_VPE4KMATH_DATA
4910 ENUMX
4911 BFD_RELOC_VPE4KMATH_INSN
4912 ENUMDOC
4913 Scenix VPE4K coprocessor - data/insn-space addressing
4914
4915 ENUM
4916 BFD_RELOC_VTABLE_INHERIT
4917 ENUMX
4918 BFD_RELOC_VTABLE_ENTRY
4919 ENUMDOC
4920 These two relocations are used by the linker to determine which of
4921 the entries in a C++ virtual function table are actually used. When
4922 the --gc-sections option is given, the linker will zero out the entries
4923 that are not used, so that the code for those functions need not be
4924 included in the output.
4925
4926 VTABLE_INHERIT is a zero-space relocation used to describe to the
4927 linker the inheritance tree of a C++ virtual function table. The
4928 relocation's symbol should be the parent class' vtable, and the
4929 relocation should be located at the child vtable.
4930
4931 VTABLE_ENTRY is a zero-space relocation that describes the use of a
4932 virtual function table entry. The reloc's symbol should refer to the
4933 table of the class mentioned in the code. Off of that base, an offset
4934 describes the entry that is being used. For Rela hosts, this offset
4935 is stored in the reloc's addend. For Rel hosts, we are forced to put
4936 this offset in the reloc's section offset.
4937
4938 ENUM
4939 BFD_RELOC_IA64_IMM14
4940 ENUMX
4941 BFD_RELOC_IA64_IMM22
4942 ENUMX
4943 BFD_RELOC_IA64_IMM64
4944 ENUMX
4945 BFD_RELOC_IA64_DIR32MSB
4946 ENUMX
4947 BFD_RELOC_IA64_DIR32LSB
4948 ENUMX
4949 BFD_RELOC_IA64_DIR64MSB
4950 ENUMX
4951 BFD_RELOC_IA64_DIR64LSB
4952 ENUMX
4953 BFD_RELOC_IA64_GPREL22
4954 ENUMX
4955 BFD_RELOC_IA64_GPREL64I
4956 ENUMX
4957 BFD_RELOC_IA64_GPREL32MSB
4958 ENUMX
4959 BFD_RELOC_IA64_GPREL32LSB
4960 ENUMX
4961 BFD_RELOC_IA64_GPREL64MSB
4962 ENUMX
4963 BFD_RELOC_IA64_GPREL64LSB
4964 ENUMX
4965 BFD_RELOC_IA64_LTOFF22
4966 ENUMX
4967 BFD_RELOC_IA64_LTOFF64I
4968 ENUMX
4969 BFD_RELOC_IA64_PLTOFF22
4970 ENUMX
4971 BFD_RELOC_IA64_PLTOFF64I
4972 ENUMX
4973 BFD_RELOC_IA64_PLTOFF64MSB
4974 ENUMX
4975 BFD_RELOC_IA64_PLTOFF64LSB
4976 ENUMX
4977 BFD_RELOC_IA64_FPTR64I
4978 ENUMX
4979 BFD_RELOC_IA64_FPTR32MSB
4980 ENUMX
4981 BFD_RELOC_IA64_FPTR32LSB
4982 ENUMX
4983 BFD_RELOC_IA64_FPTR64MSB
4984 ENUMX
4985 BFD_RELOC_IA64_FPTR64LSB
4986 ENUMX
4987 BFD_RELOC_IA64_PCREL21B
4988 ENUMX
4989 BFD_RELOC_IA64_PCREL21BI
4990 ENUMX
4991 BFD_RELOC_IA64_PCREL21M
4992 ENUMX
4993 BFD_RELOC_IA64_PCREL21F
4994 ENUMX
4995 BFD_RELOC_IA64_PCREL22
4996 ENUMX
4997 BFD_RELOC_IA64_PCREL60B
4998 ENUMX
4999 BFD_RELOC_IA64_PCREL64I
5000 ENUMX
5001 BFD_RELOC_IA64_PCREL32MSB
5002 ENUMX
5003 BFD_RELOC_IA64_PCREL32LSB
5004 ENUMX
5005 BFD_RELOC_IA64_PCREL64MSB
5006 ENUMX
5007 BFD_RELOC_IA64_PCREL64LSB
5008 ENUMX
5009 BFD_RELOC_IA64_LTOFF_FPTR22
5010 ENUMX
5011 BFD_RELOC_IA64_LTOFF_FPTR64I
5012 ENUMX
5013 BFD_RELOC_IA64_LTOFF_FPTR32MSB
5014 ENUMX
5015 BFD_RELOC_IA64_LTOFF_FPTR32LSB
5016 ENUMX
5017 BFD_RELOC_IA64_LTOFF_FPTR64MSB
5018 ENUMX
5019 BFD_RELOC_IA64_LTOFF_FPTR64LSB
5020 ENUMX
5021 BFD_RELOC_IA64_SEGREL32MSB
5022 ENUMX
5023 BFD_RELOC_IA64_SEGREL32LSB
5024 ENUMX
5025 BFD_RELOC_IA64_SEGREL64MSB
5026 ENUMX
5027 BFD_RELOC_IA64_SEGREL64LSB
5028 ENUMX
5029 BFD_RELOC_IA64_SECREL32MSB
5030 ENUMX
5031 BFD_RELOC_IA64_SECREL32LSB
5032 ENUMX
5033 BFD_RELOC_IA64_SECREL64MSB
5034 ENUMX
5035 BFD_RELOC_IA64_SECREL64LSB
5036 ENUMX
5037 BFD_RELOC_IA64_REL32MSB
5038 ENUMX
5039 BFD_RELOC_IA64_REL32LSB
5040 ENUMX
5041 BFD_RELOC_IA64_REL64MSB
5042 ENUMX
5043 BFD_RELOC_IA64_REL64LSB
5044 ENUMX
5045 BFD_RELOC_IA64_LTV32MSB
5046 ENUMX
5047 BFD_RELOC_IA64_LTV32LSB
5048 ENUMX
5049 BFD_RELOC_IA64_LTV64MSB
5050 ENUMX
5051 BFD_RELOC_IA64_LTV64LSB
5052 ENUMX
5053 BFD_RELOC_IA64_IPLTMSB
5054 ENUMX
5055 BFD_RELOC_IA64_IPLTLSB
5056 ENUMX
5057 BFD_RELOC_IA64_COPY
5058 ENUMX
5059 BFD_RELOC_IA64_LTOFF22X
5060 ENUMX
5061 BFD_RELOC_IA64_LDXMOV
5062 ENUMX
5063 BFD_RELOC_IA64_TPREL14
5064 ENUMX
5065 BFD_RELOC_IA64_TPREL22
5066 ENUMX
5067 BFD_RELOC_IA64_TPREL64I
5068 ENUMX
5069 BFD_RELOC_IA64_TPREL64MSB
5070 ENUMX
5071 BFD_RELOC_IA64_TPREL64LSB
5072 ENUMX
5073 BFD_RELOC_IA64_LTOFF_TPREL22
5074 ENUMX
5075 BFD_RELOC_IA64_DTPMOD64MSB
5076 ENUMX
5077 BFD_RELOC_IA64_DTPMOD64LSB
5078 ENUMX
5079 BFD_RELOC_IA64_LTOFF_DTPMOD22
5080 ENUMX
5081 BFD_RELOC_IA64_DTPREL14
5082 ENUMX
5083 BFD_RELOC_IA64_DTPREL22
5084 ENUMX
5085 BFD_RELOC_IA64_DTPREL64I
5086 ENUMX
5087 BFD_RELOC_IA64_DTPREL32MSB
5088 ENUMX
5089 BFD_RELOC_IA64_DTPREL32LSB
5090 ENUMX
5091 BFD_RELOC_IA64_DTPREL64MSB
5092 ENUMX
5093 BFD_RELOC_IA64_DTPREL64LSB
5094 ENUMX
5095 BFD_RELOC_IA64_LTOFF_DTPREL22
5096 ENUMDOC
5097 Intel IA64 Relocations.
5098
5099 ENUM
5100 BFD_RELOC_M68HC11_HI8
5101 ENUMDOC
5102 Motorola 68HC11 reloc.
5103 This is the 8 bit high part of an absolute address.
5104 ENUM
5105 BFD_RELOC_M68HC11_LO8
5106 ENUMDOC
5107 Motorola 68HC11 reloc.
5108 This is the 8 bit low part of an absolute address.
5109 ENUM
5110 BFD_RELOC_M68HC11_3B
5111 ENUMDOC
5112 Motorola 68HC11 reloc.
5113 This is the 3 bit of a value.
5114 ENUM
5115 BFD_RELOC_M68HC11_RL_JUMP
5116 ENUMDOC
5117 Motorola 68HC11 reloc.
5118 This reloc marks the beginning of a jump/call instruction.
5119 It is used for linker relaxation to correctly identify beginning
5120 of instruction and change some branches to use PC-relative
5121 addressing mode.
5122 ENUM
5123 BFD_RELOC_M68HC11_RL_GROUP
5124 ENUMDOC
5125 Motorola 68HC11 reloc.
5126 This reloc marks a group of several instructions that gcc generates
5127 and for which the linker relaxation pass can modify and/or remove
5128 some of them.
5129 ENUM
5130 BFD_RELOC_M68HC11_LO16
5131 ENUMDOC
5132 Motorola 68HC11 reloc.
5133 This is the 16-bit lower part of an address. It is used for 'call'
5134 instruction to specify the symbol address without any special
5135 transformation (due to memory bank window).
5136 ENUM
5137 BFD_RELOC_M68HC11_PAGE
5138 ENUMDOC
5139 Motorola 68HC11 reloc.
5140 This is a 8-bit reloc that specifies the page number of an address.
5141 It is used by 'call' instruction to specify the page number of
5142 the symbol.
5143 ENUM
5144 BFD_RELOC_M68HC11_24
5145 ENUMDOC
5146 Motorola 68HC11 reloc.
5147 This is a 24-bit reloc that represents the address with a 16-bit
5148 value and a 8-bit page number. The symbol address is transformed
5149 to follow the 16K memory bank of 68HC12 (seen as mapped in the window).
5150 ENUM
5151 BFD_RELOC_M68HC12_5B
5152 ENUMDOC
5153 Motorola 68HC12 reloc.
5154 This is the 5 bits of a value.
5155 ENUM
5156 BFD_RELOC_XGATE_RL_JUMP
5157 ENUMDOC
5158 Freescale XGATE reloc.
5159 This reloc marks the beginning of a bra/jal instruction.
5160 ENUM
5161 BFD_RELOC_XGATE_RL_GROUP
5162 ENUMDOC
5163 Freescale XGATE reloc.
5164 This reloc marks a group of several instructions that gcc generates
5165 and for which the linker relaxation pass can modify and/or remove
5166 some of them.
5167 ENUM
5168 BFD_RELOC_XGATE_LO16
5169 ENUMDOC
5170 Freescale XGATE reloc.
5171 This is the 16-bit lower part of an address. It is used for the '16-bit'
5172 instructions.
5173 ENUM
5174 BFD_RELOC_XGATE_GPAGE
5175 ENUMDOC
5176 Freescale XGATE reloc.
5177 ENUM
5178 BFD_RELOC_XGATE_24
5179 ENUMDOC
5180 Freescale XGATE reloc.
5181 ENUM
5182 BFD_RELOC_XGATE_PCREL_9
5183 ENUMDOC
5184 Freescale XGATE reloc.
5185 This is a 9-bit pc-relative reloc.
5186 ENUM
5187 BFD_RELOC_XGATE_PCREL_10
5188 ENUMDOC
5189 Freescale XGATE reloc.
5190 This is a 10-bit pc-relative reloc.
5191 ENUM
5192 BFD_RELOC_XGATE_IMM8_LO
5193 ENUMDOC
5194 Freescale XGATE reloc.
5195 This is the 16-bit lower part of an address. It is used for the '16-bit'
5196 instructions.
5197 ENUM
5198 BFD_RELOC_XGATE_IMM8_HI
5199 ENUMDOC
5200 Freescale XGATE reloc.
5201 This is the 16-bit higher part of an address. It is used for the '16-bit'
5202 instructions.
5203 ENUM
5204 BFD_RELOC_XGATE_IMM3
5205 ENUMDOC
5206 Freescale XGATE reloc.
5207 This is a 3-bit pc-relative reloc.
5208 ENUM
5209 BFD_RELOC_XGATE_IMM4
5210 ENUMDOC
5211 Freescale XGATE reloc.
5212 This is a 4-bit pc-relative reloc.
5213 ENUM
5214 BFD_RELOC_XGATE_IMM5
5215 ENUMDOC
5216 Freescale XGATE reloc.
5217 This is a 5-bit pc-relative reloc.
5218 ENUM
5219 BFD_RELOC_M68HC12_9B
5220 ENUMDOC
5221 Motorola 68HC12 reloc.
5222 This is the 9 bits of a value.
5223 ENUM
5224 BFD_RELOC_M68HC12_16B
5225 ENUMDOC
5226 Motorola 68HC12 reloc.
5227 This is the 16 bits of a value.
5228 ENUM
5229 BFD_RELOC_M68HC12_9_PCREL
5230 ENUMDOC
5231 Motorola 68HC12/XGATE reloc.
5232 This is a PCREL9 branch.
5233 ENUM
5234 BFD_RELOC_M68HC12_10_PCREL
5235 ENUMDOC
5236 Motorola 68HC12/XGATE reloc.
5237 This is a PCREL10 branch.
5238 ENUM
5239 BFD_RELOC_M68HC12_LO8XG
5240 ENUMDOC
5241 Motorola 68HC12/XGATE reloc.
5242 This is the 8 bit low part of an absolute address and immediately precedes
5243 a matching HI8XG part.
5244 ENUM
5245 BFD_RELOC_M68HC12_HI8XG
5246 ENUMDOC
5247 Motorola 68HC12/XGATE reloc.
5248 This is the 8 bit high part of an absolute address and immediately follows
5249 a matching LO8XG part.
5250 ENUM
5251 BFD_RELOC_16C_NUM08
5252 ENUMX
5253 BFD_RELOC_16C_NUM08_C
5254 ENUMX
5255 BFD_RELOC_16C_NUM16
5256 ENUMX
5257 BFD_RELOC_16C_NUM16_C
5258 ENUMX
5259 BFD_RELOC_16C_NUM32
5260 ENUMX
5261 BFD_RELOC_16C_NUM32_C
5262 ENUMX
5263 BFD_RELOC_16C_DISP04
5264 ENUMX
5265 BFD_RELOC_16C_DISP04_C
5266 ENUMX
5267 BFD_RELOC_16C_DISP08
5268 ENUMX
5269 BFD_RELOC_16C_DISP08_C
5270 ENUMX
5271 BFD_RELOC_16C_DISP16
5272 ENUMX
5273 BFD_RELOC_16C_DISP16_C
5274 ENUMX
5275 BFD_RELOC_16C_DISP24
5276 ENUMX
5277 BFD_RELOC_16C_DISP24_C
5278 ENUMX
5279 BFD_RELOC_16C_DISP24a
5280 ENUMX
5281 BFD_RELOC_16C_DISP24a_C
5282 ENUMX
5283 BFD_RELOC_16C_REG04
5284 ENUMX
5285 BFD_RELOC_16C_REG04_C
5286 ENUMX
5287 BFD_RELOC_16C_REG04a
5288 ENUMX
5289 BFD_RELOC_16C_REG04a_C
5290 ENUMX
5291 BFD_RELOC_16C_REG14
5292 ENUMX
5293 BFD_RELOC_16C_REG14_C
5294 ENUMX
5295 BFD_RELOC_16C_REG16
5296 ENUMX
5297 BFD_RELOC_16C_REG16_C
5298 ENUMX
5299 BFD_RELOC_16C_REG20
5300 ENUMX
5301 BFD_RELOC_16C_REG20_C
5302 ENUMX
5303 BFD_RELOC_16C_ABS20
5304 ENUMX
5305 BFD_RELOC_16C_ABS20_C
5306 ENUMX
5307 BFD_RELOC_16C_ABS24
5308 ENUMX
5309 BFD_RELOC_16C_ABS24_C
5310 ENUMX
5311 BFD_RELOC_16C_IMM04
5312 ENUMX
5313 BFD_RELOC_16C_IMM04_C
5314 ENUMX
5315 BFD_RELOC_16C_IMM16
5316 ENUMX
5317 BFD_RELOC_16C_IMM16_C
5318 ENUMX
5319 BFD_RELOC_16C_IMM20
5320 ENUMX
5321 BFD_RELOC_16C_IMM20_C
5322 ENUMX
5323 BFD_RELOC_16C_IMM24
5324 ENUMX
5325 BFD_RELOC_16C_IMM24_C
5326 ENUMX
5327 BFD_RELOC_16C_IMM32
5328 ENUMX
5329 BFD_RELOC_16C_IMM32_C
5330 ENUMDOC
5331 NS CR16C Relocations.
5332
5333 ENUM
5334 BFD_RELOC_CR16_NUM8
5335 ENUMX
5336 BFD_RELOC_CR16_NUM16
5337 ENUMX
5338 BFD_RELOC_CR16_NUM32
5339 ENUMX
5340 BFD_RELOC_CR16_NUM32a
5341 ENUMX
5342 BFD_RELOC_CR16_REGREL0
5343 ENUMX
5344 BFD_RELOC_CR16_REGREL4
5345 ENUMX
5346 BFD_RELOC_CR16_REGREL4a
5347 ENUMX
5348 BFD_RELOC_CR16_REGREL14
5349 ENUMX
5350 BFD_RELOC_CR16_REGREL14a
5351 ENUMX
5352 BFD_RELOC_CR16_REGREL16
5353 ENUMX
5354 BFD_RELOC_CR16_REGREL20
5355 ENUMX
5356 BFD_RELOC_CR16_REGREL20a
5357 ENUMX
5358 BFD_RELOC_CR16_ABS20
5359 ENUMX
5360 BFD_RELOC_CR16_ABS24
5361 ENUMX
5362 BFD_RELOC_CR16_IMM4
5363 ENUMX
5364 BFD_RELOC_CR16_IMM8
5365 ENUMX
5366 BFD_RELOC_CR16_IMM16
5367 ENUMX
5368 BFD_RELOC_CR16_IMM20
5369 ENUMX
5370 BFD_RELOC_CR16_IMM24
5371 ENUMX
5372 BFD_RELOC_CR16_IMM32
5373 ENUMX
5374 BFD_RELOC_CR16_IMM32a
5375 ENUMX
5376 BFD_RELOC_CR16_DISP4
5377 ENUMX
5378 BFD_RELOC_CR16_DISP8
5379 ENUMX
5380 BFD_RELOC_CR16_DISP16
5381 ENUMX
5382 BFD_RELOC_CR16_DISP20
5383 ENUMX
5384 BFD_RELOC_CR16_DISP24
5385 ENUMX
5386 BFD_RELOC_CR16_DISP24a
5387 ENUMX
5388 BFD_RELOC_CR16_SWITCH8
5389 ENUMX
5390 BFD_RELOC_CR16_SWITCH16
5391 ENUMX
5392 BFD_RELOC_CR16_SWITCH32
5393 ENUMX
5394 BFD_RELOC_CR16_GOT_REGREL20
5395 ENUMX
5396 BFD_RELOC_CR16_GOTC_REGREL20
5397 ENUMX
5398 BFD_RELOC_CR16_GLOB_DAT
5399 ENUMDOC
5400 NS CR16 Relocations.
5401
5402 ENUM
5403 BFD_RELOC_CRX_REL4
5404 ENUMX
5405 BFD_RELOC_CRX_REL8
5406 ENUMX
5407 BFD_RELOC_CRX_REL8_CMP
5408 ENUMX
5409 BFD_RELOC_CRX_REL16
5410 ENUMX
5411 BFD_RELOC_CRX_REL24
5412 ENUMX
5413 BFD_RELOC_CRX_REL32
5414 ENUMX
5415 BFD_RELOC_CRX_REGREL12
5416 ENUMX
5417 BFD_RELOC_CRX_REGREL22
5418 ENUMX
5419 BFD_RELOC_CRX_REGREL28
5420 ENUMX
5421 BFD_RELOC_CRX_REGREL32
5422 ENUMX
5423 BFD_RELOC_CRX_ABS16
5424 ENUMX
5425 BFD_RELOC_CRX_ABS32
5426 ENUMX
5427 BFD_RELOC_CRX_NUM8
5428 ENUMX
5429 BFD_RELOC_CRX_NUM16
5430 ENUMX
5431 BFD_RELOC_CRX_NUM32
5432 ENUMX
5433 BFD_RELOC_CRX_IMM16
5434 ENUMX
5435 BFD_RELOC_CRX_IMM32
5436 ENUMX
5437 BFD_RELOC_CRX_SWITCH8
5438 ENUMX
5439 BFD_RELOC_CRX_SWITCH16
5440 ENUMX
5441 BFD_RELOC_CRX_SWITCH32
5442 ENUMDOC
5443 NS CRX Relocations.
5444
5445 ENUM
5446 BFD_RELOC_CRIS_BDISP8
5447 ENUMX
5448 BFD_RELOC_CRIS_UNSIGNED_5
5449 ENUMX
5450 BFD_RELOC_CRIS_SIGNED_6
5451 ENUMX
5452 BFD_RELOC_CRIS_UNSIGNED_6
5453 ENUMX
5454 BFD_RELOC_CRIS_SIGNED_8
5455 ENUMX
5456 BFD_RELOC_CRIS_UNSIGNED_8
5457 ENUMX
5458 BFD_RELOC_CRIS_SIGNED_16
5459 ENUMX
5460 BFD_RELOC_CRIS_UNSIGNED_16
5461 ENUMX
5462 BFD_RELOC_CRIS_LAPCQ_OFFSET
5463 ENUMX
5464 BFD_RELOC_CRIS_UNSIGNED_4
5465 ENUMDOC
5466 These relocs are only used within the CRIS assembler. They are not
5467 (at present) written to any object files.
5468 ENUM
5469 BFD_RELOC_CRIS_COPY
5470 ENUMX
5471 BFD_RELOC_CRIS_GLOB_DAT
5472 ENUMX
5473 BFD_RELOC_CRIS_JUMP_SLOT
5474 ENUMX
5475 BFD_RELOC_CRIS_RELATIVE
5476 ENUMDOC
5477 Relocs used in ELF shared libraries for CRIS.
5478 ENUM
5479 BFD_RELOC_CRIS_32_GOT
5480 ENUMDOC
5481 32-bit offset to symbol-entry within GOT.
5482 ENUM
5483 BFD_RELOC_CRIS_16_GOT
5484 ENUMDOC
5485 16-bit offset to symbol-entry within GOT.
5486 ENUM
5487 BFD_RELOC_CRIS_32_GOTPLT
5488 ENUMDOC
5489 32-bit offset to symbol-entry within GOT, with PLT handling.
5490 ENUM
5491 BFD_RELOC_CRIS_16_GOTPLT
5492 ENUMDOC
5493 16-bit offset to symbol-entry within GOT, with PLT handling.
5494 ENUM
5495 BFD_RELOC_CRIS_32_GOTREL
5496 ENUMDOC
5497 32-bit offset to symbol, relative to GOT.
5498 ENUM
5499 BFD_RELOC_CRIS_32_PLT_GOTREL
5500 ENUMDOC
5501 32-bit offset to symbol with PLT entry, relative to GOT.
5502 ENUM
5503 BFD_RELOC_CRIS_32_PLT_PCREL
5504 ENUMDOC
5505 32-bit offset to symbol with PLT entry, relative to this relocation.
5506
5507 ENUM
5508 BFD_RELOC_CRIS_32_GOT_GD
5509 ENUMX
5510 BFD_RELOC_CRIS_16_GOT_GD
5511 ENUMX
5512 BFD_RELOC_CRIS_32_GD
5513 ENUMX
5514 BFD_RELOC_CRIS_DTP
5515 ENUMX
5516 BFD_RELOC_CRIS_32_DTPREL
5517 ENUMX
5518 BFD_RELOC_CRIS_16_DTPREL
5519 ENUMX
5520 BFD_RELOC_CRIS_32_GOT_TPREL
5521 ENUMX
5522 BFD_RELOC_CRIS_16_GOT_TPREL
5523 ENUMX
5524 BFD_RELOC_CRIS_32_TPREL
5525 ENUMX
5526 BFD_RELOC_CRIS_16_TPREL
5527 ENUMX
5528 BFD_RELOC_CRIS_DTPMOD
5529 ENUMX
5530 BFD_RELOC_CRIS_32_IE
5531 ENUMDOC
5532 Relocs used in TLS code for CRIS.
5533
5534 ENUM
5535 BFD_RELOC_860_COPY
5536 ENUMX
5537 BFD_RELOC_860_GLOB_DAT
5538 ENUMX
5539 BFD_RELOC_860_JUMP_SLOT
5540 ENUMX
5541 BFD_RELOC_860_RELATIVE
5542 ENUMX
5543 BFD_RELOC_860_PC26
5544 ENUMX
5545 BFD_RELOC_860_PLT26
5546 ENUMX
5547 BFD_RELOC_860_PC16
5548 ENUMX
5549 BFD_RELOC_860_LOW0
5550 ENUMX
5551 BFD_RELOC_860_SPLIT0
5552 ENUMX
5553 BFD_RELOC_860_LOW1
5554 ENUMX
5555 BFD_RELOC_860_SPLIT1
5556 ENUMX
5557 BFD_RELOC_860_LOW2
5558 ENUMX
5559 BFD_RELOC_860_SPLIT2
5560 ENUMX
5561 BFD_RELOC_860_LOW3
5562 ENUMX
5563 BFD_RELOC_860_LOGOT0
5564 ENUMX
5565 BFD_RELOC_860_SPGOT0
5566 ENUMX
5567 BFD_RELOC_860_LOGOT1
5568 ENUMX
5569 BFD_RELOC_860_SPGOT1
5570 ENUMX
5571 BFD_RELOC_860_LOGOTOFF0
5572 ENUMX
5573 BFD_RELOC_860_SPGOTOFF0
5574 ENUMX
5575 BFD_RELOC_860_LOGOTOFF1
5576 ENUMX
5577 BFD_RELOC_860_SPGOTOFF1
5578 ENUMX
5579 BFD_RELOC_860_LOGOTOFF2
5580 ENUMX
5581 BFD_RELOC_860_LOGOTOFF3
5582 ENUMX
5583 BFD_RELOC_860_LOPC
5584 ENUMX
5585 BFD_RELOC_860_HIGHADJ
5586 ENUMX
5587 BFD_RELOC_860_HAGOT
5588 ENUMX
5589 BFD_RELOC_860_HAGOTOFF
5590 ENUMX
5591 BFD_RELOC_860_HAPC
5592 ENUMX
5593 BFD_RELOC_860_HIGH
5594 ENUMX
5595 BFD_RELOC_860_HIGOT
5596 ENUMX
5597 BFD_RELOC_860_HIGOTOFF
5598 ENUMDOC
5599 Intel i860 Relocations.
5600
5601 ENUM
5602 BFD_RELOC_OPENRISC_ABS_26
5603 ENUMX
5604 BFD_RELOC_OPENRISC_REL_26
5605 ENUMDOC
5606 OpenRISC Relocations.
5607
5608 ENUM
5609 BFD_RELOC_H8_DIR16A8
5610 ENUMX
5611 BFD_RELOC_H8_DIR16R8
5612 ENUMX
5613 BFD_RELOC_H8_DIR24A8
5614 ENUMX
5615 BFD_RELOC_H8_DIR24R8
5616 ENUMX
5617 BFD_RELOC_H8_DIR32A16
5618 ENUMX
5619 BFD_RELOC_H8_DISP32A16
5620 ENUMDOC
5621 H8 elf Relocations.
5622
5623 ENUM
5624 BFD_RELOC_XSTORMY16_REL_12
5625 ENUMX
5626 BFD_RELOC_XSTORMY16_12
5627 ENUMX
5628 BFD_RELOC_XSTORMY16_24
5629 ENUMX
5630 BFD_RELOC_XSTORMY16_FPTR16
5631 ENUMDOC
5632 Sony Xstormy16 Relocations.
5633
5634 ENUM
5635 BFD_RELOC_RELC
5636 ENUMDOC
5637 Self-describing complex relocations.
5638 COMMENT
5639
5640 ENUM
5641 BFD_RELOC_XC16X_PAG
5642 ENUMX
5643 BFD_RELOC_XC16X_POF
5644 ENUMX
5645 BFD_RELOC_XC16X_SEG
5646 ENUMX
5647 BFD_RELOC_XC16X_SOF
5648 ENUMDOC
5649 Infineon Relocations.
5650
5651 ENUM
5652 BFD_RELOC_VAX_GLOB_DAT
5653 ENUMX
5654 BFD_RELOC_VAX_JMP_SLOT
5655 ENUMX
5656 BFD_RELOC_VAX_RELATIVE
5657 ENUMDOC
5658 Relocations used by VAX ELF.
5659
5660 ENUM
5661 BFD_RELOC_MT_PC16
5662 ENUMDOC
5663 Morpho MT - 16 bit immediate relocation.
5664 ENUM
5665 BFD_RELOC_MT_HI16
5666 ENUMDOC
5667 Morpho MT - Hi 16 bits of an address.
5668 ENUM
5669 BFD_RELOC_MT_LO16
5670 ENUMDOC
5671 Morpho MT - Low 16 bits of an address.
5672 ENUM
5673 BFD_RELOC_MT_GNU_VTINHERIT
5674 ENUMDOC
5675 Morpho MT - Used to tell the linker which vtable entries are used.
5676 ENUM
5677 BFD_RELOC_MT_GNU_VTENTRY
5678 ENUMDOC
5679 Morpho MT - Used to tell the linker which vtable entries are used.
5680 ENUM
5681 BFD_RELOC_MT_PCINSN8
5682 ENUMDOC
5683 Morpho MT - 8 bit immediate relocation.
5684
5685 ENUM
5686 BFD_RELOC_MSP430_10_PCREL
5687 ENUMX
5688 BFD_RELOC_MSP430_16_PCREL
5689 ENUMX
5690 BFD_RELOC_MSP430_16
5691 ENUMX
5692 BFD_RELOC_MSP430_16_PCREL_BYTE
5693 ENUMX
5694 BFD_RELOC_MSP430_16_BYTE
5695 ENUMX
5696 BFD_RELOC_MSP430_2X_PCREL
5697 ENUMX
5698 BFD_RELOC_MSP430_RL_PCREL
5699 ENUMX
5700 BFD_RELOC_MSP430_ABS8
5701 ENUMX
5702 BFD_RELOC_MSP430X_PCR20_EXT_SRC
5703 ENUMX
5704 BFD_RELOC_MSP430X_PCR20_EXT_DST
5705 ENUMX
5706 BFD_RELOC_MSP430X_PCR20_EXT_ODST
5707 ENUMX
5708 BFD_RELOC_MSP430X_ABS20_EXT_SRC
5709 ENUMX
5710 BFD_RELOC_MSP430X_ABS20_EXT_DST
5711 ENUMX
5712 BFD_RELOC_MSP430X_ABS20_EXT_ODST
5713 ENUMX
5714 BFD_RELOC_MSP430X_ABS20_ADR_SRC
5715 ENUMX
5716 BFD_RELOC_MSP430X_ABS20_ADR_DST
5717 ENUMX
5718 BFD_RELOC_MSP430X_PCR16
5719 ENUMX
5720 BFD_RELOC_MSP430X_PCR20_CALL
5721 ENUMX
5722 BFD_RELOC_MSP430X_ABS16
5723 ENUMX
5724 BFD_RELOC_MSP430_ABS_HI16
5725 ENUMX
5726 BFD_RELOC_MSP430_PREL31
5727 ENUMX
5728 BFD_RELOC_MSP430_SYM_DIFF
5729 ENUMDOC
5730 msp430 specific relocation codes
5731
5732 ENUM
5733 BFD_RELOC_NIOS2_S16
5734 ENUMX
5735 BFD_RELOC_NIOS2_U16
5736 ENUMX
5737 BFD_RELOC_NIOS2_CALL26
5738 ENUMX
5739 BFD_RELOC_NIOS2_IMM5
5740 ENUMX
5741 BFD_RELOC_NIOS2_CACHE_OPX
5742 ENUMX
5743 BFD_RELOC_NIOS2_IMM6
5744 ENUMX
5745 BFD_RELOC_NIOS2_IMM8
5746 ENUMX
5747 BFD_RELOC_NIOS2_HI16
5748 ENUMX
5749 BFD_RELOC_NIOS2_LO16
5750 ENUMX
5751 BFD_RELOC_NIOS2_HIADJ16
5752 ENUMX
5753 BFD_RELOC_NIOS2_GPREL
5754 ENUMX
5755 BFD_RELOC_NIOS2_UJMP
5756 ENUMX
5757 BFD_RELOC_NIOS2_CJMP
5758 ENUMX
5759 BFD_RELOC_NIOS2_CALLR
5760 ENUMX
5761 BFD_RELOC_NIOS2_ALIGN
5762 ENUMX
5763 BFD_RELOC_NIOS2_GOT16
5764 ENUMX
5765 BFD_RELOC_NIOS2_CALL16
5766 ENUMX
5767 BFD_RELOC_NIOS2_GOTOFF_LO
5768 ENUMX
5769 BFD_RELOC_NIOS2_GOTOFF_HA
5770 ENUMX
5771 BFD_RELOC_NIOS2_PCREL_LO
5772 ENUMX
5773 BFD_RELOC_NIOS2_PCREL_HA
5774 ENUMX
5775 BFD_RELOC_NIOS2_TLS_GD16
5776 ENUMX
5777 BFD_RELOC_NIOS2_TLS_LDM16
5778 ENUMX
5779 BFD_RELOC_NIOS2_TLS_LDO16
5780 ENUMX
5781 BFD_RELOC_NIOS2_TLS_IE16
5782 ENUMX
5783 BFD_RELOC_NIOS2_TLS_LE16
5784 ENUMX
5785 BFD_RELOC_NIOS2_TLS_DTPMOD
5786 ENUMX
5787 BFD_RELOC_NIOS2_TLS_DTPREL
5788 ENUMX
5789 BFD_RELOC_NIOS2_TLS_TPREL
5790 ENUMX
5791 BFD_RELOC_NIOS2_COPY
5792 ENUMX
5793 BFD_RELOC_NIOS2_GLOB_DAT
5794 ENUMX
5795 BFD_RELOC_NIOS2_JUMP_SLOT
5796 ENUMX
5797 BFD_RELOC_NIOS2_RELATIVE
5798 ENUMX
5799 BFD_RELOC_NIOS2_GOTOFF
5800 ENUMDOC
5801 Relocations used by the Altera Nios II core.
5802
5803 ENUM
5804 BFD_RELOC_IQ2000_OFFSET_16
5805 ENUMX
5806 BFD_RELOC_IQ2000_OFFSET_21
5807 ENUMX
5808 BFD_RELOC_IQ2000_UHI16
5809 ENUMDOC
5810 IQ2000 Relocations.
5811
5812 ENUM
5813 BFD_RELOC_XTENSA_RTLD
5814 ENUMDOC
5815 Special Xtensa relocation used only by PLT entries in ELF shared
5816 objects to indicate that the runtime linker should set the value
5817 to one of its own internal functions or data structures.
5818 ENUM
5819 BFD_RELOC_XTENSA_GLOB_DAT
5820 ENUMX
5821 BFD_RELOC_XTENSA_JMP_SLOT
5822 ENUMX
5823 BFD_RELOC_XTENSA_RELATIVE
5824 ENUMDOC
5825 Xtensa relocations for ELF shared objects.
5826 ENUM
5827 BFD_RELOC_XTENSA_PLT
5828 ENUMDOC
5829 Xtensa relocation used in ELF object files for symbols that may require
5830 PLT entries. Otherwise, this is just a generic 32-bit relocation.
5831 ENUM
5832 BFD_RELOC_XTENSA_DIFF8
5833 ENUMX
5834 BFD_RELOC_XTENSA_DIFF16
5835 ENUMX
5836 BFD_RELOC_XTENSA_DIFF32
5837 ENUMDOC
5838 Xtensa relocations to mark the difference of two local symbols.
5839 These are only needed to support linker relaxation and can be ignored
5840 when not relaxing. The field is set to the value of the difference
5841 assuming no relaxation. The relocation encodes the position of the
5842 first symbol so the linker can determine whether to adjust the field
5843 value.
5844 ENUM
5845 BFD_RELOC_XTENSA_SLOT0_OP
5846 ENUMX
5847 BFD_RELOC_XTENSA_SLOT1_OP
5848 ENUMX
5849 BFD_RELOC_XTENSA_SLOT2_OP
5850 ENUMX
5851 BFD_RELOC_XTENSA_SLOT3_OP
5852 ENUMX
5853 BFD_RELOC_XTENSA_SLOT4_OP
5854 ENUMX
5855 BFD_RELOC_XTENSA_SLOT5_OP
5856 ENUMX
5857 BFD_RELOC_XTENSA_SLOT6_OP
5858 ENUMX
5859 BFD_RELOC_XTENSA_SLOT7_OP
5860 ENUMX
5861 BFD_RELOC_XTENSA_SLOT8_OP
5862 ENUMX
5863 BFD_RELOC_XTENSA_SLOT9_OP
5864 ENUMX
5865 BFD_RELOC_XTENSA_SLOT10_OP
5866 ENUMX
5867 BFD_RELOC_XTENSA_SLOT11_OP
5868 ENUMX
5869 BFD_RELOC_XTENSA_SLOT12_OP
5870 ENUMX
5871 BFD_RELOC_XTENSA_SLOT13_OP
5872 ENUMX
5873 BFD_RELOC_XTENSA_SLOT14_OP
5874 ENUMDOC
5875 Generic Xtensa relocations for instruction operands. Only the slot
5876 number is encoded in the relocation. The relocation applies to the
5877 last PC-relative immediate operand, or if there are no PC-relative
5878 immediates, to the last immediate operand.
5879 ENUM
5880 BFD_RELOC_XTENSA_SLOT0_ALT
5881 ENUMX
5882 BFD_RELOC_XTENSA_SLOT1_ALT
5883 ENUMX
5884 BFD_RELOC_XTENSA_SLOT2_ALT
5885 ENUMX
5886 BFD_RELOC_XTENSA_SLOT3_ALT
5887 ENUMX
5888 BFD_RELOC_XTENSA_SLOT4_ALT
5889 ENUMX
5890 BFD_RELOC_XTENSA_SLOT5_ALT
5891 ENUMX
5892 BFD_RELOC_XTENSA_SLOT6_ALT
5893 ENUMX
5894 BFD_RELOC_XTENSA_SLOT7_ALT
5895 ENUMX
5896 BFD_RELOC_XTENSA_SLOT8_ALT
5897 ENUMX
5898 BFD_RELOC_XTENSA_SLOT9_ALT
5899 ENUMX
5900 BFD_RELOC_XTENSA_SLOT10_ALT
5901 ENUMX
5902 BFD_RELOC_XTENSA_SLOT11_ALT
5903 ENUMX
5904 BFD_RELOC_XTENSA_SLOT12_ALT
5905 ENUMX
5906 BFD_RELOC_XTENSA_SLOT13_ALT
5907 ENUMX
5908 BFD_RELOC_XTENSA_SLOT14_ALT
5909 ENUMDOC
5910 Alternate Xtensa relocations. Only the slot is encoded in the
5911 relocation. The meaning of these relocations is opcode-specific.
5912 ENUM
5913 BFD_RELOC_XTENSA_OP0
5914 ENUMX
5915 BFD_RELOC_XTENSA_OP1
5916 ENUMX
5917 BFD_RELOC_XTENSA_OP2
5918 ENUMDOC
5919 Xtensa relocations for backward compatibility. These have all been
5920 replaced by BFD_RELOC_XTENSA_SLOT0_OP.
5921 ENUM
5922 BFD_RELOC_XTENSA_ASM_EXPAND
5923 ENUMDOC
5924 Xtensa relocation to mark that the assembler expanded the
5925 instructions from an original target. The expansion size is
5926 encoded in the reloc size.
5927 ENUM
5928 BFD_RELOC_XTENSA_ASM_SIMPLIFY
5929 ENUMDOC
5930 Xtensa relocation to mark that the linker should simplify
5931 assembler-expanded instructions. This is commonly used
5932 internally by the linker after analysis of a
5933 BFD_RELOC_XTENSA_ASM_EXPAND.
5934 ENUM
5935 BFD_RELOC_XTENSA_TLSDESC_FN
5936 ENUMX
5937 BFD_RELOC_XTENSA_TLSDESC_ARG
5938 ENUMX
5939 BFD_RELOC_XTENSA_TLS_DTPOFF
5940 ENUMX
5941 BFD_RELOC_XTENSA_TLS_TPOFF
5942 ENUMX
5943 BFD_RELOC_XTENSA_TLS_FUNC
5944 ENUMX
5945 BFD_RELOC_XTENSA_TLS_ARG
5946 ENUMX
5947 BFD_RELOC_XTENSA_TLS_CALL
5948 ENUMDOC
5949 Xtensa TLS relocations.
5950
5951 ENUM
5952 BFD_RELOC_Z80_DISP8
5953 ENUMDOC
5954 8 bit signed offset in (ix+d) or (iy+d).
5955
5956 ENUM
5957 BFD_RELOC_Z8K_DISP7
5958 ENUMDOC
5959 DJNZ offset.
5960 ENUM
5961 BFD_RELOC_Z8K_CALLR
5962 ENUMDOC
5963 CALR offset.
5964 ENUM
5965 BFD_RELOC_Z8K_IMM4L
5966 ENUMDOC
5967 4 bit value.
5968
5969 ENUM
5970 BFD_RELOC_LM32_CALL
5971 ENUMX
5972 BFD_RELOC_LM32_BRANCH
5973 ENUMX
5974 BFD_RELOC_LM32_16_GOT
5975 ENUMX
5976 BFD_RELOC_LM32_GOTOFF_HI16
5977 ENUMX
5978 BFD_RELOC_LM32_GOTOFF_LO16
5979 ENUMX
5980 BFD_RELOC_LM32_COPY
5981 ENUMX
5982 BFD_RELOC_LM32_GLOB_DAT
5983 ENUMX
5984 BFD_RELOC_LM32_JMP_SLOT
5985 ENUMX
5986 BFD_RELOC_LM32_RELATIVE
5987 ENUMDOC
5988 Lattice Mico32 relocations.
5989
5990 ENUM
5991 BFD_RELOC_MACH_O_SECTDIFF
5992 ENUMDOC
5993 Difference between two section addreses. Must be followed by a
5994 BFD_RELOC_MACH_O_PAIR.
5995 ENUM
5996 BFD_RELOC_MACH_O_LOCAL_SECTDIFF
5997 ENUMDOC
5998 Like BFD_RELOC_MACH_O_SECTDIFF but with a local symbol.
5999 ENUM
6000 BFD_RELOC_MACH_O_PAIR
6001 ENUMDOC
6002 Pair of relocation. Contains the first symbol.
6003
6004 ENUM
6005 BFD_RELOC_MACH_O_X86_64_BRANCH32
6006 ENUMX
6007 BFD_RELOC_MACH_O_X86_64_BRANCH8
6008 ENUMDOC
6009 PCREL relocations. They are marked as branch to create PLT entry if
6010 required.
6011 ENUM
6012 BFD_RELOC_MACH_O_X86_64_GOT
6013 ENUMDOC
6014 Used when referencing a GOT entry.
6015 ENUM
6016 BFD_RELOC_MACH_O_X86_64_GOT_LOAD
6017 ENUMDOC
6018 Used when loading a GOT entry with movq. It is specially marked so that
6019 the linker could optimize the movq to a leaq if possible.
6020 ENUM
6021 BFD_RELOC_MACH_O_X86_64_SUBTRACTOR32
6022 ENUMDOC
6023 Symbol will be substracted. Must be followed by a BFD_RELOC_64.
6024 ENUM
6025 BFD_RELOC_MACH_O_X86_64_SUBTRACTOR64
6026 ENUMDOC
6027 Symbol will be substracted. Must be followed by a BFD_RELOC_64.
6028 ENUM
6029 BFD_RELOC_MACH_O_X86_64_PCREL32_1
6030 ENUMDOC
6031 Same as BFD_RELOC_32_PCREL but with an implicit -1 addend.
6032 ENUM
6033 BFD_RELOC_MACH_O_X86_64_PCREL32_2
6034 ENUMDOC
6035 Same as BFD_RELOC_32_PCREL but with an implicit -2 addend.
6036 ENUM
6037 BFD_RELOC_MACH_O_X86_64_PCREL32_4
6038 ENUMDOC
6039 Same as BFD_RELOC_32_PCREL but with an implicit -4 addend.
6040
6041 ENUM
6042 BFD_RELOC_MICROBLAZE_32_LO
6043 ENUMDOC
6044 This is a 32 bit reloc for the microblaze that stores the
6045 low 16 bits of a value
6046 ENUM
6047 BFD_RELOC_MICROBLAZE_32_LO_PCREL
6048 ENUMDOC
6049 This is a 32 bit pc-relative reloc for the microblaze that
6050 stores the low 16 bits of a value
6051 ENUM
6052 BFD_RELOC_MICROBLAZE_32_ROSDA
6053 ENUMDOC
6054 This is a 32 bit reloc for the microblaze that stores a
6055 value relative to the read-only small data area anchor
6056 ENUM
6057 BFD_RELOC_MICROBLAZE_32_RWSDA
6058 ENUMDOC
6059 This is a 32 bit reloc for the microblaze that stores a
6060 value relative to the read-write small data area anchor
6061 ENUM
6062 BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM
6063 ENUMDOC
6064 This is a 32 bit reloc for the microblaze to handle
6065 expressions of the form "Symbol Op Symbol"
6066 ENUM
6067 BFD_RELOC_MICROBLAZE_64_NONE
6068 ENUMDOC
6069 This is a 64 bit reloc that stores the 32 bit pc relative
6070 value in two words (with an imm instruction). No relocation is
6071 done here - only used for relaxing
6072 ENUM
6073 BFD_RELOC_MICROBLAZE_64_GOTPC
6074 ENUMDOC
6075 This is a 64 bit reloc that stores the 32 bit pc relative
6076 value in two words (with an imm instruction). The relocation is
6077 PC-relative GOT offset
6078 ENUM
6079 BFD_RELOC_MICROBLAZE_64_GOT
6080 ENUMDOC
6081 This is a 64 bit reloc that stores the 32 bit pc relative
6082 value in two words (with an imm instruction). The relocation is
6083 GOT offset
6084 ENUM
6085 BFD_RELOC_MICROBLAZE_64_PLT
6086 ENUMDOC
6087 This is a 64 bit reloc that stores the 32 bit pc relative
6088 value in two words (with an imm instruction). The relocation is
6089 PC-relative offset into PLT
6090 ENUM
6091 BFD_RELOC_MICROBLAZE_64_GOTOFF
6092 ENUMDOC
6093 This is a 64 bit reloc that stores the 32 bit GOT relative
6094 value in two words (with an imm instruction). The relocation is
6095 relative offset from _GLOBAL_OFFSET_TABLE_
6096 ENUM
6097 BFD_RELOC_MICROBLAZE_32_GOTOFF
6098 ENUMDOC
6099 This is a 32 bit reloc that stores the 32 bit GOT relative
6100 value in a word. The relocation is relative offset from
6101 _GLOBAL_OFFSET_TABLE_
6102 ENUM
6103 BFD_RELOC_MICROBLAZE_COPY
6104 ENUMDOC
6105 This is used to tell the dynamic linker to copy the value out of
6106 the dynamic object into the runtime process image.
6107 ENUM
6108 BFD_RELOC_MICROBLAZE_64_TLS
6109 ENUMDOC
6110 Unused Reloc
6111 ENUM
6112 BFD_RELOC_MICROBLAZE_64_TLSGD
6113 ENUMDOC
6114 This is a 64 bit reloc that stores the 32 bit GOT relative value
6115 of the GOT TLS GD info entry in two words (with an imm instruction). The
6116 relocation is GOT offset.
6117 ENUM
6118 BFD_RELOC_MICROBLAZE_64_TLSLD
6119 ENUMDOC
6120 This is a 64 bit reloc that stores the 32 bit GOT relative value
6121 of the GOT TLS LD info entry in two words (with an imm instruction). The
6122 relocation is GOT offset.
6123 ENUM
6124 BFD_RELOC_MICROBLAZE_32_TLSDTPMOD
6125 ENUMDOC
6126 This is a 32 bit reloc that stores the Module ID to GOT(n).
6127 ENUM
6128 BFD_RELOC_MICROBLAZE_32_TLSDTPREL
6129 ENUMDOC
6130 This is a 32 bit reloc that stores TLS offset to GOT(n+1).
6131 ENUM
6132 BFD_RELOC_MICROBLAZE_64_TLSDTPREL
6133 ENUMDOC
6134 This is a 32 bit reloc for storing TLS offset to two words (uses imm
6135 instruction)
6136 ENUM
6137 BFD_RELOC_MICROBLAZE_64_TLSGOTTPREL
6138 ENUMDOC
6139 This is a 64 bit reloc that stores 32-bit thread pointer relative offset
6140 to two words (uses imm instruction).
6141 ENUM
6142 BFD_RELOC_MICROBLAZE_64_TLSTPREL
6143 ENUMDOC
6144 This is a 64 bit reloc that stores 32-bit thread pointer relative offset
6145 to two words (uses imm instruction).
6146
6147 ENUM
6148 BFD_RELOC_AARCH64_RELOC_START
6149 ENUMDOC
6150 AArch64 pseudo relocation code to mark the start of the AArch64
6151 relocation enumerators. N.B. the order of the enumerators is
6152 important as several tables in the AArch64 bfd backend are indexed
6153 by these enumerators; make sure they are all synced.
6154 ENUM
6155 BFD_RELOC_AARCH64_NONE
6156 ENUMDOC
6157 AArch64 null relocation code.
6158 ENUM
6159 BFD_RELOC_AARCH64_64
6160 ENUMX
6161 BFD_RELOC_AARCH64_32
6162 ENUMX
6163 BFD_RELOC_AARCH64_16
6164 ENUMDOC
6165 Basic absolute relocations of N bits. These are equivalent to
6166 BFD_RELOC_N and they were added to assist the indexing of the howto
6167 table.
6168 ENUM
6169 BFD_RELOC_AARCH64_64_PCREL
6170 ENUMX
6171 BFD_RELOC_AARCH64_32_PCREL
6172 ENUMX
6173 BFD_RELOC_AARCH64_16_PCREL
6174 ENUMDOC
6175 PC-relative relocations. These are equivalent to BFD_RELOC_N_PCREL
6176 and they were added to assist the indexing of the howto table.
6177 ENUM
6178 BFD_RELOC_AARCH64_MOVW_G0
6179 ENUMDOC
6180 AArch64 MOV[NZK] instruction with most significant bits 0 to 15
6181 of an unsigned address/value.
6182 ENUM
6183 BFD_RELOC_AARCH64_MOVW_G0_NC
6184 ENUMDOC
6185 AArch64 MOV[NZK] instruction with less significant bits 0 to 15 of
6186 an address/value. No overflow checking.
6187 ENUM
6188 BFD_RELOC_AARCH64_MOVW_G1
6189 ENUMDOC
6190 AArch64 MOV[NZK] instruction with most significant bits 16 to 31
6191 of an unsigned address/value.
6192 ENUM
6193 BFD_RELOC_AARCH64_MOVW_G1_NC
6194 ENUMDOC
6195 AArch64 MOV[NZK] instruction with less significant bits 16 to 31
6196 of an address/value. No overflow checking.
6197 ENUM
6198 BFD_RELOC_AARCH64_MOVW_G2
6199 ENUMDOC
6200 AArch64 MOV[NZK] instruction with most significant bits 32 to 47
6201 of an unsigned address/value.
6202 ENUM
6203 BFD_RELOC_AARCH64_MOVW_G2_NC
6204 ENUMDOC
6205 AArch64 MOV[NZK] instruction with less significant bits 32 to 47
6206 of an address/value. No overflow checking.
6207 ENUM
6208 BFD_RELOC_AARCH64_MOVW_G3
6209 ENUMDOC
6210 AArch64 MOV[NZK] instruction with most signficant bits 48 to 64
6211 of a signed or unsigned address/value.
6212 ENUM
6213 BFD_RELOC_AARCH64_MOVW_G0_S
6214 ENUMDOC
6215 AArch64 MOV[NZ] instruction with most significant bits 0 to 15
6216 of a signed value. Changes instruction to MOVZ or MOVN depending on the
6217 value's sign.
6218 ENUM
6219 BFD_RELOC_AARCH64_MOVW_G1_S
6220 ENUMDOC
6221 AArch64 MOV[NZ] instruction with most significant bits 16 to 31
6222 of a signed value. Changes instruction to MOVZ or MOVN depending on the
6223 value's sign.
6224 ENUM
6225 BFD_RELOC_AARCH64_MOVW_G2_S
6226 ENUMDOC
6227 AArch64 MOV[NZ] instruction with most significant bits 32 to 47
6228 of a signed value. Changes instruction to MOVZ or MOVN depending on the
6229 value's sign.
6230 ENUM
6231 BFD_RELOC_AARCH64_LD_LO19_PCREL
6232 ENUMDOC
6233 AArch64 Load Literal instruction, holding a 19 bit pc-relative word
6234 offset. The lowest two bits must be zero and are not stored in the
6235 instruction, giving a 21 bit signed byte offset.
6236 ENUM
6237 BFD_RELOC_AARCH64_ADR_LO21_PCREL
6238 ENUMDOC
6239 AArch64 ADR instruction, holding a simple 21 bit pc-relative byte offset.
6240 ENUM
6241 BFD_RELOC_AARCH64_ADR_HI21_PCREL
6242 ENUMDOC
6243 AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page
6244 offset, giving a 4KB aligned page base address.
6245 ENUM
6246 BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL
6247 ENUMDOC
6248 AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page
6249 offset, giving a 4KB aligned page base address, but with no overflow
6250 checking.
6251 ENUM
6252 BFD_RELOC_AARCH64_ADD_LO12
6253 ENUMDOC
6254 AArch64 ADD immediate instruction, holding bits 0 to 11 of the address.
6255 Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6256 ENUM
6257 BFD_RELOC_AARCH64_LDST8_LO12
6258 ENUMDOC
6259 AArch64 8-bit load/store instruction, holding bits 0 to 11 of the
6260 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6261 ENUM
6262 BFD_RELOC_AARCH64_TSTBR14
6263 ENUMDOC
6264 AArch64 14 bit pc-relative test bit and branch.
6265 The lowest two bits must be zero and are not stored in the instruction,
6266 giving a 16 bit signed byte offset.
6267 ENUM
6268 BFD_RELOC_AARCH64_BRANCH19
6269 ENUMDOC
6270 AArch64 19 bit pc-relative conditional branch and compare & branch.
6271 The lowest two bits must be zero and are not stored in the instruction,
6272 giving a 21 bit signed byte offset.
6273 ENUM
6274 BFD_RELOC_AARCH64_JUMP26
6275 ENUMDOC
6276 AArch64 26 bit pc-relative unconditional branch.
6277 The lowest two bits must be zero and are not stored in the instruction,
6278 giving a 28 bit signed byte offset.
6279 ENUM
6280 BFD_RELOC_AARCH64_CALL26
6281 ENUMDOC
6282 AArch64 26 bit pc-relative unconditional branch and link.
6283 The lowest two bits must be zero and are not stored in the instruction,
6284 giving a 28 bit signed byte offset.
6285 ENUM
6286 BFD_RELOC_AARCH64_LDST16_LO12
6287 ENUMDOC
6288 AArch64 16-bit load/store instruction, holding bits 0 to 11 of the
6289 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6290 ENUM
6291 BFD_RELOC_AARCH64_LDST32_LO12
6292 ENUMDOC
6293 AArch64 32-bit load/store instruction, holding bits 0 to 11 of the
6294 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6295 ENUM
6296 BFD_RELOC_AARCH64_LDST64_LO12
6297 ENUMDOC
6298 AArch64 64-bit load/store instruction, holding bits 0 to 11 of the
6299 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6300 ENUM
6301 BFD_RELOC_AARCH64_LDST128_LO12
6302 ENUMDOC
6303 AArch64 128-bit load/store instruction, holding bits 0 to 11 of the
6304 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6305 ENUM
6306 BFD_RELOC_AARCH64_GOT_LD_PREL19
6307 ENUMDOC
6308 AArch64 Load Literal instruction, holding a 19 bit PC relative word
6309 offset of the global offset table entry for a symbol. The lowest two
6310 bits must be zero and are not stored in the instruction, giving a 21
6311 bit signed byte offset. This relocation type requires signed overflow
6312 checking.
6313 ENUM
6314 BFD_RELOC_AARCH64_ADR_GOT_PAGE
6315 ENUMDOC
6316 Get to the page base of the global offset table entry for a symbol as
6317 part of an ADRP instruction using a 21 bit PC relative value.Used in
6318 conjunction with BFD_RELOC_AARCH64_LD64_GOT_LO12_NC.
6319 ENUM
6320 BFD_RELOC_AARCH64_LD64_GOT_LO12_NC
6321 ENUMDOC
6322 Unsigned 12 bit byte offset for 64 bit load/store from the page of
6323 the GOT entry for this symbol. Used in conjunction with
6324 BFD_RELOC_AARCH64_ADR_GOTPAGE. Valid in LP64 ABI only.
6325 ENUM
6326 BFD_RELOC_AARCH64_LD32_GOT_LO12_NC
6327 ENUMDOC
6328 Unsigned 12 bit byte offset for 32 bit load/store from the page of
6329 the GOT entry for this symbol. Used in conjunction with
6330 BFD_RELOC_AARCH64_ADR_GOTPAGE. Valid in ILP32 ABI only.
6331 ENUM
6332 BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21
6333 ENUMDOC
6334 Get to the page base of the global offset table entry for a symbols
6335 tls_index structure as part of an adrp instruction using a 21 bit PC
6336 relative value. Used in conjunction with
6337 BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC.
6338 ENUM
6339 BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC
6340 ENUMDOC
6341 Unsigned 12 bit byte offset to global offset table entry for a symbols
6342 tls_index structure. Used in conjunction with
6343 BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21.
6344 ENUM
6345 BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1
6346 ENUMDOC
6347 AArch64 TLS INITIAL EXEC relocation.
6348 ENUM
6349 BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC
6350 ENUMDOC
6351 AArch64 TLS INITIAL EXEC relocation.
6352 ENUM
6353 BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21
6354 ENUMDOC
6355 AArch64 TLS INITIAL EXEC relocation.
6356 ENUM
6357 BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC
6358 ENUMDOC
6359 AArch64 TLS INITIAL EXEC relocation.
6360 ENUM
6361 BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC
6362 ENUMDOC
6363 AArch64 TLS INITIAL EXEC relocation.
6364 ENUM
6365 BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19
6366 ENUMDOC
6367 AArch64 TLS INITIAL EXEC relocation.
6368 ENUM
6369 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2
6370 ENUMDOC
6371 AArch64 TLS LOCAL EXEC relocation.
6372 ENUM
6373 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1
6374 ENUMDOC
6375 AArch64 TLS LOCAL EXEC relocation.
6376 ENUM
6377 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC
6378 ENUMDOC
6379 AArch64 TLS LOCAL EXEC relocation.
6380 ENUM
6381 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0
6382 ENUMDOC
6383 AArch64 TLS LOCAL EXEC relocation.
6384 ENUM
6385 BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC
6386 ENUMDOC
6387 AArch64 TLS LOCAL EXEC relocation.
6388 ENUM
6389 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12
6390 ENUMDOC
6391 AArch64 TLS LOCAL EXEC relocation.
6392 ENUM
6393 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12
6394 ENUMDOC
6395 AArch64 TLS LOCAL EXEC relocation.
6396 ENUM
6397 BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC
6398 ENUMDOC
6399 AArch64 TLS LOCAL EXEC relocation.
6400 ENUM
6401 BFD_RELOC_AARCH64_TLSDESC_LD_PREL19
6402 ENUMDOC
6403 AArch64 TLS DESC relocation.
6404 ENUM
6405 BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21
6406 ENUMDOC
6407 AArch64 TLS DESC relocation.
6408 ENUM
6409 BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21
6410 ENUMDOC
6411 AArch64 TLS DESC relocation.
6412 ENUM
6413 BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC
6414 ENUMDOC
6415 AArch64 TLS DESC relocation.
6416 ENUM
6417 BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC
6418 ENUMDOC
6419 AArch64 TLS DESC relocation.
6420 ENUM
6421 BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC
6422 ENUMDOC
6423 AArch64 TLS DESC relocation.
6424 ENUM
6425 BFD_RELOC_AARCH64_TLSDESC_OFF_G1
6426 ENUMDOC
6427 AArch64 TLS DESC relocation.
6428 ENUM
6429 BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC
6430 ENUMDOC
6431 AArch64 TLS DESC relocation.
6432 ENUM
6433 BFD_RELOC_AARCH64_TLSDESC_LDR
6434 ENUMDOC
6435 AArch64 TLS DESC relocation.
6436 ENUM
6437 BFD_RELOC_AARCH64_TLSDESC_ADD
6438 ENUMDOC
6439 AArch64 TLS DESC relocation.
6440 ENUM
6441 BFD_RELOC_AARCH64_TLSDESC_CALL
6442 ENUMDOC
6443 AArch64 TLS DESC relocation.
6444 ENUM
6445 BFD_RELOC_AARCH64_COPY
6446 ENUMDOC
6447 AArch64 TLS relocation.
6448 ENUM
6449 BFD_RELOC_AARCH64_GLOB_DAT
6450 ENUMDOC
6451 AArch64 TLS relocation.
6452 ENUM
6453 BFD_RELOC_AARCH64_JUMP_SLOT
6454 ENUMDOC
6455 AArch64 TLS relocation.
6456 ENUM
6457 BFD_RELOC_AARCH64_RELATIVE
6458 ENUMDOC
6459 AArch64 TLS relocation.
6460 ENUM
6461 BFD_RELOC_AARCH64_TLS_DTPMOD
6462 ENUMDOC
6463 AArch64 TLS relocation.
6464 ENUM
6465 BFD_RELOC_AARCH64_TLS_DTPREL
6466 ENUMDOC
6467 AArch64 TLS relocation.
6468 ENUM
6469 BFD_RELOC_AARCH64_TLS_TPREL
6470 ENUMDOC
6471 AArch64 TLS relocation.
6472 ENUM
6473 BFD_RELOC_AARCH64_TLSDESC
6474 ENUMDOC
6475 AArch64 TLS relocation.
6476 ENUM
6477 BFD_RELOC_AARCH64_IRELATIVE
6478 ENUMDOC
6479 AArch64 support for STT_GNU_IFUNC.
6480 ENUM
6481 BFD_RELOC_AARCH64_RELOC_END
6482 ENUMDOC
6483 AArch64 pseudo relocation code to mark the end of the AArch64
6484 relocation enumerators that have direct mapping to ELF reloc codes.
6485 There are a few more enumerators after this one; those are mainly
6486 used by the AArch64 assembler for the internal fixup or to select
6487 one of the above enumerators.
6488 ENUM
6489 BFD_RELOC_AARCH64_GAS_INTERNAL_FIXUP
6490 ENUMDOC
6491 AArch64 pseudo relocation code to be used internally by the AArch64
6492 assembler and not (currently) written to any object files.
6493 ENUM
6494 BFD_RELOC_AARCH64_LDST_LO12
6495 ENUMDOC
6496 AArch64 unspecified load/store instruction, holding bits 0 to 11 of the
6497 address. Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6498 ENUM
6499 BFD_RELOC_AARCH64_LD_GOT_LO12_NC
6500 ENUMDOC
6501 AArch64 pseudo relocation code to be used internally by the AArch64
6502 assembler and not (currently) written to any object files.
6503 ENUM
6504 BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_LO12_NC
6505 ENUMDOC
6506 AArch64 pseudo relocation code to be used internally by the AArch64
6507 assembler and not (currently) written to any object files.
6508 ENUM
6509 BFD_RELOC_AARCH64_TLSDESC_LD_LO12_NC
6510 ENUMDOC
6511 AArch64 pseudo relocation code to be used internally by the AArch64
6512 assembler and not (currently) written to any object files.
6513
6514 ENUM
6515 BFD_RELOC_TILEPRO_COPY
6516 ENUMX
6517 BFD_RELOC_TILEPRO_GLOB_DAT
6518 ENUMX
6519 BFD_RELOC_TILEPRO_JMP_SLOT
6520 ENUMX
6521 BFD_RELOC_TILEPRO_RELATIVE
6522 ENUMX
6523 BFD_RELOC_TILEPRO_BROFF_X1
6524 ENUMX
6525 BFD_RELOC_TILEPRO_JOFFLONG_X1
6526 ENUMX
6527 BFD_RELOC_TILEPRO_JOFFLONG_X1_PLT
6528 ENUMX
6529 BFD_RELOC_TILEPRO_IMM8_X0
6530 ENUMX
6531 BFD_RELOC_TILEPRO_IMM8_Y0
6532 ENUMX
6533 BFD_RELOC_TILEPRO_IMM8_X1
6534 ENUMX
6535 BFD_RELOC_TILEPRO_IMM8_Y1
6536 ENUMX
6537 BFD_RELOC_TILEPRO_DEST_IMM8_X1
6538 ENUMX
6539 BFD_RELOC_TILEPRO_MT_IMM15_X1
6540 ENUMX
6541 BFD_RELOC_TILEPRO_MF_IMM15_X1
6542 ENUMX
6543 BFD_RELOC_TILEPRO_IMM16_X0
6544 ENUMX
6545 BFD_RELOC_TILEPRO_IMM16_X1
6546 ENUMX
6547 BFD_RELOC_TILEPRO_IMM16_X0_LO
6548 ENUMX
6549 BFD_RELOC_TILEPRO_IMM16_X1_LO
6550 ENUMX
6551 BFD_RELOC_TILEPRO_IMM16_X0_HI
6552 ENUMX
6553 BFD_RELOC_TILEPRO_IMM16_X1_HI
6554 ENUMX
6555 BFD_RELOC_TILEPRO_IMM16_X0_HA
6556 ENUMX
6557 BFD_RELOC_TILEPRO_IMM16_X1_HA
6558 ENUMX
6559 BFD_RELOC_TILEPRO_IMM16_X0_PCREL
6560 ENUMX
6561 BFD_RELOC_TILEPRO_IMM16_X1_PCREL
6562 ENUMX
6563 BFD_RELOC_TILEPRO_IMM16_X0_LO_PCREL
6564 ENUMX
6565 BFD_RELOC_TILEPRO_IMM16_X1_LO_PCREL
6566 ENUMX
6567 BFD_RELOC_TILEPRO_IMM16_X0_HI_PCREL
6568 ENUMX
6569 BFD_RELOC_TILEPRO_IMM16_X1_HI_PCREL
6570 ENUMX
6571 BFD_RELOC_TILEPRO_IMM16_X0_HA_PCREL
6572 ENUMX
6573 BFD_RELOC_TILEPRO_IMM16_X1_HA_PCREL
6574 ENUMX
6575 BFD_RELOC_TILEPRO_IMM16_X0_GOT
6576 ENUMX
6577 BFD_RELOC_TILEPRO_IMM16_X1_GOT
6578 ENUMX
6579 BFD_RELOC_TILEPRO_IMM16_X0_GOT_LO
6580 ENUMX
6581 BFD_RELOC_TILEPRO_IMM16_X1_GOT_LO
6582 ENUMX
6583 BFD_RELOC_TILEPRO_IMM16_X0_GOT_HI
6584 ENUMX
6585 BFD_RELOC_TILEPRO_IMM16_X1_GOT_HI
6586 ENUMX
6587 BFD_RELOC_TILEPRO_IMM16_X0_GOT_HA
6588 ENUMX
6589 BFD_RELOC_TILEPRO_IMM16_X1_GOT_HA
6590 ENUMX
6591 BFD_RELOC_TILEPRO_MMSTART_X0
6592 ENUMX
6593 BFD_RELOC_TILEPRO_MMEND_X0
6594 ENUMX
6595 BFD_RELOC_TILEPRO_MMSTART_X1
6596 ENUMX
6597 BFD_RELOC_TILEPRO_MMEND_X1
6598 ENUMX
6599 BFD_RELOC_TILEPRO_SHAMT_X0
6600 ENUMX
6601 BFD_RELOC_TILEPRO_SHAMT_X1
6602 ENUMX
6603 BFD_RELOC_TILEPRO_SHAMT_Y0
6604 ENUMX
6605 BFD_RELOC_TILEPRO_SHAMT_Y1
6606 ENUMX
6607 BFD_RELOC_TILEPRO_TLS_GD_CALL
6608 ENUMX
6609 BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD
6610 ENUMX
6611 BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD
6612 ENUMX
6613 BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD
6614 ENUMX
6615 BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD
6616 ENUMX
6617 BFD_RELOC_TILEPRO_TLS_IE_LOAD
6618 ENUMX
6619 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD
6620 ENUMX
6621 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD
6622 ENUMX
6623 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO
6624 ENUMX
6625 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_LO
6626 ENUMX
6627 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HI
6628 ENUMX
6629 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HI
6630 ENUMX
6631 BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HA
6632 ENUMX
6633 BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HA
6634 ENUMX
6635 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE
6636 ENUMX
6637 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE
6638 ENUMX
6639 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_LO
6640 ENUMX
6641 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_LO
6642 ENUMX
6643 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HI
6644 ENUMX
6645 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HI
6646 ENUMX
6647 BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HA
6648 ENUMX
6649 BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HA
6650 ENUMX
6651 BFD_RELOC_TILEPRO_TLS_DTPMOD32
6652 ENUMX
6653 BFD_RELOC_TILEPRO_TLS_DTPOFF32
6654 ENUMX
6655 BFD_RELOC_TILEPRO_TLS_TPOFF32
6656 ENUMX
6657 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE
6658 ENUMX
6659 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE
6660 ENUMX
6661 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_LO
6662 ENUMX
6663 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_LO
6664 ENUMX
6665 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HI
6666 ENUMX
6667 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HI
6668 ENUMX
6669 BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HA
6670 ENUMX
6671 BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HA
6672 ENUMDOC
6673 Tilera TILEPro Relocations.
6674 ENUM
6675 BFD_RELOC_TILEGX_HW0
6676 ENUMX
6677 BFD_RELOC_TILEGX_HW1
6678 ENUMX
6679 BFD_RELOC_TILEGX_HW2
6680 ENUMX
6681 BFD_RELOC_TILEGX_HW3
6682 ENUMX
6683 BFD_RELOC_TILEGX_HW0_LAST
6684 ENUMX
6685 BFD_RELOC_TILEGX_HW1_LAST
6686 ENUMX
6687 BFD_RELOC_TILEGX_HW2_LAST
6688 ENUMX
6689 BFD_RELOC_TILEGX_COPY
6690 ENUMX
6691 BFD_RELOC_TILEGX_GLOB_DAT
6692 ENUMX
6693 BFD_RELOC_TILEGX_JMP_SLOT
6694 ENUMX
6695 BFD_RELOC_TILEGX_RELATIVE
6696 ENUMX
6697 BFD_RELOC_TILEGX_BROFF_X1
6698 ENUMX
6699 BFD_RELOC_TILEGX_JUMPOFF_X1
6700 ENUMX
6701 BFD_RELOC_TILEGX_JUMPOFF_X1_PLT
6702 ENUMX
6703 BFD_RELOC_TILEGX_IMM8_X0
6704 ENUMX
6705 BFD_RELOC_TILEGX_IMM8_Y0
6706 ENUMX
6707 BFD_RELOC_TILEGX_IMM8_X1
6708 ENUMX
6709 BFD_RELOC_TILEGX_IMM8_Y1
6710 ENUMX
6711 BFD_RELOC_TILEGX_DEST_IMM8_X1
6712 ENUMX
6713 BFD_RELOC_TILEGX_MT_IMM14_X1
6714 ENUMX
6715 BFD_RELOC_TILEGX_MF_IMM14_X1
6716 ENUMX
6717 BFD_RELOC_TILEGX_MMSTART_X0
6718 ENUMX
6719 BFD_RELOC_TILEGX_MMEND_X0
6720 ENUMX
6721 BFD_RELOC_TILEGX_SHAMT_X0
6722 ENUMX
6723 BFD_RELOC_TILEGX_SHAMT_X1
6724 ENUMX
6725 BFD_RELOC_TILEGX_SHAMT_Y0
6726 ENUMX
6727 BFD_RELOC_TILEGX_SHAMT_Y1
6728 ENUMX
6729 BFD_RELOC_TILEGX_IMM16_X0_HW0
6730 ENUMX
6731 BFD_RELOC_TILEGX_IMM16_X1_HW0
6732 ENUMX
6733 BFD_RELOC_TILEGX_IMM16_X0_HW1
6734 ENUMX
6735 BFD_RELOC_TILEGX_IMM16_X1_HW1
6736 ENUMX
6737 BFD_RELOC_TILEGX_IMM16_X0_HW2
6738 ENUMX
6739 BFD_RELOC_TILEGX_IMM16_X1_HW2
6740 ENUMX
6741 BFD_RELOC_TILEGX_IMM16_X0_HW3
6742 ENUMX
6743 BFD_RELOC_TILEGX_IMM16_X1_HW3
6744 ENUMX
6745 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST
6746 ENUMX
6747 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST
6748 ENUMX
6749 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST
6750 ENUMX
6751 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST
6752 ENUMX
6753 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST
6754 ENUMX
6755 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST
6756 ENUMX
6757 BFD_RELOC_TILEGX_IMM16_X0_HW0_PCREL
6758 ENUMX
6759 BFD_RELOC_TILEGX_IMM16_X1_HW0_PCREL
6760 ENUMX
6761 BFD_RELOC_TILEGX_IMM16_X0_HW1_PCREL
6762 ENUMX
6763 BFD_RELOC_TILEGX_IMM16_X1_HW1_PCREL
6764 ENUMX
6765 BFD_RELOC_TILEGX_IMM16_X0_HW2_PCREL
6766 ENUMX
6767 BFD_RELOC_TILEGX_IMM16_X1_HW2_PCREL
6768 ENUMX
6769 BFD_RELOC_TILEGX_IMM16_X0_HW3_PCREL
6770 ENUMX
6771 BFD_RELOC_TILEGX_IMM16_X1_HW3_PCREL
6772 ENUMX
6773 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PCREL
6774 ENUMX
6775 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PCREL
6776 ENUMX
6777 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PCREL
6778 ENUMX
6779 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PCREL
6780 ENUMX
6781 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PCREL
6782 ENUMX
6783 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PCREL
6784 ENUMX
6785 BFD_RELOC_TILEGX_IMM16_X0_HW0_GOT
6786 ENUMX
6787 BFD_RELOC_TILEGX_IMM16_X1_HW0_GOT
6788 ENUMX
6789 BFD_RELOC_TILEGX_IMM16_X0_HW0_PLT_PCREL
6790 ENUMX
6791 BFD_RELOC_TILEGX_IMM16_X1_HW0_PLT_PCREL
6792 ENUMX
6793 BFD_RELOC_TILEGX_IMM16_X0_HW1_PLT_PCREL
6794 ENUMX
6795 BFD_RELOC_TILEGX_IMM16_X1_HW1_PLT_PCREL
6796 ENUMX
6797 BFD_RELOC_TILEGX_IMM16_X0_HW2_PLT_PCREL
6798 ENUMX
6799 BFD_RELOC_TILEGX_IMM16_X1_HW2_PLT_PCREL
6800 ENUMX
6801 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_GOT
6802 ENUMX
6803 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_GOT
6804 ENUMX
6805 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_GOT
6806 ENUMX
6807 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_GOT
6808 ENUMX
6809 BFD_RELOC_TILEGX_IMM16_X0_HW3_PLT_PCREL
6810 ENUMX
6811 BFD_RELOC_TILEGX_IMM16_X1_HW3_PLT_PCREL
6812 ENUMX
6813 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_GD
6814 ENUMX
6815 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_GD
6816 ENUMX
6817 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_LE
6818 ENUMX
6819 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_LE
6820 ENUMX
6821 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
6822 ENUMX
6823 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
6824 ENUMX
6825 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
6826 ENUMX
6827 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
6828 ENUMX
6829 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
6830 ENUMX
6831 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
6832 ENUMX
6833 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
6834 ENUMX
6835 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
6836 ENUMX
6837 BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_IE
6838 ENUMX
6839 BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_IE
6840 ENUMX
6841 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
6842 ENUMX
6843 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
6844 ENUMX
6845 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
6846 ENUMX
6847 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
6848 ENUMX
6849 BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
6850 ENUMX
6851 BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
6852 ENUMX
6853 BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
6854 ENUMX
6855 BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
6856 ENUMX
6857 BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
6858 ENUMX
6859 BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
6860 ENUMX
6861 BFD_RELOC_TILEGX_TLS_DTPMOD64
6862 ENUMX
6863 BFD_RELOC_TILEGX_TLS_DTPOFF64
6864 ENUMX
6865 BFD_RELOC_TILEGX_TLS_TPOFF64
6866 ENUMX
6867 BFD_RELOC_TILEGX_TLS_DTPMOD32
6868 ENUMX
6869 BFD_RELOC_TILEGX_TLS_DTPOFF32
6870 ENUMX
6871 BFD_RELOC_TILEGX_TLS_TPOFF32
6872 ENUMX
6873 BFD_RELOC_TILEGX_TLS_GD_CALL
6874 ENUMX
6875 BFD_RELOC_TILEGX_IMM8_X0_TLS_GD_ADD
6876 ENUMX
6877 BFD_RELOC_TILEGX_IMM8_X1_TLS_GD_ADD
6878 ENUMX
6879 BFD_RELOC_TILEGX_IMM8_Y0_TLS_GD_ADD
6880 ENUMX
6881 BFD_RELOC_TILEGX_IMM8_Y1_TLS_GD_ADD
6882 ENUMX
6883 BFD_RELOC_TILEGX_TLS_IE_LOAD
6884 ENUMX
6885 BFD_RELOC_TILEGX_IMM8_X0_TLS_ADD
6886 ENUMX
6887 BFD_RELOC_TILEGX_IMM8_X1_TLS_ADD
6888 ENUMX
6889 BFD_RELOC_TILEGX_IMM8_Y0_TLS_ADD
6890 ENUMX
6891 BFD_RELOC_TILEGX_IMM8_Y1_TLS_ADD
6892 ENUMDOC
6893 Tilera TILE-Gx Relocations.
6894 ENUM
6895 BFD_RELOC_EPIPHANY_SIMM8
6896 ENUMDOC
6897 Adapteva EPIPHANY - 8 bit signed pc-relative displacement
6898 ENUM
6899 BFD_RELOC_EPIPHANY_SIMM24
6900 ENUMDOC
6901 Adapteva EPIPHANY - 24 bit signed pc-relative displacement
6902 ENUM
6903 BFD_RELOC_EPIPHANY_HIGH
6904 ENUMDOC
6905 Adapteva EPIPHANY - 16 most-significant bits of absolute address
6906 ENUM
6907 BFD_RELOC_EPIPHANY_LOW
6908 ENUMDOC
6909 Adapteva EPIPHANY - 16 least-significant bits of absolute address
6910 ENUM
6911 BFD_RELOC_EPIPHANY_SIMM11
6912 ENUMDOC
6913 Adapteva EPIPHANY - 11 bit signed number - add/sub immediate
6914 ENUM
6915 BFD_RELOC_EPIPHANY_IMM11
6916 ENUMDOC
6917 Adapteva EPIPHANY - 11 bit sign-magnitude number (ld/st displacement)
6918 ENUM
6919 BFD_RELOC_EPIPHANY_IMM8
6920 ENUMDOC
6921 Adapteva EPIPHANY - 8 bit immediate for 16 bit mov instruction.
6922
6923
6924 ENDSENUM
6925 BFD_RELOC_UNUSED
6926 CODE_FRAGMENT
6927 .
6928 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
6929 */
6930
6931 /*
6932 FUNCTION
6933 bfd_reloc_type_lookup
6934 bfd_reloc_name_lookup
6935
6936 SYNOPSIS
6937 reloc_howto_type *bfd_reloc_type_lookup
6938 (bfd *abfd, bfd_reloc_code_real_type code);
6939 reloc_howto_type *bfd_reloc_name_lookup
6940 (bfd *abfd, const char *reloc_name);
6941
6942 DESCRIPTION
6943 Return a pointer to a howto structure which, when
6944 invoked, will perform the relocation @var{code} on data from the
6945 architecture noted.
6946
6947 */
6948
6949 reloc_howto_type *
6950 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
6951 {
6952 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
6953 }
6954
6955 reloc_howto_type *
6956 bfd_reloc_name_lookup (bfd *abfd, const char *reloc_name)
6957 {
6958 return BFD_SEND (abfd, reloc_name_lookup, (abfd, reloc_name));
6959 }
6960
6961 static reloc_howto_type bfd_howto_32 =
6962 HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_dont, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE);
6963
6964 /*
6965 INTERNAL_FUNCTION
6966 bfd_default_reloc_type_lookup
6967
6968 SYNOPSIS
6969 reloc_howto_type *bfd_default_reloc_type_lookup
6970 (bfd *abfd, bfd_reloc_code_real_type code);
6971
6972 DESCRIPTION
6973 Provides a default relocation lookup routine for any architecture.
6974
6975 */
6976
6977 reloc_howto_type *
6978 bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
6979 {
6980 switch (code)
6981 {
6982 case BFD_RELOC_CTOR:
6983 /* The type of reloc used in a ctor, which will be as wide as the
6984 address - so either a 64, 32, or 16 bitter. */
6985 switch (bfd_arch_bits_per_address (abfd))
6986 {
6987 case 64:
6988 BFD_FAIL ();
6989 case 32:
6990 return &bfd_howto_32;
6991 case 16:
6992 BFD_FAIL ();
6993 default:
6994 BFD_FAIL ();
6995 }
6996 default:
6997 BFD_FAIL ();
6998 }
6999 return NULL;
7000 }
7001
7002 /*
7003 FUNCTION
7004 bfd_get_reloc_code_name
7005
7006 SYNOPSIS
7007 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
7008
7009 DESCRIPTION
7010 Provides a printable name for the supplied relocation code.
7011 Useful mainly for printing error messages.
7012 */
7013
7014 const char *
7015 bfd_get_reloc_code_name (bfd_reloc_code_real_type code)
7016 {
7017 if (code > BFD_RELOC_UNUSED)
7018 return 0;
7019 return bfd_reloc_code_real_names[code];
7020 }
7021
7022 /*
7023 INTERNAL_FUNCTION
7024 bfd_generic_relax_section
7025
7026 SYNOPSIS
7027 bfd_boolean bfd_generic_relax_section
7028 (bfd *abfd,
7029 asection *section,
7030 struct bfd_link_info *,
7031 bfd_boolean *);
7032
7033 DESCRIPTION
7034 Provides default handling for relaxing for back ends which
7035 don't do relaxing.
7036 */
7037
7038 bfd_boolean
7039 bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
7040 asection *section ATTRIBUTE_UNUSED,
7041 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
7042 bfd_boolean *again)
7043 {
7044 if (link_info->relocatable)
7045 (*link_info->callbacks->einfo)
7046 (_("%P%F: --relax and -r may not be used together\n"));
7047
7048 *again = FALSE;
7049 return TRUE;
7050 }
7051
7052 /*
7053 INTERNAL_FUNCTION
7054 bfd_generic_gc_sections
7055
7056 SYNOPSIS
7057 bfd_boolean bfd_generic_gc_sections
7058 (bfd *, struct bfd_link_info *);
7059
7060 DESCRIPTION
7061 Provides default handling for relaxing for back ends which
7062 don't do section gc -- i.e., does nothing.
7063 */
7064
7065 bfd_boolean
7066 bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED,
7067 struct bfd_link_info *info ATTRIBUTE_UNUSED)
7068 {
7069 return TRUE;
7070 }
7071
7072 /*
7073 INTERNAL_FUNCTION
7074 bfd_generic_lookup_section_flags
7075
7076 SYNOPSIS
7077 bfd_boolean bfd_generic_lookup_section_flags
7078 (struct bfd_link_info *, struct flag_info *, asection *);
7079
7080 DESCRIPTION
7081 Provides default handling for section flags lookup
7082 -- i.e., does nothing.
7083 Returns FALSE if the section should be omitted, otherwise TRUE.
7084 */
7085
7086 bfd_boolean
7087 bfd_generic_lookup_section_flags (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7088 struct flag_info *flaginfo,
7089 asection *section ATTRIBUTE_UNUSED)
7090 {
7091 if (flaginfo != NULL)
7092 {
7093 (*_bfd_error_handler) (_("INPUT_SECTION_FLAGS are not supported.\n"));
7094 return FALSE;
7095 }
7096 return TRUE;
7097 }
7098
7099 /*
7100 INTERNAL_FUNCTION
7101 bfd_generic_merge_sections
7102
7103 SYNOPSIS
7104 bfd_boolean bfd_generic_merge_sections
7105 (bfd *, struct bfd_link_info *);
7106
7107 DESCRIPTION
7108 Provides default handling for SEC_MERGE section merging for back ends
7109 which don't have SEC_MERGE support -- i.e., does nothing.
7110 */
7111
7112 bfd_boolean
7113 bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED,
7114 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
7115 {
7116 return TRUE;
7117 }
7118
7119 /*
7120 INTERNAL_FUNCTION
7121 bfd_generic_get_relocated_section_contents
7122
7123 SYNOPSIS
7124 bfd_byte *bfd_generic_get_relocated_section_contents
7125 (bfd *abfd,
7126 struct bfd_link_info *link_info,
7127 struct bfd_link_order *link_order,
7128 bfd_byte *data,
7129 bfd_boolean relocatable,
7130 asymbol **symbols);
7131
7132 DESCRIPTION
7133 Provides default handling of relocation effort for back ends
7134 which can't be bothered to do it efficiently.
7135
7136 */
7137
7138 bfd_byte *
7139 bfd_generic_get_relocated_section_contents (bfd *abfd,
7140 struct bfd_link_info *link_info,
7141 struct bfd_link_order *link_order,
7142 bfd_byte *data,
7143 bfd_boolean relocatable,
7144 asymbol **symbols)
7145 {
7146 bfd *input_bfd = link_order->u.indirect.section->owner;
7147 asection *input_section = link_order->u.indirect.section;
7148 long reloc_size;
7149 arelent **reloc_vector;
7150 long reloc_count;
7151
7152 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
7153 if (reloc_size < 0)
7154 return NULL;
7155
7156 /* Read in the section. */
7157 if (!bfd_get_full_section_contents (input_bfd, input_section, &data))
7158 return NULL;
7159
7160 if (reloc_size == 0)
7161 return data;
7162
7163 reloc_vector = (arelent **) bfd_malloc (reloc_size);
7164 if (reloc_vector == NULL)
7165 return NULL;
7166
7167 reloc_count = bfd_canonicalize_reloc (input_bfd,
7168 input_section,
7169 reloc_vector,
7170 symbols);
7171 if (reloc_count < 0)
7172 goto error_return;
7173
7174 if (reloc_count > 0)
7175 {
7176 arelent **parent;
7177 for (parent = reloc_vector; *parent != NULL; parent++)
7178 {
7179 char *error_message = NULL;
7180 asymbol *symbol;
7181 bfd_reloc_status_type r;
7182
7183 symbol = *(*parent)->sym_ptr_ptr;
7184 if (symbol->section && discarded_section (symbol->section))
7185 {
7186 bfd_byte *p;
7187 static reloc_howto_type none_howto
7188 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
7189 "unused", FALSE, 0, 0, FALSE);
7190
7191 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
7192 _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
7193 p);
7194 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
7195 (*parent)->addend = 0;
7196 (*parent)->howto = &none_howto;
7197 r = bfd_reloc_ok;
7198 }
7199 else
7200 r = bfd_perform_relocation (input_bfd,
7201 *parent,
7202 data,
7203 input_section,
7204 relocatable ? abfd : NULL,
7205 &error_message);
7206
7207 if (relocatable)
7208 {
7209 asection *os = input_section->output_section;
7210
7211 /* A partial link, so keep the relocs. */
7212 os->orelocation[os->reloc_count] = *parent;
7213 os->reloc_count++;
7214 }
7215
7216 if (r != bfd_reloc_ok)
7217 {
7218 switch (r)
7219 {
7220 case bfd_reloc_undefined:
7221 if (!((*link_info->callbacks->undefined_symbol)
7222 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
7223 input_bfd, input_section, (*parent)->address,
7224 TRUE)))
7225 goto error_return;
7226 break;
7227 case bfd_reloc_dangerous:
7228 BFD_ASSERT (error_message != NULL);
7229 if (!((*link_info->callbacks->reloc_dangerous)
7230 (link_info, error_message, input_bfd, input_section,
7231 (*parent)->address)))
7232 goto error_return;
7233 break;
7234 case bfd_reloc_overflow:
7235 if (!((*link_info->callbacks->reloc_overflow)
7236 (link_info, NULL,
7237 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
7238 (*parent)->howto->name, (*parent)->addend,
7239 input_bfd, input_section, (*parent)->address)))
7240 goto error_return;
7241 break;
7242 case bfd_reloc_outofrange:
7243 /* PR ld/13730:
7244 This error can result when processing some partially
7245 complete binaries. Do not abort, but issue an error
7246 message instead. */
7247 link_info->callbacks->einfo
7248 (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
7249 abfd, input_section, * parent);
7250 goto error_return;
7251
7252 default:
7253 abort ();
7254 break;
7255 }
7256
7257 }
7258 }
7259 }
7260
7261 free (reloc_vector);
7262 return data;
7263
7264 error_return:
7265 free (reloc_vector);
7266 return NULL;
7267 }
GDB Binutils - Deliverables
This page took 0.177679 seconds and 4 git commands to generate.