?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* elf32-xtensa.c (analyze_relocations): Zero src_count if not relaxing.
[binutils.git] / bfd / elf32-mep.c
blob4036d1e8d1677e4e8e421755c2909e3c357da0e0
1 /* MeP-specific support for 32-bit ELF.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
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/mep.h"
26 #include "libiberty.h"
27
28 /* Forward declarations. */
29
30 /* Private relocation functions. */
31 \f
32 #define MEPREL(type, size, bits, right, left, pcrel, overflow, mask) \
33 {(unsigned)type, right, size, bits, pcrel, left, overflow, mep_reloc, #type, FALSE, 0, mask, 0 }
34
35 #define N complain_overflow_dont
36 #define S complain_overflow_signed
37 #define U complain_overflow_unsigned
38
39 static bfd_reloc_status_type mep_reloc (bfd *, arelent *, struct bfd_symbol *,
40 void *, asection *, bfd *, char **);
41
42 static reloc_howto_type mep_elf_howto_table [] =
43 {
44 /* type, size, bits, leftshift, rightshift, pcrel, OD/OS/OU, mask. */
45 MEPREL (R_MEP_NONE, 0, 0, 0, 0, 0, N, 0),
46 MEPREL (R_RELC, 0, 0, 0, 0, 0, N, 0),
47 /* MEPRELOC:HOWTO */
48 /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h. */
49 MEPREL (R_MEP_8, 0, 8, 0, 0, 0, U, 0xff),
50 MEPREL (R_MEP_16, 1, 16, 0, 0, 0, U, 0xffff),
51 MEPREL (R_MEP_32, 2, 32, 0, 0, 0, U, 0xffffffff),
52 MEPREL (R_MEP_PCREL8A2, 1, 8, 1, 1, 1, S, 0x00fe),
53 MEPREL (R_MEP_PCREL12A2,1, 12, 1, 1, 1, S, 0x0ffe),
54 MEPREL (R_MEP_PCREL17A2,2, 17, 0, 1, 1, S, 0x0000ffff),
55 MEPREL (R_MEP_PCREL24A2,2, 24, 0, 1, 1, S, 0x07f0ffff),
56 MEPREL (R_MEP_PCABS24A2,2, 24, 0, 1, 0, U, 0x07f0ffff),
57 MEPREL (R_MEP_LOW16, 2, 16, 0, 0, 0, N, 0x0000ffff),
58 MEPREL (R_MEP_HI16U, 2, 32, 0,16, 0, N, 0x0000ffff),
59 MEPREL (R_MEP_HI16S, 2, 32, 0,16, 0, N, 0x0000ffff),
60 MEPREL (R_MEP_GPREL, 2, 16, 0, 0, 0, S, 0x0000ffff),
61 MEPREL (R_MEP_TPREL, 2, 16, 0, 0, 0, S, 0x0000ffff),
62 MEPREL (R_MEP_TPREL7, 1, 7, 0, 0, 0, U, 0x007f),
63 MEPREL (R_MEP_TPREL7A2, 1, 7, 1, 1, 0, U, 0x007e),
64 MEPREL (R_MEP_TPREL7A4, 1, 7, 2, 2, 0, U, 0x007c),
65 MEPREL (R_MEP_UIMM24, 2, 24, 0, 0, 0, U, 0x00ffffff),
66 MEPREL (R_MEP_ADDR24A4, 2, 24, 0, 2, 0, U, 0x00fcffff),
67 MEPREL (R_MEP_GNU_VTINHERIT,1, 0,16,32, 0, N, 0x0000),
68 MEPREL (R_MEP_GNU_VTENTRY,1, 0,16,32, 0, N, 0x0000),
69 /* MEPRELOC:END */
70 };
71
72 #define VALID_MEP_RELOC(N) ((N) >= 0 \
73 && (N) < ARRAY_SIZE (mep_elf_howto_table)
74
75 #undef N
76 #undef S
77 #undef U
78
79 static bfd_reloc_status_type
80 mep_reloc
81 (bfd * abfd ATTRIBUTE_UNUSED,
82 arelent * reloc_entry ATTRIBUTE_UNUSED,
83 struct bfd_symbol * symbol ATTRIBUTE_UNUSED,
84 void * data ATTRIBUTE_UNUSED,
85 asection * input_section ATTRIBUTE_UNUSED,
86 bfd * output_bfd ATTRIBUTE_UNUSED,
87 char ** error_message ATTRIBUTE_UNUSED)
88 {
89 return bfd_reloc_ok;
90 }
91
92 \f
93
94 #define BFD_RELOC_MEP_NONE BFD_RELOC_NONE
95 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
96 #define MAP(n) case BFD_RELOC_MEP_##n: type = R_MEP_##n; break
97 #else
98 #define MAP(n) case BFD_RELOC_MEP_/**/n: type = R_MEP_/**/n; break
99 #endif
100
101 static reloc_howto_type *
102 mep_reloc_type_lookup
103 (bfd * abfd ATTRIBUTE_UNUSED,
104 bfd_reloc_code_real_type code)
105 {
106 unsigned int type = 0;
107
108 switch (code)
109 {
110 MAP(NONE);
111 case BFD_RELOC_8:
112 type = R_MEP_8;
113 break;
114 case BFD_RELOC_16:
115 type = R_MEP_16;
116 break;
117 case BFD_RELOC_32:
118 type = R_MEP_32;
119 break;
120 case BFD_RELOC_VTABLE_ENTRY:
121 type = R_MEP_GNU_VTENTRY;
122 break;
123 case BFD_RELOC_VTABLE_INHERIT:
124 type = R_MEP_GNU_VTINHERIT;
125 break;
126 case BFD_RELOC_RELC:
127 type = R_RELC;
128 break;
129
130 /* MEPRELOC:MAP */
131 /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h. */
132 MAP(8);
133 MAP(16);
134 MAP(32);
135 MAP(PCREL8A2);
136 MAP(PCREL12A2);
137 MAP(PCREL17A2);
138 MAP(PCREL24A2);
139 MAP(PCABS24A2);
140 MAP(LOW16);
141 MAP(HI16U);
142 MAP(HI16S);
143 MAP(GPREL);
144 MAP(TPREL);
145 MAP(TPREL7);
146 MAP(TPREL7A2);
147 MAP(TPREL7A4);
148 MAP(UIMM24);
149 MAP(ADDR24A4);
150 MAP(GNU_VTINHERIT);
151 MAP(GNU_VTENTRY);
152 /* MEPRELOC:END */
153
154 default:
155 /* Pacify gcc -Wall. */
156 fprintf (stderr, "mep: no reloc for code %d\n", code);
157 return NULL;
158 }
159
160 if (mep_elf_howto_table[type].type != type)
161 {
162 fprintf (stderr, "MeP: howto %d has type %d\n", type, mep_elf_howto_table[type].type);
163 abort ();
164 }
165
166 return mep_elf_howto_table + type;
167 }
168
169 #undef MAP
170
171 \f
172 /* Perform a single relocation. */
173
174 static struct bfd_link_info *mep_info;
175 static int warn_tp = 0, warn_sda = 0;
176
177 static bfd_vma
178 mep_lookup_global
179 (char * name,
180 bfd_vma ofs,
181 bfd_vma * cache,
182 int * warn)
183 {
184 struct bfd_link_hash_entry *h;
185
186 if (*cache || *warn)
187 return *cache;
188
189 h = bfd_link_hash_lookup (mep_info->hash, name, FALSE, FALSE, TRUE);
190 if (h == 0 || h->type != bfd_link_hash_defined)
191 {
192 *warn = ofs + 1;
193 return 0;
194 }
195 *cache = (h->u.def.value
196 + h->u.def.section->output_section->vma
197 + h->u.def.section->output_offset);
198 return *cache;
199 }
200
201 static bfd_vma
202 mep_tpoff_base (bfd_vma ofs)
203 {
204 static bfd_vma cache = 0;
205 return mep_lookup_global ("__tpbase", ofs, &cache, &warn_tp);
206 }
207
208 static bfd_vma
209 mep_sdaoff_base (bfd_vma ofs)
210 {
211 static bfd_vma cache = 0;
212 return mep_lookup_global ("__sdabase", ofs, &cache, &warn_sda);
213 }
214
215 static bfd_reloc_status_type
216 mep_final_link_relocate
217 (reloc_howto_type * howto,
218 bfd * input_bfd,
219 asection * input_section,
220 bfd_byte * contents,
221 Elf_Internal_Rela * rel,
222 bfd_vma relocation)
223 {
224 unsigned long u;
225 long s;
226 unsigned char *byte;
227 bfd_vma pc;
228 bfd_reloc_status_type r = bfd_reloc_ok;
229 int e2, e4;
230
231 if (bfd_big_endian (input_bfd))
232 {
233 e2 = 0;
234 e4 = 0;
235 }
236 else
237 {
238 e2 = 1;
239 e4 = 3;
240 }
241
242 pc = (input_section->output_section->vma
243 + input_section->output_offset
244 + rel->r_offset);
245
246 s = relocation + rel->r_addend;
247
248 byte = (unsigned char *)contents + rel->r_offset;
249
250 if (howto->type == R_MEP_PCREL24A2
251 && s == 0
252 && pc >= 0x800000)
253 {
254 /* This is an unreachable branch to an undefined weak function.
255 Silently ignore it, since the opcode can't do that but should
256 never be executed anyway. */
257 return bfd_reloc_ok;
258 }
259
260 if (howto->pc_relative)
261 s -= pc;
262
263 u = (unsigned long) s;
264
265 switch (howto->type)
266 {
267 /* MEPRELOC:APPLY */
268 /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h. */
269 case R_MEP_8: /* 76543210 */
270 if (u > 255) r = bfd_reloc_overflow;
271 byte[0] = (u & 0xff);
272 break;
273 case R_MEP_16: /* fedcba9876543210 */
274 if (u > 65535) r = bfd_reloc_overflow;
275 byte[0^e2] = ((u >> 8) & 0xff);
276 byte[1^e2] = (u & 0xff);
277 break;
278 case R_MEP_32: /* vutsrqponmlkjihgfedcba9876543210 */
279 byte[0^e4] = ((u >> 24) & 0xff);
280 byte[1^e4] = ((u >> 16) & 0xff);
281 byte[2^e4] = ((u >> 8) & 0xff);
282 byte[3^e4] = (u & 0xff);
283 break;
284 case R_MEP_PCREL8A2: /* --------7654321- */
285 if (-128 > s || s > 127) r = bfd_reloc_overflow;
286 byte[1^e2] = (byte[1^e2] & 0x01) | (s & 0xfe);
287 break;
288 case R_MEP_PCREL12A2: /* ----ba987654321- */
289 if (-2048 > s || s > 2047) r = bfd_reloc_overflow;
290 byte[0^e2] = (byte[0^e2] & 0xf0) | ((s >> 8) & 0x0f);
291 byte[1^e2] = (byte[1^e2] & 0x01) | (s & 0xfe);
292 break;
293 case R_MEP_PCREL17A2: /* ----------------gfedcba987654321 */
294 if (-65536 > s || s > 65535) r = bfd_reloc_overflow;
295 byte[2^e2] = ((s >> 9) & 0xff);
296 byte[3^e2] = ((s >> 1) & 0xff);
297 break;
298 case R_MEP_PCREL24A2: /* -----7654321----nmlkjihgfedcba98 */
299 if (-8388608 > s || s > 8388607) r = bfd_reloc_overflow;
300 byte[0^e2] = (byte[0^e2] & 0xf8) | ((s >> 5) & 0x07);
301 byte[1^e2] = (byte[1^e2] & 0x0f) | ((s << 3) & 0xf0);
302 byte[2^e2] = ((s >> 16) & 0xff);
303 byte[3^e2] = ((s >> 8) & 0xff);
304 break;
305 case R_MEP_PCABS24A2: /* -----7654321----nmlkjihgfedcba98 */
306 if (u > 16777215) r = bfd_reloc_overflow;
307 byte[0^e2] = (byte[0^e2] & 0xf8) | ((u >> 5) & 0x07);
308 byte[1^e2] = (byte[1^e2] & 0x0f) | ((u << 3) & 0xf0);
309 byte[2^e2] = ((u >> 16) & 0xff);
310 byte[3^e2] = ((u >> 8) & 0xff);
311 break;
312 case R_MEP_LOW16: /* ----------------fedcba9876543210 */
313 byte[2^e2] = ((u >> 8) & 0xff);
314 byte[3^e2] = (u & 0xff);
315 break;
316 case R_MEP_HI16U: /* ----------------vutsrqponmlkjihg */
317 byte[2^e2] = ((u >> 24) & 0xff);
318 byte[3^e2] = ((u >> 16) & 0xff);
319 break;
320 case R_MEP_HI16S: /* ----------------vutsrqponmlkjihg */
321 byte[2^e2] = ((s >> 24) & 0xff);
322 byte[3^e2] = ((s >> 16) & 0xff);
323 break;
324 case R_MEP_GPREL: /* ----------------fedcba9876543210 */
325 s -= mep_sdaoff_base(rel->r_offset);
326 if (-32768 > s || s > 32767) r = bfd_reloc_overflow;
327 byte[2^e2] = ((s >> 8) & 0xff);
328 byte[3^e2] = (s & 0xff);
329 break;
330 case R_MEP_TPREL: /* ----------------fedcba9876543210 */
331 s -= mep_tpoff_base(rel->r_offset);
332 if (-32768 > s || s > 32767) r = bfd_reloc_overflow;
333 byte[2^e2] = ((s >> 8) & 0xff);
334 byte[3^e2] = (s & 0xff);
335 break;
336 case R_MEP_TPREL7: /* ---------6543210 */
337 u -= mep_tpoff_base(rel->r_offset);
338 if (u > 127) r = bfd_reloc_overflow;
339 byte[1^e2] = (byte[1^e2] & 0x80) | (u & 0x7f);
340 break;
341 case R_MEP_TPREL7A2: /* ---------654321- */
342 u -= mep_tpoff_base(rel->r_offset);
343 if (u > 127) r = bfd_reloc_overflow;
344 byte[1^e2] = (byte[1^e2] & 0x81) | (u & 0x7e);
345 break;
346 case R_MEP_TPREL7A4: /* ---------65432-- */
347 u -= mep_tpoff_base(rel->r_offset);
348 if (u > 127) r = bfd_reloc_overflow;
349 byte[1^e2] = (byte[1^e2] & 0x83) | (u & 0x7c);
350 break;
351 case R_MEP_UIMM24: /* --------76543210nmlkjihgfedcba98 */
352 if (u > 16777215) r = bfd_reloc_overflow;
353 byte[1^e2] = (u & 0xff);
354 byte[2^e2] = ((u >> 16) & 0xff);
355 byte[3^e2] = ((u >> 8) & 0xff);
356 break;
357 case R_MEP_ADDR24A4: /* --------765432--nmlkjihgfedcba98 */
358 if (u > 16777215) r = bfd_reloc_overflow;
359 byte[1^e2] = (byte[1^e2] & 0x03) | (u & 0xfc);
360 byte[2^e2] = ((u >> 16) & 0xff);
361 byte[3^e2] = ((u >> 8) & 0xff);
362 break;
363 case R_MEP_GNU_VTINHERIT: /* ---------------- */
364 break;
365 case R_MEP_GNU_VTENTRY: /* ---------------- */
366 break;
367 /* MEPRELOC:END */
368 default:
369 abort ();
370 }
371
372 return r;
373 }
374 \f
375 /* Set the howto pointer for a MEP ELF reloc. */
376
377 static void
378 mep_info_to_howto_rela
379 (bfd * abfd ATTRIBUTE_UNUSED,
380 arelent * cache_ptr,
381 Elf_Internal_Rela * dst)
382 {
383 unsigned int r_type;
384
385 r_type = ELF32_R_TYPE (dst->r_info);
386 cache_ptr->howto = & mep_elf_howto_table [r_type];
387 }
388
389 /* Look through the relocs for a section during the first phase.
390 Since we don't do .gots or .plts, we just need to consider the
391 virtual table relocs for gc. */
392
393 static bfd_boolean
394 mep_elf_check_relocs
395 (bfd * abfd,
396 struct bfd_link_info * info,
397 asection * sec,
398 const Elf_Internal_Rela * relocs)
399 {
400 Elf_Internal_Shdr * symtab_hdr;
401 struct elf_link_hash_entry ** sym_hashes;
402 struct elf_link_hash_entry ** sym_hashes_end;
403 const Elf_Internal_Rela * rel;
404 const Elf_Internal_Rela * rel_end;
405
406 if (info->relocatable)
407 return TRUE;
408
409 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
410 sym_hashes = elf_sym_hashes (abfd);
411 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
412 if (!elf_bad_symtab (abfd))
413 sym_hashes_end -= symtab_hdr->sh_info;
414
415 rel_end = relocs + sec->reloc_count;
416 for (rel = relocs; rel < rel_end; rel++)
417 {
418 struct elf_link_hash_entry *h;
419 unsigned long r_symndx;
420
421 r_symndx = ELF32_R_SYM (rel->r_info);
422 if (r_symndx < symtab_hdr->sh_info)
423 h = NULL;
424 else
425 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
426 }
427 return TRUE;
428 }
429
430 \f
431 /* Relocate a MEP ELF section.
432 There is some attempt to make this function usable for many architectures,
433 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
434 if only to serve as a learning tool.
435
436 The RELOCATE_SECTION function is called by the new ELF backend linker
437 to handle the relocations for a section.
438
439 The relocs are always passed as Rela structures; if the section
440 actually uses Rel structures, the r_addend field will always be
441 zero.
442
443 This function is responsible for adjusting the section contents as
444 necessary, and (if using Rela relocs and generating a relocatable
445 output file) adjusting the reloc addend as necessary.
446
447 This function does not have to worry about setting the reloc
448 address or the reloc symbol index.
449
450 LOCAL_SYMS is a pointer to the swapped in local symbols.
451
452 LOCAL_SECTIONS is an array giving the section in the input file
453 corresponding to the st_shndx field of each local symbol.
454
455 The global hash table entry for the global symbols can be found
456 via elf_sym_hashes (input_bfd).
457
458 When generating relocatable output, this function must handle
459 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
460 going to be the section symbol corresponding to the output
461 section, which means that the addend must be adjusted
462 accordingly. */
463
464 static bfd_boolean
465 mep_elf_relocate_section
466 (bfd * output_bfd ATTRIBUTE_UNUSED,
467 struct bfd_link_info * info,
468 bfd * input_bfd,
469 asection * input_section,
470 bfd_byte * contents,
471 Elf_Internal_Rela * relocs,
472 Elf_Internal_Sym * local_syms,
473 asection ** local_sections)
474 {
475 Elf_Internal_Shdr * symtab_hdr;
476 struct elf_link_hash_entry ** sym_hashes;
477 Elf_Internal_Rela * rel;
478 Elf_Internal_Rela * relend;
479
480 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
481 sym_hashes = elf_sym_hashes (input_bfd);
482 relend = relocs + input_section->reloc_count;
483
484 mep_info = info;
485
486 for (rel = relocs; rel < relend; rel ++)
487 {
488 reloc_howto_type * howto;
489 unsigned long r_symndx;
490 Elf_Internal_Sym * sym;
491 asection * sec;
492 struct elf_link_hash_entry * h;
493 bfd_vma relocation;
494 bfd_reloc_status_type r;
495 const char * name = NULL;
496 int r_type;
497
498 r_type = ELF32_R_TYPE (rel->r_info);
499
500 r_symndx = ELF32_R_SYM (rel->r_info);
501
502 if (info->relocatable)
503 {
504 /* This is a relocatable link. We don't have to change
505 anything, unless the reloc is against a section symbol,
506 in which case we have to adjust according to where the
507 section symbol winds up in the output section. */
508 if (r_symndx < symtab_hdr->sh_info)
509 {
510 sym = local_syms + r_symndx;
511
512 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
513 {
514 sec = local_sections [r_symndx];
515 rel->r_addend += sec->output_offset + sym->st_value;
516 }
517 }
518
519 continue;
520 }
521
522 /* Is this a complex relocation? */
523 if (ELF32_R_TYPE (rel->r_info) == R_RELC)
524 {
525 bfd_elf_perform_complex_relocation (output_bfd, info,
526 input_bfd, input_section, contents,
527 rel, local_syms, local_sections);
528 continue;
529 }
530
531 /* This is a final link. */
532 howto = mep_elf_howto_table + ELF32_R_TYPE (rel->r_info);
533 h = NULL;
534 sym = NULL;
535 sec = NULL;
536
537 if (r_symndx < symtab_hdr->sh_info)
538 {
539 sym = local_syms + r_symndx;
540 sec = local_sections [r_symndx];
541 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
542
543 name = bfd_elf_string_from_elf_section
544 (input_bfd, symtab_hdr->sh_link, sym->st_name);
545 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
546 #if 0
547 fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
548 sec->name, name, sym->st_name,
549 sec->output_section->vma, sec->output_offset,
550 sym->st_value, rel->r_addend);
551 #endif
552 }
553 else
554 {
555 h = sym_hashes [r_symndx];
556
557 while (h->root.type == bfd_link_hash_indirect
558 || h->root.type == bfd_link_hash_warning)
559 h = (struct elf_link_hash_entry *) h->root.u.i.link;
560
561 name = h->root.root.string;
562
563 if (h->root.type == bfd_link_hash_defined
564 || h->root.type == bfd_link_hash_defweak)
565 {
566 sec = h->root.u.def.section;
567 relocation = (h->root.u.def.value
568 + sec->output_section->vma
569 + sec->output_offset);
570 #if 0
571 fprintf (stderr,
572 "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
573 sec->name, name, h->root.u.def.value,
574 sec->output_section->vma, sec->output_offset, relocation);
575 #endif
576 }
577 else if (h->root.type == bfd_link_hash_undefweak)
578 {
579 #if 0
580 fprintf (stderr, "undefined: sec: %s, name: %s\n",
581 sec->name, name);
582 #endif
583 relocation = 0;
584 }
585 else
586 {
587 if (! ((*info->callbacks->undefined_symbol)
588 (info, h->root.root.string, input_bfd,
589 input_section, rel->r_offset,
590 (!info->shared && info->unresolved_syms_in_objects == RM_GENERATE_ERROR))))
591 return FALSE;
592 #if 0
593 fprintf (stderr, "unknown: name: %s\n", name);
594 #endif
595 relocation = 0;
596 }
597 }
598
599 switch (r_type)
600 {
601 default:
602 r = mep_final_link_relocate (howto, input_bfd, input_section,
603 contents, rel, relocation);
604 break;
605 }
606
607 if (r != bfd_reloc_ok)
608 {
609 const char * msg = (const char *) NULL;
610
611 switch (r)
612 {
613 case bfd_reloc_overflow:
614 r = info->callbacks->reloc_overflow
615 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
616 input_bfd, input_section, rel->r_offset);
617 break;
618
619 case bfd_reloc_undefined:
620 r = info->callbacks->undefined_symbol
621 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
622 break;
623
624 case bfd_reloc_outofrange:
625 msg = _("internal error: out of range error");
626 break;
627
628 case bfd_reloc_notsupported:
629 msg = _("internal error: unsupported relocation error");
630 break;
631
632 case bfd_reloc_dangerous:
633 msg = _("internal error: dangerous relocation");
634 break;
635
636 default:
637 msg = _("internal error: unknown error");
638 break;
639 }
640
641 if (msg)
642 r = info->callbacks->warning
643 (info, msg, name, input_bfd, input_section, rel->r_offset);
644
645 if (! r)
646 return FALSE;
647 }
648 }
649
650 if (warn_tp)
651 info->callbacks->undefined_symbol
652 (info, "__tpbase", input_bfd, input_section, warn_tp-1, TRUE);
653 if (warn_sda)
654 info->callbacks->undefined_symbol
655 (info, "__sdabase", input_bfd, input_section, warn_sda-1, TRUE);
656 if (warn_sda || warn_tp)
657 return FALSE;
658
659 return TRUE;
660 }
661 \f
662
663 /* Update the got entry reference counts for the section being
664 removed. */
665
666 static bfd_boolean
667 mep_elf_gc_sweep_hook
668 (bfd * abfd ATTRIBUTE_UNUSED,
669 struct bfd_link_info * info ATTRIBUTE_UNUSED,
670 asection * sec ATTRIBUTE_UNUSED,
671 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
672 {
673 return TRUE;
674 }
675
676 /* Return the section that should be marked against GC for a given
677 relocation. */
678
679 static asection *
680 mep_elf_gc_mark_hook
681 (asection * sec,
682 struct bfd_link_info * info ATTRIBUTE_UNUSED,
683 Elf_Internal_Rela * rel,
684 struct elf_link_hash_entry * h,
685 Elf_Internal_Sym * sym)
686 {
687 if (h != NULL)
688 {
689 switch (ELF32_R_TYPE (rel->r_info))
690 {
691 default:
692 switch (h->root.type)
693 {
694 case bfd_link_hash_defined:
695 case bfd_link_hash_defweak:
696 return h->root.u.def.section;
697
698 case bfd_link_hash_common:
699 return h->root.u.c.p->section;
700
701 default:
702 break;
703 }
704 }
705 }
706 else
707 {
708 if (!(elf_bad_symtab (sec->owner)
709 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
710 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
711 && sym->st_shndx != SHN_COMMON))
712 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
713 }
714
715 return NULL;
716 }
717
718 \f
719 /* Function to set the ELF flag bits. */
720
721 static bfd_boolean
722 mep_elf_set_private_flags (bfd * abfd,
723 flagword flags)
724 {
725 elf_elfheader (abfd)->e_flags = flags;
726 elf_flags_init (abfd) = TRUE;
727 return TRUE;
728 }
729
730 static bfd_boolean
731 mep_elf_copy_private_bfd_data (bfd * ibfd, bfd * obfd)
732 {
733 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
734 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
735 return TRUE;
736
737 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
738 elf_flags_init (obfd) = TRUE;
739 return TRUE;
740 }
741
742 /* Merge backend specific data from an object file to the output
743 object file when linking. */
744
745 static bfd_boolean
746 mep_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
747 {
748 static bfd *last_ibfd = 0;
749 flagword old_flags, new_flags;
750 flagword old_partial, new_partial;
751
752 /* Check if we have the same endianess. */
753 if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
754 return FALSE;
755
756 new_flags = elf_elfheader (ibfd)->e_flags;
757 old_flags = elf_elfheader (obfd)->e_flags;
758
759 #ifdef DEBUG
760 _bfd_error_handler ("%B: old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s",
761 ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
762 #endif
763
764 /* First call, no flags set. */
765 if (!elf_flags_init (obfd))
766 {
767 elf_flags_init (obfd) = TRUE;
768 old_flags = new_flags;
769 }
770 else if ((new_flags | old_flags) & EF_MEP_LIBRARY)
771 {
772 /* Non-library flags trump library flags. The choice doesn't really
773 matter if both OLD_FLAGS and NEW_FLAGS have EF_MEP_LIBRARY set. */
774 if (old_flags & EF_MEP_LIBRARY)
775 old_flags = new_flags;
776 }
777 else
778 {
779 /* Make sure they're for the same mach. Allow upgrade from the "mep"
780 mach. */
781 new_partial = (new_flags & EF_MEP_CPU_MASK);
782 old_partial = (old_flags & EF_MEP_CPU_MASK);
783 if (new_partial == old_partial)
784 ;
785 else if (new_partial == EF_MEP_CPU_MEP)
786 ;
787 else if (old_partial == EF_MEP_CPU_MEP)
788 old_flags = (old_flags & ~EF_MEP_CPU_MASK) | new_partial;
789 else
790 {
791 _bfd_error_handler (_("%B and %B are for different cores"), last_ibfd, ibfd);
792 bfd_set_error (bfd_error_invalid_target);
793 return FALSE;
794 }
795
796 /* Make sure they're for the same me_module. Allow basic config to
797 mix with any other. */
798 new_partial = (new_flags & EF_MEP_INDEX_MASK);
799 old_partial = (old_flags & EF_MEP_INDEX_MASK);
800 if (new_partial == old_partial)
801 ;
802 else if (new_partial == 0)
803 ;
804 else if (old_partial == 0)
805 old_flags = (old_flags & ~EF_MEP_INDEX_MASK) | new_partial;
806 else
807 {
808 _bfd_error_handler (_("%B and %B are for different configurations"), last_ibfd, ibfd);
809 bfd_set_error (bfd_error_invalid_target);
810 return FALSE;
811 }
812 }
813
814 elf_elfheader (obfd)->e_flags = old_flags;
815 last_ibfd = ibfd;
816 return TRUE;
817 }
818
819 /* This will be edited by the MeP configration tool. */
820 static const char * config_names[] =
821 {
822 "basic"
823 /* start-mepcfgtool */
824 ,"simple"
825 ,"fmax"
826 /* end-mepcfgtool */
827 };
828
829 static const char * core_names[] =
830 {
831 "MeP", "MeP-c2", "MeP-c3", "MeP-h1"
832 };
833
834 static bfd_boolean
835 mep_elf_print_private_bfd_data (bfd * abfd, void * ptr)
836 {
837 FILE * file = (FILE *) ptr;
838 flagword flags, partial_flags;
839
840 BFD_ASSERT (abfd != NULL && ptr != NULL);
841
842 /* Print normal ELF private data. */
843 _bfd_elf_print_private_bfd_data (abfd, ptr);
844
845 flags = elf_elfheader (abfd)->e_flags;
846 fprintf (file, _("private flags = 0x%lx"), (long)flags);
847
848 partial_flags = (flags & EF_MEP_CPU_MASK) >> 24;
849 if (partial_flags < ARRAY_SIZE (core_names))
850 fprintf (file, " core: %s", core_names[(long)partial_flags]);
851
852 partial_flags = flags & EF_MEP_INDEX_MASK;
853 if (partial_flags < ARRAY_SIZE (config_names))
854 fprintf (file, " me_module: %s", config_names[(long)partial_flags]);
855
856 fputc ('\n', file);
857
858 return TRUE;
859 }
860
861 /* Return the machine subcode from the ELF e_flags header. */
862
863 static int
864 elf32_mep_machine (bfd * abfd)
865 {
866 switch (elf_elfheader (abfd)->e_flags & EF_MEP_CPU_MASK)
867 {
868 default: break;
869 case EF_MEP_CPU_C2: return bfd_mach_mep;
870 case EF_MEP_CPU_C3: return bfd_mach_mep;
871 case EF_MEP_CPU_C4: return bfd_mach_mep;
872 case EF_MEP_CPU_H1: return bfd_mach_mep_h1;
873 }
874
875 return bfd_mach_mep;
876 }
877
878 static bfd_boolean
879 mep_elf_object_p (bfd * abfd)
880 {
881 /* Irix 5 and 6 is broken. Object file symbol tables are not always
882 sorted correctly such that local symbols preceed global symbols,
883 and the sh_info field in the symbol table is not always right. */
884 /* This is needed for the RELC support code. */
885 elf_bad_symtab (abfd) = TRUE;
886 bfd_default_set_arch_mach (abfd, bfd_arch_mep, elf32_mep_machine (abfd));
887 return TRUE;
888 }
889
890 static bfd_boolean
891 mep_elf_section_flags (flagword * flags, const Elf_Internal_Shdr * hdr)
892 {
893 if (hdr->sh_flags & SHF_MEP_VLIW)
894 * flags |= SEC_MEP_VLIW;
895 return TRUE;
896 }
897
898 static bfd_boolean
899 mep_elf_fake_sections (bfd * abfd ATTRIBUTE_UNUSED,
900 Elf_Internal_Shdr * hdr,
901 asection * sec)
902 {
903 if (sec->flags & SEC_MEP_VLIW)
904 hdr->sh_flags |= SHF_MEP_VLIW;
905 return TRUE;
906 }
907
908 \f
909 #define ELF_ARCH bfd_arch_mep
910 #define ELF_MACHINE_CODE EM_CYGNUS_MEP
911 #define ELF_MAXPAGESIZE 0x1000
912
913 #define TARGET_BIG_SYM bfd_elf32_mep_vec
914 #define TARGET_BIG_NAME "elf32-mep"
915
916 #define TARGET_LITTLE_SYM bfd_elf32_mep_little_vec
917 #define TARGET_LITTLE_NAME "elf32-mep-little"
918
919 #define elf_info_to_howto_rel NULL
920 #define elf_info_to_howto mep_info_to_howto_rela
921 #define elf_backend_relocate_section mep_elf_relocate_section
922 #define elf_backend_gc_mark_hook mep_elf_gc_mark_hook
923 #define elf_backend_gc_sweep_hook mep_elf_gc_sweep_hook
924 #define elf_backend_check_relocs mep_elf_check_relocs
925 #define elf_backend_object_p mep_elf_object_p
926 #define elf_backend_section_flags mep_elf_section_flags
927 #define elf_backend_fake_sections mep_elf_fake_sections
928
929 #define elf_backend_can_gc_sections 1
930
931 #define bfd_elf32_bfd_reloc_type_lookup mep_reloc_type_lookup
932 #define bfd_elf32_bfd_set_private_flags mep_elf_set_private_flags
933 #define bfd_elf32_bfd_copy_private_bfd_data mep_elf_copy_private_bfd_data
934 #define bfd_elf32_bfd_merge_private_bfd_data mep_elf_merge_private_bfd_data
935 #define bfd_elf32_bfd_print_private_bfd_data mep_elf_print_private_bfd_data
936
937 /* We use only the RELA entries. */
938 #define USE_RELA
939
940 #include "elf32-target.h"
git-cvsimport of binutils cvsroot