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