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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [reloc.c] - Blame information for rev 14

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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