projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* Handle 10 and 20-bit versions of Break instruction. Move handling
[deliverable/binutils-gdb.git] / bfd / reloc.c
1 /* BFD support for handling relocation entries.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22 /*
23 SECTION
24 Relocations
25
26 BFD maintains relocations in much the same way it maintains
27 symbols: they are left alone until required, then read in
28 en-mass and translated into an internal form. A common
29 routine <<bfd_perform_relocation>> acts upon the
30 canonical form to do the fixup.
31
32 Relocations are maintained on a per section basis,
33 while symbols are maintained on a per BFD basis.
34
35 All that a back end has to do to fit the BFD interface is to create
36 a <<struct reloc_cache_entry>> for each relocation
37 in a particular section, and fill in the right bits of the structures.
38
39 @menu
40 @* typedef arelent::
41 @* howto manager::
42 @end menu
43
44 */
45
46 /* DO compile in the reloc_code name table from libbfd.h. */
47 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
48
49 #include "bfd.h"
50 #include "sysdep.h"
51 #include "bfdlink.h"
52 #include "libbfd.h"
53 /*
54 DOCDD
55 INODE
56 typedef arelent, howto manager, Relocations, Relocations
57
58 SUBSECTION
59 typedef arelent
60
61 This is the structure of a relocation entry:
62
63 CODE_FRAGMENT
64 .
65 .typedef enum bfd_reloc_status
66 .{
67 . {* No errors detected *}
68 . bfd_reloc_ok,
69 .
70 . {* The relocation was performed, but there was an overflow. *}
71 . bfd_reloc_overflow,
72 .
73 . {* The address to relocate was not within the section supplied. *}
74 . bfd_reloc_outofrange,
75 .
76 . {* Used by special functions *}
77 . bfd_reloc_continue,
78 .
79 . {* Unsupported relocation size requested. *}
80 . bfd_reloc_notsupported,
81 .
82 . {* Unused *}
83 . bfd_reloc_other,
84 .
85 . {* The symbol to relocate against was undefined. *}
86 . bfd_reloc_undefined,
87 .
88 . {* The relocation was performed, but may not be ok - presently
89 . generated only when linking i960 coff files with i960 b.out
90 . symbols. If this type is returned, the error_message argument
91 . to bfd_perform_relocation will be set. *}
92 . bfd_reloc_dangerous
93 . }
94 . bfd_reloc_status_type;
95 .
96 .
97 .typedef struct reloc_cache_entry
98 .{
99 . {* A pointer into the canonical table of pointers *}
100 . struct symbol_cache_entry **sym_ptr_ptr;
101 .
102 . {* offset in section *}
103 . bfd_size_type address;
104 .
105 . {* addend for relocation value *}
106 . bfd_vma addend;
107 .
108 . {* Pointer to how to perform the required relocation *}
109 . reloc_howto_type *howto;
110 .
111 .} arelent;
112
113 */
114
115 /*
116 DESCRIPTION
117
118 Here is a description of each of the fields within an <<arelent>>:
119
120 o <<sym_ptr_ptr>>
121
122 The symbol table pointer points to a pointer to the symbol
123 associated with the relocation request. It is
124 the pointer into the table returned by the back end's
125 <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
126 through a pointer to a pointer so that tools like the linker
127 can fix up all the symbols of the same name by modifying only
128 one pointer. The relocation routine looks in the symbol and
129 uses the base of the section the symbol is attached to and the
130 value of the symbol as the initial relocation offset. If the
131 symbol pointer is zero, then the section provided is looked up.
132
133 o <<address>>
134
135 The <<address>> field gives the offset in bytes from the base of
136 the section data which owns the relocation record to the first
137 byte of relocatable information. The actual data relocated
138 will be relative to this point; for example, a relocation
139 type which modifies the bottom two bytes of a four byte word
140 would not touch the first byte pointed to in a big endian
141 world.
142
143 o <<addend>>
144
145 The <<addend>> is a value provided by the back end to be added (!)
146 to the relocation offset. Its interpretation is dependent upon
147 the howto. For example, on the 68k the code:
148
149
150 | char foo[];
151 | main()
152 | {
153 | return foo[0x12345678];
154 | }
155
156 Could be compiled into:
157
158 | linkw fp,#-4
159 | moveb @@#12345678,d0
160 | extbl d0
161 | unlk fp
162 | rts
163
164
165 This could create a reloc pointing to <<foo>>, but leave the
166 offset in the data, something like:
167
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
180 Using coff and an 88k, some instructions don't have enough
181 space in them to represent the full address range, and
182 pointers have to be loaded in two parts. So you'd get something like:
183
184
185 | or.u r13,r0,hi16(_foo+0x12345678)
186 | ld.b r2,r13,lo16(_foo+0x12345678)
187 | jmp r1
188
189
190 This should create two relocs, both pointing to <<_foo>>, and with
191 0x12340000 in their addend field. The data would consist of:
192
193
194 |RELOCATION RECORDS FOR [.text]:
195 |offset type value
196 |00000002 HVRT16 _foo+0x12340000
197 |00000006 LVRT16 _foo+0x12340000
198 |
199 |00000000 5da05678 ; or.u r13,r0,0x5678
200 |00000004 1c4d5678 ; ld.b r2,r13,0x5678
201 |00000008 f400c001 ; jmp r1
202
203
204 The relocation routine digs out the value from the data, adds
205 it to the addend to get the original offset, and then adds the
206 value of <<_foo>>. Note that all 32 bits have to be kept around
207 somewhere, to cope with carry from bit 15 to bit 16.
208
209 One further example is the sparc and the a.out format. The
210 sparc has a similar problem to the 88k, in that some
211 instructions don't have room for an entire offset, but on the
212 sparc the parts are created in odd sized lumps. The designers of
213 the a.out format chose to not use the data within the section
214 for storing part of the offset; all the offset is kept within
215 the reloc. Anything in the data should be ignored.
216
217 | save %sp,-112,%sp
218 | sethi %hi(_foo+0x12345678),%g2
219 | ldsb [%g2+%lo(_foo+0x12345678)],%i0
220 | ret
221 | restore
222
223 Both relocs contain a pointer to <<foo>>, and the offsets
224 contain junk.
225
226
227 |RELOCATION RECORDS FOR [.text]:
228 |offset type value
229 |00000004 HI22 _foo+0x12345678
230 |00000008 LO10 _foo+0x12345678
231 |
232 |00000000 9de3bf90 ; save %sp,-112,%sp
233 |00000004 05000000 ; sethi %hi(_foo+0),%g2
234 |00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0
235 |0000000c 81c7e008 ; ret
236 |00000010 81e80000 ; restore
237
238
239 o <<howto>>
240
241 The <<howto>> field can be imagined as a
242 relocation instruction. It is a pointer to a structure which
243 contains information on what to do with all of the other
244 information in the reloc record and data section. A back end
245 would normally have a relocation instruction set and turn
246 relocations into pointers to the correct structure on input -
247 but it would be possible to create each howto field on demand.
248
249 */
250
251 /*
252 SUBSUBSECTION
253 <<enum complain_overflow>>
254
255 Indicates what sort of overflow checking should be done when
256 performing a relocation.
257
258 CODE_FRAGMENT
259 .
260 .enum complain_overflow
261 .{
262 . {* Do not complain on overflow. *}
263 . complain_overflow_dont,
264 .
265 . {* Complain if the bitfield overflows, whether it is considered
266 . as signed or unsigned. *}
267 . complain_overflow_bitfield,
268 .
269 . {* Complain if the value overflows when considered as signed
270 . number. *}
271 . complain_overflow_signed,
272 .
273 . {* Complain if the value overflows when considered as an
274 . unsigned number. *}
275 . complain_overflow_unsigned
276 .};
277
278 */
279
280 /*
281 SUBSUBSECTION
282 <<reloc_howto_type>>
283
284 The <<reloc_howto_type>> is a structure which contains all the
285 information that libbfd needs to know to tie up a back end's data.
286
287 CODE_FRAGMENT
288 .struct symbol_cache_entry; {* Forward declaration *}
289 .
290 .struct reloc_howto_struct
291 .{
292 . {* The type field has mainly a documentary use - the back end can
293 . do what it wants with it, though normally the back end's
294 . external idea of what a reloc number is stored
295 . in this field. For example, a PC relative word relocation
296 . in a coff environment has the type 023 - because that's
297 . what the outside world calls a R_PCRWORD reloc. *}
298 . unsigned int type;
299 .
300 . {* The value the final relocation is shifted right by. This drops
301 . unwanted data from the relocation. *}
302 . unsigned int rightshift;
303 .
304 . {* The size of the item to be relocated. This is *not* a
305 . power-of-two measure. To get the number of bytes operated
306 . on by a type of relocation, use bfd_get_reloc_size. *}
307 . int size;
308 .
309 . {* The number of bits in the item to be relocated. This is used
310 . when doing overflow checking. *}
311 . unsigned int bitsize;
312 .
313 . {* Notes that the relocation is relative to the location in the
314 . data section of the addend. The relocation function will
315 . subtract from the relocation value the address of the location
316 . being relocated. *}
317 . boolean pc_relative;
318 .
319 . {* The bit position of the reloc value in the destination.
320 . The relocated value is left shifted by this amount. *}
321 . unsigned int bitpos;
322 .
323 . {* What type of overflow error should be checked for when
324 . relocating. *}
325 . enum complain_overflow complain_on_overflow;
326 .
327 . {* If this field is non null, then the supplied function is
328 . called rather than the normal function. This allows really
329 . strange relocation methods to be accomodated (e.g., i960 callj
330 . instructions). *}
331 . bfd_reloc_status_type (*special_function)
332 . PARAMS ((bfd *abfd,
333 . arelent *reloc_entry,
334 . struct symbol_cache_entry *symbol,
335 . PTR data,
336 . asection *input_section,
337 . bfd *output_bfd,
338 . char **error_message));
339 .
340 . {* The textual name of the relocation type. *}
341 . char *name;
342 .
343 . {* When performing a partial link, some formats must modify the
344 . relocations rather than the data - this flag signals this.*}
345 . boolean partial_inplace;
346 .
347 . {* The src_mask selects which parts of the read in data
348 . are to be used in the relocation sum. E.g., if this was an 8 bit
349 . bit of data which we read and relocated, this would be
350 . 0x000000ff. When we have relocs which have an addend, such as
351 . sun4 extended relocs, the value in the offset part of a
352 . relocating field is garbage so we never use it. In this case
353 . the mask would be 0x00000000. *}
354 . bfd_vma src_mask;
355 .
356 . {* The dst_mask selects which parts of the instruction are replaced
357 . into the instruction. In most cases src_mask == dst_mask,
358 . except in the above special case, where dst_mask would be
359 . 0x000000ff, and src_mask would be 0x00000000. *}
360 . bfd_vma dst_mask;
361 .
362 . {* When some formats create PC relative instructions, they leave
363 . the value of the pc of the place being relocated in the offset
364 . slot of the instruction, so that a PC relative relocation can
365 . be made just by adding in an ordinary offset (e.g., sun3 a.out).
366 . Some formats leave the displacement part of an instruction
367 . empty (e.g., m88k bcs); this flag signals the fact.*}
368 . boolean pcrel_offset;
369 .
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
382 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
383 . {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
384
385 DESCRIPTION
386 And will be replaced with the totally magic way. But for the
387 moment, we are compatible, so do it this way.
388
389
390 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
391 .
392 DESCRIPTION
393 Helper routine to turn a symbol into a relocation value.
394
395 .#define HOWTO_PREPARE(relocation, symbol) \
396 . { \
397 . if (symbol != (asymbol *)NULL) { \
398 . if (bfd_is_com_section (symbol->section)) { \
399 . relocation = 0; \
400 . } \
401 . else { \
402 . relocation = symbol->value; \
403 . } \
404 . } \
405 .}
406
407 */
408
409 /*
410 FUNCTION
411 bfd_get_reloc_size
412
413 SYNOPSIS
414 unsigned int bfd_get_reloc_size (reloc_howto_type *);
415
416 DESCRIPTION
417 For a reloc_howto_type that operates on a fixed number of bytes,
418 this returns the number of bytes operated on.
419 */
420
421 unsigned int
422 bfd_get_reloc_size (howto)
423 reloc_howto_type *howto;
424 {
425 switch (howto->size)
426 {
427 case 0: return 1;
428 case 1: return 2;
429 case 2: return 4;
430 case 3: return 0;
431 case 4: return 8;
432 case 8: return 16;
433 case -2: return 4;
434 default: abort ();
435 }
436 }
437
438 /*
439 TYPEDEF
440 arelent_chain
441
442 DESCRIPTION
443
444 How relocs are tied together in an <<asection>>:
445
446 .typedef struct relent_chain {
447 . arelent relent;
448 . struct relent_chain *next;
449 .} arelent_chain;
450
451 */
452
453
454 /*
455 FUNCTION
456 bfd_check_overflow
457
458 SYNOPSIS
459 bfd_reloc_status_type
460 bfd_check_overflow
461 (enum complain_overflow how,
462 unsigned int bitsize,
463 unsigned int rightshift,
464 bfd_vma relocation);
465
466 DESCRIPTION
467 Perform overflow checking on @var{relocation} which has @var{bitsize}
468 significant bits and will be shifted right by @var{rightshift} bits.
469 The result is either of @code{bfd_reloc_ok} or
470 @code{bfd_reloc_overflow}.
471
472 */
473
474 bfd_reloc_status_type
475 bfd_check_overflow (how, bitsize, rightshift, relocation)
476 enum complain_overflow how;
477 unsigned int bitsize, rightshift;
478 bfd_vma relocation;
479 {
480 bfd_vma check;
481 bfd_reloc_status_type flag = bfd_reloc_ok;
482
483 /* Get the value that will be used for the relocation, but
484 starting at bit position zero. */
485 check = relocation >> rightshift;
486
487 switch (how)
488 {
489 case complain_overflow_dont:
490 break;
491
492 case complain_overflow_signed:
493 {
494 /* Assumes two's complement. */
495 bfd_signed_vma reloc_signed_max =
496 ((bfd_signed_vma) 1 << (bitsize - 1)) - 1;
497 bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
498
499 /* The above right shift is incorrect for a signed value.
500 Fix it up by forcing on the upper bits. */
501 if (rightshift > 0
502 && (bfd_signed_vma) relocation < 0)
503 check |= ((bfd_vma) - 1
504 & ~((bfd_vma) - 1
505 >> rightshift));
506 if ((bfd_signed_vma) check > reloc_signed_max
507 || (bfd_signed_vma) check < reloc_signed_min)
508 flag = bfd_reloc_overflow;
509 }
510 break;
511
512 case complain_overflow_unsigned:
513 {
514 /* Assumes two's complement. This expression avoids
515 overflow if `bitsize' is the number of bits in
516 bfd_vma. */
517 bfd_vma reloc_unsigned_max =
518 ((((bfd_vma) 1 << (bitsize - 1)) - 1) << 1) | 1;
519
520 if ((bfd_vma) check > reloc_unsigned_max)
521 flag = bfd_reloc_overflow;
522 }
523 break;
524
525 case complain_overflow_bitfield:
526 {
527 /* Assumes two's complement. This expression avoids
528 overflow if `bitsize' is the number of bits in
529 bfd_vma. */
530 bfd_vma reloc_bits = (((1 << (bitsize - 1)) - 1) << 1) | 1;
531
532 if (((bfd_vma) check & ~reloc_bits) != 0
533 && ((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
534 {
535 /* The above right shift is incorrect for a signed
536 value. See if turning on the upper bits fixes the
537 overflow. */
538 if (rightshift > 0
539 && (bfd_signed_vma) relocation < 0)
540 {
541 check |= ((bfd_vma) - 1
542 & ~((bfd_vma) - 1
543 >> rightshift));
544 if (((bfd_vma) check & ~reloc_bits) != (-1 & ~reloc_bits))
545 flag = bfd_reloc_overflow;
546 }
547 else
548 flag = bfd_reloc_overflow;
549 }
550 }
551 break;
552
553 default:
554 abort ();
555 }
556
557 return flag;
558 }
559
560
561 /*
562 FUNCTION
563 bfd_perform_relocation
564
565 SYNOPSIS
566 bfd_reloc_status_type
567 bfd_perform_relocation
568 (bfd *abfd,
569 arelent *reloc_entry,
570 PTR data,
571 asection *input_section,
572 bfd *output_bfd,
573 char **error_message);
574
575 DESCRIPTION
576 If @var{output_bfd} is supplied to this function, the
577 generated image will be relocatable; the relocations are
578 copied to the output file after they have been changed to
579 reflect the new state of the world. There are two ways of
580 reflecting the results of partial linkage in an output file:
581 by modifying the output data in place, and by modifying the
582 relocation record. Some native formats (e.g., basic a.out and
583 basic coff) have no way of specifying an addend in the
584 relocation type, so the addend has to go in the output data.
585 This is no big deal since in these formats the output data
586 slot will always be big enough for the addend. Complex reloc
587 types with addends were invented to solve just this problem.
588 The @var{error_message} argument is set to an error message if
589 this return @code{bfd_reloc_dangerous}.
590
591 */
592
593
594 bfd_reloc_status_type
595 bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
596 error_message)
597 bfd *abfd;
598 arelent *reloc_entry;
599 PTR data;
600 asection *input_section;
601 bfd *output_bfd;
602 char **error_message;
603 {
604 bfd_vma relocation;
605 bfd_reloc_status_type flag = bfd_reloc_ok;
606 bfd_size_type addr = reloc_entry->address;
607 bfd_vma output_base = 0;
608 reloc_howto_type *howto = reloc_entry->howto;
609 asection *reloc_target_output_section;
610 asymbol *symbol;
611
612 symbol = *(reloc_entry->sym_ptr_ptr);
613 if (bfd_is_abs_section (symbol->section)
614 && output_bfd != (bfd *) NULL)
615 {
616 reloc_entry->address += input_section->output_offset;
617 return bfd_reloc_ok;
618 }
619
620 /* If we are not producing relocateable output, return an error if
621 the symbol is not defined. An undefined weak symbol is
622 considered to have a value of zero (SVR4 ABI, p. 4-27). */
623 if (bfd_is_und_section (symbol->section)
624 && (symbol->flags & BSF_WEAK) == 0
625 && output_bfd == (bfd *) NULL)
626 flag = bfd_reloc_undefined;
627
628 /* If there is a function supplied to handle this relocation type,
629 call it. It'll return `bfd_reloc_continue' if further processing
630 can be done. */
631 if (howto->special_function)
632 {
633 bfd_reloc_status_type cont;
634 cont = howto->special_function (abfd, reloc_entry, symbol, data,
635 input_section, output_bfd,
636 error_message);
637 if (cont != bfd_reloc_continue)
638 return cont;
639 }
640
641 /* Is the address of the relocation really within the section? */
642 if (reloc_entry->address > input_section->_cooked_size)
643 return bfd_reloc_outofrange;
644
645 /* Work out which section the relocation is targetted at and the
646 initial relocation command value. */
647
648 /* Get symbol value. (Common symbols are special.) */
649 if (bfd_is_com_section (symbol->section))
650 relocation = 0;
651 else
652 relocation = symbol->value;
653
654
655 reloc_target_output_section = symbol->section->output_section;
656
657 /* Convert input-section-relative symbol value to absolute. */
658 if (output_bfd && howto->partial_inplace == false)
659 output_base = 0;
660 else
661 output_base = reloc_target_output_section->vma;
662
663 relocation += output_base + symbol->section->output_offset;
664
665 /* Add in supplied addend. */
666 relocation += reloc_entry->addend;
667
668 /* Here the variable relocation holds the final address of the
669 symbol we are relocating against, plus any addend. */
670
671 if (howto->pc_relative == true)
672 {
673 /* This is a PC relative relocation. We want to set RELOCATION
674 to the distance between the address of the symbol and the
675 location. RELOCATION is already the address of the symbol.
676
677 We start by subtracting the address of the section containing
678 the location.
679
680 If pcrel_offset is set, we must further subtract the position
681 of the location within the section. Some targets arrange for
682 the addend to be the negative of the position of the location
683 within the section; for example, i386-aout does this. For
684 i386-aout, pcrel_offset is false. Some other targets do not
685 include the position of the location; for example, m88kbcs,
686 or ELF. For those targets, pcrel_offset is true.
687
688 If we are producing relocateable output, then we must ensure
689 that this reloc will be correctly computed when the final
690 relocation is done. If pcrel_offset is false we want to wind
691 up with the negative of the location within the section,
692 which means we must adjust the existing addend by the change
693 in the location within the section. If pcrel_offset is true
694 we do not want to adjust the existing addend at all.
695
696 FIXME: This seems logical to me, but for the case of
697 producing relocateable output it is not what the code
698 actually does. I don't want to change it, because it seems
699 far too likely that something will break. */
700
701 relocation -=
702 input_section->output_section->vma + input_section->output_offset;
703
704 if (howto->pcrel_offset == true)
705 relocation -= reloc_entry->address;
706 }
707
708 if (output_bfd != (bfd *) NULL)
709 {
710 if (howto->partial_inplace == false)
711 {
712 /* This is a partial relocation, and we want to apply the relocation
713 to the reloc entry rather than the raw data. Modify the reloc
714 inplace to reflect what we now know. */
715 reloc_entry->addend = relocation;
716 reloc_entry->address += input_section->output_offset;
717 return flag;
718 }
719 else
720 {
721 /* This is a partial relocation, but inplace, so modify the
722 reloc record a bit.
723
724 If we've relocated with a symbol with a section, change
725 into a ref to the section belonging to the symbol. */
726
727 reloc_entry->address += input_section->output_offset;
728
729 /* WTF?? */
730 if (abfd->xvec->flavour == bfd_target_coff_flavour
731 && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
732 && strcmp (abfd->xvec->name, "xcoff-powermac") != 0
733 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
734 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
735 {
736 #if 1
737 /* For m68k-coff, the addend was being subtracted twice during
738 relocation with -r. Removing the line below this comment
739 fixes that problem; see PR 2953.
740
741 However, Ian wrote the following, regarding removing the line below,
742 which explains why it is still enabled: --djm
743
744 If you put a patch like that into BFD you need to check all the COFF
745 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
746 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
747 problem in a different way. There may very well be a reason that the
748 code works as it does.
749
750 Hmmm. The first obvious point is that bfd_perform_relocation should
751 not have any tests that depend upon the flavour. It's seem like
752 entirely the wrong place for such a thing. The second obvious point
753 is that the current code ignores the reloc addend when producing
754 relocateable output for COFF. That's peculiar. In fact, I really
755 have no idea what the point of the line you want to remove is.
756
757 A typical COFF reloc subtracts the old value of the symbol and adds in
758 the new value to the location in the object file (if it's a pc
759 relative reloc it adds the difference between the symbol value and the
760 location). When relocating we need to preserve that property.
761
762 BFD handles this by setting the addend to the negative of the old
763 value of the symbol. Unfortunately it handles common symbols in a
764 non-standard way (it doesn't subtract the old value) but that's a
765 different story (we can't change it without losing backward
766 compatibility with old object files) (coff-i386 does subtract the old
767 value, to be compatible with existing coff-i386 targets, like SCO).
768
769 So everything works fine when not producing relocateable output. When
770 we are producing relocateable output, logically we should do exactly
771 what we do when not producing relocateable output. Therefore, your
772 patch is correct. In fact, it should probably always just set
773 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
774 add the value into the object file. This won't hurt the COFF code,
775 which doesn't use the addend; I'm not sure what it will do to other
776 formats (the thing to check for would be whether any formats both use
777 the addend and set partial_inplace).
778
779 When I wanted to make coff-i386 produce relocateable output, I ran
780 into the problem that you are running into: I wanted to remove that
781 line. Rather than risk it, I made the coff-i386 relocs use a special
782 function; it's coff_i386_reloc in coff-i386.c. The function
783 specifically adds the addend field into the object file, knowing that
784 bfd_perform_relocation is not going to. If you remove that line, then
785 coff-i386.c will wind up adding the addend field in twice. It's
786 trivial to fix; it just needs to be done.
787
788 The problem with removing the line is just that it may break some
789 working code. With BFD it's hard to be sure of anything. The right
790 way to deal with this is simply to build and test at least all the
791 supported COFF targets. It should be straightforward if time and disk
792 space consuming. For each target:
793 1) build the linker
794 2) generate some executable, and link it using -r (I would
795 probably use paranoia.o and link against newlib/libc.a, which
796 for all the supported targets would be available in
797 /usr/cygnus/progressive/H-host/target/lib/libc.a).
798 3) make the change to reloc.c
799 4) rebuild the linker
800 5) repeat step 2
801 6) if the resulting object files are the same, you have at least
802 made it no worse
803 7) if they are different you have to figure out which version is
804 right
805 */
806 relocation -= reloc_entry->addend;
807 #endif
808 reloc_entry->addend = 0;
809 }
810 else
811 {
812 reloc_entry->addend = relocation;
813 }
814 }
815 }
816 else
817 {
818 reloc_entry->addend = 0;
819 }
820
821 /* FIXME: This overflow checking is incomplete, because the value
822 might have overflowed before we get here. For a correct check we
823 need to compute the value in a size larger than bitsize, but we
824 can't reasonably do that for a reloc the same size as a host
825 machine word.
826 FIXME: We should also do overflow checking on the result after
827 adding in the value contained in the object file. */
828 if (howto->complain_on_overflow != complain_overflow_dont
829 && flag == bfd_reloc_ok)
830 flag = bfd_check_overflow (howto->complain_on_overflow, howto->bitsize,
831 howto->rightshift, relocation);
832
833 /*
834 Either we are relocating all the way, or we don't want to apply
835 the relocation to the reloc entry (probably because there isn't
836 any room in the output format to describe addends to relocs)
837 */
838
839 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
840 (OSF version 1.3, compiler version 3.11). It miscompiles the
841 following program:
842
843 struct str
844 {
845 unsigned int i0;
846 } s = { 0 };
847
848 int
849 main ()
850 {
851 unsigned long x;
852
853 x = 0x100000000;
854 x <<= (unsigned long) s.i0;
855 if (x == 0)
856 printf ("failed\n");
857 else
858 printf ("succeeded (%lx)\n", x);
859 }
860 */
861
862 relocation >>= (bfd_vma) howto->rightshift;
863
864 /* Shift everything up to where it's going to be used */
865
866 relocation <<= (bfd_vma) howto->bitpos;
867
868 /* Wait for the day when all have the mask in them */
869
870 /* What we do:
871 i instruction to be left alone
872 o offset within instruction
873 r relocation offset to apply
874 S src mask
875 D dst mask
876 N ~dst mask
877 A part 1
878 B part 2
879 R result
880
881 Do this:
882 i i i i i o o o o o from bfd_get<size>
883 and S S S S S to get the size offset we want
884 + r r r r r r r r r r to get the final value to place
885 and D D D D D to chop to right size
886 -----------------------
887 A A A A A
888 And this:
889 ... i i i i i o o o o o from bfd_get<size>
890 and N N N N N get instruction
891 -----------------------
892 ... B B B B B
893
894 And then:
895 B B B B B
896 or A A A A A
897 -----------------------
898 R R R R R R R R R R put into bfd_put<size>
899 */
900
901 #define DOIT(x) \
902 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
903
904 switch (howto->size)
905 {
906 case 0:
907 {
908 char x = bfd_get_8 (abfd, (char *) data + addr);
909 DOIT (x);
910 bfd_put_8 (abfd, x, (unsigned char *) data + addr);
911 }
912 break;
913
914 case 1:
915 {
916 short x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
917 DOIT (x);
918 bfd_put_16 (abfd, x, (unsigned char *) data + addr);
919 }
920 break;
921 case 2:
922 {
923 long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
924 DOIT (x);
925 bfd_put_32 (abfd, x, (bfd_byte *) data + addr);
926 }
927 break;
928 case -2:
929 {
930 long x = bfd_get_32 (abfd, (bfd_byte *) data + addr);
931 relocation = -relocation;
932 DOIT (x);
933 bfd_put_32 (abfd, x, (bfd_byte *) data + addr);
934 }
935 break;
936
937 case -1:
938 {
939 long x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
940 relocation = -relocation;
941 DOIT (x);
942 bfd_put_16 (abfd, x, (bfd_byte *) data + addr);
943 }
944 break;
945
946 case 3:
947 /* Do nothing */
948 break;
949
950 case 4:
951 #ifdef BFD64
952 {
953 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + addr);
954 DOIT (x);
955 bfd_put_64 (abfd, x, (bfd_byte *) data + addr);
956 }
957 #else
958 abort ();
959 #endif
960 break;
961 default:
962 return bfd_reloc_other;
963 }
964
965 return flag;
966 }
967
968 /*
969 FUNCTION
970 bfd_install_relocation
971
972 SYNOPSIS
973 bfd_reloc_status_type
974 bfd_install_relocation
975 (bfd *abfd,
976 arelent *reloc_entry,
977 PTR data, bfd_vma data_start,
978 asection *input_section,
979 char **error_message);
980
981 DESCRIPTION
982 This looks remarkably like <<bfd_perform_relocation>>, except it
983 does not expect that the section contents have been filled in.
984 I.e., it's suitable for use when creating, rather than applying
985 a relocation.
986
987 For now, this function should be considered reserved for the
988 assembler.
989
990 */
991
992
993 bfd_reloc_status_type
994 bfd_install_relocation (abfd, reloc_entry, data_start, data_start_offset,
995 input_section, error_message)
996 bfd *abfd;
997 arelent *reloc_entry;
998 PTR data_start;
999 bfd_vma data_start_offset;
1000 asection *input_section;
1001 char **error_message;
1002 {
1003 bfd_vma relocation;
1004 bfd_reloc_status_type flag = bfd_reloc_ok;
1005 bfd_size_type addr = reloc_entry->address;
1006 bfd_vma output_base = 0;
1007 reloc_howto_type *howto = reloc_entry->howto;
1008 asection *reloc_target_output_section;
1009 asymbol *symbol;
1010 bfd_byte *data;
1011
1012 symbol = *(reloc_entry->sym_ptr_ptr);
1013 if (bfd_is_abs_section (symbol->section))
1014 {
1015 reloc_entry->address += input_section->output_offset;
1016 return bfd_reloc_ok;
1017 }
1018
1019 /* If there is a function supplied to handle this relocation type,
1020 call it. It'll return `bfd_reloc_continue' if further processing
1021 can be done. */
1022 if (howto->special_function)
1023 {
1024 bfd_reloc_status_type cont;
1025
1026 /* XXX - The special_function calls haven't been fixed up to deal
1027 with creating new relocations and section contents. */
1028 cont = howto->special_function (abfd, reloc_entry, symbol,
1029 /* XXX - Non-portable! */
1030 ((bfd_byte *) data_start
1031 - data_start_offset),
1032 input_section, abfd, error_message);
1033 if (cont != bfd_reloc_continue)
1034 return cont;
1035 }
1036
1037 /* Is the address of the relocation really within the section? */
1038 if (reloc_entry->address > input_section->_cooked_size)
1039 return bfd_reloc_outofrange;
1040
1041 /* Work out which section the relocation is targetted at and the
1042 initial relocation command value. */
1043
1044 /* Get symbol value. (Common symbols are special.) */
1045 if (bfd_is_com_section (symbol->section))
1046 relocation = 0;
1047 else
1048 relocation = symbol->value;
1049
1050 reloc_target_output_section = symbol->section->output_section;
1051
1052 /* Convert input-section-relative symbol value to absolute. */
1053 if (howto->partial_inplace == false)
1054 output_base = 0;
1055 else
1056 output_base = reloc_target_output_section->vma;
1057
1058 relocation += output_base + symbol->section->output_offset;
1059
1060 /* Add in supplied addend. */
1061 relocation += reloc_entry->addend;
1062
1063 /* Here the variable relocation holds the final address of the
1064 symbol we are relocating against, plus any addend. */
1065
1066 if (howto->pc_relative == true)
1067 {
1068 /* This is a PC relative relocation. We want to set RELOCATION
1069 to the distance between the address of the symbol and the
1070 location. RELOCATION is already the address of the symbol.
1071
1072 We start by subtracting the address of the section containing
1073 the location.
1074
1075 If pcrel_offset is set, we must further subtract the position
1076 of the location within the section. Some targets arrange for
1077 the addend to be the negative of the position of the location
1078 within the section; for example, i386-aout does this. For
1079 i386-aout, pcrel_offset is false. Some other targets do not
1080 include the position of the location; for example, m88kbcs,
1081 or ELF. For those targets, pcrel_offset is true.
1082
1083 If we are producing relocateable output, then we must ensure
1084 that this reloc will be correctly computed when the final
1085 relocation is done. If pcrel_offset is false we want to wind
1086 up with the negative of the location within the section,
1087 which means we must adjust the existing addend by the change
1088 in the location within the section. If pcrel_offset is true
1089 we do not want to adjust the existing addend at all.
1090
1091 FIXME: This seems logical to me, but for the case of
1092 producing relocateable output it is not what the code
1093 actually does. I don't want to change it, because it seems
1094 far too likely that something will break. */
1095
1096 relocation -=
1097 input_section->output_section->vma + input_section->output_offset;
1098
1099 if (howto->pcrel_offset == true && howto->partial_inplace == true)
1100 relocation -= reloc_entry->address;
1101 }
1102
1103 if (howto->partial_inplace == false)
1104 {
1105 /* This is a partial relocation, and we want to apply the relocation
1106 to the reloc entry rather than the raw data. Modify the reloc
1107 inplace to reflect what we now know. */
1108 reloc_entry->addend = relocation;
1109 reloc_entry->address += input_section->output_offset;
1110 return flag;
1111 }
1112 else
1113 {
1114 /* This is a partial relocation, but inplace, so modify the
1115 reloc record a bit.
1116
1117 If we've relocated with a symbol with a section, change
1118 into a ref to the section belonging to the symbol. */
1119
1120 reloc_entry->address += input_section->output_offset;
1121
1122 /* WTF?? */
1123 if (abfd->xvec->flavour == bfd_target_coff_flavour
1124 && strcmp (abfd->xvec->name, "aixcoff-rs6000") != 0
1125 && strcmp (abfd->xvec->name, "xcoff-powermac") != 0
1126 && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1127 && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1128 {
1129 #if 1
1130 /* For m68k-coff, the addend was being subtracted twice during
1131 relocation with -r. Removing the line below this comment
1132 fixes that problem; see PR 2953.
1133
1134 However, Ian wrote the following, regarding removing the line below,
1135 which explains why it is still enabled: --djm
1136
1137 If you put a patch like that into BFD you need to check all the COFF
1138 linkers. I am fairly certain that patch will break coff-i386 (e.g.,
1139 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1140 problem in a different way. There may very well be a reason that the
1141 code works as it does.
1142
1143 Hmmm. The first obvious point is that bfd_install_relocation should
1144 not have any tests that depend upon the flavour. It's seem like
1145 entirely the wrong place for such a thing. The second obvious point
1146 is that the current code ignores the reloc addend when producing
1147 relocateable output for COFF. That's peculiar. In fact, I really
1148 have no idea what the point of the line you want to remove is.
1149
1150 A typical COFF reloc subtracts the old value of the symbol and adds in
1151 the new value to the location in the object file (if it's a pc
1152 relative reloc it adds the difference between the symbol value and the
1153 location). When relocating we need to preserve that property.
1154
1155 BFD handles this by setting the addend to the negative of the old
1156 value of the symbol. Unfortunately it handles common symbols in a
1157 non-standard way (it doesn't subtract the old value) but that's a
1158 different story (we can't change it without losing backward
1159 compatibility with old object files) (coff-i386 does subtract the old
1160 value, to be compatible with existing coff-i386 targets, like SCO).
1161
1162 So everything works fine when not producing relocateable output. When
1163 we are producing relocateable output, logically we should do exactly
1164 what we do when not producing relocateable output. Therefore, your
1165 patch is correct. In fact, it should probably always just set
1166 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1167 add the value into the object file. This won't hurt the COFF code,
1168 which doesn't use the addend; I'm not sure what it will do to other
1169 formats (the thing to check for would be whether any formats both use
1170 the addend and set partial_inplace).
1171
1172 When I wanted to make coff-i386 produce relocateable output, I ran
1173 into the problem that you are running into: I wanted to remove that
1174 line. Rather than risk it, I made the coff-i386 relocs use a special
1175 function; it's coff_i386_reloc in coff-i386.c. The function
1176 specifically adds the addend field into the object file, knowing that
1177 bfd_install_relocation is not going to. If you remove that line, then
1178 coff-i386.c will wind up adding the addend field in twice. It's
1179 trivial to fix; it just needs to be done.
1180
1181 The problem with removing the line is just that it may break some
1182 working code. With BFD it's hard to be sure of anything. The right
1183 way to deal with this is simply to build and test at least all the
1184 supported COFF targets. It should be straightforward if time and disk
1185 space consuming. For each target:
1186 1) build the linker
1187 2) generate some executable, and link it using -r (I would
1188 probably use paranoia.o and link against newlib/libc.a, which
1189 for all the supported targets would be available in
1190 /usr/cygnus/progressive/H-host/target/lib/libc.a).
1191 3) make the change to reloc.c
1192 4) rebuild the linker
1193 5) repeat step 2
1194 6) if the resulting object files are the same, you have at least
1195 made it no worse
1196 7) if they are different you have to figure out which version is
1197 right
1198 */
1199 relocation -= reloc_entry->addend;
1200 #endif
1201 reloc_entry->addend = 0;
1202 }
1203 else
1204 {
1205 reloc_entry->addend = relocation;
1206 }
1207 }
1208
1209 /* FIXME: This overflow checking is incomplete, because the value
1210 might have overflowed before we get here. For a correct check we
1211 need to compute the value in a size larger than bitsize, but we
1212 can't reasonably do that for a reloc the same size as a host
1213 machine word.
1214 FIXME: We should also do overflow checking on the result after
1215 adding in the value contained in the object file. */
1216 if (howto->complain_on_overflow != complain_overflow_dont)
1217 flag = bfd_check_overflow (howto->complain_on_overflow, howto->bitsize,
1218 howto->rightshift, relocation);
1219
1220 /*
1221 Either we are relocating all the way, or we don't want to apply
1222 the relocation to the reloc entry (probably because there isn't
1223 any room in the output format to describe addends to relocs)
1224 */
1225
1226 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1227 (OSF version 1.3, compiler version 3.11). It miscompiles the
1228 following program:
1229
1230 struct str
1231 {
1232 unsigned int i0;
1233 } s = { 0 };
1234
1235 int
1236 main ()
1237 {
1238 unsigned long x;
1239
1240 x = 0x100000000;
1241 x <<= (unsigned long) s.i0;
1242 if (x == 0)
1243 printf ("failed\n");
1244 else
1245 printf ("succeeded (%lx)\n", x);
1246 }
1247 */
1248
1249 relocation >>= (bfd_vma) howto->rightshift;
1250
1251 /* Shift everything up to where it's going to be used */
1252
1253 relocation <<= (bfd_vma) howto->bitpos;
1254
1255 /* Wait for the day when all have the mask in them */
1256
1257 /* What we do:
1258 i instruction to be left alone
1259 o offset within instruction
1260 r relocation offset to apply
1261 S src mask
1262 D dst mask
1263 N ~dst mask
1264 A part 1
1265 B part 2
1266 R result
1267
1268 Do this:
1269 i i i i i o o o o o from bfd_get<size>
1270 and S S S S S to get the size offset we want
1271 + r r r r r r r r r r to get the final value to place
1272 and D D D D D to chop to right size
1273 -----------------------
1274 A A A A A
1275 And this:
1276 ... i i i i i o o o o o from bfd_get<size>
1277 and N N N N N get instruction
1278 -----------------------
1279 ... B B B B B
1280
1281 And then:
1282 B B B B B
1283 or A A A A A
1284 -----------------------
1285 R R R R R R R R R R put into bfd_put<size>
1286 */
1287
1288 #define DOIT(x) \
1289 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
1290
1291 data = (bfd_byte *) data_start + (addr - data_start_offset);
1292
1293 switch (howto->size)
1294 {
1295 case 0:
1296 {
1297 char x = bfd_get_8 (abfd, (char *) data);
1298 DOIT (x);
1299 bfd_put_8 (abfd, x, (unsigned char *) data);
1300 }
1301 break;
1302
1303 case 1:
1304 {
1305 short x = bfd_get_16 (abfd, (bfd_byte *) data);
1306 DOIT (x);
1307 bfd_put_16 (abfd, x, (unsigned char *) data);
1308 }
1309 break;
1310 case 2:
1311 {
1312 long x = bfd_get_32 (abfd, (bfd_byte *) data);
1313 DOIT (x);
1314 bfd_put_32 (abfd, x, (bfd_byte *) data);
1315 }
1316 break;
1317 case -2:
1318 {
1319 long x = bfd_get_32 (abfd, (bfd_byte *) data);
1320 relocation = -relocation;
1321 DOIT (x);
1322 bfd_put_32 (abfd, x, (bfd_byte *) data);
1323 }
1324 break;
1325
1326 case 3:
1327 /* Do nothing */
1328 break;
1329
1330 case 4:
1331 {
1332 bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
1333 DOIT (x);
1334 bfd_put_64 (abfd, x, (bfd_byte *) data);
1335 }
1336 break;
1337 default:
1338 return bfd_reloc_other;
1339 }
1340
1341 return flag;
1342 }
1343
1344 /* This relocation routine is used by some of the backend linkers.
1345 They do not construct asymbol or arelent structures, so there is no
1346 reason for them to use bfd_perform_relocation. Also,
1347 bfd_perform_relocation is so hacked up it is easier to write a new
1348 function than to try to deal with it.
1349
1350 This routine does a final relocation. Whether it is useful for a
1351 relocateable link depends upon how the object format defines
1352 relocations.
1353
1354 FIXME: This routine ignores any special_function in the HOWTO,
1355 since the existing special_function values have been written for
1356 bfd_perform_relocation.
1357
1358 HOWTO is the reloc howto information.
1359 INPUT_BFD is the BFD which the reloc applies to.
1360 INPUT_SECTION is the section which the reloc applies to.
1361 CONTENTS is the contents of the section.
1362 ADDRESS is the address of the reloc within INPUT_SECTION.
1363 VALUE is the value of the symbol the reloc refers to.
1364 ADDEND is the addend of the reloc. */
1365
1366 bfd_reloc_status_type
1367 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
1368 value, addend)
1369 reloc_howto_type *howto;
1370 bfd *input_bfd;
1371 asection *input_section;
1372 bfd_byte *contents;
1373 bfd_vma address;
1374 bfd_vma value;
1375 bfd_vma addend;
1376 {
1377 bfd_vma relocation;
1378
1379 /* Sanity check the address. */
1380 if (address > input_section->_raw_size)
1381 return bfd_reloc_outofrange;
1382
1383 /* This function assumes that we are dealing with a basic relocation
1384 against a symbol. We want to compute the value of the symbol to
1385 relocate to. This is just VALUE, the value of the symbol, plus
1386 ADDEND, any addend associated with the reloc. */
1387 relocation = value + addend;
1388
1389 /* If the relocation is PC relative, we want to set RELOCATION to
1390 the distance between the symbol (currently in RELOCATION) and the
1391 location we are relocating. Some targets (e.g., i386-aout)
1392 arrange for the contents of the section to be the negative of the
1393 offset of the location within the section; for such targets
1394 pcrel_offset is false. Other targets (e.g., m88kbcs or ELF)
1395 simply leave the contents of the section as zero; for such
1396 targets pcrel_offset is true. If pcrel_offset is false we do not
1397 need to subtract out the offset of the location within the
1398 section (which is just ADDRESS). */
1399 if (howto->pc_relative)
1400 {
1401 relocation -= (input_section->output_section->vma
1402 + input_section->output_offset);
1403 if (howto->pcrel_offset)
1404 relocation -= address;
1405 }
1406
1407 return _bfd_relocate_contents (howto, input_bfd, relocation,
1408 contents + address);
1409 }
1410
1411 /* Relocate a given location using a given value and howto. */
1412
1413 bfd_reloc_status_type
1414 _bfd_relocate_contents (howto, input_bfd, relocation, location)
1415 reloc_howto_type *howto;
1416 bfd *input_bfd;
1417 bfd_vma relocation;
1418 bfd_byte *location;
1419 {
1420 int size;
1421 bfd_vma x;
1422 boolean overflow;
1423
1424 /* If the size is negative, negate RELOCATION. This isn't very
1425 general. */
1426 if (howto->size < 0)
1427 relocation = -relocation;
1428
1429 /* Get the value we are going to relocate. */
1430 size = bfd_get_reloc_size (howto);
1431 switch (size)
1432 {
1433 default:
1434 case 0:
1435 abort ();
1436 case 1:
1437 x = bfd_get_8 (input_bfd, location);
1438 break;
1439 case 2:
1440 x = bfd_get_16 (input_bfd, location);
1441 break;
1442 case 4:
1443 x = bfd_get_32 (input_bfd, location);
1444 break;
1445 case 8:
1446 #ifdef BFD64
1447 x = bfd_get_64 (input_bfd, location);
1448 #else
1449 abort ();
1450 #endif
1451 break;
1452 }
1453
1454 /* Check for overflow. FIXME: We may drop bits during the addition
1455 which we don't check for. We must either check at every single
1456 operation, which would be tedious, or we must do the computations
1457 in a type larger than bfd_vma, which would be inefficient. */
1458 overflow = false;
1459 if (howto->complain_on_overflow != complain_overflow_dont)
1460 {
1461 bfd_vma check;
1462 bfd_signed_vma signed_check;
1463 bfd_vma add;
1464 bfd_signed_vma signed_add;
1465
1466 if (howto->rightshift == 0)
1467 {
1468 check = relocation;
1469 signed_check = (bfd_signed_vma) relocation;
1470 }
1471 else
1472 {
1473 /* Drop unwanted bits from the value we are relocating to. */
1474 check = relocation >> howto->rightshift;
1475
1476 /* If this is a signed value, the rightshift just dropped
1477 leading 1 bits (assuming twos complement). */
1478 if ((bfd_signed_vma) relocation >= 0)
1479 signed_check = check;
1480 else
1481 signed_check = (check
1482 | ((bfd_vma) - 1
1483 & ~((bfd_vma) - 1 >> howto->rightshift)));
1484 }
1485
1486 /* Get the value from the object file. */
1487 add = x & howto->src_mask;
1488
1489 /* Get the value from the object file with an appropriate sign.
1490 The expression involving howto->src_mask isolates the upper
1491 bit of src_mask. If that bit is set in the value we are
1492 adding, it is negative, and we subtract out that number times
1493 two. If src_mask includes the highest possible bit, then we
1494 can not get the upper bit, but that does not matter since
1495 signed_add needs no adjustment to become negative in that
1496 case. */
1497 signed_add = add;
1498 if ((add & (((~howto->src_mask) >> 1) & howto->src_mask)) != 0)
1499 signed_add -= (((~howto->src_mask) >> 1) & howto->src_mask) << 1;
1500
1501 /* Add the value from the object file, shifted so that it is a
1502 straight number. */
1503 if (howto->bitpos == 0)
1504 {
1505 check += add;
1506 signed_check += signed_add;
1507 }
1508 else
1509 {
1510 check += add >> howto->bitpos;
1511
1512 /* For the signed case we use ADD, rather than SIGNED_ADD,
1513 to avoid warnings from SVR4 cc. This is OK since we
1514 explictly handle the sign bits. */
1515 if (signed_add >= 0)
1516 signed_check += add >> howto->bitpos;
1517 else
1518 signed_check += ((add >> howto->bitpos)
1519 | ((bfd_vma) - 1
1520 & ~((bfd_vma) - 1 >> howto->bitpos)));
1521 }
1522
1523 switch (howto->complain_on_overflow)
1524 {
1525 case complain_overflow_signed:
1526 {
1527 /* Assumes two's complement. */
1528 bfd_signed_vma reloc_signed_max =
1529 ((bfd_signed_vma) 1 << (howto->bitsize - 1)) - 1;
1530 bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1531
1532 if (signed_check > reloc_signed_max
1533 || signed_check < reloc_signed_min)
1534 overflow = true;
1535 }
1536 break;
1537 case complain_overflow_unsigned:
1538 {
1539 /* Assumes two's complement. This expression avoids
1540 overflow if howto->bitsize is the number of bits in
1541 bfd_vma. */
1542 bfd_vma reloc_unsigned_max =
1543 ((((bfd_vma) 1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1544
1545 if (check > reloc_unsigned_max)
1546 overflow = true;
1547 }
1548 break;
1549 case complain_overflow_bitfield:
1550 {
1551 /* Assumes two's complement. This expression avoids
1552 overflow if howto->bitsize is the number of bits in
1553 bfd_vma. */
1554 bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
1555
1556 if ((check & ~reloc_bits) != 0
1557 && (((bfd_vma) signed_check & ~reloc_bits)
1558 != (-1 & ~reloc_bits)))
1559 overflow = true;
1560 }
1561 break;
1562 default:
1563 abort ();
1564 }
1565 }
1566
1567 /* Put RELOCATION in the right bits. */
1568 relocation >>= (bfd_vma) howto->rightshift;
1569 relocation <<= (bfd_vma) howto->bitpos;
1570
1571 /* Add RELOCATION to the right bits of X. */
1572 x = ((x & ~howto->dst_mask)
1573 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1574
1575 /* Put the relocated value back in the object file. */
1576 switch (size)
1577 {
1578 default:
1579 case 0:
1580 abort ();
1581 case 1:
1582 bfd_put_8 (input_bfd, x, location);
1583 break;
1584 case 2:
1585 bfd_put_16 (input_bfd, x, location);
1586 break;
1587 case 4:
1588 bfd_put_32 (input_bfd, x, location);
1589 break;
1590 case 8:
1591 #ifdef BFD64
1592 bfd_put_64 (input_bfd, x, location);
1593 #else
1594 abort ();
1595 #endif
1596 break;
1597 }
1598
1599 return overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1600 }
1601
1602 /*
1603 DOCDD
1604 INODE
1605 howto manager, , typedef arelent, Relocations
1606
1607 SECTION
1608 The howto manager
1609
1610 When an application wants to create a relocation, but doesn't
1611 know what the target machine might call it, it can find out by
1612 using this bit of code.
1613
1614 */
1615
1616 /*
1617 TYPEDEF
1618 bfd_reloc_code_type
1619
1620 DESCRIPTION
1621 The insides of a reloc code. The idea is that, eventually, there
1622 will be one enumerator for every type of relocation we ever do.
1623 Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1624 return a howto pointer.
1625
1626 This does mean that the application must determine the correct
1627 enumerator value; you can't get a howto pointer from a random set
1628 of attributes.
1629
1630 SENUM
1631 bfd_reloc_code_real
1632
1633 ENUM
1634 BFD_RELOC_64
1635 ENUMX
1636 BFD_RELOC_32
1637 ENUMX
1638 BFD_RELOC_26
1639 ENUMX
1640 BFD_RELOC_24
1641 ENUMX
1642 BFD_RELOC_16
1643 ENUMX
1644 BFD_RELOC_14
1645 ENUMX
1646 BFD_RELOC_8
1647 ENUMDOC
1648 Basic absolute relocations of N bits.
1649
1650 ENUM
1651 BFD_RELOC_64_PCREL
1652 ENUMX
1653 BFD_RELOC_32_PCREL
1654 ENUMX
1655 BFD_RELOC_24_PCREL
1656 ENUMX
1657 BFD_RELOC_16_PCREL
1658 ENUMX
1659 BFD_RELOC_12_PCREL
1660 ENUMX
1661 BFD_RELOC_8_PCREL
1662 ENUMDOC
1663 PC-relative relocations. Sometimes these are relative to the address
1664 of the relocation itself; sometimes they are relative to the start of
1665 the section containing the relocation. It depends on the specific target.
1666
1667 The 24-bit relocation is used in some Intel 960 configurations.
1668
1669 ENUM
1670 BFD_RELOC_32_GOT_PCREL
1671 ENUMX
1672 BFD_RELOC_16_GOT_PCREL
1673 ENUMX
1674 BFD_RELOC_8_GOT_PCREL
1675 ENUMX
1676 BFD_RELOC_32_GOTOFF
1677 ENUMX
1678 BFD_RELOC_16_GOTOFF
1679 ENUMX
1680 BFD_RELOC_LO16_GOTOFF
1681 ENUMX
1682 BFD_RELOC_HI16_GOTOFF
1683 ENUMX
1684 BFD_RELOC_HI16_S_GOTOFF
1685 ENUMX
1686 BFD_RELOC_8_GOTOFF
1687 ENUMX
1688 BFD_RELOC_32_PLT_PCREL
1689 ENUMX
1690 BFD_RELOC_24_PLT_PCREL
1691 ENUMX
1692 BFD_RELOC_16_PLT_PCREL
1693 ENUMX
1694 BFD_RELOC_8_PLT_PCREL
1695 ENUMX
1696 BFD_RELOC_32_PLTOFF
1697 ENUMX
1698 BFD_RELOC_16_PLTOFF
1699 ENUMX
1700 BFD_RELOC_LO16_PLTOFF
1701 ENUMX
1702 BFD_RELOC_HI16_PLTOFF
1703 ENUMX
1704 BFD_RELOC_HI16_S_PLTOFF
1705 ENUMX
1706 BFD_RELOC_8_PLTOFF
1707 ENUMDOC
1708 For ELF.
1709
1710 ENUM
1711 BFD_RELOC_68K_GLOB_DAT
1712 ENUMX
1713 BFD_RELOC_68K_JMP_SLOT
1714 ENUMX
1715 BFD_RELOC_68K_RELATIVE
1716 ENUMDOC
1717 Relocations used by 68K ELF.
1718
1719 ENUM
1720 BFD_RELOC_32_BASEREL
1721 ENUMX
1722 BFD_RELOC_16_BASEREL
1723 ENUMX
1724 BFD_RELOC_LO16_BASEREL
1725 ENUMX
1726 BFD_RELOC_HI16_BASEREL
1727 ENUMX
1728 BFD_RELOC_HI16_S_BASEREL
1729 ENUMX
1730 BFD_RELOC_8_BASEREL
1731 ENUMX
1732 BFD_RELOC_RVA
1733 ENUMDOC
1734 Linkage-table relative.
1735
1736 ENUM
1737 BFD_RELOC_8_FFnn
1738 ENUMDOC
1739 Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1740
1741 ENUM
1742 BFD_RELOC_32_PCREL_S2
1743 ENUMX
1744 BFD_RELOC_16_PCREL_S2
1745 ENUMX
1746 BFD_RELOC_23_PCREL_S2
1747 ENUMDOC
1748 These PC-relative relocations are stored as word displacements --
1749 i.e., byte displacements shifted right two bits. The 30-bit word
1750 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1751 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The
1752 signed 16-bit displacement is used on the MIPS, and the 23-bit
1753 displacement is used on the Alpha.
1754
1755 ENUM
1756 BFD_RELOC_HI22
1757 ENUMX
1758 BFD_RELOC_LO10
1759 ENUMDOC
1760 High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1761 the target word. These are used on the SPARC.
1762
1763 ENUM
1764 BFD_RELOC_GPREL16
1765 ENUMX
1766 BFD_RELOC_GPREL32
1767 ENUMDOC
1768 For systems that allocate a Global Pointer register, these are
1769 displacements off that register. These relocation types are
1770 handled specially, because the value the register will have is
1771 decided relatively late.
1772
1773
1774 ENUM
1775 BFD_RELOC_I960_CALLJ
1776 ENUMDOC
1777 Reloc types used for i960/b.out.
1778
1779 ENUM
1780 BFD_RELOC_NONE
1781 ENUMX
1782 BFD_RELOC_SPARC_WDISP22
1783 ENUMX
1784 BFD_RELOC_SPARC22
1785 ENUMX
1786 BFD_RELOC_SPARC13
1787 ENUMX
1788 BFD_RELOC_SPARC_GOT10
1789 ENUMX
1790 BFD_RELOC_SPARC_GOT13
1791 ENUMX
1792 BFD_RELOC_SPARC_GOT22
1793 ENUMX
1794 BFD_RELOC_SPARC_PC10
1795 ENUMX
1796 BFD_RELOC_SPARC_PC22
1797 ENUMX
1798 BFD_RELOC_SPARC_WPLT30
1799 ENUMX
1800 BFD_RELOC_SPARC_COPY
1801 ENUMX
1802 BFD_RELOC_SPARC_GLOB_DAT
1803 ENUMX
1804 BFD_RELOC_SPARC_JMP_SLOT
1805 ENUMX
1806 BFD_RELOC_SPARC_RELATIVE
1807 ENUMX
1808 BFD_RELOC_SPARC_UA32
1809 ENUMDOC
1810 SPARC ELF relocations. There is probably some overlap with other
1811 relocation types already defined.
1812
1813 ENUM
1814 BFD_RELOC_SPARC_BASE13
1815 ENUMX
1816 BFD_RELOC_SPARC_BASE22
1817 ENUMDOC
1818 I think these are specific to SPARC a.out (e.g., Sun 4).
1819
1820 ENUMEQ
1821 BFD_RELOC_SPARC_64
1822 BFD_RELOC_64
1823 ENUMX
1824 BFD_RELOC_SPARC_10
1825 ENUMX
1826 BFD_RELOC_SPARC_11
1827 ENUMX
1828 BFD_RELOC_SPARC_OLO10
1829 ENUMX
1830 BFD_RELOC_SPARC_HH22
1831 ENUMX
1832 BFD_RELOC_SPARC_HM10
1833 ENUMX
1834 BFD_RELOC_SPARC_LM22
1835 ENUMX
1836 BFD_RELOC_SPARC_PC_HH22
1837 ENUMX
1838 BFD_RELOC_SPARC_PC_HM10
1839 ENUMX
1840 BFD_RELOC_SPARC_PC_LM22
1841 ENUMX
1842 BFD_RELOC_SPARC_WDISP16
1843 ENUMX
1844 BFD_RELOC_SPARC_WDISP19
1845 ENUMX
1846 BFD_RELOC_SPARC_7
1847 ENUMX
1848 BFD_RELOC_SPARC_6
1849 ENUMX
1850 BFD_RELOC_SPARC_5
1851 ENUMEQX
1852 BFD_RELOC_SPARC_DISP64
1853 BFD_RELOC_64_PCREL
1854 ENUMX
1855 BFD_RELOC_SPARC_PLT64
1856 ENUMX
1857 BFD_RELOC_SPARC_HIX22
1858 ENUMX
1859 BFD_RELOC_SPARC_LOX10
1860 ENUMX
1861 BFD_RELOC_SPARC_H44
1862 ENUMX
1863 BFD_RELOC_SPARC_M44
1864 ENUMX
1865 BFD_RELOC_SPARC_L44
1866 ENUMX
1867 BFD_RELOC_SPARC_REGISTER
1868 ENUMDOC
1869 SPARC64 relocations
1870
1871 ENUM
1872 BFD_RELOC_ALPHA_GPDISP_HI16
1873 ENUMDOC
1874 Alpha ECOFF and ELF relocations. Some of these treat the symbol or
1875 "addend" in some special way.
1876 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1877 writing; when reading, it will be the absolute section symbol. The
1878 addend is the displacement in bytes of the "lda" instruction from
1879 the "ldah" instruction (which is at the address of this reloc).
1880 ENUM
1881 BFD_RELOC_ALPHA_GPDISP_LO16
1882 ENUMDOC
1883 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1884 with GPDISP_HI16 relocs. The addend is ignored when writing the
1885 relocations out, and is filled in with the file's GP value on
1886 reading, for convenience.
1887
1888 ENUM
1889 BFD_RELOC_ALPHA_GPDISP
1890 ENUMDOC
1891 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1892 relocation except that there is no accompanying GPDISP_LO16
1893 relocation.
1894
1895 ENUM
1896 BFD_RELOC_ALPHA_LITERAL
1897 ENUMX
1898 BFD_RELOC_ALPHA_ELF_LITERAL
1899 ENUMX
1900 BFD_RELOC_ALPHA_LITUSE
1901 ENUMDOC
1902 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1903 the assembler turns it into a LDQ instruction to load the address of
1904 the symbol, and then fills in a register in the real instruction.
1905
1906 The LITERAL reloc, at the LDQ instruction, refers to the .lita
1907 section symbol. The addend is ignored when writing, but is filled
1908 in with the file's GP value on reading, for convenience, as with the
1909 GPDISP_LO16 reloc.
1910
1911 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1912 It should refer to the symbol to be referenced, as with 16_GOTOFF,
1913 but it generates output not based on the position within the .got
1914 section, but relative to the GP value chosen for the file during the
1915 final link stage.
1916
1917 The LITUSE reloc, on the instruction using the loaded address, gives
1918 information to the linker that it might be able to use to optimize
1919 away some literal section references. The symbol is ignored (read
1920 as the absolute section symbol), and the "addend" indicates the type
1921 of instruction using the register:
1922 1 - "memory" fmt insn
1923 2 - byte-manipulation (byte offset reg)
1924 3 - jsr (target of branch)
1925
1926 The GNU linker currently doesn't do any of this optimizing.
1927
1928 ENUM
1929 BFD_RELOC_ALPHA_HINT
1930 ENUMDOC
1931 The HINT relocation indicates a value that should be filled into the
1932 "hint" field of a jmp/jsr/ret instruction, for possible branch-
1933 prediction logic which may be provided on some processors.
1934
1935 ENUM
1936 BFD_RELOC_ALPHA_LINKAGE
1937 ENUMDOC
1938 The LINKAGE relocation outputs a linkage pair in the object file,
1939 which is filled by the linker.
1940
1941 ENUM
1942 BFD_RELOC_ALPHA_CODEADDR
1943 ENUMDOC
1944 The CODEADDR relocation outputs a STO_CA in the object file,
1945 which is filled by the linker.
1946
1947 ENUM
1948 BFD_RELOC_MIPS_JMP
1949 ENUMDOC
1950 Bits 27..2 of the relocation address shifted right 2 bits;
1951 simple reloc otherwise.
1952
1953 ENUM
1954 BFD_RELOC_MIPS16_JMP
1955 ENUMDOC
1956 The MIPS16 jump instruction.
1957
1958 ENUM
1959 BFD_RELOC_MIPS16_GPREL
1960 ENUMDOC
1961 MIPS16 GP relative reloc.
1962
1963 ENUM
1964 BFD_RELOC_HI16
1965 ENUMDOC
1966 High 16 bits of 32-bit value; simple reloc.
1967 ENUM
1968 BFD_RELOC_HI16_S
1969 ENUMDOC
1970 High 16 bits of 32-bit value but the low 16 bits will be sign
1971 extended and added to form the final result. If the low 16
1972 bits form a negative number, we need to add one to the high value
1973 to compensate for the borrow when the low bits are added.
1974 ENUM
1975 BFD_RELOC_LO16
1976 ENUMDOC
1977 Low 16 bits.
1978 ENUM
1979 BFD_RELOC_PCREL_HI16_S
1980 ENUMDOC
1981 Like BFD_RELOC_HI16_S, but PC relative.
1982 ENUM
1983 BFD_RELOC_PCREL_LO16
1984 ENUMDOC
1985 Like BFD_RELOC_LO16, but PC relative.
1986
1987 ENUMEQ
1988 BFD_RELOC_MIPS_GPREL
1989 BFD_RELOC_GPREL16
1990 ENUMDOC
1991 Relocation relative to the global pointer.
1992
1993 ENUM
1994 BFD_RELOC_MIPS_LITERAL
1995 ENUMDOC
1996 Relocation against a MIPS literal section.
1997
1998 ENUM
1999 BFD_RELOC_MIPS_GOT16
2000 ENUMX
2001 BFD_RELOC_MIPS_CALL16
2002 ENUMEQX
2003 BFD_RELOC_MIPS_GPREL32
2004 BFD_RELOC_GPREL32
2005 ENUMX
2006 BFD_RELOC_MIPS_GOT_HI16
2007 ENUMX
2008 BFD_RELOC_MIPS_GOT_LO16
2009 ENUMX
2010 BFD_RELOC_MIPS_CALL_HI16
2011 ENUMX
2012 BFD_RELOC_MIPS_CALL_LO16
2013 COMMENT
2014 {* start-sanitize-r5900 *}
2015 ENUMX
2016 BFD_RELOC_MIPS15_S3
2017 COMMENT
2018 {* end-sanitize-r5900 *}
2019 ENUMDOC
2020 MIPS ELF relocations.
2021
2022 COMMENT
2023 {* start-sanitize-sky *}
2024 ENUM
2025 BFD_RELOC_MIPS_DVP_11_PCREL
2026 ENUMDOC
2027 MIPS DVP Relocations.
2028 This is an 11-bit pc relative reloc. The recorded address is for the
2029 lower instruction word, and the value is in 128 bit units.
2030 ENUM
2031 BFD_RELOC_MIPS_DVP_27_S4
2032 ENUMDOC
2033 This is a 27 bit address left shifted by 4.
2034 COMMENT
2035 {* end-sanitize-sky *}
2036
2037 ENUM
2038 BFD_RELOC_386_GOT32
2039 ENUMX
2040 BFD_RELOC_386_PLT32
2041 ENUMX
2042 BFD_RELOC_386_COPY
2043 ENUMX
2044 BFD_RELOC_386_GLOB_DAT
2045 ENUMX
2046 BFD_RELOC_386_JUMP_SLOT
2047 ENUMX
2048 BFD_RELOC_386_RELATIVE
2049 ENUMX
2050 BFD_RELOC_386_GOTOFF
2051 ENUMX
2052 BFD_RELOC_386_GOTPC
2053 ENUMDOC
2054 i386/elf relocations
2055
2056 ENUM
2057 BFD_RELOC_NS32K_IMM_8
2058 ENUMX
2059 BFD_RELOC_NS32K_IMM_16
2060 ENUMX
2061 BFD_RELOC_NS32K_IMM_32
2062 ENUMX
2063 BFD_RELOC_NS32K_IMM_8_PCREL
2064 ENUMX
2065 BFD_RELOC_NS32K_IMM_16_PCREL
2066 ENUMX
2067 BFD_RELOC_NS32K_IMM_32_PCREL
2068 ENUMX
2069 BFD_RELOC_NS32K_DISP_8
2070 ENUMX
2071 BFD_RELOC_NS32K_DISP_16
2072 ENUMX
2073 BFD_RELOC_NS32K_DISP_32
2074 ENUMX
2075 BFD_RELOC_NS32K_DISP_8_PCREL
2076 ENUMX
2077 BFD_RELOC_NS32K_DISP_16_PCREL
2078 ENUMX
2079 BFD_RELOC_NS32K_DISP_32_PCREL
2080 ENUMDOC
2081 ns32k relocations
2082
2083 ENUM
2084 BFD_RELOC_PPC_B26
2085 ENUMX
2086 BFD_RELOC_PPC_BA26
2087 ENUMX
2088 BFD_RELOC_PPC_TOC16
2089 ENUMX
2090 BFD_RELOC_PPC_B16
2091 ENUMX
2092 BFD_RELOC_PPC_B16_BRTAKEN
2093 ENUMX
2094 BFD_RELOC_PPC_B16_BRNTAKEN
2095 ENUMX
2096 BFD_RELOC_PPC_BA16
2097 ENUMX
2098 BFD_RELOC_PPC_BA16_BRTAKEN
2099 ENUMX
2100 BFD_RELOC_PPC_BA16_BRNTAKEN
2101 ENUMX
2102 BFD_RELOC_PPC_COPY
2103 ENUMX
2104 BFD_RELOC_PPC_GLOB_DAT
2105 ENUMX
2106 BFD_RELOC_PPC_JMP_SLOT
2107 ENUMX
2108 BFD_RELOC_PPC_RELATIVE
2109 ENUMX
2110 BFD_RELOC_PPC_LOCAL24PC
2111 ENUMX
2112 BFD_RELOC_PPC_EMB_NADDR32
2113 ENUMX
2114 BFD_RELOC_PPC_EMB_NADDR16
2115 ENUMX
2116 BFD_RELOC_PPC_EMB_NADDR16_LO
2117 ENUMX
2118 BFD_RELOC_PPC_EMB_NADDR16_HI
2119 ENUMX
2120 BFD_RELOC_PPC_EMB_NADDR16_HA
2121 ENUMX
2122 BFD_RELOC_PPC_EMB_SDAI16
2123 ENUMX
2124 BFD_RELOC_PPC_EMB_SDA2I16
2125 ENUMX
2126 BFD_RELOC_PPC_EMB_SDA2REL
2127 ENUMX
2128 BFD_RELOC_PPC_EMB_SDA21
2129 ENUMX
2130 BFD_RELOC_PPC_EMB_MRKREF
2131 ENUMX
2132 BFD_RELOC_PPC_EMB_RELSEC16
2133 ENUMX
2134 BFD_RELOC_PPC_EMB_RELST_LO
2135 ENUMX
2136 BFD_RELOC_PPC_EMB_RELST_HI
2137 ENUMX
2138 BFD_RELOC_PPC_EMB_RELST_HA
2139 ENUMX
2140 BFD_RELOC_PPC_EMB_BIT_FLD
2141 ENUMX
2142 BFD_RELOC_PPC_EMB_RELSDA
2143 ENUMDOC
2144 Power(rs6000) and PowerPC relocations.
2145
2146 ENUM
2147 BFD_RELOC_CTOR
2148 ENUMDOC
2149 The type of reloc used to build a contructor table - at the moment
2150 probably a 32 bit wide absolute relocation, but the target can choose.
2151 It generally does map to one of the other relocation types.
2152
2153 ENUM
2154 BFD_RELOC_ARM_PCREL_BRANCH
2155 ENUMDOC
2156 ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
2157 not stored in the instruction.
2158 ENUM
2159 BFD_RELOC_ARM_IMMEDIATE
2160 ENUMX
2161 BFD_RELOC_ARM_OFFSET_IMM
2162 ENUMX
2163 BFD_RELOC_ARM_SHIFT_IMM
2164 ENUMX
2165 BFD_RELOC_ARM_SWI
2166 ENUMX
2167 BFD_RELOC_ARM_MULTI
2168 ENUMX
2169 BFD_RELOC_ARM_CP_OFF_IMM
2170 ENUMX
2171 BFD_RELOC_ARM_ADR_IMM
2172 ENUMX
2173 BFD_RELOC_ARM_LDR_IMM
2174 ENUMX
2175 BFD_RELOC_ARM_LITERAL
2176 ENUMX
2177 BFD_RELOC_ARM_IN_POOL
2178 ENUMX
2179 BFD_RELOC_ARM_OFFSET_IMM8
2180 ENUMX
2181 BFD_RELOC_ARM_HWLITERAL
2182 ENUMX
2183 BFD_RELOC_ARM_THUMB_ADD
2184 ENUMX
2185 BFD_RELOC_ARM_THUMB_IMM
2186 ENUMX
2187 BFD_RELOC_ARM_THUMB_SHIFT
2188 ENUMX
2189 BFD_RELOC_ARM_THUMB_OFFSET
2190 ENUMDOC
2191 These relocs are only used within the ARM assembler. They are not
2192 (at present) written to any object files.
2193
2194 ENUM
2195 BFD_RELOC_SH_PCDISP8BY2
2196 ENUMX
2197 BFD_RELOC_SH_PCDISP12BY2
2198 ENUMX
2199 BFD_RELOC_SH_IMM4
2200 ENUMX
2201 BFD_RELOC_SH_IMM4BY2
2202 ENUMX
2203 BFD_RELOC_SH_IMM4BY4
2204 ENUMX
2205 BFD_RELOC_SH_IMM8
2206 ENUMX
2207 BFD_RELOC_SH_IMM8BY2
2208 ENUMX
2209 BFD_RELOC_SH_IMM8BY4
2210 ENUMX
2211 BFD_RELOC_SH_PCRELIMM8BY2
2212 ENUMX
2213 BFD_RELOC_SH_PCRELIMM8BY4
2214 ENUMX
2215 BFD_RELOC_SH_SWITCH16
2216 ENUMX
2217 BFD_RELOC_SH_SWITCH32
2218 ENUMX
2219 BFD_RELOC_SH_USES
2220 ENUMX
2221 BFD_RELOC_SH_COUNT
2222 ENUMX
2223 BFD_RELOC_SH_ALIGN
2224 ENUMX
2225 BFD_RELOC_SH_CODE
2226 ENUMX
2227 BFD_RELOC_SH_DATA
2228 ENUMX
2229 BFD_RELOC_SH_LABEL
2230 ENUMDOC
2231 Hitachi SH relocs. Not all of these appear in object files.
2232
2233 ENUM
2234 BFD_RELOC_THUMB_PCREL_BRANCH9
2235 ENUMX
2236 BFD_RELOC_THUMB_PCREL_BRANCH12
2237 ENUMX
2238 BFD_RELOC_THUMB_PCREL_BRANCH23
2239 ENUMDOC
2240 Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must
2241 be zero and is not stored in the instruction.
2242
2243 ENUM
2244 BFD_RELOC_ARC_B22_PCREL
2245 ENUMDOC
2246 Argonaut RISC Core (ARC) relocs.
2247 ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
2248 not stored in the instruction. The high 20 bits are installed in bits 26
2249 through 7 of the instruction.
2250 ENUM
2251 BFD_RELOC_ARC_B26
2252 ENUMDOC
2253 ARC 26 bit absolute branch. The lowest two bits must be zero and are not
2254 stored in the instruction. The high 24 bits are installed in bits 23
2255 through 0.
2256
2257 COMMENT
2258 ENUM
2259 BFD_RELOC_D10V_10_PCREL_R
2260 ENUMDOC
2261 Mitsubishi D10V relocs.
2262 This is a 10-bit reloc with the right 2 bits
2263 assumed to be 0.
2264 ENUM
2265 BFD_RELOC_D10V_10_PCREL_L
2266 ENUMDOC
2267 Mitsubishi D10V relocs.
2268 This is a 10-bit reloc with the right 2 bits
2269 assumed to be 0. This is the same as the previous reloc
2270 except it is in the left container, i.e.,
2271 shifted left 15 bits.
2272 ENUM
2273 BFD_RELOC_D10V_18
2274 ENUMDOC
2275 This is an 18-bit reloc with the right 2 bits
2276 assumed to be 0.
2277 ENUM
2278 BFD_RELOC_D10V_18_PCREL
2279 ENUMDOC
2280 This is an 18-bit reloc with the right 2 bits
2281 assumed to be 0.
2282 COMMENT
2283
2284 COMMENT
2285 {* start-sanitize-d30v *}
2286 ENUM
2287 BFD_RELOC_D30V_6
2288 ENUMDOC
2289 Mitsubishi D30V relocs.
2290 This is a 6-bit absolute reloc.
2291 ENUM
2292 BFD_RELOC_D30V_9_PCREL
2293 ENUMDOC
2294 This is a 6-bit pc-relative reloc with
2295 the right 3 bits assumed to be 0.
2296 ENUM
2297 BFD_RELOC_D30V_9_PCREL_R
2298 ENUMDOC
2299 This is a 6-bit pc-relative reloc with
2300 the right 3 bits assumed to be 0. Same
2301 as the previous reloc but on the right side
2302 of the container.
2303 ENUM
2304 BFD_RELOC_D30V_15
2305 ENUMDOC
2306 This is a 12-bit absolute reloc with the
2307 right 3 bitsassumed to be 0.
2308 ENUM
2309 BFD_RELOC_D30V_15_PCREL
2310 ENUMDOC
2311 This is a 12-bit pc-relative reloc with
2312 the right 3 bits assumed to be 0.
2313 ENUM
2314 BFD_RELOC_D30V_15_PCREL_R
2315 ENUMDOC
2316 This is a 12-bit pc-relative reloc with
2317 the right 3 bits assumed to be 0. Same
2318 as the previous reloc but on the right side
2319 of the container.
2320 ENUM
2321 BFD_RELOC_D30V_21
2322 ENUMDOC
2323 This is an 18-bit absolute reloc with
2324 the right 3 bits assumed to be 0.
2325 ENUM
2326 BFD_RELOC_D30V_21_PCREL
2327 ENUMDOC
2328 This is an 18-bit pc-relative reloc with
2329 the right 3 bits assumed to be 0.
2330 ENUM
2331 BFD_RELOC_D30V_21_PCREL_R
2332 ENUMDOC
2333 This is an 18-bit pc-relative reloc with
2334 the right 3 bits assumed to be 0. Same
2335 as the previous reloc but on the right side
2336 of the container.
2337 ENUM
2338 BFD_RELOC_D30V_32
2339 ENUMDOC
2340 This is a 32-bit absolute reloc.
2341 ENUM
2342 BFD_RELOC_D30V_32_PCREL
2343 ENUMDOC
2344 This is a 32-bit pc-relative reloc.
2345 COMMENT
2346 {* end-sanitize-d30v *}
2347
2348 ENUM
2349 BFD_RELOC_M32R_24
2350 ENUMDOC
2351 Mitsubishi M32R relocs.
2352 This is a 24 bit absolute address.
2353 ENUM
2354 BFD_RELOC_M32R_10_PCREL
2355 ENUMDOC
2356 This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
2357 ENUM
2358 BFD_RELOC_M32R_18_PCREL
2359 ENUMDOC
2360 This is an 18-bit reloc with the right 2 bits assumed to be 0.
2361 ENUM
2362 BFD_RELOC_M32R_26_PCREL
2363 ENUMDOC
2364 This is a 26-bit reloc with the right 2 bits assumed to be 0.
2365 ENUM
2366 BFD_RELOC_M32R_HI16_ULO
2367 ENUMDOC
2368 This is a 16-bit reloc containing the high 16 bits of an address
2369 used when the lower 16 bits are treated as unsigned.
2370 ENUM
2371 BFD_RELOC_M32R_HI16_SLO
2372 ENUMDOC
2373 This is a 16-bit reloc containing the high 16 bits of an address
2374 used when the lower 16 bits are treated as signed.
2375 ENUM
2376 BFD_RELOC_M32R_LO16
2377 ENUMDOC
2378 This is a 16-bit reloc containing the lower 16 bits of an address.
2379 ENUM
2380 BFD_RELOC_M32R_SDA16
2381 ENUMDOC
2382 This is a 16-bit reloc containing the small data area offset for use in
2383 add3, load, and store instructions.
2384
2385 ENUM
2386 BFD_RELOC_V850_9_PCREL
2387 ENUMDOC
2388 This is a 9-bit reloc
2389 ENUM
2390 BFD_RELOC_V850_22_PCREL
2391 ENUMDOC
2392 This is a 22-bit reloc
2393
2394 ENUM
2395 BFD_RELOC_V850_SDA_16_16_OFFSET
2396 ENUMDOC
2397 This is a 16 bit offset from the short data area pointer.
2398 ENUM
2399 BFD_RELOC_V850_SDA_15_16_OFFSET
2400 ENUMDOC
2401 This is a 16 bit offset (of which only 15 bits are used) from the
2402 short data area pointer.
2403 ENUM
2404 BFD_RELOC_V850_ZDA_16_16_OFFSET
2405 ENUMDOC
2406 This is a 16 bit offset from the zero data area pointer.
2407 ENUM
2408 BFD_RELOC_V850_ZDA_15_16_OFFSET
2409 ENUMDOC
2410 This is a 16 bit offset (of which only 15 bits are used) from the
2411 zero data area pointer.
2412 ENUM
2413 BFD_RELOC_V850_TDA_6_8_OFFSET
2414 ENUMDOC
2415 This is an 8 bit offset (of which only 6 bits are used) from the
2416 tiny data area pointer.
2417 ENUM
2418 BFD_RELOC_V850_TDA_7_8_OFFSET
2419 ENUMDOC
2420 This is an 8bit offset (of which only 7 bits are used) from the tiny
2421 data area pointer.
2422 ENUM
2423 BFD_RELOC_V850_TDA_7_7_OFFSET
2424 ENUMDOC
2425 This is a 7 bit offset from the tiny data area pointer.
2426 ENUM
2427 BFD_RELOC_V850_TDA_16_16_OFFSET
2428 ENUMDOC
2429 This is a 16 bit offset from the tiny data area pointer.
2430 COMMENT
2431 {* start-sanitize-v850e *}
2432 ENUM
2433 BFD_RELOC_V850_TDA_4_5_OFFSET
2434 ENUMDOC
2435 This is a 5 bit offset (of which only 4 bits are used) from the tiny
2436 data area pointer.
2437 ENUM
2438 BFD_RELOC_V850_TDA_4_4_OFFSET
2439 ENUMDOC
2440 This is a 4 bit offset from the tiny data area pointer.
2441 ENUM
2442 BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
2443 ENUMDOC
2444 This is a 16 bit offset from the short data area pointer, with the
2445 bits placed non-contigously in the instruction.
2446 ENUM
2447 BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
2448 ENUMDOC
2449 This is a 16 bit offset from the zero data area pointer, with the
2450 bits placed non-contigously in the instruction.
2451 ENUM
2452 BFD_RELOC_V850_CALLT_6_7_OFFSET
2453 ENUMDOC
2454 This is a 6 bit offset from the call table base pointer.
2455 ENUM
2456 BFD_RELOC_V850_CALLT_16_16_OFFSET
2457 ENUMDOC
2458 This is a 16 bit offset from the call table base pointer.
2459 COMMENT
2460 {* end-sanitize-v850e *}
2461
2462 ENUM
2463 BFD_RELOC_MN10300_32_PCREL
2464 ENUMDOC
2465 This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2466 instruction.
2467 ENUM
2468 BFD_RELOC_MN10300_16_PCREL
2469 ENUMDOC
2470 This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2471 instruction.
2472
2473 ENUM
2474 BFD_RELOC_TIC30_LDP
2475 ENUMDOC
2476 This is a 8bit DP reloc for the tms320c30, where the most
2477 significant 8 bits of a 24 bit word are placed into the least
2478 significant 8 bits of the opcode.
2479
2480 ENDSENUM
2481 BFD_RELOC_UNUSED
2482 CODE_FRAGMENT
2483 .
2484 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2485 */
2486
2487
2488 /*
2489 FUNCTION
2490 bfd_reloc_type_lookup
2491
2492 SYNOPSIS
2493 reloc_howto_type *
2494 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
2495
2496 DESCRIPTION
2497 Return a pointer to a howto structure which, when
2498 invoked, will perform the relocation @var{code} on data from the
2499 architecture noted.
2500
2501 */
2502
2503
2504 reloc_howto_type *
2505 bfd_reloc_type_lookup (abfd, code)
2506 bfd *abfd;
2507 bfd_reloc_code_real_type code;
2508 {
2509 return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
2510 }
2511
2512 static reloc_howto_type bfd_howto_32 =
2513 HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
2514
2515
2516 /*
2517 INTERNAL_FUNCTION
2518 bfd_default_reloc_type_lookup
2519
2520 SYNOPSIS
2521 reloc_howto_type *bfd_default_reloc_type_lookup
2522 (bfd *abfd, bfd_reloc_code_real_type code);
2523
2524 DESCRIPTION
2525 Provides a default relocation lookup routine for any architecture.
2526
2527
2528 */
2529
2530 reloc_howto_type *
2531 bfd_default_reloc_type_lookup (abfd, code)
2532 bfd *abfd;
2533 bfd_reloc_code_real_type code;
2534 {
2535 switch (code)
2536 {
2537 case BFD_RELOC_CTOR:
2538 /* The type of reloc used in a ctor, which will be as wide as the
2539 address - so either a 64, 32, or 16 bitter. */
2540 switch (bfd_get_arch_info (abfd)->bits_per_address)
2541 {
2542 case 64:
2543 BFD_FAIL ();
2544 case 32:
2545 return &bfd_howto_32;
2546 case 16:
2547 BFD_FAIL ();
2548 default:
2549 BFD_FAIL ();
2550 }
2551 default:
2552 BFD_FAIL ();
2553 }
2554 return (reloc_howto_type *) NULL;
2555 }
2556
2557 /*
2558 FUNCTION
2559 bfd_get_reloc_code_name
2560
2561 SYNOPSIS
2562 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
2563
2564 DESCRIPTION
2565 Provides a printable name for the supplied relocation code.
2566 Useful mainly for printing error messages.
2567 */
2568
2569 const char *
2570 bfd_get_reloc_code_name (code)
2571 bfd_reloc_code_real_type code;
2572 {
2573 if (code > BFD_RELOC_UNUSED)
2574 return 0;
2575 return bfd_reloc_code_real_names[(int)code];
2576 }
2577
2578 /*
2579 INTERNAL_FUNCTION
2580 bfd_generic_relax_section
2581
2582 SYNOPSIS
2583 boolean bfd_generic_relax_section
2584 (bfd *abfd,
2585 asection *section,
2586 struct bfd_link_info *,
2587 boolean *);
2588
2589 DESCRIPTION
2590 Provides default handling for relaxing for back ends which
2591 don't do relaxing -- i.e., does nothing.
2592 */
2593
2594 /*ARGSUSED*/
2595 boolean
2596 bfd_generic_relax_section (abfd, section, link_info, again)
2597 bfd *abfd;
2598 asection *section;
2599 struct bfd_link_info *link_info;
2600 boolean *again;
2601 {
2602 *again = false;
2603 return true;
2604 }
2605
2606 /*
2607 INTERNAL_FUNCTION
2608 bfd_generic_get_relocated_section_contents
2609
2610 SYNOPSIS
2611 bfd_byte *
2612 bfd_generic_get_relocated_section_contents (bfd *abfd,
2613 struct bfd_link_info *link_info,
2614 struct bfd_link_order *link_order,
2615 bfd_byte *data,
2616 boolean relocateable,
2617 asymbol **symbols);
2618
2619 DESCRIPTION
2620 Provides default handling of relocation effort for back ends
2621 which can't be bothered to do it efficiently.
2622
2623 */
2624
2625 bfd_byte *
2626 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
2627 relocateable, symbols)
2628 bfd *abfd;
2629 struct bfd_link_info *link_info;
2630 struct bfd_link_order *link_order;
2631 bfd_byte *data;
2632 boolean relocateable;
2633 asymbol **symbols;
2634 {
2635 /* Get enough memory to hold the stuff */
2636 bfd *input_bfd = link_order->u.indirect.section->owner;
2637 asection *input_section = link_order->u.indirect.section;
2638
2639 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
2640 arelent **reloc_vector = NULL;
2641 long reloc_count;
2642
2643 if (reloc_size < 0)
2644 goto error_return;
2645
2646 reloc_vector = (arelent **) bfd_malloc ((size_t) reloc_size);
2647 if (reloc_vector == NULL && reloc_size != 0)
2648 goto error_return;
2649
2650 /* read in the section */
2651 if (!bfd_get_section_contents (input_bfd,
2652 input_section,
2653 (PTR) data,
2654 0,
2655 input_section->_raw_size))
2656 goto error_return;
2657
2658 /* We're not relaxing the section, so just copy the size info */
2659 input_section->_cooked_size = input_section->_raw_size;
2660 input_section->reloc_done = true;
2661
2662 reloc_count = bfd_canonicalize_reloc (input_bfd,
2663 input_section,
2664 reloc_vector,
2665 symbols);
2666 if (reloc_count < 0)
2667 goto error_return;
2668
2669 if (reloc_count > 0)
2670 {
2671 arelent **parent;
2672 for (parent = reloc_vector; *parent != (arelent *) NULL;
2673 parent++)
2674 {
2675 char *error_message = (char *) NULL;
2676 bfd_reloc_status_type r =
2677 bfd_perform_relocation (input_bfd,
2678 *parent,
2679 (PTR) data,
2680 input_section,
2681 relocateable ? abfd : (bfd *) NULL,
2682 &error_message);
2683
2684 if (relocateable)
2685 {
2686 asection *os = input_section->output_section;
2687
2688 /* A partial link, so keep the relocs */
2689 os->orelocation[os->reloc_count] = *parent;
2690 os->reloc_count++;
2691 }
2692
2693 if (r != bfd_reloc_ok)
2694 {
2695 switch (r)
2696 {
2697 case bfd_reloc_undefined:
2698 if (!((*link_info->callbacks->undefined_symbol)
2699 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2700 input_bfd, input_section, (*parent)->address)))
2701 goto error_return;
2702 break;
2703 case bfd_reloc_dangerous:
2704 BFD_ASSERT (error_message != (char *) NULL);
2705 if (!((*link_info->callbacks->reloc_dangerous)
2706 (link_info, error_message, input_bfd, input_section,
2707 (*parent)->address)))
2708 goto error_return;
2709 break;
2710 case bfd_reloc_overflow:
2711 if (!((*link_info->callbacks->reloc_overflow)
2712 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2713 (*parent)->howto->name, (*parent)->addend,
2714 input_bfd, input_section, (*parent)->address)))
2715 goto error_return;
2716 break;
2717 case bfd_reloc_outofrange:
2718 default:
2719 abort ();
2720 break;
2721 }
2722
2723 }
2724 }
2725 }
2726 if (reloc_vector != NULL)
2727 free (reloc_vector);
2728 return data;
2729
2730 error_return:
2731 if (reloc_vector != NULL)
2732 free (reloc_vector);
2733 return NULL;
2734 }
GDB Binutils - Deliverables
This page took 0.084848 seconds and 4 git commands to generate.