1 /* AVR-specific support for 32-bit ELF 2 Copyright (C) 1999-2024 Free Software Foundation, Inc. 3 Contributed by Denis Chertykov <denisc@overta.ru> 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, 20 Boston, MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "elf/avr.h" 27 #include "elf32-avr.h" 28 29 /* Enable debugging printout at stdout with this variable. */ 30 static bool debug_relax = false; 31 32 /* Enable debugging printout at stdout with this variable. */ 33 static bool debug_stubs = false; 34 35 static bfd_reloc_status_type 36 bfd_elf_avr_diff_reloc (bfd *, arelent *, asymbol *, void *, 37 asection *, bfd *, char **); 38 39 /* Hash table initialization and handling. Code is taken from the hppa port 40 and adapted to the needs of AVR. */ 41 42 /* We use two hash tables to hold information for linking avr objects. 43 44 The first is the elf32_avr_link_hash_table which is derived from the 45 stanard ELF linker hash table. We use this as a place to attach the other 46 hash table and some static information. 47 48 The second is the stub hash table which is derived from the base BFD 49 hash table. The stub hash table holds the information on the linker 50 stubs. */ 51 52 struct elf32_avr_stub_hash_entry 53 { 54 /* Base hash table entry structure. */ 55 struct bfd_hash_entry bh_root; 56 57 /* Offset within stub_sec of the beginning of this stub. */ 58 bfd_vma stub_offset; 59 60 /* Given the symbol's value and its section we can determine its final 61 value when building the stubs (so the stub knows where to jump). */ 62 bfd_vma target_value; 63 64 /* This way we could mark stubs to be no longer necessary. */ 65 bool is_actually_needed; 66 }; 67 68 struct elf32_avr_link_hash_table 69 { 70 /* The main hash table. */ 71 struct elf_link_hash_table etab; 72 73 /* The stub hash table. */ 74 struct bfd_hash_table bstab; 75 76 bool no_stubs; 77 78 /* Linker stub bfd. */ 79 bfd *stub_bfd; 80 81 /* The stub section. */ 82 asection *stub_sec; 83 84 /* Usually 0, unless we are generating code for a bootloader. Will 85 be initialized by elf32_avr_size_stubs to the vma offset of the 86 output section associated with the stub section. */ 87 bfd_vma vector_base; 88 89 /* Assorted information used by elf32_avr_size_stubs. */ 90 unsigned int bfd_count; 91 unsigned int top_index; 92 asection ** input_list; 93 Elf_Internal_Sym ** all_local_syms; 94 95 /* Tables for mapping vma beyond the 128k boundary to the address of the 96 corresponding stub. (AMT) 97 "amt_max_entry_cnt" reflects the number of entries that memory is allocated 98 for in the "amt_stub_offsets" and "amt_destination_addr" arrays. 99 "amt_entry_cnt" informs how many of these entries actually contain 100 useful data. */ 101 unsigned int amt_entry_cnt; 102 unsigned int amt_max_entry_cnt; 103 bfd_vma * amt_stub_offsets; 104 bfd_vma * amt_destination_addr; 105 }; 106 107 /* Various hash macros and functions. */ 108 #define avr_link_hash_table(p) \ 109 ((is_elf_hash_table ((p)->hash) \ 110 && elf_hash_table_id (elf_hash_table (p)) == AVR_ELF_DATA) \ 111 ? (struct elf32_avr_link_hash_table *) (p)->hash : NULL) 112 113 #define avr_stub_hash_entry(ent) \ 114 ((struct elf32_avr_stub_hash_entry *)(ent)) 115 116 #define avr_stub_hash_lookup(table, string, create, copy) \ 117 ((struct elf32_avr_stub_hash_entry *) \ 118 bfd_hash_lookup ((table), (string), (create), (copy))) 119 120 static reloc_howto_type elf_avr_howto_table[] = 121 { 122 HOWTO (R_AVR_NONE, /* type */ 123 0, /* rightshift */ 124 0, /* size */ 125 0, /* bitsize */ 126 false, /* pc_relative */ 127 0, /* bitpos */ 128 complain_overflow_dont, /* complain_on_overflow */ 129 bfd_elf_generic_reloc, /* special_function */ 130 "R_AVR_NONE", /* name */ 131 false, /* partial_inplace */ 132 0, /* src_mask */ 133 0, /* dst_mask */ 134 false), /* pcrel_offset */ 135 136 HOWTO (R_AVR_32, /* type */ 137 0, /* rightshift */ 138 4, /* size */ 139 32, /* bitsize */ 140 false, /* pc_relative */ 141 0, /* bitpos */ 142 complain_overflow_bitfield, /* complain_on_overflow */ 143 bfd_elf_generic_reloc, /* special_function */ 144 "R_AVR_32", /* name */ 145 false, /* partial_inplace */ 146 0xffffffff, /* src_mask */ 147 0xffffffff, /* dst_mask */ 148 false), /* pcrel_offset */ 149 150 /* A 7 bit PC relative relocation. */ 151 HOWTO (R_AVR_7_PCREL, /* type */ 152 1, /* rightshift */ 153 2, /* size */ 154 7, /* bitsize */ 155 true, /* pc_relative */ 156 3, /* bitpos */ 157 complain_overflow_bitfield, /* complain_on_overflow */ 158 bfd_elf_generic_reloc, /* special_function */ 159 "R_AVR_7_PCREL", /* name */ 160 false, /* partial_inplace */ 161 0xffff, /* src_mask */ 162 0xffff, /* dst_mask */ 163 true), /* pcrel_offset */ 164 165 /* A 13 bit PC relative relocation. */ 166 HOWTO (R_AVR_13_PCREL, /* type */ 167 1, /* rightshift */ 168 2, /* size */ 169 13, /* bitsize */ 170 true, /* pc_relative */ 171 0, /* bitpos */ 172 complain_overflow_bitfield, /* complain_on_overflow */ 173 bfd_elf_generic_reloc, /* special_function */ 174 "R_AVR_13_PCREL", /* name */ 175 false, /* partial_inplace */ 176 0xfff, /* src_mask */ 177 0xfff, /* dst_mask */ 178 true), /* pcrel_offset */ 179 180 /* A 16 bit absolute relocation. */ 181 HOWTO (R_AVR_16, /* type */ 182 0, /* rightshift */ 183 2, /* size */ 184 16, /* bitsize */ 185 false, /* pc_relative */ 186 0, /* bitpos */ 187 complain_overflow_dont, /* complain_on_overflow */ 188 bfd_elf_generic_reloc, /* special_function */ 189 "R_AVR_16", /* name */ 190 false, /* partial_inplace */ 191 0xffff, /* src_mask */ 192 0xffff, /* dst_mask */ 193 false), /* pcrel_offset */ 194 195 /* A 16 bit absolute relocation for command address 196 Will be changed when linker stubs are needed. */ 197 HOWTO (R_AVR_16_PM, /* type */ 198 1, /* rightshift */ 199 2, /* size */ 200 16, /* bitsize */ 201 false, /* pc_relative */ 202 0, /* bitpos */ 203 complain_overflow_bitfield, /* complain_on_overflow */ 204 bfd_elf_generic_reloc, /* special_function */ 205 "R_AVR_16_PM", /* name */ 206 false, /* partial_inplace */ 207 0xffff, /* src_mask */ 208 0xffff, /* dst_mask */ 209 false), /* pcrel_offset */ 210 /* A low 8 bit absolute relocation of 16 bit address. 211 For LDI command. */ 212 HOWTO (R_AVR_LO8_LDI, /* type */ 213 0, /* rightshift */ 214 2, /* size */ 215 8, /* bitsize */ 216 false, /* pc_relative */ 217 0, /* bitpos */ 218 complain_overflow_dont, /* complain_on_overflow */ 219 bfd_elf_generic_reloc, /* special_function */ 220 "R_AVR_LO8_LDI", /* name */ 221 false, /* partial_inplace */ 222 0xffff, /* src_mask */ 223 0xffff, /* dst_mask */ 224 false), /* pcrel_offset */ 225 /* A high 8 bit absolute relocation of 16 bit address. 226 For LDI command. */ 227 HOWTO (R_AVR_HI8_LDI, /* type */ 228 8, /* rightshift */ 229 2, /* size */ 230 8, /* bitsize */ 231 false, /* pc_relative */ 232 0, /* bitpos */ 233 complain_overflow_dont, /* complain_on_overflow */ 234 bfd_elf_generic_reloc, /* special_function */ 235 "R_AVR_HI8_LDI", /* name */ 236 false, /* partial_inplace */ 237 0xffff, /* src_mask */ 238 0xffff, /* dst_mask */ 239 false), /* pcrel_offset */ 240 /* A high 6 bit absolute relocation of 22 bit address. 241 For LDI command. As well second most significant 8 bit value of 242 a 32 bit link-time constant. */ 243 HOWTO (R_AVR_HH8_LDI, /* type */ 244 16, /* rightshift */ 245 2, /* size */ 246 8, /* bitsize */ 247 false, /* pc_relative */ 248 0, /* bitpos */ 249 complain_overflow_dont, /* complain_on_overflow */ 250 bfd_elf_generic_reloc, /* special_function */ 251 "R_AVR_HH8_LDI", /* name */ 252 false, /* partial_inplace */ 253 0xffff, /* src_mask */ 254 0xffff, /* dst_mask */ 255 false), /* pcrel_offset */ 256 /* A negative low 8 bit absolute relocation of 16 bit address. 257 For LDI command. */ 258 HOWTO (R_AVR_LO8_LDI_NEG, /* type */ 259 0, /* rightshift */ 260 2, /* size */ 261 8, /* bitsize */ 262 false, /* pc_relative */ 263 0, /* bitpos */ 264 complain_overflow_dont, /* complain_on_overflow */ 265 bfd_elf_generic_reloc, /* special_function */ 266 "R_AVR_LO8_LDI_NEG", /* name */ 267 false, /* partial_inplace */ 268 0xffff, /* src_mask */ 269 0xffff, /* dst_mask */ 270 false), /* pcrel_offset */ 271 /* A negative high 8 bit absolute relocation of 16 bit address. 272 For LDI command. */ 273 HOWTO (R_AVR_HI8_LDI_NEG, /* type */ 274 8, /* rightshift */ 275 2, /* size */ 276 8, /* bitsize */ 277 false, /* pc_relative */ 278 0, /* bitpos */ 279 complain_overflow_dont, /* complain_on_overflow */ 280 bfd_elf_generic_reloc, /* special_function */ 281 "R_AVR_HI8_LDI_NEG", /* name */ 282 false, /* partial_inplace */ 283 0xffff, /* src_mask */ 284 0xffff, /* dst_mask */ 285 false), /* pcrel_offset */ 286 /* A negative high 6 bit absolute relocation of 22 bit address. 287 For LDI command. */ 288 HOWTO (R_AVR_HH8_LDI_NEG, /* type */ 289 16, /* rightshift */ 290 2, /* size */ 291 8, /* bitsize */ 292 false, /* pc_relative */ 293 0, /* bitpos */ 294 complain_overflow_dont, /* complain_on_overflow */ 295 bfd_elf_generic_reloc, /* special_function */ 296 "R_AVR_HH8_LDI_NEG", /* name */ 297 false, /* partial_inplace */ 298 0xffff, /* src_mask */ 299 0xffff, /* dst_mask */ 300 false), /* pcrel_offset */ 301 /* A low 8 bit absolute relocation of 24 bit program memory address. 302 For LDI command. Will not be changed when linker stubs are needed. */ 303 HOWTO (R_AVR_LO8_LDI_PM, /* type */ 304 1, /* rightshift */ 305 2, /* size */ 306 8, /* bitsize */ 307 false, /* pc_relative */ 308 0, /* bitpos */ 309 complain_overflow_dont, /* complain_on_overflow */ 310 bfd_elf_generic_reloc, /* special_function */ 311 "R_AVR_LO8_LDI_PM", /* name */ 312 false, /* partial_inplace */ 313 0xffff, /* src_mask */ 314 0xffff, /* dst_mask */ 315 false), /* pcrel_offset */ 316 /* A low 8 bit absolute relocation of 24 bit program memory address. 317 For LDI command. Will not be changed when linker stubs are needed. */ 318 HOWTO (R_AVR_HI8_LDI_PM, /* type */ 319 9, /* rightshift */ 320 2, /* size */ 321 8, /* bitsize */ 322 false, /* pc_relative */ 323 0, /* bitpos */ 324 complain_overflow_dont, /* complain_on_overflow */ 325 bfd_elf_generic_reloc, /* special_function */ 326 "R_AVR_HI8_LDI_PM", /* name */ 327 false, /* partial_inplace */ 328 0xffff, /* src_mask */ 329 0xffff, /* dst_mask */ 330 false), /* pcrel_offset */ 331 /* A low 8 bit absolute relocation of 24 bit program memory address. 332 For LDI command. Will not be changed when linker stubs are needed. */ 333 HOWTO (R_AVR_HH8_LDI_PM, /* type */ 334 17, /* rightshift */ 335 2, /* size */ 336 8, /* bitsize */ 337 false, /* pc_relative */ 338 0, /* bitpos */ 339 complain_overflow_dont, /* complain_on_overflow */ 340 bfd_elf_generic_reloc, /* special_function */ 341 "R_AVR_HH8_LDI_PM", /* name */ 342 false, /* partial_inplace */ 343 0xffff, /* src_mask */ 344 0xffff, /* dst_mask */ 345 false), /* pcrel_offset */ 346 /* A low 8 bit absolute relocation of 24 bit program memory address. 347 For LDI command. Will not be changed when linker stubs are needed. */ 348 HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */ 349 1, /* rightshift */ 350 2, /* size */ 351 8, /* bitsize */ 352 false, /* pc_relative */ 353 0, /* bitpos */ 354 complain_overflow_dont, /* complain_on_overflow */ 355 bfd_elf_generic_reloc, /* special_function */ 356 "R_AVR_LO8_LDI_PM_NEG", /* name */ 357 false, /* partial_inplace */ 358 0xffff, /* src_mask */ 359 0xffff, /* dst_mask */ 360 false), /* pcrel_offset */ 361 /* A low 8 bit absolute relocation of 24 bit program memory address. 362 For LDI command. Will not be changed when linker stubs are needed. */ 363 HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */ 364 9, /* rightshift */ 365 2, /* size */ 366 8, /* bitsize */ 367 false, /* pc_relative */ 368 0, /* bitpos */ 369 complain_overflow_dont, /* complain_on_overflow */ 370 bfd_elf_generic_reloc, /* special_function */ 371 "R_AVR_HI8_LDI_PM_NEG", /* name */ 372 false, /* partial_inplace */ 373 0xffff, /* src_mask */ 374 0xffff, /* dst_mask */ 375 false), /* pcrel_offset */ 376 /* A low 8 bit absolute relocation of 24 bit program memory address. 377 For LDI command. Will not be changed when linker stubs are needed. */ 378 HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */ 379 17, /* rightshift */ 380 2, /* size */ 381 8, /* bitsize */ 382 false, /* pc_relative */ 383 0, /* bitpos */ 384 complain_overflow_dont, /* complain_on_overflow */ 385 bfd_elf_generic_reloc, /* special_function */ 386 "R_AVR_HH8_LDI_PM_NEG", /* name */ 387 false, /* partial_inplace */ 388 0xffff, /* src_mask */ 389 0xffff, /* dst_mask */ 390 false), /* pcrel_offset */ 391 /* Relocation for CALL command in ATmega. */ 392 HOWTO (R_AVR_CALL, /* type */ 393 1, /* rightshift */ 394 4, /* size */ 395 23, /* bitsize */ 396 false, /* pc_relative */ 397 0, /* bitpos */ 398 complain_overflow_dont,/* complain_on_overflow */ 399 bfd_elf_generic_reloc, /* special_function */ 400 "R_AVR_CALL", /* name */ 401 false, /* partial_inplace */ 402 0xffffffff, /* src_mask */ 403 0xffffffff, /* dst_mask */ 404 false), /* pcrel_offset */ 405 /* A 16 bit absolute relocation of 16 bit address. 406 For LDI command. */ 407 HOWTO (R_AVR_LDI, /* type */ 408 0, /* rightshift */ 409 2, /* size */ 410 16, /* bitsize */ 411 false, /* pc_relative */ 412 0, /* bitpos */ 413 complain_overflow_dont,/* complain_on_overflow */ 414 bfd_elf_generic_reloc, /* special_function */ 415 "R_AVR_LDI", /* name */ 416 false, /* partial_inplace */ 417 0xffff, /* src_mask */ 418 0xffff, /* dst_mask */ 419 false), /* pcrel_offset */ 420 /* A 6 bit absolute relocation of 6 bit offset. 421 For ldd/sdd command. */ 422 HOWTO (R_AVR_6, /* type */ 423 0, /* rightshift */ 424 1, /* size */ 425 6, /* bitsize */ 426 false, /* pc_relative */ 427 0, /* bitpos */ 428 complain_overflow_dont,/* complain_on_overflow */ 429 bfd_elf_generic_reloc, /* special_function */ 430 "R_AVR_6", /* name */ 431 false, /* partial_inplace */ 432 0xffff, /* src_mask */ 433 0xffff, /* dst_mask */ 434 false), /* pcrel_offset */ 435 /* A 6 bit absolute relocation of 6 bit offset. 436 For sbiw/adiw command. */ 437 HOWTO (R_AVR_6_ADIW, /* type */ 438 0, /* rightshift */ 439 1, /* size */ 440 6, /* bitsize */ 441 false, /* pc_relative */ 442 0, /* bitpos */ 443 complain_overflow_dont,/* complain_on_overflow */ 444 bfd_elf_generic_reloc, /* special_function */ 445 "R_AVR_6_ADIW", /* name */ 446 false, /* partial_inplace */ 447 0xffff, /* src_mask */ 448 0xffff, /* dst_mask */ 449 false), /* pcrel_offset */ 450 /* Most significant 8 bit value of a 32 bit link-time constant. */ 451 HOWTO (R_AVR_MS8_LDI, /* type */ 452 24, /* rightshift */ 453 2, /* size */ 454 8, /* bitsize */ 455 false, /* pc_relative */ 456 0, /* bitpos */ 457 complain_overflow_dont, /* complain_on_overflow */ 458 bfd_elf_generic_reloc, /* special_function */ 459 "R_AVR_MS8_LDI", /* name */ 460 false, /* partial_inplace */ 461 0xffff, /* src_mask */ 462 0xffff, /* dst_mask */ 463 false), /* pcrel_offset */ 464 /* Negative most significant 8 bit value of a 32 bit link-time constant. */ 465 HOWTO (R_AVR_MS8_LDI_NEG, /* type */ 466 24, /* rightshift */ 467 2, /* size */ 468 8, /* bitsize */ 469 false, /* pc_relative */ 470 0, /* bitpos */ 471 complain_overflow_dont, /* complain_on_overflow */ 472 bfd_elf_generic_reloc, /* special_function */ 473 "R_AVR_MS8_LDI_NEG", /* name */ 474 false, /* partial_inplace */ 475 0xffff, /* src_mask */ 476 0xffff, /* dst_mask */ 477 false), /* pcrel_offset */ 478 /* A low 8 bit absolute relocation of 24 bit program memory address. 479 For LDI command. Will be changed when linker stubs are needed. */ 480 HOWTO (R_AVR_LO8_LDI_GS, /* type */ 481 1, /* rightshift */ 482 2, /* size */ 483 8, /* bitsize */ 484 false, /* pc_relative */ 485 0, /* bitpos */ 486 complain_overflow_dont, /* complain_on_overflow */ 487 bfd_elf_generic_reloc, /* special_function */ 488 "R_AVR_LO8_LDI_GS", /* name */ 489 false, /* partial_inplace */ 490 0xffff, /* src_mask */ 491 0xffff, /* dst_mask */ 492 false), /* pcrel_offset */ 493 /* A low 8 bit absolute relocation of 24 bit program memory address. 494 For LDI command. Will be changed when linker stubs are needed. */ 495 HOWTO (R_AVR_HI8_LDI_GS, /* type */ 496 9, /* rightshift */ 497 2, /* size */ 498 8, /* bitsize */ 499 false, /* pc_relative */ 500 0, /* bitpos */ 501 complain_overflow_dont, /* complain_on_overflow */ 502 bfd_elf_generic_reloc, /* special_function */ 503 "R_AVR_HI8_LDI_GS", /* name */ 504 false, /* partial_inplace */ 505 0xffff, /* src_mask */ 506 0xffff, /* dst_mask */ 507 false), /* pcrel_offset */ 508 /* 8 bit offset. */ 509 HOWTO (R_AVR_8, /* type */ 510 0, /* rightshift */ 511 1, /* size */ 512 8, /* bitsize */ 513 false, /* pc_relative */ 514 0, /* bitpos */ 515 complain_overflow_bitfield,/* complain_on_overflow */ 516 bfd_elf_generic_reloc, /* special_function */ 517 "R_AVR_8", /* name */ 518 false, /* partial_inplace */ 519 0x000000ff, /* src_mask */ 520 0x000000ff, /* dst_mask */ 521 false), /* pcrel_offset */ 522 /* lo8-part to use in .byte lo8(sym). */ 523 HOWTO (R_AVR_8_LO8, /* type */ 524 0, /* rightshift */ 525 1, /* size */ 526 8, /* bitsize */ 527 false, /* pc_relative */ 528 0, /* bitpos */ 529 complain_overflow_dont,/* complain_on_overflow */ 530 bfd_elf_generic_reloc, /* special_function */ 531 "R_AVR_8_LO8", /* name */ 532 false, /* partial_inplace */ 533 0xffffff, /* src_mask */ 534 0xffffff, /* dst_mask */ 535 false), /* pcrel_offset */ 536 /* hi8-part to use in .byte hi8(sym). */ 537 HOWTO (R_AVR_8_HI8, /* type */ 538 8, /* rightshift */ 539 1, /* size */ 540 8, /* bitsize */ 541 false, /* pc_relative */ 542 0, /* bitpos */ 543 complain_overflow_dont,/* complain_on_overflow */ 544 bfd_elf_generic_reloc, /* special_function */ 545 "R_AVR_8_HI8", /* name */ 546 false, /* partial_inplace */ 547 0xffffff, /* src_mask */ 548 0xffffff, /* dst_mask */ 549 false), /* pcrel_offset */ 550 /* hlo8-part to use in .byte hlo8(sym). */ 551 HOWTO (R_AVR_8_HLO8, /* type */ 552 16, /* rightshift */ 553 1, /* size */ 554 8, /* bitsize */ 555 false, /* pc_relative */ 556 0, /* bitpos */ 557 complain_overflow_dont,/* complain_on_overflow */ 558 bfd_elf_generic_reloc, /* special_function */ 559 "R_AVR_8_HLO8", /* name */ 560 false, /* partial_inplace */ 561 0xffffff, /* src_mask */ 562 0xffffff, /* dst_mask */ 563 false), /* pcrel_offset */ 564 HOWTO (R_AVR_DIFF8, /* type */ 565 0, /* rightshift */ 566 1, /* size */ 567 8, /* bitsize */ 568 false, /* pc_relative */ 569 0, /* bitpos */ 570 complain_overflow_bitfield, /* complain_on_overflow */ 571 bfd_elf_avr_diff_reloc, /* special_function */ 572 "R_AVR_DIFF8", /* name */ 573 false, /* partial_inplace */ 574 0, /* src_mask */ 575 0xff, /* dst_mask */ 576 false), /* pcrel_offset */ 577 HOWTO (R_AVR_DIFF16, /* type */ 578 0, /* rightshift */ 579 2, /* size */ 580 16, /* bitsize */ 581 false, /* pc_relative */ 582 0, /* bitpos */ 583 complain_overflow_bitfield, /* complain_on_overflow */ 584 bfd_elf_avr_diff_reloc,/* special_function */ 585 "R_AVR_DIFF16", /* name */ 586 false, /* partial_inplace */ 587 0, /* src_mask */ 588 0xffff, /* dst_mask */ 589 false), /* pcrel_offset */ 590 HOWTO (R_AVR_DIFF32, /* type */ 591 0, /* rightshift */ 592 4, /* size */ 593 32, /* bitsize */ 594 false, /* pc_relative */ 595 0, /* bitpos */ 596 complain_overflow_bitfield, /* complain_on_overflow */ 597 bfd_elf_avr_diff_reloc,/* special_function */ 598 "R_AVR_DIFF32", /* name */ 599 false, /* partial_inplace */ 600 0, /* src_mask */ 601 0xffffffff, /* dst_mask */ 602 false), /* pcrel_offset */ 603 /* 7 bit immediate for LDS/STS in Tiny core. */ 604 HOWTO (R_AVR_LDS_STS_16, /* type */ 605 0, /* rightshift */ 606 2, /* size */ 607 7, /* bitsize */ 608 false, /* pc_relative */ 609 0, /* bitpos */ 610 complain_overflow_dont,/* complain_on_overflow */ 611 bfd_elf_generic_reloc, /* special_function */ 612 "R_AVR_LDS_STS_16", /* name */ 613 false, /* partial_inplace */ 614 0xffff, /* src_mask */ 615 0xffff, /* dst_mask */ 616 false), /* pcrel_offset */ 617 618 HOWTO (R_AVR_PORT6, /* type */ 619 0, /* rightshift */ 620 1, /* size */ 621 6, /* bitsize */ 622 false, /* pc_relative */ 623 0, /* bitpos */ 624 complain_overflow_dont,/* complain_on_overflow */ 625 bfd_elf_generic_reloc, /* special_function */ 626 "R_AVR_PORT6", /* name */ 627 false, /* partial_inplace */ 628 0xffffff, /* src_mask */ 629 0xffffff, /* dst_mask */ 630 false), /* pcrel_offset */ 631 HOWTO (R_AVR_PORT5, /* type */ 632 0, /* rightshift */ 633 1, /* size */ 634 5, /* bitsize */ 635 false, /* pc_relative */ 636 0, /* bitpos */ 637 complain_overflow_dont,/* complain_on_overflow */ 638 bfd_elf_generic_reloc, /* special_function */ 639 "R_AVR_PORT5", /* name */ 640 false, /* partial_inplace */ 641 0xffffff, /* src_mask */ 642 0xffffff, /* dst_mask */ 643 false), /* pcrel_offset */ 644 645 /* A 32 bit PC relative relocation. */ 646 HOWTO (R_AVR_32_PCREL, /* type */ 647 0, /* rightshift */ 648 4, /* size */ 649 32, /* bitsize */ 650 true, /* pc_relative */ 651 0, /* bitpos */ 652 complain_overflow_bitfield, /* complain_on_overflow */ 653 bfd_elf_generic_reloc, /* special_function */ 654 "R_AVR_32_PCREL", /* name */ 655 false, /* partial_inplace */ 656 0xffffffff, /* src_mask */ 657 0xffffffff, /* dst_mask */ 658 true), /* pcrel_offset */ 659 }; 660 661 /* Map BFD reloc types to AVR ELF reloc types. */ 662 663 struct avr_reloc_map 664 { 665 bfd_reloc_code_real_type bfd_reloc_val; 666 unsigned int elf_reloc_val; 667 }; 668 669 static const struct avr_reloc_map avr_reloc_map[] = 670 { 671 { BFD_RELOC_NONE, R_AVR_NONE }, 672 { BFD_RELOC_32, R_AVR_32 }, 673 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL }, 674 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL }, 675 { BFD_RELOC_16, R_AVR_16 }, 676 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM }, 677 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI}, 678 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI }, 679 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI }, 680 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI }, 681 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG }, 682 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG }, 683 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG }, 684 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG }, 685 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM }, 686 { BFD_RELOC_AVR_LO8_LDI_GS, R_AVR_LO8_LDI_GS }, 687 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM }, 688 { BFD_RELOC_AVR_HI8_LDI_GS, R_AVR_HI8_LDI_GS }, 689 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM }, 690 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG }, 691 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG }, 692 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG }, 693 { BFD_RELOC_AVR_CALL, R_AVR_CALL }, 694 { BFD_RELOC_AVR_LDI, R_AVR_LDI }, 695 { BFD_RELOC_AVR_6, R_AVR_6 }, 696 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW }, 697 { BFD_RELOC_8, R_AVR_8 }, 698 { BFD_RELOC_AVR_8_LO, R_AVR_8_LO8 }, 699 { BFD_RELOC_AVR_8_HI, R_AVR_8_HI8 }, 700 { BFD_RELOC_AVR_8_HLO, R_AVR_8_HLO8 }, 701 { BFD_RELOC_AVR_DIFF8, R_AVR_DIFF8 }, 702 { BFD_RELOC_AVR_DIFF16, R_AVR_DIFF16 }, 703 { BFD_RELOC_AVR_DIFF32, R_AVR_DIFF32 }, 704 { BFD_RELOC_AVR_LDS_STS_16, R_AVR_LDS_STS_16}, 705 { BFD_RELOC_AVR_PORT6, R_AVR_PORT6}, 706 { BFD_RELOC_AVR_PORT5, R_AVR_PORT5}, 707 { BFD_RELOC_32_PCREL, R_AVR_32_PCREL} 708 }; 709 710 static const struct bfd_elf_special_section elf_avr_special_sections[] = 711 { 712 { STRING_COMMA_LEN (".noinit"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 713 { NULL, 0, 0, 0, 0 } 714 }; 715 716 /* Meant to be filled one day with the wrap around address for the 717 specific device. I.e. should get the value 0x4000 for 16k devices, 718 0x8000 for 32k devices and so on. 719 720 We initialize it here with a value of 0x1000000 resulting in 721 that we will never suggest a wrap-around jump during relaxation. 722 The logic of the source code later on assumes that in 723 avr_pc_wrap_around one single bit is set. */ 724 static bfd_vma avr_pc_wrap_around = 0x10000000; 725 726 /* If this variable holds a value different from zero, the linker relaxation 727 machine will try to optimize call/ret sequences by a single jump 728 instruction. This option could be switched off by a linker switch. */ 729 static int avr_replace_call_ret_sequences = 1; 730 731 732 /* Per-section relaxation related information for avr. */ 733 734 struct avr_relax_info 735 { 736 /* Track the avr property records that apply to this section. */ 737 738 struct 739 { 740 /* Number of records in the list. */ 741 unsigned count; 742 743 /* How many records worth of space have we allocated. */ 744 unsigned allocated; 745 746 /* The records, only COUNT records are initialised. */ 747 struct avr_property_record *items; 748 } records; 749 }; 750 751 /* Per section data, specialised for avr. */ 752 753 struct elf_avr_section_data 754 { 755 /* The standard data must appear first. */ 756 struct bfd_elf_section_data elf; 757 758 /* Relaxation related information. */ 759 struct avr_relax_info relax_info; 760 }; 761 762 /* Possibly initialise avr specific data for new section SEC from ABFD. */ 763 764 static bool 765 elf_avr_new_section_hook (bfd *abfd, asection *sec) 766 { 767 if (!sec->used_by_bfd) 768 { 769 struct elf_avr_section_data *sdata; 770 size_t amt = sizeof (*sdata); 771 772 sdata = bfd_zalloc (abfd, amt); 773 if (sdata == NULL) 774 return false; 775 sec->used_by_bfd = sdata; 776 } 777 778 return _bfd_elf_new_section_hook (abfd, sec); 779 } 780 781 /* Return a pointer to the relaxation information for SEC. */ 782 783 static struct avr_relax_info * 784 get_avr_relax_info (asection *sec) 785 { 786 struct elf_avr_section_data *section_data; 787 788 /* No info available if no section or if it is an output section. */ 789 if (!sec || sec == sec->output_section) 790 return NULL; 791 792 section_data = (struct elf_avr_section_data *) elf_section_data (sec); 793 return §ion_data->relax_info; 794 } 795 796 /* Initialise the per section relaxation information for SEC. */ 797 798 static void 799 init_avr_relax_info (asection *sec) 800 { 801 struct avr_relax_info *relax_info = get_avr_relax_info (sec); 802 803 relax_info->records.count = 0; 804 relax_info->records.allocated = 0; 805 relax_info->records.items = NULL; 806 } 807 808 /* Initialize an entry in the stub hash table. */ 809 810 static struct bfd_hash_entry * 811 stub_hash_newfunc (struct bfd_hash_entry *entry, 812 struct bfd_hash_table *table, 813 const char *string) 814 { 815 /* Allocate the structure if it has not already been allocated by a 816 subclass. */ 817 if (entry == NULL) 818 { 819 entry = bfd_hash_allocate (table, 820 sizeof (struct elf32_avr_stub_hash_entry)); 821 if (entry == NULL) 822 return entry; 823 } 824 825 /* Call the allocation method of the superclass. */ 826 entry = bfd_hash_newfunc (entry, table, string); 827 if (entry != NULL) 828 { 829 struct elf32_avr_stub_hash_entry *hsh; 830 831 /* Initialize the local fields. */ 832 hsh = avr_stub_hash_entry (entry); 833 hsh->stub_offset = 0; 834 hsh->target_value = 0; 835 } 836 837 return entry; 838 } 839 840 /* This function is just a straight passthrough to the real 841 function in linker.c. Its prupose is so that its address 842 can be compared inside the avr_link_hash_table macro. */ 843 844 static struct bfd_hash_entry * 845 elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry, 846 struct bfd_hash_table * table, 847 const char * string) 848 { 849 return _bfd_elf_link_hash_newfunc (entry, table, string); 850 } 851 852 /* Free the derived linker hash table. */ 853 854 static void 855 elf32_avr_link_hash_table_free (bfd *obfd) 856 { 857 struct elf32_avr_link_hash_table *htab 858 = (struct elf32_avr_link_hash_table *) obfd->link.hash; 859 860 /* Free the address mapping table. */ 861 free (htab->amt_stub_offsets); 862 free (htab->amt_destination_addr); 863 864 bfd_hash_table_free (&htab->bstab); 865 _bfd_elf_link_hash_table_free (obfd); 866 } 867 868 /* Create the derived linker hash table. The AVR ELF port uses the derived 869 hash table to keep information specific to the AVR ELF linker (without 870 using static variables). */ 871 872 static struct bfd_link_hash_table * 873 elf32_avr_link_hash_table_create (bfd *abfd) 874 { 875 struct elf32_avr_link_hash_table *htab; 876 size_t amt = sizeof (*htab); 877 878 htab = bfd_zmalloc (amt); 879 if (htab == NULL) 880 return NULL; 881 882 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd, 883 elf32_avr_link_hash_newfunc, 884 sizeof (struct elf_link_hash_entry), 885 AVR_ELF_DATA)) 886 { 887 free (htab); 888 return NULL; 889 } 890 891 /* Init the stub hash table too. */ 892 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc, 893 sizeof (struct elf32_avr_stub_hash_entry))) 894 { 895 _bfd_elf_link_hash_table_free (abfd); 896 return NULL; 897 } 898 htab->etab.root.hash_table_free = elf32_avr_link_hash_table_free; 899 900 return &htab->etab.root; 901 } 902 903 /* Calculates the effective distance of a pc relative jump/call. */ 904 905 static int 906 avr_relative_distance_considering_wrap_around (unsigned int distance) 907 { 908 unsigned int wrap_around_mask = avr_pc_wrap_around - 1; 909 int dist_with_wrap_around = distance & wrap_around_mask; 910 911 if (dist_with_wrap_around >= ((int) (avr_pc_wrap_around >> 1))) 912 dist_with_wrap_around -= avr_pc_wrap_around; 913 914 return dist_with_wrap_around; 915 } 916 917 918 static reloc_howto_type * 919 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 920 bfd_reloc_code_real_type code) 921 { 922 unsigned int i; 923 924 for (i = 0; 925 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map); 926 i++) 927 if (avr_reloc_map[i].bfd_reloc_val == code) 928 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val]; 929 930 return NULL; 931 } 932 933 static reloc_howto_type * 934 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 935 const char *r_name) 936 { 937 unsigned int i; 938 939 for (i = 0; 940 i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]); 941 i++) 942 if (elf_avr_howto_table[i].name != NULL 943 && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0) 944 return &elf_avr_howto_table[i]; 945 946 return NULL; 947 } 948 949 /* Set the howto pointer for an AVR ELF reloc. */ 950 951 static bool 952 avr_info_to_howto_rela (bfd *abfd, 953 arelent *cache_ptr, 954 Elf_Internal_Rela *dst) 955 { 956 unsigned int r_type; 957 958 r_type = ELF32_R_TYPE (dst->r_info); 959 if (r_type >= (unsigned int) R_AVR_max) 960 { 961 /* xgettext:c-format */ 962 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 963 abfd, r_type); 964 bfd_set_error (bfd_error_bad_value); 965 return false; 966 } 967 cache_ptr->howto = &elf_avr_howto_table[r_type]; 968 return true; 969 } 970 971 static bool 972 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation) 973 { 974 return (relocation >= 0x020000); 975 } 976 977 /* Returns the address of the corresponding stub if there is one. 978 Returns otherwise an address above 0x020000. This function 979 could also be used, if there is no knowledge on the section where 980 the destination is found. */ 981 982 static bfd_vma 983 avr_get_stub_addr (bfd_vma srel, 984 struct elf32_avr_link_hash_table *htab) 985 { 986 unsigned int sindex; 987 bfd_vma stub_sec_addr = 988 (htab->stub_sec->output_section->vma + 989 htab->stub_sec->output_offset); 990 991 for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++) 992 if (htab->amt_destination_addr[sindex] == srel) 993 return htab->amt_stub_offsets[sindex] + stub_sec_addr; 994 995 /* Return an address that could not be reached by 16 bit relocs. */ 996 return 0x020000; 997 } 998 999 /* Perform a diff relocation. Nothing to do, as the difference value is already 1000 written into the section's contents. */ 1001 1002 static bfd_reloc_status_type 1003 bfd_elf_avr_diff_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1004 arelent *reloc_entry ATTRIBUTE_UNUSED, 1005 asymbol *symbol ATTRIBUTE_UNUSED, 1006 void *data ATTRIBUTE_UNUSED, 1007 asection *input_section ATTRIBUTE_UNUSED, 1008 bfd *output_bfd ATTRIBUTE_UNUSED, 1009 char **error_message ATTRIBUTE_UNUSED) 1010 { 1011 return bfd_reloc_ok; 1012 } 1013 1014 1015 /* Perform a single relocation. By default we use the standard BFD 1016 routines, but a few relocs, we have to do them ourselves. */ 1017 1018 static bfd_reloc_status_type 1019 avr_final_link_relocate (reloc_howto_type * howto, 1020 bfd * input_bfd, 1021 asection * input_section, 1022 bfd_byte * contents, 1023 Elf_Internal_Rela * rel, 1024 bfd_vma relocation, 1025 struct elf32_avr_link_hash_table * htab) 1026 { 1027 bfd_reloc_status_type r = bfd_reloc_ok; 1028 bfd_vma x; 1029 bfd_signed_vma srel; 1030 bfd_signed_vma reloc_addr; 1031 bool use_stubs = false; 1032 /* Usually is 0, unless we are generating code for a bootloader. */ 1033 bfd_signed_vma base_addr = htab->vector_base; 1034 1035 /* Absolute addr of the reloc in the final excecutable. */ 1036 reloc_addr = rel->r_offset + input_section->output_section->vma 1037 + input_section->output_offset; 1038 1039 switch (howto->type) 1040 { 1041 case R_AVR_7_PCREL: 1042 contents += rel->r_offset; 1043 srel = (bfd_signed_vma) relocation; 1044 srel += rel->r_addend; 1045 srel -= rel->r_offset; 1046 srel -= 2; /* Branch instructions add 2 to the PC... */ 1047 srel -= (input_section->output_section->vma + 1048 input_section->output_offset); 1049 1050 if (srel & 1) 1051 return bfd_reloc_other; 1052 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7))) 1053 return bfd_reloc_overflow; 1054 x = bfd_get_16 (input_bfd, contents); 1055 x = (x & 0xfc07) | (((srel >> 1) * 8) & 0x3f8); 1056 bfd_put_16 (input_bfd, x, contents); 1057 break; 1058 1059 case R_AVR_13_PCREL: 1060 contents += rel->r_offset; 1061 srel = (bfd_signed_vma) relocation; 1062 srel += rel->r_addend; 1063 srel -= rel->r_offset; 1064 srel -= 2; /* Branch instructions add 2 to the PC... */ 1065 srel -= (input_section->output_section->vma + 1066 input_section->output_offset); 1067 1068 if (srel & 1) 1069 return bfd_reloc_other; 1070 1071 srel = avr_relative_distance_considering_wrap_around (srel); 1072 1073 /* AVR addresses commands as words. */ 1074 srel >>= 1; 1075 1076 /* Check for overflow. */ 1077 if (srel < -2048 || srel > 2047) 1078 { 1079 /* Relative distance is too large. */ 1080 1081 /* Always apply WRAPAROUND for avr2, avr25, and avr4. */ 1082 switch (bfd_get_mach (input_bfd)) 1083 { 1084 case bfd_mach_avr2: 1085 case bfd_mach_avr25: 1086 case bfd_mach_avr4: 1087 break; 1088 1089 default: 1090 return bfd_reloc_overflow; 1091 } 1092 } 1093 1094 x = bfd_get_16 (input_bfd, contents); 1095 x = (x & 0xf000) | (srel & 0xfff); 1096 bfd_put_16 (input_bfd, x, contents); 1097 break; 1098 1099 case R_AVR_LO8_LDI: 1100 contents += rel->r_offset; 1101 srel = (bfd_signed_vma) relocation + rel->r_addend; 1102 x = bfd_get_16 (input_bfd, contents); 1103 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1104 bfd_put_16 (input_bfd, x, contents); 1105 break; 1106 1107 case R_AVR_LDI: 1108 contents += rel->r_offset; 1109 srel = (bfd_signed_vma) relocation + rel->r_addend; 1110 if (((srel > 0) && (srel & 0xffff) > 255) 1111 || ((srel < 0) && ((-srel) & 0xffff) > 128)) 1112 /* Remove offset for data/eeprom section. */ 1113 return bfd_reloc_overflow; 1114 1115 x = bfd_get_16 (input_bfd, contents); 1116 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1117 bfd_put_16 (input_bfd, x, contents); 1118 break; 1119 1120 case R_AVR_6: 1121 contents += rel->r_offset; 1122 srel = (bfd_signed_vma) relocation + rel->r_addend; 1123 if (((srel & 0xffff) > 63) || (srel < 0)) 1124 /* Remove offset for data/eeprom section. */ 1125 return bfd_reloc_overflow; 1126 x = bfd_get_16 (input_bfd, contents); 1127 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7) 1128 | ((srel & (1 << 5)) << 8)); 1129 bfd_put_16 (input_bfd, x, contents); 1130 break; 1131 1132 case R_AVR_6_ADIW: 1133 contents += rel->r_offset; 1134 srel = (bfd_signed_vma) relocation + rel->r_addend; 1135 if (((srel & 0xffff) > 63) || (srel < 0)) 1136 /* Remove offset for data/eeprom section. */ 1137 return bfd_reloc_overflow; 1138 x = bfd_get_16 (input_bfd, contents); 1139 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2); 1140 bfd_put_16 (input_bfd, x, contents); 1141 break; 1142 1143 case R_AVR_HI8_LDI: 1144 contents += rel->r_offset; 1145 srel = (bfd_signed_vma) relocation + rel->r_addend; 1146 srel = (srel >> 8) & 0xff; 1147 x = bfd_get_16 (input_bfd, contents); 1148 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1149 bfd_put_16 (input_bfd, x, contents); 1150 break; 1151 1152 case R_AVR_HH8_LDI: 1153 contents += rel->r_offset; 1154 srel = (bfd_signed_vma) relocation + rel->r_addend; 1155 srel = (srel >> 16) & 0xff; 1156 x = bfd_get_16 (input_bfd, contents); 1157 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1158 bfd_put_16 (input_bfd, x, contents); 1159 break; 1160 1161 case R_AVR_MS8_LDI: 1162 contents += rel->r_offset; 1163 srel = (bfd_signed_vma) relocation + rel->r_addend; 1164 srel = (srel >> 24) & 0xff; 1165 x = bfd_get_16 (input_bfd, contents); 1166 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1167 bfd_put_16 (input_bfd, x, contents); 1168 break; 1169 1170 case R_AVR_LO8_LDI_NEG: 1171 contents += rel->r_offset; 1172 srel = (bfd_signed_vma) relocation + rel->r_addend; 1173 srel = -srel; 1174 x = bfd_get_16 (input_bfd, contents); 1175 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1176 bfd_put_16 (input_bfd, x, contents); 1177 break; 1178 1179 case R_AVR_HI8_LDI_NEG: 1180 contents += rel->r_offset; 1181 srel = (bfd_signed_vma) relocation + rel->r_addend; 1182 srel = -srel; 1183 srel = (srel >> 8) & 0xff; 1184 x = bfd_get_16 (input_bfd, contents); 1185 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1186 bfd_put_16 (input_bfd, x, contents); 1187 break; 1188 1189 case R_AVR_HH8_LDI_NEG: 1190 contents += rel->r_offset; 1191 srel = (bfd_signed_vma) relocation + rel->r_addend; 1192 srel = -srel; 1193 srel = (srel >> 16) & 0xff; 1194 x = bfd_get_16 (input_bfd, contents); 1195 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1196 bfd_put_16 (input_bfd, x, contents); 1197 break; 1198 1199 case R_AVR_MS8_LDI_NEG: 1200 contents += rel->r_offset; 1201 srel = (bfd_signed_vma) relocation + rel->r_addend; 1202 srel = -srel; 1203 srel = (srel >> 24) & 0xff; 1204 x = bfd_get_16 (input_bfd, contents); 1205 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1206 bfd_put_16 (input_bfd, x, contents); 1207 break; 1208 1209 case R_AVR_LO8_LDI_GS: 1210 use_stubs = (!htab->no_stubs); 1211 /* Fall through. */ 1212 case R_AVR_LO8_LDI_PM: 1213 contents += rel->r_offset; 1214 srel = (bfd_signed_vma) relocation + rel->r_addend; 1215 1216 if (use_stubs 1217 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr)) 1218 { 1219 bfd_vma old_srel = srel; 1220 1221 /* We need to use the address of the stub instead. */ 1222 srel = avr_get_stub_addr (srel, htab); 1223 if (debug_stubs) 1224 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for " 1225 "reloc at address 0x%x.\n", 1226 (unsigned int) srel, 1227 (unsigned int) old_srel, 1228 (unsigned int) reloc_addr); 1229 1230 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr)) 1231 return bfd_reloc_overflow; 1232 } 1233 1234 if (srel & 1) 1235 return bfd_reloc_other; 1236 srel = srel >> 1; 1237 x = bfd_get_16 (input_bfd, contents); 1238 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1239 bfd_put_16 (input_bfd, x, contents); 1240 break; 1241 1242 case R_AVR_HI8_LDI_GS: 1243 use_stubs = (!htab->no_stubs); 1244 /* Fall through. */ 1245 case R_AVR_HI8_LDI_PM: 1246 contents += rel->r_offset; 1247 srel = (bfd_signed_vma) relocation + rel->r_addend; 1248 1249 if (use_stubs 1250 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr)) 1251 { 1252 bfd_vma old_srel = srel; 1253 1254 /* We need to use the address of the stub instead. */ 1255 srel = avr_get_stub_addr (srel, htab); 1256 if (debug_stubs) 1257 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for " 1258 "reloc at address 0x%x.\n", 1259 (unsigned int) srel, 1260 (unsigned int) old_srel, 1261 (unsigned int) reloc_addr); 1262 1263 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr)) 1264 return bfd_reloc_overflow; 1265 } 1266 1267 if (srel & 1) 1268 return bfd_reloc_other; 1269 srel = srel >> 1; 1270 srel = (srel >> 8) & 0xff; 1271 x = bfd_get_16 (input_bfd, contents); 1272 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1273 bfd_put_16 (input_bfd, x, contents); 1274 break; 1275 1276 case R_AVR_HH8_LDI_PM: 1277 contents += rel->r_offset; 1278 srel = (bfd_signed_vma) relocation + rel->r_addend; 1279 if (srel & 1) 1280 return bfd_reloc_other; 1281 srel = srel >> 1; 1282 srel = (srel >> 16) & 0xff; 1283 x = bfd_get_16 (input_bfd, contents); 1284 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1285 bfd_put_16 (input_bfd, x, contents); 1286 break; 1287 1288 case R_AVR_LO8_LDI_PM_NEG: 1289 contents += rel->r_offset; 1290 srel = (bfd_signed_vma) relocation + rel->r_addend; 1291 srel = -srel; 1292 if (srel & 1) 1293 return bfd_reloc_other; 1294 srel = srel >> 1; 1295 x = bfd_get_16 (input_bfd, contents); 1296 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1297 bfd_put_16 (input_bfd, x, contents); 1298 break; 1299 1300 case R_AVR_HI8_LDI_PM_NEG: 1301 contents += rel->r_offset; 1302 srel = (bfd_signed_vma) relocation + rel->r_addend; 1303 srel = -srel; 1304 if (srel & 1) 1305 return bfd_reloc_other; 1306 srel = srel >> 1; 1307 srel = (srel >> 8) & 0xff; 1308 x = bfd_get_16 (input_bfd, contents); 1309 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1310 bfd_put_16 (input_bfd, x, contents); 1311 break; 1312 1313 case R_AVR_HH8_LDI_PM_NEG: 1314 contents += rel->r_offset; 1315 srel = (bfd_signed_vma) relocation + rel->r_addend; 1316 srel = -srel; 1317 if (srel & 1) 1318 return bfd_reloc_other; 1319 srel = srel >> 1; 1320 srel = (srel >> 16) & 0xff; 1321 x = bfd_get_16 (input_bfd, contents); 1322 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00); 1323 bfd_put_16 (input_bfd, x, contents); 1324 break; 1325 1326 case R_AVR_CALL: 1327 contents += rel->r_offset; 1328 srel = (bfd_signed_vma) relocation + rel->r_addend; 1329 if (srel & 1) 1330 return bfd_reloc_other; 1331 srel = srel >> 1; 1332 x = bfd_get_16 (input_bfd, contents); 1333 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16; 1334 bfd_put_16 (input_bfd, x, contents); 1335 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2); 1336 break; 1337 1338 case R_AVR_16_PM: 1339 use_stubs = (!htab->no_stubs); 1340 contents += rel->r_offset; 1341 srel = (bfd_signed_vma) relocation + rel->r_addend; 1342 1343 if (use_stubs 1344 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr)) 1345 { 1346 bfd_vma old_srel = srel; 1347 1348 /* We need to use the address of the stub instead. */ 1349 srel = avr_get_stub_addr (srel,htab); 1350 if (debug_stubs) 1351 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for " 1352 "reloc at address 0x%x.\n", 1353 (unsigned int) srel, 1354 (unsigned int) old_srel, 1355 (unsigned int) reloc_addr); 1356 1357 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr)) 1358 return bfd_reloc_overflow; 1359 } 1360 1361 if (srel & 1) 1362 return bfd_reloc_other; 1363 srel = srel >> 1; 1364 bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents); 1365 break; 1366 1367 case R_AVR_DIFF8: 1368 case R_AVR_DIFF16: 1369 case R_AVR_DIFF32: 1370 /* Nothing to do here, as contents already contains the diff value. */ 1371 r = bfd_reloc_ok; 1372 break; 1373 1374 case R_AVR_LDS_STS_16: 1375 contents += rel->r_offset; 1376 srel = (bfd_signed_vma) relocation + rel->r_addend; 1377 if ((srel & 0xFFFF) < 0x40 || (srel & 0xFFFF) > 0xbf) 1378 return bfd_reloc_overflow; 1379 srel = srel & 0x7f; 1380 x = bfd_get_16 (input_bfd, contents); 1381 x |= (srel & 0x0f) | ((srel & 0x30) << 5) | ((srel & 0x40) << 2); 1382 bfd_put_16 (input_bfd, x, contents); 1383 break; 1384 1385 case R_AVR_PORT6: 1386 contents += rel->r_offset; 1387 srel = (bfd_signed_vma) relocation + rel->r_addend; 1388 if ((srel & 0xffff) > 0x3f) 1389 return bfd_reloc_overflow; 1390 x = bfd_get_16 (input_bfd, contents); 1391 x = (x & 0xf9f0) | ((srel & 0x30) << 5) | (srel & 0x0f); 1392 bfd_put_16 (input_bfd, x, contents); 1393 break; 1394 1395 case R_AVR_PORT5: 1396 contents += rel->r_offset; 1397 srel = (bfd_signed_vma) relocation + rel->r_addend; 1398 if ((srel & 0xffff) > 0x1f) 1399 return bfd_reloc_overflow; 1400 x = bfd_get_16 (input_bfd, contents); 1401 x = (x & 0xff07) | ((srel & 0x1f) << 3); 1402 bfd_put_16 (input_bfd, x, contents); 1403 break; 1404 1405 default: 1406 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1407 contents, rel->r_offset, 1408 relocation, rel->r_addend); 1409 } 1410 1411 return r; 1412 } 1413 1414 /* Relocate an AVR ELF section. */ 1415 1416 static int 1417 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, 1418 struct bfd_link_info *info, 1419 bfd *input_bfd, 1420 asection *input_section, 1421 bfd_byte *contents, 1422 Elf_Internal_Rela *relocs, 1423 Elf_Internal_Sym *local_syms, 1424 asection **local_sections) 1425 { 1426 Elf_Internal_Shdr * symtab_hdr; 1427 struct elf_link_hash_entry ** sym_hashes; 1428 Elf_Internal_Rela * rel; 1429 Elf_Internal_Rela * relend; 1430 struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info); 1431 1432 if (htab == NULL) 1433 return false; 1434 1435 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 1436 sym_hashes = elf_sym_hashes (input_bfd); 1437 relend = relocs + input_section->reloc_count; 1438 1439 for (rel = relocs; rel < relend; rel ++) 1440 { 1441 reloc_howto_type * howto; 1442 unsigned long r_symndx; 1443 Elf_Internal_Sym * sym; 1444 asection * sec; 1445 struct elf_link_hash_entry * h; 1446 bfd_vma relocation; 1447 bfd_reloc_status_type r; 1448 const char * name; 1449 int r_type; 1450 1451 r_type = ELF32_R_TYPE (rel->r_info); 1452 r_symndx = ELF32_R_SYM (rel->r_info); 1453 howto = elf_avr_howto_table + r_type; 1454 h = NULL; 1455 sym = NULL; 1456 sec = NULL; 1457 1458 if (r_symndx < symtab_hdr->sh_info) 1459 { 1460 sym = local_syms + r_symndx; 1461 sec = local_sections [r_symndx]; 1462 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1463 1464 name = bfd_elf_string_from_elf_section 1465 (input_bfd, symtab_hdr->sh_link, sym->st_name); 1466 name = name == NULL ? bfd_section_name (sec) : name; 1467 } 1468 else 1469 { 1470 bool unresolved_reloc, warned, ignored; 1471 1472 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1473 r_symndx, symtab_hdr, sym_hashes, 1474 h, sec, relocation, 1475 unresolved_reloc, warned, ignored); 1476 1477 name = h->root.root.string; 1478 } 1479 1480 if (sec != NULL && discarded_section (sec)) 1481 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 1482 rel, 1, relend, howto, 0, contents); 1483 1484 if (bfd_link_relocatable (info)) 1485 continue; 1486 1487 r = avr_final_link_relocate (howto, input_bfd, input_section, 1488 contents, rel, relocation, htab); 1489 1490 if (r != bfd_reloc_ok) 1491 { 1492 switch (r) 1493 { 1494 case bfd_reloc_overflow: 1495 (*info->callbacks->reloc_overflow) 1496 (info, (h ? &h->root : NULL), name, howto->name, 1497 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 1498 break; 1499 1500 case bfd_reloc_undefined: 1501 (*info->callbacks->undefined_symbol) 1502 (info, name, input_bfd, input_section, rel->r_offset, true); 1503 break; 1504 1505 case bfd_reloc_outofrange: 1506 /* xgettext:c-format */ 1507 (*info->callbacks->einfo) 1508 (_("%X%H: %s against `%s':" 1509 " error: relocation applies outside section\n"), 1510 input_bfd, input_section, rel->r_offset, howto->name, name); 1511 break; 1512 1513 case bfd_reloc_other: 1514 /* xgettext:c-format */ 1515 (*info->callbacks->einfo) 1516 (_("%X%H: %s against `%s':" 1517 " error: relocation target address is odd\n"), 1518 input_bfd, input_section, rel->r_offset, howto->name, name); 1519 break; 1520 1521 default: 1522 /* xgettext:c-format */ 1523 (*info->callbacks->einfo) 1524 (_("%X%H: %s against `%s':" 1525 " internal error: unexpected relocation result %d\n"), 1526 input_bfd, input_section, rel->r_offset, howto->name, name, r); 1527 break; 1528 } 1529 } 1530 } 1531 1532 return true; 1533 } 1534 1535 /* The final processing done just before writing out a AVR ELF object 1536 file. This gets the AVR architecture right based on the machine 1537 number. */ 1538 1539 static bool 1540 bfd_elf_avr_final_write_processing (bfd *abfd) 1541 { 1542 unsigned long val; 1543 1544 switch (bfd_get_mach (abfd)) 1545 { 1546 default: 1547 case bfd_mach_avr2: 1548 val = E_AVR_MACH_AVR2; 1549 break; 1550 1551 case bfd_mach_avr1: 1552 val = E_AVR_MACH_AVR1; 1553 break; 1554 1555 case bfd_mach_avr25: 1556 val = E_AVR_MACH_AVR25; 1557 break; 1558 1559 case bfd_mach_avr3: 1560 val = E_AVR_MACH_AVR3; 1561 break; 1562 1563 case bfd_mach_avr31: 1564 val = E_AVR_MACH_AVR31; 1565 break; 1566 1567 case bfd_mach_avr35: 1568 val = E_AVR_MACH_AVR35; 1569 break; 1570 1571 case bfd_mach_avr4: 1572 val = E_AVR_MACH_AVR4; 1573 break; 1574 1575 case bfd_mach_avr5: 1576 val = E_AVR_MACH_AVR5; 1577 break; 1578 1579 case bfd_mach_avr51: 1580 val = E_AVR_MACH_AVR51; 1581 break; 1582 1583 case bfd_mach_avr6: 1584 val = E_AVR_MACH_AVR6; 1585 break; 1586 1587 case bfd_mach_avrxmega1: 1588 val = E_AVR_MACH_XMEGA1; 1589 break; 1590 1591 case bfd_mach_avrxmega2: 1592 val = E_AVR_MACH_XMEGA2; 1593 break; 1594 1595 case bfd_mach_avrxmega3: 1596 val = E_AVR_MACH_XMEGA3; 1597 break; 1598 1599 case bfd_mach_avrxmega4: 1600 val = E_AVR_MACH_XMEGA4; 1601 break; 1602 1603 case bfd_mach_avrxmega5: 1604 val = E_AVR_MACH_XMEGA5; 1605 break; 1606 1607 case bfd_mach_avrxmega6: 1608 val = E_AVR_MACH_XMEGA6; 1609 break; 1610 1611 case bfd_mach_avrxmega7: 1612 val = E_AVR_MACH_XMEGA7; 1613 break; 1614 1615 case bfd_mach_avrtiny: 1616 val = E_AVR_MACH_AVRTINY; 1617 break; 1618 } 1619 1620 elf_elfheader (abfd)->e_machine = EM_AVR; 1621 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH; 1622 elf_elfheader (abfd)->e_flags |= val; 1623 return _bfd_elf_final_write_processing (abfd); 1624 } 1625 1626 /* Set the right machine number. */ 1627 1628 static bool 1629 elf32_avr_object_p (bfd *abfd) 1630 { 1631 unsigned int e_set = bfd_mach_avr2; 1632 1633 if (elf_elfheader (abfd)->e_machine == EM_AVR 1634 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD) 1635 { 1636 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH; 1637 1638 switch (e_mach) 1639 { 1640 default: 1641 case E_AVR_MACH_AVR2: 1642 e_set = bfd_mach_avr2; 1643 break; 1644 1645 case E_AVR_MACH_AVR1: 1646 e_set = bfd_mach_avr1; 1647 break; 1648 1649 case E_AVR_MACH_AVR25: 1650 e_set = bfd_mach_avr25; 1651 break; 1652 1653 case E_AVR_MACH_AVR3: 1654 e_set = bfd_mach_avr3; 1655 break; 1656 1657 case E_AVR_MACH_AVR31: 1658 e_set = bfd_mach_avr31; 1659 break; 1660 1661 case E_AVR_MACH_AVR35: 1662 e_set = bfd_mach_avr35; 1663 break; 1664 1665 case E_AVR_MACH_AVR4: 1666 e_set = bfd_mach_avr4; 1667 break; 1668 1669 case E_AVR_MACH_AVR5: 1670 e_set = bfd_mach_avr5; 1671 break; 1672 1673 case E_AVR_MACH_AVR51: 1674 e_set = bfd_mach_avr51; 1675 break; 1676 1677 case E_AVR_MACH_AVR6: 1678 e_set = bfd_mach_avr6; 1679 break; 1680 1681 case E_AVR_MACH_XMEGA1: 1682 e_set = bfd_mach_avrxmega1; 1683 break; 1684 1685 case E_AVR_MACH_XMEGA2: 1686 e_set = bfd_mach_avrxmega2; 1687 break; 1688 1689 case E_AVR_MACH_XMEGA3: 1690 e_set = bfd_mach_avrxmega3; 1691 break; 1692 1693 case E_AVR_MACH_XMEGA4: 1694 e_set = bfd_mach_avrxmega4; 1695 break; 1696 1697 case E_AVR_MACH_XMEGA5: 1698 e_set = bfd_mach_avrxmega5; 1699 break; 1700 1701 case E_AVR_MACH_XMEGA6: 1702 e_set = bfd_mach_avrxmega6; 1703 break; 1704 1705 case E_AVR_MACH_XMEGA7: 1706 e_set = bfd_mach_avrxmega7; 1707 break; 1708 1709 case E_AVR_MACH_AVRTINY: 1710 e_set = bfd_mach_avrtiny; 1711 break; 1712 } 1713 } 1714 return bfd_default_set_arch_mach (abfd, bfd_arch_avr, 1715 e_set); 1716 } 1717 1718 /* Returns whether the relocation type passed is a diff reloc. */ 1719 1720 static bool 1721 elf32_avr_is_diff_reloc (Elf_Internal_Rela *irel) 1722 { 1723 return (ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF8 1724 ||ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF16 1725 || ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF32); 1726 } 1727 1728 /* Reduce the diff value written in the section by count if the shrinked 1729 insn address happens to fall between the two symbols for which this 1730 diff reloc was emitted. */ 1731 1732 static void 1733 elf32_avr_adjust_diff_reloc_value (bfd *abfd, 1734 struct bfd_section *isec, 1735 Elf_Internal_Rela *irel, 1736 bfd_vma symval, 1737 bfd_vma shrinked_insn_address, 1738 int count) 1739 { 1740 unsigned char *reloc_contents = NULL; 1741 unsigned char *isec_contents = elf_section_data (isec)->this_hdr.contents; 1742 if (isec_contents == NULL) 1743 { 1744 if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents)) 1745 return; 1746 1747 elf_section_data (isec)->this_hdr.contents = isec_contents; 1748 } 1749 1750 reloc_contents = isec_contents + irel->r_offset; 1751 1752 /* Read value written in object file. */ 1753 bfd_signed_vma x = 0; 1754 switch (ELF32_R_TYPE (irel->r_info)) 1755 { 1756 case R_AVR_DIFF8: 1757 { 1758 x = bfd_get_signed_8 (abfd, reloc_contents); 1759 break; 1760 } 1761 case R_AVR_DIFF16: 1762 { 1763 x = bfd_get_signed_16 (abfd, reloc_contents); 1764 break; 1765 } 1766 case R_AVR_DIFF32: 1767 { 1768 x = bfd_get_signed_32 (abfd, reloc_contents); 1769 break; 1770 } 1771 default: 1772 { 1773 BFD_FAIL(); 1774 } 1775 } 1776 1777 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written 1778 into the object file at the reloc offset. sym2's logical value is 1779 symval (<start_of_section>) + reloc addend. Compute the start and end 1780 addresses and check if the shrinked insn falls between sym1 and sym2. */ 1781 1782 bfd_vma sym2_address = symval + irel->r_addend; 1783 bfd_vma sym1_address = sym2_address - x; 1784 1785 /* Don't assume sym2 is bigger than sym1 - the difference 1786 could be negative. Compute start and end addresses, and 1787 use those to see if they span shrinked_insn_address. */ 1788 1789 bfd_vma start_address = sym1_address < sym2_address 1790 ? sym1_address : sym2_address; 1791 bfd_vma end_address = sym1_address > sym2_address 1792 ? sym1_address : sym2_address; 1793 1794 1795 if (shrinked_insn_address >= start_address 1796 && shrinked_insn_address < end_address) 1797 { 1798 /* Reduce the diff value by count bytes and write it back into section 1799 contents. */ 1800 bfd_signed_vma new_diff = x < 0 ? x + count : x - count; 1801 1802 if (sym2_address > shrinked_insn_address) 1803 irel->r_addend -= count; 1804 1805 switch (ELF32_R_TYPE (irel->r_info)) 1806 { 1807 case R_AVR_DIFF8: 1808 { 1809 bfd_put_signed_8 (abfd, new_diff, reloc_contents); 1810 break; 1811 } 1812 case R_AVR_DIFF16: 1813 { 1814 bfd_put_signed_16 (abfd, new_diff & 0xFFFF, reloc_contents); 1815 break; 1816 } 1817 case R_AVR_DIFF32: 1818 { 1819 bfd_put_signed_32 (abfd, new_diff & 0xFFFFFFFF, reloc_contents); 1820 break; 1821 } 1822 default: 1823 { 1824 BFD_FAIL(); 1825 } 1826 } 1827 1828 } 1829 } 1830 1831 static void 1832 elf32_avr_adjust_reloc_if_spans_insn (bfd *abfd, 1833 asection *isec, 1834 Elf_Internal_Rela *irel, bfd_vma symval, 1835 bfd_vma shrinked_insn_address, 1836 bfd_vma shrink_boundary, 1837 int count) 1838 { 1839 1840 if (elf32_avr_is_diff_reloc (irel)) 1841 { 1842 elf32_avr_adjust_diff_reloc_value (abfd, isec, irel, 1843 symval, 1844 shrinked_insn_address, 1845 count); 1846 } 1847 else 1848 { 1849 bfd_vma reloc_value = symval + irel->r_addend; 1850 bool addend_within_shrink_boundary = reloc_value <= shrink_boundary; 1851 1852 bool reloc_spans_insn = 1853 (symval <= shrinked_insn_address 1854 && reloc_value > shrinked_insn_address 1855 && addend_within_shrink_boundary); 1856 1857 if (! reloc_spans_insn) 1858 return; 1859 1860 irel->r_addend -= count; 1861 1862 if (debug_relax) 1863 printf ("Relocation's addend needed to be fixed \n"); 1864 } 1865 } 1866 1867 static bool 1868 avr_should_move_sym (symvalue symval, 1869 bfd_vma start, 1870 bfd_vma end, 1871 bool did_pad) 1872 { 1873 bool sym_within_boundary = did_pad ? symval < end : symval <= end; 1874 return (symval > start && sym_within_boundary); 1875 } 1876 1877 static bool 1878 avr_should_reduce_sym_size (symvalue symval, 1879 symvalue symend, 1880 bfd_vma start, 1881 bfd_vma end, 1882 bool did_pad) 1883 { 1884 bool sym_end_within_boundary = did_pad ? symend < end : symend <= end; 1885 return (symval <= start && symend > start && sym_end_within_boundary); 1886 } 1887 1888 static bool 1889 avr_should_increase_sym_size (symvalue symval, 1890 symvalue symend, 1891 bfd_vma start, 1892 bfd_vma end, 1893 bool did_pad) 1894 { 1895 return (avr_should_move_sym (symval, start, end, did_pad) 1896 && symend >= end && did_pad); 1897 } 1898 1899 /* Delete some bytes from a section while changing the size of an instruction. 1900 The parameter "addr" denotes the section-relative offset pointing just 1901 behind the shrinked instruction. "addr+count" point at the first 1902 byte just behind the original unshrinked instruction. If delete_shrinks_insn 1903 is FALSE, we are deleting redundant padding bytes from relax_info prop 1904 record handling. In that case, addr is section-relative offset of start 1905 of padding, and count is the number of padding bytes to delete. */ 1906 1907 static bool 1908 elf32_avr_relax_delete_bytes (bfd *abfd, 1909 asection *sec, 1910 bfd_vma addr, 1911 int count, 1912 bool delete_shrinks_insn) 1913 { 1914 Elf_Internal_Shdr *symtab_hdr; 1915 unsigned int sec_shndx; 1916 bfd_byte *contents; 1917 Elf_Internal_Rela *irel, *irelend; 1918 Elf_Internal_Sym *isym; 1919 Elf_Internal_Sym *isymbuf = NULL; 1920 bfd_vma toaddr; 1921 struct elf_link_hash_entry **sym_hashes; 1922 struct elf_link_hash_entry **end_hashes; 1923 unsigned int symcount; 1924 struct avr_relax_info *relax_info; 1925 struct avr_property_record *prop_record = NULL; 1926 bool did_shrink = false; 1927 bool did_pad = false; 1928 1929 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1930 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1931 contents = elf_section_data (sec)->this_hdr.contents; 1932 relax_info = get_avr_relax_info (sec); 1933 1934 toaddr = sec->size; 1935 1936 if (relax_info->records.count > 0) 1937 { 1938 /* There should be no property record within the range of deleted 1939 bytes, however, there might be a property record for ADDR, this is 1940 how we handle alignment directives. 1941 Find the next (if any) property record after the deleted bytes. */ 1942 unsigned int i; 1943 1944 for (i = 0; i < relax_info->records.count; ++i) 1945 { 1946 bfd_vma offset = relax_info->records.items [i].offset; 1947 1948 BFD_ASSERT (offset <= addr || offset >= (addr + count)); 1949 if (offset >= (addr + count)) 1950 { 1951 prop_record = &relax_info->records.items [i]; 1952 toaddr = offset; 1953 break; 1954 } 1955 } 1956 } 1957 1958 irel = elf_section_data (sec)->relocs; 1959 irelend = irel + sec->reloc_count; 1960 1961 /* Actually delete the bytes. */ 1962 if (toaddr - addr - count > 0) 1963 { 1964 memmove (contents + addr, contents + addr + count, 1965 (size_t) (toaddr - addr - count)); 1966 did_shrink = true; 1967 } 1968 if (prop_record == NULL) 1969 { 1970 sec->size -= count; 1971 did_shrink = true; 1972 } 1973 else 1974 { 1975 /* Use the property record to fill in the bytes we've opened up. */ 1976 int fill = 0; 1977 switch (prop_record->type) 1978 { 1979 case RECORD_ORG_AND_FILL: 1980 fill = prop_record->data.org.fill; 1981 /* Fall through. */ 1982 case RECORD_ORG: 1983 break; 1984 case RECORD_ALIGN_AND_FILL: 1985 fill = prop_record->data.align.fill; 1986 /* Fall through. */ 1987 case RECORD_ALIGN: 1988 prop_record->data.align.preceding_deleted += count; 1989 break; 1990 }; 1991 /* If toaddr == (addr + count), then we didn't delete anything, yet 1992 we fill count bytes backwards from toaddr. This is still ok - we 1993 end up overwriting the bytes we would have deleted. We just need 1994 to remember we didn't delete anything i.e. don't set did_shrink, 1995 so that we don't corrupt reloc offsets or symbol values.*/ 1996 memset (contents + toaddr - count, fill, count); 1997 did_pad = true; 1998 } 1999 2000 if (!did_shrink) 2001 return true; 2002 2003 /* Adjust all the reloc addresses. */ 2004 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 2005 { 2006 bfd_vma old_reloc_address; 2007 2008 old_reloc_address = (sec->output_section->vma 2009 + sec->output_offset + irel->r_offset); 2010 2011 /* Get the new reloc address. */ 2012 if ((irel->r_offset > addr 2013 && irel->r_offset < toaddr)) 2014 { 2015 if (debug_relax) 2016 printf ("Relocation at address 0x%x needs to be moved.\n" 2017 "Old section offset: 0x%x, New section offset: 0x%x \n", 2018 (unsigned int) old_reloc_address, 2019 (unsigned int) irel->r_offset, 2020 (unsigned int) ((irel->r_offset) - count)); 2021 2022 irel->r_offset -= count; 2023 } 2024 2025 } 2026 2027 /* The reloc's own addresses are now ok. However, we need to readjust 2028 the reloc's addend, i.e. the reloc's value if two conditions are met: 2029 1.) the reloc is relative to a symbol in this section that 2030 is located in front of the shrinked instruction 2031 2.) symbol plus addend end up behind the shrinked instruction. 2032 2033 The most common case where this happens are relocs relative to 2034 the section-start symbol. 2035 2036 This step needs to be done for all of the sections of the bfd. */ 2037 2038 { 2039 struct bfd_section *isec; 2040 2041 for (isec = abfd->sections; isec; isec = isec->next) 2042 { 2043 bfd_vma symval; 2044 bfd_vma shrinked_insn_address; 2045 2046 if (isec->reloc_count == 0) 2047 continue; 2048 2049 shrinked_insn_address = (sec->output_section->vma 2050 + sec->output_offset + addr); 2051 if (delete_shrinks_insn) 2052 shrinked_insn_address -= count; 2053 2054 irel = elf_section_data (isec)->relocs; 2055 /* PR 12161: Read in the relocs for this section if necessary. */ 2056 if (irel == NULL) 2057 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, true); 2058 2059 for (irelend = irel + isec->reloc_count; 2060 irel < irelend; 2061 irel++) 2062 { 2063 /* Read this BFD's local symbols if we haven't done 2064 so already. */ 2065 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 2066 { 2067 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 2068 if (isymbuf == NULL) 2069 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 2070 symtab_hdr->sh_info, 0, 2071 NULL, NULL, NULL); 2072 if (isymbuf == NULL) 2073 return false; 2074 } 2075 2076 /* Get the value of the symbol referred to by the reloc. */ 2077 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 2078 { 2079 /* A local symbol. */ 2080 asection *sym_sec; 2081 2082 isym = isymbuf + ELF32_R_SYM (irel->r_info); 2083 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 2084 symval = isym->st_value; 2085 /* If the reloc is absolute, it will not have 2086 a symbol or section associated with it. */ 2087 if (sym_sec == sec) 2088 { 2089 /* If there is an alignment boundary, we only need to 2090 adjust addends that end up below the boundary. */ 2091 bfd_vma shrink_boundary = (toaddr 2092 + sec->output_section->vma 2093 + sec->output_offset); 2094 2095 symval += sym_sec->output_section->vma 2096 + sym_sec->output_offset; 2097 2098 if (debug_relax) 2099 printf ("Checking if the relocation's " 2100 "addend needs corrections.\n" 2101 "Address of anchor symbol: 0x%x \n" 2102 "Address of relocation target: 0x%x \n" 2103 "Address of relaxed insn: 0x%x \n", 2104 (unsigned int) symval, 2105 (unsigned int) (symval + irel->r_addend), 2106 (unsigned int) shrinked_insn_address); 2107 2108 elf32_avr_adjust_reloc_if_spans_insn (abfd, isec, irel, 2109 symval, 2110 shrinked_insn_address, 2111 shrink_boundary, 2112 count); 2113 } 2114 /* else...Reference symbol is absolute. No adjustment needed. */ 2115 } 2116 /* else...Reference symbol is extern. No need for adjusting 2117 the addend. */ 2118 } 2119 } 2120 } 2121 2122 /* Adjust the local symbols defined in this section. */ 2123 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 2124 /* Fix PR 9841, there may be no local symbols. */ 2125 if (isym != NULL) 2126 { 2127 Elf_Internal_Sym *isymend; 2128 2129 isymend = isym + symtab_hdr->sh_info; 2130 for (; isym < isymend; isym++) 2131 { 2132 if (isym->st_shndx == sec_shndx) 2133 { 2134 symvalue symval = isym->st_value; 2135 symvalue symend = symval + isym->st_size; 2136 if (avr_should_reduce_sym_size (symval, symend, 2137 addr, toaddr, did_pad)) 2138 { 2139 /* If this assert fires then we have a symbol that ends 2140 part way through an instruction. Does that make 2141 sense? */ 2142 BFD_ASSERT (isym->st_value + isym->st_size >= addr + count); 2143 isym->st_size -= count; 2144 } 2145 else if (avr_should_increase_sym_size (symval, symend, 2146 addr, toaddr, did_pad)) 2147 isym->st_size += count; 2148 2149 if (avr_should_move_sym (symval, addr, toaddr, did_pad)) 2150 isym->st_value -= count; 2151 } 2152 } 2153 } 2154 2155 /* Now adjust the global symbols defined in this section. */ 2156 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 2157 - symtab_hdr->sh_info); 2158 sym_hashes = elf_sym_hashes (abfd); 2159 end_hashes = sym_hashes + symcount; 2160 for (; sym_hashes < end_hashes; sym_hashes++) 2161 { 2162 struct elf_link_hash_entry *sym_hash = *sym_hashes; 2163 if ((sym_hash->root.type == bfd_link_hash_defined 2164 || sym_hash->root.type == bfd_link_hash_defweak) 2165 && sym_hash->root.u.def.section == sec) 2166 { 2167 symvalue symval = sym_hash->root.u.def.value; 2168 symvalue symend = symval + sym_hash->size; 2169 2170 if (avr_should_reduce_sym_size (symval, symend, 2171 addr, toaddr, did_pad)) 2172 { 2173 /* If this assert fires then we have a symbol that ends 2174 part way through an instruction. Does that make 2175 sense? */ 2176 BFD_ASSERT (symend >= addr + count); 2177 sym_hash->size -= count; 2178 } 2179 else if (avr_should_increase_sym_size (symval, symend, 2180 addr, toaddr, did_pad)) 2181 sym_hash->size += count; 2182 2183 if (avr_should_move_sym (symval, addr, toaddr, did_pad)) 2184 sym_hash->root.u.def.value -= count; 2185 } 2186 } 2187 2188 return true; 2189 } 2190 2191 static Elf_Internal_Sym * 2192 retrieve_local_syms (bfd *input_bfd) 2193 { 2194 Elf_Internal_Shdr *symtab_hdr; 2195 Elf_Internal_Sym *isymbuf; 2196 size_t locsymcount; 2197 2198 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2199 locsymcount = symtab_hdr->sh_info; 2200 2201 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 2202 if (isymbuf == NULL && locsymcount != 0) 2203 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0, 2204 NULL, NULL, NULL); 2205 2206 /* Save the symbols for this input file so they won't be read again. */ 2207 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents) 2208 symtab_hdr->contents = (unsigned char *) isymbuf; 2209 2210 return isymbuf; 2211 } 2212 2213 /* Get the input section for a given symbol index. 2214 If the symbol is: 2215 . a section symbol, return the section; 2216 . a common symbol, return the common section; 2217 . an undefined symbol, return the undefined section; 2218 . an indirect symbol, follow the links; 2219 . an absolute value, return the absolute section. */ 2220 2221 static asection * 2222 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx) 2223 { 2224 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2225 asection *target_sec = NULL; 2226 if (r_symndx < symtab_hdr->sh_info) 2227 { 2228 Elf_Internal_Sym *isymbuf; 2229 unsigned int section_index; 2230 2231 isymbuf = retrieve_local_syms (abfd); 2232 section_index = isymbuf[r_symndx].st_shndx; 2233 2234 if (section_index == SHN_UNDEF) 2235 target_sec = bfd_und_section_ptr; 2236 else if (section_index == SHN_ABS) 2237 target_sec = bfd_abs_section_ptr; 2238 else if (section_index == SHN_COMMON) 2239 target_sec = bfd_com_section_ptr; 2240 else 2241 target_sec = bfd_section_from_elf_index (abfd, section_index); 2242 } 2243 else 2244 { 2245 unsigned long indx = r_symndx - symtab_hdr->sh_info; 2246 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx]; 2247 2248 while (h->root.type == bfd_link_hash_indirect 2249 || h->root.type == bfd_link_hash_warning) 2250 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2251 2252 switch (h->root.type) 2253 { 2254 case bfd_link_hash_defined: 2255 case bfd_link_hash_defweak: 2256 target_sec = h->root.u.def.section; 2257 break; 2258 case bfd_link_hash_common: 2259 target_sec = bfd_com_section_ptr; 2260 break; 2261 case bfd_link_hash_undefined: 2262 case bfd_link_hash_undefweak: 2263 target_sec = bfd_und_section_ptr; 2264 break; 2265 default: /* New indirect warning. */ 2266 target_sec = bfd_und_section_ptr; 2267 break; 2268 } 2269 } 2270 return target_sec; 2271 } 2272 2273 /* Get the section-relative offset for a symbol number. */ 2274 2275 static bfd_vma 2276 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx) 2277 { 2278 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2279 bfd_vma offset = 0; 2280 2281 if (r_symndx < symtab_hdr->sh_info) 2282 { 2283 Elf_Internal_Sym *isymbuf; 2284 isymbuf = retrieve_local_syms (abfd); 2285 offset = isymbuf[r_symndx].st_value; 2286 } 2287 else 2288 { 2289 unsigned long indx = r_symndx - symtab_hdr->sh_info; 2290 struct elf_link_hash_entry *h = 2291 elf_sym_hashes (abfd)[indx]; 2292 2293 while (h->root.type == bfd_link_hash_indirect 2294 || h->root.type == bfd_link_hash_warning) 2295 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2296 if (h->root.type == bfd_link_hash_defined 2297 || h->root.type == bfd_link_hash_defweak) 2298 offset = h->root.u.def.value; 2299 } 2300 return offset; 2301 } 2302 2303 /* Iterate over the property records in R_LIST, and copy each record into 2304 the list of records within the relaxation information for the section to 2305 which the record applies. */ 2306 2307 static void 2308 avr_elf32_assign_records_to_sections (struct avr_property_record_list *r_list) 2309 { 2310 unsigned int i; 2311 2312 for (i = 0; i < r_list->record_count; ++i) 2313 { 2314 struct avr_relax_info *relax_info; 2315 2316 relax_info = get_avr_relax_info (r_list->records [i].section); 2317 BFD_ASSERT (relax_info != NULL); 2318 2319 if (relax_info->records.count 2320 == relax_info->records.allocated) 2321 { 2322 /* Allocate more space. */ 2323 bfd_size_type size; 2324 2325 relax_info->records.allocated += 10; 2326 size = (sizeof (struct avr_property_record) 2327 * relax_info->records.allocated); 2328 relax_info->records.items 2329 = bfd_realloc (relax_info->records.items, size); 2330 } 2331 2332 memcpy (&relax_info->records.items [relax_info->records.count], 2333 &r_list->records [i], 2334 sizeof (struct avr_property_record)); 2335 relax_info->records.count++; 2336 } 2337 } 2338 2339 /* Compare two STRUCT AVR_PROPERTY_RECORD in AP and BP, used as the 2340 ordering callback from QSORT. */ 2341 2342 static int 2343 avr_property_record_compare (const void *ap, const void *bp) 2344 { 2345 const struct avr_property_record *a 2346 = (struct avr_property_record *) ap; 2347 const struct avr_property_record *b 2348 = (struct avr_property_record *) bp; 2349 2350 if (a->offset != b->offset) 2351 return (a->offset - b->offset); 2352 2353 if (a->section != b->section) 2354 return bfd_section_vma (a->section) - bfd_section_vma (b->section); 2355 2356 return (a->type - b->type); 2357 } 2358 2359 /* Load all of the avr property sections from all of the bfd objects 2360 referenced from LINK_INFO. All of the records within each property 2361 section are assigned to the STRUCT AVR_RELAX_INFO within the section 2362 specific data of the appropriate section. */ 2363 2364 static void 2365 avr_load_all_property_sections (struct bfd_link_info *link_info) 2366 { 2367 bfd *abfd; 2368 asection *sec; 2369 2370 /* Initialize the per-section relaxation info. */ 2371 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next) 2372 for (sec = abfd->sections; sec != NULL; sec = sec->next) 2373 { 2374 init_avr_relax_info (sec); 2375 } 2376 2377 /* Load the descriptor tables from .avr.prop sections. */ 2378 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next) 2379 { 2380 struct avr_property_record_list *r_list; 2381 2382 r_list = avr_elf32_load_property_records (abfd); 2383 if (r_list != NULL) 2384 avr_elf32_assign_records_to_sections (r_list); 2385 2386 free (r_list); 2387 } 2388 2389 /* Now, for every section, ensure that the descriptor list in the 2390 relaxation data is sorted by ascending offset within the section. */ 2391 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next) 2392 for (sec = abfd->sections; sec != NULL; sec = sec->next) 2393 { 2394 struct avr_relax_info *relax_info = get_avr_relax_info (sec); 2395 if (relax_info && relax_info->records.count > 0) 2396 { 2397 unsigned int i; 2398 2399 qsort (relax_info->records.items, 2400 relax_info->records.count, 2401 sizeof (struct avr_property_record), 2402 avr_property_record_compare); 2403 2404 /* For debug purposes, list all the descriptors. */ 2405 for (i = 0; i < relax_info->records.count; ++i) 2406 { 2407 switch (relax_info->records.items [i].type) 2408 { 2409 case RECORD_ORG: 2410 break; 2411 case RECORD_ORG_AND_FILL: 2412 break; 2413 case RECORD_ALIGN: 2414 break; 2415 case RECORD_ALIGN_AND_FILL: 2416 break; 2417 }; 2418 } 2419 } 2420 } 2421 } 2422 2423 /* This function handles relaxing for the avr. 2424 Many important relaxing opportunities within functions are already 2425 realized by the compiler itself. 2426 Here we try to replace call (4 bytes) -> rcall (2 bytes) 2427 and jump -> rjmp (safes also 2 bytes). 2428 As well we now optimize seqences of 2429 - call/rcall function 2430 - ret 2431 to yield 2432 - jmp/rjmp function 2433 - ret 2434 . In case that within a sequence 2435 - jmp/rjmp label 2436 - ret 2437 the ret could no longer be reached it is optimized away. In order 2438 to check if the ret is no longer needed, it is checked that the ret's address 2439 is not the target of a branch or jump within the same section, it is checked 2440 that there is no skip instruction before the jmp/rjmp and that there 2441 is no local or global label place at the address of the ret. 2442 2443 We refrain from relaxing within sections ".vectors" and 2444 ".jumptables" in order to maintain the position of the instructions. 2445 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop 2446 if possible. (In future one could possibly use the space of the nop 2447 for the first instruction of the irq service function. 2448 2449 The .jumptables sections is meant to be used for a future tablejump variant 2450 for the devices with 3-byte program counter where the table itself 2451 contains 4-byte jump instructions whose relative offset must not 2452 be changed. */ 2453 2454 static bool 2455 elf32_avr_relax_section (bfd *abfd, 2456 asection *sec, 2457 struct bfd_link_info *link_info, 2458 bool *again) 2459 { 2460 Elf_Internal_Shdr *symtab_hdr; 2461 Elf_Internal_Rela *internal_relocs; 2462 Elf_Internal_Rela *irel, *irelend; 2463 bfd_byte *contents = NULL; 2464 Elf_Internal_Sym *isymbuf = NULL; 2465 struct elf32_avr_link_hash_table *htab; 2466 static bool relaxation_initialised = false; 2467 2468 if (!relaxation_initialised) 2469 { 2470 relaxation_initialised = true; 2471 2472 /* Load entries from the .avr.prop sections. */ 2473 avr_load_all_property_sections (link_info); 2474 } 2475 2476 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while 2477 relaxing. Such shrinking can cause issues for the sections such 2478 as .vectors and .jumptables. Instead the unused bytes should be 2479 filled with nop instructions. */ 2480 bool shrinkable = true; 2481 2482 if (!strcmp (sec->name,".vectors") 2483 || !strcmp (sec->name,".jumptables")) 2484 shrinkable = false; 2485 2486 if (bfd_link_relocatable (link_info)) 2487 (*link_info->callbacks->einfo) 2488 (_("%P%F: --relax and -r may not be used together\n")); 2489 2490 htab = avr_link_hash_table (link_info); 2491 if (htab == NULL) 2492 return false; 2493 2494 /* Assume nothing changes. */ 2495 *again = false; 2496 2497 if ((!htab->no_stubs) && (sec == htab->stub_sec)) 2498 { 2499 /* We are just relaxing the stub section. 2500 Let's calculate the size needed again. */ 2501 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size; 2502 2503 if (debug_relax) 2504 printf ("Relaxing the stub section. Size prior to this pass: %i\n", 2505 (int) last_estimated_stub_section_size); 2506 2507 elf32_avr_size_stubs (htab->stub_sec->output_section->owner, 2508 link_info, false); 2509 2510 /* Check if the number of trampolines changed. */ 2511 if (last_estimated_stub_section_size != htab->stub_sec->size) 2512 *again = true; 2513 2514 if (debug_relax) 2515 printf ("Size of stub section after this pass: %i\n", 2516 (int) htab->stub_sec->size); 2517 2518 return true; 2519 } 2520 2521 /* We don't have to do anything for a relocatable link, if 2522 this section does not have relocs, or if this is not a 2523 code section. */ 2524 if (bfd_link_relocatable (link_info) 2525 || sec->reloc_count == 0 2526 || (sec->flags & SEC_RELOC) == 0 2527 || (sec->flags & SEC_HAS_CONTENTS) == 0 2528 || (sec->flags & SEC_CODE) == 0) 2529 return true; 2530 2531 /* Check if the object file to relax uses internal symbols so that we 2532 could fix up the relocations. */ 2533 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED)) 2534 return true; 2535 2536 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2537 2538 /* Get a copy of the native relocations. */ 2539 internal_relocs = (_bfd_elf_link_read_relocs 2540 (abfd, sec, NULL, NULL, link_info->keep_memory)); 2541 if (internal_relocs == NULL) 2542 goto error_return; 2543 2544 /* Walk through the relocs looking for relaxing opportunities. */ 2545 irelend = internal_relocs + sec->reloc_count; 2546 for (irel = internal_relocs; irel < irelend; irel++) 2547 { 2548 bfd_vma symval; 2549 2550 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL 2551 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL 2552 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL) 2553 continue; 2554 2555 /* Get the section contents if we haven't done so already. */ 2556 if (contents == NULL) 2557 { 2558 /* Get cached copy if it exists. */ 2559 if (elf_section_data (sec)->this_hdr.contents != NULL) 2560 contents = elf_section_data (sec)->this_hdr.contents; 2561 else 2562 { 2563 /* Go get them off disk. */ 2564 if (! bfd_malloc_and_get_section (abfd, sec, &contents)) 2565 goto error_return; 2566 } 2567 } 2568 2569 /* Read this BFD's local symbols if we haven't done so already. */ 2570 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 2571 { 2572 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 2573 if (isymbuf == NULL) 2574 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 2575 symtab_hdr->sh_info, 0, 2576 NULL, NULL, NULL); 2577 if (isymbuf == NULL) 2578 goto error_return; 2579 } 2580 2581 2582 /* Get the value of the symbol referred to by the reloc. */ 2583 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 2584 { 2585 /* A local symbol. */ 2586 Elf_Internal_Sym *isym; 2587 asection *sym_sec; 2588 2589 isym = isymbuf + ELF32_R_SYM (irel->r_info); 2590 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 2591 symval = isym->st_value; 2592 /* If the reloc is absolute, it will not have 2593 a symbol or section associated with it. */ 2594 if (sym_sec) 2595 symval += sym_sec->output_section->vma 2596 + sym_sec->output_offset; 2597 } 2598 else 2599 { 2600 unsigned long indx; 2601 struct elf_link_hash_entry *h; 2602 2603 /* An external symbol. */ 2604 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 2605 h = elf_sym_hashes (abfd)[indx]; 2606 BFD_ASSERT (h != NULL); 2607 if (h->root.type != bfd_link_hash_defined 2608 && h->root.type != bfd_link_hash_defweak) 2609 /* This appears to be a reference to an undefined 2610 symbol. Just ignore it--it will be caught by the 2611 regular reloc processing. */ 2612 continue; 2613 2614 symval = (h->root.u.def.value 2615 + h->root.u.def.section->output_section->vma 2616 + h->root.u.def.section->output_offset); 2617 } 2618 2619 /* For simplicity of coding, we are going to modify the section 2620 contents, the section relocs, and the BFD symbol table. We 2621 must tell the rest of the code not to free up this 2622 information. It would be possible to instead create a table 2623 of changes which have to be made, as is done in coff-mips.c; 2624 that would be more work, but would require less memory when 2625 the linker is run. */ 2626 switch (ELF32_R_TYPE (irel->r_info)) 2627 { 2628 /* Try to turn a 22-bit absolute call/jump into an 13-bit 2629 pc-relative rcall/rjmp. */ 2630 case R_AVR_CALL: 2631 { 2632 bfd_vma value = symval + irel->r_addend; 2633 bfd_vma dot, gap; 2634 int distance_short_enough = 0; 2635 2636 /* Get the address of this instruction. */ 2637 dot = (sec->output_section->vma 2638 + sec->output_offset + irel->r_offset); 2639 2640 /* Compute the distance from this insn to the branch target. */ 2641 gap = value - dot; 2642 2643 /* The ISA manual states that addressable range is PC - 2k + 1 to 2644 PC + 2k. In bytes, that would be -4094 <= PC <= 4096. The range 2645 is shifted one word to the right, because pc-relative instructions 2646 implicitly add one word i.e. rjmp 0 jumps to next insn, not the 2647 current one. 2648 Therefore, for the !shrinkable case, the range is as above. 2649 If shrinkable, then the current code only deletes bytes 3 and 2650 4 of the absolute call/jmp, so the forward jump range increases 2651 by 2 bytes, but the backward (negative) jump range remains 2652 the same. */ 2653 2654 2655 /* Check if the gap falls in the range that can be accommodated 2656 in 13bits signed (It is 12bits when encoded, as we deal with 2657 word addressing). */ 2658 if (!shrinkable && ((int) gap >= -4094 && (int) gap <= 4096)) 2659 distance_short_enough = 1; 2660 /* If shrinkable, then we can check for a range of distance which 2661 is two bytes farther on the positive direction because the call 2662 or jump target will be closer by two bytes after the 2663 relaxation. */ 2664 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4098)) 2665 distance_short_enough = 1; 2666 2667 /* Here we handle the wrap-around case. E.g. for a 16k device 2668 we could use a rjmp to jump from address 0x100 to 0x3d00! 2669 In order to make this work properly, we need to fill the 2670 vaiable avr_pc_wrap_around with the appropriate value. 2671 I.e. 0x4000 for a 16k device. */ 2672 { 2673 /* Shrinking the code size makes the gaps larger in the 2674 case of wrap-arounds. So we use a heuristical safety 2675 margin to avoid that during relax the distance gets 2676 again too large for the short jumps. Let's assume 2677 a typical code-size reduction due to relax for a 2678 16k device of 600 bytes. So let's use twice the 2679 typical value as safety margin. */ 2680 int rgap; 2681 int safety_margin; 2682 2683 int assumed_shrink = 600; 2684 if (avr_pc_wrap_around > 0x4000) 2685 assumed_shrink = 900; 2686 2687 safety_margin = 2 * assumed_shrink; 2688 2689 rgap = avr_relative_distance_considering_wrap_around (gap); 2690 2691 if (rgap >= (-4092 + safety_margin) 2692 && rgap <= (4094 - safety_margin)) 2693 distance_short_enough = 1; 2694 } 2695 2696 if (distance_short_enough) 2697 { 2698 unsigned char code_msb; 2699 unsigned char code_lsb; 2700 2701 if (debug_relax) 2702 printf ("shrinking jump/call instruction at address 0x%x" 2703 " in section %s\n\n", 2704 (int) dot, sec->name); 2705 2706 /* Note that we've changed the relocs, section contents, 2707 etc. */ 2708 elf_section_data (sec)->relocs = internal_relocs; 2709 elf_section_data (sec)->this_hdr.contents = contents; 2710 symtab_hdr->contents = (unsigned char *) isymbuf; 2711 2712 /* Get the instruction code for relaxing. */ 2713 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset); 2714 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1); 2715 2716 /* Mask out the relocation bits. */ 2717 code_msb &= 0x94; 2718 code_lsb &= 0x0E; 2719 if (code_msb == 0x94 && code_lsb == 0x0E) 2720 { 2721 /* we are changing call -> rcall . */ 2722 bfd_put_8 (abfd, 0x00, contents + irel->r_offset); 2723 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1); 2724 } 2725 else if (code_msb == 0x94 && code_lsb == 0x0C) 2726 { 2727 /* we are changeing jump -> rjmp. */ 2728 bfd_put_8 (abfd, 0x00, contents + irel->r_offset); 2729 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1); 2730 } 2731 else 2732 abort (); 2733 2734 /* Fix the relocation's type. */ 2735 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 2736 R_AVR_13_PCREL); 2737 2738 /* We should not modify the ordering if 'shrinkable' is 2739 FALSE. */ 2740 if (!shrinkable) 2741 { 2742 /* Let's insert a nop. */ 2743 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2); 2744 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3); 2745 } 2746 else 2747 { 2748 /* Delete two bytes of data. */ 2749 if (!elf32_avr_relax_delete_bytes (abfd, sec, 2750 irel->r_offset + 2, 2, 2751 true)) 2752 goto error_return; 2753 2754 /* That will change things, so, we should relax again. 2755 Note that this is not required, and it may be slow. */ 2756 *again = true; 2757 } 2758 } 2759 } 2760 /* Fall through. */ 2761 2762 default: 2763 { 2764 unsigned char code_msb; 2765 unsigned char code_lsb; 2766 bfd_vma dot; 2767 2768 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1); 2769 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0); 2770 2771 /* Get the address of this instruction. */ 2772 dot = (sec->output_section->vma 2773 + sec->output_offset + irel->r_offset); 2774 2775 /* Here we look for rcall/ret or call/ret sequences that could be 2776 safely replaced by rjmp/ret or jmp/ret. */ 2777 if (((code_msb & 0xf0) == 0xd0) 2778 && avr_replace_call_ret_sequences) 2779 { 2780 /* This insn is a rcall. */ 2781 unsigned char next_insn_msb = 0; 2782 unsigned char next_insn_lsb = 0; 2783 2784 if (irel->r_offset + 3 < sec->size) 2785 { 2786 next_insn_msb = 2787 bfd_get_8 (abfd, contents + irel->r_offset + 3); 2788 next_insn_lsb = 2789 bfd_get_8 (abfd, contents + irel->r_offset + 2); 2790 } 2791 2792 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) 2793 { 2794 /* The next insn is a ret. We now convert the rcall insn 2795 into a rjmp instruction. */ 2796 code_msb &= 0xef; 2797 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1); 2798 if (debug_relax) 2799 printf ("converted rcall/ret sequence at address 0x%x" 2800 " into rjmp/ret sequence. Section is %s\n\n", 2801 (int) dot, sec->name); 2802 *again = true; 2803 break; 2804 } 2805 } 2806 else if ((0x94 == (code_msb & 0xfe)) 2807 && (0x0e == (code_lsb & 0x0e)) 2808 && avr_replace_call_ret_sequences) 2809 { 2810 /* This insn is a call. */ 2811 unsigned char next_insn_msb = 0; 2812 unsigned char next_insn_lsb = 0; 2813 2814 if (irel->r_offset + 5 < sec->size) 2815 { 2816 next_insn_msb = 2817 bfd_get_8 (abfd, contents + irel->r_offset + 5); 2818 next_insn_lsb = 2819 bfd_get_8 (abfd, contents + irel->r_offset + 4); 2820 } 2821 2822 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) 2823 { 2824 /* The next insn is a ret. We now convert the call insn 2825 into a jmp instruction. */ 2826 2827 code_lsb &= 0xfd; 2828 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset); 2829 if (debug_relax) 2830 printf ("converted call/ret sequence at address 0x%x" 2831 " into jmp/ret sequence. Section is %s\n\n", 2832 (int) dot, sec->name); 2833 *again = true; 2834 break; 2835 } 2836 } 2837 else if ((0xc0 == (code_msb & 0xf0)) 2838 || ((0x94 == (code_msb & 0xfe)) 2839 && (0x0c == (code_lsb & 0x0e)))) 2840 { 2841 /* This insn is a rjmp or a jmp. */ 2842 unsigned char next_insn_msb = 0; 2843 unsigned char next_insn_lsb = 0; 2844 int insn_size; 2845 2846 if (0xc0 == (code_msb & 0xf0)) 2847 insn_size = 2; /* rjmp insn */ 2848 else 2849 insn_size = 4; /* jmp insn */ 2850 2851 if (irel->r_offset + insn_size + 1 < sec->size) 2852 { 2853 next_insn_msb = 2854 bfd_get_8 (abfd, contents + irel->r_offset 2855 + insn_size + 1); 2856 next_insn_lsb = 2857 bfd_get_8 (abfd, contents + irel->r_offset 2858 + insn_size); 2859 } 2860 2861 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb)) 2862 { 2863 /* The next insn is a ret. We possibly could delete 2864 this ret. First we need to check for preceding 2865 sbis/sbic/sbrs or cpse "skip" instructions. */ 2866 2867 int there_is_preceding_non_skip_insn = 1; 2868 bfd_vma address_of_ret; 2869 2870 address_of_ret = dot + insn_size; 2871 2872 if (debug_relax && (insn_size == 2)) 2873 printf ("found rjmp / ret sequence at address 0x%x\n", 2874 (int) dot); 2875 if (debug_relax && (insn_size == 4)) 2876 printf ("found jmp / ret sequence at address 0x%x\n", 2877 (int) dot); 2878 2879 /* We have to make sure that there is a preceding insn. */ 2880 if (irel->r_offset >= 2) 2881 { 2882 unsigned char preceding_msb; 2883 unsigned char preceding_lsb; 2884 2885 preceding_msb = 2886 bfd_get_8 (abfd, contents + irel->r_offset - 1); 2887 preceding_lsb = 2888 bfd_get_8 (abfd, contents + irel->r_offset - 2); 2889 2890 /* sbic. */ 2891 if (0x99 == preceding_msb) 2892 there_is_preceding_non_skip_insn = 0; 2893 2894 /* sbis. */ 2895 if (0x9b == preceding_msb) 2896 there_is_preceding_non_skip_insn = 0; 2897 2898 /* sbrc */ 2899 if ((0xfc == (preceding_msb & 0xfe) 2900 && (0x00 == (preceding_lsb & 0x08)))) 2901 there_is_preceding_non_skip_insn = 0; 2902 2903 /* sbrs */ 2904 if ((0xfe == (preceding_msb & 0xfe) 2905 && (0x00 == (preceding_lsb & 0x08)))) 2906 there_is_preceding_non_skip_insn = 0; 2907 2908 /* cpse */ 2909 if (0x10 == (preceding_msb & 0xfc)) 2910 there_is_preceding_non_skip_insn = 0; 2911 2912 if (there_is_preceding_non_skip_insn == 0) 2913 if (debug_relax) 2914 printf ("preceding skip insn prevents deletion of" 2915 " ret insn at Addy 0x%x in section %s\n", 2916 (int) dot + 2, sec->name); 2917 } 2918 else 2919 { 2920 /* There is no previous instruction. */ 2921 there_is_preceding_non_skip_insn = 0; 2922 } 2923 2924 if (there_is_preceding_non_skip_insn) 2925 { 2926 /* We now only have to make sure that there is no 2927 local label defined at the address of the ret 2928 instruction and that there is no local relocation 2929 in this section pointing to the ret. */ 2930 2931 int deleting_ret_is_safe = 1; 2932 unsigned int section_offset_of_ret_insn = 2933 irel->r_offset + insn_size; 2934 Elf_Internal_Sym *isym, *isymend; 2935 unsigned int sec_shndx; 2936 struct bfd_section *isec; 2937 2938 sec_shndx = 2939 _bfd_elf_section_from_bfd_section (abfd, sec); 2940 2941 /* Check for local symbols. */ 2942 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 2943 isymend = isym + symtab_hdr->sh_info; 2944 /* PR 6019: There may not be any local symbols. */ 2945 for (; isym != NULL && isym < isymend; isym++) 2946 { 2947 if (isym->st_value == section_offset_of_ret_insn 2948 && isym->st_shndx == sec_shndx) 2949 { 2950 deleting_ret_is_safe = 0; 2951 if (debug_relax) 2952 printf ("local label prevents deletion of ret " 2953 "insn at address 0x%x\n", 2954 (int) dot + insn_size); 2955 } 2956 } 2957 2958 /* Now check for global symbols. */ 2959 { 2960 int symcount; 2961 struct elf_link_hash_entry **sym_hashes; 2962 struct elf_link_hash_entry **end_hashes; 2963 2964 symcount = (symtab_hdr->sh_size 2965 / sizeof (Elf32_External_Sym) 2966 - symtab_hdr->sh_info); 2967 sym_hashes = elf_sym_hashes (abfd); 2968 end_hashes = sym_hashes + symcount; 2969 for (; sym_hashes < end_hashes; sym_hashes++) 2970 { 2971 struct elf_link_hash_entry *sym_hash = 2972 *sym_hashes; 2973 if ((sym_hash->root.type == bfd_link_hash_defined 2974 || sym_hash->root.type == 2975 bfd_link_hash_defweak) 2976 && sym_hash->root.u.def.section == sec 2977 && sym_hash->root.u.def.value == section_offset_of_ret_insn) 2978 { 2979 deleting_ret_is_safe = 0; 2980 if (debug_relax) 2981 printf ("global label prevents deletion of " 2982 "ret insn at address 0x%x\n", 2983 (int) dot + insn_size); 2984 } 2985 } 2986 } 2987 2988 /* Now we check for relocations pointing to ret. */ 2989 for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next) 2990 { 2991 Elf_Internal_Rela *rel; 2992 Elf_Internal_Rela *relend; 2993 2994 rel = elf_section_data (isec)->relocs; 2995 if (rel == NULL) 2996 rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, true); 2997 2998 relend = rel + isec->reloc_count; 2999 3000 for (; rel && rel < relend; rel++) 3001 { 3002 bfd_vma reloc_target = 0; 3003 3004 /* Read this BFD's local symbols if we haven't 3005 done so already. */ 3006 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 3007 { 3008 isymbuf = (Elf_Internal_Sym *) 3009 symtab_hdr->contents; 3010 if (isymbuf == NULL) 3011 isymbuf = bfd_elf_get_elf_syms 3012 (abfd, 3013 symtab_hdr, 3014 symtab_hdr->sh_info, 0, 3015 NULL, NULL, NULL); 3016 if (isymbuf == NULL) 3017 break; 3018 } 3019 3020 /* Get the value of the symbol referred to 3021 by the reloc. */ 3022 if (ELF32_R_SYM (rel->r_info) 3023 < symtab_hdr->sh_info) 3024 { 3025 /* A local symbol. */ 3026 asection *sym_sec; 3027 3028 isym = isymbuf 3029 + ELF32_R_SYM (rel->r_info); 3030 sym_sec = bfd_section_from_elf_index 3031 (abfd, isym->st_shndx); 3032 symval = isym->st_value; 3033 3034 /* If the reloc is absolute, it will not 3035 have a symbol or section associated 3036 with it. */ 3037 3038 if (sym_sec) 3039 { 3040 symval += 3041 sym_sec->output_section->vma 3042 + sym_sec->output_offset; 3043 reloc_target = symval + rel->r_addend; 3044 } 3045 else 3046 { 3047 reloc_target = symval + rel->r_addend; 3048 /* Reference symbol is absolute. */ 3049 } 3050 } 3051 /* else ... reference symbol is extern. */ 3052 3053 if (address_of_ret == reloc_target) 3054 { 3055 deleting_ret_is_safe = 0; 3056 if (debug_relax) 3057 printf ("ret from " 3058 "rjmp/jmp ret sequence at address" 3059 " 0x%x could not be deleted. ret" 3060 " is target of a relocation.\n", 3061 (int) address_of_ret); 3062 break; 3063 } 3064 } 3065 } 3066 3067 if (deleting_ret_is_safe) 3068 { 3069 if (debug_relax) 3070 printf ("unreachable ret instruction " 3071 "at address 0x%x deleted.\n", 3072 (int) dot + insn_size); 3073 3074 elf_section_data (sec)->relocs = internal_relocs; 3075 elf_section_data (sec)->this_hdr.contents = contents; 3076 symtab_hdr->contents = (unsigned char *) isymbuf; 3077 3078 /* Delete two bytes of data. */ 3079 if (!elf32_avr_relax_delete_bytes (abfd, sec, 3080 irel->r_offset + insn_size, 2, 3081 true)) 3082 goto error_return; 3083 3084 /* That will change things, so, we should relax 3085 again. Note that this is not required, and it 3086 may be slow. */ 3087 *again = true; 3088 break; 3089 } 3090 } 3091 } 3092 } 3093 break; 3094 } 3095 } 3096 } 3097 3098 if (!*again) 3099 { 3100 /* Look through all the property records in this section to see if 3101 there's any alignment records that can be moved. */ 3102 struct avr_relax_info *relax_info; 3103 3104 relax_info = get_avr_relax_info (sec); 3105 if (relax_info->records.count > 0) 3106 { 3107 unsigned int i; 3108 3109 for (i = 0; i < relax_info->records.count; ++i) 3110 { 3111 switch (relax_info->records.items [i].type) 3112 { 3113 case RECORD_ORG: 3114 case RECORD_ORG_AND_FILL: 3115 break; 3116 case RECORD_ALIGN: 3117 case RECORD_ALIGN_AND_FILL: 3118 { 3119 struct avr_property_record *record; 3120 unsigned long bytes_to_align; 3121 int count = 0; 3122 3123 /* Look for alignment directives that have had enough 3124 bytes deleted before them, such that the directive 3125 can be moved backwards and still maintain the 3126 required alignment. */ 3127 record = &relax_info->records.items [i]; 3128 bytes_to_align 3129 = (unsigned long) (1 << record->data.align.bytes); 3130 while (record->data.align.preceding_deleted >= 3131 bytes_to_align) 3132 { 3133 record->data.align.preceding_deleted 3134 -= bytes_to_align; 3135 count += bytes_to_align; 3136 } 3137 3138 if (count > 0) 3139 { 3140 bfd_vma addr = record->offset; 3141 3142 /* We can delete COUNT bytes and this alignment 3143 directive will still be correctly aligned. 3144 First move the alignment directive, then delete 3145 the bytes. */ 3146 record->offset -= count; 3147 elf32_avr_relax_delete_bytes (abfd, sec, 3148 addr - count, 3149 count, false); 3150 *again = true; 3151 } 3152 } 3153 break; 3154 } 3155 } 3156 } 3157 } 3158 3159 if (contents != NULL 3160 && elf_section_data (sec)->this_hdr.contents != contents) 3161 { 3162 if (! link_info->keep_memory) 3163 free (contents); 3164 else 3165 { 3166 /* Cache the section contents for elf_link_input_bfd. */ 3167 elf_section_data (sec)->this_hdr.contents = contents; 3168 } 3169 } 3170 3171 if (elf_section_data (sec)->relocs != internal_relocs) 3172 free (internal_relocs); 3173 3174 return true; 3175 3176 error_return: 3177 if (symtab_hdr->contents != (unsigned char *) isymbuf) 3178 free (isymbuf); 3179 if (elf_section_data (sec)->this_hdr.contents != contents) 3180 free (contents); 3181 if (elf_section_data (sec)->relocs != internal_relocs) 3182 free (internal_relocs); 3183 3184 return false; 3185 } 3186 3187 /* This is a version of bfd_generic_get_relocated_section_contents 3188 which uses elf32_avr_relocate_section. 3189 3190 For avr it's essentially a cut and paste taken from the H8300 port. 3191 The author of the relaxation support patch for avr had absolutely no 3192 clue what is happening here but found out that this part of the code 3193 seems to be important. */ 3194 3195 static bfd_byte * 3196 elf32_avr_get_relocated_section_contents (bfd *output_bfd, 3197 struct bfd_link_info *link_info, 3198 struct bfd_link_order *link_order, 3199 bfd_byte *data, 3200 bool relocatable, 3201 asymbol **symbols) 3202 { 3203 Elf_Internal_Shdr *symtab_hdr; 3204 asection *input_section = link_order->u.indirect.section; 3205 bfd *input_bfd = input_section->owner; 3206 asection **sections = NULL; 3207 Elf_Internal_Rela *internal_relocs = NULL; 3208 Elf_Internal_Sym *isymbuf = NULL; 3209 3210 /* We only need to handle the case of relaxing, or of having a 3211 particular set of section contents, specially. */ 3212 if (relocatable 3213 || elf_section_data (input_section)->this_hdr.contents == NULL) 3214 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 3215 link_order, data, 3216 relocatable, 3217 symbols); 3218 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3219 3220 bfd_byte *orig_data = data; 3221 if (data == NULL) 3222 { 3223 data = bfd_malloc (input_section->size); 3224 if (data == NULL) 3225 return NULL; 3226 } 3227 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 3228 (size_t) input_section->size); 3229 3230 if ((input_section->flags & SEC_RELOC) != 0 3231 && input_section->reloc_count > 0) 3232 { 3233 asection **secpp; 3234 Elf_Internal_Sym *isym, *isymend; 3235 bfd_size_type amt; 3236 3237 internal_relocs = (_bfd_elf_link_read_relocs 3238 (input_bfd, input_section, NULL, NULL, false)); 3239 if (internal_relocs == NULL) 3240 goto error_return; 3241 3242 if (symtab_hdr->sh_info != 0) 3243 { 3244 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 3245 if (isymbuf == NULL) 3246 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 3247 symtab_hdr->sh_info, 0, 3248 NULL, NULL, NULL); 3249 if (isymbuf == NULL) 3250 goto error_return; 3251 } 3252 3253 amt = symtab_hdr->sh_info; 3254 amt *= sizeof (asection *); 3255 sections = bfd_malloc (amt); 3256 if (sections == NULL && amt != 0) 3257 goto error_return; 3258 3259 isymend = isymbuf + symtab_hdr->sh_info; 3260 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 3261 { 3262 asection *isec; 3263 3264 if (isym->st_shndx == SHN_UNDEF) 3265 isec = bfd_und_section_ptr; 3266 else if (isym->st_shndx == SHN_ABS) 3267 isec = bfd_abs_section_ptr; 3268 else if (isym->st_shndx == SHN_COMMON) 3269 isec = bfd_com_section_ptr; 3270 else 3271 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 3272 3273 *secpp = isec; 3274 } 3275 3276 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd, 3277 input_section, data, internal_relocs, 3278 isymbuf, sections)) 3279 goto error_return; 3280 3281 free (sections); 3282 if (symtab_hdr->contents != (unsigned char *) isymbuf) 3283 free (isymbuf); 3284 if (elf_section_data (input_section)->relocs != internal_relocs) 3285 free (internal_relocs); 3286 } 3287 3288 return data; 3289 3290 error_return: 3291 free (sections); 3292 if (symtab_hdr->contents != (unsigned char *) isymbuf) 3293 free (isymbuf); 3294 if (elf_section_data (input_section)->relocs != internal_relocs) 3295 free (internal_relocs); 3296 if (orig_data == NULL) 3297 free (data); 3298 return NULL; 3299 } 3300 3301 3302 /* Determines the hash entry name for a particular reloc. It consists of 3303 the identifier of the symbol section and the added reloc addend and 3304 symbol offset relative to the section the symbol is attached to. */ 3305 3306 static char * 3307 avr_stub_name (const asection *symbol_section, 3308 const bfd_vma symbol_offset, 3309 const Elf_Internal_Rela *rela) 3310 { 3311 char *stub_name; 3312 bfd_size_type len; 3313 3314 len = 8 + 1 + 8 + 1 + 1; 3315 stub_name = bfd_malloc (len); 3316 if (stub_name != NULL) 3317 sprintf (stub_name, "%08x+%08x", 3318 symbol_section->id & 0xffffffff, 3319 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset)); 3320 3321 return stub_name; 3322 } 3323 3324 3325 /* Add a new stub entry to the stub hash. Not all fields of the new 3326 stub entry are initialised. */ 3327 3328 static struct elf32_avr_stub_hash_entry * 3329 avr_add_stub (const char *stub_name, 3330 struct elf32_avr_link_hash_table *htab) 3331 { 3332 struct elf32_avr_stub_hash_entry *hsh; 3333 3334 /* Enter this entry into the linker stub hash table. */ 3335 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, true, false); 3336 3337 if (hsh == NULL) 3338 { 3339 /* xgettext:c-format */ 3340 _bfd_error_handler (_("cannot create stub entry %s"), stub_name); 3341 return NULL; 3342 } 3343 3344 hsh->stub_offset = 0; 3345 return hsh; 3346 } 3347 3348 /* We assume that there is already space allocated for the stub section 3349 contents and that before building the stubs the section size is 3350 initialized to 0. We assume that within the stub hash table entry, 3351 the absolute position of the jmp target has been written in the 3352 target_value field. We write here the offset of the generated jmp insn 3353 relative to the trampoline section start to the stub_offset entry in 3354 the stub hash table entry. */ 3355 3356 static bool 3357 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg) 3358 { 3359 struct elf32_avr_stub_hash_entry *hsh; 3360 struct bfd_link_info *info; 3361 struct elf32_avr_link_hash_table *htab; 3362 bfd *stub_bfd; 3363 bfd_byte *loc; 3364 bfd_vma target; 3365 bfd_vma starget; 3366 3367 /* Basic opcode */ 3368 bfd_vma jmp_insn = 0x0000940c; 3369 3370 /* Massage our args to the form they really have. */ 3371 hsh = avr_stub_hash_entry (bh); 3372 3373 if (!hsh->is_actually_needed) 3374 return true; 3375 3376 info = (struct bfd_link_info *) in_arg; 3377 3378 htab = avr_link_hash_table (info); 3379 if (htab == NULL) 3380 return false; 3381 3382 target = hsh->target_value; 3383 3384 /* Make a note of the offset within the stubs for this entry. */ 3385 hsh->stub_offset = htab->stub_sec->size; 3386 loc = htab->stub_sec->contents + hsh->stub_offset; 3387 3388 stub_bfd = htab->stub_sec->owner; 3389 3390 if (debug_stubs) 3391 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n", 3392 (unsigned int) target, 3393 (unsigned int) hsh->stub_offset); 3394 3395 /* We now have to add the information on the jump target to the bare 3396 opcode bits already set in jmp_insn. */ 3397 3398 /* Check for the alignment of the address. */ 3399 if (target & 1) 3400 return false; 3401 3402 starget = target >> 1; 3403 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16; 3404 bfd_put_16 (stub_bfd, jmp_insn, loc); 3405 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2); 3406 3407 htab->stub_sec->size += 4; 3408 3409 /* Now add the entries in the address mapping table if there is still 3410 space left. */ 3411 { 3412 unsigned int nr; 3413 3414 nr = htab->amt_entry_cnt + 1; 3415 if (nr <= htab->amt_max_entry_cnt) 3416 { 3417 htab->amt_entry_cnt = nr; 3418 3419 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset; 3420 htab->amt_destination_addr[nr - 1] = target; 3421 } 3422 } 3423 3424 return true; 3425 } 3426 3427 static bool 3428 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh, 3429 void *in_arg ATTRIBUTE_UNUSED) 3430 { 3431 struct elf32_avr_stub_hash_entry *hsh; 3432 3433 hsh = avr_stub_hash_entry (bh); 3434 hsh->is_actually_needed = false; 3435 3436 return true; 3437 } 3438 3439 static bool 3440 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg) 3441 { 3442 struct elf32_avr_stub_hash_entry *hsh; 3443 struct elf32_avr_link_hash_table *htab; 3444 int size; 3445 3446 /* Massage our args to the form they really have. */ 3447 hsh = avr_stub_hash_entry (bh); 3448 htab = in_arg; 3449 3450 if (hsh->is_actually_needed) 3451 size = 4; 3452 else 3453 size = 0; 3454 3455 htab->stub_sec->size += size; 3456 return true; 3457 } 3458 3459 void 3460 elf32_avr_setup_params (struct bfd_link_info *info, 3461 bfd *avr_stub_bfd, 3462 asection *avr_stub_section, 3463 bool no_stubs, 3464 bool deb_stubs, 3465 bool deb_relax, 3466 bfd_vma pc_wrap_around, 3467 bool call_ret_replacement) 3468 { 3469 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info); 3470 3471 if (htab == NULL) 3472 return; 3473 htab->stub_sec = avr_stub_section; 3474 htab->stub_bfd = avr_stub_bfd; 3475 htab->no_stubs = no_stubs; 3476 3477 debug_relax = deb_relax; 3478 debug_stubs = deb_stubs; 3479 avr_pc_wrap_around = pc_wrap_around; 3480 avr_replace_call_ret_sequences = call_ret_replacement; 3481 } 3482 3483 3484 /* Set up various things so that we can make a list of input sections 3485 for each output section included in the link. Returns -1 on error, 3486 0 when no stubs will be needed, and 1 on success. It also sets 3487 information on the stubs bfd and the stub section in the info 3488 struct. */ 3489 3490 int 3491 elf32_avr_setup_section_lists (bfd *output_bfd, 3492 struct bfd_link_info *info) 3493 { 3494 bfd *input_bfd; 3495 unsigned int bfd_count; 3496 unsigned int top_id, top_index; 3497 asection *section; 3498 asection **input_list, **list; 3499 size_t amt; 3500 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info); 3501 3502 if (htab == NULL || htab->no_stubs) 3503 return 0; 3504 3505 /* Count the number of input BFDs and find the top input section id. */ 3506 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0; 3507 input_bfd != NULL; 3508 input_bfd = input_bfd->link.next) 3509 { 3510 bfd_count += 1; 3511 for (section = input_bfd->sections; 3512 section != NULL; 3513 section = section->next) 3514 if (top_id < section->id) 3515 top_id = section->id; 3516 } 3517 3518 htab->bfd_count = bfd_count; 3519 3520 /* We can't use output_bfd->section_count here to find the top output 3521 section index as some sections may have been removed, and 3522 strip_excluded_output_sections doesn't renumber the indices. */ 3523 for (section = output_bfd->sections, top_index = 0; 3524 section != NULL; 3525 section = section->next) 3526 if (top_index < section->index) 3527 top_index = section->index; 3528 3529 htab->top_index = top_index; 3530 amt = sizeof (asection *) * (top_index + 1); 3531 input_list = bfd_malloc (amt); 3532 htab->input_list = input_list; 3533 if (input_list == NULL) 3534 return -1; 3535 3536 /* For sections we aren't interested in, mark their entries with a 3537 value we can check later. */ 3538 list = input_list + top_index; 3539 do 3540 *list = bfd_abs_section_ptr; 3541 while (list-- != input_list); 3542 3543 for (section = output_bfd->sections; 3544 section != NULL; 3545 section = section->next) 3546 if ((section->flags & SEC_CODE) != 0) 3547 input_list[section->index] = NULL; 3548 3549 return 1; 3550 } 3551 3552 3553 /* Read in all local syms for all input bfds, and create hash entries 3554 for export stubs if we are building a multi-subspace shared lib. 3555 Returns -1 on error, 0 otherwise. */ 3556 3557 static int 3558 get_local_syms (bfd *input_bfd, struct bfd_link_info *info) 3559 { 3560 unsigned int bfd_indx; 3561 Elf_Internal_Sym *local_syms, **all_local_syms; 3562 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info); 3563 size_t amt; 3564 3565 if (htab == NULL) 3566 return -1; 3567 3568 /* We want to read in symbol extension records only once. To do this 3569 we need to read in the local symbols in parallel and save them for 3570 later use; so hold pointers to the local symbols in an array. */ 3571 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count; 3572 all_local_syms = bfd_zmalloc (amt); 3573 htab->all_local_syms = all_local_syms; 3574 if (all_local_syms == NULL) 3575 return -1; 3576 3577 /* Walk over all the input BFDs, swapping in local symbols. 3578 If we are creating a shared library, create hash entries for the 3579 export stubs. */ 3580 for (bfd_indx = 0; 3581 input_bfd != NULL; 3582 input_bfd = input_bfd->link.next, bfd_indx++) 3583 { 3584 Elf_Internal_Shdr *symtab_hdr; 3585 3586 /* We'll need the symbol table in a second. */ 3587 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3588 if (symtab_hdr->sh_info == 0) 3589 continue; 3590 3591 /* We need an array of the local symbols attached to the input bfd. */ 3592 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents; 3593 if (local_syms == NULL) 3594 { 3595 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 3596 symtab_hdr->sh_info, 0, 3597 NULL, NULL, NULL); 3598 /* Cache them for elf_link_input_bfd. */ 3599 symtab_hdr->contents = (unsigned char *) local_syms; 3600 } 3601 if (local_syms == NULL) 3602 return -1; 3603 3604 all_local_syms[bfd_indx] = local_syms; 3605 } 3606 3607 return 0; 3608 } 3609 3610 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0 3611 3612 bool 3613 elf32_avr_size_stubs (bfd *output_bfd, 3614 struct bfd_link_info *info, 3615 bool is_prealloc_run) 3616 { 3617 struct elf32_avr_link_hash_table *htab; 3618 int stub_changed = 0; 3619 3620 htab = avr_link_hash_table (info); 3621 if (htab == NULL) 3622 return false; 3623 3624 /* At this point we initialize htab->vector_base 3625 To the start of the text output section. */ 3626 htab->vector_base = htab->stub_sec->output_section->vma; 3627 3628 if (get_local_syms (info->input_bfds, info)) 3629 { 3630 if (htab->all_local_syms) 3631 goto error_ret_free_local; 3632 return false; 3633 } 3634 3635 if (ADD_DUMMY_STUBS_FOR_DEBUGGING) 3636 { 3637 struct elf32_avr_stub_hash_entry *test; 3638 3639 test = avr_add_stub ("Hugo",htab); 3640 test->target_value = 0x123456; 3641 test->stub_offset = 13; 3642 3643 test = avr_add_stub ("Hugo2",htab); 3644 test->target_value = 0x84210; 3645 test->stub_offset = 14; 3646 } 3647 3648 while (1) 3649 { 3650 bfd *input_bfd; 3651 unsigned int bfd_indx; 3652 3653 /* We will have to re-generate the stub hash table each time anything 3654 in memory has changed. */ 3655 3656 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab); 3657 for (input_bfd = info->input_bfds, bfd_indx = 0; 3658 input_bfd != NULL; 3659 input_bfd = input_bfd->link.next, bfd_indx++) 3660 { 3661 Elf_Internal_Shdr *symtab_hdr; 3662 asection *section; 3663 Elf_Internal_Sym *local_syms; 3664 3665 /* We'll need the symbol table in a second. */ 3666 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3667 if (symtab_hdr->sh_info == 0) 3668 continue; 3669 3670 local_syms = htab->all_local_syms[bfd_indx]; 3671 3672 /* Walk over each section attached to the input bfd. */ 3673 for (section = input_bfd->sections; 3674 section != NULL; 3675 section = section->next) 3676 { 3677 Elf_Internal_Rela *internal_relocs, *irelaend, *irela; 3678 3679 /* If there aren't any relocs, then there's nothing more 3680 to do. */ 3681 if ((section->flags & SEC_RELOC) == 0 3682 || section->reloc_count == 0) 3683 continue; 3684 3685 /* If this section is a link-once section that will be 3686 discarded, then don't create any stubs. */ 3687 if (section->output_section == NULL 3688 || section->output_section->owner != output_bfd) 3689 continue; 3690 3691 /* Get the relocs. */ 3692 internal_relocs 3693 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL, 3694 info->keep_memory); 3695 if (internal_relocs == NULL) 3696 goto error_ret_free_local; 3697 3698 /* Now examine each relocation. */ 3699 irela = internal_relocs; 3700 irelaend = irela + section->reloc_count; 3701 for (; irela < irelaend; irela++) 3702 { 3703 unsigned int r_type, r_indx; 3704 struct elf32_avr_stub_hash_entry *hsh; 3705 asection *sym_sec; 3706 bfd_vma sym_value; 3707 bfd_vma destination; 3708 struct elf_link_hash_entry *hh; 3709 char *stub_name; 3710 3711 r_type = ELF32_R_TYPE (irela->r_info); 3712 r_indx = ELF32_R_SYM (irela->r_info); 3713 3714 /* Only look for 16 bit GS relocs. No other reloc will need a 3715 stub. */ 3716 if (!((r_type == R_AVR_16_PM) 3717 || (r_type == R_AVR_LO8_LDI_GS) 3718 || (r_type == R_AVR_HI8_LDI_GS))) 3719 continue; 3720 3721 /* Now determine the call target, its name, value, 3722 section. */ 3723 sym_sec = NULL; 3724 sym_value = 0; 3725 destination = 0; 3726 hh = NULL; 3727 if (r_indx < symtab_hdr->sh_info) 3728 { 3729 /* It's a local symbol. */ 3730 Elf_Internal_Sym *sym; 3731 Elf_Internal_Shdr *hdr; 3732 unsigned int shndx; 3733 3734 sym = local_syms + r_indx; 3735 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION) 3736 sym_value = sym->st_value; 3737 shndx = sym->st_shndx; 3738 if (shndx < elf_numsections (input_bfd)) 3739 { 3740 hdr = elf_elfsections (input_bfd)[shndx]; 3741 sym_sec = hdr->bfd_section; 3742 destination = (sym_value + irela->r_addend 3743 + sym_sec->output_offset 3744 + sym_sec->output_section->vma); 3745 } 3746 } 3747 else 3748 { 3749 /* It's an external symbol. */ 3750 int e_indx; 3751 3752 e_indx = r_indx - symtab_hdr->sh_info; 3753 hh = elf_sym_hashes (input_bfd)[e_indx]; 3754 3755 while (hh->root.type == bfd_link_hash_indirect 3756 || hh->root.type == bfd_link_hash_warning) 3757 hh = (struct elf_link_hash_entry *) 3758 (hh->root.u.i.link); 3759 3760 if (hh->root.type == bfd_link_hash_defined 3761 || hh->root.type == bfd_link_hash_defweak) 3762 { 3763 sym_sec = hh->root.u.def.section; 3764 sym_value = hh->root.u.def.value; 3765 if (sym_sec->output_section != NULL) 3766 destination = (sym_value + irela->r_addend 3767 + sym_sec->output_offset 3768 + sym_sec->output_section->vma); 3769 } 3770 else if (hh->root.type == bfd_link_hash_undefweak) 3771 { 3772 if (! bfd_link_pic (info)) 3773 continue; 3774 } 3775 else if (hh->root.type == bfd_link_hash_undefined) 3776 { 3777 if (! (info->unresolved_syms_in_objects == RM_IGNORE 3778 && (ELF_ST_VISIBILITY (hh->other) 3779 == STV_DEFAULT))) 3780 continue; 3781 } 3782 else 3783 { 3784 bfd_set_error (bfd_error_bad_value); 3785 3786 error_ret_free_internal: 3787 if (elf_section_data (section)->relocs == NULL) 3788 free (internal_relocs); 3789 goto error_ret_free_local; 3790 } 3791 } 3792 3793 if (! avr_stub_is_required_for_16_bit_reloc 3794 (destination - htab->vector_base)) 3795 { 3796 if (!is_prealloc_run) 3797 /* We are having a reloc that does't need a stub. */ 3798 continue; 3799 3800 /* We don't right now know if a stub will be needed. 3801 Let's rather be on the safe side. */ 3802 } 3803 3804 /* Get the name of this stub. */ 3805 stub_name = avr_stub_name (sym_sec, sym_value, irela); 3806 3807 if (!stub_name) 3808 goto error_ret_free_internal; 3809 3810 3811 hsh = avr_stub_hash_lookup (&htab->bstab, 3812 stub_name, 3813 false, false); 3814 if (hsh != NULL) 3815 { 3816 /* The proper stub has already been created. Mark it 3817 to be used and write the possibly changed destination 3818 value. */ 3819 hsh->is_actually_needed = true; 3820 hsh->target_value = destination; 3821 free (stub_name); 3822 continue; 3823 } 3824 3825 hsh = avr_add_stub (stub_name, htab); 3826 if (hsh == NULL) 3827 { 3828 free (stub_name); 3829 goto error_ret_free_internal; 3830 } 3831 3832 hsh->is_actually_needed = true; 3833 hsh->target_value = destination; 3834 3835 if (debug_stubs) 3836 printf ("Adding stub with destination 0x%x to the" 3837 " hash table.\n", (unsigned int) destination); 3838 if (debug_stubs) 3839 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run); 3840 3841 stub_changed = true; 3842 } 3843 3844 /* We're done with the internal relocs, free them. */ 3845 if (elf_section_data (section)->relocs == NULL) 3846 free (internal_relocs); 3847 } 3848 } 3849 3850 /* Re-Calculate the number of needed stubs. */ 3851 htab->stub_sec->size = 0; 3852 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab); 3853 3854 if (!stub_changed) 3855 break; 3856 3857 stub_changed = false; 3858 } 3859 3860 free (htab->all_local_syms); 3861 return true; 3862 3863 error_ret_free_local: 3864 free (htab->all_local_syms); 3865 return false; 3866 } 3867 3868 3869 /* Build all the stubs associated with the current output file. The 3870 stubs are kept in a hash table attached to the main linker hash 3871 table. We also set up the .plt entries for statically linked PIC 3872 functions here. This function is called via hppaelf_finish in the 3873 linker. */ 3874 3875 bool 3876 elf32_avr_build_stubs (struct bfd_link_info *info) 3877 { 3878 asection *stub_sec; 3879 struct bfd_hash_table *table; 3880 struct elf32_avr_link_hash_table *htab; 3881 bfd_size_type total_size = 0; 3882 3883 htab = avr_link_hash_table (info); 3884 if (htab == NULL) 3885 return false; 3886 3887 /* In case that there were several stub sections: */ 3888 for (stub_sec = htab->stub_bfd->sections; 3889 stub_sec != NULL; 3890 stub_sec = stub_sec->next) 3891 { 3892 bfd_size_type size; 3893 3894 /* Allocate memory to hold the linker stubs. */ 3895 size = stub_sec->size; 3896 total_size += size; 3897 3898 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size); 3899 if (stub_sec->contents == NULL && size != 0) 3900 return false; 3901 stub_sec->size = 0; 3902 } 3903 3904 /* Allocate memory for the adress mapping table. */ 3905 htab->amt_entry_cnt = 0; 3906 htab->amt_max_entry_cnt = total_size / 4; 3907 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma) 3908 * htab->amt_max_entry_cnt); 3909 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma) 3910 * htab->amt_max_entry_cnt ); 3911 3912 if (debug_stubs) 3913 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt); 3914 3915 /* Build the stubs as directed by the stub hash table. */ 3916 table = &htab->bstab; 3917 bfd_hash_traverse (table, avr_build_one_stub, info); 3918 3919 if (debug_stubs) 3920 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size); 3921 3922 return true; 3923 } 3924 3925 /* Callback used by QSORT to order relocations AP and BP. */ 3926 3927 static int 3928 internal_reloc_compare (const void *ap, const void *bp) 3929 { 3930 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap; 3931 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp; 3932 3933 if (a->r_offset != b->r_offset) 3934 return (a->r_offset - b->r_offset); 3935 3936 /* We don't need to sort on these criteria for correctness, 3937 but enforcing a more strict ordering prevents unstable qsort 3938 from behaving differently with different implementations. 3939 Without the code below we get correct but different results 3940 on Solaris 2.7 and 2.8. We would like to always produce the 3941 same results no matter the host. */ 3942 3943 if (a->r_info != b->r_info) 3944 return (a->r_info - b->r_info); 3945 3946 return (a->r_addend - b->r_addend); 3947 } 3948 3949 /* Return true if ADDRESS is within the vma range of SECTION from ABFD. */ 3950 3951 static bool 3952 avr_is_section_for_address (asection *section, bfd_vma address) 3953 { 3954 bfd_vma vma; 3955 bfd_size_type size; 3956 3957 vma = bfd_section_vma (section); 3958 if (address < vma) 3959 return false; 3960 3961 size = section->size; 3962 if (address >= vma + size) 3963 return false; 3964 3965 return true; 3966 } 3967 3968 /* Data structure used by AVR_FIND_SECTION_FOR_ADDRESS. */ 3969 3970 struct avr_find_section_data 3971 { 3972 /* The address we're looking for. */ 3973 bfd_vma address; 3974 3975 /* The section we've found. */ 3976 asection *section; 3977 }; 3978 3979 /* Helper function to locate the section holding a certain virtual memory 3980 address. This is called via bfd_map_over_sections. The DATA is an 3981 instance of STRUCT AVR_FIND_SECTION_DATA, the address field of which 3982 has been set to the address to search for, and the section field has 3983 been set to NULL. If SECTION from ABFD contains ADDRESS then the 3984 section field in DATA will be set to SECTION. As an optimisation, if 3985 the section field is already non-null then this function does not 3986 perform any checks, and just returns. */ 3987 3988 static void 3989 avr_find_section_for_address (bfd *abfd ATTRIBUTE_UNUSED, 3990 asection *section, void *data) 3991 { 3992 struct avr_find_section_data *fs_data 3993 = (struct avr_find_section_data *) data; 3994 3995 /* Return if already found. */ 3996 if (fs_data->section != NULL) 3997 return; 3998 3999 /* If this section isn't part of the addressable code content, skip it. */ 4000 if ((bfd_section_flags (section) & SEC_ALLOC) == 0 4001 && (bfd_section_flags (section) & SEC_CODE) == 0) 4002 return; 4003 4004 if (avr_is_section_for_address (section, fs_data->address)) 4005 fs_data->section = section; 4006 } 4007 4008 /* Load all of the property records from SEC, a section from ABFD. Return 4009 a STRUCT AVR_PROPERTY_RECORD_LIST containing all the records. The 4010 memory for the returned structure, and all of the records pointed too by 4011 the structure are allocated with a single call to malloc, so, only the 4012 pointer returned needs to be free'd. */ 4013 4014 static struct avr_property_record_list * 4015 avr_elf32_load_records_from_section (bfd *abfd, asection *sec) 4016 { 4017 bfd_byte *contents, *ptr; 4018 bfd_size_type size, mem_size; 4019 bfd_byte version, flags; 4020 uint16_t record_count, i; 4021 struct avr_property_record_list *r_list = NULL; 4022 Elf_Internal_Rela *internal_relocs = NULL, *rel, *rel_end; 4023 struct avr_find_section_data fs_data; 4024 4025 fs_data.section = NULL; 4026 4027 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 4028 goto load_failed; 4029 ptr = contents; 4030 4031 /* Load the relocations for the '.avr.prop' section if there are any, and 4032 sort them. */ 4033 internal_relocs = (_bfd_elf_link_read_relocs 4034 (abfd, sec, NULL, NULL, false)); 4035 if (internal_relocs) 4036 qsort (internal_relocs, sec->reloc_count, 4037 sizeof (Elf_Internal_Rela), internal_reloc_compare); 4038 4039 /* There is a header at the start of the property record section SEC, the 4040 format of this header is: 4041 uint8_t : version number 4042 uint8_t : flags 4043 uint16_t : record counter 4044 */ 4045 4046 /* Check we have at least got a headers worth of bytes. */ 4047 size = bfd_section_size (sec); 4048 if (size < AVR_PROPERTY_SECTION_HEADER_SIZE) 4049 goto load_failed; 4050 4051 version = *ptr; 4052 ptr++; 4053 flags = *ptr; 4054 ptr++; 4055 record_count = bfd_get_16 (abfd, ptr); 4056 ptr += 2; 4057 BFD_ASSERT (ptr - contents == AVR_PROPERTY_SECTION_HEADER_SIZE); 4058 4059 /* Now allocate space for the list structure, and all of the list 4060 elements in a single block. */ 4061 mem_size = sizeof (struct avr_property_record_list) 4062 + sizeof (struct avr_property_record) * record_count; 4063 r_list = bfd_malloc (mem_size); 4064 if (r_list == NULL) 4065 goto load_failed; 4066 4067 r_list->version = version; 4068 r_list->flags = flags; 4069 r_list->section = sec; 4070 r_list->record_count = record_count; 4071 r_list->records = (struct avr_property_record *) (&r_list [1]); 4072 size -= AVR_PROPERTY_SECTION_HEADER_SIZE; 4073 4074 /* Check that we understand the version number. There is only one 4075 version number right now, anything else is an error. */ 4076 if (r_list->version != AVR_PROPERTY_RECORDS_VERSION) 4077 goto load_failed; 4078 4079 rel = internal_relocs; 4080 rel_end = rel + sec->reloc_count; 4081 for (i = 0; i < record_count; ++i) 4082 { 4083 bfd_vma address; 4084 4085 /* Each entry is a 32-bit address, followed by a single byte type. 4086 After that is the type specific data. We must take care to 4087 ensure that we don't read beyond the end of the section data. */ 4088 if (size < 5) 4089 goto load_failed; 4090 4091 r_list->records [i].section = NULL; 4092 r_list->records [i].offset = 0; 4093 4094 if (rel) 4095 { 4096 /* The offset of the address within the .avr.prop section. */ 4097 size_t offset = ptr - contents; 4098 4099 while (rel < rel_end && rel->r_offset < offset) 4100 ++rel; 4101 4102 if (rel == rel_end) 4103 rel = NULL; 4104 else if (rel->r_offset == offset) 4105 { 4106 /* Find section and section offset. */ 4107 unsigned long r_symndx; 4108 4109 asection * rel_sec; 4110 bfd_vma sec_offset; 4111 4112 r_symndx = ELF32_R_SYM (rel->r_info); 4113 rel_sec = get_elf_r_symndx_section (abfd, r_symndx); 4114 sec_offset = get_elf_r_symndx_offset (abfd, r_symndx) 4115 + rel->r_addend; 4116 4117 r_list->records [i].section = rel_sec; 4118 r_list->records [i].offset = sec_offset; 4119 } 4120 } 4121 4122 address = bfd_get_32 (abfd, ptr); 4123 ptr += 4; 4124 size -= 4; 4125 4126 if (r_list->records [i].section == NULL) 4127 { 4128 /* Try to find section and offset from address. */ 4129 if (fs_data.section != NULL 4130 && !avr_is_section_for_address (fs_data.section, address)) 4131 fs_data.section = NULL; 4132 4133 if (fs_data.section == NULL) 4134 { 4135 fs_data.address = address; 4136 bfd_map_over_sections (abfd, avr_find_section_for_address, 4137 &fs_data); 4138 } 4139 4140 if (fs_data.section == NULL) 4141 { 4142 fprintf (stderr, "Failed to find matching section.\n"); 4143 goto load_failed; 4144 } 4145 4146 r_list->records [i].section = fs_data.section; 4147 r_list->records [i].offset 4148 = address - bfd_section_vma (fs_data.section); 4149 } 4150 4151 r_list->records [i].type = *ptr; 4152 ptr += 1; 4153 size -= 1; 4154 4155 switch (r_list->records [i].type) 4156 { 4157 case RECORD_ORG: 4158 /* Nothing else to load. */ 4159 break; 4160 case RECORD_ORG_AND_FILL: 4161 /* Just a 4-byte fill to load. */ 4162 if (size < 4) 4163 goto load_failed; 4164 r_list->records [i].data.org.fill = bfd_get_32 (abfd, ptr); 4165 ptr += 4; 4166 size -= 4; 4167 break; 4168 case RECORD_ALIGN: 4169 /* Just a 4-byte alignment to load. */ 4170 if (size < 4) 4171 goto load_failed; 4172 r_list->records [i].data.align.bytes = bfd_get_32 (abfd, ptr); 4173 ptr += 4; 4174 size -= 4; 4175 /* Just initialise PRECEDING_DELETED field, this field is 4176 used during linker relaxation. */ 4177 r_list->records [i].data.align.preceding_deleted = 0; 4178 break; 4179 case RECORD_ALIGN_AND_FILL: 4180 /* A 4-byte alignment, and a 4-byte fill to load. */ 4181 if (size < 8) 4182 goto load_failed; 4183 r_list->records [i].data.align.bytes = bfd_get_32 (abfd, ptr); 4184 ptr += 4; 4185 r_list->records [i].data.align.fill = bfd_get_32 (abfd, ptr); 4186 ptr += 4; 4187 size -= 8; 4188 /* Just initialise PRECEDING_DELETED field, this field is 4189 used during linker relaxation. */ 4190 r_list->records [i].data.align.preceding_deleted = 0; 4191 break; 4192 default: 4193 goto load_failed; 4194 } 4195 } 4196 4197 free (contents); 4198 if (elf_section_data (sec)->relocs != internal_relocs) 4199 free (internal_relocs); 4200 return r_list; 4201 4202 load_failed: 4203 if (elf_section_data (sec)->relocs != internal_relocs) 4204 free (internal_relocs); 4205 free (contents); 4206 free (r_list); 4207 return NULL; 4208 } 4209 4210 /* Load all of the property records from ABFD. See 4211 AVR_ELF32_LOAD_RECORDS_FROM_SECTION for details of the return value. */ 4212 4213 struct avr_property_record_list * 4214 avr_elf32_load_property_records (bfd *abfd) 4215 { 4216 asection *sec; 4217 4218 /* Find the '.avr.prop' section and load the contents into memory. */ 4219 sec = bfd_get_section_by_name (abfd, AVR_PROPERTY_RECORD_SECTION_NAME); 4220 if (sec == NULL || (sec->flags & SEC_HAS_CONTENTS) == 0) 4221 return NULL; 4222 return avr_elf32_load_records_from_section (abfd, sec); 4223 } 4224 4225 const char * 4226 avr_elf32_property_record_name (struct avr_property_record *rec) 4227 { 4228 const char *str; 4229 4230 switch (rec->type) 4231 { 4232 case RECORD_ORG: 4233 str = "ORG"; 4234 break; 4235 case RECORD_ORG_AND_FILL: 4236 str = "ORG+FILL"; 4237 break; 4238 case RECORD_ALIGN: 4239 str = "ALIGN"; 4240 break; 4241 case RECORD_ALIGN_AND_FILL: 4242 str = "ALIGN+FILL"; 4243 break; 4244 default: 4245 str = "unknown"; 4246 } 4247 4248 return str; 4249 } 4250 4251 4252 #define ELF_ARCH bfd_arch_avr 4253 #define ELF_TARGET_ID AVR_ELF_DATA 4254 #define ELF_MACHINE_CODE EM_AVR 4255 #define ELF_MACHINE_ALT1 EM_AVR_OLD 4256 #define ELF_MAXPAGESIZE 1 4257 4258 #define TARGET_LITTLE_SYM avr_elf32_vec 4259 #define TARGET_LITTLE_NAME "elf32-avr" 4260 4261 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create 4262 4263 #define elf_info_to_howto avr_info_to_howto_rela 4264 #define elf_info_to_howto_rel NULL 4265 #define elf_backend_relocate_section elf32_avr_relocate_section 4266 #define elf_backend_can_gc_sections 1 4267 #define elf_backend_rela_normal 1 4268 #define elf_backend_final_write_processing \ 4269 bfd_elf_avr_final_write_processing 4270 #define elf_backend_object_p elf32_avr_object_p 4271 4272 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section 4273 #define bfd_elf32_bfd_get_relocated_section_contents \ 4274 elf32_avr_get_relocated_section_contents 4275 #define bfd_elf32_new_section_hook elf_avr_new_section_hook 4276 #define elf_backend_special_sections elf_avr_special_sections 4277 4278 #include "elf32-target.h" 4279