1/* 32-bit ELF support for ARM 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 20 21#include "sysdep.h" 22#include "bfd.h" 23#include "libiberty.h" 24#include "libbfd.h" 25#include "elf-bfd.h" 26#include "elf-vxworks.h" 27#include "elf/arm.h" 28 29#ifndef NUM_ELEM 30#define NUM_ELEM(a) (sizeof (a) / (sizeof (a)[0])) 31#endif 32 33/* Return the relocation section associated with NAME. HTAB is the 34 bfd's elf32_arm_link_hash_entry. */ 35#define RELOC_SECTION(HTAB, NAME) \ 36 ((HTAB)->use_rel ? ".rel" NAME : ".rela" NAME) 37 38/* Return size of a relocation entry. HTAB is the bfd's 39 elf32_arm_link_hash_entry. */ 40#define RELOC_SIZE(HTAB) \ 41 ((HTAB)->use_rel \ 42 ? sizeof (Elf32_External_Rel) \ 43 : sizeof (Elf32_External_Rela)) 44 45/* Return function to swap relocations in. HTAB is the bfd's 46 elf32_arm_link_hash_entry. */ 47#define SWAP_RELOC_IN(HTAB) \ 48 ((HTAB)->use_rel \ 49 ? bfd_elf32_swap_reloc_in \ 50 : bfd_elf32_swap_reloca_in) 51 52/* Return function to swap relocations out. HTAB is the bfd's 53 elf32_arm_link_hash_entry. */ 54#define SWAP_RELOC_OUT(HTAB) \ 55 ((HTAB)->use_rel \ 56 ? bfd_elf32_swap_reloc_out \ 57 : bfd_elf32_swap_reloca_out) 58 59#define elf_info_to_howto 0 60#define elf_info_to_howto_rel elf32_arm_info_to_howto 61 62#define ARM_ELF_ABI_VERSION 0 63#ifdef __FreeBSD__ 64#define ARM_ELF_OS_ABI_VERSION ELFOSABI_FREEBSD 65#else 66#define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM 67#endif 68 69static struct elf_backend_data elf32_arm_vxworks_bed; 70 71/* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g. 72 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO 73 in that slot. */ 74 75static reloc_howto_type elf32_arm_howto_table_1[] = 76{ 77 /* No relocation */ 78 HOWTO (R_ARM_NONE, /* type */ 79 0, /* rightshift */ 80 0, /* size (0 = byte, 1 = short, 2 = long) */ 81 0, /* bitsize */ 82 FALSE, /* pc_relative */ 83 0, /* bitpos */ 84 complain_overflow_dont,/* complain_on_overflow */ 85 bfd_elf_generic_reloc, /* special_function */ 86 "R_ARM_NONE", /* name */ 87 FALSE, /* partial_inplace */ 88 0, /* src_mask */ 89 0, /* dst_mask */ 90 FALSE), /* pcrel_offset */ 91 92 HOWTO (R_ARM_PC24, /* type */ 93 2, /* rightshift */ 94 2, /* size (0 = byte, 1 = short, 2 = long) */ 95 24, /* bitsize */ 96 TRUE, /* pc_relative */ 97 0, /* bitpos */ 98 complain_overflow_signed,/* complain_on_overflow */ 99 bfd_elf_generic_reloc, /* special_function */ 100 "R_ARM_PC24", /* name */ 101 FALSE, /* partial_inplace */ 102 0x00ffffff, /* src_mask */ 103 0x00ffffff, /* dst_mask */ 104 TRUE), /* pcrel_offset */ 105 106 /* 32 bit absolute */ 107 HOWTO (R_ARM_ABS32, /* type */ 108 0, /* rightshift */ 109 2, /* size (0 = byte, 1 = short, 2 = long) */ 110 32, /* bitsize */ 111 FALSE, /* pc_relative */ 112 0, /* bitpos */ 113 complain_overflow_bitfield,/* complain_on_overflow */ 114 bfd_elf_generic_reloc, /* special_function */ 115 "R_ARM_ABS32", /* name */ 116 FALSE, /* partial_inplace */ 117 0xffffffff, /* src_mask */ 118 0xffffffff, /* dst_mask */ 119 FALSE), /* pcrel_offset */ 120 121 /* standard 32bit pc-relative reloc */ 122 HOWTO (R_ARM_REL32, /* type */ 123 0, /* rightshift */ 124 2, /* size (0 = byte, 1 = short, 2 = long) */ 125 32, /* bitsize */ 126 TRUE, /* pc_relative */ 127 0, /* bitpos */ 128 complain_overflow_bitfield,/* complain_on_overflow */ 129 bfd_elf_generic_reloc, /* special_function */ 130 "R_ARM_REL32", /* name */ 131 FALSE, /* partial_inplace */ 132 0xffffffff, /* src_mask */ 133 0xffffffff, /* dst_mask */ 134 TRUE), /* pcrel_offset */ 135 136 /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */ 137 HOWTO (R_ARM_LDR_PC_G0, /* type */ 138 0, /* rightshift */ 139 0, /* size (0 = byte, 1 = short, 2 = long) */ 140 32, /* bitsize */ 141 TRUE, /* pc_relative */ 142 0, /* bitpos */ 143 complain_overflow_dont,/* complain_on_overflow */ 144 bfd_elf_generic_reloc, /* special_function */ 145 "R_ARM_LDR_PC_G0", /* name */ 146 FALSE, /* partial_inplace */ 147 0xffffffff, /* src_mask */ 148 0xffffffff, /* dst_mask */ 149 TRUE), /* pcrel_offset */ 150 151 /* 16 bit absolute */ 152 HOWTO (R_ARM_ABS16, /* type */ 153 0, /* rightshift */ 154 1, /* size (0 = byte, 1 = short, 2 = long) */ 155 16, /* bitsize */ 156 FALSE, /* pc_relative */ 157 0, /* bitpos */ 158 complain_overflow_bitfield,/* complain_on_overflow */ 159 bfd_elf_generic_reloc, /* special_function */ 160 "R_ARM_ABS16", /* name */ 161 FALSE, /* partial_inplace */ 162 0x0000ffff, /* src_mask */ 163 0x0000ffff, /* dst_mask */ 164 FALSE), /* pcrel_offset */ 165 166 /* 12 bit absolute */ 167 HOWTO (R_ARM_ABS12, /* type */ 168 0, /* rightshift */ 169 2, /* size (0 = byte, 1 = short, 2 = long) */ 170 12, /* bitsize */ 171 FALSE, /* pc_relative */ 172 0, /* bitpos */ 173 complain_overflow_bitfield,/* complain_on_overflow */ 174 bfd_elf_generic_reloc, /* special_function */ 175 "R_ARM_ABS12", /* name */ 176 FALSE, /* partial_inplace */ 177 0x00000fff, /* src_mask */ 178 0x00000fff, /* dst_mask */ 179 FALSE), /* pcrel_offset */ 180 181 HOWTO (R_ARM_THM_ABS5, /* type */ 182 6, /* rightshift */ 183 1, /* size (0 = byte, 1 = short, 2 = long) */ 184 5, /* bitsize */ 185 FALSE, /* pc_relative */ 186 0, /* bitpos */ 187 complain_overflow_bitfield,/* complain_on_overflow */ 188 bfd_elf_generic_reloc, /* special_function */ 189 "R_ARM_THM_ABS5", /* name */ 190 FALSE, /* partial_inplace */ 191 0x000007e0, /* src_mask */ 192 0x000007e0, /* dst_mask */ 193 FALSE), /* pcrel_offset */ 194 195 /* 8 bit absolute */ 196 HOWTO (R_ARM_ABS8, /* type */ 197 0, /* rightshift */ 198 0, /* size (0 = byte, 1 = short, 2 = long) */ 199 8, /* bitsize */ 200 FALSE, /* pc_relative */ 201 0, /* bitpos */ 202 complain_overflow_bitfield,/* complain_on_overflow */ 203 bfd_elf_generic_reloc, /* special_function */ 204 "R_ARM_ABS8", /* name */ 205 FALSE, /* partial_inplace */ 206 0x000000ff, /* src_mask */ 207 0x000000ff, /* dst_mask */ 208 FALSE), /* pcrel_offset */ 209 210 HOWTO (R_ARM_SBREL32, /* type */ 211 0, /* rightshift */ 212 2, /* size (0 = byte, 1 = short, 2 = long) */ 213 32, /* bitsize */ 214 FALSE, /* pc_relative */ 215 0, /* bitpos */ 216 complain_overflow_dont,/* complain_on_overflow */ 217 bfd_elf_generic_reloc, /* special_function */ 218 "R_ARM_SBREL32", /* name */ 219 FALSE, /* partial_inplace */ 220 0xffffffff, /* src_mask */ 221 0xffffffff, /* dst_mask */ 222 FALSE), /* pcrel_offset */ 223 224 HOWTO (R_ARM_THM_CALL, /* type */ 225 1, /* rightshift */ 226 2, /* size (0 = byte, 1 = short, 2 = long) */ 227 25, /* bitsize */ 228 TRUE, /* pc_relative */ 229 0, /* bitpos */ 230 complain_overflow_signed,/* complain_on_overflow */ 231 bfd_elf_generic_reloc, /* special_function */ 232 "R_ARM_THM_CALL", /* name */ 233 FALSE, /* partial_inplace */ 234 0x07ff07ff, /* src_mask */ 235 0x07ff07ff, /* dst_mask */ 236 TRUE), /* pcrel_offset */ 237 238 HOWTO (R_ARM_THM_PC8, /* type */ 239 1, /* rightshift */ 240 1, /* size (0 = byte, 1 = short, 2 = long) */ 241 8, /* bitsize */ 242 TRUE, /* pc_relative */ 243 0, /* bitpos */ 244 complain_overflow_signed,/* complain_on_overflow */ 245 bfd_elf_generic_reloc, /* special_function */ 246 "R_ARM_THM_PC8", /* name */ 247 FALSE, /* partial_inplace */ 248 0x000000ff, /* src_mask */ 249 0x000000ff, /* dst_mask */ 250 TRUE), /* pcrel_offset */ 251 252 HOWTO (R_ARM_BREL_ADJ, /* type */ 253 1, /* rightshift */ 254 1, /* size (0 = byte, 1 = short, 2 = long) */ 255 32, /* bitsize */ 256 FALSE, /* pc_relative */ 257 0, /* bitpos */ 258 complain_overflow_signed,/* complain_on_overflow */ 259 bfd_elf_generic_reloc, /* special_function */ 260 "R_ARM_BREL_ADJ", /* name */ 261 FALSE, /* partial_inplace */ 262 0xffffffff, /* src_mask */ 263 0xffffffff, /* dst_mask */ 264 FALSE), /* pcrel_offset */ 265 266 HOWTO (R_ARM_SWI24, /* type */ 267 0, /* rightshift */ 268 0, /* size (0 = byte, 1 = short, 2 = long) */ 269 0, /* bitsize */ 270 FALSE, /* pc_relative */ 271 0, /* bitpos */ 272 complain_overflow_signed,/* complain_on_overflow */ 273 bfd_elf_generic_reloc, /* special_function */ 274 "R_ARM_SWI24", /* name */ 275 FALSE, /* partial_inplace */ 276 0x00000000, /* src_mask */ 277 0x00000000, /* dst_mask */ 278 FALSE), /* pcrel_offset */ 279 280 HOWTO (R_ARM_THM_SWI8, /* type */ 281 0, /* rightshift */ 282 0, /* size (0 = byte, 1 = short, 2 = long) */ 283 0, /* bitsize */ 284 FALSE, /* pc_relative */ 285 0, /* bitpos */ 286 complain_overflow_signed,/* complain_on_overflow */ 287 bfd_elf_generic_reloc, /* special_function */ 288 "R_ARM_SWI8", /* name */ 289 FALSE, /* partial_inplace */ 290 0x00000000, /* src_mask */ 291 0x00000000, /* dst_mask */ 292 FALSE), /* pcrel_offset */ 293 294 /* BLX instruction for the ARM. */ 295 HOWTO (R_ARM_XPC25, /* type */ 296 2, /* rightshift */ 297 2, /* size (0 = byte, 1 = short, 2 = long) */ 298 25, /* bitsize */ 299 TRUE, /* pc_relative */ 300 0, /* bitpos */ 301 complain_overflow_signed,/* complain_on_overflow */ 302 bfd_elf_generic_reloc, /* special_function */ 303 "R_ARM_XPC25", /* name */ 304 FALSE, /* partial_inplace */ 305 0x00ffffff, /* src_mask */ 306 0x00ffffff, /* dst_mask */ 307 TRUE), /* pcrel_offset */ 308 309 /* BLX instruction for the Thumb. */ 310 HOWTO (R_ARM_THM_XPC22, /* type */ 311 2, /* rightshift */ 312 2, /* size (0 = byte, 1 = short, 2 = long) */ 313 22, /* bitsize */ 314 TRUE, /* pc_relative */ 315 0, /* bitpos */ 316 complain_overflow_signed,/* complain_on_overflow */ 317 bfd_elf_generic_reloc, /* special_function */ 318 "R_ARM_THM_XPC22", /* name */ 319 FALSE, /* partial_inplace */ 320 0x07ff07ff, /* src_mask */ 321 0x07ff07ff, /* dst_mask */ 322 TRUE), /* pcrel_offset */ 323 324 /* Dynamic TLS relocations. */ 325 326 HOWTO (R_ARM_TLS_DTPMOD32, /* type */ 327 0, /* rightshift */ 328 2, /* size (0 = byte, 1 = short, 2 = long) */ 329 32, /* bitsize */ 330 FALSE, /* pc_relative */ 331 0, /* bitpos */ 332 complain_overflow_bitfield,/* complain_on_overflow */ 333 bfd_elf_generic_reloc, /* special_function */ 334 "R_ARM_TLS_DTPMOD32", /* name */ 335 TRUE, /* partial_inplace */ 336 0xffffffff, /* src_mask */ 337 0xffffffff, /* dst_mask */ 338 FALSE), /* pcrel_offset */ 339 340 HOWTO (R_ARM_TLS_DTPOFF32, /* type */ 341 0, /* rightshift */ 342 2, /* size (0 = byte, 1 = short, 2 = long) */ 343 32, /* bitsize */ 344 FALSE, /* pc_relative */ 345 0, /* bitpos */ 346 complain_overflow_bitfield,/* complain_on_overflow */ 347 bfd_elf_generic_reloc, /* special_function */ 348 "R_ARM_TLS_DTPOFF32", /* name */ 349 TRUE, /* partial_inplace */ 350 0xffffffff, /* src_mask */ 351 0xffffffff, /* dst_mask */ 352 FALSE), /* pcrel_offset */ 353 354 HOWTO (R_ARM_TLS_TPOFF32, /* type */ 355 0, /* rightshift */ 356 2, /* size (0 = byte, 1 = short, 2 = long) */ 357 32, /* bitsize */ 358 FALSE, /* pc_relative */ 359 0, /* bitpos */ 360 complain_overflow_bitfield,/* complain_on_overflow */ 361 bfd_elf_generic_reloc, /* special_function */ 362 "R_ARM_TLS_TPOFF32", /* name */ 363 TRUE, /* partial_inplace */ 364 0xffffffff, /* src_mask */ 365 0xffffffff, /* dst_mask */ 366 FALSE), /* pcrel_offset */ 367 368 /* Relocs used in ARM Linux */ 369 370 HOWTO (R_ARM_COPY, /* type */ 371 0, /* rightshift */ 372 2, /* size (0 = byte, 1 = short, 2 = long) */ 373 32, /* bitsize */ 374 FALSE, /* pc_relative */ 375 0, /* bitpos */ 376 complain_overflow_bitfield,/* complain_on_overflow */ 377 bfd_elf_generic_reloc, /* special_function */ 378 "R_ARM_COPY", /* name */ 379 TRUE, /* partial_inplace */ 380 0xffffffff, /* src_mask */ 381 0xffffffff, /* dst_mask */ 382 FALSE), /* pcrel_offset */ 383 384 HOWTO (R_ARM_GLOB_DAT, /* type */ 385 0, /* rightshift */ 386 2, /* size (0 = byte, 1 = short, 2 = long) */ 387 32, /* bitsize */ 388 FALSE, /* pc_relative */ 389 0, /* bitpos */ 390 complain_overflow_bitfield,/* complain_on_overflow */ 391 bfd_elf_generic_reloc, /* special_function */ 392 "R_ARM_GLOB_DAT", /* name */ 393 TRUE, /* partial_inplace */ 394 0xffffffff, /* src_mask */ 395 0xffffffff, /* dst_mask */ 396 FALSE), /* pcrel_offset */ 397 398 HOWTO (R_ARM_JUMP_SLOT, /* type */ 399 0, /* rightshift */ 400 2, /* size (0 = byte, 1 = short, 2 = long) */ 401 32, /* bitsize */ 402 FALSE, /* pc_relative */ 403 0, /* bitpos */ 404 complain_overflow_bitfield,/* complain_on_overflow */ 405 bfd_elf_generic_reloc, /* special_function */ 406 "R_ARM_JUMP_SLOT", /* name */ 407 TRUE, /* partial_inplace */ 408 0xffffffff, /* src_mask */ 409 0xffffffff, /* dst_mask */ 410 FALSE), /* pcrel_offset */ 411 412 HOWTO (R_ARM_RELATIVE, /* type */ 413 0, /* rightshift */ 414 2, /* size (0 = byte, 1 = short, 2 = long) */ 415 32, /* bitsize */ 416 FALSE, /* pc_relative */ 417 0, /* bitpos */ 418 complain_overflow_bitfield,/* complain_on_overflow */ 419 bfd_elf_generic_reloc, /* special_function */ 420 "R_ARM_RELATIVE", /* name */ 421 TRUE, /* partial_inplace */ 422 0xffffffff, /* src_mask */ 423 0xffffffff, /* dst_mask */ 424 FALSE), /* pcrel_offset */ 425 426 HOWTO (R_ARM_GOTOFF32, /* type */ 427 0, /* rightshift */ 428 2, /* size (0 = byte, 1 = short, 2 = long) */ 429 32, /* bitsize */ 430 FALSE, /* pc_relative */ 431 0, /* bitpos */ 432 complain_overflow_bitfield,/* complain_on_overflow */ 433 bfd_elf_generic_reloc, /* special_function */ 434 "R_ARM_GOTOFF32", /* name */ 435 TRUE, /* partial_inplace */ 436 0xffffffff, /* src_mask */ 437 0xffffffff, /* dst_mask */ 438 FALSE), /* pcrel_offset */ 439 440 HOWTO (R_ARM_GOTPC, /* type */ 441 0, /* rightshift */ 442 2, /* size (0 = byte, 1 = short, 2 = long) */ 443 32, /* bitsize */ 444 TRUE, /* pc_relative */ 445 0, /* bitpos */ 446 complain_overflow_bitfield,/* complain_on_overflow */ 447 bfd_elf_generic_reloc, /* special_function */ 448 "R_ARM_GOTPC", /* name */ 449 TRUE, /* partial_inplace */ 450 0xffffffff, /* src_mask */ 451 0xffffffff, /* dst_mask */ 452 TRUE), /* pcrel_offset */ 453 454 HOWTO (R_ARM_GOT32, /* type */ 455 0, /* rightshift */ 456 2, /* size (0 = byte, 1 = short, 2 = long) */ 457 32, /* bitsize */ 458 FALSE, /* pc_relative */ 459 0, /* bitpos */ 460 complain_overflow_bitfield,/* complain_on_overflow */ 461 bfd_elf_generic_reloc, /* special_function */ 462 "R_ARM_GOT32", /* name */ 463 TRUE, /* partial_inplace */ 464 0xffffffff, /* src_mask */ 465 0xffffffff, /* dst_mask */ 466 FALSE), /* pcrel_offset */ 467 468 HOWTO (R_ARM_PLT32, /* type */ 469 2, /* rightshift */ 470 2, /* size (0 = byte, 1 = short, 2 = long) */ 471 24, /* bitsize */ 472 TRUE, /* pc_relative */ 473 0, /* bitpos */ 474 complain_overflow_bitfield,/* complain_on_overflow */ 475 bfd_elf_generic_reloc, /* special_function */ 476 "R_ARM_PLT32", /* name */ 477 FALSE, /* partial_inplace */ 478 0x00ffffff, /* src_mask */ 479 0x00ffffff, /* dst_mask */ 480 TRUE), /* pcrel_offset */ 481 482 HOWTO (R_ARM_CALL, /* type */ 483 2, /* rightshift */ 484 2, /* size (0 = byte, 1 = short, 2 = long) */ 485 24, /* bitsize */ 486 TRUE, /* pc_relative */ 487 0, /* bitpos */ 488 complain_overflow_signed,/* complain_on_overflow */ 489 bfd_elf_generic_reloc, /* special_function */ 490 "R_ARM_CALL", /* name */ 491 FALSE, /* partial_inplace */ 492 0x00ffffff, /* src_mask */ 493 0x00ffffff, /* dst_mask */ 494 TRUE), /* pcrel_offset */ 495 496 HOWTO (R_ARM_JUMP24, /* type */ 497 2, /* rightshift */ 498 2, /* size (0 = byte, 1 = short, 2 = long) */ 499 24, /* bitsize */ 500 TRUE, /* pc_relative */ 501 0, /* bitpos */ 502 complain_overflow_signed,/* complain_on_overflow */ 503 bfd_elf_generic_reloc, /* special_function */ 504 "R_ARM_JUMP24", /* name */ 505 FALSE, /* partial_inplace */ 506 0x00ffffff, /* src_mask */ 507 0x00ffffff, /* dst_mask */ 508 TRUE), /* pcrel_offset */ 509 510 HOWTO (R_ARM_THM_JUMP24, /* type */ 511 1, /* rightshift */ 512 2, /* size (0 = byte, 1 = short, 2 = long) */ 513 24, /* bitsize */ 514 TRUE, /* pc_relative */ 515 0, /* bitpos */ 516 complain_overflow_signed,/* complain_on_overflow */ 517 bfd_elf_generic_reloc, /* special_function */ 518 "R_ARM_THM_JUMP24", /* name */ 519 FALSE, /* partial_inplace */ 520 0x07ff2fff, /* src_mask */ 521 0x07ff2fff, /* dst_mask */ 522 TRUE), /* pcrel_offset */ 523 524 HOWTO (R_ARM_BASE_ABS, /* type */ 525 0, /* rightshift */ 526 2, /* size (0 = byte, 1 = short, 2 = long) */ 527 32, /* bitsize */ 528 FALSE, /* pc_relative */ 529 0, /* bitpos */ 530 complain_overflow_dont,/* complain_on_overflow */ 531 bfd_elf_generic_reloc, /* special_function */ 532 "R_ARM_BASE_ABS", /* name */ 533 FALSE, /* partial_inplace */ 534 0xffffffff, /* src_mask */ 535 0xffffffff, /* dst_mask */ 536 FALSE), /* pcrel_offset */ 537 538 HOWTO (R_ARM_ALU_PCREL7_0, /* type */ 539 0, /* rightshift */ 540 2, /* size (0 = byte, 1 = short, 2 = long) */ 541 12, /* bitsize */ 542 TRUE, /* pc_relative */ 543 0, /* bitpos */ 544 complain_overflow_dont,/* complain_on_overflow */ 545 bfd_elf_generic_reloc, /* special_function */ 546 "R_ARM_ALU_PCREL_7_0", /* name */ 547 FALSE, /* partial_inplace */ 548 0x00000fff, /* src_mask */ 549 0x00000fff, /* dst_mask */ 550 TRUE), /* pcrel_offset */ 551 552 HOWTO (R_ARM_ALU_PCREL15_8, /* type */ 553 0, /* rightshift */ 554 2, /* size (0 = byte, 1 = short, 2 = long) */ 555 12, /* bitsize */ 556 TRUE, /* pc_relative */ 557 8, /* bitpos */ 558 complain_overflow_dont,/* complain_on_overflow */ 559 bfd_elf_generic_reloc, /* special_function */ 560 "R_ARM_ALU_PCREL_15_8",/* name */ 561 FALSE, /* partial_inplace */ 562 0x00000fff, /* src_mask */ 563 0x00000fff, /* dst_mask */ 564 TRUE), /* pcrel_offset */ 565 566 HOWTO (R_ARM_ALU_PCREL23_15, /* type */ 567 0, /* rightshift */ 568 2, /* size (0 = byte, 1 = short, 2 = long) */ 569 12, /* bitsize */ 570 TRUE, /* pc_relative */ 571 16, /* bitpos */ 572 complain_overflow_dont,/* complain_on_overflow */ 573 bfd_elf_generic_reloc, /* special_function */ 574 "R_ARM_ALU_PCREL_23_15",/* name */ 575 FALSE, /* partial_inplace */ 576 0x00000fff, /* src_mask */ 577 0x00000fff, /* dst_mask */ 578 TRUE), /* pcrel_offset */ 579 580 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */ 581 0, /* rightshift */ 582 2, /* size (0 = byte, 1 = short, 2 = long) */ 583 12, /* bitsize */ 584 FALSE, /* pc_relative */ 585 0, /* bitpos */ 586 complain_overflow_dont,/* complain_on_overflow */ 587 bfd_elf_generic_reloc, /* special_function */ 588 "R_ARM_LDR_SBREL_11_0",/* name */ 589 FALSE, /* partial_inplace */ 590 0x00000fff, /* src_mask */ 591 0x00000fff, /* dst_mask */ 592 FALSE), /* pcrel_offset */ 593 594 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */ 595 0, /* rightshift */ 596 2, /* size (0 = byte, 1 = short, 2 = long) */ 597 8, /* bitsize */ 598 FALSE, /* pc_relative */ 599 12, /* bitpos */ 600 complain_overflow_dont,/* complain_on_overflow */ 601 bfd_elf_generic_reloc, /* special_function */ 602 "R_ARM_ALU_SBREL_19_12",/* name */ 603 FALSE, /* partial_inplace */ 604 0x000ff000, /* src_mask */ 605 0x000ff000, /* dst_mask */ 606 FALSE), /* pcrel_offset */ 607 608 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */ 609 0, /* rightshift */ 610 2, /* size (0 = byte, 1 = short, 2 = long) */ 611 8, /* bitsize */ 612 FALSE, /* pc_relative */ 613 20, /* bitpos */ 614 complain_overflow_dont,/* complain_on_overflow */ 615 bfd_elf_generic_reloc, /* special_function */ 616 "R_ARM_ALU_SBREL_27_20",/* name */ 617 FALSE, /* partial_inplace */ 618 0x0ff00000, /* src_mask */ 619 0x0ff00000, /* dst_mask */ 620 FALSE), /* pcrel_offset */ 621 622 HOWTO (R_ARM_TARGET1, /* type */ 623 0, /* rightshift */ 624 2, /* size (0 = byte, 1 = short, 2 = long) */ 625 32, /* bitsize */ 626 FALSE, /* pc_relative */ 627 0, /* bitpos */ 628 complain_overflow_dont,/* complain_on_overflow */ 629 bfd_elf_generic_reloc, /* special_function */ 630 "R_ARM_TARGET1", /* name */ 631 FALSE, /* partial_inplace */ 632 0xffffffff, /* src_mask */ 633 0xffffffff, /* dst_mask */ 634 FALSE), /* pcrel_offset */ 635 636 HOWTO (R_ARM_ROSEGREL32, /* type */ 637 0, /* rightshift */ 638 2, /* size (0 = byte, 1 = short, 2 = long) */ 639 32, /* bitsize */ 640 FALSE, /* pc_relative */ 641 0, /* bitpos */ 642 complain_overflow_dont,/* complain_on_overflow */ 643 bfd_elf_generic_reloc, /* special_function */ 644 "R_ARM_ROSEGREL32", /* name */ 645 FALSE, /* partial_inplace */ 646 0xffffffff, /* src_mask */ 647 0xffffffff, /* dst_mask */ 648 FALSE), /* pcrel_offset */ 649 650 HOWTO (R_ARM_V4BX, /* type */ 651 0, /* rightshift */ 652 2, /* size (0 = byte, 1 = short, 2 = long) */ 653 32, /* bitsize */ 654 FALSE, /* pc_relative */ 655 0, /* bitpos */ 656 complain_overflow_dont,/* complain_on_overflow */ 657 bfd_elf_generic_reloc, /* special_function */ 658 "R_ARM_V4BX", /* name */ 659 FALSE, /* partial_inplace */ 660 0xffffffff, /* src_mask */ 661 0xffffffff, /* dst_mask */ 662 FALSE), /* pcrel_offset */ 663 664 HOWTO (R_ARM_TARGET2, /* type */ 665 0, /* rightshift */ 666 2, /* size (0 = byte, 1 = short, 2 = long) */ 667 32, /* bitsize */ 668 FALSE, /* pc_relative */ 669 0, /* bitpos */ 670 complain_overflow_signed,/* complain_on_overflow */ 671 bfd_elf_generic_reloc, /* special_function */ 672 "R_ARM_TARGET2", /* name */ 673 FALSE, /* partial_inplace */ 674 0xffffffff, /* src_mask */ 675 0xffffffff, /* dst_mask */ 676 TRUE), /* pcrel_offset */ 677 678 HOWTO (R_ARM_PREL31, /* type */ 679 0, /* rightshift */ 680 2, /* size (0 = byte, 1 = short, 2 = long) */ 681 31, /* bitsize */ 682 TRUE, /* pc_relative */ 683 0, /* bitpos */ 684 complain_overflow_signed,/* complain_on_overflow */ 685 bfd_elf_generic_reloc, /* special_function */ 686 "R_ARM_PREL31", /* name */ 687 FALSE, /* partial_inplace */ 688 0x7fffffff, /* src_mask */ 689 0x7fffffff, /* dst_mask */ 690 TRUE), /* pcrel_offset */ 691 692 HOWTO (R_ARM_MOVW_ABS_NC, /* type */ 693 0, /* rightshift */ 694 2, /* size (0 = byte, 1 = short, 2 = long) */ 695 16, /* bitsize */ 696 FALSE, /* pc_relative */ 697 0, /* bitpos */ 698 complain_overflow_dont,/* complain_on_overflow */ 699 bfd_elf_generic_reloc, /* special_function */ 700 "R_ARM_MOVW_ABS_NC", /* name */ 701 FALSE, /* partial_inplace */ 702 0x0000ffff, /* src_mask */ 703 0x0000ffff, /* dst_mask */ 704 FALSE), /* pcrel_offset */ 705 706 HOWTO (R_ARM_MOVT_ABS, /* type */ 707 0, /* rightshift */ 708 2, /* size (0 = byte, 1 = short, 2 = long) */ 709 16, /* bitsize */ 710 FALSE, /* pc_relative */ 711 0, /* bitpos */ 712 complain_overflow_bitfield,/* complain_on_overflow */ 713 bfd_elf_generic_reloc, /* special_function */ 714 "R_ARM_MOVT_ABS", /* name */ 715 FALSE, /* partial_inplace */ 716 0x0000ffff, /* src_mask */ 717 0x0000ffff, /* dst_mask */ 718 FALSE), /* pcrel_offset */ 719 720 HOWTO (R_ARM_MOVW_PREL_NC, /* type */ 721 0, /* rightshift */ 722 2, /* size (0 = byte, 1 = short, 2 = long) */ 723 16, /* bitsize */ 724 TRUE, /* pc_relative */ 725 0, /* bitpos */ 726 complain_overflow_dont,/* complain_on_overflow */ 727 bfd_elf_generic_reloc, /* special_function */ 728 "R_ARM_MOVW_PREL_NC", /* name */ 729 FALSE, /* partial_inplace */ 730 0x0000ffff, /* src_mask */ 731 0x0000ffff, /* dst_mask */ 732 TRUE), /* pcrel_offset */ 733 734 HOWTO (R_ARM_MOVT_PREL, /* type */ 735 0, /* rightshift */ 736 2, /* size (0 = byte, 1 = short, 2 = long) */ 737 16, /* bitsize */ 738 TRUE, /* pc_relative */ 739 0, /* bitpos */ 740 complain_overflow_bitfield,/* complain_on_overflow */ 741 bfd_elf_generic_reloc, /* special_function */ 742 "R_ARM_MOVT_PREL", /* name */ 743 FALSE, /* partial_inplace */ 744 0x0000ffff, /* src_mask */ 745 0x0000ffff, /* dst_mask */ 746 TRUE), /* pcrel_offset */ 747 748 HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */ 749 0, /* rightshift */ 750 2, /* size (0 = byte, 1 = short, 2 = long) */ 751 16, /* bitsize */ 752 FALSE, /* pc_relative */ 753 0, /* bitpos */ 754 complain_overflow_dont,/* complain_on_overflow */ 755 bfd_elf_generic_reloc, /* special_function */ 756 "R_ARM_THM_MOVW_ABS_NC",/* name */ 757 FALSE, /* partial_inplace */ 758 0x040f70ff, /* src_mask */ 759 0x040f70ff, /* dst_mask */ 760 FALSE), /* pcrel_offset */ 761 762 HOWTO (R_ARM_THM_MOVT_ABS, /* type */ 763 0, /* rightshift */ 764 2, /* size (0 = byte, 1 = short, 2 = long) */ 765 16, /* bitsize */ 766 FALSE, /* pc_relative */ 767 0, /* bitpos */ 768 complain_overflow_bitfield,/* complain_on_overflow */ 769 bfd_elf_generic_reloc, /* special_function */ 770 "R_ARM_THM_MOVT_ABS", /* name */ 771 FALSE, /* partial_inplace */ 772 0x040f70ff, /* src_mask */ 773 0x040f70ff, /* dst_mask */ 774 FALSE), /* pcrel_offset */ 775 776 HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */ 777 0, /* rightshift */ 778 2, /* size (0 = byte, 1 = short, 2 = long) */ 779 16, /* bitsize */ 780 TRUE, /* pc_relative */ 781 0, /* bitpos */ 782 complain_overflow_dont,/* complain_on_overflow */ 783 bfd_elf_generic_reloc, /* special_function */ 784 "R_ARM_THM_MOVW_PREL_NC",/* name */ 785 FALSE, /* partial_inplace */ 786 0x040f70ff, /* src_mask */ 787 0x040f70ff, /* dst_mask */ 788 TRUE), /* pcrel_offset */ 789 790 HOWTO (R_ARM_THM_MOVT_PREL, /* type */ 791 0, /* rightshift */ 792 2, /* size (0 = byte, 1 = short, 2 = long) */ 793 16, /* bitsize */ 794 TRUE, /* pc_relative */ 795 0, /* bitpos */ 796 complain_overflow_bitfield,/* complain_on_overflow */ 797 bfd_elf_generic_reloc, /* special_function */ 798 "R_ARM_THM_MOVT_PREL", /* name */ 799 FALSE, /* partial_inplace */ 800 0x040f70ff, /* src_mask */ 801 0x040f70ff, /* dst_mask */ 802 TRUE), /* pcrel_offset */ 803 804 HOWTO (R_ARM_THM_JUMP19, /* type */ 805 1, /* rightshift */ 806 2, /* size (0 = byte, 1 = short, 2 = long) */ 807 19, /* bitsize */ 808 TRUE, /* pc_relative */ 809 0, /* bitpos */ 810 complain_overflow_signed,/* complain_on_overflow */ 811 bfd_elf_generic_reloc, /* special_function */ 812 "R_ARM_THM_JUMP19", /* name */ 813 FALSE, /* partial_inplace */ 814 0x043f2fff, /* src_mask */ 815 0x043f2fff, /* dst_mask */ 816 TRUE), /* pcrel_offset */ 817 818 HOWTO (R_ARM_THM_JUMP6, /* type */ 819 1, /* rightshift */ 820 1, /* size (0 = byte, 1 = short, 2 = long) */ 821 6, /* bitsize */ 822 TRUE, /* pc_relative */ 823 0, /* bitpos */ 824 complain_overflow_unsigned,/* complain_on_overflow */ 825 bfd_elf_generic_reloc, /* special_function */ 826 "R_ARM_THM_JUMP6", /* name */ 827 FALSE, /* partial_inplace */ 828 0x02f8, /* src_mask */ 829 0x02f8, /* dst_mask */ 830 TRUE), /* pcrel_offset */ 831 832 /* These are declared as 13-bit signed relocations because we can 833 address -4095 .. 4095(base) by altering ADDW to SUBW or vice 834 versa. */ 835 HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */ 836 0, /* rightshift */ 837 2, /* size (0 = byte, 1 = short, 2 = long) */ 838 13, /* bitsize */ 839 TRUE, /* pc_relative */ 840 0, /* bitpos */ 841 complain_overflow_dont,/* complain_on_overflow */ 842 bfd_elf_generic_reloc, /* special_function */ 843 "R_ARM_THM_ALU_PREL_11_0",/* name */ 844 FALSE, /* partial_inplace */ 845 0xffffffff, /* src_mask */ 846 0xffffffff, /* dst_mask */ 847 TRUE), /* pcrel_offset */ 848 849 HOWTO (R_ARM_THM_PC12, /* type */ 850 0, /* rightshift */ 851 2, /* size (0 = byte, 1 = short, 2 = long) */ 852 13, /* bitsize */ 853 TRUE, /* pc_relative */ 854 0, /* bitpos */ 855 complain_overflow_dont,/* complain_on_overflow */ 856 bfd_elf_generic_reloc, /* special_function */ 857 "R_ARM_THM_PC12", /* name */ 858 FALSE, /* partial_inplace */ 859 0xffffffff, /* src_mask */ 860 0xffffffff, /* dst_mask */ 861 TRUE), /* pcrel_offset */ 862 863 HOWTO (R_ARM_ABS32_NOI, /* type */ 864 0, /* rightshift */ 865 2, /* size (0 = byte, 1 = short, 2 = long) */ 866 32, /* bitsize */ 867 FALSE, /* pc_relative */ 868 0, /* bitpos */ 869 complain_overflow_dont,/* complain_on_overflow */ 870 bfd_elf_generic_reloc, /* special_function */ 871 "R_ARM_ABS32_NOI", /* name */ 872 FALSE, /* partial_inplace */ 873 0xffffffff, /* src_mask */ 874 0xffffffff, /* dst_mask */ 875 FALSE), /* pcrel_offset */ 876 877 HOWTO (R_ARM_REL32_NOI, /* type */ 878 0, /* rightshift */ 879 2, /* size (0 = byte, 1 = short, 2 = long) */ 880 32, /* bitsize */ 881 TRUE, /* pc_relative */ 882 0, /* bitpos */ 883 complain_overflow_dont,/* complain_on_overflow */ 884 bfd_elf_generic_reloc, /* special_function */ 885 "R_ARM_REL32_NOI", /* name */ 886 FALSE, /* partial_inplace */ 887 0xffffffff, /* src_mask */ 888 0xffffffff, /* dst_mask */ 889 FALSE), /* pcrel_offset */ 890 891 /* Group relocations. */ 892 893 HOWTO (R_ARM_ALU_PC_G0_NC, /* type */ 894 0, /* rightshift */ 895 2, /* size (0 = byte, 1 = short, 2 = long) */ 896 32, /* bitsize */ 897 TRUE, /* pc_relative */ 898 0, /* bitpos */ 899 complain_overflow_dont,/* complain_on_overflow */ 900 bfd_elf_generic_reloc, /* special_function */ 901 "R_ARM_ALU_PC_G0_NC", /* name */ 902 FALSE, /* partial_inplace */ 903 0xffffffff, /* src_mask */ 904 0xffffffff, /* dst_mask */ 905 TRUE), /* pcrel_offset */ 906 907 HOWTO (R_ARM_ALU_PC_G0, /* type */ 908 0, /* rightshift */ 909 2, /* size (0 = byte, 1 = short, 2 = long) */ 910 32, /* bitsize */ 911 TRUE, /* pc_relative */ 912 0, /* bitpos */ 913 complain_overflow_dont,/* complain_on_overflow */ 914 bfd_elf_generic_reloc, /* special_function */ 915 "R_ARM_ALU_PC_G0", /* name */ 916 FALSE, /* partial_inplace */ 917 0xffffffff, /* src_mask */ 918 0xffffffff, /* dst_mask */ 919 TRUE), /* pcrel_offset */ 920 921 HOWTO (R_ARM_ALU_PC_G1_NC, /* type */ 922 0, /* rightshift */ 923 2, /* size (0 = byte, 1 = short, 2 = long) */ 924 32, /* bitsize */ 925 TRUE, /* pc_relative */ 926 0, /* bitpos */ 927 complain_overflow_dont,/* complain_on_overflow */ 928 bfd_elf_generic_reloc, /* special_function */ 929 "R_ARM_ALU_PC_G1_NC", /* name */ 930 FALSE, /* partial_inplace */ 931 0xffffffff, /* src_mask */ 932 0xffffffff, /* dst_mask */ 933 TRUE), /* pcrel_offset */ 934 935 HOWTO (R_ARM_ALU_PC_G1, /* type */ 936 0, /* rightshift */ 937 2, /* size (0 = byte, 1 = short, 2 = long) */ 938 32, /* bitsize */ 939 TRUE, /* pc_relative */ 940 0, /* bitpos */ 941 complain_overflow_dont,/* complain_on_overflow */ 942 bfd_elf_generic_reloc, /* special_function */ 943 "R_ARM_ALU_PC_G1", /* name */ 944 FALSE, /* partial_inplace */ 945 0xffffffff, /* src_mask */ 946 0xffffffff, /* dst_mask */ 947 TRUE), /* pcrel_offset */ 948 949 HOWTO (R_ARM_ALU_PC_G2, /* type */ 950 0, /* rightshift */ 951 2, /* size (0 = byte, 1 = short, 2 = long) */ 952 32, /* bitsize */ 953 TRUE, /* pc_relative */ 954 0, /* bitpos */ 955 complain_overflow_dont,/* complain_on_overflow */ 956 bfd_elf_generic_reloc, /* special_function */ 957 "R_ARM_ALU_PC_G2", /* name */ 958 FALSE, /* partial_inplace */ 959 0xffffffff, /* src_mask */ 960 0xffffffff, /* dst_mask */ 961 TRUE), /* pcrel_offset */ 962 963 HOWTO (R_ARM_LDR_PC_G1, /* type */ 964 0, /* rightshift */ 965 2, /* size (0 = byte, 1 = short, 2 = long) */ 966 32, /* bitsize */ 967 TRUE, /* pc_relative */ 968 0, /* bitpos */ 969 complain_overflow_dont,/* complain_on_overflow */ 970 bfd_elf_generic_reloc, /* special_function */ 971 "R_ARM_LDR_PC_G1", /* name */ 972 FALSE, /* partial_inplace */ 973 0xffffffff, /* src_mask */ 974 0xffffffff, /* dst_mask */ 975 TRUE), /* pcrel_offset */ 976 977 HOWTO (R_ARM_LDR_PC_G2, /* type */ 978 0, /* rightshift */ 979 2, /* size (0 = byte, 1 = short, 2 = long) */ 980 32, /* bitsize */ 981 TRUE, /* pc_relative */ 982 0, /* bitpos */ 983 complain_overflow_dont,/* complain_on_overflow */ 984 bfd_elf_generic_reloc, /* special_function */ 985 "R_ARM_LDR_PC_G2", /* name */ 986 FALSE, /* partial_inplace */ 987 0xffffffff, /* src_mask */ 988 0xffffffff, /* dst_mask */ 989 TRUE), /* pcrel_offset */ 990 991 HOWTO (R_ARM_LDRS_PC_G0, /* type */ 992 0, /* rightshift */ 993 2, /* size (0 = byte, 1 = short, 2 = long) */ 994 32, /* bitsize */ 995 TRUE, /* pc_relative */ 996 0, /* bitpos */ 997 complain_overflow_dont,/* complain_on_overflow */ 998 bfd_elf_generic_reloc, /* special_function */ 999 "R_ARM_LDRS_PC_G0", /* name */ 1000 FALSE, /* partial_inplace */ 1001 0xffffffff, /* src_mask */ 1002 0xffffffff, /* dst_mask */ 1003 TRUE), /* pcrel_offset */ 1004 1005 HOWTO (R_ARM_LDRS_PC_G1, /* type */ 1006 0, /* rightshift */ 1007 2, /* size (0 = byte, 1 = short, 2 = long) */ 1008 32, /* bitsize */ 1009 TRUE, /* pc_relative */ 1010 0, /* bitpos */ 1011 complain_overflow_dont,/* complain_on_overflow */ 1012 bfd_elf_generic_reloc, /* special_function */ 1013 "R_ARM_LDRS_PC_G1", /* name */ 1014 FALSE, /* partial_inplace */ 1015 0xffffffff, /* src_mask */ 1016 0xffffffff, /* dst_mask */ 1017 TRUE), /* pcrel_offset */ 1018 1019 HOWTO (R_ARM_LDRS_PC_G2, /* type */ 1020 0, /* rightshift */ 1021 2, /* size (0 = byte, 1 = short, 2 = long) */ 1022 32, /* bitsize */ 1023 TRUE, /* pc_relative */ 1024 0, /* bitpos */ 1025 complain_overflow_dont,/* complain_on_overflow */ 1026 bfd_elf_generic_reloc, /* special_function */ 1027 "R_ARM_LDRS_PC_G2", /* name */ 1028 FALSE, /* partial_inplace */ 1029 0xffffffff, /* src_mask */ 1030 0xffffffff, /* dst_mask */ 1031 TRUE), /* pcrel_offset */ 1032 1033 HOWTO (R_ARM_LDC_PC_G0, /* type */ 1034 0, /* rightshift */ 1035 2, /* size (0 = byte, 1 = short, 2 = long) */ 1036 32, /* bitsize */ 1037 TRUE, /* pc_relative */ 1038 0, /* bitpos */ 1039 complain_overflow_dont,/* complain_on_overflow */ 1040 bfd_elf_generic_reloc, /* special_function */ 1041 "R_ARM_LDC_PC_G0", /* name */ 1042 FALSE, /* partial_inplace */ 1043 0xffffffff, /* src_mask */ 1044 0xffffffff, /* dst_mask */ 1045 TRUE), /* pcrel_offset */ 1046 1047 HOWTO (R_ARM_LDC_PC_G1, /* type */ 1048 0, /* rightshift */ 1049 2, /* size (0 = byte, 1 = short, 2 = long) */ 1050 32, /* bitsize */ 1051 TRUE, /* pc_relative */ 1052 0, /* bitpos */ 1053 complain_overflow_dont,/* complain_on_overflow */ 1054 bfd_elf_generic_reloc, /* special_function */ 1055 "R_ARM_LDC_PC_G1", /* name */ 1056 FALSE, /* partial_inplace */ 1057 0xffffffff, /* src_mask */ 1058 0xffffffff, /* dst_mask */ 1059 TRUE), /* pcrel_offset */ 1060 1061 HOWTO (R_ARM_LDC_PC_G2, /* type */ 1062 0, /* rightshift */ 1063 2, /* size (0 = byte, 1 = short, 2 = long) */ 1064 32, /* bitsize */ 1065 TRUE, /* pc_relative */ 1066 0, /* bitpos */ 1067 complain_overflow_dont,/* complain_on_overflow */ 1068 bfd_elf_generic_reloc, /* special_function */ 1069 "R_ARM_LDC_PC_G2", /* name */ 1070 FALSE, /* partial_inplace */ 1071 0xffffffff, /* src_mask */ 1072 0xffffffff, /* dst_mask */ 1073 TRUE), /* pcrel_offset */ 1074 1075 HOWTO (R_ARM_ALU_SB_G0_NC, /* type */ 1076 0, /* rightshift */ 1077 2, /* size (0 = byte, 1 = short, 2 = long) */ 1078 32, /* bitsize */ 1079 TRUE, /* pc_relative */ 1080 0, /* bitpos */ 1081 complain_overflow_dont,/* complain_on_overflow */ 1082 bfd_elf_generic_reloc, /* special_function */ 1083 "R_ARM_ALU_SB_G0_NC", /* name */ 1084 FALSE, /* partial_inplace */ 1085 0xffffffff, /* src_mask */ 1086 0xffffffff, /* dst_mask */ 1087 TRUE), /* pcrel_offset */ 1088 1089 HOWTO (R_ARM_ALU_SB_G0, /* type */ 1090 0, /* rightshift */ 1091 2, /* size (0 = byte, 1 = short, 2 = long) */ 1092 32, /* bitsize */ 1093 TRUE, /* pc_relative */ 1094 0, /* bitpos */ 1095 complain_overflow_dont,/* complain_on_overflow */ 1096 bfd_elf_generic_reloc, /* special_function */ 1097 "R_ARM_ALU_SB_G0", /* name */ 1098 FALSE, /* partial_inplace */ 1099 0xffffffff, /* src_mask */ 1100 0xffffffff, /* dst_mask */ 1101 TRUE), /* pcrel_offset */ 1102 1103 HOWTO (R_ARM_ALU_SB_G1_NC, /* type */ 1104 0, /* rightshift */ 1105 2, /* size (0 = byte, 1 = short, 2 = long) */ 1106 32, /* bitsize */ 1107 TRUE, /* pc_relative */ 1108 0, /* bitpos */ 1109 complain_overflow_dont,/* complain_on_overflow */ 1110 bfd_elf_generic_reloc, /* special_function */ 1111 "R_ARM_ALU_SB_G1_NC", /* name */ 1112 FALSE, /* partial_inplace */ 1113 0xffffffff, /* src_mask */ 1114 0xffffffff, /* dst_mask */ 1115 TRUE), /* pcrel_offset */ 1116 1117 HOWTO (R_ARM_ALU_SB_G1, /* type */ 1118 0, /* rightshift */ 1119 2, /* size (0 = byte, 1 = short, 2 = long) */ 1120 32, /* bitsize */ 1121 TRUE, /* pc_relative */ 1122 0, /* bitpos */ 1123 complain_overflow_dont,/* complain_on_overflow */ 1124 bfd_elf_generic_reloc, /* special_function */ 1125 "R_ARM_ALU_SB_G1", /* name */ 1126 FALSE, /* partial_inplace */ 1127 0xffffffff, /* src_mask */ 1128 0xffffffff, /* dst_mask */ 1129 TRUE), /* pcrel_offset */ 1130 1131 HOWTO (R_ARM_ALU_SB_G2, /* type */ 1132 0, /* rightshift */ 1133 2, /* size (0 = byte, 1 = short, 2 = long) */ 1134 32, /* bitsize */ 1135 TRUE, /* pc_relative */ 1136 0, /* bitpos */ 1137 complain_overflow_dont,/* complain_on_overflow */ 1138 bfd_elf_generic_reloc, /* special_function */ 1139 "R_ARM_ALU_SB_G2", /* name */ 1140 FALSE, /* partial_inplace */ 1141 0xffffffff, /* src_mask */ 1142 0xffffffff, /* dst_mask */ 1143 TRUE), /* pcrel_offset */ 1144 1145 HOWTO (R_ARM_LDR_SB_G0, /* type */ 1146 0, /* rightshift */ 1147 2, /* size (0 = byte, 1 = short, 2 = long) */ 1148 32, /* bitsize */ 1149 TRUE, /* pc_relative */ 1150 0, /* bitpos */ 1151 complain_overflow_dont,/* complain_on_overflow */ 1152 bfd_elf_generic_reloc, /* special_function */ 1153 "R_ARM_LDR_SB_G0", /* name */ 1154 FALSE, /* partial_inplace */ 1155 0xffffffff, /* src_mask */ 1156 0xffffffff, /* dst_mask */ 1157 TRUE), /* pcrel_offset */ 1158 1159 HOWTO (R_ARM_LDR_SB_G1, /* type */ 1160 0, /* rightshift */ 1161 2, /* size (0 = byte, 1 = short, 2 = long) */ 1162 32, /* bitsize */ 1163 TRUE, /* pc_relative */ 1164 0, /* bitpos */ 1165 complain_overflow_dont,/* complain_on_overflow */ 1166 bfd_elf_generic_reloc, /* special_function */ 1167 "R_ARM_LDR_SB_G1", /* name */ 1168 FALSE, /* partial_inplace */ 1169 0xffffffff, /* src_mask */ 1170 0xffffffff, /* dst_mask */ 1171 TRUE), /* pcrel_offset */ 1172 1173 HOWTO (R_ARM_LDR_SB_G2, /* type */ 1174 0, /* rightshift */ 1175 2, /* size (0 = byte, 1 = short, 2 = long) */ 1176 32, /* bitsize */ 1177 TRUE, /* pc_relative */ 1178 0, /* bitpos */ 1179 complain_overflow_dont,/* complain_on_overflow */ 1180 bfd_elf_generic_reloc, /* special_function */ 1181 "R_ARM_LDR_SB_G2", /* name */ 1182 FALSE, /* partial_inplace */ 1183 0xffffffff, /* src_mask */ 1184 0xffffffff, /* dst_mask */ 1185 TRUE), /* pcrel_offset */ 1186 1187 HOWTO (R_ARM_LDRS_SB_G0, /* type */ 1188 0, /* rightshift */ 1189 2, /* size (0 = byte, 1 = short, 2 = long) */ 1190 32, /* bitsize */ 1191 TRUE, /* pc_relative */ 1192 0, /* bitpos */ 1193 complain_overflow_dont,/* complain_on_overflow */ 1194 bfd_elf_generic_reloc, /* special_function */ 1195 "R_ARM_LDRS_SB_G0", /* name */ 1196 FALSE, /* partial_inplace */ 1197 0xffffffff, /* src_mask */ 1198 0xffffffff, /* dst_mask */ 1199 TRUE), /* pcrel_offset */ 1200 1201 HOWTO (R_ARM_LDRS_SB_G1, /* type */ 1202 0, /* rightshift */ 1203 2, /* size (0 = byte, 1 = short, 2 = long) */ 1204 32, /* bitsize */ 1205 TRUE, /* pc_relative */ 1206 0, /* bitpos */ 1207 complain_overflow_dont,/* complain_on_overflow */ 1208 bfd_elf_generic_reloc, /* special_function */ 1209 "R_ARM_LDRS_SB_G1", /* name */ 1210 FALSE, /* partial_inplace */ 1211 0xffffffff, /* src_mask */ 1212 0xffffffff, /* dst_mask */ 1213 TRUE), /* pcrel_offset */ 1214 1215 HOWTO (R_ARM_LDRS_SB_G2, /* type */ 1216 0, /* rightshift */ 1217 2, /* size (0 = byte, 1 = short, 2 = long) */ 1218 32, /* bitsize */ 1219 TRUE, /* pc_relative */ 1220 0, /* bitpos */ 1221 complain_overflow_dont,/* complain_on_overflow */ 1222 bfd_elf_generic_reloc, /* special_function */ 1223 "R_ARM_LDRS_SB_G2", /* name */ 1224 FALSE, /* partial_inplace */ 1225 0xffffffff, /* src_mask */ 1226 0xffffffff, /* dst_mask */ 1227 TRUE), /* pcrel_offset */ 1228 1229 HOWTO (R_ARM_LDC_SB_G0, /* type */ 1230 0, /* rightshift */ 1231 2, /* size (0 = byte, 1 = short, 2 = long) */ 1232 32, /* bitsize */ 1233 TRUE, /* pc_relative */ 1234 0, /* bitpos */ 1235 complain_overflow_dont,/* complain_on_overflow */ 1236 bfd_elf_generic_reloc, /* special_function */ 1237 "R_ARM_LDC_SB_G0", /* name */ 1238 FALSE, /* partial_inplace */ 1239 0xffffffff, /* src_mask */ 1240 0xffffffff, /* dst_mask */ 1241 TRUE), /* pcrel_offset */ 1242 1243 HOWTO (R_ARM_LDC_SB_G1, /* type */ 1244 0, /* rightshift */ 1245 2, /* size (0 = byte, 1 = short, 2 = long) */ 1246 32, /* bitsize */ 1247 TRUE, /* pc_relative */ 1248 0, /* bitpos */ 1249 complain_overflow_dont,/* complain_on_overflow */ 1250 bfd_elf_generic_reloc, /* special_function */ 1251 "R_ARM_LDC_SB_G1", /* name */ 1252 FALSE, /* partial_inplace */ 1253 0xffffffff, /* src_mask */ 1254 0xffffffff, /* dst_mask */ 1255 TRUE), /* pcrel_offset */ 1256 1257 HOWTO (R_ARM_LDC_SB_G2, /* type */ 1258 0, /* rightshift */ 1259 2, /* size (0 = byte, 1 = short, 2 = long) */ 1260 32, /* bitsize */ 1261 TRUE, /* pc_relative */ 1262 0, /* bitpos */ 1263 complain_overflow_dont,/* complain_on_overflow */ 1264 bfd_elf_generic_reloc, /* special_function */ 1265 "R_ARM_LDC_SB_G2", /* name */ 1266 FALSE, /* partial_inplace */ 1267 0xffffffff, /* src_mask */ 1268 0xffffffff, /* dst_mask */ 1269 TRUE), /* pcrel_offset */ 1270 1271 /* End of group relocations. */ 1272 1273 HOWTO (R_ARM_MOVW_BREL_NC, /* type */ 1274 0, /* rightshift */ 1275 2, /* size (0 = byte, 1 = short, 2 = long) */ 1276 16, /* bitsize */ 1277 FALSE, /* pc_relative */ 1278 0, /* bitpos */ 1279 complain_overflow_dont,/* complain_on_overflow */ 1280 bfd_elf_generic_reloc, /* special_function */ 1281 "R_ARM_MOVW_BREL_NC", /* name */ 1282 FALSE, /* partial_inplace */ 1283 0x0000ffff, /* src_mask */ 1284 0x0000ffff, /* dst_mask */ 1285 FALSE), /* pcrel_offset */ 1286 1287 HOWTO (R_ARM_MOVT_BREL, /* type */ 1288 0, /* rightshift */ 1289 2, /* size (0 = byte, 1 = short, 2 = long) */ 1290 16, /* bitsize */ 1291 FALSE, /* pc_relative */ 1292 0, /* bitpos */ 1293 complain_overflow_bitfield,/* complain_on_overflow */ 1294 bfd_elf_generic_reloc, /* special_function */ 1295 "R_ARM_MOVT_BREL", /* name */ 1296 FALSE, /* partial_inplace */ 1297 0x0000ffff, /* src_mask */ 1298 0x0000ffff, /* dst_mask */ 1299 FALSE), /* pcrel_offset */ 1300 1301 HOWTO (R_ARM_MOVW_BREL, /* type */ 1302 0, /* rightshift */ 1303 2, /* size (0 = byte, 1 = short, 2 = long) */ 1304 16, /* bitsize */ 1305 FALSE, /* pc_relative */ 1306 0, /* bitpos */ 1307 complain_overflow_dont,/* complain_on_overflow */ 1308 bfd_elf_generic_reloc, /* special_function */ 1309 "R_ARM_MOVW_BREL", /* name */ 1310 FALSE, /* partial_inplace */ 1311 0x0000ffff, /* src_mask */ 1312 0x0000ffff, /* dst_mask */ 1313 FALSE), /* pcrel_offset */ 1314 1315 HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */ 1316 0, /* rightshift */ 1317 2, /* size (0 = byte, 1 = short, 2 = long) */ 1318 16, /* bitsize */ 1319 FALSE, /* pc_relative */ 1320 0, /* bitpos */ 1321 complain_overflow_dont,/* complain_on_overflow */ 1322 bfd_elf_generic_reloc, /* special_function */ 1323 "R_ARM_THM_MOVW_BREL_NC",/* name */ 1324 FALSE, /* partial_inplace */ 1325 0x040f70ff, /* src_mask */ 1326 0x040f70ff, /* dst_mask */ 1327 FALSE), /* pcrel_offset */ 1328 1329 HOWTO (R_ARM_THM_MOVT_BREL, /* type */ 1330 0, /* rightshift */ 1331 2, /* size (0 = byte, 1 = short, 2 = long) */ 1332 16, /* bitsize */ 1333 FALSE, /* pc_relative */ 1334 0, /* bitpos */ 1335 complain_overflow_bitfield,/* complain_on_overflow */ 1336 bfd_elf_generic_reloc, /* special_function */ 1337 "R_ARM_THM_MOVT_BREL", /* name */ 1338 FALSE, /* partial_inplace */ 1339 0x040f70ff, /* src_mask */ 1340 0x040f70ff, /* dst_mask */ 1341 FALSE), /* pcrel_offset */ 1342 1343 HOWTO (R_ARM_THM_MOVW_BREL, /* type */ 1344 0, /* rightshift */ 1345 2, /* size (0 = byte, 1 = short, 2 = long) */ 1346 16, /* bitsize */ 1347 FALSE, /* pc_relative */ 1348 0, /* bitpos */ 1349 complain_overflow_dont,/* complain_on_overflow */ 1350 bfd_elf_generic_reloc, /* special_function */ 1351 "R_ARM_THM_MOVW_BREL", /* name */ 1352 FALSE, /* partial_inplace */ 1353 0x040f70ff, /* src_mask */ 1354 0x040f70ff, /* dst_mask */ 1355 FALSE), /* pcrel_offset */ 1356 1357 EMPTY_HOWTO (90), /* unallocated */ 1358 EMPTY_HOWTO (91), 1359 EMPTY_HOWTO (92), 1360 EMPTY_HOWTO (93), 1361 1362 HOWTO (R_ARM_PLT32_ABS, /* type */ 1363 0, /* rightshift */ 1364 2, /* size (0 = byte, 1 = short, 2 = long) */ 1365 32, /* bitsize */ 1366 FALSE, /* pc_relative */ 1367 0, /* bitpos */ 1368 complain_overflow_dont,/* complain_on_overflow */ 1369 bfd_elf_generic_reloc, /* special_function */ 1370 "R_ARM_PLT32_ABS", /* name */ 1371 FALSE, /* partial_inplace */ 1372 0xffffffff, /* src_mask */ 1373 0xffffffff, /* dst_mask */ 1374 FALSE), /* pcrel_offset */ 1375 1376 HOWTO (R_ARM_GOT_ABS, /* type */ 1377 0, /* rightshift */ 1378 2, /* size (0 = byte, 1 = short, 2 = long) */ 1379 32, /* bitsize */ 1380 FALSE, /* pc_relative */ 1381 0, /* bitpos */ 1382 complain_overflow_dont,/* complain_on_overflow */ 1383 bfd_elf_generic_reloc, /* special_function */ 1384 "R_ARM_GOT_ABS", /* name */ 1385 FALSE, /* partial_inplace */ 1386 0xffffffff, /* src_mask */ 1387 0xffffffff, /* dst_mask */ 1388 FALSE), /* pcrel_offset */ 1389 1390 HOWTO (R_ARM_GOT_PREL, /* type */ 1391 0, /* rightshift */ 1392 2, /* size (0 = byte, 1 = short, 2 = long) */ 1393 32, /* bitsize */ 1394 TRUE, /* pc_relative */ 1395 0, /* bitpos */ 1396 complain_overflow_dont, /* complain_on_overflow */ 1397 bfd_elf_generic_reloc, /* special_function */ 1398 "R_ARM_GOT_PREL", /* name */ 1399 FALSE, /* partial_inplace */ 1400 0xffffffff, /* src_mask */ 1401 0xffffffff, /* dst_mask */ 1402 TRUE), /* pcrel_offset */ 1403 1404 HOWTO (R_ARM_GOT_BREL12, /* type */ 1405 0, /* rightshift */ 1406 2, /* size (0 = byte, 1 = short, 2 = long) */ 1407 12, /* bitsize */ 1408 FALSE, /* pc_relative */ 1409 0, /* bitpos */ 1410 complain_overflow_bitfield,/* complain_on_overflow */ 1411 bfd_elf_generic_reloc, /* special_function */ 1412 "R_ARM_GOT_BREL12", /* name */ 1413 FALSE, /* partial_inplace */ 1414 0x00000fff, /* src_mask */ 1415 0x00000fff, /* dst_mask */ 1416 FALSE), /* pcrel_offset */ 1417 1418 HOWTO (R_ARM_GOTOFF12, /* type */ 1419 0, /* rightshift */ 1420 2, /* size (0 = byte, 1 = short, 2 = long) */ 1421 12, /* bitsize */ 1422 FALSE, /* pc_relative */ 1423 0, /* bitpos */ 1424 complain_overflow_bitfield,/* complain_on_overflow */ 1425 bfd_elf_generic_reloc, /* special_function */ 1426 "R_ARM_GOTOFF12", /* name */ 1427 FALSE, /* partial_inplace */ 1428 0x00000fff, /* src_mask */ 1429 0x00000fff, /* dst_mask */ 1430 FALSE), /* pcrel_offset */ 1431 1432 EMPTY_HOWTO (R_ARM_GOTRELAX), /* reserved for future GOT-load optimizations */ 1433 1434 /* GNU extension to record C++ vtable member usage */ 1435 HOWTO (R_ARM_GNU_VTENTRY, /* type */ 1436 0, /* rightshift */ 1437 2, /* size (0 = byte, 1 = short, 2 = long) */ 1438 0, /* bitsize */ 1439 FALSE, /* pc_relative */ 1440 0, /* bitpos */ 1441 complain_overflow_dont, /* complain_on_overflow */ 1442 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 1443 "R_ARM_GNU_VTENTRY", /* name */ 1444 FALSE, /* partial_inplace */ 1445 0, /* src_mask */ 1446 0, /* dst_mask */ 1447 FALSE), /* pcrel_offset */ 1448 1449 /* GNU extension to record C++ vtable hierarchy */ 1450 HOWTO (R_ARM_GNU_VTINHERIT, /* type */ 1451 0, /* rightshift */ 1452 2, /* size (0 = byte, 1 = short, 2 = long) */ 1453 0, /* bitsize */ 1454 FALSE, /* pc_relative */ 1455 0, /* bitpos */ 1456 complain_overflow_dont, /* complain_on_overflow */ 1457 NULL, /* special_function */ 1458 "R_ARM_GNU_VTINHERIT", /* name */ 1459 FALSE, /* partial_inplace */ 1460 0, /* src_mask */ 1461 0, /* dst_mask */ 1462 FALSE), /* pcrel_offset */ 1463 1464 HOWTO (R_ARM_THM_JUMP11, /* type */ 1465 1, /* rightshift */ 1466 1, /* size (0 = byte, 1 = short, 2 = long) */ 1467 11, /* bitsize */ 1468 TRUE, /* pc_relative */ 1469 0, /* bitpos */ 1470 complain_overflow_signed, /* complain_on_overflow */ 1471 bfd_elf_generic_reloc, /* special_function */ 1472 "R_ARM_THM_JUMP11", /* name */ 1473 FALSE, /* partial_inplace */ 1474 0x000007ff, /* src_mask */ 1475 0x000007ff, /* dst_mask */ 1476 TRUE), /* pcrel_offset */ 1477 1478 HOWTO (R_ARM_THM_JUMP8, /* type */ 1479 1, /* rightshift */ 1480 1, /* size (0 = byte, 1 = short, 2 = long) */ 1481 8, /* bitsize */ 1482 TRUE, /* pc_relative */ 1483 0, /* bitpos */ 1484 complain_overflow_signed, /* complain_on_overflow */ 1485 bfd_elf_generic_reloc, /* special_function */ 1486 "R_ARM_THM_JUMP8", /* name */ 1487 FALSE, /* partial_inplace */ 1488 0x000000ff, /* src_mask */ 1489 0x000000ff, /* dst_mask */ 1490 TRUE), /* pcrel_offset */ 1491 1492 /* TLS relocations */ 1493 HOWTO (R_ARM_TLS_GD32, /* type */ 1494 0, /* rightshift */ 1495 2, /* size (0 = byte, 1 = short, 2 = long) */ 1496 32, /* bitsize */ 1497 FALSE, /* pc_relative */ 1498 0, /* bitpos */ 1499 complain_overflow_bitfield,/* complain_on_overflow */ 1500 NULL, /* special_function */ 1501 "R_ARM_TLS_GD32", /* name */ 1502 TRUE, /* partial_inplace */ 1503 0xffffffff, /* src_mask */ 1504 0xffffffff, /* dst_mask */ 1505 FALSE), /* pcrel_offset */ 1506 1507 HOWTO (R_ARM_TLS_LDM32, /* type */ 1508 0, /* rightshift */ 1509 2, /* size (0 = byte, 1 = short, 2 = long) */ 1510 32, /* bitsize */ 1511 FALSE, /* pc_relative */ 1512 0, /* bitpos */ 1513 complain_overflow_bitfield,/* complain_on_overflow */ 1514 bfd_elf_generic_reloc, /* special_function */ 1515 "R_ARM_TLS_LDM32", /* name */ 1516 TRUE, /* partial_inplace */ 1517 0xffffffff, /* src_mask */ 1518 0xffffffff, /* dst_mask */ 1519 FALSE), /* pcrel_offset */ 1520 1521 HOWTO (R_ARM_TLS_LDO32, /* type */ 1522 0, /* rightshift */ 1523 2, /* size (0 = byte, 1 = short, 2 = long) */ 1524 32, /* bitsize */ 1525 FALSE, /* pc_relative */ 1526 0, /* bitpos */ 1527 complain_overflow_bitfield,/* complain_on_overflow */ 1528 bfd_elf_generic_reloc, /* special_function */ 1529 "R_ARM_TLS_LDO32", /* name */ 1530 TRUE, /* partial_inplace */ 1531 0xffffffff, /* src_mask */ 1532 0xffffffff, /* dst_mask */ 1533 FALSE), /* pcrel_offset */ 1534 1535 HOWTO (R_ARM_TLS_IE32, /* type */ 1536 0, /* rightshift */ 1537 2, /* size (0 = byte, 1 = short, 2 = long) */ 1538 32, /* bitsize */ 1539 FALSE, /* pc_relative */ 1540 0, /* bitpos */ 1541 complain_overflow_bitfield,/* complain_on_overflow */ 1542 NULL, /* special_function */ 1543 "R_ARM_TLS_IE32", /* name */ 1544 TRUE, /* partial_inplace */ 1545 0xffffffff, /* src_mask */ 1546 0xffffffff, /* dst_mask */ 1547 FALSE), /* pcrel_offset */ 1548 1549 HOWTO (R_ARM_TLS_LE32, /* type */ 1550 0, /* rightshift */ 1551 2, /* size (0 = byte, 1 = short, 2 = long) */ 1552 32, /* bitsize */ 1553 FALSE, /* pc_relative */ 1554 0, /* bitpos */ 1555 complain_overflow_bitfield,/* complain_on_overflow */ 1556 bfd_elf_generic_reloc, /* special_function */ 1557 "R_ARM_TLS_LE32", /* name */ 1558 TRUE, /* partial_inplace */ 1559 0xffffffff, /* src_mask */ 1560 0xffffffff, /* dst_mask */ 1561 FALSE), /* pcrel_offset */ 1562 1563 HOWTO (R_ARM_TLS_LDO12, /* type */ 1564 0, /* rightshift */ 1565 2, /* size (0 = byte, 1 = short, 2 = long) */ 1566 12, /* bitsize */ 1567 FALSE, /* pc_relative */ 1568 0, /* bitpos */ 1569 complain_overflow_bitfield,/* complain_on_overflow */ 1570 bfd_elf_generic_reloc, /* special_function */ 1571 "R_ARM_TLS_LDO12", /* name */ 1572 FALSE, /* partial_inplace */ 1573 0x00000fff, /* src_mask */ 1574 0x00000fff, /* dst_mask */ 1575 FALSE), /* pcrel_offset */ 1576 1577 HOWTO (R_ARM_TLS_LE12, /* type */ 1578 0, /* rightshift */ 1579 2, /* size (0 = byte, 1 = short, 2 = long) */ 1580 12, /* bitsize */ 1581 FALSE, /* pc_relative */ 1582 0, /* bitpos */ 1583 complain_overflow_bitfield,/* complain_on_overflow */ 1584 bfd_elf_generic_reloc, /* special_function */ 1585 "R_ARM_TLS_LE12", /* name */ 1586 FALSE, /* partial_inplace */ 1587 0x00000fff, /* src_mask */ 1588 0x00000fff, /* dst_mask */ 1589 FALSE), /* pcrel_offset */ 1590 1591 HOWTO (R_ARM_TLS_IE12GP, /* type */ 1592 0, /* rightshift */ 1593 2, /* size (0 = byte, 1 = short, 2 = long) */ 1594 12, /* bitsize */ 1595 FALSE, /* pc_relative */ 1596 0, /* bitpos */ 1597 complain_overflow_bitfield,/* complain_on_overflow */ 1598 bfd_elf_generic_reloc, /* special_function */ 1599 "R_ARM_TLS_IE12GP", /* name */ 1600 FALSE, /* partial_inplace */ 1601 0x00000fff, /* src_mask */ 1602 0x00000fff, /* dst_mask */ 1603 FALSE), /* pcrel_offset */ 1604}; 1605 1606/* 112-127 private relocations 1607 128 R_ARM_ME_TOO, obsolete 1608 129-255 unallocated in AAELF. 1609 1610 249-255 extended, currently unused, relocations: */ 1611 1612static reloc_howto_type elf32_arm_howto_table_2[4] = 1613{ 1614 HOWTO (R_ARM_RREL32, /* type */ 1615 0, /* rightshift */ 1616 0, /* size (0 = byte, 1 = short, 2 = long) */ 1617 0, /* bitsize */ 1618 FALSE, /* pc_relative */ 1619 0, /* bitpos */ 1620 complain_overflow_dont,/* complain_on_overflow */ 1621 bfd_elf_generic_reloc, /* special_function */ 1622 "R_ARM_RREL32", /* name */ 1623 FALSE, /* partial_inplace */ 1624 0, /* src_mask */ 1625 0, /* dst_mask */ 1626 FALSE), /* pcrel_offset */ 1627 1628 HOWTO (R_ARM_RABS32, /* type */ 1629 0, /* rightshift */ 1630 0, /* size (0 = byte, 1 = short, 2 = long) */ 1631 0, /* bitsize */ 1632 FALSE, /* pc_relative */ 1633 0, /* bitpos */ 1634 complain_overflow_dont,/* complain_on_overflow */ 1635 bfd_elf_generic_reloc, /* special_function */ 1636 "R_ARM_RABS32", /* name */ 1637 FALSE, /* partial_inplace */ 1638 0, /* src_mask */ 1639 0, /* dst_mask */ 1640 FALSE), /* pcrel_offset */ 1641 1642 HOWTO (R_ARM_RPC24, /* type */ 1643 0, /* rightshift */ 1644 0, /* size (0 = byte, 1 = short, 2 = long) */ 1645 0, /* bitsize */ 1646 FALSE, /* pc_relative */ 1647 0, /* bitpos */ 1648 complain_overflow_dont,/* complain_on_overflow */ 1649 bfd_elf_generic_reloc, /* special_function */ 1650 "R_ARM_RPC24", /* name */ 1651 FALSE, /* partial_inplace */ 1652 0, /* src_mask */ 1653 0, /* dst_mask */ 1654 FALSE), /* pcrel_offset */ 1655 1656 HOWTO (R_ARM_RBASE, /* type */ 1657 0, /* rightshift */ 1658 0, /* size (0 = byte, 1 = short, 2 = long) */ 1659 0, /* bitsize */ 1660 FALSE, /* pc_relative */ 1661 0, /* bitpos */ 1662 complain_overflow_dont,/* complain_on_overflow */ 1663 bfd_elf_generic_reloc, /* special_function */ 1664 "R_ARM_RBASE", /* name */ 1665 FALSE, /* partial_inplace */ 1666 0, /* src_mask */ 1667 0, /* dst_mask */ 1668 FALSE) /* pcrel_offset */ 1669}; 1670 1671static reloc_howto_type * 1672elf32_arm_howto_from_type (unsigned int r_type) 1673{ 1674 if (r_type < NUM_ELEM (elf32_arm_howto_table_1)) 1675 return &elf32_arm_howto_table_1[r_type]; 1676 1677 if (r_type >= R_ARM_RREL32 1678 && r_type < R_ARM_RREL32 + NUM_ELEM (elf32_arm_howto_table_2)) 1679 return &elf32_arm_howto_table_2[r_type - R_ARM_RREL32]; 1680 1681 return NULL; 1682} 1683 1684static void 1685elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc, 1686 Elf_Internal_Rela * elf_reloc) 1687{ 1688 unsigned int r_type; 1689 1690 r_type = ELF32_R_TYPE (elf_reloc->r_info); 1691 bfd_reloc->howto = elf32_arm_howto_from_type (r_type); 1692} 1693 1694struct elf32_arm_reloc_map 1695 { 1696 bfd_reloc_code_real_type bfd_reloc_val; 1697 unsigned char elf_reloc_val; 1698 }; 1699 1700/* All entries in this list must also be present in elf32_arm_howto_table. */ 1701static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] = 1702 { 1703 {BFD_RELOC_NONE, R_ARM_NONE}, 1704 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24}, 1705 {BFD_RELOC_ARM_PCREL_CALL, R_ARM_CALL}, 1706 {BFD_RELOC_ARM_PCREL_JUMP, R_ARM_JUMP24}, 1707 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25}, 1708 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22}, 1709 {BFD_RELOC_32, R_ARM_ABS32}, 1710 {BFD_RELOC_32_PCREL, R_ARM_REL32}, 1711 {BFD_RELOC_8, R_ARM_ABS8}, 1712 {BFD_RELOC_16, R_ARM_ABS16}, 1713 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12}, 1714 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5}, 1715 {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24}, 1716 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL}, 1717 {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11}, 1718 {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19}, 1719 {BFD_RELOC_THUMB_PCREL_BRANCH9, R_ARM_THM_JUMP8}, 1720 {BFD_RELOC_THUMB_PCREL_BRANCH7, R_ARM_THM_JUMP6}, 1721 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT}, 1722 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT}, 1723 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE}, 1724 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF32}, 1725 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC}, 1726 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32}, 1727 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32}, 1728 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1}, 1729 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32}, 1730 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32}, 1731 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31}, 1732 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2}, 1733 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32}, 1734 {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32}, 1735 {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32}, 1736 {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32}, 1737 {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32}, 1738 {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32}, 1739 {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32}, 1740 {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32}, 1741 {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32}, 1742 {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT}, 1743 {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY}, 1744 {BFD_RELOC_ARM_MOVW, R_ARM_MOVW_ABS_NC}, 1745 {BFD_RELOC_ARM_MOVT, R_ARM_MOVT_ABS}, 1746 {BFD_RELOC_ARM_MOVW_PCREL, R_ARM_MOVW_PREL_NC}, 1747 {BFD_RELOC_ARM_MOVT_PCREL, R_ARM_MOVT_PREL}, 1748 {BFD_RELOC_ARM_THUMB_MOVW, R_ARM_THM_MOVW_ABS_NC}, 1749 {BFD_RELOC_ARM_THUMB_MOVT, R_ARM_THM_MOVT_ABS}, 1750 {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC}, 1751 {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL}, 1752 {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC}, 1753 {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0}, 1754 {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC}, 1755 {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1}, 1756 {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2}, 1757 {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0}, 1758 {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1}, 1759 {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2}, 1760 {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0}, 1761 {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1}, 1762 {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2}, 1763 {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0}, 1764 {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1}, 1765 {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2}, 1766 {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC}, 1767 {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0}, 1768 {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC}, 1769 {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1}, 1770 {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2}, 1771 {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0}, 1772 {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1}, 1773 {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2}, 1774 {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0}, 1775 {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1}, 1776 {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2}, 1777 {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0}, 1778 {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1}, 1779 {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2} 1780 }; 1781 1782static reloc_howto_type * 1783elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1784 bfd_reloc_code_real_type code) 1785{ 1786 unsigned int i; 1787 for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++) 1788 if (elf32_arm_reloc_map[i].bfd_reloc_val == code) 1789 return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val); 1790 1791 return NULL; 1792} 1793 1794static reloc_howto_type * 1795elf32_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1796 const char *r_name) 1797{ 1798 unsigned int i; 1799 1800 for (i = 0; 1801 i < (sizeof (elf32_arm_howto_table_1) 1802 / sizeof (elf32_arm_howto_table_1[0])); 1803 i++) 1804 if (elf32_arm_howto_table_1[i].name != NULL 1805 && strcasecmp (elf32_arm_howto_table_1[i].name, r_name) == 0) 1806 return &elf32_arm_howto_table_1[i]; 1807 1808 for (i = 0; 1809 i < (sizeof (elf32_arm_howto_table_2) 1810 / sizeof (elf32_arm_howto_table_2[0])); 1811 i++) 1812 if (elf32_arm_howto_table_2[i].name != NULL 1813 && strcasecmp (elf32_arm_howto_table_2[i].name, r_name) == 0) 1814 return &elf32_arm_howto_table_2[i]; 1815 1816 return NULL; 1817} 1818 1819/* Support for core dump NOTE sections */ 1820static bfd_boolean 1821elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 1822{ 1823 int offset; 1824 size_t size; 1825 1826 switch (note->descsz) 1827 { 1828 default: 1829 return FALSE; 1830 1831 case 148: /* Linux/ARM 32-bit*/ 1832 /* pr_cursig */ 1833 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 1834 1835 /* pr_pid */ 1836 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24); 1837 1838 /* pr_reg */ 1839 offset = 72; 1840 size = 72; 1841 1842 break; 1843 1844 case 96: /* FreeBSD/ARM */ 1845 /* pr_cursig */ 1846 if (elf_tdata(abfd)->core_signal == 0) 1847 elf_tdata (abfd)->core_signal = ((int *)(note->descdata))[5]; 1848 1849 /* pr_pid */ 1850 elf_tdata (abfd)->core_pid = ((int *)(note->descdata))[6]; 1851 1852 /* pr_reg */ 1853 offset = 28; 1854 size = 68; 1855 break; 1856 } 1857 1858 /* Make a ".reg/999" section. */ 1859 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 1860 size, note->descpos + offset); 1861} 1862 1863static bfd_boolean 1864elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 1865{ 1866 switch (note->descsz) 1867 { 1868 default: 1869 return FALSE; 1870 1871 case 124: /* Linux/ARM elf_prpsinfo */ 1872 elf_tdata (abfd)->core_program 1873 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 1874 elf_tdata (abfd)->core_command 1875 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 1876 } 1877 1878 /* Note that for some reason, a spurious space is tacked 1879 onto the end of the args in some (at least one anyway) 1880 implementations, so strip it off if it exists. */ 1881 1882 { 1883 char *command = elf_tdata (abfd)->core_command; 1884 int n = strlen (command); 1885 1886 if (0 < n && command[n - 1] == ' ') 1887 command[n - 1] = '\0'; 1888 } 1889 1890 return TRUE; 1891} 1892 1893#define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec 1894#define TARGET_LITTLE_NAME "elf32-littlearm" 1895#define TARGET_BIG_SYM bfd_elf32_bigarm_vec 1896#define TARGET_BIG_NAME "elf32-bigarm" 1897 1898#define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus 1899#define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo 1900 1901typedef unsigned long int insn32; 1902typedef unsigned short int insn16; 1903 1904/* In lieu of proper flags, assume all EABIv4 or later objects are 1905 interworkable. */ 1906#define INTERWORK_FLAG(abfd) \ 1907 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \ 1908 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)) 1909 1910/* The linker script knows the section names for placement. 1911 The entry_names are used to do simple name mangling on the stubs. 1912 Given a function name, and its type, the stub can be found. The 1913 name can be changed. The only requirement is the %s be present. */ 1914#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t" 1915#define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb" 1916 1917#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7" 1918#define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm" 1919 1920#define VFP11_ERRATUM_VENEER_SECTION_NAME ".vfp11_veneer" 1921#define VFP11_ERRATUM_VENEER_ENTRY_NAME "__vfp11_veneer_%x" 1922 1923/* The name of the dynamic interpreter. This is put in the .interp 1924 section. */ 1925#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 1926 1927#ifdef FOUR_WORD_PLT 1928 1929/* The first entry in a procedure linkage table looks like 1930 this. It is set up so that any shared library function that is 1931 called before the relocation has been set up calls the dynamic 1932 linker first. */ 1933static const bfd_vma elf32_arm_plt0_entry [] = 1934 { 1935 0xe52de004, /* str lr, [sp, #-4]! */ 1936 0xe59fe010, /* ldr lr, [pc, #16] */ 1937 0xe08fe00e, /* add lr, pc, lr */ 1938 0xe5bef008, /* ldr pc, [lr, #8]! */ 1939 }; 1940 1941/* Subsequent entries in a procedure linkage table look like 1942 this. */ 1943static const bfd_vma elf32_arm_plt_entry [] = 1944 { 1945 0xe28fc600, /* add ip, pc, #NN */ 1946 0xe28cca00, /* add ip, ip, #NN */ 1947 0xe5bcf000, /* ldr pc, [ip, #NN]! */ 1948 0x00000000, /* unused */ 1949 }; 1950 1951#else 1952 1953/* The first entry in a procedure linkage table looks like 1954 this. It is set up so that any shared library function that is 1955 called before the relocation has been set up calls the dynamic 1956 linker first. */ 1957static const bfd_vma elf32_arm_plt0_entry [] = 1958 { 1959 0xe52de004, /* str lr, [sp, #-4]! */ 1960 0xe59fe004, /* ldr lr, [pc, #4] */ 1961 0xe08fe00e, /* add lr, pc, lr */ 1962 0xe5bef008, /* ldr pc, [lr, #8]! */ 1963 0x00000000, /* &GOT[0] - . */ 1964 }; 1965 1966/* Subsequent entries in a procedure linkage table look like 1967 this. */ 1968static const bfd_vma elf32_arm_plt_entry [] = 1969 { 1970 0xe28fc600, /* add ip, pc, #0xNN00000 */ 1971 0xe28cca00, /* add ip, ip, #0xNN000 */ 1972 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */ 1973 }; 1974 1975#endif 1976 1977/* The format of the first entry in the procedure linkage table 1978 for a VxWorks executable. */ 1979static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] = 1980 { 1981 0xe52dc008, /* str ip,[sp,#-8]! */ 1982 0xe59fc000, /* ldr ip,[pc] */ 1983 0xe59cf008, /* ldr pc,[ip,#8] */ 1984 0x00000000, /* .long _GLOBAL_OFFSET_TABLE_ */ 1985 }; 1986 1987/* The format of subsequent entries in a VxWorks executable. */ 1988static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] = 1989 { 1990 0xe59fc000, /* ldr ip,[pc] */ 1991 0xe59cf000, /* ldr pc,[ip] */ 1992 0x00000000, /* .long @got */ 1993 0xe59fc000, /* ldr ip,[pc] */ 1994 0xea000000, /* b _PLT */ 1995 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */ 1996 }; 1997 1998/* The format of entries in a VxWorks shared library. */ 1999static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] = 2000 { 2001 0xe59fc000, /* ldr ip,[pc] */ 2002 0xe79cf009, /* ldr pc,[ip,r9] */ 2003 0x00000000, /* .long @got */ 2004 0xe59fc000, /* ldr ip,[pc] */ 2005 0xe599f008, /* ldr pc,[r9,#8] */ 2006 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */ 2007 }; 2008 2009/* An initial stub used if the PLT entry is referenced from Thumb code. */ 2010#define PLT_THUMB_STUB_SIZE 4 2011static const bfd_vma elf32_arm_plt_thumb_stub [] = 2012 { 2013 0x4778, /* bx pc */ 2014 0x46c0 /* nop */ 2015 }; 2016 2017/* The entries in a PLT when using a DLL-based target with multiple 2018 address spaces. */ 2019static const bfd_vma elf32_arm_symbian_plt_entry [] = 2020 { 2021 0xe51ff004, /* ldr pc, [pc, #-4] */ 2022 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */ 2023 }; 2024 2025/* Used to build a map of a section. This is required for mixed-endian 2026 code/data. */ 2027 2028typedef struct elf32_elf_section_map 2029{ 2030 bfd_vma vma; 2031 char type; 2032} 2033elf32_arm_section_map; 2034 2035/* Information about a VFP11 erratum veneer, or a branch to such a veneer. */ 2036 2037typedef enum 2038{ 2039 VFP11_ERRATUM_BRANCH_TO_ARM_VENEER, 2040 VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER, 2041 VFP11_ERRATUM_ARM_VENEER, 2042 VFP11_ERRATUM_THUMB_VENEER 2043} 2044elf32_vfp11_erratum_type; 2045 2046typedef struct elf32_vfp11_erratum_list 2047{ 2048 struct elf32_vfp11_erratum_list *next; 2049 bfd_vma vma; 2050 union 2051 { 2052 struct 2053 { 2054 struct elf32_vfp11_erratum_list *veneer; 2055 unsigned int vfp_insn; 2056 } b; 2057 struct 2058 { 2059 struct elf32_vfp11_erratum_list *branch; 2060 unsigned int id; 2061 } v; 2062 } u; 2063 elf32_vfp11_erratum_type type; 2064} 2065elf32_vfp11_erratum_list; 2066 2067typedef struct _arm_elf_section_data 2068{ 2069 struct bfd_elf_section_data elf; 2070 unsigned int mapcount; 2071 unsigned int mapsize; 2072 elf32_arm_section_map *map; 2073 unsigned int erratumcount; 2074 elf32_vfp11_erratum_list *erratumlist; 2075} 2076_arm_elf_section_data; 2077 2078#define elf32_arm_section_data(sec) \ 2079 ((_arm_elf_section_data *) elf_section_data (sec)) 2080 2081/* The size of the thread control block. */ 2082#define TCB_SIZE 8 2083 2084struct elf32_arm_obj_tdata 2085{ 2086 struct elf_obj_tdata root; 2087 2088 /* tls_type for each local got entry. */ 2089 char *local_got_tls_type; 2090 2091 /* Zero to warn when linking objects with incompatible enum sizes. */ 2092 int no_enum_size_warning; 2093}; 2094 2095#define elf32_arm_tdata(abfd) \ 2096 ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any) 2097 2098#define elf32_arm_local_got_tls_type(abfd) \ 2099 (elf32_arm_tdata (abfd)->local_got_tls_type) 2100 2101static bfd_boolean 2102elf32_arm_mkobject (bfd *abfd) 2103{ 2104 if (abfd->tdata.any == NULL) 2105 { 2106 bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata); 2107 abfd->tdata.any = bfd_zalloc (abfd, amt); 2108 if (abfd->tdata.any == NULL) 2109 return FALSE; 2110 } 2111 return bfd_elf_mkobject (abfd); 2112} 2113 2114/* The ARM linker needs to keep track of the number of relocs that it 2115 decides to copy in check_relocs for each symbol. This is so that 2116 it can discard PC relative relocs if it doesn't need them when 2117 linking with -Bsymbolic. We store the information in a field 2118 extending the regular ELF linker hash table. */ 2119 2120/* This structure keeps track of the number of relocs we have copied 2121 for a given symbol. */ 2122struct elf32_arm_relocs_copied 2123 { 2124 /* Next section. */ 2125 struct elf32_arm_relocs_copied * next; 2126 /* A section in dynobj. */ 2127 asection * section; 2128 /* Number of relocs copied in this section. */ 2129 bfd_size_type count; 2130 /* Number of PC-relative relocs copied in this section. */ 2131 bfd_size_type pc_count; 2132 }; 2133 2134#define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent)) 2135 2136/* Arm ELF linker hash entry. */ 2137struct elf32_arm_link_hash_entry 2138 { 2139 struct elf_link_hash_entry root; 2140 2141 /* Number of PC relative relocs copied for this symbol. */ 2142 struct elf32_arm_relocs_copied * relocs_copied; 2143 2144 /* We reference count Thumb references to a PLT entry separately, 2145 so that we can emit the Thumb trampoline only if needed. */ 2146 bfd_signed_vma plt_thumb_refcount; 2147 2148 /* Since PLT entries have variable size if the Thumb prologue is 2149 used, we need to record the index into .got.plt instead of 2150 recomputing it from the PLT offset. */ 2151 bfd_signed_vma plt_got_offset; 2152 2153#define GOT_UNKNOWN 0 2154#define GOT_NORMAL 1 2155#define GOT_TLS_GD 2 2156#define GOT_TLS_IE 4 2157 unsigned char tls_type; 2158 2159 /* The symbol marking the real symbol location for exported thumb 2160 symbols with Arm stubs. */ 2161 struct elf_link_hash_entry *export_glue; 2162 }; 2163 2164/* Traverse an arm ELF linker hash table. */ 2165#define elf32_arm_link_hash_traverse(table, func, info) \ 2166 (elf_link_hash_traverse \ 2167 (&(table)->root, \ 2168 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ 2169 (info))) 2170 2171/* Get the ARM elf linker hash table from a link_info structure. */ 2172#define elf32_arm_hash_table(info) \ 2173 ((struct elf32_arm_link_hash_table *) ((info)->hash)) 2174 2175/* ARM ELF linker hash table. */ 2176struct elf32_arm_link_hash_table 2177 { 2178 /* The main hash table. */ 2179 struct elf_link_hash_table root; 2180 2181 /* The size in bytes of the section containing the Thumb-to-ARM glue. */ 2182 bfd_size_type thumb_glue_size; 2183 2184 /* The size in bytes of the section containing the ARM-to-Thumb glue. */ 2185 bfd_size_type arm_glue_size; 2186 2187 /* The size in bytes of the section containing glue for VFP11 erratum 2188 veneers. */ 2189 bfd_size_type vfp11_erratum_glue_size; 2190 2191 /* An arbitrary input BFD chosen to hold the glue sections. */ 2192 bfd * bfd_of_glue_owner; 2193 2194 /* Nonzero to output a BE8 image. */ 2195 int byteswap_code; 2196 2197 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32. 2198 Nonzero if R_ARM_TARGET1 means R_ARM_REL32. */ 2199 int target1_is_rel; 2200 2201 /* The relocation to use for R_ARM_TARGET2 relocations. */ 2202 int target2_reloc; 2203 2204 /* Nonzero to fix BX instructions for ARMv4 targets. */ 2205 int fix_v4bx; 2206 2207 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */ 2208 int use_blx; 2209 2210 /* What sort of code sequences we should look for which may trigger the 2211 VFP11 denorm erratum. */ 2212 bfd_arm_vfp11_fix vfp11_fix; 2213 2214 /* Global counter for the number of fixes we have emitted. */ 2215 int num_vfp11_fixes; 2216 2217 /* Nonzero to force PIC branch veneers. */ 2218 int pic_veneer; 2219 2220 /* The number of bytes in the initial entry in the PLT. */ 2221 bfd_size_type plt_header_size; 2222 2223 /* The number of bytes in the subsequent PLT etries. */ 2224 bfd_size_type plt_entry_size; 2225 2226 /* True if the target system is VxWorks. */ 2227 int vxworks_p; 2228 2229 /* True if the target system is Symbian OS. */ 2230 int symbian_p; 2231 2232 /* True if the target uses REL relocations. */ 2233 int use_rel; 2234 2235 /* Short-cuts to get to dynamic linker sections. */ 2236 asection *sgot; 2237 asection *sgotplt; 2238 asection *srelgot; 2239 asection *splt; 2240 asection *srelplt; 2241 asection *sdynbss; 2242 asection *srelbss; 2243 2244 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */ 2245 asection *srelplt2; 2246 2247 /* Data for R_ARM_TLS_LDM32 relocations. */ 2248 union { 2249 bfd_signed_vma refcount; 2250 bfd_vma offset; 2251 } tls_ldm_got; 2252 2253 /* Small local sym to section mapping cache. */ 2254 struct sym_sec_cache sym_sec; 2255 2256 /* For convenience in allocate_dynrelocs. */ 2257 bfd * obfd; 2258 }; 2259 2260/* Create an entry in an ARM ELF linker hash table. */ 2261 2262static struct bfd_hash_entry * 2263elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry, 2264 struct bfd_hash_table * table, 2265 const char * string) 2266{ 2267 struct elf32_arm_link_hash_entry * ret = 2268 (struct elf32_arm_link_hash_entry *) entry; 2269 2270 /* Allocate the structure if it has not already been allocated by a 2271 subclass. */ 2272 if (ret == (struct elf32_arm_link_hash_entry *) NULL) 2273 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry)); 2274 if (ret == NULL) 2275 return (struct bfd_hash_entry *) ret; 2276 2277 /* Call the allocation method of the superclass. */ 2278 ret = ((struct elf32_arm_link_hash_entry *) 2279 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 2280 table, string)); 2281 if (ret != NULL) 2282 { 2283 ret->relocs_copied = NULL; 2284 ret->tls_type = GOT_UNKNOWN; 2285 ret->plt_thumb_refcount = 0; 2286 ret->plt_got_offset = -1; 2287 ret->export_glue = NULL; 2288 } 2289 2290 return (struct bfd_hash_entry *) ret; 2291} 2292 2293/* Return true if NAME is the name of the relocation section associated 2294 with S. */ 2295 2296static bfd_boolean 2297reloc_section_p (struct elf32_arm_link_hash_table *htab, 2298 const char *name, asection *s) 2299{ 2300 if (htab->use_rel) 2301 return CONST_STRNEQ (name, ".rel") && strcmp (s->name, name + 4) == 0; 2302 else 2303 return CONST_STRNEQ (name, ".rela") && strcmp (s->name, name + 5) == 0; 2304} 2305 2306/* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up 2307 shortcuts to them in our hash table. */ 2308 2309static bfd_boolean 2310create_got_section (bfd *dynobj, struct bfd_link_info *info) 2311{ 2312 struct elf32_arm_link_hash_table *htab; 2313 2314 htab = elf32_arm_hash_table (info); 2315 /* BPABI objects never have a GOT, or associated sections. */ 2316 if (htab->symbian_p) 2317 return TRUE; 2318 2319 if (! _bfd_elf_create_got_section (dynobj, info)) 2320 return FALSE; 2321 2322 htab->sgot = bfd_get_section_by_name (dynobj, ".got"); 2323 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt"); 2324 if (!htab->sgot || !htab->sgotplt) 2325 abort (); 2326 2327 htab->srelgot = bfd_make_section_with_flags (dynobj, 2328 RELOC_SECTION (htab, ".got"), 2329 (SEC_ALLOC | SEC_LOAD 2330 | SEC_HAS_CONTENTS 2331 | SEC_IN_MEMORY 2332 | SEC_LINKER_CREATED 2333 | SEC_READONLY)); 2334 if (htab->srelgot == NULL 2335 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2)) 2336 return FALSE; 2337 return TRUE; 2338} 2339 2340/* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and 2341 .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our 2342 hash table. */ 2343 2344static bfd_boolean 2345elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info) 2346{ 2347 struct elf32_arm_link_hash_table *htab; 2348 2349 htab = elf32_arm_hash_table (info); 2350 if (!htab->sgot && !create_got_section (dynobj, info)) 2351 return FALSE; 2352 2353 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 2354 return FALSE; 2355 2356 htab->splt = bfd_get_section_by_name (dynobj, ".plt"); 2357 htab->srelplt = bfd_get_section_by_name (dynobj, 2358 RELOC_SECTION (htab, ".plt")); 2359 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss"); 2360 if (!info->shared) 2361 htab->srelbss = bfd_get_section_by_name (dynobj, 2362 RELOC_SECTION (htab, ".bss")); 2363 2364 if (htab->vxworks_p) 2365 { 2366 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2)) 2367 return FALSE; 2368 2369 if (info->shared) 2370 { 2371 htab->plt_header_size = 0; 2372 htab->plt_entry_size 2373 = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry); 2374 } 2375 else 2376 { 2377 htab->plt_header_size 2378 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry); 2379 htab->plt_entry_size 2380 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry); 2381 } 2382 } 2383 2384 if (!htab->splt 2385 || !htab->srelplt 2386 || !htab->sdynbss 2387 || (!info->shared && !htab->srelbss)) 2388 abort (); 2389 2390 return TRUE; 2391} 2392 2393/* Copy the extra info we tack onto an elf_link_hash_entry. */ 2394 2395static void 2396elf32_arm_copy_indirect_symbol (struct bfd_link_info *info, 2397 struct elf_link_hash_entry *dir, 2398 struct elf_link_hash_entry *ind) 2399{ 2400 struct elf32_arm_link_hash_entry *edir, *eind; 2401 2402 edir = (struct elf32_arm_link_hash_entry *) dir; 2403 eind = (struct elf32_arm_link_hash_entry *) ind; 2404 2405 if (eind->relocs_copied != NULL) 2406 { 2407 if (edir->relocs_copied != NULL) 2408 { 2409 struct elf32_arm_relocs_copied **pp; 2410 struct elf32_arm_relocs_copied *p; 2411 2412 /* Add reloc counts against the indirect sym to the direct sym 2413 list. Merge any entries against the same section. */ 2414 for (pp = &eind->relocs_copied; (p = *pp) != NULL; ) 2415 { 2416 struct elf32_arm_relocs_copied *q; 2417 2418 for (q = edir->relocs_copied; q != NULL; q = q->next) 2419 if (q->section == p->section) 2420 { 2421 q->pc_count += p->pc_count; 2422 q->count += p->count; 2423 *pp = p->next; 2424 break; 2425 } 2426 if (q == NULL) 2427 pp = &p->next; 2428 } 2429 *pp = edir->relocs_copied; 2430 } 2431 2432 edir->relocs_copied = eind->relocs_copied; 2433 eind->relocs_copied = NULL; 2434 } 2435 2436 if (ind->root.type == bfd_link_hash_indirect) 2437 { 2438 /* Copy over PLT info. */ 2439 edir->plt_thumb_refcount += eind->plt_thumb_refcount; 2440 eind->plt_thumb_refcount = 0; 2441 2442 if (dir->got.refcount <= 0) 2443 { 2444 edir->tls_type = eind->tls_type; 2445 eind->tls_type = GOT_UNKNOWN; 2446 } 2447 } 2448 2449 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 2450} 2451 2452/* Create an ARM elf linker hash table. */ 2453 2454static struct bfd_link_hash_table * 2455elf32_arm_link_hash_table_create (bfd *abfd) 2456{ 2457 struct elf32_arm_link_hash_table *ret; 2458 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table); 2459 2460 ret = bfd_malloc (amt); 2461 if (ret == NULL) 2462 return NULL; 2463 2464 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd, 2465 elf32_arm_link_hash_newfunc, 2466 sizeof (struct elf32_arm_link_hash_entry))) 2467 { 2468 free (ret); 2469 return NULL; 2470 } 2471 2472 ret->sgot = NULL; 2473 ret->sgotplt = NULL; 2474 ret->srelgot = NULL; 2475 ret->splt = NULL; 2476 ret->srelplt = NULL; 2477 ret->sdynbss = NULL; 2478 ret->srelbss = NULL; 2479 ret->srelplt2 = NULL; 2480 ret->thumb_glue_size = 0; 2481 ret->arm_glue_size = 0; 2482 ret->vfp11_fix = BFD_ARM_VFP11_FIX_NONE; 2483 ret->vfp11_erratum_glue_size = 0; 2484 ret->num_vfp11_fixes = 0; 2485 ret->bfd_of_glue_owner = NULL; 2486 ret->byteswap_code = 0; 2487 ret->target1_is_rel = 0; 2488 ret->target2_reloc = R_ARM_NONE; 2489#ifdef FOUR_WORD_PLT 2490 ret->plt_header_size = 16; 2491 ret->plt_entry_size = 16; 2492#else 2493 ret->plt_header_size = 20; 2494 ret->plt_entry_size = 12; 2495#endif 2496 ret->fix_v4bx = 0; 2497 ret->use_blx = 0; 2498 ret->vxworks_p = 0; 2499 ret->symbian_p = 0; 2500 ret->use_rel = 1; 2501 ret->sym_sec.abfd = NULL; 2502 ret->obfd = abfd; 2503 ret->tls_ldm_got.refcount = 0; 2504 2505 return &ret->root.root; 2506} 2507 2508/* Locate the Thumb encoded calling stub for NAME. */ 2509 2510static struct elf_link_hash_entry * 2511find_thumb_glue (struct bfd_link_info *link_info, 2512 const char *name, 2513 char **error_message) 2514{ 2515 char *tmp_name; 2516 struct elf_link_hash_entry *hash; 2517 struct elf32_arm_link_hash_table *hash_table; 2518 2519 /* We need a pointer to the armelf specific hash table. */ 2520 hash_table = elf32_arm_hash_table (link_info); 2521 2522 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) 2523 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1); 2524 2525 BFD_ASSERT (tmp_name); 2526 2527 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name); 2528 2529 hash = elf_link_hash_lookup 2530 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE); 2531 2532 if (hash == NULL) 2533 asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"), 2534 tmp_name, name); 2535 2536 free (tmp_name); 2537 2538 return hash; 2539} 2540 2541/* Locate the ARM encoded calling stub for NAME. */ 2542 2543static struct elf_link_hash_entry * 2544find_arm_glue (struct bfd_link_info *link_info, 2545 const char *name, 2546 char **error_message) 2547{ 2548 char *tmp_name; 2549 struct elf_link_hash_entry *myh; 2550 struct elf32_arm_link_hash_table *hash_table; 2551 2552 /* We need a pointer to the elfarm specific hash table. */ 2553 hash_table = elf32_arm_hash_table (link_info); 2554 2555 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) 2556 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1); 2557 2558 BFD_ASSERT (tmp_name); 2559 2560 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name); 2561 2562 myh = elf_link_hash_lookup 2563 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE); 2564 2565 if (myh == NULL) 2566 asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"), 2567 tmp_name, name); 2568 2569 free (tmp_name); 2570 2571 return myh; 2572} 2573 2574/* ARM->Thumb glue (static images): 2575 2576 .arm 2577 __func_from_arm: 2578 ldr r12, __func_addr 2579 bx r12 2580 __func_addr: 2581 .word func @ behave as if you saw a ARM_32 reloc. 2582 2583 (v5t static images) 2584 .arm 2585 __func_from_arm: 2586 ldr pc, __func_addr 2587 __func_addr: 2588 .word func @ behave as if you saw a ARM_32 reloc. 2589 2590 (relocatable images) 2591 .arm 2592 __func_from_arm: 2593 ldr r12, __func_offset 2594 add r12, r12, pc 2595 bx r12 2596 __func_offset: 2597 .word func - . 2598 */ 2599 2600#define ARM2THUMB_STATIC_GLUE_SIZE 12 2601static const insn32 a2t1_ldr_insn = 0xe59fc000; 2602static const insn32 a2t2_bx_r12_insn = 0xe12fff1c; 2603static const insn32 a2t3_func_addr_insn = 0x00000001; 2604 2605#define ARM2THUMB_V5_STATIC_GLUE_SIZE 8 2606static const insn32 a2t1v5_ldr_insn = 0xe51ff004; 2607static const insn32 a2t2v5_func_addr_insn = 0x00000001; 2608 2609#define ARM2THUMB_PIC_GLUE_SIZE 16 2610static const insn32 a2t1p_ldr_insn = 0xe59fc004; 2611static const insn32 a2t2p_add_pc_insn = 0xe08cc00f; 2612static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c; 2613 2614/* Thumb->ARM: Thumb->(non-interworking aware) ARM 2615 2616 .thumb .thumb 2617 .align 2 .align 2 2618 __func_from_thumb: __func_from_thumb: 2619 bx pc push {r6, lr} 2620 nop ldr r6, __func_addr 2621 .arm mov lr, pc 2622 __func_change_to_arm: bx r6 2623 b func .arm 2624 __func_back_to_thumb: 2625 ldmia r13! {r6, lr} 2626 bx lr 2627 __func_addr: 2628 .word func */ 2629 2630#define THUMB2ARM_GLUE_SIZE 8 2631static const insn16 t2a1_bx_pc_insn = 0x4778; 2632static const insn16 t2a2_noop_insn = 0x46c0; 2633static const insn32 t2a3_b_insn = 0xea000000; 2634 2635#define VFP11_ERRATUM_VENEER_SIZE 8 2636 2637#ifndef ELFARM_NABI_C_INCLUDED 2638bfd_boolean 2639bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info) 2640{ 2641 asection * s; 2642 bfd_byte * foo; 2643 struct elf32_arm_link_hash_table * globals; 2644 2645 globals = elf32_arm_hash_table (info); 2646 2647 BFD_ASSERT (globals != NULL); 2648 2649 if (globals->arm_glue_size != 0) 2650 { 2651 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 2652 2653 s = bfd_get_section_by_name (globals->bfd_of_glue_owner, 2654 ARM2THUMB_GLUE_SECTION_NAME); 2655 2656 BFD_ASSERT (s != NULL); 2657 2658 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size); 2659 2660 BFD_ASSERT (s->size == globals->arm_glue_size); 2661 s->contents = foo; 2662 } 2663 2664 if (globals->thumb_glue_size != 0) 2665 { 2666 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 2667 2668 s = bfd_get_section_by_name 2669 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME); 2670 2671 BFD_ASSERT (s != NULL); 2672 2673 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size); 2674 2675 BFD_ASSERT (s->size == globals->thumb_glue_size); 2676 s->contents = foo; 2677 } 2678 2679 if (globals->vfp11_erratum_glue_size != 0) 2680 { 2681 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 2682 2683 s = bfd_get_section_by_name 2684 (globals->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME); 2685 2686 BFD_ASSERT (s != NULL); 2687 2688 foo = bfd_alloc (globals->bfd_of_glue_owner, 2689 globals->vfp11_erratum_glue_size); 2690 2691 BFD_ASSERT (s->size == globals->vfp11_erratum_glue_size); 2692 s->contents = foo; 2693 } 2694 2695 return TRUE; 2696} 2697 2698/* Allocate space and symbols for calling a Thumb function from Arm mode. 2699 returns the symbol identifying teh stub. */ 2700static struct elf_link_hash_entry * 2701record_arm_to_thumb_glue (struct bfd_link_info * link_info, 2702 struct elf_link_hash_entry * h) 2703{ 2704 const char * name = h->root.root.string; 2705 asection * s; 2706 char * tmp_name; 2707 struct elf_link_hash_entry * myh; 2708 struct bfd_link_hash_entry * bh; 2709 struct elf32_arm_link_hash_table * globals; 2710 bfd_vma val; 2711 bfd_size_type size; 2712 2713 globals = elf32_arm_hash_table (link_info); 2714 2715 BFD_ASSERT (globals != NULL); 2716 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 2717 2718 s = bfd_get_section_by_name 2719 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME); 2720 2721 BFD_ASSERT (s != NULL); 2722 2723 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1); 2724 2725 BFD_ASSERT (tmp_name); 2726 2727 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name); 2728 2729 myh = elf_link_hash_lookup 2730 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE); 2731 2732 if (myh != NULL) 2733 { 2734 /* We've already seen this guy. */ 2735 free (tmp_name); 2736 return myh; 2737 } 2738 2739 /* The only trick here is using hash_table->arm_glue_size as the value. 2740 Even though the section isn't allocated yet, this is where we will be 2741 putting it. */ 2742 bh = NULL; 2743 val = globals->arm_glue_size + 1; 2744 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner, 2745 tmp_name, BSF_GLOBAL, s, val, 2746 NULL, TRUE, FALSE, &bh); 2747 2748 myh = (struct elf_link_hash_entry *) bh; 2749 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC); 2750 myh->forced_local = 1; 2751 2752 free (tmp_name); 2753 2754 if (link_info->shared || globals->root.is_relocatable_executable 2755 || globals->pic_veneer) 2756 size = ARM2THUMB_PIC_GLUE_SIZE; 2757 else if (globals->use_blx) 2758 size = ARM2THUMB_V5_STATIC_GLUE_SIZE; 2759 else 2760 size = ARM2THUMB_STATIC_GLUE_SIZE; 2761 2762 s->size += size; 2763 globals->arm_glue_size += size; 2764 2765 return myh; 2766} 2767 2768static void 2769record_thumb_to_arm_glue (struct bfd_link_info *link_info, 2770 struct elf_link_hash_entry *h) 2771{ 2772 const char *name = h->root.root.string; 2773 asection *s; 2774 char *tmp_name; 2775 struct elf_link_hash_entry *myh; 2776 struct bfd_link_hash_entry *bh; 2777 struct elf32_arm_link_hash_table *hash_table; 2778 bfd_vma val; 2779 2780 hash_table = elf32_arm_hash_table (link_info); 2781 2782 BFD_ASSERT (hash_table != NULL); 2783 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL); 2784 2785 s = bfd_get_section_by_name 2786 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME); 2787 2788 BFD_ASSERT (s != NULL); 2789 2790 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) 2791 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1); 2792 2793 BFD_ASSERT (tmp_name); 2794 2795 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name); 2796 2797 myh = elf_link_hash_lookup 2798 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE); 2799 2800 if (myh != NULL) 2801 { 2802 /* We've already seen this guy. */ 2803 free (tmp_name); 2804 return; 2805 } 2806 2807 bh = NULL; 2808 val = hash_table->thumb_glue_size + 1; 2809 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, 2810 tmp_name, BSF_GLOBAL, s, val, 2811 NULL, TRUE, FALSE, &bh); 2812 2813 /* If we mark it 'Thumb', the disassembler will do a better job. */ 2814 myh = (struct elf_link_hash_entry *) bh; 2815 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC); 2816 myh->forced_local = 1; 2817 2818 free (tmp_name); 2819 2820#define CHANGE_TO_ARM "__%s_change_to_arm" 2821#define BACK_FROM_ARM "__%s_back_from_arm" 2822 2823 /* Allocate another symbol to mark where we switch to Arm mode. */ 2824 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) 2825 + strlen (CHANGE_TO_ARM) + 1); 2826 2827 BFD_ASSERT (tmp_name); 2828 2829 sprintf (tmp_name, CHANGE_TO_ARM, name); 2830 2831 bh = NULL; 2832 val = hash_table->thumb_glue_size + 4, 2833 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, 2834 tmp_name, BSF_LOCAL, s, val, 2835 NULL, TRUE, FALSE, &bh); 2836 2837 free (tmp_name); 2838 2839 s->size += THUMB2ARM_GLUE_SIZE; 2840 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE; 2841 2842 return; 2843} 2844 2845 2846/* Add an entry to the code/data map for section SEC. */ 2847 2848static void 2849elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma) 2850{ 2851 struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec); 2852 unsigned int newidx; 2853 2854 if (sec_data->map == NULL) 2855 { 2856 sec_data->map = bfd_malloc (sizeof (elf32_arm_section_map)); 2857 sec_data->mapcount = 0; 2858 sec_data->mapsize = 1; 2859 } 2860 2861 newidx = sec_data->mapcount++; 2862 2863 if (sec_data->mapcount > sec_data->mapsize) 2864 { 2865 sec_data->mapsize *= 2; 2866 sec_data->map = bfd_realloc (sec_data->map, sec_data->mapsize 2867 * sizeof (elf32_arm_section_map)); 2868 } 2869 2870 sec_data->map[newidx].vma = vma; 2871 sec_data->map[newidx].type = type; 2872} 2873 2874 2875/* Record information about a VFP11 denorm-erratum veneer. Only ARM-mode 2876 veneers are handled for now. */ 2877 2878static bfd_vma 2879record_vfp11_erratum_veneer (struct bfd_link_info *link_info, 2880 elf32_vfp11_erratum_list *branch, 2881 bfd *branch_bfd, 2882 asection *branch_sec, 2883 unsigned int offset) 2884{ 2885 asection *s; 2886 struct elf32_arm_link_hash_table *hash_table; 2887 char *tmp_name; 2888 struct elf_link_hash_entry *myh; 2889 struct bfd_link_hash_entry *bh; 2890 bfd_vma val; 2891 struct _arm_elf_section_data *sec_data; 2892 int errcount; 2893 elf32_vfp11_erratum_list *newerr; 2894 2895 hash_table = elf32_arm_hash_table (link_info); 2896 2897 BFD_ASSERT (hash_table != NULL); 2898 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL); 2899 2900 s = bfd_get_section_by_name 2901 (hash_table->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME); 2902 2903 sec_data = elf32_arm_section_data (s); 2904 2905 BFD_ASSERT (s != NULL); 2906 2907 tmp_name = bfd_malloc ((bfd_size_type) strlen 2908 (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10); 2909 2910 BFD_ASSERT (tmp_name); 2911 2912 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME, 2913 hash_table->num_vfp11_fixes); 2914 2915 myh = elf_link_hash_lookup 2916 (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE); 2917 2918 BFD_ASSERT (myh == NULL); 2919 2920 bh = NULL; 2921 val = hash_table->vfp11_erratum_glue_size; 2922 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, 2923 tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val, 2924 NULL, TRUE, FALSE, &bh); 2925 2926 myh = (struct elf_link_hash_entry *) bh; 2927 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC); 2928 myh->forced_local = 1; 2929 2930 /* Link veneer back to calling location. */ 2931 errcount = ++(sec_data->erratumcount); 2932 newerr = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list)); 2933 2934 newerr->type = VFP11_ERRATUM_ARM_VENEER; 2935 newerr->vma = -1; 2936 newerr->u.v.branch = branch; 2937 newerr->u.v.id = hash_table->num_vfp11_fixes; 2938 branch->u.b.veneer = newerr; 2939 2940 newerr->next = sec_data->erratumlist; 2941 sec_data->erratumlist = newerr; 2942 2943 /* A symbol for the return from the veneer. */ 2944 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r", 2945 hash_table->num_vfp11_fixes); 2946 2947 myh = elf_link_hash_lookup 2948 (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE); 2949 2950 if (myh != NULL) 2951 abort (); 2952 2953 bh = NULL; 2954 val = offset + 4; 2955 _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL, 2956 branch_sec, val, NULL, TRUE, FALSE, &bh); 2957 2958 myh = (struct elf_link_hash_entry *) bh; 2959 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC); 2960 myh->forced_local = 1; 2961 2962 free (tmp_name); 2963 2964 /* Generate a mapping symbol for the veneer section, and explicitly add an 2965 entry for that symbol to the code/data map for the section. */ 2966 if (hash_table->vfp11_erratum_glue_size == 0) 2967 { 2968 bh = NULL; 2969 /* FIXME: Creates an ARM symbol. Thumb mode will need attention if it 2970 ever requires this erratum fix. */ 2971 _bfd_generic_link_add_one_symbol (link_info, 2972 hash_table->bfd_of_glue_owner, "$a", 2973 BSF_LOCAL, s, 0, NULL, 2974 TRUE, FALSE, &bh); 2975 2976 myh = (struct elf_link_hash_entry *) bh; 2977 myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE); 2978 myh->forced_local = 1; 2979 2980 /* The elf32_arm_init_maps function only cares about symbols from input 2981 BFDs. We must make a note of this generated mapping symbol 2982 ourselves so that code byteswapping works properly in 2983 elf32_arm_write_section. */ 2984 elf32_arm_section_map_add (s, 'a', 0); 2985 } 2986 2987 s->size += VFP11_ERRATUM_VENEER_SIZE; 2988 hash_table->vfp11_erratum_glue_size += VFP11_ERRATUM_VENEER_SIZE; 2989 hash_table->num_vfp11_fixes++; 2990 2991 /* The offset of the veneer. */ 2992 return val; 2993} 2994 2995/* Add the glue sections to ABFD. This function is called from the 2996 linker scripts in ld/emultempl/{armelf}.em. */ 2997 2998bfd_boolean 2999bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd, 3000 struct bfd_link_info *info) 3001{ 3002 flagword flags; 3003 asection *sec; 3004 3005 /* If we are only performing a partial 3006 link do not bother adding the glue. */ 3007 if (info->relocatable) 3008 return TRUE; 3009 3010 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME); 3011 3012 if (sec == NULL) 3013 { 3014 /* Note: we do not include the flag SEC_LINKER_CREATED, as this 3015 will prevent elf_link_input_bfd() from processing the contents 3016 of this section. */ 3017 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 3018 | SEC_CODE | SEC_READONLY); 3019 3020 sec = bfd_make_section_with_flags (abfd, 3021 ARM2THUMB_GLUE_SECTION_NAME, 3022 flags); 3023 3024 if (sec == NULL 3025 || !bfd_set_section_alignment (abfd, sec, 2)) 3026 return FALSE; 3027 3028 /* Set the gc mark to prevent the section from being removed by garbage 3029 collection, despite the fact that no relocs refer to this section. */ 3030 sec->gc_mark = 1; 3031 } 3032 3033 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME); 3034 3035 if (sec == NULL) 3036 { 3037 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 3038 | SEC_CODE | SEC_READONLY); 3039 3040 sec = bfd_make_section_with_flags (abfd, 3041 THUMB2ARM_GLUE_SECTION_NAME, 3042 flags); 3043 3044 if (sec == NULL 3045 || !bfd_set_section_alignment (abfd, sec, 2)) 3046 return FALSE; 3047 3048 sec->gc_mark = 1; 3049 } 3050 3051 sec = bfd_get_section_by_name (abfd, VFP11_ERRATUM_VENEER_SECTION_NAME); 3052 3053 if (sec == NULL) 3054 { 3055 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 3056 | SEC_CODE | SEC_READONLY); 3057 3058 sec = bfd_make_section_with_flags (abfd, 3059 VFP11_ERRATUM_VENEER_SECTION_NAME, 3060 flags); 3061 3062 if (sec == NULL 3063 || !bfd_set_section_alignment (abfd, sec, 2)) 3064 return FALSE; 3065 3066 sec->gc_mark = 1; 3067 } 3068 3069 return TRUE; 3070} 3071 3072/* Select a BFD to be used to hold the sections used by the glue code. 3073 This function is called from the linker scripts in ld/emultempl/ 3074 {armelf/pe}.em */ 3075 3076bfd_boolean 3077bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info) 3078{ 3079 struct elf32_arm_link_hash_table *globals; 3080 3081 /* If we are only performing a partial link 3082 do not bother getting a bfd to hold the glue. */ 3083 if (info->relocatable) 3084 return TRUE; 3085 3086 /* Make sure we don't attach the glue sections to a dynamic object. */ 3087 BFD_ASSERT (!(abfd->flags & DYNAMIC)); 3088 3089 globals = elf32_arm_hash_table (info); 3090 3091 BFD_ASSERT (globals != NULL); 3092 3093 if (globals->bfd_of_glue_owner != NULL) 3094 return TRUE; 3095 3096 /* Save the bfd for later use. */ 3097 globals->bfd_of_glue_owner = abfd; 3098 3099 return TRUE; 3100} 3101 3102static void check_use_blx(struct elf32_arm_link_hash_table *globals) 3103{ 3104 if (bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC, 3105 Tag_CPU_arch) > 2) 3106 globals->use_blx = 1; 3107} 3108 3109bfd_boolean 3110bfd_elf32_arm_process_before_allocation (bfd *abfd, 3111 struct bfd_link_info *link_info) 3112{ 3113 Elf_Internal_Shdr *symtab_hdr; 3114 Elf_Internal_Rela *internal_relocs = NULL; 3115 Elf_Internal_Rela *irel, *irelend; 3116 bfd_byte *contents = NULL; 3117 3118 asection *sec; 3119 struct elf32_arm_link_hash_table *globals; 3120 3121 /* If we are only performing a partial link do not bother 3122 to construct any glue. */ 3123 if (link_info->relocatable) 3124 return TRUE; 3125 3126 /* Here we have a bfd that is to be included on the link. We have a hook 3127 to do reloc rummaging, before section sizes are nailed down. */ 3128 globals = elf32_arm_hash_table (link_info); 3129 check_use_blx (globals); 3130 3131 BFD_ASSERT (globals != NULL); 3132 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 3133 3134 if (globals->byteswap_code && !bfd_big_endian (abfd)) 3135 { 3136 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."), 3137 abfd); 3138 return FALSE; 3139 } 3140 3141 /* Rummage around all the relocs and map the glue vectors. */ 3142 sec = abfd->sections; 3143 3144 if (sec == NULL) 3145 return TRUE; 3146 3147 for (; sec != NULL; sec = sec->next) 3148 { 3149 if (sec->reloc_count == 0) 3150 continue; 3151 3152 if ((sec->flags & SEC_EXCLUDE) != 0) 3153 continue; 3154 3155 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3156 3157 /* Load the relocs. */ 3158 internal_relocs 3159 = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL, 3160 (Elf_Internal_Rela *) NULL, FALSE); 3161 3162 if (internal_relocs == NULL) 3163 goto error_return; 3164 3165 irelend = internal_relocs + sec->reloc_count; 3166 for (irel = internal_relocs; irel < irelend; irel++) 3167 { 3168 long r_type; 3169 unsigned long r_index; 3170 3171 struct elf_link_hash_entry *h; 3172 3173 r_type = ELF32_R_TYPE (irel->r_info); 3174 r_index = ELF32_R_SYM (irel->r_info); 3175 3176 /* These are the only relocation types we care about. */ 3177 if ( r_type != R_ARM_PC24 3178 && r_type != R_ARM_PLT32 3179 && r_type != R_ARM_CALL 3180 && r_type != R_ARM_JUMP24 3181 && r_type != R_ARM_THM_CALL) 3182 continue; 3183 3184 /* Get the section contents if we haven't done so already. */ 3185 if (contents == NULL) 3186 { 3187 /* Get cached copy if it exists. */ 3188 if (elf_section_data (sec)->this_hdr.contents != NULL) 3189 contents = elf_section_data (sec)->this_hdr.contents; 3190 else 3191 { 3192 /* Go get them off disk. */ 3193 if (! bfd_malloc_and_get_section (abfd, sec, &contents)) 3194 goto error_return; 3195 } 3196 } 3197 3198 /* If the relocation is not against a symbol it cannot concern us. */ 3199 h = NULL; 3200 3201 /* We don't care about local symbols. */ 3202 if (r_index < symtab_hdr->sh_info) 3203 continue; 3204 3205 /* This is an external symbol. */ 3206 r_index -= symtab_hdr->sh_info; 3207 h = (struct elf_link_hash_entry *) 3208 elf_sym_hashes (abfd)[r_index]; 3209 3210 /* If the relocation is against a static symbol it must be within 3211 the current section and so cannot be a cross ARM/Thumb relocation. */ 3212 if (h == NULL) 3213 continue; 3214 3215 /* If the call will go through a PLT entry then we do not need 3216 glue. */ 3217 if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1) 3218 continue; 3219 3220 switch (r_type) 3221 { 3222 case R_ARM_PC24: 3223 case R_ARM_PLT32: 3224 case R_ARM_CALL: 3225 case R_ARM_JUMP24: 3226 /* This one is a call from arm code. We need to look up 3227 the target of the call. If it is a thumb target, we 3228 insert glue. */ 3229 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC 3230 && !(r_type == R_ARM_CALL && globals->use_blx)) 3231 record_arm_to_thumb_glue (link_info, h); 3232 break; 3233 3234 case R_ARM_THM_CALL: 3235 /* This one is a call from thumb code. We look 3236 up the target of the call. If it is not a thumb 3237 target, we insert glue. */ 3238 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC && !globals->use_blx 3239 && h->root.type != bfd_link_hash_undefweak) 3240 record_thumb_to_arm_glue (link_info, h); 3241 break; 3242 3243 default: 3244 abort (); 3245 } 3246 } 3247 3248 if (contents != NULL 3249 && elf_section_data (sec)->this_hdr.contents != contents) 3250 free (contents); 3251 contents = NULL; 3252 3253 if (internal_relocs != NULL 3254 && elf_section_data (sec)->relocs != internal_relocs) 3255 free (internal_relocs); 3256 internal_relocs = NULL; 3257 } 3258 3259 return TRUE; 3260 3261error_return: 3262 if (contents != NULL 3263 && elf_section_data (sec)->this_hdr.contents != contents) 3264 free (contents); 3265 if (internal_relocs != NULL 3266 && elf_section_data (sec)->relocs != internal_relocs) 3267 free (internal_relocs); 3268 3269 return FALSE; 3270} 3271#endif 3272 3273 3274/* Initialise maps of ARM/Thumb/data for input BFDs. */ 3275 3276void 3277bfd_elf32_arm_init_maps (bfd *abfd) 3278{ 3279 Elf_Internal_Sym *isymbuf; 3280 Elf_Internal_Shdr *hdr; 3281 unsigned int i, localsyms; 3282 3283 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour || elf_tdata (abfd) == NULL) 3284 return; 3285 3286 if ((abfd->flags & DYNAMIC) != 0) 3287 return; 3288 3289 hdr = &elf_tdata (abfd)->symtab_hdr; 3290 localsyms = hdr->sh_info; 3291 3292 /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field 3293 should contain the number of local symbols, which should come before any 3294 global symbols. Mapping symbols are always local. */ 3295 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL, 3296 NULL); 3297 3298 /* No internal symbols read? Skip this BFD. */ 3299 if (isymbuf == NULL) 3300 return; 3301 3302 for (i = 0; i < localsyms; i++) 3303 { 3304 Elf_Internal_Sym *isym = &isymbuf[i]; 3305 asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 3306 const char *name; 3307 3308 if (sec != NULL 3309 && ELF_ST_BIND (isym->st_info) == STB_LOCAL) 3310 { 3311 name = bfd_elf_string_from_elf_section (abfd, 3312 hdr->sh_link, isym->st_name); 3313 3314 if (bfd_is_arm_special_symbol_name (name, 3315 BFD_ARM_SPECIAL_SYM_TYPE_MAP)) 3316 elf32_arm_section_map_add (sec, name[1], isym->st_value); 3317 } 3318 } 3319} 3320 3321 3322void 3323bfd_elf32_arm_set_vfp11_fix (bfd *obfd, struct bfd_link_info *link_info) 3324{ 3325 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info); 3326 obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd); 3327 3328 /* We assume that ARMv7+ does not need the VFP11 denorm erratum fix. */ 3329 if (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V7) 3330 { 3331 switch (globals->vfp11_fix) 3332 { 3333 case BFD_ARM_VFP11_FIX_DEFAULT: 3334 case BFD_ARM_VFP11_FIX_NONE: 3335 globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE; 3336 break; 3337 3338 default: 3339 /* Give a warning, but do as the user requests anyway. */ 3340 (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum " 3341 "workaround is not necessary for target architecture"), obfd); 3342 } 3343 } 3344 else if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_DEFAULT) 3345 /* For earlier architectures, we might need the workaround, but do not 3346 enable it by default. If users is running with broken hardware, they 3347 must enable the erratum fix explicitly. */ 3348 globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE; 3349} 3350 3351 3352enum bfd_arm_vfp11_pipe { 3353 VFP11_FMAC, 3354 VFP11_LS, 3355 VFP11_DS, 3356 VFP11_BAD 3357}; 3358 3359/* Return a VFP register number. This is encoded as RX:X for single-precision 3360 registers, or X:RX for double-precision registers, where RX is the group of 3361 four bits in the instruction encoding and X is the single extension bit. 3362 RX and X fields are specified using their lowest (starting) bit. The return 3363 value is: 3364 3365 0...31: single-precision registers s0...s31 3366 32...63: double-precision registers d0...d31. 3367 3368 Although X should be zero for VFP11 (encoding d0...d15 only), we might 3369 encounter VFP3 instructions, so we allow the full range for DP registers. */ 3370 3371static unsigned int 3372bfd_arm_vfp11_regno (unsigned int insn, bfd_boolean is_double, unsigned int rx, 3373 unsigned int x) 3374{ 3375 if (is_double) 3376 return (((insn >> rx) & 0xf) | (((insn >> x) & 1) << 4)) + 32; 3377 else 3378 return (((insn >> rx) & 0xf) << 1) | ((insn >> x) & 1); 3379} 3380 3381/* Set bits in *WMASK according to a register number REG as encoded by 3382 bfd_arm_vfp11_regno(). Ignore d16-d31. */ 3383 3384static void 3385bfd_arm_vfp11_write_mask (unsigned int *wmask, unsigned int reg) 3386{ 3387 if (reg < 32) 3388 *wmask |= 1 << reg; 3389 else if (reg < 48) 3390 *wmask |= 3 << ((reg - 32) * 2); 3391} 3392 3393/* Return TRUE if WMASK overwrites anything in REGS. */ 3394 3395static bfd_boolean 3396bfd_arm_vfp11_antidependency (unsigned int wmask, int *regs, int numregs) 3397{ 3398 int i; 3399 3400 for (i = 0; i < numregs; i++) 3401 { 3402 unsigned int reg = regs[i]; 3403 3404 if (reg < 32 && (wmask & (1 << reg)) != 0) 3405 return TRUE; 3406 3407 reg -= 32; 3408 3409 if (reg >= 16) 3410 continue; 3411 3412 if ((wmask & (3 << (reg * 2))) != 0) 3413 return TRUE; 3414 } 3415 3416 return FALSE; 3417} 3418 3419/* In this function, we're interested in two things: finding input registers 3420 for VFP data-processing instructions, and finding the set of registers which 3421 arbitrary VFP instructions may write to. We use a 32-bit unsigned int to 3422 hold the written set, so FLDM etc. are easy to deal with (we're only 3423 interested in 32 SP registers or 16 dp registers, due to the VFP version 3424 implemented by the chip in question). DP registers are marked by setting 3425 both SP registers in the write mask). */ 3426 3427static enum bfd_arm_vfp11_pipe 3428bfd_arm_vfp11_insn_decode (unsigned int insn, unsigned int *destmask, int *regs, 3429 int *numregs) 3430{ 3431 enum bfd_arm_vfp11_pipe pipe = VFP11_BAD; 3432 bfd_boolean is_double = ((insn & 0xf00) == 0xb00) ? 1 : 0; 3433 3434 if ((insn & 0x0f000e10) == 0x0e000a00) /* A data-processing insn. */ 3435 { 3436 unsigned int pqrs; 3437 unsigned int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22); 3438 unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5); 3439 3440 pqrs = ((insn & 0x00800000) >> 20) 3441 | ((insn & 0x00300000) >> 19) 3442 | ((insn & 0x00000040) >> 6); 3443 3444 switch (pqrs) 3445 { 3446 case 0: /* fmac[sd]. */ 3447 case 1: /* fnmac[sd]. */ 3448 case 2: /* fmsc[sd]. */ 3449 case 3: /* fnmsc[sd]. */ 3450 pipe = VFP11_FMAC; 3451 bfd_arm_vfp11_write_mask (destmask, fd); 3452 regs[0] = fd; 3453 regs[1] = bfd_arm_vfp11_regno (insn, is_double, 16, 7); /* Fn. */ 3454 regs[2] = fm; 3455 *numregs = 3; 3456 break; 3457 3458 case 4: /* fmul[sd]. */ 3459 case 5: /* fnmul[sd]. */ 3460 case 6: /* fadd[sd]. */ 3461 case 7: /* fsub[sd]. */ 3462 pipe = VFP11_FMAC; 3463 goto vfp_binop; 3464 3465 case 8: /* fdiv[sd]. */ 3466 pipe = VFP11_DS; 3467 vfp_binop: 3468 bfd_arm_vfp11_write_mask (destmask, fd); 3469 regs[0] = bfd_arm_vfp11_regno (insn, is_double, 16, 7); /* Fn. */ 3470 regs[1] = fm; 3471 *numregs = 2; 3472 break; 3473 3474 case 15: /* extended opcode. */ 3475 { 3476 unsigned int extn = ((insn >> 15) & 0x1e) 3477 | ((insn >> 7) & 1); 3478 3479 switch (extn) 3480 { 3481 case 0: /* fcpy[sd]. */ 3482 case 1: /* fabs[sd]. */ 3483 case 2: /* fneg[sd]. */ 3484 case 8: /* fcmp[sd]. */ 3485 case 9: /* fcmpe[sd]. */ 3486 case 10: /* fcmpz[sd]. */ 3487 case 11: /* fcmpez[sd]. */ 3488 case 16: /* fuito[sd]. */ 3489 case 17: /* fsito[sd]. */ 3490 case 24: /* ftoui[sd]. */ 3491 case 25: /* ftouiz[sd]. */ 3492 case 26: /* ftosi[sd]. */ 3493 case 27: /* ftosiz[sd]. */ 3494 /* These instructions will not bounce due to underflow. */ 3495 *numregs = 0; 3496 pipe = VFP11_FMAC; 3497 break; 3498 3499 case 3: /* fsqrt[sd]. */ 3500 /* fsqrt cannot underflow, but it can (perhaps) overwrite 3501 registers to cause the erratum in previous instructions. */ 3502 bfd_arm_vfp11_write_mask (destmask, fd); 3503 pipe = VFP11_DS; 3504 break; 3505 3506 case 15: /* fcvt{ds,sd}. */ 3507 { 3508 int rnum = 0; 3509 3510 bfd_arm_vfp11_write_mask (destmask, fd); 3511 3512 /* Only FCVTSD can underflow. */ 3513 if ((insn & 0x100) != 0) 3514 regs[rnum++] = fm; 3515 3516 *numregs = rnum; 3517 3518 pipe = VFP11_FMAC; 3519 } 3520 break; 3521 3522 default: 3523 return VFP11_BAD; 3524 } 3525 } 3526 break; 3527 3528 default: 3529 return VFP11_BAD; 3530 } 3531 } 3532 /* Two-register transfer. */ 3533 else if ((insn & 0x0fe00ed0) == 0x0c400a10) 3534 { 3535 unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5); 3536 3537 if ((insn & 0x100000) == 0) 3538 { 3539 if (is_double) 3540 bfd_arm_vfp11_write_mask (destmask, fm); 3541 else 3542 { 3543 bfd_arm_vfp11_write_mask (destmask, fm); 3544 bfd_arm_vfp11_write_mask (destmask, fm + 1); 3545 } 3546 } 3547 3548 pipe = VFP11_LS; 3549 } 3550 else if ((insn & 0x0e100e00) == 0x0c100a00) /* A load insn. */ 3551 { 3552 int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22); 3553 unsigned int puw = ((insn >> 21) & 0x1) | (((insn >> 23) & 3) << 1); 3554 3555 switch (puw) 3556 { 3557 case 0: /* Two-reg transfer. We should catch these above. */ 3558 abort (); 3559 3560 case 2: /* fldm[sdx]. */ 3561 case 3: 3562 case 5: 3563 { 3564 unsigned int i, offset = insn & 0xff; 3565 3566 if (is_double) 3567 offset >>= 1; 3568 3569 for (i = fd; i < fd + offset; i++) 3570 bfd_arm_vfp11_write_mask (destmask, i); 3571 } 3572 break; 3573 3574 case 4: /* fld[sd]. */ 3575 case 6: 3576 bfd_arm_vfp11_write_mask (destmask, fd); 3577 break; 3578 3579 default: 3580 return VFP11_BAD; 3581 } 3582 3583 pipe = VFP11_LS; 3584 } 3585 /* Single-register transfer. Note L==0. */ 3586 else if ((insn & 0x0f100e10) == 0x0e000a10) 3587 { 3588 unsigned int opcode = (insn >> 21) & 7; 3589 unsigned int fn = bfd_arm_vfp11_regno (insn, is_double, 16, 7); 3590 3591 switch (opcode) 3592 { 3593 case 0: /* fmsr/fmdlr. */ 3594 case 1: /* fmdhr. */ 3595 /* Mark fmdhr and fmdlr as writing to the whole of the DP 3596 destination register. I don't know if this is exactly right, 3597 but it is the conservative choice. */ 3598 bfd_arm_vfp11_write_mask (destmask, fn); 3599 break; 3600 3601 case 7: /* fmxr. */ 3602 break; 3603 } 3604 3605 pipe = VFP11_LS; 3606 } 3607 3608 return pipe; 3609} 3610 3611 3612static int elf32_arm_compare_mapping (const void * a, const void * b); 3613 3614 3615/* Look for potentially-troublesome code sequences which might trigger the 3616 VFP11 denormal/antidependency erratum. See, e.g., the ARM1136 errata sheet 3617 (available from ARM) for details of the erratum. A short version is 3618 described in ld.texinfo. */ 3619 3620bfd_boolean 3621bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info) 3622{ 3623 asection *sec; 3624 bfd_byte *contents = NULL; 3625 int state = 0; 3626 int regs[3], numregs = 0; 3627 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info); 3628 int use_vector = (globals->vfp11_fix == BFD_ARM_VFP11_FIX_VECTOR); 3629 3630 /* We use a simple FSM to match troublesome VFP11 instruction sequences. 3631 The states transition as follows: 3632 3633 0 -> 1 (vector) or 0 -> 2 (scalar) 3634 A VFP FMAC-pipeline instruction has been seen. Fill 3635 regs[0]..regs[numregs-1] with its input operands. Remember this 3636 instruction in 'first_fmac'. 3637 3638 1 -> 2 3639 Any instruction, except for a VFP instruction which overwrites 3640 regs[*]. 3641 3642 1 -> 3 [ -> 0 ] or 3643 2 -> 3 [ -> 0 ] 3644 A VFP instruction has been seen which overwrites any of regs[*]. 3645 We must make a veneer! Reset state to 0 before examining next 3646 instruction. 3647 3648 2 -> 0 3649 If we fail to match anything in state 2, reset to state 0 and reset 3650 the instruction pointer to the instruction after 'first_fmac'. 3651 3652 If the VFP11 vector mode is in use, there must be at least two unrelated 3653 instructions between anti-dependent VFP11 instructions to properly avoid 3654 triggering the erratum, hence the use of the extra state 1. 3655 */ 3656 3657 /* If we are only performing a partial link do not bother 3658 to construct any glue. */ 3659 if (link_info->relocatable) 3660 return TRUE; 3661 3662 /* We should have chosen a fix type by the time we get here. */ 3663 BFD_ASSERT (globals->vfp11_fix != BFD_ARM_VFP11_FIX_DEFAULT); 3664 3665 if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_NONE) 3666 return TRUE; 3667 3668 /* Skip if this bfd does not correspond to an ELF image. */ 3669 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 3670 return TRUE; 3671 3672 for (sec = abfd->sections; sec != NULL; sec = sec->next) 3673 { 3674 unsigned int i, span, first_fmac = 0, veneer_of_insn = 0; 3675 struct _arm_elf_section_data *sec_data; 3676 3677 /* If we don't have executable progbits, we're not interested in this 3678 section. Also skip if section is to be excluded. */ 3679 if (elf_section_type (sec) != SHT_PROGBITS 3680 || (elf_section_flags (sec) & SHF_EXECINSTR) == 0 3681 || (sec->flags & SEC_EXCLUDE) != 0 3682 || strcmp (sec->name, VFP11_ERRATUM_VENEER_SECTION_NAME) == 0) 3683 continue; 3684 3685 sec_data = elf32_arm_section_data (sec); 3686 3687 if (sec_data->mapcount == 0) 3688 continue; 3689 3690 if (elf_section_data (sec)->this_hdr.contents != NULL) 3691 contents = elf_section_data (sec)->this_hdr.contents; 3692 else if (! bfd_malloc_and_get_section (abfd, sec, &contents)) 3693 goto error_return; 3694 3695 qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map), 3696 elf32_arm_compare_mapping); 3697 3698 for (span = 0; span < sec_data->mapcount; span++) 3699 { 3700 unsigned int span_start = sec_data->map[span].vma; 3701 unsigned int span_end = (span == sec_data->mapcount - 1) 3702 ? sec->size : sec_data->map[span + 1].vma; 3703 char span_type = sec_data->map[span].type; 3704 3705 /* FIXME: Only ARM mode is supported at present. We may need to 3706 support Thumb-2 mode also at some point. */ 3707 if (span_type != 'a') 3708 continue; 3709 3710 for (i = span_start; i < span_end;) 3711 { 3712 unsigned int next_i = i + 4; 3713 unsigned int insn = bfd_big_endian (abfd) 3714 ? (contents[i] << 24) 3715 | (contents[i + 1] << 16) 3716 | (contents[i + 2] << 8) 3717 | contents[i + 3] 3718 : (contents[i + 3] << 24) 3719 | (contents[i + 2] << 16) 3720 | (contents[i + 1] << 8) 3721 | contents[i]; 3722 unsigned int writemask = 0; 3723 enum bfd_arm_vfp11_pipe pipe; 3724 3725 switch (state) 3726 { 3727 case 0: 3728 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask, regs, 3729 &numregs); 3730 /* I'm assuming the VFP11 erratum can trigger with denorm 3731 operands on either the FMAC or the DS pipeline. This might 3732 lead to slightly overenthusiastic veneer insertion. */ 3733 if (pipe == VFP11_FMAC || pipe == VFP11_DS) 3734 { 3735 state = use_vector ? 1 : 2; 3736 first_fmac = i; 3737 veneer_of_insn = insn; 3738 } 3739 break; 3740 3741 case 1: 3742 { 3743 int other_regs[3], other_numregs; 3744 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask, 3745 other_regs, 3746 &other_numregs); 3747 if (pipe != VFP11_BAD 3748 && bfd_arm_vfp11_antidependency (writemask, regs, 3749 numregs)) 3750 state = 3; 3751 else 3752 state = 2; 3753 } 3754 break; 3755 3756 case 2: 3757 { 3758 int other_regs[3], other_numregs; 3759 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask, 3760 other_regs, 3761 &other_numregs); 3762 if (pipe != VFP11_BAD 3763 && bfd_arm_vfp11_antidependency (writemask, regs, 3764 numregs)) 3765 state = 3; 3766 else 3767 { 3768 state = 0; 3769 next_i = first_fmac + 4; 3770 } 3771 } 3772 break; 3773 3774 case 3: 3775 abort (); /* Should be unreachable. */ 3776 } 3777 3778 if (state == 3) 3779 { 3780 elf32_vfp11_erratum_list *newerr 3781 = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list)); 3782 int errcount; 3783 3784 errcount = ++(elf32_arm_section_data (sec)->erratumcount); 3785 3786 newerr->u.b.vfp_insn = veneer_of_insn; 3787 3788 switch (span_type) 3789 { 3790 case 'a': 3791 newerr->type = VFP11_ERRATUM_BRANCH_TO_ARM_VENEER; 3792 break; 3793 3794 default: 3795 abort (); 3796 } 3797 3798 record_vfp11_erratum_veneer (link_info, newerr, abfd, sec, 3799 first_fmac); 3800 3801 newerr->vma = -1; 3802 3803 newerr->next = sec_data->erratumlist; 3804 sec_data->erratumlist = newerr; 3805 3806 state = 0; 3807 } 3808 3809 i = next_i; 3810 } 3811 } 3812 3813 if (contents != NULL 3814 && elf_section_data (sec)->this_hdr.contents != contents) 3815 free (contents); 3816 contents = NULL; 3817 } 3818 3819 return TRUE; 3820 3821error_return: 3822 if (contents != NULL 3823 && elf_section_data (sec)->this_hdr.contents != contents) 3824 free (contents); 3825 3826 return FALSE; 3827} 3828 3829/* Find virtual-memory addresses for VFP11 erratum veneers and return locations 3830 after sections have been laid out, using specially-named symbols. */ 3831 3832void 3833bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd, 3834 struct bfd_link_info *link_info) 3835{ 3836 asection *sec; 3837 struct elf32_arm_link_hash_table *globals; 3838 char *tmp_name; 3839 3840 if (link_info->relocatable) 3841 return; 3842 3843 /* Skip if this bfd does not correspond to an ELF image. */ 3844 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 3845 return; 3846 3847 globals = elf32_arm_hash_table (link_info); 3848 3849 tmp_name = bfd_malloc ((bfd_size_type) strlen 3850 (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10); 3851 3852 for (sec = abfd->sections; sec != NULL; sec = sec->next) 3853 { 3854 struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec); 3855 elf32_vfp11_erratum_list *errnode = sec_data->erratumlist; 3856 3857 for (; errnode != NULL; errnode = errnode->next) 3858 { 3859 struct elf_link_hash_entry *myh; 3860 bfd_vma vma; 3861 3862 switch (errnode->type) 3863 { 3864 case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER: 3865 case VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER: 3866 /* Find veneer symbol. */ 3867 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME, 3868 errnode->u.b.veneer->u.v.id); 3869 3870 myh = elf_link_hash_lookup 3871 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE); 3872 3873 if (myh == NULL) 3874 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer " 3875 "`%s'"), abfd, tmp_name); 3876 3877 vma = myh->root.u.def.section->output_section->vma 3878 + myh->root.u.def.section->output_offset 3879 + myh->root.u.def.value; 3880 3881 errnode->u.b.veneer->vma = vma; 3882 break; 3883 3884 case VFP11_ERRATUM_ARM_VENEER: 3885 case VFP11_ERRATUM_THUMB_VENEER: 3886 /* Find return location. */ 3887 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r", 3888 errnode->u.v.id); 3889 3890 myh = elf_link_hash_lookup 3891 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE); 3892 3893 if (myh == NULL) 3894 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer " 3895 "`%s'"), abfd, tmp_name); 3896 3897 vma = myh->root.u.def.section->output_section->vma 3898 + myh->root.u.def.section->output_offset 3899 + myh->root.u.def.value; 3900 3901 errnode->u.v.branch->vma = vma; 3902 break; 3903 3904 default: 3905 abort (); 3906 } 3907 } 3908 } 3909 3910 free (tmp_name); 3911} 3912 3913 3914/* Set target relocation values needed during linking. */ 3915 3916void 3917bfd_elf32_arm_set_target_relocs (struct bfd *output_bfd, 3918 struct bfd_link_info *link_info, 3919 int target1_is_rel, 3920 char * target2_type, 3921 int fix_v4bx, 3922 int use_blx, 3923 bfd_arm_vfp11_fix vfp11_fix, 3924 int no_enum_warn, int pic_veneer) 3925{ 3926 struct elf32_arm_link_hash_table *globals; 3927 3928 globals = elf32_arm_hash_table (link_info); 3929 3930 globals->target1_is_rel = target1_is_rel; 3931 if (strcmp (target2_type, "rel") == 0) 3932 globals->target2_reloc = R_ARM_REL32; 3933 else if (strcmp (target2_type, "abs") == 0) 3934 globals->target2_reloc = R_ARM_ABS32; 3935 else if (strcmp (target2_type, "got-rel") == 0) 3936 globals->target2_reloc = R_ARM_GOT_PREL; 3937 else 3938 { 3939 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."), 3940 target2_type); 3941 } 3942 globals->fix_v4bx = fix_v4bx; 3943 globals->use_blx |= use_blx; 3944 globals->vfp11_fix = vfp11_fix; 3945 globals->pic_veneer = pic_veneer; 3946 3947 elf32_arm_tdata (output_bfd)->no_enum_size_warning = no_enum_warn; 3948} 3949 3950/* The thumb form of a long branch is a bit finicky, because the offset 3951 encoding is split over two fields, each in it's own instruction. They 3952 can occur in any order. So given a thumb form of long branch, and an 3953 offset, insert the offset into the thumb branch and return finished 3954 instruction. 3955 3956 It takes two thumb instructions to encode the target address. Each has 3957 11 bits to invest. The upper 11 bits are stored in one (identified by 3958 H-0.. see below), the lower 11 bits are stored in the other (identified 3959 by H-1). 3960 3961 Combine together and shifted left by 1 (it's a half word address) and 3962 there you have it. 3963 3964 Op: 1111 = F, 3965 H-0, upper address-0 = 000 3966 Op: 1111 = F, 3967 H-1, lower address-0 = 800 3968 3969 They can be ordered either way, but the arm tools I've seen always put 3970 the lower one first. It probably doesn't matter. krk@cygnus.com 3971 3972 XXX: Actually the order does matter. The second instruction (H-1) 3973 moves the computed address into the PC, so it must be the second one 3974 in the sequence. The problem, however is that whilst little endian code 3975 stores the instructions in HI then LOW order, big endian code does the 3976 reverse. nickc@cygnus.com. */ 3977 3978#define LOW_HI_ORDER 0xF800F000 3979#define HI_LOW_ORDER 0xF000F800 3980 3981static insn32 3982insert_thumb_branch (insn32 br_insn, int rel_off) 3983{ 3984 unsigned int low_bits; 3985 unsigned int high_bits; 3986 3987 BFD_ASSERT ((rel_off & 1) != 1); 3988 3989 rel_off >>= 1; /* Half word aligned address. */ 3990 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */ 3991 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */ 3992 3993 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER) 3994 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits; 3995 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER) 3996 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits; 3997 else 3998 /* FIXME: abort is probably not the right call. krk@cygnus.com */ 3999 abort (); /* Error - not a valid branch instruction form. */ 4000 4001 return br_insn; 4002} 4003 4004 4005/* Store an Arm insn into an output section not processed by 4006 elf32_arm_write_section. */ 4007 4008static void 4009put_arm_insn (struct elf32_arm_link_hash_table *htab, 4010 bfd * output_bfd, bfd_vma val, void * ptr) 4011{ 4012 if (htab->byteswap_code != bfd_little_endian (output_bfd)) 4013 bfd_putl32 (val, ptr); 4014 else 4015 bfd_putb32 (val, ptr); 4016} 4017 4018 4019/* Store a 16-bit Thumb insn into an output section not processed by 4020 elf32_arm_write_section. */ 4021 4022static void 4023put_thumb_insn (struct elf32_arm_link_hash_table *htab, 4024 bfd * output_bfd, bfd_vma val, void * ptr) 4025{ 4026 if (htab->byteswap_code != bfd_little_endian (output_bfd)) 4027 bfd_putl16 (val, ptr); 4028 else 4029 bfd_putb16 (val, ptr); 4030} 4031 4032 4033/* Thumb code calling an ARM function. */ 4034 4035static int 4036elf32_thumb_to_arm_stub (struct bfd_link_info * info, 4037 const char * name, 4038 bfd * input_bfd, 4039 bfd * output_bfd, 4040 asection * input_section, 4041 bfd_byte * hit_data, 4042 asection * sym_sec, 4043 bfd_vma offset, 4044 bfd_signed_vma addend, 4045 bfd_vma val, 4046 char **error_message) 4047{ 4048 asection * s = 0; 4049 bfd_vma my_offset; 4050 unsigned long int tmp; 4051 long int ret_offset; 4052 struct elf_link_hash_entry * myh; 4053 struct elf32_arm_link_hash_table * globals; 4054 4055 myh = find_thumb_glue (info, name, error_message); 4056 if (myh == NULL) 4057 return FALSE; 4058 4059 globals = elf32_arm_hash_table (info); 4060 4061 BFD_ASSERT (globals != NULL); 4062 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 4063 4064 my_offset = myh->root.u.def.value; 4065 4066 s = bfd_get_section_by_name (globals->bfd_of_glue_owner, 4067 THUMB2ARM_GLUE_SECTION_NAME); 4068 4069 BFD_ASSERT (s != NULL); 4070 BFD_ASSERT (s->contents != NULL); 4071 BFD_ASSERT (s->output_section != NULL); 4072 4073 if ((my_offset & 0x01) == 0x01) 4074 { 4075 if (sym_sec != NULL 4076 && sym_sec->owner != NULL 4077 && !INTERWORK_FLAG (sym_sec->owner)) 4078 { 4079 (*_bfd_error_handler) 4080 (_("%B(%s): warning: interworking not enabled.\n" 4081 " first occurrence: %B: thumb call to arm"), 4082 sym_sec->owner, input_bfd, name); 4083 4084 return FALSE; 4085 } 4086 4087 --my_offset; 4088 myh->root.u.def.value = my_offset; 4089 4090 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn, 4091 s->contents + my_offset); 4092 4093 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn, 4094 s->contents + my_offset + 2); 4095 4096 ret_offset = 4097 /* Address of destination of the stub. */ 4098 ((bfd_signed_vma) val) 4099 - ((bfd_signed_vma) 4100 /* Offset from the start of the current section 4101 to the start of the stubs. */ 4102 (s->output_offset 4103 /* Offset of the start of this stub from the start of the stubs. */ 4104 + my_offset 4105 /* Address of the start of the current section. */ 4106 + s->output_section->vma) 4107 /* The branch instruction is 4 bytes into the stub. */ 4108 + 4 4109 /* ARM branches work from the pc of the instruction + 8. */ 4110 + 8); 4111 4112 put_arm_insn (globals, output_bfd, 4113 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF), 4114 s->contents + my_offset + 4); 4115 } 4116 4117 BFD_ASSERT (my_offset <= globals->thumb_glue_size); 4118 4119 /* Now go back and fix up the original BL insn to point to here. */ 4120 ret_offset = 4121 /* Address of where the stub is located. */ 4122 (s->output_section->vma + s->output_offset + my_offset) 4123 /* Address of where the BL is located. */ 4124 - (input_section->output_section->vma + input_section->output_offset 4125 + offset) 4126 /* Addend in the relocation. */ 4127 - addend 4128 /* Biassing for PC-relative addressing. */ 4129 - 8; 4130 4131 tmp = bfd_get_32 (input_bfd, hit_data 4132 - input_section->vma); 4133 4134 bfd_put_32 (output_bfd, 4135 (bfd_vma) insert_thumb_branch (tmp, ret_offset), 4136 hit_data - input_section->vma); 4137 4138 return TRUE; 4139} 4140 4141/* Populate an Arm to Thumb stub. Returns the stub symbol. */ 4142 4143static struct elf_link_hash_entry * 4144elf32_arm_create_thumb_stub (struct bfd_link_info * info, 4145 const char * name, 4146 bfd * input_bfd, 4147 bfd * output_bfd, 4148 asection * sym_sec, 4149 bfd_vma val, 4150 asection *s, 4151 char **error_message) 4152{ 4153 bfd_vma my_offset; 4154 long int ret_offset; 4155 struct elf_link_hash_entry * myh; 4156 struct elf32_arm_link_hash_table * globals; 4157 4158 myh = find_arm_glue (info, name, error_message); 4159 if (myh == NULL) 4160 return NULL; 4161 4162 globals = elf32_arm_hash_table (info); 4163 4164 BFD_ASSERT (globals != NULL); 4165 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 4166 4167 my_offset = myh->root.u.def.value; 4168 4169 if ((my_offset & 0x01) == 0x01) 4170 { 4171 if (sym_sec != NULL 4172 && sym_sec->owner != NULL 4173 && !INTERWORK_FLAG (sym_sec->owner)) 4174 { 4175 (*_bfd_error_handler) 4176 (_("%B(%s): warning: interworking not enabled.\n" 4177 " first occurrence: %B: arm call to thumb"), 4178 sym_sec->owner, input_bfd, name); 4179 } 4180 4181 --my_offset; 4182 myh->root.u.def.value = my_offset; 4183 4184 if (info->shared || globals->root.is_relocatable_executable 4185 || globals->pic_veneer) 4186 { 4187 /* For relocatable objects we can't use absolute addresses, 4188 so construct the address from a relative offset. */ 4189 /* TODO: If the offset is small it's probably worth 4190 constructing the address with adds. */ 4191 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn, 4192 s->contents + my_offset); 4193 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn, 4194 s->contents + my_offset + 4); 4195 put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn, 4196 s->contents + my_offset + 8); 4197 /* Adjust the offset by 4 for the position of the add, 4198 and 8 for the pipeline offset. */ 4199 ret_offset = (val - (s->output_offset 4200 + s->output_section->vma 4201 + my_offset + 12)) 4202 | 1; 4203 bfd_put_32 (output_bfd, ret_offset, 4204 s->contents + my_offset + 12); 4205 } 4206 else if (globals->use_blx) 4207 { 4208 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1v5_ldr_insn, 4209 s->contents + my_offset); 4210 4211 /* It's a thumb address. Add the low order bit. */ 4212 bfd_put_32 (output_bfd, val | a2t2v5_func_addr_insn, 4213 s->contents + my_offset + 4); 4214 } 4215 else 4216 { 4217 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn, 4218 s->contents + my_offset); 4219 4220 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn, 4221 s->contents + my_offset + 4); 4222 4223 /* It's a thumb address. Add the low order bit. */ 4224 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn, 4225 s->contents + my_offset + 8); 4226 } 4227 } 4228 4229 BFD_ASSERT (my_offset <= globals->arm_glue_size); 4230 4231 return myh; 4232} 4233 4234/* Arm code calling a Thumb function. */ 4235 4236static int 4237elf32_arm_to_thumb_stub (struct bfd_link_info * info, 4238 const char * name, 4239 bfd * input_bfd, 4240 bfd * output_bfd, 4241 asection * input_section, 4242 bfd_byte * hit_data, 4243 asection * sym_sec, 4244 bfd_vma offset, 4245 bfd_signed_vma addend, 4246 bfd_vma val, 4247 char **error_message) 4248{ 4249 unsigned long int tmp; 4250 bfd_vma my_offset; 4251 asection * s; 4252 long int ret_offset; 4253 struct elf_link_hash_entry * myh; 4254 struct elf32_arm_link_hash_table * globals; 4255 4256 globals = elf32_arm_hash_table (info); 4257 4258 BFD_ASSERT (globals != NULL); 4259 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 4260 4261 s = bfd_get_section_by_name (globals->bfd_of_glue_owner, 4262 ARM2THUMB_GLUE_SECTION_NAME); 4263 BFD_ASSERT (s != NULL); 4264 BFD_ASSERT (s->contents != NULL); 4265 BFD_ASSERT (s->output_section != NULL); 4266 4267 myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd, 4268 sym_sec, val, s, error_message); 4269 if (!myh) 4270 return FALSE; 4271 4272 my_offset = myh->root.u.def.value; 4273 tmp = bfd_get_32 (input_bfd, hit_data); 4274 tmp = tmp & 0xFF000000; 4275 4276 /* Somehow these are both 4 too far, so subtract 8. */ 4277 ret_offset = (s->output_offset 4278 + my_offset 4279 + s->output_section->vma 4280 - (input_section->output_offset 4281 + input_section->output_section->vma 4282 + offset + addend) 4283 - 8); 4284 4285 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF); 4286 4287 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma); 4288 4289 return TRUE; 4290} 4291 4292/* Populate Arm stub for an exported Thumb function. */ 4293 4294static bfd_boolean 4295elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf) 4296{ 4297 struct bfd_link_info * info = (struct bfd_link_info *) inf; 4298 asection * s; 4299 struct elf_link_hash_entry * myh; 4300 struct elf32_arm_link_hash_entry *eh; 4301 struct elf32_arm_link_hash_table * globals; 4302 asection *sec; 4303 bfd_vma val; 4304 char *error_message; 4305 4306 eh = elf32_arm_hash_entry(h); 4307 /* Allocate stubs for exported Thumb functions on v4t. */ 4308 if (eh->export_glue == NULL) 4309 return TRUE; 4310 4311 globals = elf32_arm_hash_table (info); 4312 4313 BFD_ASSERT (globals != NULL); 4314 BFD_ASSERT (globals->bfd_of_glue_owner != NULL); 4315 4316 s = bfd_get_section_by_name (globals->bfd_of_glue_owner, 4317 ARM2THUMB_GLUE_SECTION_NAME); 4318 BFD_ASSERT (s != NULL); 4319 BFD_ASSERT (s->contents != NULL); 4320 BFD_ASSERT (s->output_section != NULL); 4321 4322 sec = eh->export_glue->root.u.def.section; 4323 4324 BFD_ASSERT (sec->output_section != NULL); 4325 4326 val = eh->export_glue->root.u.def.value + sec->output_offset 4327 + sec->output_section->vma; 4328 myh = elf32_arm_create_thumb_stub (info, h->root.root.string, 4329 h->root.u.def.section->owner, 4330 globals->obfd, sec, val, s, 4331 &error_message); 4332 BFD_ASSERT (myh); 4333 return TRUE; 4334} 4335 4336/* Generate Arm stubs for exported Thumb symbols. */ 4337static void 4338elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED, 4339 struct bfd_link_info *link_info) 4340{ 4341 struct elf32_arm_link_hash_table * globals; 4342 4343 if (!link_info) 4344 return; 4345 4346 globals = elf32_arm_hash_table (link_info); 4347 /* If blx is available then exported Thumb symbols are OK and there is 4348 nothing to do. */ 4349 if (globals->use_blx) 4350 return; 4351 4352 elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub, 4353 link_info); 4354} 4355 4356/* Some relocations map to different relocations depending on the 4357 target. Return the real relocation. */ 4358static int 4359arm_real_reloc_type (struct elf32_arm_link_hash_table * globals, 4360 int r_type) 4361{ 4362 switch (r_type) 4363 { 4364 case R_ARM_TARGET1: 4365 if (globals->target1_is_rel) 4366 return R_ARM_REL32; 4367 else 4368 return R_ARM_ABS32; 4369 4370 case R_ARM_TARGET2: 4371 return globals->target2_reloc; 4372 4373 default: 4374 return r_type; 4375 } 4376} 4377 4378/* Return the base VMA address which should be subtracted from real addresses 4379 when resolving @dtpoff relocation. 4380 This is PT_TLS segment p_vaddr. */ 4381 4382static bfd_vma 4383dtpoff_base (struct bfd_link_info *info) 4384{ 4385 /* If tls_sec is NULL, we should have signalled an error already. */ 4386 if (elf_hash_table (info)->tls_sec == NULL) 4387 return 0; 4388 return elf_hash_table (info)->tls_sec->vma; 4389} 4390 4391/* Return the relocation value for @tpoff relocation 4392 if STT_TLS virtual address is ADDRESS. */ 4393 4394static bfd_vma 4395tpoff (struct bfd_link_info *info, bfd_vma address) 4396{ 4397 struct elf_link_hash_table *htab = elf_hash_table (info); 4398 bfd_vma base; 4399 4400 /* If tls_sec is NULL, we should have signalled an error already. */ 4401 if (htab->tls_sec == NULL) 4402 return 0; 4403 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power); 4404 return address - htab->tls_sec->vma + base; 4405} 4406 4407/* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA. 4408 VALUE is the relocation value. */ 4409 4410static bfd_reloc_status_type 4411elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value) 4412{ 4413 if (value > 0xfff) 4414 return bfd_reloc_overflow; 4415 4416 value |= bfd_get_32 (abfd, data) & 0xfffff000; 4417 bfd_put_32 (abfd, value, data); 4418 return bfd_reloc_ok; 4419} 4420 4421/* For a given value of n, calculate the value of G_n as required to 4422 deal with group relocations. We return it in the form of an 4423 encoded constant-and-rotation, together with the final residual. If n is 4424 specified as less than zero, then final_residual is filled with the 4425 input value and no further action is performed. */ 4426 4427static bfd_vma 4428calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual) 4429{ 4430 int current_n; 4431 bfd_vma g_n; 4432 bfd_vma encoded_g_n = 0; 4433 bfd_vma residual = value; /* Also known as Y_n. */ 4434 4435 for (current_n = 0; current_n <= n; current_n++) 4436 { 4437 int shift; 4438 4439 /* Calculate which part of the value to mask. */ 4440 if (residual == 0) 4441 shift = 0; 4442 else 4443 { 4444 int msb; 4445 4446 /* Determine the most significant bit in the residual and 4447 align the resulting value to a 2-bit boundary. */ 4448 for (msb = 30; msb >= 0; msb -= 2) 4449 if (residual & (3 << msb)) 4450 break; 4451 4452 /* The desired shift is now (msb - 6), or zero, whichever 4453 is the greater. */ 4454 shift = msb - 6; 4455 if (shift < 0) 4456 shift = 0; 4457 } 4458 4459 /* Calculate g_n in 32-bit as well as encoded constant+rotation form. */ 4460 g_n = residual & (0xff << shift); 4461 encoded_g_n = (g_n >> shift) 4462 | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8); 4463 4464 /* Calculate the residual for the next time around. */ 4465 residual &= ~g_n; 4466 } 4467 4468 *final_residual = residual; 4469 4470 return encoded_g_n; 4471} 4472 4473/* Given an ARM instruction, determine whether it is an ADD or a SUB. 4474 Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise. */ 4475static int 4476identify_add_or_sub(bfd_vma insn) 4477{ 4478 int opcode = insn & 0x1e00000; 4479 4480 if (opcode == 1 << 23) /* ADD */ 4481 return 1; 4482 4483 if (opcode == 1 << 22) /* SUB */ 4484 return -1; 4485 4486 return 0; 4487} 4488 4489/* Determine if we're dealing with a Thumb-2 object. */ 4490 4491static int using_thumb2 (struct elf32_arm_link_hash_table *globals) 4492{ 4493 int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC, 4494 Tag_CPU_arch); 4495 return arch == TAG_CPU_ARCH_V6T2 || arch >= TAG_CPU_ARCH_V7; 4496} 4497 4498/* Perform a relocation as part of a final link. */ 4499 4500static bfd_reloc_status_type 4501elf32_arm_final_link_relocate (reloc_howto_type * howto, 4502 bfd * input_bfd, 4503 bfd * output_bfd, 4504 asection * input_section, 4505 bfd_byte * contents, 4506 Elf_Internal_Rela * rel, 4507 bfd_vma value, 4508 struct bfd_link_info * info, 4509 asection * sym_sec, 4510 const char * sym_name, 4511 int sym_flags, 4512 struct elf_link_hash_entry * h, 4513 bfd_boolean * unresolved_reloc_p, 4514 char **error_message) 4515{ 4516 unsigned long r_type = howto->type; 4517 unsigned long r_symndx; 4518 bfd_byte * hit_data = contents + rel->r_offset; 4519 bfd * dynobj = NULL; 4520 Elf_Internal_Shdr * symtab_hdr; 4521 struct elf_link_hash_entry ** sym_hashes; 4522 bfd_vma * local_got_offsets; 4523 asection * sgot = NULL; 4524 asection * splt = NULL; 4525 asection * sreloc = NULL; 4526 bfd_vma addend; 4527 bfd_signed_vma signed_addend; 4528 struct elf32_arm_link_hash_table * globals; 4529 4530 globals = elf32_arm_hash_table (info); 4531 4532 /* Some relocation type map to different relocations depending on the 4533 target. We pick the right one here. */ 4534 r_type = arm_real_reloc_type (globals, r_type); 4535 if (r_type != howto->type) 4536 howto = elf32_arm_howto_from_type (r_type); 4537 4538 /* If the start address has been set, then set the EF_ARM_HASENTRY 4539 flag. Setting this more than once is redundant, but the cost is 4540 not too high, and it keeps the code simple. 4541 4542 The test is done here, rather than somewhere else, because the 4543 start address is only set just before the final link commences. 4544 4545 Note - if the user deliberately sets a start address of 0, the 4546 flag will not be set. */ 4547 if (bfd_get_start_address (output_bfd) != 0) 4548 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY; 4549 4550 dynobj = elf_hash_table (info)->dynobj; 4551 if (dynobj) 4552 { 4553 sgot = bfd_get_section_by_name (dynobj, ".got"); 4554 splt = bfd_get_section_by_name (dynobj, ".plt"); 4555 } 4556 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 4557 sym_hashes = elf_sym_hashes (input_bfd); 4558 local_got_offsets = elf_local_got_offsets (input_bfd); 4559 r_symndx = ELF32_R_SYM (rel->r_info); 4560 4561 if (globals->use_rel) 4562 { 4563 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask; 4564 4565 if (addend & ((howto->src_mask + 1) >> 1)) 4566 { 4567 signed_addend = -1; 4568 signed_addend &= ~ howto->src_mask; 4569 signed_addend |= addend; 4570 } 4571 else 4572 signed_addend = addend; 4573 } 4574 else 4575 addend = signed_addend = rel->r_addend; 4576 4577 switch (r_type) 4578 { 4579 case R_ARM_NONE: 4580 /* We don't need to find a value for this symbol. It's just a 4581 marker. */ 4582 *unresolved_reloc_p = FALSE; 4583 return bfd_reloc_ok; 4584 4585 case R_ARM_ABS12: 4586 if (!globals->vxworks_p) 4587 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend); 4588 4589 case R_ARM_PC24: 4590 case R_ARM_ABS32: 4591 case R_ARM_ABS32_NOI: 4592 case R_ARM_REL32: 4593 case R_ARM_REL32_NOI: 4594 case R_ARM_CALL: 4595 case R_ARM_JUMP24: 4596 case R_ARM_XPC25: 4597 case R_ARM_PREL31: 4598 case R_ARM_PLT32: 4599 /* Handle relocations which should use the PLT entry. ABS32/REL32 4600 will use the symbol's value, which may point to a PLT entry, but we 4601 don't need to handle that here. If we created a PLT entry, all 4602 branches in this object should go to it. */ 4603 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32 4604 && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI) 4605 && h != NULL 4606 && splt != NULL 4607 && h->plt.offset != (bfd_vma) -1) 4608 { 4609 /* If we've created a .plt section, and assigned a PLT entry to 4610 this function, it should not be known to bind locally. If 4611 it were, we would have cleared the PLT entry. */ 4612 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h)); 4613 4614 value = (splt->output_section->vma 4615 + splt->output_offset 4616 + h->plt.offset); 4617 *unresolved_reloc_p = FALSE; 4618 return _bfd_final_link_relocate (howto, input_bfd, input_section, 4619 contents, rel->r_offset, value, 4620 rel->r_addend); 4621 } 4622 4623 /* When generating a shared object or relocatable executable, these 4624 relocations are copied into the output file to be resolved at 4625 run time. */ 4626 if ((info->shared || globals->root.is_relocatable_executable) 4627 && (input_section->flags & SEC_ALLOC) 4628 && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI) 4629 || !SYMBOL_CALLS_LOCAL (info, h)) 4630 && (h == NULL 4631 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 4632 || h->root.type != bfd_link_hash_undefweak) 4633 && r_type != R_ARM_PC24 4634 && r_type != R_ARM_CALL 4635 && r_type != R_ARM_JUMP24 4636 && r_type != R_ARM_PREL31 4637 && r_type != R_ARM_PLT32) 4638 { 4639 Elf_Internal_Rela outrel; 4640 bfd_byte *loc; 4641 bfd_boolean skip, relocate; 4642 4643 *unresolved_reloc_p = FALSE; 4644 4645 if (sreloc == NULL) 4646 { 4647 const char * name; 4648 4649 name = (bfd_elf_string_from_elf_section 4650 (input_bfd, 4651 elf_elfheader (input_bfd)->e_shstrndx, 4652 elf_section_data (input_section)->rel_hdr.sh_name)); 4653 if (name == NULL) 4654 return bfd_reloc_notsupported; 4655 4656 BFD_ASSERT (reloc_section_p (globals, name, input_section)); 4657 4658 sreloc = bfd_get_section_by_name (dynobj, name); 4659 BFD_ASSERT (sreloc != NULL); 4660 } 4661 4662 skip = FALSE; 4663 relocate = FALSE; 4664 4665 outrel.r_addend = addend; 4666 outrel.r_offset = 4667 _bfd_elf_section_offset (output_bfd, info, input_section, 4668 rel->r_offset); 4669 if (outrel.r_offset == (bfd_vma) -1) 4670 skip = TRUE; 4671 else if (outrel.r_offset == (bfd_vma) -2) 4672 skip = TRUE, relocate = TRUE; 4673 outrel.r_offset += (input_section->output_section->vma 4674 + input_section->output_offset); 4675 4676 if (skip) 4677 memset (&outrel, 0, sizeof outrel); 4678 else if (h != NULL 4679 && h->dynindx != -1 4680 && (!info->shared 4681 || !info->symbolic 4682 || !h->def_regular)) 4683 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 4684 else 4685 { 4686 int symbol; 4687 4688 /* This symbol is local, or marked to become local. */ 4689 if (sym_flags == STT_ARM_TFUNC) 4690 value |= 1; 4691 if (globals->symbian_p) 4692 { 4693 asection *osec; 4694 4695 /* On Symbian OS, the data segment and text segement 4696 can be relocated independently. Therefore, we 4697 must indicate the segment to which this 4698 relocation is relative. The BPABI allows us to 4699 use any symbol in the right segment; we just use 4700 the section symbol as it is convenient. (We 4701 cannot use the symbol given by "h" directly as it 4702 will not appear in the dynamic symbol table.) 4703 4704 Note that the dynamic linker ignores the section 4705 symbol value, so we don't subtract osec->vma 4706 from the emitted reloc addend. */ 4707 if (sym_sec) 4708 osec = sym_sec->output_section; 4709 else 4710 osec = input_section->output_section; 4711 symbol = elf_section_data (osec)->dynindx; 4712 if (symbol == 0) 4713 { 4714 struct elf_link_hash_table *htab = elf_hash_table (info); 4715 4716 if ((osec->flags & SEC_READONLY) == 0 4717 && htab->data_index_section != NULL) 4718 osec = htab->data_index_section; 4719 else 4720 osec = htab->text_index_section; 4721 symbol = elf_section_data (osec)->dynindx; 4722 } 4723 BFD_ASSERT (symbol != 0); 4724 } 4725 else 4726 /* On SVR4-ish systems, the dynamic loader cannot 4727 relocate the text and data segments independently, 4728 so the symbol does not matter. */ 4729 symbol = 0; 4730 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE); 4731 if (globals->use_rel) 4732 relocate = TRUE; 4733 else 4734 outrel.r_addend += value; 4735 } 4736 4737 loc = sreloc->contents; 4738 loc += sreloc->reloc_count++ * RELOC_SIZE (globals); 4739 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc); 4740 4741 /* If this reloc is against an external symbol, we do not want to 4742 fiddle with the addend. Otherwise, we need to include the symbol 4743 value so that it becomes an addend for the dynamic reloc. */ 4744 if (! relocate) 4745 return bfd_reloc_ok; 4746 4747 return _bfd_final_link_relocate (howto, input_bfd, input_section, 4748 contents, rel->r_offset, value, 4749 (bfd_vma) 0); 4750 } 4751 else switch (r_type) 4752 { 4753 case R_ARM_ABS12: 4754 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend); 4755 4756 case R_ARM_XPC25: /* Arm BLX instruction. */ 4757 case R_ARM_CALL: 4758 case R_ARM_JUMP24: 4759 case R_ARM_PC24: /* Arm B/BL instruction */ 4760 case R_ARM_PLT32: 4761 if (r_type == R_ARM_XPC25) 4762 { 4763 /* Check for Arm calling Arm function. */ 4764 /* FIXME: Should we translate the instruction into a BL 4765 instruction instead ? */ 4766 if (sym_flags != STT_ARM_TFUNC) 4767 (*_bfd_error_handler) 4768 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."), 4769 input_bfd, 4770 h ? h->root.root.string : "(local)"); 4771 } 4772 else if (r_type != R_ARM_CALL || !globals->use_blx) 4773 { 4774 /* Check for Arm calling Thumb function. */ 4775 if (sym_flags == STT_ARM_TFUNC) 4776 { 4777 if (elf32_arm_to_thumb_stub (info, sym_name, input_bfd, 4778 output_bfd, input_section, 4779 hit_data, sym_sec, rel->r_offset, 4780 signed_addend, value, 4781 error_message)) 4782 return bfd_reloc_ok; 4783 else 4784 return bfd_reloc_dangerous; 4785 } 4786 } 4787 4788 /* The ARM ELF ABI says that this reloc is computed as: S - P + A 4789 where: 4790 S is the address of the symbol in the relocation. 4791 P is address of the instruction being relocated. 4792 A is the addend (extracted from the instruction) in bytes. 4793 4794 S is held in 'value'. 4795 P is the base address of the section containing the 4796 instruction plus the offset of the reloc into that 4797 section, ie: 4798 (input_section->output_section->vma + 4799 input_section->output_offset + 4800 rel->r_offset). 4801 A is the addend, converted into bytes, ie: 4802 (signed_addend * 4) 4803 4804 Note: None of these operations have knowledge of the pipeline 4805 size of the processor, thus it is up to the assembler to 4806 encode this information into the addend. */ 4807 value -= (input_section->output_section->vma 4808 + input_section->output_offset); 4809 value -= rel->r_offset; 4810 if (globals->use_rel) 4811 value += (signed_addend << howto->size); 4812 else 4813 /* RELA addends do not have to be adjusted by howto->size. */ 4814 value += signed_addend; 4815 4816 signed_addend = value; 4817 signed_addend >>= howto->rightshift; 4818 4819 /* A branch to an undefined weak symbol is turned into a jump to 4820 the next instruction. */ 4821 if (h && h->root.type == bfd_link_hash_undefweak) 4822 { 4823 value = (bfd_get_32 (input_bfd, hit_data) & 0xf0000000) 4824 | 0x0affffff; 4825 } 4826 else 4827 { 4828 /* Perform a signed range check. */ 4829 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1)) 4830 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1))) 4831 return bfd_reloc_overflow; 4832 4833 addend = (value & 2); 4834 4835 value = (signed_addend & howto->dst_mask) 4836 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask)); 4837 4838 /* Set the H bit in the BLX instruction. */ 4839 if (sym_flags == STT_ARM_TFUNC) 4840 { 4841 if (addend) 4842 value |= (1 << 24); 4843 else 4844 value &= ~(bfd_vma)(1 << 24); 4845 } 4846 if (r_type == R_ARM_CALL) 4847 { 4848 /* Select the correct instruction (BL or BLX). */ 4849 if (sym_flags == STT_ARM_TFUNC) 4850 value |= (1 << 28); 4851 else 4852 { 4853 value &= ~(bfd_vma)(1 << 28); 4854 value |= (1 << 24); 4855 } 4856 } 4857 } 4858 break; 4859 4860 case R_ARM_ABS32: 4861 value += addend; 4862 if (sym_flags == STT_ARM_TFUNC) 4863 value |= 1; 4864 break; 4865 4866 case R_ARM_ABS32_NOI: 4867 value += addend; 4868 break; 4869 4870 case R_ARM_REL32: 4871 value += addend; 4872 if (sym_flags == STT_ARM_TFUNC) 4873 value |= 1; 4874 value -= (input_section->output_section->vma 4875 + input_section->output_offset + rel->r_offset); 4876 break; 4877 4878 case R_ARM_REL32_NOI: 4879 value += addend; 4880 value -= (input_section->output_section->vma 4881 + input_section->output_offset + rel->r_offset); 4882 break; 4883 4884 case R_ARM_PREL31: 4885 value -= (input_section->output_section->vma 4886 + input_section->output_offset + rel->r_offset); 4887 value += signed_addend; 4888 if (! h || h->root.type != bfd_link_hash_undefweak) 4889 { 4890 /* Check for overflow */ 4891 if ((value ^ (value >> 1)) & (1 << 30)) 4892 return bfd_reloc_overflow; 4893 } 4894 value &= 0x7fffffff; 4895 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000); 4896 if (sym_flags == STT_ARM_TFUNC) 4897 value |= 1; 4898 break; 4899 } 4900 4901 bfd_put_32 (input_bfd, value, hit_data); 4902 return bfd_reloc_ok; 4903 4904 case R_ARM_ABS8: 4905 value += addend; 4906 if ((long) value > 0x7f || (long) value < -0x80) 4907 return bfd_reloc_overflow; 4908 4909 bfd_put_8 (input_bfd, value, hit_data); 4910 return bfd_reloc_ok; 4911 4912 case R_ARM_ABS16: 4913 value += addend; 4914 4915 if ((long) value > 0x7fff || (long) value < -0x8000) 4916 return bfd_reloc_overflow; 4917 4918 bfd_put_16 (input_bfd, value, hit_data); 4919 return bfd_reloc_ok; 4920 4921 case R_ARM_THM_ABS5: 4922 /* Support ldr and str instructions for the thumb. */ 4923 if (globals->use_rel) 4924 { 4925 /* Need to refetch addend. */ 4926 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask; 4927 /* ??? Need to determine shift amount from operand size. */ 4928 addend >>= howto->rightshift; 4929 } 4930 value += addend; 4931 4932 /* ??? Isn't value unsigned? */ 4933 if ((long) value > 0x1f || (long) value < -0x10) 4934 return bfd_reloc_overflow; 4935 4936 /* ??? Value needs to be properly shifted into place first. */ 4937 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f; 4938 bfd_put_16 (input_bfd, value, hit_data); 4939 return bfd_reloc_ok; 4940 4941 case R_ARM_THM_ALU_PREL_11_0: 4942 /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw). */ 4943 { 4944 bfd_vma insn; 4945 bfd_signed_vma relocation; 4946 4947 insn = (bfd_get_16 (input_bfd, hit_data) << 16) 4948 | bfd_get_16 (input_bfd, hit_data + 2); 4949 4950 if (globals->use_rel) 4951 { 4952 signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4) 4953 | ((insn & (1 << 26)) >> 15); 4954 if (insn & 0xf00000) 4955 signed_addend = -signed_addend; 4956 } 4957 4958 relocation = value + signed_addend; 4959 relocation -= (input_section->output_section->vma 4960 + input_section->output_offset 4961 + rel->r_offset); 4962 4963 value = abs (relocation); 4964 4965 if (value >= 0x1000) 4966 return bfd_reloc_overflow; 4967 4968 insn = (insn & 0xfb0f8f00) | (value & 0xff) 4969 | ((value & 0x700) << 4) 4970 | ((value & 0x800) << 15); 4971 if (relocation < 0) 4972 insn |= 0xa00000; 4973 4974 bfd_put_16 (input_bfd, insn >> 16, hit_data); 4975 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2); 4976 4977 return bfd_reloc_ok; 4978 } 4979 4980 case R_ARM_THM_PC12: 4981 /* Corresponds to: ldr.w reg, [pc, #offset]. */ 4982 { 4983 bfd_vma insn; 4984 bfd_signed_vma relocation; 4985 4986 insn = (bfd_get_16 (input_bfd, hit_data) << 16) 4987 | bfd_get_16 (input_bfd, hit_data + 2); 4988 4989 if (globals->use_rel) 4990 { 4991 signed_addend = insn & 0xfff; 4992 if (!(insn & (1 << 23))) 4993 signed_addend = -signed_addend; 4994 } 4995 4996 relocation = value + signed_addend; 4997 relocation -= (input_section->output_section->vma 4998 + input_section->output_offset 4999 + rel->r_offset); 5000 5001 value = abs (relocation); 5002 5003 if (value >= 0x1000) 5004 return bfd_reloc_overflow; 5005 5006 insn = (insn & 0xff7ff000) | value; 5007 if (relocation >= 0) 5008 insn |= (1 << 23); 5009 5010 bfd_put_16 (input_bfd, insn >> 16, hit_data); 5011 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2); 5012 5013 return bfd_reloc_ok; 5014 } 5015 5016 case R_ARM_THM_XPC22: 5017 case R_ARM_THM_CALL: 5018 /* Thumb BL (branch long instruction). */ 5019 { 5020 bfd_vma relocation; 5021 bfd_vma reloc_sign; 5022 bfd_boolean overflow = FALSE; 5023 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data); 5024 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2); 5025 bfd_signed_vma reloc_signed_max; 5026 bfd_signed_vma reloc_signed_min; 5027 bfd_vma check; 5028 bfd_signed_vma signed_check; 5029 int bitsize; 5030 int thumb2 = using_thumb2 (globals); 5031 5032 /* A branch to an undefined weak symbol is turned into a jump to 5033 the next instruction. */ 5034 if (h && h->root.type == bfd_link_hash_undefweak) 5035 { 5036 bfd_put_16 (input_bfd, 0xe000, hit_data); 5037 bfd_put_16 (input_bfd, 0xbf00, hit_data + 2); 5038 return bfd_reloc_ok; 5039 } 5040 5041 /* Fetch the addend. We use the Thumb-2 encoding (backwards compatible 5042 with Thumb-1) involving the J1 and J2 bits. */ 5043 if (globals->use_rel) 5044 { 5045 bfd_vma s = (upper_insn & (1 << 10)) >> 10; 5046 bfd_vma upper = upper_insn & 0x3ff; 5047 bfd_vma lower = lower_insn & 0x7ff; 5048 bfd_vma j1 = (lower_insn & (1 << 13)) >> 13; 5049 bfd_vma j2 = (lower_insn & (1 << 11)) >> 11; 5050 bfd_vma i1 = j1 ^ s ? 0 : 1; 5051 bfd_vma i2 = j2 ^ s ? 0 : 1; 5052 5053 addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1); 5054 /* Sign extend. */ 5055 addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24); 5056 5057 signed_addend = addend; 5058 } 5059 5060 if (r_type == R_ARM_THM_XPC22) 5061 { 5062 /* Check for Thumb to Thumb call. */ 5063 /* FIXME: Should we translate the instruction into a BL 5064 instruction instead ? */ 5065 if (sym_flags == STT_ARM_TFUNC) 5066 (*_bfd_error_handler) 5067 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."), 5068 input_bfd, 5069 h ? h->root.root.string : "(local)"); 5070 } 5071 else 5072 { 5073 /* If it is not a call to Thumb, assume call to Arm. 5074 If it is a call relative to a section name, then it is not a 5075 function call at all, but rather a long jump. Calls through 5076 the PLT do not require stubs. */ 5077 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION 5078 && (h == NULL || splt == NULL 5079 || h->plt.offset == (bfd_vma) -1)) 5080 { 5081 if (globals->use_blx) 5082 { 5083 /* Convert BL to BLX. */ 5084 lower_insn = (lower_insn & ~0x1000) | 0x0800; 5085 } 5086 else if (elf32_thumb_to_arm_stub 5087 (info, sym_name, input_bfd, output_bfd, input_section, 5088 hit_data, sym_sec, rel->r_offset, signed_addend, value, 5089 error_message)) 5090 return bfd_reloc_ok; 5091 else 5092 return bfd_reloc_dangerous; 5093 } 5094 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx) 5095 { 5096 /* Make sure this is a BL. */ 5097 lower_insn |= 0x1800; 5098 } 5099 } 5100 5101 /* Handle calls via the PLT. */ 5102 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1) 5103 { 5104 value = (splt->output_section->vma 5105 + splt->output_offset 5106 + h->plt.offset); 5107 if (globals->use_blx) 5108 { 5109 /* If the Thumb BLX instruction is available, convert the 5110 BL to a BLX instruction to call the ARM-mode PLT entry. */ 5111 lower_insn = (lower_insn & ~0x1000) | 0x0800; 5112 } 5113 else 5114 /* Target the Thumb stub before the ARM PLT entry. */ 5115 value -= PLT_THUMB_STUB_SIZE; 5116 *unresolved_reloc_p = FALSE; 5117 } 5118 5119 relocation = value + signed_addend; 5120 5121 relocation -= (input_section->output_section->vma 5122 + input_section->output_offset 5123 + rel->r_offset); 5124 5125 check = relocation >> howto->rightshift; 5126 5127 /* If this is a signed value, the rightshift just dropped 5128 leading 1 bits (assuming twos complement). */ 5129 if ((bfd_signed_vma) relocation >= 0) 5130 signed_check = check; 5131 else 5132 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift); 5133 5134 /* Calculate the permissable maximum and minimum values for 5135 this relocation according to whether we're relocating for 5136 Thumb-2 or not. */ 5137 bitsize = howto->bitsize; 5138 if (!thumb2) 5139 bitsize -= 2; 5140 reloc_signed_max = ((1 << (bitsize - 1)) - 1) >> howto->rightshift; 5141 reloc_signed_min = ~reloc_signed_max; 5142 5143 /* Assumes two's complement. */ 5144 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min) 5145 overflow = TRUE; 5146 5147 if ((lower_insn & 0x1800) == 0x0800) 5148 /* For a BLX instruction, make sure that the relocation is rounded up 5149 to a word boundary. This follows the semantics of the instruction 5150 which specifies that bit 1 of the target address will come from bit 5151 1 of the base address. */ 5152 relocation = (relocation + 2) & ~ 3; 5153 5154 /* Put RELOCATION back into the insn. Assumes two's complement. 5155 We use the Thumb-2 encoding, which is safe even if dealing with 5156 a Thumb-1 instruction by virtue of our overflow check above. */ 5157 reloc_sign = (signed_check < 0) ? 1 : 0; 5158 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) 5159 | ((relocation >> 12) & 0x3ff) 5160 | (reloc_sign << 10); 5161 lower_insn = (lower_insn & ~(bfd_vma) 0x2fff) 5162 | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13) 5163 | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11) 5164 | ((relocation >> 1) & 0x7ff); 5165 5166 /* Put the relocated value back in the object file: */ 5167 bfd_put_16 (input_bfd, upper_insn, hit_data); 5168 bfd_put_16 (input_bfd, lower_insn, hit_data + 2); 5169 5170 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok); 5171 } 5172 break; 5173 5174 case R_ARM_THM_JUMP24: 5175 /* Thumb32 unconditional branch instruction. */ 5176 { 5177 bfd_vma relocation; 5178 bfd_boolean overflow = FALSE; 5179 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data); 5180 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2); 5181 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift; 5182 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max; 5183 bfd_vma check; 5184 bfd_signed_vma signed_check; 5185 5186 /* Need to refetch the addend, reconstruct the top three bits, and glue the 5187 two pieces together. */ 5188 if (globals->use_rel) 5189 { 5190 bfd_vma S = (upper_insn & 0x0400) >> 10; 5191 bfd_vma hi = (upper_insn & 0x03ff); 5192 bfd_vma I1 = (lower_insn & 0x2000) >> 13; 5193 bfd_vma I2 = (lower_insn & 0x0800) >> 11; 5194 bfd_vma lo = (lower_insn & 0x07ff); 5195 5196 I1 = !(I1 ^ S); 5197 I2 = !(I2 ^ S); 5198 S = !S; 5199 5200 signed_addend = (S << 24) | (I1 << 23) | (I2 << 22) | (hi << 12) | (lo << 1); 5201 signed_addend -= (1 << 24); /* Sign extend. */ 5202 } 5203 5204 /* ??? Should handle interworking? GCC might someday try to 5205 use this for tail calls. */ 5206 5207 relocation = value + signed_addend; 5208 relocation -= (input_section->output_section->vma 5209 + input_section->output_offset 5210 + rel->r_offset); 5211 5212 check = relocation >> howto->rightshift; 5213 5214 /* If this is a signed value, the rightshift just dropped 5215 leading 1 bits (assuming twos complement). */ 5216 if ((bfd_signed_vma) relocation >= 0) 5217 signed_check = check; 5218 else 5219 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift); 5220 5221 /* Assumes two's complement. */ 5222 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min) 5223 overflow = TRUE; 5224 5225 /* Put RELOCATION back into the insn. */ 5226 { 5227 bfd_vma S = (relocation & 0x01000000) >> 24; 5228 bfd_vma I1 = (relocation & 0x00800000) >> 23; 5229 bfd_vma I2 = (relocation & 0x00400000) >> 22; 5230 bfd_vma hi = (relocation & 0x003ff000) >> 12; 5231 bfd_vma lo = (relocation & 0x00000ffe) >> 1; 5232 5233 I1 = !(I1 ^ S); 5234 I2 = !(I2 ^ S); 5235 5236 upper_insn = (upper_insn & (bfd_vma) 0xf800) | (S << 10) | hi; 5237 lower_insn = (lower_insn & (bfd_vma) 0xd000) | (I1 << 13) | (I2 << 11) | lo; 5238 } 5239 5240 /* Put the relocated value back in the object file: */ 5241 bfd_put_16 (input_bfd, upper_insn, hit_data); 5242 bfd_put_16 (input_bfd, lower_insn, hit_data + 2); 5243 5244 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok); 5245 } 5246 5247 case R_ARM_THM_JUMP19: 5248 /* Thumb32 conditional branch instruction. */ 5249 { 5250 bfd_vma relocation; 5251 bfd_boolean overflow = FALSE; 5252 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data); 5253 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2); 5254 bfd_signed_vma reloc_signed_max = 0xffffe; 5255 bfd_signed_vma reloc_signed_min = -0x100000; 5256 bfd_signed_vma signed_check; 5257 5258 /* Need to refetch the addend, reconstruct the top three bits, 5259 and squish the two 11 bit pieces together. */ 5260 if (globals->use_rel) 5261 { 5262 bfd_vma S = (upper_insn & 0x0400) >> 10; 5263 bfd_vma upper = (upper_insn & 0x003f); 5264 bfd_vma J1 = (lower_insn & 0x2000) >> 13; 5265 bfd_vma J2 = (lower_insn & 0x0800) >> 11; 5266 bfd_vma lower = (lower_insn & 0x07ff); 5267 5268 upper |= J1 << 6; 5269 upper |= J2 << 7; 5270 upper |= (!S) << 8; 5271 upper -= 0x0100; /* Sign extend. */ 5272 5273 addend = (upper << 12) | (lower << 1); 5274 signed_addend = addend; 5275 } 5276 5277 /* ??? Should handle interworking? GCC might someday try to 5278 use this for tail calls. */ 5279 5280 relocation = value + signed_addend; 5281 relocation -= (input_section->output_section->vma 5282 + input_section->output_offset 5283 + rel->r_offset); 5284 signed_check = (bfd_signed_vma) relocation; 5285 5286 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min) 5287 overflow = TRUE; 5288 5289 /* Put RELOCATION back into the insn. */ 5290 { 5291 bfd_vma S = (relocation & 0x00100000) >> 20; 5292 bfd_vma J2 = (relocation & 0x00080000) >> 19; 5293 bfd_vma J1 = (relocation & 0x00040000) >> 18; 5294 bfd_vma hi = (relocation & 0x0003f000) >> 12; 5295 bfd_vma lo = (relocation & 0x00000ffe) >> 1; 5296 5297 upper_insn = (upper_insn & 0xfbc0) | (S << 10) | hi; 5298 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo; 5299 } 5300 5301 /* Put the relocated value back in the object file: */ 5302 bfd_put_16 (input_bfd, upper_insn, hit_data); 5303 bfd_put_16 (input_bfd, lower_insn, hit_data + 2); 5304 5305 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok); 5306 } 5307 5308 case R_ARM_THM_JUMP11: 5309 case R_ARM_THM_JUMP8: 5310 case R_ARM_THM_JUMP6: 5311 /* Thumb B (branch) instruction). */ 5312 { 5313 bfd_signed_vma relocation; 5314 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1; 5315 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max; 5316 bfd_signed_vma signed_check; 5317 5318 /* CZB cannot jump backward. */ 5319 if (r_type == R_ARM_THM_JUMP6) 5320 reloc_signed_min = 0; 5321 5322 if (globals->use_rel) 5323 { 5324 /* Need to refetch addend. */ 5325 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask; 5326 if (addend & ((howto->src_mask + 1) >> 1)) 5327 { 5328 signed_addend = -1; 5329 signed_addend &= ~ howto->src_mask; 5330 signed_addend |= addend; 5331 } 5332 else 5333 signed_addend = addend; 5334 /* The value in the insn has been right shifted. We need to 5335 undo this, so that we can perform the address calculation 5336 in terms of bytes. */ 5337 signed_addend <<= howto->rightshift; 5338 } 5339 relocation = value + signed_addend; 5340 5341 relocation -= (input_section->output_section->vma 5342 + input_section->output_offset 5343 + rel->r_offset); 5344 5345 relocation >>= howto->rightshift; 5346 signed_check = relocation; 5347 5348 if (r_type == R_ARM_THM_JUMP6) 5349 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3); 5350 else 5351 relocation &= howto->dst_mask; 5352 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask)); 5353 5354 bfd_put_16 (input_bfd, relocation, hit_data); 5355 5356 /* Assumes two's complement. */ 5357 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min) 5358 return bfd_reloc_overflow; 5359 5360 return bfd_reloc_ok; 5361 } 5362 5363 case R_ARM_ALU_PCREL7_0: 5364 case R_ARM_ALU_PCREL15_8: 5365 case R_ARM_ALU_PCREL23_15: 5366 { 5367 bfd_vma insn; 5368 bfd_vma relocation; 5369 5370 insn = bfd_get_32 (input_bfd, hit_data); 5371 if (globals->use_rel) 5372 { 5373 /* Extract the addend. */ 5374 addend = (insn & 0xff) << ((insn & 0xf00) >> 7); 5375 signed_addend = addend; 5376 } 5377 relocation = value + signed_addend; 5378 5379 relocation -= (input_section->output_section->vma 5380 + input_section->output_offset 5381 + rel->r_offset); 5382 insn = (insn & ~0xfff) 5383 | ((howto->bitpos << 7) & 0xf00) 5384 | ((relocation >> howto->bitpos) & 0xff); 5385 bfd_put_32 (input_bfd, value, hit_data); 5386 } 5387 return bfd_reloc_ok; 5388 5389 case R_ARM_GNU_VTINHERIT: 5390 case R_ARM_GNU_VTENTRY: 5391 return bfd_reloc_ok; 5392 5393 case R_ARM_GOTOFF32: 5394 /* Relocation is relative to the start of the 5395 global offset table. */ 5396 5397 BFD_ASSERT (sgot != NULL); 5398 if (sgot == NULL) 5399 return bfd_reloc_notsupported; 5400 5401 /* If we are addressing a Thumb function, we need to adjust the 5402 address by one, so that attempts to call the function pointer will 5403 correctly interpret it as Thumb code. */ 5404 if (sym_flags == STT_ARM_TFUNC) 5405 value += 1; 5406 5407 /* Note that sgot->output_offset is not involved in this 5408 calculation. We always want the start of .got. If we 5409 define _GLOBAL_OFFSET_TABLE in a different way, as is 5410 permitted by the ABI, we might have to change this 5411 calculation. */ 5412 value -= sgot->output_section->vma; 5413 return _bfd_final_link_relocate (howto, input_bfd, input_section, 5414 contents, rel->r_offset, value, 5415 rel->r_addend); 5416 5417 case R_ARM_GOTPC: 5418 /* Use global offset table as symbol value. */ 5419 BFD_ASSERT (sgot != NULL); 5420 5421 if (sgot == NULL) 5422 return bfd_reloc_notsupported; 5423 5424 *unresolved_reloc_p = FALSE; 5425 value = sgot->output_section->vma; 5426 return _bfd_final_link_relocate (howto, input_bfd, input_section, 5427 contents, rel->r_offset, value, 5428 rel->r_addend); 5429 5430 case R_ARM_GOT32: 5431 case R_ARM_GOT_PREL: 5432 /* Relocation is to the entry for this symbol in the 5433 global offset table. */ 5434 if (sgot == NULL) 5435 return bfd_reloc_notsupported; 5436 5437 if (h != NULL) 5438 { 5439 bfd_vma off; 5440 bfd_boolean dyn; 5441 5442 off = h->got.offset; 5443 BFD_ASSERT (off != (bfd_vma) -1); 5444 dyn = globals->root.dynamic_sections_created; 5445 5446 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 5447 || (info->shared 5448 && SYMBOL_REFERENCES_LOCAL (info, h)) 5449 || (ELF_ST_VISIBILITY (h->other) 5450 && h->root.type == bfd_link_hash_undefweak)) 5451 { 5452 /* This is actually a static link, or it is a -Bsymbolic link 5453 and the symbol is defined locally. We must initialize this 5454 entry in the global offset table. Since the offset must 5455 always be a multiple of 4, we use the least significant bit 5456 to record whether we have initialized it already. 5457 5458 When doing a dynamic link, we create a .rel(a).got relocation 5459 entry to initialize the value. This is done in the 5460 finish_dynamic_symbol routine. */ 5461 if ((off & 1) != 0) 5462 off &= ~1; 5463 else 5464 { 5465 /* If we are addressing a Thumb function, we need to 5466 adjust the address by one, so that attempts to 5467 call the function pointer will correctly 5468 interpret it as Thumb code. */ 5469 if (sym_flags == STT_ARM_TFUNC) 5470 value |= 1; 5471 5472 bfd_put_32 (output_bfd, value, sgot->contents + off); 5473 h->got.offset |= 1; 5474 } 5475 } 5476 else 5477 *unresolved_reloc_p = FALSE; 5478 5479 value = sgot->output_offset + off; 5480 } 5481 else 5482 { 5483 bfd_vma off; 5484 5485 BFD_ASSERT (local_got_offsets != NULL && 5486 local_got_offsets[r_symndx] != (bfd_vma) -1); 5487 5488 off = local_got_offsets[r_symndx]; 5489 5490 /* The offset must always be a multiple of 4. We use the 5491 least significant bit to record whether we have already 5492 generated the necessary reloc. */ 5493 if ((off & 1) != 0) 5494 off &= ~1; 5495 else 5496 { 5497 /* If we are addressing a Thumb function, we need to 5498 adjust the address by one, so that attempts to 5499 call the function pointer will correctly 5500 interpret it as Thumb code. */ 5501 if (sym_flags == STT_ARM_TFUNC) 5502 value |= 1; 5503 5504 if (globals->use_rel) 5505 bfd_put_32 (output_bfd, value, sgot->contents + off); 5506 5507 if (info->shared) 5508 { 5509 asection * srelgot; 5510 Elf_Internal_Rela outrel; 5511 bfd_byte *loc; 5512 5513 srelgot = (bfd_get_section_by_name 5514 (dynobj, RELOC_SECTION (globals, ".got"))); 5515 BFD_ASSERT (srelgot != NULL); 5516 5517 outrel.r_addend = addend + value; 5518 outrel.r_offset = (sgot->output_section->vma 5519 + sgot->output_offset 5520 + off); 5521 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); 5522 loc = srelgot->contents; 5523 loc += srelgot->reloc_count++ * RELOC_SIZE (globals); 5524 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc); 5525 } 5526 5527 local_got_offsets[r_symndx] |= 1; 5528 } 5529 5530 value = sgot->output_offset + off; 5531 } 5532 if (r_type != R_ARM_GOT32) 5533 value += sgot->output_section->vma; 5534 5535 return _bfd_final_link_relocate (howto, input_bfd, input_section, 5536 contents, rel->r_offset, value, 5537 rel->r_addend); 5538 5539 case R_ARM_TLS_LDO32: 5540 value = value - dtpoff_base (info); 5541 5542 return _bfd_final_link_relocate (howto, input_bfd, input_section, 5543 contents, rel->r_offset, value, 5544 rel->r_addend); 5545 5546 case R_ARM_TLS_LDM32: 5547 { 5548 bfd_vma off; 5549 5550 if (globals->sgot == NULL) 5551 abort (); 5552 5553 off = globals->tls_ldm_got.offset; 5554 5555 if ((off & 1) != 0) 5556 off &= ~1; 5557 else 5558 { 5559 /* If we don't know the module number, create a relocation 5560 for it. */ 5561 if (info->shared) 5562 { 5563 Elf_Internal_Rela outrel; 5564 bfd_byte *loc; 5565 5566 if (globals->srelgot == NULL) 5567 abort (); 5568 5569 outrel.r_addend = 0; 5570 outrel.r_offset = (globals->sgot->output_section->vma 5571 + globals->sgot->output_offset + off); 5572 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32); 5573 5574 if (globals->use_rel) 5575 bfd_put_32 (output_bfd, outrel.r_addend, 5576 globals->sgot->contents + off); 5577 5578 loc = globals->srelgot->contents; 5579 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals); 5580 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc); 5581 } 5582 else 5583 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off); 5584 5585 globals->tls_ldm_got.offset |= 1; 5586 } 5587 5588 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off 5589 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset); 5590 5591 return _bfd_final_link_relocate (howto, input_bfd, input_section, 5592 contents, rel->r_offset, value, 5593 rel->r_addend); 5594 } 5595 5596 case R_ARM_TLS_GD32: 5597 case R_ARM_TLS_IE32: 5598 { 5599 bfd_vma off; 5600 int indx; 5601 char tls_type; 5602 5603 if (globals->sgot == NULL) 5604 abort (); 5605 5606 indx = 0; 5607 if (h != NULL) 5608 { 5609 bfd_boolean dyn; 5610 dyn = globals->root.dynamic_sections_created; 5611 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 5612 && (!info->shared 5613 || !SYMBOL_REFERENCES_LOCAL (info, h))) 5614 { 5615 *unresolved_reloc_p = FALSE; 5616 indx = h->dynindx; 5617 } 5618 off = h->got.offset; 5619 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type; 5620 } 5621 else 5622 { 5623 if (local_got_offsets == NULL) 5624 abort (); 5625 off = local_got_offsets[r_symndx]; 5626 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx]; 5627 } 5628 5629 if (tls_type == GOT_UNKNOWN) 5630 abort (); 5631 5632 if ((off & 1) != 0) 5633 off &= ~1; 5634 else 5635 { 5636 bfd_boolean need_relocs = FALSE; 5637 Elf_Internal_Rela outrel; 5638 bfd_byte *loc = NULL; 5639 int cur_off = off; 5640 5641 /* The GOT entries have not been initialized yet. Do it 5642 now, and emit any relocations. If both an IE GOT and a 5643 GD GOT are necessary, we emit the GD first. */ 5644 5645 if ((info->shared || indx != 0) 5646 && (h == NULL 5647 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 5648 || h->root.type != bfd_link_hash_undefweak)) 5649 { 5650 need_relocs = TRUE; 5651 if (globals->srelgot == NULL) 5652 abort (); 5653 loc = globals->srelgot->contents; 5654 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals); 5655 } 5656 5657 if (tls_type & GOT_TLS_GD) 5658 { 5659 if (need_relocs) 5660 { 5661 outrel.r_addend = 0; 5662 outrel.r_offset = (globals->sgot->output_section->vma 5663 + globals->sgot->output_offset 5664 + cur_off); 5665 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32); 5666 5667 if (globals->use_rel) 5668 bfd_put_32 (output_bfd, outrel.r_addend, 5669 globals->sgot->contents + cur_off); 5670 5671 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc); 5672 globals->srelgot->reloc_count++; 5673 loc += RELOC_SIZE (globals); 5674 5675 if (indx == 0) 5676 bfd_put_32 (output_bfd, value - dtpoff_base (info), 5677 globals->sgot->contents + cur_off + 4); 5678 else 5679 { 5680 outrel.r_addend = 0; 5681 outrel.r_info = ELF32_R_INFO (indx, 5682 R_ARM_TLS_DTPOFF32); 5683 outrel.r_offset += 4; 5684 5685 if (globals->use_rel) 5686 bfd_put_32 (output_bfd, outrel.r_addend, 5687 globals->sgot->contents + cur_off + 4); 5688 5689 5690 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc); 5691 globals->srelgot->reloc_count++; 5692 loc += RELOC_SIZE (globals); 5693 } 5694 } 5695 else 5696 { 5697 /* If we are not emitting relocations for a 5698 general dynamic reference, then we must be in a 5699 static link or an executable link with the 5700 symbol binding locally. Mark it as belonging 5701 to module 1, the executable. */ 5702 bfd_put_32 (output_bfd, 1, 5703 globals->sgot->contents + cur_off); 5704 bfd_put_32 (output_bfd, value - dtpoff_base (info), 5705 globals->sgot->contents + cur_off + 4); 5706 } 5707 5708 cur_off += 8; 5709 } 5710 5711 if (tls_type & GOT_TLS_IE) 5712 { 5713 if (need_relocs) 5714 { 5715 if (indx == 0) 5716 outrel.r_addend = value - dtpoff_base (info); 5717 else 5718 outrel.r_addend = 0; 5719 outrel.r_offset = (globals->sgot->output_section->vma 5720 + globals->sgot->output_offset 5721 + cur_off); 5722 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32); 5723 5724 if (globals->use_rel) 5725 bfd_put_32 (output_bfd, outrel.r_addend, 5726 globals->sgot->contents + cur_off); 5727 5728 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc); 5729 globals->srelgot->reloc_count++; 5730 loc += RELOC_SIZE (globals); 5731 } 5732 else 5733 bfd_put_32 (output_bfd, tpoff (info, value), 5734 globals->sgot->contents + cur_off); 5735 cur_off += 4; 5736 } 5737 5738 if (h != NULL) 5739 h->got.offset |= 1; 5740 else 5741 local_got_offsets[r_symndx] |= 1; 5742 } 5743 5744 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32) 5745 off += 8; 5746 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off 5747 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset); 5748 5749 return _bfd_final_link_relocate (howto, input_bfd, input_section, 5750 contents, rel->r_offset, value, 5751 rel->r_addend); 5752 } 5753 5754 case R_ARM_TLS_LE32: 5755 if (info->shared) 5756 { 5757 (*_bfd_error_handler) 5758 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"), 5759 input_bfd, input_section, 5760 (long) rel->r_offset, howto->name); 5761 return FALSE; 5762 } 5763 else 5764 value = tpoff (info, value); 5765 5766 return _bfd_final_link_relocate (howto, input_bfd, input_section, 5767 contents, rel->r_offset, value, 5768 rel->r_addend); 5769 5770 case R_ARM_V4BX: 5771 if (globals->fix_v4bx) 5772 { 5773 bfd_vma insn = bfd_get_32 (input_bfd, hit_data); 5774 5775 /* Ensure that we have a BX instruction. */ 5776 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10); 5777 5778 /* Preserve Rm (lowest four bits) and the condition code 5779 (highest four bits). Other bits encode MOV PC,Rm. */ 5780 insn = (insn & 0xf000000f) | 0x01a0f000; 5781 5782 bfd_put_32 (input_bfd, insn, hit_data); 5783 } 5784 return bfd_reloc_ok; 5785 5786 case R_ARM_MOVW_ABS_NC: 5787 case R_ARM_MOVT_ABS: 5788 case R_ARM_MOVW_PREL_NC: 5789 case R_ARM_MOVT_PREL: 5790 /* Until we properly support segment-base-relative addressing then 5791 we assume the segment base to be zero, as for the group relocations. 5792 Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC 5793 and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS. */ 5794 case R_ARM_MOVW_BREL_NC: 5795 case R_ARM_MOVW_BREL: 5796 case R_ARM_MOVT_BREL: 5797 { 5798 bfd_vma insn = bfd_get_32 (input_bfd, hit_data); 5799 5800 if (globals->use_rel) 5801 { 5802 addend = ((insn >> 4) & 0xf000) | (insn & 0xfff); 5803 signed_addend = (addend ^ 0x10000) - 0x10000; 5804 } 5805 5806 value += signed_addend; 5807 5808 if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL) 5809 value -= (input_section->output_section->vma 5810 + input_section->output_offset + rel->r_offset); 5811 5812 if (r_type == R_ARM_MOVW_BREL && value >= 0x10000) 5813 return bfd_reloc_overflow; 5814 5815 if (sym_flags == STT_ARM_TFUNC) 5816 value |= 1; 5817 5818 if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL 5819 || r_type == R_ARM_MOVT_BREL) 5820 value >>= 16; 5821 5822 insn &= 0xfff0f000; 5823 insn |= value & 0xfff; 5824 insn |= (value & 0xf000) << 4; 5825 bfd_put_32 (input_bfd, insn, hit_data); 5826 } 5827 return bfd_reloc_ok; 5828 5829 case R_ARM_THM_MOVW_ABS_NC: 5830 case R_ARM_THM_MOVT_ABS: 5831 case R_ARM_THM_MOVW_PREL_NC: 5832 case R_ARM_THM_MOVT_PREL: 5833 /* Until we properly support segment-base-relative addressing then 5834 we assume the segment base to be zero, as for the above relocations. 5835 Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as 5836 R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics 5837 as R_ARM_THM_MOVT_ABS. */ 5838 case R_ARM_THM_MOVW_BREL_NC: 5839 case R_ARM_THM_MOVW_BREL: 5840 case R_ARM_THM_MOVT_BREL: 5841 { 5842 bfd_vma insn; 5843 5844 insn = bfd_get_16 (input_bfd, hit_data) << 16; 5845 insn |= bfd_get_16 (input_bfd, hit_data + 2); 5846 5847 if (globals->use_rel) 5848 { 5849 addend = ((insn >> 4) & 0xf000) 5850 | ((insn >> 15) & 0x0800) 5851 | ((insn >> 4) & 0x0700) 5852 | (insn & 0x00ff); 5853 signed_addend = (addend ^ 0x10000) - 0x10000; 5854 } 5855 5856 value += signed_addend; 5857 5858 if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL) 5859 value -= (input_section->output_section->vma 5860 + input_section->output_offset + rel->r_offset); 5861 5862 if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000) 5863 return bfd_reloc_overflow; 5864 5865 if (sym_flags == STT_ARM_TFUNC) 5866 value |= 1; 5867 5868 if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL 5869 || r_type == R_ARM_THM_MOVT_BREL) 5870 value >>= 16; 5871 5872 insn &= 0xfbf08f00; 5873 insn |= (value & 0xf000) << 4; 5874 insn |= (value & 0x0800) << 15; 5875 insn |= (value & 0x0700) << 4; 5876 insn |= (value & 0x00ff); 5877 5878 bfd_put_16 (input_bfd, insn >> 16, hit_data); 5879 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2); 5880 } 5881 return bfd_reloc_ok; 5882 5883 case R_ARM_ALU_PC_G0_NC: 5884 case R_ARM_ALU_PC_G1_NC: 5885 case R_ARM_ALU_PC_G0: 5886 case R_ARM_ALU_PC_G1: 5887 case R_ARM_ALU_PC_G2: 5888 case R_ARM_ALU_SB_G0_NC: 5889 case R_ARM_ALU_SB_G1_NC: 5890 case R_ARM_ALU_SB_G0: 5891 case R_ARM_ALU_SB_G1: 5892 case R_ARM_ALU_SB_G2: 5893 { 5894 bfd_vma insn = bfd_get_32 (input_bfd, hit_data); 5895 bfd_vma pc = input_section->output_section->vma 5896 + input_section->output_offset + rel->r_offset; 5897 /* sb should be the origin of the *segment* containing the symbol. 5898 It is not clear how to obtain this OS-dependent value, so we 5899 make an arbitrary choice of zero. */ 5900 bfd_vma sb = 0; 5901 bfd_vma residual; 5902 bfd_vma g_n; 5903 bfd_signed_vma signed_value; 5904 int group = 0; 5905 5906 /* Determine which group of bits to select. */ 5907 switch (r_type) 5908 { 5909 case R_ARM_ALU_PC_G0_NC: 5910 case R_ARM_ALU_PC_G0: 5911 case R_ARM_ALU_SB_G0_NC: 5912 case R_ARM_ALU_SB_G0: 5913 group = 0; 5914 break; 5915 5916 case R_ARM_ALU_PC_G1_NC: 5917 case R_ARM_ALU_PC_G1: 5918 case R_ARM_ALU_SB_G1_NC: 5919 case R_ARM_ALU_SB_G1: 5920 group = 1; 5921 break; 5922 5923 case R_ARM_ALU_PC_G2: 5924 case R_ARM_ALU_SB_G2: 5925 group = 2; 5926 break; 5927 5928 default: 5929 abort(); 5930 } 5931 5932 /* If REL, extract the addend from the insn. If RELA, it will 5933 have already been fetched for us. */ 5934 if (globals->use_rel) 5935 { 5936 int negative; 5937 bfd_vma constant = insn & 0xff; 5938 bfd_vma rotation = (insn & 0xf00) >> 8; 5939 5940 if (rotation == 0) 5941 signed_addend = constant; 5942 else 5943 { 5944 /* Compensate for the fact that in the instruction, the 5945 rotation is stored in multiples of 2 bits. */ 5946 rotation *= 2; 5947 5948 /* Rotate "constant" right by "rotation" bits. */ 5949 signed_addend = (constant >> rotation) | 5950 (constant << (8 * sizeof (bfd_vma) - rotation)); 5951 } 5952 5953 /* Determine if the instruction is an ADD or a SUB. 5954 (For REL, this determines the sign of the addend.) */ 5955 negative = identify_add_or_sub (insn); 5956 if (negative == 0) 5957 { 5958 (*_bfd_error_handler) 5959 (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"), 5960 input_bfd, input_section, 5961 (long) rel->r_offset, howto->name); 5962 return bfd_reloc_overflow; 5963 } 5964 5965 signed_addend *= negative; 5966 } 5967 5968 /* Compute the value (X) to go in the place. */ 5969 if (r_type == R_ARM_ALU_PC_G0_NC 5970 || r_type == R_ARM_ALU_PC_G1_NC 5971 || r_type == R_ARM_ALU_PC_G0 5972 || r_type == R_ARM_ALU_PC_G1 5973 || r_type == R_ARM_ALU_PC_G2) 5974 /* PC relative. */ 5975 signed_value = value - pc + signed_addend; 5976 else 5977 /* Section base relative. */ 5978 signed_value = value - sb + signed_addend; 5979 5980 /* If the target symbol is a Thumb function, then set the 5981 Thumb bit in the address. */ 5982 if (sym_flags == STT_ARM_TFUNC) 5983 signed_value |= 1; 5984 5985 /* Calculate the value of the relevant G_n, in encoded 5986 constant-with-rotation format. */ 5987 g_n = calculate_group_reloc_mask (abs (signed_value), group, 5988 &residual); 5989 5990 /* Check for overflow if required. */ 5991 if ((r_type == R_ARM_ALU_PC_G0 5992 || r_type == R_ARM_ALU_PC_G1 5993 || r_type == R_ARM_ALU_PC_G2 5994 || r_type == R_ARM_ALU_SB_G0 5995 || r_type == R_ARM_ALU_SB_G1 5996 || r_type == R_ARM_ALU_SB_G2) && residual != 0) 5997 { 5998 (*_bfd_error_handler) 5999 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"), 6000 input_bfd, input_section, 6001 (long) rel->r_offset, abs (signed_value), howto->name); 6002 return bfd_reloc_overflow; 6003 } 6004 6005 /* Mask out the value and the ADD/SUB part of the opcode; take care 6006 not to destroy the S bit. */ 6007 insn &= 0xff1ff000; 6008 6009 /* Set the opcode according to whether the value to go in the 6010 place is negative. */ 6011 if (signed_value < 0) 6012 insn |= 1 << 22; 6013 else 6014 insn |= 1 << 23; 6015 6016 /* Encode the offset. */ 6017 insn |= g_n; 6018 6019 bfd_put_32 (input_bfd, insn, hit_data); 6020 } 6021 return bfd_reloc_ok; 6022 6023 case R_ARM_LDR_PC_G0: 6024 case R_ARM_LDR_PC_G1: 6025 case R_ARM_LDR_PC_G2: 6026 case R_ARM_LDR_SB_G0: 6027 case R_ARM_LDR_SB_G1: 6028 case R_ARM_LDR_SB_G2: 6029 { 6030 bfd_vma insn = bfd_get_32 (input_bfd, hit_data); 6031 bfd_vma pc = input_section->output_section->vma 6032 + input_section->output_offset + rel->r_offset; 6033 bfd_vma sb = 0; /* See note above. */ 6034 bfd_vma residual; 6035 bfd_signed_vma signed_value; 6036 int group = 0; 6037 6038 /* Determine which groups of bits to calculate. */ 6039 switch (r_type) 6040 { 6041 case R_ARM_LDR_PC_G0: 6042 case R_ARM_LDR_SB_G0: 6043 group = 0; 6044 break; 6045 6046 case R_ARM_LDR_PC_G1: 6047 case R_ARM_LDR_SB_G1: 6048 group = 1; 6049 break; 6050 6051 case R_ARM_LDR_PC_G2: 6052 case R_ARM_LDR_SB_G2: 6053 group = 2; 6054 break; 6055 6056 default: 6057 abort(); 6058 } 6059 6060 /* If REL, extract the addend from the insn. If RELA, it will 6061 have already been fetched for us. */ 6062 if (globals->use_rel) 6063 { 6064 int negative = (insn & (1 << 23)) ? 1 : -1; 6065 signed_addend = negative * (insn & 0xfff); 6066 } 6067 6068 /* Compute the value (X) to go in the place. */ 6069 if (r_type == R_ARM_LDR_PC_G0 6070 || r_type == R_ARM_LDR_PC_G1 6071 || r_type == R_ARM_LDR_PC_G2) 6072 /* PC relative. */ 6073 signed_value = value - pc + signed_addend; 6074 else 6075 /* Section base relative. */ 6076 signed_value = value - sb + signed_addend; 6077 6078 /* Calculate the value of the relevant G_{n-1} to obtain 6079 the residual at that stage. */ 6080 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual); 6081 6082 /* Check for overflow. */ 6083 if (residual >= 0x1000) 6084 { 6085 (*_bfd_error_handler) 6086 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"), 6087 input_bfd, input_section, 6088 (long) rel->r_offset, abs (signed_value), howto->name); 6089 return bfd_reloc_overflow; 6090 } 6091 6092 /* Mask out the value and U bit. */ 6093 insn &= 0xff7ff000; 6094 6095 /* Set the U bit if the value to go in the place is non-negative. */ 6096 if (signed_value >= 0) 6097 insn |= 1 << 23; 6098 6099 /* Encode the offset. */ 6100 insn |= residual; 6101 6102 bfd_put_32 (input_bfd, insn, hit_data); 6103 } 6104 return bfd_reloc_ok; 6105 6106 case R_ARM_LDRS_PC_G0: 6107 case R_ARM_LDRS_PC_G1: 6108 case R_ARM_LDRS_PC_G2: 6109 case R_ARM_LDRS_SB_G0: 6110 case R_ARM_LDRS_SB_G1: 6111 case R_ARM_LDRS_SB_G2: 6112 { 6113 bfd_vma insn = bfd_get_32 (input_bfd, hit_data); 6114 bfd_vma pc = input_section->output_section->vma 6115 + input_section->output_offset + rel->r_offset; 6116 bfd_vma sb = 0; /* See note above. */ 6117 bfd_vma residual; 6118 bfd_signed_vma signed_value; 6119 int group = 0; 6120 6121 /* Determine which groups of bits to calculate. */ 6122 switch (r_type) 6123 { 6124 case R_ARM_LDRS_PC_G0: 6125 case R_ARM_LDRS_SB_G0: 6126 group = 0; 6127 break; 6128 6129 case R_ARM_LDRS_PC_G1: 6130 case R_ARM_LDRS_SB_G1: 6131 group = 1; 6132 break; 6133 6134 case R_ARM_LDRS_PC_G2: 6135 case R_ARM_LDRS_SB_G2: 6136 group = 2; 6137 break; 6138 6139 default: 6140 abort(); 6141 } 6142 6143 /* If REL, extract the addend from the insn. If RELA, it will 6144 have already been fetched for us. */ 6145 if (globals->use_rel) 6146 { 6147 int negative = (insn & (1 << 23)) ? 1 : -1; 6148 signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf)); 6149 } 6150 6151 /* Compute the value (X) to go in the place. */ 6152 if (r_type == R_ARM_LDRS_PC_G0 6153 || r_type == R_ARM_LDRS_PC_G1 6154 || r_type == R_ARM_LDRS_PC_G2) 6155 /* PC relative. */ 6156 signed_value = value - pc + signed_addend; 6157 else 6158 /* Section base relative. */ 6159 signed_value = value - sb + signed_addend; 6160 6161 /* Calculate the value of the relevant G_{n-1} to obtain 6162 the residual at that stage. */ 6163 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual); 6164 6165 /* Check for overflow. */ 6166 if (residual >= 0x100) 6167 { 6168 (*_bfd_error_handler) 6169 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"), 6170 input_bfd, input_section, 6171 (long) rel->r_offset, abs (signed_value), howto->name); 6172 return bfd_reloc_overflow; 6173 } 6174 6175 /* Mask out the value and U bit. */ 6176 insn &= 0xff7ff0f0; 6177 6178 /* Set the U bit if the value to go in the place is non-negative. */ 6179 if (signed_value >= 0) 6180 insn |= 1 << 23; 6181 6182 /* Encode the offset. */ 6183 insn |= ((residual & 0xf0) << 4) | (residual & 0xf); 6184 6185 bfd_put_32 (input_bfd, insn, hit_data); 6186 } 6187 return bfd_reloc_ok; 6188 6189 case R_ARM_LDC_PC_G0: 6190 case R_ARM_LDC_PC_G1: 6191 case R_ARM_LDC_PC_G2: 6192 case R_ARM_LDC_SB_G0: 6193 case R_ARM_LDC_SB_G1: 6194 case R_ARM_LDC_SB_G2: 6195 { 6196 bfd_vma insn = bfd_get_32 (input_bfd, hit_data); 6197 bfd_vma pc = input_section->output_section->vma 6198 + input_section->output_offset + rel->r_offset; 6199 bfd_vma sb = 0; /* See note above. */ 6200 bfd_vma residual; 6201 bfd_signed_vma signed_value; 6202 int group = 0; 6203 6204 /* Determine which groups of bits to calculate. */ 6205 switch (r_type) 6206 { 6207 case R_ARM_LDC_PC_G0: 6208 case R_ARM_LDC_SB_G0: 6209 group = 0; 6210 break; 6211 6212 case R_ARM_LDC_PC_G1: 6213 case R_ARM_LDC_SB_G1: 6214 group = 1; 6215 break; 6216 6217 case R_ARM_LDC_PC_G2: 6218 case R_ARM_LDC_SB_G2: 6219 group = 2; 6220 break; 6221 6222 default: 6223 abort(); 6224 } 6225 6226 /* If REL, extract the addend from the insn. If RELA, it will 6227 have already been fetched for us. */ 6228 if (globals->use_rel) 6229 { 6230 int negative = (insn & (1 << 23)) ? 1 : -1; 6231 signed_addend = negative * ((insn & 0xff) << 2); 6232 } 6233 6234 /* Compute the value (X) to go in the place. */ 6235 if (r_type == R_ARM_LDC_PC_G0 6236 || r_type == R_ARM_LDC_PC_G1 6237 || r_type == R_ARM_LDC_PC_G2) 6238 /* PC relative. */ 6239 signed_value = value - pc + signed_addend; 6240 else 6241 /* Section base relative. */ 6242 signed_value = value - sb + signed_addend; 6243 6244 /* Calculate the value of the relevant G_{n-1} to obtain 6245 the residual at that stage. */ 6246 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual); 6247 6248 /* Check for overflow. (The absolute value to go in the place must be 6249 divisible by four and, after having been divided by four, must 6250 fit in eight bits.) */ 6251 if ((residual & 0x3) != 0 || residual >= 0x400) 6252 { 6253 (*_bfd_error_handler) 6254 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"), 6255 input_bfd, input_section, 6256 (long) rel->r_offset, abs (signed_value), howto->name); 6257 return bfd_reloc_overflow; 6258 } 6259 6260 /* Mask out the value and U bit. */ 6261 insn &= 0xff7fff00; 6262 6263 /* Set the U bit if the value to go in the place is non-negative. */ 6264 if (signed_value >= 0) 6265 insn |= 1 << 23; 6266 6267 /* Encode the offset. */ 6268 insn |= residual >> 2; 6269 6270 bfd_put_32 (input_bfd, insn, hit_data); 6271 } 6272 return bfd_reloc_ok; 6273 6274 default: 6275 return bfd_reloc_notsupported; 6276 } 6277} 6278 6279/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */ 6280static void 6281arm_add_to_rel (bfd * abfd, 6282 bfd_byte * address, 6283 reloc_howto_type * howto, 6284 bfd_signed_vma increment) 6285{ 6286 bfd_signed_vma addend; 6287 6288 if (howto->type == R_ARM_THM_CALL) 6289 { 6290 int upper_insn, lower_insn; 6291 int upper, lower; 6292 6293 upper_insn = bfd_get_16 (abfd, address); 6294 lower_insn = bfd_get_16 (abfd, address + 2); 6295 upper = upper_insn & 0x7ff; 6296 lower = lower_insn & 0x7ff; 6297 6298 addend = (upper << 12) | (lower << 1); 6299 addend += increment; 6300 addend >>= 1; 6301 6302 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff); 6303 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff); 6304 6305 bfd_put_16 (abfd, (bfd_vma) upper_insn, address); 6306 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2); 6307 } 6308 else 6309 { 6310 bfd_vma contents; 6311 6312 contents = bfd_get_32 (abfd, address); 6313 6314 /* Get the (signed) value from the instruction. */ 6315 addend = contents & howto->src_mask; 6316 if (addend & ((howto->src_mask + 1) >> 1)) 6317 { 6318 bfd_signed_vma mask; 6319 6320 mask = -1; 6321 mask &= ~ howto->src_mask; 6322 addend |= mask; 6323 } 6324 6325 /* Add in the increment, (which is a byte value). */ 6326 switch (howto->type) 6327 { 6328 default: 6329 addend += increment; 6330 break; 6331 6332 case R_ARM_PC24: 6333 case R_ARM_PLT32: 6334 case R_ARM_CALL: 6335 case R_ARM_JUMP24: 6336 addend <<= howto->size; 6337 addend += increment; 6338 6339 /* Should we check for overflow here ? */ 6340 6341 /* Drop any undesired bits. */ 6342 addend >>= howto->rightshift; 6343 break; 6344 } 6345 6346 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask); 6347 6348 bfd_put_32 (abfd, contents, address); 6349 } 6350} 6351 6352#define IS_ARM_TLS_RELOC(R_TYPE) \ 6353 ((R_TYPE) == R_ARM_TLS_GD32 \ 6354 || (R_TYPE) == R_ARM_TLS_LDO32 \ 6355 || (R_TYPE) == R_ARM_TLS_LDM32 \ 6356 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \ 6357 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \ 6358 || (R_TYPE) == R_ARM_TLS_TPOFF32 \ 6359 || (R_TYPE) == R_ARM_TLS_LE32 \ 6360 || (R_TYPE) == R_ARM_TLS_IE32) 6361 6362/* Relocate an ARM ELF section. */ 6363static bfd_boolean 6364elf32_arm_relocate_section (bfd * output_bfd, 6365 struct bfd_link_info * info, 6366 bfd * input_bfd, 6367 asection * input_section, 6368 bfd_byte * contents, 6369 Elf_Internal_Rela * relocs, 6370 Elf_Internal_Sym * local_syms, 6371 asection ** local_sections) 6372{ 6373 Elf_Internal_Shdr *symtab_hdr; 6374 struct elf_link_hash_entry **sym_hashes; 6375 Elf_Internal_Rela *rel; 6376 Elf_Internal_Rela *relend; 6377 const char *name; 6378 struct elf32_arm_link_hash_table * globals; 6379 6380 globals = elf32_arm_hash_table (info); 6381 6382 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 6383 sym_hashes = elf_sym_hashes (input_bfd); 6384 6385 rel = relocs; 6386 relend = relocs + input_section->reloc_count; 6387 for (; rel < relend; rel++) 6388 { 6389 int r_type; 6390 reloc_howto_type * howto; 6391 unsigned long r_symndx; 6392 Elf_Internal_Sym * sym; 6393 asection * sec; 6394 struct elf_link_hash_entry * h; 6395 bfd_vma relocation; 6396 bfd_reloc_status_type r; 6397 arelent bfd_reloc; 6398 char sym_type; 6399 bfd_boolean unresolved_reloc = FALSE; 6400 char *error_message = NULL; 6401 6402 r_symndx = ELF32_R_SYM (rel->r_info); 6403 r_type = ELF32_R_TYPE (rel->r_info); 6404 r_type = arm_real_reloc_type (globals, r_type); 6405 6406 if ( r_type == R_ARM_GNU_VTENTRY 6407 || r_type == R_ARM_GNU_VTINHERIT) 6408 continue; 6409 6410 bfd_reloc.howto = elf32_arm_howto_from_type (r_type); 6411 howto = bfd_reloc.howto; 6412 6413 h = NULL; 6414 sym = NULL; 6415 sec = NULL; 6416 6417 if (r_symndx < symtab_hdr->sh_info) 6418 { 6419 sym = local_syms + r_symndx; 6420 sym_type = ELF32_ST_TYPE (sym->st_info); 6421 sec = local_sections[r_symndx]; 6422 if (globals->use_rel) 6423 { 6424 relocation = (sec->output_section->vma 6425 + sec->output_offset 6426 + sym->st_value); 6427 if (!info->relocatable 6428 && (sec->flags & SEC_MERGE) 6429 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 6430 { 6431 asection *msec; 6432 bfd_vma addend, value; 6433 6434 if (howto->rightshift) 6435 { 6436 (*_bfd_error_handler) 6437 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"), 6438 input_bfd, input_section, 6439 (long) rel->r_offset, howto->name); 6440 return FALSE; 6441 } 6442 6443 value = bfd_get_32 (input_bfd, contents + rel->r_offset); 6444 6445 /* Get the (signed) value from the instruction. */ 6446 addend = value & howto->src_mask; 6447 if (addend & ((howto->src_mask + 1) >> 1)) 6448 { 6449 bfd_signed_vma mask; 6450 6451 mask = -1; 6452 mask &= ~ howto->src_mask; 6453 addend |= mask; 6454 } 6455 msec = sec; 6456 addend = 6457 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) 6458 - relocation; 6459 addend += msec->output_section->vma + msec->output_offset; 6460 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask); 6461 bfd_put_32 (input_bfd, value, contents + rel->r_offset); 6462 } 6463 } 6464 else 6465 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 6466 } 6467 else 6468 { 6469 bfd_boolean warned; 6470 6471 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 6472 r_symndx, symtab_hdr, sym_hashes, 6473 h, sec, relocation, 6474 unresolved_reloc, warned); 6475 6476 sym_type = h->type; 6477 } 6478 6479 if (sec != NULL && elf_discarded_section (sec)) 6480 { 6481 /* For relocs against symbols from removed linkonce sections, 6482 or sections discarded by a linker script, we just want the 6483 section contents zeroed. Avoid any special processing. */ 6484 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset); 6485 rel->r_info = 0; 6486 rel->r_addend = 0; 6487 continue; 6488 } 6489 6490 if (info->relocatable) 6491 { 6492 /* This is a relocatable link. We don't have to change 6493 anything, unless the reloc is against a section symbol, 6494 in which case we have to adjust according to where the 6495 section symbol winds up in the output section. */ 6496 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 6497 { 6498 if (globals->use_rel) 6499 arm_add_to_rel (input_bfd, contents + rel->r_offset, 6500 howto, (bfd_signed_vma) sec->output_offset); 6501 else 6502 rel->r_addend += sec->output_offset; 6503 } 6504 continue; 6505 } 6506 6507 if (h != NULL) 6508 name = h->root.root.string; 6509 else 6510 { 6511 name = (bfd_elf_string_from_elf_section 6512 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 6513 if (name == NULL || *name == '\0') 6514 name = bfd_section_name (input_bfd, sec); 6515 } 6516 6517 if (r_symndx != 0 6518 && r_type != R_ARM_NONE 6519 && (h == NULL 6520 || h->root.type == bfd_link_hash_defined 6521 || h->root.type == bfd_link_hash_defweak) 6522 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS)) 6523 { 6524 (*_bfd_error_handler) 6525 ((sym_type == STT_TLS 6526 ? _("%B(%A+0x%lx): %s used with TLS symbol %s") 6527 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")), 6528 input_bfd, 6529 input_section, 6530 (long) rel->r_offset, 6531 howto->name, 6532 name); 6533 } 6534 6535 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd, 6536 input_section, contents, rel, 6537 relocation, info, sec, name, 6538 (h ? ELF_ST_TYPE (h->type) : 6539 ELF_ST_TYPE (sym->st_info)), h, 6540 &unresolved_reloc, &error_message); 6541 6542 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 6543 because such sections are not SEC_ALLOC and thus ld.so will 6544 not process them. */ 6545 if (unresolved_reloc 6546 && !((input_section->flags & SEC_DEBUGGING) != 0 6547 && h->def_dynamic)) 6548 { 6549 (*_bfd_error_handler) 6550 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 6551 input_bfd, 6552 input_section, 6553 (long) rel->r_offset, 6554 howto->name, 6555 h->root.root.string); 6556 return FALSE; 6557 } 6558 6559 if (r != bfd_reloc_ok) 6560 { 6561 switch (r) 6562 { 6563 case bfd_reloc_overflow: 6564 /* If the overflowing reloc was to an undefined symbol, 6565 we have already printed one error message and there 6566 is no point complaining again. */ 6567 if ((! h || 6568 h->root.type != bfd_link_hash_undefined) 6569 && (!((*info->callbacks->reloc_overflow) 6570 (info, (h ? &h->root : NULL), name, howto->name, 6571 (bfd_vma) 0, input_bfd, input_section, 6572 rel->r_offset)))) 6573 return FALSE; 6574 break; 6575 6576 case bfd_reloc_undefined: 6577 if (!((*info->callbacks->undefined_symbol) 6578 (info, name, input_bfd, input_section, 6579 rel->r_offset, TRUE))) 6580 return FALSE; 6581 break; 6582 6583 case bfd_reloc_outofrange: 6584 error_message = _("out of range"); 6585 goto common_error; 6586 6587 case bfd_reloc_notsupported: 6588 error_message = _("unsupported relocation"); 6589 goto common_error; 6590 6591 case bfd_reloc_dangerous: 6592 /* error_message should already be set. */ 6593 goto common_error; 6594 6595 default: 6596 error_message = _("unknown error"); 6597 /* fall through */ 6598 6599 common_error: 6600 BFD_ASSERT (error_message != NULL); 6601 if (!((*info->callbacks->reloc_dangerous) 6602 (info, error_message, input_bfd, input_section, 6603 rel->r_offset))) 6604 return FALSE; 6605 break; 6606 } 6607 } 6608 } 6609 6610 return TRUE; 6611} 6612 6613/* Set the right machine number. */ 6614 6615static bfd_boolean 6616elf32_arm_object_p (bfd *abfd) 6617{ 6618 unsigned int mach; 6619 6620 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION); 6621 6622 if (mach != bfd_mach_arm_unknown) 6623 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach); 6624 6625 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT) 6626 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312); 6627 6628 else 6629 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach); 6630 6631 return TRUE; 6632} 6633 6634/* Function to keep ARM specific flags in the ELF header. */ 6635 6636static bfd_boolean 6637elf32_arm_set_private_flags (bfd *abfd, flagword flags) 6638{ 6639 if (elf_flags_init (abfd) 6640 && elf_elfheader (abfd)->e_flags != flags) 6641 { 6642 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN) 6643 { 6644 if (flags & EF_ARM_INTERWORK) 6645 (*_bfd_error_handler) 6646 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"), 6647 abfd); 6648 else 6649 _bfd_error_handler 6650 (_("Warning: Clearing the interworking flag of %B due to outside request"), 6651 abfd); 6652 } 6653 } 6654 else 6655 { 6656 elf_elfheader (abfd)->e_flags = flags; 6657 elf_flags_init (abfd) = TRUE; 6658 } 6659 6660 return TRUE; 6661} 6662 6663/* Copy backend specific data from one object module to another. */ 6664 6665static bfd_boolean 6666elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 6667{ 6668 flagword in_flags; 6669 flagword out_flags; 6670 6671 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6672 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6673 return TRUE; 6674 6675 in_flags = elf_elfheader (ibfd)->e_flags; 6676 out_flags = elf_elfheader (obfd)->e_flags; 6677 6678 if (elf_flags_init (obfd) 6679 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN 6680 && in_flags != out_flags) 6681 { 6682 /* Cannot mix APCS26 and APCS32 code. */ 6683 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26)) 6684 return FALSE; 6685 6686 /* Cannot mix float APCS and non-float APCS code. */ 6687 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT)) 6688 return FALSE; 6689 6690 /* If the src and dest have different interworking flags 6691 then turn off the interworking bit. */ 6692 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK)) 6693 { 6694 if (out_flags & EF_ARM_INTERWORK) 6695 _bfd_error_handler 6696 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"), 6697 obfd, ibfd); 6698 6699 in_flags &= ~EF_ARM_INTERWORK; 6700 } 6701 6702 /* Likewise for PIC, though don't warn for this case. */ 6703 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC)) 6704 in_flags &= ~EF_ARM_PIC; 6705 } 6706 6707 elf_elfheader (obfd)->e_flags = in_flags; 6708 elf_flags_init (obfd) = TRUE; 6709 6710 /* Also copy the EI_OSABI field. */ 6711 elf_elfheader (obfd)->e_ident[EI_OSABI] = 6712 elf_elfheader (ibfd)->e_ident[EI_OSABI]; 6713 6714 /* Copy object attributes. */ 6715 _bfd_elf_copy_obj_attributes (ibfd, obfd); 6716 6717 return TRUE; 6718} 6719 6720/* Values for Tag_ABI_PCS_R9_use. */ 6721enum 6722{ 6723 AEABI_R9_V6, 6724 AEABI_R9_SB, 6725 AEABI_R9_TLS, 6726 AEABI_R9_unused 6727}; 6728 6729/* Values for Tag_ABI_PCS_RW_data. */ 6730enum 6731{ 6732 AEABI_PCS_RW_data_absolute, 6733 AEABI_PCS_RW_data_PCrel, 6734 AEABI_PCS_RW_data_SBrel, 6735 AEABI_PCS_RW_data_unused 6736}; 6737 6738/* Values for Tag_ABI_enum_size. */ 6739enum 6740{ 6741 AEABI_enum_unused, 6742 AEABI_enum_short, 6743 AEABI_enum_wide, 6744 AEABI_enum_forced_wide 6745}; 6746 6747/* Determine whether an object attribute tag takes an integer, a 6748 string or both. */ 6749static int 6750elf32_arm_obj_attrs_arg_type (int tag) 6751{ 6752 if (tag == Tag_compatibility) 6753 return 3; 6754 else if (tag == 4 || tag == 5) 6755 return 2; 6756 else if (tag < 32) 6757 return 1; 6758 else 6759 return (tag & 1) != 0 ? 2 : 1; 6760} 6761 6762/* Merge EABI object attributes from IBFD into OBFD. Raise an error if there 6763 are conflicting attributes. */ 6764static bfd_boolean 6765elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd) 6766{ 6767 obj_attribute *in_attr; 6768 obj_attribute *out_attr; 6769 obj_attribute_list *in_list; 6770 /* Some tags have 0 = don't care, 1 = strong requirement, 6771 2 = weak requirement. */ 6772 static const int order_312[3] = {3, 1, 2}; 6773 int i; 6774 6775 if (!elf_known_obj_attributes_proc (obfd)[0].i) 6776 { 6777 /* This is the first object. Copy the attributes. */ 6778 _bfd_elf_copy_obj_attributes (ibfd, obfd); 6779 6780 /* Use the Tag_null value to indicate the attributes have been 6781 initialized. */ 6782 elf_known_obj_attributes_proc (obfd)[0].i = 1; 6783 6784 return TRUE; 6785 } 6786 6787 in_attr = elf_known_obj_attributes_proc (ibfd); 6788 out_attr = elf_known_obj_attributes_proc (obfd); 6789 /* This needs to happen before Tag_ABI_FP_number_model is merged. */ 6790 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i) 6791 { 6792 /* Ignore mismatches if teh object doesn't use floating point. */ 6793 if (out_attr[Tag_ABI_FP_number_model].i == 0) 6794 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i; 6795 else if (in_attr[Tag_ABI_FP_number_model].i != 0) 6796 { 6797 _bfd_error_handler 6798 (_("ERROR: %B uses VFP register arguments, %B does not"), 6799 ibfd, obfd); 6800 return FALSE; 6801 } 6802 } 6803 6804 for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) 6805 { 6806 /* Merge this attribute with existing attributes. */ 6807 switch (i) 6808 { 6809 case Tag_CPU_raw_name: 6810 case Tag_CPU_name: 6811 /* Use whichever has the greatest architecture requirements. We 6812 won't necessarily have both the above tags, so make sure input 6813 name is non-NULL. */ 6814 if (in_attr[Tag_CPU_arch].i > out_attr[Tag_CPU_arch].i 6815 && in_attr[i].s) 6816 out_attr[i].s = _bfd_elf_attr_strdup (obfd, in_attr[i].s); 6817 break; 6818 6819 case Tag_ABI_optimization_goals: 6820 case Tag_ABI_FP_optimization_goals: 6821 /* Use the first value seen. */ 6822 break; 6823 6824 case Tag_CPU_arch: 6825 case Tag_ARM_ISA_use: 6826 case Tag_THUMB_ISA_use: 6827 case Tag_VFP_arch: 6828 case Tag_WMMX_arch: 6829 case Tag_NEON_arch: 6830 /* ??? Do NEON and WMMX conflict? */ 6831 case Tag_ABI_FP_rounding: 6832 case Tag_ABI_FP_denormal: 6833 case Tag_ABI_FP_exceptions: 6834 case Tag_ABI_FP_user_exceptions: 6835 case Tag_ABI_FP_number_model: 6836 case Tag_ABI_align8_preserved: 6837 case Tag_ABI_HardFP_use: 6838 /* Use the largest value specified. */ 6839 if (in_attr[i].i > out_attr[i].i) 6840 out_attr[i].i = in_attr[i].i; 6841 break; 6842 6843 case Tag_CPU_arch_profile: 6844 /* Warn if conflicting architecture profiles used. */ 6845 if (out_attr[i].i && in_attr[i].i && in_attr[i].i != out_attr[i].i) 6846 { 6847 _bfd_error_handler 6848 (_("ERROR: %B: Conflicting architecture profiles %c/%c"), 6849 ibfd, in_attr[i].i, out_attr[i].i); 6850 return FALSE; 6851 } 6852 if (in_attr[i].i) 6853 out_attr[i].i = in_attr[i].i; 6854 break; 6855 case Tag_PCS_config: 6856 if (out_attr[i].i == 0) 6857 out_attr[i].i = in_attr[i].i; 6858 else if (in_attr[i].i != 0 && out_attr[i].i != 0) 6859 { 6860 /* It's sometimes ok to mix different configs, so this is only 6861 a warning. */ 6862 _bfd_error_handler 6863 (_("Warning: %B: Conflicting platform configuration"), ibfd); 6864 } 6865 break; 6866 case Tag_ABI_PCS_R9_use: 6867 if (in_attr[i].i != out_attr[i].i 6868 && out_attr[i].i != AEABI_R9_unused 6869 && in_attr[i].i != AEABI_R9_unused) 6870 { 6871 _bfd_error_handler 6872 (_("ERROR: %B: Conflicting use of R9"), ibfd); 6873 return FALSE; 6874 } 6875 if (out_attr[i].i == AEABI_R9_unused) 6876 out_attr[i].i = in_attr[i].i; 6877 break; 6878 case Tag_ABI_PCS_RW_data: 6879 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel 6880 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB 6881 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused) 6882 { 6883 _bfd_error_handler 6884 (_("ERROR: %B: SB relative addressing conflicts with use of R9"), 6885 ibfd); 6886 return FALSE; 6887 } 6888 /* Use the smallest value specified. */ 6889 if (in_attr[i].i < out_attr[i].i) 6890 out_attr[i].i = in_attr[i].i; 6891 break; 6892 case Tag_ABI_PCS_RO_data: 6893 /* Use the smallest value specified. */ 6894 if (in_attr[i].i < out_attr[i].i) 6895 out_attr[i].i = in_attr[i].i; 6896 break; 6897 case Tag_ABI_PCS_GOT_use: 6898 if (in_attr[i].i > 2 || out_attr[i].i > 2 6899 || order_312[in_attr[i].i] < order_312[out_attr[i].i]) 6900 out_attr[i].i = in_attr[i].i; 6901 break; 6902 case Tag_ABI_PCS_wchar_t: 6903 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i) 6904 { 6905 _bfd_error_handler 6906 (_("ERROR: %B: Conflicting definitions of wchar_t"), ibfd); 6907 return FALSE; 6908 } 6909 if (in_attr[i].i) 6910 out_attr[i].i = in_attr[i].i; 6911 break; 6912 case Tag_ABI_align8_needed: 6913 /* ??? Check against Tag_ABI_align8_preserved. */ 6914 if (in_attr[i].i > 2 || out_attr[i].i > 2 6915 || order_312[in_attr[i].i] < order_312[out_attr[i].i]) 6916 out_attr[i].i = in_attr[i].i; 6917 break; 6918 case Tag_ABI_enum_size: 6919 if (in_attr[i].i != AEABI_enum_unused) 6920 { 6921 if (out_attr[i].i == AEABI_enum_unused 6922 || out_attr[i].i == AEABI_enum_forced_wide) 6923 { 6924 /* The existing object is compatible with anything. 6925 Use whatever requirements the new object has. */ 6926 out_attr[i].i = in_attr[i].i; 6927 } 6928 else if (in_attr[i].i != AEABI_enum_forced_wide 6929 && out_attr[i].i != in_attr[i].i 6930 && !elf32_arm_tdata (obfd)->no_enum_size_warning) 6931 { 6932 const char *aeabi_enum_names[] = 6933 { "", "variable-size", "32-bit", "" }; 6934 _bfd_error_handler 6935 (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"), 6936 ibfd, aeabi_enum_names[in_attr[i].i], 6937 aeabi_enum_names[out_attr[i].i]); 6938 } 6939 } 6940 break; 6941 case Tag_ABI_VFP_args: 6942 /* Aready done. */ 6943 break; 6944 case Tag_ABI_WMMX_args: 6945 if (in_attr[i].i != out_attr[i].i) 6946 { 6947 _bfd_error_handler 6948 (_("ERROR: %B uses iWMMXt register arguments, %B does not"), 6949 ibfd, obfd); 6950 return FALSE; 6951 } 6952 break; 6953 default: /* All known attributes should be explicitly covered. */ 6954 abort (); 6955 } 6956 } 6957 6958 /* Merge Tag_compatibility attributes and any common GNU ones. */ 6959 _bfd_elf_merge_object_attributes (ibfd, obfd); 6960 6961 /* Check for any attributes not known on ARM. */ 6962 in_list = elf_other_obj_attributes_proc (ibfd); 6963 while (in_list && in_list->tag == Tag_compatibility) 6964 in_list = in_list->next; 6965 6966 for (; in_list; in_list = in_list->next) 6967 { 6968 if ((in_list->tag & 128) < 64) 6969 { 6970 _bfd_error_handler 6971 (_("Warning: %B: Unknown EABI object attribute %d"), 6972 ibfd, in_list->tag); 6973 break; 6974 } 6975 } 6976 return TRUE; 6977} 6978 6979 6980/* Return TRUE if the two EABI versions are incompatible. */ 6981 6982static bfd_boolean 6983elf32_arm_versions_compatible (unsigned iver, unsigned over) 6984{ 6985 /* v4 and v5 are the same spec before and after it was released, 6986 so allow mixing them. */ 6987 if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5) 6988 || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4)) 6989 return TRUE; 6990 6991 return (iver == over); 6992} 6993 6994/* Merge backend specific data from an object file to the output 6995 object file when linking. */ 6996 6997static bfd_boolean 6998elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd) 6999{ 7000 flagword out_flags; 7001 flagword in_flags; 7002 bfd_boolean flags_compatible = TRUE; 7003 asection *sec; 7004 7005 /* Check if we have the same endianess. */ 7006 if (! _bfd_generic_verify_endian_match (ibfd, obfd)) 7007 return FALSE; 7008 7009 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour 7010 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 7011 return TRUE; 7012 7013 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd)) 7014 return FALSE; 7015 7016 /* The input BFD must have had its flags initialised. */ 7017 /* The following seems bogus to me -- The flags are initialized in 7018 the assembler but I don't think an elf_flags_init field is 7019 written into the object. */ 7020 /* BFD_ASSERT (elf_flags_init (ibfd)); */ 7021 7022 in_flags = elf_elfheader (ibfd)->e_flags; 7023 out_flags = elf_elfheader (obfd)->e_flags; 7024 7025 if (!elf_flags_init (obfd)) 7026 { 7027 /* If the input is the default architecture and had the default 7028 flags then do not bother setting the flags for the output 7029 architecture, instead allow future merges to do this. If no 7030 future merges ever set these flags then they will retain their 7031 uninitialised values, which surprise surprise, correspond 7032 to the default values. */ 7033 if (bfd_get_arch_info (ibfd)->the_default 7034 && elf_elfheader (ibfd)->e_flags == 0) 7035 return TRUE; 7036 7037 elf_flags_init (obfd) = TRUE; 7038 elf_elfheader (obfd)->e_flags = in_flags; 7039 7040 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 7041 && bfd_get_arch_info (obfd)->the_default) 7042 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd)); 7043 7044 return TRUE; 7045 } 7046 7047 /* Determine what should happen if the input ARM architecture 7048 does not match the output ARM architecture. */ 7049 if (! bfd_arm_merge_machines (ibfd, obfd)) 7050 return FALSE; 7051 7052 /* Identical flags must be compatible. */ 7053 if (in_flags == out_flags) 7054 return TRUE; 7055 7056 /* Check to see if the input BFD actually contains any sections. If 7057 not, its flags may not have been initialised either, but it 7058 cannot actually cause any incompatiblity. Do not short-circuit 7059 dynamic objects; their section list may be emptied by 7060 elf_link_add_object_symbols. 7061 7062 Also check to see if there are no code sections in the input. 7063 In this case there is no need to check for code specific flags. 7064 XXX - do we need to worry about floating-point format compatability 7065 in data sections ? */ 7066 if (!(ibfd->flags & DYNAMIC)) 7067 { 7068 bfd_boolean null_input_bfd = TRUE; 7069 bfd_boolean only_data_sections = TRUE; 7070 7071 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 7072 { 7073 /* Ignore synthetic glue sections. */ 7074 if (strcmp (sec->name, ".glue_7") 7075 && strcmp (sec->name, ".glue_7t")) 7076 { 7077 if ((bfd_get_section_flags (ibfd, sec) 7078 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 7079 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 7080 only_data_sections = FALSE; 7081 7082 null_input_bfd = FALSE; 7083 break; 7084 } 7085 } 7086 7087 if (null_input_bfd || only_data_sections) 7088 return TRUE; 7089 } 7090 7091 /* Complain about various flag mismatches. */ 7092 if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags), 7093 EF_ARM_EABI_VERSION (out_flags))) 7094 { 7095 _bfd_error_handler 7096 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"), 7097 ibfd, obfd, 7098 (in_flags & EF_ARM_EABIMASK) >> 24, 7099 (out_flags & EF_ARM_EABIMASK) >> 24); 7100 return FALSE; 7101 } 7102 7103 /* Not sure what needs to be checked for EABI versions >= 1. */ 7104 /* VxWorks libraries do not use these flags. */ 7105 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed 7106 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed 7107 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN) 7108 { 7109 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26)) 7110 { 7111 _bfd_error_handler 7112 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"), 7113 ibfd, obfd, 7114 in_flags & EF_ARM_APCS_26 ? 26 : 32, 7115 out_flags & EF_ARM_APCS_26 ? 26 : 32); 7116 flags_compatible = FALSE; 7117 } 7118 7119 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT)) 7120 { 7121 if (in_flags & EF_ARM_APCS_FLOAT) 7122 _bfd_error_handler 7123 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"), 7124 ibfd, obfd); 7125 else 7126 _bfd_error_handler 7127 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"), 7128 ibfd, obfd); 7129 7130 flags_compatible = FALSE; 7131 } 7132 7133 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT)) 7134 { 7135 if (in_flags & EF_ARM_VFP_FLOAT) 7136 _bfd_error_handler 7137 (_("ERROR: %B uses VFP instructions, whereas %B does not"), 7138 ibfd, obfd); 7139 else 7140 _bfd_error_handler 7141 (_("ERROR: %B uses FPA instructions, whereas %B does not"), 7142 ibfd, obfd); 7143 7144 flags_compatible = FALSE; 7145 } 7146 7147 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT)) 7148 { 7149 if (in_flags & EF_ARM_MAVERICK_FLOAT) 7150 _bfd_error_handler 7151 (_("ERROR: %B uses Maverick instructions, whereas %B does not"), 7152 ibfd, obfd); 7153 else 7154 _bfd_error_handler 7155 (_("ERROR: %B does not use Maverick instructions, whereas %B does"), 7156 ibfd, obfd); 7157 7158 flags_compatible = FALSE; 7159 } 7160 7161#ifdef EF_ARM_SOFT_FLOAT 7162 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT)) 7163 { 7164 /* We can allow interworking between code that is VFP format 7165 layout, and uses either soft float or integer regs for 7166 passing floating point arguments and results. We already 7167 know that the APCS_FLOAT flags match; similarly for VFP 7168 flags. */ 7169 if ((in_flags & EF_ARM_APCS_FLOAT) != 0 7170 || (in_flags & EF_ARM_VFP_FLOAT) == 0) 7171 { 7172 if (in_flags & EF_ARM_SOFT_FLOAT) 7173 _bfd_error_handler 7174 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"), 7175 ibfd, obfd); 7176 else 7177 _bfd_error_handler 7178 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"), 7179 ibfd, obfd); 7180 7181 flags_compatible = FALSE; 7182 } 7183 } 7184#endif 7185 7186 /* Interworking mismatch is only a warning. */ 7187 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK)) 7188 { 7189 if (in_flags & EF_ARM_INTERWORK) 7190 { 7191 _bfd_error_handler 7192 (_("Warning: %B supports interworking, whereas %B does not"), 7193 ibfd, obfd); 7194 } 7195 else 7196 { 7197 _bfd_error_handler 7198 (_("Warning: %B does not support interworking, whereas %B does"), 7199 ibfd, obfd); 7200 } 7201 } 7202 } 7203 7204 return flags_compatible; 7205} 7206 7207/* Display the flags field. */ 7208 7209static bfd_boolean 7210elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr) 7211{ 7212 FILE * file = (FILE *) ptr; 7213 unsigned long flags; 7214 7215 BFD_ASSERT (abfd != NULL && ptr != NULL); 7216 7217 /* Print normal ELF private data. */ 7218 _bfd_elf_print_private_bfd_data (abfd, ptr); 7219 7220 flags = elf_elfheader (abfd)->e_flags; 7221 /* Ignore init flag - it may not be set, despite the flags field 7222 containing valid data. */ 7223 7224 /* xgettext:c-format */ 7225 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 7226 7227 switch (EF_ARM_EABI_VERSION (flags)) 7228 { 7229 case EF_ARM_EABI_UNKNOWN: 7230 /* The following flag bits are GNU extensions and not part of the 7231 official ARM ELF extended ABI. Hence they are only decoded if 7232 the EABI version is not set. */ 7233 if (flags & EF_ARM_INTERWORK) 7234 fprintf (file, _(" [interworking enabled]")); 7235 7236 if (flags & EF_ARM_APCS_26) 7237 fprintf (file, " [APCS-26]"); 7238 else 7239 fprintf (file, " [APCS-32]"); 7240 7241 if (flags & EF_ARM_VFP_FLOAT) 7242 fprintf (file, _(" [VFP float format]")); 7243 else if (flags & EF_ARM_MAVERICK_FLOAT) 7244 fprintf (file, _(" [Maverick float format]")); 7245 else 7246 fprintf (file, _(" [FPA float format]")); 7247 7248 if (flags & EF_ARM_APCS_FLOAT) 7249 fprintf (file, _(" [floats passed in float registers]")); 7250 7251 if (flags & EF_ARM_PIC) 7252 fprintf (file, _(" [position independent]")); 7253 7254 if (flags & EF_ARM_NEW_ABI) 7255 fprintf (file, _(" [new ABI]")); 7256 7257 if (flags & EF_ARM_OLD_ABI) 7258 fprintf (file, _(" [old ABI]")); 7259 7260 if (flags & EF_ARM_SOFT_FLOAT) 7261 fprintf (file, _(" [software FP]")); 7262 7263 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT 7264 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI 7265 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT 7266 | EF_ARM_MAVERICK_FLOAT); 7267 break; 7268 7269 case EF_ARM_EABI_VER1: 7270 fprintf (file, _(" [Version1 EABI]")); 7271 7272 if (flags & EF_ARM_SYMSARESORTED) 7273 fprintf (file, _(" [sorted symbol table]")); 7274 else 7275 fprintf (file, _(" [unsorted symbol table]")); 7276 7277 flags &= ~ EF_ARM_SYMSARESORTED; 7278 break; 7279 7280 case EF_ARM_EABI_VER2: 7281 fprintf (file, _(" [Version2 EABI]")); 7282 7283 if (flags & EF_ARM_SYMSARESORTED) 7284 fprintf (file, _(" [sorted symbol table]")); 7285 else 7286 fprintf (file, _(" [unsorted symbol table]")); 7287 7288 if (flags & EF_ARM_DYNSYMSUSESEGIDX) 7289 fprintf (file, _(" [dynamic symbols use segment index]")); 7290 7291 if (flags & EF_ARM_MAPSYMSFIRST) 7292 fprintf (file, _(" [mapping symbols precede others]")); 7293 7294 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX 7295 | EF_ARM_MAPSYMSFIRST); 7296 break; 7297 7298 case EF_ARM_EABI_VER3: 7299 fprintf (file, _(" [Version3 EABI]")); 7300 break; 7301 7302 case EF_ARM_EABI_VER4: 7303 fprintf (file, _(" [Version4 EABI]")); 7304 goto eabi; 7305 7306 case EF_ARM_EABI_VER5: 7307 fprintf (file, _(" [Version5 EABI]")); 7308 eabi: 7309 if (flags & EF_ARM_BE8) 7310 fprintf (file, _(" [BE8]")); 7311 7312 if (flags & EF_ARM_LE8) 7313 fprintf (file, _(" [LE8]")); 7314 7315 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8); 7316 break; 7317 7318 default: 7319 fprintf (file, _(" <EABI version unrecognised>")); 7320 break; 7321 } 7322 7323 flags &= ~ EF_ARM_EABIMASK; 7324 7325 if (flags & EF_ARM_RELEXEC) 7326 fprintf (file, _(" [relocatable executable]")); 7327 7328 if (flags & EF_ARM_HASENTRY) 7329 fprintf (file, _(" [has entry point]")); 7330 7331 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY); 7332 7333 if (flags) 7334 fprintf (file, _("<Unrecognised flag bits set>")); 7335 7336 fputc ('\n', file); 7337 7338 return TRUE; 7339} 7340 7341static int 7342elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type) 7343{ 7344 switch (ELF_ST_TYPE (elf_sym->st_info)) 7345 { 7346 case STT_ARM_TFUNC: 7347 return ELF_ST_TYPE (elf_sym->st_info); 7348 7349 case STT_ARM_16BIT: 7350 /* If the symbol is not an object, return the STT_ARM_16BIT flag. 7351 This allows us to distinguish between data used by Thumb instructions 7352 and non-data (which is probably code) inside Thumb regions of an 7353 executable. */ 7354 if (type != STT_OBJECT && type != STT_TLS) 7355 return ELF_ST_TYPE (elf_sym->st_info); 7356 break; 7357 7358 default: 7359 break; 7360 } 7361 7362 return type; 7363} 7364 7365static asection * 7366elf32_arm_gc_mark_hook (asection *sec, 7367 struct bfd_link_info *info, 7368 Elf_Internal_Rela *rel, 7369 struct elf_link_hash_entry *h, 7370 Elf_Internal_Sym *sym) 7371{ 7372 if (h != NULL) 7373 switch (ELF32_R_TYPE (rel->r_info)) 7374 { 7375 case R_ARM_GNU_VTINHERIT: 7376 case R_ARM_GNU_VTENTRY: 7377 return NULL; 7378 } 7379 7380 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 7381} 7382 7383/* Update the got entry reference counts for the section being removed. */ 7384 7385static bfd_boolean 7386elf32_arm_gc_sweep_hook (bfd * abfd, 7387 struct bfd_link_info * info, 7388 asection * sec, 7389 const Elf_Internal_Rela * relocs) 7390{ 7391 Elf_Internal_Shdr *symtab_hdr; 7392 struct elf_link_hash_entry **sym_hashes; 7393 bfd_signed_vma *local_got_refcounts; 7394 const Elf_Internal_Rela *rel, *relend; 7395 struct elf32_arm_link_hash_table * globals; 7396 7397 globals = elf32_arm_hash_table (info); 7398 7399 elf_section_data (sec)->local_dynrel = NULL; 7400 7401 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 7402 sym_hashes = elf_sym_hashes (abfd); 7403 local_got_refcounts = elf_local_got_refcounts (abfd); 7404 7405 relend = relocs + sec->reloc_count; 7406 for (rel = relocs; rel < relend; rel++) 7407 { 7408 unsigned long r_symndx; 7409 struct elf_link_hash_entry *h = NULL; 7410 int r_type; 7411 7412 r_symndx = ELF32_R_SYM (rel->r_info); 7413 if (r_symndx >= symtab_hdr->sh_info) 7414 { 7415 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 7416 while (h->root.type == bfd_link_hash_indirect 7417 || h->root.type == bfd_link_hash_warning) 7418 h = (struct elf_link_hash_entry *) h->root.u.i.link; 7419 } 7420 7421 r_type = ELF32_R_TYPE (rel->r_info); 7422 r_type = arm_real_reloc_type (globals, r_type); 7423 switch (r_type) 7424 { 7425 case R_ARM_GOT32: 7426 case R_ARM_GOT_PREL: 7427 case R_ARM_TLS_GD32: 7428 case R_ARM_TLS_IE32: 7429 if (h != NULL) 7430 { 7431 if (h->got.refcount > 0) 7432 h->got.refcount -= 1; 7433 } 7434 else if (local_got_refcounts != NULL) 7435 { 7436 if (local_got_refcounts[r_symndx] > 0) 7437 local_got_refcounts[r_symndx] -= 1; 7438 } 7439 break; 7440 7441 case R_ARM_TLS_LDM32: 7442 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1; 7443 break; 7444 7445 case R_ARM_ABS32: 7446 case R_ARM_ABS32_NOI: 7447 case R_ARM_REL32: 7448 case R_ARM_REL32_NOI: 7449 case R_ARM_PC24: 7450 case R_ARM_PLT32: 7451 case R_ARM_CALL: 7452 case R_ARM_JUMP24: 7453 case R_ARM_PREL31: 7454 case R_ARM_THM_CALL: 7455 case R_ARM_MOVW_ABS_NC: 7456 case R_ARM_MOVT_ABS: 7457 case R_ARM_MOVW_PREL_NC: 7458 case R_ARM_MOVT_PREL: 7459 case R_ARM_THM_MOVW_ABS_NC: 7460 case R_ARM_THM_MOVT_ABS: 7461 case R_ARM_THM_MOVW_PREL_NC: 7462 case R_ARM_THM_MOVT_PREL: 7463 /* Should the interworking branches be here also? */ 7464 7465 if (h != NULL) 7466 { 7467 struct elf32_arm_link_hash_entry *eh; 7468 struct elf32_arm_relocs_copied **pp; 7469 struct elf32_arm_relocs_copied *p; 7470 7471 eh = (struct elf32_arm_link_hash_entry *) h; 7472 7473 if (h->plt.refcount > 0) 7474 { 7475 h->plt.refcount -= 1; 7476 if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_CALL) 7477 eh->plt_thumb_refcount--; 7478 } 7479 7480 if (r_type == R_ARM_ABS32 7481 || r_type == R_ARM_REL32 7482 || r_type == R_ARM_ABS32_NOI 7483 || r_type == R_ARM_REL32_NOI) 7484 { 7485 for (pp = &eh->relocs_copied; (p = *pp) != NULL; 7486 pp = &p->next) 7487 if (p->section == sec) 7488 { 7489 p->count -= 1; 7490 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32 7491 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32_NOI) 7492 p->pc_count -= 1; 7493 if (p->count == 0) 7494 *pp = p->next; 7495 break; 7496 } 7497 } 7498 } 7499 break; 7500 7501 default: 7502 break; 7503 } 7504 } 7505 7506 return TRUE; 7507} 7508 7509/* Look through the relocs for a section during the first phase. */ 7510 7511static bfd_boolean 7512elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info, 7513 asection *sec, const Elf_Internal_Rela *relocs) 7514{ 7515 Elf_Internal_Shdr *symtab_hdr; 7516 struct elf_link_hash_entry **sym_hashes; 7517 struct elf_link_hash_entry **sym_hashes_end; 7518 const Elf_Internal_Rela *rel; 7519 const Elf_Internal_Rela *rel_end; 7520 bfd *dynobj; 7521 asection *sreloc; 7522 bfd_vma *local_got_offsets; 7523 struct elf32_arm_link_hash_table *htab; 7524 7525 if (info->relocatable) 7526 return TRUE; 7527 7528 htab = elf32_arm_hash_table (info); 7529 sreloc = NULL; 7530 7531 /* Create dynamic sections for relocatable executables so that we can 7532 copy relocations. */ 7533 if (htab->root.is_relocatable_executable 7534 && ! htab->root.dynamic_sections_created) 7535 { 7536 if (! _bfd_elf_link_create_dynamic_sections (abfd, info)) 7537 return FALSE; 7538 } 7539 7540 dynobj = elf_hash_table (info)->dynobj; 7541 local_got_offsets = elf_local_got_offsets (abfd); 7542 7543 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 7544 sym_hashes = elf_sym_hashes (abfd); 7545 sym_hashes_end = sym_hashes 7546 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym); 7547 7548 if (!elf_bad_symtab (abfd)) 7549 sym_hashes_end -= symtab_hdr->sh_info; 7550 7551 rel_end = relocs + sec->reloc_count; 7552 for (rel = relocs; rel < rel_end; rel++) 7553 { 7554 struct elf_link_hash_entry *h; 7555 struct elf32_arm_link_hash_entry *eh; 7556 unsigned long r_symndx; 7557 int r_type; 7558 7559 r_symndx = ELF32_R_SYM (rel->r_info); 7560 r_type = ELF32_R_TYPE (rel->r_info); 7561 r_type = arm_real_reloc_type (htab, r_type); 7562 7563 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 7564 { 7565 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd, 7566 r_symndx); 7567 return FALSE; 7568 } 7569 7570 if (r_symndx < symtab_hdr->sh_info) 7571 h = NULL; 7572 else 7573 { 7574 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 7575 while (h->root.type == bfd_link_hash_indirect 7576 || h->root.type == bfd_link_hash_warning) 7577 h = (struct elf_link_hash_entry *) h->root.u.i.link; 7578 } 7579 7580 eh = (struct elf32_arm_link_hash_entry *) h; 7581 7582 switch (r_type) 7583 { 7584 case R_ARM_GOT32: 7585 case R_ARM_GOT_PREL: 7586 case R_ARM_TLS_GD32: 7587 case R_ARM_TLS_IE32: 7588 /* This symbol requires a global offset table entry. */ 7589 { 7590 int tls_type, old_tls_type; 7591 7592 switch (r_type) 7593 { 7594 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break; 7595 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break; 7596 default: tls_type = GOT_NORMAL; break; 7597 } 7598 7599 if (h != NULL) 7600 { 7601 h->got.refcount++; 7602 old_tls_type = elf32_arm_hash_entry (h)->tls_type; 7603 } 7604 else 7605 { 7606 bfd_signed_vma *local_got_refcounts; 7607 7608 /* This is a global offset table entry for a local symbol. */ 7609 local_got_refcounts = elf_local_got_refcounts (abfd); 7610 if (local_got_refcounts == NULL) 7611 { 7612 bfd_size_type size; 7613 7614 size = symtab_hdr->sh_info; 7615 size *= (sizeof (bfd_signed_vma) + sizeof(char)); 7616 local_got_refcounts = bfd_zalloc (abfd, size); 7617 if (local_got_refcounts == NULL) 7618 return FALSE; 7619 elf_local_got_refcounts (abfd) = local_got_refcounts; 7620 elf32_arm_local_got_tls_type (abfd) 7621 = (char *) (local_got_refcounts + symtab_hdr->sh_info); 7622 } 7623 local_got_refcounts[r_symndx] += 1; 7624 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx]; 7625 } 7626 7627 /* We will already have issued an error message if there is a 7628 TLS / non-TLS mismatch, based on the symbol type. We don't 7629 support any linker relaxations. So just combine any TLS 7630 types needed. */ 7631 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL 7632 && tls_type != GOT_NORMAL) 7633 tls_type |= old_tls_type; 7634 7635 if (old_tls_type != tls_type) 7636 { 7637 if (h != NULL) 7638 elf32_arm_hash_entry (h)->tls_type = tls_type; 7639 else 7640 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type; 7641 } 7642 } 7643 /* Fall through */ 7644 7645 case R_ARM_TLS_LDM32: 7646 if (r_type == R_ARM_TLS_LDM32) 7647 htab->tls_ldm_got.refcount++; 7648 /* Fall through */ 7649 7650 case R_ARM_GOTOFF32: 7651 case R_ARM_GOTPC: 7652 if (htab->sgot == NULL) 7653 { 7654 if (htab->root.dynobj == NULL) 7655 htab->root.dynobj = abfd; 7656 if (!create_got_section (htab->root.dynobj, info)) 7657 return FALSE; 7658 } 7659 break; 7660 7661 case R_ARM_ABS12: 7662 /* VxWorks uses dynamic R_ARM_ABS12 relocations for 7663 ldr __GOTT_INDEX__ offsets. */ 7664 if (!htab->vxworks_p) 7665 break; 7666 /* Fall through */ 7667 7668 case R_ARM_ABS32: 7669 case R_ARM_ABS32_NOI: 7670 case R_ARM_REL32: 7671 case R_ARM_REL32_NOI: 7672 case R_ARM_PC24: 7673 case R_ARM_PLT32: 7674 case R_ARM_CALL: 7675 case R_ARM_JUMP24: 7676 case R_ARM_PREL31: 7677 case R_ARM_THM_CALL: 7678 case R_ARM_MOVW_ABS_NC: 7679 case R_ARM_MOVT_ABS: 7680 case R_ARM_MOVW_PREL_NC: 7681 case R_ARM_MOVT_PREL: 7682 case R_ARM_THM_MOVW_ABS_NC: 7683 case R_ARM_THM_MOVT_ABS: 7684 case R_ARM_THM_MOVW_PREL_NC: 7685 case R_ARM_THM_MOVT_PREL: 7686 /* Should the interworking branches be listed here? */ 7687 if (h != NULL) 7688 { 7689 /* If this reloc is in a read-only section, we might 7690 need a copy reloc. We can't check reliably at this 7691 stage whether the section is read-only, as input 7692 sections have not yet been mapped to output sections. 7693 Tentatively set the flag for now, and correct in 7694 adjust_dynamic_symbol. */ 7695 if (!info->shared) 7696 h->non_got_ref = 1; 7697 7698 /* We may need a .plt entry if the function this reloc 7699 refers to is in a different object. We can't tell for 7700 sure yet, because something later might force the 7701 symbol local. */ 7702 if (r_type != R_ARM_ABS32 7703 && r_type != R_ARM_REL32 7704 && r_type != R_ARM_ABS32_NOI 7705 && r_type != R_ARM_REL32_NOI 7706 && r_type != R_ARM_ABS12) 7707 h->needs_plt = 1; 7708 7709 /* If we create a PLT entry, this relocation will reference 7710 it, even if it's an ABS32 relocation. */ 7711 h->plt.refcount += 1; 7712 7713 if (r_type == R_ARM_THM_CALL) 7714 eh->plt_thumb_refcount += 1; 7715 } 7716 7717 /* If we are creating a shared library or relocatable executable, 7718 and this is a reloc against a global symbol, or a non PC 7719 relative reloc against a local symbol, then we need to copy 7720 the reloc into the shared library. However, if we are linking 7721 with -Bsymbolic, we do not need to copy a reloc against a 7722 global symbol which is defined in an object we are 7723 including in the link (i.e., DEF_REGULAR is set). At 7724 this point we have not seen all the input files, so it is 7725 possible that DEF_REGULAR is not set now but will be set 7726 later (it is never cleared). We account for that 7727 possibility below by storing information in the 7728 relocs_copied field of the hash table entry. */ 7729 if ((info->shared || htab->root.is_relocatable_executable) 7730 && (sec->flags & SEC_ALLOC) != 0 7731 && ((r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI) 7732 || (h != NULL && ! h->needs_plt 7733 && (! info->symbolic || ! h->def_regular)))) 7734 { 7735 struct elf32_arm_relocs_copied *p, **head; 7736 7737 /* When creating a shared object, we must copy these 7738 reloc types into the output file. We create a reloc 7739 section in dynobj and make room for this reloc. */ 7740 if (sreloc == NULL) 7741 { 7742 const char * name; 7743 7744 name = (bfd_elf_string_from_elf_section 7745 (abfd, 7746 elf_elfheader (abfd)->e_shstrndx, 7747 elf_section_data (sec)->rel_hdr.sh_name)); 7748 if (name == NULL) 7749 return FALSE; 7750 7751 BFD_ASSERT (reloc_section_p (htab, name, sec)); 7752 7753 sreloc = bfd_get_section_by_name (dynobj, name); 7754 if (sreloc == NULL) 7755 { 7756 flagword flags; 7757 7758 flags = (SEC_HAS_CONTENTS | SEC_READONLY 7759 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 7760 if ((sec->flags & SEC_ALLOC) != 0 7761 /* BPABI objects never have dynamic 7762 relocations mapped. */ 7763 && !htab->symbian_p) 7764 flags |= SEC_ALLOC | SEC_LOAD; 7765 sreloc = bfd_make_section_with_flags (dynobj, 7766 name, 7767 flags); 7768 if (sreloc == NULL 7769 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 7770 return FALSE; 7771 } 7772 7773 elf_section_data (sec)->sreloc = sreloc; 7774 } 7775 7776 /* If this is a global symbol, we count the number of 7777 relocations we need for this symbol. */ 7778 if (h != NULL) 7779 { 7780 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied; 7781 } 7782 else 7783 { 7784 /* Track dynamic relocs needed for local syms too. 7785 We really need local syms available to do this 7786 easily. Oh well. */ 7787 7788 asection *s; 7789 void *vpp; 7790 7791 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 7792 sec, r_symndx); 7793 if (s == NULL) 7794 return FALSE; 7795 7796 vpp = &elf_section_data (s)->local_dynrel; 7797 head = (struct elf32_arm_relocs_copied **) vpp; 7798 } 7799 7800 p = *head; 7801 if (p == NULL || p->section != sec) 7802 { 7803 bfd_size_type amt = sizeof *p; 7804 7805 p = bfd_alloc (htab->root.dynobj, amt); 7806 if (p == NULL) 7807 return FALSE; 7808 p->next = *head; 7809 *head = p; 7810 p->section = sec; 7811 p->count = 0; 7812 p->pc_count = 0; 7813 } 7814 7815 if (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI) 7816 p->pc_count += 1; 7817 p->count += 1; 7818 } 7819 break; 7820 7821 /* This relocation describes the C++ object vtable hierarchy. 7822 Reconstruct it for later use during GC. */ 7823 case R_ARM_GNU_VTINHERIT: 7824 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 7825 return FALSE; 7826 break; 7827 7828 /* This relocation describes which C++ vtable entries are actually 7829 used. Record for later use during GC. */ 7830 case R_ARM_GNU_VTENTRY: 7831 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 7832 return FALSE; 7833 break; 7834 } 7835 } 7836 7837 return TRUE; 7838} 7839 7840/* Unwinding tables are not referenced directly. This pass marks them as 7841 required if the corresponding code section is marked. */ 7842 7843static bfd_boolean 7844elf32_arm_gc_mark_extra_sections(struct bfd_link_info *info, 7845 elf_gc_mark_hook_fn gc_mark_hook) 7846{ 7847 bfd *sub; 7848 Elf_Internal_Shdr **elf_shdrp; 7849 bfd_boolean again; 7850 7851 /* Marking EH data may cause additional code sections to be marked, 7852 requiring multiple passes. */ 7853 again = TRUE; 7854 while (again) 7855 { 7856 again = FALSE; 7857 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 7858 { 7859 asection *o; 7860 7861 if (bfd_get_flavour (sub) != bfd_target_elf_flavour) 7862 continue; 7863 7864 elf_shdrp = elf_elfsections (sub); 7865 for (o = sub->sections; o != NULL; o = o->next) 7866 { 7867 Elf_Internal_Shdr *hdr; 7868 hdr = &elf_section_data (o)->this_hdr; 7869 if (hdr->sh_type == SHT_ARM_EXIDX && hdr->sh_link 7870 && !o->gc_mark 7871 && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark) 7872 { 7873 again = TRUE; 7874 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook)) 7875 return FALSE; 7876 } 7877 } 7878 } 7879 } 7880 7881 return TRUE; 7882} 7883 7884/* Treat mapping symbols as special target symbols. */ 7885 7886static bfd_boolean 7887elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym) 7888{ 7889 return bfd_is_arm_special_symbol_name (sym->name, 7890 BFD_ARM_SPECIAL_SYM_TYPE_ANY); 7891} 7892 7893/* This is a copy of elf_find_function() from elf.c except that 7894 ARM mapping symbols are ignored when looking for function names 7895 and STT_ARM_TFUNC is considered to a function type. */ 7896 7897static bfd_boolean 7898arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED, 7899 asection * section, 7900 asymbol ** symbols, 7901 bfd_vma offset, 7902 const char ** filename_ptr, 7903 const char ** functionname_ptr) 7904{ 7905 const char * filename = NULL; 7906 asymbol * func = NULL; 7907 bfd_vma low_func = 0; 7908 asymbol ** p; 7909 7910 for (p = symbols; *p != NULL; p++) 7911 { 7912 elf_symbol_type *q; 7913 7914 q = (elf_symbol_type *) *p; 7915 7916 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info)) 7917 { 7918 default: 7919 break; 7920 case STT_FILE: 7921 filename = bfd_asymbol_name (&q->symbol); 7922 break; 7923 case STT_FUNC: 7924 case STT_ARM_TFUNC: 7925 case STT_NOTYPE: 7926 /* Skip mapping symbols. */ 7927 if ((q->symbol.flags & BSF_LOCAL) 7928 && bfd_is_arm_special_symbol_name (q->symbol.name, 7929 BFD_ARM_SPECIAL_SYM_TYPE_ANY)) 7930 continue; 7931 /* Fall through. */ 7932 if (bfd_get_section (&q->symbol) == section 7933 && q->symbol.value >= low_func 7934 && q->symbol.value <= offset) 7935 { 7936 func = (asymbol *) q; 7937 low_func = q->symbol.value; 7938 } 7939 break; 7940 } 7941 } 7942 7943 if (func == NULL) 7944 return FALSE; 7945 7946 if (filename_ptr) 7947 *filename_ptr = filename; 7948 if (functionname_ptr) 7949 *functionname_ptr = bfd_asymbol_name (func); 7950 7951 return TRUE; 7952} 7953 7954 7955/* Find the nearest line to a particular section and offset, for error 7956 reporting. This code is a duplicate of the code in elf.c, except 7957 that it uses arm_elf_find_function. */ 7958 7959static bfd_boolean 7960elf32_arm_find_nearest_line (bfd * abfd, 7961 asection * section, 7962 asymbol ** symbols, 7963 bfd_vma offset, 7964 const char ** filename_ptr, 7965 const char ** functionname_ptr, 7966 unsigned int * line_ptr) 7967{ 7968 bfd_boolean found = FALSE; 7969 7970 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */ 7971 7972 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset, 7973 filename_ptr, functionname_ptr, 7974 line_ptr, 0, 7975 & elf_tdata (abfd)->dwarf2_find_line_info)) 7976 { 7977 if (!*functionname_ptr) 7978 arm_elf_find_function (abfd, section, symbols, offset, 7979 *filename_ptr ? NULL : filename_ptr, 7980 functionname_ptr); 7981 7982 return TRUE; 7983 } 7984 7985 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, 7986 & found, filename_ptr, 7987 functionname_ptr, line_ptr, 7988 & elf_tdata (abfd)->line_info)) 7989 return FALSE; 7990 7991 if (found && (*functionname_ptr || *line_ptr)) 7992 return TRUE; 7993 7994 if (symbols == NULL) 7995 return FALSE; 7996 7997 if (! arm_elf_find_function (abfd, section, symbols, offset, 7998 filename_ptr, functionname_ptr)) 7999 return FALSE; 8000 8001 *line_ptr = 0; 8002 return TRUE; 8003} 8004 8005static bfd_boolean 8006elf32_arm_find_inliner_info (bfd * abfd, 8007 const char ** filename_ptr, 8008 const char ** functionname_ptr, 8009 unsigned int * line_ptr) 8010{ 8011 bfd_boolean found; 8012 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr, 8013 functionname_ptr, line_ptr, 8014 & elf_tdata (abfd)->dwarf2_find_line_info); 8015 return found; 8016} 8017 8018/* Adjust a symbol defined by a dynamic object and referenced by a 8019 regular object. The current definition is in some section of the 8020 dynamic object, but we're not including those sections. We have to 8021 change the definition to something the rest of the link can 8022 understand. */ 8023 8024static bfd_boolean 8025elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info, 8026 struct elf_link_hash_entry * h) 8027{ 8028 bfd * dynobj; 8029 asection * s; 8030 struct elf32_arm_link_hash_entry * eh; 8031 struct elf32_arm_link_hash_table *globals; 8032 8033 globals = elf32_arm_hash_table (info); 8034 dynobj = elf_hash_table (info)->dynobj; 8035 8036 /* Make sure we know what is going on here. */ 8037 BFD_ASSERT (dynobj != NULL 8038 && (h->needs_plt 8039 || h->u.weakdef != NULL 8040 || (h->def_dynamic 8041 && h->ref_regular 8042 && !h->def_regular))); 8043 8044 eh = (struct elf32_arm_link_hash_entry *) h; 8045 8046 /* If this is a function, put it in the procedure linkage table. We 8047 will fill in the contents of the procedure linkage table later, 8048 when we know the address of the .got section. */ 8049 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC 8050 || h->needs_plt) 8051 { 8052 if (h->plt.refcount <= 0 8053 || SYMBOL_CALLS_LOCAL (info, h) 8054 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 8055 && h->root.type == bfd_link_hash_undefweak)) 8056 { 8057 /* This case can occur if we saw a PLT32 reloc in an input 8058 file, but the symbol was never referred to by a dynamic 8059 object, or if all references were garbage collected. In 8060 such a case, we don't actually need to build a procedure 8061 linkage table, and we can just do a PC24 reloc instead. */ 8062 h->plt.offset = (bfd_vma) -1; 8063 eh->plt_thumb_refcount = 0; 8064 h->needs_plt = 0; 8065 } 8066 8067 return TRUE; 8068 } 8069 else 8070 { 8071 /* It's possible that we incorrectly decided a .plt reloc was 8072 needed for an R_ARM_PC24 or similar reloc to a non-function sym 8073 in check_relocs. We can't decide accurately between function 8074 and non-function syms in check-relocs; Objects loaded later in 8075 the link may change h->type. So fix it now. */ 8076 h->plt.offset = (bfd_vma) -1; 8077 eh->plt_thumb_refcount = 0; 8078 } 8079 8080 /* If this is a weak symbol, and there is a real definition, the 8081 processor independent code will have arranged for us to see the 8082 real definition first, and we can just use the same value. */ 8083 if (h->u.weakdef != NULL) 8084 { 8085 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 8086 || h->u.weakdef->root.type == bfd_link_hash_defweak); 8087 h->root.u.def.section = h->u.weakdef->root.u.def.section; 8088 h->root.u.def.value = h->u.weakdef->root.u.def.value; 8089 return TRUE; 8090 } 8091 8092 /* If there are no non-GOT references, we do not need a copy 8093 relocation. */ 8094 if (!h->non_got_ref) 8095 return TRUE; 8096 8097 /* This is a reference to a symbol defined by a dynamic object which 8098 is not a function. */ 8099 8100 /* If we are creating a shared library, we must presume that the 8101 only references to the symbol are via the global offset table. 8102 For such cases we need not do anything here; the relocations will 8103 be handled correctly by relocate_section. Relocatable executables 8104 can reference data in shared objects directly, so we don't need to 8105 do anything here. */ 8106 if (info->shared || globals->root.is_relocatable_executable) 8107 return TRUE; 8108 8109 if (h->size == 0) 8110 { 8111 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"), 8112 h->root.root.string); 8113 return TRUE; 8114 } 8115 8116 /* We must allocate the symbol in our .dynbss section, which will 8117 become part of the .bss section of the executable. There will be 8118 an entry for this symbol in the .dynsym section. The dynamic 8119 object will contain position independent code, so all references 8120 from the dynamic object to this symbol will go through the global 8121 offset table. The dynamic linker will use the .dynsym entry to 8122 determine the address it must put in the global offset table, so 8123 both the dynamic object and the regular object will refer to the 8124 same memory location for the variable. */ 8125 s = bfd_get_section_by_name (dynobj, ".dynbss"); 8126 BFD_ASSERT (s != NULL); 8127 8128 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to 8129 copy the initial value out of the dynamic object and into the 8130 runtime process image. We need to remember the offset into the 8131 .rel(a).bss section we are going to use. */ 8132 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 8133 { 8134 asection *srel; 8135 8136 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss")); 8137 BFD_ASSERT (srel != NULL); 8138 srel->size += RELOC_SIZE (globals); 8139 h->needs_copy = 1; 8140 } 8141 8142 return _bfd_elf_adjust_dynamic_copy (h, s); 8143} 8144 8145/* Allocate space in .plt, .got and associated reloc sections for 8146 dynamic relocs. */ 8147 8148static bfd_boolean 8149allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) 8150{ 8151 struct bfd_link_info *info; 8152 struct elf32_arm_link_hash_table *htab; 8153 struct elf32_arm_link_hash_entry *eh; 8154 struct elf32_arm_relocs_copied *p; 8155 8156 eh = (struct elf32_arm_link_hash_entry *) h; 8157 8158 if (h->root.type == bfd_link_hash_indirect) 8159 return TRUE; 8160 8161 if (h->root.type == bfd_link_hash_warning) 8162 /* When warning symbols are created, they **replace** the "real" 8163 entry in the hash table, thus we never get to see the real 8164 symbol in a hash traversal. So look at it now. */ 8165 h = (struct elf_link_hash_entry *) h->root.u.i.link; 8166 8167 info = (struct bfd_link_info *) inf; 8168 htab = elf32_arm_hash_table (info); 8169 8170 if (htab->root.dynamic_sections_created 8171 && h->plt.refcount > 0) 8172 { 8173 /* Make sure this symbol is output as a dynamic symbol. 8174 Undefined weak syms won't yet be marked as dynamic. */ 8175 if (h->dynindx == -1 8176 && !h->forced_local) 8177 { 8178 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 8179 return FALSE; 8180 } 8181 8182 if (info->shared 8183 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 8184 { 8185 asection *s = htab->splt; 8186 8187 /* If this is the first .plt entry, make room for the special 8188 first entry. */ 8189 if (s->size == 0) 8190 s->size += htab->plt_header_size; 8191 8192 h->plt.offset = s->size; 8193 8194 /* If we will insert a Thumb trampoline before this PLT, leave room 8195 for it. */ 8196 if (!htab->use_blx && eh->plt_thumb_refcount > 0) 8197 { 8198 h->plt.offset += PLT_THUMB_STUB_SIZE; 8199 s->size += PLT_THUMB_STUB_SIZE; 8200 } 8201 8202 /* If this symbol is not defined in a regular file, and we are 8203 not generating a shared library, then set the symbol to this 8204 location in the .plt. This is required to make function 8205 pointers compare as equal between the normal executable and 8206 the shared library. */ 8207 if (! info->shared 8208 && !h->def_regular) 8209 { 8210 h->root.u.def.section = s; 8211 h->root.u.def.value = h->plt.offset; 8212 8213 /* Make sure the function is not marked as Thumb, in case 8214 it is the target of an ABS32 relocation, which will 8215 point to the PLT entry. */ 8216 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC) 8217 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC); 8218 } 8219 8220 /* Make room for this entry. */ 8221 s->size += htab->plt_entry_size; 8222 8223 if (!htab->symbian_p) 8224 { 8225 /* We also need to make an entry in the .got.plt section, which 8226 will be placed in the .got section by the linker script. */ 8227 eh->plt_got_offset = htab->sgotplt->size; 8228 htab->sgotplt->size += 4; 8229 } 8230 8231 /* We also need to make an entry in the .rel(a).plt section. */ 8232 htab->srelplt->size += RELOC_SIZE (htab); 8233 8234 /* VxWorks executables have a second set of relocations for 8235 each PLT entry. They go in a separate relocation section, 8236 which is processed by the kernel loader. */ 8237 if (htab->vxworks_p && !info->shared) 8238 { 8239 /* There is a relocation for the initial PLT entry: 8240 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */ 8241 if (h->plt.offset == htab->plt_header_size) 8242 htab->srelplt2->size += RELOC_SIZE (htab); 8243 8244 /* There are two extra relocations for each subsequent 8245 PLT entry: an R_ARM_32 relocation for the GOT entry, 8246 and an R_ARM_32 relocation for the PLT entry. */ 8247 htab->srelplt2->size += RELOC_SIZE (htab) * 2; 8248 } 8249 } 8250 else 8251 { 8252 h->plt.offset = (bfd_vma) -1; 8253 h->needs_plt = 0; 8254 } 8255 } 8256 else 8257 { 8258 h->plt.offset = (bfd_vma) -1; 8259 h->needs_plt = 0; 8260 } 8261 8262 if (h->got.refcount > 0) 8263 { 8264 asection *s; 8265 bfd_boolean dyn; 8266 int tls_type = elf32_arm_hash_entry (h)->tls_type; 8267 int indx; 8268 8269 /* Make sure this symbol is output as a dynamic symbol. 8270 Undefined weak syms won't yet be marked as dynamic. */ 8271 if (h->dynindx == -1 8272 && !h->forced_local) 8273 { 8274 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 8275 return FALSE; 8276 } 8277 8278 if (!htab->symbian_p) 8279 { 8280 s = htab->sgot; 8281 h->got.offset = s->size; 8282 8283 if (tls_type == GOT_UNKNOWN) 8284 abort (); 8285 8286 if (tls_type == GOT_NORMAL) 8287 /* Non-TLS symbols need one GOT slot. */ 8288 s->size += 4; 8289 else 8290 { 8291 if (tls_type & GOT_TLS_GD) 8292 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */ 8293 s->size += 8; 8294 if (tls_type & GOT_TLS_IE) 8295 /* R_ARM_TLS_IE32 needs one GOT slot. */ 8296 s->size += 4; 8297 } 8298 8299 dyn = htab->root.dynamic_sections_created; 8300 8301 indx = 0; 8302 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 8303 && (!info->shared 8304 || !SYMBOL_REFERENCES_LOCAL (info, h))) 8305 indx = h->dynindx; 8306 8307 if (tls_type != GOT_NORMAL 8308 && (info->shared || indx != 0) 8309 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 8310 || h->root.type != bfd_link_hash_undefweak)) 8311 { 8312 if (tls_type & GOT_TLS_IE) 8313 htab->srelgot->size += RELOC_SIZE (htab); 8314 8315 if (tls_type & GOT_TLS_GD) 8316 htab->srelgot->size += RELOC_SIZE (htab); 8317 8318 if ((tls_type & GOT_TLS_GD) && indx != 0) 8319 htab->srelgot->size += RELOC_SIZE (htab); 8320 } 8321 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 8322 || h->root.type != bfd_link_hash_undefweak) 8323 && (info->shared 8324 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 8325 htab->srelgot->size += RELOC_SIZE (htab); 8326 } 8327 } 8328 else 8329 h->got.offset = (bfd_vma) -1; 8330 8331 /* Allocate stubs for exported Thumb functions on v4t. */ 8332 if (!htab->use_blx && h->dynindx != -1 8333 && h->def_regular 8334 && ELF_ST_TYPE (h->type) == STT_ARM_TFUNC 8335 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 8336 { 8337 struct elf_link_hash_entry * th; 8338 struct bfd_link_hash_entry * bh; 8339 struct elf_link_hash_entry * myh; 8340 char name[1024]; 8341 asection *s; 8342 bh = NULL; 8343 /* Create a new symbol to regist the real location of the function. */ 8344 s = h->root.u.def.section; 8345 sprintf(name, "__real_%s", h->root.root.string); 8346 _bfd_generic_link_add_one_symbol (info, s->owner, 8347 name, BSF_GLOBAL, s, 8348 h->root.u.def.value, 8349 NULL, TRUE, FALSE, &bh); 8350 8351 myh = (struct elf_link_hash_entry *) bh; 8352 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC); 8353 myh->forced_local = 1; 8354 eh->export_glue = myh; 8355 th = record_arm_to_thumb_glue (info, h); 8356 /* Point the symbol at the stub. */ 8357 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC); 8358 h->root.u.def.section = th->root.u.def.section; 8359 h->root.u.def.value = th->root.u.def.value & ~1; 8360 } 8361 8362 if (eh->relocs_copied == NULL) 8363 return TRUE; 8364 8365 /* In the shared -Bsymbolic case, discard space allocated for 8366 dynamic pc-relative relocs against symbols which turn out to be 8367 defined in regular objects. For the normal shared case, discard 8368 space for pc-relative relocs that have become local due to symbol 8369 visibility changes. */ 8370 8371 if (info->shared || htab->root.is_relocatable_executable) 8372 { 8373 /* The only relocs that use pc_count are R_ARM_REL32 and 8374 R_ARM_REL32_NOI, which will appear on something like 8375 ".long foo - .". We want calls to protected symbols to resolve 8376 directly to the function rather than going via the plt. If people 8377 want function pointer comparisons to work as expected then they 8378 should avoid writing assembly like ".long foo - .". */ 8379 if (SYMBOL_CALLS_LOCAL (info, h)) 8380 { 8381 struct elf32_arm_relocs_copied **pp; 8382 8383 for (pp = &eh->relocs_copied; (p = *pp) != NULL; ) 8384 { 8385 p->count -= p->pc_count; 8386 p->pc_count = 0; 8387 if (p->count == 0) 8388 *pp = p->next; 8389 else 8390 pp = &p->next; 8391 } 8392 } 8393 8394 /* Also discard relocs on undefined weak syms with non-default 8395 visibility. */ 8396 if (eh->relocs_copied != NULL 8397 && h->root.type == bfd_link_hash_undefweak) 8398 { 8399 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 8400 eh->relocs_copied = NULL; 8401 8402 /* Make sure undefined weak symbols are output as a dynamic 8403 symbol in PIEs. */ 8404 else if (h->dynindx == -1 8405 && !h->forced_local) 8406 { 8407 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 8408 return FALSE; 8409 } 8410 } 8411 8412 else if (htab->root.is_relocatable_executable && h->dynindx == -1 8413 && h->root.type == bfd_link_hash_new) 8414 { 8415 /* Output absolute symbols so that we can create relocations 8416 against them. For normal symbols we output a relocation 8417 against the section that contains them. */ 8418 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 8419 return FALSE; 8420 } 8421 8422 } 8423 else 8424 { 8425 /* For the non-shared case, discard space for relocs against 8426 symbols which turn out to need copy relocs or are not 8427 dynamic. */ 8428 8429 if (!h->non_got_ref 8430 && ((h->def_dynamic 8431 && !h->def_regular) 8432 || (htab->root.dynamic_sections_created 8433 && (h->root.type == bfd_link_hash_undefweak 8434 || h->root.type == bfd_link_hash_undefined)))) 8435 { 8436 /* Make sure this symbol is output as a dynamic symbol. 8437 Undefined weak syms won't yet be marked as dynamic. */ 8438 if (h->dynindx == -1 8439 && !h->forced_local) 8440 { 8441 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 8442 return FALSE; 8443 } 8444 8445 /* If that succeeded, we know we'll be keeping all the 8446 relocs. */ 8447 if (h->dynindx != -1) 8448 goto keep; 8449 } 8450 8451 eh->relocs_copied = NULL; 8452 8453 keep: ; 8454 } 8455 8456 /* Finally, allocate space. */ 8457 for (p = eh->relocs_copied; p != NULL; p = p->next) 8458 { 8459 asection *sreloc = elf_section_data (p->section)->sreloc; 8460 sreloc->size += p->count * RELOC_SIZE (htab); 8461 } 8462 8463 return TRUE; 8464} 8465 8466/* Find any dynamic relocs that apply to read-only sections. */ 8467 8468static bfd_boolean 8469elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf) 8470{ 8471 struct elf32_arm_link_hash_entry *eh; 8472 struct elf32_arm_relocs_copied *p; 8473 8474 if (h->root.type == bfd_link_hash_warning) 8475 h = (struct elf_link_hash_entry *) h->root.u.i.link; 8476 8477 eh = (struct elf32_arm_link_hash_entry *) h; 8478 for (p = eh->relocs_copied; p != NULL; p = p->next) 8479 { 8480 asection *s = p->section; 8481 8482 if (s != NULL && (s->flags & SEC_READONLY) != 0) 8483 { 8484 struct bfd_link_info *info = (struct bfd_link_info *) inf; 8485 8486 info->flags |= DF_TEXTREL; 8487 8488 /* Not an error, just cut short the traversal. */ 8489 return FALSE; 8490 } 8491 } 8492 return TRUE; 8493} 8494 8495void 8496bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *info, 8497 int byteswap_code) 8498{ 8499 struct elf32_arm_link_hash_table *globals; 8500 8501 globals = elf32_arm_hash_table (info); 8502 globals->byteswap_code = byteswap_code; 8503} 8504 8505/* Set the sizes of the dynamic sections. */ 8506 8507static bfd_boolean 8508elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, 8509 struct bfd_link_info * info) 8510{ 8511 bfd * dynobj; 8512 asection * s; 8513 bfd_boolean plt; 8514 bfd_boolean relocs; 8515 bfd *ibfd; 8516 struct elf32_arm_link_hash_table *htab; 8517 8518 htab = elf32_arm_hash_table (info); 8519 dynobj = elf_hash_table (info)->dynobj; 8520 BFD_ASSERT (dynobj != NULL); 8521 check_use_blx (htab); 8522 8523 if (elf_hash_table (info)->dynamic_sections_created) 8524 { 8525 /* Set the contents of the .interp section to the interpreter. */ 8526 if (info->executable) 8527 { 8528 s = bfd_get_section_by_name (dynobj, ".interp"); 8529 BFD_ASSERT (s != NULL); 8530 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 8531 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 8532 } 8533 } 8534 8535 /* Set up .got offsets for local syms, and space for local dynamic 8536 relocs. */ 8537 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 8538 { 8539 bfd_signed_vma *local_got; 8540 bfd_signed_vma *end_local_got; 8541 char *local_tls_type; 8542 bfd_size_type locsymcount; 8543 Elf_Internal_Shdr *symtab_hdr; 8544 asection *srel; 8545 8546 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 8547 continue; 8548 8549 for (s = ibfd->sections; s != NULL; s = s->next) 8550 { 8551 struct elf32_arm_relocs_copied *p; 8552 8553 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next) 8554 { 8555 if (!bfd_is_abs_section (p->section) 8556 && bfd_is_abs_section (p->section->output_section)) 8557 { 8558 /* Input section has been discarded, either because 8559 it is a copy of a linkonce section or due to 8560 linker script /DISCARD/, so we'll be discarding 8561 the relocs too. */ 8562 } 8563 else if (p->count != 0) 8564 { 8565 srel = elf_section_data (p->section)->sreloc; 8566 srel->size += p->count * RELOC_SIZE (htab); 8567 if ((p->section->output_section->flags & SEC_READONLY) != 0) 8568 info->flags |= DF_TEXTREL; 8569 } 8570 } 8571 } 8572 8573 local_got = elf_local_got_refcounts (ibfd); 8574 if (!local_got) 8575 continue; 8576 8577 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 8578 locsymcount = symtab_hdr->sh_info; 8579 end_local_got = local_got + locsymcount; 8580 local_tls_type = elf32_arm_local_got_tls_type (ibfd); 8581 s = htab->sgot; 8582 srel = htab->srelgot; 8583 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 8584 { 8585 if (*local_got > 0) 8586 { 8587 *local_got = s->size; 8588 if (*local_tls_type & GOT_TLS_GD) 8589 /* TLS_GD relocs need an 8-byte structure in the GOT. */ 8590 s->size += 8; 8591 if (*local_tls_type & GOT_TLS_IE) 8592 s->size += 4; 8593 if (*local_tls_type == GOT_NORMAL) 8594 s->size += 4; 8595 8596 if (info->shared || *local_tls_type == GOT_TLS_GD) 8597 srel->size += RELOC_SIZE (htab); 8598 } 8599 else 8600 *local_got = (bfd_vma) -1; 8601 } 8602 } 8603 8604 if (htab->tls_ldm_got.refcount > 0) 8605 { 8606 /* Allocate two GOT entries and one dynamic relocation (if necessary) 8607 for R_ARM_TLS_LDM32 relocations. */ 8608 htab->tls_ldm_got.offset = htab->sgot->size; 8609 htab->sgot->size += 8; 8610 if (info->shared) 8611 htab->srelgot->size += RELOC_SIZE (htab); 8612 } 8613 else 8614 htab->tls_ldm_got.offset = -1; 8615 8616 /* Allocate global sym .plt and .got entries, and space for global 8617 sym dynamic relocs. */ 8618 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info); 8619 8620 /* Here we rummage through the found bfds to collect glue information. */ 8621 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 8622 { 8623 /* Initialise mapping tables for code/data. */ 8624 bfd_elf32_arm_init_maps (ibfd); 8625 8626 if (!bfd_elf32_arm_process_before_allocation (ibfd, info) 8627 || !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info)) 8628 /* xgettext:c-format */ 8629 _bfd_error_handler (_("Errors encountered processing file %s"), 8630 ibfd->filename); 8631 } 8632 8633 /* The check_relocs and adjust_dynamic_symbol entry points have 8634 determined the sizes of the various dynamic sections. Allocate 8635 memory for them. */ 8636 plt = FALSE; 8637 relocs = FALSE; 8638 for (s = dynobj->sections; s != NULL; s = s->next) 8639 { 8640 const char * name; 8641 8642 if ((s->flags & SEC_LINKER_CREATED) == 0) 8643 continue; 8644 8645 /* It's OK to base decisions on the section name, because none 8646 of the dynobj section names depend upon the input files. */ 8647 name = bfd_get_section_name (dynobj, s); 8648 8649 if (strcmp (name, ".plt") == 0) 8650 { 8651 /* Remember whether there is a PLT. */ 8652 plt = s->size != 0; 8653 } 8654 else if (CONST_STRNEQ (name, ".rel")) 8655 { 8656 if (s->size != 0) 8657 { 8658 /* Remember whether there are any reloc sections other 8659 than .rel(a).plt and .rela.plt.unloaded. */ 8660 if (s != htab->srelplt && s != htab->srelplt2) 8661 relocs = TRUE; 8662 8663 /* We use the reloc_count field as a counter if we need 8664 to copy relocs into the output file. */ 8665 s->reloc_count = 0; 8666 } 8667 } 8668 else if (! CONST_STRNEQ (name, ".got") 8669 && strcmp (name, ".dynbss") != 0) 8670 { 8671 /* It's not one of our sections, so don't allocate space. */ 8672 continue; 8673 } 8674 8675 if (s->size == 0) 8676 { 8677 /* If we don't need this section, strip it from the 8678 output file. This is mostly to handle .rel(a).bss and 8679 .rel(a).plt. We must create both sections in 8680 create_dynamic_sections, because they must be created 8681 before the linker maps input sections to output 8682 sections. The linker does that before 8683 adjust_dynamic_symbol is called, and it is that 8684 function which decides whether anything needs to go 8685 into these sections. */ 8686 s->flags |= SEC_EXCLUDE; 8687 continue; 8688 } 8689 8690 if ((s->flags & SEC_HAS_CONTENTS) == 0) 8691 continue; 8692 8693 /* Allocate memory for the section contents. */ 8694 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 8695 if (s->contents == NULL) 8696 return FALSE; 8697 } 8698 8699 if (elf_hash_table (info)->dynamic_sections_created) 8700 { 8701 /* Add some entries to the .dynamic section. We fill in the 8702 values later, in elf32_arm_finish_dynamic_sections, but we 8703 must add the entries now so that we get the correct size for 8704 the .dynamic section. The DT_DEBUG entry is filled in by the 8705 dynamic linker and used by the debugger. */ 8706#define add_dynamic_entry(TAG, VAL) \ 8707 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 8708 8709 if (info->executable) 8710 { 8711 if (!add_dynamic_entry (DT_DEBUG, 0)) 8712 return FALSE; 8713 } 8714 8715 if (plt) 8716 { 8717 if ( !add_dynamic_entry (DT_PLTGOT, 0) 8718 || !add_dynamic_entry (DT_PLTRELSZ, 0) 8719 || !add_dynamic_entry (DT_PLTREL, 8720 htab->use_rel ? DT_REL : DT_RELA) 8721 || !add_dynamic_entry (DT_JMPREL, 0)) 8722 return FALSE; 8723 } 8724 8725 if (relocs) 8726 { 8727 if (htab->use_rel) 8728 { 8729 if (!add_dynamic_entry (DT_REL, 0) 8730 || !add_dynamic_entry (DT_RELSZ, 0) 8731 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab))) 8732 return FALSE; 8733 } 8734 else 8735 { 8736 if (!add_dynamic_entry (DT_RELA, 0) 8737 || !add_dynamic_entry (DT_RELASZ, 0) 8738 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab))) 8739 return FALSE; 8740 } 8741 } 8742 8743 /* If any dynamic relocs apply to a read-only section, 8744 then we need a DT_TEXTREL entry. */ 8745 if ((info->flags & DF_TEXTREL) == 0) 8746 elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs, 8747 (PTR) info); 8748 8749 if ((info->flags & DF_TEXTREL) != 0) 8750 { 8751 if (!add_dynamic_entry (DT_TEXTREL, 0)) 8752 return FALSE; 8753 } 8754 } 8755#undef add_dynamic_entry 8756 8757 return TRUE; 8758} 8759 8760/* Finish up dynamic symbol handling. We set the contents of various 8761 dynamic sections here. */ 8762 8763static bfd_boolean 8764elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info, 8765 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym) 8766{ 8767 bfd * dynobj; 8768 struct elf32_arm_link_hash_table *htab; 8769 struct elf32_arm_link_hash_entry *eh; 8770 8771 dynobj = elf_hash_table (info)->dynobj; 8772 htab = elf32_arm_hash_table (info); 8773 eh = (struct elf32_arm_link_hash_entry *) h; 8774 8775 if (h->plt.offset != (bfd_vma) -1) 8776 { 8777 asection * splt; 8778 asection * srel; 8779 bfd_byte *loc; 8780 bfd_vma plt_index; 8781 Elf_Internal_Rela rel; 8782 8783 /* This symbol has an entry in the procedure linkage table. Set 8784 it up. */ 8785 8786 BFD_ASSERT (h->dynindx != -1); 8787 8788 splt = bfd_get_section_by_name (dynobj, ".plt"); 8789 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt")); 8790 BFD_ASSERT (splt != NULL && srel != NULL); 8791 8792 /* Fill in the entry in the procedure linkage table. */ 8793 if (htab->symbian_p) 8794 { 8795 put_arm_insn (htab, output_bfd, 8796 elf32_arm_symbian_plt_entry[0], 8797 splt->contents + h->plt.offset); 8798 bfd_put_32 (output_bfd, 8799 elf32_arm_symbian_plt_entry[1], 8800 splt->contents + h->plt.offset + 4); 8801 8802 /* Fill in the entry in the .rel.plt section. */ 8803 rel.r_offset = (splt->output_section->vma 8804 + splt->output_offset 8805 + h->plt.offset + 4); 8806 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT); 8807 8808 /* Get the index in the procedure linkage table which 8809 corresponds to this symbol. This is the index of this symbol 8810 in all the symbols for which we are making plt entries. The 8811 first entry in the procedure linkage table is reserved. */ 8812 plt_index = ((h->plt.offset - htab->plt_header_size) 8813 / htab->plt_entry_size); 8814 } 8815 else 8816 { 8817 bfd_vma got_offset, got_address, plt_address; 8818 bfd_vma got_displacement; 8819 asection * sgot; 8820 bfd_byte * ptr; 8821 8822 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 8823 BFD_ASSERT (sgot != NULL); 8824 8825 /* Get the offset into the .got.plt table of the entry that 8826 corresponds to this function. */ 8827 got_offset = eh->plt_got_offset; 8828 8829 /* Get the index in the procedure linkage table which 8830 corresponds to this symbol. This is the index of this symbol 8831 in all the symbols for which we are making plt entries. The 8832 first three entries in .got.plt are reserved; after that 8833 symbols appear in the same order as in .plt. */ 8834 plt_index = (got_offset - 12) / 4; 8835 8836 /* Calculate the address of the GOT entry. */ 8837 got_address = (sgot->output_section->vma 8838 + sgot->output_offset 8839 + got_offset); 8840 8841 /* ...and the address of the PLT entry. */ 8842 plt_address = (splt->output_section->vma 8843 + splt->output_offset 8844 + h->plt.offset); 8845 8846 ptr = htab->splt->contents + h->plt.offset; 8847 if (htab->vxworks_p && info->shared) 8848 { 8849 unsigned int i; 8850 bfd_vma val; 8851 8852 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4) 8853 { 8854 val = elf32_arm_vxworks_shared_plt_entry[i]; 8855 if (i == 2) 8856 val |= got_address - sgot->output_section->vma; 8857 if (i == 5) 8858 val |= plt_index * RELOC_SIZE (htab); 8859 if (i == 2 || i == 5) 8860 bfd_put_32 (output_bfd, val, ptr); 8861 else 8862 put_arm_insn (htab, output_bfd, val, ptr); 8863 } 8864 } 8865 else if (htab->vxworks_p) 8866 { 8867 unsigned int i; 8868 bfd_vma val; 8869 8870 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4) 8871 { 8872 val = elf32_arm_vxworks_exec_plt_entry[i]; 8873 if (i == 2) 8874 val |= got_address; 8875 if (i == 4) 8876 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2); 8877 if (i == 5) 8878 val |= plt_index * RELOC_SIZE (htab); 8879 if (i == 2 || i == 5) 8880 bfd_put_32 (output_bfd, val, ptr); 8881 else 8882 put_arm_insn (htab, output_bfd, val, ptr); 8883 } 8884 8885 loc = (htab->srelplt2->contents 8886 + (plt_index * 2 + 1) * RELOC_SIZE (htab)); 8887 8888 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation 8889 referencing the GOT for this PLT entry. */ 8890 rel.r_offset = plt_address + 8; 8891 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32); 8892 rel.r_addend = got_offset; 8893 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc); 8894 loc += RELOC_SIZE (htab); 8895 8896 /* Create the R_ARM_ABS32 relocation referencing the 8897 beginning of the PLT for this GOT entry. */ 8898 rel.r_offset = got_address; 8899 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32); 8900 rel.r_addend = 0; 8901 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc); 8902 } 8903 else 8904 { 8905 /* Calculate the displacement between the PLT slot and the 8906 entry in the GOT. The eight-byte offset accounts for the 8907 value produced by adding to pc in the first instruction 8908 of the PLT stub. */ 8909 got_displacement = got_address - (plt_address + 8); 8910 8911 BFD_ASSERT ((got_displacement & 0xf0000000) == 0); 8912 8913 if (!htab->use_blx && eh->plt_thumb_refcount > 0) 8914 { 8915 put_thumb_insn (htab, output_bfd, 8916 elf32_arm_plt_thumb_stub[0], ptr - 4); 8917 put_thumb_insn (htab, output_bfd, 8918 elf32_arm_plt_thumb_stub[1], ptr - 2); 8919 } 8920 8921 put_arm_insn (htab, output_bfd, 8922 elf32_arm_plt_entry[0] 8923 | ((got_displacement & 0x0ff00000) >> 20), 8924 ptr + 0); 8925 put_arm_insn (htab, output_bfd, 8926 elf32_arm_plt_entry[1] 8927 | ((got_displacement & 0x000ff000) >> 12), 8928 ptr+ 4); 8929 put_arm_insn (htab, output_bfd, 8930 elf32_arm_plt_entry[2] 8931 | (got_displacement & 0x00000fff), 8932 ptr + 8); 8933#ifdef FOUR_WORD_PLT 8934 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12); 8935#endif 8936 } 8937 8938 /* Fill in the entry in the global offset table. */ 8939 bfd_put_32 (output_bfd, 8940 (splt->output_section->vma 8941 + splt->output_offset), 8942 sgot->contents + got_offset); 8943 8944 /* Fill in the entry in the .rel(a).plt section. */ 8945 rel.r_addend = 0; 8946 rel.r_offset = got_address; 8947 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT); 8948 } 8949 8950 loc = srel->contents + plt_index * RELOC_SIZE (htab); 8951 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc); 8952 8953 if (!h->def_regular) 8954 { 8955 /* Mark the symbol as undefined, rather than as defined in 8956 the .plt section. Leave the value alone. */ 8957 sym->st_shndx = SHN_UNDEF; 8958 /* If the symbol is weak, we do need to clear the value. 8959 Otherwise, the PLT entry would provide a definition for 8960 the symbol even if the symbol wasn't defined anywhere, 8961 and so the symbol would never be NULL. */ 8962 if (!h->ref_regular_nonweak) 8963 sym->st_value = 0; 8964 } 8965 } 8966 8967 if (h->got.offset != (bfd_vma) -1 8968 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0 8969 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0) 8970 { 8971 asection * sgot; 8972 asection * srel; 8973 Elf_Internal_Rela rel; 8974 bfd_byte *loc; 8975 bfd_vma offset; 8976 8977 /* This symbol has an entry in the global offset table. Set it 8978 up. */ 8979 sgot = bfd_get_section_by_name (dynobj, ".got"); 8980 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got")); 8981 BFD_ASSERT (sgot != NULL && srel != NULL); 8982 8983 offset = (h->got.offset & ~(bfd_vma) 1); 8984 rel.r_addend = 0; 8985 rel.r_offset = (sgot->output_section->vma 8986 + sgot->output_offset 8987 + offset); 8988 8989 /* If this is a static link, or it is a -Bsymbolic link and the 8990 symbol is defined locally or was forced to be local because 8991 of a version file, we just want to emit a RELATIVE reloc. 8992 The entry in the global offset table will already have been 8993 initialized in the relocate_section function. */ 8994 if (info->shared 8995 && SYMBOL_REFERENCES_LOCAL (info, h)) 8996 { 8997 BFD_ASSERT((h->got.offset & 1) != 0); 8998 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE); 8999 if (!htab->use_rel) 9000 { 9001 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset); 9002 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset); 9003 } 9004 } 9005 else 9006 { 9007 BFD_ASSERT((h->got.offset & 1) == 0); 9008 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset); 9009 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT); 9010 } 9011 9012 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab); 9013 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc); 9014 } 9015 9016 if (h->needs_copy) 9017 { 9018 asection * s; 9019 Elf_Internal_Rela rel; 9020 bfd_byte *loc; 9021 9022 /* This symbol needs a copy reloc. Set it up. */ 9023 BFD_ASSERT (h->dynindx != -1 9024 && (h->root.type == bfd_link_hash_defined 9025 || h->root.type == bfd_link_hash_defweak)); 9026 9027 s = bfd_get_section_by_name (h->root.u.def.section->owner, 9028 RELOC_SECTION (htab, ".bss")); 9029 BFD_ASSERT (s != NULL); 9030 9031 rel.r_addend = 0; 9032 rel.r_offset = (h->root.u.def.value 9033 + h->root.u.def.section->output_section->vma 9034 + h->root.u.def.section->output_offset); 9035 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY); 9036 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab); 9037 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc); 9038 } 9039 9040 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks, 9041 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative 9042 to the ".got" section. */ 9043 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 9044 || (!htab->vxworks_p && h == htab->root.hgot)) 9045 sym->st_shndx = SHN_ABS; 9046 9047 return TRUE; 9048} 9049 9050/* Finish up the dynamic sections. */ 9051 9052static bfd_boolean 9053elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info) 9054{ 9055 bfd * dynobj; 9056 asection * sgot; 9057 asection * sdyn; 9058 9059 dynobj = elf_hash_table (info)->dynobj; 9060 9061 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 9062 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL); 9063 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 9064 9065 if (elf_hash_table (info)->dynamic_sections_created) 9066 { 9067 asection *splt; 9068 Elf32_External_Dyn *dyncon, *dynconend; 9069 struct elf32_arm_link_hash_table *htab; 9070 9071 htab = elf32_arm_hash_table (info); 9072 splt = bfd_get_section_by_name (dynobj, ".plt"); 9073 BFD_ASSERT (splt != NULL && sdyn != NULL); 9074 9075 dyncon = (Elf32_External_Dyn *) sdyn->contents; 9076 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 9077 9078 for (; dyncon < dynconend; dyncon++) 9079 { 9080 Elf_Internal_Dyn dyn; 9081 const char * name; 9082 asection * s; 9083 9084 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 9085 9086 switch (dyn.d_tag) 9087 { 9088 unsigned int type; 9089 9090 default: 9091 break; 9092 9093 case DT_HASH: 9094 name = ".hash"; 9095 goto get_vma_if_bpabi; 9096 case DT_STRTAB: 9097 name = ".dynstr"; 9098 goto get_vma_if_bpabi; 9099 case DT_SYMTAB: 9100 name = ".dynsym"; 9101 goto get_vma_if_bpabi; 9102 case DT_VERSYM: 9103 name = ".gnu.version"; 9104 goto get_vma_if_bpabi; 9105 case DT_VERDEF: 9106 name = ".gnu.version_d"; 9107 goto get_vma_if_bpabi; 9108 case DT_VERNEED: 9109 name = ".gnu.version_r"; 9110 goto get_vma_if_bpabi; 9111 9112 case DT_PLTGOT: 9113 name = ".got"; 9114 goto get_vma; 9115 case DT_JMPREL: 9116 name = RELOC_SECTION (htab, ".plt"); 9117 get_vma: 9118 s = bfd_get_section_by_name (output_bfd, name); 9119 BFD_ASSERT (s != NULL); 9120 if (!htab->symbian_p) 9121 dyn.d_un.d_ptr = s->vma; 9122 else 9123 /* In the BPABI, tags in the PT_DYNAMIC section point 9124 at the file offset, not the memory address, for the 9125 convenience of the post linker. */ 9126 dyn.d_un.d_ptr = s->filepos; 9127 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 9128 break; 9129 9130 get_vma_if_bpabi: 9131 if (htab->symbian_p) 9132 goto get_vma; 9133 break; 9134 9135 case DT_PLTRELSZ: 9136 s = bfd_get_section_by_name (output_bfd, 9137 RELOC_SECTION (htab, ".plt")); 9138 BFD_ASSERT (s != NULL); 9139 dyn.d_un.d_val = s->size; 9140 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 9141 break; 9142 9143 case DT_RELSZ: 9144 case DT_RELASZ: 9145 if (!htab->symbian_p) 9146 { 9147 /* My reading of the SVR4 ABI indicates that the 9148 procedure linkage table relocs (DT_JMPREL) should be 9149 included in the overall relocs (DT_REL). This is 9150 what Solaris does. However, UnixWare can not handle 9151 that case. Therefore, we override the DT_RELSZ entry 9152 here to make it not include the JMPREL relocs. Since 9153 the linker script arranges for .rel(a).plt to follow all 9154 other relocation sections, we don't have to worry 9155 about changing the DT_REL entry. */ 9156 s = bfd_get_section_by_name (output_bfd, 9157 RELOC_SECTION (htab, ".plt")); 9158 if (s != NULL) 9159 dyn.d_un.d_val -= s->size; 9160 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 9161 break; 9162 } 9163 /* Fall through */ 9164 9165 case DT_REL: 9166 case DT_RELA: 9167 /* In the BPABI, the DT_REL tag must point at the file 9168 offset, not the VMA, of the first relocation 9169 section. So, we use code similar to that in 9170 elflink.c, but do not check for SHF_ALLOC on the 9171 relcoation section, since relocations sections are 9172 never allocated under the BPABI. The comments above 9173 about Unixware notwithstanding, we include all of the 9174 relocations here. */ 9175 if (htab->symbian_p) 9176 { 9177 unsigned int i; 9178 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ) 9179 ? SHT_REL : SHT_RELA); 9180 dyn.d_un.d_val = 0; 9181 for (i = 1; i < elf_numsections (output_bfd); i++) 9182 { 9183 Elf_Internal_Shdr *hdr 9184 = elf_elfsections (output_bfd)[i]; 9185 if (hdr->sh_type == type) 9186 { 9187 if (dyn.d_tag == DT_RELSZ 9188 || dyn.d_tag == DT_RELASZ) 9189 dyn.d_un.d_val += hdr->sh_size; 9190 else if ((ufile_ptr) hdr->sh_offset 9191 <= dyn.d_un.d_val - 1) 9192 dyn.d_un.d_val = hdr->sh_offset; 9193 } 9194 } 9195 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 9196 } 9197 break; 9198 9199 /* Set the bottom bit of DT_INIT/FINI if the 9200 corresponding function is Thumb. */ 9201 case DT_INIT: 9202 name = info->init_function; 9203 goto get_sym; 9204 case DT_FINI: 9205 name = info->fini_function; 9206 get_sym: 9207 /* If it wasn't set by elf_bfd_final_link 9208 then there is nothing to adjust. */ 9209 if (dyn.d_un.d_val != 0) 9210 { 9211 struct elf_link_hash_entry * eh; 9212 9213 eh = elf_link_hash_lookup (elf_hash_table (info), name, 9214 FALSE, FALSE, TRUE); 9215 if (eh != (struct elf_link_hash_entry *) NULL 9216 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC) 9217 { 9218 dyn.d_un.d_val |= 1; 9219 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 9220 } 9221 } 9222 break; 9223 } 9224 } 9225 9226 /* Fill in the first entry in the procedure linkage table. */ 9227 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size) 9228 { 9229 const bfd_vma *plt0_entry; 9230 bfd_vma got_address, plt_address, got_displacement; 9231 9232 /* Calculate the addresses of the GOT and PLT. */ 9233 got_address = sgot->output_section->vma + sgot->output_offset; 9234 plt_address = splt->output_section->vma + splt->output_offset; 9235 9236 if (htab->vxworks_p) 9237 { 9238 /* The VxWorks GOT is relocated by the dynamic linker. 9239 Therefore, we must emit relocations rather than simply 9240 computing the values now. */ 9241 Elf_Internal_Rela rel; 9242 9243 plt0_entry = elf32_arm_vxworks_exec_plt0_entry; 9244 put_arm_insn (htab, output_bfd, plt0_entry[0], 9245 splt->contents + 0); 9246 put_arm_insn (htab, output_bfd, plt0_entry[1], 9247 splt->contents + 4); 9248 put_arm_insn (htab, output_bfd, plt0_entry[2], 9249 splt->contents + 8); 9250 bfd_put_32 (output_bfd, got_address, splt->contents + 12); 9251 9252 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */ 9253 rel.r_offset = plt_address + 12; 9254 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32); 9255 rel.r_addend = 0; 9256 SWAP_RELOC_OUT (htab) (output_bfd, &rel, 9257 htab->srelplt2->contents); 9258 } 9259 else 9260 { 9261 got_displacement = got_address - (plt_address + 16); 9262 9263 plt0_entry = elf32_arm_plt0_entry; 9264 put_arm_insn (htab, output_bfd, plt0_entry[0], 9265 splt->contents + 0); 9266 put_arm_insn (htab, output_bfd, plt0_entry[1], 9267 splt->contents + 4); 9268 put_arm_insn (htab, output_bfd, plt0_entry[2], 9269 splt->contents + 8); 9270 put_arm_insn (htab, output_bfd, plt0_entry[3], 9271 splt->contents + 12); 9272 9273#ifdef FOUR_WORD_PLT 9274 /* The displacement value goes in the otherwise-unused 9275 last word of the second entry. */ 9276 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28); 9277#else 9278 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16); 9279#endif 9280 } 9281 } 9282 9283 /* UnixWare sets the entsize of .plt to 4, although that doesn't 9284 really seem like the right value. */ 9285 if (splt->output_section->owner == output_bfd) 9286 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 9287 9288 if (htab->vxworks_p && !info->shared && htab->splt->size > 0) 9289 { 9290 /* Correct the .rel(a).plt.unloaded relocations. They will have 9291 incorrect symbol indexes. */ 9292 int num_plts; 9293 unsigned char *p; 9294 9295 num_plts = ((htab->splt->size - htab->plt_header_size) 9296 / htab->plt_entry_size); 9297 p = htab->srelplt2->contents + RELOC_SIZE (htab); 9298 9299 for (; num_plts; num_plts--) 9300 { 9301 Elf_Internal_Rela rel; 9302 9303 SWAP_RELOC_IN (htab) (output_bfd, p, &rel); 9304 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32); 9305 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p); 9306 p += RELOC_SIZE (htab); 9307 9308 SWAP_RELOC_IN (htab) (output_bfd, p, &rel); 9309 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32); 9310 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p); 9311 p += RELOC_SIZE (htab); 9312 } 9313 } 9314 } 9315 9316 /* Fill in the first three entries in the global offset table. */ 9317 if (sgot) 9318 { 9319 if (sgot->size > 0) 9320 { 9321 if (sdyn == NULL) 9322 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 9323 else 9324 bfd_put_32 (output_bfd, 9325 sdyn->output_section->vma + sdyn->output_offset, 9326 sgot->contents); 9327 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 9328 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 9329 } 9330 9331 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 9332 } 9333 9334 return TRUE; 9335} 9336 9337static void 9338elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED) 9339{ 9340 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */ 9341 struct elf32_arm_link_hash_table *globals; 9342 9343 i_ehdrp = elf_elfheader (abfd); 9344 9345 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN) 9346 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION; 9347 else 9348 i_ehdrp->e_ident[EI_OSABI] = 0; 9349 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION; 9350 9351 if (link_info) 9352 { 9353 globals = elf32_arm_hash_table (link_info); 9354 if (globals->byteswap_code) 9355 i_ehdrp->e_flags |= EF_ARM_BE8; 9356 } 9357} 9358 9359static enum elf_reloc_type_class 9360elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela) 9361{ 9362 switch ((int) ELF32_R_TYPE (rela->r_info)) 9363 { 9364 case R_ARM_RELATIVE: 9365 return reloc_class_relative; 9366 case R_ARM_JUMP_SLOT: 9367 return reloc_class_plt; 9368 case R_ARM_COPY: 9369 return reloc_class_copy; 9370 default: 9371 return reloc_class_normal; 9372 } 9373} 9374 9375/* Set the right machine number for an Arm ELF file. */ 9376 9377static bfd_boolean 9378elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr) 9379{ 9380 if (hdr->sh_type == SHT_NOTE) 9381 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS; 9382 9383 return TRUE; 9384} 9385 9386static void 9387elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED) 9388{ 9389 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION); 9390} 9391 9392/* Return TRUE if this is an unwinding table entry. */ 9393 9394static bfd_boolean 9395is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name) 9396{ 9397 return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind) 9398 || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once)); 9399} 9400 9401 9402/* Set the type and flags for an ARM section. We do this by 9403 the section name, which is a hack, but ought to work. */ 9404 9405static bfd_boolean 9406elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec) 9407{ 9408 const char * name; 9409 9410 name = bfd_get_section_name (abfd, sec); 9411 9412 if (is_arm_elf_unwind_section_name (abfd, name)) 9413 { 9414 hdr->sh_type = SHT_ARM_EXIDX; 9415 hdr->sh_flags |= SHF_LINK_ORDER; 9416 } 9417 return TRUE; 9418} 9419 9420/* Handle an ARM specific section when reading an object file. This is 9421 called when bfd_section_from_shdr finds a section with an unknown 9422 type. */ 9423 9424static bfd_boolean 9425elf32_arm_section_from_shdr (bfd *abfd, 9426 Elf_Internal_Shdr * hdr, 9427 const char *name, 9428 int shindex) 9429{ 9430 /* There ought to be a place to keep ELF backend specific flags, but 9431 at the moment there isn't one. We just keep track of the 9432 sections by their name, instead. Fortunately, the ABI gives 9433 names for all the ARM specific sections, so we will probably get 9434 away with this. */ 9435 switch (hdr->sh_type) 9436 { 9437 case SHT_ARM_EXIDX: 9438 case SHT_ARM_PREEMPTMAP: 9439 case SHT_ARM_ATTRIBUTES: 9440 break; 9441 9442 default: 9443 return FALSE; 9444 } 9445 9446 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 9447 return FALSE; 9448 9449 return TRUE; 9450} 9451 9452/* A structure used to record a list of sections, independently 9453 of the next and prev fields in the asection structure. */ 9454typedef struct section_list 9455{ 9456 asection * sec; 9457 struct section_list * next; 9458 struct section_list * prev; 9459} 9460section_list; 9461 9462/* Unfortunately we need to keep a list of sections for which 9463 an _arm_elf_section_data structure has been allocated. This 9464 is because it is possible for functions like elf32_arm_write_section 9465 to be called on a section which has had an elf_data_structure 9466 allocated for it (and so the used_by_bfd field is valid) but 9467 for which the ARM extended version of this structure - the 9468 _arm_elf_section_data structure - has not been allocated. */ 9469static section_list * sections_with_arm_elf_section_data = NULL; 9470 9471static void 9472record_section_with_arm_elf_section_data (asection * sec) 9473{ 9474 struct section_list * entry; 9475 9476 entry = bfd_malloc (sizeof (* entry)); 9477 if (entry == NULL) 9478 return; 9479 entry->sec = sec; 9480 entry->next = sections_with_arm_elf_section_data; 9481 entry->prev = NULL; 9482 if (entry->next != NULL) 9483 entry->next->prev = entry; 9484 sections_with_arm_elf_section_data = entry; 9485} 9486 9487static struct section_list * 9488find_arm_elf_section_entry (asection * sec) 9489{ 9490 struct section_list * entry; 9491 static struct section_list * last_entry = NULL; 9492 9493 /* This is a short cut for the typical case where the sections are added 9494 to the sections_with_arm_elf_section_data list in forward order and 9495 then looked up here in backwards order. This makes a real difference 9496 to the ld-srec/sec64k.exp linker test. */ 9497 entry = sections_with_arm_elf_section_data; 9498 if (last_entry != NULL) 9499 { 9500 if (last_entry->sec == sec) 9501 entry = last_entry; 9502 else if (last_entry->next != NULL 9503 && last_entry->next->sec == sec) 9504 entry = last_entry->next; 9505 } 9506 9507 for (; entry; entry = entry->next) 9508 if (entry->sec == sec) 9509 break; 9510 9511 if (entry) 9512 /* Record the entry prior to this one - it is the entry we are most 9513 likely to want to locate next time. Also this way if we have been 9514 called from unrecord_section_with_arm_elf_section_data() we will not 9515 be caching a pointer that is about to be freed. */ 9516 last_entry = entry->prev; 9517 9518 return entry; 9519} 9520 9521static _arm_elf_section_data * 9522get_arm_elf_section_data (asection * sec) 9523{ 9524 struct section_list * entry; 9525 9526 entry = find_arm_elf_section_entry (sec); 9527 9528 if (entry) 9529 return elf32_arm_section_data (entry->sec); 9530 else 9531 return NULL; 9532} 9533 9534static void 9535unrecord_section_with_arm_elf_section_data (asection * sec) 9536{ 9537 struct section_list * entry; 9538 9539 entry = find_arm_elf_section_entry (sec); 9540 9541 if (entry) 9542 { 9543 if (entry->prev != NULL) 9544 entry->prev->next = entry->next; 9545 if (entry->next != NULL) 9546 entry->next->prev = entry->prev; 9547 if (entry == sections_with_arm_elf_section_data) 9548 sections_with_arm_elf_section_data = entry->next; 9549 free (entry); 9550 } 9551} 9552 9553 9554typedef struct 9555{ 9556 void *finfo; 9557 struct bfd_link_info *info; 9558 asection *sec; 9559 int sec_shndx; 9560 bfd_boolean (*func) (void *, const char *, Elf_Internal_Sym *, 9561 asection *, struct elf_link_hash_entry *); 9562} output_arch_syminfo; 9563 9564enum map_symbol_type 9565{ 9566 ARM_MAP_ARM, 9567 ARM_MAP_THUMB, 9568 ARM_MAP_DATA 9569}; 9570 9571 9572/* Output a single PLT mapping symbol. */ 9573 9574static bfd_boolean 9575elf32_arm_ouput_plt_map_sym (output_arch_syminfo *osi, 9576 enum map_symbol_type type, 9577 bfd_vma offset) 9578{ 9579 static const char *names[3] = {"$a", "$t", "$d"}; 9580 struct elf32_arm_link_hash_table *htab; 9581 Elf_Internal_Sym sym; 9582 9583 htab = elf32_arm_hash_table (osi->info); 9584 sym.st_value = osi->sec->output_section->vma 9585 + osi->sec->output_offset 9586 + offset; 9587 sym.st_size = 0; 9588 sym.st_other = 0; 9589 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE); 9590 sym.st_shndx = osi->sec_shndx; 9591 if (!osi->func (osi->finfo, names[type], &sym, osi->sec, NULL)) 9592 return FALSE; 9593 return TRUE; 9594} 9595 9596 9597/* Output mapping symbols for PLT entries associated with H. */ 9598 9599static bfd_boolean 9600elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf) 9601{ 9602 output_arch_syminfo *osi = (output_arch_syminfo *) inf; 9603 struct elf32_arm_link_hash_table *htab; 9604 struct elf32_arm_link_hash_entry *eh; 9605 bfd_vma addr; 9606 9607 htab = elf32_arm_hash_table (osi->info); 9608 9609 if (h->root.type == bfd_link_hash_indirect) 9610 return TRUE; 9611 9612 if (h->root.type == bfd_link_hash_warning) 9613 /* When warning symbols are created, they **replace** the "real" 9614 entry in the hash table, thus we never get to see the real 9615 symbol in a hash traversal. So look at it now. */ 9616 h = (struct elf_link_hash_entry *) h->root.u.i.link; 9617 9618 if (h->plt.offset == (bfd_vma) -1) 9619 return TRUE; 9620 9621 eh = (struct elf32_arm_link_hash_entry *) h; 9622 addr = h->plt.offset; 9623 if (htab->symbian_p) 9624 { 9625 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr)) 9626 return FALSE; 9627 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 4)) 9628 return FALSE; 9629 } 9630 else if (htab->vxworks_p) 9631 { 9632 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr)) 9633 return FALSE; 9634 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 8)) 9635 return FALSE; 9636 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr + 12)) 9637 return FALSE; 9638 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 20)) 9639 return FALSE; 9640 } 9641 else 9642 { 9643 bfd_boolean thumb_stub; 9644 9645 thumb_stub = eh->plt_thumb_refcount > 0 && !htab->use_blx; 9646 if (thumb_stub) 9647 { 9648 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_THUMB, addr - 4)) 9649 return FALSE; 9650 } 9651#ifdef FOUR_WORD_PLT 9652 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr)) 9653 return FALSE; 9654 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 12)) 9655 return FALSE; 9656#else 9657 /* A three-word PLT with no Thumb thunk contains only Arm code, 9658 so only need to output a mapping symbol for the first PLT entry and 9659 entries with thumb thunks. */ 9660 if (thumb_stub || addr == 20) 9661 { 9662 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr)) 9663 return FALSE; 9664 } 9665#endif 9666 } 9667 9668 return TRUE; 9669} 9670 9671 9672/* Output mapping symbols for linker generated sections. */ 9673 9674static bfd_boolean 9675elf32_arm_output_arch_local_syms (bfd *output_bfd, 9676 struct bfd_link_info *info, 9677 void *finfo, bfd_boolean (*func) (void *, const char *, 9678 Elf_Internal_Sym *, 9679 asection *, 9680 struct elf_link_hash_entry *)) 9681{ 9682 output_arch_syminfo osi; 9683 struct elf32_arm_link_hash_table *htab; 9684 bfd_vma offset; 9685 bfd_size_type size; 9686 9687 htab = elf32_arm_hash_table (info); 9688 check_use_blx(htab); 9689 9690 osi.finfo = finfo; 9691 osi.info = info; 9692 osi.func = func; 9693 9694 /* ARM->Thumb glue. */ 9695 if (htab->arm_glue_size > 0) 9696 { 9697 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner, 9698 ARM2THUMB_GLUE_SECTION_NAME); 9699 9700 osi.sec_shndx = _bfd_elf_section_from_bfd_section 9701 (output_bfd, osi.sec->output_section); 9702 if (info->shared || htab->root.is_relocatable_executable 9703 || htab->pic_veneer) 9704 size = ARM2THUMB_PIC_GLUE_SIZE; 9705 else if (htab->use_blx) 9706 size = ARM2THUMB_V5_STATIC_GLUE_SIZE; 9707 else 9708 size = ARM2THUMB_STATIC_GLUE_SIZE; 9709 9710 for (offset = 0; offset < htab->arm_glue_size; offset += size) 9711 { 9712 elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_ARM, offset); 9713 elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_DATA, offset + size - 4); 9714 } 9715 } 9716 9717 /* Thumb->ARM glue. */ 9718 if (htab->thumb_glue_size > 0) 9719 { 9720 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner, 9721 THUMB2ARM_GLUE_SECTION_NAME); 9722 9723 osi.sec_shndx = _bfd_elf_section_from_bfd_section 9724 (output_bfd, osi.sec->output_section); 9725 size = THUMB2ARM_GLUE_SIZE; 9726 9727 for (offset = 0; offset < htab->thumb_glue_size; offset += size) 9728 { 9729 elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_THUMB, offset); 9730 elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_ARM, offset + 4); 9731 } 9732 } 9733 9734 /* Finally, output mapping symbols for the PLT. */ 9735 if (!htab->splt || htab->splt->size == 0) 9736 return TRUE; 9737 9738 osi.sec_shndx = _bfd_elf_section_from_bfd_section (output_bfd, 9739 htab->splt->output_section); 9740 osi.sec = htab->splt; 9741 /* Output mapping symbols for the plt header. SymbianOS does not have a 9742 plt header. */ 9743 if (htab->vxworks_p) 9744 { 9745 /* VxWorks shared libraries have no PLT header. */ 9746 if (!info->shared) 9747 { 9748 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_ARM, 0)) 9749 return FALSE; 9750 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_DATA, 12)) 9751 return FALSE; 9752 } 9753 } 9754 else if (!htab->symbian_p) 9755 { 9756 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_ARM, 0)) 9757 return FALSE; 9758#ifndef FOUR_WORD_PLT 9759 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_DATA, 16)) 9760 return FALSE; 9761#endif 9762 } 9763 9764 elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, (void *) &osi); 9765 return TRUE; 9766} 9767 9768/* Allocate target specific section data. */ 9769 9770static bfd_boolean 9771elf32_arm_new_section_hook (bfd *abfd, asection *sec) 9772{ 9773 if (!sec->used_by_bfd) 9774 { 9775 _arm_elf_section_data *sdata; 9776 bfd_size_type amt = sizeof (*sdata); 9777 9778 sdata = bfd_zalloc (abfd, amt); 9779 if (sdata == NULL) 9780 return FALSE; 9781 sec->used_by_bfd = sdata; 9782 } 9783 9784 record_section_with_arm_elf_section_data (sec); 9785 9786 return _bfd_elf_new_section_hook (abfd, sec); 9787} 9788 9789 9790/* Used to order a list of mapping symbols by address. */ 9791 9792static int 9793elf32_arm_compare_mapping (const void * a, const void * b) 9794{ 9795 return ((const elf32_arm_section_map *) a)->vma 9796 > ((const elf32_arm_section_map *) b)->vma; 9797} 9798 9799 9800/* Do code byteswapping. Return FALSE afterwards so that the section is 9801 written out as normal. */ 9802 9803static bfd_boolean 9804elf32_arm_write_section (bfd *output_bfd, 9805 struct bfd_link_info *link_info, asection *sec, 9806 bfd_byte *contents) 9807{ 9808 int mapcount, errcount; 9809 _arm_elf_section_data *arm_data; 9810 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info); 9811 elf32_arm_section_map *map; 9812 elf32_vfp11_erratum_list *errnode; 9813 bfd_vma ptr; 9814 bfd_vma end; 9815 bfd_vma offset = sec->output_section->vma + sec->output_offset; 9816 bfd_byte tmp; 9817 int i; 9818 9819 /* If this section has not been allocated an _arm_elf_section_data 9820 structure then we cannot record anything. */ 9821 arm_data = get_arm_elf_section_data (sec); 9822 if (arm_data == NULL) 9823 return FALSE; 9824 9825 mapcount = arm_data->mapcount; 9826 map = arm_data->map; 9827 errcount = arm_data->erratumcount; 9828 9829 if (errcount != 0) 9830 { 9831 unsigned int endianflip = bfd_big_endian (output_bfd) ? 3 : 0; 9832 9833 for (errnode = arm_data->erratumlist; errnode != 0; 9834 errnode = errnode->next) 9835 { 9836 bfd_vma index = errnode->vma - offset; 9837 9838 switch (errnode->type) 9839 { 9840 case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER: 9841 { 9842 bfd_vma branch_to_veneer; 9843 /* Original condition code of instruction, plus bit mask for 9844 ARM B instruction. */ 9845 unsigned int insn = (errnode->u.b.vfp_insn & 0xf0000000) 9846 | 0x0a000000; 9847 9848 /* The instruction is before the label. */ 9849 index -= 4; 9850 9851 /* Above offset included in -4 below. */ 9852 branch_to_veneer = errnode->u.b.veneer->vma 9853 - errnode->vma - 4; 9854 9855 if ((signed) branch_to_veneer < -(1 << 25) 9856 || (signed) branch_to_veneer >= (1 << 25)) 9857 (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of " 9858 "range"), output_bfd); 9859 9860 insn |= (branch_to_veneer >> 2) & 0xffffff; 9861 contents[endianflip ^ index] = insn & 0xff; 9862 contents[endianflip ^ (index + 1)] = (insn >> 8) & 0xff; 9863 contents[endianflip ^ (index + 2)] = (insn >> 16) & 0xff; 9864 contents[endianflip ^ (index + 3)] = (insn >> 24) & 0xff; 9865 } 9866 break; 9867 9868 case VFP11_ERRATUM_ARM_VENEER: 9869 { 9870 bfd_vma branch_from_veneer; 9871 unsigned int insn; 9872 9873 /* Take size of veneer into account. */ 9874 branch_from_veneer = errnode->u.v.branch->vma 9875 - errnode->vma - 12; 9876 9877 if ((signed) branch_from_veneer < -(1 << 25) 9878 || (signed) branch_from_veneer >= (1 << 25)) 9879 (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of " 9880 "range"), output_bfd); 9881 9882 /* Original instruction. */ 9883 insn = errnode->u.v.branch->u.b.vfp_insn; 9884 contents[endianflip ^ index] = insn & 0xff; 9885 contents[endianflip ^ (index + 1)] = (insn >> 8) & 0xff; 9886 contents[endianflip ^ (index + 2)] = (insn >> 16) & 0xff; 9887 contents[endianflip ^ (index + 3)] = (insn >> 24) & 0xff; 9888 9889 /* Branch back to insn after original insn. */ 9890 insn = 0xea000000 | ((branch_from_veneer >> 2) & 0xffffff); 9891 contents[endianflip ^ (index + 4)] = insn & 0xff; 9892 contents[endianflip ^ (index + 5)] = (insn >> 8) & 0xff; 9893 contents[endianflip ^ (index + 6)] = (insn >> 16) & 0xff; 9894 contents[endianflip ^ (index + 7)] = (insn >> 24) & 0xff; 9895 } 9896 break; 9897 9898 default: 9899 abort (); 9900 } 9901 } 9902 } 9903 9904 if (mapcount == 0) 9905 return FALSE; 9906 9907 if (globals->byteswap_code) 9908 { 9909 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping); 9910 9911 ptr = map[0].vma; 9912 for (i = 0; i < mapcount; i++) 9913 { 9914 if (i == mapcount - 1) 9915 end = sec->size; 9916 else 9917 end = map[i + 1].vma; 9918 9919 switch (map[i].type) 9920 { 9921 case 'a': 9922 /* Byte swap code words. */ 9923 while (ptr + 3 < end) 9924 { 9925 tmp = contents[ptr]; 9926 contents[ptr] = contents[ptr + 3]; 9927 contents[ptr + 3] = tmp; 9928 tmp = contents[ptr + 1]; 9929 contents[ptr + 1] = contents[ptr + 2]; 9930 contents[ptr + 2] = tmp; 9931 ptr += 4; 9932 } 9933 break; 9934 9935 case 't': 9936 /* Byte swap code halfwords. */ 9937 while (ptr + 1 < end) 9938 { 9939 tmp = contents[ptr]; 9940 contents[ptr] = contents[ptr + 1]; 9941 contents[ptr + 1] = tmp; 9942 ptr += 2; 9943 } 9944 break; 9945 9946 case 'd': 9947 /* Leave data alone. */ 9948 break; 9949 } 9950 ptr = end; 9951 } 9952 } 9953 9954 free (map); 9955 arm_data->mapcount = 0; 9956 arm_data->mapsize = 0; 9957 arm_data->map = NULL; 9958 unrecord_section_with_arm_elf_section_data (sec); 9959 9960 return FALSE; 9961} 9962 9963static void 9964unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED, 9965 asection * sec, 9966 void * ignore ATTRIBUTE_UNUSED) 9967{ 9968 unrecord_section_with_arm_elf_section_data (sec); 9969} 9970 9971static bfd_boolean 9972elf32_arm_close_and_cleanup (bfd * abfd) 9973{ 9974 if (abfd->sections) 9975 bfd_map_over_sections (abfd, 9976 unrecord_section_via_map_over_sections, 9977 NULL); 9978 9979 return _bfd_elf_close_and_cleanup (abfd); 9980} 9981 9982static bfd_boolean 9983elf32_arm_bfd_free_cached_info (bfd * abfd) 9984{ 9985 if (abfd->sections) 9986 bfd_map_over_sections (abfd, 9987 unrecord_section_via_map_over_sections, 9988 NULL); 9989 9990 return _bfd_free_cached_info (abfd); 9991} 9992 9993/* Display STT_ARM_TFUNC symbols as functions. */ 9994 9995static void 9996elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, 9997 asymbol *asym) 9998{ 9999 elf_symbol_type *elfsym = (elf_symbol_type *) asym; 10000 10001 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC) 10002 elfsym->symbol.flags |= BSF_FUNCTION; 10003} 10004 10005 10006/* Mangle thumb function symbols as we read them in. */ 10007 10008static bfd_boolean 10009elf32_arm_swap_symbol_in (bfd * abfd, 10010 const void *psrc, 10011 const void *pshn, 10012 Elf_Internal_Sym *dst) 10013{ 10014 if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst)) 10015 return FALSE; 10016 10017 /* New EABI objects mark thumb function symbols by setting the low bit of 10018 the address. Turn these into STT_ARM_TFUNC. */ 10019 if (ELF_ST_TYPE (dst->st_info) == STT_FUNC 10020 && (dst->st_value & 1)) 10021 { 10022 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC); 10023 dst->st_value &= ~(bfd_vma) 1; 10024 } 10025 return TRUE; 10026} 10027 10028 10029/* Mangle thumb function symbols as we write them out. */ 10030 10031static void 10032elf32_arm_swap_symbol_out (bfd *abfd, 10033 const Elf_Internal_Sym *src, 10034 void *cdst, 10035 void *shndx) 10036{ 10037 Elf_Internal_Sym newsym; 10038 10039 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit 10040 of the address set, as per the new EABI. We do this unconditionally 10041 because objcopy does not set the elf header flags until after 10042 it writes out the symbol table. */ 10043 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC) 10044 { 10045 newsym = *src; 10046 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC); 10047 if (newsym.st_shndx != SHN_UNDEF) 10048 { 10049 /* Do this only for defined symbols. At link type, the static 10050 linker will simulate the work of dynamic linker of resolving 10051 symbols and will carry over the thumbness of found symbols to 10052 the output symbol table. It's not clear how it happens, but 10053 the thumbness of undefined symbols can well be different at 10054 runtime, and writing '1' for them will be confusing for users 10055 and possibly for dynamic linker itself. 10056 */ 10057 newsym.st_value |= 1; 10058 } 10059 10060 src = &newsym; 10061 } 10062 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx); 10063} 10064 10065/* Add the PT_ARM_EXIDX program header. */ 10066 10067static bfd_boolean 10068elf32_arm_modify_segment_map (bfd *abfd, 10069 struct bfd_link_info *info ATTRIBUTE_UNUSED) 10070{ 10071 struct elf_segment_map *m; 10072 asection *sec; 10073 10074 sec = bfd_get_section_by_name (abfd, ".ARM.exidx"); 10075 if (sec != NULL && (sec->flags & SEC_LOAD) != 0) 10076 { 10077 /* If there is already a PT_ARM_EXIDX header, then we do not 10078 want to add another one. This situation arises when running 10079 "strip"; the input binary already has the header. */ 10080 m = elf_tdata (abfd)->segment_map; 10081 while (m && m->p_type != PT_ARM_EXIDX) 10082 m = m->next; 10083 if (!m) 10084 { 10085 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map)); 10086 if (m == NULL) 10087 return FALSE; 10088 m->p_type = PT_ARM_EXIDX; 10089 m->count = 1; 10090 m->sections[0] = sec; 10091 10092 m->next = elf_tdata (abfd)->segment_map; 10093 elf_tdata (abfd)->segment_map = m; 10094 } 10095 } 10096 10097 return TRUE; 10098} 10099 10100/* We may add a PT_ARM_EXIDX program header. */ 10101 10102static int 10103elf32_arm_additional_program_headers (bfd *abfd, 10104 struct bfd_link_info *info ATTRIBUTE_UNUSED) 10105{ 10106 asection *sec; 10107 10108 sec = bfd_get_section_by_name (abfd, ".ARM.exidx"); 10109 if (sec != NULL && (sec->flags & SEC_LOAD) != 0) 10110 return 1; 10111 else 10112 return 0; 10113} 10114 10115/* We have two function types: STT_FUNC and STT_ARM_TFUNC. */ 10116static bfd_boolean 10117elf32_arm_is_function_type (unsigned int type) 10118{ 10119 return (type == STT_FUNC) || (type == STT_ARM_TFUNC); 10120} 10121 10122/* We use this to override swap_symbol_in and swap_symbol_out. */ 10123const struct elf_size_info elf32_arm_size_info = { 10124 sizeof (Elf32_External_Ehdr), 10125 sizeof (Elf32_External_Phdr), 10126 sizeof (Elf32_External_Shdr), 10127 sizeof (Elf32_External_Rel), 10128 sizeof (Elf32_External_Rela), 10129 sizeof (Elf32_External_Sym), 10130 sizeof (Elf32_External_Dyn), 10131 sizeof (Elf_External_Note), 10132 4, 10133 1, 10134 32, 2, 10135 ELFCLASS32, EV_CURRENT, 10136 bfd_elf32_write_out_phdrs, 10137 bfd_elf32_write_shdrs_and_ehdr, 10138 bfd_elf32_write_relocs, 10139 elf32_arm_swap_symbol_in, 10140 elf32_arm_swap_symbol_out, 10141 bfd_elf32_slurp_reloc_table, 10142 bfd_elf32_slurp_symbol_table, 10143 bfd_elf32_swap_dyn_in, 10144 bfd_elf32_swap_dyn_out, 10145 bfd_elf32_swap_reloc_in, 10146 bfd_elf32_swap_reloc_out, 10147 bfd_elf32_swap_reloca_in, 10148 bfd_elf32_swap_reloca_out 10149}; 10150 10151#define ELF_ARCH bfd_arch_arm 10152#define ELF_MACHINE_CODE EM_ARM 10153#ifdef __QNXTARGET__ 10154#define ELF_MAXPAGESIZE 0x1000 10155#else 10156#define ELF_MAXPAGESIZE 0x8000 10157#endif 10158#define ELF_MINPAGESIZE 0x1000 10159#define ELF_COMMONPAGESIZE 0x1000 10160 10161#define bfd_elf32_mkobject elf32_arm_mkobject 10162 10163#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data 10164#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data 10165#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags 10166#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data 10167#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create 10168#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup 10169#define bfd_elf32_bfd_reloc_name_lookup elf32_arm_reloc_name_lookup 10170#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line 10171#define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info 10172#define bfd_elf32_new_section_hook elf32_arm_new_section_hook 10173#define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol 10174#define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup 10175#define bfd_elf32_bfd_free_cached_info elf32_arm_bfd_free_cached_info 10176 10177#define elf_backend_get_symbol_type elf32_arm_get_symbol_type 10178#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook 10179#define elf_backend_gc_mark_extra_sections elf32_arm_gc_mark_extra_sections 10180#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook 10181#define elf_backend_check_relocs elf32_arm_check_relocs 10182#define elf_backend_relocate_section elf32_arm_relocate_section 10183#define elf_backend_write_section elf32_arm_write_section 10184#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol 10185#define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections 10186#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol 10187#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections 10188#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections 10189#define elf_backend_init_index_section _bfd_elf_init_2_index_sections 10190#define elf_backend_post_process_headers elf32_arm_post_process_headers 10191#define elf_backend_reloc_type_class elf32_arm_reloc_type_class 10192#define elf_backend_object_p elf32_arm_object_p 10193#define elf_backend_section_flags elf32_arm_section_flags 10194#define elf_backend_fake_sections elf32_arm_fake_sections 10195#define elf_backend_section_from_shdr elf32_arm_section_from_shdr 10196#define elf_backend_final_write_processing elf32_arm_final_write_processing 10197#define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol 10198#define elf_backend_symbol_processing elf32_arm_symbol_processing 10199#define elf_backend_size_info elf32_arm_size_info 10200#define elf_backend_modify_segment_map elf32_arm_modify_segment_map 10201#define elf_backend_additional_program_headers \ 10202 elf32_arm_additional_program_headers 10203#define elf_backend_output_arch_local_syms \ 10204 elf32_arm_output_arch_local_syms 10205#define elf_backend_begin_write_processing \ 10206 elf32_arm_begin_write_processing 10207#define elf_backend_is_function_type elf32_arm_is_function_type 10208 10209#define elf_backend_can_refcount 1 10210#define elf_backend_can_gc_sections 1 10211#define elf_backend_plt_readonly 1 10212#define elf_backend_want_got_plt 1 10213#define elf_backend_want_plt_sym 0 10214#define elf_backend_may_use_rel_p 1 10215#define elf_backend_may_use_rela_p 0 10216#define elf_backend_default_use_rela_p 0 10217 10218#define elf_backend_got_header_size 12 10219 10220#undef elf_backend_obj_attrs_vendor 10221#define elf_backend_obj_attrs_vendor "aeabi" 10222#undef elf_backend_obj_attrs_section 10223#define elf_backend_obj_attrs_section ".ARM.attributes" 10224#undef elf_backend_obj_attrs_arg_type 10225#define elf_backend_obj_attrs_arg_type elf32_arm_obj_attrs_arg_type 10226#undef elf_backend_obj_attrs_section_type 10227#define elf_backend_obj_attrs_section_type SHT_ARM_ATTRIBUTES 10228 10229#include "elf32-target.h" 10230 10231/* VxWorks Targets */ 10232 10233#undef TARGET_LITTLE_SYM 10234#define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec 10235#undef TARGET_LITTLE_NAME 10236#define TARGET_LITTLE_NAME "elf32-littlearm-vxworks" 10237#undef TARGET_BIG_SYM 10238#define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec 10239#undef TARGET_BIG_NAME 10240#define TARGET_BIG_NAME "elf32-bigarm-vxworks" 10241 10242/* Like elf32_arm_link_hash_table_create -- but overrides 10243 appropriately for VxWorks. */ 10244static struct bfd_link_hash_table * 10245elf32_arm_vxworks_link_hash_table_create (bfd *abfd) 10246{ 10247 struct bfd_link_hash_table *ret; 10248 10249 ret = elf32_arm_link_hash_table_create (abfd); 10250 if (ret) 10251 { 10252 struct elf32_arm_link_hash_table *htab 10253 = (struct elf32_arm_link_hash_table *) ret; 10254 htab->use_rel = 0; 10255 htab->vxworks_p = 1; 10256 } 10257 return ret; 10258} 10259 10260static void 10261elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker) 10262{ 10263 elf32_arm_final_write_processing (abfd, linker); 10264 elf_vxworks_final_write_processing (abfd, linker); 10265} 10266 10267#undef elf32_bed 10268#define elf32_bed elf32_arm_vxworks_bed 10269 10270#undef bfd_elf32_bfd_link_hash_table_create 10271#define bfd_elf32_bfd_link_hash_table_create \ 10272 elf32_arm_vxworks_link_hash_table_create 10273#undef elf_backend_add_symbol_hook 10274#define elf_backend_add_symbol_hook \ 10275 elf_vxworks_add_symbol_hook 10276#undef elf_backend_final_write_processing 10277#define elf_backend_final_write_processing \ 10278 elf32_arm_vxworks_final_write_processing 10279#undef elf_backend_emit_relocs 10280#define elf_backend_emit_relocs \ 10281 elf_vxworks_emit_relocs 10282 10283#undef elf_backend_may_use_rel_p 10284#define elf_backend_may_use_rel_p 0 10285#undef elf_backend_may_use_rela_p 10286#define elf_backend_may_use_rela_p 1 10287#undef elf_backend_default_use_rela_p 10288#define elf_backend_default_use_rela_p 1 10289#undef elf_backend_want_plt_sym 10290#define elf_backend_want_plt_sym 1 10291#undef ELF_MAXPAGESIZE 10292#define ELF_MAXPAGESIZE 0x1000 10293 10294#include "elf32-target.h" 10295 10296 10297/* Symbian OS Targets */ 10298 10299#undef TARGET_LITTLE_SYM 10300#define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec 10301#undef TARGET_LITTLE_NAME 10302#define TARGET_LITTLE_NAME "elf32-littlearm-symbian" 10303#undef TARGET_BIG_SYM 10304#define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec 10305#undef TARGET_BIG_NAME 10306#define TARGET_BIG_NAME "elf32-bigarm-symbian" 10307 10308/* Like elf32_arm_link_hash_table_create -- but overrides 10309 appropriately for Symbian OS. */ 10310static struct bfd_link_hash_table * 10311elf32_arm_symbian_link_hash_table_create (bfd *abfd) 10312{ 10313 struct bfd_link_hash_table *ret; 10314 10315 ret = elf32_arm_link_hash_table_create (abfd); 10316 if (ret) 10317 { 10318 struct elf32_arm_link_hash_table *htab 10319 = (struct elf32_arm_link_hash_table *)ret; 10320 /* There is no PLT header for Symbian OS. */ 10321 htab->plt_header_size = 0; 10322 /* The PLT entries are each three instructions. */ 10323 htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry); 10324 htab->symbian_p = 1; 10325 /* Symbian uses armv5t or above, so use_blx is always true. */ 10326 htab->use_blx = 1; 10327 htab->root.is_relocatable_executable = 1; 10328 } 10329 return ret; 10330} 10331 10332static const struct bfd_elf_special_section 10333elf32_arm_symbian_special_sections[] = 10334{ 10335 /* In a BPABI executable, the dynamic linking sections do not go in 10336 the loadable read-only segment. The post-linker may wish to 10337 refer to these sections, but they are not part of the final 10338 program image. */ 10339 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, 0 }, 10340 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, 0 }, 10341 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, 0 }, 10342 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, 0 }, 10343 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, 0 }, 10344 /* These sections do not need to be writable as the SymbianOS 10345 postlinker will arrange things so that no dynamic relocation is 10346 required. */ 10347 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC }, 10348 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC }, 10349 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC }, 10350 { NULL, 0, 0, 0, 0 } 10351}; 10352 10353static void 10354elf32_arm_symbian_begin_write_processing (bfd *abfd, 10355 struct bfd_link_info *link_info) 10356{ 10357 /* BPABI objects are never loaded directly by an OS kernel; they are 10358 processed by a postlinker first, into an OS-specific format. If 10359 the D_PAGED bit is set on the file, BFD will align segments on 10360 page boundaries, so that an OS can directly map the file. With 10361 BPABI objects, that just results in wasted space. In addition, 10362 because we clear the D_PAGED bit, map_sections_to_segments will 10363 recognize that the program headers should not be mapped into any 10364 loadable segment. */ 10365 abfd->flags &= ~D_PAGED; 10366 elf32_arm_begin_write_processing(abfd, link_info); 10367} 10368 10369static bfd_boolean 10370elf32_arm_symbian_modify_segment_map (bfd *abfd, 10371 struct bfd_link_info *info) 10372{ 10373 struct elf_segment_map *m; 10374 asection *dynsec; 10375 10376 /* BPABI shared libraries and executables should have a PT_DYNAMIC 10377 segment. However, because the .dynamic section is not marked 10378 with SEC_LOAD, the generic ELF code will not create such a 10379 segment. */ 10380 dynsec = bfd_get_section_by_name (abfd, ".dynamic"); 10381 if (dynsec) 10382 { 10383 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 10384 if (m->p_type == PT_DYNAMIC) 10385 break; 10386 10387 if (m == NULL) 10388 { 10389 m = _bfd_elf_make_dynamic_segment (abfd, dynsec); 10390 m->next = elf_tdata (abfd)->segment_map; 10391 elf_tdata (abfd)->segment_map = m; 10392 } 10393 } 10394 10395 /* Also call the generic arm routine. */ 10396 return elf32_arm_modify_segment_map (abfd, info); 10397} 10398 10399#undef elf32_bed 10400#define elf32_bed elf32_arm_symbian_bed 10401 10402/* The dynamic sections are not allocated on SymbianOS; the postlinker 10403 will process them and then discard them. */ 10404#undef ELF_DYNAMIC_SEC_FLAGS 10405#define ELF_DYNAMIC_SEC_FLAGS \ 10406 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED) 10407 10408#undef bfd_elf32_bfd_link_hash_table_create 10409#define bfd_elf32_bfd_link_hash_table_create \ 10410 elf32_arm_symbian_link_hash_table_create 10411#undef elf_backend_add_symbol_hook 10412 10413#undef elf_backend_special_sections 10414#define elf_backend_special_sections elf32_arm_symbian_special_sections 10415 10416#undef elf_backend_begin_write_processing 10417#define elf_backend_begin_write_processing \ 10418 elf32_arm_symbian_begin_write_processing 10419#undef elf_backend_final_write_processing 10420#define elf_backend_final_write_processing \ 10421 elf32_arm_final_write_processing 10422#undef elf_backend_emit_relocs 10423 10424#undef elf_backend_modify_segment_map 10425#define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map 10426 10427/* There is no .got section for BPABI objects, and hence no header. */ 10428#undef elf_backend_got_header_size 10429#define elf_backend_got_header_size 0 10430 10431/* Similarly, there is no .got.plt section. */ 10432#undef elf_backend_want_got_plt 10433#define elf_backend_want_got_plt 0 10434 10435#undef elf_backend_may_use_rel_p 10436#define elf_backend_may_use_rel_p 1 10437#undef elf_backend_may_use_rela_p 10438#define elf_backend_may_use_rela_p 0 10439#undef elf_backend_default_use_rela_p 10440#define elf_backend_default_use_rela_p 0 10441#undef elf_backend_want_plt_sym 10442#define elf_backend_want_plt_sym 0 10443#undef ELF_MAXPAGESIZE 10444#define ELF_MAXPAGESIZE 0x8000 10445 10446#include "elf32-target.h" 10447