projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
x86: Define GNU_PROPERTY_X86_ISA_1_AVX512_BF16
[deliverable/binutils-gdb.git] / bfd / elf32-avr.c
CommitLineData
adde6300 1/* AVR-specific support for 32-bit ELF
82704155 2 Copyright (C) 1999-2019 Free Software Foundation, Inc.
adde6300
AM		 3 Contributed by Denis Chertykov <denisc@overta.ru>
4
750bce0e 5 This file is part of BFD, the Binary File Descriptor library.
adde6300 6
750bce0e
NC		 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
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
750bce0e 10 (at your option) any later version.
adde6300 11
750bce0e
NC		 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.
adde6300 16
750bce0e
NC		 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
4cdc7696 19 Foundation, Inc., 51 Franklin Street - Fifth Floor,
df406460 20 Boston, MA 02110-1301, USA. */
adde6300 21
adde6300 22#include "sysdep.h"
3db64b00 23#include "bfd.h"
adde6300
AM		 24#include "libbfd.h"
25#include "elf-bfd.h"
26#include "elf/avr.h"
28c9d252
NC		 27#include "elf32-avr.h"
28
29/* Enable debugging printout at stdout with this variable. */
30static bfd_boolean debug_relax = FALSE;
31
32/* Enable debugging printout at stdout with this variable. */
33static bfd_boolean debug_stubs = FALSE;
34
e4ef1b6c 35static bfd_reloc_status_type
f36e8886
BS		 36bfd_elf_avr_diff_reloc (bfd *, arelent *, asymbol *, void *,
37 asection *, bfd *, char **);
e4ef1b6c 38
28c9d252
NC		 39/* Hash table initialization and handling. Code is taken from the hppa port
40 and adapted to the needs of AVR. */
41
42/* We use two hash tables to hold information for linking avr objects.
43
4dfe6ac6 44 The first is the elf32_avr_link_hash_table which is derived from the
28c9d252
NC		 45 stanard ELF linker hash table. We use this as a place to attach the other
46 hash table and some static information.
47
48 The second is the stub hash table which is derived from the base BFD
49 hash table. The stub hash table holds the information on the linker
50 stubs. */
51
52struct elf32_avr_stub_hash_entry
53{
54 /* Base hash table entry structure. */
55 struct bfd_hash_entry bh_root;
56
57 /* Offset within stub_sec of the beginning of this stub. */
58 bfd_vma stub_offset;
59
60 /* Given the symbol's value and its section we can determine its final
61 value when building the stubs (so the stub knows where to jump). */
62 bfd_vma target_value;
63
64 /* This way we could mark stubs to be no longer necessary. */
65 bfd_boolean is_actually_needed;
66};
67
68struct elf32_avr_link_hash_table
69{
70 /* The main hash table. */
71 struct elf_link_hash_table etab;
72
73 /* The stub hash table. */
74 struct bfd_hash_table bstab;
75
76 bfd_boolean no_stubs;
77
78 /* Linker stub bfd. */
79 bfd *stub_bfd;
80
81 /* The stub section. */
82 asection *stub_sec;
83
84 /* Usually 0, unless we are generating code for a bootloader. Will
85 be initialized by elf32_avr_size_stubs to the vma offset of the
86 output section associated with the stub section. */
87 bfd_vma vector_base;
88
89 /* Assorted information used by elf32_avr_size_stubs. */
07d6d2b8
AM		 90 unsigned int bfd_count;
91 unsigned int top_index;
92 asection ** input_list;
28c9d252
NC		 93 Elf_Internal_Sym ** all_local_syms;
94
95 /* Tables for mapping vma beyond the 128k boundary to the address of the
96 corresponding stub. (AMT)
97 "amt_max_entry_cnt" reflects the number of entries that memory is allocated
98 for in the "amt_stub_offsets" and "amt_destination_addr" arrays.
99 "amt_entry_cnt" informs how many of these entries actually contain
100 useful data. */
101 unsigned int amt_entry_cnt;
102 unsigned int amt_max_entry_cnt;
103 bfd_vma * amt_stub_offsets;
104 bfd_vma * amt_destination_addr;
105};
106
107/* Various hash macros and functions. */
108#define avr_link_hash_table(p) \
64ee10b6 109 /* PR 3874: Check that we have an AVR style hash table before using it. */\
4dfe6ac6
NC		 110 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
111 == AVR_ELF_DATA ? ((struct elf32_avr_link_hash_table *) ((p)->hash)) : NULL)
28c9d252
NC		 112
113#define avr_stub_hash_entry(ent) \
114 ((struct elf32_avr_stub_hash_entry *)(ent))
115
116#define avr_stub_hash_lookup(table, string, create, copy) \
117 ((struct elf32_avr_stub_hash_entry *) \
118 bfd_hash_lookup ((table), (string), (create), (copy)))
adde6300 119
adde6300
AM		 120static reloc_howto_type elf_avr_howto_table[] =
121{
122 HOWTO (R_AVR_NONE, /* type */
123 0, /* rightshift */
6346d5ca
AM		 124 3, /* size (0 = byte, 1 = short, 2 = long) */
125 0, /* bitsize */
b34976b6 126 FALSE, /* pc_relative */
adde6300 127 0, /* bitpos */
6346d5ca 128 complain_overflow_dont, /* complain_on_overflow */
adde6300
AM		 129 bfd_elf_generic_reloc, /* special_function */
130 "R_AVR_NONE", /* name */
b34976b6 131 FALSE, /* partial_inplace */
adde6300
AM		 132 0, /* src_mask */
133 0, /* dst_mask */
b34976b6 134 FALSE), /* pcrel_offset */
adde6300
AM		 135
136 HOWTO (R_AVR_32, /* type */
137 0, /* rightshift */
138 2, /* size (0 = byte, 1 = short, 2 = long) */
139 32, /* bitsize */
b34976b6 140 FALSE, /* pc_relative */
adde6300
AM		 141 0, /* bitpos */
142 complain_overflow_bitfield, /* complain_on_overflow */
143 bfd_elf_generic_reloc, /* special_function */
144 "R_AVR_32", /* name */
b34976b6 145 FALSE, /* partial_inplace */
adde6300
AM		 146 0xffffffff, /* src_mask */
147 0xffffffff, /* dst_mask */
b34976b6 148 FALSE), /* pcrel_offset */
adde6300
AM		 149
150 /* A 7 bit PC relative relocation. */
151 HOWTO (R_AVR_7_PCREL, /* type */
152 1, /* rightshift */
153 1, /* size (0 = byte, 1 = short, 2 = long) */
154 7, /* bitsize */
b34976b6 155 TRUE, /* pc_relative */
adde6300
AM		 156 3, /* bitpos */
157 complain_overflow_bitfield, /* complain_on_overflow */
158 bfd_elf_generic_reloc, /* special_function */
159 "R_AVR_7_PCREL", /* name */
b34976b6 160 FALSE, /* partial_inplace */
adde6300
AM		 161 0xffff, /* src_mask */
162 0xffff, /* dst_mask */
b34976b6 163 TRUE), /* pcrel_offset */
adde6300
AM		 164
165 /* A 13 bit PC relative relocation. */
166 HOWTO (R_AVR_13_PCREL, /* type */
167 1, /* rightshift */
168 1, /* size (0 = byte, 1 = short, 2 = long) */
169 13, /* bitsize */
b34976b6 170 TRUE, /* pc_relative */
adde6300
AM		 171 0, /* bitpos */
172 complain_overflow_bitfield, /* complain_on_overflow */
173 bfd_elf_generic_reloc, /* special_function */
174 "R_AVR_13_PCREL", /* name */
b34976b6 175 FALSE, /* partial_inplace */
adde6300
AM		 176 0xfff, /* src_mask */
177 0xfff, /* dst_mask */
b34976b6 178 TRUE), /* pcrel_offset */
adde6300
AM		 179
180 /* A 16 bit absolute relocation. */
181 HOWTO (R_AVR_16, /* type */
182 0, /* rightshift */
183 1, /* size (0 = byte, 1 = short, 2 = long) */
184 16, /* bitsize */
b34976b6 185 FALSE, /* pc_relative */
adde6300
AM		 186 0, /* bitpos */
187 complain_overflow_dont, /* complain_on_overflow */
188 bfd_elf_generic_reloc, /* special_function */
189 "R_AVR_16", /* name */
b34976b6 190 FALSE, /* partial_inplace */
adde6300
AM		 191 0xffff, /* src_mask */
192 0xffff, /* dst_mask */
b34976b6 193 FALSE), /* pcrel_offset */
adde6300 194
28c9d252
NC		 195 /* A 16 bit absolute relocation for command address
196 Will be changed when linker stubs are needed. */
adde6300
AM		 197 HOWTO (R_AVR_16_PM, /* type */
198 1, /* rightshift */
199 1, /* size (0 = byte, 1 = short, 2 = long) */
200 16, /* bitsize */
b34976b6 201 FALSE, /* pc_relative */
adde6300
AM		 202 0, /* bitpos */
203 complain_overflow_bitfield, /* complain_on_overflow */
204 bfd_elf_generic_reloc, /* special_function */
205 "R_AVR_16_PM", /* name */
b34976b6 206 FALSE, /* partial_inplace */
adde6300
AM		 207 0xffff, /* src_mask */
208 0xffff, /* dst_mask */
b34976b6 209 FALSE), /* pcrel_offset */
adde6300
AM		 210 /* A low 8 bit absolute relocation of 16 bit address.
211 For LDI command. */
212 HOWTO (R_AVR_LO8_LDI, /* type */
213 0, /* rightshift */
214 1, /* size (0 = byte, 1 = short, 2 = long) */
215 8, /* bitsize */
b34976b6 216 FALSE, /* pc_relative */
adde6300
AM		 217 0, /* bitpos */
218 complain_overflow_dont, /* complain_on_overflow */
219 bfd_elf_generic_reloc, /* special_function */
220 "R_AVR_LO8_LDI", /* name */
b34976b6 221 FALSE, /* partial_inplace */
adde6300
AM		 222 0xffff, /* src_mask */
223 0xffff, /* dst_mask */
b34976b6 224 FALSE), /* pcrel_offset */
adde6300
AM		 225 /* A high 8 bit absolute relocation of 16 bit address.
226 For LDI command. */
227 HOWTO (R_AVR_HI8_LDI, /* type */
228 8, /* rightshift */
229 1, /* size (0 = byte, 1 = short, 2 = long) */
230 8, /* bitsize */
b34976b6 231 FALSE, /* pc_relative */
adde6300
AM		 232 0, /* bitpos */
233 complain_overflow_dont, /* complain_on_overflow */
234 bfd_elf_generic_reloc, /* special_function */
235 "R_AVR_HI8_LDI", /* name */
b34976b6 236 FALSE, /* partial_inplace */
adde6300
AM		 237 0xffff, /* src_mask */
238 0xffff, /* dst_mask */
b34976b6 239 FALSE), /* pcrel_offset */
adde6300 240 /* A high 6 bit absolute relocation of 22 bit address.
4cdc7696 241 For LDI command. As well second most significant 8 bit value of
df406460 242 a 32 bit link-time constant. */
adde6300
AM		 243 HOWTO (R_AVR_HH8_LDI, /* type */
244 16, /* rightshift */
245 1, /* size (0 = byte, 1 = short, 2 = long) */
246 8, /* bitsize */
b34976b6 247 FALSE, /* pc_relative */
adde6300
AM		 248 0, /* bitpos */
249 complain_overflow_dont, /* complain_on_overflow */
250 bfd_elf_generic_reloc, /* special_function */
251 "R_AVR_HH8_LDI", /* name */
b34976b6 252 FALSE, /* partial_inplace */
adde6300
AM		 253 0xffff, /* src_mask */
254 0xffff, /* dst_mask */
b34976b6 255 FALSE), /* pcrel_offset */
adde6300
AM		 256 /* A negative low 8 bit absolute relocation of 16 bit address.
257 For LDI command. */
258 HOWTO (R_AVR_LO8_LDI_NEG, /* type */
259 0, /* rightshift */
260 1, /* size (0 = byte, 1 = short, 2 = long) */
261 8, /* bitsize */
b34976b6 262 FALSE, /* pc_relative */
adde6300
AM		 263 0, /* bitpos */
264 complain_overflow_dont, /* complain_on_overflow */
265 bfd_elf_generic_reloc, /* special_function */
266 "R_AVR_LO8_LDI_NEG", /* name */
b34976b6 267 FALSE, /* partial_inplace */
adde6300
AM		 268 0xffff, /* src_mask */
269 0xffff, /* dst_mask */
b34976b6 270 FALSE), /* pcrel_offset */
df406460 271 /* A negative high 8 bit absolute relocation of 16 bit address.
adde6300
AM		 272 For LDI command. */
273 HOWTO (R_AVR_HI8_LDI_NEG, /* type */
274 8, /* rightshift */
275 1, /* size (0 = byte, 1 = short, 2 = long) */
276 8, /* bitsize */
b34976b6 277 FALSE, /* pc_relative */
adde6300
AM		 278 0, /* bitpos */
279 complain_overflow_dont, /* complain_on_overflow */
280 bfd_elf_generic_reloc, /* special_function */
281 "R_AVR_HI8_LDI_NEG", /* name */
b34976b6 282 FALSE, /* partial_inplace */
adde6300
AM		 283 0xffff, /* src_mask */
284 0xffff, /* dst_mask */
b34976b6 285 FALSE), /* pcrel_offset */
df406460 286 /* A negative high 6 bit absolute relocation of 22 bit address.
adde6300
AM		 287 For LDI command. */
288 HOWTO (R_AVR_HH8_LDI_NEG, /* type */
289 16, /* rightshift */
290 1, /* size (0 = byte, 1 = short, 2 = long) */
291 8, /* bitsize */
b34976b6 292 FALSE, /* pc_relative */
adde6300
AM		 293 0, /* bitpos */
294 complain_overflow_dont, /* complain_on_overflow */
295 bfd_elf_generic_reloc, /* special_function */
296 "R_AVR_HH8_LDI_NEG", /* name */
b34976b6 297 FALSE, /* partial_inplace */
adde6300
AM		 298 0xffff, /* src_mask */
299 0xffff, /* dst_mask */
b34976b6 300 FALSE), /* pcrel_offset */
adde6300 301 /* A low 8 bit absolute relocation of 24 bit program memory address.
28c9d252 302 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 303 HOWTO (R_AVR_LO8_LDI_PM, /* type */
304 1, /* rightshift */
305 1, /* size (0 = byte, 1 = short, 2 = long) */
306 8, /* bitsize */
b34976b6 307 FALSE, /* pc_relative */
adde6300
AM		 308 0, /* bitpos */
309 complain_overflow_dont, /* complain_on_overflow */
310 bfd_elf_generic_reloc, /* special_function */
311 "R_AVR_LO8_LDI_PM", /* name */
b34976b6 312 FALSE, /* partial_inplace */
adde6300
AM		 313 0xffff, /* src_mask */
314 0xffff, /* dst_mask */
b34976b6 315 FALSE), /* pcrel_offset */
28c9d252
NC		 316 /* A low 8 bit absolute relocation of 24 bit program memory address.
317 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 318 HOWTO (R_AVR_HI8_LDI_PM, /* type */
319 9, /* rightshift */
320 1, /* size (0 = byte, 1 = short, 2 = long) */
321 8, /* bitsize */
b34976b6 322 FALSE, /* pc_relative */
adde6300
AM		 323 0, /* bitpos */
324 complain_overflow_dont, /* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_AVR_HI8_LDI_PM", /* name */
b34976b6 327 FALSE, /* partial_inplace */
adde6300
AM		 328 0xffff, /* src_mask */
329 0xffff, /* dst_mask */
b34976b6 330 FALSE), /* pcrel_offset */
28c9d252
NC		 331 /* A low 8 bit absolute relocation of 24 bit program memory address.
332 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 333 HOWTO (R_AVR_HH8_LDI_PM, /* type */
334 17, /* rightshift */
335 1, /* size (0 = byte, 1 = short, 2 = long) */
336 8, /* bitsize */
b34976b6 337 FALSE, /* pc_relative */
adde6300
AM		 338 0, /* bitpos */
339 complain_overflow_dont, /* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_AVR_HH8_LDI_PM", /* name */
b34976b6 342 FALSE, /* partial_inplace */
adde6300
AM		 343 0xffff, /* src_mask */
344 0xffff, /* dst_mask */
b34976b6 345 FALSE), /* pcrel_offset */
28c9d252
NC		 346 /* A low 8 bit absolute relocation of 24 bit program memory address.
347 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 348 HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */
349 1, /* rightshift */
350 1, /* size (0 = byte, 1 = short, 2 = long) */
351 8, /* bitsize */
b34976b6 352 FALSE, /* pc_relative */
adde6300
AM		 353 0, /* bitpos */
354 complain_overflow_dont, /* complain_on_overflow */
355 bfd_elf_generic_reloc, /* special_function */
356 "R_AVR_LO8_LDI_PM_NEG", /* name */
b34976b6 357 FALSE, /* partial_inplace */
adde6300
AM		 358 0xffff, /* src_mask */
359 0xffff, /* dst_mask */
b34976b6 360 FALSE), /* pcrel_offset */
28c9d252
NC		 361 /* A low 8 bit absolute relocation of 24 bit program memory address.
362 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 363 HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */
364 9, /* rightshift */
365 1, /* size (0 = byte, 1 = short, 2 = long) */
366 8, /* bitsize */
b34976b6 367 FALSE, /* pc_relative */
adde6300
AM		 368 0, /* bitpos */
369 complain_overflow_dont, /* complain_on_overflow */
370 bfd_elf_generic_reloc, /* special_function */
371 "R_AVR_HI8_LDI_PM_NEG", /* name */
b34976b6 372 FALSE, /* partial_inplace */
adde6300
AM		 373 0xffff, /* src_mask */
374 0xffff, /* dst_mask */
b34976b6 375 FALSE), /* pcrel_offset */
28c9d252
NC		 376 /* A low 8 bit absolute relocation of 24 bit program memory address.
377 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 378 HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */
379 17, /* rightshift */
380 1, /* size (0 = byte, 1 = short, 2 = long) */
381 8, /* bitsize */
b34976b6 382 FALSE, /* pc_relative */
adde6300
AM		 383 0, /* bitpos */
384 complain_overflow_dont, /* complain_on_overflow */
385 bfd_elf_generic_reloc, /* special_function */
386 "R_AVR_HH8_LDI_PM_NEG", /* name */
b34976b6 387 FALSE, /* partial_inplace */
adde6300
AM		 388 0xffff, /* src_mask */
389 0xffff, /* dst_mask */
b34976b6 390 FALSE), /* pcrel_offset */
adde6300
AM		 391 /* Relocation for CALL command in ATmega. */
392 HOWTO (R_AVR_CALL, /* type */
393 1, /* rightshift */
394 2, /* size (0 = byte, 1 = short, 2 = long) */
395 23, /* bitsize */
b34976b6 396 FALSE, /* pc_relative */
adde6300 397 0, /* bitpos */
750bce0e 398 complain_overflow_dont,/* complain_on_overflow */
adde6300
AM		 399 bfd_elf_generic_reloc, /* special_function */
400 "R_AVR_CALL", /* name */
b34976b6 401 FALSE, /* partial_inplace */
adde6300
AM		 402 0xffffffff, /* src_mask */
403 0xffffffff, /* dst_mask */
750bce0e
NC		 404 FALSE), /* pcrel_offset */
405 /* A 16 bit absolute relocation of 16 bit address.
406 For LDI command. */
407 HOWTO (R_AVR_LDI, /* type */
408 0, /* rightshift */
409 1, /* size (0 = byte, 1 = short, 2 = long) */
410 16, /* bitsize */
411 FALSE, /* pc_relative */
412 0, /* bitpos */
413 complain_overflow_dont,/* complain_on_overflow */
414 bfd_elf_generic_reloc, /* special_function */
415 "R_AVR_LDI", /* name */
416 FALSE, /* partial_inplace */
417 0xffff, /* src_mask */
418 0xffff, /* dst_mask */
419 FALSE), /* pcrel_offset */
420 /* A 6 bit absolute relocation of 6 bit offset.
421 For ldd/sdd command. */
422 HOWTO (R_AVR_6, /* type */
423 0, /* rightshift */
424 0, /* size (0 = byte, 1 = short, 2 = long) */
425 6, /* bitsize */
426 FALSE, /* pc_relative */
427 0, /* bitpos */
428 complain_overflow_dont,/* complain_on_overflow */
429 bfd_elf_generic_reloc, /* special_function */
430 "R_AVR_6", /* name */
431 FALSE, /* partial_inplace */
432 0xffff, /* src_mask */
433 0xffff, /* dst_mask */
434 FALSE), /* pcrel_offset */
435 /* A 6 bit absolute relocation of 6 bit offset.
436 For sbiw/adiw command. */
437 HOWTO (R_AVR_6_ADIW, /* type */
438 0, /* rightshift */
439 0, /* size (0 = byte, 1 = short, 2 = long) */
440 6, /* bitsize */
441 FALSE, /* pc_relative */
442 0, /* bitpos */
443 complain_overflow_dont,/* complain_on_overflow */
444 bfd_elf_generic_reloc, /* special_function */
445 "R_AVR_6_ADIW", /* name */
446 FALSE, /* partial_inplace */
447 0xffff, /* src_mask */
448 0xffff, /* dst_mask */
df406460
NC		 449 FALSE), /* pcrel_offset */
450 /* Most significant 8 bit value of a 32 bit link-time constant. */
451 HOWTO (R_AVR_MS8_LDI, /* type */
452 24, /* rightshift */
453 1, /* size (0 = byte, 1 = short, 2 = long) */
454 8, /* bitsize */
455 FALSE, /* pc_relative */
456 0, /* bitpos */
457 complain_overflow_dont, /* complain_on_overflow */
458 bfd_elf_generic_reloc, /* special_function */
459 "R_AVR_MS8_LDI", /* name */
460 FALSE, /* partial_inplace */
461 0xffff, /* src_mask */
462 0xffff, /* dst_mask */
463 FALSE), /* pcrel_offset */
464 /* Negative most significant 8 bit value of a 32 bit link-time constant. */
465 HOWTO (R_AVR_MS8_LDI_NEG, /* type */
466 24, /* rightshift */
467 1, /* size (0 = byte, 1 = short, 2 = long) */
468 8, /* bitsize */
469 FALSE, /* pc_relative */
470 0, /* bitpos */
471 complain_overflow_dont, /* complain_on_overflow */
472 bfd_elf_generic_reloc, /* special_function */
473 "R_AVR_MS8_LDI_NEG", /* name */
474 FALSE, /* partial_inplace */
475 0xffff, /* src_mask */
476 0xffff, /* dst_mask */
07d6d2b8 477 FALSE), /* pcrel_offset */
28c9d252 478 /* A low 8 bit absolute relocation of 24 bit program memory address.
17e57237 479 For LDI command. Will be changed when linker stubs are needed. */
07d6d2b8
AM		 480 HOWTO (R_AVR_LO8_LDI_GS, /* type */
481 1, /* rightshift */
482 1, /* size (0 = byte, 1 = short, 2 = long) */
483 8, /* bitsize */
484 FALSE, /* pc_relative */
485 0, /* bitpos */
486 complain_overflow_dont, /* complain_on_overflow */
487 bfd_elf_generic_reloc, /* special_function */
488 "R_AVR_LO8_LDI_GS", /* name */
489 FALSE, /* partial_inplace */
490 0xffff, /* src_mask */
491 0xffff, /* dst_mask */
492 FALSE), /* pcrel_offset */
28c9d252 493 /* A low 8 bit absolute relocation of 24 bit program memory address.
17e57237 494 For LDI command. Will be changed when linker stubs are needed. */
07d6d2b8
AM		 495 HOWTO (R_AVR_HI8_LDI_GS, /* type */
496 9, /* rightshift */
497 1, /* size (0 = byte, 1 = short, 2 = long) */
498 8, /* bitsize */
499 FALSE, /* pc_relative */
500 0, /* bitpos */
501 complain_overflow_dont, /* complain_on_overflow */
502 bfd_elf_generic_reloc, /* special_function */
503 "R_AVR_HI8_LDI_GS", /* name */
504 FALSE, /* partial_inplace */
505 0xffff, /* src_mask */
506 0xffff, /* dst_mask */
507 FALSE), /* pcrel_offset */
17e57237
NC		 508 /* 8 bit offset. */
509 HOWTO (R_AVR_8, /* type */
510 0, /* rightshift */
511 0, /* size (0 = byte, 1 = short, 2 = long) */
512 8, /* bitsize */
513 FALSE, /* pc_relative */
514 0, /* bitpos */
515 complain_overflow_bitfield,/* complain_on_overflow */
516 bfd_elf_generic_reloc, /* special_function */
517 "R_AVR_8", /* name */
518 FALSE, /* partial_inplace */
519 0x000000ff, /* src_mask */
520 0x000000ff, /* dst_mask */
521 FALSE), /* pcrel_offset */
99700d6f
NC		 522 /* lo8-part to use in .byte lo8(sym). */
523 HOWTO (R_AVR_8_LO8, /* type */
524 0, /* rightshift */
525 0, /* size (0 = byte, 1 = short, 2 = long) */
526 8, /* bitsize */
527 FALSE, /* pc_relative */
528 0, /* bitpos */
529 complain_overflow_dont,/* complain_on_overflow */
530 bfd_elf_generic_reloc, /* special_function */
531 "R_AVR_8_LO8", /* name */
532 FALSE, /* partial_inplace */
533 0xffffff, /* src_mask */
534 0xffffff, /* dst_mask */
535 FALSE), /* pcrel_offset */
536 /* hi8-part to use in .byte hi8(sym). */
537 HOWTO (R_AVR_8_HI8, /* type */
538 8, /* rightshift */
539 0, /* size (0 = byte, 1 = short, 2 = long) */
540 8, /* bitsize */
541 FALSE, /* pc_relative */
542 0, /* bitpos */
543 complain_overflow_dont,/* complain_on_overflow */
544 bfd_elf_generic_reloc, /* special_function */
545 "R_AVR_8_HI8", /* name */
546 FALSE, /* partial_inplace */
547 0xffffff, /* src_mask */
548 0xffffff, /* dst_mask */
549 FALSE), /* pcrel_offset */
40551fb8
NC		 550 /* hlo8-part to use in .byte hlo8(sym). */
551 HOWTO (R_AVR_8_HLO8, /* type */
99700d6f
NC		 552 16, /* rightshift */
553 0, /* size (0 = byte, 1 = short, 2 = long) */
554 8, /* bitsize */
555 FALSE, /* pc_relative */
556 0, /* bitpos */
557 complain_overflow_dont,/* complain_on_overflow */
558 bfd_elf_generic_reloc, /* special_function */
40551fb8 559 "R_AVR_8_HLO8", /* name */
99700d6f
NC		 560 FALSE, /* partial_inplace */
561 0xffffff, /* src_mask */
562 0xffffff, /* dst_mask */
563 FALSE), /* pcrel_offset */
f36e8886 564 HOWTO (R_AVR_DIFF8, /* type */
07d6d2b8
AM		 565 0, /* rightshift */
566 0, /* size (0 = byte, 1 = short, 2 = long) */
567 8, /* bitsize */
568 FALSE, /* pc_relative */
569 0, /* bitpos */
f36e8886
BS		 570 complain_overflow_bitfield, /* complain_on_overflow */
571 bfd_elf_avr_diff_reloc, /* special_function */
07d6d2b8
AM		 572 "R_AVR_DIFF8", /* name */
573 FALSE, /* partial_inplace */
574 0, /* src_mask */
575 0xff, /* dst_mask */
576 FALSE), /* pcrel_offset */
577 HOWTO (R_AVR_DIFF16, /* type */
578 0, /* rightshift */
f36e8886
BS		 579 1, /* size (0 = byte, 1 = short, 2 = long) */
580 16, /* bitsize */
07d6d2b8
AM		 581 FALSE, /* pc_relative */
582 0, /* bitpos */
f36e8886
BS		 583 complain_overflow_bitfield, /* complain_on_overflow */
584 bfd_elf_avr_diff_reloc,/* special_function */
07d6d2b8
AM		 585 "R_AVR_DIFF16", /* name */
586 FALSE, /* partial_inplace */
587 0, /* src_mask */
588 0xffff, /* dst_mask */
589 FALSE), /* pcrel_offset */
590 HOWTO (R_AVR_DIFF32, /* type */
591 0, /* rightshift */
592 2, /* size (0 = byte, 1 = short, 2 = long) */
593 32, /* bitsize */
594 FALSE, /* pc_relative */
595 0, /* bitpos */
f36e8886
BS		 596 complain_overflow_bitfield, /* complain_on_overflow */
597 bfd_elf_avr_diff_reloc,/* special_function */
07d6d2b8
AM		 598 "R_AVR_DIFF32", /* name */
599 FALSE, /* partial_inplace */
600 0, /* src_mask */
601 0xffffffff, /* dst_mask */
602 FALSE), /* pcrel_offset */
f36e8886
BS		 603 /* 7 bit immediate for LDS/STS in Tiny core. */
604 HOWTO (R_AVR_LDS_STS_16, /* type */
07d6d2b8
AM		 605 0, /* rightshift */
606 1, /* size (0 = byte, 1 = short, 2 = long) */
607 7, /* bitsize */
608 FALSE, /* pc_relative */
609 0, /* bitpos */
f36e8886
BS		 610 complain_overflow_dont,/* complain_on_overflow */
611 bfd_elf_generic_reloc, /* special_function */
07d6d2b8
AM		 612 "R_AVR_LDS_STS_16", /* name */
613 FALSE, /* partial_inplace */
614 0xffff, /* src_mask */
615 0xffff, /* dst_mask */
75f58085
BS		 616 FALSE), /* pcrel_offset */
617
618 HOWTO (R_AVR_PORT6, /* type */
619 0, /* rightshift */
620 0, /* size (0 = byte, 1 = short, 2 = long) */
621 6, /* bitsize */
622 FALSE, /* pc_relative */
623 0, /* bitpos */
624 complain_overflow_dont,/* complain_on_overflow */
625 bfd_elf_generic_reloc, /* special_function */
626 "R_AVR_PORT6", /* name */
627 FALSE, /* partial_inplace */
628 0xffffff, /* src_mask */
629 0xffffff, /* dst_mask */
630 FALSE), /* pcrel_offset */
631 HOWTO (R_AVR_PORT5, /* type */
632 0, /* rightshift */
633 0, /* size (0 = byte, 1 = short, 2 = long) */
634 5, /* bitsize */
635 FALSE, /* pc_relative */
636 0, /* bitpos */
637 complain_overflow_dont,/* complain_on_overflow */
638 bfd_elf_generic_reloc, /* special_function */
639 "R_AVR_PORT5", /* name */
640 FALSE, /* partial_inplace */
641 0xffffff, /* src_mask */
642 0xffffff, /* dst_mask */
07d6d2b8 643 FALSE), /* pcrel_offset */
328e7bfd
DC		 644
645 /* A 32 bit PC relative relocation. */
646 HOWTO (R_AVR_32_PCREL, /* type */
07d6d2b8
AM		 647 0, /* rightshift */
648 2, /* size (0 = byte, 1 = short, 2 = long) */
328e7bfd
DC		 649 32, /* bitsize */
650 TRUE, /* pc_relative */
07d6d2b8 651 0, /* bitpos */
328e7bfd
DC		 652 complain_overflow_bitfield, /* complain_on_overflow */
653 bfd_elf_generic_reloc, /* special_function */
654 "R_AVR_32_PCREL", /* name */
655 FALSE, /* partial_inplace */
07d6d2b8
AM		 656 0xffffffff, /* src_mask */
657 0xffffffff, /* dst_mask */
328e7bfd 658 TRUE), /* pcrel_offset */
adde6300
AM		 659};
660
661/* Map BFD reloc types to AVR ELF reloc types. */
662
663struct avr_reloc_map
664{
665 bfd_reloc_code_real_type bfd_reloc_val;
666 unsigned int elf_reloc_val;
667};
668
28c9d252 669static const struct avr_reloc_map avr_reloc_map[] =
adde6300 670{
07d6d2b8
AM		 671 { BFD_RELOC_NONE, R_AVR_NONE },
672 { BFD_RELOC_32, R_AVR_32 },
673 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
674 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
675 { BFD_RELOC_16, R_AVR_16 },
676 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
677 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
678 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
679 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
680 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI },
681 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
682 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
683 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
684 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG },
685 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
686 { BFD_RELOC_AVR_LO8_LDI_GS, R_AVR_LO8_LDI_GS },
687 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
688 { BFD_RELOC_AVR_HI8_LDI_GS, R_AVR_HI8_LDI_GS },
689 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
adde6300
AM		 690 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
691 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
692 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
07d6d2b8
AM		 693 { BFD_RELOC_AVR_CALL, R_AVR_CALL },
694 { BFD_RELOC_AVR_LDI, R_AVR_LDI },
695 { BFD_RELOC_AVR_6, R_AVR_6 },
696 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW },
697 { BFD_RELOC_8, R_AVR_8 },
698 { BFD_RELOC_AVR_8_LO, R_AVR_8_LO8 },
699 { BFD_RELOC_AVR_8_HI, R_AVR_8_HI8 },
700 { BFD_RELOC_AVR_8_HLO, R_AVR_8_HLO8 },
701 { BFD_RELOC_AVR_DIFF8, R_AVR_DIFF8 },
702 { BFD_RELOC_AVR_DIFF16, R_AVR_DIFF16 },
703 { BFD_RELOC_AVR_DIFF32, R_AVR_DIFF32 },
704 { BFD_RELOC_AVR_LDS_STS_16, R_AVR_LDS_STS_16},
705 { BFD_RELOC_AVR_PORT6, R_AVR_PORT6},
706 { BFD_RELOC_AVR_PORT5, R_AVR_PORT5},
707 { BFD_RELOC_32_PCREL, R_AVR_32_PCREL}
adde6300
AM		 708};
709
deee88e9
AM		 710static const struct bfd_elf_special_section elf_avr_special_sections[] =
711{
712 { STRING_COMMA_LEN (".noinit"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
713 { NULL, 0, 0, 0, 0 }
714};
715
df406460 716/* Meant to be filled one day with the wrap around address for the
4cdc7696 717 specific device. I.e. should get the value 0x4000 for 16k devices,
df406460 718 0x8000 for 32k devices and so on.
4cdc7696 719
df406460 720 We initialize it here with a value of 0x1000000 resulting in
4cdc7696
NC		 721 that we will never suggest a wrap-around jump during relaxation.
722 The logic of the source code later on assumes that in
df406460 723 avr_pc_wrap_around one single bit is set. */
28c9d252
NC		 724static bfd_vma avr_pc_wrap_around = 0x10000000;
725
726/* If this variable holds a value different from zero, the linker relaxation
727 machine will try to optimize call/ret sequences by a single jump
728 instruction. This option could be switched off by a linker switch. */
729static int avr_replace_call_ret_sequences = 1;
730\f
bac13f5a
AB		 731
732/* Per-section relaxation related information for avr. */
733
734struct avr_relax_info
735{
736 /* Track the avr property records that apply to this section. */
737
738 struct
739 {
740 /* Number of records in the list. */
741 unsigned count;
742
743 /* How many records worth of space have we allocated. */
744 unsigned allocated;
745
746 /* The records, only COUNT records are initialised. */
747 struct avr_property_record *items;
748 } records;
749};
750
751/* Per section data, specialised for avr. */
752
753struct elf_avr_section_data
754{
755 /* The standard data must appear first. */
756 struct bfd_elf_section_data elf;
757
758 /* Relaxation related information. */
759 struct avr_relax_info relax_info;
760};
761
762/* Possibly initialise avr specific data for new section SEC from ABFD. */
763
764static bfd_boolean
765elf_avr_new_section_hook (bfd *abfd, asection *sec)
766{
767 if (!sec->used_by_bfd)
768 {
769 struct elf_avr_section_data *sdata;
770 bfd_size_type amt = sizeof (*sdata);
771
772 sdata = bfd_zalloc (abfd, amt);
773 if (sdata == NULL)
774 return FALSE;
775 sec->used_by_bfd = sdata;
776 }
777
778 return _bfd_elf_new_section_hook (abfd, sec);
779}
780
781/* Return a pointer to the relaxation information for SEC. */
782
783static struct avr_relax_info *
784get_avr_relax_info (asection *sec)
785{
786 struct elf_avr_section_data *section_data;
787
788 /* No info available if no section or if it is an output section. */
789 if (!sec || sec == sec->output_section)
790 return NULL;
791
792 section_data = (struct elf_avr_section_data *) elf_section_data (sec);
793 return &section_data->relax_info;
794}
795
796/* Initialise the per section relaxation information for SEC. */
797
798static void
799init_avr_relax_info (asection *sec)
800{
801 struct avr_relax_info *relax_info = get_avr_relax_info (sec);
802
803 relax_info->records.count = 0;
804 relax_info->records.allocated = 0;
805 relax_info->records.items = NULL;
806}
807
28c9d252
NC		 808/* Initialize an entry in the stub hash table. */
809
810static struct bfd_hash_entry *
811stub_hash_newfunc (struct bfd_hash_entry *entry,
07d6d2b8
AM		 812 struct bfd_hash_table *table,
813 const char *string)
28c9d252
NC		 814{
815 /* Allocate the structure if it has not already been allocated by a
816 subclass. */
817 if (entry == NULL)
818 {
819 entry = bfd_hash_allocate (table,
07d6d2b8 820 sizeof (struct elf32_avr_stub_hash_entry));
28c9d252 821 if (entry == NULL)
07d6d2b8 822 return entry;
28c9d252
NC		 823 }
824
825 /* Call the allocation method of the superclass. */
826 entry = bfd_hash_newfunc (entry, table, string);
827 if (entry != NULL)
828 {
829 struct elf32_avr_stub_hash_entry *hsh;
830
831 /* Initialize the local fields. */
832 hsh = avr_stub_hash_entry (entry);
833 hsh->stub_offset = 0;
834 hsh->target_value = 0;
835 }
836
837 return entry;
838}
839
64ee10b6
NC		 840/* This function is just a straight passthrough to the real
841 function in linker.c. Its prupose is so that its address
842 can be compared inside the avr_link_hash_table macro. */
843
844static struct bfd_hash_entry *
845elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
846 struct bfd_hash_table * table,
847 const char * string)
848{
849 return _bfd_elf_link_hash_newfunc (entry, table, string);
850}
851
68faa637
AM		 852/* Free the derived linker hash table. */
853
854static void
d495ab0d 855elf32_avr_link_hash_table_free (bfd *obfd)
68faa637
AM		 856{
857 struct elf32_avr_link_hash_table *htab
d495ab0d 858 = (struct elf32_avr_link_hash_table *) obfd->link.hash;
68faa637
AM		 859
860 /* Free the address mapping table. */
861 if (htab->amt_stub_offsets != NULL)
862 free (htab->amt_stub_offsets);
863 if (htab->amt_destination_addr != NULL)
864 free (htab->amt_destination_addr);
865
866 bfd_hash_table_free (&htab->bstab);
d495ab0d 867 _bfd_elf_link_hash_table_free (obfd);
68faa637
AM		 868}
869
28c9d252
NC		 870/* Create the derived linker hash table. The AVR ELF port uses the derived
871 hash table to keep information specific to the AVR ELF linker (without
872 using static variables). */
873
874static struct bfd_link_hash_table *
875elf32_avr_link_hash_table_create (bfd *abfd)
876{
877 struct elf32_avr_link_hash_table *htab;
878 bfd_size_type amt = sizeof (*htab);
879
7bf52ea2 880 htab = bfd_zmalloc (amt);
28c9d252
NC		 881 if (htab == NULL)
882 return NULL;
883
884 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
07d6d2b8
AM		 885 elf32_avr_link_hash_newfunc,
886 sizeof (struct elf_link_hash_entry),
4dfe6ac6 887 AVR_ELF_DATA))
28c9d252
NC		 888 {
889 free (htab);
890 return NULL;
891 }
892
893 /* Init the stub hash table too. */
894 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
07d6d2b8 895 sizeof (struct elf32_avr_stub_hash_entry)))
d495ab0d
AM		 896 {
897 _bfd_elf_link_hash_table_free (abfd);
898 return NULL;
899 }
900 htab->etab.root.hash_table_free = elf32_avr_link_hash_table_free;
4cdc7696 901
28c9d252
NC		 902 return &htab->etab.root;
903}
904
df406460 905/* Calculates the effective distance of a pc relative jump/call. */
73160847 906
df406460
NC		 907static int
908avr_relative_distance_considering_wrap_around (unsigned int distance)
4cdc7696 909{
df406460 910 unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
df406460
NC		 911 int dist_with_wrap_around = distance & wrap_around_mask;
912
4cdc7696 913 if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
df406460
NC		 914 dist_with_wrap_around -= avr_pc_wrap_around;
915
916 return dist_with_wrap_around;
917}
918
919
adde6300 920static reloc_howto_type *
4cdc7696
NC		 921bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
922 bfd_reloc_code_real_type code)
adde6300
AM		 923{
924 unsigned int i;
925
926 for (i = 0;
927 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
928 i++)
73160847
NC		 929 if (avr_reloc_map[i].bfd_reloc_val == code)
930 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
adde6300
AM		 931
932 return NULL;
933}
934
157090f7
AM		 935static reloc_howto_type *
936bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
937 const char *r_name)
938{
939 unsigned int i;
940
941 for (i = 0;
942 i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
943 i++)
944 if (elf_avr_howto_table[i].name != NULL
945 && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
946 return &elf_avr_howto_table[i];
947
948 return NULL;
949}
950
adde6300
AM		 951/* Set the howto pointer for an AVR ELF reloc. */
952
f3185997 953static bfd_boolean
0aa13fee 954avr_info_to_howto_rela (bfd *abfd,
4cdc7696
NC		 955 arelent *cache_ptr,
956 Elf_Internal_Rela *dst)
adde6300
AM		 957{
958 unsigned int r_type;
959
960 r_type = ELF32_R_TYPE (dst->r_info);
5860e3f8
NC		 961 if (r_type >= (unsigned int) R_AVR_max)
962 {
695344c0 963 /* xgettext:c-format */
0aa13fee
AM		 964 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
965 abfd, r_type);
f3185997
NC		 966 bfd_set_error (bfd_error_bad_value);
967 return FALSE;
5860e3f8 968 }
adde6300 969 cache_ptr->howto = &elf_avr_howto_table[r_type];
f3185997 970 return TRUE;
adde6300
AM		 971}
972
28c9d252
NC		 973static bfd_boolean
974avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
975{
976 return (relocation >= 0x020000);
977}
978
979/* Returns the address of the corresponding stub if there is one.
980 Returns otherwise an address above 0x020000. This function
981 could also be used, if there is no knowledge on the section where
982 the destination is found. */
983
984static bfd_vma
985avr_get_stub_addr (bfd_vma srel,
07d6d2b8 986 struct elf32_avr_link_hash_table *htab)
28c9d252 987{
91d6fa6a 988 unsigned int sindex;
28c9d252 989 bfd_vma stub_sec_addr =
07d6d2b8 990 (htab->stub_sec->output_section->vma +
28c9d252
NC		 991 htab->stub_sec->output_offset);
992
91d6fa6a
NC		 993 for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
994 if (htab->amt_destination_addr[sindex] == srel)
995 return htab->amt_stub_offsets[sindex] + stub_sec_addr;
28c9d252
NC		 996
997 /* Return an address that could not be reached by 16 bit relocs. */
998 return 0x020000;
999}
1000
e4ef1b6c
DC		 1001/* Perform a diff relocation. Nothing to do, as the difference value is already
1002 written into the section's contents. */
1003
1004static bfd_reloc_status_type
1005bfd_elf_avr_diff_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1006 arelent *reloc_entry ATTRIBUTE_UNUSED,
07d6d2b8
AM		 1007 asymbol *symbol ATTRIBUTE_UNUSED,
1008 void *data ATTRIBUTE_UNUSED,
1009 asection *input_section ATTRIBUTE_UNUSED,
1010 bfd *output_bfd ATTRIBUTE_UNUSED,
1011 char **error_message ATTRIBUTE_UNUSED)
e4ef1b6c
DC		 1012{
1013 return bfd_reloc_ok;
1014}
1015
1016
adde6300
AM		 1017/* Perform a single relocation. By default we use the standard BFD
1018 routines, but a few relocs, we have to do them ourselves. */
1019
1020static bfd_reloc_status_type
07d6d2b8
AM		 1021avr_final_link_relocate (reloc_howto_type * howto,
1022 bfd * input_bfd,
1023 asection * input_section,
1024 bfd_byte * contents,
1025 Elf_Internal_Rela * rel,
1026 bfd_vma relocation,
1027 struct elf32_avr_link_hash_table * htab)
adde6300
AM		 1028{
1029 bfd_reloc_status_type r = bfd_reloc_ok;
07d6d2b8 1030 bfd_vma x;
adde6300 1031 bfd_signed_vma srel;
28c9d252 1032 bfd_signed_vma reloc_addr;
07d6d2b8 1033 bfd_boolean use_stubs = FALSE;
28c9d252 1034 /* Usually is 0, unless we are generating code for a bootloader. */
07d6d2b8 1035 bfd_signed_vma base_addr = htab->vector_base;
28c9d252
NC		 1036
1037 /* Absolute addr of the reloc in the final excecutable. */
1038 reloc_addr = rel->r_offset + input_section->output_section->vma
1039 + input_section->output_offset;
adde6300
AM		 1040
1041 switch (howto->type)
1042 {
1043 case R_AVR_7_PCREL:
1044 contents += rel->r_offset;
1045 srel = (bfd_signed_vma) relocation;
1046 srel += rel->r_addend;
1047 srel -= rel->r_offset;
a7c10850 1048 srel -= 2; /* Branch instructions add 2 to the PC... */
adde6300
AM		 1049 srel -= (input_section->output_section->vma +
1050 input_section->output_offset);
1051
1052 if (srel & 1)
1053 return bfd_reloc_outofrange;
1054 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
1055 return bfd_reloc_overflow;
1056 x = bfd_get_16 (input_bfd, contents);
1057 x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
1058 bfd_put_16 (input_bfd, x, contents);
1059 break;
1060
1061 case R_AVR_13_PCREL:
1062 contents += rel->r_offset;
1063 srel = (bfd_signed_vma) relocation;
1064 srel += rel->r_addend;
1065 srel -= rel->r_offset;
a7c10850 1066 srel -= 2; /* Branch instructions add 2 to the PC... */
adde6300
AM		 1067 srel -= (input_section->output_section->vma +
1068 input_section->output_offset);
1069
1070 if (srel & 1)
1071 return bfd_reloc_outofrange;
1072
df406460
NC		 1073 srel = avr_relative_distance_considering_wrap_around (srel);
1074
adde6300
AM		 1075 /* AVR addresses commands as words. */
1076 srel >>= 1;
1077
1078 /* Check for overflow. */
1079 if (srel < -2048 || srel > 2047)
1080 {
07d6d2b8 1081 /* Relative distance is too large. */
df406460 1082
654c3c9f 1083 /* Always apply WRAPAROUND for avr2, avr25, and avr4. */
65aa24b6 1084 switch (bfd_get_mach (input_bfd))
adde6300 1085 {
65aa24b6 1086 case bfd_mach_avr2:
654c3c9f 1087 case bfd_mach_avr25:
65aa24b6
NC		 1088 case bfd_mach_avr4:
1089 break;
1090
1091 default:
1092 return bfd_reloc_overflow;
adde6300 1093 }
adde6300
AM		 1094 }
1095
1096 x = bfd_get_16 (input_bfd, contents);
1097 x = (x & 0xf000) | (srel & 0xfff);
1098 bfd_put_16 (input_bfd, x, contents);
1099 break;
1100
1101 case R_AVR_LO8_LDI:
1102 contents += rel->r_offset;
1103 srel = (bfd_signed_vma) relocation + rel->r_addend;
1104 x = bfd_get_16 (input_bfd, contents);
1105 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1106 bfd_put_16 (input_bfd, x, contents);
1107 break;
1108
750bce0e
NC		 1109 case R_AVR_LDI:
1110 contents += rel->r_offset;
1111 srel = (bfd_signed_vma) relocation + rel->r_addend;
4cdc7696
NC		 1112 if (((srel > 0) && (srel & 0xffff) > 255)
1113 || ((srel < 0) && ((-srel) & 0xffff) > 128))
07d6d2b8
AM		 1114 /* Remove offset for data/eeprom section. */
1115 return bfd_reloc_overflow;
df406460 1116
750bce0e
NC		 1117 x = bfd_get_16 (input_bfd, contents);
1118 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1119 bfd_put_16 (input_bfd, x, contents);
1120 break;
1121
1122 case R_AVR_6:
1123 contents += rel->r_offset;
1124 srel = (bfd_signed_vma) relocation + rel->r_addend;
1125 if (((srel & 0xffff) > 63) || (srel < 0))
1126 /* Remove offset for data/eeprom section. */
1127 return bfd_reloc_overflow;
1128 x = bfd_get_16 (input_bfd, contents);
4cdc7696 1129 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
07d6d2b8 1130 | ((srel & (1 << 5)) << 8));
750bce0e
NC		 1131 bfd_put_16 (input_bfd, x, contents);
1132 break;
1133
1134 case R_AVR_6_ADIW:
1135 contents += rel->r_offset;
1136 srel = (bfd_signed_vma) relocation + rel->r_addend;
1137 if (((srel & 0xffff) > 63) || (srel < 0))
1138 /* Remove offset for data/eeprom section. */
1139 return bfd_reloc_overflow;
1140 x = bfd_get_16 (input_bfd, contents);
4cdc7696 1141 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
750bce0e
NC		 1142 bfd_put_16 (input_bfd, x, contents);
1143 break;
1144
adde6300
AM		 1145 case R_AVR_HI8_LDI:
1146 contents += rel->r_offset;
1147 srel = (bfd_signed_vma) relocation + rel->r_addend;
1148 srel = (srel >> 8) & 0xff;
1149 x = bfd_get_16 (input_bfd, contents);
1150 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1151 bfd_put_16 (input_bfd, x, contents);
1152 break;
1153
1154 case R_AVR_HH8_LDI:
1155 contents += rel->r_offset;
1156 srel = (bfd_signed_vma) relocation + rel->r_addend;
1157 srel = (srel >> 16) & 0xff;
1158 x = bfd_get_16 (input_bfd, contents);
1159 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1160 bfd_put_16 (input_bfd, x, contents);
1161 break;
1162
df406460
NC		 1163 case R_AVR_MS8_LDI:
1164 contents += rel->r_offset;
1165 srel = (bfd_signed_vma) relocation + rel->r_addend;
1166 srel = (srel >> 24) & 0xff;
1167 x = bfd_get_16 (input_bfd, contents);
1168 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1169 bfd_put_16 (input_bfd, x, contents);
1170 break;
1171
adde6300
AM		 1172 case R_AVR_LO8_LDI_NEG:
1173 contents += rel->r_offset;
1174 srel = (bfd_signed_vma) relocation + rel->r_addend;
1175 srel = -srel;
1176 x = bfd_get_16 (input_bfd, contents);
1177 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1178 bfd_put_16 (input_bfd, x, contents);
1179 break;
1180
1181 case R_AVR_HI8_LDI_NEG:
1182 contents += rel->r_offset;
1183 srel = (bfd_signed_vma) relocation + rel->r_addend;
1184 srel = -srel;
1185 srel = (srel >> 8) & 0xff;
1186 x = bfd_get_16 (input_bfd, contents);
1187 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1188 bfd_put_16 (input_bfd, x, contents);
1189 break;
1190
1191 case R_AVR_HH8_LDI_NEG:
1192 contents += rel->r_offset;
1193 srel = (bfd_signed_vma) relocation + rel->r_addend;
1194 srel = -srel;
1195 srel = (srel >> 16) & 0xff;
1196 x = bfd_get_16 (input_bfd, contents);
1197 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1198 bfd_put_16 (input_bfd, x, contents);
1199 break;
1200
df406460
NC		 1201 case R_AVR_MS8_LDI_NEG:
1202 contents += rel->r_offset;
1203 srel = (bfd_signed_vma) relocation + rel->r_addend;
1204 srel = -srel;
1205 srel = (srel >> 24) & 0xff;
1206 x = bfd_get_16 (input_bfd, contents);
1207 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1208 bfd_put_16 (input_bfd, x, contents);
1209 break;
1210
28c9d252
NC		 1211 case R_AVR_LO8_LDI_GS:
1212 use_stubs = (!htab->no_stubs);
1213 /* Fall through. */
adde6300
AM		 1214 case R_AVR_LO8_LDI_PM:
1215 contents += rel->r_offset;
1216 srel = (bfd_signed_vma) relocation + rel->r_addend;
28c9d252
NC		 1217
1218 if (use_stubs
07d6d2b8
AM		 1219 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1220 {
1221 bfd_vma old_srel = srel;
1222
1223 /* We need to use the address of the stub instead. */
1224 srel = avr_get_stub_addr (srel, htab);
1225 if (debug_stubs)
1226 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1227 "reloc at address 0x%x.\n",
1228 (unsigned int) srel,
1229 (unsigned int) old_srel,
1230 (unsigned int) reloc_addr);
28c9d252
NC		 1231
1232 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1233 return bfd_reloc_outofrange;
07d6d2b8 1234 }
28c9d252 1235
adde6300
AM		 1236 if (srel & 1)
1237 return bfd_reloc_outofrange;
1238 srel = srel >> 1;
1239 x = bfd_get_16 (input_bfd, contents);
1240 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1241 bfd_put_16 (input_bfd, x, contents);
1242 break;
1243
28c9d252
NC		 1244 case R_AVR_HI8_LDI_GS:
1245 use_stubs = (!htab->no_stubs);
1246 /* Fall through. */
adde6300
AM		 1247 case R_AVR_HI8_LDI_PM:
1248 contents += rel->r_offset;
1249 srel = (bfd_signed_vma) relocation + rel->r_addend;
28c9d252
NC		 1250
1251 if (use_stubs
07d6d2b8
AM		 1252 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1253 {
1254 bfd_vma old_srel = srel;
1255
1256 /* We need to use the address of the stub instead. */
1257 srel = avr_get_stub_addr (srel, htab);
1258 if (debug_stubs)
1259 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1260 "reloc at address 0x%x.\n",
1261 (unsigned int) srel,
1262 (unsigned int) old_srel,
1263 (unsigned int) reloc_addr);
28c9d252
NC		 1264
1265 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1266 return bfd_reloc_outofrange;
07d6d2b8 1267 }
28c9d252 1268
adde6300
AM		 1269 if (srel & 1)
1270 return bfd_reloc_outofrange;
1271 srel = srel >> 1;
1272 srel = (srel >> 8) & 0xff;
1273 x = bfd_get_16 (input_bfd, contents);
1274 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1275 bfd_put_16 (input_bfd, x, contents);
1276 break;
1277
1278 case R_AVR_HH8_LDI_PM:
1279 contents += rel->r_offset;
1280 srel = (bfd_signed_vma) relocation + rel->r_addend;
1281 if (srel & 1)
1282 return bfd_reloc_outofrange;
1283 srel = srel >> 1;
1284 srel = (srel >> 16) & 0xff;
1285 x = bfd_get_16 (input_bfd, contents);
1286 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1287 bfd_put_16 (input_bfd, x, contents);
1288 break;
1289
1290 case R_AVR_LO8_LDI_PM_NEG:
1291 contents += rel->r_offset;
1292 srel = (bfd_signed_vma) relocation + rel->r_addend;
1293 srel = -srel;
1294 if (srel & 1)
1295 return bfd_reloc_outofrange;
1296 srel = srel >> 1;
1297 x = bfd_get_16 (input_bfd, contents);
1298 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1299 bfd_put_16 (input_bfd, x, contents);
1300 break;
1301
1302 case R_AVR_HI8_LDI_PM_NEG:
1303 contents += rel->r_offset;
1304 srel = (bfd_signed_vma) relocation + rel->r_addend;
1305 srel = -srel;
1306 if (srel & 1)
1307 return bfd_reloc_outofrange;
1308 srel = srel >> 1;
1309 srel = (srel >> 8) & 0xff;
1310 x = bfd_get_16 (input_bfd, contents);
1311 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1312 bfd_put_16 (input_bfd, x, contents);
1313 break;
1314
1315 case R_AVR_HH8_LDI_PM_NEG:
1316 contents += rel->r_offset;
1317 srel = (bfd_signed_vma) relocation + rel->r_addend;
1318 srel = -srel;
1319 if (srel & 1)
1320 return bfd_reloc_outofrange;
1321 srel = srel >> 1;
1322 srel = (srel >> 16) & 0xff;
1323 x = bfd_get_16 (input_bfd, contents);
1324 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1325 bfd_put_16 (input_bfd, x, contents);
1326 break;
1327
1328 case R_AVR_CALL:
1329 contents += rel->r_offset;
1330 srel = (bfd_signed_vma) relocation + rel->r_addend;
1331 if (srel & 1)
1332 return bfd_reloc_outofrange;
1333 srel = srel >> 1;
1334 x = bfd_get_16 (input_bfd, contents);
1335 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1336 bfd_put_16 (input_bfd, x, contents);
dc810e39 1337 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
adde6300
AM		 1338 break;
1339
28c9d252
NC		 1340 case R_AVR_16_PM:
1341 use_stubs = (!htab->no_stubs);
1342 contents += rel->r_offset;
1343 srel = (bfd_signed_vma) relocation + rel->r_addend;
1344
1345 if (use_stubs
07d6d2b8
AM		 1346 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1347 {
1348 bfd_vma old_srel = srel;
1349
1350 /* We need to use the address of the stub instead. */
1351 srel = avr_get_stub_addr (srel,htab);
1352 if (debug_stubs)
1353 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1354 "reloc at address 0x%x.\n",
1355 (unsigned int) srel,
1356 (unsigned int) old_srel,
1357 (unsigned int) reloc_addr);
28c9d252
NC		 1358
1359 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1360 return bfd_reloc_outofrange;
07d6d2b8 1361 }
28c9d252
NC		 1362
1363 if (srel & 1)
1364 return bfd_reloc_outofrange;
1365 srel = srel >> 1;
1366 bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1367 break;
1368
e4ef1b6c
DC		 1369 case R_AVR_DIFF8:
1370 case R_AVR_DIFF16:
1371 case R_AVR_DIFF32:
1372 /* Nothing to do here, as contents already contains the diff value. */
1373 r = bfd_reloc_ok;
1374 break;
1375
f36e8886
BS		 1376 case R_AVR_LDS_STS_16:
1377 contents += rel->r_offset;
1378 srel = (bfd_signed_vma) relocation + rel->r_addend;
1379 if ((srel & 0xFFFF) < 0x40 || (srel & 0xFFFF) > 0xbf)
07d6d2b8 1380 return bfd_reloc_outofrange;
f36e8886
BS		 1381 srel = srel & 0x7f;
1382 x = bfd_get_16 (input_bfd, contents);
1383 x |= (srel & 0x0f) | ((srel & 0x30) << 5) | ((srel & 0x40) << 2);
1384 bfd_put_16 (input_bfd, x, contents);
1385 break;
1386
75f58085
BS		 1387 case R_AVR_PORT6:
1388 contents += rel->r_offset;
1389 srel = (bfd_signed_vma) relocation + rel->r_addend;
1390 if ((srel & 0xffff) > 0x3f)
07d6d2b8 1391 return bfd_reloc_outofrange;
75f58085
BS		 1392 x = bfd_get_16 (input_bfd, contents);
1393 x = (x & 0xf9f0) | ((srel & 0x30) << 5) | (srel & 0x0f);
1394 bfd_put_16 (input_bfd, x, contents);
1395 break;
1396
1397 case R_AVR_PORT5:
1398 contents += rel->r_offset;
1399 srel = (bfd_signed_vma) relocation + rel->r_addend;
1400 if ((srel & 0xffff) > 0x1f)
07d6d2b8 1401 return bfd_reloc_outofrange;
75f58085
BS		 1402 x = bfd_get_16 (input_bfd, contents);
1403 x = (x & 0xff07) | ((srel & 0x1f) << 3);
1404 bfd_put_16 (input_bfd, x, contents);
1405 break;
1406
adde6300
AM		 1407 default:
1408 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1409 contents, rel->r_offset,
1410 relocation, rel->r_addend);
1411 }
1412
1413 return r;
1414}
1415
1416/* Relocate an AVR ELF section. */
4cdc7696 1417
b34976b6 1418static bfd_boolean
4cdc7696
NC		 1419elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1420 struct bfd_link_info *info,
1421 bfd *input_bfd,
1422 asection *input_section,
1423 bfd_byte *contents,
1424 Elf_Internal_Rela *relocs,
1425 Elf_Internal_Sym *local_syms,
1426 asection **local_sections)
adde6300 1427{
07d6d2b8 1428 Elf_Internal_Shdr * symtab_hdr;
adde6300 1429 struct elf_link_hash_entry ** sym_hashes;
07d6d2b8
AM		 1430 Elf_Internal_Rela * rel;
1431 Elf_Internal_Rela * relend;
28c9d252 1432 struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
adde6300 1433
4dfe6ac6
NC		 1434 if (htab == NULL)
1435 return FALSE;
1436
adde6300
AM		 1437 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1438 sym_hashes = elf_sym_hashes (input_bfd);
1439 relend = relocs + input_section->reloc_count;
1440
1441 for (rel = relocs; rel < relend; rel ++)
1442 {
07d6d2b8
AM		 1443 reloc_howto_type * howto;
1444 unsigned long r_symndx;
1445 Elf_Internal_Sym * sym;
1446 asection * sec;
adde6300 1447 struct elf_link_hash_entry * h;
07d6d2b8
AM		 1448 bfd_vma relocation;
1449 bfd_reloc_status_type r;
1450 const char * name;
1451 int r_type;
adde6300
AM		 1452
1453 r_type = ELF32_R_TYPE (rel->r_info);
1454 r_symndx = ELF32_R_SYM (rel->r_info);
c7e2358a 1455 howto = elf_avr_howto_table + r_type;
adde6300
AM		 1456 h = NULL;
1457 sym = NULL;
1458 sec = NULL;
1459
1460 if (r_symndx < symtab_hdr->sh_info)
1461 {
1462 sym = local_syms + r_symndx;
1463 sec = local_sections [r_symndx];
8517fae7 1464 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
adde6300
AM		 1465
1466 name = bfd_elf_string_from_elf_section
1467 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1468 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1469 }
1470 else
1471 {
62d887d4 1472 bfd_boolean unresolved_reloc, warned, ignored;
adde6300 1473
b2a8e766
AM		 1474 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1475 r_symndx, symtab_hdr, sym_hashes,
1476 h, sec, relocation,
62d887d4 1477 unresolved_reloc, warned, ignored);
dfeffb9f
L		 1478
1479 name = h->root.root.string;
adde6300
AM		 1480 }
1481
dbaa2011 1482 if (sec != NULL && discarded_section (sec))
e4067dbb 1483 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 1484 rel, 1, relend, howto, 0, contents);
ab96bf03 1485
0e1862bb 1486 if (bfd_link_relocatable (info))
ab96bf03
AM		 1487 continue;
1488
adde6300 1489 r = avr_final_link_relocate (howto, input_bfd, input_section,
28c9d252 1490 contents, rel, relocation, htab);
adde6300
AM		 1491
1492 if (r != bfd_reloc_ok)
1493 {
1494 const char * msg = (const char *) NULL;
1495
1496 switch (r)
1497 {
1498 case bfd_reloc_overflow:
1a72702b
AM		 1499 (*info->callbacks->reloc_overflow)
1500 (info, (h ? &h->root : NULL), name, howto->name,
1501 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
adde6300
AM		 1502 break;
1503
1504 case bfd_reloc_undefined:
1a72702b 1505 (*info->callbacks->undefined_symbol)
b34976b6 1506 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
adde6300
AM		 1507 break;
1508
1509 case bfd_reloc_outofrange:
1510 msg = _("internal error: out of range error");
1511 break;
1512
1513 case bfd_reloc_notsupported:
1514 msg = _("internal error: unsupported relocation error");
1515 break;
1516
1517 case bfd_reloc_dangerous:
1518 msg = _("internal error: dangerous relocation");
1519 break;
1520
1521 default:
1522 msg = _("internal error: unknown error");
1523 break;
1524 }
1525
1526 if (msg)
1a72702b
AM		 1527 (*info->callbacks->warning) (info, msg, name, input_bfd,
1528 input_section, rel->r_offset);
adde6300
AM		 1529 }
1530 }
1531
b34976b6 1532 return TRUE;
adde6300
AM		 1533}
1534
1535/* The final processing done just before writing out a AVR ELF object
1536 file. This gets the AVR architecture right based on the machine
1537 number. */
1538
1539static void
4cdc7696
NC		 1540bfd_elf_avr_final_write_processing (bfd *abfd,
1541 bfd_boolean linker ATTRIBUTE_UNUSED)
adde6300
AM		 1542{
1543 unsigned long val;
1544
1545 switch (bfd_get_mach (abfd))
1546 {
1547 default:
1548 case bfd_mach_avr2:
1549 val = E_AVR_MACH_AVR2;
1550 break;
1551
1552 case bfd_mach_avr1:
1553 val = E_AVR_MACH_AVR1;
1554 break;
1555
7b21ac3f
EW		 1556 case bfd_mach_avr25:
1557 val = E_AVR_MACH_AVR25;
28b02751 1558 break;
7b21ac3f 1559
adde6300
AM		 1560 case bfd_mach_avr3:
1561 val = E_AVR_MACH_AVR3;
1562 break;
1563
7b21ac3f
EW		 1564 case bfd_mach_avr31:
1565 val = E_AVR_MACH_AVR31;
28b02751 1566 break;
7b21ac3f
EW		 1567
1568 case bfd_mach_avr35:
1569 val = E_AVR_MACH_AVR35;
28b02751 1570 break;
7b21ac3f 1571
adde6300
AM		 1572 case bfd_mach_avr4:
1573 val = E_AVR_MACH_AVR4;
1574 break;
1575
65aa24b6
NC		 1576 case bfd_mach_avr5:
1577 val = E_AVR_MACH_AVR5;
1578 break;
28c9d252 1579
7b21ac3f
EW		 1580 case bfd_mach_avr51:
1581 val = E_AVR_MACH_AVR51;
1582 break;
1583
28c9d252
NC		 1584 case bfd_mach_avr6:
1585 val = E_AVR_MACH_AVR6;
1586 break;
8cc66334
EW		 1587
1588 case bfd_mach_avrxmega1:
1589 val = E_AVR_MACH_XMEGA1;
1590 break;
1591
1592 case bfd_mach_avrxmega2:
1593 val = E_AVR_MACH_XMEGA2;
1594 break;
1595
1596 case bfd_mach_avrxmega3:
1597 val = E_AVR_MACH_XMEGA3;
1598 break;
1599
1600 case bfd_mach_avrxmega4:
1601 val = E_AVR_MACH_XMEGA4;
1602 break;
1603
1604 case bfd_mach_avrxmega5:
1605 val = E_AVR_MACH_XMEGA5;
1606 break;
1607
1608 case bfd_mach_avrxmega6:
1609 val = E_AVR_MACH_XMEGA6;
1610 break;
1611
1612 case bfd_mach_avrxmega7:
1613 val = E_AVR_MACH_XMEGA7;
1614 break;
f36e8886
BS		 1615
1616 case bfd_mach_avrtiny:
1617 val = E_AVR_MACH_AVRTINY;
1618 break;
adde6300
AM		 1619 }
1620
1621 elf_elfheader (abfd)->e_machine = EM_AVR;
1622 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1623 elf_elfheader (abfd)->e_flags |= val;
1624}
1625
1626/* Set the right machine number. */
1627
b34976b6 1628static bfd_boolean
4cdc7696 1629elf32_avr_object_p (bfd *abfd)
adde6300 1630{
dc810e39 1631 unsigned int e_set = bfd_mach_avr2;
4cdc7696 1632
aa4f99bb
AO		 1633 if (elf_elfheader (abfd)->e_machine == EM_AVR
1634 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
adde6300
AM		 1635 {
1636 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
4cdc7696 1637
adde6300
AM		 1638 switch (e_mach)
1639 {
1640 default:
1641 case E_AVR_MACH_AVR2:
1642 e_set = bfd_mach_avr2;
1643 break;
1644
1645 case E_AVR_MACH_AVR1:
1646 e_set = bfd_mach_avr1;
1647 break;
1648
7b21ac3f
EW		 1649 case E_AVR_MACH_AVR25:
1650 e_set = bfd_mach_avr25;
1651 break;
1652
adde6300
AM		 1653 case E_AVR_MACH_AVR3:
1654 e_set = bfd_mach_avr3;
1655 break;
1656
7b21ac3f
EW		 1657 case E_AVR_MACH_AVR31:
1658 e_set = bfd_mach_avr31;
1659 break;
1660
1661 case E_AVR_MACH_AVR35:
1662 e_set = bfd_mach_avr35;
1663 break;
1664
adde6300
AM		 1665 case E_AVR_MACH_AVR4:
1666 e_set = bfd_mach_avr4;
1667 break;
65aa24b6
NC		 1668
1669 case E_AVR_MACH_AVR5:
1670 e_set = bfd_mach_avr5;
1671 break;
28c9d252 1672
7b21ac3f
EW		 1673 case E_AVR_MACH_AVR51:
1674 e_set = bfd_mach_avr51;
1675 break;
1676
28c9d252
NC		 1677 case E_AVR_MACH_AVR6:
1678 e_set = bfd_mach_avr6;
1679 break;
8cc66334
EW		 1680
1681 case E_AVR_MACH_XMEGA1:
1682 e_set = bfd_mach_avrxmega1;
1683 break;
1684
1685 case E_AVR_MACH_XMEGA2:
1686 e_set = bfd_mach_avrxmega2;
1687 break;
1688
1689 case E_AVR_MACH_XMEGA3:
1690 e_set = bfd_mach_avrxmega3;
1691 break;
1692
1693 case E_AVR_MACH_XMEGA4:
1694 e_set = bfd_mach_avrxmega4;
1695 break;
1696
1697 case E_AVR_MACH_XMEGA5:
1698 e_set = bfd_mach_avrxmega5;
1699 break;
1700
1701 case E_AVR_MACH_XMEGA6:
1702 e_set = bfd_mach_avrxmega6;
1703 break;
1704
1705 case E_AVR_MACH_XMEGA7:
1706 e_set = bfd_mach_avrxmega7;
1707 break;
f36e8886
BS		 1708
1709 case E_AVR_MACH_AVRTINY:
1710 e_set = bfd_mach_avrtiny;
1711 break;
adde6300
AM		 1712 }
1713 }
1714 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1715 e_set);
1716}
1717
e4ef1b6c
DC		 1718/* Returns whether the relocation type passed is a diff reloc. */
1719
1720static bfd_boolean
1721elf32_avr_is_diff_reloc (Elf_Internal_Rela *irel)
1722{
1723 return (ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF8
07d6d2b8
AM		 1724 ||ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF16
1725 || ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF32);
e4ef1b6c
DC		 1726}
1727
f36e8886
BS		 1728/* Reduce the diff value written in the section by count if the shrinked
1729 insn address happens to fall between the two symbols for which this
1730 diff reloc was emitted. */
e4ef1b6c
DC		 1731
1732static void
1733elf32_avr_adjust_diff_reloc_value (bfd *abfd,
07d6d2b8
AM		 1734 struct bfd_section *isec,
1735 Elf_Internal_Rela *irel,
1736 bfd_vma symval,
1737 bfd_vma shrinked_insn_address,
1738 int count)
e4ef1b6c
DC		 1739{
1740 unsigned char *reloc_contents = NULL;
1741 unsigned char *isec_contents = elf_section_data (isec)->this_hdr.contents;
1742 if (isec_contents == NULL)
1743 {
1744 if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents))
1745 return;
1746
1747 elf_section_data (isec)->this_hdr.contents = isec_contents;
1748 }
1749
1750 reloc_contents = isec_contents + irel->r_offset;
1751
1752 /* Read value written in object file. */
4cb771f2 1753 bfd_signed_vma x = 0;
e4ef1b6c
DC		 1754 switch (ELF32_R_TYPE (irel->r_info))
1755 {
1756 case R_AVR_DIFF8:
1757 {
4cb771f2 1758 x = bfd_get_signed_8 (abfd, reloc_contents);
e4ef1b6c
DC		 1759 break;
1760 }
1761 case R_AVR_DIFF16:
1762 {
4cb771f2 1763 x = bfd_get_signed_16 (abfd, reloc_contents);
e4ef1b6c
DC		 1764 break;
1765 }
1766 case R_AVR_DIFF32:
1767 {
4cb771f2 1768 x = bfd_get_signed_32 (abfd, reloc_contents);
e4ef1b6c
DC		 1769 break;
1770 }
1771 default:
1772 {
1773 BFD_FAIL();
1774 }
1775 }
1776
1777 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written
1778 into the object file at the reloc offset. sym2's logical value is
1779 symval (<start_of_section>) + reloc addend. Compute the start and end
1780 addresses and check if the shrinked insn falls between sym1 and sym2. */
1781
4cb771f2
SKS		 1782 bfd_vma sym2_address = symval + irel->r_addend;
1783 bfd_vma sym1_address = sym2_address - x;
1784
1785 /* Don't assume sym2 is bigger than sym1 - the difference
1786 could be negative. Compute start and end addresses, and
1787 use those to see if they span shrinked_insn_address. */
1788
1789 bfd_vma start_address = sym1_address < sym2_address
1790 ? sym1_address : sym2_address;
1791 bfd_vma end_address = sym1_address > sym2_address
1792 ? sym1_address : sym2_address;
e4ef1b6c 1793
e4ef1b6c 1794
f36e8886 1795 if (shrinked_insn_address >= start_address
68063779 1796 && shrinked_insn_address < end_address)
e4ef1b6c 1797 {
4cb771f2
SKS		 1798 /* Reduce the diff value by count bytes and write it back into section
1799 contents. */
1800 bfd_signed_vma new_diff = x < 0 ? x + count : x - count;
1801
68063779
SKS		 1802 if (sym2_address > shrinked_insn_address)
1803 irel->r_addend -= count;
1804
e4ef1b6c
DC		 1805 switch (ELF32_R_TYPE (irel->r_info))
1806 {
1807 case R_AVR_DIFF8:
1808 {
07d6d2b8
AM		 1809 bfd_put_signed_8 (abfd, new_diff, reloc_contents);
1810 break;
e4ef1b6c
DC		 1811 }
1812 case R_AVR_DIFF16:
1813 {
07d6d2b8
AM		 1814 bfd_put_signed_16 (abfd, new_diff & 0xFFFF, reloc_contents);
1815 break;
e4ef1b6c
DC		 1816 }
1817 case R_AVR_DIFF32:
1818 {
07d6d2b8
AM		 1819 bfd_put_signed_32 (abfd, new_diff & 0xFFFFFFFF, reloc_contents);
1820 break;
e4ef1b6c
DC		 1821 }
1822 default:
1823 {
07d6d2b8 1824 BFD_FAIL();
e4ef1b6c
DC		 1825 }
1826 }
1827
1828 }
1829}
df406460 1830
4cb771f2
SKS		 1831static void
1832elf32_avr_adjust_reloc_if_spans_insn (bfd *abfd,
07d6d2b8
AM		 1833 asection *isec,
1834 Elf_Internal_Rela *irel, bfd_vma symval,
1835 bfd_vma shrinked_insn_address,
1836 bfd_vma shrink_boundary,
1837 int count)
4cb771f2
SKS		 1838{
1839
1840 if (elf32_avr_is_diff_reloc (irel))
1841 {
1842 elf32_avr_adjust_diff_reloc_value (abfd, isec, irel,
07d6d2b8
AM		 1843 symval,
1844 shrinked_insn_address,
1845 count);
4cb771f2
SKS		 1846 }
1847 else
1848 {
1849 bfd_vma reloc_value = symval + irel->r_addend;
1850 bfd_boolean addend_within_shrink_boundary =
07d6d2b8 1851 (reloc_value <= shrink_boundary);
4cb771f2
SKS		 1852
1853 bfd_boolean reloc_spans_insn =
07d6d2b8
AM		 1854 (symval <= shrinked_insn_address
1855 && reloc_value > shrinked_insn_address
1856 && addend_within_shrink_boundary);
4cb771f2
SKS		 1857
1858 if (! reloc_spans_insn)
07d6d2b8 1859 return;
4cb771f2
SKS		 1860
1861 irel->r_addend -= count;
1862
1863 if (debug_relax)
07d6d2b8 1864 printf ("Relocation's addend needed to be fixed \n");
4cb771f2
SKS		 1865 }
1866}
1867
b660e9eb
SKS		 1868static bfd_boolean
1869avr_should_move_sym (symvalue symval,
07d6d2b8
AM		 1870 bfd_vma start,
1871 bfd_vma end,
1872 bfd_boolean did_pad)
b660e9eb
SKS		 1873{
1874 bfd_boolean sym_within_boundary =
07d6d2b8 1875 did_pad ? symval < end : symval <= end;
b660e9eb
SKS		 1876 return (symval > start && sym_within_boundary);
1877}
1878
1879static bfd_boolean
1880avr_should_reduce_sym_size (symvalue symval,
07d6d2b8
AM		 1881 symvalue symend,
1882 bfd_vma start,
1883 bfd_vma end,
1884 bfd_boolean did_pad)
b660e9eb
SKS		 1885{
1886 bfd_boolean sym_end_within_boundary =
07d6d2b8 1887 did_pad ? symend < end : symend <= end;
b660e9eb
SKS		 1888 return (symval <= start && symend > start && sym_end_within_boundary);
1889}
1890
1891static bfd_boolean
1892avr_should_increase_sym_size (symvalue symval,
07d6d2b8
AM		 1893 symvalue symend,
1894 bfd_vma start,
1895 bfd_vma end,
1896 bfd_boolean did_pad)
b660e9eb
SKS		 1897{
1898 return avr_should_move_sym (symval, start, end, did_pad)
07d6d2b8 1899 && symend >= end && did_pad;
b660e9eb
SKS		 1900}
1901
4cdc7696
NC		 1902/* Delete some bytes from a section while changing the size of an instruction.
1903 The parameter "addr" denotes the section-relative offset pointing just
1904 behind the shrinked instruction. "addr+count" point at the first
bf186506
SKS		 1905 byte just behind the original unshrinked instruction. If delete_shrinks_insn
1906 is FALSE, we are deleting redundant padding bytes from relax_info prop
1907 record handling. In that case, addr is section-relative offset of start
1908 of padding, and count is the number of padding bytes to delete. */
4cdc7696
NC		 1909
1910static bfd_boolean
1911elf32_avr_relax_delete_bytes (bfd *abfd,
07d6d2b8
AM		 1912 asection *sec,
1913 bfd_vma addr,
1914 int count,
1915 bfd_boolean delete_shrinks_insn)
4cdc7696
NC		 1916{
1917 Elf_Internal_Shdr *symtab_hdr;
1918 unsigned int sec_shndx;
1919 bfd_byte *contents;
1920 Elf_Internal_Rela *irel, *irelend;
4cdc7696
NC		 1921 Elf_Internal_Sym *isym;
1922 Elf_Internal_Sym *isymbuf = NULL;
b660e9eb 1923 bfd_vma toaddr;
4cdc7696
NC		 1924 struct elf_link_hash_entry **sym_hashes;
1925 struct elf_link_hash_entry **end_hashes;
1926 unsigned int symcount;
bac13f5a
AB		 1927 struct avr_relax_info *relax_info;
1928 struct avr_property_record *prop_record = NULL;
5c41dbc3 1929 bfd_boolean did_shrink = FALSE;
b660e9eb 1930 bfd_boolean did_pad = FALSE;
4cdc7696
NC		 1931
1932 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1933 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1934 contents = elf_section_data (sec)->this_hdr.contents;
bac13f5a 1935 relax_info = get_avr_relax_info (sec);
4cdc7696 1936
4cdc7696
NC		 1937 toaddr = sec->size;
1938
bac13f5a
AB		 1939 if (relax_info->records.count > 0)
1940 {
1941 /* There should be no property record within the range of deleted
07d6d2b8
AM		 1942 bytes, however, there might be a property record for ADDR, this is
1943 how we handle alignment directives.
1944 Find the next (if any) property record after the deleted bytes. */
bac13f5a
AB		 1945 unsigned int i;
1946
1947 for (i = 0; i < relax_info->records.count; ++i)
07d6d2b8
AM		 1948 {
1949 bfd_vma offset = relax_info->records.items [i].offset;
1950
1951 BFD_ASSERT (offset <= addr || offset >= (addr + count));
1952 if (offset >= (addr + count))
1953 {
1954 prop_record = &relax_info->records.items [i];
1955 toaddr = offset;
1956 break;
1957 }
1958 }
bac13f5a
AB		 1959 }
1960
4cdc7696
NC		 1961 irel = elf_section_data (sec)->relocs;
1962 irelend = irel + sec->reloc_count;
1963
1964 /* Actually delete the bytes. */
1965 if (toaddr - addr - count > 0)
5c41dbc3
DC		 1966 {
1967 memmove (contents + addr, contents + addr + count,
07d6d2b8 1968 (size_t) (toaddr - addr - count));
5c41dbc3
DC		 1969 did_shrink = TRUE;
1970 }
bac13f5a 1971 if (prop_record == NULL)
5c41dbc3
DC		 1972 {
1973 sec->size -= count;
1974 did_shrink = TRUE;
1975 }
bac13f5a
AB		 1976 else
1977 {
1978 /* Use the property record to fill in the bytes we've opened up. */
1979 int fill = 0;
1980 switch (prop_record->type)
07d6d2b8
AM		 1981 {
1982 case RECORD_ORG_AND_FILL:
1983 fill = prop_record->data.org.fill;
1984 /* Fall through. */
1985 case RECORD_ORG:
1986 break;
1987 case RECORD_ALIGN_AND_FILL:
1988 fill = prop_record->data.align.fill;
1989 /* Fall through. */
1990 case RECORD_ALIGN:
1991 prop_record->data.align.preceding_deleted += count;
1992 break;
1993 };
5c41dbc3 1994 /* If toaddr == (addr + count), then we didn't delete anything, yet
07d6d2b8
AM		 1995 we fill count bytes backwards from toaddr. This is still ok - we
1996 end up overwriting the bytes we would have deleted. We just need
1997 to remember we didn't delete anything i.e. don't set did_shrink,
1998 so that we don't corrupt reloc offsets or symbol values.*/
bac13f5a 1999 memset (contents + toaddr - count, fill, count);
b660e9eb 2000 did_pad = TRUE;
bac13f5a 2001 }
4cdc7696 2002
5c41dbc3
DC		 2003 if (!did_shrink)
2004 return TRUE;
2005
73160847 2006 /* Adjust all the reloc addresses. */
4cdc7696
NC		 2007 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2008 {
4cdc7696 2009 bfd_vma old_reloc_address;
4cdc7696
NC		 2010
2011 old_reloc_address = (sec->output_section->vma
07d6d2b8 2012 + sec->output_offset + irel->r_offset);
4cdc7696
NC		 2013
2014 /* Get the new reloc address. */
2015 if ((irel->r_offset > addr
07d6d2b8
AM		 2016 && irel->r_offset < toaddr))
2017 {
2018 if (debug_relax)
2019 printf ("Relocation at address 0x%x needs to be moved.\n"
2020 "Old section offset: 0x%x, New section offset: 0x%x \n",
2021 (unsigned int) old_reloc_address,
2022 (unsigned int) irel->r_offset,
2023 (unsigned int) ((irel->r_offset) - count));
2024
2025 irel->r_offset -= count;
2026 }
4cdc7696 2027
73160847 2028 }
4cdc7696 2029
73160847
NC		 2030 /* The reloc's own addresses are now ok. However, we need to readjust
2031 the reloc's addend, i.e. the reloc's value if two conditions are met:
2032 1.) the reloc is relative to a symbol in this section that
07d6d2b8 2033 is located in front of the shrinked instruction
28c9d252
NC		 2034 2.) symbol plus addend end up behind the shrinked instruction.
2035
73160847
NC		 2036 The most common case where this happens are relocs relative to
2037 the section-start symbol.
28c9d252 2038
73160847
NC		 2039 This step needs to be done for all of the sections of the bfd. */
2040
2041 {
2042 struct bfd_section *isec;
2043
2044 for (isec = abfd->sections; isec; isec = isec->next)
2045 {
2046 bfd_vma symval;
2047 bfd_vma shrinked_insn_address;
2048
a1c7aafb
NC		 2049 if (isec->reloc_count == 0)
2050 continue;
2051
73160847 2052 shrinked_insn_address = (sec->output_section->vma
07d6d2b8 2053 + sec->output_offset + addr);
bf186506 2054 if (delete_shrinks_insn)
07d6d2b8 2055 shrinked_insn_address -= count;
73160847 2056
a1c7aafb
NC		 2057 irel = elf_section_data (isec)->relocs;
2058 /* PR 12161: Read in the relocs for this section if necessary. */
2059 if (irel == NULL)
07d6d2b8 2060 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
a1c7aafb
NC		 2061
2062 for (irelend = irel + isec->reloc_count;
07d6d2b8
AM		 2063 irel < irelend;
2064 irel++)
2065 {
2066 /* Read this BFD's local symbols if we haven't done
2067 so already. */
2068 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2069 {
2070 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2071 if (isymbuf == NULL)
2072 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2073 symtab_hdr->sh_info, 0,
2074 NULL, NULL, NULL);
2075 if (isymbuf == NULL)
2076 return FALSE;
2077 }
2078
2079 /* Get the value of the symbol referred to by the reloc. */
2080 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2081 {
2082 /* A local symbol. */
2083 asection *sym_sec;
2084
2085 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2086 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2087 symval = isym->st_value;
2088 /* If the reloc is absolute, it will not have
2089 a symbol or section associated with it. */
2090 if (sym_sec == sec)
2091 {
2092 /* If there is an alignment boundary, we only need to
2093 adjust addends that end up below the boundary. */
2094 bfd_vma shrink_boundary = (toaddr
2095 + sec->output_section->vma
2096 + sec->output_offset);
2097
2098 symval += sym_sec->output_section->vma
2099 + sym_sec->output_offset;
2100
2101 if (debug_relax)
2102 printf ("Checking if the relocation's "
2103 "addend needs corrections.\n"
2104 "Address of anchor symbol: 0x%x \n"
2105 "Address of relocation target: 0x%x \n"
2106 "Address of relaxed insn: 0x%x \n",
2107 (unsigned int) symval,
2108 (unsigned int) (symval + irel->r_addend),
2109 (unsigned int) shrinked_insn_address);
2110
2111 elf32_avr_adjust_reloc_if_spans_insn (abfd, isec, irel,
2112 symval,
2113 shrinked_insn_address,
2114 shrink_boundary,
2115 count);
2116 }
73160847 2117 /* else...Reference symbol is absolute. No adjustment needed. */
28c9d252
NC		 2118 }
2119 /* else...Reference symbol is extern. No need for adjusting
73160847 2120 the addend. */
28c9d252 2121 }
73160847
NC		 2122 }
2123 }
4cdc7696
NC		 2124
2125 /* Adjust the local symbols defined in this section. */
2126 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
12123067
NC		 2127 /* Fix PR 9841, there may be no local symbols. */
2128 if (isym != NULL)
4cdc7696 2129 {
12123067
NC		 2130 Elf_Internal_Sym *isymend;
2131
2132 isymend = isym + symtab_hdr->sh_info;
2133 for (; isym < isymend; isym++)
2134 {
931b79cc 2135 if (isym->st_shndx == sec_shndx)
07d6d2b8
AM		 2136 {
2137 symvalue symval = isym->st_value;
2138 symvalue symend = symval + isym->st_size;
2139 if (avr_should_reduce_sym_size (symval, symend,
2140 addr, toaddr, did_pad))
2141 {
2142 /* If this assert fires then we have a symbol that ends
2143 part way through an instruction. Does that make
2144 sense? */
2145 BFD_ASSERT (isym->st_value + isym->st_size >= addr + count);
2146 isym->st_size -= count;
2147 }
2148 else if (avr_should_increase_sym_size (symval, symend,
2149 addr, toaddr, did_pad))
2150 isym->st_size += count;
2151
2152 if (avr_should_move_sym (symval, addr, toaddr, did_pad))
2153 isym->st_value -= count;
2154 }
12123067 2155 }
4cdc7696
NC		 2156 }
2157
2158 /* Now adjust the global symbols defined in this section. */
2159 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
07d6d2b8 2160 - symtab_hdr->sh_info);
4cdc7696
NC		 2161 sym_hashes = elf_sym_hashes (abfd);
2162 end_hashes = sym_hashes + symcount;
2163 for (; sym_hashes < end_hashes; sym_hashes++)
2164 {
2165 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2166 if ((sym_hash->root.type == bfd_link_hash_defined
07d6d2b8
AM		 2167 || sym_hash->root.type == bfd_link_hash_defweak)
2168 && sym_hash->root.u.def.section == sec)
2169 {
2170 symvalue symval = sym_hash->root.u.def.value;
2171 symvalue symend = symval + sym_hash->size;
2172
2173 if (avr_should_reduce_sym_size (symval, symend,
2174 addr, toaddr, did_pad))
2175 {
2176 /* If this assert fires then we have a symbol that ends
2177 part way through an instruction. Does that make
2178 sense? */
2179 BFD_ASSERT (symend >= addr + count);
2180 sym_hash->size -= count;
2181 }
2182 else if (avr_should_increase_sym_size (symval, symend,
2183 addr, toaddr, did_pad))
2184 sym_hash->size += count;
2185
2186 if (avr_should_move_sym (symval, addr, toaddr, did_pad))
2187 sym_hash->root.u.def.value -= count;
2188 }
4cdc7696
NC		 2189 }
2190
2191 return TRUE;
2192}
2193
137c83d6
AB		 2194static Elf_Internal_Sym *
2195retrieve_local_syms (bfd *input_bfd)
2196{
2197 Elf_Internal_Shdr *symtab_hdr;
2198 Elf_Internal_Sym *isymbuf;
2199 size_t locsymcount;
2200
2201 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2202 locsymcount = symtab_hdr->sh_info;
2203
2204 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2205 if (isymbuf == NULL && locsymcount != 0)
2206 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
2207 NULL, NULL, NULL);
2208
2209 /* Save the symbols for this input file so they won't be read again. */
2210 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
2211 symtab_hdr->contents = (unsigned char *) isymbuf;
2212
2213 return isymbuf;
2214}
2215
2216/* Get the input section for a given symbol index.
2217 If the symbol is:
2218 . a section symbol, return the section;
2219 . a common symbol, return the common section;
2220 . an undefined symbol, return the undefined section;
2221 . an indirect symbol, follow the links;
2222 . an absolute value, return the absolute section. */
2223
2224static asection *
2225get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
2226{
2227 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2228 asection *target_sec = NULL;
2229 if (r_symndx < symtab_hdr->sh_info)
2230 {
2231 Elf_Internal_Sym *isymbuf;
2232 unsigned int section_index;
2233
2234 isymbuf = retrieve_local_syms (abfd);
2235 section_index = isymbuf[r_symndx].st_shndx;
2236
2237 if (section_index == SHN_UNDEF)
2238 target_sec = bfd_und_section_ptr;
2239 else if (section_index == SHN_ABS)
2240 target_sec = bfd_abs_section_ptr;
2241 else if (section_index == SHN_COMMON)
2242 target_sec = bfd_com_section_ptr;
2243 else
2244 target_sec = bfd_section_from_elf_index (abfd, section_index);
2245 }
2246 else
2247 {
2248 unsigned long indx = r_symndx - symtab_hdr->sh_info;
2249 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
2250
2251 while (h->root.type == bfd_link_hash_indirect
07d6d2b8
AM		 2252 || h->root.type == bfd_link_hash_warning)
2253 h = (struct elf_link_hash_entry *) h->root.u.i.link;
137c83d6
AB		 2254
2255 switch (h->root.type)
2256 {
2257 case bfd_link_hash_defined:
2258 case bfd_link_hash_defweak:
2259 target_sec = h->root.u.def.section;
2260 break;
2261 case bfd_link_hash_common:
2262 target_sec = bfd_com_section_ptr;
2263 break;
2264 case bfd_link_hash_undefined:
2265 case bfd_link_hash_undefweak:
2266 target_sec = bfd_und_section_ptr;
2267 break;
2268 default: /* New indirect warning. */
2269 target_sec = bfd_und_section_ptr;
2270 break;
2271 }
2272 }
2273 return target_sec;
2274}
2275
2276/* Get the section-relative offset for a symbol number. */
2277
2278static bfd_vma
2279get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
2280{
2281 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2282 bfd_vma offset = 0;
2283
2284 if (r_symndx < symtab_hdr->sh_info)
2285 {
2286 Elf_Internal_Sym *isymbuf;
2287 isymbuf = retrieve_local_syms (abfd);
2288 offset = isymbuf[r_symndx].st_value;
2289 }
2290 else
2291 {
2292 unsigned long indx = r_symndx - symtab_hdr->sh_info;
2293 struct elf_link_hash_entry *h =
2294 elf_sym_hashes (abfd)[indx];
2295
2296 while (h->root.type == bfd_link_hash_indirect
07d6d2b8 2297 || h->root.type == bfd_link_hash_warning)
137c83d6
AB		 2298 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2299 if (h->root.type == bfd_link_hash_defined
07d6d2b8 2300 || h->root.type == bfd_link_hash_defweak)
137c83d6
AB		 2301 offset = h->root.u.def.value;
2302 }
2303 return offset;
2304}
2305
bac13f5a
AB		 2306/* Iterate over the property records in R_LIST, and copy each record into
2307 the list of records within the relaxation information for the section to
2308 which the record applies. */
2309
2310static void
2311avr_elf32_assign_records_to_sections (struct avr_property_record_list *r_list)
2312{
2313 unsigned int i;
2314
2315 for (i = 0; i < r_list->record_count; ++i)
2316 {
2317 struct avr_relax_info *relax_info;
2318
2319 relax_info = get_avr_relax_info (r_list->records [i].section);
2320 BFD_ASSERT (relax_info != NULL);
2321
2322 if (relax_info->records.count
07d6d2b8
AM		 2323 == relax_info->records.allocated)
2324 {
2325 /* Allocate more space. */
2326 bfd_size_type size;
2327
2328 relax_info->records.allocated += 10;
2329 size = (sizeof (struct avr_property_record)
2330 * relax_info->records.allocated);
2331 relax_info->records.items
2332 = bfd_realloc (relax_info->records.items, size);
2333 }
bac13f5a
AB		 2334
2335 memcpy (&relax_info->records.items [relax_info->records.count],
07d6d2b8
AM		 2336 &r_list->records [i],
2337 sizeof (struct avr_property_record));
bac13f5a
AB		 2338 relax_info->records.count++;
2339 }
2340}
2341
2342/* Compare two STRUCT AVR_PROPERTY_RECORD in AP and BP, used as the
2343 ordering callback from QSORT. */
2344
2345static int
2346avr_property_record_compare (const void *ap, const void *bp)
2347{
2348 const struct avr_property_record *a
2349 = (struct avr_property_record *) ap;
2350 const struct avr_property_record *b
2351 = (struct avr_property_record *) bp;
2352
2353 if (a->offset != b->offset)
2354 return (a->offset - b->offset);
2355
2356 if (a->section != b->section)
2357 return (bfd_get_section_vma (a->section->owner, a->section)
07d6d2b8 2358 - bfd_get_section_vma (b->section->owner, b->section));
bac13f5a
AB		 2359
2360 return (a->type - b->type);
2361}
2362
2363/* Load all of the avr property sections from all of the bfd objects
2364 referenced from LINK_INFO. All of the records within each property
2365 section are assigned to the STRUCT AVR_RELAX_INFO within the section
2366 specific data of the appropriate section. */
2367
2368static void
2369avr_load_all_property_sections (struct bfd_link_info *link_info)
2370{
2371 bfd *abfd;
2372 asection *sec;
2373
2374 /* Initialize the per-section relaxation info. */
2375 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2376 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2377 {
2378 init_avr_relax_info (sec);
2379 }
2380
2381 /* Load the descriptor tables from .avr.prop sections. */
2382 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2383 {
2384 struct avr_property_record_list *r_list;
2385
2386 r_list = avr_elf32_load_property_records (abfd);
2387 if (r_list != NULL)
07d6d2b8 2388 avr_elf32_assign_records_to_sections (r_list);
bac13f5a
AB		 2389
2390 free (r_list);
2391 }
2392
2393 /* Now, for every section, ensure that the descriptor list in the
2394 relaxation data is sorted by ascending offset within the section. */
2395 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2396 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2397 {
07d6d2b8
AM		 2398 struct avr_relax_info *relax_info = get_avr_relax_info (sec);
2399 if (relax_info && relax_info->records.count > 0)
2400 {
2401 unsigned int i;
2402
2403 qsort (relax_info->records.items,
2404 relax_info->records.count,
2405 sizeof (struct avr_property_record),
2406 avr_property_record_compare);
2407
2408 /* For debug purposes, list all the descriptors. */
2409 for (i = 0; i < relax_info->records.count; ++i)
2410 {
2411 switch (relax_info->records.items [i].type)
2412 {
2413 case RECORD_ORG:
2414 break;
2415 case RECORD_ORG_AND_FILL:
2416 break;
2417 case RECORD_ALIGN:
2418 break;
2419 case RECORD_ALIGN_AND_FILL:
2420 break;
2421 };
2422 }
2423 }
bac13f5a
AB		 2424 }
2425}
2426
df406460
NC		 2427/* This function handles relaxing for the avr.
2428 Many important relaxing opportunities within functions are already
2429 realized by the compiler itself.
2430 Here we try to replace call (4 bytes) -> rcall (2 bytes)
4cdc7696
NC		 2431 and jump -> rjmp (safes also 2 bytes).
2432 As well we now optimize seqences of
df406460
NC		 2433 - call/rcall function
2434 - ret
2435 to yield
2436 - jmp/rjmp function
2437 - ret
2438 . In case that within a sequence
2439 - jmp/rjmp label
2440 - ret
2441 the ret could no longer be reached it is optimized away. In order
2442 to check if the ret is no longer needed, it is checked that the ret's address
2443 is not the target of a branch or jump within the same section, it is checked
2444 that there is no skip instruction before the jmp/rjmp and that there
2445 is no local or global label place at the address of the ret.
4cdc7696 2446
df406460 2447 We refrain from relaxing within sections ".vectors" and
4cdc7696 2448 ".jumptables" in order to maintain the position of the instructions.
df406460 2449 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
4cdc7696 2450 if possible. (In future one could possibly use the space of the nop
df406460
NC		 2451 for the first instruction of the irq service function.
2452
2453 The .jumptables sections is meant to be used for a future tablejump variant
2454 for the devices with 3-byte program counter where the table itself
4cdc7696 2455 contains 4-byte jump instructions whose relative offset must not
df406460 2456 be changed. */
4cdc7696 2457
28c9d252 2458static bfd_boolean
4cdc7696
NC		 2459elf32_avr_relax_section (bfd *abfd,
2460 asection *sec,
07d6d2b8
AM		 2461 struct bfd_link_info *link_info,
2462 bfd_boolean *again)
df406460
NC		 2463{
2464 Elf_Internal_Shdr *symtab_hdr;
2465 Elf_Internal_Rela *internal_relocs;
2466 Elf_Internal_Rela *irel, *irelend;
2467 bfd_byte *contents = NULL;
2468 Elf_Internal_Sym *isymbuf = NULL;
28c9d252 2469 struct elf32_avr_link_hash_table *htab;
bac13f5a
AB		 2470 static bfd_boolean relaxation_initialised = FALSE;
2471
2472 if (!relaxation_initialised)
2473 {
2474 relaxation_initialised = TRUE;
2475
2476 /* Load entries from the .avr.prop sections. */
2477 avr_load_all_property_sections (link_info);
2478 }
28c9d252 2479
526f25b2 2480 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
68ffbac6
L		 2481 relaxing. Such shrinking can cause issues for the sections such
2482 as .vectors and .jumptables. Instead the unused bytes should be
526f25b2
EW		 2483 filled with nop instructions. */
2484 bfd_boolean shrinkable = TRUE;
2485
2486 if (!strcmp (sec->name,".vectors")
2487 || !strcmp (sec->name,".jumptables"))
2488 shrinkable = FALSE;
2489
0e1862bb 2490 if (bfd_link_relocatable (link_info))
c8a1f254
NS		 2491 (*link_info->callbacks->einfo)
2492 (_("%P%F: --relax and -r may not be used together\n"));
2493
28c9d252 2494 htab = avr_link_hash_table (link_info);
64ee10b6
NC		 2495 if (htab == NULL)
2496 return FALSE;
df406460
NC		 2497
2498 /* Assume nothing changes. */
2499 *again = FALSE;
2500
28c9d252
NC		 2501 if ((!htab->no_stubs) && (sec == htab->stub_sec))
2502 {
2503 /* We are just relaxing the stub section.
2504 Let's calculate the size needed again. */
2505 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
2506
2507 if (debug_relax)
07d6d2b8
AM		 2508 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
2509 (int) last_estimated_stub_section_size);
28c9d252
NC		 2510
2511 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
07d6d2b8 2512 link_info, FALSE);
28c9d252
NC		 2513
2514 /* Check if the number of trampolines changed. */
2515 if (last_estimated_stub_section_size != htab->stub_sec->size)
07d6d2b8 2516 *again = TRUE;
28c9d252
NC		 2517
2518 if (debug_relax)
07d6d2b8
AM		 2519 printf ("Size of stub section after this pass: %i\n",
2520 (int) htab->stub_sec->size);
28c9d252
NC		 2521
2522 return TRUE;
2523 }
2524
df406460
NC		 2525 /* We don't have to do anything for a relocatable link, if
2526 this section does not have relocs, or if this is not a
2527 code section. */
0e1862bb 2528 if (bfd_link_relocatable (link_info)
df406460
NC		 2529 || (sec->flags & SEC_RELOC) == 0
2530 || sec->reloc_count == 0
2531 || (sec->flags & SEC_CODE) == 0)
2532 return TRUE;
4cdc7696 2533
df406460
NC		 2534 /* Check if the object file to relax uses internal symbols so that we
2535 could fix up the relocations. */
df406460
NC		 2536 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
2537 return TRUE;
df406460
NC		 2538
2539 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2540
2541 /* Get a copy of the native relocations. */
2542 internal_relocs = (_bfd_elf_link_read_relocs
07d6d2b8 2543 (abfd, sec, NULL, NULL, link_info->keep_memory));
df406460
NC		 2544 if (internal_relocs == NULL)
2545 goto error_return;
2546
df406460
NC		 2547 /* Walk through the relocs looking for relaxing opportunities. */
2548 irelend = internal_relocs + sec->reloc_count;
2549 for (irel = internal_relocs; irel < irelend; irel++)
2550 {
2551 bfd_vma symval;
2552
4cdc7696 2553 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
f36e8886
BS		 2554 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
2555 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
07d6d2b8 2556 continue;
4cdc7696 2557
df406460
NC		 2558 /* Get the section contents if we haven't done so already. */
2559 if (contents == NULL)
07d6d2b8
AM		 2560 {
2561 /* Get cached copy if it exists. */
2562 if (elf_section_data (sec)->this_hdr.contents != NULL)
2563 contents = elf_section_data (sec)->this_hdr.contents;
2564 else
2565 {
2566 /* Go get them off disk. */
2567 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2568 goto error_return;
2569 }
2570 }
df406460 2571
91d6fa6a 2572 /* Read this BFD's local symbols if we haven't done so already. */
df406460 2573 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
07d6d2b8
AM		 2574 {
2575 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2576 if (isymbuf == NULL)
2577 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2578 symtab_hdr->sh_info, 0,
2579 NULL, NULL, NULL);
2580 if (isymbuf == NULL)
2581 goto error_return;
2582 }
df406460
NC		 2583
2584
2585 /* Get the value of the symbol referred to by the reloc. */
2586 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
07d6d2b8
AM		 2587 {
2588 /* A local symbol. */
2589 Elf_Internal_Sym *isym;
2590 asection *sym_sec;
2591
2592 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2593 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2594 symval = isym->st_value;
2595 /* If the reloc is absolute, it will not have
2596 a symbol or section associated with it. */
2597 if (sym_sec)
2598 symval += sym_sec->output_section->vma
2599 + sym_sec->output_offset;
2600 }
df406460 2601 else
07d6d2b8
AM		 2602 {
2603 unsigned long indx;
2604 struct elf_link_hash_entry *h;
2605
2606 /* An external symbol. */
2607 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2608 h = elf_sym_hashes (abfd)[indx];
2609 BFD_ASSERT (h != NULL);
2610 if (h->root.type != bfd_link_hash_defined
2611 && h->root.type != bfd_link_hash_defweak)
4cdc7696
NC		 2612 /* This appears to be a reference to an undefined
2613 symbol. Just ignore it--it will be caught by the
2614 regular reloc processing. */
2615 continue;
2616
07d6d2b8
AM		 2617 symval = (h->root.u.def.value
2618 + h->root.u.def.section->output_section->vma
2619 + h->root.u.def.section->output_offset);
2620 }
df406460
NC		 2621
2622 /* For simplicity of coding, we are going to modify the section
07d6d2b8
AM		 2623 contents, the section relocs, and the BFD symbol table. We
2624 must tell the rest of the code not to free up this
2625 information. It would be possible to instead create a table
2626 of changes which have to be made, as is done in coff-mips.c;
2627 that would be more work, but would require less memory when
2628 the linker is run. */
df406460 2629 switch (ELF32_R_TYPE (irel->r_info))
07d6d2b8 2630 {
91d6fa6a
NC		 2631 /* Try to turn a 22-bit absolute call/jump into an 13-bit
2632 pc-relative rcall/rjmp. */
2633 case R_AVR_CALL:
07d6d2b8
AM		 2634 {
2635 bfd_vma value = symval + irel->r_addend;
2636 bfd_vma dot, gap;
2637 int distance_short_enough = 0;
2638
2639 /* Get the address of this instruction. */
2640 dot = (sec->output_section->vma
2641 + sec->output_offset + irel->r_offset);
2642
2643 /* Compute the distance from this insn to the branch target. */
2644 gap = value - dot;
2645
2646 /* Check if the gap falls in the range that can be accommodated
2647 in 13bits signed (It is 12bits when encoded, as we deal with
2648 word addressing). */
2649 if (!shrinkable && ((int) gap >= -4096 && (int) gap <= 4095))
2650 distance_short_enough = 1;
2651 /* If shrinkable, then we can check for a range of distance which
2652 is two bytes farther on both the directions because the call
2653 or jump target will be closer by two bytes after the
2654 relaxation. */
2655 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4097))
2656 distance_short_enough = 1;
2657
2658 /* Here we handle the wrap-around case. E.g. for a 16k device
2659 we could use a rjmp to jump from address 0x100 to 0x3d00!
2660 In order to make this work properly, we need to fill the
2661 vaiable avr_pc_wrap_around with the appropriate value.
2662 I.e. 0x4000 for a 16k device. */
2663 {
91d6fa6a
NC		 2664 /* Shrinking the code size makes the gaps larger in the
2665 case of wrap-arounds. So we use a heuristical safety
2666 margin to avoid that during relax the distance gets
2667 again too large for the short jumps. Let's assume
2668 a typical code-size reduction due to relax for a
2669 16k device of 600 bytes. So let's use twice the
2670 typical value as safety margin. */
2671 int rgap;
2672 int safety_margin;
2673
2674 int assumed_shrink = 600;
2675 if (avr_pc_wrap_around > 0x4000)
2676 assumed_shrink = 900;
2677
2678 safety_margin = 2 * assumed_shrink;
2679
2680 rgap = avr_relative_distance_considering_wrap_around (gap);
2681
2682 if (rgap >= (-4092 + safety_margin)
2683 && rgap <= (4094 - safety_margin))
2684 distance_short_enough = 1;
07d6d2b8
AM		 2685 }
2686
2687 if (distance_short_enough)
2688 {
2689 unsigned char code_msb;
2690 unsigned char code_lsb;
2691
2692 if (debug_relax)
2693 printf ("shrinking jump/call instruction at address 0x%x"
2694 " in section %s\n\n",
2695 (int) dot, sec->name);
2696
2697 /* Note that we've changed the relocs, section contents,
2698 etc. */
2699 elf_section_data (sec)->relocs = internal_relocs;
2700 elf_section_data (sec)->this_hdr.contents = contents;
2701 symtab_hdr->contents = (unsigned char *) isymbuf;
2702
2703 /* Get the instruction code for relaxing. */
2704 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
2705 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2706
2707 /* Mask out the relocation bits. */
2708 code_msb &= 0x94;
2709 code_lsb &= 0x0E;
2710 if (code_msb == 0x94 && code_lsb == 0x0E)
2711 {
2712 /* we are changing call -> rcall . */
2713 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2714 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
2715 }
2716 else if (code_msb == 0x94 && code_lsb == 0x0C)
2717 {
2718 /* we are changeing jump -> rjmp. */
2719 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2720 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
2721 }
2722 else
2723 abort ();
2724
2725 /* Fix the relocation's type. */
2726 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2727 R_AVR_13_PCREL);
2728
2729 /* We should not modify the ordering if 'shrinkable' is
2730 FALSE. */
2731 if (!shrinkable)
2732 {
2733 /* Let's insert a nop. */
2734 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
2735 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
2736 }
2737 else
2738 {
2739 /* Delete two bytes of data. */
2740 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2741 irel->r_offset + 2, 2,
2742 TRUE))
2743 goto error_return;
2744
2745 /* That will change things, so, we should relax again.
2746 Note that this is not required, and it may be slow. */
2747 *again = TRUE;
2748 }
2749 }
2750 }
1a0670f3 2751 /* Fall through. */
4cdc7696 2752
07d6d2b8
AM		 2753 default:
2754 {
2755 unsigned char code_msb;
2756 unsigned char code_lsb;
2757 bfd_vma dot;
2758
2759 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2760 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
2761
2762 /* Get the address of this instruction. */
2763 dot = (sec->output_section->vma
2764 + sec->output_offset + irel->r_offset);
2765
2766 /* Here we look for rcall/ret or call/ret sequences that could be
2767 safely replaced by rjmp/ret or jmp/ret. */
2768 if (((code_msb & 0xf0) == 0xd0)
2769 && avr_replace_call_ret_sequences)
2770 {
2771 /* This insn is a rcall. */
2772 unsigned char next_insn_msb = 0;
2773 unsigned char next_insn_lsb = 0;
2774
2775 if (irel->r_offset + 3 < sec->size)
2776 {
2777 next_insn_msb =
91d6fa6a 2778 bfd_get_8 (abfd, contents + irel->r_offset + 3);
07d6d2b8 2779 next_insn_lsb =
91d6fa6a 2780 bfd_get_8 (abfd, contents + irel->r_offset + 2);
07d6d2b8 2781 }
4cdc7696
NC		 2782
2783 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
07d6d2b8
AM		 2784 {
2785 /* The next insn is a ret. We now convert the rcall insn
2786 into a rjmp instruction. */
2787 code_msb &= 0xef;
2788 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
2789 if (debug_relax)
2790 printf ("converted rcall/ret sequence at address 0x%x"
2791 " into rjmp/ret sequence. Section is %s\n\n",
2792 (int) dot, sec->name);
2793 *again = TRUE;
2794 break;
2795 }
2796 }
2797 else if ((0x94 == (code_msb & 0xfe))
28c9d252
NC		 2798 && (0x0e == (code_lsb & 0x0e))
2799 && avr_replace_call_ret_sequences)
07d6d2b8
AM		 2800 {
2801 /* This insn is a call. */
2802 unsigned char next_insn_msb = 0;
2803 unsigned char next_insn_lsb = 0;
2804
2805 if (irel->r_offset + 5 < sec->size)
2806 {
2807 next_insn_msb =
91d6fa6a 2808 bfd_get_8 (abfd, contents + irel->r_offset + 5);
07d6d2b8 2809 next_insn_lsb =
91d6fa6a 2810 bfd_get_8 (abfd, contents + irel->r_offset + 4);
07d6d2b8
AM		 2811 }
2812
2813 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2814 {
2815 /* The next insn is a ret. We now convert the call insn
2816 into a jmp instruction. */
2817
2818 code_lsb &= 0xfd;
2819 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2820 if (debug_relax)
2821 printf ("converted call/ret sequence at address 0x%x"
2822 " into jmp/ret sequence. Section is %s\n\n",
2823 (int) dot, sec->name);
2824 *again = TRUE;
2825 break;
2826 }
2827 }
2828 else if ((0xc0 == (code_msb & 0xf0))
2829 || ((0x94 == (code_msb & 0xfe))
2830 && (0x0c == (code_lsb & 0x0e))))
2831 {
2832 /* This insn is a rjmp or a jmp. */
2833 unsigned char next_insn_msb = 0;
2834 unsigned char next_insn_lsb = 0;
2835 int insn_size;
2836
2837 if (0xc0 == (code_msb & 0xf0))
2838 insn_size = 2; /* rjmp insn */
2839 else
2840 insn_size = 4; /* jmp insn */
2841
2842 if (irel->r_offset + insn_size + 1 < sec->size)
2843 {
2844 next_insn_msb =
91d6fa6a
NC		 2845 bfd_get_8 (abfd, contents + irel->r_offset
2846 + insn_size + 1);
07d6d2b8 2847 next_insn_lsb =
91d6fa6a
NC		 2848 bfd_get_8 (abfd, contents + irel->r_offset
2849 + insn_size);
07d6d2b8 2850 }
cc643b88 2851
07d6d2b8
AM		 2852 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2853 {
2854 /* The next insn is a ret. We possibly could delete
2855 this ret. First we need to check for preceding
2856 sbis/sbic/sbrs or cpse "skip" instructions. */
2857
2858 int there_is_preceding_non_skip_insn = 1;
2859 bfd_vma address_of_ret;
2860
2861 address_of_ret = dot + insn_size;
2862
2863 if (debug_relax && (insn_size == 2))
2864 printf ("found rjmp / ret sequence at address 0x%x\n",
2865 (int) dot);
2866 if (debug_relax && (insn_size == 4))
2867 printf ("found jmp / ret sequence at address 0x%x\n",
2868 (int) dot);
2869
2870 /* We have to make sure that there is a preceding insn. */
2871 if (irel->r_offset >= 2)
2872 {
2873 unsigned char preceding_msb;
2874 unsigned char preceding_lsb;
2875
2876 preceding_msb =
91d6fa6a 2877 bfd_get_8 (abfd, contents + irel->r_offset - 1);
07d6d2b8 2878 preceding_lsb =
91d6fa6a 2879 bfd_get_8 (abfd, contents + irel->r_offset - 2);
df406460 2880
07d6d2b8
AM		 2881 /* sbic. */
2882 if (0x99 == preceding_msb)
2883 there_is_preceding_non_skip_insn = 0;
df406460 2884
07d6d2b8
AM		 2885 /* sbis. */
2886 if (0x9b == preceding_msb)
2887 there_is_preceding_non_skip_insn = 0;
df406460 2888
07d6d2b8
AM		 2889 /* sbrc */
2890 if ((0xfc == (preceding_msb & 0xfe)
cc643b88 2891 && (0x00 == (preceding_lsb & 0x08))))
07d6d2b8 2892 there_is_preceding_non_skip_insn = 0;
df406460 2893
07d6d2b8
AM		 2894 /* sbrs */
2895 if ((0xfe == (preceding_msb & 0xfe)
cc643b88 2896 && (0x00 == (preceding_lsb & 0x08))))
07d6d2b8
AM		 2897 there_is_preceding_non_skip_insn = 0;
2898
2899 /* cpse */
2900 if (0x10 == (preceding_msb & 0xfc))
2901 there_is_preceding_non_skip_insn = 0;
2902
2903 if (there_is_preceding_non_skip_insn == 0)
2904 if (debug_relax)
2905 printf ("preceding skip insn prevents deletion of"
2906 " ret insn at Addy 0x%x in section %s\n",
2907 (int) dot + 2, sec->name);
2908 }
2909 else
2910 {
2911 /* There is no previous instruction. */
2912 there_is_preceding_non_skip_insn = 0;
2913 }
2914
2915 if (there_is_preceding_non_skip_insn)
2916 {
2917 /* We now only have to make sure that there is no
2918 local label defined at the address of the ret
2919 instruction and that there is no local relocation
2920 in this section pointing to the ret. */
2921
2922 int deleting_ret_is_safe = 1;
2923 unsigned int section_offset_of_ret_insn =
91d6fa6a 2924 irel->r_offset + insn_size;
07d6d2b8
AM		 2925 Elf_Internal_Sym *isym, *isymend;
2926 unsigned int sec_shndx;
8d6a12ee 2927 struct bfd_section *isec;
4cdc7696 2928
07d6d2b8 2929 sec_shndx =
4cdc7696 2930 _bfd_elf_section_from_bfd_section (abfd, sec);
df406460 2931
07d6d2b8
AM		 2932 /* Check for local symbols. */
2933 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2934 isymend = isym + symtab_hdr->sh_info;
696b7ad2 2935 /* PR 6019: There may not be any local symbols. */
07d6d2b8 2936 for (; isym != NULL && isym < isymend; isym++)
91d6fa6a
NC		 2937 {
2938 if (isym->st_value == section_offset_of_ret_insn
2939 && isym->st_shndx == sec_shndx)
2940 {
2941 deleting_ret_is_safe = 0;
2942 if (debug_relax)
2943 printf ("local label prevents deletion of ret "
2944 "insn at address 0x%x\n",
2945 (int) dot + insn_size);
2946 }
2947 }
2948
2949 /* Now check for global symbols. */
2950 {
2951 int symcount;
2952 struct elf_link_hash_entry **sym_hashes;
2953 struct elf_link_hash_entry **end_hashes;
2954
2955 symcount = (symtab_hdr->sh_size
2956 / sizeof (Elf32_External_Sym)
2957 - symtab_hdr->sh_info);
2958 sym_hashes = elf_sym_hashes (abfd);
2959 end_hashes = sym_hashes + symcount;
2960 for (; sym_hashes < end_hashes; sym_hashes++)
2961 {
2962 struct elf_link_hash_entry *sym_hash =
2963 *sym_hashes;
2964 if ((sym_hash->root.type == bfd_link_hash_defined
2965 || sym_hash->root.type ==
4cdc7696 2966 bfd_link_hash_defweak)
91d6fa6a
NC		 2967 && sym_hash->root.u.def.section == sec
2968 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2969 {
2970 deleting_ret_is_safe = 0;
2971 if (debug_relax)
2972 printf ("global label prevents deletion of "
2973 "ret insn at address 0x%x\n",
2974 (int) dot + insn_size);
2975 }
2976 }
2977 }
91d6fa6a 2978
8d6a12ee
NC		 2979 /* Now we check for relocations pointing to ret. */
2980 for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next)
2981 {
2982 Elf_Internal_Rela *rel;
2983 Elf_Internal_Rela *relend;
f36e8886 2984
8d6a12ee
NC		 2985 rel = elf_section_data (isec)->relocs;
2986 if (rel == NULL)
2987 rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
91d6fa6a 2988
8d6a12ee 2989 relend = rel + isec->reloc_count;
91d6fa6a 2990
8d6a12ee
NC		 2991 for (; rel && rel < relend; rel++)
2992 {
2993 bfd_vma reloc_target = 0;
2994
2995 /* Read this BFD's local symbols if we haven't
2996 done so already. */
2997 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2998 {
2999 isymbuf = (Elf_Internal_Sym *)
3000 symtab_hdr->contents;
3001 if (isymbuf == NULL)
3002 isymbuf = bfd_elf_get_elf_syms
3003 (abfd,
3004 symtab_hdr,
3005 symtab_hdr->sh_info, 0,
3006 NULL, NULL, NULL);
3007 if (isymbuf == NULL)
3008 break;
3009 }
3010
3011 /* Get the value of the symbol referred to
3012 by the reloc. */
3013 if (ELF32_R_SYM (rel->r_info)
3014 < symtab_hdr->sh_info)
3015 {
3016 /* A local symbol. */
3017 asection *sym_sec;
3018
3019 isym = isymbuf
3020 + ELF32_R_SYM (rel->r_info);
3021 sym_sec = bfd_section_from_elf_index
3022 (abfd, isym->st_shndx);
3023 symval = isym->st_value;
3024
3025 /* If the reloc is absolute, it will not
3026 have a symbol or section associated
3027 with it. */
3028
3029 if (sym_sec)
3030 {
3031 symval +=
3032 sym_sec->output_section->vma
3033 + sym_sec->output_offset;
3034 reloc_target = symval + rel->r_addend;
3035 }
3036 else
3037 {
3038 reloc_target = symval + rel->r_addend;
3039 /* Reference symbol is absolute. */
3040 }
3041 }
3042 /* else ... reference symbol is extern. */
3043
3044 if (address_of_ret == reloc_target)
3045 {
3046 deleting_ret_is_safe = 0;
3047 if (debug_relax)
3048 printf ("ret from "
3049 "rjmp/jmp ret sequence at address"
3050 " 0x%x could not be deleted. ret"
3051 " is target of a relocation.\n",
3052 (int) address_of_ret);
91d6fa6a 3053 break;
8d6a12ee
NC		 3054 }
3055 }
3056 }
91d6fa6a
NC		 3057
3058 if (deleting_ret_is_safe)
3059 {
3060 if (debug_relax)
3061 printf ("unreachable ret instruction "
3062 "at address 0x%x deleted.\n",
3063 (int) dot + insn_size);
3064
3065 /* Delete two bytes of data. */
3066 if (!elf32_avr_relax_delete_bytes (abfd, sec,
bf186506
SKS		 3067 irel->r_offset + insn_size, 2,
3068 TRUE))
91d6fa6a
NC		 3069 goto error_return;
3070
3071 /* That will change things, so, we should relax
3072 again. Note that this is not required, and it
3073 may be slow. */
3074 *again = TRUE;
3075 break;
3076 }
07d6d2b8
AM		 3077 }
3078 }
3079 }
3080 break;
3081 }
3082 }
df406460
NC		 3083 }
3084
bac13f5a
AB		 3085 if (!*again)
3086 {
3087 /* Look through all the property records in this section to see if
07d6d2b8 3088 there's any alignment records that can be moved. */
bac13f5a
AB		 3089 struct avr_relax_info *relax_info;
3090
3091 relax_info = get_avr_relax_info (sec);
3092 if (relax_info->records.count > 0)
07d6d2b8
AM		 3093 {
3094 unsigned int i;
3095
3096 for (i = 0; i < relax_info->records.count; ++i)
3097 {
3098 switch (relax_info->records.items [i].type)
3099 {
3100 case RECORD_ORG:
3101 case RECORD_ORG_AND_FILL:
3102 break;
3103 case RECORD_ALIGN:
3104 case RECORD_ALIGN_AND_FILL:
3105 {
3106 struct avr_property_record *record;
3107 unsigned long bytes_to_align;
3108 int count = 0;
3109
3110 /* Look for alignment directives that have had enough
3111 bytes deleted before them, such that the directive
3112 can be moved backwards and still maintain the
3113 required alignment. */
3114 record = &relax_info->records.items [i];
3115 bytes_to_align
3116 = (unsigned long) (1 << record->data.align.bytes);
3117 while (record->data.align.preceding_deleted >=
3118 bytes_to_align)
3119 {
3120 record->data.align.preceding_deleted
3121 -= bytes_to_align;
3122 count += bytes_to_align;
3123 }
3124
3125 if (count > 0)
3126 {
3127 bfd_vma addr = record->offset;
3128
3129 /* We can delete COUNT bytes and this alignment
3130 directive will still be correctly aligned.
3131 First move the alignment directive, then delete
3132 the bytes. */
3133 record->offset -= count;
3134 elf32_avr_relax_delete_bytes (abfd, sec,
3135 addr - count,
3136 count, FALSE);
3137 *again = TRUE;
3138 }
3139 }
3140 break;
3141 }
3142 }
3143 }
bac13f5a
AB		 3144 }
3145
df406460
NC		 3146 if (contents != NULL
3147 && elf_section_data (sec)->this_hdr.contents != contents)
3148 {
3149 if (! link_info->keep_memory)
07d6d2b8 3150 free (contents);
df406460 3151 else
07d6d2b8
AM		 3152 {
3153 /* Cache the section contents for elf_link_input_bfd. */
3154 elf_section_data (sec)->this_hdr.contents = contents;
3155 }
df406460
NC		 3156 }
3157
3158 if (internal_relocs != NULL
3159 && elf_section_data (sec)->relocs != internal_relocs)
3160 free (internal_relocs);
3161
3162 return TRUE;
3163
3164 error_return:
3165 if (isymbuf != NULL
3166 && symtab_hdr->contents != (unsigned char *) isymbuf)
3167 free (isymbuf);
3168 if (contents != NULL
3169 && elf_section_data (sec)->this_hdr.contents != contents)
3170 free (contents);
3171 if (internal_relocs != NULL
3172 && elf_section_data (sec)->relocs != internal_relocs)
3173 free (internal_relocs);
3174
4cdc7696 3175 return FALSE;
df406460
NC		 3176}
3177
3178/* This is a version of bfd_generic_get_relocated_section_contents
4cdc7696 3179 which uses elf32_avr_relocate_section.
df406460 3180
4cdc7696 3181 For avr it's essentially a cut and paste taken from the H8300 port.
df406460 3182 The author of the relaxation support patch for avr had absolutely no
4cdc7696 3183 clue what is happening here but found out that this part of the code
df406460
NC		 3184 seems to be important. */
3185
3186static bfd_byte *
3187elf32_avr_get_relocated_section_contents (bfd *output_bfd,
07d6d2b8
AM		 3188 struct bfd_link_info *link_info,
3189 struct bfd_link_order *link_order,
3190 bfd_byte *data,
3191 bfd_boolean relocatable,
3192 asymbol **symbols)
df406460
NC		 3193{
3194 Elf_Internal_Shdr *symtab_hdr;
3195 asection *input_section = link_order->u.indirect.section;
3196 bfd *input_bfd = input_section->owner;
3197 asection **sections = NULL;
3198 Elf_Internal_Rela *internal_relocs = NULL;
3199 Elf_Internal_Sym *isymbuf = NULL;
3200
3201 /* We only need to handle the case of relaxing, or of having a
3202 particular set of section contents, specially. */
3203 if (relocatable
3204 || elf_section_data (input_section)->this_hdr.contents == NULL)
3205 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
07d6d2b8
AM		 3206 link_order, data,
3207 relocatable,
3208 symbols);
df406460
NC		 3209 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3210
3211 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
07d6d2b8 3212 (size_t) input_section->size);
df406460
NC		 3213
3214 if ((input_section->flags & SEC_RELOC) != 0
3215 && input_section->reloc_count > 0)
3216 {
3217 asection **secpp;
3218 Elf_Internal_Sym *isym, *isymend;
3219 bfd_size_type amt;
3220
3221 internal_relocs = (_bfd_elf_link_read_relocs
07d6d2b8 3222 (input_bfd, input_section, NULL, NULL, FALSE));
df406460 3223 if (internal_relocs == NULL)
07d6d2b8 3224 goto error_return;
df406460
NC		 3225
3226 if (symtab_hdr->sh_info != 0)
07d6d2b8
AM		 3227 {
3228 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3229 if (isymbuf == NULL)
3230 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3231 symtab_hdr->sh_info, 0,
3232 NULL, NULL, NULL);
3233 if (isymbuf == NULL)
3234 goto error_return;
3235 }
df406460
NC		 3236
3237 amt = symtab_hdr->sh_info;
3238 amt *= sizeof (asection *);
4cdc7696 3239 sections = bfd_malloc (amt);
df406460 3240 if (sections == NULL && amt != 0)
07d6d2b8 3241 goto error_return;
df406460
NC		 3242
3243 isymend = isymbuf + symtab_hdr->sh_info;
3244 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
07d6d2b8
AM		 3245 {
3246 asection *isec;
3247
3248 if (isym->st_shndx == SHN_UNDEF)
3249 isec = bfd_und_section_ptr;
3250 else if (isym->st_shndx == SHN_ABS)
3251 isec = bfd_abs_section_ptr;
3252 else if (isym->st_shndx == SHN_COMMON)
3253 isec = bfd_com_section_ptr;
3254 else
3255 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3256
3257 *secpp = isec;
3258 }
df406460
NC		 3259
3260 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
07d6d2b8
AM		 3261 input_section, data, internal_relocs,
3262 isymbuf, sections))
3263 goto error_return;
df406460
NC		 3264
3265 if (sections != NULL)
07d6d2b8 3266 free (sections);
df406460 3267 if (isymbuf != NULL
07d6d2b8
AM		 3268 && symtab_hdr->contents != (unsigned char *) isymbuf)
3269 free (isymbuf);
df406460 3270 if (elf_section_data (input_section)->relocs != internal_relocs)
07d6d2b8 3271 free (internal_relocs);
df406460
NC		 3272 }
3273
3274 return data;
3275
3276 error_return:
3277 if (sections != NULL)
3278 free (sections);
3279 if (isymbuf != NULL
3280 && symtab_hdr->contents != (unsigned char *) isymbuf)
3281 free (isymbuf);
3282 if (internal_relocs != NULL
3283 && elf_section_data (input_section)->relocs != internal_relocs)
3284 free (internal_relocs);
3285 return NULL;
3286}
3287
3288
28c9d252
NC		 3289/* Determines the hash entry name for a particular reloc. It consists of
3290 the identifier of the symbol section and the added reloc addend and
3291 symbol offset relative to the section the symbol is attached to. */
3292
3293static char *
3294avr_stub_name (const asection *symbol_section,
07d6d2b8
AM		 3295 const bfd_vma symbol_offset,
3296 const Elf_Internal_Rela *rela)
28c9d252
NC		 3297{
3298 char *stub_name;
3299 bfd_size_type len;
3300
3301 len = 8 + 1 + 8 + 1 + 1;
3302 stub_name = bfd_malloc (len);
4a9f7d65
NC		 3303 if (stub_name != NULL)
3304 sprintf (stub_name, "%08x+%08x",
3305 symbol_section->id & 0xffffffff,
3306 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
28c9d252
NC		 3307
3308 return stub_name;
3309}
3310
3311
3312/* Add a new stub entry to the stub hash. Not all fields of the new
3313 stub entry are initialised. */
3314
3315static struct elf32_avr_stub_hash_entry *
3316avr_add_stub (const char *stub_name,
07d6d2b8 3317 struct elf32_avr_link_hash_table *htab)
28c9d252
NC		 3318{
3319 struct elf32_avr_stub_hash_entry *hsh;
3320
3321 /* Enter this entry into the linker stub hash table. */
3322 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
3323
3324 if (hsh == NULL)
3325 {
695344c0 3326 /* xgettext:c-format */
10463f39 3327 _bfd_error_handler (_("cannot create stub entry %s"), stub_name);
28c9d252
NC		 3328 return NULL;
3329 }
3330
3331 hsh->stub_offset = 0;
3332 return hsh;
3333}
3334
3335/* We assume that there is already space allocated for the stub section
3336 contents and that before building the stubs the section size is
3337 initialized to 0. We assume that within the stub hash table entry,
3338 the absolute position of the jmp target has been written in the
3339 target_value field. We write here the offset of the generated jmp insn
3340 relative to the trampoline section start to the stub_offset entry in
3341 the stub hash table entry. */
3342
3343static bfd_boolean
3344avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
3345{
3346 struct elf32_avr_stub_hash_entry *hsh;
3347 struct bfd_link_info *info;
3348 struct elf32_avr_link_hash_table *htab;
3349 bfd *stub_bfd;
3350 bfd_byte *loc;
3351 bfd_vma target;
3352 bfd_vma starget;
3353
3354 /* Basic opcode */
3355 bfd_vma jmp_insn = 0x0000940c;
3356
3357 /* Massage our args to the form they really have. */
3358 hsh = avr_stub_hash_entry (bh);
3359
3360 if (!hsh->is_actually_needed)
3361 return TRUE;
3362
3363 info = (struct bfd_link_info *) in_arg;
3364
3365 htab = avr_link_hash_table (info);
64ee10b6
NC		 3366 if (htab == NULL)
3367 return FALSE;
28c9d252
NC		 3368
3369 target = hsh->target_value;
3370
3371 /* Make a note of the offset within the stubs for this entry. */
3372 hsh->stub_offset = htab->stub_sec->size;
3373 loc = htab->stub_sec->contents + hsh->stub_offset;
3374
3375 stub_bfd = htab->stub_sec->owner;
3376
3377 if (debug_stubs)
3378 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
07d6d2b8
AM		 3379 (unsigned int) target,
3380 (unsigned int) hsh->stub_offset);
28c9d252
NC		 3381
3382 /* We now have to add the information on the jump target to the bare
3383 opcode bits already set in jmp_insn. */
3384
3385 /* Check for the alignment of the address. */
3386 if (target & 1)
3387 return FALSE;
3388
3389 starget = target >> 1;
3390 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
3391 bfd_put_16 (stub_bfd, jmp_insn, loc);
3392 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
3393
3394 htab->stub_sec->size += 4;
3395
3396 /* Now add the entries in the address mapping table if there is still
3397 space left. */
3398 {
3399 unsigned int nr;
3400
3401 nr = htab->amt_entry_cnt + 1;
3402 if (nr <= htab->amt_max_entry_cnt)
3403 {
07d6d2b8 3404 htab->amt_entry_cnt = nr;
28c9d252 3405
07d6d2b8
AM		 3406 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
3407 htab->amt_destination_addr[nr - 1] = target;
28c9d252
NC		 3408 }
3409 }
3410
3411 return TRUE;
3412}
3413
3414static bfd_boolean
3415avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
07d6d2b8 3416 void *in_arg ATTRIBUTE_UNUSED)
28c9d252
NC		 3417{
3418 struct elf32_avr_stub_hash_entry *hsh;
28c9d252 3419
28c9d252
NC		 3420 hsh = avr_stub_hash_entry (bh);
3421 hsh->is_actually_needed = FALSE;
3422
3423 return TRUE;
3424}
3425
3426static bfd_boolean
3427avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
3428{
3429 struct elf32_avr_stub_hash_entry *hsh;
3430 struct elf32_avr_link_hash_table *htab;
3431 int size;
3432
3433 /* Massage our args to the form they really have. */
3434 hsh = avr_stub_hash_entry (bh);
3435 htab = in_arg;
3436
3437 if (hsh->is_actually_needed)
3438 size = 4;
3439 else
3440 size = 0;
3441
3442 htab->stub_sec->size += size;
3443 return TRUE;
3444}
3445
3446void
3447elf32_avr_setup_params (struct bfd_link_info *info,
07d6d2b8
AM		 3448 bfd *avr_stub_bfd,
3449 asection *avr_stub_section,
3450 bfd_boolean no_stubs,
3451 bfd_boolean deb_stubs,
3452 bfd_boolean deb_relax,
3453 bfd_vma pc_wrap_around,
3454 bfd_boolean call_ret_replacement)
28c9d252 3455{
64ee10b6 3456 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
28c9d252 3457
64ee10b6
NC		 3458 if (htab == NULL)
3459 return;
28c9d252
NC		 3460 htab->stub_sec = avr_stub_section;
3461 htab->stub_bfd = avr_stub_bfd;
3462 htab->no_stubs = no_stubs;
3463
3464 debug_relax = deb_relax;
3465 debug_stubs = deb_stubs;
3466 avr_pc_wrap_around = pc_wrap_around;
3467 avr_replace_call_ret_sequences = call_ret_replacement;
3468}
3469
3470
3471/* Set up various things so that we can make a list of input sections
3472 for each output section included in the link. Returns -1 on error,
3473 0 when no stubs will be needed, and 1 on success. It also sets
3474 information on the stubs bfd and the stub section in the info
3475 struct. */
3476
3477int
3478elf32_avr_setup_section_lists (bfd *output_bfd,
07d6d2b8 3479 struct bfd_link_info *info)
28c9d252
NC		 3480{
3481 bfd *input_bfd;
3482 unsigned int bfd_count;
7292b3ac 3483 unsigned int top_id, top_index;
28c9d252
NC		 3484 asection *section;
3485 asection **input_list, **list;
3486 bfd_size_type amt;
4dfe6ac6 3487 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
28c9d252 3488
64ee10b6 3489 if (htab == NULL || htab->no_stubs)
28c9d252
NC		 3490 return 0;
3491
3492 /* Count the number of input BFDs and find the top input section id. */
3493 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3494 input_bfd != NULL;
c72f2fb2 3495 input_bfd = input_bfd->link.next)
28c9d252
NC		 3496 {
3497 bfd_count += 1;
3498 for (section = input_bfd->sections;
07d6d2b8
AM		 3499 section != NULL;
3500 section = section->next)
28c9d252
NC		 3501 if (top_id < section->id)
3502 top_id = section->id;
3503 }
3504
3505 htab->bfd_count = bfd_count;
3506
3507 /* We can't use output_bfd->section_count here to find the top output
3508 section index as some sections may have been removed, and
3509 strip_excluded_output_sections doesn't renumber the indices. */
3510 for (section = output_bfd->sections, top_index = 0;
3511 section != NULL;
3512 section = section->next)
3513 if (top_index < section->index)
3514 top_index = section->index;
3515
3516 htab->top_index = top_index;
3517 amt = sizeof (asection *) * (top_index + 1);
3518 input_list = bfd_malloc (amt);
3519 htab->input_list = input_list;
3520 if (input_list == NULL)
3521 return -1;
3522
3523 /* For sections we aren't interested in, mark their entries with a
3524 value we can check later. */
3525 list = input_list + top_index;
3526 do
3527 *list = bfd_abs_section_ptr;
3528 while (list-- != input_list);
3529
3530 for (section = output_bfd->sections;
3531 section != NULL;
3532 section = section->next)
3533 if ((section->flags & SEC_CODE) != 0)
3534 input_list[section->index] = NULL;
3535
3536 return 1;
3537}
3538
3539
3540/* Read in all local syms for all input bfds, and create hash entries
3541 for export stubs if we are building a multi-subspace shared lib.
3542 Returns -1 on error, 0 otherwise. */
3543
3544static int
3545get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
3546{
3547 unsigned int bfd_indx;
3548 Elf_Internal_Sym *local_syms, **all_local_syms;
3549 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
9a008db3 3550 bfd_size_type amt;
28c9d252 3551
64ee10b6
NC		 3552 if (htab == NULL)
3553 return -1;
3554
28c9d252
NC		 3555 /* We want to read in symbol extension records only once. To do this
3556 we need to read in the local symbols in parallel and save them for
3557 later use; so hold pointers to the local symbols in an array. */
9a008db3 3558 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
28c9d252
NC		 3559 all_local_syms = bfd_zmalloc (amt);
3560 htab->all_local_syms = all_local_syms;
3561 if (all_local_syms == NULL)
3562 return -1;
3563
3564 /* Walk over all the input BFDs, swapping in local symbols.
3565 If we are creating a shared library, create hash entries for the
3566 export stubs. */
3567 for (bfd_indx = 0;
3568 input_bfd != NULL;
c72f2fb2 3569 input_bfd = input_bfd->link.next, bfd_indx++)
28c9d252
NC		 3570 {
3571 Elf_Internal_Shdr *symtab_hdr;
3572
3573 /* We'll need the symbol table in a second. */
3574 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3575 if (symtab_hdr->sh_info == 0)
3576 continue;
3577
3578 /* We need an array of the local symbols attached to the input bfd. */
3579 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3580 if (local_syms == NULL)
3581 {
3582 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3583 symtab_hdr->sh_info, 0,
3584 NULL, NULL, NULL);
3585 /* Cache them for elf_link_input_bfd. */
3586 symtab_hdr->contents = (unsigned char *) local_syms;
3587 }
3588 if (local_syms == NULL)
3589 return -1;
3590
3591 all_local_syms[bfd_indx] = local_syms;
3592 }
3593
3594 return 0;
3595}
3596
3597#define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
3598
3599bfd_boolean
3600elf32_avr_size_stubs (bfd *output_bfd,
07d6d2b8
AM		 3601 struct bfd_link_info *info,
3602 bfd_boolean is_prealloc_run)
28c9d252 3603{
64ee10b6
NC		 3604 struct elf32_avr_link_hash_table *htab;
3605 int stub_changed = 0;
28c9d252 3606
64ee10b6
NC		 3607 htab = avr_link_hash_table (info);
3608 if (htab == NULL)
3609 return FALSE;
28c9d252 3610
64ee10b6
NC		 3611 /* At this point we initialize htab->vector_base
3612 To the start of the text output section. */
3613 htab->vector_base = htab->stub_sec->output_section->vma;
28c9d252 3614
64ee10b6
NC		 3615 if (get_local_syms (info->input_bfds, info))
3616 {
3617 if (htab->all_local_syms)
3618 goto error_ret_free_local;
3619 return FALSE;
3620 }
28c9d252
NC		 3621
3622 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
3623 {
3624 struct elf32_avr_stub_hash_entry *test;
3625
3626 test = avr_add_stub ("Hugo",htab);
3627 test->target_value = 0x123456;
3628 test->stub_offset = 13;
3629
3630 test = avr_add_stub ("Hugo2",htab);
3631 test->target_value = 0x84210;
3632 test->stub_offset = 14;
3633 }
3634
3635 while (1)
3636 {
3637 bfd *input_bfd;
3638 unsigned int bfd_indx;
3639
3640 /* We will have to re-generate the stub hash table each time anything
07d6d2b8 3641 in memory has changed. */
28c9d252
NC		 3642
3643 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
3644 for (input_bfd = info->input_bfds, bfd_indx = 0;
07d6d2b8
AM		 3645 input_bfd != NULL;
3646 input_bfd = input_bfd->link.next, bfd_indx++)
3647 {
3648 Elf_Internal_Shdr *symtab_hdr;
3649 asection *section;
3650 Elf_Internal_Sym *local_syms;
3651
3652 /* We'll need the symbol table in a second. */
3653 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3654 if (symtab_hdr->sh_info == 0)
3655 continue;
3656
3657 local_syms = htab->all_local_syms[bfd_indx];
3658
3659 /* Walk over each section attached to the input bfd. */
3660 for (section = input_bfd->sections;
3661 section != NULL;
3662 section = section->next)
3663 {
3664 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3665
3666 /* If there aren't any relocs, then there's nothing more
3667 to do. */
3668 if ((section->flags & SEC_RELOC) == 0
3669 || section->reloc_count == 0)
3670 continue;
3671
3672 /* If this section is a link-once section that will be
3673 discarded, then don't create any stubs. */
3674 if (section->output_section == NULL
3675 || section->output_section->owner != output_bfd)
3676 continue;
3677
3678 /* Get the relocs. */
3679 internal_relocs
3680 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3681 info->keep_memory);
3682 if (internal_relocs == NULL)
3683 goto error_ret_free_local;
3684
3685 /* Now examine each relocation. */
3686 irela = internal_relocs;
3687 irelaend = irela + section->reloc_count;
3688 for (; irela < irelaend; irela++)
3689 {
3690 unsigned int r_type, r_indx;
3691 struct elf32_avr_stub_hash_entry *hsh;
3692 asection *sym_sec;
3693 bfd_vma sym_value;
3694 bfd_vma destination;
3695 struct elf_link_hash_entry *hh;
3696 char *stub_name;
3697
3698 r_type = ELF32_R_TYPE (irela->r_info);
3699 r_indx = ELF32_R_SYM (irela->r_info);
3700
3701 /* Only look for 16 bit GS relocs. No other reloc will need a
3702 stub. */
3703 if (!((r_type == R_AVR_16_PM)
3704 || (r_type == R_AVR_LO8_LDI_GS)
3705 || (r_type == R_AVR_HI8_LDI_GS)))
3706 continue;
3707
3708 /* Now determine the call target, its name, value,
3709 section. */
3710 sym_sec = NULL;
3711 sym_value = 0;
3712 destination = 0;
3713 hh = NULL;
3714 if (r_indx < symtab_hdr->sh_info)
3715 {
3716 /* It's a local symbol. */
3717 Elf_Internal_Sym *sym;
3718 Elf_Internal_Shdr *hdr;
4fbb74a6 3719 unsigned int shndx;
28c9d252 3720
07d6d2b8
AM		 3721 sym = local_syms + r_indx;
3722 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3723 sym_value = sym->st_value;
4fbb74a6
AM		 3724 shndx = sym->st_shndx;
3725 if (shndx < elf_numsections (input_bfd))
3726 {
3727 hdr = elf_elfsections (input_bfd)[shndx];
3728 sym_sec = hdr->bfd_section;
3729 destination = (sym_value + irela->r_addend
3730 + sym_sec->output_offset
3731 + sym_sec->output_section->vma);
3732 }
07d6d2b8
AM		 3733 }
3734 else
3735 {
3736 /* It's an external symbol. */
3737 int e_indx;
3738
3739 e_indx = r_indx - symtab_hdr->sh_info;
3740 hh = elf_sym_hashes (input_bfd)[e_indx];
3741
3742 while (hh->root.type == bfd_link_hash_indirect
3743 || hh->root.type == bfd_link_hash_warning)
3744 hh = (struct elf_link_hash_entry *)
3745 (hh->root.u.i.link);
3746
3747 if (hh->root.type == bfd_link_hash_defined
3748 || hh->root.type == bfd_link_hash_defweak)
3749 {
3750 sym_sec = hh->root.u.def.section;
3751 sym_value = hh->root.u.def.value;
3752 if (sym_sec->output_section != NULL)
3753 destination = (sym_value + irela->r_addend
3754 + sym_sec->output_offset
3755 + sym_sec->output_section->vma);
3756 }
3757 else if (hh->root.type == bfd_link_hash_undefweak)
3758 {
3759 if (! bfd_link_pic (info))
3760 continue;
3761 }
3762 else if (hh->root.type == bfd_link_hash_undefined)
3763 {
3764 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3765 && (ELF_ST_VISIBILITY (hh->other)
3766 == STV_DEFAULT)))
3767 continue;
3768 }
3769 else
3770 {
3771 bfd_set_error (bfd_error_bad_value);
3772
3773 error_ret_free_internal:
3774 if (elf_section_data (section)->relocs == NULL)
3775 free (internal_relocs);
3776 goto error_ret_free_local;
3777 }
3778 }
3779
3780 if (! avr_stub_is_required_for_16_bit_reloc
28c9d252 3781 (destination - htab->vector_base))
07d6d2b8
AM		 3782 {
3783 if (!is_prealloc_run)
28c9d252
NC		 3784 /* We are having a reloc that does't need a stub. */
3785 continue;
3786
3787 /* We don't right now know if a stub will be needed.
3788 Let's rather be on the safe side. */
07d6d2b8
AM		 3789 }
3790
3791 /* Get the name of this stub. */
3792 stub_name = avr_stub_name (sym_sec, sym_value, irela);
3793
3794 if (!stub_name)
3795 goto error_ret_free_internal;
3796
3797
3798 hsh = avr_stub_hash_lookup (&htab->bstab,
3799 stub_name,
3800 FALSE, FALSE);
3801 if (hsh != NULL)
3802 {
3803 /* The proper stub has already been created. Mark it
3804 to be used and write the possibly changed destination
3805 value. */
3806 hsh->is_actually_needed = TRUE;
3807 hsh->target_value = destination;
3808 free (stub_name);
3809 continue;
3810 }
3811
3812 hsh = avr_add_stub (stub_name, htab);
3813 if (hsh == NULL)
3814 {
3815 free (stub_name);
3816 goto error_ret_free_internal;
3817 }
3818
3819 hsh->is_actually_needed = TRUE;
3820 hsh->target_value = destination;
3821
3822 if (debug_stubs)
3823 printf ("Adding stub with destination 0x%x to the"
3824 " hash table.\n", (unsigned int) destination);
3825 if (debug_stubs)
3826 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
3827
3828 stub_changed = TRUE;
3829 }
3830
3831 /* We're done with the internal relocs, free them. */
3832 if (elf_section_data (section)->relocs == NULL)
3833 free (internal_relocs);
3834 }
3835 }
28c9d252
NC		 3836
3837 /* Re-Calculate the number of needed stubs. */
3838 htab->stub_sec->size = 0;
3839 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
3840
3841 if (!stub_changed)
07d6d2b8 3842 break;
28c9d252
NC		 3843
3844 stub_changed = FALSE;
3845 }
3846
3847 free (htab->all_local_syms);
3848 return TRUE;
3849
3850 error_ret_free_local:
3851 free (htab->all_local_syms);
3852 return FALSE;
3853}
3854
3855
3856/* Build all the stubs associated with the current output file. The
3857 stubs are kept in a hash table attached to the main linker hash
3858 table. We also set up the .plt entries for statically linked PIC
3859 functions here. This function is called via hppaelf_finish in the
3860 linker. */
3861
3862bfd_boolean
3863elf32_avr_build_stubs (struct bfd_link_info *info)
3864{
3865 asection *stub_sec;
3866 struct bfd_hash_table *table;
3867 struct elf32_avr_link_hash_table *htab;
3868 bfd_size_type total_size = 0;
3869
3870 htab = avr_link_hash_table (info);
64ee10b6
NC		 3871 if (htab == NULL)
3872 return FALSE;
28c9d252
NC		 3873
3874 /* In case that there were several stub sections: */
3875 for (stub_sec = htab->stub_bfd->sections;
3876 stub_sec != NULL;
3877 stub_sec = stub_sec->next)
3878 {
3879 bfd_size_type size;
3880
3881 /* Allocate memory to hold the linker stubs. */
3882 size = stub_sec->size;
3883 total_size += size;
3884
3885 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3886 if (stub_sec->contents == NULL && size != 0)
3887 return FALSE;
3888 stub_sec->size = 0;
3889 }
3890
3891 /* Allocate memory for the adress mapping table. */
3892 htab->amt_entry_cnt = 0;
3893 htab->amt_max_entry_cnt = total_size / 4;
3894 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
07d6d2b8 3895 * htab->amt_max_entry_cnt);
28c9d252
NC		 3896 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3897 * htab->amt_max_entry_cnt );
3898
3899 if (debug_stubs)
3900 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3901
3902 /* Build the stubs as directed by the stub hash table. */
3903 table = &htab->bstab;
3904 bfd_hash_traverse (table, avr_build_one_stub, info);
3905
3906 if (debug_stubs)
3907 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3908
3909 return TRUE;
3910}
3911
137c83d6
AB		 3912/* Callback used by QSORT to order relocations AP and BP. */
3913
3914static int
3915internal_reloc_compare (const void *ap, const void *bp)
3916{
3917 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
3918 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
3919
3920 if (a->r_offset != b->r_offset)
3921 return (a->r_offset - b->r_offset);
3922
3923 /* We don't need to sort on these criteria for correctness,
3924 but enforcing a more strict ordering prevents unstable qsort
3925 from behaving differently with different implementations.
3926 Without the code below we get correct but different results
3927 on Solaris 2.7 and 2.8. We would like to always produce the
3928 same results no matter the host. */
3929
3930 if (a->r_info != b->r_info)
3931 return (a->r_info - b->r_info);
3932
3933 return (a->r_addend - b->r_addend);
3934}
3935
3936/* Return true if ADDRESS is within the vma range of SECTION from ABFD. */
3937
3938static bfd_boolean
3939avr_is_section_for_address (bfd *abfd, asection *section, bfd_vma address)
3940{
3941 bfd_vma vma;
3942 bfd_size_type size;
3943
3944 vma = bfd_get_section_vma (abfd, section);
3945 if (address < vma)
3946 return FALSE;
3947
3948 size = section->size;
3949 if (address >= vma + size)
3950 return FALSE;
3951
3952 return TRUE;
3953}
3954
3955/* Data structure used by AVR_FIND_SECTION_FOR_ADDRESS. */
3956
3957struct avr_find_section_data
3958{
3959 /* The address we're looking for. */
3960 bfd_vma address;
3961
3962 /* The section we've found. */
3963 asection *section;
3964};
3965
3966/* Helper function to locate the section holding a certain virtual memory
3967 address. This is called via bfd_map_over_sections. The DATA is an
3968 instance of STRUCT AVR_FIND_SECTION_DATA, the address field of which
3969 has been set to the address to search for, and the section field has
3970 been set to NULL. If SECTION from ABFD contains ADDRESS then the
3971 section field in DATA will be set to SECTION. As an optimisation, if
3972 the section field is already non-null then this function does not
3973 perform any checks, and just returns. */
3974
3975static void
3976avr_find_section_for_address (bfd *abfd,
07d6d2b8 3977 asection *section, void *data)
137c83d6
AB		 3978{
3979 struct avr_find_section_data *fs_data
3980 = (struct avr_find_section_data *) data;
3981
3982 /* Return if already found. */
3983 if (fs_data->section != NULL)
3984 return;
3985
3986 /* If this section isn't part of the addressable code content, skip it. */
3987 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0
3988 && (bfd_get_section_flags (abfd, section) & SEC_CODE) == 0)
3989 return;
3990
3991 if (avr_is_section_for_address (abfd, section, fs_data->address))
3992 fs_data->section = section;
3993}
3994
3995/* Load all of the property records from SEC, a section from ABFD. Return
3996 a STRUCT AVR_PROPERTY_RECORD_LIST containing all the records. The
3997 memory for the returned structure, and all of the records pointed too by
3998 the structure are allocated with a single call to malloc, so, only the
3999 pointer returned needs to be free'd. */
4000
4001static struct avr_property_record_list *
4002avr_elf32_load_records_from_section (bfd *abfd, asection *sec)
4003{
4004 char *contents = NULL, *ptr;
4005 bfd_size_type size, mem_size;
4006 bfd_byte version, flags;
4007 uint16_t record_count, i;
4008 struct avr_property_record_list *r_list = NULL;
4009 Elf_Internal_Rela *internal_relocs = NULL, *rel, *rel_end;
4010 struct avr_find_section_data fs_data;
4011
4012 fs_data.section = NULL;
4013
4014 size = bfd_get_section_size (sec);
4015 contents = bfd_malloc (size);
4016 bfd_get_section_contents (abfd, sec, contents, 0, size);
4017 ptr = contents;
4018
4019 /* Load the relocations for the '.avr.prop' section if there are any, and
4020 sort them. */
4021 internal_relocs = (_bfd_elf_link_read_relocs
07d6d2b8 4022 (abfd, sec, NULL, NULL, FALSE));
137c83d6
AB		 4023 if (internal_relocs)
4024 qsort (internal_relocs, sec->reloc_count,
07d6d2b8 4025 sizeof (Elf_Internal_Rela), internal_reloc_compare);
137c83d6
AB		 4026
4027 /* There is a header at the start of the property record section SEC, the
4028 format of this header is:
4029 uint8_t : version number
4030 uint8_t : flags
4031 uint16_t : record counter
4032 */
4033
4034 /* Check we have at least got a headers worth of bytes. */
4035 if (size < AVR_PROPERTY_SECTION_HEADER_SIZE)
4036 goto load_failed;
4037
4038 version = *((bfd_byte *) ptr);
4039 ptr++;
4040 flags = *((bfd_byte *) ptr);
4041 ptr++;
4042 record_count = *((uint16_t *) ptr);
4043 ptr+=2;
4044 BFD_ASSERT (ptr - contents == AVR_PROPERTY_SECTION_HEADER_SIZE);
4045
4046 /* Now allocate space for the list structure, and all of the list
4047 elements in a single block. */
4048 mem_size = sizeof (struct avr_property_record_list)
4049 + sizeof (struct avr_property_record) * record_count;
4050 r_list = bfd_malloc (mem_size);
4051 if (r_list == NULL)
4052 goto load_failed;
4053
4054 r_list->version = version;
4055 r_list->flags = flags;
4056 r_list->section = sec;
4057 r_list->record_count = record_count;
4058 r_list->records = (struct avr_property_record *) (&r_list [1]);
4059 size -= AVR_PROPERTY_SECTION_HEADER_SIZE;
4060
4061 /* Check that we understand the version number. There is only one
4062 version number right now, anything else is an error. */
4063 if (r_list->version != AVR_PROPERTY_RECORDS_VERSION)
4064 goto load_failed;
4065
4066 rel = internal_relocs;
4067 rel_end = rel + sec->reloc_count;
4068 for (i = 0; i < record_count; ++i)
4069 {
4070 bfd_vma address;
4071
4072 /* Each entry is a 32-bit address, followed by a single byte type.
07d6d2b8
AM		 4073 After that is the type specific data. We must take care to
4074 ensure that we don't read beyond the end of the section data. */
137c83d6 4075 if (size < 5)
07d6d2b8 4076 goto load_failed;
137c83d6
AB		 4077
4078 r_list->records [i].section = NULL;
4079 r_list->records [i].offset = 0;
4080
4081 if (rel)
07d6d2b8
AM		 4082 {
4083 /* The offset of the address within the .avr.prop section. */
4084 size_t offset = ptr - contents;
137c83d6 4085
07d6d2b8
AM		 4086 while (rel < rel_end && rel->r_offset < offset)
4087 ++rel;
137c83d6 4088
07d6d2b8
AM		 4089 if (rel == rel_end)
4090 rel = NULL;
4091 else if (rel->r_offset == offset)
4092 {
4093 /* Find section and section offset. */
4094 unsigned long r_symndx;
137c83d6 4095
07d6d2b8
AM		 4096 asection * rel_sec;
4097 bfd_vma sec_offset;
137c83d6 4098
07d6d2b8
AM		 4099 r_symndx = ELF32_R_SYM (rel->r_info);
4100 rel_sec = get_elf_r_symndx_section (abfd, r_symndx);
4101 sec_offset = get_elf_r_symndx_offset (abfd, r_symndx)
4102 + rel->r_addend;
137c83d6 4103
07d6d2b8
AM		 4104 r_list->records [i].section = rel_sec;
4105 r_list->records [i].offset = sec_offset;
4106 }
4107 }
137c83d6
AB		 4108
4109 address = *((uint32_t *) ptr);
4110 ptr += 4;
4111 size -= 4;
4112
4113 if (r_list->records [i].section == NULL)
07d6d2b8
AM		 4114 {
4115 /* Try to find section and offset from address. */
4116 if (fs_data.section != NULL
4117 && !avr_is_section_for_address (abfd, fs_data.section,
4118 address))
4119 fs_data.section = NULL;
4120
4121 if (fs_data.section == NULL)
4122 {
4123 fs_data.address = address;
4124 bfd_map_over_sections (abfd, avr_find_section_for_address,
4125 &fs_data);
4126 }
4127
4128 if (fs_data.section == NULL)
4129 {
4130 fprintf (stderr, "Failed to find matching section.\n");
4131 goto load_failed;
4132 }
4133
4134 r_list->records [i].section = fs_data.section;
4135 r_list->records [i].offset
4136 = address - bfd_get_section_vma (abfd, fs_data.section);
4137 }
137c83d6
AB		 4138
4139 r_list->records [i].type = *((bfd_byte *) ptr);
4140 ptr += 1;
4141 size -= 1;
4142
4143 switch (r_list->records [i].type)
07d6d2b8
AM		 4144 {
4145 case RECORD_ORG:
4146 /* Nothing else to load. */
4147 break;
4148 case RECORD_ORG_AND_FILL:
4149 /* Just a 4-byte fill to load. */
4150 if (size < 4)
4151 goto load_failed;
4152 r_list->records [i].data.org.fill = *((uint32_t *) ptr);
4153 ptr += 4;
4154 size -= 4;
4155 break;
4156 case RECORD_ALIGN:
4157 /* Just a 4-byte alignment to load. */
4158 if (size < 4)
4159 goto load_failed;
4160 r_list->records [i].data.align.bytes = *((uint32_t *) ptr);
4161 ptr += 4;
4162 size -= 4;
4163 /* Just initialise PRECEDING_DELETED field, this field is
4164 used during linker relaxation. */
4165 r_list->records [i].data.align.preceding_deleted = 0;
4166 break;
4167 case RECORD_ALIGN_AND_FILL:
4168 /* A 4-byte alignment, and a 4-byte fill to load. */
4169 if (size < 8)
4170 goto load_failed;
4171 r_list->records [i].data.align.bytes = *((uint32_t *) ptr);
4172 ptr += 4;
4173 r_list->records [i].data.align.fill = *((uint32_t *) ptr);
4174 ptr += 4;
4175 size -= 8;
4176 /* Just initialise PRECEDING_DELETED field, this field is
4177 used during linker relaxation. */
4178 r_list->records [i].data.align.preceding_deleted = 0;
4179 break;
4180 default:
4181 goto load_failed;
4182 }
137c83d6
AB		 4183 }
4184
4185 free (contents);
024ea11b
SKS		 4186 if (elf_section_data (sec)->relocs != internal_relocs)
4187 free (internal_relocs);
137c83d6
AB		 4188 return r_list;
4189
4190 load_failed:
024ea11b
SKS		 4191 if (elf_section_data (sec)->relocs != internal_relocs)
4192 free (internal_relocs);
137c83d6
AB		 4193 free (contents);
4194 free (r_list);
4195 return NULL;
4196}
4197
4198/* Load all of the property records from ABFD. See
4199 AVR_ELF32_LOAD_RECORDS_FROM_SECTION for details of the return value. */
4200
4201struct avr_property_record_list *
4202avr_elf32_load_property_records (bfd *abfd)
4203{
4204 asection *sec;
4205
4206 /* Find the '.avr.prop' section and load the contents into memory. */
4207 sec = bfd_get_section_by_name (abfd, AVR_PROPERTY_RECORD_SECTION_NAME);
4208 if (sec == NULL)
4209 return NULL;
4210 return avr_elf32_load_records_from_section (abfd, sec);
4211}
4212
4213const char *
4214avr_elf32_property_record_name (struct avr_property_record *rec)
4215{
4216 const char *str;
4217
4218 switch (rec->type)
4219 {
4220 case RECORD_ORG:
4221 str = "ORG";
4222 break;
4223 case RECORD_ORG_AND_FILL:
4224 str = "ORG+FILL";
4225 break;
4226 case RECORD_ALIGN:
4227 str = "ALIGN";
4228 break;
4229 case RECORD_ALIGN_AND_FILL:
4230 str = "ALIGN+FILL";
4231 break;
4232 default:
4233 str = "unknown";
4234 }
4235
4236 return str;
4237}
4238
4239
adde6300 4240#define ELF_ARCH bfd_arch_avr
ae95ffa6 4241#define ELF_TARGET_ID AVR_ELF_DATA
adde6300 4242#define ELF_MACHINE_CODE EM_AVR
aa4f99bb 4243#define ELF_MACHINE_ALT1 EM_AVR_OLD
adde6300
AM		 4244#define ELF_MAXPAGESIZE 1
4245
07d6d2b8 4246#define TARGET_LITTLE_SYM avr_elf32_vec
adde6300
AM		 4247#define TARGET_LITTLE_NAME "elf32-avr"
4248
28c9d252 4249#define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
28c9d252 4250
07d6d2b8
AM		 4251#define elf_info_to_howto avr_info_to_howto_rela
4252#define elf_info_to_howto_rel NULL
4253#define elf_backend_relocate_section elf32_avr_relocate_section
4254#define elf_backend_can_gc_sections 1
f0fe0e16 4255#define elf_backend_rela_normal 1
adde6300
AM		 4256#define elf_backend_final_write_processing \
4257 bfd_elf_avr_final_write_processing
4258#define elf_backend_object_p elf32_avr_object_p
4259
df406460
NC		 4260#define bfd_elf32_bfd_relax_section elf32_avr_relax_section
4261#define bfd_elf32_bfd_get_relocated_section_contents \
07d6d2b8 4262 elf32_avr_get_relocated_section_contents
bac13f5a 4263#define bfd_elf32_new_section_hook elf_avr_new_section_hook
deee88e9 4264#define elf_backend_special_sections elf_avr_special_sections
df406460 4265
adde6300 4266#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 1.448756 seconds and 4 git commands to generate.