OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [bfd/] [reloc.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
/* BFD support for handling relocation entries.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3
   2000, 2001, 2002
4
   Free Software Foundation, Inc.
5
   Written by Cygnus Support.
6
 
7
This file is part of BFD, the Binary File Descriptor library.
8
 
9
This program is free software; you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation; either version 2 of the License, or
12
(at your option) any later version.
13
 
14
This program is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
GNU General Public License for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with this program; if not, write to the Free Software
21
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
22
 
23
/*
24
SECTION
25
        Relocations
26
 
27
        BFD maintains relocations in much the same way it maintains
28
        symbols: they are left alone until required, then read in
29
        en-masse and translated into an internal form.  A common
30
        routine <<bfd_perform_relocation>> acts upon the
31
        canonical form to do the fixup.
32
 
33
        Relocations are maintained on a per section basis,
34
        while symbols are maintained on a per BFD basis.
35
 
36
        All that a back end has to do to fit the BFD interface is to create
37
        a <<struct reloc_cache_entry>> for each relocation
38
        in a particular section, and fill in the right bits of the structures.
39
 
40
@menu
41
@* typedef arelent::
42
@* howto manager::
43
@end menu
44
 
45
*/
46
 
47
/* DO compile in the reloc_code name table from libbfd.h.  */
48
#define _BFD_MAKE_TABLE_bfd_reloc_code_real
49
 
50
#include "bfd.h"
51
#include "sysdep.h"
52
#include "bfdlink.h"
53
#include "libbfd.h"
54
/*
55
DOCDD
56
INODE
57
        typedef arelent, howto manager, Relocations, Relocations
58
 
59
SUBSECTION
60
        typedef arelent
61
 
62
        This is the structure of a relocation entry:
63
 
64
CODE_FRAGMENT
65
.
66
.typedef enum bfd_reloc_status
67
.{
68
.  {* No errors detected.  *}
69
.  bfd_reloc_ok,
70
.
71
.  {* The relocation was performed, but there was an overflow.  *}
72
.  bfd_reloc_overflow,
73
.
74
.  {* The address to relocate was not within the section supplied.  *}
75
.  bfd_reloc_outofrange,
76
.
77
.  {* Used by special functions.  *}
78
.  bfd_reloc_continue,
79
.
80
.  {* Unsupported relocation size requested.  *}
81
.  bfd_reloc_notsupported,
82
.
83
.  {* Unused.  *}
84
.  bfd_reloc_other,
85
.
86
.  {* The symbol to relocate against was undefined.  *}
87
.  bfd_reloc_undefined,
88
.
89
.  {* The relocation was performed, but may not be ok - presently
90
.     generated only when linking i960 coff files with i960 b.out
91
.     symbols.  If this type is returned, the error_message argument
92
.     to bfd_perform_relocation will be set.  *}
93
.  bfd_reloc_dangerous
94
. }
95
. bfd_reloc_status_type;
96
.
97
.
98
.typedef struct reloc_cache_entry
99
.{
100
.  {* A pointer into the canonical table of pointers.  *}
101
.  struct symbol_cache_entry **sym_ptr_ptr;
102
.
103
.  {* offset in section.  *}
104
.  bfd_size_type address;
105
.
106
.  {* addend for relocation value.  *}
107
.  bfd_vma addend;
108
.
109
.  {* Pointer to how to perform the required relocation.  *}
110
.  reloc_howto_type *howto;
111
.
112
.}
113
.arelent;
114
.
115
*/
116
 
117
/*
118
DESCRIPTION
119
 
120
        Here is a description of each of the fields within an <<arelent>>:
121
 
122
        o <<sym_ptr_ptr>>
123
 
124
        The symbol table pointer points to a pointer to the symbol
125
        associated with the relocation request.  It is
126
        the pointer into the table returned by the back end's
127
        <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
128
        through a pointer to a pointer so that tools like the linker
129
        can fix up all the symbols of the same name by modifying only
130
        one pointer. The relocation routine looks in the symbol and
131
        uses the base of the section the symbol is attached to and the
132
        value of the symbol as the initial relocation offset. If the
133
        symbol pointer is zero, then the section provided is looked up.
134
 
135
        o <<address>>
136
 
137
        The <<address>> field gives the offset in bytes from the base of
138
        the section data which owns the relocation record to the first
139
        byte of relocatable information. The actual data relocated
140
        will be relative to this point; for example, a relocation
141
        type which modifies the bottom two bytes of a four byte word
142
        would not touch the first byte pointed to in a big endian
143
        world.
144
 
145
        o <<addend>>
146
 
147
        The <<addend>> is a value provided by the back end to be added (!)
148
        to the relocation offset. Its interpretation is dependent upon
149
        the howto. For example, on the 68k the code:
150
 
151
|        char foo[];
152
|        main()
153
|                {
154
|                return foo[0x12345678];
155
|                }
156
 
157
        Could be compiled into:
158
 
159
|        linkw fp,#-4
160
|        moveb @@#12345678,d0
161
|        extbl d0
162
|        unlk fp
163
|        rts
164
 
165
        This could create a reloc pointing to <<foo>>, but leave the
166
        offset in the data, something like:
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
        Using coff and an 88k, some instructions don't have enough
179
        space in them to represent the full address range, and
180
        pointers have to be loaded in two parts. So you'd get something like:
181
 
182
|        or.u     r13,r0,hi16(_foo+0x12345678)
183
|        ld.b     r2,r13,lo16(_foo+0x12345678)
184
|        jmp      r1
185
 
186
        This should create two relocs, both pointing to <<_foo>>, and with
187
        0x12340000 in their addend field. The data would consist of:
188
 
189
|RELOCATION RECORDS FOR [.text]:
190
|offset   type      value
191
|00000002 HVRT16    _foo+0x12340000
192
|00000006 LVRT16    _foo+0x12340000
193
|
194
|00000000 5da05678           ; or.u r13,r0,0x5678
195
|00000004 1c4d5678           ; ld.b r2,r13,0x5678
196
|00000008 f400c001           ; jmp r1
197
 
198
        The relocation routine digs out the value from the data, adds
199
        it to the addend to get the original offset, and then adds the
200
        value of <<_foo>>. Note that all 32 bits have to be kept around
201
        somewhere, to cope with carry from bit 15 to bit 16.
202
 
203
        One further example is the sparc and the a.out format. The
204
        sparc has a similar problem to the 88k, in that some
205
        instructions don't have room for an entire offset, but on the
206
        sparc the parts are created in odd sized lumps. The designers of
207
        the a.out format chose to not use the data within the section
208
        for storing part of the offset; all the offset is kept within
209
        the reloc. Anything in the data should be ignored.
210
 
211
|        save %sp,-112,%sp
212
|        sethi %hi(_foo+0x12345678),%g2
213
|        ldsb [%g2+%lo(_foo+0x12345678)],%i0
214
|        ret
215
|        restore
216
 
217
        Both relocs contain a pointer to <<foo>>, and the offsets
218
        contain junk.
219
 
220
|RELOCATION RECORDS FOR [.text]:
221
|offset   type      value
222
|00000004 HI22      _foo+0x12345678
223
|00000008 LO10      _foo+0x12345678
224
|
225
|00000000 9de3bf90     ; save %sp,-112,%sp
226
|00000004 05000000     ; sethi %hi(_foo+0),%g2
227
|00000008 f048a000     ; ldsb [%g2+%lo(_foo+0)],%i0
228
|0000000c 81c7e008     ; ret
229
|00000010 81e80000     ; restore
230
 
231
        o <<howto>>
232
 
233
        The <<howto>> field can be imagined as a
234
        relocation instruction. It is a pointer to a structure which
235
        contains information on what to do with all of the other
236
        information in the reloc record and data section. A back end
237
        would normally have a relocation instruction set and turn
238
        relocations into pointers to the correct structure on input -
239
        but it would be possible to create each howto field on demand.
240
 
241
*/
242
 
243
/*
244
SUBSUBSECTION
245
        <<enum complain_overflow>>
246
 
247
        Indicates what sort of overflow checking should be done when
248
        performing a relocation.
249
 
250
CODE_FRAGMENT
251
.
252
.enum complain_overflow
253
.{
254
.  {* Do not complain on overflow.  *}
255
.  complain_overflow_dont,
256
.
257
.  {* Complain if the bitfield overflows, whether it is considered
258
.     as signed or unsigned.  *}
259
.  complain_overflow_bitfield,
260
.
261
.  {* Complain if the value overflows when considered as signed
262
.     number.  *}
263
.  complain_overflow_signed,
264
.
265
.  {* Complain if the value overflows when considered as an
266
.     unsigned number.  *}
267
.  complain_overflow_unsigned
268
.};
269
 
270
*/
271
 
272
/*
273
SUBSUBSECTION
274
        <<reloc_howto_type>>
275
 
276
        The <<reloc_howto_type>> is a structure which contains all the
277
        information that libbfd needs to know to tie up a back end's data.
278
 
279
CODE_FRAGMENT
280
.struct symbol_cache_entry;             {* Forward declaration.  *}
281
.
282
.struct reloc_howto_struct
283
.{
284
.  {*  The type field has mainly a documentary use - the back end can
285
.      do what it wants with it, though normally the back end's
286
.      external idea of what a reloc number is stored
287
.      in this field.  For example, a PC relative word relocation
288
.      in a coff environment has the type 023 - because that's
289
.      what the outside world calls a R_PCRWORD reloc.  *}
290
.  unsigned int type;
291
.
292
.  {*  The value the final relocation is shifted right by.  This drops
293
.      unwanted data from the relocation.  *}
294
.  unsigned int rightshift;
295
.
296
.  {*  The size of the item to be relocated.  This is *not* a
297
.      power-of-two measure.  To get the number of bytes operated
298
.      on by a type of relocation, use bfd_get_reloc_size.  *}
299
.  int size;
300
.
301
.  {*  The number of bits in the item to be relocated.  This is used
302
.      when doing overflow checking.  *}
303
.  unsigned int bitsize;
304
.
305
.  {*  Notes that the relocation is relative to the location in the
306
.      data section of the addend.  The relocation function will
307
.      subtract from the relocation value the address of the location
308
.      being relocated.  *}
309
.  boolean pc_relative;
310
.
311
.  {*  The bit position of the reloc value in the destination.
312
.      The relocated value is left shifted by this amount.  *}
313
.  unsigned int bitpos;
314
.
315
.  {* What type of overflow error should be checked for when
316
.     relocating.  *}
317
.  enum complain_overflow complain_on_overflow;
318
.
319
.  {* If this field is non null, then the supplied function is
320
.     called rather than the normal function.  This allows really
321
.     strange relocation methods to be accomodated (e.g., i960 callj
322
.     instructions).  *}
323
.  bfd_reloc_status_type (*special_function)
324
.    PARAMS ((bfd *, arelent *, struct symbol_cache_entry *, PTR, asection *,
325
.             bfd *, char **));
326
.
327
.  {* The textual name of the relocation type.  *}
328
.  char *name;
329
.
330
.  {* Some formats record a relocation addend in the section contents
331
.     rather than with the relocation.  For ELF formats this is the
332
.     distinction between USE_REL and USE_RELA (though the code checks
333
.     for USE_REL == 1/0).  The value of this field is TRUE if the
334
.     addend is recorded with the section contents; when performing a
335
.     partial link (ld -r) the section contents (the data) will be
336
.     modified.  The value of this field is FALSE if addends are
337
.     recorded with the relocation (in arelent.addend); when performing
338
.     a partial link the relocation will be modified.
339
.     All relocations for all ELF USE_RELA targets should set this field
340
.     to FALSE (values of TRUE should be looked on with suspicion).
341
.     However, the converse is not true: not all relocations of all ELF
342
.     USE_REL targets set this field to TRUE.  Why this is so is peculiar
343
.     to each particular target.  For relocs that aren't used in partial
344
.     links (e.g. GOT stuff) it doesn't matter what this is set to.  *}
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
.     byte 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
FUNCTION
375
        The HOWTO Macro
376
 
377
DESCRIPTION
378
        The HOWTO define is horrible and will go away.
379
 
380
.#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
381
.  { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }
382
 
383
DESCRIPTION
384
        And will be replaced with the totally magic way. But for the
385
        moment, we are compatible, so do it this way.
386
 
387
.#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \
388
.  HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \
389
.         NAME, false, 0, 0, IN)
390
.
391
 
392
DESCRIPTION
393
        This is used to fill in an empty howto entry in an array.
394
 
395
.#define EMPTY_HOWTO(C) \
396
.  HOWTO ((C), 0, 0, 0, false, 0, complain_overflow_dont, NULL, \
397
.         NULL, false, 0, 0, false)
398
.
399
 
400
DESCRIPTION
401
        Helper routine to turn a symbol into a relocation value.
402
 
403
.#define HOWTO_PREPARE(relocation, symbol)               \
404
.  {                                                     \
405
.    if (symbol != (asymbol *) NULL)                     \
406
.      {                                                 \
407
.        if (bfd_is_com_section (symbol->section))       \
408
.          {                                             \
409
.            relocation = 0;                             \
410
.          }                                             \
411
.        else                                            \
412
.          {                                             \
413
.            relocation = symbol->value;                 \
414
.          }                                             \
415
.      }                                                 \
416
.  }
417
.
418
*/
419
 
420
/*
421
FUNCTION
422
        bfd_get_reloc_size
423
 
424
SYNOPSIS
425
        unsigned int bfd_get_reloc_size (reloc_howto_type *);
426
 
427
DESCRIPTION
428
        For a reloc_howto_type that operates on a fixed number of bytes,
429
        this returns the number of bytes operated on.
430
 */
431
 
432
unsigned int
433
bfd_get_reloc_size (howto)
434
     reloc_howto_type *howto;
435
{
436
  switch (howto->size)
437
    {
438
    case 0: return 1;
439
    case 1: return 2;
440
    case 2: return 4;
441
    case 3: return 0;
442
    case 4: return 8;
443
    case 8: return 16;
444
    case -2: return 4;
445
    default: abort ();
446
    }
447
}
448
 
449
/*
450
TYPEDEF
451
        arelent_chain
452
 
453
DESCRIPTION
454
 
455
        How relocs are tied together in an <<asection>>:
456
 
457
.typedef struct relent_chain
458
.{
459
.  arelent relent;
460
.  struct relent_chain *next;
461
.}
462
.arelent_chain;
463
.
464
*/
465
 
466
/* N_ONES produces N one bits, without overflowing machine arithmetic.  */
467
#define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
468
 
469
/*
470
FUNCTION
471
        bfd_check_overflow
472
 
473
SYNOPSIS
474
        bfd_reloc_status_type
475
                bfd_check_overflow
476
                        (enum complain_overflow how,
477
                         unsigned int bitsize,
478
                         unsigned int rightshift,
479
                         unsigned int addrsize,
480
                         bfd_vma relocation);
481
 
482
DESCRIPTION
483
        Perform overflow checking on @var{relocation} which has
484
        @var{bitsize} significant bits and will be shifted right by
485
        @var{rightshift} bits, on a machine with addresses containing
486
        @var{addrsize} significant bits.  The result is either of
487
        @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
488
 
489
*/
490
 
491
bfd_reloc_status_type
492
bfd_check_overflow (how, bitsize, rightshift, addrsize, relocation)
493
     enum complain_overflow how;
494
     unsigned int bitsize;
495
     unsigned int rightshift;
496
     unsigned int addrsize;
497
     bfd_vma relocation;
498
{
499
  bfd_vma fieldmask, addrmask, signmask, ss, a;
500
  bfd_reloc_status_type flag = bfd_reloc_ok;
501
 
502
  a = relocation;
503
 
504
  /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
505
     we'll be permissive: extra bits in the field mask will
506
     automatically extend the address mask for purposes of the
507
     overflow check.  */
508
  fieldmask = N_ONES (bitsize);
509
  addrmask = N_ONES (addrsize) | fieldmask;
510
 
511
  switch (how)
512
    {
513
    case complain_overflow_dont:
514
      break;
515
 
516
    case complain_overflow_signed:
517
      /* If any sign bits are set, all sign bits must be set.  That
518
         is, A must be a valid negative address after shifting.  */
519
      a = (a & addrmask) >> rightshift;
520
      signmask = ~ (fieldmask >> 1);
521
      ss = a & signmask;
522
      if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
523
        flag = bfd_reloc_overflow;
524
      break;
525
 
526
    case complain_overflow_unsigned:
527
      /* We have an overflow if the address does not fit in the field.  */
528
      a = (a & addrmask) >> rightshift;
529
      if ((a & ~ fieldmask) != 0)
530
        flag = bfd_reloc_overflow;
531
      break;
532
 
533
    case complain_overflow_bitfield:
534
      /* Bitfields are sometimes signed, sometimes unsigned.  We
535
         explicitly allow an address wrap too, which means a bitfield
536
         of n bits is allowed to store -2**n to 2**n-1.  Thus overflow
537
         if the value has some, but not all, bits set outside the
538
         field.  */
539
      a >>= rightshift;
540
      ss = a & ~ fieldmask;
541
      if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & ~ fieldmask))
542
        flag = bfd_reloc_overflow;
543
      break;
544
 
545
    default:
546
      abort ();
547
    }
548
 
549
  return flag;
550
}
551
 
