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