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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [reloc.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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