1 /* BFD back-end for National Semiconductor's CR16 ELF 2 Copyright (C) 2007-2016 Free Software Foundation, Inc. 3 Written by M R Swami Reddy. 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 Foundation, 19 Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "bfdlink.h" 24 #include "libbfd.h" 25 #include "libiberty.h" 26 #include "elf-bfd.h" 27 #include "elf/cr16.h" 28 29 /* The cr16 linker needs to keep track of the number of relocs that 30 it decides to copy in check_relocs for each symbol. This is so 31 that it can discard PC relative relocs if it doesn't need them when 32 linking with -Bsymbolic. We store the information in a field 33 extending the regular ELF linker hash table. */ 34 35 struct elf32_cr16_link_hash_entry 36 { 37 /* The basic elf link hash table entry. */ 38 struct elf_link_hash_entry root; 39 40 /* For function symbols, the number of times this function is 41 called directly (ie by name). */ 42 unsigned int direct_calls; 43 44 /* For function symbols, the size of this function's stack 45 (if <= 255 bytes). We stuff this into "call" instructions 46 to this target when it's valid and profitable to do so. 47 48 This does not include stack allocated by movm! */ 49 unsigned char stack_size; 50 51 /* For function symbols, arguments (if any) for movm instruction 52 in the prologue. We stuff this value into "call" instructions 53 to the target when it's valid and profitable to do so. */ 54 unsigned char movm_args; 55 56 /* For function symbols, the amount of stack space that would be allocated 57 by the movm instruction. This is redundant with movm_args, but we 58 add it to the hash table to avoid computing it over and over. */ 59 unsigned char movm_stack_size; 60 61 /* Used to mark functions which have had redundant parts of their 62 prologue deleted. */ 63 #define CR16_DELETED_PROLOGUE_BYTES 0x1 64 unsigned char flags; 65 66 /* Calculated value. */ 67 bfd_vma value; 68 }; 69 70 /* cr16_reloc_map array maps BFD relocation enum into a CRGAS relocation type. */ 71 72 struct cr16_reloc_map 73 { 74 bfd_reloc_code_real_type bfd_reloc_enum; /* BFD relocation enum. */ 75 unsigned short cr16_reloc_type; /* CR16 relocation type. */ 76 }; 77 78 static const struct cr16_reloc_map cr16_reloc_map[R_CR16_MAX] = 79 { 80 {BFD_RELOC_NONE, R_CR16_NONE}, 81 {BFD_RELOC_CR16_NUM8, R_CR16_NUM8}, 82 {BFD_RELOC_CR16_NUM16, R_CR16_NUM16}, 83 {BFD_RELOC_CR16_NUM32, R_CR16_NUM32}, 84 {BFD_RELOC_CR16_NUM32a, R_CR16_NUM32a}, 85 {BFD_RELOC_CR16_REGREL4, R_CR16_REGREL4}, 86 {BFD_RELOC_CR16_REGREL4a, R_CR16_REGREL4a}, 87 {BFD_RELOC_CR16_REGREL14, R_CR16_REGREL14}, 88 {BFD_RELOC_CR16_REGREL14a, R_CR16_REGREL14a}, 89 {BFD_RELOC_CR16_REGREL16, R_CR16_REGREL16}, 90 {BFD_RELOC_CR16_REGREL20, R_CR16_REGREL20}, 91 {BFD_RELOC_CR16_REGREL20a, R_CR16_REGREL20a}, 92 {BFD_RELOC_CR16_ABS20, R_CR16_ABS20}, 93 {BFD_RELOC_CR16_ABS24, R_CR16_ABS24}, 94 {BFD_RELOC_CR16_IMM4, R_CR16_IMM4}, 95 {BFD_RELOC_CR16_IMM8, R_CR16_IMM8}, 96 {BFD_RELOC_CR16_IMM16, R_CR16_IMM16}, 97 {BFD_RELOC_CR16_IMM20, R_CR16_IMM20}, 98 {BFD_RELOC_CR16_IMM24, R_CR16_IMM24}, 99 {BFD_RELOC_CR16_IMM32, R_CR16_IMM32}, 100 {BFD_RELOC_CR16_IMM32a, R_CR16_IMM32a}, 101 {BFD_RELOC_CR16_DISP4, R_CR16_DISP4}, 102 {BFD_RELOC_CR16_DISP8, R_CR16_DISP8}, 103 {BFD_RELOC_CR16_DISP16, R_CR16_DISP16}, 104 {BFD_RELOC_CR16_DISP24, R_CR16_DISP24}, 105 {BFD_RELOC_CR16_DISP24a, R_CR16_DISP24a}, 106 {BFD_RELOC_CR16_SWITCH8, R_CR16_SWITCH8}, 107 {BFD_RELOC_CR16_SWITCH16, R_CR16_SWITCH16}, 108 {BFD_RELOC_CR16_SWITCH32, R_CR16_SWITCH32}, 109 {BFD_RELOC_CR16_GOT_REGREL20, R_CR16_GOT_REGREL20}, 110 {BFD_RELOC_CR16_GOTC_REGREL20, R_CR16_GOTC_REGREL20}, 111 {BFD_RELOC_CR16_GLOB_DAT, R_CR16_GLOB_DAT} 112 }; 113 114 static reloc_howto_type cr16_elf_howto_table[] = 115 { 116 HOWTO (R_CR16_NONE, /* type */ 117 0, /* rightshift */ 118 3, /* size */ 119 0, /* bitsize */ 120 FALSE, /* pc_relative */ 121 0, /* bitpos */ 122 complain_overflow_dont, /* complain_on_overflow */ 123 bfd_elf_generic_reloc, /* special_function */ 124 "R_CR16_NONE", /* name */ 125 FALSE, /* partial_inplace */ 126 0, /* src_mask */ 127 0, /* dst_mask */ 128 FALSE), /* pcrel_offset */ 129 130 HOWTO (R_CR16_NUM8, /* type */ 131 0, /* rightshift */ 132 0, /* size */ 133 8, /* bitsize */ 134 FALSE, /* pc_relative */ 135 0, /* bitpos */ 136 complain_overflow_bitfield,/* complain_on_overflow */ 137 bfd_elf_generic_reloc, /* special_function */ 138 "R_CR16_NUM8", /* name */ 139 FALSE, /* partial_inplace */ 140 0x0, /* src_mask */ 141 0xff, /* dst_mask */ 142 FALSE), /* pcrel_offset */ 143 144 HOWTO (R_CR16_NUM16, /* type */ 145 0, /* rightshift */ 146 1, /* size */ 147 16, /* bitsize */ 148 FALSE, /* pc_relative */ 149 0, /* bitpos */ 150 complain_overflow_bitfield,/* complain_on_overflow */ 151 bfd_elf_generic_reloc, /* special_function */ 152 "R_CR16_NUM16", /* name */ 153 FALSE, /* partial_inplace */ 154 0x0, /* src_mask */ 155 0xffff, /* dst_mask */ 156 FALSE), /* pcrel_offset */ 157 158 HOWTO (R_CR16_NUM32, /* type */ 159 0, /* rightshift */ 160 2, /* size */ 161 32, /* bitsize */ 162 FALSE, /* pc_relative */ 163 0, /* bitpos */ 164 complain_overflow_bitfield,/* complain_on_overflow */ 165 bfd_elf_generic_reloc, /* special_function */ 166 "R_CR16_NUM32", /* name */ 167 FALSE, /* partial_inplace */ 168 0x0, /* src_mask */ 169 0xffffffff, /* dst_mask */ 170 FALSE), /* pcrel_offset */ 171 172 HOWTO (R_CR16_NUM32a, /* type */ 173 1, /* rightshift */ 174 2, /* size */ 175 32, /* bitsize */ 176 FALSE, /* pc_relative */ 177 0, /* bitpos */ 178 complain_overflow_bitfield,/* complain_on_overflow */ 179 bfd_elf_generic_reloc, /* special_function */ 180 "R_CR16_NUM32a", /* name */ 181 FALSE, /* partial_inplace */ 182 0x0, /* src_mask */ 183 0xffffffff, /* dst_mask */ 184 FALSE), /* pcrel_offset */ 185 186 HOWTO (R_CR16_REGREL4, /* type */ 187 0, /* rightshift */ 188 0, /* size */ 189 4, /* bitsize */ 190 FALSE, /* pc_relative */ 191 0, /* bitpos */ 192 complain_overflow_bitfield,/* complain_on_overflow */ 193 bfd_elf_generic_reloc, /* special_function */ 194 "R_CR16_REGREL4", /* name */ 195 FALSE, /* partial_inplace */ 196 0x0, /* src_mask */ 197 0xf, /* dst_mask */ 198 FALSE), /* pcrel_offset */ 199 200 HOWTO (R_CR16_REGREL4a, /* type */ 201 0, /* rightshift */ 202 0, /* size */ 203 4, /* bitsize */ 204 FALSE, /* pc_relative */ 205 0, /* bitpos */ 206 complain_overflow_bitfield,/* complain_on_overflow */ 207 bfd_elf_generic_reloc, /* special_function */ 208 "R_CR16_REGREL4a", /* name */ 209 FALSE, /* partial_inplace */ 210 0x0, /* src_mask */ 211 0xf, /* dst_mask */ 212 FALSE), /* pcrel_offset */ 213 214 HOWTO (R_CR16_REGREL14, /* type */ 215 0, /* rightshift */ 216 1, /* size */ 217 14, /* bitsize */ 218 FALSE, /* pc_relative */ 219 0, /* bitpos */ 220 complain_overflow_bitfield,/* complain_on_overflow */ 221 bfd_elf_generic_reloc, /* special_function */ 222 "R_CR16_REGREL14", /* name */ 223 FALSE, /* partial_inplace */ 224 0x0, /* src_mask */ 225 0x3fff, /* dst_mask */ 226 FALSE), /* pcrel_offset */ 227 228 HOWTO (R_CR16_REGREL14a, /* type */ 229 0, /* rightshift */ 230 1, /* size */ 231 14, /* bitsize */ 232 FALSE, /* pc_relative */ 233 0, /* bitpos */ 234 complain_overflow_bitfield,/* complain_on_overflow */ 235 bfd_elf_generic_reloc, /* special_function */ 236 "R_CR16_REGREL14a", /* name */ 237 FALSE, /* partial_inplace */ 238 0x0, /* src_mask */ 239 0x3fff, /* dst_mask */ 240 FALSE), /* pcrel_offset */ 241 242 HOWTO (R_CR16_REGREL16, /* type */ 243 0, /* rightshift */ 244 1, /* size */ 245 16, /* bitsize */ 246 FALSE, /* pc_relative */ 247 0, /* bitpos */ 248 complain_overflow_bitfield,/* complain_on_overflow */ 249 bfd_elf_generic_reloc, /* special_function */ 250 "R_CR16_REGREL16", /* name */ 251 FALSE, /* partial_inplace */ 252 0x0, /* src_mask */ 253 0xffff, /* dst_mask */ 254 FALSE), /* pcrel_offset */ 255 256 HOWTO (R_CR16_REGREL20, /* type */ 257 0, /* rightshift */ 258 2, /* size */ 259 20, /* bitsize */ 260 FALSE, /* pc_relative */ 261 0, /* bitpos */ 262 complain_overflow_bitfield,/* complain_on_overflow */ 263 bfd_elf_generic_reloc, /* special_function */ 264 "R_CR16_REGREL20", /* name */ 265 FALSE, /* partial_inplace */ 266 0x0, /* src_mask */ 267 0xfffff, /* dst_mask */ 268 FALSE), /* pcrel_offset */ 269 270 HOWTO (R_CR16_REGREL20a, /* type */ 271 0, /* rightshift */ 272 2, /* size */ 273 20, /* bitsize */ 274 FALSE, /* pc_relative */ 275 0, /* bitpos */ 276 complain_overflow_bitfield,/* complain_on_overflow */ 277 bfd_elf_generic_reloc, /* special_function */ 278 "R_CR16_REGREL20a", /* name */ 279 FALSE, /* partial_inplace */ 280 0x0, /* src_mask */ 281 0xfffff, /* dst_mask */ 282 FALSE), /* pcrel_offset */ 283 284 HOWTO (R_CR16_ABS20, /* type */ 285 0, /* rightshift */ 286 2, /* size */ 287 20, /* bitsize */ 288 FALSE, /* pc_relative */ 289 0, /* bitpos */ 290 complain_overflow_bitfield,/* complain_on_overflow */ 291 bfd_elf_generic_reloc, /* special_function */ 292 "R_CR16_ABS20", /* name */ 293 FALSE, /* partial_inplace */ 294 0x0, /* src_mask */ 295 0xfffff, /* dst_mask */ 296 FALSE), /* pcrel_offset */ 297 298 HOWTO (R_CR16_ABS24, /* type */ 299 0, /* rightshift */ 300 2, /* size */ 301 24, /* bitsize */ 302 FALSE, /* pc_relative */ 303 0, /* bitpos */ 304 complain_overflow_bitfield,/* complain_on_overflow */ 305 bfd_elf_generic_reloc, /* special_function */ 306 "R_CR16_ABS24", /* name */ 307 FALSE, /* partial_inplace */ 308 0x0, /* src_mask */ 309 0xffffff, /* dst_mask */ 310 FALSE), /* pcrel_offset */ 311 312 HOWTO (R_CR16_IMM4, /* type */ 313 0, /* rightshift */ 314 0, /* size */ 315 4, /* bitsize */ 316 FALSE, /* pc_relative */ 317 0, /* bitpos */ 318 complain_overflow_bitfield,/* complain_on_overflow */ 319 bfd_elf_generic_reloc, /* special_function */ 320 "R_CR16_IMM4", /* name */ 321 FALSE, /* partial_inplace */ 322 0x0, /* src_mask */ 323 0xf, /* dst_mask */ 324 FALSE), /* pcrel_offset */ 325 326 HOWTO (R_CR16_IMM8, /* type */ 327 0, /* rightshift */ 328 0, /* size */ 329 8, /* bitsize */ 330 FALSE, /* pc_relative */ 331 0, /* bitpos */ 332 complain_overflow_bitfield,/* complain_on_overflow */ 333 bfd_elf_generic_reloc, /* special_function */ 334 "R_CR16_IMM8", /* name */ 335 FALSE, /* partial_inplace */ 336 0x0, /* src_mask */ 337 0xff, /* dst_mask */ 338 FALSE), /* pcrel_offset */ 339 340 HOWTO (R_CR16_IMM16, /* type */ 341 0, /* rightshift */ 342 1, /* size */ 343 16, /* bitsize */ 344 FALSE, /* pc_relative */ 345 0, /* bitpos */ 346 complain_overflow_bitfield,/* complain_on_overflow */ 347 bfd_elf_generic_reloc, /* special_function */ 348 "R_CR16_IMM16", /* name */ 349 FALSE, /* partial_inplace */ 350 0x0, /* src_mask */ 351 0xffff, /* dst_mask */ 352 FALSE), /* pcrel_offset */ 353 354 HOWTO (R_CR16_IMM20, /* type */ 355 0, /* rightshift */ 356 2, /* size */ 357 20, /* bitsize */ 358 FALSE, /* pc_relative */ 359 0, /* bitpos */ 360 complain_overflow_bitfield,/* complain_on_overflow */ 361 bfd_elf_generic_reloc, /* special_function */ 362 "R_CR16_IMM20", /* name */ 363 FALSE, /* partial_inplace */ 364 0x0, /* src_mask */ 365 0xfffff, /* dst_mask */ 366 FALSE), /* pcrel_offset */ 367 368 HOWTO (R_CR16_IMM24, /* type */ 369 0, /* rightshift */ 370 2, /* size */ 371 24, /* bitsize */ 372 FALSE, /* pc_relative */ 373 0, /* bitpos */ 374 complain_overflow_bitfield,/* complain_on_overflow */ 375 bfd_elf_generic_reloc, /* special_function */ 376 "R_CR16_IMM24", /* name */ 377 FALSE, /* partial_inplace */ 378 0x0, /* src_mask */ 379 0xffffff, /* dst_mask */ 380 FALSE), /* pcrel_offset */ 381 382 HOWTO (R_CR16_IMM32, /* type */ 383 0, /* rightshift */ 384 2, /* size */ 385 32, /* bitsize */ 386 FALSE, /* pc_relative */ 387 0, /* bitpos */ 388 complain_overflow_bitfield,/* complain_on_overflow */ 389 bfd_elf_generic_reloc, /* special_function */ 390 "R_CR16_IMM32", /* name */ 391 FALSE, /* partial_inplace */ 392 0x0, /* src_mask */ 393 0xffffffff, /* dst_mask */ 394 FALSE), /* pcrel_offset */ 395 396 HOWTO (R_CR16_IMM32a, /* type */ 397 1, /* rightshift */ 398 2, /* size */ 399 32, /* bitsize */ 400 FALSE, /* pc_relative */ 401 0, /* bitpos */ 402 complain_overflow_bitfield,/* complain_on_overflow */ 403 bfd_elf_generic_reloc, /* special_function */ 404 "R_CR16_IMM32a", /* name */ 405 FALSE, /* partial_inplace */ 406 0x0, /* src_mask */ 407 0xffffffff, /* dst_mask */ 408 FALSE), /* pcrel_offset */ 409 410 HOWTO (R_CR16_DISP4, /* type */ 411 1, /* rightshift */ 412 0, /* size (0 = byte, 1 = short, 2 = long) */ 413 4, /* bitsize */ 414 TRUE, /* pc_relative */ 415 0, /* bitpos */ 416 complain_overflow_unsigned, /* complain_on_overflow */ 417 bfd_elf_generic_reloc, /* special_function */ 418 "R_CR16_DISP4", /* name */ 419 FALSE, /* partial_inplace */ 420 0x0, /* src_mask */ 421 0xf, /* dst_mask */ 422 FALSE), /* pcrel_offset */ 423 424 HOWTO (R_CR16_DISP8, /* type */ 425 1, /* rightshift */ 426 0, /* size (0 = byte, 1 = short, 2 = long) */ 427 8, /* bitsize */ 428 TRUE, /* pc_relative */ 429 0, /* bitpos */ 430 complain_overflow_unsigned, /* complain_on_overflow */ 431 bfd_elf_generic_reloc, /* special_function */ 432 "R_CR16_DISP8", /* name */ 433 FALSE, /* partial_inplace */ 434 0x0, /* src_mask */ 435 0x1ff, /* dst_mask */ 436 FALSE), /* pcrel_offset */ 437 438 HOWTO (R_CR16_DISP16, /* type */ 439 0, /* rightshift REVIITS: To sync with WinIDEA*/ 440 1, /* size (0 = byte, 1 = short, 2 = long) */ 441 16, /* bitsize */ 442 TRUE, /* pc_relative */ 443 0, /* bitpos */ 444 complain_overflow_unsigned, /* complain_on_overflow */ 445 bfd_elf_generic_reloc, /* special_function */ 446 "R_CR16_DISP16", /* name */ 447 FALSE, /* partial_inplace */ 448 0x0, /* src_mask */ 449 0x1ffff, /* dst_mask */ 450 FALSE), /* pcrel_offset */ 451 /* REVISIT: DISP24 should be left-shift by 2 as per ISA doc 452 but its not done, to sync with WinIDEA and CR16 4.1 tools */ 453 HOWTO (R_CR16_DISP24, /* type */ 454 0, /* rightshift */ 455 2, /* size (0 = byte, 1 = short, 2 = long) */ 456 24, /* bitsize */ 457 TRUE, /* pc_relative */ 458 0, /* bitpos */ 459 complain_overflow_unsigned, /* complain_on_overflow */ 460 bfd_elf_generic_reloc, /* special_function */ 461 "R_CR16_DISP24", /* name */ 462 FALSE, /* partial_inplace */ 463 0x0, /* src_mask */ 464 0x1ffffff, /* dst_mask */ 465 FALSE), /* pcrel_offset */ 466 467 HOWTO (R_CR16_DISP24a, /* type */ 468 0, /* rightshift */ 469 2, /* size (0 = byte, 1 = short, 2 = long) */ 470 24, /* bitsize */ 471 TRUE, /* pc_relative */ 472 0, /* bitpos */ 473 complain_overflow_unsigned, /* complain_on_overflow */ 474 bfd_elf_generic_reloc, /* special_function */ 475 "R_CR16_DISP24a", /* name */ 476 FALSE, /* partial_inplace */ 477 0x0, /* src_mask */ 478 0xffffff, /* dst_mask */ 479 FALSE), /* pcrel_offset */ 480 481 /* An 8 bit switch table entry. This is generated for an expression 482 such as ``.byte L1 - L2''. The offset holds the difference 483 between the reloc address and L2. */ 484 HOWTO (R_CR16_SWITCH8, /* type */ 485 0, /* rightshift */ 486 0, /* size (0 = byte, 1 = short, 2 = long) */ 487 8, /* bitsize */ 488 FALSE, /* pc_relative */ 489 0, /* bitpos */ 490 complain_overflow_unsigned, /* complain_on_overflow */ 491 bfd_elf_generic_reloc, /* special_function */ 492 "R_CR16_SWITCH8", /* name */ 493 FALSE, /* partial_inplace */ 494 0x0, /* src_mask */ 495 0xff, /* dst_mask */ 496 TRUE), /* pcrel_offset */ 497 498 /* A 16 bit switch table entry. This is generated for an expression 499 such as ``.word L1 - L2''. The offset holds the difference 500 between the reloc address and L2. */ 501 HOWTO (R_CR16_SWITCH16, /* type */ 502 0, /* rightshift */ 503 1, /* size (0 = byte, 1 = short, 2 = long) */ 504 16, /* bitsize */ 505 FALSE, /* pc_relative */ 506 0, /* bitpos */ 507 complain_overflow_unsigned, /* complain_on_overflow */ 508 bfd_elf_generic_reloc, /* special_function */ 509 "R_CR16_SWITCH16", /* name */ 510 FALSE, /* partial_inplace */ 511 0x0, /* src_mask */ 512 0xffff, /* dst_mask */ 513 TRUE), /* pcrel_offset */ 514 515 /* A 32 bit switch table entry. This is generated for an expression 516 such as ``.long L1 - L2''. The offset holds the difference 517 between the reloc address and L2. */ 518 HOWTO (R_CR16_SWITCH32, /* type */ 519 0, /* rightshift */ 520 2, /* size (0 = byte, 1 = short, 2 = long) */ 521 32, /* bitsize */ 522 FALSE, /* pc_relative */ 523 0, /* bitpos */ 524 complain_overflow_unsigned, /* complain_on_overflow */ 525 bfd_elf_generic_reloc, /* special_function */ 526 "R_CR16_SWITCH32", /* name */ 527 FALSE, /* partial_inplace */ 528 0x0, /* src_mask */ 529 0xffffffff, /* dst_mask */ 530 TRUE), /* pcrel_offset */ 531 532 HOWTO (R_CR16_GOT_REGREL20, /* type */ 533 0, /* rightshift */ 534 2, /* size */ 535 20, /* bitsize */ 536 FALSE, /* pc_relative */ 537 0, /* bitpos */ 538 complain_overflow_bitfield,/* complain_on_overflow */ 539 bfd_elf_generic_reloc, /* special_function */ 540 "R_CR16_GOT_REGREL20", /* name */ 541 TRUE, /* partial_inplace */ 542 0x0, /* src_mask */ 543 0xfffff, /* dst_mask */ 544 FALSE), /* pcrel_offset */ 545 546 HOWTO (R_CR16_GOTC_REGREL20, /* type */ 547 0, /* rightshift */ 548 2, /* size */ 549 20, /* bitsize */ 550 FALSE, /* pc_relative */ 551 0, /* bitpos */ 552 complain_overflow_bitfield,/* complain_on_overflow */ 553 bfd_elf_generic_reloc, /* special_function */ 554 "R_CR16_GOTC_REGREL20", /* name */ 555 TRUE, /* partial_inplace */ 556 0x0, /* src_mask */ 557 0xfffff, /* dst_mask */ 558 FALSE), /* pcrel_offset */ 559 560 HOWTO (R_CR16_GLOB_DAT, /* type */ 561 0, /* rightshift */ 562 2, /* size (0 = byte, 1 = short, 2 = long) */ 563 32, /* bitsize */ 564 FALSE, /* pc_relative */ 565 0, /* bitpos */ 566 complain_overflow_unsigned, /* complain_on_overflow */ 567 bfd_elf_generic_reloc, /* special_function */ 568 "R_CR16_GLOB_DAT", /* name */ 569 FALSE, /* partial_inplace */ 570 0x0, /* src_mask */ 571 0xffffffff, /* dst_mask */ 572 TRUE) /* pcrel_offset */ 573 }; 574 575 576 /* Create the GOT section. */ 577 578 static bfd_boolean 579 _bfd_cr16_elf_create_got_section (bfd * abfd, struct bfd_link_info * info) 580 { 581 flagword flags; 582 asection * s; 583 struct elf_link_hash_entry * h; 584 const struct elf_backend_data * bed = get_elf_backend_data (abfd); 585 int ptralign; 586 587 /* This function may be called more than once. */ 588 if (bfd_get_linker_section (abfd, ".got") != NULL) 589 return TRUE; 590 591 switch (bed->s->arch_size) 592 { 593 case 16: 594 ptralign = 1; 595 break; 596 597 case 32: 598 ptralign = 2; 599 break; 600 601 default: 602 bfd_set_error (bfd_error_bad_value); 603 return FALSE; 604 } 605 606 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 607 | SEC_LINKER_CREATED); 608 609 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 610 if (s == NULL 611 || ! bfd_set_section_alignment (abfd, s, ptralign)) 612 return FALSE; 613 614 if (bed->want_got_plt) 615 { 616 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags); 617 if (s == NULL 618 || ! bfd_set_section_alignment (abfd, s, ptralign)) 619 return FALSE; 620 } 621 622 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 623 (or .got.plt) section. We don't do this in the linker script 624 because we don't want to define the symbol if we are not creating 625 a global offset table. */ 626 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_"); 627 elf_hash_table (info)->hgot = h; 628 if (h == NULL) 629 return FALSE; 630 631 /* The first bit of the global offset table is the header. */ 632 s->size += bed->got_header_size; 633 634 return TRUE; 635 } 636 637 638 /* Retrieve a howto ptr using a BFD reloc_code. */ 639 640 static reloc_howto_type * 641 elf_cr16_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 642 bfd_reloc_code_real_type code) 643 { 644 unsigned int i; 645 646 for (i = 0; i < R_CR16_MAX; i++) 647 if (code == cr16_reloc_map[i].bfd_reloc_enum) 648 return &cr16_elf_howto_table[cr16_reloc_map[i].cr16_reloc_type]; 649 650 _bfd_error_handler ("Unsupported CR16 relocation type: 0x%x\n", code); 651 return NULL; 652 } 653 654 static reloc_howto_type * 655 elf_cr16_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 656 const char *r_name) 657 { 658 unsigned int i; 659 660 for (i = 0; ARRAY_SIZE (cr16_elf_howto_table); i++) 661 if (cr16_elf_howto_table[i].name != NULL 662 && strcasecmp (cr16_elf_howto_table[i].name, r_name) == 0) 663 return cr16_elf_howto_table + i; 664 665 return NULL; 666 } 667 668 /* Retrieve a howto ptr using an internal relocation entry. */ 669 670 static void 671 elf_cr16_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, 672 Elf_Internal_Rela *dst) 673 { 674 unsigned int r_type = ELF32_R_TYPE (dst->r_info); 675 676 if (r_type >= R_CR16_MAX) 677 { 678 (*_bfd_error_handler) (_("%B: unrecognised CR16 reloc number: %d"), 679 abfd, r_type); 680 bfd_set_error (bfd_error_bad_value); 681 r_type = R_CR16_NONE; 682 } 683 cache_ptr->howto = cr16_elf_howto_table + r_type; 684 } 685 686 /* Look through the relocs for a section during the first phase. 687 Since we don't do .gots or .plts, we just need to consider the 688 virtual table relocs for gc. */ 689 690 static bfd_boolean 691 cr16_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec, 692 const Elf_Internal_Rela *relocs) 693 { 694 Elf_Internal_Shdr *symtab_hdr; 695 Elf_Internal_Sym * isymbuf = NULL; 696 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 697 const Elf_Internal_Rela *rel; 698 const Elf_Internal_Rela *rel_end; 699 bfd * dynobj; 700 bfd_vma * local_got_offsets; 701 asection * sgot; 702 asection * srelgot; 703 704 sgot = NULL; 705 srelgot = NULL; 706 bfd_boolean result = FALSE; 707 708 if (bfd_link_relocatable (info)) 709 return TRUE; 710 711 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 712 sym_hashes = elf_sym_hashes (abfd); 713 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym); 714 if (!elf_bad_symtab (abfd)) 715 sym_hashes_end -= symtab_hdr->sh_info; 716 717 dynobj = elf_hash_table (info)->dynobj; 718 local_got_offsets = elf_local_got_offsets (abfd); 719 rel_end = relocs + sec->reloc_count; 720 for (rel = relocs; rel < rel_end; rel++) 721 { 722 struct elf_link_hash_entry *h; 723 unsigned long r_symndx; 724 725 r_symndx = ELF32_R_SYM (rel->r_info); 726 if (r_symndx < symtab_hdr->sh_info) 727 h = NULL; 728 else 729 { 730 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 731 while (h->root.type == bfd_link_hash_indirect 732 || h->root.type == bfd_link_hash_warning) 733 h = (struct elf_link_hash_entry *) h->root.u.i.link; 734 735 /* PR15323, ref flags aren't set for references in the same 736 object. */ 737 h->root.non_ir_ref = 1; 738 } 739 740 /* Some relocs require a global offset table. */ 741 if (dynobj == NULL) 742 { 743 switch (ELF32_R_TYPE (rel->r_info)) 744 { 745 case R_CR16_GOT_REGREL20: 746 case R_CR16_GOTC_REGREL20: 747 elf_hash_table (info)->dynobj = dynobj = abfd; 748 if (! _bfd_cr16_elf_create_got_section (dynobj, info)) 749 goto fail; 750 break; 751 752 default: 753 break; 754 } 755 } 756 757 switch (ELF32_R_TYPE (rel->r_info)) 758 { 759 case R_CR16_GOT_REGREL20: 760 case R_CR16_GOTC_REGREL20: 761 /* This symbol requires a global offset table entry. */ 762 763 if (sgot == NULL) 764 { 765 sgot = bfd_get_linker_section (dynobj, ".got"); 766 BFD_ASSERT (sgot != NULL); 767 } 768 769 if (srelgot == NULL 770 && (h != NULL || bfd_link_executable (info))) 771 { 772 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 773 if (srelgot == NULL) 774 { 775 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 776 | SEC_IN_MEMORY | SEC_LINKER_CREATED 777 | SEC_READONLY); 778 srelgot = bfd_make_section_anyway_with_flags (dynobj, 779 ".rela.got", 780 flags); 781 if (srelgot == NULL 782 || ! bfd_set_section_alignment (dynobj, srelgot, 2)) 783 goto fail; 784 } 785 } 786 787 if (h != NULL) 788 { 789 if (h->got.offset != (bfd_vma) -1) 790 /* We have already allocated space in the .got. */ 791 break; 792 793 h->got.offset = sgot->size; 794 795 /* Make sure this symbol is output as a dynamic symbol. */ 796 if (h->dynindx == -1) 797 { 798 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 799 goto fail; 800 } 801 802 srelgot->size += sizeof (Elf32_External_Rela); 803 } 804 else 805 { 806 /* This is a global offset table entry for a local 807 symbol. */ 808 if (local_got_offsets == NULL) 809 { 810 size_t size; 811 unsigned int i; 812 813 size = symtab_hdr->sh_info * sizeof (bfd_vma); 814 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size); 815 816 if (local_got_offsets == NULL) 817 goto fail; 818 819 elf_local_got_offsets (abfd) = local_got_offsets; 820 821 for (i = 0; i < symtab_hdr->sh_info; i++) 822 local_got_offsets[i] = (bfd_vma) -1; 823 } 824 825 if (local_got_offsets[r_symndx] != (bfd_vma) -1) 826 /* We have already allocated space in the .got. */ 827 break; 828 829 local_got_offsets[r_symndx] = sgot->size; 830 831 if (bfd_link_executable (info)) 832 /* If we are generating a shared object, we need to 833 output a R_CR16_RELATIVE reloc so that the dynamic 834 linker can adjust this GOT entry. */ 835 srelgot->size += sizeof (Elf32_External_Rela); 836 } 837 838 sgot->size += 4; 839 break; 840 841 } 842 } 843 844 result = TRUE; 845 fail: 846 if (isymbuf != NULL) 847 free (isymbuf); 848 849 return result; 850 } 851 852 /* Perform a relocation as part of a final link. */ 853 854 static bfd_reloc_status_type 855 cr16_elf_final_link_relocate (reloc_howto_type *howto, 856 bfd *input_bfd, 857 bfd *output_bfd ATTRIBUTE_UNUSED, 858 asection *input_section, 859 bfd_byte *contents, 860 bfd_vma offset, 861 bfd_vma Rvalue, 862 bfd_vma addend, 863 struct elf_link_hash_entry * h, 864 unsigned long symndx ATTRIBUTE_UNUSED, 865 struct bfd_link_info *info ATTRIBUTE_UNUSED, 866 asection *sec ATTRIBUTE_UNUSED, 867 int is_local ATTRIBUTE_UNUSED) 868 { 869 unsigned short r_type = howto->type; 870 bfd_byte *hit_data = contents + offset; 871 bfd_vma reloc_bits, check, Rvalue1; 872 bfd * dynobj; 873 874 dynobj = elf_hash_table (info)->dynobj; 875 876 switch (r_type) 877 { 878 case R_CR16_IMM4: 879 case R_CR16_IMM20: 880 case R_CR16_ABS20: 881 break; 882 883 case R_CR16_IMM8: 884 case R_CR16_IMM16: 885 case R_CR16_IMM32: 886 case R_CR16_IMM32a: 887 case R_CR16_REGREL4: 888 case R_CR16_REGREL4a: 889 case R_CR16_REGREL14: 890 case R_CR16_REGREL14a: 891 case R_CR16_REGREL16: 892 case R_CR16_REGREL20: 893 case R_CR16_REGREL20a: 894 case R_CR16_GOT_REGREL20: 895 case R_CR16_GOTC_REGREL20: 896 case R_CR16_ABS24: 897 case R_CR16_DISP16: 898 case R_CR16_DISP24: 899 /* 'hit_data' is relative to the start of the instruction, not the 900 relocation offset. Advance it to account for the exact offset. */ 901 hit_data += 2; 902 break; 903 904 case R_CR16_NONE: 905 return bfd_reloc_ok; 906 break; 907 908 case R_CR16_DISP4: 909 if (is_local) 910 Rvalue += -1; 911 break; 912 913 case R_CR16_DISP8: 914 case R_CR16_DISP24a: 915 if (is_local) 916 Rvalue -= -1; 917 break; 918 919 case R_CR16_SWITCH8: 920 case R_CR16_SWITCH16: 921 case R_CR16_SWITCH32: 922 /* We only care about the addend, where the difference between 923 expressions is kept. */ 924 Rvalue = 0; 925 926 default: 927 break; 928 } 929 930 if (howto->pc_relative) 931 { 932 /* Subtract the address of the section containing the location. */ 933 Rvalue -= (input_section->output_section->vma 934 + input_section->output_offset); 935 /* Subtract the position of the location within the section. */ 936 Rvalue -= offset; 937 } 938 939 /* Add in supplied addend. */ 940 Rvalue += addend; 941 942 /* Complain if the bitfield overflows, whether it is considered 943 as signed or unsigned. */ 944 check = Rvalue >> howto->rightshift; 945 946 /* Assumes two's complement. This expression avoids 947 overflow if howto->bitsize is the number of bits in 948 bfd_vma. */ 949 reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1; 950 951 /* For GOT and GOTC relocs no boundary checks applied. */ 952 if (!((r_type == R_CR16_GOT_REGREL20) 953 || (r_type == R_CR16_GOTC_REGREL20))) 954 { 955 if (((bfd_vma) check & ~reloc_bits) != 0 956 && (((bfd_vma) check & ~reloc_bits) 957 != (-(bfd_vma) 1 & ~reloc_bits))) 958 { 959 /* The above right shift is incorrect for a signed 960 value. See if turning on the upper bits fixes the 961 overflow. */ 962 if (howto->rightshift && (bfd_signed_vma) Rvalue < 0) 963 { 964 check |= ((bfd_vma) - 1 965 & ~((bfd_vma) - 1 966 >> howto->rightshift)); 967 968 if (((bfd_vma) check & ~reloc_bits) 969 != (-(bfd_vma) 1 & ~reloc_bits)) 970 return bfd_reloc_overflow; 971 } 972 else 973 return bfd_reloc_overflow; 974 } 975 976 /* Drop unwanted bits from the value we are relocating to. */ 977 Rvalue >>= (bfd_vma) howto->rightshift; 978 979 /* Apply dst_mask to select only relocatable part of the insn. */ 980 Rvalue &= howto->dst_mask; 981 } 982 983 switch (howto->size) 984 { 985 case 0: 986 if (r_type == R_CR16_DISP8) 987 { 988 Rvalue1 = bfd_get_16 (input_bfd, hit_data); 989 Rvalue = ((Rvalue1 & 0xf000) | ((Rvalue << 4) & 0xf00) 990 | (Rvalue1 & 0x00f0) | (Rvalue & 0xf)); 991 bfd_put_16 (input_bfd, Rvalue, hit_data); 992 } 993 else if (r_type == R_CR16_IMM4) 994 { 995 Rvalue1 = bfd_get_16 (input_bfd, hit_data); 996 Rvalue = (((Rvalue1 & 0xff) << 8) | ((Rvalue << 4) & 0xf0) 997 | ((Rvalue1 & 0x0f00) >> 8)); 998 bfd_put_16 (input_bfd, Rvalue, hit_data); 999 } 1000 else if (r_type == R_CR16_DISP4) 1001 { 1002 Rvalue1 = bfd_get_16 (input_bfd, hit_data); 1003 Rvalue = (Rvalue1 | ((Rvalue & 0xf) << 4)); 1004 bfd_put_16 (input_bfd, Rvalue, hit_data); 1005 } 1006 else 1007 { 1008 bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data); 1009 } 1010 break; 1011 1012 case 1: 1013 if (r_type == R_CR16_DISP16) 1014 { 1015 Rvalue |= (bfd_get_16 (input_bfd, hit_data)); 1016 Rvalue = ((Rvalue & 0xfffe) | ((Rvalue >> 16) & 0x1)); 1017 } 1018 if (r_type == R_CR16_IMM16) 1019 { 1020 Rvalue1 = bfd_get_16 (input_bfd, hit_data); 1021 1022 /* Add or subtract the offset value. */ 1023 if (Rvalue1 & 0x8000) 1024 Rvalue -= (~Rvalue1 + 1) & 0xffff; 1025 else 1026 Rvalue += Rvalue1; 1027 1028 /* Check for range. */ 1029 if ((long) Rvalue > 0xffff || (long) Rvalue < 0x0) 1030 return bfd_reloc_overflow; 1031 } 1032 1033 bfd_put_16 (input_bfd, Rvalue, hit_data); 1034 break; 1035 1036 case 2: 1037 if ((r_type == R_CR16_ABS20) || (r_type == R_CR16_IMM20)) 1038 { 1039 Rvalue1 = (bfd_get_16 (input_bfd, hit_data + 2) 1040 | (((bfd_get_16 (input_bfd, hit_data) & 0xf) <<16))); 1041 1042 /* Add or subtract the offset value. */ 1043 if (Rvalue1 & 0x80000) 1044 Rvalue -= (~Rvalue1 + 1) & 0xfffff; 1045 else 1046 Rvalue += Rvalue1; 1047 1048 /* Check for range. */ 1049 if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0) 1050 return bfd_reloc_overflow; 1051 1052 bfd_put_16 (input_bfd, ((bfd_get_16 (input_bfd, hit_data) & 0xfff0) 1053 | ((Rvalue >> 16) & 0xf)), hit_data); 1054 bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2); 1055 } 1056 else if (r_type == R_CR16_GOT_REGREL20) 1057 { 1058 asection * sgot = bfd_get_linker_section (dynobj, ".got"); 1059 1060 if (h != NULL) 1061 { 1062 bfd_vma off; 1063 1064 off = h->got.offset; 1065 BFD_ASSERT (off != (bfd_vma) -1); 1066 1067 if (! elf_hash_table (info)->dynamic_sections_created 1068 || SYMBOL_REFERENCES_LOCAL (info, h)) 1069 /* This is actually a static link, or it is a 1070 -Bsymbolic link and the symbol is defined 1071 locally, or the symbol was forced to be local 1072 because of a version file. We must initialize 1073 this entry in the global offset table. 1074 When doing a dynamic link, we create a .rela.got 1075 relocation entry to initialize the value. This 1076 is done in the finish_dynamic_symbol routine. */ 1077 bfd_put_32 (output_bfd, Rvalue, sgot->contents + off); 1078 1079 Rvalue = sgot->output_offset + off; 1080 } 1081 else 1082 { 1083 bfd_vma off; 1084 1085 off = elf_local_got_offsets (input_bfd)[symndx]; 1086 bfd_put_32 (output_bfd,Rvalue, sgot->contents + off); 1087 1088 Rvalue = sgot->output_offset + off; 1089 } 1090 1091 Rvalue += addend; 1092 1093 /* REVISIT: if ((long) Rvalue > 0xffffff || 1094 (long) Rvalue < -0x800000). */ 1095 if ((long) Rvalue > 0xffffff || (long) Rvalue < 0) 1096 return bfd_reloc_overflow; 1097 1098 1099 bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data)) 1100 | (((Rvalue >> 16) & 0xf) << 8), hit_data); 1101 bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2); 1102 1103 } 1104 else if (r_type == R_CR16_GOTC_REGREL20) 1105 { 1106 asection * sgot; 1107 sgot = bfd_get_linker_section (dynobj, ".got"); 1108 1109 if (h != NULL) 1110 { 1111 bfd_vma off; 1112 1113 off = h->got.offset; 1114 BFD_ASSERT (off != (bfd_vma) -1); 1115 1116 Rvalue >>=1; /* For code symbols. */ 1117 1118 if (! elf_hash_table (info)->dynamic_sections_created 1119 || SYMBOL_REFERENCES_LOCAL (info, h)) 1120 /* This is actually a static link, or it is a 1121 -Bsymbolic link and the symbol is defined 1122 locally, or the symbol was forced to be local 1123 because of a version file. We must initialize 1124 this entry in the global offset table. 1125 When doing a dynamic link, we create a .rela.got 1126 relocation entry to initialize the value. This 1127 is done in the finish_dynamic_symbol routine. */ 1128 bfd_put_32 (output_bfd, Rvalue, sgot->contents + off); 1129 1130 Rvalue = sgot->output_offset + off; 1131 } 1132 else 1133 { 1134 bfd_vma off; 1135 1136 off = elf_local_got_offsets (input_bfd)[symndx]; 1137 Rvalue >>= 1; 1138 bfd_put_32 (output_bfd,Rvalue, sgot->contents + off); 1139 Rvalue = sgot->output_offset + off; 1140 } 1141 1142 Rvalue += addend; 1143 1144 /* Check if any value in DISP. */ 1145 Rvalue1 =((bfd_get_32 (input_bfd, hit_data) >>16) 1146 | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16)); 1147 1148 /* Add or subtract the offset value. */ 1149 if (Rvalue1 & 0x80000) 1150 Rvalue -= (~Rvalue1 + 1) & 0xfffff; 1151 else 1152 Rvalue += Rvalue1; 1153 1154 /* Check for range. */ 1155 /* REVISIT: if ((long) Rvalue > 0xffffff 1156 || (long) Rvalue < -0x800000). */ 1157 if ((long) Rvalue > 0xffffff || (long) Rvalue < 0) 1158 return bfd_reloc_overflow; 1159 1160 bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data)) 1161 | (((Rvalue >> 16) & 0xf) << 8), hit_data); 1162 bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2); 1163 } 1164 else 1165 { 1166 if (r_type == R_CR16_ABS24) 1167 { 1168 Rvalue1 = ((bfd_get_32 (input_bfd, hit_data) >> 16) 1169 | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16) 1170 | (((bfd_get_32 (input_bfd, hit_data) & 0xf) <<20))); 1171 1172 /* Add or subtract the offset value. */ 1173 if (Rvalue1 & 0x800000) 1174 Rvalue -= (~Rvalue1 + 1) & 0xffffff; 1175 else 1176 Rvalue += Rvalue1; 1177 1178 /* Check for Range. */ 1179 if ((long) Rvalue > 0xffffff || (long) Rvalue < 0x0) 1180 return bfd_reloc_overflow; 1181 1182 Rvalue = ((((Rvalue >> 20) & 0xf) | (((Rvalue >> 16) & 0xf)<<8) 1183 | (bfd_get_32 (input_bfd, hit_data) & 0xf0f0)) 1184 | ((Rvalue & 0xffff) << 16)); 1185 } 1186 else if (r_type == R_CR16_DISP24) 1187 { 1188 Rvalue = ((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8) 1189 | (bfd_get_16 (input_bfd, hit_data))) 1190 | (((Rvalue & 0xfffe) | ((Rvalue >> 24) & 0x1)) << 16)); 1191 } 1192 else if ((r_type == R_CR16_IMM32) || (r_type == R_CR16_IMM32a)) 1193 { 1194 Rvalue1 =((((bfd_get_32 (input_bfd, hit_data)) >> 16) &0xffff) 1195 | (((bfd_get_32 (input_bfd, hit_data)) &0xffff)) << 16); 1196 1197 /* Add or subtract the offset value. */ 1198 if (Rvalue1 & 0x80000000) 1199 Rvalue -= (~Rvalue1 + 1) & 0xffffffff; 1200 else 1201 Rvalue += Rvalue1; 1202 1203 /* Check for range. */ 1204 if (Rvalue > 0xffffffff || (long) Rvalue < 0x0) 1205 return bfd_reloc_overflow; 1206 1207 Rvalue = (((Rvalue >> 16)& 0xffff) | (Rvalue & 0xffff) << 16); 1208 } 1209 else if (r_type == R_CR16_DISP24a) 1210 { 1211 Rvalue = (((Rvalue & 0xfffffe) | (Rvalue >> 23))); 1212 Rvalue = ((Rvalue >> 16) & 0xff) | ((Rvalue & 0xffff) << 16) 1213 | (bfd_get_32 (input_bfd, hit_data)); 1214 } 1215 else if ((r_type == R_CR16_REGREL20) 1216 || (r_type == R_CR16_REGREL20a)) 1217 { 1218 Rvalue1 = ((bfd_get_32 (input_bfd, hit_data) >> 16) 1219 | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16)); 1220 /* Add or subtract the offset value. */ 1221 if (Rvalue1 & 0x80000) 1222 Rvalue -= (~Rvalue1 + 1) & 0xfffff; 1223 else 1224 Rvalue += Rvalue1; 1225 1226 /* Check for range. */ 1227 if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0) 1228 return bfd_reloc_overflow; 1229 1230 Rvalue = (((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8) 1231 | ((Rvalue & 0xffff) << 16))) 1232 | (bfd_get_32 (input_bfd, hit_data) & 0xf0ff)); 1233 1234 } 1235 else if (r_type == R_CR16_NUM32) 1236 { 1237 Rvalue1 = (bfd_get_32 (input_bfd, hit_data)); 1238 1239 /* Add or subtract the offset value */ 1240 if (Rvalue1 & 0x80000000) 1241 Rvalue -= (~Rvalue1 + 1) & 0xffffffff; 1242 else 1243 Rvalue += Rvalue1; 1244 1245 /* Check for Ranga */ 1246 if (Rvalue > 0xffffffff) 1247 return bfd_reloc_overflow; 1248 } 1249 1250 bfd_put_32 (input_bfd, Rvalue, hit_data); 1251 } 1252 break; 1253 1254 default: 1255 return bfd_reloc_notsupported; 1256 } 1257 1258 return bfd_reloc_ok; 1259 } 1260 1261 /* Delete some bytes from a section while relaxing. */ 1262 1263 static bfd_boolean 1264 elf32_cr16_relax_delete_bytes (struct bfd_link_info *link_info, bfd *abfd, 1265 asection *sec, bfd_vma addr, int count) 1266 { 1267 Elf_Internal_Shdr *symtab_hdr; 1268 unsigned int sec_shndx; 1269 bfd_byte *contents; 1270 Elf_Internal_Rela *irel, *irelend; 1271 bfd_vma toaddr; 1272 Elf_Internal_Sym *isym; 1273 Elf_Internal_Sym *isymend; 1274 struct elf_link_hash_entry **sym_hashes; 1275 struct elf_link_hash_entry **end_hashes; 1276 struct elf_link_hash_entry **start_hashes; 1277 unsigned int symcount; 1278 1279 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1280 1281 contents = elf_section_data (sec)->this_hdr.contents; 1282 1283 toaddr = sec->size; 1284 1285 irel = elf_section_data (sec)->relocs; 1286 irelend = irel + sec->reloc_count; 1287 1288 /* Actually delete the bytes. */ 1289 memmove (contents + addr, contents + addr + count, 1290 (size_t) (toaddr - addr - count)); 1291 sec->size -= count; 1292 1293 /* Adjust all the relocs. */ 1294 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 1295 /* Get the new reloc address. */ 1296 if ((irel->r_offset > addr && irel->r_offset < toaddr)) 1297 irel->r_offset -= count; 1298 1299 /* Adjust the local symbols defined in this section. */ 1300 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1301 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 1302 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 1303 { 1304 if (isym->st_shndx == sec_shndx 1305 && isym->st_value > addr 1306 && isym->st_value < toaddr) 1307 { 1308 /* Adjust the addend of SWITCH relocations in this section, 1309 which reference this local symbol. */ 1310 #if 0 1311 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 1312 { 1313 unsigned long r_symndx; 1314 Elf_Internal_Sym *rsym; 1315 bfd_vma addsym, subsym; 1316 1317 /* Skip if not a SWITCH relocation. */ 1318 if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH8 1319 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH16 1320 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH32) 1321 continue; 1322 1323 r_symndx = ELF32_R_SYM (irel->r_info); 1324 rsym = (Elf_Internal_Sym *) symtab_hdr->contents + r_symndx; 1325 1326 /* Skip if not the local adjusted symbol. */ 1327 if (rsym != isym) 1328 continue; 1329 1330 addsym = isym->st_value; 1331 subsym = addsym - irel->r_addend; 1332 1333 /* Fix the addend only when -->> (addsym > addr >= subsym). */ 1334 if (subsym <= addr) 1335 irel->r_addend -= count; 1336 else 1337 continue; 1338 } 1339 #endif 1340 1341 isym->st_value -= count; 1342 } 1343 } 1344 1345 /* Now adjust the global symbols defined in this section. */ 1346 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1347 - symtab_hdr->sh_info); 1348 sym_hashes = start_hashes = elf_sym_hashes (abfd); 1349 end_hashes = sym_hashes + symcount; 1350 1351 for (; sym_hashes < end_hashes; sym_hashes++) 1352 { 1353 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1354 1355 /* The '--wrap SYMBOL' option is causing a pain when the object file, 1356 containing the definition of __wrap_SYMBOL, includes a direct 1357 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference 1358 the same symbol (which is __wrap_SYMBOL), but still exist as two 1359 different symbols in 'sym_hashes', we don't want to adjust 1360 the global symbol __wrap_SYMBOL twice. 1361 This check is only relevant when symbols are being wrapped. */ 1362 if (link_info->wrap_hash != NULL) 1363 { 1364 struct elf_link_hash_entry **cur_sym_hashes; 1365 1366 /* Loop only over the symbols whom been already checked. */ 1367 for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes; 1368 cur_sym_hashes++) 1369 /* If the current symbol is identical to 'sym_hash', that means 1370 the symbol was already adjusted (or at least checked). */ 1371 if (*cur_sym_hashes == sym_hash) 1372 break; 1373 1374 /* Don't adjust the symbol again. */ 1375 if (cur_sym_hashes < sym_hashes) 1376 continue; 1377 } 1378 1379 if ((sym_hash->root.type == bfd_link_hash_defined 1380 || sym_hash->root.type == bfd_link_hash_defweak) 1381 && sym_hash->root.u.def.section == sec 1382 && sym_hash->root.u.def.value > addr 1383 && sym_hash->root.u.def.value < toaddr) 1384 sym_hash->root.u.def.value -= count; 1385 } 1386 1387 return TRUE; 1388 } 1389 1390 /* Relocate a CR16 ELF section. */ 1391 1392 static bfd_boolean 1393 elf32_cr16_relocate_section (bfd *output_bfd, struct bfd_link_info *info, 1394 bfd *input_bfd, asection *input_section, 1395 bfd_byte *contents, Elf_Internal_Rela *relocs, 1396 Elf_Internal_Sym *local_syms, 1397 asection **local_sections) 1398 { 1399 Elf_Internal_Shdr *symtab_hdr; 1400 struct elf_link_hash_entry **sym_hashes; 1401 Elf_Internal_Rela *rel, *relend; 1402 1403 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1404 sym_hashes = elf_sym_hashes (input_bfd); 1405 1406 rel = relocs; 1407 relend = relocs + input_section->reloc_count; 1408 for (; rel < relend; rel++) 1409 { 1410 int r_type; 1411 reloc_howto_type *howto; 1412 unsigned long r_symndx; 1413 Elf_Internal_Sym *sym; 1414 asection *sec; 1415 struct elf_link_hash_entry *h; 1416 bfd_vma relocation; 1417 bfd_reloc_status_type r; 1418 1419 r_symndx = ELF32_R_SYM (rel->r_info); 1420 r_type = ELF32_R_TYPE (rel->r_info); 1421 howto = cr16_elf_howto_table + (r_type); 1422 1423 h = NULL; 1424 sym = NULL; 1425 sec = NULL; 1426 if (r_symndx < symtab_hdr->sh_info) 1427 { 1428 sym = local_syms + r_symndx; 1429 sec = local_sections[r_symndx]; 1430 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1431 } 1432 else 1433 { 1434 bfd_boolean unresolved_reloc, warned, ignored; 1435 1436 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1437 r_symndx, symtab_hdr, sym_hashes, 1438 h, sec, relocation, 1439 unresolved_reloc, warned, ignored); 1440 } 1441 1442 if (sec != NULL && discarded_section (sec)) 1443 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 1444 rel, 1, relend, howto, 0, contents); 1445 1446 if (bfd_link_relocatable (info)) 1447 continue; 1448 1449 r = cr16_elf_final_link_relocate (howto, input_bfd, output_bfd, 1450 input_section, 1451 contents, rel->r_offset, 1452 relocation, rel->r_addend, 1453 (struct elf_link_hash_entry *) h, 1454 r_symndx, 1455 info, sec, h == NULL); 1456 1457 if (r != bfd_reloc_ok) 1458 { 1459 const char *name; 1460 const char *msg = NULL; 1461 1462 if (h != NULL) 1463 name = h->root.root.string; 1464 else 1465 { 1466 name = (bfd_elf_string_from_elf_section 1467 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 1468 if (name == NULL || *name == '\0') 1469 name = bfd_section_name (input_bfd, sec); 1470 } 1471 1472 switch (r) 1473 { 1474 case bfd_reloc_overflow: 1475 (*info->callbacks->reloc_overflow) 1476 (info, (h ? &h->root : NULL), name, howto->name, 1477 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 1478 break; 1479 1480 case bfd_reloc_undefined: 1481 (*info->callbacks->undefined_symbol) 1482 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 1483 break; 1484 1485 case bfd_reloc_outofrange: 1486 msg = _("internal error: out of range error"); 1487 goto common_error; 1488 1489 case bfd_reloc_notsupported: 1490 msg = _("internal error: unsupported relocation error"); 1491 goto common_error; 1492 1493 case bfd_reloc_dangerous: 1494 msg = _("internal error: dangerous error"); 1495 goto common_error; 1496 1497 default: 1498 msg = _("internal error: unknown error"); 1499 /* Fall through. */ 1500 1501 common_error: 1502 (*info->callbacks->warning) (info, msg, name, input_bfd, 1503 input_section, rel->r_offset); 1504 break; 1505 } 1506 } 1507 } 1508 1509 return TRUE; 1510 } 1511 1512 /* This is a version of bfd_generic_get_relocated_section_contents 1513 which uses elf32_cr16_relocate_section. */ 1514 1515 static bfd_byte * 1516 elf32_cr16_get_relocated_section_contents (bfd *output_bfd, 1517 struct bfd_link_info *link_info, 1518 struct bfd_link_order *link_order, 1519 bfd_byte *data, 1520 bfd_boolean relocatable, 1521 asymbol **symbols) 1522 { 1523 Elf_Internal_Shdr *symtab_hdr; 1524 asection *input_section = link_order->u.indirect.section; 1525 bfd *input_bfd = input_section->owner; 1526 asection **sections = NULL; 1527 Elf_Internal_Rela *internal_relocs = NULL; 1528 Elf_Internal_Sym *isymbuf = NULL; 1529 1530 /* We only need to handle the case of relaxing, or of having a 1531 particular set of section contents, specially. */ 1532 if (relocatable 1533 || elf_section_data (input_section)->this_hdr.contents == NULL) 1534 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 1535 link_order, data, 1536 relocatable, 1537 symbols); 1538 1539 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1540 1541 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 1542 (size_t) input_section->size); 1543 1544 if ((input_section->flags & SEC_RELOC) != 0 1545 && input_section->reloc_count > 0) 1546 { 1547 Elf_Internal_Sym *isym; 1548 Elf_Internal_Sym *isymend; 1549 asection **secpp; 1550 bfd_size_type amt; 1551 1552 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section, 1553 NULL, NULL, FALSE); 1554 if (internal_relocs == NULL) 1555 goto error_return; 1556 1557 if (symtab_hdr->sh_info != 0) 1558 { 1559 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1560 if (isymbuf == NULL) 1561 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 1562 symtab_hdr->sh_info, 0, 1563 NULL, NULL, NULL); 1564 if (isymbuf == NULL) 1565 goto error_return; 1566 } 1567 1568 amt = symtab_hdr->sh_info; 1569 amt *= sizeof (asection *); 1570 sections = bfd_malloc (amt); 1571 if (sections == NULL && amt != 0) 1572 goto error_return; 1573 1574 isymend = isymbuf + symtab_hdr->sh_info; 1575 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 1576 { 1577 asection *isec; 1578 1579 if (isym->st_shndx == SHN_UNDEF) 1580 isec = bfd_und_section_ptr; 1581 else if (isym->st_shndx == SHN_ABS) 1582 isec = bfd_abs_section_ptr; 1583 else if (isym->st_shndx == SHN_COMMON) 1584 isec = bfd_com_section_ptr; 1585 else 1586 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 1587 1588 *secpp = isec; 1589 } 1590 1591 if (! elf32_cr16_relocate_section (output_bfd, link_info, input_bfd, 1592 input_section, data, internal_relocs, 1593 isymbuf, sections)) 1594 goto error_return; 1595 1596 if (sections != NULL) 1597 free (sections); 1598 if (isymbuf != NULL 1599 && symtab_hdr->contents != (unsigned char *) isymbuf) 1600 free (isymbuf); 1601 if (elf_section_data (input_section)->relocs != internal_relocs) 1602 free (internal_relocs); 1603 } 1604 1605 return data; 1606 1607 error_return: 1608 if (sections != NULL) 1609 free (sections); 1610 if (isymbuf != NULL 1611 && symtab_hdr->contents != (unsigned char *) isymbuf) 1612 free (isymbuf); 1613 if (internal_relocs != NULL 1614 && elf_section_data (input_section)->relocs != internal_relocs) 1615 free (internal_relocs); 1616 return NULL; 1617 } 1618 1619 /* Assorted hash table functions. */ 1620 1621 /* Initialize an entry in the link hash table. */ 1622 1623 /* Create an entry in an CR16 ELF linker hash table. */ 1624 1625 static struct bfd_hash_entry * 1626 elf32_cr16_link_hash_newfunc (struct bfd_hash_entry *entry, 1627 struct bfd_hash_table *table, 1628 const char *string) 1629 { 1630 struct elf32_cr16_link_hash_entry *ret = 1631 (struct elf32_cr16_link_hash_entry *) entry; 1632 1633 /* Allocate the structure if it has not already been allocated by a 1634 subclass. */ 1635 if (ret == (struct elf32_cr16_link_hash_entry *) NULL) 1636 ret = ((struct elf32_cr16_link_hash_entry *) 1637 bfd_hash_allocate (table, 1638 sizeof (struct elf32_cr16_link_hash_entry))); 1639 if (ret == (struct elf32_cr16_link_hash_entry *) NULL) 1640 return (struct bfd_hash_entry *) ret; 1641 1642 /* Call the allocation method of the superclass. */ 1643 ret = ((struct elf32_cr16_link_hash_entry *) 1644 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 1645 table, string)); 1646 if (ret != (struct elf32_cr16_link_hash_entry *) NULL) 1647 { 1648 ret->direct_calls = 0; 1649 ret->stack_size = 0; 1650 ret->movm_args = 0; 1651 ret->movm_stack_size = 0; 1652 ret->flags = 0; 1653 ret->value = 0; 1654 } 1655 1656 return (struct bfd_hash_entry *) ret; 1657 } 1658 1659 /* Create an cr16 ELF linker hash table. */ 1660 1661 static struct bfd_link_hash_table * 1662 elf32_cr16_link_hash_table_create (bfd *abfd) 1663 { 1664 struct elf_link_hash_table *ret; 1665 bfd_size_type amt = sizeof (struct elf_link_hash_table); 1666 1667 ret = (struct elf_link_hash_table *) bfd_zmalloc (amt); 1668 if (ret == (struct elf_link_hash_table *) NULL) 1669 return NULL; 1670 1671 if (!_bfd_elf_link_hash_table_init (ret, abfd, 1672 elf32_cr16_link_hash_newfunc, 1673 sizeof (struct elf32_cr16_link_hash_entry), 1674 GENERIC_ELF_DATA)) 1675 { 1676 free (ret); 1677 return NULL; 1678 } 1679 1680 return &ret->root; 1681 } 1682 1683 static unsigned long 1684 elf_cr16_mach (flagword flags) 1685 { 1686 switch (flags) 1687 { 1688 case EM_CR16: 1689 default: 1690 return bfd_mach_cr16; 1691 } 1692 } 1693 1694 /* The final processing done just before writing out a CR16 ELF object 1695 file. This gets the CR16 architecture right based on the machine 1696 number. */ 1697 1698 static void 1699 _bfd_cr16_elf_final_write_processing (bfd *abfd, 1700 bfd_boolean linker ATTRIBUTE_UNUSED) 1701 { 1702 unsigned long val; 1703 switch (bfd_get_mach (abfd)) 1704 { 1705 default: 1706 case bfd_mach_cr16: 1707 val = EM_CR16; 1708 break; 1709 } 1710 1711 1712 elf_elfheader (abfd)->e_flags |= val; 1713 } 1714 1715 1716 static bfd_boolean 1717 _bfd_cr16_elf_object_p (bfd *abfd) 1718 { 1719 bfd_default_set_arch_mach (abfd, bfd_arch_cr16, 1720 elf_cr16_mach (elf_elfheader (abfd)->e_flags)); 1721 return TRUE; 1722 } 1723 1724 /* Merge backend specific data from an object file to the output 1725 object file when linking. */ 1726 1727 static bfd_boolean 1728 _bfd_cr16_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 1729 { 1730 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1731 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 1732 return TRUE; 1733 1734 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 1735 && bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 1736 { 1737 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 1738 bfd_get_mach (ibfd))) 1739 return FALSE; 1740 } 1741 1742 return TRUE; 1743 } 1744 1745 1746 /* This function handles relaxing for the CR16. 1747 1748 There's quite a few relaxing opportunites available on the CR16: 1749 1750 * bcond:24 -> bcond:16 1 byte 1751 * bcond:16 -> bcond:8 1 byte 1752 * arithmetic imm32 -> arithmetic imm20 12 bits 1753 * arithmetic imm20/imm16 -> arithmetic imm4 12/16 bits 1754 1755 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */ 1756 1757 static bfd_boolean 1758 elf32_cr16_relax_section (bfd *abfd, asection *sec, 1759 struct bfd_link_info *link_info, bfd_boolean *again) 1760 { 1761 Elf_Internal_Shdr *symtab_hdr; 1762 Elf_Internal_Rela *internal_relocs; 1763 Elf_Internal_Rela *irel, *irelend; 1764 bfd_byte *contents = NULL; 1765 Elf_Internal_Sym *isymbuf = NULL; 1766 1767 /* Assume nothing changes. */ 1768 *again = FALSE; 1769 1770 /* We don't have to do anything for a relocatable link, if 1771 this section does not have relocs, or if this is not a 1772 code section. */ 1773 if (bfd_link_relocatable (link_info) 1774 || (sec->flags & SEC_RELOC) == 0 1775 || sec->reloc_count == 0 1776 || (sec->flags & SEC_CODE) == 0) 1777 return TRUE; 1778 1779 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1780 1781 /* Get a copy of the native relocations. */ 1782 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 1783 link_info->keep_memory); 1784 if (internal_relocs == NULL) 1785 goto error_return; 1786 1787 /* Walk through them looking for relaxing opportunities. */ 1788 irelend = internal_relocs + sec->reloc_count; 1789 for (irel = internal_relocs; irel < irelend; irel++) 1790 { 1791 bfd_vma symval; 1792 1793 /* If this isn't something that can be relaxed, then ignore 1794 this reloc. */ 1795 if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_DISP16 1796 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_DISP24 1797 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM32 1798 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM20 1799 && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM16) 1800 continue; 1801 1802 /* Get the section contents if we haven't done so already. */ 1803 if (contents == NULL) 1804 { 1805 /* Get cached copy if it exists. */ 1806 if (elf_section_data (sec)->this_hdr.contents != NULL) 1807 contents = elf_section_data (sec)->this_hdr.contents; 1808 /* Go get them off disk. */ 1809 else if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 1810 goto error_return; 1811 } 1812 1813 /* Read this BFD's local symbols if we haven't done so already. */ 1814 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 1815 { 1816 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1817 if (isymbuf == NULL) 1818 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 1819 symtab_hdr->sh_info, 0, 1820 NULL, NULL, NULL); 1821 if (isymbuf == NULL) 1822 goto error_return; 1823 } 1824 1825 /* Get the value of the symbol referred to by the reloc. */ 1826 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 1827 { 1828 /* A local symbol. */ 1829 Elf_Internal_Sym *isym; 1830 asection *sym_sec; 1831 1832 isym = isymbuf + ELF32_R_SYM (irel->r_info); 1833 if (isym->st_shndx == SHN_UNDEF) 1834 sym_sec = bfd_und_section_ptr; 1835 else if (isym->st_shndx == SHN_ABS) 1836 sym_sec = bfd_abs_section_ptr; 1837 else if (isym->st_shndx == SHN_COMMON) 1838 sym_sec = bfd_com_section_ptr; 1839 else 1840 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 1841 symval = (isym->st_value 1842 + sym_sec->output_section->vma 1843 + sym_sec->output_offset); 1844 } 1845 else 1846 { 1847 unsigned long indx; 1848 struct elf_link_hash_entry *h; 1849 1850 /* An external symbol. */ 1851 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 1852 h = elf_sym_hashes (abfd)[indx]; 1853 BFD_ASSERT (h != NULL); 1854 1855 if (h->root.type != bfd_link_hash_defined 1856 && h->root.type != bfd_link_hash_defweak) 1857 /* This appears to be a reference to an undefined 1858 symbol. Just ignore it--it will be caught by the 1859 regular reloc processing. */ 1860 continue; 1861 1862 symval = (h->root.u.def.value 1863 + h->root.u.def.section->output_section->vma 1864 + h->root.u.def.section->output_offset); 1865 } 1866 1867 /* For simplicity of coding, we are going to modify the section 1868 contents, the section relocs, and the BFD symbol table. We 1869 must tell the rest of the code not to free up this 1870 information. It would be possible to instead create a table 1871 of changes which have to be made, as is done in coff-mips.c; 1872 that would be more work, but would require less memory when 1873 the linker is run. */ 1874 1875 /* Try to turn a 24 branch/call into a 16bit relative 1876 branch/call. */ 1877 if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_DISP24) 1878 { 1879 bfd_vma value = symval; 1880 1881 /* Deal with pc-relative gunk. */ 1882 value -= (sec->output_section->vma + sec->output_offset); 1883 value -= irel->r_offset; 1884 value += irel->r_addend; 1885 1886 /* See if the value will fit in 16 bits, note the high value is 1887 0xfffe + 2 as the target will be two bytes closer if we are 1888 able to relax. */ 1889 if ((long) value < 0x10000 && (long) value > -0x10002) 1890 { 1891 unsigned int code; 1892 1893 /* Get the opcode. */ 1894 code = (unsigned int) bfd_get_32 (abfd, contents + irel->r_offset); 1895 1896 /* Verify it's a 'bcond' and fix the opcode. */ 1897 if ((code & 0xffff) == 0x0010) 1898 bfd_put_16 (abfd, 0x1800 | ((0xf & (code >> 20)) << 4), contents + irel->r_offset); 1899 else 1900 continue; 1901 1902 /* Note that we've changed the relocs, section contents, etc. */ 1903 elf_section_data (sec)->relocs = internal_relocs; 1904 elf_section_data (sec)->this_hdr.contents = contents; 1905 symtab_hdr->contents = (unsigned char *) isymbuf; 1906 1907 /* Fix the relocation's type. */ 1908 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1909 R_CR16_DISP16); 1910 1911 /* Delete two bytes of data. */ 1912 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec, 1913 irel->r_offset + 2, 2)) 1914 goto error_return; 1915 1916 /* That will change things, so, we should relax again. 1917 Note that this is not required, and it may be slow. */ 1918 *again = TRUE; 1919 } 1920 } 1921 1922 /* Try to turn a 16bit pc-relative branch into an 1923 8bit pc-relative branch. */ 1924 if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_DISP16) 1925 { 1926 bfd_vma value = symval; 1927 1928 /* Deal with pc-relative gunk. */ 1929 value -= (sec->output_section->vma + sec->output_offset); 1930 value -= irel->r_offset; 1931 value += irel->r_addend; 1932 1933 /* See if the value will fit in 8 bits, note the high value is 1934 0xfc + 2 as the target will be two bytes closer if we are 1935 able to relax. */ 1936 /*if ((long) value < 0x1fa && (long) value > -0x100) REVISIT:range */ 1937 if ((long) value < 0xfa && (long) value > -0x100) 1938 { 1939 unsigned short code; 1940 1941 /* Get the opcode. */ 1942 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset); 1943 1944 /* Verify it's a 'bcond' and fix the opcode. */ 1945 if ((code & 0xff0f) == 0x1800) 1946 bfd_put_16 (abfd, (code & 0xf0f0), contents + irel->r_offset); 1947 else 1948 continue; 1949 1950 /* Note that we've changed the relocs, section contents, etc. */ 1951 elf_section_data (sec)->relocs = internal_relocs; 1952 elf_section_data (sec)->this_hdr.contents = contents; 1953 symtab_hdr->contents = (unsigned char *) isymbuf; 1954 1955 /* Fix the relocation's type. */ 1956 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1957 R_CR16_DISP8); 1958 1959 /* Delete two bytes of data. */ 1960 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec, 1961 irel->r_offset + 2, 2)) 1962 goto error_return; 1963 1964 /* That will change things, so, we should relax again. 1965 Note that this is not required, and it may be slow. */ 1966 *again = TRUE; 1967 } 1968 } 1969 1970 /* Try to turn a 32-bit IMM address into a 20/16-bit IMM address */ 1971 if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM32) 1972 { 1973 bfd_vma value = symval; 1974 unsigned short is_add_mov = 0; 1975 bfd_vma value1 = 0; 1976 1977 /* Get the existing value from the mcode */ 1978 value1 = ((bfd_get_32 (abfd, contents + irel->r_offset + 2) >> 16) 1979 |(((bfd_get_32 (abfd, contents + irel->r_offset + 2) & 0xffff) << 16))); 1980 1981 /* See if the value will fit in 20 bits. */ 1982 if ((long) (value + value1) < 0xfffff && (long) (value + value1) > 0) 1983 { 1984 unsigned short code; 1985 1986 /* Get the opcode. */ 1987 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset); 1988 1989 /* Verify it's a 'arithmetic ADDD or MOVD instruction'. 1990 For ADDD and MOVD only, convert to IMM32 -> IMM20. */ 1991 1992 if (((code & 0xfff0) == 0x0070) || ((code & 0xfff0) == 0x0020)) 1993 is_add_mov = 1; 1994 1995 if (is_add_mov) 1996 { 1997 /* Note that we've changed the relocs, section contents, 1998 etc. */ 1999 elf_section_data (sec)->relocs = internal_relocs; 2000 elf_section_data (sec)->this_hdr.contents = contents; 2001 symtab_hdr->contents = (unsigned char *) isymbuf; 2002 2003 /* Fix the opcode. */ 2004 if ((code & 0xfff0) == 0x0070) /* For movd. */ 2005 bfd_put_8 (abfd, 0x05, contents + irel->r_offset + 1); 2006 else /* code == 0x0020 for addd. */ 2007 bfd_put_8 (abfd, 0x04, contents + irel->r_offset + 1); 2008 2009 bfd_put_8 (abfd, (code & 0xf) << 4, contents + irel->r_offset); 2010 2011 /* If existing value is nagavive adjust approriately 2012 place the 16-20bits (ie 4 bit) in new opcode, 2013 as the 0xffffxxxx, the higher 2 byte values removed. */ 2014 if (value1 & 0x80000000) 2015 bfd_put_8 (abfd, (0x0f | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset); 2016 else 2017 bfd_put_8 (abfd, (((value1 >> 16)&0xf) | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset); 2018 2019 /* Fix the relocation's type. */ 2020 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 2021 R_CR16_IMM20); 2022 2023 /* Delete two bytes of data. */ 2024 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec, 2025 irel->r_offset + 2, 2)) 2026 goto error_return; 2027 2028 /* That will change things, so, we should relax again. 2029 Note that this is not required, and it may be slow. */ 2030 *again = TRUE; 2031 } 2032 } 2033 2034 /* See if the value will fit in 16 bits. */ 2035 if ((!is_add_mov) 2036 && ((long)(value + value1) < 0x7fff && (long)(value + value1) > 0)) 2037 { 2038 unsigned short code; 2039 2040 /* Get the opcode. */ 2041 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset); 2042 2043 /* Note that we've changed the relocs, section contents, etc. */ 2044 elf_section_data (sec)->relocs = internal_relocs; 2045 elf_section_data (sec)->this_hdr.contents = contents; 2046 symtab_hdr->contents = (unsigned char *) isymbuf; 2047 2048 /* Fix the opcode. */ 2049 if ((code & 0xf0) == 0x70) /* For movd. */ 2050 bfd_put_8 (abfd, 0x54, contents + irel->r_offset + 1); 2051 else if ((code & 0xf0) == 0x20) /* For addd. */ 2052 bfd_put_8 (abfd, 0x60, contents + irel->r_offset + 1); 2053 else if ((code & 0xf0) == 0x90) /* For cmpd. */ 2054 bfd_put_8 (abfd, 0x56, contents + irel->r_offset + 1); 2055 else 2056 continue; 2057 2058 bfd_put_8 (abfd, 0xb0 | (code & 0xf), contents + irel->r_offset); 2059 2060 /* If existing value is nagavive adjust approriately 2061 place the 12-16bits (ie 4 bit) in new opcode, 2062 as the 0xfffffxxx, the higher 2 byte values removed. */ 2063 if (value1 & 0x80000000) 2064 bfd_put_8 (abfd, (0x0f | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset); 2065 else 2066 bfd_put_16 (abfd, value1, contents + irel->r_offset + 2); 2067 2068 2069 /* Fix the relocation's type. */ 2070 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 2071 R_CR16_IMM16); 2072 2073 /* Delete two bytes of data. */ 2074 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec, 2075 irel->r_offset + 2, 2)) 2076 goto error_return; 2077 2078 /* That will change things, so, we should relax again. 2079 Note that this is not required, and it may be slow. */ 2080 *again = TRUE; 2081 } 2082 } 2083 2084 #if 0 2085 /* Try to turn a 16bit immediate address into a 4bit 2086 immediate address. */ 2087 if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM20) 2088 || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM16)) 2089 { 2090 bfd_vma value = symval; 2091 bfd_vma value1 = 0; 2092 2093 /* Get the existing value from the mcode */ 2094 value1 = ((bfd_get_16 (abfd, contents + irel->r_offset + 2) & 0xffff)); 2095 2096 if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM20) 2097 { 2098 value1 |= ((bfd_get_16 (abfd, contents + irel->r_offset + 1) & 0xf000) << 0x4); 2099 } 2100 2101 /* See if the value will fit in 4 bits. */ 2102 if ((((long) (value + value1)) < 0xf) 2103 && (((long) (value + value1)) > 0)) 2104 { 2105 unsigned short code; 2106 2107 /* Get the opcode. */ 2108 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset); 2109 2110 /* Note that we've changed the relocs, section contents, etc. */ 2111 elf_section_data (sec)->relocs = internal_relocs; 2112 elf_section_data (sec)->this_hdr.contents = contents; 2113 symtab_hdr->contents = (unsigned char *) isymbuf; 2114 2115 /* Fix the opcode. */ 2116 if (((code & 0x0f00) == 0x0400) || ((code & 0x0f00) == 0x0500)) 2117 { 2118 if ((code & 0x0f00) == 0x0400) /* For movd imm20. */ 2119 bfd_put_8 (abfd, 0x60, contents + irel->r_offset); 2120 else /* For addd imm20. */ 2121 bfd_put_8 (abfd, 0x54, contents + irel->r_offset); 2122 bfd_put_8 (abfd, (code & 0xf0) >> 4, contents + irel->r_offset + 1); 2123 } 2124 else 2125 { 2126 if ((code & 0xfff0) == 0x56b0) /* For cmpd imm16. */ 2127 bfd_put_8 (abfd, 0x56, contents + irel->r_offset); 2128 else if ((code & 0xfff0) == 0x54b0) /* For movd imm16. */ 2129 bfd_put_8 (abfd, 0x54, contents + irel->r_offset); 2130 else if ((code & 0xfff0) == 0x58b0) /* For movb imm16. */ 2131 bfd_put_8 (abfd, 0x58, contents + irel->r_offset); 2132 else if ((code & 0xfff0) == 0x5Ab0) /* For movw imm16. */ 2133 bfd_put_8 (abfd, 0x5A, contents + irel->r_offset); 2134 else if ((code & 0xfff0) == 0x60b0) /* For addd imm16. */ 2135 bfd_put_8 (abfd, 0x60, contents + irel->r_offset); 2136 else if ((code & 0xfff0) == 0x30b0) /* For addb imm16. */ 2137 bfd_put_8 (abfd, 0x30, contents + irel->r_offset); 2138 else if ((code & 0xfff0) == 0x2Cb0) /* For addub imm16. */ 2139 bfd_put_8 (abfd, 0x2C, contents + irel->r_offset); 2140 else if ((code & 0xfff0) == 0x32b0) /* For adduw imm16. */ 2141 bfd_put_8 (abfd, 0x32, contents + irel->r_offset); 2142 else if ((code & 0xfff0) == 0x38b0) /* For subb imm16. */ 2143 bfd_put_8 (abfd, 0x38, contents + irel->r_offset); 2144 else if ((code & 0xfff0) == 0x3Cb0) /* For subcb imm16. */ 2145 bfd_put_8 (abfd, 0x3C, contents + irel->r_offset); 2146 else if ((code & 0xfff0) == 0x3Fb0) /* For subcw imm16. */ 2147 bfd_put_8 (abfd, 0x3F, contents + irel->r_offset); 2148 else if ((code & 0xfff0) == 0x3Ab0) /* For subw imm16. */ 2149 bfd_put_8 (abfd, 0x3A, contents + irel->r_offset); 2150 else if ((code & 0xfff0) == 0x50b0) /* For cmpb imm16. */ 2151 bfd_put_8 (abfd, 0x50, contents + irel->r_offset); 2152 else if ((code & 0xfff0) == 0x52b0) /* For cmpw imm16. */ 2153 bfd_put_8 (abfd, 0x52, contents + irel->r_offset); 2154 else 2155 continue; 2156 2157 bfd_put_8 (abfd, (code & 0xf), contents + irel->r_offset + 1); 2158 } 2159 2160 /* Fix the relocation's type. */ 2161 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 2162 R_CR16_IMM4); 2163 2164 /* Delete two bytes of data. */ 2165 if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec, 2166 irel->r_offset + 2, 2)) 2167 goto error_return; 2168 2169 /* That will change things, so, we should relax again. 2170 Note that this is not required, and it may be slow. */ 2171 *again = TRUE; 2172 } 2173 } 2174 #endif 2175 } 2176 2177 if (isymbuf != NULL 2178 && symtab_hdr->contents != (unsigned char *) isymbuf) 2179 { 2180 if (! link_info->keep_memory) 2181 free (isymbuf); 2182 else 2183 /* Cache the symbols for elf_link_input_bfd. */ 2184 symtab_hdr->contents = (unsigned char *) isymbuf; 2185 } 2186 2187 if (contents != NULL 2188 && elf_section_data (sec)->this_hdr.contents != contents) 2189 { 2190 if (! link_info->keep_memory) 2191 free (contents); 2192 else 2193 /* Cache the section contents for elf_link_input_bfd. */ 2194 elf_section_data (sec)->this_hdr.contents = contents; 2195 2196 } 2197 2198 if (internal_relocs != NULL 2199 && elf_section_data (sec)->relocs != internal_relocs) 2200 free (internal_relocs); 2201 2202 return TRUE; 2203 2204 error_return: 2205 if (isymbuf != NULL 2206 && symtab_hdr->contents != (unsigned char *) isymbuf) 2207 free (isymbuf); 2208 if (contents != NULL 2209 && elf_section_data (sec)->this_hdr.contents != contents) 2210 free (contents); 2211 if (internal_relocs != NULL 2212 && elf_section_data (sec)->relocs != internal_relocs) 2213 free (internal_relocs); 2214 2215 return FALSE; 2216 } 2217 2218 static asection * 2219 elf32_cr16_gc_mark_hook (asection *sec, 2220 struct bfd_link_info *info, 2221 Elf_Internal_Rela *rel, 2222 struct elf_link_hash_entry *h, 2223 Elf_Internal_Sym *sym) 2224 { 2225 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 2226 } 2227 2228 /* Update the got entry reference counts for the section being removed. */ 2229 2230 static bfd_boolean 2231 elf32_cr16_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED, 2232 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2233 asection *sec ATTRIBUTE_UNUSED, 2234 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED) 2235 { 2236 /* We don't support garbage collection of GOT and PLT relocs yet. */ 2237 return TRUE; 2238 } 2239 2240 /* Create dynamic sections when linking against a dynamic object. */ 2241 2242 static bfd_boolean 2243 _bfd_cr16_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 2244 { 2245 flagword flags; 2246 asection * s; 2247 const struct elf_backend_data * bed = get_elf_backend_data (abfd); 2248 int ptralign = 0; 2249 2250 switch (bed->s->arch_size) 2251 { 2252 case 16: 2253 ptralign = 1; 2254 break; 2255 2256 case 32: 2257 ptralign = 2; 2258 break; 2259 2260 default: 2261 bfd_set_error (bfd_error_bad_value); 2262 return FALSE; 2263 } 2264 2265 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 2266 .rel[a].bss sections. */ 2267 2268 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2269 | SEC_LINKER_CREATED); 2270 2271 s = bfd_make_section_anyway_with_flags (abfd, 2272 (bed->default_use_rela_p 2273 ? ".rela.plt" : ".rel.plt"), 2274 flags | SEC_READONLY); 2275 if (s == NULL 2276 || ! bfd_set_section_alignment (abfd, s, ptralign)) 2277 return FALSE; 2278 2279 if (! _bfd_cr16_elf_create_got_section (abfd, info)) 2280 return FALSE; 2281 2282 if (bed->want_dynbss) 2283 { 2284 /* The .dynbss section is a place to put symbols which are defined 2285 by dynamic objects, are referenced by regular objects, and are 2286 not functions. We must allocate space for them in the process 2287 image and use a R_*_COPY reloc to tell the dynamic linker to 2288 initialize them at run time. The linker script puts the .dynbss 2289 section into the .bss section of the final image. */ 2290 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss", 2291 SEC_ALLOC | SEC_LINKER_CREATED); 2292 if (s == NULL) 2293 return FALSE; 2294 2295 /* The .rel[a].bss section holds copy relocs. This section is not 2296 normally needed. We need to create it here, though, so that the 2297 linker will map it to an output section. We can't just create it 2298 only if we need it, because we will not know whether we need it 2299 until we have seen all the input files, and the first time the 2300 main linker code calls BFD after examining all the input files 2301 (size_dynamic_sections) the input sections have already been 2302 mapped to the output sections. If the section turns out not to 2303 be needed, we can discard it later. We will never need this 2304 section when generating a shared object, since they do not use 2305 copy relocs. */ 2306 if (! bfd_link_executable (info)) 2307 { 2308 s = bfd_make_section_anyway_with_flags (abfd, 2309 (bed->default_use_rela_p 2310 ? ".rela.bss" : ".rel.bss"), 2311 flags | SEC_READONLY); 2312 if (s == NULL 2313 || ! bfd_set_section_alignment (abfd, s, ptralign)) 2314 return FALSE; 2315 } 2316 } 2317 2318 return TRUE; 2319 } 2320 2321 /* Adjust a symbol defined by a dynamic object and referenced by a 2323 regular object. The current definition is in some section of the 2324 dynamic object, but we're not including those sections. We have to 2325 change the definition to something the rest of the link can 2326 understand. */ 2327 2328 static bfd_boolean 2329 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info * info, 2330 struct elf_link_hash_entry * h) 2331 { 2332 bfd * dynobj; 2333 asection * s; 2334 2335 dynobj = elf_hash_table (info)->dynobj; 2336 2337 /* Make sure we know what is going on here. */ 2338 BFD_ASSERT (dynobj != NULL 2339 && (h->needs_plt 2340 || h->u.weakdef != NULL 2341 || (h->def_dynamic 2342 && h->ref_regular 2343 && !h->def_regular))); 2344 2345 /* If this is a function, put it in the procedure linkage table. We 2346 will fill in the contents of the procedure linkage table later, 2347 when we know the address of the .got section. */ 2348 if (h->type == STT_FUNC 2349 || h->needs_plt) 2350 { 2351 if (! bfd_link_executable (info) 2352 && !h->def_dynamic 2353 && !h->ref_dynamic) 2354 { 2355 /* This case can occur if we saw a PLT reloc in an input 2356 file, but the symbol was never referred to by a dynamic 2357 object. In such a case, we don't actually need to build 2358 a procedure linkage table, and we can just do a REL32 2359 reloc instead. */ 2360 BFD_ASSERT (h->needs_plt); 2361 return TRUE; 2362 } 2363 2364 /* Make sure this symbol is output as a dynamic symbol. */ 2365 if (h->dynindx == -1) 2366 { 2367 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2368 return FALSE; 2369 } 2370 2371 /* We also need to make an entry in the .got.plt section, which 2372 will be placed in the .got section by the linker script. */ 2373 2374 s = bfd_get_linker_section (dynobj, ".got.plt"); 2375 BFD_ASSERT (s != NULL); 2376 s->size += 4; 2377 2378 /* We also need to make an entry in the .rela.plt section. */ 2379 2380 s = bfd_get_linker_section (dynobj, ".rela.plt"); 2381 BFD_ASSERT (s != NULL); 2382 s->size += sizeof (Elf32_External_Rela); 2383 2384 return TRUE; 2385 } 2386 2387 /* If this is a weak symbol, and there is a real definition, the 2388 processor independent code will have arranged for us to see the 2389 real definition first, and we can just use the same value. */ 2390 if (h->u.weakdef != NULL) 2391 { 2392 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 2393 || h->u.weakdef->root.type == bfd_link_hash_defweak); 2394 h->root.u.def.section = h->u.weakdef->root.u.def.section; 2395 h->root.u.def.value = h->u.weakdef->root.u.def.value; 2396 return TRUE; 2397 } 2398 2399 /* This is a reference to a symbol defined by a dynamic object which 2400 is not a function. */ 2401 2402 /* If we are creating a shared library, we must presume that the 2403 only references to the symbol are via the global offset table. 2404 For such cases we need not do anything here; the relocations will 2405 be handled correctly by relocate_section. */ 2406 if (bfd_link_executable (info)) 2407 return TRUE; 2408 2409 /* If there are no references to this symbol that do not use the 2410 GOT, we don't need to generate a copy reloc. */ 2411 if (!h->non_got_ref) 2412 return TRUE; 2413 2414 /* We must allocate the symbol in our .dynbss section, which will 2415 become part of the .bss section of the executable. There will be 2416 an entry for this symbol in the .dynsym section. The dynamic 2417 object will contain position independent code, so all references 2418 from the dynamic object to this symbol will go through the global 2419 offset table. The dynamic linker will use the .dynsym entry to 2420 determine the address it must put in the global offset table, so 2421 both the dynamic object and the regular object will refer to the 2422 same memory location for the variable. */ 2423 2424 s = bfd_get_linker_section (dynobj, ".dynbss"); 2425 BFD_ASSERT (s != NULL); 2426 2427 /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to 2428 copy the initial value out of the dynamic object and into the 2429 runtime process image. We need to remember the offset into the 2430 .rela.bss section we are going to use. */ 2431 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 2432 { 2433 asection * srel; 2434 2435 srel = bfd_get_linker_section (dynobj, ".rela.bss"); 2436 BFD_ASSERT (srel != NULL); 2437 srel->size += sizeof (Elf32_External_Rela); 2438 h->needs_copy = 1; 2439 } 2440 2441 return _bfd_elf_adjust_dynamic_copy (info, h, s); 2442 } 2443 2444 /* Set the sizes of the dynamic sections. */ 2445 2446 static bfd_boolean 2447 _bfd_cr16_elf_size_dynamic_sections (bfd * output_bfd, 2448 struct bfd_link_info * info) 2449 { 2450 bfd * dynobj; 2451 asection * s; 2452 bfd_boolean plt; 2453 bfd_boolean relocs; 2454 bfd_boolean reltext; 2455 2456 dynobj = elf_hash_table (info)->dynobj; 2457 BFD_ASSERT (dynobj != NULL); 2458 2459 if (elf_hash_table (info)->dynamic_sections_created) 2460 { 2461 /* Set the contents of the .interp section to the interpreter. */ 2462 if (bfd_link_executable (info) && !info->nointerp) 2463 { 2464 #if 0 2465 s = bfd_get_linker_section (dynobj, ".interp"); 2466 BFD_ASSERT (s != NULL); 2467 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 2468 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 2469 #endif 2470 } 2471 } 2472 else 2473 { 2474 /* We may have created entries in the .rela.got section. 2475 However, if we are not creating the dynamic sections, we will 2476 not actually use these entries. Reset the size of .rela.got, 2477 which will cause it to get stripped from the output file 2478 below. */ 2479 s = bfd_get_linker_section (dynobj, ".rela.got"); 2480 if (s != NULL) 2481 s->size = 0; 2482 } 2483 2484 /* The check_relocs and adjust_dynamic_symbol entry points have 2485 determined the sizes of the various dynamic sections. Allocate 2486 memory for them. */ 2487 plt = FALSE; 2488 relocs = FALSE; 2489 reltext = FALSE; 2490 for (s = dynobj->sections; s != NULL; s = s->next) 2491 { 2492 const char * name; 2493 2494 if ((s->flags & SEC_LINKER_CREATED) == 0) 2495 continue; 2496 2497 /* It's OK to base decisions on the section name, because none 2498 of the dynobj section names depend upon the input files. */ 2499 name = bfd_get_section_name (dynobj, s); 2500 2501 if (strcmp (name, ".plt") == 0) 2502 { 2503 /* Remember whether there is a PLT. */ 2504 plt = s->size != 0; 2505 } 2506 else if (CONST_STRNEQ (name, ".rela")) 2507 { 2508 if (s->size != 0) 2509 { 2510 asection * target; 2511 2512 /* Remember whether there are any reloc sections other 2513 than .rela.plt. */ 2514 if (strcmp (name, ".rela.plt") != 0) 2515 { 2516 const char * outname; 2517 2518 relocs = TRUE; 2519 2520 /* If this relocation section applies to a read only 2521 section, then we probably need a DT_TEXTREL 2522 entry. The entries in the .rela.plt section 2523 really apply to the .got section, which we 2524 created ourselves and so know is not readonly. */ 2525 outname = bfd_get_section_name (output_bfd, 2526 s->output_section); 2527 target = bfd_get_section_by_name (output_bfd, outname + 5); 2528 if (target != NULL 2529 && (target->flags & SEC_READONLY) != 0 2530 && (target->flags & SEC_ALLOC) != 0) 2531 reltext = TRUE; 2532 } 2533 2534 /* We use the reloc_count field as a counter if we need 2535 to copy relocs into the output file. */ 2536 s->reloc_count = 0; 2537 } 2538 } 2539 else if (! CONST_STRNEQ (name, ".got") 2540 && strcmp (name, ".dynbss") != 0) 2541 /* It's not one of our sections, so don't allocate space. */ 2542 continue; 2543 2544 if (s->size == 0) 2545 { 2546 /* If we don't need this section, strip it from the 2547 output file. This is mostly to handle .rela.bss and 2548 .rela.plt. We must create both sections in 2549 create_dynamic_sections, because they must be created 2550 before the linker maps input sections to output 2551 sections. The linker does that before 2552 adjust_dynamic_symbol is called, and it is that 2553 function which decides whether anything needs to go 2554 into these sections. */ 2555 s->flags |= SEC_EXCLUDE; 2556 continue; 2557 } 2558 2559 if ((s->flags & SEC_HAS_CONTENTS) == 0) 2560 continue; 2561 2562 /* Allocate memory for the section contents. We use bfd_zalloc 2563 here in case unused entries are not reclaimed before the 2564 section's contents are written out. This should not happen, 2565 but this way if it does, we get a R_CR16_NONE reloc 2566 instead of garbage. */ 2567 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 2568 if (s->contents == NULL) 2569 return FALSE; 2570 } 2571 2572 if (elf_hash_table (info)->dynamic_sections_created) 2573 { 2574 /* Add some entries to the .dynamic section. We fill in the 2575 values later, in _bfd_cr16_elf_finish_dynamic_sections, 2576 but we must add the entries now so that we get the correct 2577 size for the .dynamic section. The DT_DEBUG entry is filled 2578 in by the dynamic linker and used by the debugger. */ 2579 if (! bfd_link_executable (info)) 2580 { 2581 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0)) 2582 return FALSE; 2583 } 2584 2585 if (plt) 2586 { 2587 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0) 2588 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0) 2589 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA) 2590 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0)) 2591 return FALSE; 2592 } 2593 2594 if (relocs) 2595 { 2596 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0) 2597 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0) 2598 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT, 2599 sizeof (Elf32_External_Rela))) 2600 return FALSE; 2601 } 2602 2603 if (reltext) 2604 { 2605 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0)) 2606 return FALSE; 2607 } 2608 } 2609 2610 return TRUE; 2611 } 2612 2613 /* Finish up dynamic symbol handling. We set the contents of various 2614 dynamic sections here. */ 2615 2616 static bfd_boolean 2617 _bfd_cr16_elf_finish_dynamic_symbol (bfd * output_bfd, 2618 struct bfd_link_info * info, 2619 struct elf_link_hash_entry * h, 2620 Elf_Internal_Sym * sym) 2621 { 2622 bfd * dynobj; 2623 2624 dynobj = elf_hash_table (info)->dynobj; 2625 2626 if (h->got.offset != (bfd_vma) -1) 2627 { 2628 asection * sgot; 2629 asection * srel; 2630 Elf_Internal_Rela rel; 2631 2632 /* This symbol has an entry in the global offset table. Set it up. */ 2633 2634 sgot = bfd_get_linker_section (dynobj, ".got"); 2635 srel = bfd_get_linker_section (dynobj, ".rela.got"); 2636 BFD_ASSERT (sgot != NULL && srel != NULL); 2637 2638 rel.r_offset = (sgot->output_section->vma 2639 + sgot->output_offset 2640 + (h->got.offset & ~1)); 2641 2642 /* If this is a -Bsymbolic link, and the symbol is defined 2643 locally, we just want to emit a RELATIVE reloc. Likewise if 2644 the symbol was forced to be local because of a version file. 2645 The entry in the global offset table will already have been 2646 initialized in the relocate_section function. */ 2647 if (bfd_link_executable (info) 2648 && (info->symbolic || h->dynindx == -1) 2649 && h->def_regular) 2650 { 2651 rel.r_info = ELF32_R_INFO (0, R_CR16_GOT_REGREL20); 2652 rel.r_addend = (h->root.u.def.value 2653 + h->root.u.def.section->output_section->vma 2654 + h->root.u.def.section->output_offset); 2655 } 2656 else 2657 { 2658 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 2659 rel.r_info = ELF32_R_INFO (h->dynindx, R_CR16_GOT_REGREL20); 2660 rel.r_addend = 0; 2661 } 2662 2663 bfd_elf32_swap_reloca_out (output_bfd, &rel, 2664 (bfd_byte *) ((Elf32_External_Rela *) srel->contents 2665 + srel->reloc_count)); 2666 ++ srel->reloc_count; 2667 } 2668 2669 if (h->needs_copy) 2670 { 2671 asection * s; 2672 Elf_Internal_Rela rel; 2673 2674 /* This symbol needs a copy reloc. Set it up. */ 2675 BFD_ASSERT (h->dynindx != -1 2676 && (h->root.type == bfd_link_hash_defined 2677 || h->root.type == bfd_link_hash_defweak)); 2678 2679 s = bfd_get_linker_section (dynobj, ".rela.bss"); 2680 BFD_ASSERT (s != NULL); 2681 2682 rel.r_offset = (h->root.u.def.value 2683 + h->root.u.def.section->output_section->vma 2684 + h->root.u.def.section->output_offset); 2685 rel.r_info = ELF32_R_INFO (h->dynindx, R_CR16_GOT_REGREL20); 2686 rel.r_addend = 0; 2687 bfd_elf32_swap_reloca_out (output_bfd, &rel, 2688 (bfd_byte *) ((Elf32_External_Rela *) s->contents 2689 + s->reloc_count)); 2690 ++ s->reloc_count; 2691 } 2692 2693 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 2694 if (h == elf_hash_table (info)->hdynamic 2695 || h == elf_hash_table (info)->hgot) 2696 sym->st_shndx = SHN_ABS; 2697 2698 return TRUE; 2699 } 2700 2701 /* Finish up the dynamic sections. */ 2702 2703 static bfd_boolean 2704 _bfd_cr16_elf_finish_dynamic_sections (bfd * output_bfd, 2705 struct bfd_link_info * info) 2706 { 2707 bfd * dynobj; 2708 asection * sgot; 2709 asection * sdyn; 2710 2711 dynobj = elf_hash_table (info)->dynobj; 2712 2713 sgot = bfd_get_linker_section (dynobj, ".got.plt"); 2714 BFD_ASSERT (sgot != NULL); 2715 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 2716 2717 if (elf_hash_table (info)->dynamic_sections_created) 2718 { 2719 Elf32_External_Dyn * dyncon; 2720 Elf32_External_Dyn * dynconend; 2721 2722 BFD_ASSERT (sdyn != NULL); 2723 2724 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2725 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 2726 2727 for (; dyncon < dynconend; dyncon++) 2728 { 2729 Elf_Internal_Dyn dyn; 2730 const char * name; 2731 asection * s; 2732 2733 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 2734 2735 switch (dyn.d_tag) 2736 { 2737 default: 2738 break; 2739 2740 case DT_PLTGOT: 2741 name = ".got.plt"; 2742 goto get_vma; 2743 2744 case DT_JMPREL: 2745 name = ".rela.plt"; 2746 get_vma: 2747 s = bfd_get_linker_section (dynobj, name); 2748 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2749 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2750 break; 2751 2752 case DT_PLTRELSZ: 2753 s = bfd_get_linker_section (dynobj, ".rela.plt"); 2754 dyn.d_un.d_val = s->size; 2755 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2756 break; 2757 2758 case DT_RELASZ: 2759 /* My reading of the SVR4 ABI indicates that the 2760 procedure linkage table relocs (DT_JMPREL) should be 2761 included in the overall relocs (DT_RELA). This is 2762 what Solaris does. However, UnixWare can not handle 2763 that case. Therefore, we override the DT_RELASZ entry 2764 here to make it not include the JMPREL relocs. Since 2765 the linker script arranges for .rela.plt to follow all 2766 other relocation sections, we don't have to worry 2767 about changing the DT_RELA entry. */ 2768 s = bfd_get_linker_section (dynobj, ".rela.plt"); 2769 if (s != NULL) 2770 dyn.d_un.d_val -= s->size; 2771 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2772 break; 2773 } 2774 } 2775 2776 } 2777 2778 /* Fill in the first three entries in the global offset table. */ 2779 if (sgot->size > 0) 2780 { 2781 if (sdyn == NULL) 2782 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 2783 else 2784 bfd_put_32 (output_bfd, 2785 sdyn->output_section->vma + sdyn->output_offset, 2786 sgot->contents); 2787 } 2788 2789 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 2790 2791 return TRUE; 2792 } 2793 2794 /* Given a .data.rel section and a .emreloc in-memory section, store 2795 relocation information into the .emreloc section which can be 2796 used at runtime to relocate the section. This is called by the 2797 linker when the --embedded-relocs switch is used. This is called 2798 after the add_symbols entry point has been called for all the 2799 objects, and before the final_link entry point is called. */ 2800 2801 bfd_boolean 2802 bfd_cr16_elf32_create_embedded_relocs (bfd *abfd, 2803 struct bfd_link_info *info, 2804 asection *datasec, 2805 asection *relsec, 2806 char **errmsg) 2807 { 2808 Elf_Internal_Shdr *symtab_hdr; 2809 Elf_Internal_Sym *isymbuf = NULL; 2810 Elf_Internal_Rela *internal_relocs = NULL; 2811 Elf_Internal_Rela *irel, *irelend; 2812 bfd_byte *p; 2813 bfd_size_type amt; 2814 2815 BFD_ASSERT (! bfd_link_relocatable (info)); 2816 2817 *errmsg = NULL; 2818 2819 if (datasec->reloc_count == 0) 2820 return TRUE; 2821 2822 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2823 2824 /* Get a copy of the native relocations. */ 2825 internal_relocs = (_bfd_elf_link_read_relocs 2826 (abfd, datasec, NULL, NULL, info->keep_memory)); 2827 if (internal_relocs == NULL) 2828 goto error_return; 2829 2830 amt = (bfd_size_type) datasec->reloc_count * 8; 2831 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt); 2832 if (relsec->contents == NULL) 2833 goto error_return; 2834 2835 p = relsec->contents; 2836 2837 irelend = internal_relocs + datasec->reloc_count; 2838 for (irel = internal_relocs; irel < irelend; irel++, p += 8) 2839 { 2840 asection *targetsec; 2841 2842 /* We are going to write a four byte longword into the runtime 2843 reloc section. The longword will be the address in the data 2844 section which must be relocated. It is followed by the name 2845 of the target section NUL-padded or truncated to 8 2846 characters. */ 2847 2848 /* We can only relocate absolute longword relocs at run time. */ 2849 if (!((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a) 2850 || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32))) 2851 { 2852 *errmsg = _("unsupported reloc type"); 2853 bfd_set_error (bfd_error_bad_value); 2854 goto error_return; 2855 } 2856 2857 /* Get the target section referred to by the reloc. */ 2858 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 2859 { 2860 /* A local symbol. */ 2861 Elf_Internal_Sym *isym; 2862 2863 /* Read this BFD's local symbols if we haven't done so already. */ 2864 if (isymbuf == NULL) 2865 { 2866 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 2867 if (isymbuf == NULL) 2868 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 2869 symtab_hdr->sh_info, 0, 2870 NULL, NULL, NULL); 2871 if (isymbuf == NULL) 2872 goto error_return; 2873 } 2874 2875 isym = isymbuf + ELF32_R_SYM (irel->r_info); 2876 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx); 2877 } 2878 else 2879 { 2880 unsigned long indx; 2881 struct elf_link_hash_entry *h; 2882 2883 /* An external symbol. */ 2884 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 2885 h = elf_sym_hashes (abfd)[indx]; 2886 BFD_ASSERT (h != NULL); 2887 if (h->root.type == bfd_link_hash_defined 2888 || h->root.type == bfd_link_hash_defweak) 2889 targetsec = h->root.u.def.section; 2890 else 2891 targetsec = NULL; 2892 } 2893 2894 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p); 2895 memset (p + 4, 0, 4); 2896 if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a) 2897 && (targetsec != NULL) ) 2898 strncpy ((char *) p + 4, targetsec->output_section->name, 4); 2899 } 2900 2901 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 2902 free (isymbuf); 2903 if (internal_relocs != NULL 2904 && elf_section_data (datasec)->relocs != internal_relocs) 2905 free (internal_relocs); 2906 return TRUE; 2907 2908 error_return: 2909 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 2910 free (isymbuf); 2911 if (internal_relocs != NULL 2912 && elf_section_data (datasec)->relocs != internal_relocs) 2913 free (internal_relocs); 2914 return FALSE; 2915 } 2916 2917 2918 /* Classify relocation types, such that combreloc can sort them 2919 properly. */ 2920 2921 static enum elf_reloc_type_class 2922 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 2923 const asection *rel_sec ATTRIBUTE_UNUSED, 2924 const Elf_Internal_Rela *rela) 2925 { 2926 switch ((int) ELF32_R_TYPE (rela->r_info)) 2927 { 2928 case R_CR16_GOT_REGREL20: 2929 case R_CR16_GOTC_REGREL20: 2930 return reloc_class_relative; 2931 default: 2932 return reloc_class_normal; 2933 } 2934 } 2935 2936 /* Definitions for setting CR16 target vector. */ 2937 #define TARGET_LITTLE_SYM cr16_elf32_vec 2938 #define TARGET_LITTLE_NAME "elf32-cr16" 2939 #define ELF_ARCH bfd_arch_cr16 2940 #define ELF_MACHINE_CODE EM_CR16 2941 #define ELF_MACHINE_ALT1 EM_CR16_OLD 2942 #define ELF_MAXPAGESIZE 0x1 2943 #define elf_symbol_leading_char '_' 2944 2945 #define bfd_elf32_bfd_reloc_type_lookup elf_cr16_reloc_type_lookup 2946 #define bfd_elf32_bfd_reloc_name_lookup elf_cr16_reloc_name_lookup 2947 #define elf_info_to_howto elf_cr16_info_to_howto 2948 #define elf_info_to_howto_rel 0 2949 #define elf_backend_relocate_section elf32_cr16_relocate_section 2950 #define bfd_elf32_bfd_relax_section elf32_cr16_relax_section 2951 #define bfd_elf32_bfd_get_relocated_section_contents \ 2952 elf32_cr16_get_relocated_section_contents 2953 #define elf_backend_gc_mark_hook elf32_cr16_gc_mark_hook 2954 #define elf_backend_gc_sweep_hook elf32_cr16_gc_sweep_hook 2955 #define elf_backend_can_gc_sections 1 2956 #define elf_backend_rela_normal 1 2957 #define elf_backend_check_relocs cr16_elf_check_relocs 2958 /* So we can set bits in e_flags. */ 2959 #define elf_backend_final_write_processing \ 2960 _bfd_cr16_elf_final_write_processing 2961 #define elf_backend_object_p _bfd_cr16_elf_object_p 2962 2963 #define bfd_elf32_bfd_merge_private_bfd_data \ 2964 _bfd_cr16_elf_merge_private_bfd_data 2965 2966 2967 #define bfd_elf32_bfd_link_hash_table_create \ 2968 elf32_cr16_link_hash_table_create 2969 2970 #define elf_backend_create_dynamic_sections \ 2971 _bfd_cr16_elf_create_dynamic_sections 2972 #define elf_backend_adjust_dynamic_symbol \ 2973 _bfd_cr16_elf_adjust_dynamic_symbol 2974 #define elf_backend_size_dynamic_sections \ 2975 _bfd_cr16_elf_size_dynamic_sections 2976 #define elf_backend_omit_section_dynsym \ 2977 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) 2978 #define elf_backend_finish_dynamic_symbol \ 2979 _bfd_cr16_elf_finish_dynamic_symbol 2980 #define elf_backend_finish_dynamic_sections \ 2981 _bfd_cr16_elf_finish_dynamic_sections 2982 2983 #define elf_backend_reloc_type_class _bfd_cr16_elf_reloc_type_class 2984 2985 2986 #define elf_backend_want_got_plt 1 2987 #define elf_backend_plt_readonly 1 2988 #define elf_backend_want_plt_sym 0 2989 #define elf_backend_got_header_size 12 2990 2991 #include "elf32-target.h" 2992
