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