]> Git Repo - binutils.git/blame - bfd/elf32-m68hc1x.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2005-06-20 H.J. Lu <[email protected]>
[binutils.git] / bfd / elf32-m68hc1x.c
CommitLineData
3a65329d 1/* Motorola 68HC11/HC12-specific support for 32-bit ELF
9553c638 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
b2a8e766 3 Free Software Foundation, Inc.
3a65329d
SC		 4 Contributed by Stephane Carrez ([email protected])
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
3e110533 20Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
3a65329d
SC		 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 {
d003868e
AM		 161 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
162 section->owner, stub_name);
3a65329d
SC		 163 return NULL;
164 }
165
166 if (htab->stub_section == 0)
167 {
168 htab->stub_section = (*htab->add_stub_section) (".tramp",
169 htab->tramp_section);
170 }
171
172 stub_entry->stub_sec = htab->stub_section;
173 stub_entry->stub_offset = 0;
174 return stub_entry;
175}
176
177/* Hook called by the linker routine which adds symbols from an object
178 file. We use it for identify far symbols and force a loading of
179 the trampoline handler. */
180
181bfd_boolean
0a6a3ebe 182elf32_m68hc11_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
555cd476 183 Elf_Internal_Sym *sym,
0a6a3ebe
SC		 184 const char **namep ATTRIBUTE_UNUSED,
185 flagword *flagsp ATTRIBUTE_UNUSED,
186 asection **secp ATTRIBUTE_UNUSED,
187 bfd_vma *valp ATTRIBUTE_UNUSED)
3a65329d
SC		 188{
189 if (sym->st_other & STO_M68HC12_FAR)
190 {
191 struct elf_link_hash_entry *h;
192
193 h = (struct elf_link_hash_entry *)
194 bfd_link_hash_lookup (info->hash, "__far_trampoline",
195 FALSE, FALSE, FALSE);
196 if (h == NULL)
197 {
198 struct bfd_link_hash_entry* entry = NULL;
199
200 _bfd_generic_link_add_one_symbol (info, abfd,
201 "__far_trampoline",
202 BSF_GLOBAL,
203 bfd_und_section_ptr,
204 (bfd_vma) 0, (const char*) NULL,
205 FALSE, FALSE, &entry);
206 }
207
208 }
209 return TRUE;
210}
211
212/* External entry points for sizing and building linker stubs. */
213
214/* Set up various things so that we can make a list of input sections
215 for each output section included in the link. Returns -1 on error,
216 0 when no stubs will be needed, and 1 on success. */
217
218int
0a6a3ebe 219elf32_m68hc11_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
3a65329d
SC		 220{
221 bfd *input_bfd;
222 unsigned int bfd_count;
223 int top_id, top_index;
224 asection *section;
225 asection **input_list, **list;
226 bfd_size_type amt;
227 asection *text_section;
228 struct m68hc11_elf_link_hash_table *htab;
229
230 htab = m68hc11_elf_hash_table (info);
231
232 if (htab->root.root.creator->flavour != bfd_target_elf_flavour)
233 return 0;
234
235 /* Count the number of input BFDs and find the top input section id.
236 Also search for an existing ".tramp" section so that we know
237 where generated trampolines must go. Default to ".text" if we
238 can't find it. */
239 htab->tramp_section = 0;
240 text_section = 0;
241 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
242 input_bfd != NULL;
243 input_bfd = input_bfd->link_next)
244 {
245 bfd_count += 1;
246 for (section = input_bfd->sections;
247 section != NULL;
248 section = section->next)
249 {
250 const char* name = bfd_get_section_name (input_bfd, section);
251
252 if (!strcmp (name, ".tramp"))
253 htab->tramp_section = section;
254
255 if (!strcmp (name, ".text"))
256 text_section = section;
257
258 if (top_id < section->id)
259 top_id = section->id;
260 }
261 }
262 htab->bfd_count = bfd_count;
263 if (htab->tramp_section == 0)
264 htab->tramp_section = text_section;
265
266 /* We can't use output_bfd->section_count here to find the top output
267 section index as some sections may have been removed, and
8423293d 268 strip_excluded_output_sections doesn't renumber the indices. */
3a65329d
SC		 269 for (section = output_bfd->sections, top_index = 0;
270 section != NULL;
271 section = section->next)
272 {
273 if (top_index < section->index)
274 top_index = section->index;
275 }
276
277 htab->top_index = top_index;
278 amt = sizeof (asection *) * (top_index + 1);
279 input_list = (asection **) bfd_malloc (amt);
280 htab->input_list = input_list;
281 if (input_list == NULL)
282 return -1;
283
284 /* For sections we aren't interested in, mark their entries with a
285 value we can check later. */
286 list = input_list + top_index;
287 do
288 *list = bfd_abs_section_ptr;
289 while (list-- != input_list);
290
291 for (section = output_bfd->sections;
292 section != NULL;
293 section = section->next)
294 {
295 if ((section->flags & SEC_CODE) != 0)
296 input_list[section->index] = NULL;
297 }
298
299 return 1;
300}
301
302/* Determine and set the size of the stub section for a final link.
303
304 The basic idea here is to examine all the relocations looking for
305 PC-relative calls to a target that is unreachable with a "bl"
306 instruction. */
307
308bfd_boolean
0a6a3ebe
SC		 309elf32_m68hc11_size_stubs (bfd *output_bfd, bfd *stub_bfd,
310 struct bfd_link_info *info,
311 asection * (*add_stub_section) (const char*, asection*))
3a65329d
SC		 312{
313 bfd *input_bfd;
314 asection *section;
315 Elf_Internal_Sym *local_syms, **all_local_syms;
316 unsigned int bfd_indx, bfd_count;
317 bfd_size_type amt;
318 asection *stub_sec;
319
320 struct m68hc11_elf_link_hash_table *htab = m68hc11_elf_hash_table (info);
321
322 /* Stash our params away. */
323 htab->stub_bfd = stub_bfd;
324 htab->add_stub_section = add_stub_section;
325
326 /* Count the number of input BFDs and find the top input section id. */
327 for (input_bfd = info->input_bfds, bfd_count = 0;
328 input_bfd != NULL;
329 input_bfd = input_bfd->link_next)
330 {
331 bfd_count += 1;
332 }
333
334 /* We want to read in symbol extension records only once. To do this
335 we need to read in the local symbols in parallel and save them for
336 later use; so hold pointers to the local symbols in an array. */
337 amt = sizeof (Elf_Internal_Sym *) * bfd_count;
338 all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
339 if (all_local_syms == NULL)
340 return FALSE;
341
342 /* Walk over all the input BFDs, swapping in local symbols. */
343 for (input_bfd = info->input_bfds, bfd_indx = 0;
344 input_bfd != NULL;
345 input_bfd = input_bfd->link_next, bfd_indx++)
346 {
347 Elf_Internal_Shdr *symtab_hdr;
3a65329d
SC		 348
349 /* We'll need the symbol table in a second. */
350 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
351 if (symtab_hdr->sh_info == 0)
352 continue;
353
2a0e29b4
SC		 354 /* We need an array of the local symbols attached to the input bfd. */
355 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
356 if (local_syms == NULL)
357 {
358 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
359 symtab_hdr->sh_info, 0,
360 NULL, NULL, NULL);
361 /* Cache them for elf_link_input_bfd. */
362 symtab_hdr->contents = (unsigned char *) local_syms;
363 }
3a65329d 364 if (local_syms == NULL)
3a65329d 365 {
2a0e29b4
SC		 366 free (all_local_syms);
367 return FALSE;
3a65329d
SC		 368 }
369
2a0e29b4 370 all_local_syms[bfd_indx] = local_syms;
3a65329d
SC		 371 }
372
373 for (input_bfd = info->input_bfds, bfd_indx = 0;
374 input_bfd != NULL;
375 input_bfd = input_bfd->link_next, bfd_indx++)
376 {
377 Elf_Internal_Shdr *symtab_hdr;
378 Elf_Internal_Sym *local_syms;
379 struct elf_link_hash_entry ** sym_hashes;
380
381 sym_hashes = elf_sym_hashes (input_bfd);
382
383 /* We'll need the symbol table in a second. */
384 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
385 if (symtab_hdr->sh_info == 0)
386 continue;
387
388 local_syms = all_local_syms[bfd_indx];
389
390 /* Walk over each section attached to the input bfd. */
391 for (section = input_bfd->sections;
392 section != NULL;
393 section = section->next)
394 {
395 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
396
397 /* If there aren't any relocs, then there's nothing more
398 to do. */
399 if ((section->flags & SEC_RELOC) == 0
400 || section->reloc_count == 0)
401 continue;
402
403 /* If this section is a link-once section that will be
404 discarded, then don't create any stubs. */
405 if (section->output_section == NULL
406 || section->output_section->owner != output_bfd)
407 continue;
408
409 /* Get the relocs. */
410 internal_relocs
45d6a902
AM		 411 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
412 (Elf_Internal_Rela *) NULL,
413 info->keep_memory);
3a65329d
SC		 414 if (internal_relocs == NULL)
415 goto error_ret_free_local;
416
417 /* Now examine each relocation. */
418 irela = internal_relocs;
419 irelaend = irela + section->reloc_count;
420 for (; irela < irelaend; irela++)
421 {
422 unsigned int r_type, r_indx;
423 struct elf32_m68hc11_stub_hash_entry *stub_entry;
424 asection *sym_sec;
425 bfd_vma sym_value;
426 struct elf_link_hash_entry *hash;
427 const char *stub_name;
428 Elf_Internal_Sym *sym;
429
430 r_type = ELF32_R_TYPE (irela->r_info);
431
432 /* Only look at 16-bit relocs. */
433 if (r_type != (unsigned int) R_M68HC11_16)
434 continue;
435
436 /* Now determine the call target, its name, value,
437 section. */
438 r_indx = ELF32_R_SYM (irela->r_info);
439 if (r_indx < symtab_hdr->sh_info)
440 {
441 /* It's a local symbol. */
442 Elf_Internal_Shdr *hdr;
443 bfd_boolean is_far;
444
445 sym = local_syms + r_indx;
3a65329d
SC		 446 is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
447 if (!is_far)
448 continue;
7f888330
SC		 449
450 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
451 sym_sec = hdr->bfd_section;
3a65329d
SC		 452 stub_name = (bfd_elf_string_from_elf_section
453 (input_bfd, symtab_hdr->sh_link,
454 sym->st_name));
455 sym_value = sym->st_value;
456 hash = NULL;
457 }
458 else
459 {
460 /* It's an external symbol. */
461 int e_indx;
462
463 e_indx = r_indx - symtab_hdr->sh_info;
464 hash = (struct elf_link_hash_entry *)
465 (sym_hashes[e_indx]);
466
467 while (hash->root.type == bfd_link_hash_indirect
468 || hash->root.type == bfd_link_hash_warning)
469 hash = ((struct elf_link_hash_entry *)
470 hash->root.u.i.link);
471
472 if (hash->root.type == bfd_link_hash_defined
83774818
SC		 473 || hash->root.type == bfd_link_hash_defweak
474 || hash->root.type == bfd_link_hash_new)
3a65329d
SC		 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
SC		 792{
793 if (output_bfd != (bfd *) NULL
794 && (symbol->flags & BSF_SECTION_SYM) == 0
795 && (! reloc_entry->howto->partial_inplace
796 || reloc_entry->addend == 0))
797 {
798 reloc_entry->address += input_section->output_offset;
799 return bfd_reloc_ok;
800 }
801
802 if (output_bfd != NULL)
803 return bfd_reloc_continue;
804
07515404 805 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
3a65329d
SC		 806 return bfd_reloc_outofrange;
807
808 abort();
809}
810
811asection *
0a6a3ebe
SC		 812elf32_m68hc11_gc_mark_hook (asection *sec,
813 struct bfd_link_info *info ATTRIBUTE_UNUSED,
814 Elf_Internal_Rela *rel,
815 struct elf_link_hash_entry *h,
816 Elf_Internal_Sym *sym)
3a65329d
SC		 817{
818 if (h != NULL)
819 {
820 switch (ELF32_R_TYPE (rel->r_info))
821 {
822 default:
823 switch (h->root.type)
824 {
825 case bfd_link_hash_defined:
826 case bfd_link_hash_defweak:
827 return h->root.u.def.section;
828
829 case bfd_link_hash_common:
830 return h->root.u.c.p->section;
831
832 default:
833 break;
834 }
835 }
836 }
837 else
838 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
839
840 return NULL;
841}
842
843bfd_boolean
0a6a3ebe
SC		 844elf32_m68hc11_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
845 struct bfd_link_info *info ATTRIBUTE_UNUSED,
846 asection *sec ATTRIBUTE_UNUSED,
847 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
3a65329d
SC		 848{
849 /* We don't use got and plt entries for 68hc11/68hc12. */
850 return TRUE;
851}
852
853/* Look through the relocs for a section during the first phase.
854 Since we don't do .gots or .plts, we just need to consider the
855 virtual table relocs for gc. */
856
857bfd_boolean
0a6a3ebe
SC		 858elf32_m68hc11_check_relocs (bfd *abfd, struct bfd_link_info *info,
859 asection *sec, const Elf_Internal_Rela *relocs)
3a65329d
SC		 860{
861 Elf_Internal_Shdr * symtab_hdr;
862 struct elf_link_hash_entry ** sym_hashes;
863 struct elf_link_hash_entry ** sym_hashes_end;
864 const Elf_Internal_Rela * rel;
865 const Elf_Internal_Rela * rel_end;
866
1049f94e 867 if (info->relocatable)
3a65329d
SC		 868 return TRUE;
869
870 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
871 sym_hashes = elf_sym_hashes (abfd);
872 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
873 if (!elf_bad_symtab (abfd))
874 sym_hashes_end -= symtab_hdr->sh_info;
875
876 rel_end = relocs + sec->reloc_count;
877
878 for (rel = relocs; rel < rel_end; rel++)
879 {
880 struct elf_link_hash_entry * h;
881 unsigned long r_symndx;
882
883 r_symndx = ELF32_R_SYM (rel->r_info);
884
885 if (r_symndx < symtab_hdr->sh_info)
886 h = NULL;
887 else
888 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
889
890 switch (ELF32_R_TYPE (rel->r_info))
891 {
892 /* This relocation describes the C++ object vtable hierarchy.
893 Reconstruct it for later use during GC. */
894 case R_M68HC11_GNU_VTINHERIT:
c152c796 895 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3a65329d
SC		 896 return FALSE;
897 break;
898
899 /* This relocation describes which C++ vtable entries are actually
900 used. Record for later use during GC. */
901 case R_M68HC11_GNU_VTENTRY:
c152c796 902 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3a65329d
SC		 903 return FALSE;
904 break;
905 }
906 }
907
908 return TRUE;
909}
910
911static bfd_boolean
59c2e50f
L		 912m68hc11_get_relocation_value (bfd *input_bfd, struct bfd_link_info *info,
913 asection *input_section,
0a6a3ebe
SC		 914 asection **local_sections,
915 Elf_Internal_Sym *local_syms,
916 Elf_Internal_Rela *rel,
917 const char **name,
918 bfd_vma *relocation, bfd_boolean *is_far)
3a65329d
SC		 919{
920 Elf_Internal_Shdr *symtab_hdr;
921 struct elf_link_hash_entry **sym_hashes;
922 unsigned long r_symndx;
923 asection *sec;
924 struct elf_link_hash_entry *h;
925 Elf_Internal_Sym *sym;
926 const char* stub_name = 0;
927
59c2e50f
L		 928 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
929 sym_hashes = elf_sym_hashes (input_bfd);
3a65329d
SC		 930
931 r_symndx = ELF32_R_SYM (rel->r_info);
932
933 /* This is a final link. */
934 h = NULL;
935 sym = NULL;
936 sec = NULL;
937 if (r_symndx < symtab_hdr->sh_info)
938 {
939 sym = local_syms + r_symndx;
940 sec = local_sections[r_symndx];
941 *relocation = (sec->output_section->vma
942 + sec->output_offset
943 + sym->st_value);
944 *is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
945 if (*is_far)
946 stub_name = (bfd_elf_string_from_elf_section
59c2e50f 947 (input_bfd, symtab_hdr->sh_link,
3a65329d
SC		 948 sym->st_name));
949 }
950 else
951 {
59c2e50f
L		 952 bfd_boolean unresolved_reloc, warned;
953
b2a8e766
AM		 954 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
955 r_symndx, symtab_hdr, sym_hashes,
956 h, sec, *relocation, unresolved_reloc, warned);
59c2e50f 957
3a65329d
SC		 958 *is_far = (h && (h->other & STO_M68HC12_FAR));
959 stub_name = h->root.root.string;
960 }
961
962 if (h != NULL)
963 *name = h->root.root.string;
964 else
965 {
966 *name = (bfd_elf_string_from_elf_section
59c2e50f 967 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3a65329d
SC		 968 if (*name == NULL || **name == '\0')
969 *name = bfd_section_name (input_bfd, sec);
970 }
971
972 if (*is_far && ELF32_R_TYPE (rel->r_info) == R_M68HC11_16)
973 {
974 struct elf32_m68hc11_stub_hash_entry* stub;
975 struct m68hc11_elf_link_hash_table *htab;
976
977 htab = m68hc11_elf_hash_table (info);
978 stub = m68hc12_stub_hash_lookup (htab->stub_hash_table,
979 *name, FALSE, FALSE);
980 if (stub)
981 {
982 *relocation = stub->stub_offset
983 + stub->stub_sec->output_section->vma
984 + stub->stub_sec->output_offset;
985 *is_far = FALSE;
986 }
987 }
988 return TRUE;
989}
990
991/* Relocate a 68hc11/68hc12 ELF section. */
992bfd_boolean
0a6a3ebe
SC		 993elf32_m68hc11_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
994 struct bfd_link_info *info,
995 bfd *input_bfd, asection *input_section,
996 bfd_byte *contents, Elf_Internal_Rela *relocs,
997 Elf_Internal_Sym *local_syms,
998 asection **local_sections)
3a65329d
SC		 999{
1000 Elf_Internal_Shdr *symtab_hdr;
1001 struct elf_link_hash_entry **sym_hashes;
1002 Elf_Internal_Rela *rel, *relend;
9b69b847 1003 const char *name = NULL;
3a65329d 1004 struct m68hc11_page_info *pinfo;
9c5bfbb7 1005 const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
3a65329d
SC		 1006
1007 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1008 sym_hashes = elf_sym_hashes (input_bfd);
1009
1010 /* Get memory bank parameters. */
1011 m68hc11_elf_get_bank_parameters (info);
1012 pinfo = &m68hc11_elf_hash_table (info)->pinfo;
1013
1014 rel = relocs;
1015 relend = relocs + input_section->reloc_count;
1016 for (; rel < relend; rel++)
1017 {
1018 int r_type;
1019 arelent arel;
1020 reloc_howto_type *howto;
1021 unsigned long r_symndx;
1022 Elf_Internal_Sym *sym;
1023 asection *sec;
9b69b847 1024 bfd_vma relocation = 0;
3a65329d
SC		 1025 bfd_reloc_status_type r = bfd_reloc_undefined;
1026 bfd_vma phys_page;
1027 bfd_vma phys_addr;
1028 bfd_vma insn_addr;
1029 bfd_vma insn_page;
9b69b847 1030 bfd_boolean is_far = FALSE;
3a65329d
SC		 1031
1032 r_symndx = ELF32_R_SYM (rel->r_info);
1033 r_type = ELF32_R_TYPE (rel->r_info);
1034
1035 if (r_type == R_M68HC11_GNU_VTENTRY
1036 || r_type == R_M68HC11_GNU_VTINHERIT )
1037 continue;
1038
1049f94e 1039 if (info->relocatable)
3a65329d 1040 {
1049f94e 1041 /* This is a relocatable link. We don't have to change
3a65329d
SC		 1042 anything, unless the reloc is against a section symbol,
1043 in which case we have to adjust according to where the
1044 section symbol winds up in the output section. */
1045 if (r_symndx < symtab_hdr->sh_info)
1046 {
1047 sym = local_syms + r_symndx;
1048 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1049 {
1050 sec = local_sections[r_symndx];
1051 rel->r_addend += sec->output_offset + sym->st_value;
1052 }
1053 }
1054
1055 continue;
1056 }
1057 (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel);
1058 howto = arel.howto;
1059
59c2e50f
L		 1060 m68hc11_get_relocation_value (input_bfd, info, input_section,
1061 local_sections, local_syms,
3a65329d
SC		 1062 rel, &name, &relocation, &is_far);
1063
1064 /* Do the memory bank mapping. */
1065 phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend);
1066 phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend);
1067 switch (r_type)
1068 {
1069 case R_M68HC11_24:
1070 /* Reloc used by 68HC12 call instruction. */
1071 bfd_put_16 (input_bfd, phys_addr,
1072 (bfd_byte*) contents + rel->r_offset);
1073 bfd_put_8 (input_bfd, phys_page,
1074 (bfd_byte*) contents + rel->r_offset + 2);
1075 r = bfd_reloc_ok;
1076 r_type = R_M68HC11_NONE;
1077 break;
1078
1079 case R_M68HC11_NONE:
1080 r = bfd_reloc_ok;
1081 break;
1082
1083 case R_M68HC11_LO16:
1084 /* Reloc generated by %addr(expr) gas to obtain the
1085 address as mapped in the memory bank window. */
1086 relocation = phys_addr;
1087 break;
1088
1089 case R_M68HC11_PAGE:
1090 /* Reloc generated by %page(expr) gas to obtain the
1091 page number associated with the address. */
1092 relocation = phys_page;
1093 break;
1094
1095 case R_M68HC11_16:
1096 /* Get virtual address of instruction having the relocation. */
1097 if (is_far)
1098 {
1099 const char* msg;
1100 char* buf;
1101 msg = _("Reference to the far symbol `%s' using a wrong "
1102 "relocation may result in incorrect execution");
1103 buf = alloca (strlen (msg) + strlen (name) + 10);
1104 sprintf (buf, msg, name);
1105
1106 (* info->callbacks->warning)
1107 (info, buf, name, input_bfd, NULL, rel->r_offset);
1108 }
1109
1110 /* Get virtual address of instruction having the relocation. */
1111 insn_addr = input_section->output_section->vma
1112 + input_section->output_offset
1113 + rel->r_offset;
1114
1115 insn_page = m68hc11_phys_page (pinfo, insn_addr);
1116
1117 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend)
1118 && m68hc11_addr_is_banked (pinfo, insn_addr)
1119 && phys_page != insn_page)
1120 {
1121 const char* msg;
1122 char* buf;
1123
1124 msg = _("banked address [%lx:%04lx] (%lx) is not in the same bank "
1125 "as current banked address [%lx:%04lx] (%lx)");
1126
1127 buf = alloca (strlen (msg) + 128);
1128 sprintf (buf, msg, phys_page, phys_addr,
1129 (long) (relocation + rel->r_addend),
1130 insn_page, m68hc11_phys_addr (pinfo, insn_addr),
1131 (long) (insn_addr));
1132 if (!((*info->callbacks->warning)
1133 (info, buf, name, input_bfd, input_section,
1134 rel->r_offset)))
1135 return FALSE;
1136 break;
1137 }
1138 if (phys_page != 0 && insn_page == 0)
1139 {
1140 const char* msg;
1141 char* buf;
1142
1143 msg = _("reference to a banked address [%lx:%04lx] in the "
1144 "normal address space at %04lx");
1145
1146 buf = alloca (strlen (msg) + 128);
1147 sprintf (buf, msg, phys_page, phys_addr, insn_addr);
1148 if (!((*info->callbacks->warning)
1149 (info, buf, name, input_bfd, input_section,
1150 insn_addr)))
1151 return FALSE;
1152
1153 relocation = phys_addr;
1154 break;
1155 }
1156
1157 /* If this is a banked address use the phys_addr so that
1158 we stay in the banked window. */
1159 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend))
1160 relocation = phys_addr;
1161 break;
1162 }
1163 if (r_type != R_M68HC11_NONE)
1164 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1165 contents, rel->r_offset,
1166 relocation, rel->r_addend);
1167
1168 if (r != bfd_reloc_ok)
1169 {
1170 const char * msg = (const char *) 0;
1171
1172 switch (r)
1173 {
1174 case bfd_reloc_overflow:
1175 if (!((*info->callbacks->reloc_overflow)
dfeffb9f 1176 (info, NULL, name, howto->name, (bfd_vma) 0,
3a65329d
SC		 1177 input_bfd, input_section, rel->r_offset)))
1178 return FALSE;
1179 break;
1180
1181 case bfd_reloc_undefined:
1182 if (!((*info->callbacks->undefined_symbol)
1183 (info, name, input_bfd, input_section,
1184 rel->r_offset, TRUE)))
1185 return FALSE;
1186 break;
1187
1188 case bfd_reloc_outofrange:
1189 msg = _ ("internal error: out of range error");
1190 goto common_error;
1191
1192 case bfd_reloc_notsupported:
1193 msg = _ ("internal error: unsupported relocation error");
1194 goto common_error;
1195
1196 case bfd_reloc_dangerous:
1197 msg = _ ("internal error: dangerous error");
1198 goto common_error;
1199
1200 default:
1201 msg = _ ("internal error: unknown error");
1202 /* fall through */
1203
1204 common_error:
1205 if (!((*info->callbacks->warning)
1206 (info, msg, name, input_bfd, input_section,
1207 rel->r_offset)))
1208 return FALSE;
1209 break;
1210 }
1211 }
1212 }
1213
1214 return TRUE;
1215}
1216
1217
1218\f
1219/* Set and control ELF flags in ELF header. */
1220
1221bfd_boolean
0a6a3ebe 1222_bfd_m68hc11_elf_set_private_flags (bfd *abfd, flagword flags)
3a65329d
SC		 1223{
1224 BFD_ASSERT (!elf_flags_init (abfd)
1225 || elf_elfheader (abfd)->e_flags == flags);
1226
1227 elf_elfheader (abfd)->e_flags = flags;
1228 elf_flags_init (abfd) = TRUE;
1229 return TRUE;
1230}
1231
1232/* Merge backend specific data from an object file to the output
1233 object file when linking. */
1234
1235bfd_boolean
0a6a3ebe 1236_bfd_m68hc11_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3a65329d
SC		 1237{
1238 flagword old_flags;
1239 flagword new_flags;
1240 bfd_boolean ok = TRUE;
1241
1242 /* Check if we have the same endianess */
1243 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
1244 return FALSE;
1245
1246 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1247 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1248 return TRUE;
1249
1250 new_flags = elf_elfheader (ibfd)->e_flags;
1251 elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI;
1252 old_flags = elf_elfheader (obfd)->e_flags;
1253
1254 if (! elf_flags_init (obfd))
1255 {
1256 elf_flags_init (obfd) = TRUE;
1257 elf_elfheader (obfd)->e_flags = new_flags;
1258 elf_elfheader (obfd)->e_ident[EI_CLASS]
1259 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
1260
1261 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1262 && bfd_get_arch_info (obfd)->the_default)
1263 {
1264 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1265 bfd_get_mach (ibfd)))
1266 return FALSE;
1267 }
1268
1269 return TRUE;
1270 }
1271
1272 /* Check ABI compatibility. */
1273 if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
1274 {
1275 (*_bfd_error_handler)
d003868e
AM		 1276 (_("%B: linking files compiled for 16-bit integers (-mshort) "
1277 "and others for 32-bit integers"), ibfd);
3a65329d
SC		 1278 ok = FALSE;
1279 }
1280 if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
1281 {
1282 (*_bfd_error_handler)
d003868e
AM		 1283 (_("%B: linking files compiled for 32-bit double (-fshort-double) "
1284 "and others for 64-bit double"), ibfd);
3a65329d
SC		 1285 ok = FALSE;
1286 }
47247ced
SC		 1287
1288 /* Processor compatibility. */
1289 if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
1290 {
1291 (*_bfd_error_handler)
d003868e
AM		 1292 (_("%B: linking files compiled for HCS12 with "
1293 "others compiled for HC12"), ibfd);
47247ced
SC		 1294 ok = FALSE;
1295 }
1296 new_flags = ((new_flags & ~EF_M68HC11_MACH_MASK)
1297 | (EF_M68HC11_MERGE_MACH (new_flags, old_flags)));
1298
1299 elf_elfheader (obfd)->e_flags = new_flags;
1300
17e58af0
SC		 1301 new_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1302 old_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
3a65329d
SC		 1303
1304 /* Warn about any other mismatches */
1305 if (new_flags != old_flags)
1306 {
1307 (*_bfd_error_handler)
d003868e
AM		 1308 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1309 ibfd, (unsigned long) new_flags, (unsigned long) old_flags);
3a65329d
SC		 1310 ok = FALSE;
1311 }
1312
1313 if (! ok)
1314 {
1315 bfd_set_error (bfd_error_bad_value);
1316 return FALSE;
1317 }
1318
1319 return TRUE;
1320}
1321
1322bfd_boolean
0a6a3ebe 1323_bfd_m68hc11_elf_print_private_bfd_data (bfd *abfd, void *ptr)
3a65329d
SC		 1324{
1325 FILE *file = (FILE *) ptr;
1326
1327 BFD_ASSERT (abfd != NULL && ptr != NULL);
1328
1329 /* Print normal ELF private data. */
1330 _bfd_elf_print_private_bfd_data (abfd, ptr);
1331
1332 /* xgettext:c-format */
1333 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1334
1335 if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32)
1336 fprintf (file, _("[abi=32-bit int, "));
1337 else
1338 fprintf (file, _("[abi=16-bit int, "));
1339
1340 if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64)
1341 fprintf (file, _("64-bit double, "));
1342 else
1343 fprintf (file, _("32-bit double, "));
1344
1345 if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0)
1346 fprintf (file, _("cpu=HC11]"));
1347 else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH)
1348 fprintf (file, _("cpu=HCS12]"));
1349 else
1350 fprintf (file, _("cpu=HC12]"));
1351
1352 if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)
1353 fprintf (file, _(" [memory=bank-model]"));
1354 else
1355 fprintf (file, _(" [memory=flat]"));
1356
1357 fputc ('\n', file);
1358
1359 return TRUE;
1360}
1361
0a6a3ebe
SC		 1362static void scan_sections_for_abi (bfd *abfd ATTRIBUTE_UNUSED,
1363 asection *asect, void *arg)
3a65329d
SC		 1364{
1365 struct m68hc11_scan_param* p = (struct m68hc11_scan_param*) arg;
1366
1367 if (asect->vma >= p->pinfo->bank_virtual)
1368 p->use_memory_banks = TRUE;
1369}
1370
1371/* Tweak the OSABI field of the elf header. */
1372
1373void
0a6a3ebe 1374elf32_m68hc11_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
3a65329d
SC		 1375{
1376 struct m68hc11_scan_param param;
1377
1378 if (link_info == 0)
1379 return;
1380
1381 m68hc11_elf_get_bank_parameters (link_info);
1382
1383 param.use_memory_banks = FALSE;
1384 param.pinfo = &m68hc11_elf_hash_table (link_info)->pinfo;
1385 bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
1386 if (param.use_memory_banks)
1387 {
1388 Elf_Internal_Ehdr * i_ehdrp;
1389
1390 i_ehdrp = elf_elfheader (abfd);
1391 i_ehdrp->e_flags |= E_M68HC12_BANKS;
1392 }
1393}
1394
Empty description
This page took 0.453502 seconds and 4 git commands to generate.