projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gas/
[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,
4dfe6ac6 3 2009, 2010 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
8d25cc3d 23#include "alloca-conf.h"
3a65329d 24#include "sysdep.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
217/* External entry points for sizing and building linker stubs. */
218
219/* Set up various things so that we can make a list of input sections
220 for each output section included in the link. Returns -1 on error,
221 0 when no stubs will be needed, and 1 on success. */
222
223int
0a6a3ebe 224elf32_m68hc11_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
3a65329d
SC		 225{
226 bfd *input_bfd;
227 unsigned int bfd_count;
228 int top_id, top_index;
229 asection *section;
230 asection **input_list, **list;
231 bfd_size_type amt;
232 asection *text_section;
233 struct m68hc11_elf_link_hash_table *htab;
234
235 htab = m68hc11_elf_hash_table (info);
4dfe6ac6
NC		 236 if (htab == NULL)
237 return -1;
3a65329d 238
f13a99db 239 if (bfd_get_flavour (info->output_bfd) != bfd_target_elf_flavour)
3a65329d
SC		 240 return 0;
241
242 /* Count the number of input BFDs and find the top input section id.
243 Also search for an existing ".tramp" section so that we know
244 where generated trampolines must go. Default to ".text" if we
245 can't find it. */
246 htab->tramp_section = 0;
247 text_section = 0;
248 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
249 input_bfd != NULL;
250 input_bfd = input_bfd->link_next)
251 {
252 bfd_count += 1;
253 for (section = input_bfd->sections;
254 section != NULL;
255 section = section->next)
256 {
257 const char* name = bfd_get_section_name (input_bfd, section);
258
259 if (!strcmp (name, ".tramp"))
260 htab->tramp_section = section;
261
262 if (!strcmp (name, ".text"))
263 text_section = section;
264
265 if (top_id < section->id)
266 top_id = section->id;
267 }
268 }
269 htab->bfd_count = bfd_count;
270 if (htab->tramp_section == 0)
271 htab->tramp_section = text_section;
272
273 /* We can't use output_bfd->section_count here to find the top output
274 section index as some sections may have been removed, and
8423293d 275 strip_excluded_output_sections doesn't renumber the indices. */
3a65329d
SC		 276 for (section = output_bfd->sections, top_index = 0;
277 section != NULL;
278 section = section->next)
279 {
280 if (top_index < section->index)
281 top_index = section->index;
282 }
283
284 htab->top_index = top_index;
285 amt = sizeof (asection *) * (top_index + 1);
286 input_list = (asection **) bfd_malloc (amt);
287 htab->input_list = input_list;
288 if (input_list == NULL)
289 return -1;
290
291 /* For sections we aren't interested in, mark their entries with a
292 value we can check later. */
293 list = input_list + top_index;
294 do
295 *list = bfd_abs_section_ptr;
296 while (list-- != input_list);
297
298 for (section = output_bfd->sections;
299 section != NULL;
300 section = section->next)
301 {
302 if ((section->flags & SEC_CODE) != 0)
303 input_list[section->index] = NULL;
304 }
305
306 return 1;
307}
308
309/* Determine and set the size of the stub section for a final link.
310
311 The basic idea here is to examine all the relocations looking for
312 PC-relative calls to a target that is unreachable with a "bl"
313 instruction. */
314
315bfd_boolean
0a6a3ebe
SC		 316elf32_m68hc11_size_stubs (bfd *output_bfd, bfd *stub_bfd,
317 struct bfd_link_info *info,
318 asection * (*add_stub_section) (const char*, asection*))
3a65329d
SC		 319{
320 bfd *input_bfd;
321 asection *section;
322 Elf_Internal_Sym *local_syms, **all_local_syms;
323 unsigned int bfd_indx, bfd_count;
324 bfd_size_type amt;
325 asection *stub_sec;
3a65329d
SC		 326 struct m68hc11_elf_link_hash_table *htab = m68hc11_elf_hash_table (info);
327
4dfe6ac6
NC		 328 if (htab == NULL)
329 return FALSE;
330
3a65329d
SC		 331 /* Stash our params away. */
332 htab->stub_bfd = stub_bfd;
333 htab->add_stub_section = add_stub_section;
334
335 /* Count the number of input BFDs and find the top input section id. */
336 for (input_bfd = info->input_bfds, bfd_count = 0;
337 input_bfd != NULL;
338 input_bfd = input_bfd->link_next)
4dfe6ac6 339 bfd_count += 1;
3a65329d
SC		 340
341 /* We want to read in symbol extension records only once. To do this
342 we need to read in the local symbols in parallel and save them for
343 later use; so hold pointers to the local symbols in an array. */
344 amt = sizeof (Elf_Internal_Sym *) * bfd_count;
345 all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
346 if (all_local_syms == NULL)
347 return FALSE;
348
349 /* Walk over all the input BFDs, swapping in local symbols. */
350 for (input_bfd = info->input_bfds, bfd_indx = 0;
351 input_bfd != NULL;
352 input_bfd = input_bfd->link_next, bfd_indx++)
353 {
354 Elf_Internal_Shdr *symtab_hdr;
3a65329d
SC		 355
356 /* We'll need the symbol table in a second. */
357 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
358 if (symtab_hdr->sh_info == 0)
359 continue;
360
2a0e29b4
SC		 361 /* We need an array of the local symbols attached to the input bfd. */
362 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
363 if (local_syms == NULL)
364 {
365 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
366 symtab_hdr->sh_info, 0,
367 NULL, NULL, NULL);
368 /* Cache them for elf_link_input_bfd. */
369 symtab_hdr->contents = (unsigned char *) local_syms;
370 }
3a65329d 371 if (local_syms == NULL)
3a65329d 372 {
2a0e29b4
SC		 373 free (all_local_syms);
374 return FALSE;
3a65329d
SC		 375 }
376
2a0e29b4 377 all_local_syms[bfd_indx] = local_syms;
3a65329d
SC		 378 }
379
380 for (input_bfd = info->input_bfds, bfd_indx = 0;
381 input_bfd != NULL;
382 input_bfd = input_bfd->link_next, bfd_indx++)
383 {
384 Elf_Internal_Shdr *symtab_hdr;
3a65329d
SC		 385 struct elf_link_hash_entry ** sym_hashes;
386
387 sym_hashes = elf_sym_hashes (input_bfd);
388
389 /* We'll need the symbol table in a second. */
390 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
391 if (symtab_hdr->sh_info == 0)
392 continue;
393
394 local_syms = all_local_syms[bfd_indx];
395
396 /* Walk over each section attached to the input bfd. */
397 for (section = input_bfd->sections;
398 section != NULL;
399 section = section->next)
400 {
401 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
402
403 /* If there aren't any relocs, then there's nothing more
404 to do. */
405 if ((section->flags & SEC_RELOC) == 0
406 || section->reloc_count == 0)
407 continue;
408
409 /* If this section is a link-once section that will be
410 discarded, then don't create any stubs. */
411 if (section->output_section == NULL
412 || section->output_section->owner != output_bfd)
413 continue;
414
415 /* Get the relocs. */
416 internal_relocs
45d6a902
AM		 417 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
418 (Elf_Internal_Rela *) NULL,
419 info->keep_memory);
3a65329d
SC		 420 if (internal_relocs == NULL)
421 goto error_ret_free_local;
422
423 /* Now examine each relocation. */
424 irela = internal_relocs;
425 irelaend = irela + section->reloc_count;
426 for (; irela < irelaend; irela++)
427 {
428 unsigned int r_type, r_indx;
429 struct elf32_m68hc11_stub_hash_entry *stub_entry;
430 asection *sym_sec;
431 bfd_vma sym_value;
432 struct elf_link_hash_entry *hash;
433 const char *stub_name;
434 Elf_Internal_Sym *sym;
435
436 r_type = ELF32_R_TYPE (irela->r_info);
437
438 /* Only look at 16-bit relocs. */
439 if (r_type != (unsigned int) R_M68HC11_16)
440 continue;
441
442 /* Now determine the call target, its name, value,
443 section. */
444 r_indx = ELF32_R_SYM (irela->r_info);
445 if (r_indx < symtab_hdr->sh_info)
446 {
447 /* It's a local symbol. */
448 Elf_Internal_Shdr *hdr;
449 bfd_boolean is_far;
450
451 sym = local_syms + r_indx;
3a65329d
SC		 452 is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
453 if (!is_far)
454 continue;
7f888330 455
4fbb74a6
AM		 456 if (sym->st_shndx >= elf_numsections (input_bfd))
457 sym_sec = NULL;
458 else
459 {
460 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
461 sym_sec = hdr->bfd_section;
462 }
3a65329d
SC		 463 stub_name = (bfd_elf_string_from_elf_section
464 (input_bfd, symtab_hdr->sh_link,
465 sym->st_name));
466 sym_value = sym->st_value;
467 hash = NULL;
468 }
469 else
470 {
471 /* It's an external symbol. */
472 int e_indx;
473
474 e_indx = r_indx - symtab_hdr->sh_info;
475 hash = (struct elf_link_hash_entry *)
476 (sym_hashes[e_indx]);
477
478 while (hash->root.type == bfd_link_hash_indirect
479 || hash->root.type == bfd_link_hash_warning)
480 hash = ((struct elf_link_hash_entry *)
481 hash->root.u.i.link);
482
483 if (hash->root.type == bfd_link_hash_defined
83774818
SC		 484 || hash->root.type == bfd_link_hash_defweak
485 || hash->root.type == bfd_link_hash_new)
3a65329d
SC		 486 {
487 if (!(hash->other & STO_M68HC12_FAR))
488 continue;
489 }
490 else if (hash->root.type == bfd_link_hash_undefweak)
491 {
492 continue;
493 }
494 else if (hash->root.type == bfd_link_hash_undefined)
495 {
496 continue;
497 }
498 else
499 {
500 bfd_set_error (bfd_error_bad_value);
501 goto error_ret_free_internal;
502 }
503 sym_sec = hash->root.u.def.section;
504 sym_value = hash->root.u.def.value;
505 stub_name = hash->root.root.string;
506 }
507
508 if (!stub_name)
509 goto error_ret_free_internal;
510
511 stub_entry = m68hc12_stub_hash_lookup
512 (htab->stub_hash_table,
513 stub_name,
514 FALSE, FALSE);
515 if (stub_entry == NULL)
516 {
517 if (add_stub_section == 0)
518 continue;
519
520 stub_entry = m68hc12_add_stub (stub_name, section, htab);
521 if (stub_entry == NULL)
522 {
523 error_ret_free_internal:
524 if (elf_section_data (section)->relocs == NULL)
525 free (internal_relocs);
526 goto error_ret_free_local;
527 }
528 }
529
530 stub_entry->target_value = sym_value;
531 stub_entry->target_section = sym_sec;
532 }
533
534 /* We're done with the internal relocs, free them. */
535 if (elf_section_data (section)->relocs == NULL)
536 free (internal_relocs);
537 }
538 }
539
540 if (add_stub_section)
541 {
542 /* OK, we've added some stubs. Find out the new size of the
543 stub sections. */
544 for (stub_sec = htab->stub_bfd->sections;
545 stub_sec != NULL;
546 stub_sec = stub_sec->next)
547 {
eea6121a 548 stub_sec->size = 0;
3a65329d
SC		 549 }
550
551 bfd_hash_traverse (htab->stub_hash_table, htab->size_one_stub, htab);
552 }
2a0e29b4 553 free (all_local_syms);
3a65329d
SC		 554 return TRUE;
555
556 error_ret_free_local:
2a0e29b4 557 free (all_local_syms);
3a65329d
SC		 558 return FALSE;
559}
560
561/* Export the trampoline addresses in the symbol table. */
562static bfd_boolean
0a6a3ebe 563m68hc11_elf_export_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
3a65329d
SC		 564{
565 struct bfd_link_info *info;
566 struct m68hc11_elf_link_hash_table *htab;
567 struct elf32_m68hc11_stub_hash_entry *stub_entry;
568 char* name;
569 bfd_boolean result;
570
571 info = (struct bfd_link_info *) in_arg;
572 htab = m68hc11_elf_hash_table (info);
4dfe6ac6
NC		 573 if (htab == NULL)
574 return FALSE;
3a65329d
SC		 575
576 /* Massage our args to the form they really have. */
577 stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry;
578
579 /* Generate the trampoline according to HC11 or HC12. */
580 result = (* htab->build_one_stub) (gen_entry, in_arg);
581
582 /* Make a printable name that does not conflict with the real function. */
583 name = alloca (strlen (stub_entry->root.string) + 16);
584 sprintf (name, "tramp.%s", stub_entry->root.string);
585
586 /* Export the symbol for debugging/disassembling. */
587 m68hc11_elf_set_symbol (htab->stub_bfd, info, name,
588 stub_entry->stub_offset,
589 stub_entry->stub_sec);
590 return result;
591}
592
593/* Export a symbol or set its value and section. */
594static void
0a6a3ebe
SC		 595m68hc11_elf_set_symbol (bfd *abfd, struct bfd_link_info *info,
596 const char *name, bfd_vma value, asection *sec)
3a65329d
SC		 597{
598 struct elf_link_hash_entry *h;
599
600 h = (struct elf_link_hash_entry *)
601 bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
602 if (h == NULL)
603 {
604 _bfd_generic_link_add_one_symbol (info, abfd,
605 name,
606 BSF_GLOBAL,
607 sec,
608 value,
609 (const char*) NULL,
610 TRUE, FALSE, NULL);
611 }
612 else
613 {
614 h->root.type = bfd_link_hash_defined;
615 h->root.u.def.value = value;
616 h->root.u.def.section = sec;
617 }
618}
619
620
621/* Build all the stubs associated with the current output file. The
622 stubs are kept in a hash table attached to the main linker hash
623 table. This function is called via m68hc12elf_finish in the
624 linker. */
625
626bfd_boolean
0a6a3ebe 627elf32_m68hc11_build_stubs (bfd *abfd, struct bfd_link_info *info)
3a65329d
SC		 628{
629 asection *stub_sec;
630 struct bfd_hash_table *table;
631 struct m68hc11_elf_link_hash_table *htab;
632 struct m68hc11_scan_param param;
633
634 m68hc11_elf_get_bank_parameters (info);
635 htab = m68hc11_elf_hash_table (info);
4dfe6ac6
NC		 636 if (htab == NULL)
637 return FALSE;
3a65329d
SC		 638
639 for (stub_sec = htab->stub_bfd->sections;
640 stub_sec != NULL;
641 stub_sec = stub_sec->next)
642 {
643 bfd_size_type size;
644
645 /* Allocate memory to hold the linker stubs. */
eea6121a 646 size = stub_sec->size;
3a65329d
SC		 647 stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
648 if (stub_sec->contents == NULL && size != 0)
649 return FALSE;
eea6121a 650 stub_sec->size = 0;
3a65329d
SC		 651 }
652
653 /* Build the stubs as directed by the stub hash table. */
654 table = htab->stub_hash_table;
655 bfd_hash_traverse (table, m68hc11_elf_export_one_stub, info);
656
657 /* Scan the output sections to see if we use the memory banks.
658 If so, export the symbols that define how the memory banks
659 are mapped. This is used by gdb and the simulator to obtain
660 the information. It can be used by programs to burn the eprom
661 at the good addresses. */
662 param.use_memory_banks = FALSE;
663 param.pinfo = &htab->pinfo;
664 bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
665 if (param.use_memory_banks)
666 {
667 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_START_NAME,
668 htab->pinfo.bank_physical,
669 bfd_abs_section_ptr);
670 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_VIRTUAL_NAME,
671 htab->pinfo.bank_virtual,
672 bfd_abs_section_ptr);
673 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_SIZE_NAME,
674 htab->pinfo.bank_size,
675 bfd_abs_section_ptr);
676 }
677
678 return TRUE;
679}
680
681void
0a6a3ebe 682m68hc11_elf_get_bank_parameters (struct bfd_link_info *info)
3a65329d
SC		 683{
684 unsigned i;
685 struct m68hc11_page_info *pinfo;
686 struct bfd_link_hash_entry *h;
4dfe6ac6
NC		 687 struct m68hc11_elf_link_hash_table *htab;
688
689 htab = m68hc11_elf_hash_table (info);
690 if (htab == NULL)
691 return;
3a65329d 692
4dfe6ac6 693 pinfo = & htab->pinfo;
3a65329d
SC		 694 if (pinfo->bank_param_initialized)
695 return;
696
697 pinfo->bank_virtual = M68HC12_BANK_VIRT;
698 pinfo->bank_mask = M68HC12_BANK_MASK;
699 pinfo->bank_physical = M68HC12_BANK_BASE;
700 pinfo->bank_shift = M68HC12_BANK_SHIFT;
701 pinfo->bank_size = 1 << M68HC12_BANK_SHIFT;
702
703 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_START_NAME,
704 FALSE, FALSE, TRUE);
705 if (h != (struct bfd_link_hash_entry*) NULL
706 && h->type == bfd_link_hash_defined)
707 pinfo->bank_physical = (h->u.def.value
708 + h->u.def.section->output_section->vma
709 + h->u.def.section->output_offset);
710
711 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_VIRTUAL_NAME,
712 FALSE, FALSE, TRUE);
713 if (h != (struct bfd_link_hash_entry*) NULL
714 && h->type == bfd_link_hash_defined)
715 pinfo->bank_virtual = (h->u.def.value
716 + h->u.def.section->output_section->vma
717 + h->u.def.section->output_offset);
718
719 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_SIZE_NAME,
720 FALSE, FALSE, TRUE);
721 if (h != (struct bfd_link_hash_entry*) NULL
722 && h->type == bfd_link_hash_defined)
723 pinfo->bank_size = (h->u.def.value
724 + h->u.def.section->output_section->vma
725 + h->u.def.section->output_offset);
726
727 pinfo->bank_shift = 0;
728 for (i = pinfo->bank_size; i != 0; i >>= 1)
729 pinfo->bank_shift++;
730 pinfo->bank_shift--;
731 pinfo->bank_mask = (1 << pinfo->bank_shift) - 1;
732 pinfo->bank_physical_end = pinfo->bank_physical + pinfo->bank_size;
733 pinfo->bank_param_initialized = 1;
734
735 h = bfd_link_hash_lookup (info->hash, "__far_trampoline", FALSE,
736 FALSE, TRUE);
737 if (h != (struct bfd_link_hash_entry*) NULL
738 && h->type == bfd_link_hash_defined)
739 pinfo->trampoline_addr = (h->u.def.value
740 + h->u.def.section->output_section->vma
741 + h->u.def.section->output_offset);
742}
743
744/* Return 1 if the address is in banked memory.
745 This can be applied to a virtual address and to a physical address. */
746int
0a6a3ebe 747m68hc11_addr_is_banked (struct m68hc11_page_info *pinfo, bfd_vma addr)
3a65329d
SC		 748{
749 if (addr >= pinfo->bank_virtual)
750 return 1;
751
752 if (addr >= pinfo->bank_physical && addr <= pinfo->bank_physical_end)
753 return 1;
754
755 return 0;
756}
757
758/* Return the physical address seen by the processor, taking
759 into account banked memory. */
760bfd_vma
0a6a3ebe 761m68hc11_phys_addr (struct m68hc11_page_info *pinfo, bfd_vma addr)
3a65329d
SC		 762{
763 if (addr < pinfo->bank_virtual)
764 return addr;
765
766 /* Map the address to the memory bank. */
767 addr -= pinfo->bank_virtual;
768 addr &= pinfo->bank_mask;
769 addr += pinfo->bank_physical;
770 return addr;
771}
772
773/* Return the page number corresponding to an address in banked memory. */
774bfd_vma
0a6a3ebe 775m68hc11_phys_page (struct m68hc11_page_info *pinfo, bfd_vma addr)
3a65329d
SC		 776{
777 if (addr < pinfo->bank_virtual)
778 return 0;
779
780 /* Map the address to the memory bank. */
781 addr -= pinfo->bank_virtual;
782 addr >>= pinfo->bank_shift;
783 addr &= 0x0ff;
784 return addr;
785}
786
787/* This function is used for relocs which are only used for relaxing,
788 which the linker should otherwise ignore. */
789
790bfd_reloc_status_type
0a6a3ebe
SC		 791m68hc11_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED,
792 arelent *reloc_entry,
793 asymbol *symbol ATTRIBUTE_UNUSED,
794 void *data ATTRIBUTE_UNUSED,
795 asection *input_section,
796 bfd *output_bfd,
797 char **error_message ATTRIBUTE_UNUSED)
3a65329d
SC		 798{
799 if (output_bfd != NULL)
800 reloc_entry->address += input_section->output_offset;
801 return bfd_reloc_ok;
802}
803
804bfd_reloc_status_type
0a6a3ebe
SC		 805m68hc11_elf_special_reloc (bfd *abfd ATTRIBUTE_UNUSED,
806 arelent *reloc_entry,
807 asymbol *symbol,
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 != (bfd *) NULL
814 && (symbol->flags & BSF_SECTION_SYM) == 0
815 && (! reloc_entry->howto->partial_inplace
816 || reloc_entry->addend == 0))
817 {
818 reloc_entry->address += input_section->output_offset;
819 return bfd_reloc_ok;
820 }
821
822 if (output_bfd != NULL)
823 return bfd_reloc_continue;
824
07515404 825 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
3a65329d
SC		 826 return bfd_reloc_outofrange;
827
828 abort();
829}
830
3a65329d
SC		 831/* Look through the relocs for a section during the first phase.
832 Since we don't do .gots or .plts, we just need to consider the
833 virtual table relocs for gc. */
834
835bfd_boolean
0a6a3ebe
SC		 836elf32_m68hc11_check_relocs (bfd *abfd, struct bfd_link_info *info,
837 asection *sec, const Elf_Internal_Rela *relocs)
3a65329d
SC		 838{
839 Elf_Internal_Shdr * symtab_hdr;
840 struct elf_link_hash_entry ** sym_hashes;
3a65329d
SC		 841 const Elf_Internal_Rela * rel;
842 const Elf_Internal_Rela * rel_end;
843
1049f94e 844 if (info->relocatable)
3a65329d
SC		 845 return TRUE;
846
847 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
848 sym_hashes = elf_sym_hashes (abfd);
3a65329d
SC		 849 rel_end = relocs + sec->reloc_count;
850
851 for (rel = relocs; rel < rel_end; rel++)
852 {
853 struct elf_link_hash_entry * h;
854 unsigned long r_symndx;
855
856 r_symndx = ELF32_R_SYM (rel->r_info);
857
858 if (r_symndx < symtab_hdr->sh_info)
859 h = NULL;
860 else
973a3492
L		 861 {
862 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
863 while (h->root.type == bfd_link_hash_indirect
864 || h->root.type == bfd_link_hash_warning)
865 h = (struct elf_link_hash_entry *) h->root.u.i.link;
866 }
3a65329d
SC		 867
868 switch (ELF32_R_TYPE (rel->r_info))
869 {
870 /* This relocation describes the C++ object vtable hierarchy.
871 Reconstruct it for later use during GC. */
872 case R_M68HC11_GNU_VTINHERIT:
c152c796 873 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3a65329d
SC		 874 return FALSE;
875 break;
876
877 /* This relocation describes which C++ vtable entries are actually
878 used. Record for later use during GC. */
879 case R_M68HC11_GNU_VTENTRY:
d17e0c6e
JB		 880 BFD_ASSERT (h != NULL);
881 if (h != NULL
882 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3a65329d
SC		 883 return FALSE;
884 break;
885 }
886 }
887
888 return TRUE;
889}
890
3a65329d
SC		 891/* Relocate a 68hc11/68hc12 ELF section. */
892bfd_boolean
0a6a3ebe
SC		 893elf32_m68hc11_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
894 struct bfd_link_info *info,
895 bfd *input_bfd, asection *input_section,
896 bfd_byte *contents, Elf_Internal_Rela *relocs,
897 Elf_Internal_Sym *local_syms,
898 asection **local_sections)
3a65329d
SC		 899{
900 Elf_Internal_Shdr *symtab_hdr;
901 struct elf_link_hash_entry **sym_hashes;
902 Elf_Internal_Rela *rel, *relend;
9b69b847 903 const char *name = NULL;
3a65329d 904 struct m68hc11_page_info *pinfo;
9c5bfbb7 905 const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
4dfe6ac6 906 struct m68hc11_elf_link_hash_table *htab;
3a65329d
SC		 907
908 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
909 sym_hashes = elf_sym_hashes (input_bfd);
910
4dfe6ac6
NC		 911 htab = m68hc11_elf_hash_table (info);
912 if (htab == NULL)
913 return FALSE;
914
3a65329d
SC		 915 /* Get memory bank parameters. */
916 m68hc11_elf_get_bank_parameters (info);
3a65329d 917
4dfe6ac6 918 pinfo = & htab->pinfo;
3a65329d
SC		 919 rel = relocs;
920 relend = relocs + input_section->reloc_count;
4dfe6ac6 921
3a65329d
SC		 922 for (; rel < relend; rel++)
923 {
924 int r_type;
925 arelent arel;
926 reloc_howto_type *howto;
927 unsigned long r_symndx;
928 Elf_Internal_Sym *sym;
929 asection *sec;
9b69b847 930 bfd_vma relocation = 0;
3a65329d
SC		 931 bfd_reloc_status_type r = bfd_reloc_undefined;
932 bfd_vma phys_page;
933 bfd_vma phys_addr;
934 bfd_vma insn_addr;
935 bfd_vma insn_page;
9b69b847 936 bfd_boolean is_far = FALSE;
ab96bf03 937 struct elf_link_hash_entry *h;
3a65329d
SC		 938
939 r_symndx = ELF32_R_SYM (rel->r_info);
940 r_type = ELF32_R_TYPE (rel->r_info);
941
942 if (r_type == R_M68HC11_GNU_VTENTRY
943 || r_type == R_M68HC11_GNU_VTINHERIT )
944 continue;
945
ab96bf03
AM		 946 (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel);
947 howto = arel.howto;
948
949 h = NULL;
950 sym = NULL;
951 sec = NULL;
952 if (r_symndx < symtab_hdr->sh_info)
953 {
954 sym = local_syms + r_symndx;
955 sec = local_sections[r_symndx];
956 relocation = (sec->output_section->vma
957 + sec->output_offset
958 + sym->st_value);
959 is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
ab96bf03
AM		 960 }
961 else
962 {
963 bfd_boolean unresolved_reloc, warned;
964
965 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
966 r_symndx, symtab_hdr, sym_hashes,
967 h, sec, relocation, unresolved_reloc,
968 warned);
969
970 is_far = (h && (h->other & STO_M68HC12_FAR));
ab96bf03
AM		 971 }
972
973 if (sec != NULL && elf_discarded_section (sec))
e4067dbb
DJ		 974 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
975 rel, relend, howto, contents);
ab96bf03 976
1049f94e 977 if (info->relocatable)
3a65329d 978 {
1049f94e 979 /* This is a relocatable link. We don't have to change
3a65329d
SC		 980 anything, unless the reloc is against a section symbol,
981 in which case we have to adjust according to where the
982 section symbol winds up in the output section. */
ab96bf03
AM		 983 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
984 rel->r_addend += sec->output_offset;
3a65329d
SC		 985 continue;
986 }
3a65329d 987
ab96bf03
AM		 988 if (h != NULL)
989 name = h->root.root.string;
990 else
991 {
992 name = (bfd_elf_string_from_elf_section
993 (input_bfd, symtab_hdr->sh_link, sym->st_name));
994 if (name == NULL || *name == '\0')
995 name = bfd_section_name (input_bfd, sec);
996 }
997
998 if (is_far && ELF32_R_TYPE (rel->r_info) == R_M68HC11_16)
999 {
1000 struct elf32_m68hc11_stub_hash_entry* stub;
ab96bf03 1001
ab96bf03
AM		 1002 stub = m68hc12_stub_hash_lookup (htab->stub_hash_table,
1003 name, FALSE, FALSE);
1004 if (stub)
1005 {
1006 relocation = stub->stub_offset
1007 + stub->stub_sec->output_section->vma
1008 + stub->stub_sec->output_offset;
1009 is_far = FALSE;
1010 }
1011 }
3a65329d
SC		 1012
1013 /* Do the memory bank mapping. */
1014 phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend);
1015 phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend);
1016 switch (r_type)
1017 {
1018 case R_M68HC11_24:
1019 /* Reloc used by 68HC12 call instruction. */
1020 bfd_put_16 (input_bfd, phys_addr,
1021 (bfd_byte*) contents + rel->r_offset);
1022 bfd_put_8 (input_bfd, phys_page,
1023 (bfd_byte*) contents + rel->r_offset + 2);
1024 r = bfd_reloc_ok;
1025 r_type = R_M68HC11_NONE;
1026 break;
1027
1028 case R_M68HC11_NONE:
1029 r = bfd_reloc_ok;
1030 break;
1031
1032 case R_M68HC11_LO16:
1033 /* Reloc generated by %addr(expr) gas to obtain the
1034 address as mapped in the memory bank window. */
1035 relocation = phys_addr;
1036 break;
1037
1038 case R_M68HC11_PAGE:
1039 /* Reloc generated by %page(expr) gas to obtain the
1040 page number associated with the address. */
1041 relocation = phys_page;
1042 break;
1043
1044 case R_M68HC11_16:
1045 /* Get virtual address of instruction having the relocation. */
1046 if (is_far)
1047 {
1048 const char* msg;
1049 char* buf;
1050 msg = _("Reference to the far symbol `%s' using a wrong "
1051 "relocation may result in incorrect execution");
1052 buf = alloca (strlen (msg) + strlen (name) + 10);
1053 sprintf (buf, msg, name);
1054
1055 (* info->callbacks->warning)
1056 (info, buf, name, input_bfd, NULL, rel->r_offset);
1057 }
1058
1059 /* Get virtual address of instruction having the relocation. */
1060 insn_addr = input_section->output_section->vma
1061 + input_section->output_offset
1062 + rel->r_offset;
1063
1064 insn_page = m68hc11_phys_page (pinfo, insn_addr);
1065
1066 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend)
1067 && m68hc11_addr_is_banked (pinfo, insn_addr)
1068 && phys_page != insn_page)
1069 {
1070 const char* msg;
1071 char* buf;
1072
1073 msg = _("banked address [%lx:%04lx] (%lx) is not in the same bank "
1074 "as current banked address [%lx:%04lx] (%lx)");
1075
1076 buf = alloca (strlen (msg) + 128);
1077 sprintf (buf, msg, phys_page, phys_addr,
1078 (long) (relocation + rel->r_addend),
1079 insn_page, m68hc11_phys_addr (pinfo, insn_addr),
1080 (long) (insn_addr));
1081 if (!((*info->callbacks->warning)
1082 (info, buf, name, input_bfd, input_section,
1083 rel->r_offset)))
1084 return FALSE;
1085 break;
1086 }
1087 if (phys_page != 0 && insn_page == 0)
1088 {
1089 const char* msg;
1090 char* buf;
1091
1092 msg = _("reference to a banked address [%lx:%04lx] in the "
1093 "normal address space at %04lx");
1094
1095 buf = alloca (strlen (msg) + 128);
1096 sprintf (buf, msg, phys_page, phys_addr, insn_addr);
1097 if (!((*info->callbacks->warning)
1098 (info, buf, name, input_bfd, input_section,
1099 insn_addr)))
1100 return FALSE;
1101
1102 relocation = phys_addr;
1103 break;
1104 }
1105
1106 /* If this is a banked address use the phys_addr so that
1107 we stay in the banked window. */
1108 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend))
1109 relocation = phys_addr;
1110 break;
1111 }
1112 if (r_type != R_M68HC11_NONE)
1113 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1114 contents, rel->r_offset,
1115 relocation, rel->r_addend);
1116
1117 if (r != bfd_reloc_ok)
1118 {
1119 const char * msg = (const char *) 0;
1120
1121 switch (r)
1122 {
1123 case bfd_reloc_overflow:
1124 if (!((*info->callbacks->reloc_overflow)
dfeffb9f 1125 (info, NULL, name, howto->name, (bfd_vma) 0,
3a65329d
SC		 1126 input_bfd, input_section, rel->r_offset)))
1127 return FALSE;
1128 break;
1129
1130 case bfd_reloc_undefined:
1131 if (!((*info->callbacks->undefined_symbol)
1132 (info, name, input_bfd, input_section,
1133 rel->r_offset, TRUE)))
1134 return FALSE;
1135 break;
1136
1137 case bfd_reloc_outofrange:
1138 msg = _ ("internal error: out of range error");
1139 goto common_error;
1140
1141 case bfd_reloc_notsupported:
1142 msg = _ ("internal error: unsupported relocation error");
1143 goto common_error;
1144
1145 case bfd_reloc_dangerous:
1146 msg = _ ("internal error: dangerous error");
1147 goto common_error;
1148
1149 default:
1150 msg = _ ("internal error: unknown error");
1151 /* fall through */
1152
1153 common_error:
1154 if (!((*info->callbacks->warning)
1155 (info, msg, name, input_bfd, input_section,
1156 rel->r_offset)))
1157 return FALSE;
1158 break;
1159 }
1160 }
1161 }
1162
1163 return TRUE;
1164}
1165
1166
1167\f
1168/* Set and control ELF flags in ELF header. */
1169
1170bfd_boolean
0a6a3ebe 1171_bfd_m68hc11_elf_set_private_flags (bfd *abfd, flagword flags)
3a65329d
SC		 1172{
1173 BFD_ASSERT (!elf_flags_init (abfd)
1174 || elf_elfheader (abfd)->e_flags == flags);
1175
1176 elf_elfheader (abfd)->e_flags = flags;
1177 elf_flags_init (abfd) = TRUE;
1178 return TRUE;
1179}
1180
1181/* Merge backend specific data from an object file to the output
1182 object file when linking. */
1183
1184bfd_boolean
0a6a3ebe 1185_bfd_m68hc11_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3a65329d
SC		 1186{
1187 flagword old_flags;
1188 flagword new_flags;
1189 bfd_boolean ok = TRUE;
1190
1191 /* Check if we have the same endianess */
1192 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
1193 return FALSE;
1194
1195 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1196 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1197 return TRUE;
1198
1199 new_flags = elf_elfheader (ibfd)->e_flags;
1200 elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI;
1201 old_flags = elf_elfheader (obfd)->e_flags;
1202
1203 if (! elf_flags_init (obfd))
1204 {
1205 elf_flags_init (obfd) = TRUE;
1206 elf_elfheader (obfd)->e_flags = new_flags;
1207 elf_elfheader (obfd)->e_ident[EI_CLASS]
1208 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
1209
1210 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1211 && bfd_get_arch_info (obfd)->the_default)
1212 {
1213 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1214 bfd_get_mach (ibfd)))
1215 return FALSE;
1216 }
1217
1218 return TRUE;
1219 }
1220
1221 /* Check ABI compatibility. */
1222 if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
1223 {
1224 (*_bfd_error_handler)
d003868e
AM		 1225 (_("%B: linking files compiled for 16-bit integers (-mshort) "
1226 "and others for 32-bit integers"), ibfd);
3a65329d
SC		 1227 ok = FALSE;
1228 }
1229 if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
1230 {
1231 (*_bfd_error_handler)
d003868e
AM		 1232 (_("%B: linking files compiled for 32-bit double (-fshort-double) "
1233 "and others for 64-bit double"), ibfd);
3a65329d
SC		 1234 ok = FALSE;
1235 }
47247ced
SC		 1236
1237 /* Processor compatibility. */
1238 if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
1239 {
1240 (*_bfd_error_handler)
d003868e
AM		 1241 (_("%B: linking files compiled for HCS12 with "
1242 "others compiled for HC12"), ibfd);
47247ced
SC		 1243 ok = FALSE;
1244 }
1245 new_flags = ((new_flags & ~EF_M68HC11_MACH_MASK)
1246 | (EF_M68HC11_MERGE_MACH (new_flags, old_flags)));
1247
1248 elf_elfheader (obfd)->e_flags = new_flags;
1249
17e58af0
SC		 1250 new_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1251 old_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
3a65329d
SC		 1252
1253 /* Warn about any other mismatches */
1254 if (new_flags != old_flags)
1255 {
1256 (*_bfd_error_handler)
d003868e
AM		 1257 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1258 ibfd, (unsigned long) new_flags, (unsigned long) old_flags);
3a65329d
SC		 1259 ok = FALSE;
1260 }
1261
1262 if (! ok)
1263 {
1264 bfd_set_error (bfd_error_bad_value);
1265 return FALSE;
1266 }
1267
1268 return TRUE;
1269}
1270
1271bfd_boolean
0a6a3ebe 1272_bfd_m68hc11_elf_print_private_bfd_data (bfd *abfd, void *ptr)
3a65329d
SC		 1273{
1274 FILE *file = (FILE *) ptr;
1275
1276 BFD_ASSERT (abfd != NULL && ptr != NULL);
1277
1278 /* Print normal ELF private data. */
1279 _bfd_elf_print_private_bfd_data (abfd, ptr);
1280
1281 /* xgettext:c-format */
1282 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1283
1284 if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32)
1285 fprintf (file, _("[abi=32-bit int, "));
1286 else
1287 fprintf (file, _("[abi=16-bit int, "));
1288
1289 if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64)
1290 fprintf (file, _("64-bit double, "));
1291 else
1292 fprintf (file, _("32-bit double, "));
1293
1294 if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0)
1295 fprintf (file, _("cpu=HC11]"));
1296 else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH)
1297 fprintf (file, _("cpu=HCS12]"));
1298 else
1299 fprintf (file, _("cpu=HC12]"));
1300
1301 if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)
1302 fprintf (file, _(" [memory=bank-model]"));
1303 else
1304 fprintf (file, _(" [memory=flat]"));
1305
1306 fputc ('\n', file);
1307
1308 return TRUE;
1309}
1310
0a6a3ebe
SC		 1311static void scan_sections_for_abi (bfd *abfd ATTRIBUTE_UNUSED,
1312 asection *asect, void *arg)
3a65329d
SC		 1313{
1314 struct m68hc11_scan_param* p = (struct m68hc11_scan_param*) arg;
1315
1316 if (asect->vma >= p->pinfo->bank_virtual)
1317 p->use_memory_banks = TRUE;
1318}
1319
1320/* Tweak the OSABI field of the elf header. */
1321
1322void
0a6a3ebe 1323elf32_m68hc11_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
3a65329d
SC		 1324{
1325 struct m68hc11_scan_param param;
4dfe6ac6
NC		 1326 struct m68hc11_elf_link_hash_table *htab;
1327
1328 if (link_info == NULL)
1329 return;
3a65329d 1330
4dfe6ac6
NC		 1331 htab = m68hc11_elf_hash_table (link_info);
1332 if (htab == NULL)
3a65329d
SC		 1333 return;
1334
1335 m68hc11_elf_get_bank_parameters (link_info);
1336
1337 param.use_memory_banks = FALSE;
4dfe6ac6
NC		 1338 param.pinfo = & htab->pinfo;
1339
3a65329d 1340 bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
4dfe6ac6 1341
3a65329d
SC		 1342 if (param.use_memory_banks)
1343 {
1344 Elf_Internal_Ehdr * i_ehdrp;
1345
1346 i_ehdrp = elf_elfheader (abfd);
1347 i_ehdrp->e_flags |= E_M68HC12_BANKS;
1348 }
1349}
GDB Binutils - Deliverables
This page took 0.742179 seconds and 4 git commands to generate.