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