552
/*
553
FUNCTION
554
        bfd_perform_relocation
555
 
556
SYNOPSIS
557
        bfd_reloc_status_type
558
                bfd_perform_relocation
559
                        (bfd *abfd,
560
                         arelent *reloc_entry,
561
                         PTR data,
562
                         asection *input_section,
563
                         bfd *output_bfd,
564
                         char **error_message);
565
 
566
DESCRIPTION
567
        If @var{output_bfd} is supplied to this function, the
568
        generated image will be relocatable; the relocations are
569
        copied to the output file after they have been changed to
570
        reflect the new state of the world. There are two ways of
571
        reflecting the results of partial linkage in an output file:
572
        by modifying the output data in place, and by modifying the
573
        relocation record.  Some native formats (e.g., basic a.out and
574
        basic coff) have no way of specifying an addend in the
575
        relocation type, so the addend has to go in the output data.
576
        This is no big deal since in these formats the output data
577
        slot will always be big enough for the addend. Complex reloc
578
        types with addends were invented to solve just this problem.
579
        The @var{error_message} argument is set to an error message if
580
        this return @code{bfd_reloc_dangerous}.
581
 
582
*/
583
 
584
bfd_reloc_status_type
585
bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
586
                        error_message)
587
     bfd *abfd;
588
     arelent *reloc_entry;
589
     PTR data;
590
     asection *input_section;
591
     bfd *output_bfd;
592
     char **error_message;
593
{
594
  bfd_vma relocation;
595
  bfd_reloc_status_type flag = bfd_reloc_ok;
596
  bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
597
  bfd_vma output_base = 0;
598
  reloc_howto_type *howto = reloc_entry->howto;
599
  asection *reloc_target_output_section;
600
  asymbol *symbol;
601
 
602
  symbol = *(reloc_entry->sym_ptr_ptr);
603
  if (bfd_is_abs_section (symbol->section)
604
      && output_bfd != (bfd *) NULL)
605
    {
606
      reloc_entry->address += input_section->output_offset;
607
      return bfd_reloc_ok;
608
    }
609
 
610
  /* If we are not producing relocateable output, return an error if
611
     the symbol is not defined.  An undefined weak symbol is
612
     considered to have a value of zero (SVR4 ABI, p. 4-27).  */
613
  if (bfd_is_und_section (symbol->section)
614
      && (symbol->flags & BSF_WEAK) == 0
615
      && output_bfd == (bfd *) NULL)
616
    flag = bfd_reloc_undefined;
617
 
618
  /* If there is a function supplied to handle this relocation type,
619
     call it.  It'll return `bfd_reloc_continue' if further processing
620
     can be done.  */
621
  if (howto->special_function)
622
    {
623
      bfd_reloc_status_type cont;
624
      cont = howto->special_function (abfd, reloc_entry, symbol, data,
625
                                      input_section, output_bfd,
626
                                      error_message);
627
      if (cont != bfd_reloc_continue)
628
        return cont;
629
    }
630
 
631
  /* Is the address of the relocation really within the section?  */
632
  if (reloc_entry->address > (input_section->_cooked_size
633
                              / bfd_octets_per_byte (abfd)))
634
    return bfd_reloc_outofrange;
635
 
636
  /* Work out which section the relocation is targetted at and the
637
     initial relocation command value.  */
638
 
639
  /* Get symbol value.  (Common symbols are special.)  */
640
  if (bfd_is_com_section (symbol->section))
641
    relocation = 0;
642
  else
643
    relocation = symbol->value;
644
 
645
  reloc_target_output_section = symbol->section->output_section;
646
 
647
  /* Convert input-section-relative symbol value to absolute.  */
648
  if (output_bfd && ! howto->partial_inplace)
649
    output_base = 0;
650
  else
651
    output_base = reloc_target_output_section->vma;
652
 
653
  relocation += output_base + symbol->section->output_offset;
654
 
655
  /* Add in supplied addend.  */
656
  relocation += reloc_entry->addend;
657
 
658
  /* Here the variable relocation holds the final address of the
659
     symbol we are relocating against, plus any addend.  */
660
 
661
  if (howto->pc_relative)
662
    {
663
      /* This is a PC relative relocation.  We want to set RELOCATION
664
         to the distance between the address of the symbol and the
665
         location.  RELOCATION is already the address of the symbol.
666
 
667
         We start by subtracting the address of the section containing
668
         the location.
669
 
670
         If pcrel_offset is set, we must further subtract the position
671
         of the location within the section.  Some targets arrange for
672
         the addend to be the negative of the position of the location
673
         within the section; for example, i386-aout does this.  For
674
         i386-aout, pcrel_offset is false.  Some other targets do not
675
         include the position of the location; for example, m88kbcs,
676
         or ELF.  For those targets, pcrel_offset is true.
677
 
678
         If we are producing relocateable output, then we must ensure
679
         that this reloc will be correctly computed when the final
680
         relocation is done.  If pcrel_offset is false we want to wind
681
         up with the negative of the location within the section,
682
         which means we must adjust the existing addend by the change
683
         in the location within the section.  If pcrel_offset is true
684
         we do not want to adjust the existing addend at all.
685
 
686
         FIXME: This seems logical to me, but for the case of
687
         producing relocateable output it is not what the code
688
         actually does.  I don't want to change it, because it seems
689
         far too likely that something will break.  */
690
 
691
      relocation -=
692
        input_section->output_section->vma + input_section->output_offset;
693
 
694
      if (howto->pcrel_offset)
695
        relocation -= reloc_entry->address;
696
    }
697
 
698
  if (output_bfd != (bfd *) NULL)
699
    {
700
      if (! howto->partial_inplace)
701
        {
702
          /* This is a partial relocation, and we want to apply the relocation
703
             to the reloc entry rather than the raw data. Modify the reloc
704
             inplace to reflect what we now know.  */
705
          reloc_entry->addend = relocation;
706
          reloc_entry->address += input_section->output_offset;
707
          return flag;
708
        }
709
      else
710
        {
711
          /* This is a partial relocation, but inplace, so modify the
712
             reloc record a bit.
713
 
714
             If we've relocated with a symbol with a section, change
715
             into a ref to the section belonging to the symbol.  */
716
 
717
          reloc_entry->address += input_section->output_offset;
718
 
719
          /* WTF?? */
720
          if (abfd->xvec->flavour == bfd_target_coff_flavour
721
              && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
722
              && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
723
            {
724
#if 1
725
              /* For m68k-coff, the addend was being subtracted twice during
726
                 relocation with -r.  Removing the line below this comment
727
                 fixes that problem; see PR 2953.
728
 
729
However, Ian wrote the following, regarding removing the line below,
730
which explains why it is still enabled:  --djm
731
 
732
If you put a patch like that into BFD you need to check all the COFF
733
linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
734
SCO); see coff_i386_reloc in coff-i386.c where I worked around the
735
problem in a different way.  There may very well be a reason that the
736
code works as it does.
737
 
738
Hmmm.  The first obvious point is that bfd_perform_relocation should
739
not have any tests that depend upon the flavour.  It's seem like
740
entirely the wrong place for such a thing.  The second obvious point
741
is that the current code ignores the reloc addend when producing
742
relocateable output for COFF.  That's peculiar.  In fact, I really
743
have no idea what the point of the line you want to remove is.
744
 
745
A typical COFF reloc subtracts the old value of the symbol and adds in
746
the new value to the location in the object file (if it's a pc
747
relative reloc it adds the difference between the symbol value and the
748
location).  When relocating we need to preserve that property.
749
 
750
BFD handles this by setting the addend to the negative of the old
751
value of the symbol.  Unfortunately it handles common symbols in a
752
non-standard way (it doesn't subtract the old value) but that's a
753
different story (we can't change it without losing backward
754
compatibility with old object files) (coff-i386 does subtract the old
755
value, to be compatible with existing coff-i386 targets, like SCO).
756
 
757
So everything works fine when not producing relocateable output.  When
758
we are producing relocateable output, logically we should do exactly
759
what we do when not producing relocateable output.  Therefore, your
760
patch is correct.  In fact, it should probably always just set
761
reloc_entry->addend to 0 for all cases, since it is, in fact, going to
762
add the value into the object file.  This won't hurt the COFF code,
763
which doesn't use the addend; I'm not sure what it will do to other
764
formats (the thing to check for would be whether any formats both use
765
the addend and set partial_inplace).
766
 
767
When I wanted to make coff-i386 produce relocateable output, I ran
768
into the problem that you are running into: I wanted to remove that
769
line.  Rather than risk it, I made the coff-i386 relocs use a special
770
function; it's coff_i386_reloc in coff-i386.c.  The function
771
specifically adds the addend field into the object file, knowing that
772
bfd_perform_relocation is not going to.  If you remove that line, then
773
coff-i386.c will wind up adding the addend field in twice.  It's
774
trivial to fix; it just needs to be done.
775
 
776
The problem with removing the line is just that it may break some
777
working code.  With BFD it's hard to be sure of anything.  The right
778
way to deal with this is simply to build and test at least all the
779
supported COFF targets.  It should be straightforward if time and disk
780
space consuming.  For each target:
781
    1) build the linker
782
    2) generate some executable, and link it using -r (I would
783
       probably use paranoia.o and link against newlib/libc.a, which
784
       for all the supported targets would be available in
785
       /usr/cygnus/progressive/H-host/target/lib/libc.a).
786
    3) make the change to reloc.c
787
    4) rebuild the linker
788
    5) repeat step 2
789
    6) if the resulting object files are the same, you have at least
790
       made it no worse
791
    7) if they are different you have to figure out which version is
792
       right
793
*/
794
              relocation -= reloc_entry->addend;
795
#endif
796
              reloc_entry->addend = 0;
797
            }
798
          else
799
            {
800
              reloc_entry->addend = relocation;
801
            }
802
        }
803
    }
804
  else
805
    {
806
      reloc_entry->addend = 0;
807
    }
808
 
809
  /* FIXME: This overflow checking is incomplete, because the value
810
     might have overflowed before we get here.  For a correct check we
811
     need to compute the value in a size larger than bitsize, but we
812
     can't reasonably do that for a reloc the same size as a host
813
     machine word.
814
     FIXME: We should also do overflow checking on the result after
815
     adding in the value contained in the object file.  */
816
  if (howto->complain_on_overflow != complain_overflow_dont
817
      && flag == bfd_reloc_ok)
818
    flag = bfd_check_overflow (howto->complain_on_overflow,
819
                               howto->bitsize,
820
                               howto->rightshift,
821
                               bfd_arch_bits_per_address (abfd),
822
                               relocation);
823
 
824
  /* Either we are relocating all the way, or we don't want to apply
825
     the relocation to the reloc entry (probably because there isn't
826
     any room in the output format to describe addends to relocs).  */
827
 
828
  /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
829
     (OSF version 1.3, compiler version 3.11).  It miscompiles the
830
     following program:
831
 
832
     struct str
833
     {
834
       unsigned int i0;
835
     } s = { 0 };
836
 
837
     int
838
     main ()
839
     {
840
       unsigned long x;
841
 
842
       x = 0x100000000;
843
       x <<= (unsigned long) s.i0;
844
       if (x == 0)
845
         printf ("failed\n");
846
       else
847
         printf ("succeeded (%lx)\n", x);
848
     }
849
     */
850
 
851
  relocation >>= (bfd_vma) howto->rightshift;
852
 
853
  /* Shift everything up to where it's going to be used.  */
854
  relocation <<= (bfd_vma) howto->bitpos;
855
 
856
  /* Wait for the day when all have the mask in them.  */
857
 
858
  /* What we do:
859
     i instruction to be left alone
860
     o offset within instruction
861
     r relocation offset to apply
862
     S src mask
863
     D dst mask
864
     N ~dst mask
865
     A part 1
866
     B part 2
867
     R result
868
 
869
     Do this:
870
     ((  i i i i i o o o o o  from bfd_get<size>
871
     and           S S S S S) to get the size offset we want
872
     +   r r r r r r r r r r) to get the final value to place
873
     and           D D D D D  to chop to right size
874
     -----------------------
875
     =             A A A A A
876
     And this:
877
     (   i i i i i o o o o o  from bfd_get<size>
878
     and N N N N N          ) get instruction
879
     -----------------------
880
     =   B B B B B
881
 
882
     And then:
883
     (   B B B B B
884
     or            A A A A A)
885
     -----------------------
886
     =   R R R R R R R R R R  put into bfd_put<size>
887
     */
888
 
889
#define DOIT(x) \
890
  x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
891
 
892
  switch (howto->size)
893
    {
894
    case 0:
895
      {
896
        char x = bfd_get_8 (abfd, (char *) data + octets);
897
        DOIT (x);
898
        bfd_put_8 (abfd, x, (unsigned char *) data + octets);
899
      }
900
      break;
901
 
902
    case 1:
903
      {
904
        short x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
905
        DOIT (x);
906
        bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets);
907
      }
908
      break;
909
    case 2:
910
      {
911
        long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
912
        DOIT (x);
913
        bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
914
      }
915
      break;
916
    case -2:
917
      {
918
        long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
919
        relocation = -relocation;
920
        DOIT (x);
921
        bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
922
      }
923
      break;
924
 
925
    case -1:
926
      {
927
        long x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
928
        relocation = -relocation;
929
        DOIT (x);
930
        bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
931
      }
932
      break;
933
 
934
    case 3:
935
      /* Do nothing */
936
      break;
937
 
938
    case 4:
939
#ifdef BFD64
940
      {
941
        bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets);
942
        DOIT (x);
943
        bfd_put_64 (abfd, x, (bfd_byte *) data + octets);
944
      }
945
#else
946
      abort ();
947
#endif
948
      break;
949
    default:
950
      return bfd_reloc_other;
951
    }
952
 
953
  return flag;
954
}
955
 
956
/*
957
FUNCTION
958
        bfd_install_relocation
959
 
960
SYNOPSIS
961
        bfd_reloc_status_type
962
                bfd_install_relocation
963
                        (bfd *abfd,
964
                         arelent *reloc_entry,
965
                         PTR data, bfd_vma data_start,
966
                         asection *input_section,
967
                         char **error_message);
968
 
969
DESCRIPTION
970
        This looks remarkably like <<bfd_perform_relocation>>, except it
971
        does not expect that the section contents have been filled in.
972
        I.e., it's suitable for use when creating, rather than applying
973
        a relocation.
974
 
975
        For now, this function should be considered reserved for the
976
        assembler.
977
*/
978
 
979
bfd_reloc_status_type
980
bfd_install_relocation (abfd, reloc_entry, data_start, data_start_offset,
981
                        input_section, error_message)
982
     bfd *abfd;
983
     arelent *reloc_entry;
984
     PTR data_start;
985
     bfd_vma data_start_offset;
986
     asection *input_section;
987
     char **error_message;
