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