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