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