1 /* BFD back-end for Hitachi H8/300 COFF binaries.
2 Copyright 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
3 Written by Steve Chamberlain, <sac@cygnus.com>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "coff/h8300.h"
28 #include "coff/internal.h"
31 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (1)
33 /* We derive a hash table from the basic BFD hash table to
34 hold entries in the function vector. Aside from the
35 info stored by the basic hash table, we need the offset
36 of a particular entry within the hash table as well as
37 the offset where we'll add the next entry. */
39 struct funcvec_hash_entry
41 /* The basic hash table entry. */
42 struct bfd_hash_entry root
;
44 /* The offset within the vectors section where
49 struct funcvec_hash_table
51 /* The basic hash table. */
52 struct bfd_hash_table root
;
56 /* Offset at which we'll add the next entry. */
60 static struct bfd_hash_entry
*
62 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
65 funcvec_hash_table_init
66 PARAMS ((struct funcvec_hash_table
*, bfd
*,
67 struct bfd_hash_entry
*(*) PARAMS ((struct bfd_hash_entry
*,
68 struct bfd_hash_table
*,
71 /* To lookup a value in the function vector hash table. */
72 #define funcvec_hash_lookup(table, string, create, copy) \
73 ((struct funcvec_hash_entry *) \
74 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
76 /* The derived h8300 COFF linker table. Note it's derived from
77 the generic linker hash table, not the COFF backend linker hash
78 table! We use this to attach additional data structures we
79 need while linking on the h8300. */
80 struct h8300_coff_link_hash_table
82 /* The main hash table. */
83 struct generic_link_hash_table root
;
85 /* Section for the vectors table. This gets attached to a
86 random input bfd, we keep it here for easy access. */
87 asection
*vectors_sec
;
89 /* Hash table of the functions we need to enter into the function
91 struct funcvec_hash_table
*funcvec_hash_table
;
94 static struct bfd_link_hash_table
*h8300_coff_link_hash_table_create
97 /* Get the H8/300 COFF linker hash table from a link_info structure. */
99 #define h8300_coff_hash_table(p) \
100 ((struct h8300_coff_link_hash_table *) ((coff_hash_table (p))))
102 /* Initialize fields within a funcvec hash table entry. Called whenever
103 a new entry is added to the funcvec hash table. */
105 static struct bfd_hash_entry
*
106 funcvec_hash_newfunc (entry
, gen_table
, string
)
107 struct bfd_hash_entry
*entry
;
108 struct bfd_hash_table
*gen_table
;
111 struct funcvec_hash_entry
*ret
;
112 struct funcvec_hash_table
*table
;
114 ret
= (struct funcvec_hash_entry
*) entry
;
115 table
= (struct funcvec_hash_table
*) gen_table
;
117 /* Allocate the structure if it has not already been allocated by a
120 ret
= ((struct funcvec_hash_entry
*)
121 bfd_hash_allocate (gen_table
,
122 sizeof (struct funcvec_hash_entry
)));
126 /* Call the allocation method of the superclass. */
127 ret
= ((struct funcvec_hash_entry
*)
128 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, gen_table
, string
));
133 /* Note where this entry will reside in the function vector table. */
134 ret
->offset
= table
->offset
;
136 /* Bump the offset at which we store entries in the function
137 vector. We'd like to bump up the size of the vectors section,
138 but it's not easily available here. */
139 if (bfd_get_mach (table
->abfd
) == bfd_mach_h8300
)
141 else if (bfd_get_mach (table
->abfd
) == bfd_mach_h8300h
)
146 /* Everything went OK. */
147 return (struct bfd_hash_entry
*) ret
;
150 /* Initialize the function vector hash table. */
153 funcvec_hash_table_init (table
, abfd
, newfunc
)
154 struct funcvec_hash_table
*table
;
156 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
157 struct bfd_hash_table
*,
160 /* Initialize our local fields, then call the generic initialization
164 return (bfd_hash_table_init (&table
->root
, newfunc
));
167 /* Create the derived linker hash table. We use a derived hash table
168 basically to hold "static" information during an h8/300 coff link
169 without using static variables. */
171 static struct bfd_link_hash_table
*
172 h8300_coff_link_hash_table_create (abfd
)
175 struct h8300_coff_link_hash_table
*ret
;
176 ret
= ((struct h8300_coff_link_hash_table
*)
177 bfd_alloc (abfd
, sizeof (struct h8300_coff_link_hash_table
)));
180 if (!_bfd_link_hash_table_init (&ret
->root
.root
, abfd
, _bfd_generic_link_hash_newfunc
))
182 bfd_release (abfd
, ret
);
186 /* Initialize our data. */
187 ret
->vectors_sec
= NULL
;
188 ret
->funcvec_hash_table
= NULL
;
190 /* OK. Everything's intialized, return the base pointer. */
191 return &ret
->root
.root
;
194 /* special handling for H8/300 relocs.
195 We only come here for pcrel stuff and return normally if not an -r link.
196 When doing -r, we can't do any arithmetic for the pcrel stuff, because
197 the code in reloc.c assumes that we can manipulate the targets of
198 the pcrel branches. This isn't so, since the H8/300 can do relaxing,
199 which means that the gap after the instruction may not be enough to
200 contain the offset required for the branch, so we have to use the only
201 the addend until the final link */
203 static bfd_reloc_status_type
204 special (abfd
, reloc_entry
, symbol
, data
, input_section
, output_bfd
,
207 arelent
*reloc_entry
;
210 asection
*input_section
;
212 char **error_message
;
214 if (output_bfd
== (bfd
*) NULL
)
215 return bfd_reloc_continue
;
220 static reloc_howto_type howto_table
[] =
222 HOWTO (R_RELBYTE
, 0, 0, 8, false, 0, complain_overflow_bitfield
, special
, "8", false, 0x000000ff, 0x000000ff, false),
223 HOWTO (R_RELWORD
, 0, 1, 16, false, 0, complain_overflow_bitfield
, special
, "16", false, 0x0000ffff, 0x0000ffff, false),
224 HOWTO (R_RELLONG
, 0, 2, 32, false, 0, complain_overflow_bitfield
, special
, "32", false, 0xffffffff, 0xffffffff, false),
225 HOWTO (R_PCRBYTE
, 0, 0, 8, true, 0, complain_overflow_signed
, special
, "DISP8", false, 0x000000ff, 0x000000ff, true),
226 HOWTO (R_PCRWORD
, 0, 1, 16, true, 0, complain_overflow_signed
, special
, "DISP16", false, 0x0000ffff, 0x0000ffff, true),
227 HOWTO (R_PCRLONG
, 0, 2, 32, true, 0, complain_overflow_signed
, special
, "DISP32", false, 0xffffffff, 0xffffffff, true),
228 HOWTO (R_MOVB1
, 0, 1, 16, false, 0, complain_overflow_bitfield
, special
, "16/8", false, 0x0000ffff, 0x0000ffff, false),
229 HOWTO (R_MOVB2
, 0, 1, 16, false, 0, complain_overflow_bitfield
, special
, "8/16", false, 0x0000ffff, 0x0000ffff, false),
230 HOWTO (R_JMP1
, 0, 1, 16, false, 0, complain_overflow_bitfield
, special
, "16/pcrel", false, 0x0000ffff, 0x0000ffff, false),
231 HOWTO (R_JMP2
, 0, 0, 8, false, 0, complain_overflow_bitfield
, special
, "pcrecl/16", false, 0x000000ff, 0x000000ff, false),
234 HOWTO (R_JMPL1
, 0, 2, 32, false, 0, complain_overflow_bitfield
, special
, "24/pcrell", false, 0x00ffffff, 0x00ffffff, false),
235 HOWTO (R_JMPL_B8
, 0, 0, 8, false, 0, complain_overflow_bitfield
, special
, "pc8/24", false, 0x000000ff, 0x000000ff, false),
237 HOWTO (R_MOVLB1
, 0, 1, 16, false, 0, complain_overflow_bitfield
,special
, "24/8", false, 0x0000ffff, 0x0000ffff, false),
238 HOWTO (R_MOVLB2
, 0, 1, 16, false, 0, complain_overflow_bitfield
, special
, "8/24", false, 0x0000ffff, 0x0000ffff, false),
240 /* An indirect reference to a function. This causes the function's address
241 to be added to the function vector in lo-mem and puts the address of
242 the function vector's entry in the jsr instruction. */
243 HOWTO (R_MEM_INDIRECT
, 0, 0, 8, false, 0, complain_overflow_bitfield
, special
, "8/indirect", false, 0x000000ff, 0x000000ff, false),
245 /* Internal reloc for relaxing. This is created when a 16bit pc-relative
246 branch is turned into an 8bit pc-relative branch. */
247 HOWTO (R_PCRWORD_B
, 0, 0, 8, true, 0, complain_overflow_bitfield
, special
, "pcrecl/16", false, 0x000000ff, 0x000000ff, false),
251 /* Turn a howto into a reloc number */
253 #define SELECT_RELOC(x,howto) \
254 { x.r_type = select_reloc(howto); }
256 #define BADMAG(x) (H8300BADMAG(x)&& H8300HBADMAG(x))
257 #define H8300 1 /* Customize coffcode.h */
258 #define __A_MAGIC_SET__
262 /* Code to swap in the reloc */
263 #define SWAP_IN_RELOC_OFFSET bfd_h_get_32
264 #define SWAP_OUT_RELOC_OFFSET bfd_h_put_32
265 #define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \
266 dst->r_stuff[0] = 'S'; \
267 dst->r_stuff[1] = 'C';
272 reloc_howto_type
*howto
;
277 /* Code to turn a r_type into a howto ptr, uses the above howto table
281 rtype2howto (internal
, dst
)
283 struct internal_reloc
*dst
;
288 internal
->howto
= howto_table
+ 0;
291 internal
->howto
= howto_table
+ 1;
294 internal
->howto
= howto_table
+ 2;
297 internal
->howto
= howto_table
+ 3;
300 internal
->howto
= howto_table
+ 4;
303 internal
->howto
= howto_table
+ 5;
306 internal
->howto
= howto_table
+ 6;
309 internal
->howto
= howto_table
+ 7;
312 internal
->howto
= howto_table
+ 8;
315 internal
->howto
= howto_table
+ 9;
318 internal
->howto
= howto_table
+ 10;
321 internal
->howto
= howto_table
+ 11;
324 internal
->howto
= howto_table
+ 12;
327 internal
->howto
= howto_table
+ 13;
330 internal
->howto
= howto_table
+ 14;
333 internal
->howto
= howto_table
+ 15;
341 #define RTYPE2HOWTO(internal, relocentry) rtype2howto(internal,relocentry)
344 /* Perform any necessaru magic to the addend in a reloc entry */
347 #define CALC_ADDEND(abfd, symbol, ext_reloc, cache_ptr) \
348 cache_ptr->addend = ext_reloc.r_offset;
351 #define RELOC_PROCESSING(relent,reloc,symbols,abfd,section) \
352 reloc_processing(relent, reloc, symbols, abfd, section)
355 reloc_processing (relent
, reloc
, symbols
, abfd
, section
)
357 struct internal_reloc
*reloc
;
362 relent
->address
= reloc
->r_vaddr
;
363 rtype2howto (relent
, reloc
);
365 if (((int) reloc
->r_symndx
) > 0)
367 relent
->sym_ptr_ptr
= symbols
+ obj_convert (abfd
)[reloc
->r_symndx
];
371 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
376 relent
->addend
= reloc
->r_offset
;
378 relent
->address
-= section
->vma
;
379 /* relent->section = 0;*/
384 h8300_reloc16_estimate(abfd
, input_section
, reloc
, shrink
, link_info
)
386 asection
*input_section
;
389 struct bfd_link_info
*link_info
;
395 /* The address of the thing to be relocated will have moved back by
396 the size of the shrink - but we don't change reloc->address here,
397 since we need it to know where the relocation lives in the source
400 /* reloc->address -= shrink; conceptual */
402 bfd_vma address
= reloc
->address
- shrink
;
405 switch (reloc
->howto
->type
)
413 /* Thing is a move one byte */
415 value
= bfd_coff_reloc16_get_value(reloc
, link_info
, input_section
);
420 /* Change the reloc type from 16bit, possible 8 to 8bit
422 reloc
->howto
= reloc
->howto
+ 1;
423 /* The place to relc moves back by one */
424 /* This will be two bytes smaller in the long run */
426 bfd_perform_slip(abfd
, 2, input_section
, address
);
430 /* This is the 24 bit branch which could become an 8 bitter,
431 the relocation points to the first byte of the insn, not the
435 value
= bfd_coff_reloc16_get_value(reloc
, link_info
, input_section
);
437 dot
= input_section
->output_section
->vma
+
438 input_section
->output_offset
+ address
;
440 /* See if the address we're looking at within 127 bytes of where
441 we are, if so then we can use a small branch rather than the
442 jump we were going to */
446 if (-120 < (long)gap
&& (long)gap
< 120 )
449 /* Change the reloc type from 24bit, possible 8 to 8bit
451 reloc
->howto
= reloc
->howto
+ 1;
452 /* This will be two bytes smaller in the long run */
454 bfd_perform_slip(abfd
, 2, input_section
, address
);
460 value
= bfd_coff_reloc16_get_value(reloc
, link_info
, input_section
);
462 dot
= input_section
->output_section
->vma
+
463 input_section
->output_offset
+ address
;
465 /* See if the address we're looking at within 127 bytes of where
466 we are, if so then we can use a small branch rather than the
467 jump we were going to */
469 gap
= value
- (dot
- shrink
);
472 if (-120 < (long)gap
&& (long)gap
< 120 )
475 /* Change the reloc type from 16bit, possible 8 to 8bit
477 reloc
->howto
= reloc
->howto
+ 1;
478 /* The place to relc moves back by one */
480 /* This will be two bytes smaller in the long run */
482 bfd_perform_slip(abfd
, 2, input_section
, address
);
488 value
= bfd_coff_reloc16_get_value(reloc
, link_info
, input_section
);
490 dot
= input_section
->output_section
->vma
+
491 input_section
->output_offset
+ address
- 2;
493 /* See if the address we're looking at within 127 bytes of where
494 we are, if so then we can use a small branch rather than the
495 jump we were going to */
497 gap
= value
- (dot
- shrink
);
500 if (-120 < (long)gap
&& (long)gap
< 120 )
503 /* Change the reloc type from 16bit, possible 8 to 8bit
505 reloc
->howto
= howto_table
+ 15;
506 /* The place to relc moves back by one */
508 /* This will be two bytes smaller in the long run */
510 bfd_perform_slip(abfd
, 2, input_section
, address
);
519 /* First phase of a relaxing link */
523 R_MOVB1 R_MOVB2 mov.b with 16bit or 8 bit address
524 R_JMP1 R_JMP2 jmp or pcrel branch
525 R_JMPL1 R_JMPL_B8 24jmp or pcrel branch
526 R_MOVLB1 R_MOVLB2 24 or 8 bit reloc for mov.b
527 R_PCRWORD R_PCRWORD_B 8 bit pcrel branch from 16bit pcrel
534 h8300_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
537 struct bfd_link_info
*link_info
;
538 struct bfd_link_order
*link_order
;
541 unsigned int *src_ptr
;
542 unsigned int *dst_ptr
;
544 unsigned int src_address
= *src_ptr
;
545 unsigned int dst_address
= *dst_ptr
;
546 asection
*input_section
= link_order
->u
.indirect
.section
;
548 switch (reloc
->howto
->type
)
550 /* A 24 bit branch which could be a 8 bit pcrel, really pointing to
551 the byte before the 24bit hole, so we can treat it as a 32bit pointer */
554 bfd_vma dot
= link_order
->offset
556 + link_order
->u
.indirect
.section
->output_section
->vma
;
557 int gap
= (bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
)
559 if (gap
> 127 || gap
< -128)
561 if (! ((*link_info
->callbacks
->reloc_overflow
)
562 (link_info
, bfd_asymbol_name (*reloc
->sym_ptr_ptr
),
563 reloc
->howto
->name
, reloc
->addend
, input_section
->owner
,
564 input_section
, reloc
->address
)))
568 bfd_put_8 (abfd
, gap
, data
+ dst_address
);
576 bfd_vma dot
= link_order
->offset
578 + link_order
->u
.indirect
.section
->output_section
->vma
;
579 int gap
= (bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
)
581 if (gap
> 32767 || gap
< -32768)
583 if (! ((*link_info
->callbacks
->reloc_overflow
)
584 (link_info
, bfd_asymbol_name (*reloc
->sym_ptr_ptr
),
585 reloc
->howto
->name
, reloc
->addend
, input_section
->owner
,
586 input_section
, reloc
->address
)))
590 bfd_put_16 (abfd
, gap
, data
+ dst_address
);
599 unsigned int gap
= bfd_coff_reloc16_get_value (reloc
, link_info
,
602 || (gap
>= 0x0000ff00
603 && gap
<= 0x0000ffff)
604 || ( gap
>= 0x00ffff00
605 && gap
<= 0x00ffffff)
606 || ( gap
>= 0xffffff00
607 && gap
<= 0xffffffff))
609 bfd_put_8 (abfd
, gap
, data
+ dst_address
);
615 if (! ((*link_info
->callbacks
->reloc_overflow
)
616 (link_info
, bfd_asymbol_name (*reloc
->sym_ptr_ptr
),
617 reloc
->howto
->name
, reloc
->addend
, input_section
->owner
,
618 input_section
, reloc
->address
)))
624 /* A relword which would have like to have been a pcrel */
626 /* A relword which would like to have been modified but
630 bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
),
637 bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
),
644 /* Special relaxed type, there will be a gap between where we
645 get stuff from and where we put stuff to now
647 for a mov.b @aa:16 -> mov.b @aa:8
648 opcode 0x6a 0x0y offset
651 if (data
[dst_address
- 1] != 0x6a)
653 switch (data
[src_address
] & 0xf0)
657 data
[dst_address
- 1] = (data
[src_address
] & 0xf) | 0x20;
661 data
[dst_address
- 1] = (data
[src_address
] & 0xf) | 0x30;
667 /* the offset must fit ! after all, what was all the relaxing
671 bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
),
674 /* Note the magic - src goes up by two bytes, but dst by only
683 /* Special relaxed type */
685 bfd_vma dot
= link_order
->offset
687 + link_order
->u
.indirect
.section
->output_section
->vma
;
689 int gap
= (bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
)
692 if ((gap
& ~0xff) != 0 && ((gap
& 0xff00) != 0xff00))
695 bfd_put_8 (abfd
, gap
, data
+ dst_address
);
697 switch (data
[dst_address
- 1])
701 bfd_put_8 (abfd
, 0x55, data
+ dst_address
- 1);
705 bfd_put_8 (abfd
, 0x40, data
+ dst_address
- 1);
720 /* Special relaxed type */
722 bfd_vma dot
= link_order
->offset
724 + link_order
->u
.indirect
.section
->output_section
->vma
- 2;
726 int gap
= (bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
)
729 if ((gap
& ~0xff) != 0 && ((gap
& 0xff00) != 0xff00))
732 switch (data
[dst_address
- 2])
737 /* bCC:16 -> bCC:8 */
738 /* Get the condition code from the original insn. */
739 tmp
= data
[dst_address
- 1];
743 /* Now or in the high nibble of the opcode. */
747 bfd_put_8 (abfd
, tmp
, data
+ dst_address
- 2);
754 /* Output the target. */
755 bfd_put_8 (abfd
, gap
, data
+ dst_address
- 1);
757 /* We don't advance dst_address -- the 8bit reloc is applied at
758 dst_address - 1, so the next insn should begin at dst_address.
760 src_address is advanced by two (original reloc was 16bits). */
767 case R_JMPL_B8
: /* 24 bit branch which is now 8 bits */
769 /* Speciial relaxed type */
771 bfd_vma dot
= link_order
->offset
773 + link_order
->u
.indirect
.section
->output_section
->vma
;
775 int gap
= (bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
)
778 if ((gap
& ~0xff) != 0 && ((gap
& 0xff00) != 0xff00))
781 switch (data
[src_address
])
785 bfd_put_8 (abfd
, 0x55, data
+ dst_address
);
789 bfd_put_8 (abfd
, 0x40, data
+ dst_address
);
793 bfd_put_8 (abfd
, 0xde, data
+ dst_address
);
797 bfd_put_8 (abfd
, gap
, data
+ dst_address
+ 1);
806 int v
= bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
);
807 int o
= bfd_get_32 (abfd
, data
+ src_address
);
808 v
= (v
& 0x00ffffff) | (o
& 0xff000000);
809 bfd_put_32 (abfd
, v
, data
+ dst_address
);
817 /* A 24 bit mov which could be an 8 bit move, really pointing to
818 the byte before the 24bit hole, so we can treat it as a 32bit pointer */
821 int v
= bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
);
822 int o
= bfd_get_32 (abfd
, data
+ dst_address
);
823 v
= (v
& 0x00ffffff) | (o
& 0xff000000);
824 bfd_put_32 (abfd
, v
, data
+ dst_address
);
831 /* An 8bit memory indirect instruction (jmp/jsr).
833 There's several things that need to be done to handle
836 If this is a reloc against the absolute symbol, then
837 we should handle it just R_RELBYTE. Likewise if it's
838 for a symbol with a value ge 0 and le 0xff.
840 Otherwise it's a jump/call through the function vector,
841 and the linker is expected to set up the function vector
842 and put the right value into the jump/call instruction. */
845 /* We need to find the symbol so we can determine it's
846 address in the function vector table. */
850 struct funcvec_hash_entry
*h
;
851 asection
*vectors_sec
= h8300_coff_hash_table (link_info
)->vectors_sec
;
853 /* First see if this is a reloc against the absolute symbol
854 or against a symbol with a nonnegative value <= 0xff. */
855 symbol
= *(reloc
->sym_ptr_ptr
);
856 value
= bfd_coff_reloc16_get_value (reloc
, link_info
, input_section
);
857 if (symbol
== bfd_abs_section_ptr
->symbol
858 || (value
>= 0 && value
<= 0xff))
860 /* This should be handled in a manner very similar to
861 R_RELBYTES. If the value is in range, then just slam
862 the value into the right location. Else trigger a
863 reloc overflow callback. */
864 if (value
>= 0 && value
<= 0xff)
866 bfd_put_8 (abfd
, value
, data
+ dst_address
);
872 if (! ((*link_info
->callbacks
->reloc_overflow
)
873 (link_info
, bfd_asymbol_name (*reloc
->sym_ptr_ptr
),
874 reloc
->howto
->name
, reloc
->addend
, input_section
->owner
,
875 input_section
, reloc
->address
)))
881 /* This is a jump/call through a function vector, and we're
882 expected to create the function vector ourselves.
884 First look up this symbol in the linker hash table -- we need
885 the derived linker symbol which holds this symbol's index
886 in the function vector. */
888 if (symbol
->flags
& BSF_LOCAL
)
890 char *new_name
= bfd_malloc (strlen (name
) + 9);
891 if (new_name
== NULL
)
894 strcpy (new_name
, name
);
895 sprintf (new_name
+ strlen (name
), "_%08x",
896 (int)symbol
->section
);
900 h
= funcvec_hash_lookup (h8300_coff_hash_table (link_info
)->funcvec_hash_table
,
903 /* This shouldn't ever happen. If it does that means we've got
904 data corruption of some kind. Aborting seems like a reasonable
906 if (h
== NULL
|| vectors_sec
== NULL
)
909 /* Place the address of the function vector entry into the
912 vectors_sec
->output_offset
+ h
->offset
,
918 /* Now create an entry in the function vector itself. */
919 if (bfd_get_mach (input_section
->owner
) == bfd_mach_h8300
)
921 bfd_coff_reloc16_get_value (reloc
,
924 vectors_sec
->contents
+ h
->offset
);
925 else if (bfd_get_mach (input_section
->owner
) == bfd_mach_h8300h
)
927 bfd_coff_reloc16_get_value (reloc
,
930 vectors_sec
->contents
+ h
->offset
);
934 /* Gross. We've already written the contents of the vector section
935 before we get here... So we write it again with the new data. */
936 bfd_set_section_contents (vectors_sec
->output_section
->owner
,
937 vectors_sec
->output_section
,
938 vectors_sec
->contents
,
939 vectors_sec
->output_offset
,
940 vectors_sec
->_raw_size
);
950 *src_ptr
= src_address
;
951 *dst_ptr
= dst_address
;
955 /* Routine for the h8300 linker.
957 This routine is necessary to handle the special R_MEM_INDIRECT
958 relocs on the h8300. It's responsible for generating a vectors
959 section and attaching it to an input bfd as well as sizing
960 the vectors section. It also creates our vectors hash table.
962 It uses the generic linker routines to actually add the symbols.
963 from this BFD to the bfd linker hash table. It may add a few
964 selected static symbols to the bfd linker hash table. */
967 h8300_bfd_link_add_symbols(abfd
, info
)
969 struct bfd_link_info
*info
;
972 struct funcvec_hash_table
*funcvec_hash_table
;
974 /* If we haven't created a vectors section, do so now. */
975 if (!h8300_coff_hash_table (info
)->vectors_sec
)
979 /* Make sure the appropriate flags are set, including SEC_IN_MEMORY. */
980 flags
= (SEC_ALLOC
| SEC_LOAD
981 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_READONLY
);
982 h8300_coff_hash_table (info
)->vectors_sec
= bfd_make_section (abfd
,
985 /* If the section wasn't created, or we couldn't set the flags,
986 quit quickly now, rather than dieing a painful death later. */
987 if (! h8300_coff_hash_table (info
)->vectors_sec
988 || ! bfd_set_section_flags (abfd
,
989 h8300_coff_hash_table(info
)->vectors_sec
,
993 /* Also create the vector hash table. */
994 funcvec_hash_table
= ((struct funcvec_hash_table
*)
995 bfd_alloc (abfd
, sizeof (struct funcvec_hash_table
)));
997 if (!funcvec_hash_table
)
1000 /* And initialize the funcvec hash table. */
1001 if (!funcvec_hash_table_init (funcvec_hash_table
, abfd
,
1002 funcvec_hash_newfunc
))
1004 bfd_release (abfd
, funcvec_hash_table
);
1008 /* Store away a pointer to the funcvec hash table. */
1009 h8300_coff_hash_table (info
)->funcvec_hash_table
= funcvec_hash_table
;
1012 /* Load up the function vector hash table. */
1013 funcvec_hash_table
= h8300_coff_hash_table (info
)->funcvec_hash_table
;
1015 /* Add the symbols using the generic code. */
1016 _bfd_generic_link_add_symbols (abfd
, info
);
1018 /* Now scan the relocs for all the sections in this bfd; create
1019 additional space in the .vectors section as needed. */
1020 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1022 unsigned long reloc_size
, reloc_count
, i
;
1026 /* Suck in the relocs, symbols & canonicalize them. */
1027 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
1028 if (reloc_size
<= 0)
1031 relocs
= (arelent
**)bfd_malloc ((size_t)reloc_size
);
1035 /* The symbols should have been read in by _bfd_generic link_add_symbols
1036 call abovec, so we can cheat and use the pointer to them that was
1037 saved in the above call. */
1038 symbols
= _bfd_generic_link_get_symbols(abfd
);
1039 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, symbols
);
1041 /* Now walk through all the relocations in this section. */
1042 for (i
= 0; i
< reloc_count
; i
++)
1044 arelent
*reloc
= relocs
[i
];
1045 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
1048 /* We've got an indirect reloc. See if we need to add it
1049 to the function vector table. At this point, we have
1050 to add a new entry for each unique symbol referenced
1051 by an R_MEM_INDIRECT relocation except for a reloc
1052 against the absolute section symbol. */
1053 if (reloc
->howto
->type
== R_MEM_INDIRECT
1054 && symbol
!= bfd_abs_section_ptr
->symbol
)
1057 struct funcvec_hash_entry
*h
;
1059 name
= symbol
->name
;
1060 if (symbol
->flags
& BSF_LOCAL
)
1062 char *new_name
= bfd_malloc (strlen (name
) + 9);
1064 if (new_name
== NULL
)
1067 strcpy (new_name
, name
);
1068 sprintf (new_name
+ strlen (name
), "_%08x",
1069 (int)symbol
->section
);
1073 /* Look this symbol up in the function vector hash table. */
1074 h
= funcvec_hash_lookup (h8300_coff_hash_table (info
)->funcvec_hash_table
,
1075 name
, false, false);
1078 /* If this symbol isn't already in the hash table, add
1079 it and bump up the size of the hash table. */
1082 h
= funcvec_hash_lookup (h8300_coff_hash_table (info
)->funcvec_hash_table
,
1090 /* Bump the size of the vectors section. Each vector
1091 takes 2 bytes on the h8300 and 4 bytes on the h8300h. */
1092 if (bfd_get_mach (abfd
) == bfd_mach_h8300
)
1093 h8300_coff_hash_table (info
)->vectors_sec
->_raw_size
+= 2;
1094 else if (bfd_get_mach (abfd
) == bfd_mach_h8300h
)
1095 h8300_coff_hash_table (info
)->vectors_sec
->_raw_size
+= 4;
1100 /* We're done with the relocations, release them. */
1104 /* Now actually allocate some space for the function vector. It's
1105 wasteful to do this more than once, but this is easier. */
1106 if (h8300_coff_hash_table (info
)->vectors_sec
->_raw_size
!= 0)
1108 /* Free the old contents. */
1109 if (h8300_coff_hash_table (info
)->vectors_sec
->contents
)
1110 free (h8300_coff_hash_table (info
)->vectors_sec
->contents
);
1112 /* Allocate new contents. */
1113 h8300_coff_hash_table (info
)->vectors_sec
->contents
1114 = bfd_malloc (h8300_coff_hash_table (info
)->vectors_sec
->_raw_size
);
1120 #define coff_reloc16_extra_cases h8300_reloc16_extra_cases
1121 #define coff_reloc16_estimate h8300_reloc16_estimate
1122 #define coff_bfd_link_add_symbols h8300_bfd_link_add_symbols
1123 #define coff_bfd_link_hash_table_create h8300_coff_link_hash_table_create
1125 #define COFF_LONG_FILENAMES
1126 #include "coffcode.h"
1129 #undef coff_bfd_get_relocated_section_contents
1130 #undef coff_bfd_relax_section
1131 #define coff_bfd_get_relocated_section_contents \
1132 bfd_coff_reloc16_get_relocated_section_contents
1133 #define coff_bfd_relax_section bfd_coff_reloc16_relax_section
1137 const bfd_target h8300coff_vec
=
1139 "coff-h8300", /* name */
1140 bfd_target_coff_flavour
,
1141 BFD_ENDIAN_BIG
, /* data byte order is big */
1142 BFD_ENDIAN_BIG
, /* header byte order is big */
1144 (HAS_RELOC
| EXEC_P
| /* object flags */
1145 HAS_LINENO
| HAS_DEBUG
|
1146 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| BFD_IS_RELAXABLE
),
1147 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
1148 '_', /* leading char */
1149 '/', /* ar_pad_char */
1150 15, /* ar_max_namelen */
1151 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1152 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1153 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
1154 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1155 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1156 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
1158 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
1159 bfd_generic_archive_p
, _bfd_dummy_target
},
1160 {bfd_false
, coff_mkobject
, _bfd_generic_mkarchive
, /* bfd_set_format */
1162 {bfd_false
, coff_write_object_contents
, /* bfd_write_contents */
1163 _bfd_write_archive_contents
, bfd_false
},
1165 BFD_JUMP_TABLE_GENERIC (coff
),
1166 BFD_JUMP_TABLE_COPY (coff
),
1167 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1168 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff
),
1169 BFD_JUMP_TABLE_SYMBOLS (coff
),
1170 BFD_JUMP_TABLE_RELOCS (coff
),
1171 BFD_JUMP_TABLE_WRITE (coff
),
1172 BFD_JUMP_TABLE_LINK (coff
),
1173 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),