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