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