?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* ld-mips-elf/tlsbin-o32.s, ld-mips-elf/mips-dyn.ld,
[binutils.git] / bfd / elf32-dlx.c
blob44f190c179a06c8ec25f6aec18b78bc57f8a157a
1 /* DLX specific support for 32-bit ELF
2 Copyright 2002, 2003, 2004 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20 #include "bfd.h"
21 #include "sysdep.h"
22 #include "libbfd.h"
23 #include "elf-bfd.h"
24 #include "elf/dlx.h"
25
26 int set_dlx_skip_hi16_flag PARAMS ((int));
27
28 static bfd_boolean elf32_dlx_check_relocs
29 PARAMS ((bfd *, struct bfd_link_info *, asection *,
30 const Elf_Internal_Rela *));
31 static void elf32_dlx_info_to_howto
32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
33 static void elf32_dlx_info_to_howto_rel
34 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
35 static bfd_reloc_status_type elf32_dlx_relocate16
36 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
37 static bfd_reloc_status_type elf32_dlx_relocate26
38 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
39 static reloc_howto_type *elf32_dlx_reloc_type_lookup
40 PARAMS ((bfd *, bfd_reloc_code_real_type));
41 static bfd_reloc_status_type _bfd_dlx_elf_hi16_reloc
42 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
43 static reloc_howto_type * dlx_rtype_to_howto
44 PARAMS ((unsigned int));
45
46
47 #define USE_REL 1
48
49 #define bfd_elf32_bfd_reloc_type_lookup elf32_dlx_reloc_type_lookup
50 #define elf_info_to_howto elf32_dlx_info_to_howto
51 #define elf_info_to_howto_rel elf32_dlx_info_to_howto_rel
52 #define elf_backend_check_relocs elf32_dlx_check_relocs
53
54 static reloc_howto_type dlx_elf_howto_table[]=
55 {
56 /* No relocation. */
57 HOWTO (R_DLX_NONE, /* type */
58 0, /* rightshift */
59 0, /* size (0 = byte, 1 = short, 2 = long) */
60 0, /* bitsize */
61 FALSE, /* pc_relative */
62 0, /* bitpos */
63 complain_overflow_dont,/* complain_on_overflow */
64 bfd_elf_generic_reloc, /* special_function */
65 "R_DLX_NONE", /* name */
66 FALSE, /* partial_inplace */
67 0, /* src_mask */
68 0, /* dst_mask */
69 FALSE), /* pcrel_offset */
70
71 /* 8 bit relocation. */
72 HOWTO (R_DLX_RELOC_8, /* type */
73 0, /* rightshift */
74 0, /* size (0 = byte, 1 = short, 2 = long) */
75 8, /* bitsize */
76 FALSE, /* pc_relative */
77 0, /* bitpos */
78 complain_overflow_dont,/* complain_on_overflow */
79 bfd_elf_generic_reloc, /* special_function */
80 "R_DLX_RELOC_8", /* name */
81 TRUE, /* partial_inplace */
82 0xff, /* src_mask */
83 0xff, /* dst_mask */
84 FALSE), /* pcrel_offset */
85
86 /* 16 bit relocation. */
87 HOWTO (R_DLX_RELOC_16, /* type */
88 0, /* rightshift */
89 1, /* size (0 = byte, 1 = short, 2 = long) */
90 16, /* bitsize */
91 FALSE, /* pc_relative */
92 0, /* bitpos */
93 complain_overflow_dont,/* complain_on_overflow */
94 bfd_elf_generic_reloc, /* special_function */
95 "R_DLX_RELOC_16", /* name */
96 TRUE, /* partial_inplace */
97 0xffff, /* src_mask */
98 0xffff, /* dst_mask */
99 FALSE), /* pcrel_offset */
100
101 /* 32 bit relocation. */
102 HOWTO (R_DLX_RELOC_32, /* type */
103 0, /* rightshift */
104 2, /* size (0 = byte, 1 = short, 2 = long) */
105 32, /* bitsize */
106 FALSE, /* pc_relative */
107 0, /* bitpos */
108 complain_overflow_dont,/* complain_on_overflow */
109 bfd_elf_generic_reloc, /* special_function */
110 "R_DLX_RELOC_32", /* name */
111 TRUE, /* partial_inplace */
112 0xffffffff, /* src_mask */
113 0xffffffff, /* dst_mask */
114 FALSE), /* pcrel_offset */
115
116 /* GNU extension to record C++ vtable hierarchy */
117 HOWTO (R_DLX_GNU_VTINHERIT, /* type */
118 0, /* rightshift */
119 2, /* size (0 = byte, 1 = short, 2 = long) */
120 0, /* bitsize */
121 FALSE, /* pc_relative */
122 0, /* bitpos */
123 complain_overflow_dont,/* complain_on_overflow */
124 NULL, /* special_function */
125 "R_DLX_GNU_VTINHERIT", /* name */
126 FALSE, /* partial_inplace */
127 0, /* src_mask */
128 0, /* dst_mask */
129 FALSE), /* pcrel_offset */
130
131 /* GNU extension to record C++ vtable member usage */
132 HOWTO (R_DLX_GNU_VTENTRY, /* type */
133 0, /* rightshift */
134 2, /* size (0 = byte, 1 = short, 2 = long) */
135 0, /* bitsize */
136 FALSE, /* pc_relative */
137 0, /* bitpos */
138 complain_overflow_dont,/* complain_on_overflow */
139 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
140 "R_DLX_GNU_VTENTRY", /* name */
141 FALSE, /* partial_inplace */
142 0, /* src_mask */
143 0, /* dst_mask */
144 FALSE) /* pcrel_offset */
145 };
146
147 /* 16 bit offset for pc-relative branches. */
148 static reloc_howto_type elf_dlx_gnu_rel16_s2 =
149 HOWTO (R_DLX_RELOC_16_PCREL, /* type */
150 0, /* rightshift */
151 1, /* size (0 = byte, 1 = short, 2 = long) */
152 16, /* bitsize */
153 TRUE, /* pc_relative */
154 0, /* bitpos */
155 complain_overflow_signed, /* complain_on_overflow */
156 elf32_dlx_relocate16, /* special_function */
157 "R_DLX_RELOC_16_PCREL",/* name */
158 TRUE, /* partial_inplace */
159 0xffff, /* src_mask */
160 0xffff, /* dst_mask */
161 TRUE); /* pcrel_offset */
162
163 /* 26 bit offset for pc-relative branches. */
164 static reloc_howto_type elf_dlx_gnu_rel26_s2 =
165 HOWTO (R_DLX_RELOC_26_PCREL, /* type */
166 0, /* rightshift */
167 2, /* size (0 = byte, 1 = short, 2 = long) */
168 26, /* bitsize */
169 TRUE, /* pc_relative */
170 0, /* bitpos */
171 complain_overflow_dont,/* complain_on_overflow */
172 elf32_dlx_relocate26, /* special_function */
173 "R_DLX_RELOC_26_PCREL",/* name */
174 TRUE, /* partial_inplace */
175 0xffff, /* src_mask */
176 0xffff, /* dst_mask */
177 TRUE); /* pcrel_offset */
178
179 /* High 16 bits of symbol value. */
180 static reloc_howto_type elf_dlx_reloc_16_hi =
181 HOWTO (R_DLX_RELOC_16_HI, /* type */
182 16, /* rightshift */
183 2, /* size (0 = byte, 1 = short, 2 = long) */
184 32, /* bitsize */
185 FALSE, /* pc_relative */
186 0, /* bitpos */
187 complain_overflow_dont, /* complain_on_overflow */
188 _bfd_dlx_elf_hi16_reloc,/* special_function */
189 "R_DLX_RELOC_16_HI", /* name */
190 TRUE, /* partial_inplace */
191 0xFFFF, /* src_mask */
192 0xffff, /* dst_mask */
193 FALSE); /* pcrel_offset */
194
195 /* Low 16 bits of symbol value. */
196 static reloc_howto_type elf_dlx_reloc_16_lo =
197 HOWTO (R_DLX_RELOC_16_LO, /* type */
198 0, /* rightshift */
199 1, /* size (0 = byte, 1 = short, 2 = long) */
200 16, /* bitsize */
201 FALSE, /* pc_relative */
202 0, /* bitpos */
203 complain_overflow_dont,/* complain_on_overflow */
204 bfd_elf_generic_reloc, /* special_function */
205 "R_DLX_RELOC_16_LO", /* name */
206 TRUE, /* partial_inplace */
207 0xffff, /* src_mask */
208 0xffff, /* dst_mask */
209 FALSE); /* pcrel_offset */
210
211
212 /* The gas default behavior is not to preform the %hi modifier so that the
213 GNU assembler can have the lower 16 bits offset placed in the insn, BUT
214 we do like the gas to indicate it is %hi reloc type so when we in the link
215 loader phase we can have the corrected hi16 vale replace the buggous lo16
216 value that was placed there by gas. */
217
218 static int skip_dlx_elf_hi16_reloc = 0;
219
220 int
221 set_dlx_skip_hi16_flag (flag)
222 int flag;
223 {
224 skip_dlx_elf_hi16_reloc = flag;
225 return flag;
226 }
227
228 static bfd_reloc_status_type
229 _bfd_dlx_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
230 input_section, output_bfd, error_message)
231 bfd *abfd;
232 arelent *reloc_entry;
233 asymbol *symbol;
234 PTR data;
235 asection *input_section;
236 bfd *output_bfd;
237 char **error_message;
238 {
239 bfd_reloc_status_type ret;
240 bfd_vma relocation;
241
242 /* If the skip flag is set then we simply do the generic relocating, this
243 is more of a hack for dlx gas/gld, so we do not need to do the %hi/%lo
244 fixup like mips gld did. */
245 if (skip_dlx_elf_hi16_reloc)
246 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
247 input_section, output_bfd, error_message);
248
249 /* If we're relocating, and this an external symbol, we don't want
250 to change anything. */
251 if (output_bfd != (bfd *) NULL
252 && (symbol->flags & BSF_SECTION_SYM) == 0
253 && reloc_entry->addend == 0)
254 {
255 reloc_entry->address += input_section->output_offset;
256 return bfd_reloc_ok;
257 }
258
259 ret = bfd_reloc_ok;
260
261 if (bfd_is_und_section (symbol->section)
262 && output_bfd == (bfd *) NULL)
263 ret = bfd_reloc_undefined;
264
265 relocation = (bfd_is_com_section (symbol->section)) ? 0 : symbol->value;
266 relocation += symbol->section->output_section->vma;
267 relocation += symbol->section->output_offset;
268 relocation += reloc_entry->addend;
269 relocation += bfd_get_16 (abfd, (bfd_byte *)data + reloc_entry->address);
270
271 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
272 return bfd_reloc_outofrange;
273
274 bfd_put_16 (abfd, (short)((relocation >> 16) & 0xFFFF),
275 (bfd_byte *)data + reloc_entry->address);
276
277 return ret;
278 }
279
280 /* ELF relocs are against symbols. If we are producing relocatable
281 output, and the reloc is against an external symbol, and nothing
282 has given us any additional addend, the resulting reloc will also
283 be against the same symbol. In such a case, we don't want to
284 change anything about the way the reloc is handled, since it will
285 all be done at final link time. Rather than put special case code
286 into bfd_perform_relocation, all the reloc types use this howto
287 function. It just short circuits the reloc if producing
288 relocatable output against an external symbol. */
289
290 static bfd_reloc_status_type
291 elf32_dlx_relocate16 (abfd, reloc_entry, symbol, data,
292 input_section, output_bfd, error_message)
293 bfd *abfd;
294 arelent *reloc_entry;
295 asymbol *symbol;
296 PTR data;
297 asection *input_section;
298 bfd *output_bfd;
299 char **error_message ATTRIBUTE_UNUSED;
300 {
301 unsigned long insn, vallo, allignment;
302 int val;
303
304 /* HACK: I think this first condition is necessary when producing
305 relocatable output. After the end of HACK, the code is identical
306 to bfd_elf_generic_reloc(). I would _guess_ the first change
307 belongs there rather than here. martindo 1998-10-23. */
308
309 if (skip_dlx_elf_hi16_reloc)
310 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
311 input_section, output_bfd, error_message);
312
313 /* Check undefined section and undefined symbols */
314 if (bfd_is_und_section (symbol->section)
315 && output_bfd == (bfd *) NULL)
316 return bfd_reloc_undefined;
317
318 /* Can not support a long jump to sections other then .text */
319 if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
320 {
321 fprintf (stderr,
322 "BFD Link Error: branch (PC rel16) to section (%s) not supported\n",
323 symbol->section->output_section->name);
324 return bfd_reloc_undefined;
325 }
326
327 insn = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
328 allignment = 1 << (input_section->output_section->alignment_power - 1);
329 vallo = insn & 0x0000FFFF;
330
331 if (vallo & 0x8000)
332 vallo = ~(vallo | 0xFFFF0000) + 1;
333
334 /* vallo points to the vma of next instruction. */
335 vallo += (((unsigned long)(input_section->output_section->vma +
336 input_section->output_offset) +
337 allignment) & ~allignment);
338
339 /* val is the displacement (PC relative to next instruction). */
340 val = (symbol->section->output_offset +
341 symbol->section->output_section->vma +
342 symbol->value) - vallo;
343
344 if (abs ((int) val) > 0x00007FFF)
345 return bfd_reloc_outofrange;
346
347 insn = (insn & 0xFFFF0000) | (val & 0x0000FFFF);
348
349 bfd_put_32 (abfd, insn,
350 (bfd_byte *) data + reloc_entry->address);
351
352 return bfd_reloc_ok;
353 }
354
355 static bfd_reloc_status_type
356 elf32_dlx_relocate26 (abfd, reloc_entry, symbol, data,
357 input_section, output_bfd, error_message)
358 bfd *abfd;
359 arelent *reloc_entry;
360 asymbol *symbol;
361 PTR data;
362 asection *input_section;
363 bfd *output_bfd;
364 char **error_message ATTRIBUTE_UNUSED;
365 {
366 unsigned long insn, vallo, allignment;
367 int val;
368
369 /* HACK: I think this first condition is necessary when producing
370 relocatable output. After the end of HACK, the code is identical
371 to bfd_elf_generic_reloc(). I would _guess_ the first change
372 belongs there rather than here. martindo 1998-10-23. */
373
374 if (skip_dlx_elf_hi16_reloc)
375 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
376 input_section, output_bfd, error_message);
377
378 /* Check undefined section and undefined symbols. */
379 if (bfd_is_und_section (symbol->section)
380 && output_bfd == (bfd *) NULL)
381 return bfd_reloc_undefined;
382
383 /* Can not support a long jump to sections other then .text */
384 if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
385 {
386 fprintf (stderr,
387 "BFD Link Error: jump (PC rel26) to section (%s) not supported\n",
388 symbol->section->output_section->name);
389 return bfd_reloc_undefined;
390 }
391
392 insn = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
393 allignment = 1 << (input_section->output_section->alignment_power - 1);
394 vallo = insn & 0x03FFFFFF;
395
396 if (vallo & 0x03000000)
397 vallo = ~(vallo | 0xFC000000) + 1;
398
399 /* vallo is the vma for the next instruction. */
400 vallo += (((unsigned long) (input_section->output_section->vma +
401 input_section->output_offset) +
402 allignment) & ~allignment);
403
404 /* val is the displacement (PC relative to next instruction). */
405 val = (symbol->section->output_offset +
406 symbol->section->output_section->vma + symbol->value)
407 - vallo;
408
409 if (abs ((int) val) > 0x01FFFFFF)
410 return bfd_reloc_outofrange;
411
412 insn = (insn & 0xFC000000) | (val & 0x03FFFFFF);
413 bfd_put_32 (abfd, insn,
414 (bfd_byte *) data + reloc_entry->address);
415
416 return bfd_reloc_ok;
417 }
418
419 /* A mapping from BFD reloc types to DLX ELF reloc types.
420 Stolen from elf32-mips.c.
421
422 More about this table - for dlx elf relocation we do not really
423 need this table, if we have a rtype defined in this table will
424 caused tc_gen_relocate confused and die on us, but if we remove
425 this table it will caused more problem, so for now simple solution
426 is to remove those entries which may cause problem. */
427 struct elf_reloc_map
428 {
429 bfd_reloc_code_real_type bfd_reloc_val;
430 enum elf_dlx_reloc_type elf_reloc_val;
431 };
432
433 static const struct elf_reloc_map dlx_reloc_map[] =
434 {
435 { BFD_RELOC_NONE, R_DLX_NONE },
436 { BFD_RELOC_16, R_DLX_RELOC_16 },
437 { BFD_RELOC_32, R_DLX_RELOC_32 },
438 { BFD_RELOC_DLX_HI16_S, R_DLX_RELOC_16_HI },
439 { BFD_RELOC_DLX_LO16, R_DLX_RELOC_16_LO },
440 { BFD_RELOC_VTABLE_INHERIT, R_DLX_GNU_VTINHERIT },
441 { BFD_RELOC_VTABLE_ENTRY, R_DLX_GNU_VTENTRY }
442 };
443
444
445 /* Look through the relocs for a section during the first phase.
446 Since we don't do .gots or .plts, we just need to consider the
447 virtual table relocs for gc. */
448
449 static bfd_boolean
450 elf32_dlx_check_relocs (abfd, info, sec, relocs)
451 bfd *abfd;
452 struct bfd_link_info *info;
453 asection *sec;
454 const Elf_Internal_Rela *relocs;
455 {
456 Elf_Internal_Shdr *symtab_hdr;
457 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
458 const Elf_Internal_Rela *rel;
459 const Elf_Internal_Rela *rel_end;
460
461 if (info->relocatable)
462 return TRUE;
463
464 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
465 sym_hashes = elf_sym_hashes (abfd);
466 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
467 if (!elf_bad_symtab (abfd))
468 sym_hashes_end -= symtab_hdr->sh_info;
469
470 rel_end = relocs + sec->reloc_count;
471 for (rel = relocs; rel < rel_end; rel++)
472 {
473 struct elf_link_hash_entry *h;
474 unsigned long r_symndx;
475
476 r_symndx = ELF32_R_SYM (rel->r_info);
477 if (r_symndx < symtab_hdr->sh_info)
478 h = NULL;
479 else
480 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
481
482 switch (ELF32_R_TYPE (rel->r_info))
483 {
484 /* This relocation describes the C++ object vtable hierarchy.
485 Reconstruct it for later use during GC. */
486 case R_DLX_GNU_VTINHERIT:
487 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
488 return FALSE;
489 break;
490
491 /* This relocation describes which C++ vtable entries are actually
492 used. Record for later use during GC. */
493 case R_DLX_GNU_VTENTRY:
494 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
495 return FALSE;
496 break;
497 }
498 }
499
500 return TRUE;
501 }
502
503 /* Given a BFD reloc type, return a howto structure. */
504
505 static reloc_howto_type *
506 elf32_dlx_reloc_type_lookup (abfd, code)
507 bfd *abfd ATTRIBUTE_UNUSED;
508 bfd_reloc_code_real_type code;
509 {
510 unsigned int i;
511
512 for (i = 0; i < sizeof (dlx_reloc_map) / sizeof (struct elf_reloc_map); i++)
513 if (dlx_reloc_map[i].bfd_reloc_val == code)
514 return &dlx_elf_howto_table[(int) dlx_reloc_map[i].elf_reloc_val];
515
516 switch (code)
517 {
518 default:
519 bfd_set_error (bfd_error_bad_value);
520 return NULL;
521 case BFD_RELOC_16_PCREL_S2:
522 return &elf_dlx_gnu_rel16_s2;
523 case BFD_RELOC_DLX_JMP26:
524 return &elf_dlx_gnu_rel26_s2;
525 case BFD_RELOC_HI16_S:
526 return &elf_dlx_reloc_16_hi;
527 case BFD_RELOC_LO16:
528 return &elf_dlx_reloc_16_lo;
529 }
530 }
531
532 static reloc_howto_type *
533 dlx_rtype_to_howto (r_type)
534 unsigned int r_type;
535 {
536 switch (r_type)
537 {
538 case R_DLX_RELOC_16_PCREL:
539 return & elf_dlx_gnu_rel16_s2;
540 break;
541 case R_DLX_RELOC_26_PCREL:
542 return & elf_dlx_gnu_rel26_s2;
543 break;
544 case R_DLX_RELOC_16_HI:
545 return & elf_dlx_reloc_16_hi;
546 break;
547 case R_DLX_RELOC_16_LO:
548 return & elf_dlx_reloc_16_lo;
549 break;
550
551 default:
552 BFD_ASSERT (r_type < (unsigned int) R_DLX_max);
553 return & dlx_elf_howto_table[r_type];
554 break;
555 }
556 }
557
558 static void
559 elf32_dlx_info_to_howto (abfd, cache_ptr, dst)
560 bfd * abfd ATTRIBUTE_UNUSED;
561 arelent * cache_ptr ATTRIBUTE_UNUSED;
562 Elf_Internal_Rela * dst ATTRIBUTE_UNUSED;
563 {
564 abort ();
565 }
566
567 static void
568 elf32_dlx_info_to_howto_rel (abfd, cache_ptr, dst)
569 bfd *abfd ATTRIBUTE_UNUSED;
570 arelent *cache_ptr;
571 Elf_Internal_Rela *dst;
572 {
573 unsigned int r_type;
574
575 r_type = ELF32_R_TYPE (dst->r_info);
576 cache_ptr->howto = dlx_rtype_to_howto (r_type);
577 return;
578 }
579
580 #define TARGET_BIG_SYM bfd_elf32_dlx_big_vec
581 #define TARGET_BIG_NAME "elf32-dlx"
582 #define ELF_ARCH bfd_arch_dlx
583 #define ELF_MACHINE_CODE EM_DLX
584 #define ELF_MAXPAGESIZE 1 /* FIXME: This number is wrong, It should be the page size in bytes. */
585
586 #include "elf32-target.h"
git-cvsimport of binutils cvsroot