← Back to branch summary

~ubuntu-branches/ubuntu/hoary/binutils/hoary

« back to all changes in this revision

Viewing changes to bfd/elf32-or32.c

  • Committer: Bazaar Package Importer
  • Author(s): James Troup
  • Date: 2004-05-19 10:35:44 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040519103544-17h3o6e8pwndydrg
Tags: 2.14.90.0.7-8
debian/rules: don't use gcc-2.95 on m68k.  Thanks to Adam Conrad for
pointing this out.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bfd/elf32-or32.c
 
1
/* OR32-specific support for 32-bit ELF
 
2
   Copyright 2002 Free Software Foundation, Inc.
 
3
   Contributed by Ivan Guzvinec  <ivang@opencores.org>
 
4
 
 
5
   This file is part of BFD, the Binary File Descriptor library.
 
6
 
 
7
   This program is free software; you can redistribute it and/or modify
 
8
   it under the terms of the GNU General Public License as published by
 
9
   the Free Software Foundation; either version 2 of the License, or
 
10
   (at your option) any later version.
 
11
 
 
12
   This program is distributed in the hope that it will be useful,
 
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
   GNU General Public License for more details.
 
16
 
 
17
   You should have received a copy of the GNU General Public License
 
18
   along with this program; if not, write to the Free Software
 
19
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
20
 
 
21
#include "bfd.h"
 
22
#include "sysdep.h"
 
23
#include "libbfd.h"
 
24
#include "elf-bfd.h"
 
25
#include "elf/or32.h"
 
26
#include "libiberty.h"
 
27
 
 
28
static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
 
29
  PARAMS ((bfd *, bfd_reloc_code_real_type));
 
30
static void or32_info_to_howto_rel
 
31
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
 
32
static bfd_boolean or32_elf_object_p
 
33
  PARAMS ((bfd *));
 
34
static void or32_elf_final_write_processing
 
35
  PARAMS ((bfd *, bfd_boolean));
 
36
static bfd_reloc_status_type or32_elf_32_reloc
 
37
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
38
static bfd_reloc_status_type or32_elf_16_reloc
 
39
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
40
static bfd_reloc_status_type or32_elf_8_reloc
 
41
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
42
static bfd_reloc_status_type or32_elf_const_reloc
 
43
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
44
static bfd_reloc_status_type or32_elf_consth_reloc
 
45
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
46
static bfd_reloc_status_type or32_elf_jumptarg_reloc
 
47
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
48
 
 
49
/* Try to minimize the amount of space occupied by relocation tables
 
50
   on the ROM (not that the ROM won't be swamped by other ELF overhead).  */
 
51
#define USE_REL 1
 
52
 
 
53
static reloc_howto_type elf_or32_howto_table[] =
 
