1 /* BFD back-end for Motorola MCore COFF/PE
2 Copyright 1999, 2000, 2001, 2002, 2003 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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "coff/mcore.h"
25 #include "coff/internal.h"
26 #include "coff/pe.h"
27 #include "libcoff.h"
28
29 #ifdef BADMAG
30 #undef BADMAG
31 #endif
32 #define BADMAG(x) MCOREBADMAG(x)
33
34 #ifndef NUM_ELEM
35 #define NUM_ELEM(A) (sizeof (A) / sizeof (A)[0])
36 #endif
37
38 /* This file is compiled more than once, but we only compile the
39 final_link routine once. */
40 extern bfd_boolean mcore_bfd_coff_final_link
41 PARAMS ((bfd *, struct bfd_link_info *));
42 #if 0
43 static struct bfd_link_hash_table *coff_mcore_link_hash_table_create
44 PARAMS ((bfd *));
45 #endif
46 static bfd_reloc_status_type mcore_coff_unsupported_reloc
47 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
48 static bfd_boolean coff_mcore_relocate_section
49 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
50 struct internal_reloc *, struct internal_syment *, asection **));
51 static reloc_howto_type *mcore_coff_reloc_type_lookup
52 PARAMS ((bfd *, bfd_reloc_code_real_type));
53 static reloc_howto_type *coff_mcore_rtype_to_howto
54 PARAMS ((bfd *, asection *, struct internal_reloc *,
55 struct coff_link_hash_entry *, struct internal_syment *,
56 bfd_vma *));
57 static void mcore_emit_base_file_entry
58 PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_vma));
59 static bfd_boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
60
61 /* The NT loader points the toc register to &toc + 32768, in order to
62 use the complete range of a 16-bit displacement. We have to adjust
63 for this when we fix up loads displaced off the toc reg. */
64 #define TOC_LOAD_ADJUSTMENT (-32768)
65 #define TOC_SECTION_NAME ".private.toc"
66
67 /* The main body of code is in coffcode.h. */
68 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
69
70 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
71 from smaller values. Start with zero, widen, *then* decrement. */
72 #define MINUS_ONE (((bfd_vma)0) - 1)
73
74 static reloc_howto_type mcore_coff_howto_table[] =
75 {
76 /* Unused: */
77 HOWTO (IMAGE_REL_MCORE_ABSOLUTE,/* type */
78 0, /* rightshift */
79 0, /* size (0 = byte, 1 = short, 2 = long) */
80 0, /* bitsize */
81 FALSE, /* pc_relative */
82 0, /* bitpos */
83 complain_overflow_dont, /* dont complain_on_overflow */
84 NULL, /* special_function */
85 "ABSOLUTE", /* name */
86 FALSE, /* partial_inplace */
87 0x00, /* src_mask */
88 0x00, /* dst_mask */
89 FALSE), /* pcrel_offset */
90
91 HOWTO (IMAGE_REL_MCORE_ADDR32,/* type */
92 0, /* rightshift */
93 2, /* size (0 = byte, 1 = short, 2 = long) */
94 32, /* bitsize */
95 FALSE, /* pc_relative */
96 0, /* bitpos */
97 complain_overflow_bitfield, /* complain_on_overflow */
98 NULL, /* special_function */
99 "ADDR32", /* name */
100 TRUE, /* partial_inplace */
101 0xffffffff, /* src_mask */
102 0xffffffff, /* dst_mask */
103 FALSE), /* pcrel_offset */
104
105 /* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions.
106 Should not appear in object files. */
107 HOWTO (IMAGE_REL_MCORE_PCREL_IMM8BY4, /* type */
108 2, /* rightshift */
109 1, /* size (0 = byte, 1 = short, 2 = long) */
110 8, /* bitsize */
111 TRUE, /* pc_relative */
112 0, /* bitpos */
113 complain_overflow_bitfield, /* complain_on_overflow */
114 mcore_coff_unsupported_reloc, /* special_function */
115 "IMM8BY4", /* name */
116 FALSE, /* partial_inplace */
117 0, /* src_mask */
118 0, /* dst_mask */
119 TRUE), /* pcrel_offset */
120
121 /* bsr/bt/bf/br instructions; 11 bits + 1 zero bit
122 Span 2k instructions == 4k bytes.
123 Only useful pieces at the relocated address are the opcode (5 bits) */
124 HOWTO (IMAGE_REL_MCORE_PCREL_IMM11BY2,/* type */
125 1, /* rightshift */
126 1, /* size (0 = byte, 1 = short, 2 = long) */
127 11, /* bitsize */
128 TRUE, /* pc_relative */
129 0, /* bitpos */
130 complain_overflow_signed, /* complain_on_overflow */
131 NULL, /* special_function */
132 "IMM11BY2", /* name */
133 FALSE, /* partial_inplace */
134 0x0, /* src_mask */
135 0x7ff, /* dst_mask */
136 TRUE), /* pcrel_offset */
137
138 /* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported. */
139 HOWTO (IMAGE_REL_MCORE_PCREL_IMM4BY2, /* type */
140 1, /* rightshift */
141 1, /* size (0 = byte, 1 = short, 2 = long) */
142 4, /* bitsize */
143 TRUE, /* pc_relative */
144 0, /* bitpos */
145 complain_overflow_bitfield, /* complain_on_overflow */
146 mcore_coff_unsupported_reloc, /* special_function */
147 "IMM4BY2", /* name */
148 FALSE, /* partial_inplace */
149 0, /* src_mask */
150 0, /* dst_mask */
151 TRUE), /* pcrel_offset */
152
153 /* 32-bit pc-relative. Eventually this will help support PIC code. */
154 HOWTO (IMAGE_REL_MCORE_PCREL_32,/* type */
155 0, /* rightshift */
156 2, /* size (0 = byte, 1 = short, 2 = long) */
157 32, /* bitsize */
158 TRUE, /* pc_relative */
159 0, /* bitpos */
160 complain_overflow_bitfield, /* complain_on_overflow */
161 NULL, /* special_function */
162 "PCREL_32", /* name */
163 FALSE, /* partial_inplace */
164 0x0, /* src_mask */
165 0xffffffff, /* dst_mask */
166 TRUE), /* pcrel_offset */
167
168 /* Like PCREL_IMM11BY2, this relocation indicates that there is a
169 'jsri' at the specified address. There is a separate relocation
170 entry for the literal pool entry that it references, but we
171 might be able to change the jsri to a bsr if the target turns out
172 to be close enough [even though we won't reclaim the literal pool
173 entry, we'll get some runtime efficiency back]. Note that this
174 is a relocation that we are allowed to safely ignore. */
175 HOWTO (IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2,/* type */
176 1, /* rightshift */
177 1, /* size (0 = byte, 1 = short, 2 = long) */
178 11, /* bitsize */
179 TRUE, /* pc_relative */
180 0, /* bitpos */
181 complain_overflow_signed, /* complain_on_overflow */
182 NULL, /* special_function */
183 "JSR_IMM11BY2", /* name */
184 FALSE, /* partial_inplace */
185 0x0, /* src_mask */
186 0x7ff, /* dst_mask */
187 TRUE), /* pcrel_offset */
188
189 HOWTO (IMAGE_REL_MCORE_RVA, /* type */
190 0, /* rightshift */
191 2, /* size (0 = byte, 1 = short, 2 = long) */
192 32, /* bitsize */
193 FALSE, /* pc_relative */
194 0, /* bitpos */
195 complain_overflow_signed, /* complain_on_overflow */
196 NULL, /* special_function */
197 "MCORE_RVA", /* name */
198 TRUE, /* partial_inplace */
199 0xffffffff, /* src_mask */
200 0xffffffff, /* dst_mask */
201 TRUE) /* pcrel_offset */
202 };
203
204 /* Extend the coff_link_hash_table structure with a few M*Core specific fields.
205 This allows us to store global data here without actually creating any
206 global variables, which is a no-no in the BFD world. */
207 typedef struct coff_mcore_link_hash_table
208 {
209 /* The original coff_link_hash_table structure. MUST be first field. */
210 struct coff_link_hash_table root;
211
212 bfd * bfd_of_toc_owner;
213 long int global_toc_size;
214 long int import_table_size;
215 long int first_thunk_address;
216 long int thunk_size;
217 }
218 mcore_hash_table;
219
220 /* Get the MCore coff linker hash table from a link_info structure. */
221 #define coff_mcore_hash_table(info) \
222 ((mcore_hash_table *) ((info)->hash))
223
224 #if 0
225 /* Create an MCore coff linker hash table. */
226
227 static struct bfd_link_hash_table *
228 coff_mcore_link_hash_table_create (abfd)
229 bfd * abfd;
230 {
231 mcore_hash_table * ret;
232
233 ret = (mcore_hash_table *) bfd_malloc ((bfd_size_type) sizeof (* ret));
234 if (ret == (mcore_hash_table *) NULL)
235 return NULL;
236
237 if (! _bfd_coff_link_hash_table_init
238 (& ret->root, abfd, _bfd_coff_link_hash_newfunc))
239 {
240 free (ret);
241 return (struct bfd_link_hash_table *) NULL;
242 }
243
244 ret->bfd_of_toc_owner = NULL;
245 ret->global_toc_size = 0;
246 ret->import_table_size = 0;
247 ret->first_thunk_address = 0;
248 ret->thunk_size = 0;
249
250 return & ret->root.root;
251 }
252 #endif
253
254 /* Add an entry to the base file. */
255
256 static void
mcore_emit_base_file_entry(info,output_bfd,input_section,reloc_offset)257 mcore_emit_base_file_entry (info, output_bfd, input_section, reloc_offset)
258 struct bfd_link_info * info;
259 bfd * output_bfd;
260 asection * input_section;
261 bfd_vma reloc_offset;
262 {
263 bfd_vma addr = reloc_offset
264 - input_section->vma
265 + input_section->output_offset
266 + input_section->output_section->vma;
267
268 if (coff_data (output_bfd)->pe)
269 addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
270
271 fwrite (&addr, 1, sizeof (addr), (FILE *) info->base_file);
272 }
273
274 static bfd_reloc_status_type
mcore_coff_unsupported_reloc(abfd,reloc_entry,symbol,data,input_section,output_bfd,error_message)275 mcore_coff_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
276 output_bfd, error_message)
277 bfd * abfd;
278 arelent * reloc_entry;
279 asymbol * symbol ATTRIBUTE_UNUSED;
280 PTR data ATTRIBUTE_UNUSED;
281 asection * input_section ATTRIBUTE_UNUSED;
282 bfd * output_bfd ATTRIBUTE_UNUSED;
283 char ** error_message ATTRIBUTE_UNUSED;
284 {
285 BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
286
287 _bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
288 bfd_archive_filename (abfd),
289 reloc_entry->howto->name,
290 reloc_entry->howto->type);
291
292 return bfd_reloc_notsupported;
293 }
294
295 /* A cheesy little macro to make the code a little more readable. */
296 #define HOW2MAP(bfd_rtype, mcore_rtype) \
297 case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype]
298
299 static reloc_howto_type *
mcore_coff_reloc_type_lookup(abfd,code)300 mcore_coff_reloc_type_lookup (abfd, code)
301 bfd * abfd ATTRIBUTE_UNUSED;
302 bfd_reloc_code_real_type code;
303 {
304 switch (code)
305 {
306 HOW2MAP (BFD_RELOC_32, IMAGE_REL_MCORE_ADDR32);
307 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM8BY4, IMAGE_REL_MCORE_PCREL_IMM8BY4);
308 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM11BY2, IMAGE_REL_MCORE_PCREL_IMM11BY2);
309 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM4BY2, IMAGE_REL_MCORE_PCREL_IMM4BY2);
310 HOW2MAP (BFD_RELOC_32_PCREL, IMAGE_REL_MCORE_PCREL_32);
311 HOW2MAP (BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2);
312 HOW2MAP (BFD_RELOC_RVA, IMAGE_REL_MCORE_RVA);
313 default:
314 return NULL;
315 }
316 /*NOTREACHED*/
317 }
318
319 #undef HOW2MAP
320
321 #define RTYPE2HOWTO(cache_ptr, dst) \
322 (cache_ptr)->howto = mcore_coff_howto_table + (dst)->r_type;
323
324 static reloc_howto_type *
coff_mcore_rtype_to_howto(abfd,sec,rel,h,sym,addendp)325 coff_mcore_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
326 bfd * abfd ATTRIBUTE_UNUSED;
327 asection * sec;
328 struct internal_reloc * rel;
329 struct coff_link_hash_entry * h ATTRIBUTE_UNUSED;
330 struct internal_syment * sym;
331 bfd_vma * addendp;
332 {
333 reloc_howto_type * howto;
334
335 if (rel->r_type >= NUM_ELEM (mcore_coff_howto_table))
336 return NULL;
337
338 howto = mcore_coff_howto_table + rel->r_type;
339
340 if (rel->r_type == IMAGE_REL_MCORE_RVA)
341 * addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
342
343 else if (howto->pc_relative)
344 {
345 * addendp = sec->vma - 2; /* XXX guess - is this right ? */
346
347 /* If the symbol is defined, then the generic code is going to
348 add back the symbol value in order to cancel out an
349 adjustment it made to the addend. However, we set the addend
350 to 0 at the start of this function. We need to adjust here,
351 to avoid the adjustment the generic code will make. FIXME:
352 This is getting a bit hackish. */
353 if (sym != NULL && sym->n_scnum != 0)
354 * addendp -= sym->n_value;
355 }
356 else
357 * addendp = 0;
358
359 return howto;
360 }
361
362 /* Return TRUE if this relocation should appear in the output .reloc section.
363 This function is referenced in pe_mkobject in peicode.h. */
364
365 static bfd_boolean
in_reloc_p(abfd,howto)366 in_reloc_p (abfd, howto)
367 bfd * abfd ATTRIBUTE_UNUSED;
368 reloc_howto_type * howto;
369 {
370 return ! howto->pc_relative && howto->type != IMAGE_REL_MCORE_RVA;
371 }
372
373 /* The reloc processing routine for the optimized COFF linker. */
374 static bfd_boolean
coff_mcore_relocate_section(output_bfd,info,input_bfd,input_section,contents,relocs,syms,sections)375 coff_mcore_relocate_section (output_bfd, info, input_bfd, input_section,
376 contents, relocs, syms, sections)
377 bfd * output_bfd;
378 struct bfd_link_info * info;
379 bfd * input_bfd;
380 asection * input_section;
381 bfd_byte * contents;
382 struct internal_reloc * relocs;
383 struct internal_syment * syms;
384 asection ** sections;
385 {
386 struct internal_reloc * rel;
387 struct internal_reloc * relend;
388 bfd_boolean hihalf;
389 bfd_vma hihalf_val;
390
391 /* If we are performing a relocatable link, we don't need to do a
392 thing. The caller will take care of adjusting the reloc
393 addresses and symbol indices. */
394 if (info->relocatable)
395 return TRUE;
396
397 /* Check if we have the same endianess */
398 if ( input_bfd->xvec->byteorder != output_bfd->xvec->byteorder
399 && output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
400 {
401 (*_bfd_error_handler)
402 (_("%s: compiled for a %s system and target is %s.\n"),
403 bfd_archive_filename (input_bfd),
404 bfd_big_endian (input_bfd) ? _("big endian") : _("little endian"),
405 bfd_big_endian (output_bfd) ? _("big endian") : _("little endian"));
406
407 bfd_set_error (bfd_error_wrong_format);
408 return FALSE;
409 }
410
411 hihalf = FALSE;
412 hihalf_val = 0;
413
414 rel = relocs;
415 relend = rel + input_section->reloc_count;
416
417 for (; rel < relend; rel++)
418 {
419 long symndx;
420 struct internal_syment * sym;
421 bfd_vma val;
422 bfd_vma addend;
423 bfd_reloc_status_type rstat;
424 bfd_byte * loc;
425 unsigned short r_type = rel->r_type;
426 reloc_howto_type * howto = NULL;
427 struct coff_link_hash_entry * h;
428 const char * my_name;
429
430 symndx = rel->r_symndx;
431 loc = contents + rel->r_vaddr - input_section->vma;
432
433 if (symndx == -1)
434 {
435 h = NULL;
436 sym = NULL;
437 }
438 else
439 {
440 h = obj_coff_sym_hashes (input_bfd)[symndx];
441 sym = syms + symndx;
442 }
443
444 addend = 0;
445
446 /* Get the howto and initialise the addend. */
447 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
448 sym, & addend);
449 if (howto == NULL)
450 return FALSE;
451
452 val = 0;
453
454 if (h == NULL)
455 {
456 if (symndx == -1)
457 my_name = "*ABS*";
458 else
459 {
460 asection * sec = sections[symndx];
461
462 val = (sym->n_value
463 + sec->output_section->vma
464 + sec->output_offset);
465
466 if (sym == NULL)
467 my_name = "*unknown*";
468 else if ( sym->_n._n_n._n_zeroes == 0
469 && sym->_n._n_n._n_offset != 0)
470 my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
471 else
472 {
473 static char buf [SYMNMLEN + 1];
474
475 strncpy (buf, sym->_n._n_name, SYMNMLEN);
476 buf[SYMNMLEN] = '\0';
477 my_name = buf;
478 }
479 }
480 }
481 else
482 {
483 if ( h->root.type == bfd_link_hash_defined
484 || h->root.type == bfd_link_hash_defweak)
485 {
486 asection * sec = h->root.u.def.section;
487
488 val = (h->root.u.def.value
489 + sec->output_section->vma
490 + sec->output_offset);
491 }
492 else
493 {
494 if (! ((*info->callbacks->undefined_symbol)
495 (info, h->root.root.string, input_bfd, input_section,
496 rel->r_vaddr - input_section->vma, TRUE)))
497 return FALSE;
498 }
499
500 my_name = h->root.root.string;
501 }
502
503 rstat = bfd_reloc_ok;
504
505 /* Each case must do its own relocation, setting rstat appropriately. */
506 switch (r_type)
507 {
508 default:
509 _bfd_error_handler (_("%s: unsupported relocation type 0x%02x"),
510 bfd_archive_filename (input_bfd), r_type);
511 bfd_set_error (bfd_error_bad_value);
512 return FALSE;
513
514 case IMAGE_REL_MCORE_ABSOLUTE:
515 fprintf (stderr,
516 _("Warning: unsupported reloc %s <file %s, section %s>\n"),
517 howto->name,
518 bfd_archive_filename (input_bfd),
519 input_section->name);
520
521 fprintf (stderr,"sym %ld (%s), r_vaddr %ld (%lx)\n",
522 rel->r_symndx, my_name, (long) rel->r_vaddr,
523 (unsigned long) rel->r_vaddr);
524 break;
525
526 case IMAGE_REL_MCORE_PCREL_IMM8BY4:
527 case IMAGE_REL_MCORE_PCREL_IMM11BY2:
528 case IMAGE_REL_MCORE_PCREL_IMM4BY2:
529 case IMAGE_REL_MCORE_PCREL_32:
530 case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2:
531 case IMAGE_REL_MCORE_ADDR32:
532 /* XXX fixme - shouldn't this be like the code for the RVA reloc ? */
533 rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
534 break;
535
536 case IMAGE_REL_MCORE_RVA:
537 rstat = _bfd_final_link_relocate
538 (howto, input_bfd,
539 input_section, contents, rel->r_vaddr - input_section->vma,
540 val, addend);
541 break;
542 }
543
544 if (info->base_file)
545 {
546 /* Emit a reloc if the backend thinks it needs it. */
547 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
548 mcore_emit_base_file_entry (info, output_bfd, input_section, rel->r_vaddr);
549 }
550
551 switch (rstat)
552 {
553 default:
554 abort ();
555
556 case bfd_reloc_ok:
557 break;
558
559 case bfd_reloc_overflow:
560 if (! ((*info->callbacks->reloc_overflow)
561 (info, my_name, howto->name,
562 (bfd_vma) 0, input_bfd,
563 input_section, rel->r_vaddr - input_section->vma)))
564 return FALSE;
565 }
566 }
567
568 return TRUE;
569 }
570
571 /* Tailor coffcode.h -- macro heaven. */
572
573 /* We use the special COFF backend linker, with our own special touch. */
574
575 #define coff_bfd_reloc_type_lookup mcore_coff_reloc_type_lookup
576 #define coff_relocate_section coff_mcore_relocate_section
577 #define coff_rtype_to_howto coff_mcore_rtype_to_howto
578
579 #define SELECT_RELOC(internal, howto) {internal.r_type = howto->type;}
580
581 /* Make sure that the 'r_offset' field is copied properly
582 so that identical binaries will compare the same. */
583 #define SWAP_IN_RELOC_OFFSET H_GET_32
584 #define SWAP_OUT_RELOC_OFFSET H_PUT_32
585
586 #define COFF_PAGE_SIZE 0x1000
587
588 #include "coffcode.h"
589
590 /* Forward declaration to initialise alternative_target field. */
591 extern const bfd_target TARGET_LITTLE_SYM;
592
593 /* The transfer vectors that lead the outside world to all of the above. */
594 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED,
595 (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
596 0, & TARGET_LITTLE_SYM, COFF_SWAP_TABLE)
597 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED,
598 (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
599 0, & TARGET_BIG_SYM, COFF_SWAP_TABLE)
600