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