1 /* V850-specific support for 32-bit ELF 2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 3 Free Software Foundation, Inc. 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 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21 /* XXX FIXME: This code is littered with 32bit int, 16bit short, 8bit char 22 dependencies. As is the gas & simulator code for the v850. */ 23 24 #include "bfd.h" 25 #include "sysdep.h" 26 #include "bfdlink.h" 27 #include "libbfd.h" 28 #include "elf-bfd.h" 29 #include "elf/v850.h" 30 #include "libiberty.h" 31 32 /* Sign-extend a 24-bit number. */ 33 #define SEXT24(x) ((((x) & 0xffffff) ^ 0x800000) - 0x800000) 34 35 static reloc_howto_type *v850_elf_reloc_type_lookup 36 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); 37 static void v850_elf_info_to_howto_rel 38 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 39 static void v850_elf_info_to_howto_rela 40 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 41 static bfd_reloc_status_type v850_elf_reloc 42 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 43 static bfd_boolean v850_elf_is_local_label_name 44 PARAMS ((bfd *, const char *)); 45 static bfd_boolean v850_elf_relocate_section 46 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 47 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 48 static bfd_reloc_status_type v850_elf_perform_relocation 49 PARAMS ((bfd *, unsigned int, bfd_vma, bfd_byte *)); 50 static bfd_boolean v850_elf_check_relocs 51 PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *)); 52 static void remember_hi16s_reloc 53 PARAMS ((bfd *, bfd_vma, bfd_byte *)); 54 static bfd_byte * find_remembered_hi16s_reloc 55 PARAMS ((bfd_vma, bfd_boolean *)); 56 static bfd_reloc_status_type v850_elf_final_link_relocate 57 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *, bfd_vma, 58 bfd_vma, bfd_vma, struct bfd_link_info *, asection *, int)); 59 static bfd_boolean v850_elf_object_p 60 PARAMS ((bfd *)); 61 static bfd_boolean v850_elf_fake_sections 62 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *)); 63 static void v850_elf_final_write_processing 64 PARAMS ((bfd *, bfd_boolean)); 65 static bfd_boolean v850_elf_set_private_flags 66 PARAMS ((bfd *, flagword)); 67 static bfd_boolean v850_elf_merge_private_bfd_data 68 PARAMS ((bfd *, bfd *)); 69 static bfd_boolean v850_elf_print_private_bfd_data 70 PARAMS ((bfd *, PTR)); 71 static bfd_boolean v850_elf_section_from_bfd_section 72 PARAMS ((bfd *, asection *, int *)); 73 static void v850_elf_symbol_processing 74 PARAMS ((bfd *, asymbol *)); 75 static bfd_boolean v850_elf_add_symbol_hook 76 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Sym *, 77 const char **, flagword *, asection **, bfd_vma *)); 78 static bfd_boolean v850_elf_link_output_symbol_hook 79 PARAMS ((struct bfd_link_info *, const char *, Elf_Internal_Sym *, 80 asection *, struct elf_link_hash_entry *)); 81 static bfd_boolean v850_elf_section_from_shdr 82 PARAMS ((bfd *, Elf_Internal_Shdr *, const char *)); 83 static bfd_boolean v850_elf_gc_sweep_hook 84 PARAMS ((bfd *, struct bfd_link_info *, asection *, 85 const Elf_Internal_Rela *)); 86 static asection * v850_elf_gc_mark_hook 87 PARAMS ((asection *, struct bfd_link_info *, 88 Elf_Internal_Rela *, struct elf_link_hash_entry *, 89 Elf_Internal_Sym *)); 90 static bfd_reloc_status_type v850_elf_ignore_reloc 91 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 92 static bfd_boolean v850_elf_relax_delete_bytes 93 PARAMS ((bfd *, asection *, bfd_vma, bfd_vma, int)); 94 static bfd_boolean v850_elf_relax_section 95 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *)); 96 97 /* Note: It is REQUIRED that the 'type' value of each entry 98 in this array match the index of the entry in the array. */ 99 static reloc_howto_type v850_elf_howto_table[] = 100 { 101 /* This reloc does nothing. */ 102 HOWTO (R_V850_NONE, /* type */ 103 0, /* rightshift */ 104 2, /* size (0 = byte, 1 = short, 2 = long) */ 105 32, /* bitsize */ 106 FALSE, /* pc_relative */ 107 0, /* bitpos */ 108 complain_overflow_bitfield, /* complain_on_overflow */ 109 bfd_elf_generic_reloc, /* special_function */ 110 "R_V850_NONE", /* name */ 111 FALSE, /* partial_inplace */ 112 0, /* src_mask */ 113 0, /* dst_mask */ 114 FALSE), /* pcrel_offset */ 115 116 /* A PC relative 9 bit branch. */ 117 HOWTO (R_V850_9_PCREL, /* type */ 118 2, /* rightshift */ 119 2, /* size (0 = byte, 1 = short, 2 = long) */ 120 26, /* bitsize */ 121 TRUE, /* pc_relative */ 122 0, /* bitpos */ 123 complain_overflow_bitfield, /* complain_on_overflow */ 124 v850_elf_reloc, /* special_function */ 125 "R_V850_9_PCREL", /* name */ 126 FALSE, /* partial_inplace */ 127 0x00ffffff, /* src_mask */ 128 0x00ffffff, /* dst_mask */ 129 TRUE), /* pcrel_offset */ 130 131 /* A PC relative 22 bit branch. */ 132 HOWTO (R_V850_22_PCREL, /* type */ 133 2, /* rightshift */ 134 2, /* size (0 = byte, 1 = short, 2 = long) */ 135 22, /* bitsize */ 136 TRUE, /* pc_relative */ 137 7, /* bitpos */ 138 complain_overflow_signed, /* complain_on_overflow */ 139 v850_elf_reloc, /* special_function */ 140 "R_V850_22_PCREL", /* name */ 141 FALSE, /* partial_inplace */ 142 0x07ffff80, /* src_mask */ 143 0x07ffff80, /* dst_mask */ 144 TRUE), /* pcrel_offset */ 145 146 /* High 16 bits of symbol value. */ 147 HOWTO (R_V850_HI16_S, /* type */ 148 0, /* rightshift */ 149 1, /* size (0 = byte, 1 = short, 2 = long) */ 150 16, /* bitsize */ 151 FALSE, /* pc_relative */ 152 0, /* bitpos */ 153 complain_overflow_dont, /* complain_on_overflow */ 154 v850_elf_reloc, /* special_function */ 155 "R_V850_HI16_S", /* name */ 156 FALSE, /* partial_inplace */ 157 0xffff, /* src_mask */ 158 0xffff, /* dst_mask */ 159 FALSE), /* pcrel_offset */ 160 161 /* High 16 bits of symbol value. */ 162 HOWTO (R_V850_HI16, /* type */ 163 0, /* rightshift */ 164 1, /* size (0 = byte, 1 = short, 2 = long) */ 165 16, /* bitsize */ 166 FALSE, /* pc_relative */ 167 0, /* bitpos */ 168 complain_overflow_dont, /* complain_on_overflow */ 169 v850_elf_reloc, /* special_function */ 170 "R_V850_HI16", /* name */ 171 FALSE, /* partial_inplace */ 172 0xffff, /* src_mask */ 173 0xffff, /* dst_mask */ 174 FALSE), /* pcrel_offset */ 175 176 /* Low 16 bits of symbol value. */ 177 HOWTO (R_V850_LO16, /* type */ 178 0, /* rightshift */ 179 1, /* size (0 = byte, 1 = short, 2 = long) */ 180 16, /* bitsize */ 181 FALSE, /* pc_relative */ 182 0, /* bitpos */ 183 complain_overflow_dont, /* complain_on_overflow */ 184 v850_elf_reloc, /* special_function */ 185 "R_V850_LO16", /* name */ 186 FALSE, /* partial_inplace */ 187 0xffff, /* src_mask */ 188 0xffff, /* dst_mask */ 189 FALSE), /* pcrel_offset */ 190 191 /* Simple 32bit reloc. */ 192 HOWTO (R_V850_ABS32, /* type */ 193 0, /* rightshift */ 194 2, /* size (0 = byte, 1 = short, 2 = long) */ 195 32, /* bitsize */ 196 FALSE, /* pc_relative */ 197 0, /* bitpos */ 198 complain_overflow_dont, /* complain_on_overflow */ 199 v850_elf_reloc, /* special_function */ 200 "R_V850_ABS32", /* name */ 201 FALSE, /* partial_inplace */ 202 0xffffffff, /* src_mask */ 203 0xffffffff, /* dst_mask */ 204 FALSE), /* pcrel_offset */ 205 206 /* Simple 16bit reloc. */ 207 HOWTO (R_V850_16, /* type */ 208 0, /* rightshift */ 209 1, /* size (0 = byte, 1 = short, 2 = long) */ 210 16, /* bitsize */ 211 FALSE, /* pc_relative */ 212 0, /* bitpos */ 213 complain_overflow_dont, /* complain_on_overflow */ 214 bfd_elf_generic_reloc, /* special_function */ 215 "R_V850_16", /* name */ 216 FALSE, /* partial_inplace */ 217 0xffff, /* src_mask */ 218 0xffff, /* dst_mask */ 219 FALSE), /* pcrel_offset */ 220 221 /* Simple 8bit reloc. */ 222 HOWTO (R_V850_8, /* type */ 223 0, /* rightshift */ 224 0, /* size (0 = byte, 1 = short, 2 = long) */ 225 8, /* bitsize */ 226 FALSE, /* pc_relative */ 227 0, /* bitpos */ 228 complain_overflow_dont, /* complain_on_overflow */ 229 bfd_elf_generic_reloc, /* special_function */ 230 "R_V850_8", /* name */ 231 FALSE, /* partial_inplace */ 232 0xff, /* src_mask */ 233 0xff, /* dst_mask */ 234 FALSE), /* pcrel_offset */ 235 236 /* 16 bit offset from the short data area pointer. */ 237 HOWTO (R_V850_SDA_16_16_OFFSET, /* type */ 238 0, /* rightshift */ 239 1, /* size (0 = byte, 1 = short, 2 = long) */ 240 16, /* bitsize */ 241 FALSE, /* pc_relative */ 242 0, /* bitpos */ 243 complain_overflow_dont, /* complain_on_overflow */ 244 v850_elf_reloc, /* special_function */ 245 "R_V850_SDA_16_16_OFFSET", /* name */ 246 FALSE, /* partial_inplace */ 247 0xffff, /* src_mask */ 248 0xffff, /* dst_mask */ 249 FALSE), /* pcrel_offset */ 250 251 /* 15 bit offset from the short data area pointer. */ 252 HOWTO (R_V850_SDA_15_16_OFFSET, /* type */ 253 1, /* rightshift */ 254 1, /* size (0 = byte, 1 = short, 2 = long) */ 255 16, /* bitsize */ 256 FALSE, /* pc_relative */ 257 1, /* bitpos */ 258 complain_overflow_dont, /* complain_on_overflow */ 259 v850_elf_reloc, /* special_function */ 260 "R_V850_SDA_15_16_OFFSET", /* name */ 261 FALSE, /* partial_inplace */ 262 0xfffe, /* src_mask */ 263 0xfffe, /* dst_mask */ 264 FALSE), /* pcrel_offset */ 265 266 /* 16 bit offset from the zero data area pointer. */ 267 HOWTO (R_V850_ZDA_16_16_OFFSET, /* type */ 268 0, /* rightshift */ 269 1, /* size (0 = byte, 1 = short, 2 = long) */ 270 16, /* bitsize */ 271 FALSE, /* pc_relative */ 272 0, /* bitpos */ 273 complain_overflow_dont, /* complain_on_overflow */ 274 v850_elf_reloc, /* special_function */ 275 "R_V850_ZDA_16_16_OFFSET", /* name */ 276 FALSE, /* partial_inplace */ 277 0xffff, /* src_mask */ 278 0xffff, /* dst_mask */ 279 FALSE), /* pcrel_offset */ 280 281 /* 15 bit offset from the zero data area pointer. */ 282 HOWTO (R_V850_ZDA_15_16_OFFSET, /* type */ 283 1, /* rightshift */ 284 1, /* size (0 = byte, 1 = short, 2 = long) */ 285 16, /* bitsize */ 286 FALSE, /* pc_relative */ 287 1, /* bitpos */ 288 complain_overflow_dont, /* complain_on_overflow */ 289 v850_elf_reloc, /* special_function */ 290 "R_V850_ZDA_15_16_OFFSET", /* name */ 291 FALSE, /* partial_inplace */ 292 0xfffe, /* src_mask */ 293 0xfffe, /* dst_mask */ 294 FALSE), /* pcrel_offset */ 295 296 /* 6 bit offset from the tiny data area pointer. */ 297 HOWTO (R_V850_TDA_6_8_OFFSET, /* type */ 298 2, /* rightshift */ 299 1, /* size (0 = byte, 1 = short, 2 = long) */ 300 8, /* bitsize */ 301 FALSE, /* pc_relative */ 302 1, /* bitpos */ 303 complain_overflow_dont, /* complain_on_overflow */ 304 v850_elf_reloc, /* special_function */ 305 "R_V850_TDA_6_8_OFFSET", /* name */ 306 FALSE, /* partial_inplace */ 307 0x7e, /* src_mask */ 308 0x7e, /* dst_mask */ 309 FALSE), /* pcrel_offset */ 310 311 /* 8 bit offset from the tiny data area pointer. */ 312 HOWTO (R_V850_TDA_7_8_OFFSET, /* type */ 313 1, /* rightshift */ 314 1, /* size (0 = byte, 1 = short, 2 = long) */ 315 8, /* bitsize */ 316 FALSE, /* pc_relative */ 317 0, /* bitpos */ 318 complain_overflow_dont, /* complain_on_overflow */ 319 v850_elf_reloc, /* special_function */ 320 "R_V850_TDA_7_8_OFFSET", /* name */ 321 FALSE, /* partial_inplace */ 322 0x7f, /* src_mask */ 323 0x7f, /* dst_mask */ 324 FALSE), /* pcrel_offset */ 325 326 /* 7 bit offset from the tiny data area pointer. */ 327 HOWTO (R_V850_TDA_7_7_OFFSET, /* type */ 328 0, /* rightshift */ 329 1, /* size (0 = byte, 1 = short, 2 = long) */ 330 7, /* bitsize */ 331 FALSE, /* pc_relative */ 332 0, /* bitpos */ 333 complain_overflow_dont, /* complain_on_overflow */ 334 v850_elf_reloc, /* special_function */ 335 "R_V850_TDA_7_7_OFFSET", /* name */ 336 FALSE, /* partial_inplace */ 337 0x7f, /* src_mask */ 338 0x7f, /* dst_mask */ 339 FALSE), /* pcrel_offset */ 340 341 /* 16 bit offset from the tiny data area pointer! */ 342 HOWTO (R_V850_TDA_16_16_OFFSET, /* type */ 343 0, /* rightshift */ 344 1, /* size (0 = byte, 1 = short, 2 = long) */ 345 16, /* bitsize */ 346 FALSE, /* pc_relative */ 347 0, /* bitpos */ 348 complain_overflow_dont, /* complain_on_overflow */ 349 v850_elf_reloc, /* special_function */ 350 "R_V850_TDA_16_16_OFFSET", /* name */ 351 FALSE, /* partial_inplace */ 352 0xffff, /* src_mask */ 353 0xfff, /* dst_mask */ 354 FALSE), /* pcrel_offset */ 355 356 /* 5 bit offset from the tiny data area pointer. */ 357 HOWTO (R_V850_TDA_4_5_OFFSET, /* type */ 358 1, /* rightshift */ 359 1, /* size (0 = byte, 1 = short, 2 = long) */ 360 5, /* bitsize */ 361 FALSE, /* pc_relative */ 362 0, /* bitpos */ 363 complain_overflow_dont, /* complain_on_overflow */ 364 v850_elf_reloc, /* special_function */ 365 "R_V850_TDA_4_5_OFFSET", /* name */ 366 FALSE, /* partial_inplace */ 367 0x0f, /* src_mask */ 368 0x0f, /* dst_mask */ 369 FALSE), /* pcrel_offset */ 370 371 /* 4 bit offset from the tiny data area pointer. */ 372 HOWTO (R_V850_TDA_4_4_OFFSET, /* type */ 373 0, /* rightshift */ 374 1, /* size (0 = byte, 1 = short, 2 = long) */ 375 4, /* bitsize */ 376 FALSE, /* pc_relative */ 377 0, /* bitpos */ 378 complain_overflow_dont, /* complain_on_overflow */ 379 v850_elf_reloc, /* special_function */ 380 "R_V850_TDA_4_4_OFFSET", /* name */ 381 FALSE, /* partial_inplace */ 382 0x0f, /* src_mask */ 383 0x0f, /* dst_mask */ 384 FALSE), /* pcrel_offset */ 385 386 /* 16 bit offset from the short data area pointer. */ 387 HOWTO (R_V850_SDA_16_16_SPLIT_OFFSET, /* type */ 388 0, /* rightshift */ 389 2, /* size (0 = byte, 1 = short, 2 = long) */ 390 16, /* bitsize */ 391 FALSE, /* pc_relative */ 392 0, /* bitpos */ 393 complain_overflow_dont, /* complain_on_overflow */ 394 v850_elf_reloc, /* special_function */ 395 "R_V850_SDA_16_16_SPLIT_OFFSET",/* name */ 396 FALSE, /* partial_inplace */ 397 0xfffe0020, /* src_mask */ 398 0xfffe0020, /* dst_mask */ 399 FALSE), /* pcrel_offset */ 400 401 /* 16 bit offset from the zero data area pointer. */ 402 HOWTO (R_V850_ZDA_16_16_SPLIT_OFFSET, /* type */ 403 0, /* rightshift */ 404 2, /* size (0 = byte, 1 = short, 2 = long) */ 405 16, /* bitsize */ 406 FALSE, /* pc_relative */ 407 0, /* bitpos */ 408 complain_overflow_dont, /* complain_on_overflow */ 409 v850_elf_reloc, /* special_function */ 410 "R_V850_ZDA_16_16_SPLIT_OFFSET",/* name */ 411 FALSE, /* partial_inplace */ 412 0xfffe0020, /* src_mask */ 413 0xfffe0020, /* dst_mask */ 414 FALSE), /* pcrel_offset */ 415 416 /* 6 bit offset from the call table base pointer. */ 417 HOWTO (R_V850_CALLT_6_7_OFFSET, /* type */ 418 0, /* rightshift */ 419 1, /* size (0 = byte, 1 = short, 2 = long) */ 420 7, /* bitsize */ 421 FALSE, /* pc_relative */ 422 0, /* bitpos */ 423 complain_overflow_dont, /* complain_on_overflow */ 424 v850_elf_reloc, /* special_function */ 425 "R_V850_CALLT_6_7_OFFSET", /* name */ 426 FALSE, /* partial_inplace */ 427 0x3f, /* src_mask */ 428 0x3f, /* dst_mask */ 429 FALSE), /* pcrel_offset */ 430 431 /* 16 bit offset from the call table base pointer. */ 432 HOWTO (R_V850_CALLT_16_16_OFFSET, /* type */ 433 0, /* rightshift */ 434 1, /* size (0 = byte, 1 = short, 2 = long) */ 435 16, /* bitsize */ 436 FALSE, /* pc_relative */ 437 0, /* bitpos */ 438 complain_overflow_dont, /* complain_on_overflow */ 439 v850_elf_reloc, /* special_function */ 440 "R_V850_CALLT_16_16_OFFSET", /* name */ 441 FALSE, /* partial_inplace */ 442 0xffff, /* src_mask */ 443 0xffff, /* dst_mask */ 444 FALSE), /* pcrel_offset */ 445 446 /* GNU extension to record C++ vtable hierarchy */ 447 HOWTO (R_V850_GNU_VTINHERIT, /* type */ 448 0, /* rightshift */ 449 2, /* size (0 = byte, 1 = short, 2 = long) */ 450 0, /* bitsize */ 451 FALSE, /* pc_relative */ 452 0, /* bitpos */ 453 complain_overflow_dont, /* complain_on_overflow */ 454 NULL, /* special_function */ 455 "R_V850_GNU_VTINHERIT", /* name */ 456 FALSE, /* partial_inplace */ 457 0, /* src_mask */ 458 0, /* dst_mask */ 459 FALSE), /* pcrel_offset */ 460 461 /* GNU extension to record C++ vtable member usage */ 462 HOWTO (R_V850_GNU_VTENTRY, /* type */ 463 0, /* rightshift */ 464 2, /* size (0 = byte, 1 = short, 2 = long) */ 465 0, /* bitsize */ 466 FALSE, /* pc_relative */ 467 0, /* bitpos */ 468 complain_overflow_dont, /* complain_on_overflow */ 469 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 470 "R_V850_GNU_VTENTRY", /* name */ 471 FALSE, /* partial_inplace */ 472 0, /* src_mask */ 473 0, /* dst_mask */ 474 FALSE), /* pcrel_offset */ 475 476 /* Indicates a .longcall pseudo-op. The compiler will generate a .longcall 477 pseudo-op when it finds a function call which can be relaxed. */ 478 HOWTO (R_V850_LONGCALL, /* type */ 479 0, /* rightshift */ 480 2, /* size (0 = byte, 1 = short, 2 = long) */ 481 32, /* bitsize */ 482 TRUE, /* pc_relative */ 483 0, /* bitpos */ 484 complain_overflow_signed, /* complain_on_overflow */ 485 v850_elf_ignore_reloc, /* special_function */ 486 "R_V850_LONGCALL", /* name */ 487 FALSE, /* partial_inplace */ 488 0, /* src_mask */ 489 0, /* dst_mask */ 490 TRUE), /* pcrel_offset */ 491 492 /* Indicates a .longjump pseudo-op. The compiler will generate a 493 .longjump pseudo-op when it finds a branch which can be relaxed. */ 494 HOWTO (R_V850_LONGJUMP, /* type */ 495 0, /* rightshift */ 496 2, /* size (0 = byte, 1 = short, 2 = long) */ 497 32, /* bitsize */ 498 TRUE, /* pc_relative */ 499 0, /* bitpos */ 500 complain_overflow_signed, /* complain_on_overflow */ 501 v850_elf_ignore_reloc, /* special_function */ 502 "R_V850_LONGJUMP", /* name */ 503 FALSE, /* partial_inplace */ 504 0, /* src_mask */ 505 0, /* dst_mask */ 506 TRUE), /* pcrel_offset */ 507 508 HOWTO (R_V850_ALIGN, /* type */ 509 0, /* rightshift */ 510 1, /* size (0 = byte, 1 = short, 2 = long) */ 511 0, /* bitsize */ 512 FALSE, /* pc_relative */ 513 0, /* bitpos */ 514 complain_overflow_unsigned, /* complain_on_overflow */ 515 v850_elf_ignore_reloc, /* special_function */ 516 "R_V850_ALIGN", /* name */ 517 FALSE, /* partial_inplace */ 518 0, /* src_mask */ 519 0, /* dst_mask */ 520 TRUE), /* pcrel_offset */ 521 522 /* Simple pc-relative 32bit reloc. */ 523 HOWTO (R_V850_REL32, /* type */ 524 0, /* rightshift */ 525 2, /* size (0 = byte, 1 = short, 2 = long) */ 526 32, /* bitsize */ 527 TRUE, /* pc_relative */ 528 0, /* bitpos */ 529 complain_overflow_dont, /* complain_on_overflow */ 530 v850_elf_reloc, /* special_function */ 531 "R_V850_REL32", /* name */ 532 FALSE, /* partial_inplace */ 533 0xffffffff, /* src_mask */ 534 0xffffffff, /* dst_mask */ 535 FALSE), /* pcrel_offset */ 536 }; 537 538 /* Map BFD reloc types to V850 ELF reloc types. */ 539 540 struct v850_elf_reloc_map 541 { 542 /* BFD_RELOC_V850_CALLT_16_16_OFFSET is 258, which will not fix in an 543 unsigned char. */ 544 bfd_reloc_code_real_type bfd_reloc_val; 545 unsigned int elf_reloc_val; 546 }; 547 548 static const struct v850_elf_reloc_map v850_elf_reloc_map[] = 549 { 550 { BFD_RELOC_NONE, R_V850_NONE }, 551 { BFD_RELOC_V850_9_PCREL, R_V850_9_PCREL }, 552 { BFD_RELOC_V850_22_PCREL, R_V850_22_PCREL }, 553 { BFD_RELOC_HI16_S, R_V850_HI16_S }, 554 { BFD_RELOC_HI16, R_V850_HI16 }, 555 { BFD_RELOC_LO16, R_V850_LO16 }, 556 { BFD_RELOC_32, R_V850_ABS32 }, 557 { BFD_RELOC_32_PCREL, R_V850_REL32 }, 558 { BFD_RELOC_16, R_V850_16 }, 559 { BFD_RELOC_8, R_V850_8 }, 560 { BFD_RELOC_V850_SDA_16_16_OFFSET, R_V850_SDA_16_16_OFFSET }, 561 { BFD_RELOC_V850_SDA_15_16_OFFSET, R_V850_SDA_15_16_OFFSET }, 562 { BFD_RELOC_V850_ZDA_16_16_OFFSET, R_V850_ZDA_16_16_OFFSET }, 563 { BFD_RELOC_V850_ZDA_15_16_OFFSET, R_V850_ZDA_15_16_OFFSET }, 564 { BFD_RELOC_V850_TDA_6_8_OFFSET, R_V850_TDA_6_8_OFFSET }, 565 { BFD_RELOC_V850_TDA_7_8_OFFSET, R_V850_TDA_7_8_OFFSET }, 566 { BFD_RELOC_V850_TDA_7_7_OFFSET, R_V850_TDA_7_7_OFFSET }, 567 { BFD_RELOC_V850_TDA_16_16_OFFSET, R_V850_TDA_16_16_OFFSET }, 568 { BFD_RELOC_V850_TDA_4_5_OFFSET, R_V850_TDA_4_5_OFFSET }, 569 { BFD_RELOC_V850_TDA_4_4_OFFSET, R_V850_TDA_4_4_OFFSET }, 570 { BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, R_V850_SDA_16_16_SPLIT_OFFSET }, 571 { BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, R_V850_ZDA_16_16_SPLIT_OFFSET }, 572 { BFD_RELOC_V850_CALLT_6_7_OFFSET, R_V850_CALLT_6_7_OFFSET }, 573 { BFD_RELOC_V850_CALLT_16_16_OFFSET, R_V850_CALLT_16_16_OFFSET }, 574 { BFD_RELOC_VTABLE_INHERIT, R_V850_GNU_VTINHERIT }, 575 { BFD_RELOC_VTABLE_ENTRY, R_V850_GNU_VTENTRY }, 576 { BFD_RELOC_V850_LONGCALL, R_V850_LONGCALL }, 577 { BFD_RELOC_V850_LONGJUMP, R_V850_LONGJUMP }, 578 { BFD_RELOC_V850_ALIGN, R_V850_ALIGN }, 579 580 }; 581 582 /* Map a bfd relocation into the appropriate howto structure. */ 583 584 static reloc_howto_type * 585 v850_elf_reloc_type_lookup (abfd, code) 586 bfd *abfd ATTRIBUTE_UNUSED; 587 bfd_reloc_code_real_type code; 588 { 589 unsigned int i; 590 591 for (i = ARRAY_SIZE (v850_elf_reloc_map); i --;) 592 if (v850_elf_reloc_map[i].bfd_reloc_val == code) 593 { 594 unsigned int elf_reloc_val = v850_elf_reloc_map[i].elf_reloc_val; 595 596 BFD_ASSERT (v850_elf_howto_table[elf_reloc_val].type == elf_reloc_val); 597 598 return v850_elf_howto_table + elf_reloc_val; 599 } 600 601 return NULL; 602 } 603 604 /* Set the howto pointer for an V850 ELF reloc. */ 605 606 static void 607 v850_elf_info_to_howto_rel (abfd, cache_ptr, dst) 608 bfd *abfd ATTRIBUTE_UNUSED; 609 arelent *cache_ptr; 610 Elf_Internal_Rela *dst; 611 { 612 unsigned int r_type; 613 614 r_type = ELF32_R_TYPE (dst->r_info); 615 BFD_ASSERT (r_type < (unsigned int) R_V850_max); 616 cache_ptr->howto = &v850_elf_howto_table[r_type]; 617 } 618 619 /* Set the howto pointer for a V850 ELF reloc (type RELA). */ 620 static void 621 v850_elf_info_to_howto_rela (abfd, cache_ptr, dst) 622 bfd *abfd ATTRIBUTE_UNUSED; 623 arelent * cache_ptr; 624 Elf_Internal_Rela *dst; 625 { 626 unsigned int r_type; 627 628 r_type = ELF32_R_TYPE (dst->r_info); 629 BFD_ASSERT (r_type < (unsigned int) R_V850_max); 630 cache_ptr->howto = &v850_elf_howto_table[r_type]; 631 } 632 633 /* Look through the relocs for a section during the first phase, and 634 allocate space in the global offset table or procedure linkage 635 table. */ 636 637 static bfd_boolean 638 v850_elf_check_relocs (abfd, info, sec, relocs) 639 bfd *abfd; 640 struct bfd_link_info *info; 641 asection *sec; 642 const Elf_Internal_Rela *relocs; 643 { 644 bfd_boolean ret = TRUE; 645 bfd *dynobj; 646 Elf_Internal_Shdr *symtab_hdr; 647 struct elf_link_hash_entry **sym_hashes; 648 const Elf_Internal_Rela *rel; 649 const Elf_Internal_Rela *rel_end; 650 asection *sreloc; 651 enum v850_reloc_type r_type; 652 int other = 0; 653 const char *common = (const char *)0; 654 655 if (info->relocatable) 656 return TRUE; 657 658 #ifdef DEBUG 659 fprintf (stderr, "v850_elf_check_relocs called for section %s in %s\n", 660 bfd_get_section_name (abfd, sec), 661 bfd_archive_filename (abfd)); 662 #endif 663 664 dynobj = elf_hash_table (info)->dynobj; 665 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 666 sym_hashes = elf_sym_hashes (abfd); 667 sreloc = NULL; 668 669 rel_end = relocs + sec->reloc_count; 670 for (rel = relocs; rel < rel_end; rel++) 671 { 672 unsigned long r_symndx; 673 struct elf_link_hash_entry *h; 674 675 r_symndx = ELF32_R_SYM (rel->r_info); 676 if (r_symndx < symtab_hdr->sh_info) 677 h = NULL; 678 else 679 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 680 681 r_type = (enum v850_reloc_type) ELF32_R_TYPE (rel->r_info); 682 switch (r_type) 683 { 684 default: 685 case R_V850_NONE: 686 case R_V850_9_PCREL: 687 case R_V850_22_PCREL: 688 case R_V850_HI16_S: 689 case R_V850_HI16: 690 case R_V850_LO16: 691 case R_V850_ABS32: 692 case R_V850_REL32: 693 case R_V850_16: 694 case R_V850_8: 695 case R_V850_CALLT_6_7_OFFSET: 696 case R_V850_CALLT_16_16_OFFSET: 697 break; 698 699 /* This relocation describes the C++ object vtable hierarchy. 700 Reconstruct it for later use during GC. */ 701 case R_V850_GNU_VTINHERIT: 702 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 703 return FALSE; 704 break; 705 706 /* This relocation describes which C++ vtable entries 707 are actually used. Record for later use during GC. */ 708 case R_V850_GNU_VTENTRY: 709 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 710 return FALSE; 711 break; 712 713 case R_V850_SDA_16_16_SPLIT_OFFSET: 714 case R_V850_SDA_16_16_OFFSET: 715 case R_V850_SDA_15_16_OFFSET: 716 other = V850_OTHER_SDA; 717 common = ".scommon"; 718 goto small_data_common; 719 720 case R_V850_ZDA_16_16_SPLIT_OFFSET: 721 case R_V850_ZDA_16_16_OFFSET: 722 case R_V850_ZDA_15_16_OFFSET: 723 other = V850_OTHER_ZDA; 724 common = ".zcommon"; 725 goto small_data_common; 726 727 case R_V850_TDA_4_5_OFFSET: 728 case R_V850_TDA_4_4_OFFSET: 729 case R_V850_TDA_6_8_OFFSET: 730 case R_V850_TDA_7_8_OFFSET: 731 case R_V850_TDA_7_7_OFFSET: 732 case R_V850_TDA_16_16_OFFSET: 733 other = V850_OTHER_TDA; 734 common = ".tcommon"; 735 /* fall through */ 736 737 #define V850_OTHER_MASK (V850_OTHER_TDA | V850_OTHER_SDA | V850_OTHER_ZDA) 738 739 small_data_common: 740 if (h) 741 { 742 /* Flag which type of relocation was used. */ 743 h->other |= other; 744 if ((h->other & V850_OTHER_MASK) != (other & V850_OTHER_MASK) 745 && (h->other & V850_OTHER_ERROR) == 0) 746 { 747 const char * msg; 748 static char buff[200]; /* XXX */ 749 750 switch (h->other & V850_OTHER_MASK) 751 { 752 default: 753 msg = _("Variable `%s' cannot occupy in multiple small data regions"); 754 break; 755 case V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA: 756 msg = _("Variable `%s' can only be in one of the small, zero, and tiny data regions"); 757 break; 758 case V850_OTHER_SDA | V850_OTHER_ZDA: 759 msg = _("Variable `%s' cannot be in both small and zero data regions simultaneously"); 760 break; 761 case V850_OTHER_SDA | V850_OTHER_TDA: 762 msg = _("Variable `%s' cannot be in both small and tiny data regions simultaneously"); 763 break; 764 case V850_OTHER_ZDA | V850_OTHER_TDA: 765 msg = _("Variable `%s' cannot be in both zero and tiny data regions simultaneously"); 766 break; 767 } 768 769 sprintf (buff, msg, h->root.root.string); 770 info->callbacks->warning (info, buff, h->root.root.string, 771 abfd, h->root.u.def.section, 772 (bfd_vma) 0); 773 774 bfd_set_error (bfd_error_bad_value); 775 h->other |= V850_OTHER_ERROR; 776 ret = FALSE; 777 } 778 } 779 780 if (h && h->root.type == bfd_link_hash_common 781 && h->root.u.c.p 782 && !strcmp (bfd_get_section_name (abfd, h->root.u.c.p->section), "COMMON")) 783 { 784 asection * section; 785 786 section = h->root.u.c.p->section = bfd_make_section_old_way (abfd, common); 787 section->flags |= SEC_IS_COMMON; 788 } 789 790 #ifdef DEBUG 791 fprintf (stderr, "v850_elf_check_relocs, found %s relocation for %s%s\n", 792 v850_elf_howto_table[ (int)r_type ].name, 793 (h && h->root.root.string) ? h->root.root.string : "<unknown>", 794 (h->root.type == bfd_link_hash_common) ? ", symbol is common" : ""); 795 #endif 796 break; 797 } 798 } 799 800 return ret; 801 } 802 803 /* In the old version, when an entry was checked out from the table, 804 it was deleted. This produced an error if the entry was needed 805 more than once, as the second attempted retry failed. 806 807 In the current version, the entry is not deleted, instead we set 808 the field 'found' to TRUE. If a second lookup matches the same 809 entry, then we know that the hi16s reloc has already been updated 810 and does not need to be updated a second time. 811 812 TODO - TOFIX: If it is possible that we need to restore 2 different 813 addresses from the same table entry, where the first generates an 814 overflow, whilst the second do not, then this code will fail. */ 815 816 typedef struct hi16s_location 817 { 818 bfd_vma addend; 819 bfd_byte *address; 820 unsigned long counter; 821 bfd_boolean found; 822 struct hi16s_location *next; 823 } 824 hi16s_location; 825 826 static hi16s_location *previous_hi16s; 827 static hi16s_location *free_hi16s; 828 static unsigned long hi16s_counter; 829 830 static void 831 remember_hi16s_reloc (abfd, addend, address) 832 bfd *abfd; 833 bfd_vma addend; 834 bfd_byte *address; 835 { 836 hi16s_location * entry = NULL; 837 bfd_size_type amt = sizeof (* free_hi16s); 838 839 /* Find a free structure. */ 840 if (free_hi16s == NULL) 841 free_hi16s = (hi16s_location *) bfd_zalloc (abfd, amt); 842 843 entry = free_hi16s; 844 free_hi16s = free_hi16s->next; 845 846 entry->addend = addend; 847 entry->address = address; 848 entry->counter = hi16s_counter ++; 849 entry->found = FALSE; 850 entry->next = previous_hi16s; 851 previous_hi16s = entry; 852 853 /* Cope with wrap around of our counter. */ 854 if (hi16s_counter == 0) 855 { 856 /* XXX - Assume that all counter entries differ only in their low 16 bits. */ 857 for (entry = previous_hi16s; entry != NULL; entry = entry->next) 858 entry->counter &= 0xffff; 859 860 hi16s_counter = 0x10000; 861 } 862 863 return; 864 } 865 866 static bfd_byte * 867 find_remembered_hi16s_reloc (addend, already_found) 868 bfd_vma addend; 869 bfd_boolean *already_found; 870 { 871 hi16s_location *match = NULL; 872 hi16s_location *entry; 873 hi16s_location *previous = NULL; 874 hi16s_location *prev; 875 bfd_byte *addr; 876 877 /* Search the table. Record the most recent entry that matches. */ 878 for (entry = previous_hi16s; entry; entry = entry->next) 879 { 880 if (entry->addend == addend 881 && (match == NULL || match->counter < entry->counter)) 882 { 883 previous = prev; 884 match = entry; 885 } 886 887 prev = entry; 888 } 889 890 if (match == NULL) 891 return NULL; 892 893 /* Extract the address. */ 894 addr = match->address; 895 896 /* Remember if this entry has already been used before. */ 897 if (already_found) 898 * already_found = match->found; 899 900 /* Note that this entry has now been used. */ 901 match->found = TRUE; 902 903 return addr; 904 } 905 906 /* FIXME: The code here probably ought to be removed and the code in reloc.c 907 allowed to do its stuff instead. At least for most of the relocs, anyway. */ 908 909 static bfd_reloc_status_type 910 v850_elf_perform_relocation (abfd, r_type, addend, address) 911 bfd *abfd; 912 unsigned int r_type; 913 bfd_vma addend; 914 bfd_byte *address; 915 { 916 unsigned long insn; 917 bfd_signed_vma saddend = (bfd_signed_vma) addend; 918 919 switch (r_type) 920 { 921 default: 922 /* fprintf (stderr, "reloc type %d not SUPPORTED\n", r_type ); */ 923 return bfd_reloc_notsupported; 924 925 case R_V850_REL32: 926 case R_V850_ABS32: 927 bfd_put_32 (abfd, addend, address); 928 return bfd_reloc_ok; 929 930 case R_V850_22_PCREL: 931 if (saddend > 0x1fffff || saddend < -0x200000) 932 return bfd_reloc_overflow; 933 934 if ((addend % 2) != 0) 935 return bfd_reloc_dangerous; 936 937 insn = bfd_get_32 (abfd, address); 938 insn &= ~0xfffe003f; 939 insn |= (((addend & 0xfffe) << 16) | ((addend & 0x3f0000) >> 16)); 940 bfd_put_32 (abfd, (bfd_vma) insn, address); 941 return bfd_reloc_ok; 942 943 case R_V850_9_PCREL: 944 if (saddend > 0xff || saddend < -0x100) 945 return bfd_reloc_overflow; 946 947 if ((addend % 2) != 0) 948 return bfd_reloc_dangerous; 949 950 insn = bfd_get_16 (abfd, address); 951 insn &= ~ 0xf870; 952 insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3); 953 break; 954 955 case R_V850_HI16: 956 addend += (bfd_get_16 (abfd, address) << 16); 957 addend = (addend >> 16); 958 insn = addend; 959 break; 960 961 case R_V850_HI16_S: 962 /* Remember where this relocation took place. */ 963 remember_hi16s_reloc (abfd, addend, address); 964 965 addend += (bfd_get_16 (abfd, address) << 16); 966 addend = (addend >> 16) + ((addend & 0x8000) != 0); 967 968 /* This relocation cannot overflow. */ 969 if (addend > 0x7fff) 970 addend = 0; 971 972 insn = addend; 973 break; 974 975 case R_V850_LO16: 976 /* Calculate the sum of the value stored in the instruction and the 977 addend and check for overflow from the low 16 bits into the high 978 16 bits. The assembler has already done some of this: If the 979 value stored in the instruction has its 15th bit set, (counting 980 from zero) then the assembler will have added 1 to the value 981 stored in the associated HI16S reloc. So for example, these 982 relocations: 983 984 movhi hi( fred ), r0, r1 985 movea lo( fred ), r1, r1 986 987 will store 0 in the value fields for the MOVHI and MOVEA instructions 988 and addend will be the address of fred, but for these instructions: 989 990 movhi hi( fred + 0x123456), r0, r1 991 movea lo( fred + 0x123456), r1, r1 992 993 the value stored in the MOVHI instruction will be 0x12 and the value 994 stored in the MOVEA instruction will be 0x3456. If however the 995 instructions were: 996 997 movhi hi( fred + 0x10ffff), r0, r1 998 movea lo( fred + 0x10ffff), r1, r1 999 1000 then the value stored in the MOVHI instruction would be 0x11 (not 1001 0x10) and the value stored in the MOVEA instruction would be 0xffff. 1002 Thus (assuming for the moment that the addend is 0), at run time the 1003 MOVHI instruction loads 0x110000 into r1, then the MOVEA instruction 1004 adds 0xffffffff (sign extension!) producing 0x10ffff. Similarly if 1005 the instructions were: 1006 1007 movhi hi( fred - 1), r0, r1 1008 movea lo( fred - 1), r1, r1 1009 1010 then 0 is stored in the MOVHI instruction and -1 is stored in the 1011 MOVEA instruction. 1012 1013 Overflow can occur if the addition of the value stored in the 1014 instruction plus the addend sets the 15th bit when before it was clear. 1015 This is because the 15th bit will be sign extended into the high part, 1016 thus reducing its value by one, but since the 15th bit was originally 1017 clear, the assembler will not have added 1 to the previous HI16S reloc 1018 to compensate for this effect. For example: 1019 1020 movhi hi( fred + 0x123456), r0, r1 1021 movea lo( fred + 0x123456), r1, r1 1022 1023 The value stored in HI16S reloc is 0x12, the value stored in the LO16 1024 reloc is 0x3456. If we assume that the address of fred is 0x00007000 1025 then the relocations become: 1026 1027 HI16S: 0x0012 + (0x00007000 >> 16) = 0x12 1028 LO16: 0x3456 + (0x00007000 & 0xffff) = 0xa456 1029 1030 but when the instructions are executed, the MOVEA instruction's value 1031 is signed extended, so the sum becomes: 1032 1033 0x00120000 1034 + 0xffffa456 1035 ------------ 1036 0x0011a456 but 'fred + 0x123456' = 0x0012a456 1037 1038 Note that if the 15th bit was set in the value stored in the LO16 1039 reloc, then we do not have to do anything: 1040 1041 movhi hi( fred + 0x10ffff), r0, r1 1042 movea lo( fred + 0x10ffff), r1, r1 1043 1044 HI16S: 0x0011 + (0x00007000 >> 16) = 0x11 1045 LO16: 0xffff + (0x00007000 & 0xffff) = 0x6fff 1046 1047 0x00110000 1048 + 0x00006fff 1049 ------------ 1050 0x00116fff = fred + 0x10ffff = 0x7000 + 0x10ffff 1051 1052 Overflow can also occur if the computation carries into the 16th bit 1053 and it also results in the 15th bit having the same value as the 15th 1054 bit of the original value. What happens is that the HI16S reloc 1055 will have already examined the 15th bit of the original value and 1056 added 1 to the high part if the bit is set. This compensates for the 1057 sign extension of 15th bit of the result of the computation. But now 1058 there is a carry into the 16th bit, and this has not been allowed for. 1059 1060 So, for example if fred is at address 0xf000: 1061 1062 movhi hi( fred + 0xffff), r0, r1 [bit 15 of the offset is set] 1063 movea lo( fred + 0xffff), r1, r1 1064 1065 HI16S: 0x0001 + (0x0000f000 >> 16) = 0x0001 1066 LO16: 0xffff + (0x0000f000 & 0xffff) = 0xefff (carry into bit 16 is lost) 1067 1068 0x00010000 1069 + 0xffffefff 1070 ------------ 1071 0x0000efff but 'fred + 0xffff' = 0x0001efff 1072 1073 Similarly, if the 15th bit remains clear, but overflow occurs into 1074 the 16th bit then (assuming the address of fred is 0xf000): 1075 1076 movhi hi( fred + 0x7000), r0, r1 [bit 15 of the offset is clear] 1077 movea lo( fred + 0x7000), r1, r1 1078 1079 HI16S: 0x0000 + (0x0000f000 >> 16) = 0x0000 1080 LO16: 0x7000 + (0x0000f000 & 0xffff) = 0x6fff (carry into bit 16 is lost) 1081 1082 0x00000000 1083 + 0x00006fff 1084 ------------ 1085 0x00006fff but 'fred + 0x7000' = 0x00016fff 1086 1087 Note - there is no need to change anything if a carry occurs, and the 1088 15th bit changes its value from being set to being clear, as the HI16S 1089 reloc will have already added in 1 to the high part for us: 1090 1091 movhi hi( fred + 0xffff), r0, r1 [bit 15 of the offset is set] 1092 movea lo( fred + 0xffff), r1, r1 1093 1094 HI16S: 0x0001 + (0x00007000 >> 16) 1095 LO16: 0xffff + (0x00007000 & 0xffff) = 0x6fff (carry into bit 16 is lost) 1096 1097 0x00010000 1098 + 0x00006fff (bit 15 not set, so the top half is zero) 1099 ------------ 1100 0x00016fff which is right (assuming that fred is at 0x7000) 1101 1102 but if the 15th bit goes from being clear to being set, then we must 1103 once again handle overflow: 1104 1105 movhi hi( fred + 0x7000), r0, r1 [bit 15 of the offset is clear] 1106 movea lo( fred + 0x7000), r1, r1 1107 1108 HI16S: 0x0000 + (0x0000ffff >> 16) 1109 LO16: 0x7000 + (0x0000ffff & 0xffff) = 0x6fff (carry into bit 16) 1110 1111 0x00000000 1112 + 0x00006fff (bit 15 not set, so the top half is zero) 1113 ------------ 1114 0x00006fff which is wrong (assuming that fred is at 0xffff). */ 1115 { 1116 long result; 1117 1118 insn = bfd_get_16 (abfd, address); 1119 result = insn + addend; 1120 1121 #define BIT15_SET(x) ((x) & 0x8000) 1122 #define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff) 1123 1124 if ((BIT15_SET (result) && ! BIT15_SET (addend)) 1125 || (OVERFLOWS (addend, insn) 1126 && ((! BIT15_SET (insn)) || (BIT15_SET (addend))))) 1127 { 1128 bfd_boolean already_updated; 1129 bfd_byte *hi16s_address = find_remembered_hi16s_reloc 1130 (addend, & already_updated); 1131 1132 /* Amend the matching HI16_S relocation. */ 1133 if (hi16s_address != NULL) 1134 { 1135 if (! already_updated) 1136 { 1137 insn = bfd_get_16 (abfd, hi16s_address); 1138 insn += 1; 1139 bfd_put_16 (abfd, (bfd_vma) insn, hi16s_address); 1140 } 1141 } 1142 else 1143 { 1144 fprintf (stderr, _("FAILED to find previous HI16 reloc\n")); 1145 return bfd_reloc_overflow; 1146 } 1147 } 1148 1149 /* Do not complain if value has top bit set, as this has been anticipated. */ 1150 insn = result & 0xffff; 1151 break; 1152 } 1153 1154 case R_V850_8: 1155 addend += (char) bfd_get_8 (abfd, address); 1156 1157 saddend = (bfd_signed_vma) addend; 1158 1159 if (saddend > 0x7f || saddend < -0x80) 1160 return bfd_reloc_overflow; 1161 1162 bfd_put_8 (abfd, addend, address); 1163 return bfd_reloc_ok; 1164 1165 case R_V850_CALLT_16_16_OFFSET: 1166 addend += bfd_get_16 (abfd, address); 1167 1168 saddend = (bfd_signed_vma) addend; 1169 1170 if (saddend > 0xffff || saddend < 0) 1171 return bfd_reloc_overflow; 1172 1173 insn = addend; 1174 break; 1175 1176 case R_V850_16: 1177 1178 /* drop through */ 1179 case R_V850_SDA_16_16_OFFSET: 1180 case R_V850_ZDA_16_16_OFFSET: 1181 case R_V850_TDA_16_16_OFFSET: 1182 addend += bfd_get_16 (abfd, address); 1183 1184 saddend = (bfd_signed_vma) addend; 1185 1186 if (saddend > 0x7fff || saddend < -0x8000) 1187 return bfd_reloc_overflow; 1188 1189 insn = addend; 1190 break; 1191 1192 case R_V850_SDA_15_16_OFFSET: 1193 case R_V850_ZDA_15_16_OFFSET: 1194 insn = bfd_get_16 (abfd, address); 1195 addend += (insn & 0xfffe); 1196 1197 saddend = (bfd_signed_vma) addend; 1198 1199 if (saddend > 0x7ffe || saddend < -0x8000) 1200 return bfd_reloc_overflow; 1201 1202 if (addend & 1) 1203 return bfd_reloc_dangerous; 1204 1205 insn = (addend &~ (bfd_vma) 1) | (insn & 1); 1206 break; 1207 1208 case R_V850_TDA_6_8_OFFSET: 1209 insn = bfd_get_16 (abfd, address); 1210 addend += ((insn & 0x7e) << 1); 1211 1212 saddend = (bfd_signed_vma) addend; 1213 1214 if (saddend > 0xfc || saddend < 0) 1215 return bfd_reloc_overflow; 1216 1217 if (addend & 3) 1218 return bfd_reloc_dangerous; 1219 1220 insn &= 0xff81; 1221 insn |= (addend >> 1); 1222 break; 1223 1224 case R_V850_TDA_7_8_OFFSET: 1225 insn = bfd_get_16 (abfd, address); 1226 addend += ((insn & 0x7f) << 1); 1227 1228 saddend = (bfd_signed_vma) addend; 1229 1230 if (saddend > 0xfe || saddend < 0) 1231 return bfd_reloc_overflow; 1232 1233 if (addend & 1) 1234 return bfd_reloc_dangerous; 1235 1236 insn &= 0xff80; 1237 insn |= (addend >> 1); 1238 break; 1239 1240 case R_V850_TDA_7_7_OFFSET: 1241 insn = bfd_get_16 (abfd, address); 1242 addend += insn & 0x7f; 1243 1244 saddend = (bfd_signed_vma) addend; 1245 1246 if (saddend > 0x7f || saddend < 0) 1247 return bfd_reloc_overflow; 1248 1249 insn &= 0xff80; 1250 insn |= addend; 1251 break; 1252 1253 case R_V850_TDA_4_5_OFFSET: 1254 insn = bfd_get_16 (abfd, address); 1255 addend += ((insn & 0xf) << 1); 1256 1257 saddend = (bfd_signed_vma) addend; 1258 1259 if (saddend > 0x1e || saddend < 0) 1260 return bfd_reloc_overflow; 1261 1262 if (addend & 1) 1263 return bfd_reloc_dangerous; 1264 1265 insn &= 0xfff0; 1266 insn |= (addend >> 1); 1267 break; 1268 1269 case R_V850_TDA_4_4_OFFSET: 1270 insn = bfd_get_16 (abfd, address); 1271 addend += insn & 0xf; 1272 1273 saddend = (bfd_signed_vma) addend; 1274 1275 if (saddend > 0xf || saddend < 0) 1276 return bfd_reloc_overflow; 1277 1278 insn &= 0xfff0; 1279 insn |= addend; 1280 break; 1281 1282 case R_V850_ZDA_16_16_SPLIT_OFFSET: 1283 case R_V850_SDA_16_16_SPLIT_OFFSET: 1284 insn = bfd_get_32 (abfd, address); 1285 addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5); 1286 1287 saddend = (bfd_signed_vma) addend; 1288 1289 if (saddend > 0x7fff || saddend < -0x8000) 1290 return bfd_reloc_overflow; 1291 1292 insn &= 0x0001ffdf; 1293 insn |= (addend & 1) << 5; 1294 insn |= (addend &~ (bfd_vma) 1) << 16; 1295 1296 bfd_put_32 (abfd, (bfd_vma) insn, address); 1297 return bfd_reloc_ok; 1298 1299 case R_V850_CALLT_6_7_OFFSET: 1300 insn = bfd_get_16 (abfd, address); 1301 addend += ((insn & 0x3f) << 1); 1302 1303 saddend = (bfd_signed_vma) addend; 1304 1305 if (saddend > 0x7e || saddend < 0) 1306 return bfd_reloc_overflow; 1307 1308 if (addend & 1) 1309 return bfd_reloc_dangerous; 1310 1311 insn &= 0xff80; 1312 insn |= (addend >> 1); 1313 break; 1314 1315 case R_V850_GNU_VTINHERIT: 1316 case R_V850_GNU_VTENTRY: 1317 return bfd_reloc_ok; 1318 1319 } 1320 1321 bfd_put_16 (abfd, (bfd_vma) insn, address); 1322 return bfd_reloc_ok; 1323 } 1324 1325 /* Insert the addend into the instruction. */ 1326 1327 static bfd_reloc_status_type 1328 v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err) 1329 bfd *abfd ATTRIBUTE_UNUSED; 1330 arelent *reloc; 1331 asymbol *symbol; 1332 PTR data ATTRIBUTE_UNUSED; 1333 asection *isection; 1334 bfd *obfd; 1335 char **err ATTRIBUTE_UNUSED; 1336 { 1337 long relocation; 1338 1339 /* If there is an output BFD, 1340 and the symbol is not a section name (which is only defined at final link time), 1341 and either we are not putting the addend into the instruction 1342 or the addend is zero, so there is nothing to add into the instruction 1343 then just fixup the address and return. */ 1344 if (obfd != (bfd *) NULL 1345 && (symbol->flags & BSF_SECTION_SYM) == 0 1346 && (! reloc->howto->partial_inplace 1347 || reloc->addend == 0)) 1348 { 1349 reloc->address += isection->output_offset; 1350 return bfd_reloc_ok; 1351 } 1352 1353 /* Catch relocs involving undefined symbols. */ 1354 if (bfd_is_und_section (symbol->section) 1355 && (symbol->flags & BSF_WEAK) == 0 1356 && obfd == NULL) 1357 return bfd_reloc_undefined; 1358 1359 /* We handle final linking of some relocs ourselves. */ 1360 1361 /* Is the address of the relocation really within the section? */ 1362 if (reloc->address > isection->_cooked_size) 1363 return bfd_reloc_outofrange; 1364 1365 /* Work out which section the relocation is targeted at and the 1366 initial relocation command value. */ 1367 1368 if (reloc->howto->pc_relative) 1369 return bfd_reloc_ok; 1370 1371 /* Get symbol value. (Common symbols are special.) */ 1372 if (bfd_is_com_section (symbol->section)) 1373 relocation = 0; 1374 else 1375 relocation = symbol->value; 1376 1377 /* Convert input-section-relative symbol value to absolute + addend. */ 1378 relocation += symbol->section->output_section->vma; 1379 relocation += symbol->section->output_offset; 1380 relocation += reloc->addend; 1381 1382 #if 0 /* Since this reloc is going to be processed later on, we should 1383 not make it pc-relative here. To test this, try assembling and 1384 linking this program: 1385 1386 .text 1387 .globl _start 1388 nop 1389 _start: 1390 jr foo 1391 1392 .section ".foo","ax" 1393 nop 1394 foo: 1395 nop */ 1396 if (reloc->howto->pc_relative) 1397 { 1398 /* Here the variable relocation holds the final address of the 1399 symbol we are relocating against, plus any addend. */ 1400 relocation -= isection->output_section->vma + isection->output_offset; 1401 1402 /* Deal with pcrel_offset. */ 1403 relocation -= reloc->address; 1404 } 1405 #endif 1406 reloc->addend = relocation; 1407 return bfd_reloc_ok; 1408 } 1409 1410 /* This function is used for relocs which are only used 1411 for relaxing, which the linker should otherwise ignore. */ 1412 1413 static bfd_reloc_status_type 1414 v850_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section, 1415 output_bfd, error_message) 1416 bfd *abfd ATTRIBUTE_UNUSED; 1417 arelent *reloc_entry; 1418 asymbol *symbol ATTRIBUTE_UNUSED; 1419 PTR data ATTRIBUTE_UNUSED; 1420 asection *input_section; 1421 bfd *output_bfd; 1422 char **error_message ATTRIBUTE_UNUSED; 1423 { 1424 if (output_bfd != NULL) 1425 reloc_entry->address += input_section->output_offset; 1426 1427 return bfd_reloc_ok; 1428 } 1429 1430 static bfd_boolean 1431 v850_elf_is_local_label_name (abfd, name) 1432 bfd *abfd ATTRIBUTE_UNUSED; 1433 const char *name; 1434 { 1435 return ( (name[0] == '.' && (name[1] == 'L' || name[1] == '.')) 1436 || (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')); 1437 } 1438 1439 /* We overload some of the bfd_reloc error codes for own purposes. */ 1440 #define bfd_reloc_gp_not_found bfd_reloc_other 1441 #define bfd_reloc_ep_not_found bfd_reloc_continue 1442 #define bfd_reloc_ctbp_not_found (bfd_reloc_dangerous + 1) 1443 1444 /* Perform a relocation as part of a final link. */ 1445 1446 static bfd_reloc_status_type 1447 v850_elf_final_link_relocate (howto, input_bfd, output_bfd, 1448 input_section, contents, offset, value, 1449 addend, info, sym_sec, is_local) 1450 reloc_howto_type *howto; 1451 bfd *input_bfd; 1452 bfd *output_bfd ATTRIBUTE_UNUSED; 1453 asection *input_section; 1454 bfd_byte *contents; 1455 bfd_vma offset; 1456 bfd_vma value; 1457 bfd_vma addend; 1458 struct bfd_link_info *info; 1459 asection *sym_sec; 1460 int is_local ATTRIBUTE_UNUSED; 1461 { 1462 unsigned int r_type = howto->type; 1463 bfd_byte *hit_data = contents + offset; 1464 1465 /* Adjust the value according to the relocation. */ 1466 switch (r_type) 1467 { 1468 case R_V850_9_PCREL: 1469 value -= (input_section->output_section->vma 1470 + input_section->output_offset); 1471 value -= offset; 1472 break; 1473 1474 case R_V850_22_PCREL: 1475 value -= (input_section->output_section->vma 1476 + input_section->output_offset 1477 + offset); 1478 1479 /* If the sign extension will corrupt the value then we have overflowed. */ 1480 if (((value & 0xff000000) != 0x0) && ((value & 0xff000000) != 0xff000000)) 1481 return bfd_reloc_overflow; 1482 1483 /* Only the bottom 24 bits of the PC are valid */ 1484 value = SEXT24 (value); 1485 break; 1486 1487 case R_V850_REL32: 1488 value -= (input_section->output_section->vma 1489 + input_section->output_offset 1490 + offset); 1491 break; 1492 1493 case R_V850_HI16_S: 1494 case R_V850_HI16: 1495 case R_V850_LO16: 1496 case R_V850_16: 1497 case R_V850_ABS32: 1498 case R_V850_8: 1499 break; 1500 1501 case R_V850_ZDA_15_16_OFFSET: 1502 case R_V850_ZDA_16_16_OFFSET: 1503 case R_V850_ZDA_16_16_SPLIT_OFFSET: 1504 if (sym_sec == NULL) 1505 return bfd_reloc_undefined; 1506 1507 value -= sym_sec->output_section->vma; 1508 break; 1509 1510 case R_V850_SDA_15_16_OFFSET: 1511 case R_V850_SDA_16_16_OFFSET: 1512 case R_V850_SDA_16_16_SPLIT_OFFSET: 1513 { 1514 unsigned long gp; 1515 struct bfd_link_hash_entry * h; 1516 1517 if (sym_sec == NULL) 1518 return bfd_reloc_undefined; 1519 1520 /* Get the value of __gp. */ 1521 h = bfd_link_hash_lookup (info->hash, "__gp", FALSE, FALSE, TRUE); 1522 if (h == (struct bfd_link_hash_entry *) NULL 1523 || h->type != bfd_link_hash_defined) 1524 return bfd_reloc_gp_not_found; 1525 1526 gp = (h->u.def.value 1527 + h->u.def.section->output_section->vma 1528 + h->u.def.section->output_offset); 1529 1530 value -= sym_sec->output_section->vma; 1531 value -= (gp - sym_sec->output_section->vma); 1532 } 1533 break; 1534 1535 case R_V850_TDA_4_4_OFFSET: 1536 case R_V850_TDA_4_5_OFFSET: 1537 case R_V850_TDA_16_16_OFFSET: 1538 case R_V850_TDA_7_7_OFFSET: 1539 case R_V850_TDA_7_8_OFFSET: 1540 case R_V850_TDA_6_8_OFFSET: 1541 { 1542 unsigned long ep; 1543 struct bfd_link_hash_entry * h; 1544 1545 /* Get the value of __ep. */ 1546 h = bfd_link_hash_lookup (info->hash, "__ep", FALSE, FALSE, TRUE); 1547 if (h == (struct bfd_link_hash_entry *) NULL 1548 || h->type != bfd_link_hash_defined) 1549 return bfd_reloc_ep_not_found; 1550 1551 ep = (h->u.def.value 1552 + h->u.def.section->output_section->vma 1553 + h->u.def.section->output_offset); 1554 1555 value -= ep; 1556 } 1557 break; 1558 1559 case R_V850_CALLT_6_7_OFFSET: 1560 { 1561 unsigned long ctbp; 1562 struct bfd_link_hash_entry * h; 1563 1564 /* Get the value of __ctbp. */ 1565 h = bfd_link_hash_lookup (info->hash, "__ctbp", FALSE, FALSE, TRUE); 1566 if (h == (struct bfd_link_hash_entry *) NULL 1567 || h->type != bfd_link_hash_defined) 1568 return bfd_reloc_ctbp_not_found; 1569 1570 ctbp = (h->u.def.value 1571 + h->u.def.section->output_section->vma 1572 + h->u.def.section->output_offset); 1573 value -= ctbp; 1574 } 1575 break; 1576 1577 case R_V850_CALLT_16_16_OFFSET: 1578 { 1579 unsigned long ctbp; 1580 struct bfd_link_hash_entry * h; 1581 1582 if (sym_sec == NULL) 1583 return bfd_reloc_undefined; 1584 1585 /* Get the value of __ctbp. */ 1586 h = bfd_link_hash_lookup (info->hash, "__ctbp", FALSE, FALSE, TRUE); 1587 if (h == (struct bfd_link_hash_entry *) NULL 1588 || h->type != bfd_link_hash_defined) 1589 return bfd_reloc_ctbp_not_found; 1590 1591 ctbp = (h->u.def.value 1592 + h->u.def.section->output_section->vma 1593 + h->u.def.section->output_offset); 1594 1595 value -= sym_sec->output_section->vma; 1596 value -= (ctbp - sym_sec->output_section->vma); 1597 } 1598 break; 1599 1600 case R_V850_NONE: 1601 case R_V850_GNU_VTINHERIT: 1602 case R_V850_GNU_VTENTRY: 1603 case R_V850_LONGCALL: 1604 case R_V850_LONGJUMP: 1605 case R_V850_ALIGN: 1606 return bfd_reloc_ok; 1607 1608 default: 1609 return bfd_reloc_notsupported; 1610 } 1611 1612 /* Perform the relocation. */ 1613 return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data); 1614 } 1615 1616 /* Relocate an V850 ELF section. */ 1617 1618 static bfd_boolean 1619 v850_elf_relocate_section (output_bfd, info, input_bfd, input_section, 1620 contents, relocs, local_syms, local_sections) 1621 bfd *output_bfd; 1622 struct bfd_link_info *info; 1623 bfd *input_bfd; 1624 asection *input_section; 1625 bfd_byte *contents; 1626 Elf_Internal_Rela *relocs; 1627 Elf_Internal_Sym *local_syms; 1628 asection **local_sections; 1629 { 1630 Elf_Internal_Shdr *symtab_hdr; 1631 struct elf_link_hash_entry **sym_hashes; 1632 Elf_Internal_Rela *rel; 1633 Elf_Internal_Rela *relend; 1634 1635 if (info->relocatable) 1636 return TRUE; 1637 1638 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 1639 sym_hashes = elf_sym_hashes (input_bfd); 1640 1641 if (sym_hashes == NULL) 1642 { 1643 info->callbacks->warning 1644 (info, "no hash table available", 1645 NULL, input_bfd, input_section, (bfd_vma) 0); 1646 1647 return FALSE; 1648 } 1649 1650 /* Reset the list of remembered HI16S relocs to empty. */ 1651 free_hi16s = previous_hi16s; 1652 previous_hi16s = NULL; 1653 hi16s_counter = 0; 1654 1655 rel = relocs; 1656 relend = relocs + input_section->reloc_count; 1657 for (; rel < relend; rel++) 1658 { 1659 int r_type; 1660 reloc_howto_type *howto; 1661 unsigned long r_symndx; 1662 Elf_Internal_Sym *sym; 1663 asection *sec; 1664 struct elf_link_hash_entry *h; 1665 bfd_vma relocation; 1666 bfd_reloc_status_type r; 1667 1668 r_symndx = ELF32_R_SYM (rel->r_info); 1669 r_type = ELF32_R_TYPE (rel->r_info); 1670 1671 if (r_type == R_V850_GNU_VTENTRY 1672 || r_type == R_V850_GNU_VTINHERIT) 1673 continue; 1674 1675 /* This is a final link. */ 1676 howto = v850_elf_howto_table + r_type; 1677 h = NULL; 1678 sym = NULL; 1679 sec = NULL; 1680 if (r_symndx < symtab_hdr->sh_info) 1681 { 1682 sym = local_syms + r_symndx; 1683 sec = local_sections[r_symndx]; 1684 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1685 #if 0 1686 { 1687 char * name; 1688 1689 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name); 1690 name = (name == NULL) ? "<none>" : name; 1691 fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n", 1692 sec->name, name, sym->st_name, 1693 sec->output_section->vma, sec->output_offset, sym->st_value, rel->r_addend); 1694 } 1695 #endif 1696 } 1697 else 1698 { 1699 bfd_boolean unresolved_reloc, warned; 1700 1701 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1702 r_symndx, symtab_hdr, sym_hashes, 1703 h, sec, relocation, 1704 unresolved_reloc, warned); 1705 } 1706 1707 /* FIXME: We should use the addend, but the COFF relocations don't. */ 1708 r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd, 1709 input_section, 1710 contents, rel->r_offset, 1711 relocation, rel->r_addend, 1712 info, sec, h == NULL); 1713 1714 if (r != bfd_reloc_ok) 1715 { 1716 const char * name; 1717 const char * msg = (const char *)0; 1718 1719 if (h != NULL) 1720 name = h->root.root.string; 1721 else 1722 { 1723 name = (bfd_elf_string_from_elf_section 1724 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 1725 if (name == NULL || *name == '\0') 1726 name = bfd_section_name (input_bfd, sec); 1727 } 1728 1729 switch (r) 1730 { 1731 case bfd_reloc_overflow: 1732 if (! ((*info->callbacks->reloc_overflow) 1733 (info, name, howto->name, (bfd_vma) 0, 1734 input_bfd, input_section, rel->r_offset))) 1735 return FALSE; 1736 break; 1737 1738 case bfd_reloc_undefined: 1739 if (! ((*info->callbacks->undefined_symbol) 1740 (info, name, input_bfd, input_section, 1741 rel->r_offset, TRUE))) 1742 return FALSE; 1743 break; 1744 1745 case bfd_reloc_outofrange: 1746 msg = _("internal error: out of range error"); 1747 goto common_error; 1748 1749 case bfd_reloc_notsupported: 1750 msg = _("internal error: unsupported relocation error"); 1751 goto common_error; 1752 1753 case bfd_reloc_dangerous: 1754 msg = _("internal error: dangerous relocation"); 1755 goto common_error; 1756 1757 case bfd_reloc_gp_not_found: 1758 msg = _("could not locate special linker symbol __gp"); 1759 goto common_error; 1760 1761 case bfd_reloc_ep_not_found: 1762 msg = _("could not locate special linker symbol __ep"); 1763 goto common_error; 1764 1765 case bfd_reloc_ctbp_not_found: 1766 msg = _("could not locate special linker symbol __ctbp"); 1767 goto common_error; 1768 1769 default: 1770 msg = _("internal error: unknown error"); 1771 /* fall through */ 1772 1773 common_error: 1774 if (!((*info->callbacks->warning) 1775 (info, msg, name, input_bfd, input_section, 1776 rel->r_offset))) 1777 return FALSE; 1778 break; 1779 } 1780 } 1781 } 1782 1783 return TRUE; 1784 } 1785 1786 static bfd_boolean 1787 v850_elf_gc_sweep_hook (abfd, info, sec, relocs) 1788 bfd *abfd ATTRIBUTE_UNUSED; 1789 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1790 asection *sec ATTRIBUTE_UNUSED; 1791 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED; 1792 { 1793 /* No got and plt entries for v850-elf. */ 1794 return TRUE; 1795 } 1796 1797 static asection * 1798 v850_elf_gc_mark_hook (sec, info, rel, h, sym) 1799 asection *sec; 1800 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1801 Elf_Internal_Rela *rel; 1802 struct elf_link_hash_entry *h; 1803 Elf_Internal_Sym *sym; 1804 { 1805 if (h != NULL) 1806 { 1807 switch (ELF32_R_TYPE (rel->r_info)) 1808 { 1809 case R_V850_GNU_VTINHERIT: 1810 case R_V850_GNU_VTENTRY: 1811 break; 1812 1813 default: 1814 switch (h->root.type) 1815 { 1816 case bfd_link_hash_defined: 1817 case bfd_link_hash_defweak: 1818 return h->root.u.def.section; 1819 1820 case bfd_link_hash_common: 1821 return h->root.u.c.p->section; 1822 1823 default: 1824 break; 1825 } 1826 } 1827 } 1828 else 1829 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 1830 1831 return NULL; 1832 } 1833 1834 /* Set the right machine number. */ 1835 1836 static bfd_boolean 1837 v850_elf_object_p (abfd) 1838 bfd *abfd; 1839 { 1840 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH) 1841 { 1842 default: 1843 case E_V850_ARCH: 1844 bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850); 1845 break; 1846 case E_V850E_ARCH: 1847 bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e); 1848 break; 1849 case E_V850E1_ARCH: 1850 bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e1); 1851 break; 1852 } 1853 return TRUE; 1854 } 1855 1856 /* Store the machine number in the flags field. */ 1857 1858 static void 1859 v850_elf_final_write_processing (abfd, linker) 1860 bfd *abfd; 1861 bfd_boolean linker ATTRIBUTE_UNUSED; 1862 { 1863 unsigned long val; 1864 1865 switch (bfd_get_mach (abfd)) 1866 { 1867 default: 1868 case bfd_mach_v850: val = E_V850_ARCH; break; 1869 case bfd_mach_v850e: val = E_V850E_ARCH; break; 1870 case bfd_mach_v850e1: val = E_V850E1_ARCH; break; 1871 } 1872 1873 elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH; 1874 elf_elfheader (abfd)->e_flags |= val; 1875 } 1876 1877 /* Function to keep V850 specific file flags. */ 1878 1879 static bfd_boolean 1880 v850_elf_set_private_flags (abfd, flags) 1881 bfd *abfd; 1882 flagword flags; 1883 { 1884 BFD_ASSERT (!elf_flags_init (abfd) 1885 || elf_elfheader (abfd)->e_flags == flags); 1886 1887 elf_elfheader (abfd)->e_flags = flags; 1888 elf_flags_init (abfd) = TRUE; 1889 return TRUE; 1890 } 1891 1892 /* Merge backend specific data from an object file 1893 to the output object file when linking. */ 1894 static bfd_boolean 1895 v850_elf_merge_private_bfd_data (ibfd, obfd) 1896 bfd *ibfd; 1897 bfd *obfd; 1898 { 1899 flagword out_flags; 1900 flagword in_flags; 1901 1902 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1903 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 1904 return TRUE; 1905 1906 in_flags = elf_elfheader (ibfd)->e_flags; 1907 out_flags = elf_elfheader (obfd)->e_flags; 1908 1909 if (! elf_flags_init (obfd)) 1910 { 1911 /* If the input is the default architecture then do not 1912 bother setting the flags for the output architecture, 1913 instead allow future merges to do this. If no future 1914 merges ever set these flags then they will retain their 1915 unitialised values, which surprise surprise, correspond 1916 to the default values. */ 1917 if (bfd_get_arch_info (ibfd)->the_default) 1918 return TRUE; 1919 1920 elf_flags_init (obfd) = TRUE; 1921 elf_elfheader (obfd)->e_flags = in_flags; 1922 1923 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 1924 && bfd_get_arch_info (obfd)->the_default) 1925 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd)); 1926 1927 return TRUE; 1928 } 1929 1930 /* Check flag compatibility. */ 1931 if (in_flags == out_flags) 1932 return TRUE; 1933 1934 if ((in_flags & EF_V850_ARCH) != (out_flags & EF_V850_ARCH) 1935 && (in_flags & EF_V850_ARCH) != E_V850_ARCH) 1936 { 1937 /* Allow v850e1 binaries to be linked with v850e binaries. 1938 Set the output binary to v850e. */ 1939 if ((in_flags & EF_V850_ARCH) == E_V850E1_ARCH 1940 && (out_flags & EF_V850_ARCH) == E_V850E_ARCH) 1941 return TRUE; 1942 1943 if ((in_flags & EF_V850_ARCH) == E_V850E_ARCH 1944 && (out_flags & EF_V850_ARCH) == E_V850E1_ARCH) 1945 { 1946 elf_elfheader (obfd)->e_flags = 1947 ((out_flags & ~ EF_V850_ARCH) | E_V850E_ARCH); 1948 return TRUE; 1949 } 1950 1951 _bfd_error_handler (_("%s: Architecture mismatch with previous modules"), 1952 bfd_archive_filename (ibfd)); 1953 } 1954 1955 return TRUE; 1956 } 1957 1958 /* Display the flags field. */ 1959 1960 static bfd_boolean 1961 v850_elf_print_private_bfd_data (abfd, ptr) 1962 bfd *abfd; 1963 PTR ptr; 1964 { 1965 FILE * file = (FILE *) ptr; 1966 1967 BFD_ASSERT (abfd != NULL && ptr != NULL); 1968 1969 _bfd_elf_print_private_bfd_data (abfd, ptr); 1970 1971 /* xgettext:c-format */ 1972 fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags); 1973 1974 switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH) 1975 { 1976 default: 1977 case E_V850_ARCH: fprintf (file, _("v850 architecture")); break; 1978 case E_V850E_ARCH: fprintf (file, _("v850e architecture")); break; 1979 case E_V850E1_ARCH: fprintf (file, _("v850e1 architecture")); break; 1980 } 1981 1982 fputc ('\n', file); 1983 1984 return TRUE; 1985 } 1986 1987 /* V850 ELF uses four common sections. One is the usual one, and the 1988 others are for (small) objects in one of the special data areas: 1989 small, tiny and zero. All the objects are kept together, and then 1990 referenced via the gp register, the ep register or the r0 register 1991 respectively, which yields smaller, faster assembler code. This 1992 approach is copied from elf32-mips.c. */ 1993 1994 static asection v850_elf_scom_section; 1995 static asymbol v850_elf_scom_symbol; 1996 static asymbol * v850_elf_scom_symbol_ptr; 1997 static asection v850_elf_tcom_section; 1998 static asymbol v850_elf_tcom_symbol; 1999 static asymbol * v850_elf_tcom_symbol_ptr; 2000 static asection v850_elf_zcom_section; 2001 static asymbol v850_elf_zcom_symbol; 2002 static asymbol * v850_elf_zcom_symbol_ptr; 2003 2004 /* Given a BFD section, try to locate the 2005 corresponding ELF section index. */ 2006 2007 static bfd_boolean 2008 v850_elf_section_from_bfd_section (abfd, sec, retval) 2009 bfd *abfd ATTRIBUTE_UNUSED; 2010 asection *sec; 2011 int *retval; 2012 { 2013 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0) 2014 *retval = SHN_V850_SCOMMON; 2015 else if (strcmp (bfd_get_section_name (abfd, sec), ".tcommon") == 0) 2016 *retval = SHN_V850_TCOMMON; 2017 else if (strcmp (bfd_get_section_name (abfd, sec), ".zcommon") == 0) 2018 *retval = SHN_V850_ZCOMMON; 2019 else 2020 return FALSE; 2021 2022 return TRUE; 2023 } 2024 2025 /* Handle the special V850 section numbers that a symbol may use. */ 2026 2027 static void 2028 v850_elf_symbol_processing (abfd, asym) 2029 bfd *abfd; 2030 asymbol *asym; 2031 { 2032 elf_symbol_type * elfsym = (elf_symbol_type *) asym; 2033 unsigned int indx; 2034 2035 indx = elfsym->internal_elf_sym.st_shndx; 2036 2037 /* If the section index is an "ordinary" index, then it may 2038 refer to a v850 specific section created by the assembler. 2039 Check the section's type and change the index it matches. 2040 2041 FIXME: Should we alter the st_shndx field as well ? */ 2042 2043 if (indx < elf_numsections (abfd)) 2044 switch (elf_elfsections(abfd)[indx]->sh_type) 2045 { 2046 case SHT_V850_SCOMMON: 2047 indx = SHN_V850_SCOMMON; 2048 break; 2049 2050 case SHT_V850_TCOMMON: 2051 indx = SHN_V850_TCOMMON; 2052 break; 2053 2054 case SHT_V850_ZCOMMON: 2055 indx = SHN_V850_ZCOMMON; 2056 break; 2057 2058 default: 2059 break; 2060 } 2061 2062 switch (indx) 2063 { 2064 case SHN_V850_SCOMMON: 2065 if (v850_elf_scom_section.name == NULL) 2066 { 2067 /* Initialize the small common section. */ 2068 v850_elf_scom_section.name = ".scommon"; 2069 v850_elf_scom_section.flags = SEC_IS_COMMON | SEC_ALLOC | SEC_DATA; 2070 v850_elf_scom_section.output_section = & v850_elf_scom_section; 2071 v850_elf_scom_section.symbol = & v850_elf_scom_symbol; 2072 v850_elf_scom_section.symbol_ptr_ptr = & v850_elf_scom_symbol_ptr; 2073 v850_elf_scom_symbol.name = ".scommon"; 2074 v850_elf_scom_symbol.flags = BSF_SECTION_SYM; 2075 v850_elf_scom_symbol.section = & v850_elf_scom_section; 2076 v850_elf_scom_symbol_ptr = & v850_elf_scom_symbol; 2077 } 2078 asym->section = & v850_elf_scom_section; 2079 asym->value = elfsym->internal_elf_sym.st_size; 2080 break; 2081 2082 case SHN_V850_TCOMMON: 2083 if (v850_elf_tcom_section.name == NULL) 2084 { 2085 /* Initialize the tcommon section. */ 2086 v850_elf_tcom_section.name = ".tcommon"; 2087 v850_elf_tcom_section.flags = SEC_IS_COMMON; 2088 v850_elf_tcom_section.output_section = & v850_elf_tcom_section; 2089 v850_elf_tcom_section.symbol = & v850_elf_tcom_symbol; 2090 v850_elf_tcom_section.symbol_ptr_ptr = & v850_elf_tcom_symbol_ptr; 2091 v850_elf_tcom_symbol.name = ".tcommon"; 2092 v850_elf_tcom_symbol.flags = BSF_SECTION_SYM; 2093 v850_elf_tcom_symbol.section = & v850_elf_tcom_section; 2094 v850_elf_tcom_symbol_ptr = & v850_elf_tcom_symbol; 2095 } 2096 asym->section = & v850_elf_tcom_section; 2097 asym->value = elfsym->internal_elf_sym.st_size; 2098 break; 2099 2100 case SHN_V850_ZCOMMON: 2101 if (v850_elf_zcom_section.name == NULL) 2102 { 2103 /* Initialize the zcommon section. */ 2104 v850_elf_zcom_section.name = ".zcommon"; 2105 v850_elf_zcom_section.flags = SEC_IS_COMMON; 2106 v850_elf_zcom_section.output_section = & v850_elf_zcom_section; 2107 v850_elf_zcom_section.symbol = & v850_elf_zcom_symbol; 2108 v850_elf_zcom_section.symbol_ptr_ptr = & v850_elf_zcom_symbol_ptr; 2109 v850_elf_zcom_symbol.name = ".zcommon"; 2110 v850_elf_zcom_symbol.flags = BSF_SECTION_SYM; 2111 v850_elf_zcom_symbol.section = & v850_elf_zcom_section; 2112 v850_elf_zcom_symbol_ptr = & v850_elf_zcom_symbol; 2113 } 2114 asym->section = & v850_elf_zcom_section; 2115 asym->value = elfsym->internal_elf_sym.st_size; 2116 break; 2117 } 2118 } 2119 2120 /* Hook called by the linker routine which adds symbols from an object 2121 file. We must handle the special v850 section numbers here. */ 2122 2123 static bfd_boolean 2124 v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp) 2125 bfd *abfd; 2126 struct bfd_link_info *info ATTRIBUTE_UNUSED; 2127 Elf_Internal_Sym *sym; 2128 const char **namep ATTRIBUTE_UNUSED; 2129 flagword *flagsp ATTRIBUTE_UNUSED; 2130 asection **secp; 2131 bfd_vma *valp; 2132 { 2133 unsigned int indx = sym->st_shndx; 2134 2135 /* If the section index is an "ordinary" index, then it may 2136 refer to a v850 specific section created by the assembler. 2137 Check the section's type and change the index it matches. 2138 2139 FIXME: Should we alter the st_shndx field as well ? */ 2140 2141 if (indx < elf_numsections (abfd)) 2142 switch (elf_elfsections(abfd)[indx]->sh_type) 2143 { 2144 case SHT_V850_SCOMMON: 2145 indx = SHN_V850_SCOMMON; 2146 break; 2147 2148 case SHT_V850_TCOMMON: 2149 indx = SHN_V850_TCOMMON; 2150 break; 2151 2152 case SHT_V850_ZCOMMON: 2153 indx = SHN_V850_ZCOMMON; 2154 break; 2155 2156 default: 2157 break; 2158 } 2159 2160 switch (indx) 2161 { 2162 case SHN_V850_SCOMMON: 2163 *secp = bfd_make_section_old_way (abfd, ".scommon"); 2164 (*secp)->flags |= SEC_IS_COMMON; 2165 *valp = sym->st_size; 2166 break; 2167 2168 case SHN_V850_TCOMMON: 2169 *secp = bfd_make_section_old_way (abfd, ".tcommon"); 2170 (*secp)->flags |= SEC_IS_COMMON; 2171 *valp = sym->st_size; 2172 break; 2173 2174 case SHN_V850_ZCOMMON: 2175 *secp = bfd_make_section_old_way (abfd, ".zcommon"); 2176 (*secp)->flags |= SEC_IS_COMMON; 2177 *valp = sym->st_size; 2178 break; 2179 } 2180 2181 return TRUE; 2182 } 2183 2184 static bfd_boolean 2185 v850_elf_link_output_symbol_hook (info, name, sym, input_sec, h) 2186 struct bfd_link_info *info ATTRIBUTE_UNUSED; 2187 const char *name ATTRIBUTE_UNUSED; 2188 Elf_Internal_Sym *sym; 2189 asection *input_sec; 2190 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED; 2191 { 2192 /* If we see a common symbol, which implies a relocatable link, then 2193 if a symbol was in a special common section in an input file, mark 2194 it as a special common in the output file. */ 2195 2196 if (sym->st_shndx == SHN_COMMON) 2197 { 2198 if (strcmp (input_sec->name, ".scommon") == 0) 2199 sym->st_shndx = SHN_V850_SCOMMON; 2200 else if (strcmp (input_sec->name, ".tcommon") == 0) 2201 sym->st_shndx = SHN_V850_TCOMMON; 2202 else if (strcmp (input_sec->name, ".zcommon") == 0) 2203 sym->st_shndx = SHN_V850_ZCOMMON; 2204 } 2205 2206 return TRUE; 2207 } 2208 2209 static bfd_boolean 2210 v850_elf_section_from_shdr (abfd, hdr, name) 2211 bfd *abfd; 2212 Elf_Internal_Shdr *hdr; 2213 const char *name; 2214 { 2215 /* There ought to be a place to keep ELF backend specific flags, but 2216 at the moment there isn't one. We just keep track of the 2217 sections by their name, instead. */ 2218 2219 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name)) 2220 return FALSE; 2221 2222 switch (hdr->sh_type) 2223 { 2224 case SHT_V850_SCOMMON: 2225 case SHT_V850_TCOMMON: 2226 case SHT_V850_ZCOMMON: 2227 if (! bfd_set_section_flags (abfd, hdr->bfd_section, 2228 (bfd_get_section_flags (abfd, 2229 hdr->bfd_section) 2230 | SEC_IS_COMMON))) 2231 return FALSE; 2232 } 2233 2234 return TRUE; 2235 } 2236 2237 /* Set the correct type for a V850 ELF section. We do this 2238 by the section name, which is a hack, but ought to work. */ 2239 2240 static bfd_boolean 2241 v850_elf_fake_sections (abfd, hdr, sec) 2242 bfd *abfd ATTRIBUTE_UNUSED; 2243 Elf_Internal_Shdr *hdr; 2244 asection *sec; 2245 { 2246 register const char * name; 2247 2248 name = bfd_get_section_name (abfd, sec); 2249 2250 if (strcmp (name, ".scommon") == 0) 2251 { 2252 hdr->sh_type = SHT_V850_SCOMMON; 2253 } 2254 else if (strcmp (name, ".tcommon") == 0) 2255 { 2256 hdr->sh_type = SHT_V850_TCOMMON; 2257 } 2258 else if (strcmp (name, ".zcommon") == 0) 2259 hdr->sh_type = SHT_V850_ZCOMMON; 2260 2261 return TRUE; 2262 } 2263 2264 /* Delete some bytes from a section while relaxing. */ 2265 2266 static bfd_boolean 2267 v850_elf_relax_delete_bytes (abfd, sec, addr, toaddr, count) 2268 bfd *abfd; 2269 asection *sec; 2270 bfd_vma addr; 2271 bfd_vma toaddr; 2272 int count; 2273 { 2274 Elf_Internal_Shdr *symtab_hdr; 2275 Elf32_External_Sym *extsyms; 2276 Elf32_External_Sym *esym; 2277 Elf32_External_Sym *esymend; 2278 int index; 2279 unsigned int sec_shndx; 2280 bfd_byte *contents; 2281 Elf_Internal_Rela *irel; 2282 Elf_Internal_Rela *irelend; 2283 struct elf_link_hash_entry *sym_hash; 2284 Elf_Internal_Shdr *shndx_hdr; 2285 Elf_External_Sym_Shndx *shndx; 2286 2287 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2288 extsyms = (Elf32_External_Sym *) symtab_hdr->contents; 2289 2290 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 2291 2292 contents = elf_section_data (sec)->this_hdr.contents; 2293 2294 /* The deletion must stop at the next ALIGN reloc for an alignment 2295 power larger than the number of bytes we are deleting. */ 2296 2297 /* Actually delete the bytes. */ 2298 #if (DEBUG_RELAX & 2) 2299 fprintf (stderr, "relax_delete: contents: sec: %s %p .. %p %x\n", 2300 sec->name, addr, toaddr, count ); 2301 #endif 2302 memmove (contents + addr, contents + addr + count, 2303 toaddr - addr - count); 2304 memset (contents + toaddr-count, 0, count); 2305 2306 /* Adjust all the relocs. */ 2307 irel = elf_section_data (sec)->relocs; 2308 irelend = irel + sec->reloc_count; 2309 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 2310 shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents; 2311 2312 for (; irel < irelend; irel++) 2313 { 2314 bfd_vma raddr, paddr, symval; 2315 Elf_Internal_Sym isym; 2316 2317 /* Get the new reloc address. */ 2318 raddr = irel->r_offset; 2319 if ((raddr >= (addr + count) && raddr < toaddr)) 2320 irel->r_offset -= count; 2321 2322 if (raddr >= addr && raddr < addr + count) 2323 { 2324 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 2325 (int) R_V850_NONE); 2326 continue; 2327 } 2328 2329 if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN) 2330 continue; 2331 2332 bfd_elf32_swap_symbol_in (abfd, 2333 extsyms + ELF32_R_SYM (irel->r_info), 2334 shndx ? shndx + ELF32_R_SYM (irel->r_info) : NULL, 2335 & isym); 2336 2337 if (isym.st_shndx != sec_shndx) 2338 continue; 2339 2340 /* Get the value of the symbol referred to by the reloc. */ 2341 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 2342 { 2343 symval = isym.st_value; 2344 #if (DEBUG_RELAX & 2) 2345 { 2346 char * name = bfd_elf_string_from_elf_section 2347 (abfd, symtab_hdr->sh_link, isym.st_name); 2348 fprintf (stderr, 2349 "relax_delete: local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n", 2350 sec->name, name, isym.st_name, 2351 sec->output_section->vma, sec->output_offset, 2352 isym.st_value, irel->r_addend); 2353 } 2354 #endif 2355 } 2356 else 2357 { 2358 unsigned long indx; 2359 struct elf_link_hash_entry * h; 2360 2361 /* An external symbol. */ 2362 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 2363 2364 h = elf_sym_hashes (abfd) [indx]; 2365 BFD_ASSERT (h != NULL); 2366 2367 symval = h->root.u.def.value; 2368 #if (DEBUG_RELAX & 2) 2369 fprintf (stderr, 2370 "relax_delete: defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n", 2371 sec->name, h->root.root.string, h->root.u.def.value, 2372 sec->output_section->vma, sec->output_offset, irel->r_addend); 2373 #endif 2374 } 2375 2376 paddr = symval + irel->r_addend; 2377 2378 if ( (symval >= addr + count && symval < toaddr) 2379 && (paddr < addr + count || paddr >= toaddr)) 2380 irel->r_addend += count; 2381 else if ( (symval < addr + count || symval >= toaddr) 2382 && (paddr >= addr + count && paddr < toaddr)) 2383 irel->r_addend -= count; 2384 } 2385 2386 /* Adjust the local symbols defined in this section. */ 2387 esym = extsyms; 2388 esymend = esym + symtab_hdr->sh_info; 2389 2390 for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL)) 2391 { 2392 Elf_Internal_Sym isym; 2393 2394 bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym); 2395 2396 if (isym.st_shndx == sec_shndx 2397 && isym.st_value >= addr + count 2398 && isym.st_value < toaddr) 2399 { 2400 isym.st_value -= count; 2401 2402 if (isym.st_value + isym.st_size >= toaddr) 2403 isym.st_size += count; 2404 2405 bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx); 2406 } 2407 else if (isym.st_shndx == sec_shndx 2408 && isym.st_value < addr + count) 2409 { 2410 if (isym.st_value+isym.st_size >= addr + count 2411 && isym.st_value+isym.st_size < toaddr) 2412 isym.st_size -= count; 2413 2414 if (isym.st_value >= addr 2415 && isym.st_value < addr + count) 2416 isym.st_value = addr; 2417 2418 bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx); 2419 } 2420 } 2421 2422 /* Now adjust the global symbols defined in this section. */ 2423 esym = extsyms + symtab_hdr->sh_info; 2424 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)); 2425 2426 for (index = 0; esym < esymend; esym ++, index ++) 2427 { 2428 Elf_Internal_Sym isym; 2429 2430 bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym); 2431 sym_hash = elf_sym_hashes (abfd) [index]; 2432 2433 if (isym.st_shndx == sec_shndx 2434 && ((sym_hash)->root.type == bfd_link_hash_defined 2435 || (sym_hash)->root.type == bfd_link_hash_defweak) 2436 && (sym_hash)->root.u.def.section == sec 2437 && (sym_hash)->root.u.def.value >= addr + count 2438 && (sym_hash)->root.u.def.value < toaddr) 2439 { 2440 if ((sym_hash)->root.u.def.value + isym.st_size >= toaddr) 2441 { 2442 isym.st_size += count; 2443 bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx); 2444 } 2445 2446 (sym_hash)->root.u.def.value -= count; 2447 } 2448 else if (isym.st_shndx == sec_shndx 2449 && ((sym_hash)->root.type == bfd_link_hash_defined 2450 || (sym_hash)->root.type == bfd_link_hash_defweak) 2451 && (sym_hash)->root.u.def.section == sec 2452 && (sym_hash)->root.u.def.value < addr + count) 2453 { 2454 if ((sym_hash)->root.u.def.value+isym.st_size >= addr + count 2455 && (sym_hash)->root.u.def.value+isym.st_size < toaddr) 2456 isym.st_size -= count; 2457 2458 if ((sym_hash)->root.u.def.value >= addr 2459 && (sym_hash)->root.u.def.value < addr + count) 2460 (sym_hash)->root.u.def.value = addr; 2461 2462 bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx); 2463 } 2464 2465 if (shndx) 2466 ++ shndx; 2467 } 2468 2469 return TRUE; 2470 } 2471 2472 #define NOP_OPCODE (0x0000) 2473 #define MOVHI 0x0640 /* 4byte */ 2474 #define MOVHI_MASK 0x07e0 2475 #define MOVHI_R1(insn) ((insn) & 0x1f) /* 4byte */ 2476 #define MOVHI_R2(insn) ((insn) >> 11) 2477 #define MOVEA 0x0620 /* 2byte */ 2478 #define MOVEA_MASK 0x07e0 2479 #define MOVEA_R1(insn) ((insn) & 0x1f) 2480 #define MOVEA_R2(insn) ((insn) >> 11) 2481 #define JARL_4 0x00040780 /* 4byte */ 2482 #define JARL_4_MASK 0xFFFF07FF 2483 #define JARL_R2(insn) (int)(((insn) & (~JARL_4_MASK)) >> 11) 2484 #define ADD_I 0x0240 /* 2byte */ 2485 #define ADD_I_MASK 0x07e0 2486 #define ADD_I5(insn) ((((insn) & 0x001f) << 11) >> 11) /* 2byte */ 2487 #define ADD_R2(insn) ((insn) >> 11) 2488 #define JMP_R 0x0060 /* 2byte */ 2489 #define JMP_R_MASK 0xFFE0 2490 #define JMP_R1(insn) ((insn) & 0x1f) 2491 2492 static bfd_boolean 2493 v850_elf_relax_section (abfd, sec, link_info, again) 2494 bfd *abfd; 2495 asection *sec; 2496 struct bfd_link_info *link_info; 2497 bfd_boolean *again; 2498 { 2499 Elf_Internal_Shdr *symtab_hdr; 2500 Elf_Internal_Rela *internal_relocs; 2501 Elf_Internal_Rela *irel; 2502 Elf_Internal_Rela *irelend; 2503 Elf_Internal_Rela *irelalign = NULL; 2504 Elf_Internal_Sym *isymbuf = NULL; 2505 bfd_byte *contents = NULL; 2506 bfd_vma addr = 0; 2507 bfd_vma toaddr; 2508 int align_pad_size = 0; 2509 bfd_boolean result = TRUE; 2510 2511 *again = FALSE; 2512 2513 if (link_info->relocatable 2514 || (sec->flags & SEC_RELOC) == 0 2515 || sec->reloc_count == 0) 2516 return TRUE; 2517 2518 /* If this is the first time we have been called 2519 for this section, initialize the cooked size. */ 2520 if (sec->_cooked_size == 0) 2521 sec->_cooked_size = sec->_raw_size; 2522 2523 symtab_hdr = & elf_tdata (abfd)->symtab_hdr; 2524 2525 internal_relocs = (_bfd_elf_link_read_relocs 2526 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 2527 link_info->keep_memory)); 2528 if (internal_relocs == NULL) 2529 goto error_return; 2530 2531 irelend = internal_relocs + sec->reloc_count; 2532 2533 while (addr < sec->_cooked_size) 2534 { 2535 toaddr = sec->_cooked_size; 2536 2537 for (irel = internal_relocs; irel < irelend; irel ++) 2538 if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN 2539 && irel->r_offset > addr 2540 && irel->r_offset < toaddr) 2541 toaddr = irel->r_offset; 2542 2543 #ifdef DEBUG_RELAX 2544 fprintf (stderr, "relax region 0x%x to 0x%x align pad %d\n", 2545 addr, toaddr, align_pad_size); 2546 #endif 2547 if (irelalign) 2548 { 2549 bfd_vma alignto; 2550 bfd_vma alignmoveto; 2551 2552 alignmoveto = BFD_ALIGN (addr - align_pad_size, 1 << irelalign->r_addend); 2553 alignto = BFD_ALIGN (addr, 1 << irelalign->r_addend); 2554 2555 if (alignmoveto < alignto) 2556 { 2557 unsigned int i; 2558 2559 align_pad_size = alignto - alignmoveto; 2560 #ifdef DEBUG_RELAX 2561 fprintf (stderr, "relax move region 0x%x to 0x%x delete size 0x%x\n", 2562 alignmoveto, toaddr, align_pad_size); 2563 #endif 2564 if (!v850_elf_relax_delete_bytes (abfd, sec, alignmoveto, 2565 toaddr, align_pad_size)) 2566 goto error_return; 2567 2568 for (i = BFD_ALIGN (toaddr - align_pad_size, 1); 2569 (i + 1) < toaddr; i += 2) 2570 bfd_put_16 (abfd, NOP_OPCODE, contents + i); 2571 2572 addr = alignmoveto; 2573 } 2574 else 2575 align_pad_size = 0; 2576 } 2577 2578 for (irel = internal_relocs; irel < irelend; irel++) 2579 { 2580 bfd_vma laddr; 2581 bfd_vma addend; 2582 bfd_vma symval; 2583 int insn[5]; 2584 int no_match = -1; 2585 Elf_Internal_Rela *hi_irelfn; 2586 Elf_Internal_Rela *lo_irelfn; 2587 Elf_Internal_Rela *irelcall; 2588 bfd_signed_vma foff; 2589 2590 if (! (irel->r_offset >= addr && irel->r_offset < toaddr 2591 && (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL 2592 || ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP))) 2593 continue; 2594 2595 #ifdef DEBUG_RELAX 2596 fprintf (stderr, "relax check r_info 0x%x r_offset 0x%x r_addend 0x%x\n", 2597 irel->r_info, 2598 irel->r_offset, 2599 irel->r_addend ); 2600 #endif 2601 2602 /* Get the section contents. */ 2603 if (contents == NULL) 2604 { 2605 if (elf_section_data (sec)->this_hdr.contents != NULL) 2606 contents = elf_section_data (sec)->this_hdr.contents; 2607 else 2608 { 2609 contents = (bfd_byte *) bfd_malloc (sec->_raw_size); 2610 if (contents == NULL) 2611 goto error_return; 2612 2613 if (! bfd_get_section_contents (abfd, sec, contents, 2614 (file_ptr) 0, sec->_raw_size)) 2615 goto error_return; 2616 } 2617 } 2618 2619 /* Read this BFD's local symbols if we haven't done so already. */ 2620 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 2621 { 2622 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 2623 if (isymbuf == NULL) 2624 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 2625 symtab_hdr->sh_info, 0, 2626 NULL, NULL, NULL); 2627 if (isymbuf == NULL) 2628 goto error_return; 2629 } 2630 2631 laddr = irel->r_offset; 2632 2633 if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL) 2634 { 2635 /* Check code for -mlong-calls output. */ 2636 if (laddr + 16 <= (bfd_vma) sec->_raw_size) 2637 { 2638 insn[0] = bfd_get_16 (abfd, contents + laddr); 2639 insn[1] = bfd_get_16 (abfd, contents + laddr + 4); 2640 insn[2] = bfd_get_32 (abfd, contents + laddr + 8); 2641 insn[3] = bfd_get_16 (abfd, contents + laddr + 12); 2642 insn[4] = bfd_get_16 (abfd, contents + laddr + 14); 2643 2644 if ((insn[0] & MOVHI_MASK) != MOVHI 2645 || MOVHI_R1 (insn[0]) != 0) 2646 no_match = 0; 2647 2648 if (no_match < 0 2649 && ((insn[1] & MOVEA_MASK) != MOVEA 2650 || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1]))) 2651 no_match = 1; 2652 2653 if (no_match < 0 2654 && (insn[2] & JARL_4_MASK) != JARL_4) 2655 no_match = 2; 2656 2657 if (no_match < 0 2658 && ((insn[3] & ADD_I_MASK) != ADD_I 2659 || ADD_I5 (insn[3]) != 4 2660 || JARL_R2 (insn[2]) != ADD_R2 (insn[3]))) 2661 no_match = 3; 2662 2663 if (no_match < 0 2664 && ((insn[4] & JMP_R_MASK) != JMP_R 2665 || MOVEA_R2 (insn[1]) != JMP_R1 (insn[4]))) 2666 no_match = 4; 2667 } 2668 else 2669 { 2670 ((*_bfd_error_handler) 2671 ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insns", 2672 bfd_get_filename (abfd), (unsigned long) irel->r_offset)); 2673 2674 continue; 2675 } 2676 2677 if (no_match >= 0) 2678 { 2679 ((*_bfd_error_handler) 2680 ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insn 0x%x", 2681 bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match])); 2682 2683 continue; 2684 } 2685 2686 /* Get the reloc for the address from which the register is 2687 being loaded. This reloc will tell us which function is 2688 actually being called. */ 2689 for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++) 2690 if (hi_irelfn->r_offset == laddr + 2 2691 && ELF32_R_TYPE (hi_irelfn->r_info) 2692 == (int) R_V850_HI16_S) 2693 break; 2694 2695 for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++) 2696 if (lo_irelfn->r_offset == laddr + 6 2697 && ELF32_R_TYPE (lo_irelfn->r_info) 2698 == (int) R_V850_LO16) 2699 break; 2700 2701 for (irelcall = internal_relocs; irelcall < irelend; irelcall ++) 2702 if (irelcall->r_offset == laddr + 8 2703 && ELF32_R_TYPE (irelcall->r_info) 2704 == (int) R_V850_22_PCREL) 2705 break; 2706 2707 if ( hi_irelfn == irelend 2708 || lo_irelfn == irelend 2709 || irelcall == irelend) 2710 { 2711 ((*_bfd_error_handler) 2712 ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc", 2713 bfd_get_filename (abfd), (unsigned long) irel->r_offset )); 2714 2715 continue; 2716 } 2717 2718 if (ELF32_R_SYM (irelcall->r_info) < symtab_hdr->sh_info) 2719 { 2720 Elf_Internal_Sym * isym; 2721 2722 /* A local symbol. */ 2723 isym = isymbuf + ELF32_R_SYM (irelcall->r_info); 2724 2725 symval = isym->st_value; 2726 } 2727 else 2728 { 2729 unsigned long indx; 2730 struct elf_link_hash_entry * h; 2731 2732 /* An external symbol. */ 2733 indx = ELF32_R_SYM (irelcall->r_info) - symtab_hdr->sh_info; 2734 h = elf_sym_hashes (abfd)[indx]; 2735 BFD_ASSERT (h != NULL); 2736 2737 if ( h->root.type != bfd_link_hash_defined 2738 && h->root.type != bfd_link_hash_defweak) 2739 /* This appears to be a reference to an undefined 2740 symbol. Just ignore it--it will be caught by the 2741 regular reloc processing. */ 2742 continue; 2743 2744 symval = h->root.u.def.value; 2745 } 2746 2747 if (symval + irelcall->r_addend != irelcall->r_offset + 4) 2748 { 2749 ((*_bfd_error_handler) 2750 ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc 0x%lx", 2751 bfd_get_filename (abfd), (unsigned long) irel->r_offset, irelcall->r_offset )); 2752 2753 continue; 2754 } 2755 2756 /* Get the value of the symbol referred to by the reloc. */ 2757 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info) 2758 { 2759 Elf_Internal_Sym *isym; 2760 asection *sym_sec; 2761 2762 /* A local symbol. */ 2763 isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info); 2764 2765 if (isym->st_shndx == SHN_UNDEF) 2766 sym_sec = bfd_und_section_ptr; 2767 else if (isym->st_shndx == SHN_ABS) 2768 sym_sec = bfd_abs_section_ptr; 2769 else if (isym->st_shndx == SHN_COMMON) 2770 sym_sec = bfd_com_section_ptr; 2771 else 2772 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 2773 symval = (isym->st_value 2774 + sym_sec->output_section->vma 2775 + sym_sec->output_offset); 2776 } 2777 else 2778 { 2779 unsigned long indx; 2780 struct elf_link_hash_entry *h; 2781 2782 /* An external symbol. */ 2783 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info; 2784 h = elf_sym_hashes (abfd)[indx]; 2785 BFD_ASSERT (h != NULL); 2786 2787 if ( h->root.type != bfd_link_hash_defined 2788 && h->root.type != bfd_link_hash_defweak) 2789 /* This appears to be a reference to an undefined 2790 symbol. Just ignore it--it will be caught by the 2791 regular reloc processing. */ 2792 continue; 2793 2794 symval = (h->root.u.def.value 2795 + h->root.u.def.section->output_section->vma 2796 + h->root.u.def.section->output_offset); 2797 } 2798 2799 addend = irel->r_addend; 2800 2801 foff = (symval + addend 2802 - (irel->r_offset 2803 + sec->output_section->vma 2804 + sec->output_offset 2805 + 4)); 2806 #ifdef DEBUG_RELAX 2807 fprintf (stderr, "relax longcall r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n", 2808 irel->r_offset, 2809 (irel->r_offset 2810 + sec->output_section->vma 2811 + sec->output_offset), 2812 symval, addend, foff); 2813 #endif 2814 2815 if (foff < -0x100000 || foff >= 0x100000) 2816 /* After all that work, we can't shorten this function call. */ 2817 continue; 2818 2819 /* For simplicity of coding, we are going to modify the section 2820 contents, the section relocs, and the BFD symbol table. We 2821 must tell the rest of the code not to free up this 2822 information. It would be possible to instead create a table 2823 of changes which have to be made, as is done in coff-mips.c; 2824 that would be more work, but would require less memory when 2825 the linker is run. */ 2826 elf_section_data (sec)->relocs = internal_relocs; 2827 elf_section_data (sec)->this_hdr.contents = contents; 2828 symtab_hdr->contents = (bfd_byte *) isymbuf; 2829 2830 /* Replace the long call with a jarl. */ 2831 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_22_PCREL); 2832 2833 addend = 0; 2834 2835 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info) 2836 /* If this needs to be changed because of future relaxing, 2837 it will be handled here like other internal IND12W 2838 relocs. */ 2839 bfd_put_32 (abfd, 2840 0x00000780 | (JARL_R2 (insn[2])<<11) | ((addend << 16) & 0xffff) | ((addend >> 16) & 0xf), 2841 contents + irel->r_offset); 2842 else 2843 /* We can't fully resolve this yet, because the external 2844 symbol value may be changed by future relaxing. 2845 We let the final link phase handle it. */ 2846 bfd_put_32 (abfd, 0x00000780 | (JARL_R2 (insn[2])<<11), 2847 contents + irel->r_offset); 2848 2849 hi_irelfn->r_info = 2850 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE); 2851 lo_irelfn->r_info = 2852 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE); 2853 irelcall->r_info = 2854 ELF32_R_INFO (ELF32_R_SYM (irelcall->r_info), R_V850_NONE); 2855 2856 if (! v850_elf_relax_delete_bytes (abfd, sec, 2857 irel->r_offset + 4, toaddr, 12)) 2858 goto error_return; 2859 2860 align_pad_size += 12; 2861 } 2862 else if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP) 2863 { 2864 /* Check code for -mlong-jumps output. */ 2865 if (laddr + 10 <= (bfd_vma) sec->_raw_size) 2866 { 2867 insn[0] = bfd_get_16 (abfd, contents + laddr); 2868 insn[1] = bfd_get_16 (abfd, contents + laddr + 4); 2869 insn[2] = bfd_get_16 (abfd, contents + laddr + 8); 2870 2871 if ((insn[0] & MOVHI_MASK) != MOVHI 2872 || MOVHI_R1 (insn[0]) != 0) 2873 no_match = 0; 2874 2875 if (no_match < 0 2876 && ((insn[1] & MOVEA_MASK) != MOVEA 2877 || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1]))) 2878 no_match = 1; 2879 2880 if (no_match < 0 2881 && ((insn[2] & JMP_R_MASK) != JMP_R 2882 || MOVEA_R2 (insn[1]) != JMP_R1 (insn[2]))) 2883 no_match = 4; 2884 } 2885 else 2886 { 2887 ((*_bfd_error_handler) 2888 ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insns", 2889 bfd_get_filename (abfd), (unsigned long) irel->r_offset)); 2890 2891 continue; 2892 } 2893 2894 if (no_match >= 0) 2895 { 2896 ((*_bfd_error_handler) 2897 ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insn 0x%x", 2898 bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match])); 2899 2900 continue; 2901 } 2902 2903 /* Get the reloc for the address from which the register is 2904 being loaded. This reloc will tell us which function is 2905 actually being called. */ 2906 for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++) 2907 if (hi_irelfn->r_offset == laddr + 2 2908 && ELF32_R_TYPE (hi_irelfn->r_info) == (int) R_V850_HI16_S) 2909 break; 2910 2911 for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++) 2912 if (lo_irelfn->r_offset == laddr + 6 2913 && ELF32_R_TYPE (lo_irelfn->r_info) == (int) R_V850_LO16) 2914 break; 2915 2916 if ( hi_irelfn == irelend 2917 || lo_irelfn == irelend) 2918 { 2919 ((*_bfd_error_handler) 2920 ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized reloc", 2921 bfd_get_filename (abfd), (unsigned long) irel->r_offset )); 2922 2923 continue; 2924 } 2925 2926 /* Get the value of the symbol referred to by the reloc. */ 2927 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info) 2928 { 2929 Elf_Internal_Sym * isym; 2930 asection * sym_sec; 2931 2932 /* A local symbol. */ 2933 isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info); 2934 2935 if (isym->st_shndx == SHN_UNDEF) 2936 sym_sec = bfd_und_section_ptr; 2937 else if (isym->st_shndx == SHN_ABS) 2938 sym_sec = bfd_abs_section_ptr; 2939 else if (isym->st_shndx == SHN_COMMON) 2940 sym_sec = bfd_com_section_ptr; 2941 else 2942 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 2943 symval = (isym->st_value 2944 + sym_sec->output_section->vma 2945 + sym_sec->output_offset); 2946 #ifdef DEBUG_RELAX 2947 { 2948 char * name = bfd_elf_string_from_elf_section 2949 (abfd, symtab_hdr->sh_link, isym->st_name); 2950 2951 fprintf (stderr, "relax long jump local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n", 2952 sym_sec->name, name, isym->st_name, 2953 sym_sec->output_section->vma, 2954 sym_sec->output_offset, 2955 isym->st_value, irel->r_addend); 2956 } 2957 #endif 2958 } 2959 else 2960 { 2961 unsigned long indx; 2962 struct elf_link_hash_entry * h; 2963 2964 /* An external symbol. */ 2965 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 2966 h = elf_sym_hashes (abfd)[indx]; 2967 BFD_ASSERT (h != NULL); 2968 2969 if ( h->root.type != bfd_link_hash_defined 2970 && h->root.type != bfd_link_hash_defweak) 2971 /* This appears to be a reference to an undefined 2972 symbol. Just ignore it--it will be caught by the 2973 regular reloc processing. */ 2974 continue; 2975 2976 symval = (h->root.u.def.value 2977 + h->root.u.def.section->output_section->vma 2978 + h->root.u.def.section->output_offset); 2979 #ifdef DEBUG_RELAX 2980 fprintf (stderr, 2981 "relax longjump defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n", 2982 sec->name, h->root.root.string, h->root.u.def.value, 2983 sec->output_section->vma, sec->output_offset, irel->r_addend); 2984 #endif 2985 } 2986 2987 addend = irel->r_addend; 2988 2989 foff = (symval + addend 2990 - (irel->r_offset 2991 + sec->output_section->vma 2992 + sec->output_offset 2993 + 4)); 2994 #ifdef DEBUG_RELAX 2995 fprintf (stderr, "relax longjump r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n", 2996 irel->r_offset, 2997 (irel->r_offset 2998 + sec->output_section->vma 2999 + sec->output_offset), 3000 symval, addend, foff); 3001 #endif 3002 if (foff < -0x100000 || foff >= 0x100000) 3003 /* After all that work, we can't shorten this function call. */ 3004 continue; 3005 3006 /* For simplicity of coding, we are going to modify the section 3007 contents, the section relocs, and the BFD symbol table. We 3008 must tell the rest of the code not to free up this 3009 information. It would be possible to instead create a table 3010 of changes which have to be made, as is done in coff-mips.c; 3011 that would be more work, but would require less memory when 3012 the linker is run. */ 3013 elf_section_data (sec)->relocs = internal_relocs; 3014 elf_section_data (sec)->this_hdr.contents = contents; 3015 symtab_hdr->contents = (bfd_byte *) isymbuf; 3016 3017 if (foff < -0x100 || foff >= 0x100) 3018 { 3019 /* Replace the long jump with a jr. */ 3020 3021 irel->r_info = 3022 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_22_PCREL); 3023 3024 irel->r_addend = addend; 3025 addend = 0; 3026 3027 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info) 3028 /* If this needs to be changed because of future relaxing, 3029 it will be handled here like other internal IND12W 3030 relocs. */ 3031 bfd_put_32 (abfd, 3032 0x00000780 | ((addend << 15) & 0xffff0000) | ((addend >> 17) & 0xf), 3033 contents + irel->r_offset); 3034 else 3035 /* We can't fully resolve this yet, because the external 3036 symbol value may be changed by future relaxing. 3037 We let the final link phase handle it. */ 3038 bfd_put_32 (abfd, 0x00000780, contents + irel->r_offset); 3039 3040 hi_irelfn->r_info = 3041 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE); 3042 lo_irelfn->r_info = 3043 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE); 3044 if (!v850_elf_relax_delete_bytes (abfd, sec, 3045 irel->r_offset + 4, toaddr, 6)) 3046 goto error_return; 3047 3048 align_pad_size += 6; 3049 } 3050 else 3051 { 3052 /* Replace the long jump with a br. */ 3053 3054 irel->r_info = 3055 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_9_PCREL); 3056 3057 irel->r_addend = addend; 3058 addend = 0; 3059 3060 if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info) 3061 /* If this needs to be changed because of future relaxing, 3062 it will be handled here like other internal IND12W 3063 relocs. */ 3064 bfd_put_16 (abfd, 3065 0x0585 | ((addend << 10) & 0xf800) | ((addend << 3) & 0x0070), 3066 contents + irel->r_offset); 3067 else 3068 /* We can't fully resolve this yet, because the external 3069 symbol value may be changed by future relaxing. 3070 We let the final link phase handle it. */ 3071 bfd_put_16 (abfd, 0x0585, contents + irel->r_offset); 3072 3073 hi_irelfn->r_info = 3074 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE); 3075 lo_irelfn->r_info = 3076 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE); 3077 if (!v850_elf_relax_delete_bytes (abfd, sec, 3078 irel->r_offset + 2, toaddr, 8)) 3079 goto error_return; 3080 3081 align_pad_size += 8; 3082 } 3083 } 3084 } 3085 3086 irelalign = NULL; 3087 for (irel = internal_relocs; irel < irelend; irel++) 3088 { 3089 if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN 3090 && irel->r_offset == toaddr) 3091 { 3092 irel->r_offset -= align_pad_size; 3093 3094 if (irelalign == NULL || irelalign->r_addend > irel->r_addend) 3095 irelalign = irel; 3096 } 3097 } 3098 3099 addr = toaddr; 3100 } 3101 3102 if (!irelalign) 3103 { 3104 #ifdef DEBUG_RELAX 3105 fprintf (stderr, "relax pad %d shorten %d -> %d\n", 3106 align_pad_size, 3107 sec->_cooked_size, 3108 sec->_cooked_size - align_pad_size); 3109 #endif 3110 sec->_cooked_size -= align_pad_size; 3111 } 3112 3113 finish: 3114 if (internal_relocs != NULL 3115 && elf_section_data (sec)->relocs != internal_relocs) 3116 free (internal_relocs); 3117 3118 if (contents != NULL 3119 && elf_section_data (sec)->this_hdr.contents != (unsigned char *) contents) 3120 free (contents); 3121 3122 if (isymbuf != NULL 3123 && symtab_hdr->contents != (bfd_byte *) isymbuf) 3124 free (isymbuf); 3125 3126 return result; 3127 3128 error_return: 3129 result = FALSE; 3130 goto finish; 3131 } 3132 3133 static struct bfd_elf_special_section const v850_elf_special_sections[]= 3134 { 3135 { ".sdata", 6, -2, SHT_PROGBITS, (SHF_ALLOC + SHF_WRITE 3136 + SHF_V850_GPREL) }, 3137 { ".rosdata", 8, -2, SHT_PROGBITS, (SHF_ALLOC 3138 + SHF_V850_GPREL) }, 3139 { ".sbss", 5, -2, SHT_NOBITS, (SHF_ALLOC + SHF_WRITE 3140 + SHF_V850_GPREL) }, 3141 { ".scommon", 8, -2, SHT_V850_SCOMMON, (SHF_ALLOC + SHF_WRITE 3142 + SHF_V850_GPREL) }, 3143 { ".tdata", 6, -2, SHT_PROGBITS, (SHF_ALLOC + SHF_WRITE 3144 + SHF_V850_EPREL) }, 3145 { ".tbss", 5, -2, SHT_NOBITS, (SHF_ALLOC + SHF_WRITE 3146 + SHF_V850_EPREL) }, 3147 { ".tcommon", 8, -2, SHT_V850_TCOMMON, (SHF_ALLOC + SHF_WRITE 3148 + SHF_V850_R0REL) }, 3149 { ".zdata", 6, -2, SHT_PROGBITS, (SHF_ALLOC + SHF_WRITE 3150 + SHF_V850_R0REL) }, 3151 { ".rozdata", 8, -2, SHT_PROGBITS, (SHF_ALLOC 3152 + SHF_V850_R0REL) }, 3153 { ".zbss", 5, -2, SHT_NOBITS, (SHF_ALLOC + SHF_WRITE 3154 + SHF_V850_R0REL) }, 3155 { ".zcommon", 8, -2, SHT_V850_ZCOMMON, (SHF_ALLOC + SHF_WRITE 3156 + SHF_V850_R0REL) }, 3157 { ".call_table_data", 16, 0, SHT_PROGBITS, (SHF_ALLOC 3158 + SHF_WRITE) }, 3159 { ".call_table_text", 16, 0, SHT_PROGBITS, (SHF_ALLOC + SHF_WRITE 3160 + SHF_EXECINSTR) }, 3161 { NULL, 0, 0, 0, 0 } 3162 }; 3163 3164 #define TARGET_LITTLE_SYM bfd_elf32_v850_vec 3165 #define TARGET_LITTLE_NAME "elf32-v850" 3166 #define ELF_ARCH bfd_arch_v850 3167 #define ELF_MACHINE_CODE EM_V850 3168 #define ELF_MACHINE_ALT1 EM_CYGNUS_V850 3169 #define ELF_MAXPAGESIZE 0x1000 3170 3171 #define elf_info_to_howto v850_elf_info_to_howto_rela 3172 #define elf_info_to_howto_rel v850_elf_info_to_howto_rel 3173 3174 #define elf_backend_check_relocs v850_elf_check_relocs 3175 #define elf_backend_relocate_section v850_elf_relocate_section 3176 #define elf_backend_object_p v850_elf_object_p 3177 #define elf_backend_final_write_processing v850_elf_final_write_processing 3178 #define elf_backend_section_from_bfd_section v850_elf_section_from_bfd_section 3179 #define elf_backend_symbol_processing v850_elf_symbol_processing 3180 #define elf_backend_add_symbol_hook v850_elf_add_symbol_hook 3181 #define elf_backend_link_output_symbol_hook v850_elf_link_output_symbol_hook 3182 #define elf_backend_section_from_shdr v850_elf_section_from_shdr 3183 #define elf_backend_fake_sections v850_elf_fake_sections 3184 #define elf_backend_gc_mark_hook v850_elf_gc_mark_hook 3185 #define elf_backend_gc_sweep_hook v850_elf_gc_sweep_hook 3186 #define elf_backend_special_sections v850_elf_special_sections 3187 3188 #define elf_backend_can_gc_sections 1 3189 #define elf_backend_rela_normal 1 3190 3191 #define bfd_elf32_bfd_is_local_label_name v850_elf_is_local_label_name 3192 #define bfd_elf32_bfd_reloc_type_lookup v850_elf_reloc_type_lookup 3193 #define bfd_elf32_bfd_merge_private_bfd_data v850_elf_merge_private_bfd_data 3194 #define bfd_elf32_bfd_set_private_flags v850_elf_set_private_flags 3195 #define bfd_elf32_bfd_print_private_bfd_data v850_elf_print_private_bfd_data 3196 #define bfd_elf32_bfd_relax_section v850_elf_relax_section 3197 3198 #define elf_symbol_leading_char '_' 3199 3200 #include "elf32-target.h" 3201