54
{
 
55
  /* This reloc does nothing.  */
 
56
  HOWTO (R_OR32_NONE,           /* type */
 
57
         0,                     /* rightshift */
 
58
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
 
59
         32,                    /* bitsize */
 
60
         FALSE,                 /* pc_relative */
 
61
         0,                     /* bitpos */
 
62
         complain_overflow_bitfield, /* complain_on_overflow */
 
63
         bfd_elf_generic_reloc, /* special_function */
 
64
         "R_OR32_NONE",         /* name */
 
65
         FALSE,                 /* partial_inplace */
 
66
         0,                     /* src_mask */
 
67
         0,                     /* dst_mask */
 
68
         FALSE),                /* pcrel_offset */
 
69
 
 
70
  /* A standard 32 bit relocation.  */
 
71
  HOWTO (R_OR32_32,             /* type */
 
72
         0,                     /* rightshift */
 
73
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
 
74
         32,                    /* bitsize */
 
75
         FALSE,                 /* pc_relative */
 
76
         0,                     /* bitpos */
 
77
         complain_overflow_bitfield, /* complain_on_overflow */
 
78
         or32_elf_32_reloc,     /* special_function */
 
79
         "R_OR32_32",           /* name */
 
80
         FALSE,                 /* partial_inplace */
 
81
         0xffffffff,            /* src_mask */
 
82
         0xffffffff,            /* dst_mask */
 
83
         FALSE),                /* pcrel_offset */
 
84
 
 
85
  /* A standard 16 bit relocation.  */
 
86
  HOWTO (R_OR32_16,             /* type */
 
87
         0,                     /* rightshift */
 
88
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
 
89
         16,                    /* bitsize */
 
90
         FALSE,                 /* pc_relative */
 
91
         0,                     /* bitpos */
 
92
         complain_overflow_bitfield, /* complain_on_overflow */
 
93
         or32_elf_16_reloc,     /* special_function */
 
94
         "R_OR32_16",           /* name */
 
95
         FALSE,                 /* partial_inplace */
 
96
         0x0000ffff,            /* src_mask */
 
97
         0x0000ffff,            /* dst_mask */
 
98
         FALSE),                /* pcrel_offset */
 
99
 
 
100
  /* A standard 8 bit relocation.  */
 
101
  HOWTO (R_OR32_8,              /* type */
 
102
         0,                     /* rightshift */
 
103
         0,                     /* size (0 = byte, 1 = short, 2 = long) */
 
104
         8,                     /* bitsize */
 
105
         FALSE,                 /* pc_relative */
 
106
         0,                     /* bitpos */
 
107
         complain_overflow_bitfield, /* complain_on_overflow */
 
108
         or32_elf_8_reloc,      /* special_function */
 
109
         "R_OR32_8",            /* name */
 
110
         FALSE,                 /* partial_inplace */
 
111
         0x000000ff,            /* src_mask */
 
112
         0x000000ff,            /* dst_mask */
 
113
         FALSE),                /* pcrel_offset */
 
114
 
 
115
  /* A standard low 16 bit relocation.  */
 
116
  HOWTO (R_OR32_CONST,          /* type */
 
117
         0,                     /* rightshift */
 
118
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
 
119
         16,                    /* bitsize */
 
120
         FALSE,                 /* pc_relative */
 
121
         0,                     /* bitpos */
 
122
         complain_overflow_dont, /* complain_on_overflow */
 
123
         or32_elf_const_reloc,  /* special_function */
 
124
         "R_OR32_CONST",        /* name */
 
125
         FALSE,                 /* partial_inplace */
 
126
         0x0000ffff,            /* src_mask */
 
127
         0x0000ffff,            /* dst_mask */
 
128
         FALSE),                /* pcrel_offset */
 
129
 
 
130
  /* A standard high 16 bit relocation.  */
 
131
  HOWTO (R_OR32_CONSTH,         /* type */
 
132
         16,                    /* rightshift */
 
133
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
 
134
         16,                    /* bitsize */
 
135
         TRUE,                  /* pc_relative */
 
136
         0,                     /* bitpos */
 
137
         complain_overflow_dont, /* complain_on_overflow */
 
138
         or32_elf_consth_reloc, /* special_function */
 
139
         "R_OR32_CONSTH",       /* name */
 
140
         FALSE,                 /* partial_inplace */
 
141
         0xffff0000,            /* src_mask */
 
142
         0x0000ffff,            /* dst_mask */
 
143
         FALSE),                /* pcrel_offset */
 
144
 
 
145
  /* A standard branch relocation.  */
 
146
  HOWTO (R_OR32_JUMPTARG,       /* type */
 
147
         2,                     /* rightshift */
 
148
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
 
149
         28,                    /* bitsize */
 
150
         TRUE,                  /* pc_relative */
 
151
         0,                     /* bitpos */
 
152
         complain_overflow_signed, /* complain_on_overflow */
 
153
         or32_elf_jumptarg_reloc,/* special_function */
 
154
         "R_OR32_JUMPTARG",     /* name */
 
155
         FALSE,                 /* partial_inplace */
 
156
         0,                     /* src_mask */
 
157
         0x03ffffff,            /* dst_mask */
 
158
         TRUE),                 /* pcrel_offset */
 
159
 
 
160
  /* GNU extension to record C++ vtable hierarchy.  */
 
161
  HOWTO (R_OR32_GNU_VTINHERIT, /* type */
 
162
         0,                     /* rightshift */
 
163
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
 
164
         0,                     /* bitsize */
 
165
         FALSE,                 /* pc_relative */
 
166
         0,                     /* bitpos */
 
167
         complain_overflow_dont, /* complain_on_overflow */
 
168
         NULL,                  /* special_function */
 
169
         "R_OR32_GNU_VTINHERIT", /* name */
 
170
         FALSE,                 /* partial_inplace */
 
171
         0,                     /* src_mask */
 
172
         0,                     /* dst_mask */
 
173
         FALSE),                /* pcrel_offset */
 
174
 
 
175
  /* GNU extension to record C++ vtable member usage.  */
 
176
  HOWTO (R_OR32_GNU_VTENTRY,     /* type */
 
177
         0,                     /* rightshift */
 
178
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
 
179
         0,                     /* bitsize */
 
180
         FALSE,                 /* pc_relative */
 
181
         0,                     /* bitpos */
 
182
         complain_overflow_dont, /* complain_on_overflow */
 
183
         _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 
184
         "R_OR32_GNU_VTENTRY",   /* name */
 
185
         FALSE,                 /* partial_inplace */
 
186
         0,                     /* src_mask */
 
187
         0,                     /* dst_mask */
 
188
         FALSE),                /* pcrel_offset */
 
189
};
 
