?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(Ada) Fix resolving of homonym components in tagged types
[binutils-gdb.git] / bfd / elf32-m68hc11.c
blob95d271f65aa0fce3a0362933971e7414829b3418
1 /* Motorola 68HC11-specific support for 32-bit ELF
2 Copyright (C) 1999-2018 Free Software Foundation, Inc.
3 Contributed by Stephane Carrez (stcarrez@nerim.fr)
4 (Heavily copied from the D10V port by Martin Hunt (hunt@cygnus.com))
5
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. */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "elf32-m68hc1x.h"
29 #include "elf/m68hc11.h"
30 #include "opcode/m68hc11.h"
31
32 /* Relocation functions. */
33 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
34 (bfd *, bfd_reloc_code_real_type);
35 static bfd_boolean m68hc11_info_to_howto_rel
36 (bfd *, arelent *, Elf_Internal_Rela *);
37
38 /* Trampoline generation. */
39 static bfd_boolean m68hc11_elf_size_one_stub
40 (struct bfd_hash_entry *gen_entry, void *in_arg);
41 static bfd_boolean m68hc11_elf_build_one_stub
42 (struct bfd_hash_entry *gen_entry, void *in_arg);
43 static struct bfd_link_hash_table* m68hc11_elf_bfd_link_hash_table_create
44 (bfd* abfd);
45
46 /* Linker relaxation. */
47 static bfd_boolean m68hc11_elf_relax_section
48 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
49 static void m68hc11_elf_relax_delete_bytes
50 (bfd *, asection *, bfd_vma, int);
51 static void m68hc11_relax_group
52 (bfd *, asection *, bfd_byte *, unsigned, unsigned long, unsigned long);
53 static int compare_reloc (const void *, const void *);
54
55 /* Use REL instead of RELA to save space */
56 #define USE_REL 1
57
58 /* The Motorola 68HC11 microcontroller only addresses 64Kb but we also
59 support a memory bank switching mechanism similar to 68HC12.
60 We must handle 8 and 16-bit relocations. The 32-bit relocation
61 are used for debugging sections (DWARF2) to represent a virtual
62 address.
63 The 3-bit and 16-bit PC rel relocation is only used by 68HC12. */
64 static reloc_howto_type elf_m68hc11_howto_table[] = {
65 /* This reloc does nothing. */
66 HOWTO (R_M68HC11_NONE, /* type */
67 0, /* rightshift */
68 3, /* size (0 = byte, 1 = short, 2 = long) */
69 0, /* bitsize */
70 FALSE, /* pc_relative */
71 0, /* bitpos */
72 complain_overflow_dont,/* complain_on_overflow */
73 bfd_elf_generic_reloc, /* special_function */
74 "R_M68HC11_NONE", /* name */
75 FALSE, /* partial_inplace */
76 0, /* src_mask */
77 0, /* dst_mask */
78 FALSE), /* pcrel_offset */
79
80 /* A 8 bit absolute relocation */
81 HOWTO (R_M68HC11_8, /* type */
82 0, /* rightshift */
83 0, /* size (0 = byte, 1 = short, 2 = long) */
84 8, /* bitsize */
85 FALSE, /* pc_relative */
86 0, /* bitpos */
87 complain_overflow_bitfield, /* complain_on_overflow */
88 bfd_elf_generic_reloc, /* special_function */
89 "R_M68HC11_8", /* name */
90 FALSE, /* partial_inplace */
91 0x00ff, /* src_mask */
92 0x00ff, /* dst_mask */
93 FALSE), /* pcrel_offset */
94
95 /* A 8 bit absolute relocation (upper address) */
96 HOWTO (R_M68HC11_HI8, /* type */
97 8, /* rightshift */
98 0, /* size (0 = byte, 1 = short, 2 = long) */
99 8, /* bitsize */
100 FALSE, /* pc_relative */
101 0, /* bitpos */
102 complain_overflow_bitfield, /* complain_on_overflow */
103 bfd_elf_generic_reloc, /* special_function */
104 "R_M68HC11_HI8", /* name */
105 FALSE, /* partial_inplace */
106 0x00ff, /* src_mask */
107 0x00ff, /* dst_mask */
108 FALSE), /* pcrel_offset */
109
110 /* A 8 bit absolute relocation (upper address) */
111 HOWTO (R_M68HC11_LO8, /* type */
112 0, /* rightshift */
113 0, /* size (0 = byte, 1 = short, 2 = long) */
114 8, /* bitsize */
115 FALSE, /* pc_relative */
116 0, /* bitpos */
117 complain_overflow_dont, /* complain_on_overflow */
118 bfd_elf_generic_reloc, /* special_function */
119 "R_M68HC11_LO8", /* name */
120 FALSE, /* partial_inplace */
121 0x00ff, /* src_mask */
122 0x00ff, /* dst_mask */
123 FALSE), /* pcrel_offset */
124
125 /* A 8 bit PC-rel relocation */
126 HOWTO (R_M68HC11_PCREL_8, /* type */
127 0, /* rightshift */
128 0, /* size (0 = byte, 1 = short, 2 = long) */
129 8, /* bitsize */
130 TRUE, /* pc_relative */
131 0, /* bitpos */
132 complain_overflow_bitfield, /* complain_on_overflow */
133 bfd_elf_generic_reloc, /* special_function */
134 "R_M68HC11_PCREL_8", /* name */
135 FALSE, /* partial_inplace */
136 0x00ff, /* src_mask */
137 0x00ff, /* dst_mask */
138 TRUE), /* pcrel_offset */
139
140 /* A 16 bit absolute relocation */
141 HOWTO (R_M68HC11_16, /* type */
142 0, /* rightshift */
143 1, /* size (0 = byte, 1 = short, 2 = long) */
144 16, /* bitsize */
145 FALSE, /* pc_relative */
146 0, /* bitpos */
147 complain_overflow_dont /*bitfield */ , /* complain_on_overflow */
148 bfd_elf_generic_reloc, /* special_function */
149 "R_M68HC11_16", /* name */
150 FALSE, /* partial_inplace */
151 0xffff, /* src_mask */
152 0xffff, /* dst_mask */
153 FALSE), /* pcrel_offset */
154
155 /* A 32 bit absolute relocation. This one is never used for the
156 code relocation. It's used by gas for -gstabs generation. */
157 HOWTO (R_M68HC11_32, /* type */
158 0, /* rightshift */
159 2, /* size (0 = byte, 1 = short, 2 = long) */
160 32, /* bitsize */
161 FALSE, /* pc_relative */
162 0, /* bitpos */
163 complain_overflow_bitfield, /* complain_on_overflow */
164 bfd_elf_generic_reloc, /* special_function */
165 "R_M68HC11_32", /* name */
166 FALSE, /* partial_inplace */
167 0xffffffff, /* src_mask */
168 0xffffffff, /* dst_mask */
169 FALSE), /* pcrel_offset */
170
171 /* A 3 bit absolute relocation */
172 HOWTO (R_M68HC11_3B, /* type */
173 0, /* rightshift */
174 0, /* size (0 = byte, 1 = short, 2 = long) */
175 3, /* bitsize */
176 FALSE, /* pc_relative */
177 0, /* bitpos */
178 complain_overflow_bitfield, /* complain_on_overflow */
179 bfd_elf_generic_reloc, /* special_function */
180 "R_M68HC11_4B", /* name */
181 FALSE, /* partial_inplace */
182 0x003, /* src_mask */
183 0x003, /* dst_mask */
184 FALSE), /* pcrel_offset */
185
186 /* A 16 bit PC-rel relocation */
187 HOWTO (R_M68HC11_PCREL_16, /* type */
188 0, /* rightshift */
189 1, /* size (0 = byte, 1 = short, 2 = long) */
190 16, /* bitsize */
191 TRUE, /* pc_relative */
192 0, /* bitpos */
193 complain_overflow_dont, /* complain_on_overflow */
194 bfd_elf_generic_reloc, /* special_function */
195 "R_M68HC11_PCREL_16", /* name */
196 FALSE, /* partial_inplace */
197 0xffff, /* src_mask */
198 0xffff, /* dst_mask */
199 TRUE), /* pcrel_offset */
200
201 /* GNU extension to record C++ vtable hierarchy */
202 HOWTO (R_M68HC11_GNU_VTINHERIT, /* type */
203 0, /* rightshift */
204 1, /* size (0 = byte, 1 = short, 2 = long) */
205 0, /* bitsize */
206 FALSE, /* pc_relative */
207 0, /* bitpos */
208 complain_overflow_dont, /* complain_on_overflow */
209 NULL, /* special_function */
210 "R_M68HC11_GNU_VTINHERIT", /* name */
211 FALSE, /* partial_inplace */
212 0, /* src_mask */
213 0, /* dst_mask */
214 FALSE), /* pcrel_offset */
215
216 /* GNU extension to record C++ vtable member usage */
217 HOWTO (R_M68HC11_GNU_VTENTRY, /* type */
218 0, /* rightshift */
219 1, /* size (0 = byte, 1 = short, 2 = long) */
220 0, /* bitsize */
221 FALSE, /* pc_relative */
222 0, /* bitpos */
223 complain_overflow_dont, /* complain_on_overflow */
224 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
225 "R_M68HC11_GNU_VTENTRY", /* name */
226 FALSE, /* partial_inplace */
227 0, /* src_mask */
228 0, /* dst_mask */
229 FALSE), /* pcrel_offset */
230
231 /* A 24 bit relocation */
232 HOWTO (R_M68HC11_24, /* type */
233 0, /* rightshift */
234 1, /* size (0 = byte, 1 = short, 2 = long) */
235 24, /* bitsize */
236 FALSE, /* pc_relative */
237 0, /* bitpos */
238 complain_overflow_bitfield, /* complain_on_overflow */
239 bfd_elf_generic_reloc, /* special_function */
240 "R_M68HC11_24", /* name */
241 FALSE, /* partial_inplace */
242 0xffffff, /* src_mask */
243 0xffffff, /* dst_mask */
244 FALSE), /* pcrel_offset */
245
246 /* A 16-bit low relocation */
247 HOWTO (R_M68HC11_LO16, /* type */
248 0, /* rightshift */
249 1, /* size (0 = byte, 1 = short, 2 = long) */
250 16, /* bitsize */
251 FALSE, /* pc_relative */
252 0, /* bitpos */
253 complain_overflow_bitfield, /* complain_on_overflow */
254 bfd_elf_generic_reloc, /* special_function */
255 "R_M68HC11_LO16", /* name */
256 FALSE, /* partial_inplace */
257 0xffff, /* src_mask */
258 0xffff, /* dst_mask */
259 FALSE), /* pcrel_offset */
260
261 /* A page relocation */
262 HOWTO (R_M68HC11_PAGE, /* type */
263 0, /* rightshift */
264 0, /* size (0 = byte, 1 = short, 2 = long) */
265 8, /* bitsize */
266 FALSE, /* pc_relative */
267 0, /* bitpos */
268 complain_overflow_bitfield, /* complain_on_overflow */
269 bfd_elf_generic_reloc, /* special_function */
270 "R_M68HC11_PAGE", /* name */
271 FALSE, /* partial_inplace */
272 0x00ff, /* src_mask */
273 0x00ff, /* dst_mask */
274 FALSE), /* pcrel_offset */
275
276 EMPTY_HOWTO (14),
277 EMPTY_HOWTO (15),
278 EMPTY_HOWTO (16),
279 EMPTY_HOWTO (17),
280 EMPTY_HOWTO (18),
281 EMPTY_HOWTO (19),
282
283 /* Mark beginning of a jump instruction (any form). */
284 HOWTO (R_M68HC11_RL_JUMP, /* type */
285 0, /* rightshift */
286 1, /* size (0 = byte, 1 = short, 2 = long) */
287 0, /* bitsize */
288 FALSE, /* pc_relative */
289 0, /* bitpos */
290 complain_overflow_dont, /* complain_on_overflow */
291 m68hc11_elf_ignore_reloc, /* special_function */
292 "R_M68HC11_RL_JUMP", /* name */
293 TRUE, /* partial_inplace */
294 0, /* src_mask */
295 0, /* dst_mask */
296 TRUE), /* pcrel_offset */
297
298 /* Mark beginning of Gcc relaxation group instruction. */
299 HOWTO (R_M68HC11_RL_GROUP, /* type */
300 0, /* rightshift */
301 1, /* size (0 = byte, 1 = short, 2 = long) */
302 0, /* bitsize */
303 FALSE, /* pc_relative */
304 0, /* bitpos */
305 complain_overflow_dont, /* complain_on_overflow */
306 m68hc11_elf_ignore_reloc, /* special_function */
307 "R_M68HC11_RL_GROUP", /* name */
308 TRUE, /* partial_inplace */
309 0, /* src_mask */
310 0, /* dst_mask */
311 TRUE), /* pcrel_offset */
312 };
313
314 /* Map BFD reloc types to M68HC11 ELF reloc types. */
315
316 struct m68hc11_reloc_map
317 {
318 bfd_reloc_code_real_type bfd_reloc_val;
319 unsigned char elf_reloc_val;
320 };
321
322 static const struct m68hc11_reloc_map m68hc11_reloc_map[] = {
323 {BFD_RELOC_NONE, R_M68HC11_NONE,},
324 {BFD_RELOC_8, R_M68HC11_8},
325 {BFD_RELOC_M68HC11_HI8, R_M68HC11_HI8},
326 {BFD_RELOC_M68HC11_LO8, R_M68HC11_LO8},
327 {BFD_RELOC_8_PCREL, R_M68HC11_PCREL_8},
328 {BFD_RELOC_16_PCREL, R_M68HC11_PCREL_16},
329 {BFD_RELOC_16, R_M68HC11_16},
330 {BFD_RELOC_32, R_M68HC11_32},
331 {BFD_RELOC_M68HC11_3B, R_M68HC11_3B},
332
333 {BFD_RELOC_VTABLE_INHERIT, R_M68HC11_GNU_VTINHERIT},
334 {BFD_RELOC_VTABLE_ENTRY, R_M68HC11_GNU_VTENTRY},
335
336 {BFD_RELOC_M68HC11_LO16, R_M68HC11_LO16},
337 {BFD_RELOC_M68HC11_PAGE, R_M68HC11_PAGE},
338 {BFD_RELOC_M68HC11_24, R_M68HC11_24},
339
340 {BFD_RELOC_M68HC11_RL_JUMP, R_M68HC11_RL_JUMP},
341 {BFD_RELOC_M68HC11_RL_GROUP, R_M68HC11_RL_GROUP},
342 };
343
344 static reloc_howto_type *
345 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
346 bfd_reloc_code_real_type code)
347 {
348 unsigned int i;
349
350 for (i = 0;
351 i < sizeof (m68hc11_reloc_map) / sizeof (struct m68hc11_reloc_map);
352 i++)
353 {
354 if (m68hc11_reloc_map[i].bfd_reloc_val == code)
355 return &elf_m68hc11_howto_table[m68hc11_reloc_map[i].elf_reloc_val];
356 }
357
358 return NULL;
359 }
360
361 static reloc_howto_type *
362 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
363 const char *r_name)
364 {
365 unsigned int i;
366
367 for (i = 0;
368 i < (sizeof (elf_m68hc11_howto_table)
369 / sizeof (elf_m68hc11_howto_table[0]));
370 i++)
371 if (elf_m68hc11_howto_table[i].name != NULL
372 && strcasecmp (elf_m68hc11_howto_table[i].name, r_name) == 0)
373 return &elf_m68hc11_howto_table[i];
374
375 return NULL;
376 }
377
378 /* Set the howto pointer for an M68HC11 ELF reloc. */
379
380 static bfd_boolean
381 m68hc11_info_to_howto_rel (bfd *abfd,
382 arelent *cache_ptr, Elf_Internal_Rela *dst)
383 {
384 unsigned int r_type;
385
386 r_type = ELF32_R_TYPE (dst->r_info);
387 if (r_type >= (unsigned int) R_M68HC11_max)
388 {
389 /* xgettext:c-format */
390 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
391 abfd, r_type);
392 bfd_set_error (bfd_error_bad_value);
393 return FALSE;
394 }
395 cache_ptr->howto = &elf_m68hc11_howto_table[r_type];
396 return TRUE;
397 }
398
399 \f
400 /* Far trampoline generation. */
401
402 /* Build a 68HC11 trampoline stub. */
403 static bfd_boolean
404 m68hc11_elf_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
405 {
406 struct elf32_m68hc11_stub_hash_entry *stub_entry;
407 struct bfd_link_info *info;
408 struct m68hc11_elf_link_hash_table *htab;
409 asection *stub_sec;
410 bfd *stub_bfd;
411 bfd_byte *loc;
412 bfd_vma sym_value, phys_page, phys_addr;
413
414 /* Massage our args to the form they really have. */
415 stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry;
416 info = (struct bfd_link_info *) in_arg;
417
418 htab = m68hc11_elf_hash_table (info);
419 if (htab == NULL)
420 return FALSE;
421
422 stub_sec = stub_entry->stub_sec;
423
424 /* Make a note of the offset within the stubs for this entry. */
425 stub_entry->stub_offset = stub_sec->size;
426 stub_sec->size += 10;
427 loc = stub_sec->contents + stub_entry->stub_offset;
428
429 stub_bfd = stub_sec->owner;
430
431 /* Create the trampoline call stub:
432
433 pshb
434 ldab #%page(symbol)
435 ldy #%addr(symbol)
436 jmp __trampoline
437
438 */
439 sym_value = (stub_entry->target_value
440 + stub_entry->target_section->output_offset
441 + stub_entry->target_section->output_section->vma);
442 phys_addr = m68hc11_phys_addr (&htab->pinfo, sym_value);
443 phys_page = m68hc11_phys_page (&htab->pinfo, sym_value);
444
445 /* pshb; ldab #%page(sym) */
446 bfd_put_8 (stub_bfd, 0x37, loc);
447 bfd_put_8 (stub_bfd, 0xC6, loc + 1);
448 bfd_put_8 (stub_bfd, phys_page, loc + 2);
449 loc += 3;
450
451 /* ldy #%addr(sym) */
452 bfd_put_8 (stub_bfd, 0x18, loc);
453 bfd_put_8 (stub_bfd, 0xCE, loc + 1);
454 bfd_put_16 (stub_bfd, phys_addr, loc + 2);
455 loc += 4;
456
457 /* jmp __trampoline */
458 bfd_put_8 (stub_bfd, 0x7E, loc);
459 bfd_put_16 (stub_bfd, htab->pinfo.trampoline_addr, loc + 1);
460
461 return TRUE;
462 }
463
464 /* As above, but don't actually build the stub. Just bump offset so
465 we know stub section sizes. */
466
467 static bfd_boolean
468 m68hc11_elf_size_one_stub (struct bfd_hash_entry *gen_entry,
469 void *in_arg ATTRIBUTE_UNUSED)
470 {
471 struct elf32_m68hc11_stub_hash_entry *stub_entry;
472
473 /* Massage our args to the form they really have. */
474 stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry;
475
476 stub_entry->stub_sec->size += 10;
477 return TRUE;
478 }
479
480 /* Create a 68HC11 ELF linker hash table. */
481
482 static struct bfd_link_hash_table *
483 m68hc11_elf_bfd_link_hash_table_create (bfd *abfd)
484 {
485 struct m68hc11_elf_link_hash_table *ret;
486
487 ret = m68hc11_elf_hash_table_create (abfd);
488 if (ret == (struct m68hc11_elf_link_hash_table *) NULL)
489 return NULL;
490
491 ret->size_one_stub = m68hc11_elf_size_one_stub;
492 ret->build_one_stub = m68hc11_elf_build_one_stub;
493
494 return &ret->root.root;
495 }
496
497 \f
498 /* 68HC11 Linker Relaxation. */
499
500 struct m68hc11_direct_relax
501 {
502 const char *name;
503 unsigned char code;
504 unsigned char direct_code;
505 } m68hc11_direct_relax_table[] = {
506 { "adca", 0xB9, 0x99 },
507 { "adcb", 0xF9, 0xD9 },
508 { "adda", 0xBB, 0x9B },
509 { "addb", 0xFB, 0xDB },
510 { "addd", 0xF3, 0xD3 },
511 { "anda", 0xB4, 0x94 },
512 { "andb", 0xF4, 0xD4 },
513 { "cmpa", 0xB1, 0x91 },
514 { "cmpb", 0xF1, 0xD1 },
515 { "cpd", 0xB3, 0x93 },
516 { "cpxy", 0xBC, 0x9C },
517 /* { "cpy", 0xBC, 0x9C }, */
518 { "eora", 0xB8, 0x98 },
519 { "eorb", 0xF8, 0xD8 },
520 { "jsr", 0xBD, 0x9D },
521 { "ldaa", 0xB6, 0x96 },
522 { "ldab", 0xF6, 0xD6 },
523 { "ldd", 0xFC, 0xDC },
524 { "lds", 0xBE, 0x9E },
525 { "ldxy", 0xFE, 0xDE },
526 /* { "ldy", 0xFE, 0xDE },*/
527 { "oraa", 0xBA, 0x9A },
528 { "orab", 0xFA, 0xDA },
529 { "sbca", 0xB2, 0x92 },
530 { "sbcb", 0xF2, 0xD2 },
531 { "staa", 0xB7, 0x97 },
532 { "stab", 0xF7, 0xD7 },
533 { "std", 0xFD, 0xDD },
534 { "sts", 0xBF, 0x9F },
535 { "stxy", 0xFF, 0xDF },
536 /* { "sty", 0xFF, 0xDF },*/
537 { "suba", 0xB0, 0x90 },
538 { "subb", 0xF0, 0xD0 },
539 { "subd", 0xB3, 0x93 },
540 { 0, 0, 0 }
541 };
542
543 static struct m68hc11_direct_relax *
544 find_relaxable_insn (unsigned char code)
545 {
546 int i;
547
548 for (i = 0; m68hc11_direct_relax_table[i].name; i++)
549 if (m68hc11_direct_relax_table[i].code == code)
550 return &m68hc11_direct_relax_table[i];
551
552 return 0;
553 }
554
555 static int
556 compare_reloc (const void *e1, const void *e2)
557 {
558 const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
559 const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
560
561 if (i1->r_offset == i2->r_offset)
562 return 0;
563 else
564 return i1->r_offset < i2->r_offset ? -1 : 1;
565 }
566
567 #define M6811_OP_LDX_IMMEDIATE (0xCE)
568
569 static void
570 m68hc11_relax_group (bfd *abfd, asection *sec, bfd_byte *contents,
571 unsigned value, unsigned long offset,
572 unsigned long end_group)
573 {
574 unsigned char code;
575 unsigned long start_offset;
576 unsigned long ldx_offset = offset;
577 unsigned long ldx_size;
578 int can_delete_ldx;
579 int relax_ldy = 0;
580
581 /* First instruction of the relax group must be a
582 LDX #value or LDY #value. If this is not the case,
583 ignore the relax group. */
584 code = bfd_get_8 (abfd, contents + offset);
585 if (code == 0x18)
586 {
587 relax_ldy++;
588 offset++;
589 code = bfd_get_8 (abfd, contents + offset);
590 }
591 ldx_size = offset - ldx_offset + 3;
592 offset += 3;
593 if (code != M6811_OP_LDX_IMMEDIATE || offset >= end_group)
594 return;
595
596
597 /* We can remove the LDX/LDY only when all bset/brclr instructions
598 of the relax group have been converted to use direct addressing
599 mode. */
600 can_delete_ldx = 1;
601 while (offset < end_group)
602 {
603 unsigned isize;
604 unsigned new_value;
605 int bset_use_y;
606
607 bset_use_y = 0;
608 start_offset = offset;
609 code = bfd_get_8 (abfd, contents + offset);
610 if (code == 0x18)
611 {
612 bset_use_y++;
613 offset++;
614 code = bfd_get_8 (abfd, contents + offset);
615 }
616
617 /* Check the instruction and translate to use direct addressing mode. */
618 switch (code)
619 {
620 /* bset */
621 case 0x1C:
622 code = 0x14;
623 isize = 3;
624 break;
625
626 /* brclr */
627 case 0x1F:
628 code = 0x13;
629 isize = 4;
630 break;
631
632 /* brset */
633 case 0x1E:
634 code = 0x12;
635 isize = 4;
636 break;
637
638 /* bclr */
639 case 0x1D:
640 code = 0x15;
641 isize = 3;
642 break;
643
644 /* This instruction is not recognized and we are not
645 at end of the relax group. Ignore and don't remove
646 the first LDX (we don't know what it is used for...). */
647 default:
648 return;
649 }
650 new_value = (unsigned) bfd_get_8 (abfd, contents + offset + 1);
651 new_value += value;
652 if ((new_value & 0xff00) == 0 && bset_use_y == relax_ldy)
653 {
654 bfd_put_8 (abfd, code, contents + offset);
655 bfd_put_8 (abfd, new_value, contents + offset + 1);
656 if (start_offset != offset)
657 {
658 m68hc11_elf_relax_delete_bytes (abfd, sec, start_offset,
659 offset - start_offset);
660 end_group--;
661 }
662 }
663 else
664 {
665 can_delete_ldx = 0;
666 }
667 offset = start_offset + isize;
668 }
669 if (can_delete_ldx)
670 {
671 /* Remove the move instruction (3 or 4 bytes win). */
672 m68hc11_elf_relax_delete_bytes (abfd, sec, ldx_offset, ldx_size);
673 }
674 }
675
676 /* This function handles relaxing for the 68HC11.
677
678
679 and somewhat more difficult to support. */
680
681 static bfd_boolean
682 m68hc11_elf_relax_section (bfd *abfd, asection *sec,
683 struct bfd_link_info *link_info, bfd_boolean *again)
684 {
685 Elf_Internal_Shdr *symtab_hdr;
686 Elf_Internal_Rela *internal_relocs;
687 Elf_Internal_Rela *free_relocs = NULL;
688 Elf_Internal_Rela *irel, *irelend;
689 bfd_byte *contents = NULL;
690 bfd_byte *free_contents = NULL;
691 Elf32_External_Sym *free_extsyms = NULL;
692 Elf_Internal_Rela *prev_insn_branch = NULL;
693 Elf_Internal_Rela *prev_insn_group = NULL;
694 unsigned insn_group_value = 0;
695 Elf_Internal_Sym *isymbuf = NULL;
696
697 /* Assume nothing changes. */
698 *again = FALSE;
699
700 /* We don't have to do anything for a relocatable link, if
701 this section does not have relocs, or if this is not a
702 code section. */
703 if (bfd_link_relocatable (link_info)
704 || (sec->flags & SEC_RELOC) == 0
705 || sec->reloc_count == 0
706 || (sec->flags & SEC_CODE) == 0)
707 return TRUE;
708
709 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
710
711 /* Get a copy of the native relocations. */
712 internal_relocs = (_bfd_elf_link_read_relocs
713 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
714 link_info->keep_memory));
715 if (internal_relocs == NULL)
716 goto error_return;
717 if (! link_info->keep_memory)
718 free_relocs = internal_relocs;
719
720 /* Checking for branch relaxation relies on the relocations to
721 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
722 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
723 compare_reloc);
724
725 /* Walk through them looking for relaxing opportunities. */
726 irelend = internal_relocs + sec->reloc_count;
727 for (irel = internal_relocs; irel < irelend; irel++)
728 {
729 bfd_vma symval;
730 bfd_vma value;
731 Elf_Internal_Sym *isym;
732 asection *sym_sec;
733 int is_far = 0;
734
735 /* If this isn't something that can be relaxed, then ignore
736 this reloc. */
737 if (ELF32_R_TYPE (irel->r_info) != (int) R_M68HC11_16
738 && ELF32_R_TYPE (irel->r_info) != (int) R_M68HC11_RL_JUMP
739 && ELF32_R_TYPE (irel->r_info) != (int) R_M68HC11_RL_GROUP)
740 {
741 prev_insn_branch = 0;
742 prev_insn_group = 0;
743 continue;
744 }
745
746 /* Get the section contents if we haven't done so already. */
747 if (contents == NULL)
748 {
749 /* Get cached copy if it exists. */
750 if (elf_section_data (sec)->this_hdr.contents != NULL)
751 contents = elf_section_data (sec)->this_hdr.contents;
752 else
753 {
754 /* Go get them off disk. */
755 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
756 goto error_return;
757 }
758 }
759
760 /* Try to eliminate an unconditional 8 bit pc-relative branch
761 which immediately follows a conditional 8 bit pc-relative
762 branch around the unconditional branch.
763
764 original: new:
765 bCC lab1 bCC' lab2
766 bra lab2
767 lab1: lab1:
768
769 This happens when the bCC can't reach lab2 at assembly time,
770 but due to other relaxations it can reach at link time. */
771 if (ELF32_R_TYPE (irel->r_info) == (int) R_M68HC11_RL_JUMP)
772 {
773 Elf_Internal_Rela *nrel;
774 unsigned char code;
775 unsigned char roffset;
776
777 prev_insn_branch = 0;
778 prev_insn_group = 0;
779
780 /* Do nothing if this reloc is the last byte in the section. */
781 if (irel->r_offset + 2 >= sec->size)
782 continue;
783
784 /* See if the next instruction is an unconditional pc-relative
785 branch, more often than not this test will fail, so we
786 test it first to speed things up. */
787 code = bfd_get_8 (abfd, contents + irel->r_offset + 2);
788 if (code != 0x7e)
789 continue;
790
791 /* Also make sure the next relocation applies to the next
792 instruction and that it's a pc-relative 8 bit branch. */
793 nrel = irel + 1;
794 if (nrel == irelend
795 || irel->r_offset + 3 != nrel->r_offset
796 || ELF32_R_TYPE (nrel->r_info) != (int) R_M68HC11_16)
797 continue;
798
799 /* Make sure our destination immediately follows the
800 unconditional branch. */
801 roffset = bfd_get_8 (abfd, contents + irel->r_offset + 1);
802 if (roffset != 3)
803 continue;
804
805 prev_insn_branch = irel;
806 prev_insn_group = 0;
807 continue;
808 }
809
810 /* Read this BFD's symbols if we haven't done so already. */
811 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
812 {
813 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
814 if (isymbuf == NULL)
815 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
816 symtab_hdr->sh_info, 0,
817 NULL, NULL, NULL);
818 if (isymbuf == NULL)
819 goto error_return;
820 }
821
822 /* Get the value of the symbol referred to by the reloc. */
823 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
824 {
825 /* A local symbol. */
826 isym = isymbuf + ELF32_R_SYM (irel->r_info);
827 is_far = isym->st_other & STO_M68HC12_FAR;
828 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
829 symval = (isym->st_value
830 + sym_sec->output_section->vma
831 + sym_sec->output_offset);
832 }
833 else
834 {
835 unsigned long indx;
836 struct elf_link_hash_entry *h;
837
838 /* An external symbol. */
839 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
840 h = elf_sym_hashes (abfd)[indx];
841 BFD_ASSERT (h != NULL);
842 if (h->root.type != bfd_link_hash_defined
843 && h->root.type != bfd_link_hash_defweak)
844 {
845 /* This appears to be a reference to an undefined
846 symbol. Just ignore it--it will be caught by the
847 regular reloc processing. */
848 prev_insn_branch = 0;
849 prev_insn_group = 0;
850 continue;
851 }
852
853 is_far = h->other & STO_M68HC12_FAR;
854 isym = 0;
855 sym_sec = h->root.u.def.section;
856 symval = (h->root.u.def.value
857 + sym_sec->output_section->vma
858 + sym_sec->output_offset);
859 }
860
861 if (ELF32_R_TYPE (irel->r_info) == (int) R_M68HC11_RL_GROUP)
862 {
863 prev_insn_branch = 0;
864 prev_insn_group = 0;
865
866 /* Do nothing if this reloc is the last byte in the section. */
867 if (irel->r_offset == sec->size)
868 continue;
869
870 prev_insn_group = irel;
871 insn_group_value = isym->st_value;
872 continue;
873 }
874
875 /* When we relax some bytes, the size of our section changes.
876 This affects the layout of next input sections that go in our
877 output section. When the symbol is part of another section that
878 will go in the same output section as the current one, it's
879 final address may now be incorrect (too far). We must let the
880 linker re-compute all section offsets before processing this
881 reloc. Code example:
882
883 Initial Final
884 .sect .text section size = 6 section size = 4
885 jmp foo
886 jmp bar
887 .sect .text.foo_bar output_offset = 6 output_offset = 4
888 foo: rts
889 bar: rts
890
891 If we process the reloc now, the jmp bar is replaced by a
892 relative branch to the initial bar address (output_offset 6). */
893 if (*again && sym_sec != sec
894 && sym_sec->output_section == sec->output_section)
895 {
896 prev_insn_group = 0;
897 prev_insn_branch = 0;
898 continue;
899 }
900
901 value = symval;
902 /* Try to turn a far branch to a near branch. */
903 if (ELF32_R_TYPE (irel->r_info) == (int) R_M68HC11_16
904 && prev_insn_branch)
905 {
906 bfd_vma offset;
907 unsigned char code;
908
909 offset = value - (prev_insn_branch->r_offset
910 + sec->output_section->vma
911 + sec->output_offset + 2);
912
913 /* If the offset is still out of -128..+127 range,
914 leave that far branch unchanged. */
915 if ((offset & 0xff80) != 0 && (offset & 0xff80) != 0xff80)
916 {
917 prev_insn_branch = 0;
918 continue;
919 }
920
921 /* Shrink the branch. */
922 code = bfd_get_8 (abfd, contents + prev_insn_branch->r_offset);
923 if (code == 0x7e)
924 {
925 code = 0x20;
926 bfd_put_8 (abfd, code, contents + prev_insn_branch->r_offset);
927 bfd_put_8 (abfd, 0xff,
928 contents + prev_insn_branch->r_offset + 1);
929 irel->r_offset = prev_insn_branch->r_offset + 1;
930 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
931 R_M68HC11_PCREL_8);
932 m68hc11_elf_relax_delete_bytes (abfd, sec,
933 irel->r_offset + 1, 1);
934 }
935 else
936 {
937 code ^= 0x1;
938 bfd_put_8 (abfd, code, contents + prev_insn_branch->r_offset);
939 bfd_put_8 (abfd, 0xff,
940 contents + prev_insn_branch->r_offset + 1);
941 irel->r_offset = prev_insn_branch->r_offset + 1;
942 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
943 R_M68HC11_PCREL_8);
944 m68hc11_elf_relax_delete_bytes (abfd, sec,
945 irel->r_offset + 1, 3);
946 }
947 prev_insn_branch = 0;
948 *again = TRUE;
949 }
950
951 /* Try to turn a 16 bit address into a 8 bit page0 address. */
952 else if (ELF32_R_TYPE (irel->r_info) == (int) R_M68HC11_16
953 && (value & 0xff00) == 0)
954 {
955 unsigned char code;
956 unsigned short offset;
957 struct m68hc11_direct_relax *rinfo;
958
959 prev_insn_branch = 0;
960 offset = bfd_get_16 (abfd, contents + irel->r_offset);
961 offset += value;
962 if ((offset & 0xff00) != 0)
963 {
964 prev_insn_group = 0;
965 continue;
966 }
967
968 if (prev_insn_group)
969 {
970 unsigned long old_sec_size = sec->size;
971
972 /* Note that we've changed the relocation contents, etc. */
973 elf_section_data (sec)->relocs = internal_relocs;
974 free_relocs = NULL;
975
976 elf_section_data (sec)->this_hdr.contents = contents;
977 free_contents = NULL;
978
979 symtab_hdr->contents = (bfd_byte *) isymbuf;
980 free_extsyms = NULL;
981
982 m68hc11_relax_group (abfd, sec, contents, offset,
983 prev_insn_group->r_offset,
984 insn_group_value);
985 irel = prev_insn_group;
986 prev_insn_group = 0;
987 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
988 R_M68HC11_NONE);
989 if (sec->size != old_sec_size)
990 *again = TRUE;
991 continue;
992 }
993
994 /* Get the opcode. */
995 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
996 rinfo = find_relaxable_insn (code);
997 if (rinfo == 0)
998 {
999 prev_insn_group = 0;
1000 continue;
1001 }
1002
1003 /* Note that we've changed the relocation contents, etc. */
1004 elf_section_data (sec)->relocs = internal_relocs;
1005 free_relocs = NULL;
1006
1007 elf_section_data (sec)->this_hdr.contents = contents;
1008 free_contents = NULL;
1009
1010 symtab_hdr->contents = (bfd_byte *) isymbuf;
1011 free_extsyms = NULL;
1012
1013 /* Fix the opcode. */
1014 /* printf ("A relaxable case : 0x%02x (%s)\n",
1015 code, rinfo->name); */
1016 bfd_put_8 (abfd, rinfo->direct_code,
1017 contents + irel->r_offset - 1);
1018
1019 /* Delete one byte of data (upper byte of address). */
1020 m68hc11_elf_relax_delete_bytes (abfd, sec, irel->r_offset, 1);
1021
1022 /* Fix the relocation's type. */
1023 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1024 R_M68HC11_8);
1025
1026 /* That will change things, so, we should relax again. */
1027 *again = TRUE;
1028 }
1029 else if (ELF32_R_TYPE (irel->r_info) == R_M68HC11_16 && !is_far)
1030 {
1031 unsigned char code;
1032 bfd_vma offset;
1033
1034 prev_insn_branch = 0;
1035 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1036 if (code == 0x7e || code == 0xbd)
1037 {
1038 offset = value - (irel->r_offset
1039 + sec->output_section->vma
1040 + sec->output_offset + 1);
1041 offset += bfd_get_16 (abfd, contents + irel->r_offset);
1042
1043 /* If the offset is still out of -128..+127 range,
1044 leave that far branch unchanged. */
1045 if ((offset & 0xff80) == 0 || (offset & 0xff80) == 0xff80)
1046 {
1047
1048 /* Note that we've changed the relocation contents, etc. */
1049 elf_section_data (sec)->relocs = internal_relocs;
1050 free_relocs = NULL;
1051
1052 elf_section_data (sec)->this_hdr.contents = contents;
1053 free_contents = NULL;
1054
1055 symtab_hdr->contents = (bfd_byte *) isymbuf;
1056 free_extsyms = NULL;
1057
1058 /* Shrink the branch. */
1059 code = (code == 0x7e) ? 0x20 : 0x8d;
1060 bfd_put_8 (abfd, code,
1061 contents + irel->r_offset - 1);
1062 bfd_put_8 (abfd, 0xff,
1063 contents + irel->r_offset);
1064 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1065 R_M68HC11_PCREL_8);
1066 m68hc11_elf_relax_delete_bytes (abfd, sec,
1067 irel->r_offset + 1, 1);
1068 /* That will change things, so, we should relax again. */
1069 *again = TRUE;
1070 }
1071 }
1072 }
1073 prev_insn_branch = 0;
1074 prev_insn_group = 0;
1075 }
1076
1077 if (free_relocs != NULL)
1078 {
1079 free (free_relocs);
1080 free_relocs = NULL;
1081 }
1082
1083 if (free_contents != NULL)
1084 {
1085 if (! link_info->keep_memory)
1086 free (free_contents);
1087 else
1088 {
1089 /* Cache the section contents for elf_link_input_bfd. */
1090 elf_section_data (sec)->this_hdr.contents = contents;
1091 }
1092 free_contents = NULL;
1093 }
1094
1095 if (free_extsyms != NULL)
1096 {
1097 if (! link_info->keep_memory)
1098 free (free_extsyms);
1099 else
1100 {
1101 /* Cache the symbols for elf_link_input_bfd. */
1102 symtab_hdr->contents = (unsigned char *) isymbuf;
1103 }
1104 free_extsyms = NULL;
1105 }
1106
1107 return TRUE;
1108
1109 error_return:
1110 if (free_relocs != NULL)
1111 free (free_relocs);
1112 if (free_contents != NULL)
1113 free (free_contents);
1114 if (free_extsyms != NULL)
1115 free (free_extsyms);
1116 return FALSE;
1117 }
1118
1119 /* Delete some bytes from a section while relaxing. */
1120
1121 static void
1122 m68hc11_elf_relax_delete_bytes (bfd *abfd, asection *sec,
1123 bfd_vma addr, int count)
1124 {
1125 Elf_Internal_Shdr *symtab_hdr;
1126 unsigned int sec_shndx;
1127 bfd_byte *contents;
1128 Elf_Internal_Rela *irel, *irelend;
1129 bfd_vma toaddr;
1130 Elf_Internal_Sym *isymbuf, *isym, *isymend;
1131 struct elf_link_hash_entry **sym_hashes;
1132 struct elf_link_hash_entry **end_hashes;
1133 unsigned int symcount;
1134
1135 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1136 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1137
1138 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1139
1140 contents = elf_section_data (sec)->this_hdr.contents;
1141
1142 toaddr = sec->size;
1143
1144 irel = elf_section_data (sec)->relocs;
1145 irelend = irel + sec->reloc_count;
1146
1147 /* Actually delete the bytes. */
1148 memmove (contents + addr, contents + addr + count,
1149 (size_t) (toaddr - addr - count));
1150
1151 sec->size -= count;
1152
1153 /* Adjust all the relocs. */
1154 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1155 {
1156 unsigned char code;
1157 unsigned char offset;
1158 unsigned short raddr;
1159 unsigned long old_offset;
1160 int branch_pos;
1161
1162 old_offset = irel->r_offset;
1163
1164 /* See if this reloc was for the bytes we have deleted, in which
1165 case we no longer care about it. Don't delete relocs which
1166 represent addresses, though. */
1167 if (ELF32_R_TYPE (irel->r_info) != R_M68HC11_RL_JUMP
1168 && irel->r_offset >= addr && irel->r_offset < addr + count)
1169 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1170 R_M68HC11_NONE);
1171
1172 if (ELF32_R_TYPE (irel->r_info) == R_M68HC11_NONE)
1173 continue;
1174
1175 /* Get the new reloc address. */
1176 if ((irel->r_offset > addr
1177 && irel->r_offset < toaddr))
1178 irel->r_offset -= count;
1179
1180 /* If this is a PC relative reloc, see if the range it covers
1181 includes the bytes we have deleted. */
1182 switch (ELF32_R_TYPE (irel->r_info))
1183 {
1184 default:
1185 break;
1186
1187 case R_M68HC11_RL_JUMP:
1188 code = bfd_get_8 (abfd, contents + irel->r_offset);
1189 switch (code)
1190 {
1191 /* jsr and jmp instruction are also marked with RL_JUMP
1192 relocs but no adjustment must be made. */
1193 case 0x7e:
1194 case 0x9d:
1195 case 0xbd:
1196 continue;
1197
1198 case 0x12:
1199 case 0x13:
1200 branch_pos = 3;
1201 raddr = 4;
1202
1203 /* Special case when we translate a brclr N,y into brclr *<addr>
1204 In this case, the 0x18 page2 prefix is removed.
1205 The reloc offset is not modified but the instruction
1206 size is reduced by 1. */
1207 if (old_offset == addr)
1208 raddr++;
1209 break;
1210
1211 case 0x1e:
1212 case 0x1f:
1213 branch_pos = 3;
1214 raddr = 4;
1215 break;
1216
1217 case 0x18:
1218 branch_pos = 4;
1219 raddr = 5;
1220 break;
1221
1222 default:
1223 branch_pos = 1;
1224 raddr = 2;
1225 break;
1226 }
1227 offset = bfd_get_8 (abfd, contents + irel->r_offset + branch_pos);
1228 raddr += old_offset;
1229 raddr += ((unsigned short) offset | ((offset & 0x80) ? 0xff00 : 0));
1230 if (irel->r_offset < addr && raddr > addr)
1231 {
1232 offset -= count;
1233 bfd_put_8 (abfd, offset, contents + irel->r_offset + branch_pos);
1234 }
1235 else if (irel->r_offset >= addr && raddr <= addr)
1236 {
1237 offset += count;
1238 bfd_put_8 (abfd, offset, contents + irel->r_offset + branch_pos);
1239 }
1240 else
1241 {
1242 /*printf ("Not adjusted 0x%04x [0x%4x 0x%4x]\n", raddr,
1243 irel->r_offset, addr);*/
1244 }
1245
1246 break;
1247 }
1248 }
1249
1250 /* Adjust the local symbols defined in this section. */
1251 isymend = isymbuf + symtab_hdr->sh_info;
1252 for (isym = isymbuf; isym < isymend; isym++)
1253 {
1254 if (isym->st_shndx == sec_shndx
1255 && isym->st_value > addr
1256 && isym->st_value <= toaddr)
1257 isym->st_value -= count;
1258 }
1259
1260 /* Now adjust the global symbols defined in this section. */
1261 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1262 - symtab_hdr->sh_info);
1263 sym_hashes = elf_sym_hashes (abfd);
1264 end_hashes = sym_hashes + symcount;
1265 for (; sym_hashes < end_hashes; sym_hashes++)
1266 {
1267 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1268 if ((sym_hash->root.type == bfd_link_hash_defined
1269 || sym_hash->root.type == bfd_link_hash_defweak)
1270 && sym_hash->root.u.def.section == sec
1271 && sym_hash->root.u.def.value > addr
1272 && sym_hash->root.u.def.value <= toaddr)
1273 {
1274 sym_hash->root.u.def.value -= count;
1275 }
1276 }
1277 }
1278
1279 /* Specific sections:
1280 - The .page0 is a data section that is mapped in [0x0000..0x00FF].
1281 Page0 accesses are faster on the M68HC11. Soft registers used by GCC-m6811
1282 are located in .page0.
1283 - The .vectors is the section that represents the interrupt
1284 vectors. */
1285 static const struct bfd_elf_special_section elf32_m68hc11_special_sections[] =
1286 {
1287 { STRING_COMMA_LEN (".eeprom"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1288 { STRING_COMMA_LEN (".page0"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1289 { STRING_COMMA_LEN (".softregs"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
1290 { STRING_COMMA_LEN (".vectors"), 0, SHT_PROGBITS, SHF_ALLOC },
1291 { NULL, 0, 0, 0, 0 }
1292 };
1293 \f
1294 #define ELF_ARCH bfd_arch_m68hc11
1295 #define ELF_TARGET_ID M68HC11_ELF_DATA
1296 #define ELF_MACHINE_CODE EM_68HC11
1297 #define ELF_MAXPAGESIZE 0x1000
1298
1299 #define TARGET_BIG_SYM m68hc11_elf32_vec
1300 #define TARGET_BIG_NAME "elf32-m68hc11"
1301
1302 #define elf_info_to_howto NULL
1303 #define elf_info_to_howto_rel m68hc11_info_to_howto_rel
1304 #define bfd_elf32_bfd_relax_section m68hc11_elf_relax_section
1305 #define elf_backend_check_relocs elf32_m68hc11_check_relocs
1306 #define elf_backend_relocate_section elf32_m68hc11_relocate_section
1307 #define elf_backend_add_symbol_hook elf32_m68hc11_add_symbol_hook
1308 #define elf_backend_object_p 0
1309 #define elf_backend_final_write_processing 0
1310 #define elf_backend_can_gc_sections 1
1311 #define elf_backend_special_sections elf32_m68hc11_special_sections
1312 #define elf_backend_merge_symbol_attribute elf32_m68hc11_merge_symbol_attribute
1313
1314 #define bfd_elf32_bfd_link_hash_table_create \
1315 m68hc11_elf_bfd_link_hash_table_create
1316 #define bfd_elf32_bfd_merge_private_bfd_data \
1317 _bfd_m68hc11_elf_merge_private_bfd_data
1318 #define bfd_elf32_bfd_set_private_flags _bfd_m68hc11_elf_set_private_flags
1319 #define bfd_elf32_bfd_print_private_bfd_data \
1320 _bfd_m68hc11_elf_print_private_bfd_data
1321
1322 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.