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