1 /* BFD back-end for Motorola MCore COFF/PE
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
24 #include "coff/mcore.h"
25 #include "coff/internal.h"
32 #define BADMAG(x) MCOREBADMAG(x)
35 #define NUM_ELEM(A) (sizeof (A) / sizeof (A)[0])
38 /* This file is compiled more than once, but we only compile the
39 final_link routine once. */
40 extern boolean mcore_bfd_coff_final_link
41 PARAMS ((bfd *, struct bfd_link_info *));
43 static struct bfd_link_hash_table * coff_mcore_link_hash_table_create
45 static bfd_reloc_status_type mcore_coff_unsupported_reloc
46 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
47 static boolean coff_mcore_relocate_section
48 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
49 struct internal_reloc *, struct internal_syment *, asection **));
50 static reloc_howto_type * mcore_coff_reloc_type_lookup
51 PARAMS ((bfd *, bfd_reloc_code_real_type));
52 static reloc_howto_type * coff_mcore_rtype_to_howto
53 PARAMS ((bfd *, asection *, struct internal_reloc *,
54 struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *));
55 static void mcore_emit_base_file_entry
56 PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_vma));
57 static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
58 static struct bfd_link_hash_table * coff_mcore_link_hash_table_create PARAMS ((bfd *));
60 /* The NT loader points the toc register to &toc + 32768, in order to
61 use the complete range of a 16-bit displacement. We have to adjust
62 for this when we fix up loads displaced off the toc reg. */
63 #define TOC_LOAD_ADJUSTMENT (-32768)
64 #define TOC_SECTION_NAME ".private.toc"
66 /* The main body of code is in coffcode.h. */
67 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
69 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
70 from smaller values. Start with zero, widen, *then* decrement. */
71 #define MINUS_ONE (((bfd_vma)0) - 1)
73 static reloc_howto_type mcore_coff_howto_table[] =
76 HOWTO (IMAGE_REL_MCORE_ABSOLUTE,/* type */
78 0, /* size (0 = byte, 1 = short, 2 = long) */
80 false, /* pc_relative */
82 complain_overflow_dont, /* dont complain_on_overflow */
83 NULL, /* special_function */
84 "ABSOLUTE", /* name */
85 false, /* partial_inplace */
88 false), /* pcrel_offset */
90 HOWTO (IMAGE_REL_MCORE_ADDR32,/* type */
92 2, /* size (0 = byte, 1 = short, 2 = long) */
94 false, /* pc_relative */
96 complain_overflow_bitfield, /* complain_on_overflow */
97 NULL, /* special_function */
99 true, /* partial_inplace */
100 0xffffffff, /* src_mask */
101 0xffffffff, /* dst_mask */
102 false), /* pcrel_offset */
104 /* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions.
105 Should not appear in object files. */
106 HOWTO (IMAGE_REL_MCORE_PCREL_IMM8BY4, /* type */
108 1, /* size (0 = byte, 1 = short, 2 = long) */
110 true, /* pc_relative */
112 complain_overflow_bitfield, /* complain_on_overflow */
113 mcore_coff_unsupported_reloc, /* special_function */
114 "IMM8BY4", /* name */
115 false, /* partial_inplace */
118 true), /* pcrel_offset */
120 /* bsr/bt/bf/br instructions; 11 bits + 1 zero bit
121 Span 2k instructions == 4k bytes.
122 Only useful pieces at the relocated address are the opcode (5 bits) */
123 HOWTO (IMAGE_REL_MCORE_PCREL_IMM11BY2,/* type */
125 1, /* size (0 = byte, 1 = short, 2 = long) */
127 true, /* pc_relative */
129 complain_overflow_signed, /* complain_on_overflow */
130 NULL, /* special_function */
131 "IMM11BY2", /* name */
132 false, /* partial_inplace */
134 0x7ff, /* dst_mask */
135 true), /* pcrel_offset */
137 /* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported. */
138 HOWTO (IMAGE_REL_MCORE_PCREL_IMM4BY2, /* type */
140 1, /* size (0 = byte, 1 = short, 2 = long) */
142 true, /* pc_relative */
144 complain_overflow_bitfield, /* complain_on_overflow */
145 mcore_coff_unsupported_reloc, /* special_function */
146 "IMM4BY2", /* name */
147 false, /* partial_inplace */
150 true), /* pcrel_offset */
152 /* 32-bit pc-relative. Eventually this will help support PIC code. */
153 HOWTO (IMAGE_REL_MCORE_PCREL_32,/* type */
155 2, /* size (0 = byte, 1 = short, 2 = long) */
157 true, /* pc_relative */
159 complain_overflow_bitfield, /* complain_on_overflow */
160 NULL, /* special_function */
161 "PCREL_32", /* name */
162 false, /* partial_inplace */
164 0xffffffff, /* dst_mask */
165 true), /* pcrel_offset */
167 /* Like PCREL_IMM11BY2, this relocation indicates that there is a
168 'jsri' at the specified address. There is a separate relocation
169 entry for the literal pool entry that it references, but we
170 might be able to change the jsri to a bsr if the target turns out
171 to be close enough [even though we won't reclaim the literal pool
172 entry, we'll get some runtime efficiency back]. Note that this
173 is a relocation that we are allowed to safely ignore. */
174 HOWTO (IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2,/* type */
176 1, /* size (0 = byte, 1 = short, 2 = long) */
178 true, /* pc_relative */
180 complain_overflow_signed, /* complain_on_overflow */
181 NULL, /* special_function */
182 "JSR_IMM11BY2", /* name */
183 false, /* partial_inplace */
185 0x7ff, /* dst_mask */
186 true), /* pcrel_offset */
188 HOWTO (IMAGE_REL_MCORE_RVA, /* type */
190 2, /* size (0 = byte, 1 = short, 2 = long) */
192 false, /* pc_relative */
194 complain_overflow_signed, /* complain_on_overflow */
195 NULL, /* special_function */
196 "MCORE_RVA", /* name */
197 true, /* partial_inplace */
198 0xffffffff, /* src_mask */
199 0xffffffff, /* dst_mask */
200 true) /* pcrel_offset */
203 /* Extend the coff_link_hash_table structure with a few M*Core specific fields.
204 This allows us to store global data here without actually creating any
205 global variables, which is a no-no in the BFD world. */
206 typedef struct coff_mcore_link_hash_table
208 /* The original coff_link_hash_table structure. MUST be first field. */
209 struct coff_link_hash_table root;
211 bfd * bfd_of_toc_owner;
212 long int global_toc_size;
213 long int import_table_size;
214 long int first_thunk_address;
219 /* Get the MCore coff linker hash table from a link_info structure. */
220 #define coff_mcore_hash_table(info) \
221 ((mcore_hash_table *) ((info)->hash))
223 /* Create an MCore coff linker hash table. */
225 static struct bfd_link_hash_table *
226 coff_mcore_link_hash_table_create (abfd)
229 mcore_hash_table * ret;
231 ret = (mcore_hash_table *) bfd_alloc (abfd, (bfd_size_type) sizeof (* ret));
232 if (ret == (mcore_hash_table *) NULL)
235 if (! _bfd_coff_link_hash_table_init
236 (& ret->root, abfd, _bfd_coff_link_hash_newfunc))
238 bfd_release (abfd, ret);
239 return (struct bfd_link_hash_table *) NULL;
242 ret->bfd_of_toc_owner = NULL;
243 ret->global_toc_size = 0;
244 ret->import_table_size = 0;
245 ret->first_thunk_address = 0;
248 return & ret->root.root;
251 /* Add an entry to the base file. */
254 mcore_emit_base_file_entry (info, output_bfd, input_section, reloc_offset)
255 struct bfd_link_info * info;
257 asection * input_section;
258 bfd_vma reloc_offset;
260 bfd_vma addr = reloc_offset
262 + input_section->output_offset
263 + input_section->output_section->vma;
265 if (coff_data (output_bfd)->pe)
266 addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
268 fwrite (&addr, 1, sizeof (addr), (FILE *) info->base_file);
271 static bfd_reloc_status_type
272 mcore_coff_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
273 output_bfd, error_message)
275 arelent * reloc_entry;
276 asymbol * symbol ATTRIBUTE_UNUSED;
277 PTR data ATTRIBUTE_UNUSED;
278 asection * input_section ATTRIBUTE_UNUSED;
279 bfd * output_bfd ATTRIBUTE_UNUSED;
280 char ** error_message ATTRIBUTE_UNUSED;
282 BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
284 _bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
285 bfd_get_filename (abfd),
286 reloc_entry->howto->name,
287 reloc_entry->howto->type);
289 return bfd_reloc_notsupported;
292 /* A cheesy little macro to make the code a little more readable. */
293 #define HOW2MAP(bfd_rtype, mcore_rtype) \
294 case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype]
296 static reloc_howto_type *
297 mcore_coff_reloc_type_lookup (abfd, code)
298 bfd * abfd ATTRIBUTE_UNUSED;
299 bfd_reloc_code_real_type code;
303 HOW2MAP (BFD_RELOC_32, IMAGE_REL_MCORE_ADDR32);
304 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM8BY4, IMAGE_REL_MCORE_PCREL_IMM8BY4);
305 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM11BY2, IMAGE_REL_MCORE_PCREL_IMM11BY2);
306 HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM4BY2, IMAGE_REL_MCORE_PCREL_IMM4BY2);
307 HOW2MAP (BFD_RELOC_32_PCREL, IMAGE_REL_MCORE_PCREL_32);
308 HOW2MAP (BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2);
309 HOW2MAP (BFD_RELOC_RVA, IMAGE_REL_MCORE_RVA);
318 #define RTYPE2HOWTO(cache_ptr, dst) \
319 (cache_ptr)->howto = mcore_coff_howto_table + (dst)->r_type;
321 static reloc_howto_type *
322 coff_mcore_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
323 bfd * abfd ATTRIBUTE_UNUSED;
325 struct internal_reloc * rel;
326 struct coff_link_hash_entry * h ATTRIBUTE_UNUSED;
327 struct internal_syment * sym;
330 reloc_howto_type * howto;
332 if (rel->r_type >= NUM_ELEM (mcore_coff_howto_table))
335 howto = mcore_coff_howto_table + rel->r_type;
337 if (rel->r_type == IMAGE_REL_MCORE_RVA)
338 * addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
340 else if (howto->pc_relative)
342 * addendp = sec->vma - 2; /* XXX guess - is this right ? */
344 /* If the symbol is defined, then the generic code is going to
345 add back the symbol value in order to cancel out an
346 adjustment it made to the addend. However, we set the addend
347 to 0 at the start of this function. We need to adjust here,
348 to avoid the adjustment the generic code will make. FIXME:
349 This is getting a bit hackish. */
350 if (sym != NULL && sym->n_scnum != 0)
351 * addendp -= sym->n_value;
359 /* Return true if this relocation should appear in the output .reloc section.
360 This function is referenced in pe_mkobject in peicode.h. */
363 in_reloc_p (abfd, howto)
364 bfd * abfd ATTRIBUTE_UNUSED;
365 reloc_howto_type * howto;
367 return ! howto->pc_relative && howto->type != IMAGE_REL_MCORE_RVA;
370 /* The reloc processing routine for the optimized COFF linker. */
372 coff_mcore_relocate_section (output_bfd, info, input_bfd, input_section,
373 contents, relocs, syms, sections)
375 struct bfd_link_info * info;
377 asection * input_section;
379 struct internal_reloc * relocs;
380 struct internal_syment * syms;
381 asection ** sections;
383 struct internal_reloc * rel;
384 struct internal_reloc * relend;
388 /* If we are performing a relocateable link, we don't need to do a
389 thing. The caller will take care of adjusting the reloc
390 addresses and symbol indices. */
391 if (info->relocateable)
394 /* Check if we have the same endianess */
395 if ( input_bfd->xvec->byteorder != output_bfd->xvec->byteorder
396 && output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
398 (*_bfd_error_handler)
399 (_("%s: compiled for a %s endian system and target is %s endian.\n"),
400 bfd_get_filename (input_bfd),
401 bfd_big_endian (input_bfd) ? "big" : "little",
402 bfd_big_endian (output_bfd) ? "big" : "little");
404 bfd_set_error (bfd_error_wrong_format);
412 relend = rel + input_section->reloc_count;
414 for (; rel < relend; rel++)
417 struct internal_syment * sym;
420 bfd_reloc_status_type rstat;
422 unsigned short r_type = rel->r_type;
423 reloc_howto_type * howto = NULL;
424 struct coff_link_hash_entry * h;
425 const char * my_name;
427 symndx = rel->r_symndx;
428 loc = contents + rel->r_vaddr - input_section->vma;
437 h = obj_coff_sym_hashes (input_bfd)[symndx];
443 /* Get the howto and initialise the addend. */
444 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
457 asection * sec = sections[symndx];
460 + sec->output_section->vma
461 + sec->output_offset);
464 my_name = "*unknown*";
465 else if ( sym->_n._n_n._n_zeroes == 0
466 && sym->_n._n_n._n_offset != 0)
467 my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
470 static char buf [SYMNMLEN + 1];
472 strncpy (buf, sym->_n._n_name, SYMNMLEN);
473 buf[SYMNMLEN] = '\0';
480 if ( h->root.type == bfd_link_hash_defined
481 || h->root.type == bfd_link_hash_defweak)
483 asection * sec = h->root.u.def.section;
485 val = (h->root.u.def.value
486 + sec->output_section->vma
487 + sec->output_offset);
491 if (! ((*info->callbacks->undefined_symbol)
492 (info, h->root.root.string, input_bfd, input_section,
493 rel->r_vaddr - input_section->vma, true)))
497 my_name = h->root.root.string;
500 rstat = bfd_reloc_ok;
502 /* Each case must do its own relocation, setting rstat appropriately. */
506 _bfd_error_handler (_("%s: unsupported relocation type 0x%02x"),
507 bfd_get_filename (input_bfd), r_type);
508 bfd_set_error (bfd_error_bad_value);
511 case IMAGE_REL_MCORE_ABSOLUTE:
513 _("Warning: unsupported reloc %s <file %s, section %s>\n"),
515 bfd_get_filename (input_bfd),
516 input_section->name);
518 fprintf (stderr,"sym %ld (%s), r_vaddr %ld (%lx)\n",
519 rel->r_symndx, my_name, (long) rel->r_vaddr,
520 (unsigned long) rel->r_vaddr);
523 case IMAGE_REL_MCORE_PCREL_IMM8BY4:
524 case IMAGE_REL_MCORE_PCREL_IMM11BY2:
525 case IMAGE_REL_MCORE_PCREL_IMM4BY2:
526 case IMAGE_REL_MCORE_PCREL_32:
527 case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2:
528 case IMAGE_REL_MCORE_ADDR32:
529 /* XXX fixme - shouldn't this be like the code for the RVA reloc ? */
530 rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
533 case IMAGE_REL_MCORE_RVA:
534 rstat = _bfd_final_link_relocate
536 input_section, contents, rel->r_vaddr - input_section->vma,
543 /* Emit a reloc if the backend thinks it needs it. */
544 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
545 mcore_emit_base_file_entry (info, output_bfd, input_section, rel->r_vaddr);
556 case bfd_reloc_overflow:
557 if (! ((*info->callbacks->reloc_overflow)
558 (info, my_name, howto->name,
559 (bfd_vma) 0, input_bfd,
560 input_section, rel->r_vaddr - input_section->vma)))
568 /* Tailor coffcode.h -- macro heaven. */
570 /* We use the special COFF backend linker, with our own special touch. */
572 #define coff_bfd_reloc_type_lookup mcore_coff_reloc_type_lookup
573 #define coff_relocate_section coff_mcore_relocate_section
574 #define coff_rtype_to_howto coff_mcore_rtype_to_howto
576 #define SELECT_RELOC(internal, howto) {internal.r_type = howto->type;}
578 #define COFF_PAGE_SIZE 0x1000
580 #include "coffcode.h"
582 /* Forward declaration to initialise alterbative_target field. */
583 extern const bfd_target TARGET_LITTLE_SYM;
585 /* The transfer vectors that lead the outside world to all of the above. */
586 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED,
587 (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
588 0, & TARGET_LITTLE_SYM)
589 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED,
590 (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),