elf32-cris.c revision 1.1.1.3
1 /* CRIS-specific support for 32-bit ELF. 2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 3 2010, 2011, 2012 Free Software Foundation, Inc. 4 Contributed by Axis Communications AB. 5 Written by Hans-Peter Nilsson, based on elf32-fr30.c 6 PIC and shlib bits based primarily on elf32-m68k.c and elf32-i386.c. 7 8 This file is part of BFD, the Binary File Descriptor library. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 23 MA 02110-1301, USA. */ 24 25 #include "sysdep.h" 26 #include "bfd.h" 27 #include "libbfd.h" 28 #include "elf-bfd.h" 29 #include "elf/cris.h" 30 #include <limits.h> 31 32 bfd_reloc_status_type 33 cris_elf_pcrel_reloc (bfd *, arelent *, asymbol *, void *, 34 asection *, bfd *, char **); 35 static bfd_boolean 36 cris_elf_set_mach_from_flags (bfd *, unsigned long); 37 38 /* Forward declarations. */ 39 static reloc_howto_type cris_elf_howto_table [] = 40 { 41 /* This reloc does nothing. */ 42 HOWTO (R_CRIS_NONE, /* type */ 43 0, /* rightshift */ 44 2, /* size (0 = byte, 1 = short, 2 = long) */ 45 32, /* bitsize */ 46 FALSE, /* pc_relative */ 47 0, /* bitpos */ 48 complain_overflow_bitfield, /* complain_on_overflow */ 49 bfd_elf_generic_reloc, /* special_function */ 50 "R_CRIS_NONE", /* name */ 51 FALSE, /* partial_inplace */ 52 0, /* src_mask */ 53 0, /* dst_mask */ 54 FALSE), /* pcrel_offset */ 55 56 /* An 8 bit absolute relocation. */ 57 HOWTO (R_CRIS_8, /* type */ 58 0, /* rightshift */ 59 0, /* size (0 = byte, 1 = short, 2 = long) */ 60 8, /* bitsize */ 61 FALSE, /* pc_relative */ 62 0, /* bitpos */ 63 complain_overflow_bitfield, /* complain_on_overflow */ 64 bfd_elf_generic_reloc, /* special_function */ 65 "R_CRIS_8", /* name */ 66 FALSE, /* partial_inplace */ 67 0x0000, /* src_mask */ 68 0x00ff, /* dst_mask */ 69 FALSE), /* pcrel_offset */ 70 71 /* A 16 bit absolute relocation. */ 72 HOWTO (R_CRIS_16, /* type */ 73 0, /* rightshift */ 74 1, /* size (0 = byte, 1 = short, 2 = long) */ 75 16, /* bitsize */ 76 FALSE, /* pc_relative */ 77 0, /* bitpos */ 78 complain_overflow_bitfield, /* complain_on_overflow */ 79 bfd_elf_generic_reloc, /* special_function */ 80 "R_CRIS_16", /* name */ 81 FALSE, /* partial_inplace */ 82 0x00000000, /* src_mask */ 83 0x0000ffff, /* dst_mask */ 84 FALSE), /* pcrel_offset */ 85 86 /* A 32 bit absolute relocation. */ 87 HOWTO (R_CRIS_32, /* type */ 88 0, /* rightshift */ 89 2, /* size (0 = byte, 1 = short, 2 = long) */ 90 32, /* bitsize */ 91 FALSE, /* pc_relative */ 92 0, /* bitpos */ 93 /* We don't want overflow complaints for 64-bit vma builds 94 for e.g. sym+0x40000000 (or actually sym-0xc0000000 in 95 32-bit ELF) where sym=0xc0001234. 96 Don't do this for the PIC relocs, as we don't expect to 97 see them with large offsets. */ 98 complain_overflow_dont, /* complain_on_overflow */ 99 bfd_elf_generic_reloc, /* special_function */ 100 "R_CRIS_32", /* name */ 101 FALSE, /* partial_inplace */ 102 0x00000000, /* src_mask */ 103 0xffffffff, /* dst_mask */ 104 FALSE), /* pcrel_offset */ 105 106 /* An 8 bit PC-relative relocation. */ 107 HOWTO (R_CRIS_8_PCREL, /* type */ 108 0, /* rightshift */ 109 0, /* size (0 = byte, 1 = short, 2 = long) */ 110 8, /* bitsize */ 111 TRUE, /* pc_relative */ 112 0, /* bitpos */ 113 complain_overflow_bitfield, /* complain_on_overflow */ 114 cris_elf_pcrel_reloc, /* special_function */ 115 "R_CRIS_8_PCREL", /* name */ 116 FALSE, /* partial_inplace */ 117 0x0000, /* src_mask */ 118 0x00ff, /* dst_mask */ 119 TRUE), /* pcrel_offset */ 120 121 /* A 16 bit PC-relative relocation. */ 122 HOWTO (R_CRIS_16_PCREL, /* type */ 123 0, /* rightshift */ 124 1, /* size (0 = byte, 1 = short, 2 = long) */ 125 16, /* bitsize */ 126 TRUE, /* pc_relative */ 127 0, /* bitpos */ 128 complain_overflow_bitfield, /* complain_on_overflow */ 129 cris_elf_pcrel_reloc, /* special_function */ 130 "R_CRIS_16_PCREL", /* name */ 131 FALSE, /* partial_inplace */ 132 0x00000000, /* src_mask */ 133 0x0000ffff, /* dst_mask */ 134 TRUE), /* pcrel_offset */ 135 136 /* A 32 bit PC-relative relocation. */ 137 HOWTO (R_CRIS_32_PCREL, /* type */ 138 0, /* rightshift */ 139 2, /* size (0 = byte, 1 = short, 2 = long) */ 140 32, /* bitsize */ 141 TRUE, /* pc_relative */ 142 0, /* bitpos */ 143 complain_overflow_bitfield, /* complain_on_overflow */ 144 cris_elf_pcrel_reloc, /* special_function */ 145 "R_CRIS_32_PCREL", /* name */ 146 FALSE, /* partial_inplace */ 147 0x00000000, /* src_mask */ 148 0xffffffff, /* dst_mask */ 149 TRUE), /* pcrel_offset */ 150 151 /* GNU extension to record C++ vtable hierarchy. */ 152 HOWTO (R_CRIS_GNU_VTINHERIT, /* type */ 153 0, /* rightshift */ 154 2, /* size (0 = byte, 1 = short, 2 = long) */ 155 0, /* bitsize */ 156 FALSE, /* pc_relative */ 157 0, /* bitpos */ 158 complain_overflow_dont, /* complain_on_overflow */ 159 NULL, /* special_function */ 160 "R_CRIS_GNU_VTINHERIT", /* name */ 161 FALSE, /* partial_inplace */ 162 0, /* src_mask */ 163 0, /* dst_mask */ 164 FALSE), /* pcrel_offset */ 165 166 /* GNU extension to record C++ vtable member usage. */ 167 HOWTO (R_CRIS_GNU_VTENTRY, /* type */ 168 0, /* rightshift */ 169 2, /* size (0 = byte, 1 = short, 2 = long) */ 170 0, /* bitsize */ 171 FALSE, /* pc_relative */ 172 0, /* bitpos */ 173 complain_overflow_dont, /* complain_on_overflow */ 174 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 175 "R_CRIS_GNU_VTENTRY", /* name */ 176 FALSE, /* partial_inplace */ 177 0, /* src_mask */ 178 0, /* dst_mask */ 179 FALSE), /* pcrel_offset */ 180 181 /* This is used only by the dynamic linker. The symbol should exist 182 both in the object being run and in some shared library. The 183 dynamic linker copies the data addressed by the symbol from the 184 shared library into the object, because the object being 185 run has to have the data at some particular address. */ 186 HOWTO (R_CRIS_COPY, /* type */ 187 0, /* rightshift */ 188 2, /* size (0 = byte, 1 = short, 2 = long) */ 189 32, /* bitsize */ 190 FALSE, /* pc_relative */ 191 0, /* bitpos */ 192 complain_overflow_bitfield, /* complain_on_overflow */ 193 bfd_elf_generic_reloc, /* special_function */ 194 "R_CRIS_COPY", /* name */ 195 FALSE, /* partial_inplace */ 196 0, /* src_mask */ 197 0, /* dst_mask */ 198 FALSE), /* pcrel_offset */ 199 200 /* Like R_CRIS_32, but used when setting global offset table entries. */ 201 HOWTO (R_CRIS_GLOB_DAT, /* type */ 202 0, /* rightshift */ 203 2, /* size (0 = byte, 1 = short, 2 = long) */ 204 32, /* bitsize */ 205 FALSE, /* pc_relative */ 206 0, /* bitpos */ 207 complain_overflow_bitfield, /* complain_on_overflow */ 208 bfd_elf_generic_reloc, /* special_function */ 209 "R_CRIS_GLOB_DAT", /* name */ 210 FALSE, /* partial_inplace */ 211 0, /* src_mask */ 212 0xffffffff, /* dst_mask */ 213 FALSE), /* pcrel_offset */ 214 215 /* Marks a procedure linkage table entry for a symbol. */ 216 HOWTO (R_CRIS_JUMP_SLOT, /* type */ 217 0, /* rightshift */ 218 2, /* size (0 = byte, 1 = short, 2 = long) */ 219 32, /* bitsize */ 220 FALSE, /* pc_relative */ 221 0, /* bitpos */ 222 complain_overflow_bitfield, /* complain_on_overflow */ 223 bfd_elf_generic_reloc, /* special_function */ 224 "R_CRIS_JUMP_SLOT", /* name */ 225 FALSE, /* partial_inplace */ 226 0, /* src_mask */ 227 0, /* dst_mask */ 228 FALSE), /* pcrel_offset */ 229 230 /* Used only by the dynamic linker. When the object is run, this 231 longword is set to the load address of the object, plus the 232 addend. */ 233 HOWTO (R_CRIS_RELATIVE, /* type */ 234 0, /* rightshift */ 235 2, /* size (0 = byte, 1 = short, 2 = long) */ 236 32, /* bitsize */ 237 FALSE, /* pc_relative */ 238 0, /* bitpos */ 239 complain_overflow_bitfield, /* complain_on_overflow */ 240 bfd_elf_generic_reloc, /* special_function */ 241 "R_CRIS_RELATIVE", /* name */ 242 FALSE, /* partial_inplace */ 243 0, /* src_mask */ 244 0xffffffff, /* dst_mask */ 245 FALSE), /* pcrel_offset */ 246 247 /* Like R_CRIS_32, but referring to the GOT table entry for the symbol. */ 248 HOWTO (R_CRIS_16_GOT, /* type */ 249 0, /* rightshift */ 250 1, /* size (0 = byte, 1 = short, 2 = long) */ 251 16, /* bitsize */ 252 FALSE, /* pc_relative */ 253 0, /* bitpos */ 254 complain_overflow_bitfield, /* complain_on_overflow */ 255 bfd_elf_generic_reloc, /* special_function */ 256 "R_CRIS_16_GOT", /* name */ 257 FALSE, /* partial_inplace */ 258 0, /* src_mask */ 259 0xffff, /* dst_mask */ 260 FALSE), /* pcrel_offset */ 261 262 HOWTO (R_CRIS_32_GOT, /* type */ 263 0, /* rightshift */ 264 2, /* size (0 = byte, 1 = short, 2 = long) */ 265 32, /* bitsize */ 266 FALSE, /* pc_relative */ 267 0, /* bitpos */ 268 complain_overflow_bitfield, /* complain_on_overflow */ 269 bfd_elf_generic_reloc, /* special_function */ 270 "R_CRIS_32_GOT", /* name */ 271 FALSE, /* partial_inplace */ 272 0, /* src_mask */ 273 0xffffffff, /* dst_mask */ 274 FALSE), /* pcrel_offset */ 275 276 /* Like R_CRIS_32_GOT, but referring to (and requesting a) PLT part of 277 the GOT table for the symbol. */ 278 HOWTO (R_CRIS_16_GOTPLT, /* type */ 279 0, /* rightshift */ 280 1, /* size (0 = byte, 1 = short, 2 = long) */ 281 16, /* bitsize */ 282 FALSE, /* pc_relative */ 283 0, /* bitpos */ 284 complain_overflow_bitfield, /* complain_on_overflow */ 285 bfd_elf_generic_reloc, /* special_function */ 286 "R_CRIS_16_GOTPLT", /* name */ 287 FALSE, /* partial_inplace */ 288 0, /* src_mask */ 289 0xffff, /* dst_mask */ 290 FALSE), /* pcrel_offset */ 291 292 HOWTO (R_CRIS_32_GOTPLT, /* type */ 293 0, /* rightshift */ 294 2, /* size (0 = byte, 1 = short, 2 = long) */ 295 32, /* bitsize */ 296 FALSE, /* pc_relative */ 297 0, /* bitpos */ 298 complain_overflow_bitfield, /* complain_on_overflow */ 299 bfd_elf_generic_reloc, /* special_function */ 300 "R_CRIS_32_GOTPLT", /* name */ 301 FALSE, /* partial_inplace */ 302 0, /* src_mask */ 303 0xffffffff, /* dst_mask */ 304 FALSE), /* pcrel_offset */ 305 306 /* A 32-bit offset from GOT to (local const) symbol: no GOT entry should 307 be necessary. */ 308 HOWTO (R_CRIS_32_GOTREL, /* type */ 309 0, /* rightshift */ 310 2, /* size (0 = byte, 1 = short, 2 = long) */ 311 32, /* bitsize */ 312 FALSE, /* pc_relative */ 313 0, /* bitpos */ 314 complain_overflow_bitfield, /* complain_on_overflow */ 315 bfd_elf_generic_reloc, /* special_function */ 316 "R_CRIS_32_GOTREL", /* name */ 317 FALSE, /* partial_inplace */ 318 0, /* src_mask */ 319 0xffffffff, /* dst_mask */ 320 FALSE), /* pcrel_offset */ 321 322 /* A 32-bit offset from GOT to entry for this symbol in PLT and request 323 to create PLT entry for symbol. */ 324 HOWTO (R_CRIS_32_PLT_GOTREL, /* type */ 325 0, /* rightshift */ 326 2, /* size (0 = byte, 1 = short, 2 = long) */ 327 32, /* bitsize */ 328 FALSE, /* pc_relative */ 329 0, /* bitpos */ 330 complain_overflow_bitfield, /* complain_on_overflow */ 331 bfd_elf_generic_reloc, /* special_function */ 332 "R_CRIS_32_PLT_GOTREL", /* name */ 333 FALSE, /* partial_inplace */ 334 0, /* src_mask */ 335 0xffffffff, /* dst_mask */ 336 FALSE), /* pcrel_offset */ 337 338 /* A 32-bit offset from PC (location after the relocation) + addend to 339 entry for this symbol in PLT and request to create PLT entry for 340 symbol. */ 341 HOWTO (R_CRIS_32_PLT_PCREL, /* type */ 342 0, /* rightshift */ 343 2, /* size (0 = byte, 1 = short, 2 = long) */ 344 32, /* bitsize */ 345 TRUE, /* pc_relative */ 346 0, /* bitpos */ 347 complain_overflow_bitfield, /* complain_on_overflow */ 348 cris_elf_pcrel_reloc, /* special_function */ 349 "R_CRIS_32_PLT_PCREL", /* name */ 350 FALSE, /* partial_inplace */ 351 0, /* src_mask */ 352 0xffffffff, /* dst_mask */ 353 TRUE), /* pcrel_offset */ 354 355 /* We don't handle these in any special manner and cross-format 356 linking is not supported; just recognize them enough to pass them 357 around. FIXME: do the same for most PIC relocs and add sanity 358 tests to actually refuse gracefully to handle these and PIC 359 relocs for cross-format linking. */ 360 #define TLSHOWTO32(name) \ 361 HOWTO (name, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, \ 362 bfd_elf_generic_reloc, #name, FALSE, 0, 0xffffffff, FALSE) 363 #define TLSHOWTO16X(name, X) \ 364 HOWTO (name, 0, 1, 16, FALSE, 0, complain_overflow_ ## X, \ 365 bfd_elf_generic_reloc, #name, FALSE, 0, 0xffff, FALSE) 366 #define TLSHOWTO16(name) TLSHOWTO16X(name, unsigned) 367 #define TLSHOWTO16S(name) TLSHOWTO16X(name, signed) 368 369 TLSHOWTO32 (R_CRIS_32_GOT_GD), 370 TLSHOWTO16 (R_CRIS_16_GOT_GD), 371 TLSHOWTO32 (R_CRIS_32_GD), 372 TLSHOWTO32 (R_CRIS_DTP), 373 TLSHOWTO32 (R_CRIS_32_DTPREL), 374 TLSHOWTO16S (R_CRIS_16_DTPREL), 375 TLSHOWTO32 (R_CRIS_32_GOT_TPREL), 376 TLSHOWTO16S (R_CRIS_16_GOT_TPREL), 377 TLSHOWTO32 (R_CRIS_32_TPREL), 378 TLSHOWTO16S (R_CRIS_16_TPREL), 379 TLSHOWTO32 (R_CRIS_DTPMOD), 380 TLSHOWTO32 (R_CRIS_32_IE) 381 }; 382 383 /* Map BFD reloc types to CRIS ELF reloc types. */ 385 386 struct cris_reloc_map 387 { 388 bfd_reloc_code_real_type bfd_reloc_val; 389 unsigned int cris_reloc_val; 390 }; 391 392 static const struct cris_reloc_map cris_reloc_map [] = 393 { 394 { BFD_RELOC_NONE, R_CRIS_NONE }, 395 { BFD_RELOC_8, R_CRIS_8 }, 396 { BFD_RELOC_16, R_CRIS_16 }, 397 { BFD_RELOC_32, R_CRIS_32 }, 398 { BFD_RELOC_8_PCREL, R_CRIS_8_PCREL }, 399 { BFD_RELOC_16_PCREL, R_CRIS_16_PCREL }, 400 { BFD_RELOC_32_PCREL, R_CRIS_32_PCREL }, 401 { BFD_RELOC_VTABLE_INHERIT, R_CRIS_GNU_VTINHERIT }, 402 { BFD_RELOC_VTABLE_ENTRY, R_CRIS_GNU_VTENTRY }, 403 { BFD_RELOC_CRIS_COPY, R_CRIS_COPY }, 404 { BFD_RELOC_CRIS_GLOB_DAT, R_CRIS_GLOB_DAT }, 405 { BFD_RELOC_CRIS_JUMP_SLOT, R_CRIS_JUMP_SLOT }, 406 { BFD_RELOC_CRIS_RELATIVE, R_CRIS_RELATIVE }, 407 { BFD_RELOC_CRIS_16_GOT, R_CRIS_16_GOT }, 408 { BFD_RELOC_CRIS_32_GOT, R_CRIS_32_GOT }, 409 { BFD_RELOC_CRIS_16_GOTPLT, R_CRIS_16_GOTPLT }, 410 { BFD_RELOC_CRIS_32_GOTPLT, R_CRIS_32_GOTPLT }, 411 { BFD_RELOC_CRIS_32_GOTREL, R_CRIS_32_GOTREL }, 412 { BFD_RELOC_CRIS_32_PLT_GOTREL, R_CRIS_32_PLT_GOTREL }, 413 { BFD_RELOC_CRIS_32_PLT_PCREL, R_CRIS_32_PLT_PCREL }, 414 { BFD_RELOC_CRIS_32_GOT_GD, R_CRIS_32_GOT_GD }, 415 { BFD_RELOC_CRIS_16_GOT_GD, R_CRIS_16_GOT_GD }, 416 { BFD_RELOC_CRIS_32_GD, R_CRIS_32_GD }, 417 { BFD_RELOC_CRIS_DTP, R_CRIS_DTP }, 418 { BFD_RELOC_CRIS_32_DTPREL, R_CRIS_32_DTPREL }, 419 { BFD_RELOC_CRIS_16_DTPREL, R_CRIS_16_DTPREL }, 420 { BFD_RELOC_CRIS_32_GOT_TPREL, R_CRIS_32_GOT_TPREL }, 421 { BFD_RELOC_CRIS_16_GOT_TPREL, R_CRIS_16_GOT_TPREL }, 422 { BFD_RELOC_CRIS_32_TPREL, R_CRIS_32_TPREL }, 423 { BFD_RELOC_CRIS_16_TPREL, R_CRIS_16_TPREL }, 424 { BFD_RELOC_CRIS_DTPMOD, R_CRIS_DTPMOD }, 425 { BFD_RELOC_CRIS_32_IE, R_CRIS_32_IE } 426 }; 427 428 static reloc_howto_type * 429 cris_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 430 bfd_reloc_code_real_type code) 431 { 432 unsigned int i; 433 434 for (i = 0; i < sizeof (cris_reloc_map) / sizeof (cris_reloc_map[0]); i++) 435 if (cris_reloc_map [i].bfd_reloc_val == code) 436 return & cris_elf_howto_table [cris_reloc_map[i].cris_reloc_val]; 437 438 return NULL; 439 } 440 441 static reloc_howto_type * 442 cris_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) 443 { 444 unsigned int i; 445 446 for (i = 0; 447 i < sizeof (cris_elf_howto_table) / sizeof (cris_elf_howto_table[0]); 448 i++) 449 if (cris_elf_howto_table[i].name != NULL 450 && strcasecmp (cris_elf_howto_table[i].name, r_name) == 0) 451 return &cris_elf_howto_table[i]; 452 453 return NULL; 454 } 455 456 /* Set the howto pointer for an CRIS ELF reloc. */ 457 458 static void 459 cris_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED, 460 arelent * cache_ptr, 461 Elf_Internal_Rela * dst) 462 { 463 enum elf_cris_reloc_type r_type; 464 465 r_type = ELF32_R_TYPE (dst->r_info); 466 BFD_ASSERT (r_type < (unsigned int) R_CRIS_max); 467 cache_ptr->howto = & cris_elf_howto_table [r_type]; 468 } 469 470 bfd_reloc_status_type 471 cris_elf_pcrel_reloc (bfd *abfd ATTRIBUTE_UNUSED, 472 arelent *reloc_entry, 473 asymbol *symbol, 474 void * data ATTRIBUTE_UNUSED, 475 asection *input_section, 476 bfd *output_bfd, 477 char **error_message ATTRIBUTE_UNUSED) 478 { 479 /* By default (using only bfd_elf_generic_reloc when linking to 480 non-ELF formats) PC-relative relocs are relative to the beginning 481 of the reloc. CRIS PC-relative relocs are relative to the position 482 *after* the reloc because that's what pre-CRISv32 PC points to 483 after reading an insn field with that reloc. (For CRISv32, PC is 484 actually relative to the start of the insn, but we keep the old 485 definition.) Still, we use as much generic machinery as we can. 486 487 Only adjust when doing a final link. */ 488 if (output_bfd == (bfd *) NULL) 489 reloc_entry->addend -= 1 << reloc_entry->howto->size; 490 491 return 492 bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 493 input_section, output_bfd, error_message); 494 } 495 496 /* Support for core dump NOTE sections. 498 The slightly unintuitive code layout is an attempt to keep at least 499 some similarities with other ports, hoping to simplify general 500 changes, while still keeping Linux/CRIS and Linux/CRISv32 code apart. */ 501 502 static bfd_boolean 503 cris_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 504 { 505 int offset; 506 size_t size; 507 508 if (bfd_get_mach (abfd) == bfd_mach_cris_v32) 509 switch (note->descsz) 510 { 511 default: 512 return FALSE; 513 514 case 202: /* Linux/CRISv32 */ 515 /* pr_cursig */ 516 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 517 518 /* pr_pid */ 519 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 22); 520 521 /* pr_reg */ 522 offset = 70; 523 size = 128; 524 525 break; 526 } 527 else 528 switch (note->descsz) 529 { 530 default: 531 return FALSE; 532 533 case 214: /* Linux/CRIS */ 534 /* pr_cursig */ 535 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 536 537 /* pr_pid */ 538 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 22); 539 540 /* pr_reg */ 541 offset = 70; 542 size = 140; 543 544 break; 545 } 546 547 /* Make a ".reg/999" section. */ 548 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 549 size, note->descpos + offset); 550 } 551 552 static bfd_boolean 553 cris_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 554 { 555 if (bfd_get_mach (abfd) == bfd_mach_cris_v32) 556 switch (note->descsz) 557 { 558 default: 559 return FALSE; 560 561 case 124: /* Linux/CRISv32 elf_prpsinfo */ 562 elf_tdata (abfd)->core_program 563 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 564 elf_tdata (abfd)->core_command 565 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 566 } 567 else 568 switch (note->descsz) 569 { 570 default: 571 return FALSE; 572 573 case 124: /* Linux/CRIS elf_prpsinfo */ 574 elf_tdata (abfd)->core_program 575 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 576 elf_tdata (abfd)->core_command 577 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 578 } 579 580 /* Note that for some reason, a spurious space is tacked 581 onto the end of the args in some (at least one anyway) 582 implementations, so strip it off if it exists. */ 583 584 { 585 char *command = elf_tdata (abfd)->core_command; 586 int n = strlen (command); 587 588 if (0 < n && command[n - 1] == ' ') 589 command[n - 1] = '\0'; 590 } 591 592 return TRUE; 593 } 594 595 /* The name of the dynamic interpreter. This is put in the .interp 597 section. */ 598 599 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1" 600 601 /* The size in bytes of an entry in the procedure linkage table. */ 602 603 #define PLT_ENTRY_SIZE 20 604 #define PLT_ENTRY_SIZE_V32 26 605 606 /* The first entry in an absolute procedure linkage table looks like this. */ 607 608 static const bfd_byte elf_cris_plt0_entry[PLT_ENTRY_SIZE] = 609 { 610 0xfc, 0xe1, 611 0x7e, 0x7e, /* push mof. */ 612 0x7f, 0x0d, /* (dip [pc+]) */ 613 0, 0, 0, 0, /* Replaced with address of .got + 4. */ 614 0x30, 0x7a, /* move [...],mof */ 615 0x7f, 0x0d, /* (dip [pc+]) */ 616 0, 0, 0, 0, /* Replaced with address of .got + 8. */ 617 0x30, 0x09 /* jump [...] */ 618 }; 619 620 static const bfd_byte elf_cris_plt0_entry_v32[PLT_ENTRY_SIZE_V32] = 621 { 622 0x84, 0xe2, /* subq 4,$sp */ 623 0x6f, 0xfe, /* move.d 0,$acr */ 624 0, 0, 0, 0, /* Replaced by address of .got + 4. */ 625 0x7e, 0x7a, /* move $mof,[$sp] */ 626 0x3f, 0x7a, /* move [$acr],$mof */ 627 0x04, 0xf2, /* addq 4,acr */ 628 0x6f, 0xfa, /* move.d [$acr],$acr */ 629 0xbf, 0x09, /* jump $acr */ 630 0xb0, 0x05, /* nop */ 631 0, 0 /* Pad out to 26 bytes. */ 632 }; 633 634 /* Subsequent entries in an absolute procedure linkage table look like 635 this. */ 636 637 static const bfd_byte elf_cris_plt_entry[PLT_ENTRY_SIZE] = 638 { 639 0x7f, 0x0d, /* (dip [pc+]) */ 640 0, 0, 0, 0, /* Replaced with address of this symbol in .got. */ 641 0x30, 0x09, /* jump [...] */ 642 0x3f, 0x7e, /* move [pc+],mof */ 643 0, 0, 0, 0, /* Replaced with offset into relocation table. */ 644 0x2f, 0xfe, /* add.d [pc+],pc */ 645 0xec, 0xff, 646 0xff, 0xff /* Replaced with offset to start of .plt. */ 647 }; 648 649 static const bfd_byte elf_cris_plt_entry_v32[PLT_ENTRY_SIZE_V32] = 650 { 651 0x6f, 0xfe, /* move.d 0,$acr */ 652 0, 0, 0, 0, /* Replaced with address of this symbol in .got. */ 653 0x6f, 0xfa, /* move.d [$acr],$acr */ 654 0xbf, 0x09, /* jump $acr */ 655 0xb0, 0x05, /* nop */ 656 0x3f, 0x7e, /* move 0,mof */ 657 0, 0, 0, 0, /* Replaced with offset into relocation table. */ 658 0xbf, 0x0e, /* ba start_of_plt0_entry */ 659 0, 0, 0, 0, /* Replaced with offset to plt0 entry. */ 660 0xb0, 0x05 /* nop */ 661 }; 662 663 /* The first entry in a PIC procedure linkage table looks like this. */ 664 665 static const bfd_byte elf_cris_pic_plt0_entry[PLT_ENTRY_SIZE] = 666 { 667 0xfc, 0xe1, 0x7e, 0x7e, /* push mof */ 668 0x04, 0x01, 0x30, 0x7a, /* move [r0+4],mof */ 669 0x08, 0x01, 0x30, 0x09, /* jump [r0+8] */ 670 0, 0, 0, 0, 0, 0, 0, 0, /* Pad out to 20 bytes. */ 671 }; 672 673 static const bfd_byte elf_cris_pic_plt0_entry_v32[PLT_ENTRY_SIZE_V32] = 674 { 675 0x84, 0xe2, /* subq 4,$sp */ 676 0x04, 0x01, /* addoq 4,$r0,$acr */ 677 0x7e, 0x7a, /* move $mof,[$sp] */ 678 0x3f, 0x7a, /* move [$acr],$mof */ 679 0x04, 0xf2, /* addq 4,$acr */ 680 0x6f, 0xfa, /* move.d [$acr],$acr */ 681 0xbf, 0x09, /* jump $acr */ 682 0xb0, 0x05, /* nop */ 683 0, 0, /* Pad out to 26 bytes. */ 684 0, 0, 0, 0, 685 0, 0, 0, 0 686 }; 687 688 /* Subsequent entries in a PIC procedure linkage table look like this. */ 689 690 static const bfd_byte elf_cris_pic_plt_entry[PLT_ENTRY_SIZE] = 691 { 692 0x6f, 0x0d, /* (bdap [pc+].d,r0) */ 693 0, 0, 0, 0, /* Replaced with offset of this symbol in .got. */ 694 0x30, 0x09, /* jump [...] */ 695 0x3f, 0x7e, /* move [pc+],mof */ 696 0, 0, 0, 0, /* Replaced with offset into relocation table. */ 697 0x2f, 0xfe, /* add.d [pc+],pc */ 698 0xec, 0xff, /* Replaced with offset to start of .plt. */ 699 0xff, 0xff 700 }; 701 702 static const bfd_byte elf_cris_pic_plt_entry_v32[PLT_ENTRY_SIZE_V32] = 703 { 704 0x6f, 0x0d, /* addo.d 0,$r0,$acr */ 705 0, 0, 0, 0, /* Replaced with offset of this symbol in .got. */ 706 0x6f, 0xfa, /* move.d [$acr],$acr */ 707 0xbf, 0x09, /* jump $acr */ 708 0xb0, 0x05, /* nop */ 709 0x3f, 0x7e, /* move relocoffs,$mof */ 710 0, 0, 0, 0, /* Replaced with offset into relocation table. */ 711 0xbf, 0x0e, /* ba start_of_plt */ 712 0, 0, 0, 0, /* Replaced with offset to start of .plt. */ 713 0xb0, 0x05 /* nop */ 714 }; 715 716 /* We copy elf32-m68k.c and elf32-i386.c for the basic linker hash bits 718 (and most other PIC/shlib stuff). Check that we don't drift away 719 without reason. 720 721 The CRIS linker, like the m68k and i386 linkers (and probably the rest 722 too) needs to keep track of the number of relocs that it decides to 723 copy in check_relocs for each symbol. This is so that it can discard 724 PC relative relocs if it doesn't need them when linking with 725 -Bsymbolic. We store the information in a field extending the regular 726 ELF linker hash table. */ 727 728 /* This structure keeps track of the number of PC relative relocs we have 729 copied for a given symbol. */ 730 731 struct elf_cris_pcrel_relocs_copied 732 { 733 /* Next section. */ 734 struct elf_cris_pcrel_relocs_copied *next; 735 736 /* A section in dynobj. */ 737 asection *section; 738 739 /* Number of relocs copied in this section. */ 740 bfd_size_type count; 741 742 /* Example of reloc being copied, for message. */ 743 enum elf_cris_reloc_type r_type; 744 }; 745 746 /* CRIS ELF linker hash entry. */ 747 748 struct elf_cris_link_hash_entry 749 { 750 struct elf_link_hash_entry root; 751 752 /* Number of PC relative relocs copied for this symbol. */ 753 struct elf_cris_pcrel_relocs_copied *pcrel_relocs_copied; 754 755 /* The GOTPLT references are CRIS-specific; the goal is to avoid having 756 both a general GOT and a PLT-specific GOT entry for the same symbol, 757 when it is referenced both as a function and as a function pointer. 758 759 Number of GOTPLT references for a function. */ 760 bfd_signed_vma gotplt_refcount; 761 762 /* Actual GOTPLT index for this symbol, if applicable, or zero if not 763 (zero is never used as an index). FIXME: We should be able to fold 764 this with gotplt_refcount in a union, like the got and plt unions in 765 elf_link_hash_entry. */ 766 bfd_size_type gotplt_offset; 767 768 /* The root.got.refcount is the sum of the regular reference counts 769 (this) and those members below. We have to keep a separate count 770 to track when we've found the first (or last) reference to a 771 regular got entry. The offset is in root.got.offset. */ 772 bfd_signed_vma reg_got_refcount; 773 774 /* Similar to the above, the number of reloc references to this 775 symbols that need a R_CRIS_32_TPREL slot. The offset is in 776 root.got.offset, because this and .dtp_refcount can't validly 777 happen when there's also a regular GOT entry; that's invalid 778 input for which an error is emitted. */ 779 bfd_signed_vma tprel_refcount; 780 781 /* Similar to the above, the number of reloc references to this 782 symbols that need a R_CRIS_DTP slot. The offset is in 783 root.got.offset; plus 4 if .tprel_refcount > 0. */ 784 bfd_signed_vma dtp_refcount; 785 }; 786 787 static bfd_boolean 788 elf_cris_discard_excess_dso_dynamics (struct elf_cris_link_hash_entry *, 789 void * ); 790 static bfd_boolean 791 elf_cris_discard_excess_program_dynamics (struct elf_cris_link_hash_entry *, 792 void *); 793 794 /* The local_got_refcounts and local_got_offsets are a multiple of 795 LSNUM in size, namely LGOT_ALLOC_NELTS_FOR(LSNUM) (plus one for the 796 refcount for GOT itself, see code), with the summary / group offset 797 for local symbols located at offset N, reference counts for 798 ordinary (address) relocs at offset N + LSNUM, for R_CRIS_DTP 799 relocs at offset N + 2*LSNUM, and for R_CRIS_32_TPREL relocs at N + 800 3*LSNUM. */ 801 802 #define LGOT_REG_NDX(x) ((x) + symtab_hdr->sh_info) 803 #define LGOT_DTP_NDX(x) ((x) + 2 * symtab_hdr->sh_info) 804 #define LGOT_TPREL_NDX(x) ((x) + 3 * symtab_hdr->sh_info) 805 #define LGOT_ALLOC_NELTS_FOR(x) ((x) * 4) 806 807 /* CRIS ELF linker hash table. */ 808 809 struct elf_cris_link_hash_table 810 { 811 struct elf_link_hash_table root; 812 813 /* We can't use the PLT offset and calculate to get the GOTPLT offset, 814 since we try and avoid creating GOTPLT:s when there's already a GOT. 815 Instead, we keep and update the next available index here. */ 816 bfd_size_type next_gotplt_entry; 817 818 /* The number of R_CRIS_32_DTPREL and R_CRIS_16_DTPREL that have 819 been seen for any input; if != 0, then the constant-offset 820 R_CRIS_DTPMOD is needed for this DSO/executable. This turns 821 negative at relocation, so that we don't need an extra flag for 822 when the reloc is output. */ 823 bfd_signed_vma dtpmod_refcount; 824 }; 825 826 /* Traverse a CRIS ELF linker hash table. */ 827 828 #define elf_cris_link_hash_traverse(table, func, info) \ 829 (elf_link_hash_traverse \ 830 (&(table)->root, \ 831 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ 832 (info))) 833 834 /* Get the CRIS ELF linker hash table from a link_info structure. */ 835 836 #define elf_cris_hash_table(p) \ 837 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 838 == CRIS_ELF_DATA ? ((struct elf_cris_link_hash_table *) ((p)->hash)) : NULL) 839 840 /* Get the CRIS ELF linker hash entry from a regular hash entry (the 841 "parent class"). The .root reference is just a simple type 842 check on the argument. */ 843 844 #define elf_cris_hash_entry(p) \ 845 ((struct elf_cris_link_hash_entry *) (&(p)->root)) 846 847 /* Create an entry in a CRIS ELF linker hash table. */ 848 849 static struct bfd_hash_entry * 850 elf_cris_link_hash_newfunc (struct bfd_hash_entry *entry, 851 struct bfd_hash_table *table, 852 const char *string) 853 { 854 struct elf_cris_link_hash_entry *ret = 855 (struct elf_cris_link_hash_entry *) entry; 856 857 /* Allocate the structure if it has not already been allocated by a 858 subclass. */ 859 if (ret == (struct elf_cris_link_hash_entry *) NULL) 860 ret = ((struct elf_cris_link_hash_entry *) 861 bfd_hash_allocate (table, 862 sizeof (struct elf_cris_link_hash_entry))); 863 if (ret == (struct elf_cris_link_hash_entry *) NULL) 864 return (struct bfd_hash_entry *) ret; 865 866 /* Call the allocation method of the superclass. */ 867 ret = ((struct elf_cris_link_hash_entry *) 868 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 869 table, string)); 870 if (ret != (struct elf_cris_link_hash_entry *) NULL) 871 { 872 ret->pcrel_relocs_copied = NULL; 873 ret->gotplt_refcount = 0; 874 ret->gotplt_offset = 0; 875 ret->dtp_refcount = 0; 876 ret->tprel_refcount = 0; 877 ret->reg_got_refcount = 0; 878 } 879 880 return (struct bfd_hash_entry *) ret; 881 } 882 883 /* Create a CRIS ELF linker hash table. */ 884 885 static struct bfd_link_hash_table * 886 elf_cris_link_hash_table_create (bfd *abfd) 887 { 888 struct elf_cris_link_hash_table *ret; 889 bfd_size_type amt = sizeof (struct elf_cris_link_hash_table); 890 891 ret = ((struct elf_cris_link_hash_table *) bfd_malloc (amt)); 892 if (ret == (struct elf_cris_link_hash_table *) NULL) 893 return NULL; 894 895 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 896 elf_cris_link_hash_newfunc, 897 sizeof (struct elf_cris_link_hash_entry), 898 CRIS_ELF_DATA)) 899 { 900 free (ret); 901 return NULL; 902 } 903 904 /* Initialize to skip over the first three entries in the gotplt; they 905 are used for run-time symbol evaluation. */ 906 ret->next_gotplt_entry = 12; 907 908 /* We haven't seen any R_CRIS_nn_GOT_TPREL initially. */ 909 ret->dtpmod_refcount = 0; 910 911 return &ret->root.root; 912 } 913 914 /* Perform a single relocation. By default we use the standard BFD 916 routines, with a few tweaks. */ 917 918 static bfd_reloc_status_type 919 cris_final_link_relocate (reloc_howto_type * howto, 920 bfd * input_bfd, 921 asection * input_section, 922 bfd_byte * contents, 923 Elf_Internal_Rela * rel, 924 bfd_vma relocation) 925 { 926 bfd_reloc_status_type r; 927 enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rel->r_info); 928 929 /* PC-relative relocations are relative to the position *after* 930 the reloc. Note that for R_CRIS_8_PCREL the adjustment is 931 not a single byte, since PC must be 16-bit-aligned. */ 932 switch (r_type) 933 { 934 /* Check that the 16-bit GOT relocs are positive. */ 935 case R_CRIS_16_GOTPLT: 936 case R_CRIS_16_GOT: 937 if ((bfd_signed_vma) relocation < 0) 938 return bfd_reloc_overflow; 939 break; 940 941 case R_CRIS_32_PLT_PCREL: 942 case R_CRIS_32_PCREL: 943 relocation -= 2; 944 /* Fall through. */ 945 case R_CRIS_8_PCREL: 946 case R_CRIS_16_PCREL: 947 relocation -= 2; 948 break; 949 950 default: 951 break; 952 } 953 954 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 955 contents, rel->r_offset, 956 relocation, rel->r_addend); 957 return r; 958 } 959 960 962 /* The number of errors left before we stop outputting reloc-specific 963 explanatory messages. By coincidence, this works nicely together 964 with the default number of messages you'll get from LD about 965 "relocation truncated to fit" messages before you get an 966 "additional relocation overflows omitted from the output". */ 967 static int additional_relocation_error_msg_count = 10; 968 969 /* Relocate an CRIS ELF section. See elf32-fr30.c, from where this was 970 copied, for further comments. */ 971 972 static bfd_boolean 973 cris_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, 974 struct bfd_link_info *info, 975 bfd *input_bfd, 976 asection *input_section, 977 bfd_byte *contents, 978 Elf_Internal_Rela *relocs, 979 Elf_Internal_Sym *local_syms, 980 asection **local_sections) 981 { 982 struct elf_cris_link_hash_table * htab; 983 bfd *dynobj; 984 Elf_Internal_Shdr *symtab_hdr; 985 struct elf_link_hash_entry **sym_hashes; 986 bfd_vma *local_got_offsets; 987 asection *sgot; 988 asection *splt; 989 asection *sreloc; 990 Elf_Internal_Rela *rel; 991 Elf_Internal_Rela *relend; 992 asection *srelgot; 993 994 htab = elf_cris_hash_table (info); 995 if (htab == NULL) 996 return FALSE; 997 998 dynobj = elf_hash_table (info)->dynobj; 999 local_got_offsets = elf_local_got_offsets (input_bfd); 1000 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 1001 sym_hashes = elf_sym_hashes (input_bfd); 1002 relend = relocs + input_section->reloc_count; 1003 1004 sgot = NULL; 1005 splt = NULL; 1006 sreloc = NULL; 1007 srelgot = NULL; 1008 1009 if (dynobj != NULL) 1010 { 1011 splt = bfd_get_linker_section (dynobj, ".plt"); 1012 sgot = bfd_get_linker_section (dynobj, ".got"); 1013 } 1014 1015 for (rel = relocs; rel < relend; rel ++) 1016 { 1017 reloc_howto_type *howto; 1018 unsigned long r_symndx; 1019 Elf_Internal_Sym *sym; 1020 asection *sec; 1021 struct elf_link_hash_entry *h; 1022 bfd_vma relocation; 1023 bfd_reloc_status_type r; 1024 const char *symname = NULL; 1025 enum elf_cris_reloc_type r_type; 1026 1027 r_type = ELF32_R_TYPE (rel->r_info); 1028 1029 if ( r_type == R_CRIS_GNU_VTINHERIT 1030 || r_type == R_CRIS_GNU_VTENTRY) 1031 continue; 1032 1033 r_symndx = ELF32_R_SYM (rel->r_info); 1034 howto = cris_elf_howto_table + r_type; 1035 h = NULL; 1036 sym = NULL; 1037 sec = NULL; 1038 1039 if (r_symndx < symtab_hdr->sh_info) 1040 { 1041 sym = local_syms + r_symndx; 1042 sec = local_sections [r_symndx]; 1043 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1044 1045 symname = (bfd_elf_string_from_elf_section 1046 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 1047 if (symname == NULL) 1048 symname = bfd_section_name (input_bfd, sec); 1049 } 1050 else 1051 { 1052 bfd_boolean warned; 1053 bfd_boolean unresolved_reloc; 1054 1055 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1056 r_symndx, symtab_hdr, sym_hashes, 1057 h, sec, relocation, 1058 unresolved_reloc, warned); 1059 1060 symname = h->root.root.string; 1061 1062 if (unresolved_reloc 1063 /* Perhaps we should detect the cases that 1064 sec->output_section is expected to be NULL like i386 and 1065 m68k, but apparently (and according to elfxx-ia64.c) all 1066 valid cases are where the symbol is defined in a shared 1067 object which we link dynamically against. This includes 1068 PLT relocs for which we've created a PLT entry and other 1069 relocs for which we're prepared to create dynamic 1070 relocations. 1071 1072 For now, new situations cause us to just err when 1073 sec->output_offset is NULL but the object with the symbol 1074 is *not* dynamically linked against. Thus this will 1075 automatically remind us so we can see if there are other 1076 valid cases we need to revisit. */ 1077 && (sec->owner->flags & DYNAMIC) != 0) 1078 relocation = 0; 1079 1080 else if (h->root.type == bfd_link_hash_defined 1081 || h->root.type == bfd_link_hash_defweak) 1082 { 1083 /* Here follow the cases where the relocation value must 1084 be zero (or when further handling is simplified when 1085 zero). I can't claim to understand the various 1086 conditions and they weren't described in the files 1087 where I copied them from (elf32-m68k.c and 1088 elf32-i386.c), but let's mention examples of where 1089 they happen. FIXME: Perhaps define and use a 1090 dynamic_symbol_p function like ia64. 1091 1092 - When creating a shared library, we can have an 1093 ordinary relocation for a symbol defined in a shared 1094 library (perhaps the one we create). We then make 1095 the relocation value zero, as the value seen now will 1096 be added into the relocation addend in this shared 1097 library, but must be handled only at dynamic-link 1098 time. FIXME: Not sure this example covers the 1099 h->elf_link_hash_flags test, though it's there in 1100 other targets. */ 1101 if (info->shared 1102 && ((! info->symbolic && h->dynindx != -1) 1103 || !h->def_regular) 1104 && (input_section->flags & SEC_ALLOC) != 0 1105 && (r_type == R_CRIS_8 1106 || r_type == R_CRIS_16 1107 || r_type == R_CRIS_32 1108 || r_type == R_CRIS_8_PCREL 1109 || r_type == R_CRIS_16_PCREL 1110 || r_type == R_CRIS_32_PCREL)) 1111 relocation = 0; 1112 else if (!info->relocatable && unresolved_reloc 1113 && (_bfd_elf_section_offset (output_bfd, info, 1114 input_section, 1115 rel->r_offset) 1116 != (bfd_vma) -1)) 1117 { 1118 _bfd_error_handler 1119 (_("%B, section %A: unresolvable relocation %s against symbol `%s'"), 1120 input_bfd, 1121 input_section, 1122 cris_elf_howto_table[r_type].name, 1123 symname); 1124 bfd_set_error (bfd_error_bad_value); 1125 return FALSE; 1126 } 1127 } 1128 } 1129 1130 if (sec != NULL && discarded_section (sec)) 1131 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 1132 rel, 1, relend, howto, 0, contents); 1133 1134 if (info->relocatable) 1135 continue; 1136 1137 switch (r_type) 1138 { 1139 case R_CRIS_16_GOTPLT: 1140 case R_CRIS_32_GOTPLT: 1141 /* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT, 1142 but we require a PLT, and the PLT handling will take care of 1143 filling in the PLT-specific GOT entry. For the GOT offset, 1144 calculate it as we do when filling it in for the .got.plt 1145 section. If we don't have a PLT, punt to GOT handling. */ 1146 if (h != NULL 1147 && ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0) 1148 { 1149 asection *sgotplt 1150 = bfd_get_linker_section (dynobj, ".got.plt"); 1151 bfd_vma got_offset; 1152 1153 BFD_ASSERT (h->dynindx != -1); 1154 BFD_ASSERT (sgotplt != NULL); 1155 1156 got_offset 1157 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset; 1158 1159 relocation = got_offset; 1160 break; 1161 } 1162 1163 /* We didn't make a PLT entry for this symbol. Maybe everything is 1164 folded into the GOT. Other than folding, this happens when 1165 statically linking PIC code, or when using -Bsymbolic. Check 1166 that we instead have a GOT entry as done for us by 1167 elf_cris_adjust_dynamic_symbol, and drop through into the 1168 ordinary GOT cases. This must not happen for the 1169 executable, because any reference it does to a function 1170 that is satisfied by a DSO must generate a PLT. We assume 1171 these call-specific relocs don't address non-functions. */ 1172 if (h != NULL 1173 && (h->got.offset == (bfd_vma) -1 1174 || (!info->shared 1175 && !(h->def_regular 1176 || (!h->def_dynamic 1177 && h->root.type == bfd_link_hash_undefweak))))) 1178 { 1179 (*_bfd_error_handler) 1180 ((h->got.offset == (bfd_vma) -1) 1181 ? _("%B, section %A: No PLT nor GOT for relocation %s" 1182 " against symbol `%s'") 1183 : _("%B, section %A: No PLT for relocation %s" 1184 " against symbol `%s'"), 1185 input_bfd, 1186 input_section, 1187 cris_elf_howto_table[r_type].name, 1188 (symname != NULL && symname[0] != '\0' 1189 ? symname : _("[whose name is lost]"))); 1190 1191 /* FIXME: Perhaps blaming input is not the right thing to 1192 do; this is probably an internal error. But it is true 1193 that we didn't like that particular input. */ 1194 bfd_set_error (bfd_error_bad_value); 1195 return FALSE; 1196 } 1197 /* Fall through. */ 1198 1199 /* The size of the actual relocation is not used here; we only 1200 fill in the GOT table here. */ 1201 case R_CRIS_16_GOT: 1202 case R_CRIS_32_GOT: 1203 { 1204 bfd_vma off; 1205 1206 /* Note that despite using RELA relocations, the .got contents 1207 is always filled in with the link-relative relocation 1208 value; the addend. */ 1209 1210 if (h != NULL) 1211 { 1212 off = h->got.offset; 1213 BFD_ASSERT (off != (bfd_vma) -1); 1214 1215 if (!elf_hash_table (info)->dynamic_sections_created 1216 || (! info->shared 1217 && (h->def_regular 1218 || h->type == STT_FUNC 1219 || h->needs_plt)) 1220 || (info->shared 1221 && (info->symbolic || h->dynindx == -1) 1222 && h->def_regular)) 1223 { 1224 /* This wasn't checked above for ! info->shared, but 1225 must hold there if we get here; the symbol must 1226 be defined in the regular program or be undefweak 1227 or be a function or otherwise need a PLT. */ 1228 BFD_ASSERT (!elf_hash_table (info)->dynamic_sections_created 1229 || info->shared 1230 || h->def_regular 1231 || h->type == STT_FUNC 1232 || h->needs_plt 1233 || h->root.type == bfd_link_hash_undefweak); 1234 1235 /* This is actually a static link, or it is a 1236 -Bsymbolic link and the symbol is defined locally, 1237 or is undefweak, or the symbol was forced to be 1238 local because of a version file, or we're not 1239 creating a dynamic object. We must initialize this 1240 entry in the global offset table. Since the offset 1241 must always be a multiple of 4, we use the least 1242 significant bit to record whether we have 1243 initialized it already. 1244 1245 If this GOT entry should be runtime-initialized, we 1246 will create a .rela.got relocation entry to 1247 initialize the value. This is done in the 1248 finish_dynamic_symbol routine. */ 1249 if ((off & 1) != 0) 1250 off &= ~1; 1251 else 1252 { 1253 bfd_put_32 (output_bfd, relocation, 1254 sgot->contents + off); 1255 h->got.offset |= 1; 1256 } 1257 } 1258 } 1259 else 1260 { 1261 BFD_ASSERT (local_got_offsets != NULL 1262 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1263 1264 off = local_got_offsets[r_symndx]; 1265 1266 /* The offset must always be a multiple of 4. We use 1267 the least significant bit to record whether we have 1268 already generated the necessary reloc. */ 1269 if ((off & 1) != 0) 1270 off &= ~1; 1271 else 1272 { 1273 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1274 1275 if (info->shared) 1276 { 1277 Elf_Internal_Rela outrel; 1278 bfd_byte *loc; 1279 1280 if (srelgot == NULL) 1281 srelgot 1282 = bfd_get_linker_section (dynobj, ".rela.got"); 1283 BFD_ASSERT (srelgot != NULL); 1284 1285 outrel.r_offset = (sgot->output_section->vma 1286 + sgot->output_offset 1287 + off); 1288 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE); 1289 outrel.r_addend = relocation; 1290 loc = srelgot->contents; 1291 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 1292 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1293 } 1294 1295 local_got_offsets[r_symndx] |= 1; 1296 } 1297 } 1298 1299 relocation = sgot->output_offset + off; 1300 if (rel->r_addend != 0) 1301 { 1302 /* We can't do anything for a relocation which is against 1303 a symbol *plus offset*. GOT holds relocations for 1304 symbols. Make this an error; the compiler isn't 1305 allowed to pass us these kinds of things. */ 1306 if (h == NULL) 1307 (*_bfd_error_handler) 1308 (_("%B, section %A: relocation %s with non-zero addend %d" 1309 " against local symbol"), 1310 input_bfd, 1311 input_section, 1312 cris_elf_howto_table[r_type].name, 1313 rel->r_addend); 1314 else 1315 (*_bfd_error_handler) 1316 (_("%B, section %A: relocation %s with non-zero addend %d" 1317 " against symbol `%s'"), 1318 input_bfd, 1319 input_section, 1320 cris_elf_howto_table[r_type].name, 1321 rel->r_addend, 1322 symname[0] != '\0' ? symname : _("[whose name is lost]")); 1323 1324 bfd_set_error (bfd_error_bad_value); 1325 return FALSE; 1326 } 1327 } 1328 break; 1329 1330 case R_CRIS_32_GOTREL: 1331 /* This relocation must only be performed against local symbols. 1332 It's also ok when we link a program and the symbol is either 1333 defined in an ordinary (non-DSO) object or is undefined weak. */ 1334 if (h != NULL 1335 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1336 && !(!info->shared 1337 && (h->def_regular 1338 || (!h->def_dynamic 1339 && h->root.type == bfd_link_hash_undefweak)))) 1340 { 1341 (*_bfd_error_handler) 1342 (_("%B, section %A: relocation %s is" 1343 " not allowed for global symbol: `%s'"), 1344 input_bfd, 1345 input_section, 1346 cris_elf_howto_table[r_type].name, 1347 symname); 1348 bfd_set_error (bfd_error_bad_value); 1349 return FALSE; 1350 } 1351 1352 /* This can happen if we get a link error with the input ELF 1353 variant mismatching the output variant. Emit an error so 1354 it's noticed if it happens elsewhere. */ 1355 if (sgot == NULL) 1356 { 1357 (*_bfd_error_handler) 1358 (_("%B, section %A: relocation %s with no GOT created"), 1359 input_bfd, 1360 input_section, 1361 cris_elf_howto_table[r_type].name); 1362 bfd_set_error (bfd_error_bad_value); 1363 return FALSE; 1364 } 1365 1366 /* This relocation is like a PC-relative one, except the 1367 reference point is the location of GOT. Note that 1368 sgot->output_offset is not involved in this calculation. We 1369 always want the start of entire .got section, not the 1370 position after the reserved header. */ 1371 relocation -= sgot->output_section->vma; 1372 break; 1373 1374 case R_CRIS_32_PLT_PCREL: 1375 /* Relocation is to the entry for this symbol in the 1376 procedure linkage table. */ 1377 1378 /* Resolve a PLT_PCREL reloc against a local symbol directly, 1379 without using the procedure linkage table. */ 1380 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 1381 break; 1382 1383 if (h->plt.offset == (bfd_vma) -1 1384 || splt == NULL) 1385 { 1386 /* We didn't make a PLT entry for this symbol. This 1387 happens when statically linking PIC code, or when 1388 using -Bsymbolic. */ 1389 break; 1390 } 1391 1392 relocation = (splt->output_section->vma 1393 + splt->output_offset 1394 + h->plt.offset); 1395 break; 1396 1397 case R_CRIS_32_PLT_GOTREL: 1398 /* Like R_CRIS_32_PLT_PCREL, but the reference point is the 1399 start of the .got section. See also comment at 1400 R_CRIS_32_GOT. */ 1401 relocation -= sgot->output_section->vma; 1402 1403 /* Resolve a PLT_GOTREL reloc against a local symbol directly, 1404 without using the procedure linkage table. */ 1405 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 1406 break; 1407 1408 if (h->plt.offset == (bfd_vma) -1 1409 || splt == NULL) 1410 { 1411 /* We didn't make a PLT entry for this symbol. This 1412 happens when statically linking PIC code, or when 1413 using -Bsymbolic. */ 1414 break; 1415 } 1416 1417 relocation = (splt->output_section->vma 1418 + splt->output_offset 1419 + h->plt.offset 1420 - sgot->output_section->vma); 1421 break; 1422 1423 case R_CRIS_8_PCREL: 1424 case R_CRIS_16_PCREL: 1425 case R_CRIS_32_PCREL: 1426 /* If the symbol was local, we need no shlib-specific handling. */ 1427 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1428 || h->dynindx == -1) 1429 break; 1430 1431 /* Fall through. */ 1432 case R_CRIS_8: 1433 case R_CRIS_16: 1434 case R_CRIS_32: 1435 if (info->shared 1436 && r_symndx != STN_UNDEF 1437 && (input_section->flags & SEC_ALLOC) != 0 1438 && ((r_type != R_CRIS_8_PCREL 1439 && r_type != R_CRIS_16_PCREL 1440 && r_type != R_CRIS_32_PCREL) 1441 || (!info->symbolic 1442 || (h != NULL && !h->def_regular)))) 1443 { 1444 Elf_Internal_Rela outrel; 1445 bfd_byte *loc; 1446 bfd_boolean skip, relocate; 1447 1448 /* When generating a shared object, these relocations 1449 are copied into the output file to be resolved at run 1450 time. */ 1451 1452 if (sreloc == NULL) 1453 { 1454 sreloc = _bfd_elf_get_dynamic_reloc_section 1455 (dynobj, input_section, /*rela?*/ TRUE); 1456 /* The section should have been created in cris_elf_check_relocs, 1457 but that function will not be called for objects which fail in 1458 cris_elf_merge_private_bfd_data. */ 1459 if (sreloc == NULL) 1460 { 1461 bfd_set_error (bfd_error_bad_value); 1462 return FALSE; 1463 } 1464 } 1465 1466 skip = FALSE; 1467 relocate = FALSE; 1468 1469 outrel.r_offset = 1470 _bfd_elf_section_offset (output_bfd, info, input_section, 1471 rel->r_offset); 1472 if (outrel.r_offset == (bfd_vma) -1) 1473 skip = TRUE; 1474 else if (outrel.r_offset == (bfd_vma) -2 1475 /* For now, undefined weak symbols with non-default 1476 visibility (yielding 0), like exception info for 1477 discarded sections, will get a R_CRIS_NONE 1478 relocation rather than no relocation, because we 1479 notice too late that the symbol doesn't need a 1480 relocation. */ 1481 || (h != NULL 1482 && h->root.type == bfd_link_hash_undefweak 1483 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)) 1484 skip = TRUE, relocate = TRUE; 1485 outrel.r_offset += (input_section->output_section->vma 1486 + input_section->output_offset); 1487 1488 if (skip) 1489 memset (&outrel, 0, sizeof outrel); 1490 /* h->dynindx may be -1 if the symbol was marked to 1491 become local. */ 1492 else if (h != NULL 1493 && ((! info->symbolic && h->dynindx != -1) 1494 || !h->def_regular)) 1495 { 1496 BFD_ASSERT (h->dynindx != -1); 1497 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1498 outrel.r_addend = relocation + rel->r_addend; 1499 } 1500 else 1501 { 1502 outrel.r_addend = relocation + rel->r_addend; 1503 1504 if (r_type == R_CRIS_32) 1505 { 1506 relocate = TRUE; 1507 outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE); 1508 } 1509 else 1510 { 1511 long indx; 1512 1513 if (bfd_is_abs_section (sec)) 1514 indx = 0; 1515 else if (sec == NULL || sec->owner == NULL) 1516 { 1517 bfd_set_error (bfd_error_bad_value); 1518 return FALSE; 1519 } 1520 else 1521 { 1522 asection *osec; 1523 1524 /* We are turning this relocation into one 1525 against a section symbol. It would be 1526 proper to subtract the symbol's value, 1527 osec->vma, from the emitted reloc addend, 1528 but ld.so expects buggy relocs. */ 1529 osec = sec->output_section; 1530 indx = elf_section_data (osec)->dynindx; 1531 if (indx == 0) 1532 { 1533 osec = htab->root.text_index_section; 1534 indx = elf_section_data (osec)->dynindx; 1535 } 1536 BFD_ASSERT (indx != 0); 1537 } 1538 1539 outrel.r_info = ELF32_R_INFO (indx, r_type); 1540 } 1541 } 1542 1543 loc = sreloc->contents; 1544 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 1545 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1546 1547 /* This reloc will be computed at runtime, so there's no 1548 need to do anything now, except for R_CRIS_32 relocations 1549 that have been turned into R_CRIS_RELATIVE. */ 1550 if (!relocate) 1551 continue; 1552 } 1553 1554 break; 1555 1556 case R_CRIS_16_DTPREL: 1557 case R_CRIS_32_DTPREL: 1558 /* This relocation must only be performed against local 1559 symbols, or to sections that are not loadable. It's also 1560 ok when we link a program and the symbol is defined in an 1561 ordinary (non-DSO) object (if it's undefined there, we've 1562 already seen an error). */ 1563 if (h != NULL 1564 && (input_section->flags & SEC_ALLOC) != 0 1565 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1566 && (info->shared 1567 || (!h->def_regular 1568 && h->root.type != bfd_link_hash_undefined))) 1569 { 1570 (*_bfd_error_handler) 1571 ((h->root.type == bfd_link_hash_undefined) 1572 /* We shouldn't get here for GCC-emitted code. */ 1573 ? _("%B, section %A: relocation %s has an undefined" 1574 " reference to `%s', perhaps a declaration mixup?") 1575 : ("%B, section %A: relocation %s is" 1576 " not allowed for `%s', a global symbol with default" 1577 " visibility, perhaps a declaration mixup?"), 1578 input_bfd, 1579 input_section, 1580 cris_elf_howto_table[r_type].name, 1581 symname != NULL && symname[0] != '\0' 1582 ? symname : _("[whose name is lost]")); 1583 bfd_set_error (bfd_error_bad_value); 1584 return FALSE; 1585 } 1586 1587 BFD_ASSERT ((input_section->flags & SEC_ALLOC) == 0 1588 || htab->dtpmod_refcount != 0); 1589 1590 /* Fill in a R_CRIS_DTPMOD reloc at offset 3 if we haven't 1591 already done so. Note that we do this in .got.plt, not 1592 in .got, as .got.plt contains the first part, still the 1593 reloc is against .got, because the linker script directs 1594 (is required to direct) them both into .got. */ 1595 if (htab->dtpmod_refcount > 0 1596 && (input_section->flags & SEC_ALLOC) != 0) 1597 { 1598 asection *sgotplt = bfd_get_linker_section (dynobj, ".got.plt"); 1599 BFD_ASSERT (sgotplt != NULL); 1600 1601 if (info->shared) 1602 { 1603 Elf_Internal_Rela outrel; 1604 bfd_byte *loc; 1605 1606 if (srelgot == NULL) 1607 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 1608 BFD_ASSERT (srelgot != NULL); 1609 loc = srelgot->contents; 1610 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 1611 1612 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 12); 1613 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 16); 1614 outrel.r_offset = (sgotplt->output_section->vma 1615 + sgotplt->output_offset 1616 + 12); 1617 outrel.r_info = ELF32_R_INFO (0, R_CRIS_DTPMOD); 1618 outrel.r_addend = 0; 1619 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1620 } 1621 else 1622 { 1623 /* For an executable, the GOT entry contents is known. */ 1624 bfd_put_32 (output_bfd, (bfd_vma) 1, sgotplt->contents + 12); 1625 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 16); 1626 } 1627 1628 /* Reverse the sign to mark that we've emitted the 1629 required GOT entry. */ 1630 htab->dtpmod_refcount = - htab->dtpmod_refcount; 1631 } 1632 1633 /* The relocation is the offset from the start of the module 1634 TLS block to the (local) symbol. */ 1635 relocation -= elf_hash_table (info)->tls_sec == NULL 1636 ? 0 : elf_hash_table (info)->tls_sec->vma; 1637 break; 1638 1639 case R_CRIS_32_GD: 1640 if (info->shared) 1641 { 1642 bfd_set_error (bfd_error_invalid_operation); 1643 1644 /* We've already informed in cris_elf_check_relocs that 1645 this is an error. */ 1646 return FALSE; 1647 } 1648 /* Fall through. */ 1649 1650 case R_CRIS_16_GOT_GD: 1651 case R_CRIS_32_GOT_GD: 1652 if (rel->r_addend != 0) 1653 { 1654 /* We can't do anything for a relocation which is against a 1655 symbol *plus offset*. The GOT holds relocations for 1656 symbols. Make this an error; the compiler isn't allowed 1657 to pass us these kinds of things. */ 1658 (*_bfd_error_handler) 1659 (_("%B, section %A: relocation %s with non-zero addend %d" 1660 " against symbol `%s'"), 1661 input_bfd, 1662 input_section, 1663 cris_elf_howto_table[r_type].name, 1664 rel->r_addend, 1665 symname[0] != '\0' ? symname : _("[whose name is lost]")); 1666 1667 bfd_set_error (bfd_error_bad_value); 1668 return FALSE; 1669 } 1670 1671 if (!info->shared 1672 && (h == NULL || h->def_regular || ELF_COMMON_DEF_P (h))) 1673 { 1674 /* Known contents of the GOT. */ 1675 bfd_vma off; 1676 1677 /* The symbol is defined in the program, so just write 1678 (1, known_tpoffset) into the GOT. */ 1679 relocation -= elf_hash_table (info)->tls_sec->vma; 1680 1681 if (h != NULL) 1682 { 1683 off = elf_cris_hash_entry (h)->tprel_refcount > 0 1684 ? h->got.offset + 4 : h->got.offset; 1685 } 1686 else 1687 { 1688 off = local_got_offsets[r_symndx]; 1689 if (local_got_offsets[LGOT_TPREL_NDX (r_symndx)]) 1690 off += 4; 1691 } 1692 1693 /* We use bit 1 of the offset as a flag for GOT entry with 1694 the R_CRIS_DTP reloc, setting it when we've emitted the 1695 GOT entry and reloc. Bit 0 is used for R_CRIS_32_TPREL 1696 relocs. */ 1697 if ((off & 2) == 0) 1698 { 1699 off &= ~3; 1700 1701 if (h != NULL) 1702 h->got.offset |= 2; 1703 else 1704 local_got_offsets[r_symndx] |= 2; 1705 1706 bfd_put_32 (output_bfd, 1, sgot->contents + off); 1707 bfd_put_32 (output_bfd, relocation, sgot->contents + off + 4); 1708 } 1709 else 1710 off &= ~3; 1711 1712 relocation = sgot->output_offset + off 1713 + (r_type == R_CRIS_32_GD ? sgot->output_section->vma : 0); 1714 } 1715 else 1716 { 1717 /* Not all parts of the GOT entry are known; emit a real 1718 relocation. */ 1719 bfd_vma off; 1720 1721 if (h != NULL) 1722 off = elf_cris_hash_entry (h)->tprel_refcount > 0 1723 ? h->got.offset + 4 : h->got.offset; 1724 else 1725 { 1726 off = local_got_offsets[r_symndx]; 1727 if (local_got_offsets[LGOT_TPREL_NDX (r_symndx)]) 1728 off += 4; 1729 } 1730 1731 /* See above re bit 1 and bit 0 usage. */ 1732 if ((off & 2) == 0) 1733 { 1734 Elf_Internal_Rela outrel; 1735 bfd_byte *loc; 1736 1737 off &= ~3; 1738 1739 if (h != NULL) 1740 h->got.offset |= 2; 1741 else 1742 local_got_offsets[r_symndx] |= 2; 1743 1744 /* Clear the target contents of the GOT (just as a 1745 gesture; it's already cleared on allocation): this 1746 relocation is not like the other dynrelocs. */ 1747 bfd_put_32 (output_bfd, 0, sgot->contents + off); 1748 bfd_put_32 (output_bfd, 0, sgot->contents + off + 4); 1749 1750 if (srelgot == NULL) 1751 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 1752 BFD_ASSERT (srelgot != NULL); 1753 1754 if (h != NULL && h->dynindx != -1) 1755 { 1756 outrel.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_DTP); 1757 relocation = 0; 1758 } 1759 else 1760 { 1761 outrel.r_info = ELF32_R_INFO (0, R_CRIS_DTP); 1762 1763 /* NULL if we had an error. */ 1764 relocation -= elf_hash_table (info)->tls_sec == NULL 1765 ? 0 : elf_hash_table (info)->tls_sec->vma; 1766 } 1767 1768 outrel.r_offset = (sgot->output_section->vma 1769 + sgot->output_offset 1770 + off); 1771 outrel.r_addend = relocation; 1772 loc = srelgot->contents; 1773 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 1774 1775 /* NULL if we had an error. */ 1776 if (srelgot->contents != NULL) 1777 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1778 } 1779 else 1780 off &= ~3; 1781 1782 relocation = sgot->output_offset + off 1783 + (r_type == R_CRIS_32_GD ? sgot->output_section->vma : 0); 1784 } 1785 1786 /* The GOT-relative offset to the GOT entry is the 1787 relocation, or for R_CRIS_32_GD, the actual address of 1788 the GOT entry. */ 1789 break; 1790 1791 case R_CRIS_32_IE: 1792 if (info->shared) 1793 { 1794 bfd_set_error (bfd_error_invalid_operation); 1795 1796 /* We've already informed in cris_elf_check_relocs that 1797 this is an error. */ 1798 return FALSE; 1799 } 1800 /* Fall through. */ 1801 1802 case R_CRIS_32_GOT_TPREL: 1803 case R_CRIS_16_GOT_TPREL: 1804 if (rel->r_addend != 0) 1805 { 1806 /* We can't do anything for a relocation which is 1807 against a symbol *plus offset*. GOT holds 1808 relocations for symbols. Make this an error; the 1809 compiler isn't allowed to pass us these kinds of 1810 things. */ 1811 (*_bfd_error_handler) 1812 (_("%B, section %A: relocation %s with non-zero addend %d" 1813 " against symbol `%s'"), 1814 input_bfd, 1815 input_section, 1816 cris_elf_howto_table[r_type].name, 1817 rel->r_addend, 1818 symname[0] != '\0' ? symname : _("[whose name is lost]")); 1819 bfd_set_error (bfd_error_bad_value); 1820 return FALSE; 1821 } 1822 1823 if (!info->shared 1824 && (h == NULL || h->def_regular || ELF_COMMON_DEF_P (h))) 1825 { 1826 /* Known contents of the GOT. */ 1827 bfd_vma off; 1828 1829 /* The symbol is defined in the program, so just write 1830 the -prog_tls_size+known_tpoffset into the GOT. */ 1831 relocation -= elf_hash_table (info)->tls_sec->vma; 1832 relocation -= elf_hash_table (info)->tls_size; 1833 1834 if (h != NULL) 1835 off = h->got.offset; 1836 else 1837 off = local_got_offsets[r_symndx]; 1838 1839 /* Bit 0 is used to mark whether we've emitted the required 1840 entry (and if needed R_CRIS_32_TPREL reloc). Bit 1 1841 is used similarly for R_CRIS_DTP, see above. */ 1842 if ((off & 1) == 0) 1843 { 1844 off &= ~3; 1845 1846 if (h != NULL) 1847 h->got.offset |= 1; 1848 else 1849 local_got_offsets[r_symndx] |= 1; 1850 1851 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1852 } 1853 else 1854 off &= ~3; 1855 1856 relocation = sgot->output_offset + off 1857 + (r_type == R_CRIS_32_IE ? sgot->output_section->vma : 0); 1858 } 1859 else 1860 { 1861 /* Emit a real relocation. */ 1862 bfd_vma off; 1863 1864 if (h != NULL) 1865 off = h->got.offset; 1866 else 1867 off = local_got_offsets[r_symndx]; 1868 1869 /* See above re usage of bit 0 and 1. */ 1870 if ((off & 1) == 0) 1871 { 1872 Elf_Internal_Rela outrel; 1873 bfd_byte *loc; 1874 1875 off &= ~3; 1876 1877 if (h != NULL) 1878 h->got.offset |= 1; 1879 else 1880 local_got_offsets[r_symndx] |= 1; 1881 1882 if (srelgot == NULL) 1883 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 1884 BFD_ASSERT (srelgot != NULL); 1885 1886 if (h != NULL && h->dynindx != -1) 1887 { 1888 outrel.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_32_TPREL); 1889 relocation = 0; 1890 } 1891 else 1892 { 1893 outrel.r_info = ELF32_R_INFO (0, R_CRIS_32_TPREL); 1894 1895 /* NULL if we had an error. */ 1896 relocation -= elf_hash_table (info)->tls_sec == NULL 1897 ? 0 : elf_hash_table (info)->tls_sec->vma; 1898 } 1899 1900 /* Just "define" the initial contents in some 1901 semi-logical way. */ 1902 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1903 1904 outrel.r_offset = (sgot->output_section->vma 1905 + sgot->output_offset 1906 + off); 1907 outrel.r_addend = relocation; 1908 loc = srelgot->contents; 1909 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 1910 /* NULL if we had an error. */ 1911 if (srelgot->contents != NULL) 1912 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1913 } 1914 else 1915 off &= ~3; 1916 1917 relocation = sgot->output_offset + off 1918 + (r_type == R_CRIS_32_IE ? sgot->output_section->vma : 0); 1919 } 1920 1921 /* The GOT-relative offset to the GOT entry is the relocation, 1922 or for R_CRIS_32_GD, the actual address of the GOT entry. */ 1923 break; 1924 1925 case R_CRIS_16_TPREL: 1926 case R_CRIS_32_TPREL: 1927 /* This relocation must only be performed against symbols 1928 defined in an ordinary (non-DSO) object. */ 1929 if (info->shared) 1930 { 1931 bfd_set_error (bfd_error_invalid_operation); 1932 1933 /* We've already informed in cris_elf_check_relocs that 1934 this is an error. */ 1935 return FALSE; 1936 } 1937 1938 if (h != NULL 1939 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1940 && !(h->def_regular || ELF_COMMON_DEF_P (h)) 1941 /* If it's undefined, then an error message has already 1942 been emitted. */ 1943 && h->root.type != bfd_link_hash_undefined) 1944 { 1945 (*_bfd_error_handler) 1946 (_("%B, section %A: relocation %s is" 1947 " not allowed for symbol: `%s'" 1948 " which is defined outside the program," 1949 " perhaps a declaration mixup?"), 1950 input_bfd, 1951 input_section, 1952 cris_elf_howto_table[r_type].name, 1953 symname); 1954 bfd_set_error (bfd_error_bad_value); 1955 return FALSE; 1956 } 1957 1958 /* NULL if we had an error. */ 1959 relocation -= elf_hash_table (info)->tls_sec == NULL 1960 ? 0 1961 : (elf_hash_table (info)->tls_sec->vma 1962 + elf_hash_table (info)->tls_size); 1963 1964 /* The TLS-relative offset is the relocation. */ 1965 break; 1966 1967 default: 1968 BFD_FAIL (); 1969 return FALSE; 1970 } 1971 1972 r = cris_final_link_relocate (howto, input_bfd, input_section, 1973 contents, rel, relocation); 1974 1975 if (r != bfd_reloc_ok) 1976 { 1977 const char * msg = (const char *) NULL; 1978 1979 switch (r) 1980 { 1981 case bfd_reloc_overflow: 1982 r = info->callbacks->reloc_overflow 1983 (info, (h ? &h->root : NULL), symname, howto->name, 1984 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 1985 if (additional_relocation_error_msg_count > 0) 1986 { 1987 additional_relocation_error_msg_count--; 1988 switch (r_type) 1989 { 1990 case R_CRIS_16_GOTPLT: 1991 case R_CRIS_16_GOT: 1992 1993 /* Not just TLS is involved here, so we make 1994 generation and message depend on -fPIC/-fpic 1995 only. */ 1996 case R_CRIS_16_GOT_TPREL: 1997 case R_CRIS_16_GOT_GD: 1998 (*_bfd_error_handler) 1999 (_("(too many global variables for -fpic:" 2000 " recompile with -fPIC)")); 2001 break; 2002 2003 case R_CRIS_16_TPREL: 2004 case R_CRIS_16_DTPREL: 2005 (*_bfd_error_handler) 2006 (_("(thread-local data too big for -fpic or" 2007 " -msmall-tls: recompile with -fPIC or" 2008 " -mno-small-tls)")); 2009 break; 2010 2011 /* No known cause for overflow for other relocs. */ 2012 default: 2013 break; 2014 } 2015 } 2016 break; 2017 2018 case bfd_reloc_undefined: 2019 r = info->callbacks->undefined_symbol 2020 (info, symname, input_bfd, input_section, rel->r_offset, 2021 TRUE); 2022 break; 2023 2024 case bfd_reloc_outofrange: 2025 msg = _("internal error: out of range error"); 2026 break; 2027 2028 case bfd_reloc_notsupported: 2029 msg = _("internal error: unsupported relocation error"); 2030 break; 2031 2032 case bfd_reloc_dangerous: 2033 msg = _("internal error: dangerous relocation"); 2034 break; 2035 2036 default: 2037 msg = _("internal error: unknown error"); 2038 break; 2039 } 2040 2041 if (msg) 2042 r = info->callbacks->warning 2043 (info, msg, symname, input_bfd, input_section, rel->r_offset); 2044 2045 if (! r) 2046 return FALSE; 2047 } 2048 } 2049 2050 return TRUE; 2051 } 2052 2053 /* Finish up dynamic symbol handling. We set the contents of various 2055 dynamic sections here. */ 2056 2057 static bfd_boolean 2058 elf_cris_finish_dynamic_symbol (bfd *output_bfd, 2059 struct bfd_link_info *info, 2060 struct elf_link_hash_entry *h, 2061 Elf_Internal_Sym *sym) 2062 { 2063 struct elf_cris_link_hash_table * htab; 2064 bfd *dynobj; 2065 2066 /* Where in the plt entry to put values. */ 2067 int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16; 2068 2069 /* What offset to add to the distance to the first PLT entry for the 2070 value at plt_off3. */ 2071 int plt_off3_value_bias = 4; 2072 2073 /* Where in the PLT entry the call-dynlink-stub is (happens to be same 2074 for PIC and non-PIC for v32 and pre-v32). */ 2075 int plt_stub_offset = 8; 2076 int plt_entry_size = PLT_ENTRY_SIZE; 2077 const bfd_byte *plt_entry = elf_cris_plt_entry; 2078 const bfd_byte *plt_pic_entry = elf_cris_pic_plt_entry; 2079 2080 htab = elf_cris_hash_table (info); 2081 if (htab == NULL) 2082 return FALSE; 2083 2084 /* Adjust the various PLT entry offsets. */ 2085 if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32) 2086 { 2087 plt_off2 = 14; 2088 plt_off3 = 20; 2089 plt_off3_value_bias = -2; 2090 plt_stub_offset = 12; 2091 plt_entry_size = PLT_ENTRY_SIZE_V32; 2092 plt_entry = elf_cris_plt_entry_v32; 2093 plt_pic_entry = elf_cris_pic_plt_entry_v32; 2094 } 2095 2096 dynobj = elf_hash_table (info)->dynobj; 2097 2098 if (h->plt.offset != (bfd_vma) -1) 2099 { 2100 asection *splt; 2101 asection *sgotplt; 2102 asection *srela; 2103 bfd_vma got_base; 2104 2105 bfd_vma gotplt_offset 2106 = elf_cris_hash_entry (h)->gotplt_offset; 2107 Elf_Internal_Rela rela; 2108 bfd_byte *loc; 2109 bfd_boolean has_gotplt = gotplt_offset != 0; 2110 2111 /* Get the index in the .rela.plt relocations for the .got.plt 2112 entry that corresponds to this symbol. 2113 We have to count backwards here, and the result is only valid 2114 as an index into .rela.plt. We also have to undo the effect 2115 of the R_CRIS_DTPMOD entry at .got index 3 (offset 12 into 2116 .got.plt) for which gotplt_offset is adjusted, because while 2117 that entry goes into .got.plt, its relocation goes into 2118 .rela.got, not .rela.plt. (It's not PLT-specific; not to be 2119 processed as part of the runtime lazy .rela.plt relocation). 2120 FIXME: There be literal constants here... */ 2121 bfd_vma rela_plt_index 2122 = (htab->dtpmod_refcount != 0 2123 ? gotplt_offset/4 - 2 - 3 : gotplt_offset/4 - 3); 2124 2125 /* Get the offset into the .got table of the entry that corresponds 2126 to this function. Note that we embed knowledge that "incoming" 2127 .got goes after .got.plt in the output without padding (pointer 2128 aligned). However, that knowledge is present in several other 2129 places too. */ 2130 bfd_vma got_offset 2131 = (has_gotplt 2132 ? gotplt_offset 2133 : h->got.offset + htab->next_gotplt_entry); 2134 2135 /* This symbol has an entry in the procedure linkage table. Set it 2136 up. */ 2137 2138 BFD_ASSERT (h->dynindx != -1); 2139 2140 splt = bfd_get_linker_section (dynobj, ".plt"); 2141 sgotplt = bfd_get_linker_section (dynobj, ".got.plt"); 2142 srela = bfd_get_linker_section (dynobj, ".rela.plt"); 2143 BFD_ASSERT (splt != NULL && sgotplt != NULL 2144 && (! has_gotplt || srela != NULL)); 2145 2146 got_base = sgotplt->output_section->vma + sgotplt->output_offset; 2147 2148 /* Fill in the entry in the procedure linkage table. */ 2149 if (! info->shared) 2150 { 2151 memcpy (splt->contents + h->plt.offset, plt_entry, 2152 plt_entry_size); 2153 2154 /* We need to enter the absolute address of the GOT entry here. */ 2155 bfd_put_32 (output_bfd, got_base + got_offset, 2156 splt->contents + h->plt.offset + plt_off1); 2157 } 2158 else 2159 { 2160 memcpy (splt->contents + h->plt.offset, plt_pic_entry, 2161 plt_entry_size); 2162 bfd_put_32 (output_bfd, got_offset, 2163 splt->contents + h->plt.offset + plt_off1); 2164 } 2165 2166 /* Fill in the plt entry and make a relocation, if this is a "real" 2167 PLT entry. */ 2168 if (has_gotplt) 2169 { 2170 /* Fill in the offset to the reloc table. */ 2171 bfd_put_32 (output_bfd, 2172 rela_plt_index * sizeof (Elf32_External_Rela), 2173 splt->contents + h->plt.offset + plt_off2); 2174 2175 /* Fill in the offset to the first PLT entry, where to "jump". */ 2176 bfd_put_32 (output_bfd, 2177 - (h->plt.offset + plt_off3 + plt_off3_value_bias), 2178 splt->contents + h->plt.offset + plt_off3); 2179 2180 /* Fill in the entry in the global offset table with the address of 2181 the relocating stub. */ 2182 bfd_put_32 (output_bfd, 2183 (splt->output_section->vma 2184 + splt->output_offset 2185 + h->plt.offset 2186 + plt_stub_offset), 2187 sgotplt->contents + got_offset); 2188 2189 /* Fill in the entry in the .rela.plt section. */ 2190 rela.r_offset = (sgotplt->output_section->vma 2191 + sgotplt->output_offset 2192 + got_offset); 2193 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_JUMP_SLOT); 2194 rela.r_addend = 0; 2195 loc = srela->contents + rela_plt_index * sizeof (Elf32_External_Rela); 2196 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2197 } 2198 2199 if (!h->def_regular) 2200 { 2201 /* Mark the symbol as undefined, rather than as defined in 2202 the .plt section. Leave the value alone. */ 2203 sym->st_shndx = SHN_UNDEF; 2204 2205 /* FIXME: From elf32-sparc.c 2001-02-19 (1.18). I still don't 2206 know whether resetting the value is significant; if it really 2207 is, rather than a quirk or bug in the sparc port, then I 2208 believe we'd see this elsewhere. */ 2209 /* If the symbol is weak, we do need to clear the value. 2210 Otherwise, the PLT entry would provide a definition for 2211 the symbol even if the symbol wasn't defined anywhere, 2212 and so the symbol would never be NULL. */ 2213 if (!h->ref_regular_nonweak) 2214 sym->st_value = 0; 2215 } 2216 } 2217 2218 /* For an ordinary program, we emit .got relocs only for symbols that 2219 are in the dynamic-symbols table and are either defined by the 2220 program or are undefined weak symbols, or are function symbols 2221 where we do not output a PLT: the PLT reloc was output above and all 2222 references to the function symbol are redirected to the PLT. */ 2223 if (h->got.offset != (bfd_vma) -1 2224 && (elf_cris_hash_entry (h)->reg_got_refcount > 0) 2225 && (info->shared 2226 || (h->dynindx != -1 2227 && h->plt.offset == (bfd_vma) -1 2228 && !h->def_regular 2229 && h->root.type != bfd_link_hash_undefweak))) 2230 { 2231 asection *sgot; 2232 asection *srela; 2233 Elf_Internal_Rela rela; 2234 bfd_byte *loc; 2235 bfd_byte *where; 2236 2237 /* This symbol has an entry in the global offset table. Set it up. */ 2238 2239 sgot = bfd_get_linker_section (dynobj, ".got"); 2240 srela = bfd_get_linker_section (dynobj, ".rela.got"); 2241 BFD_ASSERT (sgot != NULL && srela != NULL); 2242 2243 rela.r_offset = (sgot->output_section->vma 2244 + sgot->output_offset 2245 + (h->got.offset &~ (bfd_vma) 1)); 2246 2247 /* If this is a static link, or it is a -Bsymbolic link and the 2248 symbol is defined locally or was forced to be local because 2249 of a version file, we just want to emit a RELATIVE reloc. 2250 The entry in the global offset table will already have been 2251 initialized in the relocate_section function. */ 2252 where = sgot->contents + (h->got.offset &~ (bfd_vma) 1); 2253 if (! elf_hash_table (info)->dynamic_sections_created 2254 || (info->shared 2255 && (info->symbolic || h->dynindx == -1) 2256 && h->def_regular)) 2257 { 2258 rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE); 2259 rela.r_addend = bfd_get_signed_32 (output_bfd, where); 2260 } 2261 else 2262 { 2263 bfd_put_32 (output_bfd, (bfd_vma) 0, where); 2264 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_GLOB_DAT); 2265 rela.r_addend = 0; 2266 } 2267 2268 loc = srela->contents; 2269 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela); 2270 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2271 } 2272 2273 if (h->needs_copy) 2274 { 2275 asection *s; 2276 Elf_Internal_Rela rela; 2277 bfd_byte *loc; 2278 2279 /* This symbol needs a copy reloc. Set it up. */ 2280 2281 BFD_ASSERT (h->dynindx != -1 2282 && (h->root.type == bfd_link_hash_defined 2283 || h->root.type == bfd_link_hash_defweak)); 2284 2285 s = bfd_get_linker_section (dynobj, ".rela.bss"); 2286 BFD_ASSERT (s != NULL); 2287 2288 rela.r_offset = (h->root.u.def.value 2289 + h->root.u.def.section->output_section->vma 2290 + h->root.u.def.section->output_offset); 2291 rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_COPY); 2292 rela.r_addend = 0; 2293 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 2294 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2295 } 2296 2297 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 2298 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2299 || h == elf_hash_table (info)->hgot) 2300 sym->st_shndx = SHN_ABS; 2301 2302 return TRUE; 2303 } 2304 2305 /* Finish up the dynamic sections. Do *not* emit relocs here, as their 2307 offsets were changed, as part of -z combreloc handling, from those we 2308 computed. */ 2309 2310 static bfd_boolean 2311 elf_cris_finish_dynamic_sections (bfd *output_bfd, 2312 struct bfd_link_info *info) 2313 { 2314 bfd *dynobj; 2315 asection *sgot; 2316 asection *sdyn; 2317 2318 dynobj = elf_hash_table (info)->dynobj; 2319 2320 sgot = bfd_get_linker_section (dynobj, ".got.plt"); 2321 BFD_ASSERT (sgot != NULL); 2322 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 2323 2324 if (elf_hash_table (info)->dynamic_sections_created) 2325 { 2326 asection *splt; 2327 Elf32_External_Dyn *dyncon, *dynconend; 2328 2329 splt = bfd_get_linker_section (dynobj, ".plt"); 2330 BFD_ASSERT (splt != NULL && sdyn != NULL); 2331 2332 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2333 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 2334 for (; dyncon < dynconend; dyncon++) 2335 { 2336 Elf_Internal_Dyn dyn; 2337 asection *s; 2338 2339 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 2340 2341 switch (dyn.d_tag) 2342 { 2343 default: 2344 break; 2345 2346 case DT_PLTGOT: 2347 s = bfd_get_section_by_name (output_bfd, ".got"); 2348 BFD_ASSERT (s != NULL); 2349 dyn.d_un.d_ptr = s->vma; 2350 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2351 break; 2352 2353 case DT_JMPREL: 2354 /* Yes, we *can* have a .plt and no .plt.rela, for instance 2355 if all symbols are found in the .got (not .got.plt). */ 2356 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 2357 dyn.d_un.d_ptr = s != NULL ? s->vma : 0; 2358 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2359 break; 2360 2361 case DT_PLTRELSZ: 2362 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 2363 if (s == NULL) 2364 dyn.d_un.d_val = 0; 2365 else 2366 dyn.d_un.d_val = s->size; 2367 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2368 break; 2369 2370 case DT_RELASZ: 2371 /* The procedure linkage table relocs (DT_JMPREL) should 2372 not be included in the overall relocs (DT_RELA). 2373 Therefore, we override the DT_RELASZ entry here to 2374 make it not include the JMPREL relocs. Since the 2375 linker script arranges for .rela.plt to follow all 2376 other relocation sections, we don't have to worry 2377 about changing the DT_RELA entry. */ 2378 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 2379 if (s != NULL) 2380 dyn.d_un.d_val -= s->size; 2381 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2382 break; 2383 } 2384 } 2385 2386 /* Fill in the first entry in the procedure linkage table. */ 2387 if (splt->size > 0) 2388 { 2389 if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32) 2390 { 2391 if (info->shared) 2392 memcpy (splt->contents, elf_cris_pic_plt0_entry_v32, 2393 PLT_ENTRY_SIZE_V32); 2394 else 2395 { 2396 memcpy (splt->contents, elf_cris_plt0_entry_v32, 2397 PLT_ENTRY_SIZE_V32); 2398 bfd_put_32 (output_bfd, 2399 sgot->output_section->vma 2400 + sgot->output_offset + 4, 2401 splt->contents + 4); 2402 2403 elf_section_data (splt->output_section)->this_hdr.sh_entsize 2404 = PLT_ENTRY_SIZE_V32; 2405 } 2406 } 2407 else 2408 { 2409 if (info->shared) 2410 memcpy (splt->contents, elf_cris_pic_plt0_entry, 2411 PLT_ENTRY_SIZE); 2412 else 2413 { 2414 memcpy (splt->contents, elf_cris_plt0_entry, 2415 PLT_ENTRY_SIZE); 2416 bfd_put_32 (output_bfd, 2417 sgot->output_section->vma 2418 + sgot->output_offset + 4, 2419 splt->contents + 6); 2420 bfd_put_32 (output_bfd, 2421 sgot->output_section->vma 2422 + sgot->output_offset + 8, 2423 splt->contents + 14); 2424 2425 elf_section_data (splt->output_section)->this_hdr.sh_entsize 2426 = PLT_ENTRY_SIZE; 2427 } 2428 } 2429 } 2430 } 2431 2432 /* Fill in the first three entries in the global offset table. */ 2433 if (sgot->size > 0) 2434 { 2435 if (sdyn == NULL) 2436 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 2437 else 2438 bfd_put_32 (output_bfd, 2439 sdyn->output_section->vma + sdyn->output_offset, 2440 sgot->contents); 2441 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 2442 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 2443 } 2444 2445 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 2446 2447 return TRUE; 2448 } 2449 2450 /* Return the section that should be marked against GC for a given 2452 relocation. */ 2453 2454 static asection * 2455 cris_elf_gc_mark_hook (asection *sec, 2456 struct bfd_link_info *info, 2457 Elf_Internal_Rela *rel, 2458 struct elf_link_hash_entry *h, 2459 Elf_Internal_Sym *sym) 2460 { 2461 enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rel->r_info); 2462 if (h != NULL) 2463 switch (r_type) 2464 { 2465 case R_CRIS_GNU_VTINHERIT: 2466 case R_CRIS_GNU_VTENTRY: 2467 return NULL; 2468 2469 default: 2470 break; 2471 } 2472 2473 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 2474 } 2475 2476 /* Update the got entry reference counts for the section being removed. */ 2477 2478 static bfd_boolean 2479 cris_elf_gc_sweep_hook (bfd *abfd, 2480 struct bfd_link_info *info, 2481 asection *sec, 2482 const Elf_Internal_Rela *relocs) 2483 { 2484 struct elf_cris_link_hash_table * htab; 2485 Elf_Internal_Shdr *symtab_hdr; 2486 struct elf_link_hash_entry **sym_hashes; 2487 bfd_signed_vma *local_got_refcounts; 2488 const Elf_Internal_Rela *rel, *relend; 2489 bfd *dynobj; 2490 asection *sgot; 2491 asection *srelgot; 2492 2493 if (info->relocatable) 2494 return TRUE; 2495 2496 dynobj = elf_hash_table (info)->dynobj; 2497 if (dynobj == NULL) 2498 return TRUE; 2499 2500 htab = elf_cris_hash_table (info); 2501 if (htab == NULL) 2502 return FALSE; 2503 2504 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2505 sym_hashes = elf_sym_hashes (abfd); 2506 local_got_refcounts = elf_local_got_refcounts (abfd); 2507 2508 sgot = bfd_get_linker_section (dynobj, ".got"); 2509 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 2510 2511 relend = relocs + sec->reloc_count; 2512 for (rel = relocs; rel < relend; rel++) 2513 { 2514 unsigned long r_symndx; 2515 struct elf_link_hash_entry *h = NULL; 2516 bfd_signed_vma got_element_size = 4; 2517 bfd_signed_vma *specific_refcount = NULL; 2518 enum elf_cris_reloc_type r_type; 2519 2520 r_symndx = ELF32_R_SYM (rel->r_info); 2521 if (r_symndx >= symtab_hdr->sh_info) 2522 { 2523 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2524 while (h->root.type == bfd_link_hash_indirect 2525 || h->root.type == bfd_link_hash_warning) 2526 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2527 } 2528 2529 r_type = ELF32_R_TYPE (rel->r_info); 2530 switch (r_type) 2531 { 2532 case R_CRIS_32_GOT: 2533 case R_CRIS_16_GOT: 2534 case R_CRIS_16_GOTPLT: 2535 case R_CRIS_32_GOTPLT: 2536 specific_refcount = h != NULL 2537 ? &((struct elf_cris_link_hash_entry *) h)->reg_got_refcount 2538 : &local_got_refcounts[LGOT_REG_NDX (r_symndx)]; 2539 break; 2540 2541 case R_CRIS_32_GD: 2542 case R_CRIS_32_GOT_GD: 2543 case R_CRIS_16_GOT_GD: 2544 got_element_size = 8; 2545 specific_refcount = h != NULL 2546 ? &((struct elf_cris_link_hash_entry *) h)->dtp_refcount 2547 : &local_got_refcounts[LGOT_DTP_NDX (r_symndx)]; 2548 break; 2549 2550 case R_CRIS_32_IE: 2551 case R_CRIS_16_GOT_TPREL: 2552 case R_CRIS_32_GOT_TPREL: 2553 specific_refcount = h != NULL 2554 ? &((struct elf_cris_link_hash_entry *) h)->tprel_refcount 2555 : &local_got_refcounts[LGOT_TPREL_NDX (r_symndx)]; 2556 break; 2557 2558 default: 2559 break; 2560 } 2561 2562 switch (r_type) 2563 { 2564 case R_CRIS_32_IE: 2565 case R_CRIS_32_GD: 2566 case R_CRIS_16_GOT_TPREL: 2567 case R_CRIS_32_GOT_TPREL: 2568 case R_CRIS_32_GOT_GD: 2569 case R_CRIS_16_GOT_GD: 2570 case R_CRIS_16_GOT: 2571 case R_CRIS_32_GOT: 2572 if (h != NULL) 2573 { 2574 /* If the counters are 0 when we got here, we've 2575 miscounted somehow somewhere, an internal error. */ 2576 BFD_ASSERT (h->got.refcount > 0); 2577 --h->got.refcount; 2578 2579 BFD_ASSERT (*specific_refcount > 0); 2580 --*specific_refcount; 2581 if (*specific_refcount == 0) 2582 { 2583 /* We don't need the .got entry any more. */ 2584 sgot->size -= got_element_size; 2585 srelgot->size -= sizeof (Elf32_External_Rela); 2586 } 2587 break; 2588 } 2589 2590 local_got_reloc: 2591 if (local_got_refcounts != NULL) 2592 { 2593 /* If the counters are 0 when we got here, we've 2594 miscounted somehow somewhere, an internal error. */ 2595 BFD_ASSERT (local_got_refcounts[r_symndx] > 0); 2596 --local_got_refcounts[r_symndx]; 2597 2598 BFD_ASSERT (*specific_refcount > 0); 2599 --*specific_refcount; 2600 if (*specific_refcount == 0) 2601 { 2602 /* We don't need the .got entry any more. */ 2603 sgot->size -= got_element_size; 2604 if (info->shared) 2605 srelgot->size -= sizeof (Elf32_External_Rela); 2606 } 2607 } 2608 break; 2609 2610 case R_CRIS_16_GOTPLT: 2611 case R_CRIS_32_GOTPLT: 2612 /* For local symbols, treat these like GOT relocs. */ 2613 if (h == NULL) 2614 goto local_got_reloc; 2615 else 2616 /* For global symbols, adjust the reloc-specific refcount. */ 2617 elf_cris_hash_entry (h)->gotplt_refcount--; 2618 /* Fall through. */ 2619 2620 case R_CRIS_32_PLT_GOTREL: 2621 /* FIXME: We don't garbage-collect away the .got section. */ 2622 if (local_got_refcounts != NULL) 2623 local_got_refcounts[-1]--; 2624 /* Fall through. */ 2625 2626 case R_CRIS_8: 2627 case R_CRIS_16: 2628 case R_CRIS_32: 2629 case R_CRIS_8_PCREL: 2630 case R_CRIS_16_PCREL: 2631 case R_CRIS_32_PCREL: 2632 case R_CRIS_32_PLT_PCREL: 2633 /* Negate the increment we did in cris_elf_check_relocs. */ 2634 if (h != NULL) 2635 { 2636 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2637 && h->plt.refcount > 0) 2638 --h->plt.refcount; 2639 } 2640 break; 2641 2642 case R_CRIS_32_DTPREL: 2643 /* This'd be a .dtpreld entry in e.g. debug info. */ 2644 if ((sec->flags & SEC_ALLOC) == 0) 2645 break; 2646 /* Fall through. */ 2647 case R_CRIS_16_DTPREL: 2648 htab->dtpmod_refcount--; 2649 if (htab->dtpmod_refcount == 0) 2650 htab->next_gotplt_entry -= 8; 2651 BFD_ASSERT (local_got_refcounts != NULL); 2652 local_got_refcounts[-1]--; 2653 break; 2654 2655 default: 2656 break; 2657 } 2658 } 2659 2660 return TRUE; 2661 } 2662 2663 /* The elf_backend_plt_sym_val hook function. */ 2664 2665 static bfd_vma 2666 cris_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED, const asection *plt, 2667 const arelent *rel) 2668 { 2669 bfd_size_type plt_entry_size; 2670 bfd_size_type pltoffs; 2671 bfd *abfd = plt->owner; 2672 2673 /* Same for CRIS and CRIS v32; see elf_cris_(|pic_)plt_entry(|_v32)[]. */ 2674 bfd_size_type plt_entry_got_offset = 2; 2675 bfd_size_type plt_sec_size; 2676 bfd_size_type got_vma_for_dyn; 2677 asection *got; 2678 2679 /* FIXME: the .got section should be readily available also when 2680 we're not linking. */ 2681 if ((got = bfd_get_section_by_name (abfd, ".got")) == NULL) 2682 return (bfd_vma) -1; 2683 2684 plt_sec_size = bfd_section_size (plt->owner, plt); 2685 plt_entry_size 2686 = (bfd_get_mach (abfd) == bfd_mach_cris_v32 2687 ? PLT_ENTRY_SIZE_V32 : PLT_ENTRY_SIZE); 2688 2689 /* Data in PLT is GOT-relative for DYN, but absolute for EXE. */ 2690 got_vma_for_dyn = (abfd->flags & EXEC_P) ? 0 : got->vma; 2691 2692 /* Because we can have merged GOT entries; a single .got entry for 2693 both GOT and the PLT part of the GOT (.got.plt), the index of the 2694 reloc in .rela.plt is not the same as the index in the PLT. 2695 Instead, we have to hunt down the GOT offset in the PLT that 2696 corresponds to that of this reloc. Unfortunately, we will only 2697 be called for the .rela.plt relocs, so we'll miss synthetic 2698 symbols for .plt entries with merged GOT entries. (FIXME: 2699 fixable by providing our own bfd_elf32_get_synthetic_symtab. 2700 Doesn't seem worthwile at time of this writing.) FIXME: we've 2701 gone from O(1) to O(N) (N number of PLT entries) for finding each 2702 PLT address. Shouldn't matter in practice though. */ 2703 2704 for (pltoffs = plt_entry_size; 2705 pltoffs < plt_sec_size; 2706 pltoffs += plt_entry_size) 2707 { 2708 bfd_size_type got_offset; 2709 bfd_byte gotoffs_raw[4]; 2710 2711 if (!bfd_get_section_contents (abfd, (asection *) plt, gotoffs_raw, 2712 pltoffs + plt_entry_got_offset, 2713 sizeof (gotoffs_raw))) 2714 return (bfd_vma) -1; 2715 2716 got_offset = bfd_get_32 (abfd, gotoffs_raw); 2717 if (got_offset + got_vma_for_dyn == rel->address) 2718 return plt->vma + pltoffs; 2719 } 2720 2721 /* While it's tempting to BFD_ASSERT that we shouldn't get here, 2722 that'd not be graceful behavior for invalid input. */ 2723 return (bfd_vma) -1; 2724 } 2725 2726 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT 2727 entry but we found we will not create any. Called when we find we will 2728 not have any PLT for this symbol, by for example 2729 elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link, 2730 or elf_cris_size_dynamic_sections if no dynamic sections will be 2731 created (we're only linking static objects). */ 2732 2733 static bfd_boolean 2734 elf_cris_adjust_gotplt_to_got (struct elf_cris_link_hash_entry *h, void * p) 2735 { 2736 struct bfd_link_info *info = (struct bfd_link_info *) p; 2737 2738 /* A GOTPLT reloc, when activated, is supposed to be included into 2739 the PLT refcount. */ 2740 BFD_ASSERT (h->gotplt_refcount == 0 2741 || h->gotplt_refcount <= h->root.plt.refcount); 2742 2743 /* If nobody wanted a GOTPLT with this symbol, we're done. */ 2744 if (h->gotplt_refcount <= 0) 2745 return TRUE; 2746 2747 if (h->reg_got_refcount > 0) 2748 { 2749 /* There's a GOT entry for this symbol. Just adjust the refcounts. 2750 Probably not necessary at this stage, but keeping them accurate 2751 helps avoiding surprises later. */ 2752 h->root.got.refcount += h->gotplt_refcount; 2753 h->reg_got_refcount += h->gotplt_refcount; 2754 h->gotplt_refcount = 0; 2755 } 2756 else 2757 { 2758 /* No GOT entry for this symbol. We need to create one. */ 2759 bfd *dynobj = elf_hash_table (info)->dynobj; 2760 asection *sgot; 2761 asection *srelgot; 2762 2763 BFD_ASSERT (dynobj != NULL); 2764 sgot = bfd_get_linker_section (dynobj, ".got"); 2765 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 2766 2767 /* Put accurate refcounts there. */ 2768 h->root.got.refcount += h->gotplt_refcount; 2769 h->reg_got_refcount = h->gotplt_refcount; 2770 2771 h->gotplt_refcount = 0; 2772 2773 /* We always have a .got and a .rela.got section if there were 2774 GOTPLT relocs in input. */ 2775 BFD_ASSERT (sgot != NULL && srelgot != NULL); 2776 2777 /* Allocate space in the .got section. */ 2778 sgot->size += 4; 2779 2780 /* Allocate relocation space. */ 2781 srelgot->size += sizeof (Elf32_External_Rela); 2782 } 2783 2784 return TRUE; 2785 } 2786 2787 /* Try to fold PLT entries with GOT entries. There are two cases when we 2788 want to do this: 2789 2790 - When all PLT references are GOTPLT references, and there are GOT 2791 references, and this is not the executable. We don't have to 2792 generate a PLT at all. 2793 2794 - When there are both (ordinary) PLT references and GOT references, 2795 and this isn't the executable. 2796 We want to make the PLT reference use the ordinary GOT entry rather 2797 than R_CRIS_JUMP_SLOT, a run-time dynamically resolved GOTPLT entry, 2798 since the GOT entry will have to be resolved at startup anyway. 2799 2800 Though the latter case is handled when room for the PLT is allocated, 2801 not here. 2802 2803 By folding into the GOT, we may need a round-trip to a PLT in the 2804 executable for calls, a loss in performance. Still, losing a 2805 reloc is a win in size and at least in start-up time. 2806 2807 Note that this function is called before symbols are forced local by 2808 version scripts. The differing cases are handled by 2809 elf_cris_hide_symbol. */ 2810 2811 static bfd_boolean 2812 elf_cris_try_fold_plt_to_got (struct elf_cris_link_hash_entry *h, void * p) 2813 { 2814 struct bfd_link_info *info = (struct bfd_link_info *) p; 2815 2816 /* If there are no GOT references for this symbol, we can't fold any 2817 other reference so there's nothing to do. Likewise if there are no 2818 PLT references; GOTPLT references included. */ 2819 if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0) 2820 return TRUE; 2821 2822 /* GOTPLT relocs are supposed to be included into the PLT refcount. */ 2823 BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount); 2824 2825 if (h->gotplt_refcount == h->root.plt.refcount) 2826 { 2827 /* The only PLT references are GOTPLT references, and there are GOT 2828 references. Convert PLT to GOT references. */ 2829 if (! elf_cris_adjust_gotplt_to_got (h, info)) 2830 return FALSE; 2831 2832 /* Clear the PLT references, so no PLT will be created. */ 2833 h->root.plt.offset = (bfd_vma) -1; 2834 } 2835 2836 return TRUE; 2837 } 2838 2839 /* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc 2840 to use a GOT entry (and create one) rather than requiring a GOTPLT 2841 entry. */ 2842 2843 static void 2844 elf_cris_hide_symbol (struct bfd_link_info *info, 2845 struct elf_link_hash_entry *h, 2846 bfd_boolean force_local) 2847 { 2848 elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info); 2849 2850 _bfd_elf_link_hash_hide_symbol (info, h, force_local); 2851 } 2852 2853 /* Adjust a symbol defined by a dynamic object and referenced by a 2854 regular object. The current definition is in some section of the 2855 dynamic object, but we're not including those sections. We have to 2856 change the definition to something the rest of the link can 2857 understand. */ 2858 2859 static bfd_boolean 2860 elf_cris_adjust_dynamic_symbol (struct bfd_link_info *info, 2861 struct elf_link_hash_entry *h) 2862 { 2863 struct elf_cris_link_hash_table * htab; 2864 bfd *dynobj; 2865 asection *s; 2866 bfd_size_type plt_entry_size; 2867 2868 htab = elf_cris_hash_table (info); 2869 if (htab == NULL) 2870 return FALSE; 2871 2872 dynobj = elf_hash_table (info)->dynobj; 2873 2874 /* Make sure we know what is going on here. */ 2875 BFD_ASSERT (dynobj != NULL 2876 && (h->needs_plt 2877 || h->u.weakdef != NULL 2878 || (h->def_dynamic 2879 && h->ref_regular 2880 && !h->def_regular))); 2881 2882 plt_entry_size 2883 = (bfd_get_mach (dynobj) == bfd_mach_cris_v32 2884 ? PLT_ENTRY_SIZE_V32 : PLT_ENTRY_SIZE); 2885 2886 /* If this is a function, put it in the procedure linkage table. We 2887 will fill in the contents of the procedure linkage table later, 2888 when we know the address of the .got section. */ 2889 if (h->type == STT_FUNC 2890 || h->needs_plt) 2891 { 2892 /* If we link a program (not a DSO), we'll get rid of unnecessary 2893 PLT entries; we point to the actual symbols -- even for pic 2894 relocs, because a program built with -fpic should have the same 2895 result as one built without -fpic, specifically considering weak 2896 symbols. 2897 FIXME: m68k and i386 differ here, for unclear reasons. */ 2898 if (! info->shared 2899 && !h->def_dynamic) 2900 { 2901 /* This case can occur if we saw a PLT reloc in an input file, 2902 but the symbol was not defined by a dynamic object. In such 2903 a case, we don't actually need to build a procedure linkage 2904 table, and we can just do an absolute or PC reloc instead, or 2905 change a .got.plt index to a .got index for GOTPLT relocs. */ 2906 BFD_ASSERT (h->needs_plt); 2907 h->needs_plt = 0; 2908 h->plt.offset = (bfd_vma) -1; 2909 return 2910 elf_cris_adjust_gotplt_to_got ((struct 2911 elf_cris_link_hash_entry *) h, 2912 info); 2913 } 2914 2915 /* If we had a R_CRIS_GLOB_DAT that didn't have to point to a PLT; 2916 where a pointer-equivalent symbol was unimportant (i.e. more 2917 like R_CRIS_JUMP_SLOT after symbol evaluation) we could get rid 2918 of the PLT. We can't for the executable, because the GOT 2919 entries will point to the PLT there (and be constant). */ 2920 if (info->shared 2921 && !elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry*) 2922 h, info)) 2923 return FALSE; 2924 2925 /* GC or folding may have rendered this entry unused. */ 2926 if (h->plt.refcount <= 0) 2927 { 2928 h->needs_plt = 0; 2929 h->plt.offset = (bfd_vma) -1; 2930 return TRUE; 2931 } 2932 2933 /* Make sure this symbol is output as a dynamic symbol. */ 2934 if (h->dynindx == -1) 2935 { 2936 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2937 return FALSE; 2938 } 2939 2940 s = bfd_get_linker_section (dynobj, ".plt"); 2941 BFD_ASSERT (s != NULL); 2942 2943 /* If this is the first .plt entry, make room for the special 2944 first entry. */ 2945 if (s->size == 0) 2946 s->size += plt_entry_size; 2947 2948 /* If this symbol is not defined in a regular file, and we are 2949 not generating a shared library, then set the symbol to this 2950 location in the .plt. */ 2951 if (!info->shared 2952 && !h->def_regular) 2953 { 2954 h->root.u.def.section = s; 2955 h->root.u.def.value = s->size; 2956 } 2957 2958 /* If there's already a GOT entry, use that, not a .got.plt. A 2959 GOT field still has a reference count when we get here; it's 2960 not yet changed to an offset. We can't do this for an 2961 executable, because then the reloc associated with the PLT 2962 would get a non-PLT reloc pointing to the PLT. FIXME: Move 2963 this to elf_cris_try_fold_plt_to_got. */ 2964 if (info->shared && h->got.refcount > 0) 2965 { 2966 h->got.refcount += h->plt.refcount; 2967 2968 /* Mark the PLT offset to use the GOT entry by setting the low 2969 bit in the plt offset; it is always a multiple of 2970 plt_entry_size (which is at least a multiple of 2). */ 2971 BFD_ASSERT ((s->size % plt_entry_size) == 0); 2972 2973 /* Change the PLT refcount to an offset. */ 2974 h->plt.offset = s->size; 2975 2976 /* By not setting gotplt_offset (i.e. it remains at 0), we signal 2977 that the got entry should be used instead. */ 2978 BFD_ASSERT (((struct elf_cris_link_hash_entry *) 2979 h)->gotplt_offset == 0); 2980 2981 /* Make room for this entry. */ 2982 s->size += plt_entry_size; 2983 2984 return TRUE; 2985 } 2986 2987 /* No GOT reference for this symbol; prepare for an ordinary PLT. */ 2988 h->plt.offset = s->size; 2989 2990 /* Make room for this entry. */ 2991 s->size += plt_entry_size; 2992 2993 /* We also need to make an entry in the .got.plt section, which 2994 will be placed in the .got section by the linker script. */ 2995 ((struct elf_cris_link_hash_entry *) h)->gotplt_offset 2996 = htab->next_gotplt_entry; 2997 htab->next_gotplt_entry += 4; 2998 2999 s = bfd_get_linker_section (dynobj, ".got.plt"); 3000 BFD_ASSERT (s != NULL); 3001 s->size += 4; 3002 3003 /* We also need to make an entry in the .rela.plt section. */ 3004 3005 s = bfd_get_linker_section (dynobj, ".rela.plt"); 3006 BFD_ASSERT (s != NULL); 3007 s->size += sizeof (Elf32_External_Rela); 3008 3009 return TRUE; 3010 } 3011 3012 /* Reinitialize the plt offset now that it is not used as a reference 3013 count any more. */ 3014 h->plt.offset = (bfd_vma) -1; 3015 3016 /* If this is a weak symbol, and there is a real definition, the 3017 processor independent code will have arranged for us to see the 3018 real definition first, and we can just use the same value. */ 3019 if (h->u.weakdef != NULL) 3020 { 3021 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 3022 || h->u.weakdef->root.type == bfd_link_hash_defweak); 3023 h->root.u.def.section = h->u.weakdef->root.u.def.section; 3024 h->root.u.def.value = h->u.weakdef->root.u.def.value; 3025 return TRUE; 3026 } 3027 3028 /* This is a reference to a symbol defined by a dynamic object which 3029 is not a function. */ 3030 3031 /* If we are creating a shared library, we must presume that the 3032 only references to the symbol are via the global offset table. 3033 For such cases we need not do anything here; the relocations will 3034 be handled correctly by relocate_section. */ 3035 if (info->shared) 3036 return TRUE; 3037 3038 /* If there are no references to this symbol that do not use the 3039 GOT, we don't need to generate a copy reloc. */ 3040 if (!h->non_got_ref) 3041 return TRUE; 3042 3043 /* We must allocate the symbol in our .dynbss section, which will 3044 become part of the .bss section of the executable. There will be 3045 an entry for this symbol in the .dynsym section. The dynamic 3046 object will contain position independent code, so all references 3047 from the dynamic object to this symbol will go through the global 3048 offset table. The dynamic linker will use the .dynsym entry to 3049 determine the address it must put in the global offset table, so 3050 both the dynamic object and the regular object will refer to the 3051 same memory location for the variable. */ 3052 3053 s = bfd_get_linker_section (dynobj, ".dynbss"); 3054 BFD_ASSERT (s != NULL); 3055 3056 /* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to 3057 copy the initial value out of the dynamic object and into the 3058 runtime process image. We need to remember the offset into the 3059 .rela.bss section we are going to use. */ 3060 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 3061 { 3062 asection *srel; 3063 3064 srel = bfd_get_linker_section (dynobj, ".rela.bss"); 3065 BFD_ASSERT (srel != NULL); 3066 srel->size += sizeof (Elf32_External_Rela); 3067 h->needs_copy = 1; 3068 } 3069 3070 return _bfd_elf_adjust_dynamic_copy (h, s); 3071 } 3072 3073 /* Adjust our "subclass" elements for an indirect symbol. */ 3074 3075 static void 3076 elf_cris_copy_indirect_symbol (struct bfd_link_info *info, 3077 struct elf_link_hash_entry *dir, 3078 struct elf_link_hash_entry *ind) 3079 { 3080 struct elf_cris_link_hash_entry *edir, *eind; 3081 3082 edir = (struct elf_cris_link_hash_entry *) dir; 3083 eind = (struct elf_cris_link_hash_entry *) ind; 3084 3085 /* Only indirect symbols are replaced; we're not interested in 3086 updating any of EIND's fields for other symbols. */ 3087 if (eind->root.root.type != bfd_link_hash_indirect) 3088 { 3089 /* Still, we need to copy flags for e.g. weak definitions. */ 3090 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 3091 return; 3092 } 3093 3094 BFD_ASSERT (edir->gotplt_offset == 0 || eind->gotplt_offset == 0); 3095 3096 #define XMOVOPZ(F, OP, Z) edir->F OP eind->F; eind->F = Z 3097 #define XMOVE(F) XMOVOPZ (F, +=, 0) 3098 if (eind->pcrel_relocs_copied != NULL) 3099 { 3100 if (edir->pcrel_relocs_copied != NULL) 3101 { 3102 struct elf_cris_pcrel_relocs_copied **pp; 3103 struct elf_cris_pcrel_relocs_copied *p; 3104 3105 /* Add reloc counts against the indirect sym to the direct sym 3106 list. Merge any entries against the same section. */ 3107 for (pp = &eind->pcrel_relocs_copied; *pp != NULL;) 3108 { 3109 struct elf_cris_pcrel_relocs_copied *q; 3110 p = *pp; 3111 for (q = edir->pcrel_relocs_copied; q != NULL; q = q->next) 3112 if (q->section == p->section) 3113 { 3114 q->count += p->count; 3115 *pp = p->next; 3116 break; 3117 } 3118 if (q == NULL) 3119 pp = &p->next; 3120 } 3121 *pp = edir->pcrel_relocs_copied; 3122 } 3123 XMOVOPZ (pcrel_relocs_copied, =, NULL); 3124 } 3125 XMOVE (gotplt_refcount); 3126 XMOVE (gotplt_offset); 3127 XMOVE (reg_got_refcount); 3128 XMOVE (tprel_refcount); 3129 XMOVE (dtp_refcount); 3130 #undef XMOVE 3131 #undef XMOVOPZ 3132 3133 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 3134 } 3135 3136 /* Look through the relocs for a section during the first phase. */ 3137 3138 static bfd_boolean 3139 cris_elf_check_relocs (bfd *abfd, 3140 struct bfd_link_info *info, 3141 asection *sec, 3142 const Elf_Internal_Rela *relocs) 3143 { 3144 struct elf_cris_link_hash_table * htab; 3145 bfd *dynobj; 3146 Elf_Internal_Shdr *symtab_hdr; 3147 struct elf_link_hash_entry **sym_hashes; 3148 bfd_signed_vma *local_got_refcounts; 3149 const Elf_Internal_Rela *rel; 3150 const Elf_Internal_Rela *rel_end; 3151 asection *sgot; 3152 asection *srelgot; 3153 asection *sreloc; 3154 3155 if (info->relocatable) 3156 return TRUE; 3157 3158 htab = elf_cris_hash_table (info); 3159 if (htab == NULL) 3160 return FALSE; 3161 3162 dynobj = elf_hash_table (info)->dynobj; 3163 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3164 sym_hashes = elf_sym_hashes (abfd); 3165 local_got_refcounts = elf_local_got_refcounts (abfd); 3166 3167 sgot = NULL; 3168 srelgot = NULL; 3169 sreloc = NULL; 3170 3171 rel_end = relocs + sec->reloc_count; 3172 for (rel = relocs; rel < rel_end; rel++) 3173 { 3174 struct elf_link_hash_entry *h; 3175 unsigned long r_symndx; 3176 enum elf_cris_reloc_type r_type; 3177 bfd_signed_vma got_element_size = 4; 3178 unsigned long r_symndx_lgot = INT_MAX; 3179 3180 r_symndx = ELF32_R_SYM (rel->r_info); 3181 if (r_symndx < symtab_hdr->sh_info) 3182 { 3183 h = NULL; 3184 r_symndx_lgot = LGOT_REG_NDX (r_symndx); 3185 } 3186 else 3187 { 3188 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 3189 while (h->root.type == bfd_link_hash_indirect 3190 || h->root.type == bfd_link_hash_warning) 3191 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3192 } 3193 3194 r_type = ELF32_R_TYPE (rel->r_info); 3195 3196 /* Some relocs require linker-created sections; we need to hang them 3197 on the first input bfd we found that contained dynamic relocs. */ 3198 switch (r_type) 3199 { 3200 case R_CRIS_32_DTPREL: 3201 if ((sec->flags & SEC_ALLOC) == 0) 3202 /* This'd be a .dtpreld entry in e.g. debug info. We have 3203 several different switch statements below, but none of 3204 that is needed; we need no preparations for resolving 3205 R_CRIS_32_DTPREL into a non-allocated section (debug 3206 info), so let's just move on to the next 3207 relocation. */ 3208 continue; 3209 /* Fall through. */ 3210 case R_CRIS_16_DTPREL: 3211 /* The first .got.plt entry is right after the R_CRIS_DTPMOD 3212 entry at index 3. */ 3213 if (htab->dtpmod_refcount == 0) 3214 htab->next_gotplt_entry += 8; 3215 3216 htab->dtpmod_refcount++; 3217 /* Fall through. */ 3218 3219 case R_CRIS_32_IE: 3220 case R_CRIS_32_GD: 3221 case R_CRIS_16_GOT_GD: 3222 case R_CRIS_32_GOT_GD: 3223 case R_CRIS_32_GOT_TPREL: 3224 case R_CRIS_16_GOT_TPREL: 3225 case R_CRIS_16_GOT: 3226 case R_CRIS_32_GOT: 3227 case R_CRIS_32_GOTREL: 3228 case R_CRIS_32_PLT_GOTREL: 3229 case R_CRIS_32_PLT_PCREL: 3230 case R_CRIS_16_GOTPLT: 3231 case R_CRIS_32_GOTPLT: 3232 if (dynobj == NULL) 3233 { 3234 elf_hash_table (info)->dynobj = dynobj = abfd; 3235 3236 /* We could handle this if we can get a handle on the 3237 output bfd in elf_cris_adjust_dynamic_symbol. Failing 3238 that, we must insist on dynobj being a specific mach. */ 3239 if (bfd_get_mach (dynobj) == bfd_mach_cris_v10_v32) 3240 { 3241 (*_bfd_error_handler) 3242 (_("%B, section %A:\n v10/v32 compatible object %s" 3243 " must not contain a PIC relocation"), 3244 abfd, sec); 3245 return FALSE; 3246 } 3247 3248 /* Create the .got section, so we can assume it's always 3249 present whenever there's a dynobj. */ 3250 if (!_bfd_elf_create_got_section (dynobj, info)) 3251 return FALSE; 3252 } 3253 3254 if (sgot == NULL) 3255 sgot = bfd_get_linker_section (dynobj, ".got"); 3256 3257 if (local_got_refcounts == NULL) 3258 { 3259 bfd_size_type amt; 3260 3261 /* We use index local_got_refcounts[-1] to count all 3262 GOT-relative relocations that do not have explicit 3263 GOT entries. */ 3264 amt = LGOT_ALLOC_NELTS_FOR (symtab_hdr->sh_info) + 1; 3265 amt *= sizeof (bfd_signed_vma); 3266 local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt)); 3267 if (local_got_refcounts == NULL) 3268 return FALSE; 3269 3270 local_got_refcounts++; 3271 elf_local_got_refcounts (abfd) = local_got_refcounts; 3272 } 3273 break; 3274 3275 default: 3276 break; 3277 } 3278 3279 /* Some relocs require a global offset table (but perhaps not a 3280 specific GOT entry). */ 3281 switch (r_type) 3282 { 3283 case R_CRIS_16_DTPREL: 3284 case R_CRIS_32_DTPREL: 3285 /* Not requesting .got.rela for an executable: the contents 3286 of the first entry is constant there. For a shared 3287 library, we need .got.rela for the R_CRIS_DTPMOD 3288 relocation at index 3. */ 3289 if (!info->shared) 3290 break; 3291 /* Fall through. */ 3292 3293 case R_CRIS_32_IE: 3294 case R_CRIS_32_GD: 3295 case R_CRIS_16_GOT_GD: 3296 case R_CRIS_32_GOT_GD: 3297 case R_CRIS_32_GOT_TPREL: 3298 case R_CRIS_16_GOT_TPREL: 3299 /* Fall through. */ 3300 3301 /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT 3302 entry only for local symbols. Unfortunately, we don't know 3303 until later on if there's a version script that forces the 3304 symbol local. We must have the .rela.got section in place 3305 before we know if the symbol looks global now, so we need 3306 to treat the reloc just like for R_CRIS_16_GOT and 3307 R_CRIS_32_GOT. */ 3308 case R_CRIS_16_GOTPLT: 3309 case R_CRIS_32_GOTPLT: 3310 case R_CRIS_16_GOT: 3311 case R_CRIS_32_GOT: 3312 if (srelgot == NULL 3313 && (h != NULL || info->shared)) 3314 { 3315 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 3316 if (srelgot == NULL) 3317 { 3318 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 3319 | SEC_IN_MEMORY | SEC_LINKER_CREATED 3320 | SEC_READONLY); 3321 srelgot = bfd_make_section_anyway_with_flags (dynobj, 3322 ".rela.got", 3323 flags); 3324 if (srelgot == NULL 3325 || !bfd_set_section_alignment (dynobj, srelgot, 2)) 3326 return FALSE; 3327 } 3328 } 3329 break; 3330 3331 default: 3332 break; 3333 } 3334 3335 /* Warn and error for invalid input. */ 3336 switch (r_type) 3337 { 3338 case R_CRIS_32_IE: 3339 case R_CRIS_32_TPREL: 3340 case R_CRIS_16_TPREL: 3341 case R_CRIS_32_GD: 3342 if (info->shared) 3343 { 3344 (*_bfd_error_handler) 3345 (_("%B, section %A:\n relocation %s not valid" 3346 " in a shared object;" 3347 " typically an option mixup, recompile with -fPIC"), 3348 abfd, 3349 sec, 3350 cris_elf_howto_table[r_type].name); 3351 /* Don't return FALSE here; we want messages for all of 3352 these and the error behavior is ungraceful 3353 anyway. */ 3354 } 3355 default: 3356 break; 3357 } 3358 3359 switch (r_type) 3360 { 3361 case R_CRIS_32_GD: 3362 case R_CRIS_16_GOT_GD: 3363 case R_CRIS_32_GOT_GD: 3364 /* These are requests for tls_index entries, run-time R_CRIS_DTP. */ 3365 got_element_size = 8; 3366 r_symndx_lgot = LGOT_DTP_NDX (r_symndx); 3367 break; 3368 3369 case R_CRIS_16_DTPREL: 3370 case R_CRIS_32_DTPREL: 3371 /* These two just request for the constant-index 3372 module-local tls_index-sized GOT entry, which we add 3373 elsewhere. */ 3374 break; 3375 3376 case R_CRIS_32_IE: 3377 case R_CRIS_32_GOT_TPREL: 3378 case R_CRIS_16_GOT_TPREL: 3379 r_symndx_lgot = LGOT_TPREL_NDX (r_symndx); 3380 3381 /* Those relocs also require that a DSO is of type 3382 Initial Exec. Like other targets, we don't reset this 3383 flag even if the relocs are GC:ed away. */ 3384 if (info->shared) 3385 info->flags |= DF_STATIC_TLS; 3386 break; 3387 3388 /* Let's list the other assembler-generated TLS-relocs too, 3389 just to show that they're not forgotten. */ 3390 case R_CRIS_16_TPREL: 3391 case R_CRIS_32_TPREL: 3392 default: 3393 break; 3394 } 3395 3396 switch (r_type) 3397 { 3398 case R_CRIS_16_GOTPLT: 3399 case R_CRIS_32_GOTPLT: 3400 /* Mark that we need a GOT entry if the PLT entry (and its GOT 3401 entry) is eliminated. We can only do this for a non-local 3402 symbol. */ 3403 if (h != NULL) 3404 { 3405 elf_cris_hash_entry (h)->gotplt_refcount++; 3406 goto handle_gotplt_reloc; 3407 } 3408 /* If h is NULL then this is a local symbol, and we must make a 3409 GOT entry for it, so handle it like a GOT reloc. */ 3410 /* Fall through. */ 3411 3412 case R_CRIS_32_IE: 3413 case R_CRIS_32_GD: 3414 case R_CRIS_16_GOT_GD: 3415 case R_CRIS_32_GOT_GD: 3416 case R_CRIS_32_GOT_TPREL: 3417 case R_CRIS_16_GOT_TPREL: 3418 case R_CRIS_16_GOT: 3419 case R_CRIS_32_GOT: 3420 /* This symbol requires a global offset table entry. */ 3421 if (h != NULL) 3422 { 3423 if (h->got.refcount == 0) 3424 { 3425 /* Make sure this symbol is output as a dynamic symbol. */ 3426 if (h->dynindx == -1) 3427 { 3428 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 3429 return FALSE; 3430 } 3431 } 3432 3433 /* Update the sum of reloc counts for this symbol. */ 3434 h->got.refcount++; 3435 3436 switch (r_type) 3437 { 3438 case R_CRIS_16_GOT: 3439 case R_CRIS_32_GOT: 3440 if (elf_cris_hash_entry (h)->reg_got_refcount == 0) 3441 { 3442 /* Allocate space in the .got section. */ 3443 sgot->size += got_element_size; 3444 /* Allocate relocation space. */ 3445 srelgot->size += sizeof (Elf32_External_Rela); 3446 } 3447 elf_cris_hash_entry (h)->reg_got_refcount++; 3448 break; 3449 3450 case R_CRIS_32_GD: 3451 case R_CRIS_16_GOT_GD: 3452 case R_CRIS_32_GOT_GD: 3453 if (elf_cris_hash_entry (h)->dtp_refcount == 0) 3454 { 3455 /* Allocate space in the .got section. */ 3456 sgot->size += got_element_size; 3457 /* Allocate relocation space. */ 3458 srelgot->size += sizeof (Elf32_External_Rela); 3459 } 3460 elf_cris_hash_entry (h)->dtp_refcount++; 3461 break; 3462 3463 case R_CRIS_32_IE: 3464 case R_CRIS_32_GOT_TPREL: 3465 case R_CRIS_16_GOT_TPREL: 3466 if (elf_cris_hash_entry (h)->tprel_refcount == 0) 3467 { 3468 /* Allocate space in the .got section. */ 3469 sgot->size += got_element_size; 3470 /* Allocate relocation space. */ 3471 srelgot->size += sizeof (Elf32_External_Rela); 3472 } 3473 elf_cris_hash_entry (h)->tprel_refcount++; 3474 break; 3475 3476 default: 3477 BFD_FAIL (); 3478 break; 3479 } 3480 } 3481 else 3482 { 3483 /* This is a global offset table entry for a local symbol. */ 3484 if (local_got_refcounts[r_symndx_lgot] == 0) 3485 { 3486 sgot->size += got_element_size; 3487 if (info->shared) 3488 { 3489 /* If we are generating a shared object, we need 3490 to output a R_CRIS_RELATIVE reloc so that the 3491 dynamic linker can adjust this GOT entry. 3492 Similarly for non-regular got entries. */ 3493 srelgot->size += sizeof (Elf32_External_Rela); 3494 } 3495 } 3496 /* Update the reloc-specific count. */ 3497 local_got_refcounts[r_symndx_lgot]++; 3498 3499 /* This one is the sum of all the others. */ 3500 local_got_refcounts[r_symndx]++; 3501 } 3502 break; 3503 3504 case R_CRIS_16_DTPREL: 3505 case R_CRIS_32_DTPREL: 3506 case R_CRIS_32_GOTREL: 3507 /* This reference requires a global offset table. 3508 FIXME: The actual refcount isn't used currently; the .got 3509 section can't be removed if there were any references in the 3510 input. */ 3511 local_got_refcounts[-1]++; 3512 break; 3513 3514 handle_gotplt_reloc: 3515 3516 case R_CRIS_32_PLT_GOTREL: 3517 /* This reference requires a global offset table. */ 3518 local_got_refcounts[-1]++; 3519 /* Fall through. */ 3520 3521 case R_CRIS_32_PLT_PCREL: 3522 /* This symbol requires a procedure linkage table entry. We 3523 actually build the entry in adjust_dynamic_symbol, 3524 because this might be a case of linking PIC code which is 3525 never referenced by a dynamic object, in which case we 3526 don't need to generate a procedure linkage table entry 3527 after all. */ 3528 3529 /* Beware: if we'd check for visibility of the symbol here 3530 (and not marking the need for a PLT when non-visible), we'd 3531 get into trouble with keeping handling consistent with 3532 regards to relocs found before definition and GOTPLT 3533 handling. Eliminable PLT entries will be dealt with later 3534 anyway. */ 3535 if (h == NULL) 3536 continue; 3537 3538 h->needs_plt = 1; 3539 h->plt.refcount++; 3540 break; 3541 3542 case R_CRIS_8: 3543 case R_CRIS_16: 3544 case R_CRIS_32: 3545 /* Let's help debug shared library creation. Any of these 3546 relocs *can* be used in shared libs, but pages containing 3547 them cannot be shared, so they're not appropriate for 3548 common use. Don't warn for sections we don't care about, 3549 such as debug sections or non-constant sections. We 3550 can't help tables of (global) function pointers, for 3551 example, though they must be emitted in a (writable) data 3552 section to avoid having impure text sections. */ 3553 if (info->shared 3554 && (sec->flags & SEC_ALLOC) != 0 3555 && (sec->flags & SEC_READONLY) != 0) 3556 { 3557 /* FIXME: How do we make this optionally a warning only? */ 3558 (*_bfd_error_handler) 3559 (_("%B, section %A:\n relocation %s should not" 3560 " be used in a shared object; recompile with -fPIC"), 3561 abfd, 3562 sec, 3563 cris_elf_howto_table[r_type].name); 3564 } 3565 3566 /* We don't need to handle relocs into sections not going into 3567 the "real" output. */ 3568 if ((sec->flags & SEC_ALLOC) == 0) 3569 break; 3570 3571 if (h != NULL) 3572 { 3573 h->non_got_ref = 1; 3574 3575 /* Make sure a plt entry is created for this symbol if it 3576 turns out to be a function defined by a dynamic object. */ 3577 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 3578 h->plt.refcount++; 3579 } 3580 3581 /* If we are creating a shared library and this is not a local 3582 symbol, we need to copy the reloc into the shared library. 3583 However when linking with -Bsymbolic and this is a global 3584 symbol which is defined in an object we are including in the 3585 link (i.e., DEF_REGULAR is set), then we can resolve the 3586 reloc directly. At this point we have not seen all the input 3587 files, so it is possible that DEF_REGULAR is not set now but 3588 will be set later (it is never cleared). In case of a weak 3589 definition, DEF_REGULAR may be cleared later by a strong 3590 definition in a shared library. We account for that 3591 possibility below by storing information in the relocs_copied 3592 field of the hash table entry. A similar situation occurs 3593 when creating shared libraries and symbol visibility changes 3594 render the symbol local. */ 3595 3596 /* No need to do anything if we're not creating a shared object. */ 3597 if (! info->shared) 3598 break; 3599 3600 /* We may need to create a reloc section in the dynobj and made room 3601 for this reloc. */ 3602 if (sreloc == NULL) 3603 { 3604 sreloc = _bfd_elf_make_dynamic_reloc_section 3605 (sec, dynobj, 2, abfd, /*rela?*/ TRUE); 3606 3607 if (sreloc == NULL) 3608 return FALSE; 3609 } 3610 3611 if (sec->flags & SEC_READONLY) 3612 info->flags |= DF_TEXTREL; 3613 3614 sreloc->size += sizeof (Elf32_External_Rela); 3615 break; 3616 3617 case R_CRIS_8_PCREL: 3618 case R_CRIS_16_PCREL: 3619 case R_CRIS_32_PCREL: 3620 if (h != NULL) 3621 { 3622 h->non_got_ref = 1; 3623 3624 /* Make sure a plt entry is created for this symbol if it 3625 turns out to be a function defined by a dynamic object. */ 3626 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 3627 h->plt.refcount++; 3628 } 3629 3630 /* If we are creating a shared library and this is not a local 3631 symbol, we need to copy the reloc into the shared library. 3632 However when linking with -Bsymbolic and this is a global 3633 symbol which is defined in an object we are including in the 3634 link (i.e., DEF_REGULAR is set), then we can resolve the 3635 reloc directly. At this point we have not seen all the input 3636 files, so it is possible that DEF_REGULAR is not set now but 3637 will be set later (it is never cleared). In case of a weak 3638 definition, DEF_REGULAR may be cleared later by a strong 3639 definition in a shared library. We account for that 3640 possibility below by storing information in the relocs_copied 3641 field of the hash table entry. A similar situation occurs 3642 when creating shared libraries and symbol visibility changes 3643 render the symbol local. */ 3644 3645 /* No need to do anything if we're not creating a shared object. */ 3646 if (! info->shared) 3647 break; 3648 3649 /* We don't need to handle relocs into sections not going into 3650 the "real" output. */ 3651 if ((sec->flags & SEC_ALLOC) == 0) 3652 break; 3653 3654 /* If the symbol is local, then we know already we can 3655 eliminate the reloc. */ 3656 if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 3657 break; 3658 3659 /* If this is with -Bsymbolic and the symbol isn't weak, and 3660 is defined by an ordinary object (the ones we include in 3661 this shared library) then we can also eliminate the 3662 reloc. See comment above for more eliminable cases which 3663 we can't identify at this time. */ 3664 if (info->symbolic 3665 && h->root.type != bfd_link_hash_defweak 3666 && h->def_regular) 3667 break; 3668 3669 /* We may need to create a reloc section in the dynobj and made room 3670 for this reloc. */ 3671 if (sreloc == NULL) 3672 { 3673 sreloc = _bfd_elf_make_dynamic_reloc_section 3674 (sec, dynobj, 2, abfd, /*rela?*/ TRUE); 3675 3676 if (sreloc == NULL) 3677 return FALSE; 3678 } 3679 3680 sreloc->size += sizeof (Elf32_External_Rela); 3681 3682 /* We count the number of PC relative relocations we have 3683 entered for this symbol, so that we can discard them 3684 again if the symbol is later defined by a regular object. 3685 We know that h is really a pointer to an 3686 elf_cris_link_hash_entry. */ 3687 { 3688 struct elf_cris_link_hash_entry *eh; 3689 struct elf_cris_pcrel_relocs_copied *p; 3690 3691 eh = elf_cris_hash_entry (h); 3692 3693 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next) 3694 if (p->section == sec) 3695 break; 3696 3697 if (p == NULL) 3698 { 3699 p = ((struct elf_cris_pcrel_relocs_copied *) 3700 bfd_alloc (dynobj, (bfd_size_type) sizeof *p)); 3701 if (p == NULL) 3702 return FALSE; 3703 p->next = eh->pcrel_relocs_copied; 3704 eh->pcrel_relocs_copied = p; 3705 p->section = sec; 3706 p->count = 0; 3707 p->r_type = r_type; 3708 } 3709 3710 ++p->count; 3711 } 3712 break; 3713 3714 /* This relocation describes the C++ object vtable hierarchy. 3715 Reconstruct it for later use during GC. */ 3716 case R_CRIS_GNU_VTINHERIT: 3717 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 3718 return FALSE; 3719 break; 3720 3721 /* This relocation describes which C++ vtable entries are actually 3722 used. Record for later use during GC. */ 3723 case R_CRIS_GNU_VTENTRY: 3724 BFD_ASSERT (h != NULL); 3725 if (h != NULL 3726 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 3727 return FALSE; 3728 break; 3729 3730 case R_CRIS_16_TPREL: 3731 case R_CRIS_32_TPREL: 3732 /* Already warned above, when necessary. */ 3733 break; 3734 3735 default: 3736 /* Other relocs do not appear here. */ 3737 bfd_set_error (bfd_error_bad_value); 3738 return FALSE; 3739 } 3740 } 3741 3742 return TRUE; 3743 } 3744 3745 /* Set the sizes of the dynamic sections. */ 3746 3747 static bfd_boolean 3748 elf_cris_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 3749 struct bfd_link_info *info) 3750 { 3751 struct elf_cris_link_hash_table * htab; 3752 bfd *dynobj; 3753 asection *s; 3754 bfd_boolean plt; 3755 bfd_boolean relocs; 3756 3757 htab = elf_cris_hash_table (info); 3758 if (htab == NULL) 3759 return FALSE; 3760 3761 dynobj = elf_hash_table (info)->dynobj; 3762 BFD_ASSERT (dynobj != NULL); 3763 3764 if (elf_hash_table (info)->dynamic_sections_created) 3765 { 3766 /* Set the contents of the .interp section to the interpreter. */ 3767 if (info->executable) 3768 { 3769 s = bfd_get_linker_section (dynobj, ".interp"); 3770 BFD_ASSERT (s != NULL); 3771 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 3772 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 3773 } 3774 } 3775 else 3776 { 3777 /* Adjust all expected GOTPLT uses to use a GOT entry instead. */ 3778 elf_cris_link_hash_traverse (htab, elf_cris_adjust_gotplt_to_got, 3779 info); 3780 3781 /* We may have created entries in the .rela.got section. 3782 However, if we are not creating the dynamic sections, we will 3783 not actually use these entries. Reset the size of .rela.got, 3784 which will cause it to get stripped from the output file 3785 below. */ 3786 s = bfd_get_linker_section (dynobj, ".rela.got"); 3787 if (s != NULL) 3788 s->size = 0; 3789 } 3790 3791 /* If this is a -Bsymbolic shared link, then we need to discard all PC 3792 relative relocs against symbols defined in a regular object. We 3793 allocated space for them in the check_relocs routine, but we will not 3794 fill them in in the relocate_section routine. We also discard space 3795 for relocs that have become for local symbols due to symbol 3796 visibility changes. For programs, we discard space for relocs for 3797 symbols not referenced by any dynamic object. */ 3798 if (info->shared) 3799 elf_cris_link_hash_traverse (htab, 3800 elf_cris_discard_excess_dso_dynamics, 3801 info); 3802 else 3803 elf_cris_link_hash_traverse (htab, 3804 elf_cris_discard_excess_program_dynamics, 3805 info); 3806 3807 /* The check_relocs and adjust_dynamic_symbol entry points have 3808 determined the sizes of the various dynamic sections. Allocate 3809 memory for them. */ 3810 plt = FALSE; 3811 relocs = FALSE; 3812 for (s = dynobj->sections; s != NULL; s = s->next) 3813 { 3814 const char *name; 3815 3816 if ((s->flags & SEC_LINKER_CREATED) == 0) 3817 continue; 3818 3819 /* It's OK to base decisions on the section name, because none 3820 of the dynobj section names depend upon the input files. */ 3821 name = bfd_get_section_name (dynobj, s); 3822 3823 if (strcmp (name, ".plt") == 0) 3824 { 3825 /* Remember whether there is a PLT. */ 3826 plt = s->size != 0; 3827 } 3828 else if (strcmp (name, ".got.plt") == 0) 3829 { 3830 /* The .got.plt contains the .got header as well as the 3831 actual .got.plt contents. The .got header may contain a 3832 R_CRIS_DTPMOD entry at index 3. */ 3833 s->size += htab->dtpmod_refcount != 0 3834 ? 8 : 0; 3835 } 3836 else if (CONST_STRNEQ (name, ".rela")) 3837 { 3838 if (strcmp (name, ".rela.got") == 0 3839 && htab->dtpmod_refcount != 0 3840 && info->shared) 3841 s->size += sizeof (Elf32_External_Rela); 3842 3843 if (s->size != 0) 3844 { 3845 /* Remember whether there are any reloc sections other 3846 than .rela.plt. */ 3847 if (strcmp (name, ".rela.plt") != 0) 3848 relocs = TRUE; 3849 3850 /* We use the reloc_count field as a counter if we need 3851 to copy relocs into the output file. */ 3852 s->reloc_count = 0; 3853 } 3854 } 3855 else if (! CONST_STRNEQ (name, ".got") 3856 && strcmp (name, ".dynbss") != 0) 3857 { 3858 /* It's not one of our sections, so don't allocate space. */ 3859 continue; 3860 } 3861 3862 if (s->size == 0) 3863 { 3864 /* If we don't need this section, strip it from the 3865 output file. This is mostly to handle .rela.bss and 3866 .rela.plt. We must create both sections in 3867 create_dynamic_sections, because they must be created 3868 before the linker maps input sections to output 3869 sections. The linker does that before 3870 adjust_dynamic_symbol is called, and it is that 3871 function which decides whether anything needs to go 3872 into these sections. */ 3873 s->flags |= SEC_EXCLUDE; 3874 continue; 3875 } 3876 3877 if ((s->flags & SEC_HAS_CONTENTS) == 0) 3878 continue; 3879 3880 /* Allocate memory for the section contents. We use bfd_zalloc here 3881 in case unused entries are not reclaimed before the section's 3882 contents are written out. This should not happen, but this way 3883 if it does, we will not write out garbage. For reloc sections, 3884 this will make entries have the type R_CRIS_NONE. */ 3885 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 3886 if (s->contents == NULL) 3887 return FALSE; 3888 } 3889 3890 if (elf_hash_table (info)->dynamic_sections_created) 3891 { 3892 /* Add some entries to the .dynamic section. We fill in the 3893 values later, in elf_cris_finish_dynamic_sections, but we 3894 must add the entries now so that we get the correct size for 3895 the .dynamic section. The DT_DEBUG entry is filled in by the 3896 dynamic linker and used by the debugger. */ 3897 #define add_dynamic_entry(TAG, VAL) \ 3898 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 3899 3900 if (!info->shared) 3901 { 3902 if (!add_dynamic_entry (DT_DEBUG, 0)) 3903 return FALSE; 3904 } 3905 3906 if (plt) 3907 { 3908 if (!add_dynamic_entry (DT_PLTGOT, 0) 3909 || !add_dynamic_entry (DT_PLTRELSZ, 0) 3910 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 3911 || !add_dynamic_entry (DT_JMPREL, 0)) 3912 return FALSE; 3913 } 3914 3915 if (relocs) 3916 { 3917 if (!add_dynamic_entry (DT_RELA, 0) 3918 || !add_dynamic_entry (DT_RELASZ, 0) 3919 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 3920 return FALSE; 3921 } 3922 3923 if ((info->flags & DF_TEXTREL) != 0) 3924 { 3925 if (!add_dynamic_entry (DT_TEXTREL, 0)) 3926 return FALSE; 3927 info->flags |= DF_TEXTREL; 3928 } 3929 } 3930 #undef add_dynamic_entry 3931 3932 return TRUE; 3933 } 3934 3935 /* This function is called via elf_cris_link_hash_traverse if we are 3936 creating a shared object. In the -Bsymbolic case, it discards the 3937 space allocated to copy PC relative relocs against symbols which 3938 are defined in regular objects. For the normal non-symbolic case, 3939 we also discard space for relocs that have become local due to 3940 symbol visibility changes. We allocated space for them in the 3941 check_relocs routine, but we won't fill them in in the 3942 relocate_section routine. */ 3943 3944 static bfd_boolean 3945 elf_cris_discard_excess_dso_dynamics (struct elf_cris_link_hash_entry *h, 3946 void * inf) 3947 { 3948 struct elf_cris_pcrel_relocs_copied *s; 3949 struct bfd_link_info *info = (struct bfd_link_info *) inf; 3950 3951 /* If a symbol has been forced local or we have found a regular 3952 definition for the symbolic link case, then we won't be needing 3953 any relocs. */ 3954 if (h->root.def_regular 3955 && (h->root.forced_local 3956 || info->symbolic)) 3957 { 3958 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next) 3959 { 3960 asection *sreloc 3961 = _bfd_elf_get_dynamic_reloc_section (elf_hash_table (info) 3962 ->dynobj, 3963 s->section, 3964 /*rela?*/ TRUE); 3965 sreloc->size -= s->count * sizeof (Elf32_External_Rela); 3966 } 3967 return TRUE; 3968 } 3969 3970 /* If we have accounted for PC-relative relocs for read-only 3971 sections, now is the time to warn for them. We can't do it in 3972 cris_elf_check_relocs, because we don't know the status of all 3973 symbols at that time (and it's common to force symbols local 3974 late). */ 3975 3976 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next) 3977 if ((s->section->flags & SEC_READONLY) != 0) 3978 { 3979 /* FIXME: How do we make this optionally a warning only? */ 3980 (*_bfd_error_handler) 3981 (_("%B, section `%A', to symbol `%s':\n" 3982 " relocation %s should not be used" 3983 " in a shared object; recompile with -fPIC"), 3984 s->section->owner, 3985 s->section, 3986 h->root.root.root.string, 3987 cris_elf_howto_table[s->r_type].name); 3988 3989 info->flags |= DF_TEXTREL; 3990 } 3991 3992 return TRUE; 3993 } 3994 3995 /* This function is called via elf_cris_link_hash_traverse if we are *not* 3996 creating a shared object. We discard space for relocs for symbols put 3997 in the .got, but which we found we do not have to resolve at run-time. */ 3998 3999 static bfd_boolean 4000 elf_cris_discard_excess_program_dynamics (struct elf_cris_link_hash_entry *h, 4001 void * inf) 4002 { 4003 struct bfd_link_info *info = (struct bfd_link_info *) inf; 4004 4005 /* If we're not creating a shared library and have a symbol which is 4006 referred to by .got references, but the symbol is defined locally, 4007 (or rather, not defined by a DSO) then lose the reloc for the .got 4008 (don't allocate room for it). Likewise for relocs for something 4009 for which we create a PLT. */ 4010 if (!h->root.def_dynamic 4011 || h->root.plt.refcount > 0) 4012 { 4013 if (h->reg_got_refcount > 0 4014 /* The size of this section is only valid and in sync with the 4015 various reference counts if we do dynamic; don't decrement it 4016 otherwise. */ 4017 && elf_hash_table (info)->dynamic_sections_created) 4018 { 4019 bfd *dynobj = elf_hash_table (info)->dynobj; 4020 asection *srelgot; 4021 4022 BFD_ASSERT (dynobj != NULL); 4023 4024 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 4025 4026 BFD_ASSERT (srelgot != NULL); 4027 4028 srelgot->size -= sizeof (Elf32_External_Rela); 4029 } 4030 4031 /* If the locally-defined symbol isn't used by a DSO, then we don't 4032 have to export it as a dynamic symbol. This was already done for 4033 functions; doing this for all symbols would presumably not 4034 introduce new problems. Of course we don't do this if we're 4035 exporting all dynamic symbols. */ 4036 if (! info->export_dynamic 4037 && h->root.dynindx != -1 4038 && !h->root.def_dynamic 4039 && !h->root.ref_dynamic) 4040 { 4041 h->root.dynindx = -1; 4042 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 4043 h->root.dynstr_index); 4044 } 4045 } 4046 4047 return TRUE; 4048 } 4049 4050 /* Reject a file depending on presence and expectation of prefixed 4051 underscores on symbols. */ 4052 4053 static bfd_boolean 4054 cris_elf_object_p (bfd *abfd) 4055 { 4056 if (! cris_elf_set_mach_from_flags (abfd, elf_elfheader (abfd)->e_flags)) 4057 return FALSE; 4058 4059 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)) 4060 return (bfd_get_symbol_leading_char (abfd) == '_'); 4061 else 4062 return (bfd_get_symbol_leading_char (abfd) == 0); 4063 } 4064 4065 /* Mark presence or absence of leading underscore. Set machine type 4066 flags from mach type. */ 4067 4068 static void 4069 cris_elf_final_write_processing (bfd *abfd, 4070 bfd_boolean linker ATTRIBUTE_UNUSED) 4071 { 4072 unsigned long e_flags = elf_elfheader (abfd)->e_flags; 4073 4074 e_flags &= ~EF_CRIS_UNDERSCORE; 4075 if (bfd_get_symbol_leading_char (abfd) == '_') 4076 e_flags |= EF_CRIS_UNDERSCORE; 4077 4078 switch (bfd_get_mach (abfd)) 4079 { 4080 case bfd_mach_cris_v0_v10: 4081 e_flags |= EF_CRIS_VARIANT_ANY_V0_V10; 4082 break; 4083 4084 case bfd_mach_cris_v10_v32: 4085 e_flags |= EF_CRIS_VARIANT_COMMON_V10_V32; 4086 break; 4087 4088 case bfd_mach_cris_v32: 4089 e_flags |= EF_CRIS_VARIANT_V32; 4090 break; 4091 4092 default: 4093 _bfd_abort (__FILE__, __LINE__, 4094 _("Unexpected machine number")); 4095 } 4096 4097 elf_elfheader (abfd)->e_flags = e_flags; 4098 } 4099 4100 /* Set the mach type from e_flags value. */ 4101 4102 static bfd_boolean 4103 cris_elf_set_mach_from_flags (bfd *abfd, 4104 unsigned long flags) 4105 { 4106 switch (flags & EF_CRIS_VARIANT_MASK) 4107 { 4108 case EF_CRIS_VARIANT_ANY_V0_V10: 4109 bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v0_v10); 4110 break; 4111 4112 case EF_CRIS_VARIANT_V32: 4113 bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v32); 4114 break; 4115 4116 case EF_CRIS_VARIANT_COMMON_V10_V32: 4117 bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v10_v32); 4118 break; 4119 4120 default: 4121 /* Since we don't recognize them, we obviously can't support them 4122 with this code; we'd have to require that all future handling 4123 would be optional. */ 4124 bfd_set_error (bfd_error_wrong_format); 4125 return FALSE; 4126 } 4127 4128 return TRUE; 4129 } 4130 4131 /* Display the flags field. */ 4132 4133 static bfd_boolean 4134 cris_elf_print_private_bfd_data (bfd *abfd, void * ptr) 4135 { 4136 FILE *file = (FILE *) ptr; 4137 4138 BFD_ASSERT (abfd != NULL && ptr != NULL); 4139 4140 _bfd_elf_print_private_bfd_data (abfd, ptr); 4141 4142 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 4143 4144 if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE) 4145 fprintf (file, _(" [symbols have a _ prefix]")); 4146 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK) 4147 == EF_CRIS_VARIANT_COMMON_V10_V32) 4148 fprintf (file, _(" [v10 and v32]")); 4149 if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK) 4150 == EF_CRIS_VARIANT_V32) 4151 fprintf (file, _(" [v32]")); 4152 4153 fputc ('\n', file); 4154 return TRUE; 4155 } 4156 4157 /* Don't mix files with and without a leading underscore. */ 4158 4159 static bfd_boolean 4160 cris_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 4161 { 4162 int imach, omach; 4163 4164 if (! _bfd_generic_verify_endian_match (ibfd, obfd)) 4165 return FALSE; 4166 4167 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 4168 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 4169 return TRUE; 4170 4171 imach = bfd_get_mach (ibfd); 4172 4173 if (! elf_flags_init (obfd)) 4174 { 4175 /* This happens when ld starts out with a 'blank' output file. */ 4176 elf_flags_init (obfd) = TRUE; 4177 4178 /* We ignore the linker-set mach, and instead set it according to 4179 the first input file. This would also happen if we could 4180 somehow filter out the OUTPUT_ARCH () setting from elf.sc. 4181 This allows us to keep the same linker config across 4182 cris(v0..v10) and crisv32. The drawback is that we can't force 4183 the output type, which might be a sane thing to do for a 4184 v10+v32 compatibility object. */ 4185 if (! bfd_set_arch_mach (obfd, bfd_arch_cris, imach)) 4186 return FALSE; 4187 } 4188 4189 if (bfd_get_symbol_leading_char (ibfd) 4190 != bfd_get_symbol_leading_char (obfd)) 4191 { 4192 (*_bfd_error_handler) 4193 (bfd_get_symbol_leading_char (ibfd) == '_' 4194 ? _("%B: uses _-prefixed symbols, but writing file with non-prefixed symbols") 4195 : _("%B: uses non-prefixed symbols, but writing file with _-prefixed symbols"), 4196 ibfd); 4197 bfd_set_error (bfd_error_bad_value); 4198 return FALSE; 4199 } 4200 4201 omach = bfd_get_mach (obfd); 4202 4203 if (imach != omach) 4204 { 4205 /* We can get an incompatible combination only if either is 4206 bfd_mach_cris_v32, and the other one isn't compatible. */ 4207 if ((imach == bfd_mach_cris_v32 4208 && omach != bfd_mach_cris_v10_v32) 4209 || (omach == bfd_mach_cris_v32 4210 && imach != bfd_mach_cris_v10_v32)) 4211 { 4212 (*_bfd_error_handler) 4213 ((imach == bfd_mach_cris_v32) 4214 ? _("%B contains CRIS v32 code, incompatible" 4215 " with previous objects") 4216 : _("%B contains non-CRIS-v32 code, incompatible" 4217 " with previous objects"), 4218 ibfd); 4219 bfd_set_error (bfd_error_bad_value); 4220 return FALSE; 4221 } 4222 4223 /* We don't have to check the case where the input is compatible 4224 with v10 and v32, because the output is already known to be set 4225 to the other (compatible) mach. */ 4226 if (omach == bfd_mach_cris_v10_v32 4227 && ! bfd_set_arch_mach (obfd, bfd_arch_cris, imach)) 4228 return FALSE; 4229 } 4230 4231 return TRUE; 4232 } 4233 4234 /* Do side-effects of e_flags copying to obfd. */ 4235 4236 static bfd_boolean 4237 cris_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 4238 { 4239 /* Call the base function. */ 4240 if (!_bfd_elf_copy_private_bfd_data (ibfd, obfd)) 4241 return FALSE; 4242 4243 /* If output is big-endian for some obscure reason, stop here. */ 4244 if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE) 4245 return FALSE; 4246 4247 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 4248 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 4249 return TRUE; 4250 4251 /* Do what we really came here for. */ 4252 return bfd_set_arch_mach (obfd, bfd_arch_cris, bfd_get_mach (ibfd)); 4253 } 4254 4255 static enum elf_reloc_type_class 4256 elf_cris_reloc_type_class (const Elf_Internal_Rela *rela) 4257 { 4258 enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rela->r_info); 4259 switch (r_type) 4260 { 4261 case R_CRIS_RELATIVE: 4262 return reloc_class_relative; 4263 case R_CRIS_JUMP_SLOT: 4264 return reloc_class_plt; 4265 case R_CRIS_COPY: 4266 return reloc_class_copy; 4267 default: 4268 return reloc_class_normal; 4269 } 4270 } 4271 4272 /* The elf_backend_got_elt_size worker. For one symbol, we can have up to 4273 two GOT entries from three types with two different sizes. We handle 4274 it as a single entry, so we can use the regular offset-calculation 4275 machinery. */ 4276 4277 static bfd_vma 4278 elf_cris_got_elt_size (bfd *abfd ATTRIBUTE_UNUSED, 4279 struct bfd_link_info *info ATTRIBUTE_UNUSED, 4280 struct elf_link_hash_entry *hr, 4281 bfd *ibfd, 4282 unsigned long symndx) 4283 { 4284 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) hr; 4285 bfd_vma eltsiz = 0; 4286 4287 /* We may have one regular GOT entry or up to two TLS GOT 4288 entries. */ 4289 if (h == NULL) 4290 { 4291 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 4292 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (ibfd); 4293 4294 BFD_ASSERT (local_got_refcounts != NULL); 4295 4296 if (local_got_refcounts[LGOT_REG_NDX (symndx)] > 0) 4297 { 4298 /* We can't have a variable referred to both as a regular 4299 variable and through TLS relocs. */ 4300 BFD_ASSERT (local_got_refcounts[LGOT_DTP_NDX (symndx)] == 0 4301 && local_got_refcounts[LGOT_TPREL_NDX (symndx)] == 0); 4302 return 4; 4303 } 4304 4305 if (local_got_refcounts[LGOT_DTP_NDX (symndx)] > 0) 4306 eltsiz += 8; 4307 4308 if (local_got_refcounts[LGOT_TPREL_NDX (symndx)] > 0) 4309 eltsiz += 4; 4310 } 4311 else 4312 { 4313 struct elf_cris_link_hash_entry *hh = elf_cris_hash_entry (h); 4314 if (hh->reg_got_refcount > 0) 4315 { 4316 /* The actual error-on-input is emitted elsewhere. */ 4317 BFD_ASSERT (hh->dtp_refcount == 0 && hh->tprel_refcount == 0); 4318 return 4; 4319 } 4320 4321 if (hh->dtp_refcount > 0) 4322 eltsiz += 8; 4323 4324 if (hh->tprel_refcount > 0) 4325 eltsiz += 4; 4326 } 4327 4328 /* We're only called when h->got.refcount is non-zero, so we must 4329 have a non-zero size. */ 4330 BFD_ASSERT (eltsiz != 0); 4331 return eltsiz; 4332 } 4333 4334 #define ELF_ARCH bfd_arch_cris 4336 #define ELF_TARGET_ID CRIS_ELF_DATA 4337 #define ELF_MACHINE_CODE EM_CRIS 4338 #define ELF_MAXPAGESIZE 0x2000 4339 4340 #define TARGET_LITTLE_SYM bfd_elf32_cris_vec 4341 #define TARGET_LITTLE_NAME "elf32-cris" 4342 #define elf_symbol_leading_char 0 4343 4344 #define elf_info_to_howto_rel NULL 4345 #define elf_info_to_howto cris_info_to_howto_rela 4346 #define elf_backend_relocate_section cris_elf_relocate_section 4347 #define elf_backend_gc_mark_hook cris_elf_gc_mark_hook 4348 #define elf_backend_gc_sweep_hook cris_elf_gc_sweep_hook 4349 #define elf_backend_plt_sym_val cris_elf_plt_sym_val 4350 #define elf_backend_check_relocs cris_elf_check_relocs 4351 #define elf_backend_grok_prstatus cris_elf_grok_prstatus 4352 #define elf_backend_grok_psinfo cris_elf_grok_psinfo 4353 4354 #define elf_backend_can_gc_sections 1 4355 #define elf_backend_can_refcount 1 4356 4357 #define elf_backend_object_p cris_elf_object_p 4358 #define elf_backend_final_write_processing \ 4359 cris_elf_final_write_processing 4360 #define bfd_elf32_bfd_print_private_bfd_data \ 4361 cris_elf_print_private_bfd_data 4362 #define bfd_elf32_bfd_merge_private_bfd_data \ 4363 cris_elf_merge_private_bfd_data 4364 #define bfd_elf32_bfd_copy_private_bfd_data \ 4365 cris_elf_copy_private_bfd_data 4366 4367 #define bfd_elf32_bfd_reloc_type_lookup cris_reloc_type_lookup 4368 #define bfd_elf32_bfd_reloc_name_lookup cris_reloc_name_lookup 4369 4370 #define bfd_elf32_bfd_link_hash_table_create \ 4371 elf_cris_link_hash_table_create 4372 #define elf_backend_adjust_dynamic_symbol \ 4373 elf_cris_adjust_dynamic_symbol 4374 #define elf_backend_copy_indirect_symbol \ 4375 elf_cris_copy_indirect_symbol 4376 #define elf_backend_size_dynamic_sections \ 4377 elf_cris_size_dynamic_sections 4378 #define elf_backend_init_index_section _bfd_elf_init_1_index_section 4379 #define elf_backend_finish_dynamic_symbol \ 4380 elf_cris_finish_dynamic_symbol 4381 #define elf_backend_finish_dynamic_sections \ 4382 elf_cris_finish_dynamic_sections 4383 #define elf_backend_create_dynamic_sections \ 4384 _bfd_elf_create_dynamic_sections 4385 #define bfd_elf32_bfd_final_link \ 4386 bfd_elf_gc_common_final_link 4387 #define elf_backend_hide_symbol elf_cris_hide_symbol 4388 #define elf_backend_reloc_type_class elf_cris_reloc_type_class 4389 4390 #define elf_backend_want_got_plt 1 4391 #define elf_backend_plt_readonly 1 4392 #define elf_backend_want_plt_sym 0 4393 #define elf_backend_got_header_size 12 4394 #define elf_backend_got_elt_size elf_cris_got_elt_size 4395 4396 /* Later, we my want to optimize RELA entries into REL entries for dynamic 4397 linking and libraries (if it's a win of any significance). Until then, 4398 take the easy route. */ 4399 #define elf_backend_may_use_rel_p 0 4400 #define elf_backend_may_use_rela_p 1 4401 #define elf_backend_rela_normal 1 4402 4403 #include "elf32-target.h" 4404 4405 #undef TARGET_LITTLE_SYM 4406 #undef TARGET_LITTLE_NAME 4407 #undef elf_symbol_leading_char 4408 4409 #define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec 4410 #define TARGET_LITTLE_NAME "elf32-us-cris" 4411 #define elf_symbol_leading_char '_' 4412 #undef elf32_bed 4413 #define elf32_bed elf32_us_cris_bed 4414 4415 #include "elf32-target.h" 4416
Indexes created Mon Sep 14 00:24:24 UTC 2026