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