Commit | Line | Data |
---|---|---|
adde6300 AM |
1 | /* AVR-specific support for 32-bit ELF |
2 | Copyright (C) 1999, 2000 Free Software Foundation, Inc. | |
3 | Contributed by Denis Chertykov <denisc@overta.ru> | |
4 | ||
5 | This file is part of BFD, the Binary File Descriptor library. | |
6 | ||
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. | |
11 | ||
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. | |
16 | ||
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. */ | |
20 | ||
21 | ||
22 | #include "bfd.h" | |
23 | #include "sysdep.h" | |
24 | #include "libbfd.h" | |
25 | #include "elf-bfd.h" | |
26 | #include "elf/avr.h" | |
27 | ||
28 | static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup | |
29 | PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); | |
30 | static void avr_info_to_howto_rela | |
31 | PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *)); | |
32 | static asection *elf32_avr_gc_mark_hook | |
33 | PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *, | |
34 | struct elf_link_hash_entry *, Elf_Internal_Sym *)); | |
35 | static boolean elf32_avr_gc_sweep_hook | |
36 | PARAMS ((bfd *, struct bfd_link_info *, asection *, | |
37 | const Elf_Internal_Rela *)); | |
38 | static boolean elf32_avr_check_relocs | |
39 | PARAMS ((bfd *, struct bfd_link_info *, asection *, | |
40 | const Elf_Internal_Rela *)); | |
41 | static bfd_reloc_status_type avr_final_link_relocate | |
42 | PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, | |
43 | Elf_Internal_Rela *, bfd_vma)); | |
44 | static boolean elf32_avr_relocate_section | |
45 | PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, | |
46 | Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); | |
47 | static void bfd_elf_avr_final_write_processing PARAMS ((bfd *, boolean)); | |
48 | static boolean elf32_avr_object_p PARAMS ((bfd *)); | |
49 | ||
50 | ||
51 | /* Use RELA instead of REL */ | |
52 | #undef USE_REL | |
53 | ||
54 | static reloc_howto_type elf_avr_howto_table[] = | |
55 | { | |
56 | HOWTO (R_AVR_NONE, /* type */ | |
57 | 0, /* rightshift */ | |
58 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
59 | 32, /* bitsize */ | |
60 | false, /* pc_relative */ | |
61 | 0, /* bitpos */ | |
62 | complain_overflow_bitfield, /* complain_on_overflow */ | |
63 | bfd_elf_generic_reloc, /* special_function */ | |
64 | "R_AVR_NONE", /* name */ | |
65 | false, /* partial_inplace */ | |
66 | 0, /* src_mask */ | |
67 | 0, /* dst_mask */ | |
68 | false), /* pcrel_offset */ | |
69 | ||
70 | HOWTO (R_AVR_32, /* type */ | |
71 | 0, /* rightshift */ | |
72 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
73 | 32, /* bitsize */ | |
74 | false, /* pc_relative */ | |
75 | 0, /* bitpos */ | |
76 | complain_overflow_bitfield, /* complain_on_overflow */ | |
77 | bfd_elf_generic_reloc, /* special_function */ | |
78 | "R_AVR_32", /* name */ | |
79 | false, /* partial_inplace */ | |
80 | 0xffffffff, /* src_mask */ | |
81 | 0xffffffff, /* dst_mask */ | |
82 | false), /* pcrel_offset */ | |
83 | ||
84 | /* A 7 bit PC relative relocation. */ | |
85 | HOWTO (R_AVR_7_PCREL, /* type */ | |
86 | 1, /* rightshift */ | |
87 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
88 | 7, /* bitsize */ | |
89 | true, /* pc_relative */ | |
90 | 3, /* bitpos */ | |
91 | complain_overflow_bitfield, /* complain_on_overflow */ | |
92 | bfd_elf_generic_reloc, /* special_function */ | |
93 | "R_AVR_7_PCREL", /* name */ | |
94 | false, /* partial_inplace */ | |
95 | 0xffff, /* src_mask */ | |
96 | 0xffff, /* dst_mask */ | |
97 | true), /* pcrel_offset */ | |
98 | ||
99 | /* A 13 bit PC relative relocation. */ | |
100 | HOWTO (R_AVR_13_PCREL, /* type */ | |
101 | 1, /* rightshift */ | |
102 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
103 | 13, /* bitsize */ | |
104 | true, /* pc_relative */ | |
105 | 0, /* bitpos */ | |
106 | complain_overflow_bitfield, /* complain_on_overflow */ | |
107 | bfd_elf_generic_reloc, /* special_function */ | |
108 | "R_AVR_13_PCREL", /* name */ | |
109 | false, /* partial_inplace */ | |
110 | 0xfff, /* src_mask */ | |
111 | 0xfff, /* dst_mask */ | |
112 | true), /* pcrel_offset */ | |
113 | ||
114 | /* A 16 bit absolute relocation. */ | |
115 | HOWTO (R_AVR_16, /* type */ | |
116 | 0, /* rightshift */ | |
117 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
118 | 16, /* bitsize */ | |
119 | false, /* pc_relative */ | |
120 | 0, /* bitpos */ | |
121 | complain_overflow_dont, /* complain_on_overflow */ | |
122 | bfd_elf_generic_reloc, /* special_function */ | |
123 | "R_AVR_16", /* name */ | |
124 | false, /* partial_inplace */ | |
125 | 0xffff, /* src_mask */ | |
126 | 0xffff, /* dst_mask */ | |
127 | false), /* pcrel_offset */ | |
128 | ||
129 | /* A 16 bit absolute relocation for command address. */ | |
130 | HOWTO (R_AVR_16_PM, /* type */ | |
131 | 1, /* rightshift */ | |
132 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
133 | 16, /* bitsize */ | |
134 | false, /* pc_relative */ | |
135 | 0, /* bitpos */ | |
136 | complain_overflow_bitfield, /* complain_on_overflow */ | |
137 | bfd_elf_generic_reloc, /* special_function */ | |
138 | "R_AVR_16_PM", /* name */ | |
139 | false, /* partial_inplace */ | |
140 | 0xffff, /* src_mask */ | |
141 | 0xffff, /* dst_mask */ | |
142 | false), /* pcrel_offset */ | |
143 | /* A low 8 bit absolute relocation of 16 bit address. | |
144 | For LDI command. */ | |
145 | HOWTO (R_AVR_LO8_LDI, /* type */ | |
146 | 0, /* rightshift */ | |
147 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
148 | 8, /* bitsize */ | |
149 | false, /* pc_relative */ | |
150 | 0, /* bitpos */ | |
151 | complain_overflow_dont, /* complain_on_overflow */ | |
152 | bfd_elf_generic_reloc, /* special_function */ | |
153 | "R_AVR_LO8_LDI", /* name */ | |
154 | false, /* partial_inplace */ | |
155 | 0xffff, /* src_mask */ | |
156 | 0xffff, /* dst_mask */ | |
157 | false), /* pcrel_offset */ | |
158 | /* A high 8 bit absolute relocation of 16 bit address. | |
159 | For LDI command. */ | |
160 | HOWTO (R_AVR_HI8_LDI, /* type */ | |
161 | 8, /* rightshift */ | |
162 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
163 | 8, /* bitsize */ | |
164 | false, /* pc_relative */ | |
165 | 0, /* bitpos */ | |
166 | complain_overflow_dont, /* complain_on_overflow */ | |
167 | bfd_elf_generic_reloc, /* special_function */ | |
168 | "R_AVR_HI8_LDI", /* name */ | |
169 | false, /* partial_inplace */ | |
170 | 0xffff, /* src_mask */ | |
171 | 0xffff, /* dst_mask */ | |
172 | false), /* pcrel_offset */ | |
173 | /* A high 6 bit absolute relocation of 22 bit address. | |
174 | For LDI command. */ | |
175 | HOWTO (R_AVR_HH8_LDI, /* type */ | |
176 | 16, /* rightshift */ | |
177 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
178 | 8, /* bitsize */ | |
179 | false, /* pc_relative */ | |
180 | 0, /* bitpos */ | |
181 | complain_overflow_dont, /* complain_on_overflow */ | |
182 | bfd_elf_generic_reloc, /* special_function */ | |
183 | "R_AVR_HH8_LDI", /* name */ | |
184 | false, /* partial_inplace */ | |
185 | 0xffff, /* src_mask */ | |
186 | 0xffff, /* dst_mask */ | |
187 | false), /* pcrel_offset */ | |
188 | /* A negative low 8 bit absolute relocation of 16 bit address. | |
189 | For LDI command. */ | |
190 | HOWTO (R_AVR_LO8_LDI_NEG, /* type */ | |
191 | 0, /* rightshift */ | |
192 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
193 | 8, /* bitsize */ | |
194 | false, /* pc_relative */ | |
195 | 0, /* bitpos */ | |
196 | complain_overflow_dont, /* complain_on_overflow */ | |
197 | bfd_elf_generic_reloc, /* special_function */ | |
198 | "R_AVR_LO8_LDI_NEG", /* name */ | |
199 | false, /* partial_inplace */ | |
200 | 0xffff, /* src_mask */ | |
201 | 0xffff, /* dst_mask */ | |
202 | false), /* pcrel_offset */ | |
203 | /* A hegative high 8 bit absolute relocation of 16 bit address. | |
204 | For LDI command. */ | |
205 | HOWTO (R_AVR_HI8_LDI_NEG, /* type */ | |
206 | 8, /* rightshift */ | |
207 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
208 | 8, /* bitsize */ | |
209 | false, /* pc_relative */ | |
210 | 0, /* bitpos */ | |
211 | complain_overflow_dont, /* complain_on_overflow */ | |
212 | bfd_elf_generic_reloc, /* special_function */ | |
213 | "R_AVR_HI8_LDI_NEG", /* name */ | |
214 | false, /* partial_inplace */ | |
215 | 0xffff, /* src_mask */ | |
216 | 0xffff, /* dst_mask */ | |
217 | false), /* pcrel_offset */ | |
218 | /* A hegative high 6 bit absolute relocation of 22 bit address. | |
219 | For LDI command. */ | |
220 | HOWTO (R_AVR_HH8_LDI_NEG, /* type */ | |
221 | 16, /* rightshift */ | |
222 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
223 | 8, /* bitsize */ | |
224 | false, /* pc_relative */ | |
225 | 0, /* bitpos */ | |
226 | complain_overflow_dont, /* complain_on_overflow */ | |
227 | bfd_elf_generic_reloc, /* special_function */ | |
228 | "R_AVR_HH8_LDI_NEG", /* name */ | |
229 | false, /* partial_inplace */ | |
230 | 0xffff, /* src_mask */ | |
231 | 0xffff, /* dst_mask */ | |
232 | false), /* pcrel_offset */ | |
233 | /* A low 8 bit absolute relocation of 24 bit program memory address. | |
234 | For LDI command. */ | |
235 | HOWTO (R_AVR_LO8_LDI_PM, /* type */ | |
236 | 1, /* rightshift */ | |
237 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
238 | 8, /* bitsize */ | |
239 | false, /* pc_relative */ | |
240 | 0, /* bitpos */ | |
241 | complain_overflow_dont, /* complain_on_overflow */ | |
242 | bfd_elf_generic_reloc, /* special_function */ | |
243 | "R_AVR_LO8_LDI_PM", /* name */ | |
244 | false, /* partial_inplace */ | |
245 | 0xffff, /* src_mask */ | |
246 | 0xffff, /* dst_mask */ | |
247 | false), /* pcrel_offset */ | |
248 | /* A high 8 bit absolute relocation of 16 bit program memory address. | |
249 | For LDI command. */ | |
250 | HOWTO (R_AVR_HI8_LDI_PM, /* type */ | |
251 | 9, /* rightshift */ | |
252 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
253 | 8, /* bitsize */ | |
254 | false, /* pc_relative */ | |
255 | 0, /* bitpos */ | |
256 | complain_overflow_dont, /* complain_on_overflow */ | |
257 | bfd_elf_generic_reloc, /* special_function */ | |
258 | "R_AVR_HI8_LDI_PM", /* name */ | |
259 | false, /* partial_inplace */ | |
260 | 0xffff, /* src_mask */ | |
261 | 0xffff, /* dst_mask */ | |
262 | false), /* pcrel_offset */ | |
263 | /* A high 8 bit absolute relocation of 24 bit program memory address. | |
264 | For LDI command. */ | |
265 | HOWTO (R_AVR_HH8_LDI_PM, /* type */ | |
266 | 17, /* rightshift */ | |
267 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
268 | 8, /* bitsize */ | |
269 | false, /* pc_relative */ | |
270 | 0, /* bitpos */ | |
271 | complain_overflow_dont, /* complain_on_overflow */ | |
272 | bfd_elf_generic_reloc, /* special_function */ | |
273 | "R_AVR_HH8_LDI_PM", /* name */ | |
274 | false, /* partial_inplace */ | |
275 | 0xffff, /* src_mask */ | |
276 | 0xffff, /* dst_mask */ | |
277 | false), /* pcrel_offset */ | |
278 | /* A low 8 bit absolute relocation of a negative 24 bit | |
279 | program memory address. For LDI command. */ | |
280 | HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */ | |
281 | 1, /* rightshift */ | |
282 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
283 | 8, /* bitsize */ | |
284 | false, /* pc_relative */ | |
285 | 0, /* bitpos */ | |
286 | complain_overflow_dont, /* complain_on_overflow */ | |
287 | bfd_elf_generic_reloc, /* special_function */ | |
288 | "R_AVR_LO8_LDI_PM_NEG", /* name */ | |
289 | false, /* partial_inplace */ | |
290 | 0xffff, /* src_mask */ | |
291 | 0xffff, /* dst_mask */ | |
292 | false), /* pcrel_offset */ | |
293 | /* A high 8 bit absolute relocation of a negative 16 bit | |
294 | program memory address. For LDI command. */ | |
295 | HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */ | |
296 | 9, /* rightshift */ | |
297 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
298 | 8, /* bitsize */ | |
299 | false, /* pc_relative */ | |
300 | 0, /* bitpos */ | |
301 | complain_overflow_dont, /* complain_on_overflow */ | |
302 | bfd_elf_generic_reloc, /* special_function */ | |
303 | "R_AVR_HI8_LDI_PM_NEG", /* name */ | |
304 | false, /* partial_inplace */ | |
305 | 0xffff, /* src_mask */ | |
306 | 0xffff, /* dst_mask */ | |
307 | false), /* pcrel_offset */ | |
308 | /* A high 8 bit absolute relocation of a negative 24 bit | |
309 | program memory address. For LDI command. */ | |
310 | HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */ | |
311 | 17, /* rightshift */ | |
312 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
313 | 8, /* bitsize */ | |
314 | false, /* pc_relative */ | |
315 | 0, /* bitpos */ | |
316 | complain_overflow_dont, /* complain_on_overflow */ | |
317 | bfd_elf_generic_reloc, /* special_function */ | |
318 | "R_AVR_HH8_LDI_PM_NEG", /* name */ | |
319 | false, /* partial_inplace */ | |
320 | 0xffff, /* src_mask */ | |
321 | 0xffff, /* dst_mask */ | |
322 | false), /* pcrel_offset */ | |
323 | /* Relocation for CALL command in ATmega. */ | |
324 | HOWTO (R_AVR_CALL, /* type */ | |
325 | 1, /* rightshift */ | |
326 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
327 | 23, /* bitsize */ | |
328 | false, /* pc_relative */ | |
329 | 0, /* bitpos */ | |
330 | complain_overflow_dont, /* complain_on_overflow */ | |
331 | bfd_elf_generic_reloc, /* special_function */ | |
332 | "R_AVR_CALL", /* name */ | |
333 | false, /* partial_inplace */ | |
334 | 0xffffffff, /* src_mask */ | |
335 | 0xffffffff, /* dst_mask */ | |
336 | false) /* pcrel_offset */ | |
337 | }; | |
338 | ||
339 | /* Map BFD reloc types to AVR ELF reloc types. */ | |
340 | ||
341 | struct avr_reloc_map | |
342 | { | |
343 | bfd_reloc_code_real_type bfd_reloc_val; | |
344 | unsigned int elf_reloc_val; | |
345 | }; | |
346 | ||
347 | static const struct avr_reloc_map avr_reloc_map[] = | |
348 | { | |
349 | { BFD_RELOC_NONE, R_AVR_NONE }, | |
350 | { BFD_RELOC_32, R_AVR_32 }, | |
351 | { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL }, | |
352 | { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL }, | |
353 | { BFD_RELOC_16, R_AVR_16 }, | |
354 | { BFD_RELOC_AVR_16_PM, R_AVR_16_PM }, | |
355 | { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI}, | |
356 | { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI }, | |
357 | { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI }, | |
358 | { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG }, | |
359 | { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG }, | |
360 | { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG }, | |
361 | { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM }, | |
362 | { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM }, | |
363 | { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM }, | |
364 | { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG }, | |
365 | { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG }, | |
366 | { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG }, | |
367 | { BFD_RELOC_AVR_CALL, R_AVR_CALL } | |
368 | }; | |
369 | ||
370 | static reloc_howto_type * | |
371 | bfd_elf32_bfd_reloc_type_lookup (abfd, code) | |
00d2865b | 372 | bfd *abfd ATTRIBUTE_UNUSED; |
adde6300 AM |
373 | bfd_reloc_code_real_type code; |
374 | { | |
375 | unsigned int i; | |
376 | ||
377 | for (i = 0; | |
378 | i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map); | |
379 | i++) | |
380 | { | |
381 | if (avr_reloc_map[i].bfd_reloc_val == code) | |
382 | return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val]; | |
383 | } | |
384 | ||
385 | return NULL; | |
386 | } | |
387 | ||
388 | /* Set the howto pointer for an AVR ELF reloc. */ | |
389 | ||
390 | static void | |
391 | avr_info_to_howto_rela (abfd, cache_ptr, dst) | |
00d2865b | 392 | bfd *abfd ATTRIBUTE_UNUSED; |
adde6300 AM |
393 | arelent *cache_ptr; |
394 | Elf32_Internal_Rela *dst; | |
395 | { | |
396 | unsigned int r_type; | |
397 | ||
398 | r_type = ELF32_R_TYPE (dst->r_info); | |
399 | BFD_ASSERT (r_type < (unsigned int) R_AVR_max); | |
400 | cache_ptr->howto = &elf_avr_howto_table[r_type]; | |
401 | } | |
402 | ||
403 | static asection * | |
404 | elf32_avr_gc_mark_hook (abfd, info, rel, h, sym) | |
405 | bfd *abfd; | |
00d2865b | 406 | struct bfd_link_info *info ATTRIBUTE_UNUSED; |
adde6300 AM |
407 | Elf_Internal_Rela *rel; |
408 | struct elf_link_hash_entry *h; | |
409 | Elf_Internal_Sym *sym; | |
410 | { | |
411 | if (h != NULL) | |
412 | { | |
413 | switch (ELF32_R_TYPE (rel->r_info)) | |
414 | { | |
415 | default: | |
416 | switch (h->root.type) | |
417 | { | |
418 | case bfd_link_hash_defined: | |
419 | case bfd_link_hash_defweak: | |
420 | return h->root.u.def.section; | |
421 | ||
422 | case bfd_link_hash_common: | |
423 | return h->root.u.c.p->section; | |
424 | ||
425 | default: | |
426 | break; | |
427 | } | |
428 | } | |
429 | } | |
430 | else | |
431 | { | |
432 | if (!(elf_bad_symtab (abfd) | |
433 | && ELF_ST_BIND (sym->st_info) != STB_LOCAL) | |
434 | && !((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE) | |
435 | && sym->st_shndx != SHN_COMMON)) | |
436 | { | |
437 | return bfd_section_from_elf_index (abfd, sym->st_shndx); | |
438 | } | |
439 | } | |
440 | return NULL; | |
441 | } | |
442 | ||
443 | static boolean | |
444 | elf32_avr_gc_sweep_hook (abfd, info, sec, relocs) | |
00d2865b NC |
445 | bfd *abfd ATTRIBUTE_UNUSED; |
446 | struct bfd_link_info *info ATTRIBUTE_UNUSED; | |
447 | asection *sec ATTRIBUTE_UNUSED; | |
448 | const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED; | |
adde6300 AM |
449 | { |
450 | /* We don't use got and plt entries for avr. */ | |
451 | return true; | |
452 | } | |
453 | ||
454 | /* Look through the relocs for a section during the first phase. | |
455 | Since we don't do .gots or .plts, we just need to consider the | |
456 | virtual table relocs for gc. */ | |
457 | ||
458 | static boolean | |
459 | elf32_avr_check_relocs (abfd, info, sec, relocs) | |
460 | bfd *abfd; | |
461 | struct bfd_link_info *info; | |
462 | asection *sec; | |
463 | const Elf_Internal_Rela *relocs; | |
464 | { | |
465 | Elf_Internal_Shdr *symtab_hdr; | |
466 | struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; | |
467 | const Elf_Internal_Rela *rel; | |
468 | const Elf_Internal_Rela *rel_end; | |
469 | ||
470 | if (info->relocateable) | |
471 | return true; | |
472 | ||
473 | symtab_hdr = &elf_tdata (abfd)->symtab_hdr; | |
474 | sym_hashes = elf_sym_hashes (abfd); | |
475 | sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym); | |
476 | if (!elf_bad_symtab (abfd)) | |
477 | sym_hashes_end -= symtab_hdr->sh_info; | |
478 | ||
479 | rel_end = relocs + sec->reloc_count; | |
480 | for (rel = relocs; rel < rel_end; rel++) | |
481 | { | |
482 | struct elf_link_hash_entry *h; | |
483 | unsigned long r_symndx; | |
484 | ||
485 | r_symndx = ELF32_R_SYM (rel->r_info); | |
486 | if (r_symndx < symtab_hdr->sh_info) | |
487 | h = NULL; | |
488 | else | |
489 | h = sym_hashes[r_symndx - symtab_hdr->sh_info]; | |
490 | } | |
491 | ||
492 | return true; | |
493 | } | |
494 | ||
495 | /* Perform a single relocation. By default we use the standard BFD | |
496 | routines, but a few relocs, we have to do them ourselves. */ | |
497 | ||
498 | static bfd_reloc_status_type | |
499 | avr_final_link_relocate (howto, input_bfd, input_section, | |
500 | contents, rel, relocation) | |
501 | reloc_howto_type * howto; | |
502 | bfd * input_bfd; | |
503 | asection * input_section; | |
504 | bfd_byte * contents; | |
505 | Elf_Internal_Rela * rel; | |
506 | bfd_vma relocation; | |
507 | { | |
508 | bfd_reloc_status_type r = bfd_reloc_ok; | |
509 | bfd_vma x; | |
510 | bfd_signed_vma srel; | |
511 | ||
512 | switch (howto->type) | |
513 | { | |
514 | case R_AVR_7_PCREL: | |
515 | contents += rel->r_offset; | |
516 | srel = (bfd_signed_vma) relocation; | |
517 | srel += rel->r_addend; | |
518 | srel -= rel->r_offset; | |
519 | srel -= 2; /* Branch instructions add 2 to the PC... */ | |
520 | srel -= (input_section->output_section->vma + | |
521 | input_section->output_offset); | |
522 | ||
523 | if (srel & 1) | |
524 | return bfd_reloc_outofrange; | |
525 | if (srel > ((1 << 7) - 1) || (srel < - (1 << 7))) | |
526 | return bfd_reloc_overflow; | |
527 | x = bfd_get_16 (input_bfd, contents); | |
528 | x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8); | |
529 | bfd_put_16 (input_bfd, x, contents); | |
530 | break; | |
531 | ||
532 | case R_AVR_13_PCREL: | |
533 | contents += rel->r_offset; | |
534 | srel = (bfd_signed_vma) relocation; | |
535 | srel += rel->r_addend; | |
536 | srel -= rel->r_offset; | |
537 | srel -= 2; /* Branch instructions add 2 to the PC... */ | |
538 | srel -= (input_section->output_section->vma + | |
539 | input_section->output_offset); | |
540 | ||
541 | if (srel & 1) | |
542 | return bfd_reloc_outofrange; | |
543 | ||
544 | /* AVR addresses commands as words. */ | |
545 | srel >>= 1; | |
546 | ||
547 | /* Check for overflow. */ | |
548 | if (srel < -2048 || srel > 2047) | |
549 | { | |
550 | /* Apply WRAPAROUND if possible. */ | |
65aa24b6 | 551 | switch (bfd_get_mach (input_bfd)) |
adde6300 | 552 | { |
65aa24b6 NC |
553 | case bfd_mach_avr2: |
554 | case bfd_mach_avr4: | |
555 | break; | |
556 | ||
557 | default: | |
558 | return bfd_reloc_overflow; | |
adde6300 | 559 | } |
adde6300 AM |
560 | } |
561 | ||
562 | x = bfd_get_16 (input_bfd, contents); | |
563 | x = (x & 0xf000) | (srel & 0xfff); | |
564 | bfd_put_16 (input_bfd, x, contents); | |
565 | break; | |
566 | ||
567 | case R_AVR_LO8_LDI: | |
568 | contents += rel->r_offset; | |
569 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
570 | x = bfd_get_16 (input_bfd, contents); | |
571 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
572 | bfd_put_16 (input_bfd, x, contents); | |
573 | break; | |
574 | ||
575 | case R_AVR_HI8_LDI: | |
576 | contents += rel->r_offset; | |
577 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
578 | srel = (srel >> 8) & 0xff; | |
579 | x = bfd_get_16 (input_bfd, contents); | |
580 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
581 | bfd_put_16 (input_bfd, x, contents); | |
582 | break; | |
583 | ||
584 | case R_AVR_HH8_LDI: | |
585 | contents += rel->r_offset; | |
586 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
587 | srel = (srel >> 16) & 0xff; | |
588 | x = bfd_get_16 (input_bfd, contents); | |
589 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
590 | bfd_put_16 (input_bfd, x, contents); | |
591 | break; | |
592 | ||
593 | case R_AVR_LO8_LDI_NEG: | |
594 | contents += rel->r_offset; | |
595 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
596 | srel = -srel; | |
597 | x = bfd_get_16 (input_bfd, contents); | |
598 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
599 | bfd_put_16 (input_bfd, x, contents); | |
600 | break; | |
601 | ||
602 | case R_AVR_HI8_LDI_NEG: | |
603 | contents += rel->r_offset; | |
604 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
605 | srel = -srel; | |
606 | srel = (srel >> 8) & 0xff; | |
607 | x = bfd_get_16 (input_bfd, contents); | |
608 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
609 | bfd_put_16 (input_bfd, x, contents); | |
610 | break; | |
611 | ||
612 | case R_AVR_HH8_LDI_NEG: | |
613 | contents += rel->r_offset; | |
614 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
615 | srel = -srel; | |
616 | srel = (srel >> 16) & 0xff; | |
617 | x = bfd_get_16 (input_bfd, contents); | |
618 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
619 | bfd_put_16 (input_bfd, x, contents); | |
620 | break; | |
621 | ||
622 | case R_AVR_LO8_LDI_PM: | |
623 | contents += rel->r_offset; | |
624 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
625 | if (srel & 1) | |
626 | return bfd_reloc_outofrange; | |
627 | srel = srel >> 1; | |
628 | x = bfd_get_16 (input_bfd, contents); | |
629 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
630 | bfd_put_16 (input_bfd, x, contents); | |
631 | break; | |
632 | ||
633 | case R_AVR_HI8_LDI_PM: | |
634 | contents += rel->r_offset; | |
635 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
636 | if (srel & 1) | |
637 | return bfd_reloc_outofrange; | |
638 | srel = srel >> 1; | |
639 | srel = (srel >> 8) & 0xff; | |
640 | x = bfd_get_16 (input_bfd, contents); | |
641 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
642 | bfd_put_16 (input_bfd, x, contents); | |
643 | break; | |
644 | ||
645 | case R_AVR_HH8_LDI_PM: | |
646 | contents += rel->r_offset; | |
647 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
648 | if (srel & 1) | |
649 | return bfd_reloc_outofrange; | |
650 | srel = srel >> 1; | |
651 | srel = (srel >> 16) & 0xff; | |
652 | x = bfd_get_16 (input_bfd, contents); | |
653 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
654 | bfd_put_16 (input_bfd, x, contents); | |
655 | break; | |
656 | ||
657 | case R_AVR_LO8_LDI_PM_NEG: | |
658 | contents += rel->r_offset; | |
659 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
660 | srel = -srel; | |
661 | if (srel & 1) | |
662 | return bfd_reloc_outofrange; | |
663 | srel = srel >> 1; | |
664 | x = bfd_get_16 (input_bfd, contents); | |
665 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
666 | bfd_put_16 (input_bfd, x, contents); | |
667 | break; | |
668 | ||
669 | case R_AVR_HI8_LDI_PM_NEG: | |
670 | contents += rel->r_offset; | |
671 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
672 | srel = -srel; | |
673 | if (srel & 1) | |
674 | return bfd_reloc_outofrange; | |
675 | srel = srel >> 1; | |
676 | srel = (srel >> 8) & 0xff; | |
677 | x = bfd_get_16 (input_bfd, contents); | |
678 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
679 | bfd_put_16 (input_bfd, x, contents); | |
680 | break; | |
681 | ||
682 | case R_AVR_HH8_LDI_PM_NEG: | |
683 | contents += rel->r_offset; | |
684 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
685 | srel = -srel; | |
686 | if (srel & 1) | |
687 | return bfd_reloc_outofrange; | |
688 | srel = srel >> 1; | |
689 | srel = (srel >> 16) & 0xff; | |
690 | x = bfd_get_16 (input_bfd, contents); | |
691 | x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); | |
692 | bfd_put_16 (input_bfd, x, contents); | |
693 | break; | |
694 | ||
695 | case R_AVR_CALL: | |
696 | contents += rel->r_offset; | |
697 | srel = (bfd_signed_vma) relocation + rel->r_addend; | |
698 | if (srel & 1) | |
699 | return bfd_reloc_outofrange; | |
700 | srel = srel >> 1; | |
701 | x = bfd_get_16 (input_bfd, contents); | |
702 | x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16; | |
703 | bfd_put_16 (input_bfd, x, contents); | |
704 | bfd_put_16 (input_bfd, srel & 0xffff, contents+2); | |
705 | break; | |
706 | ||
707 | default: | |
708 | r = _bfd_final_link_relocate (howto, input_bfd, input_section, | |
709 | contents, rel->r_offset, | |
710 | relocation, rel->r_addend); | |
711 | } | |
712 | ||
713 | return r; | |
714 | } | |
715 | ||
716 | /* Relocate an AVR ELF section. */ | |
717 | static boolean | |
718 | elf32_avr_relocate_section (output_bfd, info, input_bfd, input_section, | |
719 | contents, relocs, local_syms, local_sections) | |
00d2865b | 720 | bfd *output_bfd ATTRIBUTE_UNUSED; |
adde6300 AM |
721 | struct bfd_link_info *info; |
722 | bfd *input_bfd; | |
723 | asection *input_section; | |
724 | bfd_byte *contents; | |
725 | Elf_Internal_Rela *relocs; | |
726 | Elf_Internal_Sym *local_syms; | |
727 | asection **local_sections; | |
728 | { | |
729 | Elf_Internal_Shdr * symtab_hdr; | |
730 | struct elf_link_hash_entry ** sym_hashes; | |
731 | Elf_Internal_Rela * rel; | |
732 | Elf_Internal_Rela * relend; | |
733 | ||
734 | symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; | |
735 | sym_hashes = elf_sym_hashes (input_bfd); | |
736 | relend = relocs + input_section->reloc_count; | |
737 | ||
738 | for (rel = relocs; rel < relend; rel ++) | |
739 | { | |
740 | reloc_howto_type * howto; | |
741 | unsigned long r_symndx; | |
742 | Elf_Internal_Sym * sym; | |
743 | asection * sec; | |
744 | struct elf_link_hash_entry * h; | |
745 | bfd_vma relocation; | |
746 | bfd_reloc_status_type r; | |
747 | const char * name = NULL; | |
748 | int r_type; | |
749 | ||
750 | r_type = ELF32_R_TYPE (rel->r_info); | |
751 | r_symndx = ELF32_R_SYM (rel->r_info); | |
752 | ||
753 | if (info->relocateable) | |
754 | { | |
755 | /* This is a relocateable link. We don't have to change | |
756 | anything, unless the reloc is against a section symbol, | |
757 | in which case we have to adjust according to where the | |
758 | section symbol winds up in the output section. */ | |
759 | if (r_symndx < symtab_hdr->sh_info) | |
760 | { | |
761 | sym = local_syms + r_symndx; | |
762 | ||
763 | if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) | |
764 | { | |
765 | sec = local_sections [r_symndx]; | |
766 | rel->r_addend += sec->output_offset + sym->st_value; | |
767 | } | |
768 | } | |
769 | ||
770 | continue; | |
771 | } | |
772 | ||
773 | /* This is a final link. */ | |
774 | howto = elf_avr_howto_table + ELF32_R_TYPE (rel->r_info); | |
775 | h = NULL; | |
776 | sym = NULL; | |
777 | sec = NULL; | |
778 | ||
779 | if (r_symndx < symtab_hdr->sh_info) | |
780 | { | |
781 | sym = local_syms + r_symndx; | |
782 | sec = local_sections [r_symndx]; | |
783 | relocation = (sec->output_section->vma | |
784 | + sec->output_offset | |
785 | + sym->st_value); | |
786 | ||
787 | name = bfd_elf_string_from_elf_section | |
788 | (input_bfd, symtab_hdr->sh_link, sym->st_name); | |
789 | name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; | |
790 | } | |
791 | else | |
792 | { | |
793 | h = sym_hashes [r_symndx - symtab_hdr->sh_info]; | |
794 | ||
795 | while (h->root.type == bfd_link_hash_indirect | |
796 | || h->root.type == bfd_link_hash_warning) | |
797 | h = (struct elf_link_hash_entry *) h->root.u.i.link; | |
798 | ||
799 | name = h->root.root.string; | |
800 | ||
801 | if (h->root.type == bfd_link_hash_defined | |
802 | || h->root.type == bfd_link_hash_defweak) | |
803 | { | |
804 | sec = h->root.u.def.section; | |
805 | relocation = (h->root.u.def.value | |
806 | + sec->output_section->vma | |
807 | + sec->output_offset); | |
808 | } | |
809 | else if (h->root.type == bfd_link_hash_undefweak) | |
810 | { | |
811 | relocation = 0; | |
812 | } | |
813 | else | |
814 | { | |
815 | if (! ((*info->callbacks->undefined_symbol) | |
816 | (info, h->root.root.string, input_bfd, | |
817 | input_section, rel->r_offset, true))) | |
818 | return false; | |
819 | relocation = 0; | |
820 | } | |
821 | } | |
822 | ||
823 | r = avr_final_link_relocate (howto, input_bfd, input_section, | |
824 | contents, rel, relocation); | |
825 | ||
826 | if (r != bfd_reloc_ok) | |
827 | { | |
828 | const char * msg = (const char *) NULL; | |
829 | ||
830 | switch (r) | |
831 | { | |
832 | case bfd_reloc_overflow: | |
833 | r = info->callbacks->reloc_overflow | |
834 | (info, name, howto->name, (bfd_vma) 0, | |
835 | input_bfd, input_section, rel->r_offset); | |
836 | break; | |
837 | ||
838 | case bfd_reloc_undefined: | |
839 | r = info->callbacks->undefined_symbol | |
840 | (info, name, input_bfd, input_section, rel->r_offset, true); | |
841 | break; | |
842 | ||
843 | case bfd_reloc_outofrange: | |
844 | msg = _("internal error: out of range error"); | |
845 | break; | |
846 | ||
847 | case bfd_reloc_notsupported: | |
848 | msg = _("internal error: unsupported relocation error"); | |
849 | break; | |
850 | ||
851 | case bfd_reloc_dangerous: | |
852 | msg = _("internal error: dangerous relocation"); | |
853 | break; | |
854 | ||
855 | default: | |
856 | msg = _("internal error: unknown error"); | |
857 | break; | |
858 | } | |
859 | ||
860 | if (msg) | |
861 | r = info->callbacks->warning | |
862 | (info, msg, name, input_bfd, input_section, rel->r_offset); | |
863 | ||
864 | if (! r) | |
865 | return false; | |
866 | } | |
867 | } | |
868 | ||
869 | return true; | |
870 | } | |
871 | ||
872 | /* The final processing done just before writing out a AVR ELF object | |
873 | file. This gets the AVR architecture right based on the machine | |
874 | number. */ | |
875 | ||
876 | static void | |
877 | bfd_elf_avr_final_write_processing (abfd, linker) | |
878 | bfd *abfd; | |
879 | boolean linker ATTRIBUTE_UNUSED; | |
880 | { | |
881 | unsigned long val; | |
882 | ||
883 | switch (bfd_get_mach (abfd)) | |
884 | { | |
885 | default: | |
886 | case bfd_mach_avr2: | |
887 | val = E_AVR_MACH_AVR2; | |
888 | break; | |
889 | ||
890 | case bfd_mach_avr1: | |
891 | val = E_AVR_MACH_AVR1; | |
892 | break; | |
893 | ||
894 | case bfd_mach_avr3: | |
895 | val = E_AVR_MACH_AVR3; | |
896 | break; | |
897 | ||
898 | case bfd_mach_avr4: | |
899 | val = E_AVR_MACH_AVR4; | |
900 | break; | |
901 | ||
65aa24b6 NC |
902 | case bfd_mach_avr5: |
903 | val = E_AVR_MACH_AVR5; | |
904 | break; | |
adde6300 AM |
905 | } |
906 | ||
907 | elf_elfheader (abfd)->e_machine = EM_AVR; | |
908 | elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH; | |
909 | elf_elfheader (abfd)->e_flags |= val; | |
910 | } | |
911 | ||
912 | /* Set the right machine number. */ | |
913 | ||
914 | static boolean | |
915 | elf32_avr_object_p (abfd) | |
916 | bfd *abfd; | |
917 | { | |
918 | int e_set = bfd_mach_avr2; | |
919 | if (elf_elfheader (abfd)->e_machine == EM_AVR) | |
920 | { | |
921 | int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH; | |
922 | switch (e_mach) | |
923 | { | |
924 | default: | |
925 | case E_AVR_MACH_AVR2: | |
926 | e_set = bfd_mach_avr2; | |
927 | break; | |
928 | ||
929 | case E_AVR_MACH_AVR1: | |
930 | e_set = bfd_mach_avr1; | |
931 | break; | |
932 | ||
933 | case E_AVR_MACH_AVR3: | |
934 | e_set = bfd_mach_avr3; | |
935 | break; | |
936 | ||
937 | case E_AVR_MACH_AVR4: | |
938 | e_set = bfd_mach_avr4; | |
939 | break; | |
65aa24b6 NC |
940 | |
941 | case E_AVR_MACH_AVR5: | |
942 | e_set = bfd_mach_avr5; | |
943 | break; | |
adde6300 AM |
944 | } |
945 | } | |
946 | return bfd_default_set_arch_mach (abfd, bfd_arch_avr, | |
947 | e_set); | |
948 | } | |
949 | ||
950 | ||
951 | #define ELF_ARCH bfd_arch_avr | |
952 | #define ELF_MACHINE_CODE EM_AVR | |
953 | #define ELF_MAXPAGESIZE 1 | |
954 | ||
955 | #define TARGET_LITTLE_SYM bfd_elf32_avr_vec | |
956 | #define TARGET_LITTLE_NAME "elf32-avr" | |
957 | ||
958 | #define elf_info_to_howto avr_info_to_howto_rela | |
959 | #define elf_info_to_howto_rel NULL | |
960 | #define elf_backend_relocate_section elf32_avr_relocate_section | |
961 | #define elf_backend_gc_mark_hook elf32_avr_gc_mark_hook | |
962 | #define elf_backend_gc_sweep_hook elf32_avr_gc_sweep_hook | |
963 | #define elf_backend_check_relocs elf32_avr_check_relocs | |
964 | #define elf_backend_can_gc_sections 1 | |
965 | #define elf_backend_final_write_processing \ | |
966 | bfd_elf_avr_final_write_processing | |
967 | #define elf_backend_object_p elf32_avr_object_p | |
968 | ||
969 | ||
970 | #include "elf32-target.h" |