988
{
989
  bfd_vma relocation;
990
  bfd_reloc_status_type flag = bfd_reloc_ok;
991
  bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
992
  bfd_vma output_base = 0;
993
  reloc_howto_type *howto = reloc_entry->howto;
994
  asection *reloc_target_output_section;
995
  asymbol *symbol;
996
  bfd_byte *data;
997
 
998
  symbol = *(reloc_entry->sym_ptr_ptr);
999
  if (bfd_is_abs_section (symbol->section))
1000
    {
1001
      reloc_entry->address += input_section->output_offset;
1002
      return bfd_reloc_ok;
1003
    }
1004
 
1005
  /* If there is a function supplied to handle this relocation type,
1006
     call it.  It'll return `bfd_reloc_continue' if further processing
1007
     can be done.  */
1008
  if (howto->special_function)
1009
    {
1010
      bfd_reloc_status_type cont;
1011
 
1012
      /* XXX - The special_function calls haven't been fixed up to deal
1013
         with creating new relocations and section contents.  */
1014
      cont = howto->special_function (abfd, reloc_entry, symbol,
1015
                                      /* XXX - Non-portable! */
1016
                                      ((bfd_byte *) data_start
1017
                                       - data_start_offset),
1018
                                      input_section, abfd, error_message);
1019
      if (cont != bfd_reloc_continue)
1020
        return cont;
1021
    }
1022
 
1023
  /* Is the address of the relocation really within the section?  */
1024
  if (reloc_entry->address > (input_section->_cooked_size
1025
                              / bfd_octets_per_byte (abfd)))
1026
    return bfd_reloc_outofrange;
1027
 
1028
  /* Work out which section the relocation is targetted at and the
1029
     initial relocation command value.  */
1030
 
1031
  /* Get symbol value.  (Common symbols are special.)  */
1032
  if (bfd_is_com_section (symbol->section))
1033
    relocation = 0;
1034
  else
1035
    relocation = symbol->value;
1036
 
1037
  reloc_target_output_section = symbol->section->output_section;
1038
 
1039
  /* Convert input-section-relative symbol value to absolute.  */
1040
  if (! howto->partial_inplace)
1041
    output_base = 0;
1042
  else
1043
    output_base = reloc_target_output_section->vma;
1044
 
1045
  relocation += output_base + symbol->section->output_offset;
1046
 
1047
  /* Add in supplied addend.  */
1048
  relocation += reloc_entry->addend;
1049
 
1050
  /* Here the variable relocation holds the final address of the
1051
     symbol we are relocating against, plus any addend.  */
1052
 
1053
  if (howto->pc_relative)
1054
    {
1055
      /* This is a PC relative relocation.  We want to set RELOCATION
1056
         to the distance between the address of the symbol and the
1057
         location.  RELOCATION is already the address of the symbol.
1058
 
1059
         We start by subtracting the address of the section containing
1060
         the location.
1061
 
1062
         If pcrel_offset is set, we must further subtract the position
1063
         of the location within the section.  Some targets arrange for
1064
         the addend to be the negative of the position of the location
1065
         within the section; for example, i386-aout does this.  For
1066
         i386-aout, pcrel_offset is false.  Some other targets do not
1067
         include the position of the location; for example, m88kbcs,
1068
         or ELF.  For those targets, pcrel_offset is true.
1069
 
1070
         If we are producing relocateable output, then we must ensure
1071
         that this reloc will be correctly computed when the final
1072
         relocation is done.  If pcrel_offset is false we want to wind
1073
         up with the negative of the location within the section,
1074
         which means we must adjust the existing addend by the change
1075
         in the location within the section.  If pcrel_offset is true
1076
         we do not want to adjust the existing addend at all.
1077
 
1078
         FIXME: This seems logical to me, but for the case of
1079
         producing relocateable output it is not what the code
1080
         actually does.  I don't want to change it, because it seems
1081
         far too likely that something will break.  */
1082
 
1083
      relocation -=
1084
        input_section->output_section->vma + input_section->output_offset;
1085
 
1086
      if (howto->pcrel_offset && howto->partial_inplace)
1087
        relocation -= reloc_entry->address;
1088
    }
1089
 
1090
  if (! howto->partial_inplace)
1091
    {
1092
      /* This is a partial relocation, and we want to apply the relocation
1093
         to the reloc entry rather than the raw data. Modify the reloc
1094
         inplace to reflect what we now know.  */
1095
      reloc_entry->addend = relocation;
1096
      reloc_entry->address += input_section->output_offset;
1097
      return flag;
1098
    }
1099
  else
1100
    {
1101
      /* This is a partial relocation, but inplace, so modify the
1102
         reloc record a bit.
1103
 
1104
         If we've relocated with a symbol with a section, change
1105
         into a ref to the section belonging to the symbol.  */
1106
      reloc_entry->address += input_section->output_offset;
1107
 
1108
      /* WTF?? */
1109
      if (abfd->xvec->flavour == bfd_target_coff_flavour
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
 
1118
However, Ian wrote the following, regarding removing the line below,
1119
which explains why it is still enabled:  --djm
1120
 
1121
If you put a patch like that into BFD you need to check all the COFF
1122
linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
1123
SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1124
problem in a different way.  There may very well be a reason that the
1125
code works as it does.
1126
 
1127
Hmmm.  The first obvious point is that bfd_install_relocation should
1128
not have any tests that depend upon the flavour.  It's seem like
1129
entirely the wrong place for such a thing.  The second obvious point
1130
is that the current code ignores the reloc addend when producing
1131
relocateable output for COFF.  That's peculiar.  In fact, I really
1132
have no idea what the point of the line you want to remove is.
1133
 
1134
A typical COFF reloc subtracts the old value of the symbol and adds in
1135
the new value to the location in the object file (if it's a pc
1136
relative reloc it adds the difference between the symbol value and the
1137
location).  When relocating we need to preserve that property.
1138
 
1139
BFD handles this by setting the addend to the negative of the old
1140
value of the symbol.  Unfortunately it handles common symbols in a
1141
non-standard way (it doesn't subtract the old value) but that's a
1142
different story (we can't change it without losing backward
1143
compatibility with old object files) (coff-i386 does subtract the old
1144
value, to be compatible with existing coff-i386 targets, like SCO).
1145
 
1146
So everything works fine when not producing relocateable output.  When
1147
we are producing relocateable output, logically we should do exactly
1148
what we do when not producing relocateable output.  Therefore, your
1149
patch is correct.  In fact, it should probably always just set
1150
reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1151
add the value into the object file.  This won't hurt the COFF code,
1152
which doesn't use the addend; I'm not sure what it will do to other
1153
formats (the thing to check for would be whether any formats both use
1154
the addend and set partial_inplace).
1155
 
1156
When I wanted to make coff-i386 produce relocateable output, I ran
1157
into the problem that you are running into: I wanted to remove that
1158
line.  Rather than risk it, I made the coff-i386 relocs use a special
1159
function; it's coff_i386_reloc in coff-i386.c.  The function
1160
specifically adds the addend field into the object file, knowing that
1161
bfd_install_relocation is not going to.  If you remove that line, then
1162
coff-i386.c will wind up adding the addend field in twice.  It's
1163
trivial to fix; it just needs to be done.
1164
 
1165
The problem with removing the line is just that it may break some
1166
working code.  With BFD it's hard to be sure of anything.  The right
1167
way to deal with this is simply to build and test at least all the
1168
supported COFF targets.  It should be straightforward if time and disk
1169
space 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
          relocation -= reloc_entry->addend;
1183
#endif
1184
          reloc_entry->addend = 0;
1185
        }
1186
      else
1187
        {
1188
          reloc_entry->addend = relocation;
1189
        }
1190
    }
1191
 
1192
  /* FIXME: This overflow checking is incomplete, because the value
1193
     might have overflowed before we get here.  For a correct check we
1194
     need to compute the value in a size larger than bitsize, but we
1195
     can't reasonably do that for a reloc the same size as a host
1196
     machine word.
1197
     FIXME: We should also do overflow checking on the result after
1198
     adding in the value contained in the object file.  */
1199
  if (howto->complain_on_overflow != complain_overflow_dont)
1200
    flag = bfd_check_overflow (howto->complain_on_overflow,
1201
                               howto->bitsize,
1202
                               howto->rightshift,
1203
                               bfd_arch_bits_per_address (abfd),
1204
                               relocation);
1205
 
1206
  /* Either we are relocating all the way, or we don't want to apply
1207
     the relocation to the reloc entry (probably because there isn't
1208
     any room in the output format to describe addends to relocs).  */
1209
 
1210
  /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1211
     (OSF version 1.3, compiler version 3.11).  It miscompiles the
1212
     following program:
1213
 
1214
     struct str
1215
     {
1216
       unsigned int i0;
1217
     } s = { 0 };
1218
 
1219
     int
1220
     main ()
1221
     {
1222
       unsigned long x;
1223
 
1224
       x = 0x100000000;
1225
       x <<= (unsigned long) s.i0;
1226
       if (x == 0)
1227
         printf ("failed\n");
1228
       else
1229
         printf ("succeeded (%lx)\n", x);
1230
     }
1231
     */
1232
 
1233
  relocation >>= (bfd_vma) howto->rightshift;
1234
 
1235
  /* Shift everything up to where it's going to be used.  */
1236
  relocation <<= (bfd_vma) howto->bitpos;
1237
 
1238
  /* Wait for the day when all have the mask in them.  */
1239
 
1240
  /* What we do:
1241
     i instruction to be left alone
1242
     o offset within instruction
1243
     r relocation offset to apply
1244
     S src mask
1245
     D dst mask
1246
     N ~dst mask
1247
     A part 1
1248
     B part 2
1249
     R result
1250
 
1251
     Do this:
1252
     ((  i i i i i o o o o o  from bfd_get<size>
1253
     and           S S S S S) to get the size offset we want
1254
     +   r r r r r r r r r r) to get the final value to place
1255
     and           D D D D D  to chop to right size
1256
     -----------------------
1257
     =             A A A A A
1258
     And this:
1259
     (   i i i i i o o o o o  from bfd_get<size>
1260
     and N N N N N          ) get instruction
1261
     -----------------------
1262
     =   B B B B B
1263
 
1264
     And then:
1265
     (   B B B B B
1266
     or            A A A A A)
1267
     -----------------------
1268
     =   R R R R R R R R R R  put into bfd_put<size>
1269
     */
1270
 
1271
#define DOIT(x) \
1272
  x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
1273
 
1274
  data = (bfd_byte *) data_start + (octets - data_start_offset);
1275
 
1276
  switch (howto->size)
1277
    {
1278
    case 0:
1279
      {
1280
        char x = bfd_get_8 (abfd, (char *) data);
1281
        DOIT (x);
1282
        bfd_put_8 (abfd, x, (unsigned char *) data);
1283
      }
1284
      break;
1285
 
1286
    case 1:
1287
      {
1288
        short x = bfd_get_16 (abfd, (bfd_byte *) data);
1289
        DOIT (x);
1290
        bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data);
1291
      }
1292
      break;
1293
    case 2:
1294
      {
1295
        long x = bfd_get_32 (abfd, (bfd_byte *) data);
1296
        DOIT (x);
1297
        bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data);
1298
      }
1299
      break;
1300
    case -2:
1301
      {
1302
        long x = bfd_get_32 (abfd, (bfd_byte *) data);
1303
        relocation = -relocation;
1304
        DOIT (x);
1305
        bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data);
1306
      }
1307
      break;
1308
 
1309
    case 3:
1310
      /* Do nothing */
1311
      break;
1312
 
1313
    case 4:
1314
      {
1315
        bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
1316
        DOIT (x);
1317
        bfd_put_64 (abfd, x, (bfd_byte *) data);
1318
      }
1319
      break;
1320
    default:
1321
      return bfd_reloc_other;
1322
    }
1323
 
1324
  return flag;
1325
}
1326
 
1327
/* This relocation routine is used by some of the backend linkers.
1328
   They do not construct asymbol or arelent structures, so there is no
1329
   reason for them to use bfd_perform_relocation.  Also,
1330
   bfd_perform_relocation is so hacked up it is easier to write a new
1331
   function than to try to deal with it.
1332
 
1333
   This routine does a final relocation.  Whether it is useful for a
1334
   relocateable link depends upon how the object format defines
1335
   relocations.
1336
 
1337
   FIXME: This routine ignores any special_function in the HOWTO,
1338
   since the existing special_function values have been written for
1339
   bfd_perform_relocation.
1340
 
1341
   HOWTO is the reloc howto information.
1342
   INPUT_BFD is the BFD which the reloc applies to.
1343
   INPUT_SECTION is the section which the reloc applies to.
1344
   CONTENTS is the contents of the section.
1345
   ADDRESS is the address of the reloc within INPUT_SECTION.
1346
   VALUE is the value of the symbol the reloc refers to.
1347
   ADDEND is the addend of the reloc.  */
1348
 
1349
bfd_reloc_status_type
1350
_bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
1351
                          value, addend)
1352
     reloc_howto_type *howto;
1353
     bfd *input_bfd;
1354
     asection *input_section;
1355
     bfd_byte *contents;
1356
     bfd_vma address;
1357
     bfd_vma value;
1358
     bfd_vma addend;
1359
{
1360
  bfd_vma relocation;
1361
 
1362
  /* Sanity check the address.  */
1363
  if (address > input_section->_raw_size)
1364
    return bfd_reloc_outofrange;
1365
 
1366
  /* This function assumes that we are dealing with a basic relocation
1367
     against a symbol.  We want to compute the value of the symbol to
1368
     relocate to.  This is just VALUE, the value of the symbol, plus
1369
     ADDEND, any addend associated with the reloc.  */
1370
  relocation = value + addend;
1371
 
1372
  /* If the relocation is PC relative, we want to set RELOCATION to
1373
     the distance between the symbol (currently in RELOCATION) and the
1374
     location we are relocating.  Some targets (e.g., i386-aout)
1375
     arrange for the contents of the section to be the negative of the
1376
     offset of the location within the section; for such targets
1377
     pcrel_offset is false.  Other targets (e.g., m88kbcs or ELF)
1378
     simply leave the contents of the section as zero; for such
1379
     targets pcrel_offset is true.  If pcrel_offset is false we do not
1380
     need to subtract out the offset of the location within the
1381
     section (which is just ADDRESS).  */
1382
  if (howto->pc_relative)
1383
    {
1384
      relocation -= (input_section->output_section->vma
1385
                     + input_section->output_offset);
1386
      if (howto->pcrel_offset)
1387
        relocation -= address;
1388
    }
1389
 
1390
  return _bfd_relocate_contents (howto, input_bfd, relocation,
1391
                                 contents + address);
1392
}
1393
 
1394
/* Relocate a given location using a given value and howto.  */
1395
 
1396
bfd_reloc_status_type
1397
_bfd_relocate_contents (howto, input_bfd, relocation, location)
1398
     reloc_howto_type *howto;
1399
     bfd *input_bfd;
1400
     bfd_vma relocation;
1401
     bfd_byte *location;
1402
{
1403
  int size;
1404
  bfd_vma x = 0;
1405
  bfd_reloc_status_type flag;
1406
  unsigned int rightshift = howto->rightshift;
1407
  unsigned int bitpos = howto->bitpos;
1408
 
1409
  /* If the size is negative, negate RELOCATION.  This isn't very
1410
     general.  */
1411
  if (howto->size < 0)
1412
    relocation = -relocation;
1413
 
1414
  /* Get the value we are going to relocate.  */
1415
  size = bfd_get_reloc_size (howto);
1416
  switch (size)
1417
    {
1418
    default:
1419
    case 0:
1420
      abort ();
1421
    case 1:
1422
      x = bfd_get_8 (input_bfd, location);
1423
      break;
1424
    case 2:
1425
      x = bfd_get_16 (input_bfd, location);
1426
      break;
1427
    case 4:
1428
      x = bfd_get_32 (input_bfd, location);
1429
      break;
1430
    case 8:
1431
#ifdef BFD64
1432
      x = bfd_get_64 (input_bfd, location);
1433
#else
1434
      abort ();
1435
#endif
1436
      break;
1437
    }
1438
 
1439
  /* Check for overflow.  FIXME: We may drop bits during the addition
1440
     which we don't check for.  We must either check at every single
1441
     operation, which would be tedious, or we must do the computations
1442
     in a type larger than bfd_vma, which would be inefficient.  */
1443
  flag = bfd_reloc_ok;
1444
  if (howto->complain_on_overflow != complain_overflow_dont)
1445
    {
1446
      bfd_vma addrmask, fieldmask, signmask, ss;
1447
      bfd_vma a, b, sum;
1448
 
1449
      /* Get the values to be added together.  For signed and unsigned
1450
         relocations, we assume that all values should be truncated to
1451
         the size of an address.  For bitfields, all the bits matter.
1452
         See also bfd_check_overflow.  */
1453
      fieldmask = N_ONES (howto->bitsize);
1454
      addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
1455
      a = relocation;
1456
      b = x & howto->src_mask;
1457
 
1458
      switch (howto->complain_on_overflow)
1459
        {
1460
        case complain_overflow_signed:
1461
          a = (a & addrmask) >> rightshift;
1462
 
1463
          /* If any sign bits are set, all sign bits must be set.
1464
             That is, A must be a valid negative address after
1465
             shifting.  */
1466
          signmask = ~ (fieldmask >> 1);
1467
          ss = a & signmask;
1468
          if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
1469
            flag = bfd_reloc_overflow;
1470
 
1471
          /* We only need this next bit of code if the sign bit of B
1472
             is below the sign bit of A.  This would only happen if
1473
             SRC_MASK had fewer bits than BITSIZE.  Note that if
1474
             SRC_MASK has more bits than BITSIZE, we can get into
1475
             trouble; we would need to verify that B is in range, as
1476
             we do for A above.  */
1477
          signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1478
 
1479
          /* Set all the bits above the sign bit.  */
1480
          b = (b ^ signmask) - signmask;
1481
 
1482
          b = (b & addrmask) >> bitpos;
1483
 
1484
          /* Now we can do the addition.  */
1485
          sum = a + b;
1486
 
1487
          /* See if the result has the correct sign.  Bits above the
1488
             sign bit are junk now; ignore them.  If the sum is
1489
             positive, make sure we did not have all negative inputs;
1490
             if the sum is negative, make sure we did not have all
1491
             positive inputs.  The test below looks only at the sign
1492
             bits, and it really just
1493
                 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1494
             */
1495
          signmask = (fieldmask >> 1) + 1;
1496
          if (((~ (a ^ b)) & (a ^ sum)) & signmask)
1497
            flag = bfd_reloc_overflow;
1498
 
1499
          break;
1500
 
1501
        case complain_overflow_unsigned:
1502
          /* Checking for an unsigned overflow is relatively easy:
1503
             trim the addresses and add, and trim the result as well.
1504
             Overflow is normally indicated when the result does not
1505
             fit in the field.  However, we also need to consider the
1506
             case when, e.g., fieldmask is 0x7fffffff or smaller, an
1507
             input is 0x80000000, and bfd_vma is only 32 bits; then we
1508
             will get sum == 0, but there is an overflow, since the
1509
             inputs did not fit in the field.  Instead of doing a
1510
             separate test, we can check for this by or-ing in the
1511
             operands when testing for the sum overflowing its final
1512
             field.  */
1513
          a = (a & addrmask) >> rightshift;
1514
          b = (b & addrmask) >> bitpos;
1515
          sum = (a + b) & addrmask;
1516
          if ((a | b | sum) & ~ fieldmask)
1517
            flag = bfd_reloc_overflow;
1518
 
1519
          break;
1520
 
1521
        case complain_overflow_bitfield:
1522
          /* Much like the signed check, but for a field one bit
1523
             wider, and no trimming inputs with addrmask.  We allow a
1524
             bitfield to represent numbers in the range -2**n to
1525
             2**n-1, where n is the number of bits in the field.
1526
             Note that when bfd_vma is 32 bits, a 32-bit reloc can't
1527
             overflow, which is exactly what we want.  */
1528
          a >>= rightshift;
1529
 
1530
          signmask = ~ fieldmask;
1531
          ss = a & signmask;
1532
          if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & signmask))
1533
            flag = bfd_reloc_overflow;
1534
 
1535
          signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1536
          b = (b ^ signmask) - signmask;
1537
 
1538
          b >>= bitpos;
1539
 
1540
          sum = a + b;
1541
 
1542
          /* We mask with addrmask here to explicitly allow an address
1543
             wrap-around.  The Linux kernel relies on it, and it is
1544
             the only way to write assembler code which can run when
1545
             loaded at a location 0x80000000 away from the location at
1546
             which it is linked.  */
1547
          signmask = fieldmask + 1;
1548
          if (((~ (a ^ b)) & (a ^ sum)) & signmask & addrmask)
1549
            flag = bfd_reloc_overflow;
1550
 
1551
          break;
1552
 
1553
        default:
1554
          abort ();
1555
        }
1556
    }
1557
 
1558
  /* Put RELOCATION in the right bits.  */
1559
  relocation >>= (bfd_vma) rightshift;