190
 
 
191
/* Map BFD reloc types to OR32 ELF reloc types.  */
 
192
 
 
193
struct or32_reloc_map
 
194
{
 
195
  bfd_reloc_code_real_type  bfd_reloc_val;
 
196
  unsigned char             elf_reloc_val;
 
197
};
 
198
 
 
199
static const struct or32_reloc_map or32_reloc_map[] =
 
200
{
 
201
  { BFD_RELOC_NONE, R_OR32_NONE },
 
202
  { BFD_RELOC_32, R_OR32_32 },
 
203
  { BFD_RELOC_16, R_OR32_16 },
 
204
  { BFD_RELOC_8, R_OR32_8 },
 
205
  { BFD_RELOC_LO16, R_OR32_CONST },
 
206
  { BFD_RELOC_HI16, R_OR32_CONSTH },
 
207
  { BFD_RELOC_32_GOT_PCREL, R_OR32_JUMPTARG },
 
208
  { BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT },
 
209
  { BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY },
 
210
};
 
211
 
 
212
static reloc_howto_type *
 
213
bfd_elf32_bfd_reloc_type_lookup (abfd, code)
 
214
     bfd *abfd ATTRIBUTE_UNUSED;
 
215
     bfd_reloc_code_real_type code;
 
216
{
 
217
  unsigned int i;
 
218
 
 
219
  for (i = ARRAY_SIZE (or32_reloc_map); i--;)
 
220
    {
 
221
      if (or32_reloc_map[i].bfd_reloc_val == code)
 
222
        return &elf_or32_howto_table[or32_reloc_map[i].elf_reloc_val];
 
223
    }
 
224
 
 
225
  return NULL;
 
226
}
 
227
 
 
228
/* Set the howto pointer for an OR32 ELF reloc.  */
 
229
 
 
230
static void
 
231
or32_info_to_howto_rel (abfd, cache_ptr, dst)
 
232
     bfd *abfd ATTRIBUTE_UNUSED;
 
233
     arelent *cache_ptr;
 
234
     Elf_Internal_Rela *dst;
 
235
{
 
236
  unsigned int r_type;
 
237
 
 
238
  r_type = ELF32_R_TYPE (dst->r_info);
 
239
  BFD_ASSERT (r_type < (unsigned int) R_OR32_max);
 
240
  cache_ptr->howto = &elf_or32_howto_table[r_type];
 
241
}
 
242
 
 
243
/* Set the right machine number for an OR32 ELF file.  */
 
244
 
 
245
static bfd_boolean
 
246
or32_elf_object_p (abfd)
 
247
     bfd *abfd;
 
248
{
 
249
  (void) bfd_default_set_arch_mach (abfd, bfd_arch_or32, 0);
 
250
  return TRUE;
 
251
}
 
