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

Subversion Repositories openrisc

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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