projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* coff-arm.c (coff_arm_link_hash_table_create): Use bfd_zmalloc.
[deliverable/binutils-gdb.git] / bfd / elf32-avr.c
CommitLineData
adde6300 1/* AVR-specific support for 32-bit ELF
4dfe6ac6 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
dbaa2011
AM		 3 2010, 2011, 2012
4 Free Software Foundation, Inc.
adde6300
AM		 5 Contributed by Denis Chertykov <denisc@overta.ru>
6
750bce0e 7 This file is part of BFD, the Binary File Descriptor library.
adde6300 8
750bce0e
NC		 9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
cd123cb7 11 the Free Software Foundation; either version 3 of the License, or
750bce0e 12 (at your option) any later version.
adde6300 13
750bce0e
NC		 14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
adde6300 18
750bce0e
NC		 19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
4cdc7696 21 Foundation, Inc., 51 Franklin Street - Fifth Floor,
df406460 22 Boston, MA 02110-1301, USA. */
adde6300 23
adde6300 24#include "sysdep.h"
3db64b00 25#include "bfd.h"
adde6300
AM		 26#include "libbfd.h"
27#include "elf-bfd.h"
28#include "elf/avr.h"
28c9d252
NC		 29#include "elf32-avr.h"
30
31/* Enable debugging printout at stdout with this variable. */
32static bfd_boolean debug_relax = FALSE;
33
34/* Enable debugging printout at stdout with this variable. */
35static bfd_boolean debug_stubs = FALSE;
36
37/* Hash table initialization and handling. Code is taken from the hppa port
38 and adapted to the needs of AVR. */
39
40/* We use two hash tables to hold information for linking avr objects.
41
4dfe6ac6 42 The first is the elf32_avr_link_hash_table which is derived from the
28c9d252
NC		 43 stanard ELF linker hash table. We use this as a place to attach the other
44 hash table and some static information.
45
46 The second is the stub hash table which is derived from the base BFD
47 hash table. The stub hash table holds the information on the linker
48 stubs. */
49
50struct elf32_avr_stub_hash_entry
51{
52 /* Base hash table entry structure. */
53 struct bfd_hash_entry bh_root;
54
55 /* Offset within stub_sec of the beginning of this stub. */
56 bfd_vma stub_offset;
57
58 /* Given the symbol's value and its section we can determine its final
59 value when building the stubs (so the stub knows where to jump). */
60 bfd_vma target_value;
61
62 /* This way we could mark stubs to be no longer necessary. */
63 bfd_boolean is_actually_needed;
64};
65
66struct elf32_avr_link_hash_table
67{
68 /* The main hash table. */
69 struct elf_link_hash_table etab;
70
71 /* The stub hash table. */
72 struct bfd_hash_table bstab;
73
74 bfd_boolean no_stubs;
75
76 /* Linker stub bfd. */
77 bfd *stub_bfd;
78
79 /* The stub section. */
80 asection *stub_sec;
81
82 /* Usually 0, unless we are generating code for a bootloader. Will
83 be initialized by elf32_avr_size_stubs to the vma offset of the
84 output section associated with the stub section. */
85 bfd_vma vector_base;
86
87 /* Assorted information used by elf32_avr_size_stubs. */
88 unsigned int bfd_count;
89 int top_index;
90 asection ** input_list;
91 Elf_Internal_Sym ** all_local_syms;
92
93 /* Tables for mapping vma beyond the 128k boundary to the address of the
94 corresponding stub. (AMT)
95 "amt_max_entry_cnt" reflects the number of entries that memory is allocated
96 for in the "amt_stub_offsets" and "amt_destination_addr" arrays.
97 "amt_entry_cnt" informs how many of these entries actually contain
98 useful data. */
99 unsigned int amt_entry_cnt;
100 unsigned int amt_max_entry_cnt;
101 bfd_vma * amt_stub_offsets;
102 bfd_vma * amt_destination_addr;
103};
104
105/* Various hash macros and functions. */
106#define avr_link_hash_table(p) \
64ee10b6 107 /* PR 3874: Check that we have an AVR style hash table before using it. */\
4dfe6ac6
NC		 108 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
109 == AVR_ELF_DATA ? ((struct elf32_avr_link_hash_table *) ((p)->hash)) : NULL)
28c9d252
NC		 110
111#define avr_stub_hash_entry(ent) \
112 ((struct elf32_avr_stub_hash_entry *)(ent))
113
114#define avr_stub_hash_lookup(table, string, create, copy) \
115 ((struct elf32_avr_stub_hash_entry *) \
116 bfd_hash_lookup ((table), (string), (create), (copy)))
adde6300 117
adde6300
AM		 118static reloc_howto_type elf_avr_howto_table[] =
119{
120 HOWTO (R_AVR_NONE, /* type */
121 0, /* rightshift */
122 2, /* size (0 = byte, 1 = short, 2 = long) */
123 32, /* bitsize */
b34976b6 124 FALSE, /* pc_relative */
adde6300
AM		 125 0, /* bitpos */
126 complain_overflow_bitfield, /* complain_on_overflow */
127 bfd_elf_generic_reloc, /* special_function */
128 "R_AVR_NONE", /* name */
b34976b6 129 FALSE, /* partial_inplace */
adde6300
AM		 130 0, /* src_mask */
131 0, /* dst_mask */
b34976b6 132 FALSE), /* pcrel_offset */
adde6300
AM		 133
134 HOWTO (R_AVR_32, /* type */
135 0, /* rightshift */
136 2, /* size (0 = byte, 1 = short, 2 = long) */
137 32, /* bitsize */
b34976b6 138 FALSE, /* pc_relative */
adde6300
AM		 139 0, /* bitpos */
140 complain_overflow_bitfield, /* complain_on_overflow */
141 bfd_elf_generic_reloc, /* special_function */
142 "R_AVR_32", /* name */
b34976b6 143 FALSE, /* partial_inplace */
adde6300
AM		 144 0xffffffff, /* src_mask */
145 0xffffffff, /* dst_mask */
b34976b6 146 FALSE), /* pcrel_offset */
adde6300
AM		 147
148 /* A 7 bit PC relative relocation. */
149 HOWTO (R_AVR_7_PCREL, /* type */
150 1, /* rightshift */
151 1, /* size (0 = byte, 1 = short, 2 = long) */
152 7, /* bitsize */
b34976b6 153 TRUE, /* pc_relative */
adde6300
AM		 154 3, /* bitpos */
155 complain_overflow_bitfield, /* complain_on_overflow */
156 bfd_elf_generic_reloc, /* special_function */
157 "R_AVR_7_PCREL", /* name */
b34976b6 158 FALSE, /* partial_inplace */
adde6300
AM		 159 0xffff, /* src_mask */
160 0xffff, /* dst_mask */
b34976b6 161 TRUE), /* pcrel_offset */
adde6300
AM		 162
163 /* A 13 bit PC relative relocation. */
164 HOWTO (R_AVR_13_PCREL, /* type */
165 1, /* rightshift */
166 1, /* size (0 = byte, 1 = short, 2 = long) */
167 13, /* bitsize */
b34976b6 168 TRUE, /* pc_relative */
adde6300
AM		 169 0, /* bitpos */
170 complain_overflow_bitfield, /* complain_on_overflow */
171 bfd_elf_generic_reloc, /* special_function */
172 "R_AVR_13_PCREL", /* name */
b34976b6 173 FALSE, /* partial_inplace */
adde6300
AM		 174 0xfff, /* src_mask */
175 0xfff, /* dst_mask */
b34976b6 176 TRUE), /* pcrel_offset */
adde6300
AM		 177
178 /* A 16 bit absolute relocation. */
179 HOWTO (R_AVR_16, /* type */
180 0, /* rightshift */
181 1, /* size (0 = byte, 1 = short, 2 = long) */
182 16, /* bitsize */
b34976b6 183 FALSE, /* pc_relative */
adde6300
AM		 184 0, /* bitpos */
185 complain_overflow_dont, /* complain_on_overflow */
186 bfd_elf_generic_reloc, /* special_function */
187 "R_AVR_16", /* name */
b34976b6 188 FALSE, /* partial_inplace */
adde6300
AM		 189 0xffff, /* src_mask */
190 0xffff, /* dst_mask */
b34976b6 191 FALSE), /* pcrel_offset */
adde6300 192
28c9d252
NC		 193 /* A 16 bit absolute relocation for command address
194 Will be changed when linker stubs are needed. */
adde6300
AM		 195 HOWTO (R_AVR_16_PM, /* type */
196 1, /* rightshift */
197 1, /* size (0 = byte, 1 = short, 2 = long) */
198 16, /* bitsize */
b34976b6 199 FALSE, /* pc_relative */
adde6300
AM		 200 0, /* bitpos */
201 complain_overflow_bitfield, /* complain_on_overflow */
202 bfd_elf_generic_reloc, /* special_function */
203 "R_AVR_16_PM", /* name */
b34976b6 204 FALSE, /* partial_inplace */
adde6300
AM		 205 0xffff, /* src_mask */
206 0xffff, /* dst_mask */
b34976b6 207 FALSE), /* pcrel_offset */
adde6300
AM		 208 /* A low 8 bit absolute relocation of 16 bit address.
209 For LDI command. */
210 HOWTO (R_AVR_LO8_LDI, /* type */
211 0, /* rightshift */
212 1, /* size (0 = byte, 1 = short, 2 = long) */
213 8, /* bitsize */
b34976b6 214 FALSE, /* pc_relative */
adde6300
AM		 215 0, /* bitpos */
216 complain_overflow_dont, /* complain_on_overflow */
217 bfd_elf_generic_reloc, /* special_function */
218 "R_AVR_LO8_LDI", /* name */
b34976b6 219 FALSE, /* partial_inplace */
adde6300
AM		 220 0xffff, /* src_mask */
221 0xffff, /* dst_mask */
b34976b6 222 FALSE), /* pcrel_offset */
adde6300
AM		 223 /* A high 8 bit absolute relocation of 16 bit address.
224 For LDI command. */
225 HOWTO (R_AVR_HI8_LDI, /* type */
226 8, /* rightshift */
227 1, /* size (0 = byte, 1 = short, 2 = long) */
228 8, /* bitsize */
b34976b6 229 FALSE, /* pc_relative */
adde6300
AM		 230 0, /* bitpos */
231 complain_overflow_dont, /* complain_on_overflow */
232 bfd_elf_generic_reloc, /* special_function */
233 "R_AVR_HI8_LDI", /* name */
b34976b6 234 FALSE, /* partial_inplace */
adde6300
AM		 235 0xffff, /* src_mask */
236 0xffff, /* dst_mask */
b34976b6 237 FALSE), /* pcrel_offset */
adde6300 238 /* A high 6 bit absolute relocation of 22 bit address.
4cdc7696 239 For LDI command. As well second most significant 8 bit value of
df406460 240 a 32 bit link-time constant. */
adde6300
AM		 241 HOWTO (R_AVR_HH8_LDI, /* type */
242 16, /* rightshift */
243 1, /* size (0 = byte, 1 = short, 2 = long) */
244 8, /* bitsize */
b34976b6 245 FALSE, /* pc_relative */
adde6300
AM		 246 0, /* bitpos */
247 complain_overflow_dont, /* complain_on_overflow */
248 bfd_elf_generic_reloc, /* special_function */
249 "R_AVR_HH8_LDI", /* name */
b34976b6 250 FALSE, /* partial_inplace */
adde6300
AM		 251 0xffff, /* src_mask */
252 0xffff, /* dst_mask */
b34976b6 253 FALSE), /* pcrel_offset */
adde6300
AM		 254 /* A negative low 8 bit absolute relocation of 16 bit address.
255 For LDI command. */
256 HOWTO (R_AVR_LO8_LDI_NEG, /* type */
257 0, /* rightshift */
258 1, /* size (0 = byte, 1 = short, 2 = long) */
259 8, /* bitsize */
b34976b6 260 FALSE, /* pc_relative */
adde6300
AM		 261 0, /* bitpos */
262 complain_overflow_dont, /* complain_on_overflow */
263 bfd_elf_generic_reloc, /* special_function */
264 "R_AVR_LO8_LDI_NEG", /* name */
b34976b6 265 FALSE, /* partial_inplace */
adde6300
AM		 266 0xffff, /* src_mask */
267 0xffff, /* dst_mask */
b34976b6 268 FALSE), /* pcrel_offset */
df406460 269 /* A negative high 8 bit absolute relocation of 16 bit address.
adde6300
AM		 270 For LDI command. */
271 HOWTO (R_AVR_HI8_LDI_NEG, /* type */
272 8, /* rightshift */
273 1, /* size (0 = byte, 1 = short, 2 = long) */
274 8, /* bitsize */
b34976b6 275 FALSE, /* pc_relative */
adde6300
AM		 276 0, /* bitpos */
277 complain_overflow_dont, /* complain_on_overflow */
278 bfd_elf_generic_reloc, /* special_function */
279 "R_AVR_HI8_LDI_NEG", /* name */
b34976b6 280 FALSE, /* partial_inplace */
adde6300
AM		 281 0xffff, /* src_mask */
282 0xffff, /* dst_mask */
b34976b6 283 FALSE), /* pcrel_offset */
df406460 284 /* A negative high 6 bit absolute relocation of 22 bit address.
adde6300
AM		 285 For LDI command. */
286 HOWTO (R_AVR_HH8_LDI_NEG, /* type */
287 16, /* rightshift */
288 1, /* size (0 = byte, 1 = short, 2 = long) */
289 8, /* bitsize */
b34976b6 290 FALSE, /* pc_relative */
adde6300
AM		 291 0, /* bitpos */
292 complain_overflow_dont, /* complain_on_overflow */
293 bfd_elf_generic_reloc, /* special_function */
294 "R_AVR_HH8_LDI_NEG", /* name */
b34976b6 295 FALSE, /* partial_inplace */
adde6300
AM		 296 0xffff, /* src_mask */
297 0xffff, /* dst_mask */
b34976b6 298 FALSE), /* pcrel_offset */
adde6300 299 /* A low 8 bit absolute relocation of 24 bit program memory address.
28c9d252 300 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 301 HOWTO (R_AVR_LO8_LDI_PM, /* type */
302 1, /* rightshift */
303 1, /* size (0 = byte, 1 = short, 2 = long) */
304 8, /* bitsize */
b34976b6 305 FALSE, /* pc_relative */
adde6300
AM		 306 0, /* bitpos */
307 complain_overflow_dont, /* complain_on_overflow */
308 bfd_elf_generic_reloc, /* special_function */
309 "R_AVR_LO8_LDI_PM", /* name */
b34976b6 310 FALSE, /* partial_inplace */
adde6300
AM		 311 0xffff, /* src_mask */
312 0xffff, /* dst_mask */
b34976b6 313 FALSE), /* pcrel_offset */
28c9d252
NC		 314 /* A low 8 bit absolute relocation of 24 bit program memory address.
315 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 316 HOWTO (R_AVR_HI8_LDI_PM, /* type */
317 9, /* rightshift */
318 1, /* size (0 = byte, 1 = short, 2 = long) */
319 8, /* bitsize */
b34976b6 320 FALSE, /* pc_relative */
adde6300
AM		 321 0, /* bitpos */
322 complain_overflow_dont, /* complain_on_overflow */
323 bfd_elf_generic_reloc, /* special_function */
324 "R_AVR_HI8_LDI_PM", /* name */
b34976b6 325 FALSE, /* partial_inplace */
adde6300
AM		 326 0xffff, /* src_mask */
327 0xffff, /* dst_mask */
b34976b6 328 FALSE), /* pcrel_offset */
28c9d252
NC		 329 /* A low 8 bit absolute relocation of 24 bit program memory address.
330 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 331 HOWTO (R_AVR_HH8_LDI_PM, /* type */
332 17, /* rightshift */
333 1, /* size (0 = byte, 1 = short, 2 = long) */
334 8, /* bitsize */
b34976b6 335 FALSE, /* pc_relative */
adde6300
AM		 336 0, /* bitpos */
337 complain_overflow_dont, /* complain_on_overflow */
338 bfd_elf_generic_reloc, /* special_function */
339 "R_AVR_HH8_LDI_PM", /* name */
b34976b6 340 FALSE, /* partial_inplace */
adde6300
AM		 341 0xffff, /* src_mask */
342 0xffff, /* dst_mask */
b34976b6 343 FALSE), /* pcrel_offset */
28c9d252
NC		 344 /* A low 8 bit absolute relocation of 24 bit program memory address.
345 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 346 HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */
347 1, /* rightshift */
348 1, /* size (0 = byte, 1 = short, 2 = long) */
349 8, /* bitsize */
b34976b6 350 FALSE, /* pc_relative */
adde6300
AM		 351 0, /* bitpos */
352 complain_overflow_dont, /* complain_on_overflow */
353 bfd_elf_generic_reloc, /* special_function */
354 "R_AVR_LO8_LDI_PM_NEG", /* name */
b34976b6 355 FALSE, /* partial_inplace */
adde6300
AM		 356 0xffff, /* src_mask */
357 0xffff, /* dst_mask */
b34976b6 358 FALSE), /* pcrel_offset */
28c9d252
NC		 359 /* A low 8 bit absolute relocation of 24 bit program memory address.
360 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 361 HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */
362 9, /* rightshift */
363 1, /* size (0 = byte, 1 = short, 2 = long) */
364 8, /* bitsize */
b34976b6 365 FALSE, /* pc_relative */
adde6300
AM		 366 0, /* bitpos */
367 complain_overflow_dont, /* complain_on_overflow */
368 bfd_elf_generic_reloc, /* special_function */
369 "R_AVR_HI8_LDI_PM_NEG", /* name */
b34976b6 370 FALSE, /* partial_inplace */
adde6300
AM		 371 0xffff, /* src_mask */
372 0xffff, /* dst_mask */
b34976b6 373 FALSE), /* pcrel_offset */
28c9d252
NC		 374 /* A low 8 bit absolute relocation of 24 bit program memory address.
375 For LDI command. Will not be changed when linker stubs are needed. */
adde6300
AM		 376 HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */
377 17, /* rightshift */
378 1, /* size (0 = byte, 1 = short, 2 = long) */
379 8, /* bitsize */
b34976b6 380 FALSE, /* pc_relative */
adde6300
AM		 381 0, /* bitpos */
382 complain_overflow_dont, /* complain_on_overflow */
383 bfd_elf_generic_reloc, /* special_function */
384 "R_AVR_HH8_LDI_PM_NEG", /* name */
b34976b6 385 FALSE, /* partial_inplace */
adde6300
AM		 386 0xffff, /* src_mask */
387 0xffff, /* dst_mask */
b34976b6 388 FALSE), /* pcrel_offset */
adde6300
AM		 389 /* Relocation for CALL command in ATmega. */
390 HOWTO (R_AVR_CALL, /* type */
391 1, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 23, /* bitsize */
b34976b6 394 FALSE, /* pc_relative */
adde6300 395 0, /* bitpos */
750bce0e 396 complain_overflow_dont,/* complain_on_overflow */
adde6300
AM		 397 bfd_elf_generic_reloc, /* special_function */
398 "R_AVR_CALL", /* name */
b34976b6 399 FALSE, /* partial_inplace */
adde6300
AM		 400 0xffffffff, /* src_mask */
401 0xffffffff, /* dst_mask */
750bce0e
NC		 402 FALSE), /* pcrel_offset */
403 /* A 16 bit absolute relocation of 16 bit address.
404 For LDI command. */
405 HOWTO (R_AVR_LDI, /* type */
406 0, /* rightshift */
407 1, /* size (0 = byte, 1 = short, 2 = long) */
408 16, /* bitsize */
409 FALSE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_dont,/* complain_on_overflow */
412 bfd_elf_generic_reloc, /* special_function */
413 "R_AVR_LDI", /* name */
414 FALSE, /* partial_inplace */
415 0xffff, /* src_mask */
416 0xffff, /* dst_mask */
417 FALSE), /* pcrel_offset */
418 /* A 6 bit absolute relocation of 6 bit offset.
419 For ldd/sdd command. */
420 HOWTO (R_AVR_6, /* type */
421 0, /* rightshift */
422 0, /* size (0 = byte, 1 = short, 2 = long) */
423 6, /* bitsize */
424 FALSE, /* pc_relative */
425 0, /* bitpos */
426 complain_overflow_dont,/* complain_on_overflow */
427 bfd_elf_generic_reloc, /* special_function */
428 "R_AVR_6", /* name */
429 FALSE, /* partial_inplace */
430 0xffff, /* src_mask */
431 0xffff, /* dst_mask */
432 FALSE), /* pcrel_offset */
433 /* A 6 bit absolute relocation of 6 bit offset.
434 For sbiw/adiw command. */
435 HOWTO (R_AVR_6_ADIW, /* type */
436 0, /* rightshift */
437 0, /* size (0 = byte, 1 = short, 2 = long) */
438 6, /* bitsize */
439 FALSE, /* pc_relative */
440 0, /* bitpos */
441 complain_overflow_dont,/* complain_on_overflow */
442 bfd_elf_generic_reloc, /* special_function */
443 "R_AVR_6_ADIW", /* name */
444 FALSE, /* partial_inplace */
445 0xffff, /* src_mask */
446 0xffff, /* dst_mask */
df406460
NC		 447 FALSE), /* pcrel_offset */
448 /* Most significant 8 bit value of a 32 bit link-time constant. */
449 HOWTO (R_AVR_MS8_LDI, /* type */
450 24, /* rightshift */
451 1, /* size (0 = byte, 1 = short, 2 = long) */
452 8, /* bitsize */
453 FALSE, /* pc_relative */
454 0, /* bitpos */
455 complain_overflow_dont, /* complain_on_overflow */
456 bfd_elf_generic_reloc, /* special_function */
457 "R_AVR_MS8_LDI", /* name */
458 FALSE, /* partial_inplace */
459 0xffff, /* src_mask */
460 0xffff, /* dst_mask */
461 FALSE), /* pcrel_offset */
462 /* Negative most significant 8 bit value of a 32 bit link-time constant. */
463 HOWTO (R_AVR_MS8_LDI_NEG, /* type */
464 24, /* rightshift */
465 1, /* size (0 = byte, 1 = short, 2 = long) */
466 8, /* bitsize */
467 FALSE, /* pc_relative */
468 0, /* bitpos */
469 complain_overflow_dont, /* complain_on_overflow */
470 bfd_elf_generic_reloc, /* special_function */
471 "R_AVR_MS8_LDI_NEG", /* name */
472 FALSE, /* partial_inplace */
473 0xffff, /* src_mask */
474 0xffff, /* dst_mask */
28c9d252
NC		 475 FALSE), /* pcrel_offset */
476 /* A low 8 bit absolute relocation of 24 bit program memory address.
17e57237 477 For LDI command. Will be changed when linker stubs are needed. */
28c9d252
NC		 478 HOWTO (R_AVR_LO8_LDI_GS, /* type */
479 1, /* rightshift */
480 1, /* size (0 = byte, 1 = short, 2 = long) */
481 8, /* bitsize */
482 FALSE, /* pc_relative */
483 0, /* bitpos */
484 complain_overflow_dont, /* complain_on_overflow */
485 bfd_elf_generic_reloc, /* special_function */
486 "R_AVR_LO8_LDI_GS", /* name */
487 FALSE, /* partial_inplace */
488 0xffff, /* src_mask */
489 0xffff, /* dst_mask */
490 FALSE), /* pcrel_offset */
491 /* A low 8 bit absolute relocation of 24 bit program memory address.
17e57237 492 For LDI command. Will be changed when linker stubs are needed. */
28c9d252
NC		 493 HOWTO (R_AVR_HI8_LDI_GS, /* type */
494 9, /* rightshift */
495 1, /* size (0 = byte, 1 = short, 2 = long) */
496 8, /* bitsize */
497 FALSE, /* pc_relative */
498 0, /* bitpos */
499 complain_overflow_dont, /* complain_on_overflow */
500 bfd_elf_generic_reloc, /* special_function */
501 "R_AVR_HI8_LDI_GS", /* name */
502 FALSE, /* partial_inplace */
503 0xffff, /* src_mask */
504 0xffff, /* dst_mask */
17e57237
NC		 505 FALSE), /* pcrel_offset */
506 /* 8 bit offset. */
507 HOWTO (R_AVR_8, /* type */
508 0, /* rightshift */
509 0, /* size (0 = byte, 1 = short, 2 = long) */
510 8, /* bitsize */
511 FALSE, /* pc_relative */
512 0, /* bitpos */
513 complain_overflow_bitfield,/* complain_on_overflow */
514 bfd_elf_generic_reloc, /* special_function */
515 "R_AVR_8", /* name */
516 FALSE, /* partial_inplace */
517 0x000000ff, /* src_mask */
518 0x000000ff, /* dst_mask */
519 FALSE), /* pcrel_offset */
99700d6f
NC		 520 /* lo8-part to use in .byte lo8(sym). */
521 HOWTO (R_AVR_8_LO8, /* type */
522 0, /* rightshift */
523 0, /* size (0 = byte, 1 = short, 2 = long) */
524 8, /* bitsize */
525 FALSE, /* pc_relative */
526 0, /* bitpos */
527 complain_overflow_dont,/* complain_on_overflow */
528 bfd_elf_generic_reloc, /* special_function */
529 "R_AVR_8_LO8", /* name */
530 FALSE, /* partial_inplace */
531 0xffffff, /* src_mask */
532 0xffffff, /* dst_mask */
533 FALSE), /* pcrel_offset */
534 /* hi8-part to use in .byte hi8(sym). */
535 HOWTO (R_AVR_8_HI8, /* type */
536 8, /* rightshift */
537 0, /* size (0 = byte, 1 = short, 2 = long) */
538 8, /* bitsize */
539 FALSE, /* pc_relative */
540 0, /* bitpos */
541 complain_overflow_dont,/* complain_on_overflow */
542 bfd_elf_generic_reloc, /* special_function */
543 "R_AVR_8_HI8", /* name */
544 FALSE, /* partial_inplace */
545 0xffffff, /* src_mask */
546 0xffffff, /* dst_mask */
547 FALSE), /* pcrel_offset */
40551fb8
NC		 548 /* hlo8-part to use in .byte hlo8(sym). */
549 HOWTO (R_AVR_8_HLO8, /* type */
99700d6f
NC		 550 16, /* rightshift */
551 0, /* size (0 = byte, 1 = short, 2 = long) */
552 8, /* bitsize */
553 FALSE, /* pc_relative */
554 0, /* bitpos */
555 complain_overflow_dont,/* complain_on_overflow */
556 bfd_elf_generic_reloc, /* special_function */
40551fb8 557 "R_AVR_8_HLO8", /* name */
99700d6f
NC		 558 FALSE, /* partial_inplace */
559 0xffffff, /* src_mask */
560 0xffffff, /* dst_mask */
561 FALSE), /* pcrel_offset */
adde6300
AM		 562};
563
564/* Map BFD reloc types to AVR ELF reloc types. */
565
566struct avr_reloc_map
567{
568 bfd_reloc_code_real_type bfd_reloc_val;
569 unsigned int elf_reloc_val;
570};
571
28c9d252 572static const struct avr_reloc_map avr_reloc_map[] =
adde6300
AM		 573{
574 { BFD_RELOC_NONE, R_AVR_NONE },
575 { BFD_RELOC_32, R_AVR_32 },
576 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
577 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
578 { BFD_RELOC_16, R_AVR_16 },
579 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
580 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
581 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
582 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
df406460 583 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI },
adde6300
AM		 584 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
585 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
586 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
df406460 587 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG },
adde6300 588 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
28c9d252 589 { BFD_RELOC_AVR_LO8_LDI_GS, R_AVR_LO8_LDI_GS },
adde6300 590 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
28c9d252 591 { BFD_RELOC_AVR_HI8_LDI_GS, R_AVR_HI8_LDI_GS },
adde6300
AM		 592 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
593 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
594 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
595 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
750bce0e
NC		 596 { BFD_RELOC_AVR_CALL, R_AVR_CALL },
597 { BFD_RELOC_AVR_LDI, R_AVR_LDI },
598 { BFD_RELOC_AVR_6, R_AVR_6 },
17e57237 599 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW },
99700d6f
NC		 600 { BFD_RELOC_8, R_AVR_8 },
601 { BFD_RELOC_AVR_8_LO, R_AVR_8_LO8 },
602 { BFD_RELOC_AVR_8_HI, R_AVR_8_HI8 },
40551fb8 603 { BFD_RELOC_AVR_8_HLO, R_AVR_8_HLO8 }
adde6300
AM		 604};
605
df406460 606/* Meant to be filled one day with the wrap around address for the
4cdc7696 607 specific device. I.e. should get the value 0x4000 for 16k devices,
df406460 608 0x8000 for 32k devices and so on.
4cdc7696 609
df406460 610 We initialize it here with a value of 0x1000000 resulting in
4cdc7696
NC		 611 that we will never suggest a wrap-around jump during relaxation.
612 The logic of the source code later on assumes that in
df406460 613 avr_pc_wrap_around one single bit is set. */
28c9d252
NC		 614static bfd_vma avr_pc_wrap_around = 0x10000000;
615
616/* If this variable holds a value different from zero, the linker relaxation
617 machine will try to optimize call/ret sequences by a single jump
618 instruction. This option could be switched off by a linker switch. */
619static int avr_replace_call_ret_sequences = 1;
620\f
621/* Initialize an entry in the stub hash table. */
622
623static struct bfd_hash_entry *
624stub_hash_newfunc (struct bfd_hash_entry *entry,
625 struct bfd_hash_table *table,
626 const char *string)
627{
628 /* Allocate the structure if it has not already been allocated by a
629 subclass. */
630 if (entry == NULL)
631 {
632 entry = bfd_hash_allocate (table,
633 sizeof (struct elf32_avr_stub_hash_entry));
634 if (entry == NULL)
635 return entry;
636 }
637
638 /* Call the allocation method of the superclass. */
639 entry = bfd_hash_newfunc (entry, table, string);
640 if (entry != NULL)
641 {
642 struct elf32_avr_stub_hash_entry *hsh;
643
644 /* Initialize the local fields. */
645 hsh = avr_stub_hash_entry (entry);
646 hsh->stub_offset = 0;
647 hsh->target_value = 0;
648 }
649
650 return entry;
651}
652
64ee10b6
NC		 653/* This function is just a straight passthrough to the real
654 function in linker.c. Its prupose is so that its address
655 can be compared inside the avr_link_hash_table macro. */
656
657static struct bfd_hash_entry *
658elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
659 struct bfd_hash_table * table,
660 const char * string)
661{
662 return _bfd_elf_link_hash_newfunc (entry, table, string);
663}
664
28c9d252
NC		 665/* Create the derived linker hash table. The AVR ELF port uses the derived
666 hash table to keep information specific to the AVR ELF linker (without
667 using static variables). */
668
669static struct bfd_link_hash_table *
670elf32_avr_link_hash_table_create (bfd *abfd)
671{
672 struct elf32_avr_link_hash_table *htab;
673 bfd_size_type amt = sizeof (*htab);
674
7bf52ea2 675 htab = bfd_zmalloc (amt);
28c9d252
NC		 676 if (htab == NULL)
677 return NULL;
678
679 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
64ee10b6 680 elf32_avr_link_hash_newfunc,
4dfe6ac6
NC		 681 sizeof (struct elf_link_hash_entry),
682 AVR_ELF_DATA))
28c9d252
NC		 683 {
684 free (htab);
685 return NULL;
686 }
687
688 /* Init the stub hash table too. */
689 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
690 sizeof (struct elf32_avr_stub_hash_entry)))
691 return NULL;
4cdc7696 692
28c9d252
NC		 693 return &htab->etab.root;
694}
695
696/* Free the derived linker hash table. */
697
698static void
699elf32_avr_link_hash_table_free (struct bfd_link_hash_table *btab)
700{
701 struct elf32_avr_link_hash_table *htab
702 = (struct elf32_avr_link_hash_table *) btab;
703
704 /* Free the address mapping table. */
705 if (htab->amt_stub_offsets != NULL)
706 free (htab->amt_stub_offsets);
707 if (htab->amt_destination_addr != NULL)
708 free (htab->amt_destination_addr);
709
710 bfd_hash_table_free (&htab->bstab);
711 _bfd_generic_link_hash_table_free (btab);
712}
df406460
NC		 713
714/* Calculates the effective distance of a pc relative jump/call. */
73160847 715
df406460
NC		 716static int
717avr_relative_distance_considering_wrap_around (unsigned int distance)
4cdc7696 718{
df406460 719 unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
df406460
NC		 720 int dist_with_wrap_around = distance & wrap_around_mask;
721
4cdc7696 722 if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
df406460
NC		 723 dist_with_wrap_around -= avr_pc_wrap_around;
724
725 return dist_with_wrap_around;
726}
727
728
adde6300 729static reloc_howto_type *
4cdc7696
NC		 730bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
731 bfd_reloc_code_real_type code)
adde6300
AM		 732{
733 unsigned int i;
734
735 for (i = 0;
736 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
737 i++)
73160847
NC		 738 if (avr_reloc_map[i].bfd_reloc_val == code)
739 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
adde6300
AM		 740
741 return NULL;
742}
743
157090f7
AM		 744static reloc_howto_type *
745bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
746 const char *r_name)
747{
748 unsigned int i;
749
750 for (i = 0;
751 i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
752 i++)
753 if (elf_avr_howto_table[i].name != NULL
754 && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
755 return &elf_avr_howto_table[i];
756
757 return NULL;
758}
759
adde6300
AM		 760/* Set the howto pointer for an AVR ELF reloc. */
761
762static void
4cdc7696
NC		 763avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
764 arelent *cache_ptr,
765 Elf_Internal_Rela *dst)
adde6300
AM		 766{
767 unsigned int r_type;
768
769 r_type = ELF32_R_TYPE (dst->r_info);
770 BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
771 cache_ptr->howto = &elf_avr_howto_table[r_type];
772}
773
28c9d252
NC		 774static bfd_boolean
775avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
776{
777 return (relocation >= 0x020000);
778}
779
780/* Returns the address of the corresponding stub if there is one.
781 Returns otherwise an address above 0x020000. This function
782 could also be used, if there is no knowledge on the section where
783 the destination is found. */
784
785static bfd_vma
786avr_get_stub_addr (bfd_vma srel,
787 struct elf32_avr_link_hash_table *htab)
788{
91d6fa6a 789 unsigned int sindex;
28c9d252
NC		 790 bfd_vma stub_sec_addr =
791 (htab->stub_sec->output_section->vma +
792 htab->stub_sec->output_offset);
793
91d6fa6a
NC		 794 for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
795 if (htab->amt_destination_addr[sindex] == srel)
796 return htab->amt_stub_offsets[sindex] + stub_sec_addr;
28c9d252
NC		 797
798 /* Return an address that could not be reached by 16 bit relocs. */
799 return 0x020000;
800}
801
adde6300
AM		 802/* Perform a single relocation. By default we use the standard BFD
803 routines, but a few relocs, we have to do them ourselves. */
804
805static bfd_reloc_status_type
28c9d252
NC		 806avr_final_link_relocate (reloc_howto_type * howto,
807 bfd * input_bfd,
808 asection * input_section,
809 bfd_byte * contents,
810 Elf_Internal_Rela * rel,
811 bfd_vma relocation,
812 struct elf32_avr_link_hash_table * htab)
adde6300
AM		 813{
814 bfd_reloc_status_type r = bfd_reloc_ok;
815 bfd_vma x;
816 bfd_signed_vma srel;
28c9d252
NC		 817 bfd_signed_vma reloc_addr;
818 bfd_boolean use_stubs = FALSE;
819 /* Usually is 0, unless we are generating code for a bootloader. */
820 bfd_signed_vma base_addr = htab->vector_base;
821
822 /* Absolute addr of the reloc in the final excecutable. */
823 reloc_addr = rel->r_offset + input_section->output_section->vma
824 + input_section->output_offset;
adde6300
AM		 825
826 switch (howto->type)
827 {
828 case R_AVR_7_PCREL:
829 contents += rel->r_offset;
830 srel = (bfd_signed_vma) relocation;
831 srel += rel->r_addend;
832 srel -= rel->r_offset;
a7c10850 833 srel -= 2; /* Branch instructions add 2 to the PC... */
adde6300
AM		 834 srel -= (input_section->output_section->vma +
835 input_section->output_offset);
836
837 if (srel & 1)
838 return bfd_reloc_outofrange;
839 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
840 return bfd_reloc_overflow;
841 x = bfd_get_16 (input_bfd, contents);
842 x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
843 bfd_put_16 (input_bfd, x, contents);
844 break;
845
846 case R_AVR_13_PCREL:
847 contents += rel->r_offset;
848 srel = (bfd_signed_vma) relocation;
849 srel += rel->r_addend;
850 srel -= rel->r_offset;
a7c10850 851 srel -= 2; /* Branch instructions add 2 to the PC... */
adde6300
AM		 852 srel -= (input_section->output_section->vma +
853 input_section->output_offset);
854
855 if (srel & 1)
856 return bfd_reloc_outofrange;
857
df406460
NC		 858 srel = avr_relative_distance_considering_wrap_around (srel);
859
adde6300
AM		 860 /* AVR addresses commands as words. */
861 srel >>= 1;
862
863 /* Check for overflow. */
864 if (srel < -2048 || srel > 2047)
865 {
df406460
NC		 866 /* Relative distance is too large. */
867
654c3c9f 868 /* Always apply WRAPAROUND for avr2, avr25, and avr4. */
65aa24b6 869 switch (bfd_get_mach (input_bfd))
adde6300 870 {
65aa24b6 871 case bfd_mach_avr2:
654c3c9f 872 case bfd_mach_avr25:
65aa24b6
NC		 873 case bfd_mach_avr4:
874 break;
875
876 default:
877 return bfd_reloc_overflow;
adde6300 878 }
adde6300
AM		 879 }
880
881 x = bfd_get_16 (input_bfd, contents);
882 x = (x & 0xf000) | (srel & 0xfff);
883 bfd_put_16 (input_bfd, x, contents);
884 break;
885
886 case R_AVR_LO8_LDI:
887 contents += rel->r_offset;
888 srel = (bfd_signed_vma) relocation + rel->r_addend;
889 x = bfd_get_16 (input_bfd, contents);
890 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
891 bfd_put_16 (input_bfd, x, contents);
892 break;
893
750bce0e
NC		 894 case R_AVR_LDI:
895 contents += rel->r_offset;
896 srel = (bfd_signed_vma) relocation + rel->r_addend;
4cdc7696
NC		 897 if (((srel > 0) && (srel & 0xffff) > 255)
898 || ((srel < 0) && ((-srel) & 0xffff) > 128))
df406460
NC		 899 /* Remove offset for data/eeprom section. */
900 return bfd_reloc_overflow;
901
750bce0e
NC		 902 x = bfd_get_16 (input_bfd, contents);
903 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
904 bfd_put_16 (input_bfd, x, contents);
905 break;
906
907 case R_AVR_6:
908 contents += rel->r_offset;
909 srel = (bfd_signed_vma) relocation + rel->r_addend;
910 if (((srel & 0xffff) > 63) || (srel < 0))
911 /* Remove offset for data/eeprom section. */
912 return bfd_reloc_overflow;
913 x = bfd_get_16 (input_bfd, contents);
4cdc7696 914 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
df406460 915 | ((srel & (1 << 5)) << 8));
750bce0e
NC		 916 bfd_put_16 (input_bfd, x, contents);
917 break;
918
919 case R_AVR_6_ADIW:
920 contents += rel->r_offset;
921 srel = (bfd_signed_vma) relocation + rel->r_addend;
922 if (((srel & 0xffff) > 63) || (srel < 0))
923 /* Remove offset for data/eeprom section. */
924 return bfd_reloc_overflow;
925 x = bfd_get_16 (input_bfd, contents);
4cdc7696 926 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
750bce0e
NC		 927 bfd_put_16 (input_bfd, x, contents);
928 break;
929
adde6300
AM		 930 case R_AVR_HI8_LDI:
931 contents += rel->r_offset;
932 srel = (bfd_signed_vma) relocation + rel->r_addend;
933 srel = (srel >> 8) & 0xff;
934 x = bfd_get_16 (input_bfd, contents);
935 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
936 bfd_put_16 (input_bfd, x, contents);
937 break;
938
939 case R_AVR_HH8_LDI:
940 contents += rel->r_offset;
941 srel = (bfd_signed_vma) relocation + rel->r_addend;
942 srel = (srel >> 16) & 0xff;
943 x = bfd_get_16 (input_bfd, contents);
944 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
945 bfd_put_16 (input_bfd, x, contents);
946 break;
947
df406460
NC		 948 case R_AVR_MS8_LDI:
949 contents += rel->r_offset;
950 srel = (bfd_signed_vma) relocation + rel->r_addend;
951 srel = (srel >> 24) & 0xff;
952 x = bfd_get_16 (input_bfd, contents);
953 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
954 bfd_put_16 (input_bfd, x, contents);
955 break;
956
adde6300
AM		 957 case R_AVR_LO8_LDI_NEG:
958 contents += rel->r_offset;
959 srel = (bfd_signed_vma) relocation + rel->r_addend;
960 srel = -srel;
961 x = bfd_get_16 (input_bfd, contents);
962 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
963 bfd_put_16 (input_bfd, x, contents);
964 break;
965
966 case R_AVR_HI8_LDI_NEG:
967 contents += rel->r_offset;
968 srel = (bfd_signed_vma) relocation + rel->r_addend;
969 srel = -srel;
970 srel = (srel >> 8) & 0xff;
971 x = bfd_get_16 (input_bfd, contents);
972 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
973 bfd_put_16 (input_bfd, x, contents);
974 break;
975
976 case R_AVR_HH8_LDI_NEG:
977 contents += rel->r_offset;
978 srel = (bfd_signed_vma) relocation + rel->r_addend;
979 srel = -srel;
980 srel = (srel >> 16) & 0xff;
981 x = bfd_get_16 (input_bfd, contents);
982 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
983 bfd_put_16 (input_bfd, x, contents);
984 break;
985
df406460
NC		 986 case R_AVR_MS8_LDI_NEG:
987 contents += rel->r_offset;
988 srel = (bfd_signed_vma) relocation + rel->r_addend;
989 srel = -srel;
990 srel = (srel >> 24) & 0xff;
991 x = bfd_get_16 (input_bfd, contents);
992 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
993 bfd_put_16 (input_bfd, x, contents);
994 break;
995
28c9d252
NC		 996 case R_AVR_LO8_LDI_GS:
997 use_stubs = (!htab->no_stubs);
998 /* Fall through. */
adde6300
AM		 999 case R_AVR_LO8_LDI_PM:
1000 contents += rel->r_offset;
1001 srel = (bfd_signed_vma) relocation + rel->r_addend;
28c9d252
NC		 1002
1003 if (use_stubs
1004 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1005 {
1006 bfd_vma old_srel = srel;
1007
1008 /* We need to use the address of the stub instead. */
1009 srel = avr_get_stub_addr (srel, htab);
1010 if (debug_stubs)
1011 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1012 "reloc at address 0x%x.\n",
1013 (unsigned int) srel,
1014 (unsigned int) old_srel,
1015 (unsigned int) reloc_addr);
1016
1017 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1018 return bfd_reloc_outofrange;
1019 }
1020
adde6300
AM		 1021 if (srel & 1)
1022 return bfd_reloc_outofrange;
1023 srel = srel >> 1;
1024 x = bfd_get_16 (input_bfd, contents);
1025 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1026 bfd_put_16 (input_bfd, x, contents);
1027 break;
1028
28c9d252
NC		 1029 case R_AVR_HI8_LDI_GS:
1030 use_stubs = (!htab->no_stubs);
1031 /* Fall through. */
adde6300
AM		 1032 case R_AVR_HI8_LDI_PM:
1033 contents += rel->r_offset;
1034 srel = (bfd_signed_vma) relocation + rel->r_addend;
28c9d252
NC		 1035
1036 if (use_stubs
1037 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1038 {
1039 bfd_vma old_srel = srel;
1040
1041 /* We need to use the address of the stub instead. */
1042 srel = avr_get_stub_addr (srel, htab);
1043 if (debug_stubs)
1044 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1045 "reloc at address 0x%x.\n",
1046 (unsigned int) srel,
1047 (unsigned int) old_srel,
1048 (unsigned int) reloc_addr);
1049
1050 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1051 return bfd_reloc_outofrange;
1052 }
1053
adde6300
AM		 1054 if (srel & 1)
1055 return bfd_reloc_outofrange;
1056 srel = srel >> 1;
1057 srel = (srel >> 8) & 0xff;
1058 x = bfd_get_16 (input_bfd, contents);
1059 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1060 bfd_put_16 (input_bfd, x, contents);
1061 break;
1062
1063 case R_AVR_HH8_LDI_PM:
1064 contents += rel->r_offset;
1065 srel = (bfd_signed_vma) relocation + rel->r_addend;
1066 if (srel & 1)
1067 return bfd_reloc_outofrange;
1068 srel = srel >> 1;
1069 srel = (srel >> 16) & 0xff;
1070 x = bfd_get_16 (input_bfd, contents);
1071 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1072 bfd_put_16 (input_bfd, x, contents);
1073 break;
1074
1075 case R_AVR_LO8_LDI_PM_NEG:
1076 contents += rel->r_offset;
1077 srel = (bfd_signed_vma) relocation + rel->r_addend;
1078 srel = -srel;
1079 if (srel & 1)
1080 return bfd_reloc_outofrange;
1081 srel = srel >> 1;
1082 x = bfd_get_16 (input_bfd, contents);
1083 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1084 bfd_put_16 (input_bfd, x, contents);
1085 break;
1086
1087 case R_AVR_HI8_LDI_PM_NEG:
1088 contents += rel->r_offset;
1089 srel = (bfd_signed_vma) relocation + rel->r_addend;
1090 srel = -srel;
1091 if (srel & 1)
1092 return bfd_reloc_outofrange;
1093 srel = srel >> 1;
1094 srel = (srel >> 8) & 0xff;
1095 x = bfd_get_16 (input_bfd, contents);
1096 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1097 bfd_put_16 (input_bfd, x, contents);
1098 break;
1099
1100 case R_AVR_HH8_LDI_PM_NEG:
1101 contents += rel->r_offset;
1102 srel = (bfd_signed_vma) relocation + rel->r_addend;
1103 srel = -srel;
1104 if (srel & 1)
1105 return bfd_reloc_outofrange;
1106 srel = srel >> 1;
1107 srel = (srel >> 16) & 0xff;
1108 x = bfd_get_16 (input_bfd, contents);
1109 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1110 bfd_put_16 (input_bfd, x, contents);
1111 break;
1112
1113 case R_AVR_CALL:
1114 contents += rel->r_offset;
1115 srel = (bfd_signed_vma) relocation + rel->r_addend;
1116 if (srel & 1)
1117 return bfd_reloc_outofrange;
1118 srel = srel >> 1;
1119 x = bfd_get_16 (input_bfd, contents);
1120 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1121 bfd_put_16 (input_bfd, x, contents);
dc810e39 1122 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
adde6300
AM		 1123 break;
1124
28c9d252
NC		 1125 case R_AVR_16_PM:
1126 use_stubs = (!htab->no_stubs);
1127 contents += rel->r_offset;
1128 srel = (bfd_signed_vma) relocation + rel->r_addend;
1129
1130 if (use_stubs
1131 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1132 {
1133 bfd_vma old_srel = srel;
1134
1135 /* We need to use the address of the stub instead. */
1136 srel = avr_get_stub_addr (srel,htab);
1137 if (debug_stubs)
1138 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1139 "reloc at address 0x%x.\n",
1140 (unsigned int) srel,
1141 (unsigned int) old_srel,
1142 (unsigned int) reloc_addr);
1143
1144 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1145 return bfd_reloc_outofrange;
1146 }
1147
1148 if (srel & 1)
1149 return bfd_reloc_outofrange;
1150 srel = srel >> 1;
1151 bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1152 break;
1153
adde6300
AM		 1154 default:
1155 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1156 contents, rel->r_offset,
1157 relocation, rel->r_addend);
1158 }
1159
1160 return r;
1161}
1162
1163/* Relocate an AVR ELF section. */
4cdc7696 1164
b34976b6 1165static bfd_boolean
4cdc7696
NC		 1166elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1167 struct bfd_link_info *info,
1168 bfd *input_bfd,
1169 asection *input_section,
1170 bfd_byte *contents,
1171 Elf_Internal_Rela *relocs,
1172 Elf_Internal_Sym *local_syms,
1173 asection **local_sections)
adde6300
AM		 1174{
1175 Elf_Internal_Shdr * symtab_hdr;
1176 struct elf_link_hash_entry ** sym_hashes;
1177 Elf_Internal_Rela * rel;
1178 Elf_Internal_Rela * relend;
28c9d252 1179 struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
adde6300 1180
4dfe6ac6
NC		 1181 if (htab == NULL)
1182 return FALSE;
1183
adde6300
AM		 1184 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1185 sym_hashes = elf_sym_hashes (input_bfd);
1186 relend = relocs + input_section->reloc_count;
1187
1188 for (rel = relocs; rel < relend; rel ++)
1189 {
1190 reloc_howto_type * howto;
1191 unsigned long r_symndx;
1192 Elf_Internal_Sym * sym;
1193 asection * sec;
1194 struct elf_link_hash_entry * h;
1195 bfd_vma relocation;
1196 bfd_reloc_status_type r;
dfeffb9f 1197 const char * name;
adde6300
AM		 1198 int r_type;
1199
1200 r_type = ELF32_R_TYPE (rel->r_info);
1201 r_symndx = ELF32_R_SYM (rel->r_info);
c7e2358a 1202 howto = elf_avr_howto_table + r_type;
adde6300
AM		 1203 h = NULL;
1204 sym = NULL;
1205 sec = NULL;
1206
1207 if (r_symndx < symtab_hdr->sh_info)
1208 {
1209 sym = local_syms + r_symndx;
1210 sec = local_sections [r_symndx];
8517fae7 1211 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
adde6300
AM		 1212
1213 name = bfd_elf_string_from_elf_section
1214 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1215 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1216 }
1217 else
1218 {
59c2e50f 1219 bfd_boolean unresolved_reloc, warned;
adde6300 1220
b2a8e766
AM		 1221 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1222 r_symndx, symtab_hdr, sym_hashes,
1223 h, sec, relocation,
1224 unresolved_reloc, warned);
dfeffb9f
L		 1225
1226 name = h->root.root.string;
adde6300
AM		 1227 }
1228
dbaa2011 1229 if (sec != NULL && discarded_section (sec))
e4067dbb 1230 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 1231 rel, 1, relend, howto, 0, contents);
ab96bf03
AM		 1232
1233 if (info->relocatable)
1234 continue;
1235
adde6300 1236 r = avr_final_link_relocate (howto, input_bfd, input_section,
28c9d252 1237 contents, rel, relocation, htab);
adde6300
AM		 1238
1239 if (r != bfd_reloc_ok)
1240 {
1241 const char * msg = (const char *) NULL;
1242
1243 switch (r)
1244 {
1245 case bfd_reloc_overflow:
1246 r = info->callbacks->reloc_overflow
dfeffb9f
L		 1247 (info, (h ? &h->root : NULL),
1248 name, howto->name, (bfd_vma) 0,
adde6300
AM		 1249 input_bfd, input_section, rel->r_offset);
1250 break;
1251
1252 case bfd_reloc_undefined:
1253 r = info->callbacks->undefined_symbol
b34976b6 1254 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
adde6300
AM		 1255 break;
1256
1257 case bfd_reloc_outofrange:
1258 msg = _("internal error: out of range error");
1259 break;
1260
1261 case bfd_reloc_notsupported:
1262 msg = _("internal error: unsupported relocation error");
1263 break;
1264
1265 case bfd_reloc_dangerous:
1266 msg = _("internal error: dangerous relocation");
1267 break;
1268
1269 default:
1270 msg = _("internal error: unknown error");
1271 break;
1272 }
1273
1274 if (msg)
1275 r = info->callbacks->warning
1276 (info, msg, name, input_bfd, input_section, rel->r_offset);
1277
1278 if (! r)
b34976b6 1279 return FALSE;
adde6300
AM		 1280 }
1281 }
1282
b34976b6 1283 return TRUE;
adde6300
AM		 1284}
1285
1286/* The final processing done just before writing out a AVR ELF object
1287 file. This gets the AVR architecture right based on the machine
1288 number. */
1289
1290static void
4cdc7696
NC		 1291bfd_elf_avr_final_write_processing (bfd *abfd,
1292 bfd_boolean linker ATTRIBUTE_UNUSED)
adde6300
AM		 1293{
1294 unsigned long val;
1295
1296 switch (bfd_get_mach (abfd))
1297 {
1298 default:
1299 case bfd_mach_avr2:
1300 val = E_AVR_MACH_AVR2;
1301 break;
1302
1303 case bfd_mach_avr1:
1304 val = E_AVR_MACH_AVR1;
1305 break;
1306
7b21ac3f
EW		 1307 case bfd_mach_avr25:
1308 val = E_AVR_MACH_AVR25;
28b02751 1309 break;
7b21ac3f 1310
adde6300
AM		 1311 case bfd_mach_avr3:
1312 val = E_AVR_MACH_AVR3;
1313 break;
1314
7b21ac3f
EW		 1315 case bfd_mach_avr31:
1316 val = E_AVR_MACH_AVR31;
28b02751 1317 break;
7b21ac3f
EW		 1318
1319 case bfd_mach_avr35:
1320 val = E_AVR_MACH_AVR35;
28b02751 1321 break;
7b21ac3f 1322
adde6300
AM		 1323 case bfd_mach_avr4:
1324 val = E_AVR_MACH_AVR4;
1325 break;
1326
65aa24b6
NC		 1327 case bfd_mach_avr5:
1328 val = E_AVR_MACH_AVR5;
1329 break;
28c9d252 1330
7b21ac3f
EW		 1331 case bfd_mach_avr51:
1332 val = E_AVR_MACH_AVR51;
1333 break;
1334
28c9d252
NC		 1335 case bfd_mach_avr6:
1336 val = E_AVR_MACH_AVR6;
1337 break;
8cc66334
EW		 1338
1339 case bfd_mach_avrxmega1:
1340 val = E_AVR_MACH_XMEGA1;
1341 break;
1342
1343 case bfd_mach_avrxmega2:
1344 val = E_AVR_MACH_XMEGA2;
1345 break;
1346
1347 case bfd_mach_avrxmega3:
1348 val = E_AVR_MACH_XMEGA3;
1349 break;
1350
1351 case bfd_mach_avrxmega4:
1352 val = E_AVR_MACH_XMEGA4;
1353 break;
1354
1355 case bfd_mach_avrxmega5:
1356 val = E_AVR_MACH_XMEGA5;
1357 break;
1358
1359 case bfd_mach_avrxmega6:
1360 val = E_AVR_MACH_XMEGA6;
1361 break;
1362
1363 case bfd_mach_avrxmega7:
1364 val = E_AVR_MACH_XMEGA7;
1365 break;
adde6300
AM		 1366 }
1367
1368 elf_elfheader (abfd)->e_machine = EM_AVR;
1369 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1370 elf_elfheader (abfd)->e_flags |= val;
df406460 1371 elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
adde6300
AM		 1372}
1373
1374/* Set the right machine number. */
1375
b34976b6 1376static bfd_boolean
4cdc7696 1377elf32_avr_object_p (bfd *abfd)
adde6300 1378{
dc810e39 1379 unsigned int e_set = bfd_mach_avr2;
4cdc7696 1380
aa4f99bb
AO		 1381 if (elf_elfheader (abfd)->e_machine == EM_AVR
1382 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
adde6300
AM		 1383 {
1384 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
4cdc7696 1385
adde6300
AM		 1386 switch (e_mach)
1387 {
1388 default:
1389 case E_AVR_MACH_AVR2:
1390 e_set = bfd_mach_avr2;
1391 break;
1392
1393 case E_AVR_MACH_AVR1:
1394 e_set = bfd_mach_avr1;
1395 break;
1396
7b21ac3f
EW		 1397 case E_AVR_MACH_AVR25:
1398 e_set = bfd_mach_avr25;
1399 break;
1400
adde6300
AM		 1401 case E_AVR_MACH_AVR3:
1402 e_set = bfd_mach_avr3;
1403 break;
1404
7b21ac3f
EW		 1405 case E_AVR_MACH_AVR31:
1406 e_set = bfd_mach_avr31;
1407 break;
1408
1409 case E_AVR_MACH_AVR35:
1410 e_set = bfd_mach_avr35;
1411 break;
1412
adde6300
AM		 1413 case E_AVR_MACH_AVR4:
1414 e_set = bfd_mach_avr4;
1415 break;
65aa24b6
NC		 1416
1417 case E_AVR_MACH_AVR5:
1418 e_set = bfd_mach_avr5;
1419 break;
28c9d252 1420
7b21ac3f
EW		 1421 case E_AVR_MACH_AVR51:
1422 e_set = bfd_mach_avr51;
1423 break;
1424
28c9d252
NC		 1425 case E_AVR_MACH_AVR6:
1426 e_set = bfd_mach_avr6;
1427 break;
8cc66334
EW		 1428
1429 case E_AVR_MACH_XMEGA1:
1430 e_set = bfd_mach_avrxmega1;
1431 break;
1432
1433 case E_AVR_MACH_XMEGA2:
1434 e_set = bfd_mach_avrxmega2;
1435 break;
1436
1437 case E_AVR_MACH_XMEGA3:
1438 e_set = bfd_mach_avrxmega3;
1439 break;
1440
1441 case E_AVR_MACH_XMEGA4:
1442 e_set = bfd_mach_avrxmega4;
1443 break;
1444
1445 case E_AVR_MACH_XMEGA5:
1446 e_set = bfd_mach_avrxmega5;
1447 break;
1448
1449 case E_AVR_MACH_XMEGA6:
1450 e_set = bfd_mach_avrxmega6;
1451 break;
1452
1453 case E_AVR_MACH_XMEGA7:
1454 e_set = bfd_mach_avrxmega7;
1455 break;
adde6300
AM		 1456 }
1457 }
1458 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1459 e_set);
1460}
1461
df406460 1462
4cdc7696
NC		 1463/* Delete some bytes from a section while changing the size of an instruction.
1464 The parameter "addr" denotes the section-relative offset pointing just
1465 behind the shrinked instruction. "addr+count" point at the first
1466 byte just behind the original unshrinked instruction. */
1467
1468static bfd_boolean
1469elf32_avr_relax_delete_bytes (bfd *abfd,
73160847 1470 asection *sec,
4cdc7696 1471 bfd_vma addr,
73160847 1472 int count)
4cdc7696
NC		 1473{
1474 Elf_Internal_Shdr *symtab_hdr;
1475 unsigned int sec_shndx;
1476 bfd_byte *contents;
1477 Elf_Internal_Rela *irel, *irelend;
4cdc7696
NC		 1478 Elf_Internal_Sym *isym;
1479 Elf_Internal_Sym *isymbuf = NULL;
4cdc7696
NC		 1480 bfd_vma toaddr;
1481 struct elf_link_hash_entry **sym_hashes;
1482 struct elf_link_hash_entry **end_hashes;
1483 unsigned int symcount;
1484
1485 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1486 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1487 contents = elf_section_data (sec)->this_hdr.contents;
1488
4cdc7696
NC		 1489 toaddr = sec->size;
1490
1491 irel = elf_section_data (sec)->relocs;
1492 irelend = irel + sec->reloc_count;
1493
1494 /* Actually delete the bytes. */
1495 if (toaddr - addr - count > 0)
1496 memmove (contents + addr, contents + addr + count,
1497 (size_t) (toaddr - addr - count));
1498 sec->size -= count;
1499
73160847 1500 /* Adjust all the reloc addresses. */
4cdc7696
NC		 1501 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1502 {
4cdc7696 1503 bfd_vma old_reloc_address;
4cdc7696
NC		 1504
1505 old_reloc_address = (sec->output_section->vma
1506 + sec->output_offset + irel->r_offset);
4cdc7696
NC		 1507
1508 /* Get the new reloc address. */
1509 if ((irel->r_offset > addr
1510 && irel->r_offset < toaddr))
1511 {
28c9d252 1512 if (debug_relax)
4cdc7696
NC		 1513 printf ("Relocation at address 0x%x needs to be moved.\n"
1514 "Old section offset: 0x%x, New section offset: 0x%x \n",
1515 (unsigned int) old_reloc_address,
1516 (unsigned int) irel->r_offset,
1517 (unsigned int) ((irel->r_offset) - count));
1518
1519 irel->r_offset -= count;
1520 }
1521
73160847 1522 }
4cdc7696 1523
73160847
NC		 1524 /* The reloc's own addresses are now ok. However, we need to readjust
1525 the reloc's addend, i.e. the reloc's value if two conditions are met:
1526 1.) the reloc is relative to a symbol in this section that
1527 is located in front of the shrinked instruction
28c9d252
NC		 1528 2.) symbol plus addend end up behind the shrinked instruction.
1529
73160847
NC		 1530 The most common case where this happens are relocs relative to
1531 the section-start symbol.
28c9d252 1532
73160847
NC		 1533 This step needs to be done for all of the sections of the bfd. */
1534
1535 {
1536 struct bfd_section *isec;
1537
1538 for (isec = abfd->sections; isec; isec = isec->next)
1539 {
1540 bfd_vma symval;
1541 bfd_vma shrinked_insn_address;
1542
a1c7aafb
NC		 1543 if (isec->reloc_count == 0)
1544 continue;
1545
73160847
NC		 1546 shrinked_insn_address = (sec->output_section->vma
1547 + sec->output_offset + addr - count);
1548
a1c7aafb
NC		 1549 irel = elf_section_data (isec)->relocs;
1550 /* PR 12161: Read in the relocs for this section if necessary. */
1551 if (irel == NULL)
6aa82b64 1552 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
a1c7aafb
NC		 1553
1554 for (irelend = irel + isec->reloc_count;
73160847
NC		 1555 irel < irelend;
1556 irel++)
1557 {
28c9d252 1558 /* Read this BFD's local symbols if we haven't done
73160847
NC		 1559 so already. */
1560 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1561 {
1562 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1563 if (isymbuf == NULL)
1564 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1565 symtab_hdr->sh_info, 0,
1566 NULL, NULL, NULL);
1567 if (isymbuf == NULL)
1568 return FALSE;
1569 }
1570
1571 /* Get the value of the symbol referred to by the reloc. */
1572 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1573 {
1574 /* A local symbol. */
73160847
NC		 1575 asection *sym_sec;
1576
1577 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1578 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1579 symval = isym->st_value;
1580 /* If the reloc is absolute, it will not have
1581 a symbol or section associated with it. */
1582 if (sym_sec == sec)
28c9d252 1583 {
73160847
NC		 1584 symval += sym_sec->output_section->vma
1585 + sym_sec->output_offset;
4cdc7696 1586
28c9d252 1587 if (debug_relax)
73160847
NC		 1588 printf ("Checking if the relocation's "
1589 "addend needs corrections.\n"
1590 "Address of anchor symbol: 0x%x \n"
1591 "Address of relocation target: 0x%x \n"
1592 "Address of relaxed insn: 0x%x \n",
1593 (unsigned int) symval,
1594 (unsigned int) (symval + irel->r_addend),
1595 (unsigned int) shrinked_insn_address);
1596
1597 if (symval <= shrinked_insn_address
1598 && (symval + irel->r_addend) > shrinked_insn_address)
1599 {
1600 irel->r_addend -= count;
1601
28c9d252 1602 if (debug_relax)
73160847
NC		 1603 printf ("Relocation's addend needed to be fixed \n");
1604 }
4cdc7696 1605 }
73160847 1606 /* else...Reference symbol is absolute. No adjustment needed. */
28c9d252
NC		 1607 }
1608 /* else...Reference symbol is extern. No need for adjusting
73160847 1609 the addend. */
28c9d252 1610 }
73160847
NC		 1611 }
1612 }
4cdc7696
NC		 1613
1614 /* Adjust the local symbols defined in this section. */
1615 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
12123067
NC		 1616 /* Fix PR 9841, there may be no local symbols. */
1617 if (isym != NULL)
4cdc7696 1618 {
12123067
NC		 1619 Elf_Internal_Sym *isymend;
1620
1621 isymend = isym + symtab_hdr->sh_info;
1622 for (; isym < isymend; isym++)
1623 {
1624 if (isym->st_shndx == sec_shndx
1625 && isym->st_value > addr
1626 && isym->st_value < toaddr)
1627 isym->st_value -= count;
1628 }
4cdc7696
NC		 1629 }
1630
1631 /* Now adjust the global symbols defined in this section. */
1632 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1633 - symtab_hdr->sh_info);
1634 sym_hashes = elf_sym_hashes (abfd);
1635 end_hashes = sym_hashes + symcount;
1636 for (; sym_hashes < end_hashes; sym_hashes++)
1637 {
1638 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1639 if ((sym_hash->root.type == bfd_link_hash_defined
1640 || sym_hash->root.type == bfd_link_hash_defweak)
1641 && sym_hash->root.u.def.section == sec
1642 && sym_hash->root.u.def.value > addr
1643 && sym_hash->root.u.def.value < toaddr)
1644 {
1645 sym_hash->root.u.def.value -= count;
1646 }
1647 }
1648
1649 return TRUE;
1650}
1651
df406460
NC		 1652/* This function handles relaxing for the avr.
1653 Many important relaxing opportunities within functions are already
1654 realized by the compiler itself.
1655 Here we try to replace call (4 bytes) -> rcall (2 bytes)
4cdc7696
NC		 1656 and jump -> rjmp (safes also 2 bytes).
1657 As well we now optimize seqences of
df406460
NC		 1658 - call/rcall function
1659 - ret
1660 to yield
1661 - jmp/rjmp function
1662 - ret
1663 . In case that within a sequence
1664 - jmp/rjmp label
1665 - ret
1666 the ret could no longer be reached it is optimized away. In order
1667 to check if the ret is no longer needed, it is checked that the ret's address
1668 is not the target of a branch or jump within the same section, it is checked
1669 that there is no skip instruction before the jmp/rjmp and that there
1670 is no local or global label place at the address of the ret.
4cdc7696 1671
df406460 1672 We refrain from relaxing within sections ".vectors" and
4cdc7696 1673 ".jumptables" in order to maintain the position of the instructions.
df406460 1674 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
4cdc7696 1675 if possible. (In future one could possibly use the space of the nop
df406460
NC		 1676 for the first instruction of the irq service function.
1677
1678 The .jumptables sections is meant to be used for a future tablejump variant
1679 for the devices with 3-byte program counter where the table itself
4cdc7696 1680 contains 4-byte jump instructions whose relative offset must not
df406460 1681 be changed. */
4cdc7696 1682
28c9d252 1683static bfd_boolean
4cdc7696
NC		 1684elf32_avr_relax_section (bfd *abfd,
1685 asection *sec,
df406460
NC		 1686 struct bfd_link_info *link_info,
1687 bfd_boolean *again)
1688{
1689 Elf_Internal_Shdr *symtab_hdr;
1690 Elf_Internal_Rela *internal_relocs;
1691 Elf_Internal_Rela *irel, *irelend;
1692 bfd_byte *contents = NULL;
1693 Elf_Internal_Sym *isymbuf = NULL;
28c9d252
NC		 1694 struct elf32_avr_link_hash_table *htab;
1695
526f25b2 1696 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
68ffbac6
L		 1697 relaxing. Such shrinking can cause issues for the sections such
1698 as .vectors and .jumptables. Instead the unused bytes should be
526f25b2
EW		 1699 filled with nop instructions. */
1700 bfd_boolean shrinkable = TRUE;
1701
1702 if (!strcmp (sec->name,".vectors")
1703 || !strcmp (sec->name,".jumptables"))
1704 shrinkable = FALSE;
1705
c8a1f254
NS		 1706 if (link_info->relocatable)
1707 (*link_info->callbacks->einfo)
1708 (_("%P%F: --relax and -r may not be used together\n"));
1709
28c9d252 1710 htab = avr_link_hash_table (link_info);
64ee10b6
NC		 1711 if (htab == NULL)
1712 return FALSE;
df406460
NC		 1713
1714 /* Assume nothing changes. */
1715 *again = FALSE;
1716
28c9d252
NC		 1717 if ((!htab->no_stubs) && (sec == htab->stub_sec))
1718 {
1719 /* We are just relaxing the stub section.
1720 Let's calculate the size needed again. */
1721 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
1722
1723 if (debug_relax)
1724 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
1725 (int) last_estimated_stub_section_size);
1726
1727 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
1728 link_info, FALSE);
1729
1730 /* Check if the number of trampolines changed. */
1731 if (last_estimated_stub_section_size != htab->stub_sec->size)
1732 *again = TRUE;
1733
1734 if (debug_relax)
1735 printf ("Size of stub section after this pass: %i\n",
1736 (int) htab->stub_sec->size);
1737
1738 return TRUE;
1739 }
1740
df406460
NC		 1741 /* We don't have to do anything for a relocatable link, if
1742 this section does not have relocs, or if this is not a
1743 code section. */
1744 if (link_info->relocatable
1745 || (sec->flags & SEC_RELOC) == 0
1746 || sec->reloc_count == 0
1747 || (sec->flags & SEC_CODE) == 0)
1748 return TRUE;
4cdc7696 1749
df406460
NC		 1750 /* Check if the object file to relax uses internal symbols so that we
1751 could fix up the relocations. */
df406460
NC		 1752 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1753 return TRUE;
df406460
NC		 1754
1755 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1756
1757 /* Get a copy of the native relocations. */
1758 internal_relocs = (_bfd_elf_link_read_relocs
4cdc7696 1759 (abfd, sec, NULL, NULL, link_info->keep_memory));
df406460
NC		 1760 if (internal_relocs == NULL)
1761 goto error_return;
1762
df406460
NC		 1763 /* Walk through the relocs looking for relaxing opportunities. */
1764 irelend = internal_relocs + sec->reloc_count;
1765 for (irel = internal_relocs; irel < irelend; irel++)
1766 {
1767 bfd_vma symval;
1768
4cdc7696 1769 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
91d6fa6a
NC		 1770 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1771 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
df406460 1772 continue;
4cdc7696 1773
df406460
NC		 1774 /* Get the section contents if we haven't done so already. */
1775 if (contents == NULL)
1776 {
1777 /* Get cached copy if it exists. */
1778 if (elf_section_data (sec)->this_hdr.contents != NULL)
1779 contents = elf_section_data (sec)->this_hdr.contents;
1780 else
1781 {
1782 /* Go get them off disk. */
4cdc7696 1783 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
df406460
NC		 1784 goto error_return;
1785 }
1786 }
1787
91d6fa6a 1788 /* Read this BFD's local symbols if we haven't done so already. */
df406460
NC		 1789 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1790 {
1791 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1792 if (isymbuf == NULL)
1793 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1794 symtab_hdr->sh_info, 0,
1795 NULL, NULL, NULL);
1796 if (isymbuf == NULL)
1797 goto error_return;
1798 }
1799
1800
1801 /* Get the value of the symbol referred to by the reloc. */
1802 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1803 {
1804 /* A local symbol. */
1805 Elf_Internal_Sym *isym;
1806 asection *sym_sec;
1807
1808 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1809 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1810 symval = isym->st_value;
1811 /* If the reloc is absolute, it will not have
1812 a symbol or section associated with it. */
1813 if (sym_sec)
1814 symval += sym_sec->output_section->vma
1815 + sym_sec->output_offset;
1816 }
1817 else
1818 {
1819 unsigned long indx;
1820 struct elf_link_hash_entry *h;
1821
1822 /* An external symbol. */
1823 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1824 h = elf_sym_hashes (abfd)[indx];
1825 BFD_ASSERT (h != NULL);
1826 if (h->root.type != bfd_link_hash_defined
1827 && h->root.type != bfd_link_hash_defweak)
4cdc7696
NC		 1828 /* This appears to be a reference to an undefined
1829 symbol. Just ignore it--it will be caught by the
1830 regular reloc processing. */
1831 continue;
1832
df406460
NC		 1833 symval = (h->root.u.def.value
1834 + h->root.u.def.section->output_section->vma
1835 + h->root.u.def.section->output_offset);
1836 }
1837
1838 /* For simplicity of coding, we are going to modify the section
1839 contents, the section relocs, and the BFD symbol table. We
1840 must tell the rest of the code not to free up this
1841 information. It would be possible to instead create a table
1842 of changes which have to be made, as is done in coff-mips.c;
1843 that would be more work, but would require less memory when
1844 the linker is run. */
1845 switch (ELF32_R_TYPE (irel->r_info))
1846 {
91d6fa6a
NC		 1847 /* Try to turn a 22-bit absolute call/jump into an 13-bit
1848 pc-relative rcall/rjmp. */
1849 case R_AVR_CALL:
df406460
NC		 1850 {
1851 bfd_vma value = symval + irel->r_addend;
1852 bfd_vma dot, gap;
1853 int distance_short_enough = 0;
1854
1855 /* Get the address of this instruction. */
1856 dot = (sec->output_section->vma
1857 + sec->output_offset + irel->r_offset);
1858
1859 /* Compute the distance from this insn to the branch target. */
1860 gap = value - dot;
1861
526f25b2
EW		 1862 /* Check if the gap falls in the range that can be accommodated
1863 in 13bits signed (It is 12bits when encoded, as we deal with
1864 word addressing). */
1865 if (!shrinkable && ((int) gap >= -4096 && (int) gap <= 4095))
1866 distance_short_enough = 1;
1867 /* If shrinkable, then we can check for a range of distance which
1868 is two bytes farther on both the directions because the call
68ffbac6 1869 or jump target will be closer by two bytes after the
526f25b2
EW		 1870 relaxation. */
1871 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4097))
df406460
NC		 1872 distance_short_enough = 1;
1873
1874 /* Here we handle the wrap-around case. E.g. for a 16k device
4cdc7696 1875 we could use a rjmp to jump from address 0x100 to 0x3d00!
df406460
NC		 1876 In order to make this work properly, we need to fill the
1877 vaiable avr_pc_wrap_around with the appropriate value.
1878 I.e. 0x4000 for a 16k device. */
1879 {
91d6fa6a
NC		 1880 /* Shrinking the code size makes the gaps larger in the
1881 case of wrap-arounds. So we use a heuristical safety
1882 margin to avoid that during relax the distance gets
1883 again too large for the short jumps. Let's assume
1884 a typical code-size reduction due to relax for a
1885 16k device of 600 bytes. So let's use twice the
1886 typical value as safety margin. */
1887 int rgap;
1888 int safety_margin;
1889
1890 int assumed_shrink = 600;
1891 if (avr_pc_wrap_around > 0x4000)
1892 assumed_shrink = 900;
1893
1894 safety_margin = 2 * assumed_shrink;
1895
1896 rgap = avr_relative_distance_considering_wrap_around (gap);
1897
1898 if (rgap >= (-4092 + safety_margin)
1899 && rgap <= (4094 - safety_margin))
1900 distance_short_enough = 1;
4cdc7696 1901 }
df406460
NC		 1902
1903 if (distance_short_enough)
1904 {
1905 unsigned char code_msb;
1906 unsigned char code_lsb;
1907
28c9d252 1908 if (debug_relax)
df406460
NC		 1909 printf ("shrinking jump/call instruction at address 0x%x"
1910 " in section %s\n\n",
1911 (int) dot, sec->name);
1912
1913 /* Note that we've changed the relocs, section contents,
1914 etc. */
1915 elf_section_data (sec)->relocs = internal_relocs;
1916 elf_section_data (sec)->this_hdr.contents = contents;
1917 symtab_hdr->contents = (unsigned char *) isymbuf;
1918
1919 /* Get the instruction code for relaxing. */
1920 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
1921 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1922
1923 /* Mask out the relocation bits. */
1924 code_msb &= 0x94;
1925 code_lsb &= 0x0E;
1926 if (code_msb == 0x94 && code_lsb == 0x0E)
1927 {
1928 /* we are changing call -> rcall . */
1929 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1930 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
1931 }
1932 else if (code_msb == 0x94 && code_lsb == 0x0C)
1933 {
1934 /* we are changeing jump -> rjmp. */
1935 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1936 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
1937 }
4cdc7696 1938 else
df406460
NC		 1939 abort ();
1940
1941 /* Fix the relocation's type. */
1942 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1943 R_AVR_13_PCREL);
1944
526f25b2 1945 /* We should not modify the ordering if 'shrinkable' is
68ffbac6 1946 FALSE. */
526f25b2 1947 if (!shrinkable)
df406460
NC		 1948 {
1949 /* Let's insert a nop. */
1950 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
1951 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
1952 }
1953 else
1954 {
1955 /* Delete two bytes of data. */
1956 if (!elf32_avr_relax_delete_bytes (abfd, sec,
1957 irel->r_offset + 2, 2))
1958 goto error_return;
1959
1960 /* That will change things, so, we should relax again.
1961 Note that this is not required, and it may be slow. */
1962 *again = TRUE;
1963 }
1964 }
1965 }
4cdc7696 1966
df406460
NC		 1967 default:
1968 {
1969 unsigned char code_msb;
1970 unsigned char code_lsb;
1971 bfd_vma dot;
1972
1973 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1974 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
1975
1976 /* Get the address of this instruction. */
1977 dot = (sec->output_section->vma
1978 + sec->output_offset + irel->r_offset);
4cdc7696
NC		 1979
1980 /* Here we look for rcall/ret or call/ret sequences that could be
28c9d252
NC		 1981 safely replaced by rjmp/ret or jmp/ret. */
1982 if (((code_msb & 0xf0) == 0xd0)
1983 && avr_replace_call_ret_sequences)
df406460
NC		 1984 {
1985 /* This insn is a rcall. */
1986 unsigned char next_insn_msb = 0;
1987 unsigned char next_insn_lsb = 0;
1988
1989 if (irel->r_offset + 3 < sec->size)
1990 {
4cdc7696 1991 next_insn_msb =
91d6fa6a 1992 bfd_get_8 (abfd, contents + irel->r_offset + 3);
4cdc7696 1993 next_insn_lsb =
91d6fa6a 1994 bfd_get_8 (abfd, contents + irel->r_offset + 2);
df406460 1995 }
4cdc7696
NC		 1996
1997 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
df406460
NC		 1998 {
1999 /* The next insn is a ret. We now convert the rcall insn
2000 into a rjmp instruction. */
df406460
NC		 2001 code_msb &= 0xef;
2002 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
28c9d252 2003 if (debug_relax)
df406460
NC		 2004 printf ("converted rcall/ret sequence at address 0x%x"
2005 " into rjmp/ret sequence. Section is %s\n\n",
2006 (int) dot, sec->name);
2007 *again = TRUE;
2008 break;
2009 }
2010 }
2011 else if ((0x94 == (code_msb & 0xfe))
28c9d252
NC		 2012 && (0x0e == (code_lsb & 0x0e))
2013 && avr_replace_call_ret_sequences)
df406460
NC		 2014 {
2015 /* This insn is a call. */
2016 unsigned char next_insn_msb = 0;
2017 unsigned char next_insn_lsb = 0;
2018
2019 if (irel->r_offset + 5 < sec->size)
2020 {
2021 next_insn_msb =
91d6fa6a 2022 bfd_get_8 (abfd, contents + irel->r_offset + 5);
df406460 2023 next_insn_lsb =
91d6fa6a 2024 bfd_get_8 (abfd, contents + irel->r_offset + 4);
df406460 2025 }
4cdc7696 2026
df406460
NC		 2027 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2028 {
2029 /* The next insn is a ret. We now convert the call insn
2030 into a jmp instruction. */
2031
2032 code_lsb &= 0xfd;
2033 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
28c9d252 2034 if (debug_relax)
df406460
NC		 2035 printf ("converted call/ret sequence at address 0x%x"
2036 " into jmp/ret sequence. Section is %s\n\n",
2037 (int) dot, sec->name);
2038 *again = TRUE;
2039 break;
2040 }
2041 }
4cdc7696
NC		 2042 else if ((0xc0 == (code_msb & 0xf0))
2043 || ((0x94 == (code_msb & 0xfe))
df406460
NC		 2044 && (0x0c == (code_lsb & 0x0e))))
2045 {
4cdc7696 2046 /* This insn is a rjmp or a jmp. */
df406460
NC		 2047 unsigned char next_insn_msb = 0;
2048 unsigned char next_insn_lsb = 0;
2049 int insn_size;
2050
2051 if (0xc0 == (code_msb & 0xf0))
2052 insn_size = 2; /* rjmp insn */
2053 else
2054 insn_size = 4; /* jmp insn */
2055
2056 if (irel->r_offset + insn_size + 1 < sec->size)
2057 {
4cdc7696 2058 next_insn_msb =
91d6fa6a
NC		 2059 bfd_get_8 (abfd, contents + irel->r_offset
2060 + insn_size + 1);
4cdc7696 2061 next_insn_lsb =
91d6fa6a
NC		 2062 bfd_get_8 (abfd, contents + irel->r_offset
2063 + insn_size);
df406460
NC		 2064 }
2065
2066 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2067 {
2068 /* The next insn is a ret. We possibly could delete
cc643b88 2069 this ret. First we need to check for preceding
df406460
NC		 2070 sbis/sbic/sbrs or cpse "skip" instructions. */
2071
cc643b88 2072 int there_is_preceding_non_skip_insn = 1;
df406460
NC		 2073 bfd_vma address_of_ret;
2074
2075 address_of_ret = dot + insn_size;
2076
28c9d252 2077 if (debug_relax && (insn_size == 2))
4cdc7696 2078 printf ("found rjmp / ret sequence at address 0x%x\n",
df406460 2079 (int) dot);
28c9d252 2080 if (debug_relax && (insn_size == 4))
4cdc7696 2081 printf ("found jmp / ret sequence at address 0x%x\n",
df406460
NC		 2082 (int) dot);
2083
cc643b88 2084 /* We have to make sure that there is a preceding insn. */
df406460
NC		 2085 if (irel->r_offset >= 2)
2086 {
cc643b88
NC		 2087 unsigned char preceding_msb;
2088 unsigned char preceding_lsb;
2089
2090 preceding_msb =
91d6fa6a 2091 bfd_get_8 (abfd, contents + irel->r_offset - 1);
cc643b88 2092 preceding_lsb =
91d6fa6a 2093 bfd_get_8 (abfd, contents + irel->r_offset - 2);
df406460
NC		 2094
2095 /* sbic. */
cc643b88
NC		 2096 if (0x99 == preceding_msb)
2097 there_is_preceding_non_skip_insn = 0;
df406460
NC		 2098
2099 /* sbis. */
cc643b88
NC		 2100 if (0x9b == preceding_msb)
2101 there_is_preceding_non_skip_insn = 0;
df406460
NC		 2102
2103 /* sbrc */
cc643b88
NC		 2104 if ((0xfc == (preceding_msb & 0xfe)
2105 && (0x00 == (preceding_lsb & 0x08))))
2106 there_is_preceding_non_skip_insn = 0;
df406460 2107
4cdc7696 2108 /* sbrs */
cc643b88
NC		 2109 if ((0xfe == (preceding_msb & 0xfe)
2110 && (0x00 == (preceding_lsb & 0x08))))
2111 there_is_preceding_non_skip_insn = 0;
4cdc7696 2112
df406460 2113 /* cpse */
cc643b88
NC		 2114 if (0x10 == (preceding_msb & 0xfc))
2115 there_is_preceding_non_skip_insn = 0;
4cdc7696 2116
cc643b88 2117 if (there_is_preceding_non_skip_insn == 0)
28c9d252 2118 if (debug_relax)
cc643b88
NC		 2119 printf ("preceding skip insn prevents deletion of"
2120 " ret insn at Addy 0x%x in section %s\n",
df406460
NC		 2121 (int) dot + 2, sec->name);
2122 }
2123 else
2124 {
2125 /* There is no previous instruction. */
cc643b88 2126 there_is_preceding_non_skip_insn = 0;
4cdc7696 2127 }
df406460 2128
cc643b88 2129 if (there_is_preceding_non_skip_insn)
df406460
NC		 2130 {
2131 /* We now only have to make sure that there is no
2132 local label defined at the address of the ret
2133 instruction and that there is no local relocation
2134 in this section pointing to the ret. */
2135
2136 int deleting_ret_is_safe = 1;
4cdc7696 2137 unsigned int section_offset_of_ret_insn =
91d6fa6a 2138 irel->r_offset + insn_size;
df406460
NC		 2139 Elf_Internal_Sym *isym, *isymend;
2140 unsigned int sec_shndx;
4cdc7696
NC		 2141
2142 sec_shndx =
2143 _bfd_elf_section_from_bfd_section (abfd, sec);
df406460
NC		 2144
2145 /* Check for local symbols. */
2146 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2147 isymend = isym + symtab_hdr->sh_info;
696b7ad2
NC		 2148 /* PR 6019: There may not be any local symbols. */
2149 for (; isym != NULL && isym < isymend; isym++)
91d6fa6a
NC		 2150 {
2151 if (isym->st_value == section_offset_of_ret_insn
2152 && isym->st_shndx == sec_shndx)
2153 {
2154 deleting_ret_is_safe = 0;
2155 if (debug_relax)
2156 printf ("local label prevents deletion of ret "
2157 "insn at address 0x%x\n",
2158 (int) dot + insn_size);
2159 }
2160 }
2161
2162 /* Now check for global symbols. */
2163 {
2164 int symcount;
2165 struct elf_link_hash_entry **sym_hashes;
2166 struct elf_link_hash_entry **end_hashes;
2167
2168 symcount = (symtab_hdr->sh_size
2169 / sizeof (Elf32_External_Sym)
2170 - symtab_hdr->sh_info);
2171 sym_hashes = elf_sym_hashes (abfd);
2172 end_hashes = sym_hashes + symcount;
2173 for (; sym_hashes < end_hashes; sym_hashes++)
2174 {
2175 struct elf_link_hash_entry *sym_hash =
2176 *sym_hashes;
2177 if ((sym_hash->root.type == bfd_link_hash_defined
2178 || sym_hash->root.type ==
4cdc7696 2179 bfd_link_hash_defweak)
91d6fa6a
NC		 2180 && sym_hash->root.u.def.section == sec
2181 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2182 {
2183 deleting_ret_is_safe = 0;
2184 if (debug_relax)
2185 printf ("global label prevents deletion of "
2186 "ret insn at address 0x%x\n",
2187 (int) dot + insn_size);
2188 }
2189 }
2190 }
2191 /* Now we check for relocations pointing to ret. */
2192 {
2193 Elf_Internal_Rela *rel;
2194 Elf_Internal_Rela *relend;
2195
2196 relend = elf_section_data (sec)->relocs
2197 + sec->reloc_count;
2198
2199 for (rel = elf_section_data (sec)->relocs;
2200 rel < relend; rel++)
2201 {
2202 bfd_vma reloc_target = 0;
2203
2204 /* Read this BFD's local symbols if we haven't
2205 done so already. */
2206 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2207 {
2208 isymbuf = (Elf_Internal_Sym *)
2209 symtab_hdr->contents;
2210 if (isymbuf == NULL)
2211 isymbuf = bfd_elf_get_elf_syms
2212 (abfd,
2213 symtab_hdr,
2214 symtab_hdr->sh_info, 0,
2215 NULL, NULL, NULL);
2216 if (isymbuf == NULL)
2217 break;
2218 }
2219
2220 /* Get the value of the symbol referred to
2221 by the reloc. */
2222 if (ELF32_R_SYM (rel->r_info)
2223 < symtab_hdr->sh_info)
2224 {
2225 /* A local symbol. */
2226 asection *sym_sec;
2227
2228 isym = isymbuf
2229 + ELF32_R_SYM (rel->r_info);
2230 sym_sec = bfd_section_from_elf_index
2231 (abfd, isym->st_shndx);
2232 symval = isym->st_value;
2233
2234 /* If the reloc is absolute, it will not
2235 have a symbol or section associated
2236 with it. */
2237
2238 if (sym_sec)
2239 {
2240 symval +=
2241 sym_sec->output_section->vma
2242 + sym_sec->output_offset;
2243 reloc_target = symval + rel->r_addend;
2244 }
2245 else
2246 {
2247 reloc_target = symval + rel->r_addend;
2248 /* Reference symbol is absolute. */
2249 }
2250 }
2251 /* else ... reference symbol is extern. */
2252
2253 if (address_of_ret == reloc_target)
2254 {
2255 deleting_ret_is_safe = 0;
2256 if (debug_relax)
2257 printf ("ret from "
2258 "rjmp/jmp ret sequence at address"
2259 " 0x%x could not be deleted. ret"
2260 " is target of a relocation.\n",
2261 (int) address_of_ret);
2262 }
2263 }
2264 }
2265
2266 if (deleting_ret_is_safe)
2267 {
2268 if (debug_relax)
2269 printf ("unreachable ret instruction "
2270 "at address 0x%x deleted.\n",
2271 (int) dot + insn_size);
2272
2273 /* Delete two bytes of data. */
2274 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2275 irel->r_offset + insn_size, 2))
2276 goto error_return;
2277
2278 /* That will change things, so, we should relax
2279 again. Note that this is not required, and it
2280 may be slow. */
2281 *again = TRUE;
2282 break;
2283 }
df406460 2284 }
4cdc7696
NC		 2285
2286 }
2287 }
df406460
NC		 2288 break;
2289 }
2290 }
2291 }
2292
2293 if (contents != NULL
2294 && elf_section_data (sec)->this_hdr.contents != contents)
2295 {
2296 if (! link_info->keep_memory)
2297 free (contents);
2298 else
2299 {
2300 /* Cache the section contents for elf_link_input_bfd. */
2301 elf_section_data (sec)->this_hdr.contents = contents;
2302 }
2303 }
2304
2305 if (internal_relocs != NULL
2306 && elf_section_data (sec)->relocs != internal_relocs)
2307 free (internal_relocs);
2308
2309 return TRUE;
2310
2311 error_return:
2312 if (isymbuf != NULL
2313 && symtab_hdr->contents != (unsigned char *) isymbuf)
2314 free (isymbuf);
2315 if (contents != NULL
2316 && elf_section_data (sec)->this_hdr.contents != contents)
2317 free (contents);
2318 if (internal_relocs != NULL
2319 && elf_section_data (sec)->relocs != internal_relocs)
2320 free (internal_relocs);
2321
4cdc7696 2322 return FALSE;
df406460
NC		 2323}
2324
2325/* This is a version of bfd_generic_get_relocated_section_contents
4cdc7696 2326 which uses elf32_avr_relocate_section.
df406460 2327
4cdc7696 2328 For avr it's essentially a cut and paste taken from the H8300 port.
df406460 2329 The author of the relaxation support patch for avr had absolutely no
4cdc7696 2330 clue what is happening here but found out that this part of the code
df406460
NC		 2331 seems to be important. */
2332
2333static bfd_byte *
2334elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2335 struct bfd_link_info *link_info,
2336 struct bfd_link_order *link_order,
2337 bfd_byte *data,
2338 bfd_boolean relocatable,
2339 asymbol **symbols)
2340{
2341 Elf_Internal_Shdr *symtab_hdr;
2342 asection *input_section = link_order->u.indirect.section;
2343 bfd *input_bfd = input_section->owner;
2344 asection **sections = NULL;
2345 Elf_Internal_Rela *internal_relocs = NULL;
2346 Elf_Internal_Sym *isymbuf = NULL;
2347
2348 /* We only need to handle the case of relaxing, or of having a
2349 particular set of section contents, specially. */
2350 if (relocatable
2351 || elf_section_data (input_section)->this_hdr.contents == NULL)
2352 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2353 link_order, data,
2354 relocatable,
2355 symbols);
2356 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2357
2358 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2359 (size_t) input_section->size);
2360
2361 if ((input_section->flags & SEC_RELOC) != 0
2362 && input_section->reloc_count > 0)
2363 {
2364 asection **secpp;
2365 Elf_Internal_Sym *isym, *isymend;
2366 bfd_size_type amt;
2367
2368 internal_relocs = (_bfd_elf_link_read_relocs
4cdc7696 2369 (input_bfd, input_section, NULL, NULL, FALSE));
df406460
NC		 2370 if (internal_relocs == NULL)
2371 goto error_return;
2372
2373 if (symtab_hdr->sh_info != 0)
2374 {
2375 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2376 if (isymbuf == NULL)
2377 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2378 symtab_hdr->sh_info, 0,
2379 NULL, NULL, NULL);
2380 if (isymbuf == NULL)
2381 goto error_return;
2382 }
2383
2384 amt = symtab_hdr->sh_info;
2385 amt *= sizeof (asection *);
4cdc7696 2386 sections = bfd_malloc (amt);
df406460
NC		 2387 if (sections == NULL && amt != 0)
2388 goto error_return;
2389
2390 isymend = isymbuf + symtab_hdr->sh_info;
2391 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2392 {
2393 asection *isec;
2394
2395 if (isym->st_shndx == SHN_UNDEF)
2396 isec = bfd_und_section_ptr;
2397 else if (isym->st_shndx == SHN_ABS)
2398 isec = bfd_abs_section_ptr;
2399 else if (isym->st_shndx == SHN_COMMON)
2400 isec = bfd_com_section_ptr;
2401 else
2402 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2403
2404 *secpp = isec;
2405 }
2406
2407 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2408 input_section, data, internal_relocs,
2409 isymbuf, sections))
2410 goto error_return;
2411
2412 if (sections != NULL)
2413 free (sections);
2414 if (isymbuf != NULL
2415 && symtab_hdr->contents != (unsigned char *) isymbuf)
2416 free (isymbuf);
2417 if (elf_section_data (input_section)->relocs != internal_relocs)
2418 free (internal_relocs);
2419 }
2420
2421 return data;
2422
2423 error_return:
2424 if (sections != NULL)
2425 free (sections);
2426 if (isymbuf != NULL
2427 && symtab_hdr->contents != (unsigned char *) isymbuf)
2428 free (isymbuf);
2429 if (internal_relocs != NULL
2430 && elf_section_data (input_section)->relocs != internal_relocs)
2431 free (internal_relocs);
2432 return NULL;
2433}
2434
2435
28c9d252
NC		 2436/* Determines the hash entry name for a particular reloc. It consists of
2437 the identifier of the symbol section and the added reloc addend and
2438 symbol offset relative to the section the symbol is attached to. */
2439
2440static char *
2441avr_stub_name (const asection *symbol_section,
2442 const bfd_vma symbol_offset,
2443 const Elf_Internal_Rela *rela)
2444{
2445 char *stub_name;
2446 bfd_size_type len;
2447
2448 len = 8 + 1 + 8 + 1 + 1;
2449 stub_name = bfd_malloc (len);
2450
2451 sprintf (stub_name, "%08x+%08x",
2452 symbol_section->id & 0xffffffff,
2453 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2454
2455 return stub_name;
2456}
2457
2458
2459/* Add a new stub entry to the stub hash. Not all fields of the new
2460 stub entry are initialised. */
2461
2462static struct elf32_avr_stub_hash_entry *
2463avr_add_stub (const char *stub_name,
2464 struct elf32_avr_link_hash_table *htab)
2465{
2466 struct elf32_avr_stub_hash_entry *hsh;
2467
2468 /* Enter this entry into the linker stub hash table. */
2469 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2470
2471 if (hsh == NULL)
2472 {
2473 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2474 NULL, stub_name);
2475 return NULL;
2476 }
2477
2478 hsh->stub_offset = 0;
2479 return hsh;
2480}
2481
2482/* We assume that there is already space allocated for the stub section
2483 contents and that before building the stubs the section size is
2484 initialized to 0. We assume that within the stub hash table entry,
2485 the absolute position of the jmp target has been written in the
2486 target_value field. We write here the offset of the generated jmp insn
2487 relative to the trampoline section start to the stub_offset entry in
2488 the stub hash table entry. */
2489
2490static bfd_boolean
2491avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2492{
2493 struct elf32_avr_stub_hash_entry *hsh;
2494 struct bfd_link_info *info;
2495 struct elf32_avr_link_hash_table *htab;
2496 bfd *stub_bfd;
2497 bfd_byte *loc;
2498 bfd_vma target;
2499 bfd_vma starget;
2500
2501 /* Basic opcode */
2502 bfd_vma jmp_insn = 0x0000940c;
2503
2504 /* Massage our args to the form they really have. */
2505 hsh = avr_stub_hash_entry (bh);
2506
2507 if (!hsh->is_actually_needed)
2508 return TRUE;
2509
2510 info = (struct bfd_link_info *) in_arg;
2511
2512 htab = avr_link_hash_table (info);
64ee10b6
NC		 2513 if (htab == NULL)
2514 return FALSE;
28c9d252
NC		 2515
2516 target = hsh->target_value;
2517
2518 /* Make a note of the offset within the stubs for this entry. */
2519 hsh->stub_offset = htab->stub_sec->size;
2520 loc = htab->stub_sec->contents + hsh->stub_offset;
2521
2522 stub_bfd = htab->stub_sec->owner;
2523
2524 if (debug_stubs)
2525 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2526 (unsigned int) target,
2527 (unsigned int) hsh->stub_offset);
2528
2529 /* We now have to add the information on the jump target to the bare
2530 opcode bits already set in jmp_insn. */
2531
2532 /* Check for the alignment of the address. */
2533 if (target & 1)
2534 return FALSE;
2535
2536 starget = target >> 1;
2537 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2538 bfd_put_16 (stub_bfd, jmp_insn, loc);
2539 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2540
2541 htab->stub_sec->size += 4;
2542
2543 /* Now add the entries in the address mapping table if there is still
2544 space left. */
2545 {
2546 unsigned int nr;
2547
2548 nr = htab->amt_entry_cnt + 1;
2549 if (nr <= htab->amt_max_entry_cnt)
2550 {
2551 htab->amt_entry_cnt = nr;
2552
2553 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2554 htab->amt_destination_addr[nr - 1] = target;
2555 }
2556 }
2557
2558 return TRUE;
2559}
2560
2561static bfd_boolean
2562avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
c7e2358a 2563 void *in_arg ATTRIBUTE_UNUSED)
28c9d252
NC		 2564{
2565 struct elf32_avr_stub_hash_entry *hsh;
28c9d252 2566
28c9d252
NC		 2567 hsh = avr_stub_hash_entry (bh);
2568 hsh->is_actually_needed = FALSE;
2569
2570 return TRUE;
2571}
2572
2573static bfd_boolean
2574avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2575{
2576 struct elf32_avr_stub_hash_entry *hsh;
2577 struct elf32_avr_link_hash_table *htab;
2578 int size;
2579
2580 /* Massage our args to the form they really have. */
2581 hsh = avr_stub_hash_entry (bh);
2582 htab = in_arg;
2583
2584 if (hsh->is_actually_needed)
2585 size = 4;
2586 else
2587 size = 0;
2588
2589 htab->stub_sec->size += size;
2590 return TRUE;
2591}
2592
2593void
2594elf32_avr_setup_params (struct bfd_link_info *info,
2595 bfd *avr_stub_bfd,
2596 asection *avr_stub_section,
2597 bfd_boolean no_stubs,
2598 bfd_boolean deb_stubs,
2599 bfd_boolean deb_relax,
2600 bfd_vma pc_wrap_around,
2601 bfd_boolean call_ret_replacement)
2602{
64ee10b6 2603 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
28c9d252 2604
64ee10b6
NC		 2605 if (htab == NULL)
2606 return;
28c9d252
NC		 2607 htab->stub_sec = avr_stub_section;
2608 htab->stub_bfd = avr_stub_bfd;
2609 htab->no_stubs = no_stubs;
2610
2611 debug_relax = deb_relax;
2612 debug_stubs = deb_stubs;
2613 avr_pc_wrap_around = pc_wrap_around;
2614 avr_replace_call_ret_sequences = call_ret_replacement;
2615}
2616
2617
2618/* Set up various things so that we can make a list of input sections
2619 for each output section included in the link. Returns -1 on error,
2620 0 when no stubs will be needed, and 1 on success. It also sets
2621 information on the stubs bfd and the stub section in the info
2622 struct. */
2623
2624int
2625elf32_avr_setup_section_lists (bfd *output_bfd,
2626 struct bfd_link_info *info)
2627{
2628 bfd *input_bfd;
2629 unsigned int bfd_count;
2630 int top_id, top_index;
2631 asection *section;
2632 asection **input_list, **list;
2633 bfd_size_type amt;
4dfe6ac6 2634 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
28c9d252 2635
64ee10b6 2636 if (htab == NULL || htab->no_stubs)
28c9d252
NC		 2637 return 0;
2638
2639 /* Count the number of input BFDs and find the top input section id. */
2640 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2641 input_bfd != NULL;
2642 input_bfd = input_bfd->link_next)
2643 {
2644 bfd_count += 1;
2645 for (section = input_bfd->sections;
2646 section != NULL;
2647 section = section->next)
2648 if (top_id < section->id)
2649 top_id = section->id;
2650 }
2651
2652 htab->bfd_count = bfd_count;
2653
2654 /* We can't use output_bfd->section_count here to find the top output
2655 section index as some sections may have been removed, and
2656 strip_excluded_output_sections doesn't renumber the indices. */
2657 for (section = output_bfd->sections, top_index = 0;
2658 section != NULL;
2659 section = section->next)
2660 if (top_index < section->index)
2661 top_index = section->index;
2662
2663 htab->top_index = top_index;
2664 amt = sizeof (asection *) * (top_index + 1);
2665 input_list = bfd_malloc (amt);
2666 htab->input_list = input_list;
2667 if (input_list == NULL)
2668 return -1;
2669
2670 /* For sections we aren't interested in, mark their entries with a
2671 value we can check later. */
2672 list = input_list + top_index;
2673 do
2674 *list = bfd_abs_section_ptr;
2675 while (list-- != input_list);
2676
2677 for (section = output_bfd->sections;
2678 section != NULL;
2679 section = section->next)
2680 if ((section->flags & SEC_CODE) != 0)
2681 input_list[section->index] = NULL;
2682
2683 return 1;
2684}
2685
2686
2687/* Read in all local syms for all input bfds, and create hash entries
2688 for export stubs if we are building a multi-subspace shared lib.
2689 Returns -1 on error, 0 otherwise. */
2690
2691static int
2692get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2693{
2694 unsigned int bfd_indx;
2695 Elf_Internal_Sym *local_syms, **all_local_syms;
2696 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
9a008db3 2697 bfd_size_type amt;
28c9d252 2698
64ee10b6
NC		 2699 if (htab == NULL)
2700 return -1;
2701
28c9d252
NC		 2702 /* We want to read in symbol extension records only once. To do this
2703 we need to read in the local symbols in parallel and save them for
2704 later use; so hold pointers to the local symbols in an array. */
9a008db3 2705 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
28c9d252
NC		 2706 all_local_syms = bfd_zmalloc (amt);
2707 htab->all_local_syms = all_local_syms;
2708 if (all_local_syms == NULL)
2709 return -1;
2710
2711 /* Walk over all the input BFDs, swapping in local symbols.
2712 If we are creating a shared library, create hash entries for the
2713 export stubs. */
2714 for (bfd_indx = 0;
2715 input_bfd != NULL;
2716 input_bfd = input_bfd->link_next, bfd_indx++)
2717 {
2718 Elf_Internal_Shdr *symtab_hdr;
2719
2720 /* We'll need the symbol table in a second. */
2721 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2722 if (symtab_hdr->sh_info == 0)
2723 continue;
2724
2725 /* We need an array of the local symbols attached to the input bfd. */
2726 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2727 if (local_syms == NULL)
2728 {
2729 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2730 symtab_hdr->sh_info, 0,
2731 NULL, NULL, NULL);
2732 /* Cache them for elf_link_input_bfd. */
2733 symtab_hdr->contents = (unsigned char *) local_syms;
2734 }
2735 if (local_syms == NULL)
2736 return -1;
2737
2738 all_local_syms[bfd_indx] = local_syms;
2739 }
2740
2741 return 0;
2742}
2743
2744#define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
2745
2746bfd_boolean
2747elf32_avr_size_stubs (bfd *output_bfd,
2748 struct bfd_link_info *info,
2749 bfd_boolean is_prealloc_run)
2750{
64ee10b6
NC		 2751 struct elf32_avr_link_hash_table *htab;
2752 int stub_changed = 0;
28c9d252 2753
64ee10b6
NC		 2754 htab = avr_link_hash_table (info);
2755 if (htab == NULL)
2756 return FALSE;
28c9d252 2757
64ee10b6
NC		 2758 /* At this point we initialize htab->vector_base
2759 To the start of the text output section. */
2760 htab->vector_base = htab->stub_sec->output_section->vma;
28c9d252 2761
64ee10b6
NC		 2762 if (get_local_syms (info->input_bfds, info))
2763 {
2764 if (htab->all_local_syms)
2765 goto error_ret_free_local;
2766 return FALSE;
2767 }
28c9d252
NC		 2768
2769 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
2770 {
2771 struct elf32_avr_stub_hash_entry *test;
2772
2773 test = avr_add_stub ("Hugo",htab);
2774 test->target_value = 0x123456;
2775 test->stub_offset = 13;
2776
2777 test = avr_add_stub ("Hugo2",htab);
2778 test->target_value = 0x84210;
2779 test->stub_offset = 14;
2780 }
2781
2782 while (1)
2783 {
2784 bfd *input_bfd;
2785 unsigned int bfd_indx;
2786
2787 /* We will have to re-generate the stub hash table each time anything
2788 in memory has changed. */
2789
2790 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
2791 for (input_bfd = info->input_bfds, bfd_indx = 0;
2792 input_bfd != NULL;
2793 input_bfd = input_bfd->link_next, bfd_indx++)
2794 {
2795 Elf_Internal_Shdr *symtab_hdr;
2796 asection *section;
2797 Elf_Internal_Sym *local_syms;
2798
2799 /* We'll need the symbol table in a second. */
2800 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2801 if (symtab_hdr->sh_info == 0)
2802 continue;
2803
2804 local_syms = htab->all_local_syms[bfd_indx];
2805
2806 /* Walk over each section attached to the input bfd. */
2807 for (section = input_bfd->sections;
2808 section != NULL;
2809 section = section->next)
2810 {
2811 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2812
2813 /* If there aren't any relocs, then there's nothing more
2814 to do. */
2815 if ((section->flags & SEC_RELOC) == 0
2816 || section->reloc_count == 0)
2817 continue;
2818
2819 /* If this section is a link-once section that will be
2820 discarded, then don't create any stubs. */
2821 if (section->output_section == NULL
2822 || section->output_section->owner != output_bfd)
2823 continue;
2824
2825 /* Get the relocs. */
2826 internal_relocs
2827 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2828 info->keep_memory);
2829 if (internal_relocs == NULL)
2830 goto error_ret_free_local;
2831
2832 /* Now examine each relocation. */
2833 irela = internal_relocs;
2834 irelaend = irela + section->reloc_count;
2835 for (; irela < irelaend; irela++)
2836 {
2837 unsigned int r_type, r_indx;
2838 struct elf32_avr_stub_hash_entry *hsh;
2839 asection *sym_sec;
2840 bfd_vma sym_value;
2841 bfd_vma destination;
2842 struct elf_link_hash_entry *hh;
2843 char *stub_name;
2844
2845 r_type = ELF32_R_TYPE (irela->r_info);
2846 r_indx = ELF32_R_SYM (irela->r_info);
2847
2848 /* Only look for 16 bit GS relocs. No other reloc will need a
2849 stub. */
2850 if (!((r_type == R_AVR_16_PM)
2851 || (r_type == R_AVR_LO8_LDI_GS)
2852 || (r_type == R_AVR_HI8_LDI_GS)))
2853 continue;
2854
2855 /* Now determine the call target, its name, value,
2856 section. */
2857 sym_sec = NULL;
2858 sym_value = 0;
2859 destination = 0;
2860 hh = NULL;
2861 if (r_indx < symtab_hdr->sh_info)
2862 {
2863 /* It's a local symbol. */
2864 Elf_Internal_Sym *sym;
2865 Elf_Internal_Shdr *hdr;
4fbb74a6 2866 unsigned int shndx;
28c9d252
NC		 2867
2868 sym = local_syms + r_indx;
28c9d252
NC		 2869 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2870 sym_value = sym->st_value;
4fbb74a6
AM		 2871 shndx = sym->st_shndx;
2872 if (shndx < elf_numsections (input_bfd))
2873 {
2874 hdr = elf_elfsections (input_bfd)[shndx];
2875 sym_sec = hdr->bfd_section;
2876 destination = (sym_value + irela->r_addend
2877 + sym_sec->output_offset
2878 + sym_sec->output_section->vma);
2879 }
28c9d252
NC		 2880 }
2881 else
2882 {
2883 /* It's an external symbol. */
2884 int e_indx;
2885
2886 e_indx = r_indx - symtab_hdr->sh_info;
2887 hh = elf_sym_hashes (input_bfd)[e_indx];
2888
2889 while (hh->root.type == bfd_link_hash_indirect
2890 || hh->root.type == bfd_link_hash_warning)
2891 hh = (struct elf_link_hash_entry *)
2892 (hh->root.u.i.link);
2893
2894 if (hh->root.type == bfd_link_hash_defined
2895 || hh->root.type == bfd_link_hash_defweak)
2896 {
2897 sym_sec = hh->root.u.def.section;
2898 sym_value = hh->root.u.def.value;
2899 if (sym_sec->output_section != NULL)
2900 destination = (sym_value + irela->r_addend
2901 + sym_sec->output_offset
2902 + sym_sec->output_section->vma);
2903 }
2904 else if (hh->root.type == bfd_link_hash_undefweak)
2905 {
2906 if (! info->shared)
2907 continue;
2908 }
2909 else if (hh->root.type == bfd_link_hash_undefined)
2910 {
2911 if (! (info->unresolved_syms_in_objects == RM_IGNORE
2912 && (ELF_ST_VISIBILITY (hh->other)
2913 == STV_DEFAULT)))
2914 continue;
2915 }
2916 else
2917 {
2918 bfd_set_error (bfd_error_bad_value);
2919
2920 error_ret_free_internal:
2921 if (elf_section_data (section)->relocs == NULL)
2922 free (internal_relocs);
2923 goto error_ret_free_local;
2924 }
2925 }
2926
2927 if (! avr_stub_is_required_for_16_bit_reloc
2928 (destination - htab->vector_base))
2929 {
2930 if (!is_prealloc_run)
2931 /* We are having a reloc that does't need a stub. */
2932 continue;
2933
2934 /* We don't right now know if a stub will be needed.
2935 Let's rather be on the safe side. */
2936 }
2937
2938 /* Get the name of this stub. */
2939 stub_name = avr_stub_name (sym_sec, sym_value, irela);
2940
2941 if (!stub_name)
2942 goto error_ret_free_internal;
2943
2944
2945 hsh = avr_stub_hash_lookup (&htab->bstab,
2946 stub_name,
2947 FALSE, FALSE);
2948 if (hsh != NULL)
2949 {
2950 /* The proper stub has already been created. Mark it
2951 to be used and write the possibly changed destination
2952 value. */
2953 hsh->is_actually_needed = TRUE;
2954 hsh->target_value = destination;
2955 free (stub_name);
2956 continue;
2957 }
2958
2959 hsh = avr_add_stub (stub_name, htab);
2960 if (hsh == NULL)
2961 {
2962 free (stub_name);
2963 goto error_ret_free_internal;
2964 }
2965
2966 hsh->is_actually_needed = TRUE;
2967 hsh->target_value = destination;
2968
2969 if (debug_stubs)
2970 printf ("Adding stub with destination 0x%x to the"
2971 " hash table.\n", (unsigned int) destination);
2972 if (debug_stubs)
2973 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
2974
2975 stub_changed = TRUE;
2976 }
2977
2978 /* We're done with the internal relocs, free them. */
2979 if (elf_section_data (section)->relocs == NULL)
2980 free (internal_relocs);
2981 }
2982 }
2983
2984 /* Re-Calculate the number of needed stubs. */
2985 htab->stub_sec->size = 0;
2986 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
2987
2988 if (!stub_changed)
2989 break;
2990
2991 stub_changed = FALSE;
2992 }
2993
2994 free (htab->all_local_syms);
2995 return TRUE;
2996
2997 error_ret_free_local:
2998 free (htab->all_local_syms);
2999 return FALSE;
3000}
3001
3002
3003/* Build all the stubs associated with the current output file. The
3004 stubs are kept in a hash table attached to the main linker hash
3005 table. We also set up the .plt entries for statically linked PIC
3006 functions here. This function is called via hppaelf_finish in the
3007 linker. */
3008
3009bfd_boolean
3010elf32_avr_build_stubs (struct bfd_link_info *info)
3011{
3012 asection *stub_sec;
3013 struct bfd_hash_table *table;
3014 struct elf32_avr_link_hash_table *htab;
3015 bfd_size_type total_size = 0;
3016
3017 htab = avr_link_hash_table (info);
64ee10b6
NC		 3018 if (htab == NULL)
3019 return FALSE;
28c9d252
NC		 3020
3021 /* In case that there were several stub sections: */
3022 for (stub_sec = htab->stub_bfd->sections;
3023 stub_sec != NULL;
3024 stub_sec = stub_sec->next)
3025 {
3026 bfd_size_type size;
3027
3028 /* Allocate memory to hold the linker stubs. */
3029 size = stub_sec->size;
3030 total_size += size;
3031
3032 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3033 if (stub_sec->contents == NULL && size != 0)
3034 return FALSE;
3035 stub_sec->size = 0;
3036 }
3037
3038 /* Allocate memory for the adress mapping table. */
3039 htab->amt_entry_cnt = 0;
3040 htab->amt_max_entry_cnt = total_size / 4;
3041 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3042 * htab->amt_max_entry_cnt);
3043 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3044 * htab->amt_max_entry_cnt );
3045
3046 if (debug_stubs)
3047 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3048
3049 /* Build the stubs as directed by the stub hash table. */
3050 table = &htab->bstab;
3051 bfd_hash_traverse (table, avr_build_one_stub, info);
3052
3053 if (debug_stubs)
3054 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3055
3056 return TRUE;
3057}
3058
adde6300 3059#define ELF_ARCH bfd_arch_avr
ae95ffa6 3060#define ELF_TARGET_ID AVR_ELF_DATA
adde6300 3061#define ELF_MACHINE_CODE EM_AVR
aa4f99bb 3062#define ELF_MACHINE_ALT1 EM_AVR_OLD
adde6300
AM		 3063#define ELF_MAXPAGESIZE 1
3064
3065#define TARGET_LITTLE_SYM bfd_elf32_avr_vec
3066#define TARGET_LITTLE_NAME "elf32-avr"
3067
28c9d252
NC		 3068#define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3069#define bfd_elf32_bfd_link_hash_table_free elf32_avr_link_hash_table_free
3070
adde6300
AM		 3071#define elf_info_to_howto avr_info_to_howto_rela
3072#define elf_info_to_howto_rel NULL
3073#define elf_backend_relocate_section elf32_avr_relocate_section
adde6300 3074#define elf_backend_can_gc_sections 1
f0fe0e16 3075#define elf_backend_rela_normal 1
adde6300
AM		 3076#define elf_backend_final_write_processing \
3077 bfd_elf_avr_final_write_processing
3078#define elf_backend_object_p elf32_avr_object_p
3079
df406460
NC		 3080#define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3081#define bfd_elf32_bfd_get_relocated_section_contents \
3082 elf32_avr_get_relocated_section_contents
3083
adde6300 3084#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.815421 seconds and 4 git commands to generate.