252
 
 
253
/* The final processing done just before writing out an OR32 ELF object file.
 
254
   This gets the OR32 architecture right based on the machine number.  */
 
255
 
 
256
static void
 
257
or32_elf_final_write_processing (abfd, linker)
 
258
     bfd *abfd;
 
259
     bfd_boolean linker ATTRIBUTE_UNUSED;
 
260
{
 
261
  int mach;
 
262
  unsigned long val;
 
263
 
 
264
  switch (mach = bfd_get_mach (abfd))
 
265
    {
 
266
    /*
 
267
    case bfd_mach_arc_base:
 
268
      val = E_OR32_MACH_BASE;
 
269
      break;
 
270
    */
 
271
    default:
 
272
      val = 0;
 
273
      return;
 
274
    }
 
275
 
 
276
  elf_elfheader (abfd)->e_flags &=~ EF_OR32_MACH;
 
277
  elf_elfheader (abfd)->e_flags |= val;
 
278
}
 
279
 
 
280
bfd_reloc_status_type
 
281
or32_elf_32_reloc (abfd, reloc_entry, symbol, data, input_section,
 
282
                   output_bfd, error_message)
 
283
     bfd *abfd;
 
284
     arelent *reloc_entry;
 
285
     asymbol *symbol;
 
286
     PTR data;
 
287
     asection *input_section;
 
288
     bfd *output_bfd;
 
289
     char **error_message ATTRIBUTE_UNUSED;
 
290
{
 
291
  if (output_bfd != (bfd *) NULL)
 
292
    {
 
293
      unsigned long insn;
 
294
      bfd_size_type addr = reloc_entry->address;
 
295
 
 
296
      reloc_entry->address += input_section->output_offset;
 
297
 
 
298
      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 
299
      insn += symbol->section->output_section->vma;
 
300
      insn += symbol->section->output_offset;
 
301
      insn += symbol->value;
 
302
      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
 
303
 
 
304
      return bfd_reloc_ok;
 
305
    }
 
306
 
 
307
  return bfd_reloc_continue;
 
308
}
 
309
 
 
310
bfd_reloc_status_type
 
311
or32_elf_16_reloc (abfd, reloc_entry, symbol, data, input_section,
 
312
                   output_bfd, error_message)
 
313
     bfd *abfd;
 
314
     arelent *reloc_entry;
 
315
     asymbol *symbol;
 
316
     PTR data;
 
317
     asection *input_section;
 
318
     bfd *output_bfd;
 
319
     char **error_message ATTRIBUTE_UNUSED;
 
320
{
 
321
  if (output_bfd != (bfd *) NULL)
 
322
    {
 
323
      unsigned short insn;
 
324
      bfd_size_type addr = reloc_entry->address;
 
325
 
 
326
      reloc_entry->address += input_section->output_offset;
 
327
 
 
328
      insn = bfd_get_16 (abfd, (bfd_byte *) data + addr);
 
329
      insn += symbol->section->output_section->vma;
 
330
      insn += symbol->section->output_offset;
 
331
      insn += symbol->value;
 
332
      bfd_put_16 (abfd, insn, (bfd_byte *) data + addr);
 
333
 
 
334
      return bfd_reloc_ok;
 
335
    }
 
336
 
 
337
  return bfd_reloc_continue;
 
338
}
 
339
 
 
340
bfd_reloc_status_type
 
341
or32_elf_8_reloc (abfd, reloc_entry, symbol, data, input_section,
 
342
                  output_bfd, error_message)
 
343
     bfd *abfd ATTRIBUTE_UNUSED;
 
344
     arelent *reloc_entry;
 
345
     asymbol *symbol;
 
346
     PTR data;
 
347
     asection *input_section;
 
348
     bfd *output_bfd;
 
349
     char **error_message ATTRIBUTE_UNUSED;
 
