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