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