350
{
 
351
  if (output_bfd != (bfd *) NULL)
 
352
    {
 
353
      unsigned char insn;
 
354
      bfd_size_type addr = reloc_entry->address;
 
355
 
 
356
      reloc_entry->address += input_section->output_offset;
 
357
 
 
358
      insn = bfd_get_8 (abfd, (bfd_byte *) data + addr);
 
359
      insn += symbol->section->output_section->vma;
 
360
      insn += symbol->section->output_offset;
 
361
      insn += symbol->value;
 
362
      bfd_put_8 (abfd, insn, (bfd_byte *) data + addr);
 
363
 
 
364
      return bfd_reloc_ok;
 
365
    }
 
366
 
 
367
  return bfd_reloc_continue;
 
368
}
 
369
 
 
370
/* Do a R_OR32_CONSTH relocation.  This has to be done in combination
 
371
   with a R_OR32_CONST reloc, because there is a carry from the LO16 to
 
372
   the HI16.  Here we just save the information we need; we do the
 
373
   actual relocation when we see the LO16.  OR32 ELF requires that the
 
374
   LO16 immediately follow the HI16.  As a GNU extension, we permit an
 
375
   arbitrary number of HI16 relocs to be associated with a single LO16
 
376
   reloc.  This extension permits gcc to output the HI and LO relocs
 
377
   itself. This code is copied from the elf32-mips.c.  */
 
378
 
 
379
struct or32_consth
 
380
{
 
381
  struct or32_consth *next;
 
382
  bfd_byte *addr;
 
383
  bfd_vma addend;
 
384
};
 
385
 
 
386
/* FIXME: This should not be a static variable.  */
 
387
 
 
388
static struct or32_consth *or32_consth_list;
 
389
 
 
390
bfd_reloc_status_type
 
391
or32_elf_consth_reloc (abfd, reloc_entry, symbol, data, input_section,
 
392
                       output_bfd, error_message)
 
393
     bfd *abfd ATTRIBUTE_UNUSED;
 
394
     arelent *reloc_entry;
 
395
     asymbol *symbol;
 
396
     PTR data;
 
397
     asection *input_section;
 
398
     bfd *output_bfd;
 
399
     char **error_message ATTRIBUTE_UNUSED;
 
400
{
 
401
  bfd_reloc_status_type ret;
 
402
  bfd_vma relocation;
 
403
  struct or32_consth *n;
 
404
 
 
405
  ret = bfd_reloc_ok;
 
406
 
 
407
  if (bfd_is_und_section (symbol->section)
 
408
      && output_bfd == (bfd *) NULL)
 
409
    ret = bfd_reloc_undefined;
 
410
 
 
411
  if (bfd_is_com_section (symbol->section))
 
412
    relocation = 0;
 
413
  else
 
414
    relocation = symbol->value;
 
415
 
 
416
  relocation += symbol->section->output_section->vma;
 
417
  relocation += symbol->section->output_offset;
 
418
  relocation += reloc_entry->addend;
 
419
 
 
420
  if (reloc_entry->address > input_section->_cooked_size)
 
421
    return bfd_reloc_outofrange;
 
422
 
 
423
  /* Save the information, and let LO16 do the actual relocation.  */
 
424
  n = (struct or32_consth *) bfd_malloc (sizeof *n);
 
425
  if (n == NULL)
 
426
    return bfd_reloc_outofrange;
 
427
  n->addr = (bfd_byte *) data + reloc_entry->address;
 
428
  n->addend = relocation;
 
429
  n->next = or32_consth_list;
 
430
  or32_consth_list = n;
 
431
 
 
432
  if (output_bfd != (bfd *) NULL)
 
433
    reloc_entry->address += input_section->output_offset;
 
434
 
 
435
  return ret;
 
436
}
 
437
 
 
438
/* Do a R_OR32_CONST relocation.  This is a straightforward 16 bit
 
439
   inplace relocation; this function exists in order to do the
 
440
   R_OR32_CONSTH relocation described above.  */
 
441
 
 
442
bfd_reloc_status_type
 
443
or32_elf_const_reloc (abfd, reloc_entry, symbol, data, input_section,
 
444
                      output_bfd, error_message)
 
445
     bfd *abfd;
 
446
     arelent *reloc_entry;
 
447
     asymbol *symbol;
 
448
     PTR data;
 
449
     asection *input_section;
 
450
     bfd *output_bfd;
 
451
     char **error_message;
 
