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