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