452
{
 
453
  if (or32_consth_list != NULL)
 
454
    {
 
455
      struct or32_consth *l;
 
456
 
 
457
      l = or32_consth_list;
 
458
      while (l != NULL)
 
459
        {
 
460
          unsigned long insn;
 
461
          unsigned long val;
 
462
          unsigned long vallo;
 
463
          struct or32_consth *next;
 
464
 
 
465
          /* Do the HI16 relocation.  Note that we actually don't need
 
466
             to know anything about the LO16 itself, except where to
 
467
             find the low 16 bits of the addend needed by the LO16.  */
 
468
          insn = bfd_get_32 (abfd, l->addr);
 
469
          vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
 
470
                   & 0xffff);
 
471
          val = ((insn & 0xffff) << 16) + vallo;
 
472
          val += l->addend;
 
473
 
 
474
          insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
 
475
          bfd_put_32 (abfd, insn, l->addr);
 
476
 
 
477
          next = l->next;
 
478
          free (l);
 
479
          l = next;
 
480
        }
 
481
 
 
482
      or32_consth_list = NULL;
 
483
    }
 
484
 
 
485
  if (output_bfd != (bfd *) NULL)
 
486
    {
 
487
      unsigned long insn, tmp;
 
488
      bfd_size_type addr = reloc_entry->address;
 
489
 
 
490
      reloc_entry->address += input_section->output_offset;
 
491
 
 
492
      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 
493
      tmp = insn & 0x0000ffff;
 
494
      tmp += symbol->section->output_section->vma;
 
495
      tmp += symbol->section->output_offset;
 
496
      tmp += symbol->value;
 
497
      insn = (insn & 0xffff0000) | (tmp & 0x0000ffff);
 
498
      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
 
499
 
 
500
      return bfd_reloc_ok;
 
501
    }
 
502
 
 
503
  /* Now do the LO16 reloc in the usual way.  */
 
504
  return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 
505
                                input_section, output_bfd, error_message);
 
506
}
 
507
 
 
508
bfd_reloc_status_type
 
509
or32_elf_jumptarg_reloc (abfd, reloc_entry, symbol, data, input_section,
 
510
                         output_bfd, error_message)
 
511
     bfd *abfd;
 
512
     arelent *reloc_entry;
 
513
     asymbol *symbol ATTRIBUTE_UNUSED;
 
514
     PTR data;
 
515
     asection *input_section;
 
516
     bfd *output_bfd;
 
517
     char **error_message ATTRIBUTE_UNUSED;
 
518
{
 
519
  if (output_bfd != (bfd *) NULL)
 
520
    {
 
521
      unsigned long insn, tmp;
 
522
      bfd_size_type addr = reloc_entry->address;
 
523
 
 
524
      reloc_entry->address += input_section->output_offset;
 
525
 
 
526
      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 
527
      tmp = insn | 0xfc000000;
 
528
      tmp -= (input_section->output_offset >> 2);
 
529
      insn = (insn & 0xfc000000) | (tmp & 0x03ffffff);
 
530
      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
 
531
 
 
532
      return bfd_reloc_ok;
 
533
    }
 
534
 
 
535
  return bfd_reloc_continue;
 
536
}
 
537
 
 
538
#define TARGET_LITTLE_SYM       bfd_elf32_or32_little_vec
 
539
#define TARGET_LITTLE_NAME      "elf32-littleor32"
 
540
#define TARGET_BIG_SYM          bfd_elf32_or32_big_vec
 
541
#define TARGET_BIG_NAME         "elf32-or32"
 
542
#define ELF_ARCH                bfd_arch_or32
 
543
#define ELF_MACHINE_CODE        EM_OR32
 
544
#define ELF_MAXPAGESIZE         0x1000
 
545
 
 
546
#define elf_info_to_howto       0
 
547
#define elf_info_to_howto_rel   or32_info_to_howto_rel
 
548
#define elf_backend_object_p    or32_elf_object_p
 
549
#define elf_backend_final_write_processing \
 
550
                                or32_elf_final_write_processing
 
551
 
 
552
#include "elf32-target.h"