projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR ld/14357
[deliverable/binutils-gdb.git] / bfd / elf32-m68hc1x.c
CommitLineData
3a65329d 1/* Motorola 68HC11/HC12-specific support for 32-bit ELF
8d25cc3d 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
5efbbc43 3 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
3a65329d
SC		 4 Contributed by Stephane Carrez (stcarrez@nerim.fr)
5
cd123cb7
NC		 6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
3a65329d 22
3a65329d 23#include "sysdep.h"
df7b86aa 24#include "alloca-conf.h"
3db64b00 25#include "bfd.h"
3a65329d
SC		 26#include "bfdlink.h"
27#include "libbfd.h"
28#include "elf-bfd.h"
29#include "elf32-m68hc1x.h"
30#include "elf/m68hc11.h"
31#include "opcode/m68hc11.h"
32
33
34#define m68hc12_stub_hash_lookup(table, string, create, copy) \
35 ((struct elf32_m68hc11_stub_hash_entry *) \
36 bfd_hash_lookup ((table), (string), (create), (copy)))
37
38static struct elf32_m68hc11_stub_hash_entry* m68hc12_add_stub
0a6a3ebe
SC		 39 (const char *stub_name,
40 asection *section,
41 struct m68hc11_elf_link_hash_table *htab);
3a65329d
SC		 42
43static struct bfd_hash_entry *stub_hash_newfunc
0a6a3ebe 44 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
3a65329d 45
0a6a3ebe
SC		 46static void m68hc11_elf_set_symbol (bfd* abfd, struct bfd_link_info *info,
47 const char* name, bfd_vma value,
48 asection* sec);
3a65329d
SC		 49
50static bfd_boolean m68hc11_elf_export_one_stub
0a6a3ebe 51 (struct bfd_hash_entry *gen_entry, void *in_arg);
3a65329d 52
0a6a3ebe 53static void scan_sections_for_abi (bfd*, asection*, PTR);
3a65329d
SC		 54
55struct m68hc11_scan_param
56{
57 struct m68hc11_page_info* pinfo;
58 bfd_boolean use_memory_banks;
59};
60
61
62/* Create a 68HC11/68HC12 ELF linker hash table. */
63
64struct m68hc11_elf_link_hash_table*
0a6a3ebe 65m68hc11_elf_hash_table_create (bfd *abfd)
3a65329d
SC		 66{
67 struct m68hc11_elf_link_hash_table *ret;
68 bfd_size_type amt = sizeof (struct m68hc11_elf_link_hash_table);
69
47247ced 70 ret = (struct m68hc11_elf_link_hash_table *) bfd_malloc (amt);
3a65329d
SC		 71 if (ret == (struct m68hc11_elf_link_hash_table *) NULL)
72 return NULL;
73
47247ced 74 memset (ret, 0, amt);
66eb6687
AM		 75 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
76 _bfd_elf_link_hash_newfunc,
4dfe6ac6
NC		 77 sizeof (struct elf_link_hash_entry),
78 M68HC11_ELF_DATA))
3a65329d 79 {
47247ced 80 free (ret);
3a65329d
SC		 81 return NULL;
82 }
83
84 /* Init the stub hash table too. */
85 amt = sizeof (struct bfd_hash_table);
86 ret->stub_hash_table = (struct bfd_hash_table*) bfd_malloc (amt);
87 if (ret->stub_hash_table == NULL)
88 {
47247ced 89 free (ret);
3a65329d
SC		 90 return NULL;
91 }
66eb6687
AM		 92 if (!bfd_hash_table_init (ret->stub_hash_table, stub_hash_newfunc,
93 sizeof (struct elf32_m68hc11_stub_hash_entry)))
3a65329d
SC		 94 return NULL;
95
96 ret->stub_bfd = NULL;
97 ret->stub_section = 0;
98 ret->add_stub_section = NULL;
87d72d41 99 ret->sym_cache.abfd = NULL;
3a65329d
SC		 100
101 return ret;
102}
103
104/* Free the derived linker hash table. */
105
106void
0a6a3ebe 107m68hc11_elf_bfd_link_hash_table_free (struct bfd_link_hash_table *hash)
3a65329d
SC		 108{
109 struct m68hc11_elf_link_hash_table *ret
110 = (struct m68hc11_elf_link_hash_table *) hash;
111
112 bfd_hash_table_free (ret->stub_hash_table);
113 free (ret->stub_hash_table);
114 _bfd_generic_link_hash_table_free (hash);
115}
116
117/* Assorted hash table functions. */
118
119/* Initialize an entry in the stub hash table. */
120
121static struct bfd_hash_entry *
0a6a3ebe
SC		 122stub_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table,
123 const char *string)
3a65329d
SC		 124{
125 /* Allocate the structure if it has not already been allocated by a
126 subclass. */
127 if (entry == NULL)
128 {
129 entry = bfd_hash_allocate (table,
130 sizeof (struct elf32_m68hc11_stub_hash_entry));
131 if (entry == NULL)
132 return entry;
133 }
134
135 /* Call the allocation method of the superclass. */
136 entry = bfd_hash_newfunc (entry, table, string);
137 if (entry != NULL)
138 {
139 struct elf32_m68hc11_stub_hash_entry *eh;
140
141 /* Initialize the local fields. */
142 eh = (struct elf32_m68hc11_stub_hash_entry *) entry;
143 eh->stub_sec = NULL;
144 eh->stub_offset = 0;
145 eh->target_value = 0;
146 eh->target_section = NULL;
147 }
148
149 return entry;
150}
151
152/* Add a new stub entry to the stub hash. Not all fields of the new
153 stub entry are initialised. */
154
155static struct elf32_m68hc11_stub_hash_entry *
0a6a3ebe
SC		 156m68hc12_add_stub (const char *stub_name, asection *section,
157 struct m68hc11_elf_link_hash_table *htab)
3a65329d
SC		 158{
159 struct elf32_m68hc11_stub_hash_entry *stub_entry;
160
161 /* Enter this entry into the linker stub hash table. */
162 stub_entry = m68hc12_stub_hash_lookup (htab->stub_hash_table, stub_name,
163 TRUE, FALSE);
164 if (stub_entry == NULL)
165 {
d003868e
AM		 166 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
167 section->owner, stub_name);
3a65329d
SC		 168 return NULL;
169 }
170
171 if (htab->stub_section == 0)
172 {
173 htab->stub_section = (*htab->add_stub_section) (".tramp",
174 htab->tramp_section);
175 }
176
177 stub_entry->stub_sec = htab->stub_section;
178 stub_entry->stub_offset = 0;
179 return stub_entry;
180}
181
182/* Hook called by the linker routine which adds symbols from an object
183 file. We use it for identify far symbols and force a loading of
184 the trampoline handler. */
185
186bfd_boolean
0a6a3ebe 187elf32_m68hc11_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
555cd476 188 Elf_Internal_Sym *sym,
0a6a3ebe
SC		 189 const char **namep ATTRIBUTE_UNUSED,
190 flagword *flagsp ATTRIBUTE_UNUSED,
191 asection **secp ATTRIBUTE_UNUSED,
192 bfd_vma *valp ATTRIBUTE_UNUSED)
3a65329d
SC		 193{
194 if (sym->st_other & STO_M68HC12_FAR)
195 {
196 struct elf_link_hash_entry *h;
197
198 h = (struct elf_link_hash_entry *)
199 bfd_link_hash_lookup (info->hash, "__far_trampoline",
200 FALSE, FALSE, FALSE);
201 if (h == NULL)
202 {
203 struct bfd_link_hash_entry* entry = NULL;
204
205 _bfd_generic_link_add_one_symbol (info, abfd,
206 "__far_trampoline",
207 BSF_GLOBAL,
208 bfd_und_section_ptr,
209 (bfd_vma) 0, (const char*) NULL,
210 FALSE, FALSE, &entry);
211 }
212
213 }
214 return TRUE;
215}
216
5efbbc43
AM		 217/* Merge non-visibility st_other attributes, STO_M68HC12_FAR and
218 STO_M68HC12_INTERRUPT. */
219
220void
221elf32_m68hc11_merge_symbol_attribute (struct elf_link_hash_entry *h,
222 const Elf_Internal_Sym *isym,
223 bfd_boolean definition,
224 bfd_boolean dynamic ATTRIBUTE_UNUSED)
225{
226 if (definition)
227 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
228 | ELF_ST_VISIBILITY (h->other));
229}
230
3a65329d
SC		 231/* External entry points for sizing and building linker stubs. */
232
233/* Set up various things so that we can make a list of input sections
234 for each output section included in the link. Returns -1 on error,
235 0 when no stubs will be needed, and 1 on success. */
236
237int
0a6a3ebe 238elf32_m68hc11_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
3a65329d
SC		 239{
240 bfd *input_bfd;
241 unsigned int bfd_count;
242 int top_id, top_index;
243 asection *section;
244 asection **input_list, **list;
245 bfd_size_type amt;
246 asection *text_section;
247 struct m68hc11_elf_link_hash_table *htab;
248
249 htab = m68hc11_elf_hash_table (info);
4dfe6ac6
NC		 250 if (htab == NULL)
251 return -1;
3a65329d 252
f13a99db 253 if (bfd_get_flavour (info->output_bfd) != bfd_target_elf_flavour)
3a65329d
SC		 254 return 0;
255
256 /* Count the number of input BFDs and find the top input section id.
257 Also search for an existing ".tramp" section so that we know
258 where generated trampolines must go. Default to ".text" if we
259 can't find it. */
260 htab->tramp_section = 0;
261 text_section = 0;
262 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
263 input_bfd != NULL;
264 input_bfd = input_bfd->link_next)
265 {
266 bfd_count += 1;
267 for (section = input_bfd->sections;
268 section != NULL;
269 section = section->next)
270 {
271 const char* name = bfd_get_section_name (input_bfd, section);
272
273 if (!strcmp (name, ".tramp"))
274 htab->tramp_section = section;
275
276 if (!strcmp (name, ".text"))
277 text_section = section;
278
279 if (top_id < section->id)
280 top_id = section->id;
281 }
282 }
283 htab->bfd_count = bfd_count;
284 if (htab->tramp_section == 0)
285 htab->tramp_section = text_section;
286
287 /* We can't use output_bfd->section_count here to find the top output
288 section index as some sections may have been removed, and
8423293d 289 strip_excluded_output_sections doesn't renumber the indices. */
3a65329d
SC		 290 for (section = output_bfd->sections, top_index = 0;
291 section != NULL;
292 section = section->next)
293 {
294 if (top_index < section->index)
295 top_index = section->index;
296 }
297
298 htab->top_index = top_index;
299 amt = sizeof (asection *) * (top_index + 1);
300 input_list = (asection **) bfd_malloc (amt);
301 htab->input_list = input_list;
302 if (input_list == NULL)
303 return -1;
304
305 /* For sections we aren't interested in, mark their entries with a
306 value we can check later. */
307 list = input_list + top_index;
308 do
309 *list = bfd_abs_section_ptr;
310 while (list-- != input_list);
311
312 for (section = output_bfd->sections;
313 section != NULL;
314 section = section->next)
315 {
316 if ((section->flags & SEC_CODE) != 0)
317 input_list[section->index] = NULL;
318 }
319
320 return 1;
321}
322
323/* Determine and set the size of the stub section for a final link.
324
325 The basic idea here is to examine all the relocations looking for
326 PC-relative calls to a target that is unreachable with a "bl"
327 instruction. */
328
329bfd_boolean
0a6a3ebe
SC		 330elf32_m68hc11_size_stubs (bfd *output_bfd, bfd *stub_bfd,
331 struct bfd_link_info *info,
332 asection * (*add_stub_section) (const char*, asection*))
3a65329d
SC		 333{
334 bfd *input_bfd;
335 asection *section;
336 Elf_Internal_Sym *local_syms, **all_local_syms;
337 unsigned int bfd_indx, bfd_count;
338 bfd_size_type amt;
339 asection *stub_sec;
3a65329d
SC		 340 struct m68hc11_elf_link_hash_table *htab = m68hc11_elf_hash_table (info);
341
4dfe6ac6
NC		 342 if (htab == NULL)
343 return FALSE;
344
3a65329d
SC		 345 /* Stash our params away. */
346 htab->stub_bfd = stub_bfd;
347 htab->add_stub_section = add_stub_section;
348
349 /* Count the number of input BFDs and find the top input section id. */
350 for (input_bfd = info->input_bfds, bfd_count = 0;
351 input_bfd != NULL;
352 input_bfd = input_bfd->link_next)
4dfe6ac6 353 bfd_count += 1;
3a65329d
SC		 354
355 /* We want to read in symbol extension records only once. To do this
356 we need to read in the local symbols in parallel and save them for
357 later use; so hold pointers to the local symbols in an array. */
358 amt = sizeof (Elf_Internal_Sym *) * bfd_count;
359 all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
360 if (all_local_syms == NULL)
361 return FALSE;
362
363 /* Walk over all the input BFDs, swapping in local symbols. */
364 for (input_bfd = info->input_bfds, bfd_indx = 0;
365 input_bfd != NULL;
366 input_bfd = input_bfd->link_next, bfd_indx++)
367 {
368 Elf_Internal_Shdr *symtab_hdr;
3a65329d
SC		 369
370 /* We'll need the symbol table in a second. */
371 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
372 if (symtab_hdr->sh_info == 0)
373 continue;
374
2a0e29b4
SC		 375 /* We need an array of the local symbols attached to the input bfd. */
376 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
377 if (local_syms == NULL)
378 {
379 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
380 symtab_hdr->sh_info, 0,
381 NULL, NULL, NULL);
382 /* Cache them for elf_link_input_bfd. */
383 symtab_hdr->contents = (unsigned char *) local_syms;
384 }
3a65329d 385 if (local_syms == NULL)
3a65329d 386 {
2a0e29b4
SC		 387 free (all_local_syms);
388 return FALSE;
3a65329d
SC		 389 }
390
2a0e29b4 391 all_local_syms[bfd_indx] = local_syms;
3a65329d
SC		 392 }
393
394 for (input_bfd = info->input_bfds, bfd_indx = 0;
395 input_bfd != NULL;
396 input_bfd = input_bfd->link_next, bfd_indx++)
397 {
398 Elf_Internal_Shdr *symtab_hdr;
3a65329d
SC		 399 struct elf_link_hash_entry ** sym_hashes;
400
401 sym_hashes = elf_sym_hashes (input_bfd);
402
403 /* We'll need the symbol table in a second. */
404 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
405 if (symtab_hdr->sh_info == 0)
406 continue;
407
408 local_syms = all_local_syms[bfd_indx];
409
410 /* Walk over each section attached to the input bfd. */
411 for (section = input_bfd->sections;
412 section != NULL;
413 section = section->next)
414 {
415 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
416
417 /* If there aren't any relocs, then there's nothing more
418 to do. */
419 if ((section->flags & SEC_RELOC) == 0
420 || section->reloc_count == 0)
421 continue;
422
423 /* If this section is a link-once section that will be
424 discarded, then don't create any stubs. */
425 if (section->output_section == NULL
426 || section->output_section->owner != output_bfd)
427 continue;
428
429 /* Get the relocs. */
430 internal_relocs
45d6a902
AM		 431 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
432 (Elf_Internal_Rela *) NULL,
433 info->keep_memory);
3a65329d
SC		 434 if (internal_relocs == NULL)
435 goto error_ret_free_local;
436
437 /* Now examine each relocation. */
438 irela = internal_relocs;
439 irelaend = irela + section->reloc_count;
440 for (; irela < irelaend; irela++)
441 {
442 unsigned int r_type, r_indx;
443 struct elf32_m68hc11_stub_hash_entry *stub_entry;
444 asection *sym_sec;
445 bfd_vma sym_value;
446 struct elf_link_hash_entry *hash;
447 const char *stub_name;
448 Elf_Internal_Sym *sym;
449
450 r_type = ELF32_R_TYPE (irela->r_info);
451
452 /* Only look at 16-bit relocs. */
453 if (r_type != (unsigned int) R_M68HC11_16)
454 continue;
455
456 /* Now determine the call target, its name, value,
457 section. */
458 r_indx = ELF32_R_SYM (irela->r_info);
459 if (r_indx < symtab_hdr->sh_info)
460 {
461 /* It's a local symbol. */
462 Elf_Internal_Shdr *hdr;
463 bfd_boolean is_far;
464
465 sym = local_syms + r_indx;
3a65329d
SC		 466 is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
467 if (!is_far)
468 continue;
7f888330 469
4fbb74a6
AM		 470 if (sym->st_shndx >= elf_numsections (input_bfd))
471 sym_sec = NULL;
472 else
473 {
474 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
475 sym_sec = hdr->bfd_section;
476 }
3a65329d
SC		 477 stub_name = (bfd_elf_string_from_elf_section
478 (input_bfd, symtab_hdr->sh_link,
479 sym->st_name));
480 sym_value = sym->st_value;
481 hash = NULL;
482 }
483 else
484 {
485 /* It's an external symbol. */
486 int e_indx;
487
488 e_indx = r_indx - symtab_hdr->sh_info;
489 hash = (struct elf_link_hash_entry *)
490 (sym_hashes[e_indx]);
491
492 while (hash->root.type == bfd_link_hash_indirect
493 || hash->root.type == bfd_link_hash_warning)
494 hash = ((struct elf_link_hash_entry *)
495 hash->root.u.i.link);
496
497 if (hash->root.type == bfd_link_hash_defined
83774818
SC		 498 || hash->root.type == bfd_link_hash_defweak
499 || hash->root.type == bfd_link_hash_new)
3a65329d
SC		 500 {
501 if (!(hash->other & STO_M68HC12_FAR))
502 continue;
503 }
504 else if (hash->root.type == bfd_link_hash_undefweak)
505 {
506 continue;
507 }
508 else if (hash->root.type == bfd_link_hash_undefined)
509 {
510 continue;
511 }
512 else
513 {
514 bfd_set_error (bfd_error_bad_value);
515 goto error_ret_free_internal;
516 }
517 sym_sec = hash->root.u.def.section;
518 sym_value = hash->root.u.def.value;
519 stub_name = hash->root.root.string;
520 }
521
522 if (!stub_name)
523 goto error_ret_free_internal;
524
525 stub_entry = m68hc12_stub_hash_lookup
526 (htab->stub_hash_table,
527 stub_name,
528 FALSE, FALSE);
529 if (stub_entry == NULL)
530 {
531 if (add_stub_section == 0)
532 continue;
533
534 stub_entry = m68hc12_add_stub (stub_name, section, htab);
535 if (stub_entry == NULL)
536 {
537 error_ret_free_internal:
538 if (elf_section_data (section)->relocs == NULL)
539 free (internal_relocs);
540 goto error_ret_free_local;
541 }
542 }
543
544 stub_entry->target_value = sym_value;
545 stub_entry->target_section = sym_sec;
546 }
547
548 /* We're done with the internal relocs, free them. */
549 if (elf_section_data (section)->relocs == NULL)
550 free (internal_relocs);
551 }
552 }
553
554 if (add_stub_section)
555 {
556 /* OK, we've added some stubs. Find out the new size of the
557 stub sections. */
558 for (stub_sec = htab->stub_bfd->sections;
559 stub_sec != NULL;
560 stub_sec = stub_sec->next)
561 {
eea6121a 562 stub_sec->size = 0;
3a65329d
SC		 563 }
564
565 bfd_hash_traverse (htab->stub_hash_table, htab->size_one_stub, htab);
566 }
2a0e29b4 567 free (all_local_syms);
3a65329d
SC		 568 return TRUE;
569
570 error_ret_free_local:
2a0e29b4 571 free (all_local_syms);
3a65329d
SC		 572 return FALSE;
573}
574
575/* Export the trampoline addresses in the symbol table. */
576static bfd_boolean
0a6a3ebe 577m68hc11_elf_export_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
3a65329d
SC		 578{
579 struct bfd_link_info *info;
580 struct m68hc11_elf_link_hash_table *htab;
581 struct elf32_m68hc11_stub_hash_entry *stub_entry;
582 char* name;
583 bfd_boolean result;
584
585 info = (struct bfd_link_info *) in_arg;
586 htab = m68hc11_elf_hash_table (info);
4dfe6ac6
NC		 587 if (htab == NULL)
588 return FALSE;
3a65329d
SC		 589
590 /* Massage our args to the form they really have. */
591 stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry;
592
593 /* Generate the trampoline according to HC11 or HC12. */
594 result = (* htab->build_one_stub) (gen_entry, in_arg);
595
596 /* Make a printable name that does not conflict with the real function. */
597 name = alloca (strlen (stub_entry->root.string) + 16);
598 sprintf (name, "tramp.%s", stub_entry->root.string);
599
600 /* Export the symbol for debugging/disassembling. */
601 m68hc11_elf_set_symbol (htab->stub_bfd, info, name,
602 stub_entry->stub_offset,
603 stub_entry->stub_sec);
604 return result;
605}
606
607/* Export a symbol or set its value and section. */
608static void
0a6a3ebe
SC		 609m68hc11_elf_set_symbol (bfd *abfd, struct bfd_link_info *info,
610 const char *name, bfd_vma value, asection *sec)
3a65329d
SC		 611{
612 struct elf_link_hash_entry *h;
613
614 h = (struct elf_link_hash_entry *)
615 bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
616 if (h == NULL)
617 {
618 _bfd_generic_link_add_one_symbol (info, abfd,
619 name,
620 BSF_GLOBAL,
621 sec,
622 value,
623 (const char*) NULL,
624 TRUE, FALSE, NULL);
625 }
626 else
627 {
628 h->root.type = bfd_link_hash_defined;
629 h->root.u.def.value = value;
630 h->root.u.def.section = sec;
631 }
632}
633
634
635/* Build all the stubs associated with the current output file. The
636 stubs are kept in a hash table attached to the main linker hash
637 table. This function is called via m68hc12elf_finish in the
638 linker. */
639
640bfd_boolean
0a6a3ebe 641elf32_m68hc11_build_stubs (bfd *abfd, struct bfd_link_info *info)
3a65329d
SC		 642{
643 asection *stub_sec;
644 struct bfd_hash_table *table;
645 struct m68hc11_elf_link_hash_table *htab;
646 struct m68hc11_scan_param param;
647
648 m68hc11_elf_get_bank_parameters (info);
649 htab = m68hc11_elf_hash_table (info);
4dfe6ac6
NC		 650 if (htab == NULL)
651 return FALSE;
3a65329d
SC		 652
653 for (stub_sec = htab->stub_bfd->sections;
654 stub_sec != NULL;
655 stub_sec = stub_sec->next)
656 {
657 bfd_size_type size;
658
659 /* Allocate memory to hold the linker stubs. */
eea6121a 660 size = stub_sec->size;
3a65329d
SC		 661 stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
662 if (stub_sec->contents == NULL && size != 0)
663 return FALSE;
eea6121a 664 stub_sec->size = 0;
3a65329d
SC		 665 }
666
667 /* Build the stubs as directed by the stub hash table. */
668 table = htab->stub_hash_table;
669 bfd_hash_traverse (table, m68hc11_elf_export_one_stub, info);
670
671 /* Scan the output sections to see if we use the memory banks.
672 If so, export the symbols that define how the memory banks
673 are mapped. This is used by gdb and the simulator to obtain
674 the information. It can be used by programs to burn the eprom
675 at the good addresses. */
676 param.use_memory_banks = FALSE;
677 param.pinfo = &htab->pinfo;
678 bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
679 if (param.use_memory_banks)
680 {
681 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_START_NAME,
682 htab->pinfo.bank_physical,
683 bfd_abs_section_ptr);
684 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_VIRTUAL_NAME,
685 htab->pinfo.bank_virtual,
686 bfd_abs_section_ptr);
687 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_SIZE_NAME,
688 htab->pinfo.bank_size,
689 bfd_abs_section_ptr);
690 }
691
692 return TRUE;
693}
694
695void
0a6a3ebe 696m68hc11_elf_get_bank_parameters (struct bfd_link_info *info)
3a65329d
SC		 697{
698 unsigned i;
699 struct m68hc11_page_info *pinfo;
700 struct bfd_link_hash_entry *h;
4dfe6ac6
NC		 701 struct m68hc11_elf_link_hash_table *htab;
702
703 htab = m68hc11_elf_hash_table (info);
704 if (htab == NULL)
705 return;
3a65329d 706
4dfe6ac6 707 pinfo = & htab->pinfo;
3a65329d
SC		 708 if (pinfo->bank_param_initialized)
709 return;
710
711 pinfo->bank_virtual = M68HC12_BANK_VIRT;
712 pinfo->bank_mask = M68HC12_BANK_MASK;
713 pinfo->bank_physical = M68HC12_BANK_BASE;
714 pinfo->bank_shift = M68HC12_BANK_SHIFT;
715 pinfo->bank_size = 1 << M68HC12_BANK_SHIFT;
716
717 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_START_NAME,
718 FALSE, FALSE, TRUE);
719 if (h != (struct bfd_link_hash_entry*) NULL
720 && h->type == bfd_link_hash_defined)
721 pinfo->bank_physical = (h->u.def.value
722 + h->u.def.section->output_section->vma
723 + h->u.def.section->output_offset);
724
725 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_VIRTUAL_NAME,
726 FALSE, FALSE, TRUE);
727 if (h != (struct bfd_link_hash_entry*) NULL
728 && h->type == bfd_link_hash_defined)
729 pinfo->bank_virtual = (h->u.def.value
730 + h->u.def.section->output_section->vma
731 + h->u.def.section->output_offset);
732
733 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_SIZE_NAME,
734 FALSE, FALSE, TRUE);
735 if (h != (struct bfd_link_hash_entry*) NULL
736 && h->type == bfd_link_hash_defined)
737 pinfo->bank_size = (h->u.def.value
738 + h->u.def.section->output_section->vma
739 + h->u.def.section->output_offset);
740
741 pinfo->bank_shift = 0;
742 for (i = pinfo->bank_size; i != 0; i >>= 1)
743 pinfo->bank_shift++;
744 pinfo->bank_shift--;
745 pinfo->bank_mask = (1 << pinfo->bank_shift) - 1;
746 pinfo->bank_physical_end = pinfo->bank_physical + pinfo->bank_size;
747 pinfo->bank_param_initialized = 1;
748
749 h = bfd_link_hash_lookup (info->hash, "__far_trampoline", FALSE,
750 FALSE, TRUE);
751 if (h != (struct bfd_link_hash_entry*) NULL
752 && h->type == bfd_link_hash_defined)
753 pinfo->trampoline_addr = (h->u.def.value
754 + h->u.def.section->output_section->vma
755 + h->u.def.section->output_offset);
756}
757
758/* Return 1 if the address is in banked memory.
759 This can be applied to a virtual address and to a physical address. */
760int
0a6a3ebe 761m68hc11_addr_is_banked (struct m68hc11_page_info *pinfo, bfd_vma addr)
3a65329d
SC		 762{
763 if (addr >= pinfo->bank_virtual)
764 return 1;
765
766 if (addr >= pinfo->bank_physical && addr <= pinfo->bank_physical_end)
767 return 1;
768
769 return 0;
770}
771
772/* Return the physical address seen by the processor, taking
773 into account banked memory. */
774bfd_vma
0a6a3ebe 775m68hc11_phys_addr (struct m68hc11_page_info *pinfo, bfd_vma addr)
3a65329d
SC		 776{
777 if (addr < pinfo->bank_virtual)
778 return addr;
779
780 /* Map the address to the memory bank. */
781 addr -= pinfo->bank_virtual;
782 addr &= pinfo->bank_mask;
783 addr += pinfo->bank_physical;
784 return addr;
785}
786
787/* Return the page number corresponding to an address in banked memory. */
788bfd_vma
0a6a3ebe 789m68hc11_phys_page (struct m68hc11_page_info *pinfo, bfd_vma addr)
3a65329d
SC		 790{
791 if (addr < pinfo->bank_virtual)
792 return 0;
793
794 /* Map the address to the memory bank. */
795 addr -= pinfo->bank_virtual;
796 addr >>= pinfo->bank_shift;
797 addr &= 0x0ff;
798 return addr;
799}
800
801/* This function is used for relocs which are only used for relaxing,
802 which the linker should otherwise ignore. */
803
804bfd_reloc_status_type
0a6a3ebe
SC		 805m68hc11_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED,
806 arelent *reloc_entry,
807 asymbol *symbol ATTRIBUTE_UNUSED,
808 void *data ATTRIBUTE_UNUSED,
809 asection *input_section,
810 bfd *output_bfd,
811 char **error_message ATTRIBUTE_UNUSED)
3a65329d
SC		 812{
813 if (output_bfd != NULL)
814 reloc_entry->address += input_section->output_offset;
815 return bfd_reloc_ok;
816}
817
818bfd_reloc_status_type
0a6a3ebe
SC		 819m68hc11_elf_special_reloc (bfd *abfd ATTRIBUTE_UNUSED,
820 arelent *reloc_entry,
821 asymbol *symbol,
822 void *data ATTRIBUTE_UNUSED,
823 asection *input_section,
824 bfd *output_bfd,
825 char **error_message ATTRIBUTE_UNUSED)
3a65329d
SC		 826{
827 if (output_bfd != (bfd *) NULL
828 && (symbol->flags & BSF_SECTION_SYM) == 0
829 && (! reloc_entry->howto->partial_inplace
830 || reloc_entry->addend == 0))
831 {
832 reloc_entry->address += input_section->output_offset;
833 return bfd_reloc_ok;
834 }
835
836 if (output_bfd != NULL)
837 return bfd_reloc_continue;
838
07515404 839 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
3a65329d
SC		 840 return bfd_reloc_outofrange;
841
842 abort();
843}
844
3a65329d
SC		 845/* Look through the relocs for a section during the first phase.
846 Since we don't do .gots or .plts, we just need to consider the
847 virtual table relocs for gc. */
848
849bfd_boolean
0a6a3ebe
SC		 850elf32_m68hc11_check_relocs (bfd *abfd, struct bfd_link_info *info,
851 asection *sec, const Elf_Internal_Rela *relocs)
3a65329d
SC		 852{
853 Elf_Internal_Shdr * symtab_hdr;
854 struct elf_link_hash_entry ** sym_hashes;
3a65329d
SC		 855 const Elf_Internal_Rela * rel;
856 const Elf_Internal_Rela * rel_end;
857
1049f94e 858 if (info->relocatable)
3a65329d
SC		 859 return TRUE;
860
861 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
862 sym_hashes = elf_sym_hashes (abfd);
3a65329d
SC		 863 rel_end = relocs + sec->reloc_count;
864
865 for (rel = relocs; rel < rel_end; rel++)
866 {
867 struct elf_link_hash_entry * h;
868 unsigned long r_symndx;
869
870 r_symndx = ELF32_R_SYM (rel->r_info);
871
872 if (r_symndx < symtab_hdr->sh_info)
873 h = NULL;
874 else
973a3492
L		 875 {
876 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
877 while (h->root.type == bfd_link_hash_indirect
878 || h->root.type == bfd_link_hash_warning)
879 h = (struct elf_link_hash_entry *) h->root.u.i.link;
880 }
3a65329d
SC		 881
882 switch (ELF32_R_TYPE (rel->r_info))
883 {
884 /* This relocation describes the C++ object vtable hierarchy.
885 Reconstruct it for later use during GC. */
886 case R_M68HC11_GNU_VTINHERIT:
c152c796 887 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3a65329d
SC		 888 return FALSE;
889 break;
890
891 /* This relocation describes which C++ vtable entries are actually
892 used. Record for later use during GC. */
893 case R_M68HC11_GNU_VTENTRY:
d17e0c6e
JB		 894 BFD_ASSERT (h != NULL);
895 if (h != NULL
896 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3a65329d
SC		 897 return FALSE;
898 break;
899 }
900 }
901
902 return TRUE;
903}
904
3a65329d
SC		 905/* Relocate a 68hc11/68hc12 ELF section. */
906bfd_boolean
0a6a3ebe
SC		 907elf32_m68hc11_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
908 struct bfd_link_info *info,
909 bfd *input_bfd, asection *input_section,
910 bfd_byte *contents, Elf_Internal_Rela *relocs,
911 Elf_Internal_Sym *local_syms,
912 asection **local_sections)
3a65329d
SC		 913{
914 Elf_Internal_Shdr *symtab_hdr;
915 struct elf_link_hash_entry **sym_hashes;
916 Elf_Internal_Rela *rel, *relend;
9b69b847 917 const char *name = NULL;
3a65329d 918 struct m68hc11_page_info *pinfo;
9c5bfbb7 919 const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
4dfe6ac6 920 struct m68hc11_elf_link_hash_table *htab;
3a65329d
SC		 921
922 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
923 sym_hashes = elf_sym_hashes (input_bfd);
924
4dfe6ac6
NC		 925 htab = m68hc11_elf_hash_table (info);
926 if (htab == NULL)
927 return FALSE;
928
3a65329d
SC		 929 /* Get memory bank parameters. */
930 m68hc11_elf_get_bank_parameters (info);
3a65329d 931
4dfe6ac6 932 pinfo = & htab->pinfo;
3a65329d
SC		 933 rel = relocs;
934 relend = relocs + input_section->reloc_count;
4dfe6ac6 935
3a65329d
SC		 936 for (; rel < relend; rel++)
937 {
938 int r_type;
939 arelent arel;
940 reloc_howto_type *howto;
941 unsigned long r_symndx;
942 Elf_Internal_Sym *sym;
943 asection *sec;
9b69b847 944 bfd_vma relocation = 0;
3a65329d
SC		 945 bfd_reloc_status_type r = bfd_reloc_undefined;
946 bfd_vma phys_page;
947 bfd_vma phys_addr;
948 bfd_vma insn_addr;
949 bfd_vma insn_page;
9b69b847 950 bfd_boolean is_far = FALSE;
ab96bf03 951 struct elf_link_hash_entry *h;
6927f982 952 bfd_vma val;
3a65329d
SC		 953
954 r_symndx = ELF32_R_SYM (rel->r_info);
955 r_type = ELF32_R_TYPE (rel->r_info);
956
957 if (r_type == R_M68HC11_GNU_VTENTRY
958 || r_type == R_M68HC11_GNU_VTINHERIT )
959 continue;
960
ab96bf03
AM		 961 (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel);
962 howto = arel.howto;
963
964 h = NULL;
965 sym = NULL;
966 sec = NULL;
967 if (r_symndx < symtab_hdr->sh_info)
968 {
969 sym = local_syms + r_symndx;
970 sec = local_sections[r_symndx];
971 relocation = (sec->output_section->vma
972 + sec->output_offset
973 + sym->st_value);
974 is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
ab96bf03
AM		 975 }
976 else
977 {
978 bfd_boolean unresolved_reloc, warned;
979
980 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
981 r_symndx, symtab_hdr, sym_hashes,
982 h, sec, relocation, unresolved_reloc,
983 warned);
984
985 is_far = (h && (h->other & STO_M68HC12_FAR));
ab96bf03
AM		 986 }
987
dbaa2011 988 if (sec != NULL && discarded_section (sec))
e4067dbb 989 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 990 rel, 1, relend, howto, 0, contents);
ab96bf03 991
1049f94e 992 if (info->relocatable)
3a65329d 993 {
1049f94e 994 /* This is a relocatable link. We don't have to change
3a65329d
SC		 995 anything, unless the reloc is against a section symbol,
996 in which case we have to adjust according to where the
997 section symbol winds up in the output section. */
ab96bf03
AM		 998 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
999 rel->r_addend += sec->output_offset;
3a65329d
SC		 1000 continue;
1001 }
3a65329d 1002
ab96bf03
AM		 1003 if (h != NULL)
1004 name = h->root.root.string;
1005 else
1006 {
1007 name = (bfd_elf_string_from_elf_section
1008 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1009 if (name == NULL || *name == '\0')
1010 name = bfd_section_name (input_bfd, sec);
1011 }
1012
1013 if (is_far && ELF32_R_TYPE (rel->r_info) == R_M68HC11_16)
1014 {
1015 struct elf32_m68hc11_stub_hash_entry* stub;
ab96bf03 1016
ab96bf03
AM		 1017 stub = m68hc12_stub_hash_lookup (htab->stub_hash_table,
1018 name, FALSE, FALSE);
1019 if (stub)
1020 {
1021 relocation = stub->stub_offset
1022 + stub->stub_sec->output_section->vma
1023 + stub->stub_sec->output_offset;
1024 is_far = FALSE;
1025 }
1026 }
3a65329d
SC		 1027
1028 /* Do the memory bank mapping. */
1029 phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend);
1030 phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend);
1031 switch (r_type)
1032 {
6927f982
NC		 1033 case R_M68HC12_LO8XG:
1034 /* This relocation is specific to XGATE IMM16 calls and will precede
1035 a HI8. tc-m68hc11 only generates them in pairs.
1036 Leave the relocation to the HI8XG step. */
1037 r = bfd_reloc_ok;
1038 r_type = R_M68HC11_NONE;
1039 break;
1040
1041 case R_M68HC12_HI8XG:
1042 /* This relocation is specific to XGATE IMM16 calls and must follow
1043 a LO8XG. Does not actually check that it was a LO8XG.
1044 Adjusts high and low bytes. */
1045 relocation = phys_addr;
1046 if ((elf_elfheader (input_bfd)->e_flags & E_M68HC11_XGATE_RAMOFFSET)
1047 && (relocation >= 0x2000))
1048 relocation += 0xc000; /* HARDCODED RAM offset for XGATE. */
1049
1050 /* Fetch 16 bit value including low byte in previous insn. */
1051 val = (bfd_get_8 (input_bfd, (bfd_byte*) contents + rel->r_offset) << 8)
1052 | bfd_get_8 (input_bfd, (bfd_byte*) contents + rel->r_offset - 2);
1053
1054 /* Add on value to preserve carry, then write zero to high byte. */
1055 relocation += val;
1056
1057 /* Write out top byte. */
1058 bfd_put_8 (input_bfd, (relocation >> 8) & 0xff,
1059 (bfd_byte*) contents + rel->r_offset);
1060
1061 /* Write out low byte to previous instruction. */
1062 bfd_put_8 (input_bfd, relocation & 0xff,
1063 (bfd_byte*) contents + rel->r_offset - 2);
1064
1065 /* Mark as relocation completed. */
1066 r = bfd_reloc_ok;
1067 r_type = R_M68HC11_NONE;
1068 break;
1069
1070 /* The HI8 and LO8 relocs are generated by %hi(expr) %lo(expr)
1071 assembler directives. %hi does not support carry. */
1072 case R_M68HC11_HI8:
1073 case R_M68HC11_LO8:
1074 relocation = phys_addr;
1075 break;
1076
3a65329d
SC		 1077 case R_M68HC11_24:
1078 /* Reloc used by 68HC12 call instruction. */
1079 bfd_put_16 (input_bfd, phys_addr,
1080 (bfd_byte*) contents + rel->r_offset);
1081 bfd_put_8 (input_bfd, phys_page,
1082 (bfd_byte*) contents + rel->r_offset + 2);
1083 r = bfd_reloc_ok;
1084 r_type = R_M68HC11_NONE;
1085 break;
1086
1087 case R_M68HC11_NONE:
1088 r = bfd_reloc_ok;
1089 break;
1090
1091 case R_M68HC11_LO16:
1092 /* Reloc generated by %addr(expr) gas to obtain the
1093 address as mapped in the memory bank window. */
1094 relocation = phys_addr;
1095 break;
1096
1097 case R_M68HC11_PAGE:
1098 /* Reloc generated by %page(expr) gas to obtain the
1099 page number associated with the address. */
1100 relocation = phys_page;
1101 break;
1102
1103 case R_M68HC11_16:
1104 /* Get virtual address of instruction having the relocation. */
1105 if (is_far)
1106 {
1107 const char* msg;
1108 char* buf;
1109 msg = _("Reference to the far symbol `%s' using a wrong "
1110 "relocation may result in incorrect execution");
1111 buf = alloca (strlen (msg) + strlen (name) + 10);
1112 sprintf (buf, msg, name);
1113
1114 (* info->callbacks->warning)
1115 (info, buf, name, input_bfd, NULL, rel->r_offset);
1116 }
1117
1118 /* Get virtual address of instruction having the relocation. */
1119 insn_addr = input_section->output_section->vma
1120 + input_section->output_offset
1121 + rel->r_offset;
1122
1123 insn_page = m68hc11_phys_page (pinfo, insn_addr);
1124
1125 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend)
1126 && m68hc11_addr_is_banked (pinfo, insn_addr)
1127 && phys_page != insn_page)
1128 {
1129 const char* msg;
1130 char* buf;
1131
1132 msg = _("banked address [%lx:%04lx] (%lx) is not in the same bank "
1133 "as current banked address [%lx:%04lx] (%lx)");
1134
1135 buf = alloca (strlen (msg) + 128);
1136 sprintf (buf, msg, phys_page, phys_addr,
1137 (long) (relocation + rel->r_addend),
1138 insn_page, m68hc11_phys_addr (pinfo, insn_addr),
1139 (long) (insn_addr));
1140 if (!((*info->callbacks->warning)
1141 (info, buf, name, input_bfd, input_section,
1142 rel->r_offset)))
1143 return FALSE;
1144 break;
1145 }
1146 if (phys_page != 0 && insn_page == 0)
1147 {
1148 const char* msg;
1149 char* buf;
1150
1151 msg = _("reference to a banked address [%lx:%04lx] in the "
1152 "normal address space at %04lx");
1153
1154 buf = alloca (strlen (msg) + 128);
1155 sprintf (buf, msg, phys_page, phys_addr, insn_addr);
1156 if (!((*info->callbacks->warning)
1157 (info, buf, name, input_bfd, input_section,
1158 insn_addr)))
1159 return FALSE;
1160
1161 relocation = phys_addr;
1162 break;
1163 }
1164
1165 /* If this is a banked address use the phys_addr so that
1166 we stay in the banked window. */
1167 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend))
1168 relocation = phys_addr;
1169 break;
1170 }
6927f982 1171
3a65329d 1172 if (r_type != R_M68HC11_NONE)
6927f982
NC		 1173 {
1174 if ((r_type == R_M68HC12_PCREL_9) || (r_type == R_M68HC12_PCREL_10))
1175 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3a65329d 1176 contents, rel->r_offset,
6927f982
NC		 1177 relocation - 2, rel->r_addend);
1178 else
1179 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1180 contents, rel->r_offset,
1181 relocation, rel->r_addend);
1182 }
3a65329d
SC		 1183
1184 if (r != bfd_reloc_ok)
1185 {
1186 const char * msg = (const char *) 0;
1187
1188 switch (r)
1189 {
1190 case bfd_reloc_overflow:
1191 if (!((*info->callbacks->reloc_overflow)
dfeffb9f 1192 (info, NULL, name, howto->name, (bfd_vma) 0,
3a65329d
SC		 1193 input_bfd, input_section, rel->r_offset)))
1194 return FALSE;
1195 break;
1196
1197 case bfd_reloc_undefined:
1198 if (!((*info->callbacks->undefined_symbol)
1199 (info, name, input_bfd, input_section,
1200 rel->r_offset, TRUE)))
1201 return FALSE;
1202 break;
1203
1204 case bfd_reloc_outofrange:
1205 msg = _ ("internal error: out of range error");
1206 goto common_error;
1207
1208 case bfd_reloc_notsupported:
1209 msg = _ ("internal error: unsupported relocation error");
1210 goto common_error;
1211
1212 case bfd_reloc_dangerous:
1213 msg = _ ("internal error: dangerous error");
1214 goto common_error;
1215
1216 default:
1217 msg = _ ("internal error: unknown error");
1218 /* fall through */
1219
1220 common_error:
1221 if (!((*info->callbacks->warning)
1222 (info, msg, name, input_bfd, input_section,
1223 rel->r_offset)))
1224 return FALSE;
1225 break;
1226 }
1227 }
1228 }
1229
1230 return TRUE;
1231}
1232
1233
1234\f
1235/* Set and control ELF flags in ELF header. */
1236
1237bfd_boolean
0a6a3ebe 1238_bfd_m68hc11_elf_set_private_flags (bfd *abfd, flagword flags)
3a65329d
SC		 1239{
1240 BFD_ASSERT (!elf_flags_init (abfd)
1241 || elf_elfheader (abfd)->e_flags == flags);
1242
1243 elf_elfheader (abfd)->e_flags = flags;
1244 elf_flags_init (abfd) = TRUE;
1245 return TRUE;
1246}
1247
1248/* Merge backend specific data from an object file to the output
1249 object file when linking. */
1250
1251bfd_boolean
0a6a3ebe 1252_bfd_m68hc11_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3a65329d
SC		 1253{
1254 flagword old_flags;
1255 flagword new_flags;
1256 bfd_boolean ok = TRUE;
1257
cc643b88 1258 /* Check if we have the same endianness */
3a65329d
SC		 1259 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
1260 return FALSE;
1261
1262 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1263 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1264 return TRUE;
1265
1266 new_flags = elf_elfheader (ibfd)->e_flags;
1267 elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI;
1268 old_flags = elf_elfheader (obfd)->e_flags;
1269
1270 if (! elf_flags_init (obfd))
1271 {
1272 elf_flags_init (obfd) = TRUE;
1273 elf_elfheader (obfd)->e_flags = new_flags;
1274 elf_elfheader (obfd)->e_ident[EI_CLASS]
1275 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
1276
1277 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1278 && bfd_get_arch_info (obfd)->the_default)
1279 {
1280 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1281 bfd_get_mach (ibfd)))
1282 return FALSE;
1283 }
1284
1285 return TRUE;
1286 }
1287
1288 /* Check ABI compatibility. */
1289 if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
1290 {
1291 (*_bfd_error_handler)
d003868e
AM		 1292 (_("%B: linking files compiled for 16-bit integers (-mshort) "
1293 "and others for 32-bit integers"), ibfd);
3a65329d
SC		 1294 ok = FALSE;
1295 }
1296 if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
1297 {
1298 (*_bfd_error_handler)
d003868e
AM		 1299 (_("%B: linking files compiled for 32-bit double (-fshort-double) "
1300 "and others for 64-bit double"), ibfd);
3a65329d
SC		 1301 ok = FALSE;
1302 }
47247ced
SC		 1303
1304 /* Processor compatibility. */
1305 if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
1306 {
1307 (*_bfd_error_handler)
d003868e
AM		 1308 (_("%B: linking files compiled for HCS12 with "
1309 "others compiled for HC12"), ibfd);
47247ced
SC		 1310 ok = FALSE;
1311 }
1312 new_flags = ((new_flags & ~EF_M68HC11_MACH_MASK)
1313 | (EF_M68HC11_MERGE_MACH (new_flags, old_flags)));
1314
1315 elf_elfheader (obfd)->e_flags = new_flags;
1316
17e58af0
SC		 1317 new_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1318 old_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
3a65329d
SC		 1319
1320 /* Warn about any other mismatches */
1321 if (new_flags != old_flags)
1322 {
1323 (*_bfd_error_handler)
d003868e
AM		 1324 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1325 ibfd, (unsigned long) new_flags, (unsigned long) old_flags);
3a65329d
SC		 1326 ok = FALSE;
1327 }
1328
1329 if (! ok)
1330 {
1331 bfd_set_error (bfd_error_bad_value);
1332 return FALSE;
1333 }
1334
1335 return TRUE;
1336}
1337
1338bfd_boolean
0a6a3ebe 1339_bfd_m68hc11_elf_print_private_bfd_data (bfd *abfd, void *ptr)
3a65329d
SC		 1340{
1341 FILE *file = (FILE *) ptr;
1342
1343 BFD_ASSERT (abfd != NULL && ptr != NULL);
1344
1345 /* Print normal ELF private data. */
1346 _bfd_elf_print_private_bfd_data (abfd, ptr);
1347
1348 /* xgettext:c-format */
1349 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1350
1351 if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32)
1352 fprintf (file, _("[abi=32-bit int, "));
1353 else
1354 fprintf (file, _("[abi=16-bit int, "));
1355
1356 if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64)
1357 fprintf (file, _("64-bit double, "));
1358 else
1359 fprintf (file, _("32-bit double, "));
1360
1361 if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0)
1362 fprintf (file, _("cpu=HC11]"));
1363 else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH)
1364 fprintf (file, _("cpu=HCS12]"));
1365 else
1366 fprintf (file, _("cpu=HC12]"));
1367
1368 if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)
1369 fprintf (file, _(" [memory=bank-model]"));
1370 else
1371 fprintf (file, _(" [memory=flat]"));
1372
6927f982
NC		 1373 if (elf_elfheader (abfd)->e_flags & E_M68HC11_XGATE_RAMOFFSET)
1374 fprintf (file, _(" [XGATE RAM offsetting]"));
1375
3a65329d
SC		 1376 fputc ('\n', file);
1377
1378 return TRUE;
1379}
1380
0a6a3ebe
SC		 1381static void scan_sections_for_abi (bfd *abfd ATTRIBUTE_UNUSED,
1382 asection *asect, void *arg)
3a65329d
SC		 1383{
1384 struct m68hc11_scan_param* p = (struct m68hc11_scan_param*) arg;
1385
1386 if (asect->vma >= p->pinfo->bank_virtual)
1387 p->use_memory_banks = TRUE;
1388}
1389
1390/* Tweak the OSABI field of the elf header. */
1391
1392void
0a6a3ebe 1393elf32_m68hc11_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
3a65329d
SC		 1394{
1395 struct m68hc11_scan_param param;
4dfe6ac6
NC		 1396 struct m68hc11_elf_link_hash_table *htab;
1397
1398 if (link_info == NULL)
1399 return;
3a65329d 1400
4dfe6ac6
NC		 1401 htab = m68hc11_elf_hash_table (link_info);
1402 if (htab == NULL)
3a65329d
SC		 1403 return;
1404
1405 m68hc11_elf_get_bank_parameters (link_info);
1406
1407 param.use_memory_banks = FALSE;
4dfe6ac6
NC		 1408 param.pinfo = & htab->pinfo;
1409
3a65329d 1410 bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
4dfe6ac6 1411
3a65329d
SC		 1412 if (param.use_memory_banks)
1413 {
1414 Elf_Internal_Ehdr * i_ehdrp;
1415
1416 i_ehdrp = elf_elfheader (abfd);
1417 i_ehdrp->e_flags |= E_M68HC12_BANKS;
1418 }
1419}
GDB Binutils - Deliverables
This page took 0.51851 seconds and 4 git commands to generate.