?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / gnu / dist / gdb6 / bfd / elf32-or32.c
blob546aa151f5c80a44e2d238c2ddc817cbcb61bcaf
1 /* OR32-specific support for 32-bit ELF
2 Copyright 2002, 2004, 2005 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, 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 /* Try to minimize the amount of space occupied by relocation tables
29 on the ROM (not that the ROM won't be swamped by other ELF overhead). */
30 #define USE_REL 1
31
32 /* Set the right machine number for an OR32 ELF file. */
33
34 static bfd_boolean
35 or32_elf_object_p (bfd *abfd)
36 {
37 (void) bfd_default_set_arch_mach (abfd, bfd_arch_or32, 0);
38 return TRUE;
39 }
40
41 /* The final processing done just before writing out an OR32 ELF object file.
42 This gets the OR32 architecture right based on the machine number. */
43
44 static void
45 or32_elf_final_write_processing (bfd *abfd,
46 bfd_boolean linker ATTRIBUTE_UNUSED)
47 {
48 elf_elfheader (abfd)->e_flags &=~ EF_OR32_MACH;
49 }
50
51 static bfd_reloc_status_type
52 or32_elf_32_reloc (bfd *abfd,
53 arelent *reloc_entry,
54 asymbol *symbol,
55 void * data,
56 asection *input_section,
57 bfd *output_bfd,
58 char **error_message ATTRIBUTE_UNUSED)
59 {
60 if (output_bfd != NULL)
61 {
62 unsigned long insn;
63 bfd_size_type addr = reloc_entry->address;
64
65 reloc_entry->address += input_section->output_offset;
66
67 insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
68 insn += symbol->section->output_section->vma;
69 insn += symbol->section->output_offset;
70 insn += symbol->value;
71 bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
72
73 return bfd_reloc_ok;
74 }
75
76 return bfd_reloc_continue;
77 }
78
79 static bfd_reloc_status_type
80 or32_elf_16_reloc (bfd *abfd,
81 arelent *reloc_entry,
82 asymbol *symbol,
83 void * data,
84 asection *input_section,
85 bfd *output_bfd,
86 char **error_message ATTRIBUTE_UNUSED)
87 {
88 if (output_bfd != NULL)
89 {
90 unsigned short insn;
91 bfd_size_type addr = reloc_entry->address;
92
93 reloc_entry->address += input_section->output_offset;
94
95 insn = bfd_get_16 (abfd, (bfd_byte *) data + addr);
96 insn += symbol->section->output_section->vma;
97 insn += symbol->section->output_offset;
98 insn += symbol->value;
99 bfd_put_16 (abfd, insn, (bfd_byte *) data + addr);
100
101 return bfd_reloc_ok;
102 }
103
104 return bfd_reloc_continue;
105 }
106
107 static bfd_reloc_status_type
108 or32_elf_8_reloc (bfd *abfd ATTRIBUTE_UNUSED,
109 arelent *reloc_entry,
110 asymbol *symbol,
111 void * data,
112 asection *input_section,
113 bfd *output_bfd,
114 char **error_message ATTRIBUTE_UNUSED)
115 {
116 if (output_bfd != NULL)
117 {
118 unsigned char insn;
119 bfd_size_type addr = reloc_entry->address;
120
121 reloc_entry->address += input_section->output_offset;
122
123 insn = bfd_get_8 (abfd, (bfd_byte *) data + addr);
124 insn += symbol->section->output_section->vma;
125 insn += symbol->section->output_offset;
126 insn += symbol->value;
127 bfd_put_8 (abfd, insn, (bfd_byte *) data + addr);
128
129 return bfd_reloc_ok;
130 }
131
132 return bfd_reloc_continue;
133 }
134
135 /* Do a R_OR32_CONSTH relocation. This has to be done in combination
136 with a R_OR32_CONST reloc, because there is a carry from the LO16 to
137 the HI16. Here we just save the information we need; we do the
138 actual relocation when we see the LO16. OR32 ELF requires that the
139 LO16 immediately follow the HI16. As a GNU extension, we permit an
140 arbitrary number of HI16 relocs to be associated with a single LO16
141 reloc. This extension permits gcc to output the HI and LO relocs
142 itself. This code is copied from the elf32-mips.c. */
143
144 struct or32_consth
145 {
146 struct or32_consth *next;
147 bfd_byte *addr;
148 bfd_vma addend;
149 };
150
151 /* FIXME: This should not be a static variable. */
152
153 static struct or32_consth *or32_consth_list;
154
155 static bfd_reloc_status_type
156 or32_elf_consth_reloc (bfd *abfd ATTRIBUTE_UNUSED,
157 arelent *reloc_entry,
158 asymbol *symbol,
159 void * data,
160 asection *input_section,
161 bfd *output_bfd,
162 char **error_message ATTRIBUTE_UNUSED)
163 {
164 bfd_reloc_status_type ret;
165 bfd_vma relocation;
166 struct or32_consth *n;
167
168 ret = bfd_reloc_ok;
169
170 if (bfd_is_und_section (symbol->section)
171 && output_bfd == NULL)
172 ret = bfd_reloc_undefined;
173
174 if (bfd_is_com_section (symbol->section))
175 relocation = 0;
176 else
177 relocation = symbol->value;
178
179 relocation += symbol->section->output_section->vma;
180 relocation += symbol->section->output_offset;
181 relocation += reloc_entry->addend;
182
183 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
184 return bfd_reloc_outofrange;
185
186 /* Save the information, and let LO16 do the actual relocation. */
187 n = bfd_malloc (sizeof *n);
188 if (n == NULL)
189 return bfd_reloc_outofrange;
190 n->addr = (bfd_byte *) data + reloc_entry->address;
191 n->addend = relocation;
192 n->next = or32_consth_list;
193 or32_consth_list = n;
194
195 if (output_bfd != NULL)
196 reloc_entry->address += input_section->output_offset;
197
198 return ret;
199 }
200
201 /* Do a R_OR32_CONST relocation. This is a straightforward 16 bit
202 inplace relocation; this function exists in order to do the
203 R_OR32_CONSTH relocation described above. */
204
205 static bfd_reloc_status_type
206 or32_elf_const_reloc (bfd *abfd,
207 arelent *reloc_entry,
208 asymbol *symbol,
209 void * data,
210 asection *input_section,
211 bfd *output_bfd,
212 char **error_message)
213 {
214 if (or32_consth_list != NULL)
215 {
216 struct or32_consth *l;
217
218 l = or32_consth_list;
219 while (l != NULL)
220 {
221 unsigned long insn;
222 unsigned long val;
223 unsigned long vallo;
224 struct or32_consth *next;
225
226 /* Do the HI16 relocation. Note that we actually don't need
227 to know anything about the LO16 itself, except where to
228 find the low 16 bits of the addend needed by the LO16. */
229 insn = bfd_get_32 (abfd, l->addr);
230 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
231 & 0xffff);
232 val = ((insn & 0xffff) << 16) + vallo;
233 val += l->addend;
234
235 insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
236 bfd_put_32 (abfd, insn, l->addr);
237
238 next = l->next;
239 free (l);
240 l = next;
241 }
242
243 or32_consth_list = NULL;
244 }
245
246 if (output_bfd != NULL)
247 {
248 unsigned long insn, tmp;
249 bfd_size_type addr = reloc_entry->address;
250
251 reloc_entry->address += input_section->output_offset;
252
253 insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
254 tmp = insn & 0x0000ffff;
255 tmp += symbol->section->output_section->vma;
256 tmp += symbol->section->output_offset;
257 tmp += symbol->value;
258 insn = (insn & 0xffff0000) | (tmp & 0x0000ffff);
259 bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
260
261 return bfd_reloc_ok;
262 }
263
264 /* Now do the LO16 reloc in the usual way. */
265 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
266 input_section, output_bfd, error_message);
267 }
268
269 static bfd_reloc_status_type
270 or32_elf_jumptarg_reloc (bfd *abfd,
271 arelent *reloc_entry,
272 asymbol *symbol ATTRIBUTE_UNUSED,
273 void * data,
274 asection *input_section,
275 bfd *output_bfd,
276 char **error_message ATTRIBUTE_UNUSED)
277 {
278 if (output_bfd != NULL)
279 {
280 unsigned long insn, tmp;
281 bfd_size_type addr = reloc_entry->address;
282
283 reloc_entry->address += input_section->output_offset;
284
285 insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
286 tmp = insn | 0xfc000000;
287 tmp -= (input_section->output_offset >> 2);
288 insn = (insn & 0xfc000000) | (tmp & 0x03ffffff);
289 bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
290
291 return bfd_reloc_ok;
292 }
293
294 return bfd_reloc_continue;
295 }
296
297 static reloc_howto_type elf_or32_howto_table[] =
298 {
299 /* This reloc does nothing. */
300 HOWTO (R_OR32_NONE, /* type */
301 0, /* rightshift */
302 2, /* size (0 = byte, 1 = short, 2 = long) */
303 32, /* bitsize */
304 FALSE, /* pc_relative */
305 0, /* bitpos */
306 complain_overflow_bitfield, /* complain_on_overflow */
307 bfd_elf_generic_reloc, /* special_function */
308 "R_OR32_NONE", /* name */
309 FALSE, /* partial_inplace */
310 0, /* src_mask */
311 0, /* dst_mask */
312 FALSE), /* pcrel_offset */
313
314 /* A standard 32 bit relocation. */
315 HOWTO (R_OR32_32, /* type */
316 0, /* rightshift */
317 2, /* size (0 = byte, 1 = short, 2 = long) */
318 32, /* bitsize */
319 FALSE, /* pc_relative */
320 0, /* bitpos */
321 complain_overflow_bitfield, /* complain_on_overflow */
322 or32_elf_32_reloc, /* special_function */
323 "R_OR32_32", /* name */
324 FALSE, /* partial_inplace */
325 0xffffffff, /* src_mask */
326 0xffffffff, /* dst_mask */
327 FALSE), /* pcrel_offset */
328
329 /* A standard 16 bit relocation. */
330 HOWTO (R_OR32_16, /* type */
331 0, /* rightshift */
332 1, /* size (0 = byte, 1 = short, 2 = long) */
333 16, /* bitsize */
334 FALSE, /* pc_relative */
335 0, /* bitpos */
336 complain_overflow_bitfield, /* complain_on_overflow */
337 or32_elf_16_reloc, /* special_function */
338 "R_OR32_16", /* name */
339 FALSE, /* partial_inplace */
340 0x0000ffff, /* src_mask */
341 0x0000ffff, /* dst_mask */
342 FALSE), /* pcrel_offset */
343
344 /* A standard 8 bit relocation. */
345 HOWTO (R_OR32_8, /* type */
346 0, /* rightshift */
347 0, /* size (0 = byte, 1 = short, 2 = long) */
348 8, /* bitsize */
349 FALSE, /* pc_relative */
350 0, /* bitpos */
351 complain_overflow_bitfield, /* complain_on_overflow */
352 or32_elf_8_reloc, /* special_function */
353 "R_OR32_8", /* name */
354 FALSE, /* partial_inplace */
355 0x000000ff, /* src_mask */
356 0x000000ff, /* dst_mask */
357 FALSE), /* pcrel_offset */
358
359 /* A standard low 16 bit relocation. */
360 HOWTO (R_OR32_CONST, /* type */
361 0, /* rightshift */
362 2, /* size (0 = byte, 1 = short, 2 = long) */
363 16, /* bitsize */
364 FALSE, /* pc_relative */
365 0, /* bitpos */
366 complain_overflow_dont, /* complain_on_overflow */
367 or32_elf_const_reloc, /* special_function */
368 "R_OR32_CONST", /* name */
369 FALSE, /* partial_inplace */
370 0x0000ffff, /* src_mask */
371 0x0000ffff, /* dst_mask */
372 FALSE), /* pcrel_offset */
373
374 /* A standard high 16 bit relocation. */
375 HOWTO (R_OR32_CONSTH, /* type */
376 16, /* rightshift */
377 2, /* size (0 = byte, 1 = short, 2 = long) */
378 16, /* bitsize */
379 TRUE, /* pc_relative */
380 0, /* bitpos */
381 complain_overflow_dont, /* complain_on_overflow */
382 or32_elf_consth_reloc, /* special_function */
383 "R_OR32_CONSTH", /* name */
384 FALSE, /* partial_inplace */
385 0xffff0000, /* src_mask */
386 0x0000ffff, /* dst_mask */
387 FALSE), /* pcrel_offset */
388
389 /* A standard branch relocation. */
390 HOWTO (R_OR32_JUMPTARG, /* type */
391 2, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 28, /* bitsize */
394 TRUE, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_signed, /* complain_on_overflow */
397 or32_elf_jumptarg_reloc,/* special_function */
398 "R_OR32_JUMPTARG", /* name */
399 FALSE, /* partial_inplace */
400 0, /* src_mask */
401 0x03ffffff, /* dst_mask */
402 TRUE), /* pcrel_offset */
403
404 /* GNU extension to record C++ vtable hierarchy. */
405 HOWTO (R_OR32_GNU_VTINHERIT, /* type */
406 0, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 0, /* bitsize */
409 FALSE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_dont, /* complain_on_overflow */
412 NULL, /* special_function */
413 "R_OR32_GNU_VTINHERIT", /* name */
414 FALSE, /* partial_inplace */
415 0, /* src_mask */
416 0, /* dst_mask */
417 FALSE), /* pcrel_offset */
418
419 /* GNU extension to record C++ vtable member usage. */
420 HOWTO (R_OR32_GNU_VTENTRY, /* type */
421 0, /* rightshift */
422 2, /* size (0 = byte, 1 = short, 2 = long) */
423 0, /* bitsize */
424 FALSE, /* pc_relative */
425 0, /* bitpos */
426 complain_overflow_dont, /* complain_on_overflow */
427 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
428 "R_OR32_GNU_VTENTRY", /* name */
429 FALSE, /* partial_inplace */
430 0, /* src_mask */
431 0, /* dst_mask */
432 FALSE), /* pcrel_offset */
433 };
434
435 /* Map BFD reloc types to OR32 ELF reloc types. */
436
437 struct or32_reloc_map
438 {
439 bfd_reloc_code_real_type bfd_reloc_val;
440 unsigned char elf_reloc_val;
441 };
442
443 static const struct or32_reloc_map or32_reloc_map[] =
444 {
445 { BFD_RELOC_NONE, R_OR32_NONE },
446 { BFD_RELOC_32, R_OR32_32 },
447 { BFD_RELOC_16, R_OR32_16 },
448 { BFD_RELOC_8, R_OR32_8 },
449 { BFD_RELOC_LO16, R_OR32_CONST },
450 { BFD_RELOC_HI16, R_OR32_CONSTH },
451 { BFD_RELOC_32_GOT_PCREL, R_OR32_JUMPTARG },
452 { BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT },
453 { BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY },
454 };
455
456 static reloc_howto_type *
457 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
458 bfd_reloc_code_real_type code)
459 {
460 unsigned int i;
461
462 for (i = ARRAY_SIZE (or32_reloc_map); i--;)
463 if (or32_reloc_map[i].bfd_reloc_val == code)
464 return &elf_or32_howto_table[or32_reloc_map[i].elf_reloc_val];
465
466 return NULL;
467 }
468
469 /* Set the howto pointer for an OR32 ELF reloc. */
470
471 static void
472 or32_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
473 arelent *cache_ptr,
474 Elf_Internal_Rela *dst)
475 {
476 unsigned int r_type;
477
478 r_type = ELF32_R_TYPE (dst->r_info);
479 BFD_ASSERT (r_type < (unsigned int) R_OR32_max);
480 cache_ptr->howto = &elf_or32_howto_table[r_type];
481 }
482
483 #define TARGET_LITTLE_SYM bfd_elf32_or32_little_vec
484 #define TARGET_LITTLE_NAME "elf32-littleor32"
485 #define TARGET_BIG_SYM bfd_elf32_or32_big_vec
486 #define TARGET_BIG_NAME "elf32-or32"
487 #define ELF_ARCH bfd_arch_or32
488 #define ELF_MACHINE_CODE EM_OR32
489 #define ELF_MAXPAGESIZE 0x1000
490
491 #define elf_info_to_howto 0
492 #define elf_info_to_howto_rel or32_info_to_howto_rel
493 #define elf_backend_object_p or32_elf_object_p
494 #define elf_backend_final_write_processing \
495 or32_elf_final_write_processing
496
497 #include "elf32-target.h"
NetBSD on the FriendlyARM MINI2440