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