1 /* RISC-V-specific support for NN-bit ELF. 2 Copyright (C) 2011-2020 Free Software Foundation, Inc. 3 4 Contributed by Andrew Waterman (andrew@sifive.com). 5 Based on TILE-Gx and MIPS targets. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; see the file COPYING3. If not, 21 see <http://www.gnu.org/licenses/>. */ 22 23 /* This file handles RISC-V ELF targets. */ 24 25 #include "sysdep.h" 26 #include "bfd.h" 27 #include "libbfd.h" 28 #include "bfdlink.h" 29 #include "genlink.h" 30 #include "elf-bfd.h" 31 #include "elfxx-riscv.h" 32 #include "elf/riscv.h" 33 #include "opcode/riscv.h" 34 35 /* Internal relocations used exclusively by the relaxation pass. */ 36 #define R_RISCV_DELETE (R_RISCV_max + 1) 37 38 #define ARCH_SIZE NN 39 40 #define MINUS_ONE ((bfd_vma)0 - 1) 41 42 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3) 43 44 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES) 45 46 /* The name of the dynamic interpreter. This is put in the .interp 47 section. */ 48 49 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1" 50 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1" 51 52 #define ELF_ARCH bfd_arch_riscv 53 #define ELF_TARGET_ID RISCV_ELF_DATA 54 #define ELF_MACHINE_CODE EM_RISCV 55 #define ELF_MAXPAGESIZE 0x1000 56 #define ELF_COMMONPAGESIZE 0x1000 57 58 /* RISC-V ELF linker hash entry. */ 59 60 struct riscv_elf_link_hash_entry 61 { 62 struct elf_link_hash_entry elf; 63 64 #define GOT_UNKNOWN 0 65 #define GOT_NORMAL 1 66 #define GOT_TLS_GD 2 67 #define GOT_TLS_IE 4 68 #define GOT_TLS_LE 8 69 char tls_type; 70 }; 71 72 #define riscv_elf_hash_entry(ent) \ 73 ((struct riscv_elf_link_hash_entry *)(ent)) 74 75 struct _bfd_riscv_elf_obj_tdata 76 { 77 struct elf_obj_tdata root; 78 79 /* tls_type for each local got entry. */ 80 char *local_got_tls_type; 81 }; 82 83 #define _bfd_riscv_elf_tdata(abfd) \ 84 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any) 85 86 #define _bfd_riscv_elf_local_got_tls_type(abfd) \ 87 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type) 88 89 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \ 90 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \ 91 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx])) 92 93 #define is_riscv_elf(bfd) \ 94 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 95 && elf_tdata (bfd) != NULL \ 96 && elf_object_id (bfd) == RISCV_ELF_DATA) 97 98 static bfd_boolean 99 elfNN_riscv_mkobject (bfd *abfd) 100 { 101 return bfd_elf_allocate_object (abfd, 102 sizeof (struct _bfd_riscv_elf_obj_tdata), 103 RISCV_ELF_DATA); 104 } 105 106 #include "elf/common.h" 107 #include "elf/internal.h" 108 109 struct riscv_elf_link_hash_table 110 { 111 struct elf_link_hash_table elf; 112 113 /* Short-cuts to get to dynamic linker sections. */ 114 asection *sdyntdata; 115 116 /* The max alignment of output sections. */ 117 bfd_vma max_alignment; 118 }; 119 120 121 /* Get the RISC-V ELF linker hash table from a link_info structure. */ 122 #define riscv_elf_hash_table(p) \ 123 ((is_elf_hash_table ((p)->hash) \ 124 && elf_hash_table_id (elf_hash_table (p)) == RISCV_ELF_DATA) \ 125 ? (struct riscv_elf_link_hash_table *) (p)->hash : NULL) 126 127 static bfd_boolean 128 riscv_info_to_howto_rela (bfd *abfd, 129 arelent *cache_ptr, 130 Elf_Internal_Rela *dst) 131 { 132 cache_ptr->howto = riscv_elf_rtype_to_howto (abfd, ELFNN_R_TYPE (dst->r_info)); 133 return cache_ptr->howto != NULL; 134 } 135 136 static void 137 riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel) 138 { 139 const struct elf_backend_data *bed; 140 bfd_byte *loc; 141 142 bed = get_elf_backend_data (abfd); 143 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela); 144 bed->s->swap_reloca_out (abfd, rel, loc); 145 } 146 147 /* PLT/GOT stuff. */ 148 149 #define PLT_HEADER_INSNS 8 150 #define PLT_ENTRY_INSNS 4 151 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4) 152 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4) 153 154 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES 155 156 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE) 157 158 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset) 159 160 static bfd_vma 161 riscv_elf_got_plt_val (bfd_vma plt_index, struct bfd_link_info *info) 162 { 163 return sec_addr (riscv_elf_hash_table (info)->elf.sgotplt) 164 + GOTPLT_HEADER_SIZE + (plt_index * GOT_ENTRY_SIZE); 165 } 166 167 #if ARCH_SIZE == 32 168 # define MATCH_LREG MATCH_LW 169 #else 170 # define MATCH_LREG MATCH_LD 171 #endif 172 173 /* Generate a PLT header. */ 174 175 static bfd_boolean 176 riscv_make_plt_header (bfd *output_bfd, bfd_vma gotplt_addr, bfd_vma addr, 177 uint32_t *entry) 178 { 179 bfd_vma gotplt_offset_high = RISCV_PCREL_HIGH_PART (gotplt_addr, addr); 180 bfd_vma gotplt_offset_low = RISCV_PCREL_LOW_PART (gotplt_addr, addr); 181 182 /* RVE has no t3 register, so this won't work, and is not supported. */ 183 if (elf_elfheader (output_bfd)->e_flags & EF_RISCV_RVE) 184 { 185 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"), 186 output_bfd); 187 return FALSE; 188 } 189 190 /* auipc t2, %hi(.got.plt) 191 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12 192 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve 193 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset 194 addi t0, t2, %lo(.got.plt) # &.got.plt 195 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset 196 l[w|d] t0, PTRSIZE(t0) # link map 197 jr t3 */ 198 199 entry[0] = RISCV_UTYPE (AUIPC, X_T2, gotplt_offset_high); 200 entry[1] = RISCV_RTYPE (SUB, X_T1, X_T1, X_T3); 201 entry[2] = RISCV_ITYPE (LREG, X_T3, X_T2, gotplt_offset_low); 202 entry[3] = RISCV_ITYPE (ADDI, X_T1, X_T1, (uint32_t) -(PLT_HEADER_SIZE + 12)); 203 entry[4] = RISCV_ITYPE (ADDI, X_T0, X_T2, gotplt_offset_low); 204 entry[5] = RISCV_ITYPE (SRLI, X_T1, X_T1, 4 - RISCV_ELF_LOG_WORD_BYTES); 205 entry[6] = RISCV_ITYPE (LREG, X_T0, X_T0, RISCV_ELF_WORD_BYTES); 206 entry[7] = RISCV_ITYPE (JALR, 0, X_T3, 0); 207 208 return TRUE; 209 } 210 211 /* Generate a PLT entry. */ 212 213 static bfd_boolean 214 riscv_make_plt_entry (bfd *output_bfd, bfd_vma got, bfd_vma addr, 215 uint32_t *entry) 216 { 217 /* RVE has no t3 register, so this won't work, and is not supported. */ 218 if (elf_elfheader (output_bfd)->e_flags & EF_RISCV_RVE) 219 { 220 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"), 221 output_bfd); 222 return FALSE; 223 } 224 225 /* auipc t3, %hi(.got.plt entry) 226 l[w|d] t3, %lo(.got.plt entry)(t3) 227 jalr t1, t3 228 nop */ 229 230 entry[0] = RISCV_UTYPE (AUIPC, X_T3, RISCV_PCREL_HIGH_PART (got, addr)); 231 entry[1] = RISCV_ITYPE (LREG, X_T3, X_T3, RISCV_PCREL_LOW_PART (got, addr)); 232 entry[2] = RISCV_ITYPE (JALR, X_T1, X_T3, 0); 233 entry[3] = RISCV_NOP; 234 235 return TRUE; 236 } 237 238 /* Create an entry in an RISC-V ELF linker hash table. */ 239 240 static struct bfd_hash_entry * 241 link_hash_newfunc (struct bfd_hash_entry *entry, 242 struct bfd_hash_table *table, const char *string) 243 { 244 /* Allocate the structure if it has not already been allocated by a 245 subclass. */ 246 if (entry == NULL) 247 { 248 entry = 249 bfd_hash_allocate (table, 250 sizeof (struct riscv_elf_link_hash_entry)); 251 if (entry == NULL) 252 return entry; 253 } 254 255 /* Call the allocation method of the superclass. */ 256 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 257 if (entry != NULL) 258 { 259 struct riscv_elf_link_hash_entry *eh; 260 261 eh = (struct riscv_elf_link_hash_entry *) entry; 262 eh->tls_type = GOT_UNKNOWN; 263 } 264 265 return entry; 266 } 267 268 /* Create a RISC-V ELF linker hash table. */ 269 270 static struct bfd_link_hash_table * 271 riscv_elf_link_hash_table_create (bfd *abfd) 272 { 273 struct riscv_elf_link_hash_table *ret; 274 size_t amt = sizeof (struct riscv_elf_link_hash_table); 275 276 ret = (struct riscv_elf_link_hash_table *) bfd_zmalloc (amt); 277 if (ret == NULL) 278 return NULL; 279 280 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc, 281 sizeof (struct riscv_elf_link_hash_entry), 282 RISCV_ELF_DATA)) 283 { 284 free (ret); 285 return NULL; 286 } 287 288 ret->max_alignment = (bfd_vma) -1; 289 return &ret->elf.root; 290 } 291 292 /* Create the .got section. */ 293 294 static bfd_boolean 295 riscv_elf_create_got_section (bfd *abfd, struct bfd_link_info *info) 296 { 297 flagword flags; 298 asection *s, *s_got; 299 struct elf_link_hash_entry *h; 300 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 301 struct elf_link_hash_table *htab = elf_hash_table (info); 302 303 /* This function may be called more than once. */ 304 if (htab->sgot != NULL) 305 return TRUE; 306 307 flags = bed->dynamic_sec_flags; 308 309 s = bfd_make_section_anyway_with_flags (abfd, 310 (bed->rela_plts_and_copies_p 311 ? ".rela.got" : ".rel.got"), 312 (bed->dynamic_sec_flags 313 | SEC_READONLY)); 314 if (s == NULL 315 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 316 return FALSE; 317 htab->srelgot = s; 318 319 s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 320 if (s == NULL 321 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 322 return FALSE; 323 htab->sgot = s; 324 325 /* The first bit of the global offset table is the header. */ 326 s->size += bed->got_header_size; 327 328 if (bed->want_got_plt) 329 { 330 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags); 331 if (s == NULL 332 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 333 return FALSE; 334 htab->sgotplt = s; 335 336 /* Reserve room for the header. */ 337 s->size += GOTPLT_HEADER_SIZE; 338 } 339 340 if (bed->want_got_sym) 341 { 342 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 343 section. We don't do this in the linker script because we don't want 344 to define the symbol if we are not creating a global offset 345 table. */ 346 h = _bfd_elf_define_linkage_sym (abfd, info, s_got, 347 "_GLOBAL_OFFSET_TABLE_"); 348 elf_hash_table (info)->hgot = h; 349 if (h == NULL) 350 return FALSE; 351 } 352 353 return TRUE; 354 } 355 356 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and 357 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our 358 hash table. */ 359 360 static bfd_boolean 361 riscv_elf_create_dynamic_sections (bfd *dynobj, 362 struct bfd_link_info *info) 363 { 364 struct riscv_elf_link_hash_table *htab; 365 366 htab = riscv_elf_hash_table (info); 367 BFD_ASSERT (htab != NULL); 368 369 if (!riscv_elf_create_got_section (dynobj, info)) 370 return FALSE; 371 372 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 373 return FALSE; 374 375 if (!bfd_link_pic (info)) 376 { 377 /* Technically, this section doesn't have contents. It is used as the 378 target of TLS copy relocs, to copy TLS data from shared libraries into 379 the executable. However, if we don't mark it as loadable, then it 380 matches the IS_TBSS test in ldlang.c, and there is no run-time address 381 space allocated for it even though it has SEC_ALLOC. That test is 382 correct for .tbss, but not correct for this section. There is also 383 a second problem that having a section with no contents can only work 384 if it comes after all sections with contents in the same segment, 385 but the linker script does not guarantee that. This is just mixed in 386 with other .tdata.* sections. We can fix both problems by lying and 387 saying that there are contents. This section is expected to be small 388 so this should not cause a significant extra program startup cost. */ 389 htab->sdyntdata = 390 bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn", 391 (SEC_ALLOC | SEC_THREAD_LOCAL 392 | SEC_LOAD | SEC_DATA 393 | SEC_HAS_CONTENTS 394 | SEC_LINKER_CREATED)); 395 } 396 397 if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss 398 || (!bfd_link_pic (info) && (!htab->elf.srelbss || !htab->sdyntdata))) 399 abort (); 400 401 return TRUE; 402 } 403 404 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 405 406 static void 407 riscv_elf_copy_indirect_symbol (struct bfd_link_info *info, 408 struct elf_link_hash_entry *dir, 409 struct elf_link_hash_entry *ind) 410 { 411 struct riscv_elf_link_hash_entry *edir, *eind; 412 413 edir = (struct riscv_elf_link_hash_entry *) dir; 414 eind = (struct riscv_elf_link_hash_entry *) ind; 415 416 if (ind->root.type == bfd_link_hash_indirect 417 && dir->got.refcount <= 0) 418 { 419 edir->tls_type = eind->tls_type; 420 eind->tls_type = GOT_UNKNOWN; 421 } 422 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 423 } 424 425 static bfd_boolean 426 riscv_elf_record_tls_type (bfd *abfd, struct elf_link_hash_entry *h, 427 unsigned long symndx, char tls_type) 428 { 429 char *new_tls_type = &_bfd_riscv_elf_tls_type (abfd, h, symndx); 430 431 *new_tls_type |= tls_type; 432 if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL)) 433 { 434 (*_bfd_error_handler) 435 (_("%pB: `%s' accessed both as normal and thread local symbol"), 436 abfd, h ? h->root.root.string : "<local>"); 437 return FALSE; 438 } 439 return TRUE; 440 } 441 442 static bfd_boolean 443 riscv_elf_record_got_reference (bfd *abfd, struct bfd_link_info *info, 444 struct elf_link_hash_entry *h, long symndx) 445 { 446 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 447 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 448 449 if (htab->elf.sgot == NULL) 450 { 451 if (!riscv_elf_create_got_section (htab->elf.dynobj, info)) 452 return FALSE; 453 } 454 455 if (h != NULL) 456 { 457 h->got.refcount += 1; 458 return TRUE; 459 } 460 461 /* This is a global offset table entry for a local symbol. */ 462 if (elf_local_got_refcounts (abfd) == NULL) 463 { 464 bfd_size_type size = symtab_hdr->sh_info * (sizeof (bfd_vma) + 1); 465 if (!(elf_local_got_refcounts (abfd) = bfd_zalloc (abfd, size))) 466 return FALSE; 467 _bfd_riscv_elf_local_got_tls_type (abfd) 468 = (char *) (elf_local_got_refcounts (abfd) + symtab_hdr->sh_info); 469 } 470 elf_local_got_refcounts (abfd) [symndx] += 1; 471 472 return TRUE; 473 } 474 475 static bfd_boolean 476 bad_static_reloc (bfd *abfd, unsigned r_type, struct elf_link_hash_entry *h) 477 { 478 reloc_howto_type * r = riscv_elf_rtype_to_howto (abfd, r_type); 479 480 (*_bfd_error_handler) 481 (_("%pB: relocation %s against `%s' can not be used when making a shared " 482 "object; recompile with -fPIC"), 483 abfd, r ? r->name : _("<unknown>"), 484 h != NULL ? h->root.root.string : "a local symbol"); 485 bfd_set_error (bfd_error_bad_value); 486 return FALSE; 487 } 488 /* Look through the relocs for a section during the first phase, and 489 allocate space in the global offset table or procedure linkage 490 table. */ 491 492 static bfd_boolean 493 riscv_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, 494 asection *sec, const Elf_Internal_Rela *relocs) 495 { 496 struct riscv_elf_link_hash_table *htab; 497 Elf_Internal_Shdr *symtab_hdr; 498 struct elf_link_hash_entry **sym_hashes; 499 const Elf_Internal_Rela *rel; 500 asection *sreloc = NULL; 501 502 if (bfd_link_relocatable (info)) 503 return TRUE; 504 505 htab = riscv_elf_hash_table (info); 506 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 507 sym_hashes = elf_sym_hashes (abfd); 508 509 if (htab->elf.dynobj == NULL) 510 htab->elf.dynobj = abfd; 511 512 for (rel = relocs; rel < relocs + sec->reloc_count; rel++) 513 { 514 unsigned int r_type; 515 unsigned int r_symndx; 516 struct elf_link_hash_entry *h; 517 518 r_symndx = ELFNN_R_SYM (rel->r_info); 519 r_type = ELFNN_R_TYPE (rel->r_info); 520 521 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 522 { 523 (*_bfd_error_handler) (_("%pB: bad symbol index: %d"), 524 abfd, r_symndx); 525 return FALSE; 526 } 527 528 if (r_symndx < symtab_hdr->sh_info) 529 h = NULL; 530 else 531 { 532 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 533 while (h->root.type == bfd_link_hash_indirect 534 || h->root.type == bfd_link_hash_warning) 535 h = (struct elf_link_hash_entry *) h->root.u.i.link; 536 } 537 538 switch (r_type) 539 { 540 case R_RISCV_TLS_GD_HI20: 541 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx) 542 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_GD)) 543 return FALSE; 544 break; 545 546 case R_RISCV_TLS_GOT_HI20: 547 if (bfd_link_pic (info)) 548 info->flags |= DF_STATIC_TLS; 549 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx) 550 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_IE)) 551 return FALSE; 552 break; 553 554 case R_RISCV_GOT_HI20: 555 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx) 556 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_NORMAL)) 557 return FALSE; 558 break; 559 560 case R_RISCV_CALL: 561 case R_RISCV_CALL_PLT: 562 /* These symbol requires a procedure linkage table entry. We 563 actually build the entry in adjust_dynamic_symbol, 564 because these might be a case of linking PIC code without 565 linking in any dynamic objects, in which case we don't 566 need to generate a procedure linkage table after all. */ 567 568 /* If it is a local symbol, then we resolve it directly 569 without creating a PLT entry. */ 570 if (h == NULL) 571 continue; 572 573 h->needs_plt = 1; 574 h->plt.refcount += 1; 575 break; 576 577 case R_RISCV_JAL: 578 case R_RISCV_BRANCH: 579 case R_RISCV_RVC_BRANCH: 580 case R_RISCV_RVC_JUMP: 581 case R_RISCV_PCREL_HI20: 582 /* In shared libraries, these relocs are known to bind locally. */ 583 if (bfd_link_pic (info)) 584 break; 585 goto static_reloc; 586 587 case R_RISCV_TPREL_HI20: 588 if (!bfd_link_executable (info)) 589 return bad_static_reloc (abfd, r_type, h); 590 if (h != NULL) 591 riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_LE); 592 goto static_reloc; 593 594 case R_RISCV_HI20: 595 if (bfd_link_pic (info)) 596 return bad_static_reloc (abfd, r_type, h); 597 /* Fall through. */ 598 599 case R_RISCV_COPY: 600 case R_RISCV_JUMP_SLOT: 601 case R_RISCV_RELATIVE: 602 case R_RISCV_64: 603 case R_RISCV_32: 604 /* Fall through. */ 605 606 static_reloc: 607 /* This reloc might not bind locally. */ 608 if (h != NULL) 609 h->non_got_ref = 1; 610 611 if (h != NULL && !bfd_link_pic (info)) 612 { 613 /* We may need a .plt entry if the function this reloc 614 refers to is in a shared lib. */ 615 h->plt.refcount += 1; 616 } 617 618 /* If we are creating a shared library, and this is a reloc 619 against a global symbol, or a non PC relative reloc 620 against a local symbol, then we need to copy the reloc 621 into the shared library. However, if we are linking with 622 -Bsymbolic, we do not need to copy a reloc against a 623 global symbol which is defined in an object we are 624 including in the link (i.e., DEF_REGULAR is set). At 625 this point we have not seen all the input files, so it is 626 possible that DEF_REGULAR is not set now but will be set 627 later (it is never cleared). In case of a weak definition, 628 DEF_REGULAR may be cleared later by a strong definition in 629 a shared library. We account for that possibility below by 630 storing information in the relocs_copied field of the hash 631 table entry. A similar situation occurs when creating 632 shared libraries and symbol visibility changes render the 633 symbol local. 634 635 If on the other hand, we are creating an executable, we 636 may need to keep relocations for symbols satisfied by a 637 dynamic library if we manage to avoid copy relocs for the 638 symbol. */ 639 reloc_howto_type * r = riscv_elf_rtype_to_howto (abfd, r_type); 640 641 if ((bfd_link_pic (info) 642 && (sec->flags & SEC_ALLOC) != 0 643 && ((r != NULL && ! r->pc_relative) 644 || (h != NULL 645 && (! info->symbolic 646 || h->root.type == bfd_link_hash_defweak 647 || !h->def_regular)))) 648 || (!bfd_link_pic (info) 649 && (sec->flags & SEC_ALLOC) != 0 650 && h != NULL 651 && (h->root.type == bfd_link_hash_defweak 652 || !h->def_regular))) 653 { 654 struct elf_dyn_relocs *p; 655 struct elf_dyn_relocs **head; 656 657 /* When creating a shared object, we must copy these 658 relocs into the output file. We create a reloc 659 section in dynobj and make room for the reloc. */ 660 if (sreloc == NULL) 661 { 662 sreloc = _bfd_elf_make_dynamic_reloc_section 663 (sec, htab->elf.dynobj, RISCV_ELF_LOG_WORD_BYTES, 664 abfd, /*rela?*/ TRUE); 665 666 if (sreloc == NULL) 667 return FALSE; 668 } 669 670 /* If this is a global symbol, we count the number of 671 relocations we need for this symbol. */ 672 if (h != NULL) 673 head = &h->dyn_relocs; 674 else 675 { 676 /* Track dynamic relocs needed for local syms too. 677 We really need local syms available to do this 678 easily. Oh well. */ 679 680 asection *s; 681 void *vpp; 682 Elf_Internal_Sym *isym; 683 684 isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache, 685 abfd, r_symndx); 686 if (isym == NULL) 687 return FALSE; 688 689 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 690 if (s == NULL) 691 s = sec; 692 693 vpp = &elf_section_data (s)->local_dynrel; 694 head = (struct elf_dyn_relocs **) vpp; 695 } 696 697 p = *head; 698 if (p == NULL || p->sec != sec) 699 { 700 size_t amt = sizeof *p; 701 p = ((struct elf_dyn_relocs *) 702 bfd_alloc (htab->elf.dynobj, amt)); 703 if (p == NULL) 704 return FALSE; 705 p->next = *head; 706 *head = p; 707 p->sec = sec; 708 p->count = 0; 709 p->pc_count = 0; 710 } 711 712 p->count += 1; 713 p->pc_count += r == NULL ? 0 : r->pc_relative; 714 } 715 716 break; 717 718 case R_RISCV_GNU_VTINHERIT: 719 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 720 return FALSE; 721 break; 722 723 case R_RISCV_GNU_VTENTRY: 724 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 725 return FALSE; 726 break; 727 728 default: 729 break; 730 } 731 } 732 733 return TRUE; 734 } 735 736 static asection * 737 riscv_elf_gc_mark_hook (asection *sec, 738 struct bfd_link_info *info, 739 Elf_Internal_Rela *rel, 740 struct elf_link_hash_entry *h, 741 Elf_Internal_Sym *sym) 742 { 743 if (h != NULL) 744 switch (ELFNN_R_TYPE (rel->r_info)) 745 { 746 case R_RISCV_GNU_VTINHERIT: 747 case R_RISCV_GNU_VTENTRY: 748 return NULL; 749 } 750 751 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 752 } 753 754 /* Adjust a symbol defined by a dynamic object and referenced by a 755 regular object. The current definition is in some section of the 756 dynamic object, but we're not including those sections. We have to 757 change the definition to something the rest of the link can 758 understand. */ 759 760 static bfd_boolean 761 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 762 struct elf_link_hash_entry *h) 763 { 764 struct riscv_elf_link_hash_table *htab; 765 struct riscv_elf_link_hash_entry * eh; 766 bfd *dynobj; 767 asection *s, *srel; 768 769 htab = riscv_elf_hash_table (info); 770 BFD_ASSERT (htab != NULL); 771 772 dynobj = htab->elf.dynobj; 773 774 /* Make sure we know what is going on here. */ 775 BFD_ASSERT (dynobj != NULL 776 && (h->needs_plt 777 || h->type == STT_GNU_IFUNC 778 || h->is_weakalias 779 || (h->def_dynamic 780 && h->ref_regular 781 && !h->def_regular))); 782 783 /* If this is a function, put it in the procedure linkage table. We 784 will fill in the contents of the procedure linkage table later 785 (although we could actually do it here). */ 786 if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt) 787 { 788 if (h->plt.refcount <= 0 789 || SYMBOL_CALLS_LOCAL (info, h) 790 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 791 && h->root.type == bfd_link_hash_undefweak)) 792 { 793 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an 794 input file, but the symbol was never referred to by a dynamic 795 object, or if all references were garbage collected. In such 796 a case, we don't actually need to build a PLT entry. */ 797 h->plt.offset = (bfd_vma) -1; 798 h->needs_plt = 0; 799 } 800 801 return TRUE; 802 } 803 else 804 h->plt.offset = (bfd_vma) -1; 805 806 /* If this is a weak symbol, and there is a real definition, the 807 processor independent code will have arranged for us to see the 808 real definition first, and we can just use the same value. */ 809 if (h->is_weakalias) 810 { 811 struct elf_link_hash_entry *def = weakdef (h); 812 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 813 h->root.u.def.section = def->root.u.def.section; 814 h->root.u.def.value = def->root.u.def.value; 815 return TRUE; 816 } 817 818 /* This is a reference to a symbol defined by a dynamic object which 819 is not a function. */ 820 821 /* If we are creating a shared library, we must presume that the 822 only references to the symbol are via the global offset table. 823 For such cases we need not do anything here; the relocations will 824 be handled correctly by relocate_section. */ 825 if (bfd_link_pic (info)) 826 return TRUE; 827 828 /* If there are no references to this symbol that do not use the 829 GOT, we don't need to generate a copy reloc. */ 830 if (!h->non_got_ref) 831 return TRUE; 832 833 /* If -z nocopyreloc was given, we won't generate them either. */ 834 if (info->nocopyreloc) 835 { 836 h->non_got_ref = 0; 837 return TRUE; 838 } 839 840 /* If we don't find any dynamic relocs in read-only sections, then 841 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 842 if (!_bfd_elf_readonly_dynrelocs (h)) 843 { 844 h->non_got_ref = 0; 845 return TRUE; 846 } 847 848 /* We must allocate the symbol in our .dynbss section, which will 849 become part of the .bss section of the executable. There will be 850 an entry for this symbol in the .dynsym section. The dynamic 851 object will contain position independent code, so all references 852 from the dynamic object to this symbol will go through the global 853 offset table. The dynamic linker will use the .dynsym entry to 854 determine the address it must put in the global offset table, so 855 both the dynamic object and the regular object will refer to the 856 same memory location for the variable. */ 857 858 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker 859 to copy the initial value out of the dynamic object and into the 860 runtime process image. We need to remember the offset into the 861 .rel.bss section we are going to use. */ 862 eh = (struct riscv_elf_link_hash_entry *) h; 863 if (eh->tls_type & ~GOT_NORMAL) 864 { 865 s = htab->sdyntdata; 866 srel = htab->elf.srelbss; 867 } 868 else if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 869 { 870 s = htab->elf.sdynrelro; 871 srel = htab->elf.sreldynrelro; 872 } 873 else 874 { 875 s = htab->elf.sdynbss; 876 srel = htab->elf.srelbss; 877 } 878 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 879 { 880 srel->size += sizeof (ElfNN_External_Rela); 881 h->needs_copy = 1; 882 } 883 884 return _bfd_elf_adjust_dynamic_copy (info, h, s); 885 } 886 887 /* Allocate space in .plt, .got and associated reloc sections for 888 dynamic relocs. */ 889 890 static bfd_boolean 891 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 892 { 893 struct bfd_link_info *info; 894 struct riscv_elf_link_hash_table *htab; 895 struct elf_dyn_relocs *p; 896 897 if (h->root.type == bfd_link_hash_indirect) 898 return TRUE; 899 900 info = (struct bfd_link_info *) inf; 901 htab = riscv_elf_hash_table (info); 902 BFD_ASSERT (htab != NULL); 903 904 if (htab->elf.dynamic_sections_created 905 && h->plt.refcount > 0) 906 { 907 /* Make sure this symbol is output as a dynamic symbol. 908 Undefined weak syms won't yet be marked as dynamic. */ 909 if (h->dynindx == -1 910 && !h->forced_local) 911 { 912 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 913 return FALSE; 914 } 915 916 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)) 917 { 918 asection *s = htab->elf.splt; 919 920 if (s->size == 0) 921 s->size = PLT_HEADER_SIZE; 922 923 h->plt.offset = s->size; 924 925 /* Make room for this entry. */ 926 s->size += PLT_ENTRY_SIZE; 927 928 /* We also need to make an entry in the .got.plt section. */ 929 htab->elf.sgotplt->size += GOT_ENTRY_SIZE; 930 931 /* We also need to make an entry in the .rela.plt section. */ 932 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela); 933 934 /* If this symbol is not defined in a regular file, and we are 935 not generating a shared library, then set the symbol to this 936 location in the .plt. This is required to make function 937 pointers compare as equal between the normal executable and 938 the shared library. */ 939 if (! bfd_link_pic (info) 940 && !h->def_regular) 941 { 942 h->root.u.def.section = s; 943 h->root.u.def.value = h->plt.offset; 944 } 945 } 946 else 947 { 948 h->plt.offset = (bfd_vma) -1; 949 h->needs_plt = 0; 950 } 951 } 952 else 953 { 954 h->plt.offset = (bfd_vma) -1; 955 h->needs_plt = 0; 956 } 957 958 if (h->got.refcount > 0) 959 { 960 asection *s; 961 bfd_boolean dyn; 962 int tls_type = riscv_elf_hash_entry (h)->tls_type; 963 964 /* Make sure this symbol is output as a dynamic symbol. 965 Undefined weak syms won't yet be marked as dynamic. */ 966 if (h->dynindx == -1 967 && !h->forced_local) 968 { 969 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 970 return FALSE; 971 } 972 973 s = htab->elf.sgot; 974 h->got.offset = s->size; 975 dyn = htab->elf.dynamic_sections_created; 976 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE)) 977 { 978 /* TLS_GD needs two dynamic relocs and two GOT slots. */ 979 if (tls_type & GOT_TLS_GD) 980 { 981 s->size += 2 * RISCV_ELF_WORD_BYTES; 982 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela); 983 } 984 985 /* TLS_IE needs one dynamic reloc and one GOT slot. */ 986 if (tls_type & GOT_TLS_IE) 987 { 988 s->size += RISCV_ELF_WORD_BYTES; 989 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela); 990 } 991 } 992 else 993 { 994 s->size += RISCV_ELF_WORD_BYTES; 995 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h) 996 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) 997 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela); 998 } 999 } 1000 else 1001 h->got.offset = (bfd_vma) -1; 1002 1003 if (h->dyn_relocs == NULL) 1004 return TRUE; 1005 1006 /* In the shared -Bsymbolic case, discard space allocated for 1007 dynamic pc-relative relocs against symbols which turn out to be 1008 defined in regular objects. For the normal shared case, discard 1009 space for pc-relative relocs that have become local due to symbol 1010 visibility changes. */ 1011 1012 if (bfd_link_pic (info)) 1013 { 1014 if (SYMBOL_CALLS_LOCAL (info, h)) 1015 { 1016 struct elf_dyn_relocs **pp; 1017 1018 for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) 1019 { 1020 p->count -= p->pc_count; 1021 p->pc_count = 0; 1022 if (p->count == 0) 1023 *pp = p->next; 1024 else 1025 pp = &p->next; 1026 } 1027 } 1028 1029 /* Also discard relocs on undefined weak syms with non-default 1030 visibility. */ 1031 if (h->dyn_relocs != NULL 1032 && h->root.type == bfd_link_hash_undefweak) 1033 { 1034 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1035 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) 1036 h->dyn_relocs = NULL; 1037 1038 /* Make sure undefined weak symbols are output as a dynamic 1039 symbol in PIEs. */ 1040 else if (h->dynindx == -1 1041 && !h->forced_local) 1042 { 1043 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1044 return FALSE; 1045 } 1046 } 1047 } 1048 else 1049 { 1050 /* For the non-shared case, discard space for relocs against 1051 symbols which turn out to need copy relocs or are not 1052 dynamic. */ 1053 1054 if (!h->non_got_ref 1055 && ((h->def_dynamic 1056 && !h->def_regular) 1057 || (htab->elf.dynamic_sections_created 1058 && (h->root.type == bfd_link_hash_undefweak 1059 || h->root.type == bfd_link_hash_undefined)))) 1060 { 1061 /* Make sure this symbol is output as a dynamic symbol. 1062 Undefined weak syms won't yet be marked as dynamic. */ 1063 if (h->dynindx == -1 1064 && !h->forced_local) 1065 { 1066 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1067 return FALSE; 1068 } 1069 1070 /* If that succeeded, we know we'll be keeping all the 1071 relocs. */ 1072 if (h->dynindx != -1) 1073 goto keep; 1074 } 1075 1076 h->dyn_relocs = NULL; 1077 1078 keep: ; 1079 } 1080 1081 /* Finally, allocate space. */ 1082 for (p = h->dyn_relocs; p != NULL; p = p->next) 1083 { 1084 asection *sreloc = elf_section_data (p->sec)->sreloc; 1085 sreloc->size += p->count * sizeof (ElfNN_External_Rela); 1086 } 1087 1088 return TRUE; 1089 } 1090 1091 static bfd_boolean 1092 riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 1093 { 1094 struct riscv_elf_link_hash_table *htab; 1095 bfd *dynobj; 1096 asection *s; 1097 bfd *ibfd; 1098 1099 htab = riscv_elf_hash_table (info); 1100 BFD_ASSERT (htab != NULL); 1101 dynobj = htab->elf.dynobj; 1102 BFD_ASSERT (dynobj != NULL); 1103 1104 if (elf_hash_table (info)->dynamic_sections_created) 1105 { 1106 /* Set the contents of the .interp section to the interpreter. */ 1107 if (bfd_link_executable (info) && !info->nointerp) 1108 { 1109 s = bfd_get_linker_section (dynobj, ".interp"); 1110 BFD_ASSERT (s != NULL); 1111 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1; 1112 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER; 1113 } 1114 } 1115 1116 /* Set up .got offsets for local syms, and space for local dynamic 1117 relocs. */ 1118 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 1119 { 1120 bfd_signed_vma *local_got; 1121 bfd_signed_vma *end_local_got; 1122 char *local_tls_type; 1123 bfd_size_type locsymcount; 1124 Elf_Internal_Shdr *symtab_hdr; 1125 asection *srel; 1126 1127 if (! is_riscv_elf (ibfd)) 1128 continue; 1129 1130 for (s = ibfd->sections; s != NULL; s = s->next) 1131 { 1132 struct elf_dyn_relocs *p; 1133 1134 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next) 1135 { 1136 if (!bfd_is_abs_section (p->sec) 1137 && bfd_is_abs_section (p->sec->output_section)) 1138 { 1139 /* Input section has been discarded, either because 1140 it is a copy of a linkonce section or due to 1141 linker script /DISCARD/, so we'll be discarding 1142 the relocs too. */ 1143 } 1144 else if (p->count != 0) 1145 { 1146 srel = elf_section_data (p->sec)->sreloc; 1147 srel->size += p->count * sizeof (ElfNN_External_Rela); 1148 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 1149 info->flags |= DF_TEXTREL; 1150 } 1151 } 1152 } 1153 1154 local_got = elf_local_got_refcounts (ibfd); 1155 if (!local_got) 1156 continue; 1157 1158 symtab_hdr = &elf_symtab_hdr (ibfd); 1159 locsymcount = symtab_hdr->sh_info; 1160 end_local_got = local_got + locsymcount; 1161 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd); 1162 s = htab->elf.sgot; 1163 srel = htab->elf.srelgot; 1164 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 1165 { 1166 if (*local_got > 0) 1167 { 1168 *local_got = s->size; 1169 s->size += RISCV_ELF_WORD_BYTES; 1170 if (*local_tls_type & GOT_TLS_GD) 1171 s->size += RISCV_ELF_WORD_BYTES; 1172 if (bfd_link_pic (info) 1173 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE))) 1174 srel->size += sizeof (ElfNN_External_Rela); 1175 } 1176 else 1177 *local_got = (bfd_vma) -1; 1178 } 1179 } 1180 1181 /* Allocate global sym .plt and .got entries, and space for global 1182 sym dynamic relocs. */ 1183 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info); 1184 1185 if (htab->elf.sgotplt) 1186 { 1187 struct elf_link_hash_entry *got; 1188 got = elf_link_hash_lookup (elf_hash_table (info), 1189 "_GLOBAL_OFFSET_TABLE_", 1190 FALSE, FALSE, FALSE); 1191 1192 /* Don't allocate .got.plt section if there are no GOT nor PLT 1193 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */ 1194 if ((got == NULL 1195 || !got->ref_regular_nonweak) 1196 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE) 1197 && (htab->elf.splt == NULL 1198 || htab->elf.splt->size == 0) 1199 && (htab->elf.sgot == NULL 1200 || (htab->elf.sgot->size 1201 == get_elf_backend_data (output_bfd)->got_header_size))) 1202 htab->elf.sgotplt->size = 0; 1203 } 1204 1205 /* The check_relocs and adjust_dynamic_symbol entry points have 1206 determined the sizes of the various dynamic sections. Allocate 1207 memory for them. */ 1208 for (s = dynobj->sections; s != NULL; s = s->next) 1209 { 1210 if ((s->flags & SEC_LINKER_CREATED) == 0) 1211 continue; 1212 1213 if (s == htab->elf.splt 1214 || s == htab->elf.sgot 1215 || s == htab->elf.sgotplt 1216 || s == htab->elf.sdynbss 1217 || s == htab->elf.sdynrelro 1218 || s == htab->sdyntdata) 1219 { 1220 /* Strip this section if we don't need it; see the 1221 comment below. */ 1222 } 1223 else if (strncmp (s->name, ".rela", 5) == 0) 1224 { 1225 if (s->size != 0) 1226 { 1227 /* We use the reloc_count field as a counter if we need 1228 to copy relocs into the output file. */ 1229 s->reloc_count = 0; 1230 } 1231 } 1232 else 1233 { 1234 /* It's not one of our sections. */ 1235 continue; 1236 } 1237 1238 if (s->size == 0) 1239 { 1240 /* If we don't need this section, strip it from the 1241 output file. This is mostly to handle .rela.bss and 1242 .rela.plt. We must create both sections in 1243 create_dynamic_sections, because they must be created 1244 before the linker maps input sections to output 1245 sections. The linker does that before 1246 adjust_dynamic_symbol is called, and it is that 1247 function which decides whether anything needs to go 1248 into these sections. */ 1249 s->flags |= SEC_EXCLUDE; 1250 continue; 1251 } 1252 1253 if ((s->flags & SEC_HAS_CONTENTS) == 0) 1254 continue; 1255 1256 /* Allocate memory for the section contents. Zero the memory 1257 for the benefit of .rela.plt, which has 4 unused entries 1258 at the beginning, and we don't want garbage. */ 1259 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 1260 if (s->contents == NULL) 1261 return FALSE; 1262 } 1263 1264 return _bfd_elf_add_dynamic_tags (output_bfd, info, TRUE); 1265 } 1266 1267 #define TP_OFFSET 0 1268 #define DTP_OFFSET 0x800 1269 1270 /* Return the relocation value for a TLS dtp-relative reloc. */ 1271 1272 static bfd_vma 1273 dtpoff (struct bfd_link_info *info, bfd_vma address) 1274 { 1275 /* If tls_sec is NULL, we should have signalled an error already. */ 1276 if (elf_hash_table (info)->tls_sec == NULL) 1277 return 0; 1278 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET; 1279 } 1280 1281 /* Return the relocation value for a static TLS tp-relative relocation. */ 1282 1283 static bfd_vma 1284 tpoff (struct bfd_link_info *info, bfd_vma address) 1285 { 1286 /* If tls_sec is NULL, we should have signalled an error already. */ 1287 if (elf_hash_table (info)->tls_sec == NULL) 1288 return 0; 1289 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET; 1290 } 1291 1292 /* Return the global pointer's value, or 0 if it is not in use. */ 1293 1294 static bfd_vma 1295 riscv_global_pointer_value (struct bfd_link_info *info) 1296 { 1297 struct bfd_link_hash_entry *h; 1298 1299 h = bfd_link_hash_lookup (info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE); 1300 if (h == NULL || h->type != bfd_link_hash_defined) 1301 return 0; 1302 1303 return h->u.def.value + sec_addr (h->u.def.section); 1304 } 1305 1306 /* Emplace a static relocation. */ 1307 1308 static bfd_reloc_status_type 1309 perform_relocation (const reloc_howto_type *howto, 1310 const Elf_Internal_Rela *rel, 1311 bfd_vma value, 1312 asection *input_section, 1313 bfd *input_bfd, 1314 bfd_byte *contents) 1315 { 1316 if (howto->pc_relative) 1317 value -= sec_addr (input_section) + rel->r_offset; 1318 value += rel->r_addend; 1319 1320 switch (ELFNN_R_TYPE (rel->r_info)) 1321 { 1322 case R_RISCV_HI20: 1323 case R_RISCV_TPREL_HI20: 1324 case R_RISCV_PCREL_HI20: 1325 case R_RISCV_GOT_HI20: 1326 case R_RISCV_TLS_GOT_HI20: 1327 case R_RISCV_TLS_GD_HI20: 1328 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))) 1329 return bfd_reloc_overflow; 1330 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)); 1331 break; 1332 1333 case R_RISCV_LO12_I: 1334 case R_RISCV_GPREL_I: 1335 case R_RISCV_TPREL_LO12_I: 1336 case R_RISCV_TPREL_I: 1337 case R_RISCV_PCREL_LO12_I: 1338 value = ENCODE_ITYPE_IMM (value); 1339 break; 1340 1341 case R_RISCV_LO12_S: 1342 case R_RISCV_GPREL_S: 1343 case R_RISCV_TPREL_LO12_S: 1344 case R_RISCV_TPREL_S: 1345 case R_RISCV_PCREL_LO12_S: 1346 value = ENCODE_STYPE_IMM (value); 1347 break; 1348 1349 case R_RISCV_CALL: 1350 case R_RISCV_CALL_PLT: 1351 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))) 1352 return bfd_reloc_overflow; 1353 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)) 1354 | (ENCODE_ITYPE_IMM (value) << 32); 1355 break; 1356 1357 case R_RISCV_JAL: 1358 if (!VALID_UJTYPE_IMM (value)) 1359 return bfd_reloc_overflow; 1360 value = ENCODE_UJTYPE_IMM (value); 1361 break; 1362 1363 case R_RISCV_BRANCH: 1364 if (!VALID_SBTYPE_IMM (value)) 1365 return bfd_reloc_overflow; 1366 value = ENCODE_SBTYPE_IMM (value); 1367 break; 1368 1369 case R_RISCV_RVC_BRANCH: 1370 if (!VALID_RVC_B_IMM (value)) 1371 return bfd_reloc_overflow; 1372 value = ENCODE_RVC_B_IMM (value); 1373 break; 1374 1375 case R_RISCV_RVC_JUMP: 1376 if (!VALID_RVC_J_IMM (value)) 1377 return bfd_reloc_overflow; 1378 value = ENCODE_RVC_J_IMM (value); 1379 break; 1380 1381 case R_RISCV_RVC_LUI: 1382 if (RISCV_CONST_HIGH_PART (value) == 0) 1383 { 1384 /* Linker relaxation can convert an address equal to or greater than 1385 0x800 to slightly below 0x800. C.LUI does not accept zero as a 1386 valid immediate. We can fix this by converting it to a C.LI. */ 1387 bfd_vma insn = bfd_get (howto->bitsize, input_bfd, 1388 contents + rel->r_offset); 1389 insn = (insn & ~MATCH_C_LUI) | MATCH_C_LI; 1390 bfd_put (howto->bitsize, input_bfd, insn, contents + rel->r_offset); 1391 value = ENCODE_RVC_IMM (0); 1392 } 1393 else if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value))) 1394 return bfd_reloc_overflow; 1395 else 1396 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)); 1397 break; 1398 1399 case R_RISCV_32: 1400 case R_RISCV_64: 1401 case R_RISCV_ADD8: 1402 case R_RISCV_ADD16: 1403 case R_RISCV_ADD32: 1404 case R_RISCV_ADD64: 1405 case R_RISCV_SUB6: 1406 case R_RISCV_SUB8: 1407 case R_RISCV_SUB16: 1408 case R_RISCV_SUB32: 1409 case R_RISCV_SUB64: 1410 case R_RISCV_SET6: 1411 case R_RISCV_SET8: 1412 case R_RISCV_SET16: 1413 case R_RISCV_SET32: 1414 case R_RISCV_32_PCREL: 1415 case R_RISCV_TLS_DTPREL32: 1416 case R_RISCV_TLS_DTPREL64: 1417 break; 1418 1419 case R_RISCV_DELETE: 1420 return bfd_reloc_ok; 1421 1422 default: 1423 return bfd_reloc_notsupported; 1424 } 1425 1426 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset); 1427 word = (word & ~howto->dst_mask) | (value & howto->dst_mask); 1428 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset); 1429 1430 return bfd_reloc_ok; 1431 } 1432 1433 /* Remember all PC-relative high-part relocs we've encountered to help us 1434 later resolve the corresponding low-part relocs. */ 1435 1436 typedef struct 1437 { 1438 bfd_vma address; 1439 bfd_vma value; 1440 } riscv_pcrel_hi_reloc; 1441 1442 typedef struct riscv_pcrel_lo_reloc 1443 { 1444 asection * input_section; 1445 struct bfd_link_info * info; 1446 reloc_howto_type * howto; 1447 const Elf_Internal_Rela * reloc; 1448 bfd_vma addr; 1449 const char * name; 1450 bfd_byte * contents; 1451 struct riscv_pcrel_lo_reloc * next; 1452 } riscv_pcrel_lo_reloc; 1453 1454 typedef struct 1455 { 1456 htab_t hi_relocs; 1457 riscv_pcrel_lo_reloc *lo_relocs; 1458 } riscv_pcrel_relocs; 1459 1460 static hashval_t 1461 riscv_pcrel_reloc_hash (const void *entry) 1462 { 1463 const riscv_pcrel_hi_reloc *e = entry; 1464 return (hashval_t)(e->address >> 2); 1465 } 1466 1467 static bfd_boolean 1468 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2) 1469 { 1470 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2; 1471 return e1->address == e2->address; 1472 } 1473 1474 static bfd_boolean 1475 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p) 1476 { 1477 1478 p->lo_relocs = NULL; 1479 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash, 1480 riscv_pcrel_reloc_eq, free); 1481 return p->hi_relocs != NULL; 1482 } 1483 1484 static void 1485 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p) 1486 { 1487 riscv_pcrel_lo_reloc *cur = p->lo_relocs; 1488 1489 while (cur != NULL) 1490 { 1491 riscv_pcrel_lo_reloc *next = cur->next; 1492 free (cur); 1493 cur = next; 1494 } 1495 1496 htab_delete (p->hi_relocs); 1497 } 1498 1499 static bfd_boolean 1500 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela *rel, 1501 struct bfd_link_info *info, 1502 bfd_vma pc, 1503 bfd_vma addr, 1504 bfd_byte *contents, 1505 const reloc_howto_type *howto, 1506 bfd *input_bfd) 1507 { 1508 /* We may need to reference low addreses in PC-relative modes even when the 1509 * PC is far away from these addresses. For example, undefweak references 1510 * need to produce the address 0 when linked. As 0 is far from the arbitrary 1511 * addresses that we can link PC-relative programs at, the linker can't 1512 * actually relocate references to those symbols. In order to allow these 1513 * programs to work we simply convert the PC-relative auipc sequences to 1514 * 0-relative lui sequences. */ 1515 if (bfd_link_pic (info)) 1516 return FALSE; 1517 1518 /* If it's possible to reference the symbol using auipc we do so, as that's 1519 * more in the spirit of the PC-relative relocations we're processing. */ 1520 bfd_vma offset = addr - pc; 1521 if (ARCH_SIZE == 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset))) 1522 return FALSE; 1523 1524 /* If it's impossible to reference this with a LUI-based offset then don't 1525 * bother to convert it at all so users still see the PC-relative relocation 1526 * in the truncation message. */ 1527 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr))) 1528 return FALSE; 1529 1530 rel->r_info = ELFNN_R_INFO(addr, R_RISCV_HI20); 1531 1532 bfd_vma insn = bfd_get(howto->bitsize, input_bfd, contents + rel->r_offset); 1533 insn = (insn & ~MASK_AUIPC) | MATCH_LUI; 1534 bfd_put(howto->bitsize, input_bfd, insn, contents + rel->r_offset); 1535 return TRUE; 1536 } 1537 1538 static bfd_boolean 1539 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr, 1540 bfd_vma value, bfd_boolean absolute) 1541 { 1542 bfd_vma offset = absolute ? value : value - addr; 1543 riscv_pcrel_hi_reloc entry = {addr, offset}; 1544 riscv_pcrel_hi_reloc **slot = 1545 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT); 1546 1547 BFD_ASSERT (*slot == NULL); 1548 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc)); 1549 if (*slot == NULL) 1550 return FALSE; 1551 **slot = entry; 1552 return TRUE; 1553 } 1554 1555 static bfd_boolean 1556 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p, 1557 asection *input_section, 1558 struct bfd_link_info *info, 1559 reloc_howto_type *howto, 1560 const Elf_Internal_Rela *reloc, 1561 bfd_vma addr, 1562 const char *name, 1563 bfd_byte *contents) 1564 { 1565 riscv_pcrel_lo_reloc *entry; 1566 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc)); 1567 if (entry == NULL) 1568 return FALSE; 1569 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr, 1570 name, contents, p->lo_relocs}; 1571 p->lo_relocs = entry; 1572 return TRUE; 1573 } 1574 1575 static bfd_boolean 1576 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p) 1577 { 1578 riscv_pcrel_lo_reloc *r; 1579 1580 for (r = p->lo_relocs; r != NULL; r = r->next) 1581 { 1582 bfd *input_bfd = r->input_section->owner; 1583 1584 riscv_pcrel_hi_reloc search = {r->addr, 0}; 1585 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search); 1586 if (entry == NULL 1587 /* Check for overflow into bit 11 when adding reloc addend. */ 1588 || (! (entry->value & 0x800) 1589 && ((entry->value + r->reloc->r_addend) & 0x800))) 1590 { 1591 char *string = (entry == NULL 1592 ? "%pcrel_lo missing matching %pcrel_hi" 1593 : "%pcrel_lo overflow with an addend"); 1594 (*r->info->callbacks->reloc_dangerous) 1595 (r->info, string, input_bfd, r->input_section, r->reloc->r_offset); 1596 return TRUE; 1597 } 1598 1599 perform_relocation (r->howto, r->reloc, entry->value, r->input_section, 1600 input_bfd, r->contents); 1601 } 1602 1603 return TRUE; 1604 } 1605 1606 /* Relocate a RISC-V ELF section. 1607 1608 The RELOCATE_SECTION function is called by the new ELF backend linker 1609 to handle the relocations for a section. 1610 1611 The relocs are always passed as Rela structures. 1612 1613 This function is responsible for adjusting the section contents as 1614 necessary, and (if generating a relocatable output file) adjusting 1615 the reloc addend as necessary. 1616 1617 This function does not have to worry about setting the reloc 1618 address or the reloc symbol index. 1619 1620 LOCAL_SYMS is a pointer to the swapped in local symbols. 1621 1622 LOCAL_SECTIONS is an array giving the section in the input file 1623 corresponding to the st_shndx field of each local symbol. 1624 1625 The global hash table entry for the global symbols can be found 1626 via elf_sym_hashes (input_bfd). 1627 1628 When generating relocatable output, this function must handle 1629 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 1630 going to be the section symbol corresponding to the output 1631 section, which means that the addend must be adjusted 1632 accordingly. */ 1633 1634 static bfd_boolean 1635 riscv_elf_relocate_section (bfd *output_bfd, 1636 struct bfd_link_info *info, 1637 bfd *input_bfd, 1638 asection *input_section, 1639 bfd_byte *contents, 1640 Elf_Internal_Rela *relocs, 1641 Elf_Internal_Sym *local_syms, 1642 asection **local_sections) 1643 { 1644 Elf_Internal_Rela *rel; 1645 Elf_Internal_Rela *relend; 1646 riscv_pcrel_relocs pcrel_relocs; 1647 bfd_boolean ret = FALSE; 1648 asection *sreloc = elf_section_data (input_section)->sreloc; 1649 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 1650 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd); 1651 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 1652 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd); 1653 bfd_boolean absolute; 1654 1655 if (!riscv_init_pcrel_relocs (&pcrel_relocs)) 1656 return FALSE; 1657 1658 relend = relocs + input_section->reloc_count; 1659 for (rel = relocs; rel < relend; rel++) 1660 { 1661 unsigned long r_symndx; 1662 struct elf_link_hash_entry *h; 1663 Elf_Internal_Sym *sym; 1664 asection *sec; 1665 bfd_vma relocation; 1666 bfd_reloc_status_type r = bfd_reloc_ok; 1667 const char *name; 1668 bfd_vma off, ie_off; 1669 bfd_boolean unresolved_reloc, is_ie = FALSE; 1670 bfd_vma pc = sec_addr (input_section) + rel->r_offset; 1671 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type; 1672 reloc_howto_type *howto = riscv_elf_rtype_to_howto (input_bfd, r_type); 1673 const char *msg = NULL; 1674 char *msg_buf = NULL; 1675 bfd_boolean resolved_to_zero; 1676 1677 if (howto == NULL 1678 || r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY) 1679 continue; 1680 1681 /* This is a final link. */ 1682 r_symndx = ELFNN_R_SYM (rel->r_info); 1683 h = NULL; 1684 sym = NULL; 1685 sec = NULL; 1686 unresolved_reloc = FALSE; 1687 if (r_symndx < symtab_hdr->sh_info) 1688 { 1689 sym = local_syms + r_symndx; 1690 sec = local_sections[r_symndx]; 1691 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1692 } 1693 else 1694 { 1695 bfd_boolean warned, ignored; 1696 1697 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1698 r_symndx, symtab_hdr, sym_hashes, 1699 h, sec, relocation, 1700 unresolved_reloc, warned, ignored); 1701 if (warned) 1702 { 1703 /* To avoid generating warning messages about truncated 1704 relocations, set the relocation's address to be the same as 1705 the start of this section. */ 1706 if (input_section->output_section != NULL) 1707 relocation = input_section->output_section->vma; 1708 else 1709 relocation = 0; 1710 } 1711 } 1712 1713 if (sec != NULL && discarded_section (sec)) 1714 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 1715 rel, 1, relend, howto, 0, contents); 1716 1717 if (bfd_link_relocatable (info)) 1718 continue; 1719 1720 if (h != NULL) 1721 name = h->root.root.string; 1722 else 1723 { 1724 name = (bfd_elf_string_from_elf_section 1725 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 1726 if (name == NULL || *name == '\0') 1727 name = bfd_section_name (sec); 1728 } 1729 1730 resolved_to_zero = (h != NULL 1731 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)); 1732 1733 switch (r_type) 1734 { 1735 case R_RISCV_NONE: 1736 case R_RISCV_RELAX: 1737 case R_RISCV_TPREL_ADD: 1738 case R_RISCV_COPY: 1739 case R_RISCV_JUMP_SLOT: 1740 case R_RISCV_RELATIVE: 1741 /* These require nothing of us at all. */ 1742 continue; 1743 1744 case R_RISCV_HI20: 1745 case R_RISCV_BRANCH: 1746 case R_RISCV_RVC_BRANCH: 1747 case R_RISCV_RVC_LUI: 1748 case R_RISCV_LO12_I: 1749 case R_RISCV_LO12_S: 1750 case R_RISCV_SET6: 1751 case R_RISCV_SET8: 1752 case R_RISCV_SET16: 1753 case R_RISCV_SET32: 1754 case R_RISCV_32_PCREL: 1755 case R_RISCV_DELETE: 1756 /* These require no special handling beyond perform_relocation. */ 1757 break; 1758 1759 case R_RISCV_GOT_HI20: 1760 if (h != NULL) 1761 { 1762 bfd_boolean dyn, pic; 1763 1764 off = h->got.offset; 1765 BFD_ASSERT (off != (bfd_vma) -1); 1766 dyn = elf_hash_table (info)->dynamic_sections_created; 1767 pic = bfd_link_pic (info); 1768 1769 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h) 1770 || (pic && SYMBOL_REFERENCES_LOCAL (info, h))) 1771 { 1772 /* This is actually a static link, or it is a 1773 -Bsymbolic link and the symbol is defined 1774 locally, or the symbol was forced to be local 1775 because of a version file. We must initialize 1776 this entry in the global offset table. Since the 1777 offset must always be a multiple of the word size, 1778 we use the least significant bit to record whether 1779 we have initialized it already. 1780 1781 When doing a dynamic link, we create a .rela.got 1782 relocation entry to initialize the value. This 1783 is done in the finish_dynamic_symbol routine. */ 1784 if ((off & 1) != 0) 1785 off &= ~1; 1786 else 1787 { 1788 bfd_put_NN (output_bfd, relocation, 1789 htab->elf.sgot->contents + off); 1790 h->got.offset |= 1; 1791 } 1792 } 1793 else 1794 unresolved_reloc = FALSE; 1795 } 1796 else 1797 { 1798 BFD_ASSERT (local_got_offsets != NULL 1799 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1800 1801 off = local_got_offsets[r_symndx]; 1802 1803 /* The offset must always be a multiple of the word size. 1804 So, we can use the least significant bit to record 1805 whether we have already processed this entry. */ 1806 if ((off & 1) != 0) 1807 off &= ~1; 1808 else 1809 { 1810 if (bfd_link_pic (info)) 1811 { 1812 asection *s; 1813 Elf_Internal_Rela outrel; 1814 1815 /* We need to generate a R_RISCV_RELATIVE reloc 1816 for the dynamic linker. */ 1817 s = htab->elf.srelgot; 1818 BFD_ASSERT (s != NULL); 1819 1820 outrel.r_offset = sec_addr (htab->elf.sgot) + off; 1821 outrel.r_info = 1822 ELFNN_R_INFO (0, R_RISCV_RELATIVE); 1823 outrel.r_addend = relocation; 1824 relocation = 0; 1825 riscv_elf_append_rela (output_bfd, s, &outrel); 1826 } 1827 1828 bfd_put_NN (output_bfd, relocation, 1829 htab->elf.sgot->contents + off); 1830 local_got_offsets[r_symndx] |= 1; 1831 } 1832 } 1833 relocation = sec_addr (htab->elf.sgot) + off; 1834 absolute = riscv_zero_pcrel_hi_reloc (rel, 1835 info, 1836 pc, 1837 relocation, 1838 contents, 1839 howto, 1840 input_bfd); 1841 r_type = ELFNN_R_TYPE (rel->r_info); 1842 howto = riscv_elf_rtype_to_howto (input_bfd, r_type); 1843 if (howto == NULL) 1844 r = bfd_reloc_notsupported; 1845 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, 1846 relocation, absolute)) 1847 r = bfd_reloc_overflow; 1848 break; 1849 1850 case R_RISCV_ADD8: 1851 case R_RISCV_ADD16: 1852 case R_RISCV_ADD32: 1853 case R_RISCV_ADD64: 1854 { 1855 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd, 1856 contents + rel->r_offset); 1857 relocation = old_value + relocation; 1858 } 1859 break; 1860 1861 case R_RISCV_SUB6: 1862 case R_RISCV_SUB8: 1863 case R_RISCV_SUB16: 1864 case R_RISCV_SUB32: 1865 case R_RISCV_SUB64: 1866 { 1867 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd, 1868 contents + rel->r_offset); 1869 relocation = old_value - relocation; 1870 } 1871 break; 1872 1873 case R_RISCV_CALL: 1874 case R_RISCV_CALL_PLT: 1875 /* Handle a call to an undefined weak function. This won't be 1876 relaxed, so we have to handle it here. */ 1877 if (h != NULL && h->root.type == bfd_link_hash_undefweak 1878 && (!bfd_link_pic (info) || h->plt.offset == MINUS_ONE)) 1879 { 1880 /* We can use x0 as the base register. */ 1881 bfd_vma insn = bfd_get_32 (input_bfd, 1882 contents + rel->r_offset + 4); 1883 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 1884 bfd_put_32 (input_bfd, insn, contents + rel->r_offset + 4); 1885 /* Set the relocation value so that we get 0 after the pc 1886 relative adjustment. */ 1887 relocation = sec_addr (input_section) + rel->r_offset; 1888 } 1889 /* Fall through. */ 1890 1891 case R_RISCV_JAL: 1892 case R_RISCV_RVC_JUMP: 1893 /* This line has to match the check in _bfd_riscv_relax_section. */ 1894 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE) 1895 { 1896 /* Refer to the PLT entry. */ 1897 relocation = sec_addr (htab->elf.splt) + h->plt.offset; 1898 unresolved_reloc = FALSE; 1899 } 1900 break; 1901 1902 case R_RISCV_TPREL_HI20: 1903 relocation = tpoff (info, relocation); 1904 break; 1905 1906 case R_RISCV_TPREL_LO12_I: 1907 case R_RISCV_TPREL_LO12_S: 1908 relocation = tpoff (info, relocation); 1909 break; 1910 1911 case R_RISCV_TPREL_I: 1912 case R_RISCV_TPREL_S: 1913 relocation = tpoff (info, relocation); 1914 if (VALID_ITYPE_IMM (relocation + rel->r_addend)) 1915 { 1916 /* We can use tp as the base register. */ 1917 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 1918 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 1919 insn |= X_TP << OP_SH_RS1; 1920 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 1921 } 1922 else 1923 r = bfd_reloc_overflow; 1924 break; 1925 1926 case R_RISCV_GPREL_I: 1927 case R_RISCV_GPREL_S: 1928 { 1929 bfd_vma gp = riscv_global_pointer_value (info); 1930 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend); 1931 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp)) 1932 { 1933 /* We can use x0 or gp as the base register. */ 1934 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 1935 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 1936 if (!x0_base) 1937 { 1938 rel->r_addend -= gp; 1939 insn |= X_GP << OP_SH_RS1; 1940 } 1941 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 1942 } 1943 else 1944 r = bfd_reloc_overflow; 1945 break; 1946 } 1947 1948 case R_RISCV_PCREL_HI20: 1949 absolute = riscv_zero_pcrel_hi_reloc (rel, 1950 info, 1951 pc, 1952 relocation, 1953 contents, 1954 howto, 1955 input_bfd); 1956 r_type = ELFNN_R_TYPE (rel->r_info); 1957 howto = riscv_elf_rtype_to_howto (input_bfd, r_type); 1958 if (howto == NULL) 1959 r = bfd_reloc_notsupported; 1960 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, 1961 relocation + rel->r_addend, 1962 absolute)) 1963 r = bfd_reloc_overflow; 1964 break; 1965 1966 case R_RISCV_PCREL_LO12_I: 1967 case R_RISCV_PCREL_LO12_S: 1968 /* We don't allow section symbols plus addends as the auipc address, 1969 because then riscv_relax_delete_bytes would have to search through 1970 all relocs to update these addends. This is also ambiguous, as 1971 we do allow offsets to be added to the target address, which are 1972 not to be used to find the auipc address. */ 1973 if (((sym != NULL && (ELF_ST_TYPE (sym->st_info) == STT_SECTION)) 1974 || (h != NULL && h->type == STT_SECTION)) 1975 && rel->r_addend) 1976 { 1977 msg = _("%pcrel_lo section symbol with an addend"); 1978 r = bfd_reloc_dangerous; 1979 break; 1980 } 1981 1982 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info, 1983 howto, rel, relocation, name, 1984 contents)) 1985 continue; 1986 r = bfd_reloc_overflow; 1987 break; 1988 1989 case R_RISCV_TLS_DTPREL32: 1990 case R_RISCV_TLS_DTPREL64: 1991 relocation = dtpoff (info, relocation); 1992 break; 1993 1994 case R_RISCV_32: 1995 case R_RISCV_64: 1996 if ((input_section->flags & SEC_ALLOC) == 0) 1997 break; 1998 1999 if ((bfd_link_pic (info) 2000 && (h == NULL 2001 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2002 && !resolved_to_zero) 2003 || h->root.type != bfd_link_hash_undefweak) 2004 && (! howto->pc_relative 2005 || !SYMBOL_CALLS_LOCAL (info, h))) 2006 || (!bfd_link_pic (info) 2007 && h != NULL 2008 && h->dynindx != -1 2009 && !h->non_got_ref 2010 && ((h->def_dynamic 2011 && !h->def_regular) 2012 || h->root.type == bfd_link_hash_undefweak 2013 || h->root.type == bfd_link_hash_undefined))) 2014 { 2015 Elf_Internal_Rela outrel; 2016 bfd_boolean skip_static_relocation, skip_dynamic_relocation; 2017 2018 /* When generating a shared object, these relocations 2019 are copied into the output file to be resolved at run 2020 time. */ 2021 2022 outrel.r_offset = 2023 _bfd_elf_section_offset (output_bfd, info, input_section, 2024 rel->r_offset); 2025 skip_static_relocation = outrel.r_offset != (bfd_vma) -2; 2026 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2; 2027 outrel.r_offset += sec_addr (input_section); 2028 2029 if (skip_dynamic_relocation) 2030 memset (&outrel, 0, sizeof outrel); 2031 else if (h != NULL && h->dynindx != -1 2032 && !(bfd_link_pic (info) 2033 && SYMBOLIC_BIND (info, h) 2034 && h->def_regular)) 2035 { 2036 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type); 2037 outrel.r_addend = rel->r_addend; 2038 } 2039 else 2040 { 2041 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE); 2042 outrel.r_addend = relocation + rel->r_addend; 2043 } 2044 2045 riscv_elf_append_rela (output_bfd, sreloc, &outrel); 2046 if (skip_static_relocation) 2047 continue; 2048 } 2049 break; 2050 2051 case R_RISCV_TLS_GOT_HI20: 2052 is_ie = TRUE; 2053 /* Fall through. */ 2054 2055 case R_RISCV_TLS_GD_HI20: 2056 if (h != NULL) 2057 { 2058 off = h->got.offset; 2059 h->got.offset |= 1; 2060 } 2061 else 2062 { 2063 off = local_got_offsets[r_symndx]; 2064 local_got_offsets[r_symndx] |= 1; 2065 } 2066 2067 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx); 2068 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD)); 2069 /* If this symbol is referenced by both GD and IE TLS, the IE 2070 reference's GOT slot follows the GD reference's slots. */ 2071 ie_off = 0; 2072 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE)) 2073 ie_off = 2 * GOT_ENTRY_SIZE; 2074 2075 if ((off & 1) != 0) 2076 off &= ~1; 2077 else 2078 { 2079 Elf_Internal_Rela outrel; 2080 int indx = 0; 2081 bfd_boolean need_relocs = FALSE; 2082 2083 if (htab->elf.srelgot == NULL) 2084 abort (); 2085 2086 if (h != NULL) 2087 { 2088 bfd_boolean dyn, pic; 2089 dyn = htab->elf.dynamic_sections_created; 2090 pic = bfd_link_pic (info); 2091 2092 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h) 2093 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h))) 2094 indx = h->dynindx; 2095 } 2096 2097 /* The GOT entries have not been initialized yet. Do it 2098 now, and emit any relocations. */ 2099 if ((bfd_link_pic (info) || indx != 0) 2100 && (h == NULL 2101 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2102 || h->root.type != bfd_link_hash_undefweak)) 2103 need_relocs = TRUE; 2104 2105 if (tls_type & GOT_TLS_GD) 2106 { 2107 if (need_relocs) 2108 { 2109 outrel.r_offset = sec_addr (htab->elf.sgot) + off; 2110 outrel.r_addend = 0; 2111 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN); 2112 bfd_put_NN (output_bfd, 0, 2113 htab->elf.sgot->contents + off); 2114 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 2115 if (indx == 0) 2116 { 2117 BFD_ASSERT (! unresolved_reloc); 2118 bfd_put_NN (output_bfd, 2119 dtpoff (info, relocation), 2120 (htab->elf.sgot->contents + off + 2121 RISCV_ELF_WORD_BYTES)); 2122 } 2123 else 2124 { 2125 bfd_put_NN (output_bfd, 0, 2126 (htab->elf.sgot->contents + off + 2127 RISCV_ELF_WORD_BYTES)); 2128 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN); 2129 outrel.r_offset += RISCV_ELF_WORD_BYTES; 2130 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 2131 } 2132 } 2133 else 2134 { 2135 /* If we are not emitting relocations for a 2136 general dynamic reference, then we must be in a 2137 static link or an executable link with the 2138 symbol binding locally. Mark it as belonging 2139 to module 1, the executable. */ 2140 bfd_put_NN (output_bfd, 1, 2141 htab->elf.sgot->contents + off); 2142 bfd_put_NN (output_bfd, 2143 dtpoff (info, relocation), 2144 (htab->elf.sgot->contents + off + 2145 RISCV_ELF_WORD_BYTES)); 2146 } 2147 } 2148 2149 if (tls_type & GOT_TLS_IE) 2150 { 2151 if (need_relocs) 2152 { 2153 bfd_put_NN (output_bfd, 0, 2154 htab->elf.sgot->contents + off + ie_off); 2155 outrel.r_offset = sec_addr (htab->elf.sgot) 2156 + off + ie_off; 2157 outrel.r_addend = 0; 2158 if (indx == 0) 2159 outrel.r_addend = tpoff (info, relocation); 2160 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN); 2161 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 2162 } 2163 else 2164 { 2165 bfd_put_NN (output_bfd, tpoff (info, relocation), 2166 htab->elf.sgot->contents + off + ie_off); 2167 } 2168 } 2169 } 2170 2171 BFD_ASSERT (off < (bfd_vma) -2); 2172 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0); 2173 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, 2174 relocation, FALSE)) 2175 r = bfd_reloc_overflow; 2176 unresolved_reloc = FALSE; 2177 break; 2178 2179 default: 2180 r = bfd_reloc_notsupported; 2181 } 2182 2183 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 2184 because such sections are not SEC_ALLOC and thus ld.so will 2185 not process them. */ 2186 if (unresolved_reloc 2187 && !((input_section->flags & SEC_DEBUGGING) != 0 2188 && h->def_dynamic) 2189 && _bfd_elf_section_offset (output_bfd, info, input_section, 2190 rel->r_offset) != (bfd_vma) -1) 2191 { 2192 switch (r_type) 2193 { 2194 case R_RISCV_JAL: 2195 case R_RISCV_RVC_JUMP: 2196 if (asprintf (&msg_buf, 2197 _("%%X%%P: relocation %s against `%s' can " 2198 "not be used when making a shared object; " 2199 "recompile with -fPIC\n"), 2200 howto->name, 2201 h->root.root.string) == -1) 2202 msg_buf = NULL; 2203 break; 2204 2205 default: 2206 if (asprintf (&msg_buf, 2207 _("%%X%%P: unresolvable %s relocation against " 2208 "symbol `%s'\n"), 2209 howto->name, 2210 h->root.root.string) == -1) 2211 msg_buf = NULL; 2212 break; 2213 } 2214 2215 msg = msg_buf; 2216 r = bfd_reloc_notsupported; 2217 } 2218 2219 if (r == bfd_reloc_ok) 2220 r = perform_relocation (howto, rel, relocation, input_section, 2221 input_bfd, contents); 2222 2223 /* We should have already detected the error and set message before. 2224 If the error message isn't set since the linker runs out of memory 2225 or we don't set it before, then we should set the default message 2226 with the "internal error" string here. */ 2227 switch (r) 2228 { 2229 case bfd_reloc_ok: 2230 continue; 2231 2232 case bfd_reloc_overflow: 2233 info->callbacks->reloc_overflow 2234 (info, (h ? &h->root : NULL), name, howto->name, 2235 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 2236 break; 2237 2238 case bfd_reloc_undefined: 2239 info->callbacks->undefined_symbol 2240 (info, name, input_bfd, input_section, rel->r_offset, 2241 TRUE); 2242 break; 2243 2244 case bfd_reloc_outofrange: 2245 if (msg == NULL) 2246 msg = _("%X%P: internal error: out of range error\n"); 2247 break; 2248 2249 case bfd_reloc_notsupported: 2250 if (msg == NULL) 2251 msg = _("%X%P: internal error: unsupported relocation error\n"); 2252 break; 2253 2254 case bfd_reloc_dangerous: 2255 /* The error message should already be set. */ 2256 if (msg == NULL) 2257 msg = _("dangerous relocation error"); 2258 info->callbacks->reloc_dangerous 2259 (info, msg, input_bfd, input_section, rel->r_offset); 2260 break; 2261 2262 default: 2263 msg = _("%X%P: internal error: unknown error\n"); 2264 break; 2265 } 2266 2267 /* Do not report error message for the dangerous relocation again. */ 2268 if (msg && r != bfd_reloc_dangerous) 2269 info->callbacks->einfo (msg); 2270 2271 /* Free the unused `msg_buf`. */ 2272 free (msg_buf); 2273 2274 /* We already reported the error via a callback, so don't try to report 2275 it again by returning false. That leads to spurious errors. */ 2276 ret = TRUE; 2277 goto out; 2278 } 2279 2280 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs); 2281 out: 2282 riscv_free_pcrel_relocs (&pcrel_relocs); 2283 return ret; 2284 } 2285 2286 /* Finish up dynamic symbol handling. We set the contents of various 2287 dynamic sections here. */ 2288 2289 static bfd_boolean 2290 riscv_elf_finish_dynamic_symbol (bfd *output_bfd, 2291 struct bfd_link_info *info, 2292 struct elf_link_hash_entry *h, 2293 Elf_Internal_Sym *sym) 2294 { 2295 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 2296 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 2297 2298 if (h->plt.offset != (bfd_vma) -1) 2299 { 2300 /* We've decided to create a PLT entry for this symbol. */ 2301 bfd_byte *loc; 2302 bfd_vma i, header_address, plt_idx, got_address; 2303 uint32_t plt_entry[PLT_ENTRY_INSNS]; 2304 Elf_Internal_Rela rela; 2305 2306 BFD_ASSERT (h->dynindx != -1); 2307 2308 /* Calculate the address of the PLT header. */ 2309 header_address = sec_addr (htab->elf.splt); 2310 2311 /* Calculate the index of the entry. */ 2312 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE; 2313 2314 /* Calculate the address of the .got.plt entry. */ 2315 got_address = riscv_elf_got_plt_val (plt_idx, info); 2316 2317 /* Find out where the .plt entry should go. */ 2318 loc = htab->elf.splt->contents + h->plt.offset; 2319 2320 /* Fill in the PLT entry itself. */ 2321 if (! riscv_make_plt_entry (output_bfd, got_address, 2322 header_address + h->plt.offset, 2323 plt_entry)) 2324 return FALSE; 2325 2326 for (i = 0; i < PLT_ENTRY_INSNS; i++) 2327 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i); 2328 2329 /* Fill in the initial value of the .got.plt entry. */ 2330 loc = htab->elf.sgotplt->contents 2331 + (got_address - sec_addr (htab->elf.sgotplt)); 2332 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc); 2333 2334 /* Fill in the entry in the .rela.plt section. */ 2335 rela.r_offset = got_address; 2336 rela.r_addend = 0; 2337 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT); 2338 2339 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela); 2340 bed->s->swap_reloca_out (output_bfd, &rela, loc); 2341 2342 if (!h->def_regular) 2343 { 2344 /* Mark the symbol as undefined, rather than as defined in 2345 the .plt section. Leave the value alone. */ 2346 sym->st_shndx = SHN_UNDEF; 2347 /* If the symbol is weak, we do need to clear the value. 2348 Otherwise, the PLT entry would provide a definition for 2349 the symbol even if the symbol wasn't defined anywhere, 2350 and so the symbol would never be NULL. */ 2351 if (!h->ref_regular_nonweak) 2352 sym->st_value = 0; 2353 } 2354 } 2355 2356 if (h->got.offset != (bfd_vma) -1 2357 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) 2358 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) 2359 { 2360 asection *sgot; 2361 asection *srela; 2362 Elf_Internal_Rela rela; 2363 2364 /* This symbol has an entry in the GOT. Set it up. */ 2365 2366 sgot = htab->elf.sgot; 2367 srela = htab->elf.srelgot; 2368 BFD_ASSERT (sgot != NULL && srela != NULL); 2369 2370 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1); 2371 2372 /* If this is a local symbol reference, we just want to emit a RELATIVE 2373 reloc. This can happen if it is a -Bsymbolic link, or a pie link, or 2374 the symbol was forced to be local because of a version file. 2375 The entry in the global offset table will already have been 2376 initialized in the relocate_section function. */ 2377 if (bfd_link_pic (info) 2378 && SYMBOL_REFERENCES_LOCAL (info, h)) 2379 { 2380 BFD_ASSERT((h->got.offset & 1) != 0); 2381 asection *sec = h->root.u.def.section; 2382 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE); 2383 rela.r_addend = (h->root.u.def.value 2384 + sec->output_section->vma 2385 + sec->output_offset); 2386 } 2387 else 2388 { 2389 BFD_ASSERT((h->got.offset & 1) == 0); 2390 BFD_ASSERT (h->dynindx != -1); 2391 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN); 2392 rela.r_addend = 0; 2393 } 2394 2395 bfd_put_NN (output_bfd, 0, 2396 sgot->contents + (h->got.offset & ~(bfd_vma) 1)); 2397 riscv_elf_append_rela (output_bfd, srela, &rela); 2398 } 2399 2400 if (h->needs_copy) 2401 { 2402 Elf_Internal_Rela rela; 2403 asection *s; 2404 2405 /* This symbols needs a copy reloc. Set it up. */ 2406 BFD_ASSERT (h->dynindx != -1); 2407 2408 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value; 2409 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY); 2410 rela.r_addend = 0; 2411 if (h->root.u.def.section == htab->elf.sdynrelro) 2412 s = htab->elf.sreldynrelro; 2413 else 2414 s = htab->elf.srelbss; 2415 riscv_elf_append_rela (output_bfd, s, &rela); 2416 } 2417 2418 /* Mark some specially defined symbols as absolute. */ 2419 if (h == htab->elf.hdynamic 2420 || (h == htab->elf.hgot || h == htab->elf.hplt)) 2421 sym->st_shndx = SHN_ABS; 2422 2423 return TRUE; 2424 } 2425 2426 /* Finish up the dynamic sections. */ 2427 2428 static bfd_boolean 2429 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info, 2430 bfd *dynobj, asection *sdyn) 2431 { 2432 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 2433 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 2434 size_t dynsize = bed->s->sizeof_dyn; 2435 bfd_byte *dyncon, *dynconend; 2436 2437 dynconend = sdyn->contents + sdyn->size; 2438 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize) 2439 { 2440 Elf_Internal_Dyn dyn; 2441 asection *s; 2442 2443 bed->s->swap_dyn_in (dynobj, dyncon, &dyn); 2444 2445 switch (dyn.d_tag) 2446 { 2447 case DT_PLTGOT: 2448 s = htab->elf.sgotplt; 2449 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2450 break; 2451 case DT_JMPREL: 2452 s = htab->elf.srelplt; 2453 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2454 break; 2455 case DT_PLTRELSZ: 2456 s = htab->elf.srelplt; 2457 dyn.d_un.d_val = s->size; 2458 break; 2459 default: 2460 continue; 2461 } 2462 2463 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon); 2464 } 2465 return TRUE; 2466 } 2467 2468 static bfd_boolean 2469 riscv_elf_finish_dynamic_sections (bfd *output_bfd, 2470 struct bfd_link_info *info) 2471 { 2472 bfd *dynobj; 2473 asection *sdyn; 2474 struct riscv_elf_link_hash_table *htab; 2475 2476 htab = riscv_elf_hash_table (info); 2477 BFD_ASSERT (htab != NULL); 2478 dynobj = htab->elf.dynobj; 2479 2480 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 2481 2482 if (elf_hash_table (info)->dynamic_sections_created) 2483 { 2484 asection *splt; 2485 bfd_boolean ret; 2486 2487 splt = htab->elf.splt; 2488 BFD_ASSERT (splt != NULL && sdyn != NULL); 2489 2490 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn); 2491 2492 if (!ret) 2493 return ret; 2494 2495 /* Fill in the head and tail entries in the procedure linkage table. */ 2496 if (splt->size > 0) 2497 { 2498 int i; 2499 uint32_t plt_header[PLT_HEADER_INSNS]; 2500 ret = riscv_make_plt_header (output_bfd, 2501 sec_addr (htab->elf.sgotplt), 2502 sec_addr (splt), plt_header); 2503 if (!ret) 2504 return ret; 2505 2506 for (i = 0; i < PLT_HEADER_INSNS; i++) 2507 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i); 2508 2509 elf_section_data (splt->output_section)->this_hdr.sh_entsize 2510 = PLT_ENTRY_SIZE; 2511 } 2512 } 2513 2514 if (htab->elf.sgotplt) 2515 { 2516 asection *output_section = htab->elf.sgotplt->output_section; 2517 2518 if (bfd_is_abs_section (output_section)) 2519 { 2520 (*_bfd_error_handler) 2521 (_("discarded output section: `%pA'"), htab->elf.sgotplt); 2522 return FALSE; 2523 } 2524 2525 if (htab->elf.sgotplt->size > 0) 2526 { 2527 /* Write the first two entries in .got.plt, needed for the dynamic 2528 linker. */ 2529 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents); 2530 bfd_put_NN (output_bfd, (bfd_vma) 0, 2531 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE); 2532 } 2533 2534 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE; 2535 } 2536 2537 if (htab->elf.sgot) 2538 { 2539 asection *output_section = htab->elf.sgot->output_section; 2540 2541 if (htab->elf.sgot->size > 0) 2542 { 2543 /* Set the first entry in the global offset table to the address of 2544 the dynamic section. */ 2545 bfd_vma val = sdyn ? sec_addr (sdyn) : 0; 2546 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents); 2547 } 2548 2549 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE; 2550 } 2551 2552 return TRUE; 2553 } 2554 2555 /* Return address for Ith PLT stub in section PLT, for relocation REL 2556 or (bfd_vma) -1 if it should not be included. */ 2557 2558 static bfd_vma 2559 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt, 2560 const arelent *rel ATTRIBUTE_UNUSED) 2561 { 2562 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE; 2563 } 2564 2565 static enum elf_reloc_type_class 2566 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 2567 const asection *rel_sec ATTRIBUTE_UNUSED, 2568 const Elf_Internal_Rela *rela) 2569 { 2570 switch (ELFNN_R_TYPE (rela->r_info)) 2571 { 2572 case R_RISCV_RELATIVE: 2573 return reloc_class_relative; 2574 case R_RISCV_JUMP_SLOT: 2575 return reloc_class_plt; 2576 case R_RISCV_COPY: 2577 return reloc_class_copy; 2578 default: 2579 return reloc_class_normal; 2580 } 2581 } 2582 2583 /* Given the ELF header flags in FLAGS, it returns a string that describes the 2584 float ABI. */ 2585 2586 static const char * 2587 riscv_float_abi_string (flagword flags) 2588 { 2589 switch (flags & EF_RISCV_FLOAT_ABI) 2590 { 2591 case EF_RISCV_FLOAT_ABI_SOFT: 2592 return "soft-float"; 2593 break; 2594 case EF_RISCV_FLOAT_ABI_SINGLE: 2595 return "single-float"; 2596 break; 2597 case EF_RISCV_FLOAT_ABI_DOUBLE: 2598 return "double-float"; 2599 break; 2600 case EF_RISCV_FLOAT_ABI_QUAD: 2601 return "quad-float"; 2602 break; 2603 default: 2604 abort (); 2605 } 2606 } 2607 2608 /* The information of architecture attribute. */ 2609 static riscv_subset_list_t in_subsets; 2610 static riscv_subset_list_t out_subsets; 2611 static riscv_subset_list_t merged_subsets; 2612 2613 /* Predicator for standard extension. */ 2614 2615 static bfd_boolean 2616 riscv_std_ext_p (const char *name) 2617 { 2618 return (strlen (name) == 1) && (name[0] != 'x') && (name[0] != 's'); 2619 } 2620 2621 /* Check if the versions are compatible. */ 2622 2623 static bfd_boolean 2624 riscv_version_mismatch (bfd *ibfd, 2625 struct riscv_subset_t *in, 2626 struct riscv_subset_t *out) 2627 { 2628 if (in == NULL || out == NULL) 2629 return TRUE; 2630 2631 /* Since there are no version conflicts for now, we just report 2632 warning when the versions are mis-matched. */ 2633 if (in->major_version != out->major_version 2634 || in->minor_version != out->minor_version) 2635 { 2636 _bfd_error_handler 2637 (_("warning: %pB: mis-matched ISA version %d.%d for '%s' " 2638 "extension, the output version is %d.%d"), 2639 ibfd, 2640 in->major_version, 2641 in->minor_version, 2642 in->name, 2643 out->major_version, 2644 out->minor_version); 2645 2646 /* Update the output ISA versions to the newest ones. */ 2647 if ((in->major_version > out->major_version) 2648 || (in->major_version == out->major_version 2649 && in->minor_version > out->minor_version)) 2650 { 2651 out->major_version = in->major_version; 2652 out->minor_version = in->minor_version; 2653 } 2654 } 2655 2656 return TRUE; 2657 } 2658 2659 /* Return true if subset is 'i' or 'e'. */ 2660 2661 static bfd_boolean 2662 riscv_i_or_e_p (bfd *ibfd, 2663 const char *arch, 2664 struct riscv_subset_t *subset) 2665 { 2666 if ((strcasecmp (subset->name, "e") != 0) 2667 && (strcasecmp (subset->name, "i") != 0)) 2668 { 2669 _bfd_error_handler 2670 (_("error: %pB: corrupted ISA string '%s'. " 2671 "First letter should be 'i' or 'e' but got '%s'"), 2672 ibfd, arch, subset->name); 2673 return FALSE; 2674 } 2675 return TRUE; 2676 } 2677 2678 /* Merge standard extensions. 2679 2680 Return Value: 2681 Return FALSE if failed to merge. 2682 2683 Arguments: 2684 `bfd`: bfd handler. 2685 `in_arch`: Raw arch string for input object. 2686 `out_arch`: Raw arch string for output object. 2687 `pin`: subset list for input object, and it'll skip all merged subset after 2688 merge. 2689 `pout`: Like `pin`, but for output object. */ 2690 2691 static bfd_boolean 2692 riscv_merge_std_ext (bfd *ibfd, 2693 const char *in_arch, 2694 const char *out_arch, 2695 struct riscv_subset_t **pin, 2696 struct riscv_subset_t **pout) 2697 { 2698 const char *standard_exts = riscv_supported_std_ext (); 2699 const char *p; 2700 struct riscv_subset_t *in = *pin; 2701 struct riscv_subset_t *out = *pout; 2702 2703 /* First letter should be 'i' or 'e'. */ 2704 if (!riscv_i_or_e_p (ibfd, in_arch, in)) 2705 return FALSE; 2706 2707 if (!riscv_i_or_e_p (ibfd, out_arch, out)) 2708 return FALSE; 2709 2710 if (strcasecmp (in->name, out->name) != 0) 2711 { 2712 /* TODO: We might allow merge 'i' with 'e'. */ 2713 _bfd_error_handler 2714 (_("error: %pB: mis-matched ISA string to merge '%s' and '%s'"), 2715 ibfd, in->name, out->name); 2716 return FALSE; 2717 } 2718 else if (!riscv_version_mismatch (ibfd, in, out)) 2719 return FALSE; 2720 else 2721 riscv_add_subset (&merged_subsets, 2722 out->name, out->major_version, out->minor_version); 2723 2724 in = in->next; 2725 out = out->next; 2726 2727 /* Handle standard extension first. */ 2728 for (p = standard_exts; *p; ++p) 2729 { 2730 char find_ext[2] = {*p, '\0'}; 2731 struct riscv_subset_t *find_in = 2732 riscv_lookup_subset (&in_subsets, find_ext); 2733 struct riscv_subset_t *find_out = 2734 riscv_lookup_subset (&out_subsets, find_ext); 2735 2736 if (find_in == NULL && find_out == NULL) 2737 continue; 2738 2739 if (!riscv_version_mismatch (ibfd, find_in, find_out)) 2740 return FALSE; 2741 2742 struct riscv_subset_t *merged = find_out ? find_out : find_in; 2743 riscv_add_subset (&merged_subsets, merged->name, 2744 merged->major_version, merged->minor_version); 2745 } 2746 2747 /* Skip all standard extensions. */ 2748 while ((in != NULL) && riscv_std_ext_p (in->name)) in = in->next; 2749 while ((out != NULL) && riscv_std_ext_p (out->name)) out = out->next; 2750 2751 *pin = in; 2752 *pout = out; 2753 2754 return TRUE; 2755 } 2756 2757 /* If C is a prefix class, then return the EXT string without the prefix. 2758 Otherwise return the entire EXT string. */ 2759 2760 static const char * 2761 riscv_skip_prefix (const char *ext, riscv_isa_ext_class_t c) 2762 { 2763 switch (c) 2764 { 2765 case RV_ISA_CLASS_X: return &ext[1]; 2766 case RV_ISA_CLASS_S: return &ext[1]; 2767 case RV_ISA_CLASS_Z: return &ext[1]; 2768 default: return ext; 2769 } 2770 } 2771 2772 /* Compare prefixed extension names canonically. */ 2773 2774 static int 2775 riscv_prefix_cmp (const char *a, const char *b) 2776 { 2777 riscv_isa_ext_class_t ca = riscv_get_prefix_class (a); 2778 riscv_isa_ext_class_t cb = riscv_get_prefix_class (b); 2779 2780 /* Extension name without prefix */ 2781 const char *anp = riscv_skip_prefix (a, ca); 2782 const char *bnp = riscv_skip_prefix (b, cb); 2783 2784 if (ca == cb) 2785 return strcasecmp (anp, bnp); 2786 2787 return (int)ca - (int)cb; 2788 } 2789 2790 /* Merge multi letter extensions. PIN is a pointer to the head of the input 2791 object subset list. Likewise for POUT and the output object. Return TRUE 2792 on success and FALSE when a conflict is found. */ 2793 2794 static bfd_boolean 2795 riscv_merge_multi_letter_ext (bfd *ibfd, 2796 riscv_subset_t **pin, 2797 riscv_subset_t **pout) 2798 { 2799 riscv_subset_t *in = *pin; 2800 riscv_subset_t *out = *pout; 2801 riscv_subset_t *tail; 2802 2803 int cmp; 2804 2805 while (in && out) 2806 { 2807 cmp = riscv_prefix_cmp (in->name, out->name); 2808 2809 if (cmp < 0) 2810 { 2811 /* `in' comes before `out', append `in' and increment. */ 2812 riscv_add_subset (&merged_subsets, in->name, in->major_version, 2813 in->minor_version); 2814 in = in->next; 2815 } 2816 else if (cmp > 0) 2817 { 2818 /* `out' comes before `in', append `out' and increment. */ 2819 riscv_add_subset (&merged_subsets, out->name, out->major_version, 2820 out->minor_version); 2821 out = out->next; 2822 } 2823 else 2824 { 2825 /* Both present, check version and increment both. */ 2826 if (!riscv_version_mismatch (ibfd, in, out)) 2827 return FALSE; 2828 2829 riscv_add_subset (&merged_subsets, out->name, out->major_version, 2830 out->minor_version); 2831 out = out->next; 2832 in = in->next; 2833 } 2834 } 2835 2836 if (in || out) { 2837 /* If we're here, either `in' or `out' is running longer than 2838 the other. So, we need to append the corresponding tail. */ 2839 tail = in ? in : out; 2840 2841 while (tail) 2842 { 2843 riscv_add_subset (&merged_subsets, tail->name, tail->major_version, 2844 tail->minor_version); 2845 tail = tail->next; 2846 } 2847 } 2848 2849 return TRUE; 2850 } 2851 2852 /* Merge Tag_RISCV_arch attribute. */ 2853 2854 static char * 2855 riscv_merge_arch_attr_info (bfd *ibfd, char *in_arch, char *out_arch) 2856 { 2857 riscv_subset_t *in, *out; 2858 char *merged_arch_str; 2859 2860 unsigned xlen_in, xlen_out; 2861 merged_subsets.head = NULL; 2862 merged_subsets.tail = NULL; 2863 2864 riscv_parse_subset_t rpe_in; 2865 riscv_parse_subset_t rpe_out; 2866 2867 /* Only assembler needs to check the default version of ISA, so just set 2868 the rpe_in.get_default_version and rpe_out.get_default_version to NULL. */ 2869 rpe_in.subset_list = &in_subsets; 2870 rpe_in.error_handler = _bfd_error_handler; 2871 rpe_in.xlen = &xlen_in; 2872 rpe_in.get_default_version = NULL; 2873 2874 rpe_out.subset_list = &out_subsets; 2875 rpe_out.error_handler = _bfd_error_handler; 2876 rpe_out.xlen = &xlen_out; 2877 rpe_out.get_default_version = NULL; 2878 2879 if (in_arch == NULL && out_arch == NULL) 2880 return NULL; 2881 2882 if (in_arch == NULL && out_arch != NULL) 2883 return out_arch; 2884 2885 if (in_arch != NULL && out_arch == NULL) 2886 return in_arch; 2887 2888 /* Parse subset from arch string. */ 2889 if (!riscv_parse_subset (&rpe_in, in_arch)) 2890 return NULL; 2891 2892 if (!riscv_parse_subset (&rpe_out, out_arch)) 2893 return NULL; 2894 2895 /* Checking XLEN. */ 2896 if (xlen_out != xlen_in) 2897 { 2898 _bfd_error_handler 2899 (_("error: %pB: ISA string of input (%s) doesn't match " 2900 "output (%s)"), ibfd, in_arch, out_arch); 2901 return NULL; 2902 } 2903 2904 /* Merge subset list. */ 2905 in = in_subsets.head; 2906 out = out_subsets.head; 2907 2908 /* Merge standard extension. */ 2909 if (!riscv_merge_std_ext (ibfd, in_arch, out_arch, &in, &out)) 2910 return NULL; 2911 2912 /* Merge all non-single letter extensions with single call. */ 2913 if (!riscv_merge_multi_letter_ext (ibfd, &in, &out)) 2914 return NULL; 2915 2916 if (xlen_in != xlen_out) 2917 { 2918 _bfd_error_handler 2919 (_("error: %pB: XLEN of input (%u) doesn't match " 2920 "output (%u)"), ibfd, xlen_in, xlen_out); 2921 return NULL; 2922 } 2923 2924 if (xlen_in != ARCH_SIZE) 2925 { 2926 _bfd_error_handler 2927 (_("error: %pB: unsupported XLEN (%u), you might be " 2928 "using wrong emulation"), ibfd, xlen_in); 2929 return NULL; 2930 } 2931 2932 merged_arch_str = riscv_arch_str (ARCH_SIZE, &merged_subsets); 2933 2934 /* Release the subset lists. */ 2935 riscv_release_subset_list (&in_subsets); 2936 riscv_release_subset_list (&out_subsets); 2937 riscv_release_subset_list (&merged_subsets); 2938 2939 return merged_arch_str; 2940 } 2941 2942 /* Merge object attributes from IBFD into output_bfd of INFO. 2943 Raise an error if there are conflicting attributes. */ 2944 2945 static bfd_boolean 2946 riscv_merge_attributes (bfd *ibfd, struct bfd_link_info *info) 2947 { 2948 bfd *obfd = info->output_bfd; 2949 obj_attribute *in_attr; 2950 obj_attribute *out_attr; 2951 bfd_boolean result = TRUE; 2952 bfd_boolean priv_attrs_merged = FALSE; 2953 const char *sec_name = get_elf_backend_data (ibfd)->obj_attrs_section; 2954 unsigned int i; 2955 2956 /* Skip linker created files. */ 2957 if (ibfd->flags & BFD_LINKER_CREATED) 2958 return TRUE; 2959 2960 /* Skip any input that doesn't have an attribute section. 2961 This enables to link object files without attribute section with 2962 any others. */ 2963 if (bfd_get_section_by_name (ibfd, sec_name) == NULL) 2964 return TRUE; 2965 2966 if (!elf_known_obj_attributes_proc (obfd)[0].i) 2967 { 2968 /* This is the first object. Copy the attributes. */ 2969 _bfd_elf_copy_obj_attributes (ibfd, obfd); 2970 2971 out_attr = elf_known_obj_attributes_proc (obfd); 2972 2973 /* Use the Tag_null value to indicate the attributes have been 2974 initialized. */ 2975 out_attr[0].i = 1; 2976 2977 return TRUE; 2978 } 2979 2980 in_attr = elf_known_obj_attributes_proc (ibfd); 2981 out_attr = elf_known_obj_attributes_proc (obfd); 2982 2983 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) 2984 { 2985 switch (i) 2986 { 2987 case Tag_RISCV_arch: 2988 if (!out_attr[Tag_RISCV_arch].s) 2989 out_attr[Tag_RISCV_arch].s = in_attr[Tag_RISCV_arch].s; 2990 else if (in_attr[Tag_RISCV_arch].s 2991 && out_attr[Tag_RISCV_arch].s) 2992 { 2993 /* Check arch compatible. */ 2994 char *merged_arch = 2995 riscv_merge_arch_attr_info (ibfd, 2996 in_attr[Tag_RISCV_arch].s, 2997 out_attr[Tag_RISCV_arch].s); 2998 if (merged_arch == NULL) 2999 { 3000 result = FALSE; 3001 out_attr[Tag_RISCV_arch].s = ""; 3002 } 3003 else 3004 out_attr[Tag_RISCV_arch].s = merged_arch; 3005 } 3006 break; 3007 3008 case Tag_RISCV_priv_spec: 3009 case Tag_RISCV_priv_spec_minor: 3010 case Tag_RISCV_priv_spec_revision: 3011 /* If we have handled the priv attributes, then skip it. */ 3012 if (!priv_attrs_merged) 3013 { 3014 unsigned int Tag_a = Tag_RISCV_priv_spec; 3015 unsigned int Tag_b = Tag_RISCV_priv_spec_minor; 3016 unsigned int Tag_c = Tag_RISCV_priv_spec_revision; 3017 enum riscv_priv_spec_class in_priv_spec; 3018 enum riscv_priv_spec_class out_priv_spec; 3019 3020 /* Get the priv spec class from elf attribute numbers. */ 3021 riscv_get_priv_spec_class_from_numbers (in_attr[Tag_a].i, 3022 in_attr[Tag_b].i, 3023 in_attr[Tag_c].i, 3024 &in_priv_spec); 3025 riscv_get_priv_spec_class_from_numbers (out_attr[Tag_a].i, 3026 out_attr[Tag_b].i, 3027 out_attr[Tag_c].i, 3028 &out_priv_spec); 3029 3030 /* Allow to link the object without the priv specs. */ 3031 if (out_priv_spec == PRIV_SPEC_CLASS_NONE) 3032 { 3033 out_attr[Tag_a].i = in_attr[Tag_a].i; 3034 out_attr[Tag_b].i = in_attr[Tag_b].i; 3035 out_attr[Tag_c].i = in_attr[Tag_c].i; 3036 } 3037 else if (in_priv_spec != PRIV_SPEC_CLASS_NONE 3038 && in_priv_spec != out_priv_spec) 3039 { 3040 _bfd_error_handler 3041 (_("warning: %pB use privilege spec version %u.%u.%u but " 3042 "the output use version %u.%u.%u"), 3043 ibfd, 3044 in_attr[Tag_a].i, 3045 in_attr[Tag_b].i, 3046 in_attr[Tag_c].i, 3047 out_attr[Tag_a].i, 3048 out_attr[Tag_b].i, 3049 out_attr[Tag_c].i); 3050 3051 /* The priv spec v1.9.1 can not be linked with other spec 3052 versions since the conflicts. We plan to drop the 3053 v1.9.1 in a year or two, so this confict should be 3054 removed in the future. */ 3055 if (in_priv_spec == PRIV_SPEC_CLASS_1P9P1 3056 || out_priv_spec == PRIV_SPEC_CLASS_1P9P1) 3057 { 3058 _bfd_error_handler 3059 (_("warning: privilege spec version 1.9.1 can not be " 3060 "linked with other spec versions")); 3061 } 3062 3063 /* Update the output priv spec to the newest one. */ 3064 if (in_priv_spec > out_priv_spec) 3065 { 3066 out_attr[Tag_a].i = in_attr[Tag_a].i; 3067 out_attr[Tag_b].i = in_attr[Tag_b].i; 3068 out_attr[Tag_c].i = in_attr[Tag_c].i; 3069 } 3070 } 3071 priv_attrs_merged = TRUE; 3072 } 3073 break; 3074 3075 case Tag_RISCV_unaligned_access: 3076 out_attr[i].i |= in_attr[i].i; 3077 break; 3078 3079 case Tag_RISCV_stack_align: 3080 if (out_attr[i].i == 0) 3081 out_attr[i].i = in_attr[i].i; 3082 else if (in_attr[i].i != 0 3083 && out_attr[i].i != 0 3084 && out_attr[i].i != in_attr[i].i) 3085 { 3086 _bfd_error_handler 3087 (_("error: %pB use %u-byte stack aligned but the output " 3088 "use %u-byte stack aligned"), 3089 ibfd, in_attr[i].i, out_attr[i].i); 3090 result = FALSE; 3091 } 3092 break; 3093 3094 default: 3095 result &= _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i); 3096 } 3097 3098 /* If out_attr was copied from in_attr then it won't have a type yet. */ 3099 if (in_attr[i].type && !out_attr[i].type) 3100 out_attr[i].type = in_attr[i].type; 3101 } 3102 3103 /* Merge Tag_compatibility attributes and any common GNU ones. */ 3104 if (!_bfd_elf_merge_object_attributes (ibfd, info)) 3105 return FALSE; 3106 3107 /* Check for any attributes not known on RISC-V. */ 3108 result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd); 3109 3110 return result; 3111 } 3112 3113 /* Merge backend specific data from an object file to the output 3114 object file when linking. */ 3115 3116 static bfd_boolean 3117 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 3118 { 3119 bfd *obfd = info->output_bfd; 3120 flagword new_flags, old_flags; 3121 3122 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd)) 3123 return TRUE; 3124 3125 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0) 3126 { 3127 (*_bfd_error_handler) 3128 (_("%pB: ABI is incompatible with that of the selected emulation:\n" 3129 " target emulation `%s' does not match `%s'"), 3130 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd)); 3131 return FALSE; 3132 } 3133 3134 if (!_bfd_elf_merge_object_attributes (ibfd, info)) 3135 return FALSE; 3136 3137 if (!riscv_merge_attributes (ibfd, info)) 3138 return FALSE; 3139 3140 new_flags = elf_elfheader (ibfd)->e_flags; 3141 old_flags = elf_elfheader (obfd)->e_flags; 3142 3143 if (! elf_flags_init (obfd)) 3144 { 3145 elf_flags_init (obfd) = TRUE; 3146 elf_elfheader (obfd)->e_flags = new_flags; 3147 return TRUE; 3148 } 3149 3150 /* Check to see if the input BFD actually contains any sections. If not, 3151 its flags may not have been initialized either, but it cannot actually 3152 cause any incompatibility. Do not short-circuit dynamic objects; their 3153 section list may be emptied by elf_link_add_object_symbols. 3154 3155 Also check to see if there are no code sections in the input. In this 3156 case, there is no need to check for code specific flags. */ 3157 if (!(ibfd->flags & DYNAMIC)) 3158 { 3159 bfd_boolean null_input_bfd = TRUE; 3160 bfd_boolean only_data_sections = TRUE; 3161 asection *sec; 3162 3163 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 3164 { 3165 if ((bfd_section_flags (sec) 3166 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 3167 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 3168 only_data_sections = FALSE; 3169 3170 null_input_bfd = FALSE; 3171 break; 3172 } 3173 3174 if (null_input_bfd || only_data_sections) 3175 return TRUE; 3176 } 3177 3178 /* Disallow linking different float ABIs. */ 3179 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI) 3180 { 3181 (*_bfd_error_handler) 3182 (_("%pB: can't link %s modules with %s modules"), ibfd, 3183 riscv_float_abi_string (new_flags), 3184 riscv_float_abi_string (old_flags)); 3185 goto fail; 3186 } 3187 3188 /* Disallow linking RVE and non-RVE. */ 3189 if ((old_flags ^ new_flags) & EF_RISCV_RVE) 3190 { 3191 (*_bfd_error_handler) 3192 (_("%pB: can't link RVE with other target"), ibfd); 3193 goto fail; 3194 } 3195 3196 /* Allow linking RVC and non-RVC, and keep the RVC flag. */ 3197 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC; 3198 3199 return TRUE; 3200 3201 fail: 3202 bfd_set_error (bfd_error_bad_value); 3203 return FALSE; 3204 } 3205 3206 /* Delete some bytes from a section while relaxing. */ 3207 3208 static bfd_boolean 3209 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count, 3210 struct bfd_link_info *link_info) 3211 { 3212 unsigned int i, symcount; 3213 bfd_vma toaddr = sec->size; 3214 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd); 3215 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3216 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 3217 struct bfd_elf_section_data *data = elf_section_data (sec); 3218 bfd_byte *contents = data->this_hdr.contents; 3219 3220 /* Actually delete the bytes. */ 3221 sec->size -= count; 3222 memmove (contents + addr, contents + addr + count, toaddr - addr - count); 3223 3224 /* Adjust the location of all of the relocs. Note that we need not 3225 adjust the addends, since all PC-relative references must be against 3226 symbols, which we will adjust below. */ 3227 for (i = 0; i < sec->reloc_count; i++) 3228 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr) 3229 data->relocs[i].r_offset -= count; 3230 3231 /* Adjust the local symbols defined in this section. */ 3232 for (i = 0; i < symtab_hdr->sh_info; i++) 3233 { 3234 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i; 3235 if (sym->st_shndx == sec_shndx) 3236 { 3237 /* If the symbol is in the range of memory we just moved, we 3238 have to adjust its value. */ 3239 if (sym->st_value > addr && sym->st_value <= toaddr) 3240 sym->st_value -= count; 3241 3242 /* If the symbol *spans* the bytes we just deleted (i.e. its 3243 *end* is in the moved bytes but its *start* isn't), then we 3244 must adjust its size. 3245 3246 This test needs to use the original value of st_value, otherwise 3247 we might accidentally decrease size when deleting bytes right 3248 before the symbol. But since deleted relocs can't span across 3249 symbols, we can't have both a st_value and a st_size decrease, 3250 so it is simpler to just use an else. */ 3251 else if (sym->st_value <= addr 3252 && sym->st_value + sym->st_size > addr 3253 && sym->st_value + sym->st_size <= toaddr) 3254 sym->st_size -= count; 3255 } 3256 } 3257 3258 /* Now adjust the global symbols defined in this section. */ 3259 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym)) 3260 - symtab_hdr->sh_info); 3261 3262 for (i = 0; i < symcount; i++) 3263 { 3264 struct elf_link_hash_entry *sym_hash = sym_hashes[i]; 3265 3266 /* The '--wrap SYMBOL' option is causing a pain when the object file, 3267 containing the definition of __wrap_SYMBOL, includes a direct 3268 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference 3269 the same symbol (which is __wrap_SYMBOL), but still exist as two 3270 different symbols in 'sym_hashes', we don't want to adjust 3271 the global symbol __wrap_SYMBOL twice. */ 3272 /* The same problem occurs with symbols that are versioned_hidden, as 3273 foo becomes an alias for foo@BAR, and hence they need the same 3274 treatment. */ 3275 if (link_info->wrap_hash != NULL 3276 || sym_hash->versioned == versioned_hidden) 3277 { 3278 struct elf_link_hash_entry **cur_sym_hashes; 3279 3280 /* Loop only over the symbols which have already been checked. */ 3281 for (cur_sym_hashes = sym_hashes; cur_sym_hashes < &sym_hashes[i]; 3282 cur_sym_hashes++) 3283 { 3284 /* If the current symbol is identical to 'sym_hash', that means 3285 the symbol was already adjusted (or at least checked). */ 3286 if (*cur_sym_hashes == sym_hash) 3287 break; 3288 } 3289 /* Don't adjust the symbol again. */ 3290 if (cur_sym_hashes < &sym_hashes[i]) 3291 continue; 3292 } 3293 3294 if ((sym_hash->root.type == bfd_link_hash_defined 3295 || sym_hash->root.type == bfd_link_hash_defweak) 3296 && sym_hash->root.u.def.section == sec) 3297 { 3298 /* As above, adjust the value if needed. */ 3299 if (sym_hash->root.u.def.value > addr 3300 && sym_hash->root.u.def.value <= toaddr) 3301 sym_hash->root.u.def.value -= count; 3302 3303 /* As above, adjust the size if needed. */ 3304 else if (sym_hash->root.u.def.value <= addr 3305 && sym_hash->root.u.def.value + sym_hash->size > addr 3306 && sym_hash->root.u.def.value + sym_hash->size <= toaddr) 3307 sym_hash->size -= count; 3308 } 3309 } 3310 3311 return TRUE; 3312 } 3313 3314 /* A second format for recording PC-relative hi relocations. This stores the 3315 information required to relax them to GP-relative addresses. */ 3316 3317 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc; 3318 struct riscv_pcgp_hi_reloc 3319 { 3320 bfd_vma hi_sec_off; 3321 bfd_vma hi_addend; 3322 bfd_vma hi_addr; 3323 unsigned hi_sym; 3324 asection *sym_sec; 3325 bfd_boolean undefined_weak; 3326 riscv_pcgp_hi_reloc *next; 3327 }; 3328 3329 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc; 3330 struct riscv_pcgp_lo_reloc 3331 { 3332 bfd_vma hi_sec_off; 3333 riscv_pcgp_lo_reloc *next; 3334 }; 3335 3336 typedef struct 3337 { 3338 riscv_pcgp_hi_reloc *hi; 3339 riscv_pcgp_lo_reloc *lo; 3340 } riscv_pcgp_relocs; 3341 3342 /* Initialize the pcgp reloc info in P. */ 3343 3344 static bfd_boolean 3345 riscv_init_pcgp_relocs (riscv_pcgp_relocs *p) 3346 { 3347 p->hi = NULL; 3348 p->lo = NULL; 3349 return TRUE; 3350 } 3351 3352 /* Free the pcgp reloc info in P. */ 3353 3354 static void 3355 riscv_free_pcgp_relocs (riscv_pcgp_relocs *p, 3356 bfd *abfd ATTRIBUTE_UNUSED, 3357 asection *sec ATTRIBUTE_UNUSED) 3358 { 3359 riscv_pcgp_hi_reloc *c; 3360 riscv_pcgp_lo_reloc *l; 3361 3362 for (c = p->hi; c != NULL;) 3363 { 3364 riscv_pcgp_hi_reloc *next = c->next; 3365 free (c); 3366 c = next; 3367 } 3368 3369 for (l = p->lo; l != NULL;) 3370 { 3371 riscv_pcgp_lo_reloc *next = l->next; 3372 free (l); 3373 l = next; 3374 } 3375 } 3376 3377 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index. 3378 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to 3379 relax the corresponding lo part reloc. */ 3380 3381 static bfd_boolean 3382 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off, 3383 bfd_vma hi_addend, bfd_vma hi_addr, 3384 unsigned hi_sym, asection *sym_sec, 3385 bfd_boolean undefined_weak) 3386 { 3387 riscv_pcgp_hi_reloc *new = bfd_malloc (sizeof(*new)); 3388 if (!new) 3389 return FALSE; 3390 new->hi_sec_off = hi_sec_off; 3391 new->hi_addend = hi_addend; 3392 new->hi_addr = hi_addr; 3393 new->hi_sym = hi_sym; 3394 new->sym_sec = sym_sec; 3395 new->undefined_weak = undefined_weak; 3396 new->next = p->hi; 3397 p->hi = new; 3398 return TRUE; 3399 } 3400 3401 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index. 3402 This is used by a lo part reloc to find the corresponding hi part reloc. */ 3403 3404 static riscv_pcgp_hi_reloc * 3405 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs *p, bfd_vma hi_sec_off) 3406 { 3407 riscv_pcgp_hi_reloc *c; 3408 3409 for (c = p->hi; c != NULL; c = c->next) 3410 if (c->hi_sec_off == hi_sec_off) 3411 return c; 3412 return NULL; 3413 } 3414 3415 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info. 3416 This is used to record relocs that can't be relaxed. */ 3417 3418 static bfd_boolean 3419 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off) 3420 { 3421 riscv_pcgp_lo_reloc *new = bfd_malloc (sizeof(*new)); 3422 if (!new) 3423 return FALSE; 3424 new->hi_sec_off = hi_sec_off; 3425 new->next = p->lo; 3426 p->lo = new; 3427 return TRUE; 3428 } 3429 3430 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index. 3431 This is used by a hi part reloc to find the corresponding lo part reloc. */ 3432 3433 static bfd_boolean 3434 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off) 3435 { 3436 riscv_pcgp_lo_reloc *c; 3437 3438 for (c = p->lo; c != NULL; c = c->next) 3439 if (c->hi_sec_off == hi_sec_off) 3440 return TRUE; 3441 return FALSE; 3442 } 3443 3444 typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *, 3445 struct bfd_link_info *, 3446 Elf_Internal_Rela *, 3447 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *, 3448 riscv_pcgp_relocs *, 3449 bfd_boolean undefined_weak); 3450 3451 /* Relax AUIPC + JALR into JAL. */ 3452 3453 static bfd_boolean 3454 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec, 3455 struct bfd_link_info *link_info, 3456 Elf_Internal_Rela *rel, 3457 bfd_vma symval, 3458 bfd_vma max_alignment, 3459 bfd_vma reserve_size ATTRIBUTE_UNUSED, 3460 bfd_boolean *again, 3461 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED, 3462 bfd_boolean undefined_weak ATTRIBUTE_UNUSED) 3463 { 3464 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 3465 bfd_vma foff = symval - (sec_addr (sec) + rel->r_offset); 3466 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH; 3467 bfd_vma auipc, jalr; 3468 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC; 3469 3470 /* If the call crosses section boundaries, an alignment directive could 3471 cause the PC-relative offset to later increase, so we need to add in the 3472 max alignment of any section inclusive from the call to the target. 3473 Otherwise, we only need to use the alignment of the current section. */ 3474 if (VALID_UJTYPE_IMM (foff)) 3475 { 3476 if (sym_sec->output_section == sec->output_section 3477 && sym_sec->output_section != bfd_abs_section_ptr) 3478 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power; 3479 foff += ((bfd_signed_vma) foff < 0 ? -max_alignment : max_alignment); 3480 } 3481 3482 /* See if this function call can be shortened. */ 3483 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero)) 3484 return TRUE; 3485 3486 /* Shorten the function call. */ 3487 BFD_ASSERT (rel->r_offset + 8 <= sec->size); 3488 3489 auipc = bfd_get_32 (abfd, contents + rel->r_offset); 3490 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4); 3491 rd = (jalr >> OP_SH_RD) & OP_MASK_RD; 3492 rvc = rvc && VALID_RVC_J_IMM (foff); 3493 3494 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */ 3495 rvc = rvc && (rd == 0 || (rd == X_RA && ARCH_SIZE == 32)); 3496 3497 if (rvc) 3498 { 3499 /* Relax to C.J[AL] rd, addr. */ 3500 r_type = R_RISCV_RVC_JUMP; 3501 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL; 3502 len = 2; 3503 } 3504 else if (VALID_UJTYPE_IMM (foff)) 3505 { 3506 /* Relax to JAL rd, addr. */ 3507 r_type = R_RISCV_JAL; 3508 auipc = MATCH_JAL | (rd << OP_SH_RD); 3509 } 3510 else /* near_zero */ 3511 { 3512 /* Relax to JALR rd, x0, addr. */ 3513 r_type = R_RISCV_LO12_I; 3514 auipc = MATCH_JALR | (rd << OP_SH_RD); 3515 } 3516 3517 /* Replace the R_RISCV_CALL reloc. */ 3518 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type); 3519 /* Replace the AUIPC. */ 3520 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset); 3521 3522 /* Delete unnecessary JALR. */ 3523 *again = TRUE; 3524 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len, 3525 link_info); 3526 } 3527 3528 /* Traverse all output sections and return the max alignment. */ 3529 3530 static bfd_vma 3531 _bfd_riscv_get_max_alignment (asection *sec) 3532 { 3533 unsigned int max_alignment_power = 0; 3534 asection *o; 3535 3536 for (o = sec->output_section->owner->sections; o != NULL; o = o->next) 3537 { 3538 if (o->alignment_power > max_alignment_power) 3539 max_alignment_power = o->alignment_power; 3540 } 3541 3542 return (bfd_vma) 1 << max_alignment_power; 3543 } 3544 3545 /* Relax non-PIC global variable references. */ 3546 3547 static bfd_boolean 3548 _bfd_riscv_relax_lui (bfd *abfd, 3549 asection *sec, 3550 asection *sym_sec, 3551 struct bfd_link_info *link_info, 3552 Elf_Internal_Rela *rel, 3553 bfd_vma symval, 3554 bfd_vma max_alignment, 3555 bfd_vma reserve_size, 3556 bfd_boolean *again, 3557 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED, 3558 bfd_boolean undefined_weak) 3559 { 3560 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 3561 bfd_vma gp = riscv_global_pointer_value (link_info); 3562 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC; 3563 3564 BFD_ASSERT (rel->r_offset + 4 <= sec->size); 3565 3566 if (gp) 3567 { 3568 /* If gp and the symbol are in the same output section, which is not the 3569 abs section, then consider only that output section's alignment. */ 3570 struct bfd_link_hash_entry *h = 3571 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, 3572 TRUE); 3573 if (h->u.def.section->output_section == sym_sec->output_section 3574 && sym_sec->output_section != bfd_abs_section_ptr) 3575 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power; 3576 } 3577 3578 /* Is the reference in range of x0 or gp? 3579 Valid gp range conservatively because of alignment issue. */ 3580 if (undefined_weak 3581 || (VALID_ITYPE_IMM (symval) 3582 || (symval >= gp 3583 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size)) 3584 || (symval < gp 3585 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))) 3586 { 3587 unsigned sym = ELFNN_R_SYM (rel->r_info); 3588 switch (ELFNN_R_TYPE (rel->r_info)) 3589 { 3590 case R_RISCV_LO12_I: 3591 if (undefined_weak) 3592 { 3593 /* Change the RS1 to zero. */ 3594 bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset); 3595 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 3596 bfd_put_32 (abfd, insn, contents + rel->r_offset); 3597 } 3598 else 3599 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I); 3600 return TRUE; 3601 3602 case R_RISCV_LO12_S: 3603 if (undefined_weak) 3604 { 3605 /* Change the RS1 to zero. */ 3606 bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset); 3607 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 3608 bfd_put_32 (abfd, insn, contents + rel->r_offset); 3609 } 3610 else 3611 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S); 3612 return TRUE; 3613 3614 case R_RISCV_HI20: 3615 /* We can delete the unnecessary LUI and reloc. */ 3616 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE); 3617 *again = TRUE; 3618 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4, 3619 link_info); 3620 3621 default: 3622 abort (); 3623 } 3624 } 3625 3626 /* Can we relax LUI to C.LUI? Alignment might move the section forward; 3627 account for this assuming page alignment at worst. In the presence of 3628 RELRO segment the linker aligns it by one page size, therefore sections 3629 after the segment can be moved more than one page. */ 3630 3631 if (use_rvc 3632 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20 3633 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval)) 3634 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval) 3635 + (link_info->relro ? 2 * ELF_MAXPAGESIZE 3636 : ELF_MAXPAGESIZE))) 3637 { 3638 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */ 3639 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset); 3640 unsigned rd = ((unsigned)lui >> OP_SH_RD) & OP_MASK_RD; 3641 if (rd == 0 || rd == X_SP) 3642 return TRUE; 3643 3644 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI; 3645 bfd_put_32 (abfd, lui, contents + rel->r_offset); 3646 3647 /* Replace the R_RISCV_HI20 reloc. */ 3648 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI); 3649 3650 *again = TRUE; 3651 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2, 3652 link_info); 3653 } 3654 3655 return TRUE; 3656 } 3657 3658 /* Relax non-PIC TLS references. */ 3659 3660 static bfd_boolean 3661 _bfd_riscv_relax_tls_le (bfd *abfd, 3662 asection *sec, 3663 asection *sym_sec ATTRIBUTE_UNUSED, 3664 struct bfd_link_info *link_info, 3665 Elf_Internal_Rela *rel, 3666 bfd_vma symval, 3667 bfd_vma max_alignment ATTRIBUTE_UNUSED, 3668 bfd_vma reserve_size ATTRIBUTE_UNUSED, 3669 bfd_boolean *again, 3670 riscv_pcgp_relocs *prcel_relocs ATTRIBUTE_UNUSED, 3671 bfd_boolean undefined_weak ATTRIBUTE_UNUSED) 3672 { 3673 /* See if this symbol is in range of tp. */ 3674 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0) 3675 return TRUE; 3676 3677 BFD_ASSERT (rel->r_offset + 4 <= sec->size); 3678 switch (ELFNN_R_TYPE (rel->r_info)) 3679 { 3680 case R_RISCV_TPREL_LO12_I: 3681 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I); 3682 return TRUE; 3683 3684 case R_RISCV_TPREL_LO12_S: 3685 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S); 3686 return TRUE; 3687 3688 case R_RISCV_TPREL_HI20: 3689 case R_RISCV_TPREL_ADD: 3690 /* We can delete the unnecessary instruction and reloc. */ 3691 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE); 3692 *again = TRUE; 3693 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4, link_info); 3694 3695 default: 3696 abort (); 3697 } 3698 } 3699 3700 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */ 3701 3702 static bfd_boolean 3703 _bfd_riscv_relax_align (bfd *abfd, asection *sec, 3704 asection *sym_sec, 3705 struct bfd_link_info *link_info, 3706 Elf_Internal_Rela *rel, 3707 bfd_vma symval, 3708 bfd_vma max_alignment ATTRIBUTE_UNUSED, 3709 bfd_vma reserve_size ATTRIBUTE_UNUSED, 3710 bfd_boolean *again ATTRIBUTE_UNUSED, 3711 riscv_pcgp_relocs *pcrel_relocs ATTRIBUTE_UNUSED, 3712 bfd_boolean undefined_weak ATTRIBUTE_UNUSED) 3713 { 3714 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 3715 bfd_vma alignment = 1, pos; 3716 while (alignment <= rel->r_addend) 3717 alignment *= 2; 3718 3719 symval -= rel->r_addend; 3720 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment; 3721 bfd_vma nop_bytes = aligned_addr - symval; 3722 3723 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */ 3724 sec->sec_flg0 = TRUE; 3725 3726 /* Make sure there are enough NOPs to actually achieve the alignment. */ 3727 if (rel->r_addend < nop_bytes) 3728 { 3729 _bfd_error_handler 3730 (_("%pB(%pA+%#" PRIx64 "): %" PRId64 " bytes required for alignment " 3731 "to %" PRId64 "-byte boundary, but only %" PRId64 " present"), 3732 abfd, sym_sec, (uint64_t) rel->r_offset, 3733 (int64_t) nop_bytes, (int64_t) alignment, (int64_t) rel->r_addend); 3734 bfd_set_error (bfd_error_bad_value); 3735 return FALSE; 3736 } 3737 3738 /* Delete the reloc. */ 3739 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE); 3740 3741 /* If the number of NOPs is already correct, there's nothing to do. */ 3742 if (nop_bytes == rel->r_addend) 3743 return TRUE; 3744 3745 /* Write as many RISC-V NOPs as we need. */ 3746 for (pos = 0; pos < (nop_bytes & -4); pos += 4) 3747 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos); 3748 3749 /* Write a final RVC NOP if need be. */ 3750 if (nop_bytes % 4 != 0) 3751 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos); 3752 3753 /* Delete the excess bytes. */ 3754 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes, 3755 rel->r_addend - nop_bytes, link_info); 3756 } 3757 3758 /* Relax PC-relative references to GP-relative references. */ 3759 3760 static bfd_boolean 3761 _bfd_riscv_relax_pc (bfd *abfd ATTRIBUTE_UNUSED, 3762 asection *sec, 3763 asection *sym_sec, 3764 struct bfd_link_info *link_info, 3765 Elf_Internal_Rela *rel, 3766 bfd_vma symval, 3767 bfd_vma max_alignment, 3768 bfd_vma reserve_size, 3769 bfd_boolean *again ATTRIBUTE_UNUSED, 3770 riscv_pcgp_relocs *pcgp_relocs, 3771 bfd_boolean undefined_weak) 3772 { 3773 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 3774 bfd_vma gp = riscv_global_pointer_value (link_info); 3775 3776 BFD_ASSERT (rel->r_offset + 4 <= sec->size); 3777 3778 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the 3779 * actual target address. */ 3780 riscv_pcgp_hi_reloc hi_reloc; 3781 memset (&hi_reloc, 0, sizeof (hi_reloc)); 3782 switch (ELFNN_R_TYPE (rel->r_info)) 3783 { 3784 case R_RISCV_PCREL_LO12_I: 3785 case R_RISCV_PCREL_LO12_S: 3786 { 3787 /* If the %lo has an addend, it isn't for the label pointing at the 3788 hi part instruction, but rather for the symbol pointed at by the 3789 hi part instruction. So we must subtract it here for the lookup. 3790 It is still used below in the final symbol address. */ 3791 bfd_vma hi_sec_off = symval - sec_addr (sym_sec) - rel->r_addend; 3792 riscv_pcgp_hi_reloc *hi = riscv_find_pcgp_hi_reloc (pcgp_relocs, 3793 hi_sec_off); 3794 if (hi == NULL) 3795 { 3796 riscv_record_pcgp_lo_reloc (pcgp_relocs, hi_sec_off); 3797 return TRUE; 3798 } 3799 3800 hi_reloc = *hi; 3801 symval = hi_reloc.hi_addr; 3802 sym_sec = hi_reloc.sym_sec; 3803 3804 /* We can not know whether the undefined weak symbol is referenced 3805 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore, 3806 we have to record the 'undefined_weak' flag when handling the 3807 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */ 3808 undefined_weak = hi_reloc.undefined_weak; 3809 } 3810 break; 3811 3812 case R_RISCV_PCREL_HI20: 3813 /* Mergeable symbols and code might later move out of range. */ 3814 if (! undefined_weak 3815 && sym_sec->flags & (SEC_MERGE | SEC_CODE)) 3816 return TRUE; 3817 3818 /* If the cooresponding lo relocation has already been seen then it's not 3819 * safe to relax this relocation. */ 3820 if (riscv_find_pcgp_lo_reloc (pcgp_relocs, rel->r_offset)) 3821 return TRUE; 3822 3823 break; 3824 3825 default: 3826 abort (); 3827 } 3828 3829 if (gp) 3830 { 3831 /* If gp and the symbol are in the same output section, which is not the 3832 abs section, then consider only that output section's alignment. */ 3833 struct bfd_link_hash_entry *h = 3834 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, 3835 TRUE); 3836 if (h->u.def.section->output_section == sym_sec->output_section 3837 && sym_sec->output_section != bfd_abs_section_ptr) 3838 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power; 3839 } 3840 3841 /* Is the reference in range of x0 or gp? 3842 Valid gp range conservatively because of alignment issue. */ 3843 if (undefined_weak 3844 || (VALID_ITYPE_IMM (symval) 3845 || (symval >= gp 3846 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size)) 3847 || (symval < gp 3848 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))) 3849 { 3850 unsigned sym = hi_reloc.hi_sym; 3851 switch (ELFNN_R_TYPE (rel->r_info)) 3852 { 3853 case R_RISCV_PCREL_LO12_I: 3854 if (undefined_weak) 3855 { 3856 /* Change the RS1 to zero, and then modify the relocation 3857 type to R_RISCV_LO12_I. */ 3858 bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset); 3859 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 3860 bfd_put_32 (abfd, insn, contents + rel->r_offset); 3861 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_LO12_I); 3862 rel->r_addend = hi_reloc.hi_addend; 3863 } 3864 else 3865 { 3866 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I); 3867 rel->r_addend += hi_reloc.hi_addend; 3868 } 3869 return TRUE; 3870 3871 case R_RISCV_PCREL_LO12_S: 3872 if (undefined_weak) 3873 { 3874 /* Change the RS1 to zero, and then modify the relocation 3875 type to R_RISCV_LO12_S. */ 3876 bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset); 3877 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 3878 bfd_put_32 (abfd, insn, contents + rel->r_offset); 3879 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_LO12_S); 3880 rel->r_addend = hi_reloc.hi_addend; 3881 } 3882 else 3883 { 3884 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S); 3885 rel->r_addend += hi_reloc.hi_addend; 3886 } 3887 return TRUE; 3888 3889 case R_RISCV_PCREL_HI20: 3890 riscv_record_pcgp_hi_reloc (pcgp_relocs, 3891 rel->r_offset, 3892 rel->r_addend, 3893 symval, 3894 ELFNN_R_SYM(rel->r_info), 3895 sym_sec, 3896 undefined_weak); 3897 /* We can delete the unnecessary AUIPC and reloc. */ 3898 rel->r_info = ELFNN_R_INFO (0, R_RISCV_DELETE); 3899 rel->r_addend = 4; 3900 return TRUE; 3901 3902 default: 3903 abort (); 3904 } 3905 } 3906 3907 return TRUE; 3908 } 3909 3910 /* Relax PC-relative references to GP-relative references. */ 3911 3912 static bfd_boolean 3913 _bfd_riscv_relax_delete (bfd *abfd, 3914 asection *sec, 3915 asection *sym_sec ATTRIBUTE_UNUSED, 3916 struct bfd_link_info *link_info, 3917 Elf_Internal_Rela *rel, 3918 bfd_vma symval ATTRIBUTE_UNUSED, 3919 bfd_vma max_alignment ATTRIBUTE_UNUSED, 3920 bfd_vma reserve_size ATTRIBUTE_UNUSED, 3921 bfd_boolean *again ATTRIBUTE_UNUSED, 3922 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED, 3923 bfd_boolean undefined_weak ATTRIBUTE_UNUSED) 3924 { 3925 if (!riscv_relax_delete_bytes(abfd, sec, rel->r_offset, rel->r_addend, 3926 link_info)) 3927 return FALSE; 3928 rel->r_info = ELFNN_R_INFO(0, R_RISCV_NONE); 3929 return TRUE; 3930 } 3931 3932 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1 3933 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be 3934 disabled, handles code alignment directives. */ 3935 3936 static bfd_boolean 3937 _bfd_riscv_relax_section (bfd *abfd, asection *sec, 3938 struct bfd_link_info *info, 3939 bfd_boolean *again) 3940 { 3941 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd); 3942 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 3943 struct bfd_elf_section_data *data = elf_section_data (sec); 3944 Elf_Internal_Rela *relocs; 3945 bfd_boolean ret = FALSE; 3946 unsigned int i; 3947 bfd_vma max_alignment, reserve_size = 0; 3948 riscv_pcgp_relocs pcgp_relocs; 3949 3950 *again = FALSE; 3951 3952 if (bfd_link_relocatable (info) 3953 || sec->sec_flg0 3954 || (sec->flags & SEC_RELOC) == 0 3955 || sec->reloc_count == 0 3956 || (info->disable_target_specific_optimizations 3957 && info->relax_pass == 0)) 3958 return TRUE; 3959 3960 riscv_init_pcgp_relocs (&pcgp_relocs); 3961 3962 /* Read this BFD's relocs if we haven't done so already. */ 3963 if (data->relocs) 3964 relocs = data->relocs; 3965 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 3966 info->keep_memory))) 3967 goto fail; 3968 3969 if (htab) 3970 { 3971 max_alignment = htab->max_alignment; 3972 if (max_alignment == (bfd_vma) -1) 3973 { 3974 max_alignment = _bfd_riscv_get_max_alignment (sec); 3975 htab->max_alignment = max_alignment; 3976 } 3977 } 3978 else 3979 max_alignment = _bfd_riscv_get_max_alignment (sec); 3980 3981 /* Examine and consider relaxing each reloc. */ 3982 for (i = 0; i < sec->reloc_count; i++) 3983 { 3984 asection *sym_sec; 3985 Elf_Internal_Rela *rel = relocs + i; 3986 relax_func_t relax_func; 3987 int type = ELFNN_R_TYPE (rel->r_info); 3988 bfd_vma symval; 3989 char symtype; 3990 bfd_boolean undefined_weak = FALSE; 3991 3992 relax_func = NULL; 3993 if (info->relax_pass == 0) 3994 { 3995 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT) 3996 relax_func = _bfd_riscv_relax_call; 3997 else if (type == R_RISCV_HI20 3998 || type == R_RISCV_LO12_I 3999 || type == R_RISCV_LO12_S) 4000 relax_func = _bfd_riscv_relax_lui; 4001 else if (!bfd_link_pic(info) 4002 && (type == R_RISCV_PCREL_HI20 4003 || type == R_RISCV_PCREL_LO12_I 4004 || type == R_RISCV_PCREL_LO12_S)) 4005 relax_func = _bfd_riscv_relax_pc; 4006 else if (type == R_RISCV_TPREL_HI20 4007 || type == R_RISCV_TPREL_ADD 4008 || type == R_RISCV_TPREL_LO12_I 4009 || type == R_RISCV_TPREL_LO12_S) 4010 relax_func = _bfd_riscv_relax_tls_le; 4011 else 4012 continue; 4013 4014 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */ 4015 if (i == sec->reloc_count - 1 4016 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX 4017 || rel->r_offset != (rel + 1)->r_offset) 4018 continue; 4019 4020 /* Skip over the R_RISCV_RELAX. */ 4021 i++; 4022 } 4023 else if (info->relax_pass == 1 && type == R_RISCV_DELETE) 4024 relax_func = _bfd_riscv_relax_delete; 4025 else if (info->relax_pass == 2 && type == R_RISCV_ALIGN) 4026 relax_func = _bfd_riscv_relax_align; 4027 else 4028 continue; 4029 4030 data->relocs = relocs; 4031 4032 /* Read this BFD's contents if we haven't done so already. */ 4033 if (!data->this_hdr.contents 4034 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents)) 4035 goto fail; 4036 4037 /* Read this BFD's symbols if we haven't done so already. */ 4038 if (symtab_hdr->sh_info != 0 4039 && !symtab_hdr->contents 4040 && !(symtab_hdr->contents = 4041 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr, 4042 symtab_hdr->sh_info, 4043 0, NULL, NULL, NULL))) 4044 goto fail; 4045 4046 /* Get the value of the symbol referred to by the reloc. */ 4047 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info) 4048 { 4049 /* A local symbol. */ 4050 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents 4051 + ELFNN_R_SYM (rel->r_info)); 4052 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size 4053 ? 0 : isym->st_size - rel->r_addend; 4054 4055 if (isym->st_shndx == SHN_UNDEF) 4056 sym_sec = sec, symval = rel->r_offset; 4057 else 4058 { 4059 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd)); 4060 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section; 4061 #if 0 4062 /* The purpose of this code is unknown. It breaks linker scripts 4063 for embedded development that place sections at address zero. 4064 This code is believed to be unnecessary. Disabling it but not 4065 yet removing it, in case something breaks. */ 4066 if (sec_addr (sym_sec) == 0) 4067 continue; 4068 #endif 4069 symval = isym->st_value; 4070 } 4071 symtype = ELF_ST_TYPE (isym->st_info); 4072 } 4073 else 4074 { 4075 unsigned long indx; 4076 struct elf_link_hash_entry *h; 4077 4078 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info; 4079 h = elf_sym_hashes (abfd)[indx]; 4080 4081 while (h->root.type == bfd_link_hash_indirect 4082 || h->root.type == bfd_link_hash_warning) 4083 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4084 4085 if (h->root.type == bfd_link_hash_undefweak 4086 && (relax_func == _bfd_riscv_relax_lui 4087 || relax_func == _bfd_riscv_relax_pc)) 4088 { 4089 /* For the lui and auipc relaxations, since the symbol 4090 value of an undefined weak symbol is always be zero, 4091 we can optimize the patterns into a single LI/MV/ADDI 4092 instruction. 4093 4094 Note that, creating shared libraries and pie output may 4095 break the rule above. Fortunately, since we do not relax 4096 pc relocs when creating shared libraries and pie output, 4097 and the absolute address access for R_RISCV_HI20 isn't 4098 allowed when "-fPIC" is set, the problem of creating shared 4099 libraries can not happen currently. Once we support the 4100 auipc relaxations when creating shared libraries, then we will 4101 need the more rigorous checking for this optimization. */ 4102 undefined_weak = TRUE; 4103 } 4104 4105 /* This line has to match the check in riscv_elf_relocate_section 4106 in the R_RISCV_CALL[_PLT] case. */ 4107 if (bfd_link_pic (info) && h->plt.offset != MINUS_ONE) 4108 { 4109 sym_sec = htab->elf.splt; 4110 symval = h->plt.offset; 4111 } 4112 else if (undefined_weak) 4113 { 4114 symval = 0; 4115 sym_sec = bfd_und_section_ptr; 4116 } 4117 else if ((h->root.type == bfd_link_hash_defined 4118 || h->root.type == bfd_link_hash_defweak) 4119 && h->root.u.def.section != NULL 4120 && h->root.u.def.section->output_section != NULL) 4121 { 4122 symval = h->root.u.def.value; 4123 sym_sec = h->root.u.def.section; 4124 } 4125 else 4126 continue; 4127 4128 if (h->type != STT_FUNC) 4129 reserve_size = 4130 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend; 4131 symtype = h->type; 4132 } 4133 4134 if (sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE 4135 && (sym_sec->flags & SEC_MERGE)) 4136 { 4137 /* At this stage in linking, no SEC_MERGE symbol has been 4138 adjusted, so all references to such symbols need to be 4139 passed through _bfd_merged_section_offset. (Later, in 4140 relocate_section, all SEC_MERGE symbols *except* for 4141 section symbols have been adjusted.) 4142 4143 gas may reduce relocations against symbols in SEC_MERGE 4144 sections to a relocation against the section symbol when 4145 the original addend was zero. When the reloc is against 4146 a section symbol we should include the addend in the 4147 offset passed to _bfd_merged_section_offset, since the 4148 location of interest is the original symbol. On the 4149 other hand, an access to "sym+addend" where "sym" is not 4150 a section symbol should not include the addend; Such an 4151 access is presumed to be an offset from "sym"; The 4152 location of interest is just "sym". */ 4153 if (symtype == STT_SECTION) 4154 symval += rel->r_addend; 4155 4156 symval = _bfd_merged_section_offset (abfd, &sym_sec, 4157 elf_section_data (sym_sec)->sec_info, 4158 symval); 4159 4160 if (symtype != STT_SECTION) 4161 symval += rel->r_addend; 4162 } 4163 else 4164 symval += rel->r_addend; 4165 4166 symval += sec_addr (sym_sec); 4167 4168 if (!relax_func (abfd, sec, sym_sec, info, rel, symval, 4169 max_alignment, reserve_size, again, 4170 &pcgp_relocs, undefined_weak)) 4171 goto fail; 4172 } 4173 4174 ret = TRUE; 4175 4176 fail: 4177 if (relocs != data->relocs) 4178 free (relocs); 4179 riscv_free_pcgp_relocs(&pcgp_relocs, abfd, sec); 4180 4181 return ret; 4182 } 4183 4184 #if ARCH_SIZE == 32 4185 # define PRSTATUS_SIZE 204 4186 # define PRSTATUS_OFFSET_PR_CURSIG 12 4187 # define PRSTATUS_OFFSET_PR_PID 24 4188 # define PRSTATUS_OFFSET_PR_REG 72 4189 # define ELF_GREGSET_T_SIZE 128 4190 # define PRPSINFO_SIZE 128 4191 # define PRPSINFO_OFFSET_PR_PID 16 4192 # define PRPSINFO_OFFSET_PR_FNAME 32 4193 # define PRPSINFO_OFFSET_PR_PSARGS 48 4194 #else 4195 # define PRSTATUS_SIZE 376 4196 # define PRSTATUS_OFFSET_PR_CURSIG 12 4197 # define PRSTATUS_OFFSET_PR_PID 32 4198 # define PRSTATUS_OFFSET_PR_REG 112 4199 # define ELF_GREGSET_T_SIZE 256 4200 # define PRPSINFO_SIZE 136 4201 # define PRPSINFO_OFFSET_PR_PID 24 4202 # define PRPSINFO_OFFSET_PR_FNAME 40 4203 # define PRPSINFO_OFFSET_PR_PSARGS 56 4204 #endif 4205 4206 /* Support for core dump NOTE sections. */ 4207 4208 static bfd_boolean 4209 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 4210 { 4211 switch (note->descsz) 4212 { 4213 default: 4214 return FALSE; 4215 4216 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */ 4217 /* pr_cursig */ 4218 elf_tdata (abfd)->core->signal 4219 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG); 4220 4221 /* pr_pid */ 4222 elf_tdata (abfd)->core->lwpid 4223 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID); 4224 break; 4225 } 4226 4227 /* Make a ".reg/999" section. */ 4228 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE, 4229 note->descpos + PRSTATUS_OFFSET_PR_REG); 4230 } 4231 4232 static bfd_boolean 4233 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 4234 { 4235 switch (note->descsz) 4236 { 4237 default: 4238 return FALSE; 4239 4240 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */ 4241 /* pr_pid */ 4242 elf_tdata (abfd)->core->pid 4243 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID); 4244 4245 /* pr_fname */ 4246 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup 4247 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16); 4248 4249 /* pr_psargs */ 4250 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup 4251 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80); 4252 break; 4253 } 4254 4255 /* Note that for some reason, a spurious space is tacked 4256 onto the end of the args in some (at least one anyway) 4257 implementations, so strip it off if it exists. */ 4258 4259 { 4260 char *command = elf_tdata (abfd)->core->command; 4261 int n = strlen (command); 4262 4263 if (0 < n && command[n - 1] == ' ') 4264 command[n - 1] = '\0'; 4265 } 4266 4267 return TRUE; 4268 } 4269 4270 /* Set the right mach type. */ 4271 static bfd_boolean 4272 riscv_elf_object_p (bfd *abfd) 4273 { 4274 /* There are only two mach types in RISCV currently. */ 4275 if (strcmp (abfd->xvec->name, "elf32-littleriscv") == 0) 4276 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv32); 4277 else 4278 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv64); 4279 4280 return TRUE; 4281 } 4282 4283 /* Determine whether an object attribute tag takes an integer, a 4284 string or both. */ 4285 4286 static int 4287 riscv_elf_obj_attrs_arg_type (int tag) 4288 { 4289 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL; 4290 } 4291 4292 #define TARGET_LITTLE_SYM riscv_elfNN_vec 4293 #define TARGET_LITTLE_NAME "elfNN-littleriscv" 4294 4295 #define elf_backend_reloc_type_class riscv_reloc_type_class 4296 4297 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup 4298 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create 4299 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup 4300 #define bfd_elfNN_bfd_merge_private_bfd_data \ 4301 _bfd_riscv_elf_merge_private_bfd_data 4302 4303 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol 4304 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections 4305 #define elf_backend_check_relocs riscv_elf_check_relocs 4306 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol 4307 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections 4308 #define elf_backend_relocate_section riscv_elf_relocate_section 4309 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol 4310 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections 4311 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook 4312 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val 4313 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus 4314 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo 4315 #define elf_backend_object_p riscv_elf_object_p 4316 #define elf_info_to_howto_rel NULL 4317 #define elf_info_to_howto riscv_info_to_howto_rela 4318 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section 4319 #define bfd_elfNN_mkobject elfNN_riscv_mkobject 4320 4321 #define elf_backend_init_index_section _bfd_elf_init_1_index_section 4322 4323 #define elf_backend_can_gc_sections 1 4324 #define elf_backend_can_refcount 1 4325 #define elf_backend_want_got_plt 1 4326 #define elf_backend_plt_readonly 1 4327 #define elf_backend_plt_alignment 4 4328 #define elf_backend_want_plt_sym 1 4329 #define elf_backend_got_header_size (ARCH_SIZE / 8) 4330 #define elf_backend_want_dynrelro 1 4331 #define elf_backend_rela_normal 1 4332 #define elf_backend_default_execstack 0 4333 4334 #undef elf_backend_obj_attrs_vendor 4335 #define elf_backend_obj_attrs_vendor "riscv" 4336 #undef elf_backend_obj_attrs_arg_type 4337 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type 4338 #undef elf_backend_obj_attrs_section_type 4339 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES 4340 #undef elf_backend_obj_attrs_section 4341 #define elf_backend_obj_attrs_section ".riscv.attributes" 4342 4343 #include "elfNN-target.h" 4344