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