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