1560
  relocation <<= (bfd_vma) bitpos;
1561
 
1562
  /* Add RELOCATION to the right bits of X.  */
1563
  x = ((x & ~howto->dst_mask)
1564
       | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1565
 
1566
  /* Put the relocated value back in the object file.  */
1567
  switch (size)
1568
    {
1569
    default:
1570
    case 0:
1571
      abort ();
1572
    case 1:
1573
      bfd_put_8 (input_bfd, x, location);
1574
      break;
1575
    case 2:
1576
      bfd_put_16 (input_bfd, x, location);
1577
      break;
1578
    case 4:
1579
      bfd_put_32 (input_bfd, x, location);
1580
      break;
1581
    case 8:
1582
#ifdef BFD64
1583
      bfd_put_64 (input_bfd, x, location);
1584
#else
1585
      abort ();
1586
#endif
1587
      break;
1588
    }
1589
 
1590
  return flag;
1591
}
1592
 
1593
/*
1594
DOCDD
1595
INODE
1596
        howto manager,  , typedef arelent, Relocations
1597
 
1598
SECTION
1599
        The howto manager
1600
 
1601
        When an application wants to create a relocation, but doesn't
1602
        know what the target machine might call it, it can find out by
1603
        using this bit of code.
1604
 
1605
*/
1606
 
