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