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