1607
/*
1608
TYPEDEF
1609
        bfd_reloc_code_type
1610
 
1611
DESCRIPTION
1612
        The insides of a reloc code.  The idea is that, eventually, there
1613
        will be one enumerator for every type of relocation we ever do.
1614
        Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1615
        return a howto pointer.
1616
 
1617
        This does mean that the application must determine the correct
1618
        enumerator value; you can't get a howto pointer from a random set
1619
        of attributes.
1620
 
1621
SENUM
1622
   bfd_reloc_code_real
1623
 
1624
ENUM
1625
  BFD_RELOC_64
1626
ENUMX
1627
  BFD_RELOC_32
1628
ENUMX
1629
  BFD_RELOC_26
1630
ENUMX
1631
  BFD_RELOC_24
1632
ENUMX
1633
  BFD_RELOC_16
1634
ENUMX
1635
  BFD_RELOC_14
1636
ENUMX
1637
  BFD_RELOC_8
1638
ENUMDOC
1639
  Basic absolute relocations of N bits.
1640
 
1641
ENUM
1642
  BFD_RELOC_64_PCREL
1643
ENUMX
1644
  BFD_RELOC_32_PCREL
1645
ENUMX
1646
  BFD_RELOC_24_PCREL
1647
ENUMX
1648
  BFD_RELOC_16_PCREL
1649
ENUMX
1650
  BFD_RELOC_12_PCREL
1651
ENUMX
1652
  BFD_RELOC_8_PCREL
1653
ENUMDOC
1654
  PC-relative relocations.  Sometimes these are relative to the address
1655
of the relocation itself; sometimes they are relative to the start of
1656
the section containing the relocation.  It depends on the specific target.
1657
 
1658
The 24-bit relocation is used in some Intel 960 configurations.
1659
 
1660
ENUM
1661
  BFD_RELOC_32_GOT_PCREL
1662
ENUMX
1663
  BFD_RELOC_16_GOT_PCREL
1664
ENUMX
1665
  BFD_RELOC_8_GOT_PCREL
1666
ENUMX
1667
  BFD_RELOC_32_GOTOFF
1668
ENUMX
1669
  BFD_RELOC_16_GOTOFF
1670
ENUMX
1671
  BFD_RELOC_LO16_GOTOFF
1672
ENUMX
1673
  BFD_RELOC_HI16_GOTOFF
1674
ENUMX
1675
  BFD_RELOC_HI16_S_GOTOFF
1676
ENUMX
1677
  BFD_RELOC_8_GOTOFF
1678
ENUMX
1679
  BFD_RELOC_64_PLT_PCREL
1680
ENUMX
1681
  BFD_RELOC_32_PLT_PCREL
1682
ENUMX
1683
  BFD_RELOC_24_PLT_PCREL
1684
ENUMX
1685
  BFD_RELOC_16_PLT_PCREL
1686
ENUMX
1687
  BFD_RELOC_8_PLT_PCREL
1688
ENUMX
1689
  BFD_RELOC_64_PLTOFF
1690
ENUMX
1691
  BFD_RELOC_32_PLTOFF
1692
ENUMX
1693
  BFD_RELOC_16_PLTOFF
1694
ENUMX
1695
  BFD_RELOC_LO16_PLTOFF
1696
ENUMX
1697
  BFD_RELOC_HI16_PLTOFF
1698
ENUMX
1699
  BFD_RELOC_HI16_S_PLTOFF
1700
ENUMX
1701
  BFD_RELOC_8_PLTOFF
1702
ENUMDOC
1703
  For ELF.
1704
 
1705
ENUM
1706
  BFD_RELOC_68K_GLOB_DAT
1707
ENUMX
1708
  BFD_RELOC_68K_JMP_SLOT
1709
ENUMX
1710
  BFD_RELOC_68K_RELATIVE
1711
ENUMDOC
1712
  Relocations used by 68K ELF.
1713
 
1714
ENUM
1715
  BFD_RELOC_32_BASEREL
1716
ENUMX
1717
  BFD_RELOC_16_BASEREL
1718
ENUMX
1719
  BFD_RELOC_LO16_BASEREL
1720
ENUMX
1721
  BFD_RELOC_HI16_BASEREL
1722
ENUMX
1723
  BFD_RELOC_HI16_S_BASEREL
1724
ENUMX
1725
  BFD_RELOC_8_BASEREL
1726
ENUMX
1727
  BFD_RELOC_RVA
1728
ENUMDOC
1729
  Linkage-table relative.
1730
 
1731
ENUM
1732
  BFD_RELOC_8_FFnn
1733
ENUMDOC
1734
  Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1735
 
1736
ENUM
1737
  BFD_RELOC_32_PCREL_S2
1738
ENUMX
1739
  BFD_RELOC_16_PCREL_S2
1740
ENUMX
1741
  BFD_RELOC_23_PCREL_S2
1742
ENUMDOC
1743
  These PC-relative relocations are stored as word displacements --
1744
i.e., byte displacements shifted right two bits.  The 30-bit word
1745
displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1746
SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
1747
signed 16-bit displacement is used on the MIPS, and the 23-bit
1748
displacement is used on the Alpha.
1749
 
1750
ENUM
1751
  BFD_RELOC_HI22
1752
ENUMX
1753
  BFD_RELOC_LO10
1754
ENUMDOC
1755
  High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1756
the target word.  These are used on the SPARC.
1757
 
1758
ENUM
1759
  BFD_RELOC_GPREL16
1760
ENUMX
1761
  BFD_RELOC_GPREL32
1762
ENUMDOC
1763
  For systems that allocate a Global Pointer register, these are
1764
displacements off that register.  These relocation types are
1765
handled specially, because the value the register will have is
1766
decided relatively late.
1767
 
1768
ENUM
1769
  BFD_RELOC_I960_CALLJ
1770
ENUMDOC
1771
  Reloc types used for i960/b.out.
1772
 
1773
ENUM
1774
  BFD_RELOC_NONE
1775
ENUMX
1776
  BFD_RELOC_SPARC_WDISP22
1777
ENUMX
1778
  BFD_RELOC_SPARC22
1779
ENUMX
1780
  BFD_RELOC_SPARC13
1781
ENUMX
1782
  BFD_RELOC_SPARC_GOT10
1783
ENUMX
1784
  BFD_RELOC_SPARC_GOT13
1785
ENUMX
1786
  BFD_RELOC_SPARC_GOT22
1787
ENUMX
1788
  BFD_RELOC_SPARC_PC10
1789
ENUMX
1790
  BFD_RELOC_SPARC_PC22
1791
ENUMX
1792
  BFD_RELOC_SPARC_WPLT30
1793
ENUMX
1794
  BFD_RELOC_SPARC_COPY
1795
ENUMX
1796
  BFD_RELOC_SPARC_GLOB_DAT
1797
ENUMX
1798
  BFD_RELOC_SPARC_JMP_SLOT
1799
ENUMX
1800
  BFD_RELOC_SPARC_RELATIVE
1801
ENUMX
1802
  BFD_RELOC_SPARC_UA16
1803
ENUMX
1804
  BFD_RELOC_SPARC_UA32
1805
ENUMX
1806
  BFD_RELOC_SPARC_UA64
1807
ENUMDOC
1808
  SPARC ELF relocations.  There is probably some overlap with other
1809
  relocation types already defined.
1810
 
1811
ENUM
1812
  BFD_RELOC_SPARC_BASE13
1813
ENUMX
1814
  BFD_RELOC_SPARC_BASE22
1815
ENUMDOC
1816
  I think these are specific to SPARC a.out (e.g., Sun 4).
1817
 
1818
ENUMEQ
1819
  BFD_RELOC_SPARC_64
1820
  BFD_RELOC_64
1821
ENUMX
1822
  BFD_RELOC_SPARC_10
1823
ENUMX
1824
  BFD_RELOC_SPARC_11
1825
ENUMX
1826
  BFD_RELOC_SPARC_OLO10
1827
ENUMX
1828
  BFD_RELOC_SPARC_HH22
1829
ENUMX
1830
  BFD_RELOC_SPARC_HM10
1831
ENUMX
1832
  BFD_RELOC_SPARC_LM22
1833
ENUMX
1834
  BFD_RELOC_SPARC_PC_HH22
1835
ENUMX
1836
  BFD_RELOC_SPARC_PC_HM10
1837
ENUMX
1838
  BFD_RELOC_SPARC_PC_LM22
1839
ENUMX
1840
  BFD_RELOC_SPARC_WDISP16
1841
ENUMX
1842
  BFD_RELOC_SPARC_WDISP19
1843
ENUMX
1844
  BFD_RELOC_SPARC_7
1845
ENUMX
1846
  BFD_RELOC_SPARC_6
1847
ENUMX
1848
  BFD_RELOC_SPARC_5
1849
ENUMEQX
1850
  BFD_RELOC_SPARC_DISP64
1851
  BFD_RELOC_64_PCREL
1852
ENUMX
1853
  BFD_RELOC_SPARC_PLT32
1854
ENUMX
1855
  BFD_RELOC_SPARC_PLT64
1856
ENUMX
1857
  BFD_RELOC_SPARC_HIX22
1858
ENUMX
1859
  BFD_RELOC_SPARC_LOX10
1860
ENUMX
1861
  BFD_RELOC_SPARC_H44
1862
ENUMX
1863
  BFD_RELOC_SPARC_M44
1864
ENUMX
1865
  BFD_RELOC_SPARC_L44
1866
ENUMX
1867
  BFD_RELOC_SPARC_REGISTER
1868
ENUMDOC
1869
  SPARC64 relocations
1870
 
1871
ENUM
1872
  BFD_RELOC_SPARC_REV32
1873
ENUMDOC
1874
  SPARC little endian relocation
1875
 
1876
ENUM
1877
  BFD_RELOC_ALPHA_GPDISP_HI16
1878
ENUMDOC
1879
  Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
1880
     "addend" in some special way.
1881
  For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1882
     writing; when reading, it will be the absolute section symbol.  The
1883
     addend is the displacement in bytes of the "lda" instruction from
1884
     the "ldah" instruction (which is at the address of this reloc).
1885
ENUM
1886
  BFD_RELOC_ALPHA_GPDISP_LO16
1887
ENUMDOC
1888
  For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1889
     with GPDISP_HI16 relocs.  The addend is ignored when writing the
1890
     relocations out, and is filled in with the file's GP value on
1891
     reading, for convenience.
1892
 
1893
ENUM
1894
  BFD_RELOC_ALPHA_GPDISP
1895
ENUMDOC
1896
  The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1897
     relocation except that there is no accompanying GPDISP_LO16
1898
     relocation.
1899
 
1900
ENUM
1901
  BFD_RELOC_ALPHA_LITERAL
1902
ENUMX
1903
  BFD_RELOC_ALPHA_ELF_LITERAL
1904
ENUMX
1905
  BFD_RELOC_ALPHA_LITUSE
1906
ENUMDOC
1907
  The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1908
     the assembler turns it into a LDQ instruction to load the address of
1909
     the symbol, and then fills in a register in the real instruction.
1910
 
1911
     The LITERAL reloc, at the LDQ instruction, refers to the .lita
1912
     section symbol.  The addend is ignored when writing, but is filled
1913
     in with the file's GP value on reading, for convenience, as with the
1914
     GPDISP_LO16 reloc.
1915
 
1916
     The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1917
     It should refer to the symbol to be referenced, as with 16_GOTOFF,
1918
     but it generates output not based on the position within the .got
1919
     section, but relative to the GP value chosen for the file during the
1920
     final link stage.
1921
 
1922
     The LITUSE reloc, on the instruction using the loaded address, gives
1923
     information to the linker that it might be able to use to optimize
1924
     away some literal section references.  The symbol is ignored (read
1925
     as the absolute section symbol), and the "addend" indicates the type
1926
     of instruction using the register:
1927
              1 - "memory" fmt insn
1928
              2 - byte-manipulation (byte offset reg)
1929
              3 - jsr (target of branch)
1930
 
1931
ENUM
1932
  BFD_RELOC_ALPHA_HINT
1933
ENUMDOC
1934
  The HINT relocation indicates a value that should be filled into the
1935
     "hint" field of a jmp/jsr/ret instruction, for possible branch-
1936
     prediction logic which may be provided on some processors.
1937
 
1938
ENUM
1939
  BFD_RELOC_ALPHA_LINKAGE
1940
ENUMDOC
1941
  The LINKAGE relocation outputs a linkage pair in the object file,
1942
     which is filled by the linker.
1943
 
1944
ENUM
1945
  BFD_RELOC_ALPHA_CODEADDR
1946
ENUMDOC
1947
  The CODEADDR relocation outputs a STO_CA in the object file,
1948
     which is filled by the linker.
1949
 
1950
ENUM
1951
  BFD_RELOC_ALPHA_GPREL_HI16
1952
ENUMX
1953
  BFD_RELOC_ALPHA_GPREL_LO16
1954
ENUMDOC
1955
  The GPREL_HI/LO relocations together form a 32-bit offset from the
1956
     GP register.
1957
 
1958
ENUM
1959
  BFD_RELOC_ALPHA_BRSGP
1960
ENUMDOC
1961
  Like BFD_RELOC_23_PCREL_S2, except that the source and target must
1962
  share a common GP, and the target address is adjusted for
1963
  STO_ALPHA_STD_GPLOAD.
1964
 
1965
ENUM
1966
  BFD_RELOC_ALPHA_TLSGD
1967
ENUMX
1968
  BFD_RELOC_ALPHA_TLSLDM
1969
ENUMX
1970
  BFD_RELOC_ALPHA_DTPMOD64
1971
ENUMX
1972
  BFD_RELOC_ALPHA_GOTDTPREL16
1973
ENUMX
1974
  BFD_RELOC_ALPHA_DTPREL64
1975
ENUMX
1976
  BFD_RELOC_ALPHA_DTPREL_HI16
1977
ENUMX
1978
  BFD_RELOC_ALPHA_DTPREL_LO16
1979
ENUMX
1980
  BFD_RELOC_ALPHA_DTPREL16
1981
ENUMX
1982
  BFD_RELOC_ALPHA_GOTTPREL16
1983
ENUMX
1984
  BFD_RELOC_ALPHA_TPREL64
1985
ENUMX
1986
  BFD_RELOC_ALPHA_TPREL_HI16
1987
ENUMX
1988
  BFD_RELOC_ALPHA_TPREL_LO16
1989
ENUMX
1990
  BFD_RELOC_ALPHA_TPREL16
1991
ENUMDOC
1992
  Alpha thread-local storage relocations.
1993
 
1994
ENUM
1995
  BFD_RELOC_MIPS_JMP
1996
ENUMDOC
1997
  Bits 27..2 of the relocation address shifted right 2 bits;
1998
     simple reloc otherwise.
1999
 
2000
ENUM
2001
  BFD_RELOC_MIPS16_JMP
2002
ENUMDOC
2003
  The MIPS16 jump instruction.
2004
 
2005
ENUM
2006
  BFD_RELOC_MIPS16_GPREL
2007
ENUMDOC
2008
  MIPS16 GP relative reloc.
2009
 
2010
ENUM
2011
  BFD_RELOC_HI16
2012
ENUMDOC
2013
  High 16 bits of 32-bit value; simple reloc.
2014
ENUM
2015
  BFD_RELOC_HI16_S
2016
ENUMDOC
2017
  High 16 bits of 32-bit value but the low 16 bits will be sign
2018
     extended and added to form the final result.  If the low 16
2019
     bits form a negative number, we need to add one to the high value
2020
     to compensate for the borrow when the low bits are added.
2021
ENUM
2022
  BFD_RELOC_LO16
2023
ENUMDOC
2024
  Low 16 bits.
2025
ENUM
2026
  BFD_RELOC_PCREL_HI16_S
2027
ENUMDOC
2028
  Like BFD_RELOC_HI16_S, but PC relative.
2029
ENUM
2030
  BFD_RELOC_PCREL_LO16
2031
ENUMDOC
2032
  Like BFD_RELOC_LO16, but PC relative.
2033
 
2034
ENUM
2035
  BFD_RELOC_MIPS_LITERAL
2036
ENUMDOC
2037
  Relocation against a MIPS literal section.
2038
 
2039
ENUM
2040
  BFD_RELOC_MIPS_GOT16
2041
ENUMX
2042
  BFD_RELOC_MIPS_CALL16
2043
ENUMX
2044
  BFD_RELOC_MIPS_GOT_HI16
2045
ENUMX
2046
  BFD_RELOC_MIPS_GOT_LO16
2047
ENUMX
2048
  BFD_RELOC_MIPS_CALL_HI16
2049
ENUMX
2050
  BFD_RELOC_MIPS_CALL_LO16
2051
ENUMX
2052
  BFD_RELOC_MIPS_SUB
2053
ENUMX
2054
  BFD_RELOC_MIPS_GOT_PAGE
2055
ENUMX
2056
  BFD_RELOC_MIPS_GOT_OFST
2057
ENUMX
2058
  BFD_RELOC_MIPS_GOT_DISP
2059
ENUMX
2060
  BFD_RELOC_MIPS_SHIFT5
2061
ENUMX
2062
  BFD_RELOC_MIPS_SHIFT6
2063
ENUMX
2064
  BFD_RELOC_MIPS_INSERT_A
2065
ENUMX
2066
  BFD_RELOC_MIPS_INSERT_B
2067
ENUMX
2068
  BFD_RELOC_MIPS_DELETE
2069
ENUMX
2070
  BFD_RELOC_MIPS_HIGHEST
2071
ENUMX
2072
  BFD_RELOC_MIPS_HIGHER
2073
ENUMX
2074
  BFD_RELOC_MIPS_SCN_DISP
2075
ENUMX
2076
  BFD_RELOC_MIPS_REL16
2077
ENUMX
2078
  BFD_RELOC_MIPS_RELGOT
2079
ENUMX
2080
  BFD_RELOC_MIPS_JALR
2081
COMMENT
2082
ENUM
2083
  BFD_RELOC_FRV_LABEL16
2084
ENUMX
2085
  BFD_RELOC_FRV_LABEL24
2086
ENUMX
2087
  BFD_RELOC_FRV_LO16
2088
ENUMX
2089
  BFD_RELOC_FRV_HI16
2090
ENUMX
2091
  BFD_RELOC_FRV_GPREL12
2092
ENUMX
2093
  BFD_RELOC_FRV_GPRELU12
2094
ENUMX
2095
  BFD_RELOC_FRV_GPREL32
2096
ENUMX
2097
  BFD_RELOC_FRV_GPRELHI
2098
ENUMX
2099
  BFD_RELOC_FRV_GPRELLO
2100
ENUMDOC
2101
  Fujitsu Frv Relocations.
2102
COMMENT
2103
COMMENT
2104
ENUMDOC
2105
  MIPS ELF relocations.
2106
 
2107
COMMENT
2108
 
2109
ENUM
2110
  BFD_RELOC_386_GOT32
2111
ENUMX
2112
  BFD_RELOC_386_PLT32
2113
ENUMX
2114
  BFD_RELOC_386_COPY
2115
ENUMX
2116
  BFD_RELOC_386_GLOB_DAT
2117
ENUMX
2118
  BFD_RELOC_386_JUMP_SLOT
2119
ENUMX
2120
  BFD_RELOC_386_RELATIVE
2121
ENUMX
2122
  BFD_RELOC_386_GOTOFF
2123
ENUMX
2124
  BFD_RELOC_386_GOTPC
2125
ENUMX
2126
  BFD_RELOC_386_TLS_LE
2127
ENUMX
2128
  BFD_RELOC_386_TLS_GD
2129
ENUMX
2130
  BFD_RELOC_386_TLS_LDM
2131
ENUMX
2132
  BFD_RELOC_386_TLS_LDO_32
2133
ENUMX
2134
  BFD_RELOC_386_TLS_IE_32
2135
ENUMX
2136
  BFD_RELOC_386_TLS_LE_32
2137
ENUMX
2138
  BFD_RELOC_386_TLS_DTPMOD32
2139
ENUMX
2140
  BFD_RELOC_386_TLS_DTPOFF32
2141
ENUMX
2142
  BFD_RELOC_386_TLS_TPOFF32
2143
ENUMDOC
2144
  i386/elf relocations
2145
 
2146
ENUM
2147
  BFD_RELOC_X86_64_GOT32
2148
ENUMX
2149
  BFD_RELOC_X86_64_PLT32
2150
ENUMX
2151
  BFD_RELOC_X86_64_COPY
2152
ENUMX
2153
  BFD_RELOC_X86_64_GLOB_DAT
2154
ENUMX
2155
  BFD_RELOC_X86_64_JUMP_SLOT
2156
ENUMX
2157
  BFD_RELOC_X86_64_RELATIVE
2158
ENUMX
2159
  BFD_RELOC_X86_64_GOTPCREL
2160
ENUMX
2161
  BFD_RELOC_X86_64_32S
2162
ENUMDOC
2163
  x86-64/elf relocations
2164
 
2165
ENUM
2166
  BFD_RELOC_NS32K_IMM_8
2167
ENUMX
2168
  BFD_RELOC_NS32K_IMM_16
2169
ENUMX
2170
  BFD_RELOC_NS32K_IMM_32
2171
ENUMX
2172
  BFD_RELOC_NS32K_IMM_8_PCREL
2173
ENUMX
2174
  BFD_RELOC_NS32K_IMM_16_PCREL
2175
ENUMX
2176
  BFD_RELOC_NS32K_IMM_32_PCREL
2177
ENUMX
2178
  BFD_RELOC_NS32K_DISP_8
2179
ENUMX
2180
  BFD_RELOC_NS32K_DISP_16
2181
ENUMX
2182
  BFD_RELOC_NS32K_DISP_32
2183
ENUMX
2184
  BFD_RELOC_NS32K_DISP_8_PCREL
2185
ENUMX
2186
  BFD_RELOC_NS32K_DISP_16_PCREL
2187
ENUMX
2188
  BFD_RELOC_NS32K_DISP_32_PCREL
2189
ENUMDOC
2190
  ns32k relocations
2191
 
2192
ENUM
2193
  BFD_RELOC_PDP11_DISP_8_PCREL
2194
ENUMX
2195
  BFD_RELOC_PDP11_DISP_6_PCREL
2196
ENUMDOC
2197
  PDP11 relocations
2198
 
2199
ENUM
2200
  BFD_RELOC_PJ_CODE_HI16
2201
ENUMX
2202
  BFD_RELOC_PJ_CODE_LO16
2203
ENUMX
2204
  BFD_RELOC_PJ_CODE_DIR16
2205
ENUMX
2206
  BFD_RELOC_PJ_CODE_DIR32
2207
ENUMX
2208
  BFD_RELOC_PJ_CODE_REL16
2209
ENUMX
2210
  BFD_RELOC_PJ_CODE_REL32
2211
ENUMDOC
2212
  Picojava relocs.  Not all of these appear in object files.
2213
 
2214
ENUM
2215
  BFD_RELOC_PPC_B26
2216
ENUMX
2217
  BFD_RELOC_PPC_BA26
2218
ENUMX
2219
  BFD_RELOC_PPC_TOC16
2220
ENUMX
2221
  BFD_RELOC_PPC_B16
2222
ENUMX
2223
  BFD_RELOC_PPC_B16_BRTAKEN
2224
ENUMX
2225
  BFD_RELOC_PPC_B16_BRNTAKEN
2226
ENUMX
2227
  BFD_RELOC_PPC_BA16
2228
ENUMX
2229
  BFD_RELOC_PPC_BA16_BRTAKEN
2230
ENUMX
2231
  BFD_RELOC_PPC_BA16_BRNTAKEN
2232
ENUMX
2233
  BFD_RELOC_PPC_COPY
2234
ENUMX
2235
  BFD_RELOC_PPC_GLOB_DAT
2236
ENUMX
2237
  BFD_RELOC_PPC_JMP_SLOT
2238
ENUMX
2239
  BFD_RELOC_PPC_RELATIVE
2240
ENUMX
2241
  BFD_RELOC_PPC_LOCAL24PC
2242
ENUMX
2243
  BFD_RELOC_PPC_EMB_NADDR32
2244
ENUMX
2245
  BFD_RELOC_PPC_EMB_NADDR16
2246
ENUMX
2247
  BFD_RELOC_PPC_EMB_NADDR16_LO
2248
ENUMX
2249
  BFD_RELOC_PPC_EMB_NADDR16_HI
2250
ENUMX
2251
  BFD_RELOC_PPC_EMB_NADDR16_HA
2252
ENUMX
2253
  BFD_RELOC_PPC_EMB_SDAI16
2254
ENUMX
2255
  BFD_RELOC_PPC_EMB_SDA2I16
2256
ENUMX
2257
  BFD_RELOC_PPC_EMB_SDA2REL
2258
ENUMX
2259
  BFD_RELOC_PPC_EMB_SDA21
2260
ENUMX
2261
  BFD_RELOC_PPC_EMB_MRKREF
2262
ENUMX
2263
  BFD_RELOC_PPC_EMB_RELSEC16
2264
ENUMX
2265
  BFD_RELOC_PPC_EMB_RELST_LO
2266
ENUMX
2267
  BFD_RELOC_PPC_EMB_RELST_HI
2268
ENUMX
2269
  BFD_RELOC_PPC_EMB_RELST_HA
2270
ENUMX
2271
  BFD_RELOC_PPC_EMB_BIT_FLD
2272
ENUMX
2273
  BFD_RELOC_PPC_EMB_RELSDA
2274
ENUMX
2275
  BFD_RELOC_PPC64_HIGHER
2276
ENUMX
2277
  BFD_RELOC_PPC64_HIGHER_S
2278
ENUMX
2279
  BFD_RELOC_PPC64_HIGHEST
2280
ENUMX
2281
  BFD_RELOC_PPC64_HIGHEST_S
2282
ENUMX
2283
  BFD_RELOC_PPC64_TOC16_LO
2284
ENUMX
2285
  BFD_RELOC_PPC64_TOC16_HI
2286
ENUMX
2287
  BFD_RELOC_PPC64_TOC16_HA
2288
ENUMX
2289
  BFD_RELOC_PPC64_TOC
2290
ENUMX
2291
  BFD_RELOC_PPC64_PLTGOT16
2292
ENUMX
2293
  BFD_RELOC_PPC64_PLTGOT16_LO
2294
ENUMX
2295
  BFD_RELOC_PPC64_PLTGOT16_HI
2296
ENUMX
2297
  BFD_RELOC_PPC64_PLTGOT16_HA
2298
ENUMX
2299
  BFD_RELOC_PPC64_ADDR16_DS
2300
ENUMX
2301
  BFD_RELOC_PPC64_ADDR16_LO_DS
2302
ENUMX
2303
  BFD_RELOC_PPC64_GOT16_DS
2304
ENUMX
2305
  BFD_RELOC_PPC64_GOT16_LO_DS
2306
ENUMX
2307
  BFD_RELOC_PPC64_PLT16_LO_DS
2308
ENUMX
2309
  BFD_RELOC_PPC64_SECTOFF_DS
2310
ENUMX
2311
  BFD_RELOC_PPC64_SECTOFF_LO_DS
2312
ENUMX
2313
  BFD_RELOC_PPC64_TOC16_DS
2314
ENUMX
2315
  BFD_RELOC_PPC64_TOC16_LO_DS
2316
ENUMX
2317
  BFD_RELOC_PPC64_PLTGOT16_DS
2318
ENUMX
2319
  BFD_RELOC_PPC64_PLTGOT16_LO_DS
2320
ENUMDOC
2321
  Power(rs6000) and PowerPC relocations.
2322
 
2323
ENUM
2324
  BFD_RELOC_I370_D12
2325
ENUMDOC
2326
  IBM 370/390 relocations
2327
 
2328
ENUM
2329
  BFD_RELOC_CTOR
2330
ENUMDOC
2331
  The type of reloc used to build a contructor table - at the moment
2332
  probably a 32 bit wide absolute relocation, but the target can choose.
2333
  It generally does map to one of the other relocation types.
2334
 
2335
ENUM
2336
  BFD_RELOC_ARM_PCREL_BRANCH
2337
ENUMDOC
2338
  ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
2339
  not stored in the instruction.
2340
ENUM
2341
  BFD_RELOC_ARM_PCREL_BLX
2342
ENUMDOC
2343
  ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
2344
  not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2345
  field in the instruction.
2346
ENUM
2347
  BFD_RELOC_THUMB_PCREL_BLX
2348
ENUMDOC
2349
  Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
2350
  not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2351
  field in the instruction.
2352
ENUM
2353
  BFD_RELOC_ARM_IMMEDIATE
2354
ENUMX
2355
  BFD_RELOC_ARM_ADRL_IMMEDIATE
2356
ENUMX
2357
  BFD_RELOC_ARM_OFFSET_IMM
2358
ENUMX
2359
  BFD_RELOC_ARM_SHIFT_IMM
2360
ENUMX
2361
  BFD_RELOC_ARM_SWI
2362
ENUMX
2363
  BFD_RELOC_ARM_MULTI
2364
ENUMX
2365
  BFD_RELOC_ARM_CP_OFF_IMM
2366
ENUMX
2367
  BFD_RELOC_ARM_ADR_IMM
2368
ENUMX
2369
  BFD_RELOC_ARM_LDR_IMM
2370
ENUMX
2371
  BFD_RELOC_ARM_LITERAL
2372
ENUMX
2373
  BFD_RELOC_ARM_IN_POOL
2374
ENUMX
2375
  BFD_RELOC_ARM_OFFSET_IMM8
2376
ENUMX
2377
  BFD_RELOC_ARM_HWLITERAL
2378
ENUMX
2379
  BFD_RELOC_ARM_THUMB_ADD
2380
ENUMX
2381
  BFD_RELOC_ARM_THUMB_IMM
2382
ENUMX
2383
  BFD_RELOC_ARM_THUMB_SHIFT
2384
ENUMX
2385
  BFD_RELOC_ARM_THUMB_OFFSET
2386
ENUMX
2387
  BFD_RELOC_ARM_GOT12
2388
ENUMX
2389
  BFD_RELOC_ARM_GOT32
2390
ENUMX
2391
  BFD_RELOC_ARM_JUMP_SLOT
2392
ENUMX
2393
  BFD_RELOC_ARM_COPY
2394
ENUMX
2395
  BFD_RELOC_ARM_GLOB_DAT
2396
ENUMX
2397
  BFD_RELOC_ARM_PLT32
2398
ENUMX
2399
  BFD_RELOC_ARM_RELATIVE
2400
ENUMX
2401
  BFD_RELOC_ARM_GOTOFF
2402
ENUMX
2403
  BFD_RELOC_ARM_GOTPC
2404
ENUMDOC
2405
  These relocs are only used within the ARM assembler.  They are not
2406
  (at present) written to any object files.
2407
 
2408
ENUM
2409
  BFD_RELOC_SH_PCDISP8BY2
2410
ENUMX
2411
  BFD_RELOC_SH_PCDISP12BY2
2412
ENUMX
2413
  BFD_RELOC_SH_IMM4
2414
ENUMX
2415
  BFD_RELOC_SH_IMM4BY2
2416
ENUMX
2417
  BFD_RELOC_SH_IMM4BY4
2418
ENUMX
2419
  BFD_RELOC_SH_IMM8
2420
ENUMX
2421
  BFD_RELOC_SH_IMM8BY2
2422
ENUMX
2423
  BFD_RELOC_SH_IMM8BY4
2424
ENUMX
2425
  BFD_RELOC_SH_PCRELIMM8BY2
2426
ENUMX
2427
  BFD_RELOC_SH_PCRELIMM8BY4
2428
ENUMX
2429
  BFD_RELOC_SH_SWITCH16
2430
ENUMX
2431
  BFD_RELOC_SH_SWITCH32
2432
ENUMX
2433
  BFD_RELOC_SH_USES
2434
ENUMX
2435
  BFD_RELOC_SH_COUNT
2436
ENUMX
2437
  BFD_RELOC_SH_ALIGN
2438
ENUMX
2439
  BFD_RELOC_SH_CODE
2440
ENUMX
2441
  BFD_RELOC_SH_DATA
2442
ENUMX
2443
  BFD_RELOC_SH_LABEL
2444
ENUMX
2445
  BFD_RELOC_SH_LOOP_START
2446
ENUMX
2447
  BFD_RELOC_SH_LOOP_END
2448
ENUMX
2449
  BFD_RELOC_SH_COPY
2450
ENUMX
2451
  BFD_RELOC_SH_GLOB_DAT
2452
ENUMX
2453
  BFD_RELOC_SH_JMP_SLOT
2454
ENUMX
2455
  BFD_RELOC_SH_RELATIVE
2456
ENUMX
2457
  BFD_RELOC_SH_GOTPC
2458
ENUMX
2459
  BFD_RELOC_SH_GOT_LOW16
2460
ENUMX
2461
  BFD_RELOC_SH_GOT_MEDLOW16
2462
ENUMX
2463
  BFD_RELOC_SH_GOT_MEDHI16
2464
ENUMX
2465
  BFD_RELOC_SH_GOT_HI16
2466
ENUMX
2467
  BFD_RELOC_SH_GOTPLT_LOW16
2468
ENUMX
2469
  BFD_RELOC_SH_GOTPLT_MEDLOW16
2470
ENUMX
2471
  BFD_RELOC_SH_GOTPLT_MEDHI16
2472
ENUMX
2473
  BFD_RELOC_SH_GOTPLT_HI16
2474
ENUMX
2475
  BFD_RELOC_SH_PLT_LOW16
2476
ENUMX
2477
  BFD_RELOC_SH_PLT_MEDLOW16
2478
ENUMX
2479
  BFD_RELOC_SH_PLT_MEDHI16
2480
ENUMX
2481
  BFD_RELOC_SH_PLT_HI16
2482
ENUMX
2483
  BFD_RELOC_SH_GOTOFF_LOW16
2484
ENUMX
2485
  BFD_RELOC_SH_GOTOFF_MEDLOW16
2486
ENUMX
2487
  BFD_RELOC_SH_GOTOFF_MEDHI16
2488
ENUMX
2489
  BFD_RELOC_SH_GOTOFF_HI16
2490
ENUMX
2491
  BFD_RELOC_SH_GOTPC_LOW16
2492
ENUMX
2493
  BFD_RELOC_SH_GOTPC_MEDLOW16
2494
ENUMX
2495
  BFD_RELOC_SH_GOTPC_MEDHI16
2496
ENUMX
2497
  BFD_RELOC_SH_GOTPC_HI16
2498
ENUMX
2499
  BFD_RELOC_SH_COPY64
2500
ENUMX
2501
  BFD_RELOC_SH_GLOB_DAT64
2502
ENUMX
2503
  BFD_RELOC_SH_JMP_SLOT64
2504
ENUMX
2505
  BFD_RELOC_SH_RELATIVE64
2506
ENUMX
2507
  BFD_RELOC_SH_GOT10BY4
2508
ENUMX
2509
  BFD_RELOC_SH_GOT10BY8
2510
ENUMX
2511
  BFD_RELOC_SH_GOTPLT10BY4
2512
ENUMX
2513
  BFD_RELOC_SH_GOTPLT10BY8
2514
ENUMX
2515
  BFD_RELOC_SH_GOTPLT32
2516
ENUMX
2517
  BFD_RELOC_SH_SHMEDIA_CODE
2518
ENUMX
2519
  BFD_RELOC_SH_IMMU5
2520
ENUMX
2521
  BFD_RELOC_SH_IMMS6
2522
ENUMX
2523
  BFD_RELOC_SH_IMMS6BY32
2524
ENUMX
2525
  BFD_RELOC_SH_IMMU6
2526
ENUMX
2527
  BFD_RELOC_SH_IMMS10
2528
ENUMX
2529
  BFD_RELOC_SH_IMMS10BY2
2530
ENUMX
2531
  BFD_RELOC_SH_IMMS10BY4
2532
ENUMX
2533
  BFD_RELOC_SH_IMMS10BY8
2534
ENUMX
2535
  BFD_RELOC_SH_IMMS16
2536
ENUMX
2537
  BFD_RELOC_SH_IMMU16
2538
ENUMX
2539
  BFD_RELOC_SH_IMM_LOW16
2540
ENUMX
2541
  BFD_RELOC_SH_IMM_LOW16_PCREL
2542
ENUMX
2543
  BFD_RELOC_SH_IMM_MEDLOW16
2544
ENUMX
2545
  BFD_RELOC_SH_IMM_MEDLOW16_PCREL
2546
ENUMX
2547
  BFD_RELOC_SH_IMM_MEDHI16
2548
ENUMX
2549
  BFD_RELOC_SH_IMM_MEDHI16_PCREL
2550
ENUMX
2551
  BFD_RELOC_SH_IMM_HI16
2552
ENUMX
2553
  BFD_RELOC_SH_IMM_HI16_PCREL
2554
ENUMX
2555
  BFD_RELOC_SH_PT_16
2556
ENUMDOC
2557
  Hitachi SH relocs.  Not all of these appear in object files.
2558
 
2559
ENUM
2560
  BFD_RELOC_THUMB_PCREL_BRANCH9
2561
ENUMX
2562
  BFD_RELOC_THUMB_PCREL_BRANCH12
2563
ENUMX
2564
  BFD_RELOC_THUMB_PCREL_BRANCH23
2565
ENUMDOC
2566
  Thumb 23-, 12- and 9-bit pc-relative branches.  The lowest bit must
2567
  be zero and is not stored in the instruction.
2568
 
2569
ENUM
2570
  BFD_RELOC_ARC_B22_PCREL
2571
ENUMDOC
2572
  ARC Cores relocs.
2573
  ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
2574
  not stored in the instruction.  The high 20 bits are installed in bits 26
2575
  through 7 of the instruction.
2576
ENUM
2577
  BFD_RELOC_ARC_B26
2578
ENUMDOC
2579
  ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
2580
  stored in the instruction.  The high 24 bits are installed in bits 23
2581
  through 0.
2582
 
2583
ENUM
2584
  BFD_RELOC_D10V_10_PCREL_R
2585
ENUMDOC
2586
  Mitsubishi D10V relocs.
2587
  This is a 10-bit reloc with the right 2 bits
2588
  assumed to be 0.
2589
ENUM
2590
  BFD_RELOC_D10V_10_PCREL_L
2591
ENUMDOC
2592
  Mitsubishi D10V relocs.
2593
  This is a 10-bit reloc with the right 2 bits
2594
  assumed to be 0.  This is the same as the previous reloc
2595
  except it is in the left container, i.e.,
2596
  shifted left 15 bits.
2597
ENUM
2598
  BFD_RELOC_D10V_18
2599
ENUMDOC
2600
  This is an 18-bit reloc with the right 2 bits
2601
  assumed to be 0.
2602
ENUM
2603
  BFD_RELOC_D10V_18_PCREL
2604
ENUMDOC
2605
  This is an 18-bit reloc with the right 2 bits
2606
  assumed to be 0.
2607
 
2608
ENUM
2609
  BFD_RELOC_D30V_6
2610
ENUMDOC
2611
  Mitsubishi D30V relocs.
2612
  This is a 6-bit absolute reloc.
2613
ENUM
2614
  BFD_RELOC_D30V_9_PCREL
2615
ENUMDOC
2616
  This is a 6-bit pc-relative reloc with
2617
  the right 3 bits assumed to be 0.
2618
ENUM
2619
  BFD_RELOC_D30V_9_PCREL_R
2620
ENUMDOC
2621
  This is a 6-bit pc-relative reloc with
2622
  the right 3 bits assumed to be 0. Same
2623
  as the previous reloc but on the right side
2624
  of the container.
2625
ENUM
2626
  BFD_RELOC_D30V_15
2627
ENUMDOC
2628
  This is a 12-bit absolute reloc with the
2629
  right 3 bitsassumed to be 0.
2630
ENUM
2631
  BFD_RELOC_D30V_15_PCREL
2632
ENUMDOC
2633
  This is a 12-bit pc-relative reloc with
2634
  the right 3 bits assumed to be 0.
2635
ENUM
2636
  BFD_RELOC_D30V_15_PCREL_R
2637
ENUMDOC
2638
  This is a 12-bit pc-relative reloc with
2639
  the right 3 bits assumed to be 0. Same
2640
  as the previous reloc but on the right side
2641
  of the container.
2642
ENUM
2643
  BFD_RELOC_D30V_21
2644
ENUMDOC
2645
  This is an 18-bit absolute reloc with
2646
  the right 3 bits assumed to be 0.
2647
ENUM
2648
  BFD_RELOC_D30V_21_PCREL
2649
ENUMDOC
2650
  This is an 18-bit pc-relative reloc with
2651
  the right 3 bits assumed to be 0.
2652
ENUM
2653
  BFD_RELOC_D30V_21_PCREL_R
2654
ENUMDOC
2655
  This is an 18-bit pc-relative reloc with
2656
  the right 3 bits assumed to be 0. Same
2657
  as the previous reloc but on the right side
2658
  of the container.
2659
ENUM
2660
  BFD_RELOC_D30V_32
2661
ENUMDOC
2662
  This is a 32-bit absolute reloc.
2663
ENUM
2664
  BFD_RELOC_D30V_32_PCREL
2665
ENUMDOC
2666
  This is a 32-bit pc-relative reloc.
2667
 
2668
ENUM
2669
  BFD_RELOC_DLX_HI16_S
2670
ENUMDOC
2671
  DLX relocs
2672
ENUM
2673
  BFD_RELOC_DLX_LO16
2674
ENUMDOC
2675
  DLX relocs
2676
ENUM
2677
  BFD_RELOC_DLX_JMP26
2678
ENUMDOC
2679
  DLX relocs
2680
 
2681
ENUM
2682
  BFD_RELOC_M32R_24
2683
ENUMDOC
2684
  Mitsubishi M32R relocs.
2685
  This is a 24 bit absolute address.
2686
ENUM
2687
  BFD_RELOC_M32R_10_PCREL
2688
ENUMDOC
2689
  This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
2690
ENUM
2691
  BFD_RELOC_M32R_18_PCREL
2692
ENUMDOC
2693
  This is an 18-bit reloc with the right 2 bits assumed to be 0.
2694
ENUM
2695
  BFD_RELOC_M32R_26_PCREL
2696
ENUMDOC
2697
  This is a 26-bit reloc with the right 2 bits assumed to be 0.
2698
ENUM
2699
  BFD_RELOC_M32R_HI16_ULO
2700
ENUMDOC
2701
  This is a 16-bit reloc containing the high 16 bits of an address
2702
  used when the lower 16 bits are treated as unsigned.
2703
ENUM
2704
  BFD_RELOC_M32R_HI16_SLO
2705
ENUMDOC
2706
  This is a 16-bit reloc containing the high 16 bits of an address
2707
  used when the lower 16 bits are treated as signed.
2708
ENUM
2709
  BFD_RELOC_M32R_LO16
2710
ENUMDOC
2711
  This is a 16-bit reloc containing the lower 16 bits of an address.
2712
ENUM
2713
  BFD_RELOC_M32R_SDA16
2714
ENUMDOC
2715
  This is a 16-bit reloc containing the small data area offset for use in
2716
  add3, load, and store instructions.
2717
 
2718
ENUM
2719
  BFD_RELOC_V850_9_PCREL
2720
ENUMDOC
2721
  This is a 9-bit reloc
2722
ENUM
2723
  BFD_RELOC_V850_22_PCREL
2724
ENUMDOC
2725
  This is a 22-bit reloc
2726
 
2727
ENUM
2728
  BFD_RELOC_V850_SDA_16_16_OFFSET
2729
ENUMDOC
2730
  This is a 16 bit offset from the short data area pointer.
2731
ENUM
2732
  BFD_RELOC_V850_SDA_15_16_OFFSET
2733
ENUMDOC
2734
  This is a 16 bit offset (of which only 15 bits are used) from the
2735
  short data area pointer.
2736
ENUM
2737
  BFD_RELOC_V850_ZDA_16_16_OFFSET
2738
ENUMDOC
2739
  This is a 16 bit offset from the zero data area pointer.
2740
ENUM
2741
  BFD_RELOC_V850_ZDA_15_16_OFFSET
2742
ENUMDOC
2743
  This is a 16 bit offset (of which only 15 bits are used) from the
2744
  zero data area pointer.
2745
ENUM
2746
  BFD_RELOC_V850_TDA_6_8_OFFSET
2747
ENUMDOC
2748
  This is an 8 bit offset (of which only 6 bits are used) from the
2749
  tiny data area pointer.
2750
ENUM
2751
  BFD_RELOC_V850_TDA_7_8_OFFSET
2752
ENUMDOC
2753
  This is an 8bit offset (of which only 7 bits are used) from the tiny
2754
  data area pointer.
2755
ENUM
2756
  BFD_RELOC_V850_TDA_7_7_OFFSET
2757
ENUMDOC
2758
  This is a 7 bit offset from the tiny data area pointer.
2759
ENUM
2760
  BFD_RELOC_V850_TDA_16_16_OFFSET
2761
ENUMDOC
2762
  This is a 16 bit offset from the tiny data area pointer.
2763
COMMENT
2764
ENUM
2765
  BFD_RELOC_V850_TDA_4_5_OFFSET
2766
ENUMDOC
2767
  This is a 5 bit offset (of which only 4 bits are used) from the tiny
2768
  data area pointer.
2769
ENUM
2770
  BFD_RELOC_V850_TDA_4_4_OFFSET
2771
ENUMDOC
2772
  This is a 4 bit offset from the tiny data area pointer.
2773
ENUM
2774
  BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
2775
ENUMDOC
2776
  This is a 16 bit offset from the short data area pointer, with the
2777
  bits placed non-contigously in the instruction.
2778
ENUM
2779
  BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
2780
ENUMDOC
2781
  This is a 16 bit offset from the zero data area pointer, with the
2782
  bits placed non-contigously in the instruction.
2783
ENUM
2784
  BFD_RELOC_V850_CALLT_6_7_OFFSET
2785
ENUMDOC
2786
  This is a 6 bit offset from the call table base pointer.
2787
ENUM
2788
  BFD_RELOC_V850_CALLT_16_16_OFFSET
2789
ENUMDOC
2790
  This is a 16 bit offset from the call table base pointer.
2791
ENUM
2792
  BFD_RELOC_V850_LONGCALL
2793
ENUMDOC
2794
  Used for relaxing indirect function calls.
2795
ENUM
2796
  BFD_RELOC_V850_LONGJUMP
2797
ENUMDOC
2798
  Used for relaxing indirect jumps.
2799
ENUM
2800
  BFD_RELOC_V850_ALIGN
2801
ENUMDOC
2802
  Used to maintain alignment whilst relaxing.
2803
ENUM
2804
  BFD_RELOC_MN10300_32_PCREL
2805
ENUMDOC
2806
  This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2807
  instruction.
2808
ENUM
2809
  BFD_RELOC_MN10300_16_PCREL
2810
ENUMDOC
2811
  This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2812
  instruction.
2813
 
2814
ENUM
2815
  BFD_RELOC_TIC30_LDP
2816
ENUMDOC
2817
  This is a 8bit DP reloc for the tms320c30, where the most
2818
  significant 8 bits of a 24 bit word are placed into the least
2819
  significant 8 bits of the opcode.
2820
 
2821
ENUM
2822
  BFD_RELOC_TIC54X_PARTLS7
2823
ENUMDOC
2824
  This is a 7bit reloc for the tms320c54x, where the least
2825
  significant 7 bits of a 16 bit word are placed into the least
2826
  significant 7 bits of the opcode.
2827
 
2828
ENUM
2829
  BFD_RELOC_TIC54X_PARTMS9
2830
ENUMDOC
2831
  This is a 9bit DP reloc for the tms320c54x, where the most
2832
  significant 9 bits of a 16 bit word are placed into the least
2833
  significant 9 bits of the opcode.
2834
 
2835
ENUM
2836
  BFD_RELOC_TIC54X_23
2837
ENUMDOC
2838
  This is an extended address 23-bit reloc for the tms320c54x.
2839
 
2840
ENUM
2841
  BFD_RELOC_TIC54X_16_OF_23
2842
ENUMDOC
2843
  This is a 16-bit reloc for the tms320c54x, where the least
2844
  significant 16 bits of a 23-bit extended address are placed into
2845
  the opcode.
2846
 
2847
ENUM
2848
  BFD_RELOC_TIC54X_MS7_OF_23
2849
ENUMDOC
2850
  This is a reloc for the tms320c54x, where the most
2851
  significant 7 bits of a 23-bit extended address are placed into
2852
  the opcode.
2853
 
2854
ENUM
2855
  BFD_RELOC_FR30_48
2856
ENUMDOC
2857
  This is a 48 bit reloc for the FR30 that stores 32 bits.
2858
ENUM
2859
  BFD_RELOC_FR30_20
2860
ENUMDOC
2861
  This is a 32 bit reloc for the FR30 that stores 20 bits split up into
2862
  two sections.
2863
ENUM
2864
  BFD_RELOC_FR30_6_IN_4
2865
ENUMDOC
2866
  This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
2867
  4 bits.
2868
ENUM
2869
  BFD_RELOC_FR30_8_IN_8
2870
ENUMDOC
2871
  This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
2872
  into 8 bits.
2873
ENUM
2874
  BFD_RELOC_FR30_9_IN_8
2875
ENUMDOC
2876
  This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
2877
  into 8 bits.
2878
ENUM
2879
  BFD_RELOC_FR30_10_IN_8
2880
ENUMDOC
2881
  This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
2882
  into 8 bits.
2883
ENUM
2884
  BFD_RELOC_FR30_9_PCREL
2885
ENUMDOC
2886
  This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
2887
  short offset into 8 bits.
2888
ENUM
2889
  BFD_RELOC_FR30_12_PCREL
2890
ENUMDOC
2891
  This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
2892
  short offset into 11 bits.
2893
 
2894
ENUM
2895
  BFD_RELOC_MCORE_PCREL_IMM8BY4
2896
ENUMX
2897
  BFD_RELOC_MCORE_PCREL_IMM11BY2
2898
ENUMX
2899
  BFD_RELOC_MCORE_PCREL_IMM4BY2
2900
ENUMX
2901
  BFD_RELOC_MCORE_PCREL_32
2902
ENUMX
2903
  BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
2904
ENUMX
2905
  BFD_RELOC_MCORE_RVA
2906
ENUMDOC
2907
  Motorola Mcore relocations.
2908
 
2909
ENUM
2910
  BFD_RELOC_MMIX_GETA
2911
ENUMX
2912
  BFD_RELOC_MMIX_GETA_1
2913
ENUMX
2914
  BFD_RELOC_MMIX_GETA_2
2915
ENUMX
2916
  BFD_RELOC_MMIX_GETA_3
2917
ENUMDOC
2918
  These are relocations for the GETA instruction.
2919
ENUM
2920
  BFD_RELOC_MMIX_CBRANCH
2921
ENUMX
2922
  BFD_RELOC_MMIX_CBRANCH_J
2923
ENUMX
2924
  BFD_RELOC_MMIX_CBRANCH_1
2925
ENUMX
2926
  BFD_RELOC_MMIX_CBRANCH_2
2927
ENUMX
2928
  BFD_RELOC_MMIX_CBRANCH_3
2929
ENUMDOC
2930
  These are relocations for a conditional branch instruction.
2931
ENUM
2932
  BFD_RELOC_MMIX_PUSHJ
2933
ENUMX
2934
  BFD_RELOC_MMIX_PUSHJ_1
2935
ENUMX
2936
  BFD_RELOC_MMIX_PUSHJ_2
2937
ENUMX
2938
  BFD_RELOC_MMIX_PUSHJ_3
2939
ENUMDOC
2940
  These are relocations for the PUSHJ instruction.
2941
ENUM
2942
  BFD_RELOC_MMIX_JMP
2943
ENUMX
2944
  BFD_RELOC_MMIX_JMP_1
2945
ENUMX
2946
  BFD_RELOC_MMIX_JMP_2
2947
ENUMX
2948
  BFD_RELOC_MMIX_JMP_3
2949
ENUMDOC
2950
  These are relocations for the JMP instruction.
2951
ENUM
2952
  BFD_RELOC_MMIX_ADDR19
2953
ENUMDOC
2954
  This is a relocation for a relative address as in a GETA instruction or
2955
  a branch.
2956
ENUM
2957
  BFD_RELOC_MMIX_ADDR27
2958
ENUMDOC
2959
  This is a relocation for a relative address as in a JMP instruction.
2960
ENUM
2961
  BFD_RELOC_MMIX_REG_OR_BYTE
2962
ENUMDOC
2963
  This is a relocation for an instruction field that may be a general
2964
  register or a value 0..255.
2965
ENUM
2966
  BFD_RELOC_MMIX_REG
2967
ENUMDOC
2968
  This is a relocation for an instruction field that may be a general
2969
  register.
2970
ENUM
2971
  BFD_RELOC_MMIX_BASE_PLUS_OFFSET
2972
ENUMDOC
2973
  This is a relocation for two instruction fields holding a register and
2974
  an offset, the equivalent of the relocation.
2975
ENUM
2976
  BFD_RELOC_MMIX_LOCAL
2977
ENUMDOC
2978
  This relocation is an assertion that the expression is not allocated as
2979
  a global register.  It does not modify contents.
2980
 
2981
ENUM
2982
  BFD_RELOC_AVR_7_PCREL
2983
ENUMDOC
2984
  This is a 16 bit reloc for the AVR that stores 8 bit pc relative
2985
  short offset into 7 bits.
2986
ENUM
2987
  BFD_RELOC_AVR_13_PCREL
2988
ENUMDOC
2989
  This is a 16 bit reloc for the AVR that stores 13 bit pc relative
2990
  short offset into 12 bits.
2991
ENUM
2992
  BFD_RELOC_AVR_16_PM
2993
ENUMDOC
2994
  This is a 16 bit reloc for the AVR that stores 17 bit value (usually
2995
  program memory address) into 16 bits.
2996
ENUM
2997
  BFD_RELOC_AVR_LO8_LDI
2998
ENUMDOC
2999
  This is a 16 bit reloc for the AVR that stores 8 bit value (usually
3000
  data memory address) into 8 bit immediate value of LDI insn.
3001
ENUM
3002
  BFD_RELOC_AVR_HI8_LDI
3003
ENUMDOC
3004
  This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
3005
  of data memory address) into 8 bit immediate value of LDI insn.
3006
ENUM
3007
  BFD_RELOC_AVR_HH8_LDI
3008
ENUMDOC
3009
  This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
3010
  of program memory address) into 8 bit immediate value of LDI insn.
3011
ENUM
3012
  BFD_RELOC_AVR_LO8_LDI_NEG
3013
ENUMDOC
3014
  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3015
  (usually data memory address) into 8 bit immediate value of SUBI insn.
3016
ENUM
3017
  BFD_RELOC_AVR_HI8_LDI_NEG
3018
ENUMDOC
3019
  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3020
  (high 8 bit of data memory address) into 8 bit immediate value of
3021
  SUBI insn.
3022
ENUM
3023
  BFD_RELOC_AVR_HH8_LDI_NEG
3024
ENUMDOC
3025
  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3026
  (most high 8 bit of program memory address) into 8 bit immediate value
3027
  of LDI or SUBI insn.
3028
ENUM
3029
  BFD_RELOC_AVR_LO8_LDI_PM
3030
ENUMDOC
3031
  This is a 16 bit reloc for the AVR that stores 8 bit value (usually
3032
  command address) into 8 bit immediate value of LDI insn.
3033
ENUM
3034
  BFD_RELOC_AVR_HI8_LDI_PM
3035
ENUMDOC
3036
  This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
3037
  of command address) into 8 bit immediate value of LDI insn.
3038
ENUM
3039
  BFD_RELOC_AVR_HH8_LDI_PM
3040
ENUMDOC
3041
  This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
3042
  of command address) into 8 bit immediate value of LDI insn.
3043
ENUM
3044
  BFD_RELOC_AVR_LO8_LDI_PM_NEG
3045
ENUMDOC
3046
  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3047
  (usually command address) into 8 bit immediate value of SUBI insn.
3048
ENUM
3049
  BFD_RELOC_AVR_HI8_LDI_PM_NEG
3050
ENUMDOC
3051
  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3052
  (high 8 bit of 16 bit command address) into 8 bit immediate value
3053
  of SUBI insn.
3054
ENUM
3055
  BFD_RELOC_AVR_HH8_LDI_PM_NEG
3056
ENUMDOC
3057
  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3058
  (high 6 bit of 22 bit command address) into 8 bit immediate
3059
  value of SUBI insn.
3060
ENUM
3061
  BFD_RELOC_AVR_CALL
3062
ENUMDOC
3063
  This is a 32 bit reloc for the AVR that stores 23 bit value
3064
  into 22 bits.
3065
 
3066
ENUM
3067
  BFD_RELOC_390_12
3068
ENUMDOC
3069
   Direct 12 bit.
3070
ENUM
3071
  BFD_RELOC_390_GOT12
3072
ENUMDOC
3073
  12 bit GOT offset.
3074
ENUM
3075
  BFD_RELOC_390_PLT32
3076
ENUMDOC
3077
  32 bit PC relative PLT address.
3078
ENUM
3079
  BFD_RELOC_390_COPY
3080
ENUMDOC
3081
  Copy symbol at runtime.
3082
ENUM
3083
  BFD_RELOC_390_GLOB_DAT
3084
ENUMDOC
3085
  Create GOT entry.
3086
ENUM
3087
  BFD_RELOC_390_JMP_SLOT
3088
ENUMDOC
3089
  Create PLT entry.
3090
ENUM
3091
  BFD_RELOC_390_RELATIVE
3092
ENUMDOC
3093
  Adjust by program base.
3094
ENUM
3095
  BFD_RELOC_390_GOTPC
3096
ENUMDOC
3097
  32 bit PC relative offset to GOT.
3098
ENUM
3099
  BFD_RELOC_390_GOT16
3100
ENUMDOC
3101
  16 bit GOT offset.
3102
ENUM
3103
  BFD_RELOC_390_PC16DBL
3104
ENUMDOC
3105
  PC relative 16 bit shifted by 1.
3106
ENUM
3107
  BFD_RELOC_390_PLT16DBL
3108
ENUMDOC
3109
  16 bit PC rel. PLT shifted by 1.
3110
ENUM
3111
  BFD_RELOC_390_PC32DBL
3112
ENUMDOC
3113
  PC relative 32 bit shifted by 1.
3114
ENUM
3115
  BFD_RELOC_390_PLT32DBL
3116
ENUMDOC
3117
  32 bit PC rel. PLT shifted by 1.
3118
ENUM
3119
  BFD_RELOC_390_GOTPCDBL
3120
ENUMDOC
3121
  32 bit PC rel. GOT shifted by 1.
3122
ENUM
3123
  BFD_RELOC_390_GOT64
3124
ENUMDOC
3125
  64 bit GOT offset.
3126
ENUM
3127
  BFD_RELOC_390_PLT64
3128
ENUMDOC
3129
  64 bit PC relative PLT address.
3130
ENUM
3131
  BFD_RELOC_390_GOTENT
3132
ENUMDOC
3133
  32 bit rel. offset to GOT entry.
3134
 
3135
ENUM
3136
  BFD_RELOC_IP2K_FR9
3137
ENUMDOC
3138
  Scenix IP2K - 9-bit register number / data address
3139
ENUM
3140
  BFD_RELOC_IP2K_BANK
3141
ENUMDOC
3142
  Scenix IP2K - 4-bit register/data bank number
3143
ENUM
3144
  BFD_RELOC_IP2K_ADDR16CJP
3145
ENUMDOC
3146
  Scenix IP2K - low 13 bits of instruction word address
3147
ENUM
3148
  BFD_RELOC_IP2K_PAGE3
3149
ENUMDOC
3150
  Scenix IP2K - high 3 bits of instruction word address
3151
ENUM
3152
  BFD_RELOC_IP2K_LO8DATA
3153
ENUMX
3154
  BFD_RELOC_IP2K_HI8DATA
3155
ENUMX
3156
  BFD_RELOC_IP2K_EX8DATA
3157
ENUMDOC
3158
  Scenix IP2K - ext/low/high 8 bits of data address
3159
ENUM
3160
  BFD_RELOC_IP2K_LO8INSN
3161
ENUMX
3162
  BFD_RELOC_IP2K_HI8INSN
3163
ENUMDOC
3164
  Scenix IP2K - low/high 8 bits of instruction word address
3165
ENUM
3166
  BFD_RELOC_IP2K_PC_SKIP
3167
ENUMDOC
3168
  Scenix IP2K - even/odd PC modifier to modify snb pcl.0
3169
ENUM
3170
  BFD_RELOC_IP2K_TEXT
3171
ENUMDOC
3172
  Scenix IP2K - 16 bit word address in text section.
3173
ENUM
3174
  BFD_RELOC_IP2K_FR_OFFSET
3175
ENUMDOC
3176
  Scenix IP2K - 7-bit sp or dp offset
3177
ENUM
3178
  BFD_RELOC_VPE4KMATH_DATA
3179
ENUMX
3180
  BFD_RELOC_VPE4KMATH_INSN
3181
ENUMDOC
3182
  Scenix VPE4K coprocessor - data/insn-space addressing
3183
 
3184
ENUM
3185
  BFD_RELOC_VTABLE_INHERIT
3186
ENUMX
3187
  BFD_RELOC_VTABLE_ENTRY
3188
ENUMDOC
3189
  These two relocations are used by the linker to determine which of
3190
  the entries in a C++ virtual function table are actually used.  When
3191
  the --gc-sections option is given, the linker will zero out the entries
3192
  that are not used, so that the code for those functions need not be
3193
  included in the output.
3194
 
3195
  VTABLE_INHERIT is a zero-space relocation used to describe to the
3196
  linker the inheritence tree of a C++ virtual function table.  The
3197
  relocation's symbol should be the parent class' vtable, and the
3198
  relocation should be located at the child vtable.
3199
 
3200
  VTABLE_ENTRY is a zero-space relocation that describes the use of a
3201
  virtual function table entry.  The reloc's symbol should refer to the
3202
  table of the class mentioned in the code.  Off of that base, an offset
3203
  describes the entry that is being used.  For Rela hosts, this offset
3204
  is stored in the reloc's addend.  For Rel hosts, we are forced to put
3205
  this offset in the reloc's section offset.
3206
 
3207
ENUM
3208
  BFD_RELOC_IA64_IMM14
3209
ENUMX
3210
  BFD_RELOC_IA64_IMM22
3211
ENUMX
3212
  BFD_RELOC_IA64_IMM64
3213
ENUMX
3214
  BFD_RELOC_IA64_DIR32MSB
3215
ENUMX
3216
  BFD_RELOC_IA64_DIR32LSB
3217
ENUMX
3218
  BFD_RELOC_IA64_DIR64MSB
3219
ENUMX
3220
  BFD_RELOC_IA64_DIR64LSB
3221
ENUMX
3222
  BFD_RELOC_IA64_GPREL22
3223
ENUMX
3224
  BFD_RELOC_IA64_GPREL64I
3225
ENUMX
3226
  BFD_RELOC_IA64_GPREL32MSB
3227
ENUMX
3228
  BFD_RELOC_IA64_GPREL32LSB
3229
ENUMX
3230
  BFD_RELOC_IA64_GPREL64MSB
3231
ENUMX
3232
  BFD_RELOC_IA64_GPREL64LSB
3233
ENUMX
3234
  BFD_RELOC_IA64_LTOFF22
3235
ENUMX
3236
  BFD_RELOC_IA64_LTOFF64I
3237
ENUMX
3238
  BFD_RELOC_IA64_PLTOFF22
3239
ENUMX
3240
  BFD_RELOC_IA64_PLTOFF64I
3241
ENUMX
3242
  BFD_RELOC_IA64_PLTOFF64MSB
3243
ENUMX
3244
  BFD_RELOC_IA64_PLTOFF64LSB
3245
ENUMX
3246
  BFD_RELOC_IA64_FPTR64I
3247
ENUMX
3248
  BFD_RELOC_IA64_FPTR32MSB
3249
ENUMX
3250
  BFD_RELOC_IA64_FPTR32LSB
3251
ENUMX
3252
  BFD_RELOC_IA64_FPTR64MSB
3253
ENUMX
3254
  BFD_RELOC_IA64_FPTR64LSB
3255
ENUMX
3256
  BFD_RELOC_IA64_PCREL21B
3257
ENUMX
3258
  BFD_RELOC_IA64_PCREL21BI
3259
ENUMX
3260
  BFD_RELOC_IA64_PCREL21M
3261
ENUMX
3262
  BFD_RELOC_IA64_PCREL21F
3263
ENUMX
3264
  BFD_RELOC_IA64_PCREL22
3265
ENUMX
3266
  BFD_RELOC_IA64_PCREL60B
3267
ENUMX
3268
  BFD_RELOC_IA64_PCREL64I
3269
ENUMX
3270
  BFD_RELOC_IA64_PCREL32MSB
3271
ENUMX
3272
  BFD_RELOC_IA64_PCREL32LSB
3273
ENUMX
3274
  BFD_RELOC_IA64_PCREL64MSB
3275
ENUMX
3276
  BFD_RELOC_IA64_PCREL64LSB
3277
ENUMX
3278
  BFD_RELOC_IA64_LTOFF_FPTR22
3279
ENUMX
3280
  BFD_RELOC_IA64_LTOFF_FPTR64I
3281
ENUMX
3282
  BFD_RELOC_IA64_LTOFF_FPTR32MSB
3283
ENUMX
3284
  BFD_RELOC_IA64_LTOFF_FPTR32LSB
3285
ENUMX
3286
  BFD_RELOC_IA64_LTOFF_FPTR64MSB
3287
ENUMX
3288
  BFD_RELOC_IA64_LTOFF_FPTR64LSB
3289
ENUMX
3290
  BFD_RELOC_IA64_SEGREL32MSB
3291
ENUMX
3292
  BFD_RELOC_IA64_SEGREL32LSB
3293
ENUMX
3294
  BFD_RELOC_IA64_SEGREL64MSB
3295
ENUMX
3296
  BFD_RELOC_IA64_SEGREL64LSB
3297
ENUMX
3298
  BFD_RELOC_IA64_SECREL32MSB
3299
ENUMX
3300
  BFD_RELOC_IA64_SECREL32LSB
3301
ENUMX
3302
  BFD_RELOC_IA64_SECREL64MSB
3303
ENUMX
3304
  BFD_RELOC_IA64_SECREL64LSB
3305
ENUMX
3306
  BFD_RELOC_IA64_REL32MSB
3307
ENUMX
3308
  BFD_RELOC_IA64_REL32LSB
3309
ENUMX
3310
  BFD_RELOC_IA64_REL64MSB
3311
ENUMX
3312
  BFD_RELOC_IA64_REL64LSB
3313
ENUMX
3314
  BFD_RELOC_IA64_LTV32MSB
3315
ENUMX
3316
  BFD_RELOC_IA64_LTV32LSB
3317
ENUMX
3318
  BFD_RELOC_IA64_LTV64MSB
3319
ENUMX
3320
  BFD_RELOC_IA64_LTV64LSB
3321
ENUMX
3322
  BFD_RELOC_IA64_IPLTMSB
3323
ENUMX
3324
  BFD_RELOC_IA64_IPLTLSB
3325
ENUMX
3326
  BFD_RELOC_IA64_COPY
3327
ENUMX
3328
  BFD_RELOC_IA64_LTOFF22X
3329
ENUMX
3330
  BFD_RELOC_IA64_LDXMOV
3331
ENUMX
3332
  BFD_RELOC_IA64_TPREL14
3333
ENUMX
3334
  BFD_RELOC_IA64_TPREL22
3335
ENUMX
3336
  BFD_RELOC_IA64_TPREL64I
3337
ENUMX
3338
  BFD_RELOC_IA64_TPREL64MSB
3339
ENUMX
3340
  BFD_RELOC_IA64_TPREL64LSB
3341
ENUMX
3342
  BFD_RELOC_IA64_LTOFF_TPREL22
3343
ENUMX
3344
  BFD_RELOC_IA64_DTPMOD64MSB
3345
ENUMX
3346
  BFD_RELOC_IA64_DTPMOD64LSB
3347
ENUMX
3348
  BFD_RELOC_IA64_LTOFF_DTPMOD22
3349
ENUMX
3350
  BFD_RELOC_IA64_DTPREL14
3351
ENUMX
3352
  BFD_RELOC_IA64_DTPREL22
3353
ENUMX
3354
  BFD_RELOC_IA64_DTPREL64I
3355
ENUMX
3356
  BFD_RELOC_IA64_DTPREL32MSB
3357
ENUMX
3358
  BFD_RELOC_IA64_DTPREL32LSB
3359
ENUMX
3360
  BFD_RELOC_IA64_DTPREL64MSB
3361
ENUMX
3362
  BFD_RELOC_IA64_DTPREL64LSB
3363
ENUMX
3364
  BFD_RELOC_IA64_LTOFF_DTPREL22
3365
ENUMDOC
3366
  Intel IA64 Relocations.
3367
 
3368
ENUM
3369
  BFD_RELOC_M68HC11_HI8
3370
ENUMDOC
3371
  Motorola 68HC11 reloc.
3372
  This is the 8 bit high part of an absolute address.
3373
ENUM
3374
  BFD_RELOC_M68HC11_LO8
3375
ENUMDOC
3376
  Motorola 68HC11 reloc.
3377
  This is the 8 bit low part of an absolute address.
3378
ENUM
3379
  BFD_RELOC_M68HC11_3B
3380
ENUMDOC
3381
  Motorola 68HC11 reloc.
3382
  This is the 3 bit of a value.
3383
ENUM
3384
  BFD_RELOC_M68HC11_RL_JUMP
3385
ENUMDOC
3386
  Motorola 68HC11 reloc.
3387
  This reloc marks the beginning of a jump/call instruction.
3388
  It is used for linker relaxation to correctly identify beginning
3389
  of instruction and change some branchs to use PC-relative
3390
  addressing mode.
3391
ENUM
3392
  BFD_RELOC_M68HC11_RL_GROUP
3393
ENUMDOC
3394
  Motorola 68HC11 reloc.
3395
  This reloc marks a group of several instructions that gcc generates
3396
  and for which the linker relaxation pass can modify and/or remove
3397
  some of them.
3398
ENUM
3399
  BFD_RELOC_M68HC11_LO16
3400
ENUMDOC
3401
  Motorola 68HC11 reloc.
3402
  This is the 16-bit lower part of an address.  It is used for 'call'
3403
  instruction to specify the symbol address without any special
3404
  transformation (due to memory bank window).
3405
ENUM
3406
  BFD_RELOC_M68HC11_PAGE
3407
ENUMDOC
3408
  Motorola 68HC11 reloc.
3409
  This is a 8-bit reloc that specifies the page number of an address.
3410
  It is used by 'call' instruction to specify the page number of
3411
  the symbol.
3412
ENUM
3413
  BFD_RELOC_M68HC11_24
3414
ENUMDOC
3415
  Motorola 68HC11 reloc.
3416
  This is a 24-bit reloc that represents the address with a 16-bit
3417
  value and a 8-bit page number.  The symbol address is transformed
3418
  to follow the 16K memory bank of 68HC12 (seen as mapped in the window).
3419
 
3420
ENUM
3421
  BFD_RELOC_CRIS_BDISP8
3422
ENUMX
3423
  BFD_RELOC_CRIS_UNSIGNED_5
3424
ENUMX
3425
  BFD_RELOC_CRIS_SIGNED_6
3426
ENUMX
3427
  BFD_RELOC_CRIS_UNSIGNED_6
3428
ENUMX
3429
  BFD_RELOC_CRIS_UNSIGNED_4
3430
ENUMDOC
3431
  These relocs are only used within the CRIS assembler.  They are not
3432
  (at present) written to any object files.
3433
ENUM
3434
  BFD_RELOC_CRIS_COPY
3435
ENUMX
3436
  BFD_RELOC_CRIS_GLOB_DAT
3437
ENUMX
3438
  BFD_RELOC_CRIS_JUMP_SLOT
3439
ENUMX
3440
  BFD_RELOC_CRIS_RELATIVE
3441
ENUMDOC
3442
  Relocs used in ELF shared libraries for CRIS.
3443
ENUM
3444
  BFD_RELOC_CRIS_32_GOT
3445
ENUMDOC
3446
  32-bit offset to symbol-entry within GOT.
3447
ENUM
3448
  BFD_RELOC_CRIS_16_GOT
3449
ENUMDOC
3450
  16-bit offset to symbol-entry within GOT.
3451
ENUM
3452
  BFD_RELOC_CRIS_32_GOTPLT
3453
ENUMDOC
3454
  32-bit offset to symbol-entry within GOT, with PLT handling.
3455
ENUM
3456
  BFD_RELOC_CRIS_16_GOTPLT
3457
ENUMDOC
3458
  16-bit offset to symbol-entry within GOT, with PLT handling.
3459
ENUM
3460
  BFD_RELOC_CRIS_32_GOTREL
3461
ENUMDOC
3462
  32-bit offset to symbol, relative to GOT.
3463
ENUM
3464
  BFD_RELOC_CRIS_32_PLT_GOTREL
3465
ENUMDOC
3466
  32-bit offset to symbol with PLT entry, relative to GOT.
3467
ENUM
3468
  BFD_RELOC_CRIS_32_PLT_PCREL
3469
ENUMDOC
3470
  32-bit offset to symbol with PLT entry, relative to this relocation.
3471
 
3472
ENUM
3473
  BFD_RELOC_860_COPY
3474
ENUMX
3475
  BFD_RELOC_860_GLOB_DAT
3476
ENUMX
3477
  BFD_RELOC_860_JUMP_SLOT
3478
ENUMX
3479
  BFD_RELOC_860_RELATIVE
3480
ENUMX
3481
  BFD_RELOC_860_PC26
3482
ENUMX
3483
  BFD_RELOC_860_PLT26
3484
ENUMX
3485
  BFD_RELOC_860_PC16
3486
ENUMX
3487
  BFD_RELOC_860_LOW0
3488
ENUMX
3489
  BFD_RELOC_860_SPLIT0
3490
ENUMX
3491
  BFD_RELOC_860_LOW1
3492
ENUMX
3493
  BFD_RELOC_860_SPLIT1
3494
ENUMX
3495
  BFD_RELOC_860_LOW2
3496
ENUMX
3497
  BFD_RELOC_860_SPLIT2
3498
ENUMX
3499
  BFD_RELOC_860_LOW3
3500
ENUMX
3501
  BFD_RELOC_860_LOGOT0
3502
ENUMX
3503
  BFD_RELOC_860_SPGOT0
3504
ENUMX
3505
  BFD_RELOC_860_LOGOT1
3506
ENUMX
3507
  BFD_RELOC_860_SPGOT1
3508
ENUMX
3509
  BFD_RELOC_860_LOGOTOFF0
3510
ENUMX
3511
  BFD_RELOC_860_SPGOTOFF0
3512
ENUMX
3513
  BFD_RELOC_860_LOGOTOFF1
3514
ENUMX
3515
  BFD_RELOC_860_SPGOTOFF1
3516
ENUMX
3517
  BFD_RELOC_860_LOGOTOFF2
3518
ENUMX
3519
  BFD_RELOC_860_LOGOTOFF3
3520
ENUMX
3521
  BFD_RELOC_860_LOPC
3522
ENUMX
3523
  BFD_RELOC_860_HIGHADJ
3524
ENUMX
3525
  BFD_RELOC_860_HAGOT
3526
ENUMX
3527
  BFD_RELOC_860_HAGOTOFF
3528
ENUMX
3529
  BFD_RELOC_860_HAPC
3530
ENUMX
3531
  BFD_RELOC_860_HIGH
3532
ENUMX
3533
  BFD_RELOC_860_HIGOT
3534
ENUMX
3535
  BFD_RELOC_860_HIGOTOFF
3536
ENUMDOC
3537
  Intel i860 Relocations.
3538
 
3539
ENUM
3540
  BFD_RELOC_OPENRISC_ABS_26
3541
ENUMX
3542
  BFD_RELOC_OPENRISC_REL_26
3543
ENUMDOC
3544
  OpenRISC Relocations.
3545
 
3546
ENUM
3547
  BFD_RELOC_H8_DIR16A8
3548
ENUMX
3549
  BFD_RELOC_H8_DIR16R8
3550
ENUMX
3551
  BFD_RELOC_H8_DIR24A8
3552
ENUMX
3553
  BFD_RELOC_H8_DIR24R8
3554
ENUMX
3555
  BFD_RELOC_H8_DIR32A16
3556
ENUMDOC
3557
  H8 elf Relocations.
3558
 
3559
ENUM
3560
  BFD_RELOC_XSTORMY16_REL_12
3561
ENUMX
3562
  BFD_RELOC_XSTORMY16_24
3563
ENUMX
3564
  BFD_RELOC_XSTORMY16_FPTR16
3565
ENUMDOC
3566
  Sony Xstormy16 Relocations.
3567
 
3568
ENUM
3569
  BFD_RELOC_VAX_GLOB_DAT
3570
ENUMX
3571
  BFD_RELOC_VAX_JMP_SLOT
3572
ENUMX
3573
  BFD_RELOC_VAX_RELATIVE
3574
ENUMDOC
3575
  Relocations used by VAX ELF.
3576
 
3577
ENDSENUM
3578
  BFD_RELOC_UNUSED
3579
CODE_FRAGMENT
3580
.
3581
.typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
3582
*/
3583
 
