← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gclcvs/quantal

« back to all changes in this revision

Viewing changes to binutils/bfd/elf32-arc.c

  • Committer: Bazaar Package Importer
  • Author(s): Camm Maguire
  • Date: 2004-06-24 15:13:46 UTC
  • Revision ID: james.westby@ubuntu.com-20040624151346-xh0xaaktyyp7aorc
Tags: 2.7.0-26
C_GC_OFFSET is 2 on m68k-linux

Show diffs side-by-side

added added

removed removed

Lines of Context:
binutils/bfd/elf32-arc.c
 
1
/* ARC-specific support for 32-bit ELF
 
2
   Copyright 1994, 1995, 1997, 1999, 2001 Free Software Foundation, Inc.
 
3
   Contributed by Doug Evans (dje@cygnus.com).
 
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/arc.h"
 
26
#include "libiberty.h"
 
27
 
 
28
static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
 
29
  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
 
30
static void arc_info_to_howto_rel
 
31
  PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
 
32
static boolean arc_elf_object_p
 
33
  PARAMS ((bfd *));
 
34
static void arc_elf_final_write_processing
 
35
  PARAMS ((bfd *, boolean));
 
36
static bfd_reloc_status_type arc_elf_b22_pcrel
 
37
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
38
 
 
39
/* Try to minimize the amount of space occupied by relocation tables
 
40
   on the ROM (not that the ROM won't be swamped by other ELF overhead).  */
 
41
 
 
42
#define USE_REL
 
43
 
 
44
static reloc_howto_type elf_arc_howto_table[] =
 
45
{
 
46
  /* This reloc does nothing.  */
 
47
  HOWTO (R_ARC_NONE,            /* type  */
 
48
         0,                     /* rightshift  */
 
49
         2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 
50
         32,                    /* bitsize  */
 
51
         false,                 /* pc_relative  */
 
52
         0,                     /* bitpos  */
 
53
         complain_overflow_bitfield, /* complain_on_overflow  */
 
54
         bfd_elf_generic_reloc, /* special_function  */
 
55
         "R_ARC_NONE",          /* name  */
 
56
         true,                  /* partial_inplace  */
 
57
         0,                     /* src_mask  */
 
58
         0,                     /* dst_mask  */
 
59
         false),                /* pcrel_offset  */
 
60
 
 
61
  /* A standard 32 bit relocation.  */
 
62
  HOWTO (R_ARC_32,              /* type  */
 
63
         0,                     /* rightshift  */
 
64
         2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 
65
         32,                    /* bitsize  */
 
66
         false,                 /* pc_relative  */
 
67
         0,                     /* bitpos  */
 
68
         complain_overflow_bitfield, /* complain_on_overflow  */
 
69
         bfd_elf_generic_reloc, /* special_function  */
 
70
         "R_ARC_32",            /* name  */
 
71
         true,                  /* partial_inplace  */
 
72
         0xffffffff,            /* src_mask  */
 
73
         0xffffffff,            /* dst_mask  */
 
74
         false),                /* pcrel_offset  */
 
75
 
 
76
  /* A 26 bit absolute branch, right shifted by 2.  */
 
77
  HOWTO (R_ARC_B26,             /* type  */
 
78
         2,                     /* rightshift  */
 
79
         2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 
80
         26,                    /* bitsize  */
 
81
         false,                 /* pc_relative  */
 
82
         0,                     /* bitpos  */
 
83
         complain_overflow_bitfield, /* complain_on_overflow  */
 
84
         bfd_elf_generic_reloc, /* special_function  */
 
85
         "R_ARC_B26",           /* name  */
 
86
         true,                  /* partial_inplace  */
 
87
         0x00ffffff,            /* src_mask  */
 
88
         0x00ffffff,            /* dst_mask  */
 
89
         false),                /* pcrel_offset  */
 
90
 
 
91
  /* A relative 22 bit branch; bits 21-2 are stored in bits 26-7.  */
 
92
  HOWTO (R_ARC_B22_PCREL,       /* type  */
 
93
         2,                     /* rightshift  */
 
94
         2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 
95
         22,                    /* bitsize  */
 
96
         true,                  /* pc_relative  */
 
97
         7,                     /* bitpos  */
 
98
         complain_overflow_signed, /* complain_on_overflow  */
 
99
         arc_elf_b22_pcrel,     /* special_function  */
 
100
         "R_ARC_B22_PCREL",     /* name  */
 
101
         true,                  /* partial_inplace  */
 
102
         0x07ffff80,            /* src_mask  */
 
103
         0x07ffff80,            /* dst_mask  */
 
104
         false),                /* pcrel_offset  */
 
105
};
 
106
 
 
107
/* Map BFD reloc types to ARC ELF reloc types.  */
 
108
 
 
109
struct arc_reloc_map
 
110
{
 
111
  bfd_reloc_code_real_type bfd_reloc_val;
 
112
  unsigned char elf_reloc_val;
 
113
};
 
114
 
 
115
static const struct arc_reloc_map arc_reloc_map[] =
 
116
{
 
117
  { BFD_RELOC_NONE, R_ARC_NONE, },
 
118
  { BFD_RELOC_32, R_ARC_32 },
 
119
  { BFD_RELOC_CTOR, R_ARC_32 },
 
120
  { BFD_RELOC_ARC_B26, R_ARC_B26 },
 
121
  { BFD_RELOC_ARC_B22_PCREL, R_ARC_B22_PCREL },
 
122
};
 
123
 
 
124
static reloc_howto_type *
 
125
bfd_elf32_bfd_reloc_type_lookup (abfd, code)
 
