Commit | Line | Data |
---|---|---|
67bb9940 | 1 | # This shell script emits a C file. -*- C -*- |
2571583a | 2 | # Copyright (C) 1991-2017 Free Software Foundation, Inc. |
67bb9940 | 3 | # |
f96b4a7b | 4 | # This file is part of the GNU Binutils. |
67bb9940 SC |
5 | # |
6 | # This program is free software; you can redistribute it and/or modify | |
7 | # it under the terms of the GNU General Public License as published by | |
f96b4a7b | 8 | # the Free Software Foundation; either version 3 of the License, or |
67bb9940 SC |
9 | # (at your option) any later version. |
10 | # | |
11 | # This program is distributed in the hope that it will be useful, | |
12 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | # GNU General Public License for more details. | |
15 | # | |
16 | # You should have received a copy of the GNU General Public License | |
17 | # along with this program; if not, write to the Free Software | |
f96b4a7b NC |
18 | # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
19 | # MA 02110-1301, USA. | |
67bb9940 SC |
20 | # |
21 | ||
22 | # This file is sourced from elf32.em, and defines extra m68hc12-elf | |
23 | # and m68hc11-elf specific routines. It is used to generate the | |
24 | # HC11/HC12 trampolines to call a far function by using a normal 'jsr/bsr'. | |
25 | # | |
26 | # - The HC11/HC12 relocations are checked to see if there is a | |
27 | # R_M68HC11_16 relocation to a symbol marked with STO_M68HC12_FAR. | |
28 | # This relocation cannot be made on the symbol but must be made on | |
29 | # its trampoline | |
30 | # The trampolines to generate are collected during this pass | |
31 | # (See elf32_m68hc11_size_stubs) | |
32 | # | |
33 | # - The trampolines are generated in a ".tramp" section. The generation | |
34 | # takes care of HC11 and HC12 specificities. | |
35 | # (See elf32_m68hc11_build_stubs) | |
36 | # | |
37 | # - During relocation the R_M68HC11_16 relocation to the far symbols | |
38 | # are redirected to the trampoline that was generated. | |
39 | # | |
40 | # Copied from hppaelf and adapted for M68HC11/M68HC12 specific needs. | |
41 | # | |
92b93329 | 42 | fragment <<EOF |
67bb9940 SC |
43 | |
44 | #include "ldctor.h" | |
45 | #include "elf32-m68hc1x.h" | |
46 | ||
0c7a8e5a | 47 | static asection *m68hc11elf_add_stub_section (const char *, asection *); |
67bb9940 SC |
48 | |
49 | /* Fake input file for stubs. */ | |
50 | static lang_input_statement_type *stub_file; | |
51 | ||
52 | /* By default the HC11/HC12 trampolines to call a far function using | |
53 | a normal 'bsr' and 'jsr' convention are generated during the link. | |
54 | The --no-trampoline option prevents that. */ | |
55 | static int no_trampoline = 0; | |
56 | ||
57 | /* Name of memory bank window in the MEMORY description. | |
58 | This is set by --bank-window option. */ | |
59 | static const char* bank_window_name = 0; | |
60 | ||
61 | static void | |
0c7a8e5a | 62 | m68hc11_elf_${EMULATION_NAME}_before_allocation (void) |
67bb9940 SC |
63 | { |
64 | lang_memory_region_type* region; | |
65 | int ret; | |
66 | ||
67 | gld${EMULATION_NAME}_before_allocation (); | |
68 | ||
fd9770d8 NC |
69 | if (bfd_get_flavour (link_info.output_bfd) != bfd_target_elf_flavour) |
70 | return; | |
71 | ||
67bb9940 SC |
72 | /* If generating a relocatable output file, then we don't |
73 | have to generate the trampolines. */ | |
0e1862bb | 74 | if (bfd_link_relocatable (&link_info)) |
67bb9940 SC |
75 | return; |
76 | ||
f13a99db | 77 | ret = elf32_m68hc11_setup_section_lists (link_info.output_bfd, &link_info); |
67bb9940 SC |
78 | if (ret != 0 && no_trampoline == 0) |
79 | { | |
80 | if (ret < 0) | |
81 | { | |
d003af55 | 82 | einfo (_("%X%P: can not size stub section: %E\n")); |
67bb9940 SC |
83 | return; |
84 | } | |
85 | ||
86 | /* Call into the BFD backend to do the real work. */ | |
f13a99db | 87 | if (!elf32_m68hc11_size_stubs (link_info.output_bfd, |
0c7a8e5a AM |
88 | stub_file->the_bfd, |
89 | &link_info, | |
90 | &m68hc11elf_add_stub_section)) | |
67bb9940 | 91 | { |
d003af55 | 92 | einfo (_("%X%P: can not size stub section: %E\n")); |
67bb9940 SC |
93 | return; |
94 | } | |
95 | } | |
96 | ||
97 | if (bank_window_name == 0) | |
98 | return; | |
99 | ||
100 | /* The 'bank_window_name' memory region is a special region that describes | |
101 | the memory bank window to access to paged memory. For 68HC12 | |
102 | this is fixed and should be: | |
103 | ||
104 | window (rx) : ORIGIN = 0x8000, LENGTH = 16K | |
105 | ||
106 | But for 68HC11 this is board specific. The definition of such | |
107 | memory region allows to control how this paged memory is accessed. */ | |
383b8428 | 108 | region = lang_memory_region_lookup (bank_window_name, FALSE); |
67bb9940 SC |
109 | |
110 | /* Check the length to see if it was defined in the script. */ | |
111 | if (region->length != 0) | |
112 | { | |
113 | struct m68hc11_page_info *pinfo; | |
114 | unsigned i; | |
115 | ||
116 | /* Get default values */ | |
117 | m68hc11_elf_get_bank_parameters (&link_info); | |
118 | pinfo = &m68hc11_elf_hash_table (&link_info)->pinfo; | |
119 | ||
120 | /* And override them with the region definition. */ | |
121 | pinfo->bank_size = region->length; | |
122 | pinfo->bank_shift = 0; | |
123 | for (i = pinfo->bank_size; i != 0; i >>= 1) | |
0c7a8e5a | 124 | pinfo->bank_shift++; |
67bb9940 SC |
125 | pinfo->bank_shift--; |
126 | pinfo->bank_size = 1L << pinfo->bank_shift; | |
127 | pinfo->bank_mask = (1 << pinfo->bank_shift) - 1; | |
128 | pinfo->bank_physical = region->origin; | |
129 | pinfo->bank_physical_end = region->origin + pinfo->bank_size; | |
130 | ||
131 | if (pinfo->bank_size != region->length) | |
0c7a8e5a AM |
132 | { |
133 | einfo (_("warning: the size of the 'window' memory region " | |
134 | "is not a power of 2\n")); | |
135 | einfo (_("warning: its size %d is truncated to %d\n"), | |
136 | region->length, pinfo->bank_size); | |
137 | } | |
67bb9940 SC |
138 | } |
139 | } | |
140 | ||
141 | /* This is called before the input files are opened. We create a new | |
142 | fake input file to hold the stub sections. */ | |
143 | ||
144 | static void | |
0c7a8e5a | 145 | m68hc11elf_create_output_section_statements (void) |
67bb9940 | 146 | { |
fd9770d8 NC |
147 | if (bfd_get_flavour (link_info.output_bfd) != bfd_target_elf_flavour) |
148 | { | |
d003af55 AM |
149 | einfo (_("%X%P: changing output format whilst linking " |
150 | "is not supported\n")); | |
fd9770d8 NC |
151 | return; |
152 | } | |
153 | ||
67bb9940 SC |
154 | stub_file = lang_add_input_file ("linker stubs", |
155 | lang_input_file_is_fake_enum, | |
156 | NULL); | |
f13a99db | 157 | stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd); |
67bb9940 SC |
158 | if (stub_file->the_bfd == NULL |
159 | || !bfd_set_arch_mach (stub_file->the_bfd, | |
f13a99db AM |
160 | bfd_get_arch (link_info.output_bfd), |
161 | bfd_get_mach (link_info.output_bfd))) | |
67bb9940 | 162 | { |
d003af55 | 163 | einfo (_("%X%P: can not create BFD %E\n")); |
67bb9940 SC |
164 | return; |
165 | } | |
166 | ||
167 | ldlang_add_file (stub_file); | |
168 | } | |
169 | ||
170 | ||
171 | struct hook_stub_info | |
172 | { | |
173 | lang_statement_list_type add; | |
174 | asection *input_section; | |
175 | }; | |
176 | ||
177 | /* Traverse the linker tree to find the spot where the stub goes. */ | |
178 | ||
67bb9940 | 179 | static bfd_boolean |
0c7a8e5a | 180 | hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp) |
67bb9940 SC |
181 | { |
182 | lang_statement_union_type *l; | |
183 | bfd_boolean ret; | |
184 | ||
185 | for (; (l = *lp) != NULL; lp = &l->header.next) | |
186 | { | |
187 | switch (l->header.type) | |
188 | { | |
189 | case lang_constructors_statement_enum: | |
190 | ret = hook_in_stub (info, &constructor_list.head); | |
191 | if (ret) | |
192 | return ret; | |
193 | break; | |
194 | ||
195 | case lang_output_section_statement_enum: | |
196 | ret = hook_in_stub (info, | |
197 | &l->output_section_statement.children.head); | |
198 | if (ret) | |
199 | return ret; | |
200 | break; | |
201 | ||
202 | case lang_wild_statement_enum: | |
203 | ret = hook_in_stub (info, &l->wild_statement.children.head); | |
204 | if (ret) | |
205 | return ret; | |
206 | break; | |
207 | ||
208 | case lang_group_statement_enum: | |
209 | ret = hook_in_stub (info, &l->group_statement.children.head); | |
210 | if (ret) | |
211 | return ret; | |
212 | break; | |
213 | ||
214 | case lang_input_section_enum: | |
215 | if (l->input_section.section == info->input_section | |
a0f49396 | 216 | || strcmp (bfd_get_section_name (l->input_section.section->owner, |
0c7a8e5a | 217 | l->input_section.section), |
a0f49396 | 218 | bfd_get_section_name (info->input_section->owner, |
0c7a8e5a | 219 | info->input_section)) == 0) |
67bb9940 SC |
220 | { |
221 | /* We've found our section. Insert the stub immediately | |
222 | before its associated input section. */ | |
223 | *lp = info->add.head; | |
224 | *(info->add.tail) = l; | |
225 | return TRUE; | |
226 | } | |
227 | break; | |
228 | ||
229 | case lang_data_statement_enum: | |
230 | case lang_reloc_statement_enum: | |
231 | case lang_object_symbols_statement_enum: | |
232 | case lang_output_statement_enum: | |
233 | case lang_target_statement_enum: | |
234 | case lang_input_statement_enum: | |
235 | case lang_assignment_statement_enum: | |
236 | case lang_padding_statement_enum: | |
237 | case lang_address_statement_enum: | |
238 | case lang_fill_statement_enum: | |
239 | break; | |
240 | ||
241 | default: | |
242 | FAIL (); | |
243 | break; | |
244 | } | |
245 | } | |
246 | return FALSE; | |
247 | } | |
248 | ||
249 | ||
250 | /* Call-back for elf32_m68hc11_size_stubs. */ | |
251 | ||
252 | /* Create a new stub section, and arrange for it to be linked | |
253 | immediately before INPUT_SECTION. */ | |
254 | ||
255 | static asection * | |
0c7a8e5a AM |
256 | m68hc11elf_add_stub_section (const char *stub_sec_name, |
257 | asection *tramp_section) | |
67bb9940 SC |
258 | { |
259 | asection *stub_sec; | |
260 | flagword flags; | |
261 | asection *output_section; | |
67bb9940 SC |
262 | lang_output_section_statement_type *os; |
263 | struct hook_stub_info info; | |
0c7a8e5a | 264 | |
67bb9940 SC |
265 | flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE |
266 | | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP); | |
9795b468 AM |
267 | stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd, |
268 | stub_sec_name, flags); | |
269 | if (stub_sec == NULL) | |
67bb9940 SC |
270 | goto err_ret; |
271 | ||
272 | output_section = tramp_section->output_section; | |
24ef1aa7 | 273 | os = lang_output_section_get (output_section); |
67bb9940 SC |
274 | |
275 | /* Try to put the new section at the same place as an existing | |
276 | .tramp section. Such .tramp section exists in most cases and | |
277 | contains the trampoline code. This way we put the generated trampoline | |
278 | at the correct place. */ | |
279 | info.input_section = tramp_section; | |
280 | lang_list_init (&info.add); | |
b9c361e0 | 281 | lang_add_section (&info.add, stub_sec, NULL, os); |
67bb9940 SC |
282 | |
283 | if (info.add.head == NULL) | |
284 | goto err_ret; | |
285 | ||
286 | if (hook_in_stub (&info, &os->children.head)) | |
287 | return stub_sec; | |
288 | ||
289 | err_ret: | |
d003af55 | 290 | einfo (_("%X%P: can not make stub section: %E\n")); |
67bb9940 SC |
291 | return NULL; |
292 | } | |
293 | ||
eaeb0a9d | 294 | /* For the 68HC12 we use this opportunity to build linker stubs. */ |
67bb9940 SC |
295 | |
296 | static void | |
eaeb0a9d | 297 | m68hc11elf_after_allocation (void) |
67bb9940 | 298 | { |
fd9770d8 | 299 | if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour) |
67bb9940 | 300 | { |
fd9770d8 NC |
301 | /* Now build the linker stubs. */ |
302 | if (stub_file->the_bfd->sections != NULL) | |
67bb9940 | 303 | { |
fd9770d8 NC |
304 | /* Call again the trampoline analyzer to initialize the trampoline |
305 | stubs with the correct symbol addresses. Since there could have | |
306 | been relaxation, the symbol addresses that were found during | |
307 | first call may no longer be correct. */ | |
308 | if (!elf32_m68hc11_size_stubs (link_info.output_bfd, | |
309 | stub_file->the_bfd, | |
310 | &link_info, 0)) | |
311 | { | |
d003af55 | 312 | einfo (_("%X%P: can not size stub section: %E\n")); |
fd9770d8 NC |
313 | return; |
314 | } | |
315 | if (!elf32_m68hc11_build_stubs (link_info.output_bfd, &link_info)) | |
d003af55 | 316 | einfo (_("%X%P: can not build stubs: %E\n")); |
67bb9940 | 317 | } |
67bb9940 | 318 | } |
b1ab9777 | 319 | |
eaeb0a9d | 320 | gld${EMULATION_NAME}_after_allocation (); |
67bb9940 SC |
321 | } |
322 | ||
323 | ||
324 | /* Avoid processing the fake stub_file in vercheck, stat_needed and | |
325 | check_needed routines. */ | |
326 | ||
0c7a8e5a | 327 | static void (*real_func) (lang_input_statement_type *); |
67bb9940 | 328 | |
0c7a8e5a | 329 | static void m68hc11_for_each_input_file_wrapper (lang_input_statement_type *l) |
67bb9940 SC |
330 | { |
331 | if (l != stub_file) | |
332 | (*real_func) (l); | |
333 | } | |
334 | ||
335 | static void | |
0c7a8e5a | 336 | m68hc11_lang_for_each_input_file (void (*func) (lang_input_statement_type *)) |
67bb9940 SC |
337 | { |
338 | real_func = func; | |
339 | lang_for_each_input_file (&m68hc11_for_each_input_file_wrapper); | |
340 | } | |
341 | ||
342 | #define lang_for_each_input_file m68hc11_lang_for_each_input_file | |
343 | ||
344 | EOF | |
345 | ||
346 | # Define some shell vars to insert bits of code into the standard elf | |
347 | # parse_args and list_options functions. | |
348 | # | |
349 | PARSE_AND_LIST_PROLOGUE=' | |
0c7a8e5a AM |
350 | #define OPTION_NO_TRAMPOLINE 300 |
351 | #define OPTION_BANK_WINDOW 301 | |
67bb9940 SC |
352 | ' |
353 | ||
354 | # The options are repeated below so that no abbreviations are allowed. | |
355 | # Otherwise -s matches stub-group-size | |
356 | PARSE_AND_LIST_LONGOPTS=' | |
357 | { "no-trampoline", no_argument, NULL, OPTION_NO_TRAMPOLINE }, | |
358 | { "bank-window", required_argument, NULL, OPTION_BANK_WINDOW }, | |
359 | ' | |
360 | ||
361 | PARSE_AND_LIST_OPTIONS=' | |
442996ee AM |
362 | fprintf (file, _( |
363 | " --no-trampoline Do not generate the far trampolines used to call\n" | |
364 | " a far function using 'jsr' or 'bsr'.\n" | |
365 | " --bank-window NAME Specify the name of the memory region describing\n" | |
366 | " the layout of the memory bank window.\n" | |
67bb9940 SC |
367 | )); |
368 | ' | |
369 | ||
370 | PARSE_AND_LIST_ARGS_CASES=' | |
371 | case OPTION_NO_TRAMPOLINE: | |
372 | no_trampoline = 1; | |
373 | break; | |
374 | case OPTION_BANK_WINDOW: | |
375 | bank_window_name = optarg; | |
376 | break; | |
377 | ' | |
378 | ||
379 | # Put these extra m68hc11elf routines in ld_${EMULATION_NAME}_emulation | |
380 | # | |
381 | LDEMUL_BEFORE_ALLOCATION=m68hc11_elf_${EMULATION_NAME}_before_allocation | |
eaeb0a9d | 382 | LDEMUL_AFTER_ALLOCATION=m68hc11elf_after_allocation |
67bb9940 | 383 | LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=m68hc11elf_create_output_section_statements |