3584
/*
3585
FUNCTION
3586
        bfd_reloc_type_lookup
3587
 
3588
SYNOPSIS
3589
        reloc_howto_type *
3590
        bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
3591
 
3592
DESCRIPTION
3593
        Return a pointer to a howto structure which, when
3594
        invoked, will perform the relocation @var{code} on data from the
3595
        architecture noted.
3596
 
3597
*/
3598
 
3599
reloc_howto_type *
3600
bfd_reloc_type_lookup (abfd, code)
3601
     bfd *abfd;
3602
     bfd_reloc_code_real_type code;
3603
{
3604
  return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
3605
}
3606
 
3607
static reloc_howto_type bfd_howto_32 =
3608
HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
3609
 
3610
/*
3611
INTERNAL_FUNCTION
3612
        bfd_default_reloc_type_lookup
3613
 
3614
SYNOPSIS
3615
        reloc_howto_type *bfd_default_reloc_type_lookup
3616
        (bfd *abfd, bfd_reloc_code_real_type  code);
3617
 
3618
DESCRIPTION
3619
        Provides a default relocation lookup routine for any architecture.
3620
 
3621
*/
3622
 
3623
reloc_howto_type *
3624
bfd_default_reloc_type_lookup (abfd, code)
3625
     bfd *abfd;