126
     bfd *abfd ATTRIBUTE_UNUSED;
 
127
     bfd_reloc_code_real_type code;
 
128
{
 
129
  unsigned int i;
 
130
 
 
131
  for (i = ARRAY_SIZE (arc_reloc_map); i--;)
 
132
    if (arc_reloc_map[i].bfd_reloc_val == code)
 
133
      return elf_arc_howto_table + arc_reloc_map[i].elf_reloc_val;
 
134
 
 
135
  return NULL;
 
136
}
 
137
 
 
138
/* Set the howto pointer for an ARC ELF reloc.  */
 
139
 
 
140
static void
 
141
arc_info_to_howto_rel (abfd, cache_ptr, dst)
 
142
     bfd *abfd ATTRIBUTE_UNUSED;
 
143
     arelent *cache_ptr;
 
144
     Elf32_Internal_Rel *dst;
 
145
{
 
146
  unsigned int r_type;
 
147
 
 
148
  r_type = ELF32_R_TYPE (dst->r_info);
 
149
  BFD_ASSERT (r_type < (unsigned int) R_ARC_max);
 
150
  cache_ptr->howto = &elf_arc_howto_table[r_type];
 
151
}
 
152
 
 
153
/* Set the right machine number for an ARC ELF file.  */
 
154
 
 
155
static boolean
 
156
arc_elf_object_p (abfd)
 
157
     bfd *abfd;
 
158
{
 
159
  unsigned int mach = bfd_mach_arc_6;
 
160
 
 
161
  if (elf_elfheader(abfd)->e_machine == EM_ARC)
 
162
    {
 
163
      unsigned long arch = elf_elfheader (abfd)->e_flags & EF_ARC_MACH;
 
164
 
 
165
      switch (arch)
 
166
        {
 
167
        case E_ARC_MACH_ARC5:
 
168
          mach = bfd_mach_arc_5;
 
169
          break;
 
170
        default:
 
171
        case E_ARC_MACH_ARC6:
 
172
          mach = bfd_mach_arc_6;
 
173
          break;
 
174
        case E_ARC_MACH_ARC7:
 
175
          mach = bfd_mach_arc_7;
 
176
          break;
 
177
        case E_ARC_MACH_ARC8:
 
178
          mach = bfd_mach_arc_8;
 
179
          break;
 
180
        }
 
181
    }
 
182
  return bfd_default_set_arch_mach (abfd, bfd_arch_arc, mach);
 
183
}
 
184
 
 
185
/* The final processing done just before writing out an ARC ELF object file.
 
186
   This gets the ARC architecture right based on the machine number.  */
 
187
 
 
188
static void
 
189
arc_elf_final_write_processing (abfd, linker)
 
190
     bfd *abfd;
 
191
     boolean linker ATTRIBUTE_UNUSED;
 
192
{
 
193
  unsigned long val;
 
194
 
 
195
  switch (bfd_get_mach (abfd))
 
196
    {
 
197
    case bfd_mach_arc_5:
 
198
      val = E_ARC_MACH_ARC5;
 
199
      break;
 
200
    default:
 
201
    case bfd_mach_arc_6:
 
202
      val = E_ARC_MACH_ARC6;
 
203
      break;
 
204
    case bfd_mach_arc_7:
 
205
      val = E_ARC_MACH_ARC7;
 
206
      break;
 
207
    case bfd_mach_arc_8:
 
208
      val = E_ARC_MACH_ARC8;
 
209
      break;
 
210
    }
 
211
  elf_elfheader (abfd)->e_flags &=~ EF_ARC_MACH;
 
212
  elf_elfheader (abfd)->e_flags |= val;
 
213
}
 
214
 
 
215
bfd_reloc_status_type
 
216
arc_elf_b22_pcrel (abfd, reloc_entry, symbol, data, input_section,
 
217
                   output_bfd, error_message)
 
218
     bfd * abfd;
 
219
     arelent * reloc_entry;
 
220
     asymbol * symbol;
 
221
     PTR data;
 
222
     asection * input_section;
 
223
     bfd * output_bfd;
 
224
     char ** error_message;
 
225
{
 
226
  /* If linking, back up the final symbol address by the address of the
 
227
     reloc.  This cannot be accomplished by setting the pcrel_offset
 
228
     field to true, as bfd_install_relocation will detect this and refuse
 
229
     to install the offset in the first place, but bfd_perform_relocation
 
230
     will still insist on removing it.  */
 
231
  if (output_bfd == (bfd *) NULL)
 
232
    reloc_entry->addend -= reloc_entry->address;
 
233
 
 
234
  /* Fall through to the default elf reloc handler.  */
 
235
  return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 
236
                                input_section, output_bfd, error_message);
 
237
}
 
238
 
 
239
#define TARGET_LITTLE_SYM bfd_elf32_littlearc_vec
 
240
#define TARGET_LITTLE_NAME "elf32-littlearc"
 
241
#define TARGET_BIG_SYM bfd_elf32_bigarc_vec
 
242
#define TARGET_BIG_NAME "elf32-bigarc"
 
243
#define ELF_ARCH bfd_arch_arc
 
244
#define ELF_MACHINE_CODE EM_ARC
 
245
#define ELF_MAXPAGESIZE 0x1000
 
246
 
 
247
#define elf_info_to_howto 0
 
248
#define elf_info_to_howto_rel arc_info_to_howto_rel
 
249
#define elf_backend_object_p arc_elf_object_p
 
250
#define elf_backend_final_write_processing arc_elf_final_write_processing
 
251
 
 
252
#include "elf32-target.h"