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