3626
     bfd_reloc_code_real_type code;
3627
{
3628
  switch (code)
3629
    {
3630
    case BFD_RELOC_CTOR:
3631
      /* The type of reloc used in a ctor, which will be as wide as the
3632
         address - so either a 64, 32, or 16 bitter.  */
3633
      switch (bfd_get_arch_info (abfd)->bits_per_address)
3634
        {
3635
        case 64:
3636
          BFD_FAIL ();
3637
        case 32:
3638
          return &bfd_howto_32;
3639
        case 16:
3640
          BFD_FAIL ();
3641
        default:
3642
          BFD_FAIL ();
3643
        }
3644
    default:
3645
      BFD_FAIL ();
3646
    }
3647
  return (reloc_howto_type *) NULL;
3648
}
3649
 
3650
/*
3651
FUNCTION
3652
        bfd_get_reloc_code_name
3653
 
3654
SYNOPSIS
3655
        const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
3656
 
3657
DESCRIPTION
3658
        Provides a printable name for the supplied relocation code.
3659
        Useful mainly for printing error messages.
3660
*/
3661
 
3662
const char *
3663
bfd_get_reloc_code_name (code)
3664
     bfd_reloc_code_real_type code;
3665
{
3666
  if (code > BFD_RELOC_UNUSED)
3667
    return 0;
3668
  return bfd_reloc_code_real_names[(int)code];
3669
}
3670
 
