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