3671
/*
3672
INTERNAL_FUNCTION
3673
        bfd_generic_relax_section
3674
 
3675
SYNOPSIS
3676
        boolean bfd_generic_relax_section
3677
         (bfd *abfd,
3678
          asection *section,
3679
          struct bfd_link_info *,
3680
          boolean *);
3681
 
3682
DESCRIPTION
3683
        Provides default handling for relaxing for back ends which
3684
        don't do relaxing -- i.e., does nothing.
3685
*/
3686
 
3687
boolean
3688
bfd_generic_relax_section (abfd, section, link_info, again)
3689
     bfd *abfd ATTRIBUTE_UNUSED;
3690
     asection *section ATTRIBUTE_UNUSED;
3691
     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3692
     boolean *again;
3693
{
3694
  *again = false;
3695
  return true;
3696
}
3697
 
3698
/*
3699
INTERNAL_FUNCTION
3700
        bfd_generic_gc_sections
3701
 
3702
SYNOPSIS
3703
        boolean bfd_generic_gc_sections
3704
         (bfd *, struct bfd_link_info *);
3705
 
3706
DESCRIPTION
3707
        Provides default handling for relaxing for back ends which
3708
        don't do section gc -- i.e., does nothing.
3709
*/
3710
 
3711
boolean
3712
bfd_generic_gc_sections (abfd, link_info)
3713
     bfd *abfd ATTRIBUTE_UNUSED;
3714
     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3715
{
3716
  return true;
3717
}
3718
 
3719
/*
3720
INTERNAL_FUNCTION
3721
        bfd_generic_merge_sections
3722
 
3723
SYNOPSIS
3724
        boolean bfd_generic_merge_sections
3725
         (bfd *, struct bfd_link_info *);
3726
 
3727
DESCRIPTION
3728
        Provides default handling for SEC_MERGE section merging for back ends
3729
        which don't have SEC_MERGE support -- i.e., does nothing.
3730
*/
3731
 
3732
boolean
3733
bfd_generic_merge_sections (abfd, link_info)
3734
     bfd *abfd ATTRIBUTE_UNUSED;
3735
     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3736
{
3737
  return true;
3738
}
3739
 
3740
/*
3741
INTERNAL_FUNCTION
3742
        bfd_generic_get_relocated_section_contents
3743
 
3744
SYNOPSIS
3745
        bfd_byte *
3746
           bfd_generic_get_relocated_section_contents (bfd *abfd,
3747
             struct bfd_link_info *link_info,
3748
             struct bfd_link_order *link_order,
3749
             bfd_byte *data,
3750
             boolean relocateable,
3751
             asymbol **symbols);
3752
 
3753
DESCRIPTION
3754
        Provides default handling of relocation effort for back ends
3755
        which can't be bothered to do it efficiently.
3756
 
3757
*/
3758
 
3759
bfd_byte *
3760
bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
3761
                                            relocateable, symbols)
3762
     bfd *abfd;
3763
     struct bfd_link_info *link_info;
3764
     struct bfd_link_order *link_order;
3765
     bfd_byte *data;
3766
     boolean relocateable;
3767
     asymbol **symbols;
3768
{
3769
  /* Get enough memory to hold the stuff.  */
3770
  bfd *input_bfd = link_order->u.indirect.section->owner;
3771
  asection *input_section = link_order->u.indirect.section;
3772
 
3773
  long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
3774
  arelent **reloc_vector = NULL;
3775
  long reloc_count;
3776
 
3777
  if (reloc_size < 0)
3778
    goto error_return;
3779
 
3780
  reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
3781
  if (reloc_vector == NULL && reloc_size != 0)
3782
    goto error_return;
3783
 
3784
  /* Read in the section.  */
3785
  if (!bfd_get_section_contents (input_bfd,
3786
                                 input_section,
3787
                                 (PTR) data,
3788
                                 (bfd_vma) 0,
3789
                                 input_section->_raw_size))
3790
    goto error_return;
3791
 
3792
  /* We're not relaxing the section, so just copy the size info.  */
3793
  input_section->_cooked_size = input_section->_raw_size;
3794
  input_section->reloc_done = true;
3795
 
3796
  reloc_count = bfd_canonicalize_reloc (input_bfd,
3797
                                        input_section,
3798
                                        reloc_vector,
3799
                                        symbols);
3800
  if (reloc_count < 0)
3801
    goto error_return;
3802
 
3803
  if (reloc_count > 0)
3804
    {
3805
      arelent **parent;
3806
      for (parent = reloc_vector; *parent != (arelent *) NULL;
3807
           parent++)
3808
        {
3809
          char *error_message = (char *) NULL;
3810
          bfd_reloc_status_type r =
3811
            bfd_perform_relocation (input_bfd,
3812
                                    *parent,
3813
                                    (PTR) data,
3814
                                    input_section,
3815
                                    relocateable ? abfd : (bfd *) NULL,
3816
                                    &error_message);
3817
 
3818
          if (relocateable)
3819
            {
3820
              asection *os = input_section->output_section;
3821
 
3822
              /* A partial link, so keep the relocs.  */
3823
              os->orelocation[os->reloc_count] = *parent;
3824
              os->reloc_count++;
3825
            }
3826
 
3827
          if (r != bfd_reloc_ok)
3828
            {
3829
              switch (r)
3830
                {
3831
                case bfd_reloc_undefined:
3832
                  if (!((*link_info->callbacks->undefined_symbol)
3833
                        (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
3834
                         input_bfd, input_section, (*parent)->address,
3835
                         true)))
3836
                    goto error_return;
3837
                  break;
3838
                case bfd_reloc_dangerous:
3839
                  BFD_ASSERT (error_message != (char *) NULL);
3840
                  if (!((*link_info->callbacks->reloc_dangerous)
3841
                        (link_info, error_message, input_bfd, input_section,
3842
                         (*parent)->address)))
3843
                    goto error_return;
3844
                  break;
3845
                case bfd_reloc_overflow:
3846
                  if (!((*link_info->callbacks->reloc_overflow)
3847
                        (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
3848
                         (*parent)->howto->name, (*parent)->addend,
3849
                         input_bfd, input_section, (*parent)->address)))
3850
                    goto error_return;
3851
                  break;
3852
                case bfd_reloc_outofrange:
3853
                default:
3854
                  abort ();
3855
                  break;
3856
                }
3857
 
3858
            }
3859
        }
3860
    }
3861
  if (reloc_vector != NULL)
3862
    free (reloc_vector);
3863
  return data;
3864
 
3865
error_return:
3866
  if (reloc_vector != NULL)
3867
    free (reloc_vector);
3868
  return NULL;
3869
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.