1/* RISC-V-specific support for NN-bit ELF. 2 Copyright (C) 2011-2017 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#define ARCH_SIZE NN 36 37#define MINUS_ONE ((bfd_vma)0 - 1) 38 39#define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3) 40 41#define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES) 42 43/* The name of the dynamic interpreter. This is put in the .interp 44 section. */ 45 46#define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1" 47#define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1" 48 49#define ELF_ARCH bfd_arch_riscv 50#define ELF_TARGET_ID RISCV_ELF_DATA 51#define ELF_MACHINE_CODE EM_RISCV 52#define ELF_MAXPAGESIZE 0x1000 53#define ELF_COMMONPAGESIZE 0x1000 54 55/* The RISC-V linker needs to keep track of the number of relocs that it 56 decides to copy as dynamic relocs in check_relocs for each symbol. 57 This is so that it can later discard them if they are found to be 58 unnecessary. We store the information in a field extending the 59 regular ELF linker hash table. */ 60 61struct riscv_elf_dyn_relocs 62{ 63 struct riscv_elf_dyn_relocs *next; 64 65 /* The input section of the reloc. */ 66 asection *sec; 67 68 /* Total number of relocs copied for the input section. */ 69 bfd_size_type count; 70 71 /* Number of pc-relative relocs copied for the input section. */ 72 bfd_size_type pc_count; 73}; 74 75/* RISC-V ELF linker hash entry. */ 76 77struct riscv_elf_link_hash_entry 78{ 79 struct elf_link_hash_entry elf; 80 81 /* Track dynamic relocs copied for this symbol. */ 82 struct riscv_elf_dyn_relocs *dyn_relocs; 83 84#define GOT_UNKNOWN 0 85#define GOT_NORMAL 1 86#define GOT_TLS_GD 2 87#define GOT_TLS_IE 4 88#define GOT_TLS_LE 8 89 char tls_type; 90}; 91 92#define riscv_elf_hash_entry(ent) \ 93 ((struct riscv_elf_link_hash_entry *)(ent)) 94 95struct _bfd_riscv_elf_obj_tdata 96{ 97 struct elf_obj_tdata root; 98 99 /* tls_type for each local got entry. */ 100 char *local_got_tls_type; 101}; 102 103#define _bfd_riscv_elf_tdata(abfd) \ 104 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any) 105 106#define _bfd_riscv_elf_local_got_tls_type(abfd) \ 107 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type) 108 109#define _bfd_riscv_elf_tls_type(abfd, h, symndx) \ 110 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \ 111 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx])) 112 113#define is_riscv_elf(bfd) \ 114 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 115 && elf_tdata (bfd) != NULL \ 116 && elf_object_id (bfd) == RISCV_ELF_DATA) 117 118#include "elf/common.h" 119#include "elf/internal.h" 120 121struct riscv_elf_link_hash_table 122{ 123 struct elf_link_hash_table elf; 124 125 /* Short-cuts to get to dynamic linker sections. */ 126 asection *sdyntdata; 127 128 /* Small local sym to section mapping cache. */ 129 struct sym_cache sym_cache; 130}; 131 132 133/* Get the RISC-V ELF linker hash table from a link_info structure. */ 134#define riscv_elf_hash_table(p) \ 135 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 136 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL) 137 138static void 139riscv_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, 140 arelent *cache_ptr, 141 Elf_Internal_Rela *dst) 142{ 143 cache_ptr->howto = riscv_elf_rtype_to_howto (ELFNN_R_TYPE (dst->r_info)); 144} 145 146static void 147riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel) 148{ 149 const struct elf_backend_data *bed; 150 bfd_byte *loc; 151 152 bed = get_elf_backend_data (abfd); 153 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela); 154 bed->s->swap_reloca_out (abfd, rel, loc); 155} 156 157/* PLT/GOT stuff. */ 158 159#define PLT_HEADER_INSNS 8 160#define PLT_ENTRY_INSNS 4 161#define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4) 162#define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4) 163 164#define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES 165 166#define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE) 167 168#define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset) 169 170static bfd_vma 171riscv_elf_got_plt_val (bfd_vma plt_index, struct bfd_link_info *info) 172{ 173 return sec_addr (riscv_elf_hash_table (info)->elf.sgotplt) 174 + GOTPLT_HEADER_SIZE + (plt_index * GOT_ENTRY_SIZE); 175} 176 177#if ARCH_SIZE == 32 178# define MATCH_LREG MATCH_LW 179#else 180# define MATCH_LREG MATCH_LD 181#endif 182 183/* Generate a PLT header. */ 184 185static void 186riscv_make_plt_header (bfd_vma gotplt_addr, bfd_vma addr, uint32_t *entry) 187{ 188 bfd_vma gotplt_offset_high = RISCV_PCREL_HIGH_PART (gotplt_addr, addr); 189 bfd_vma gotplt_offset_low = RISCV_PCREL_LOW_PART (gotplt_addr, addr); 190 191 /* auipc t2, %hi(.got.plt) 192 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12 193 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve 194 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset 195 addi t0, t2, %lo(.got.plt) # &.got.plt 196 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset 197 l[w|d] t0, PTRSIZE(t0) # link map 198 jr t3 */ 199 200 entry[0] = RISCV_UTYPE (AUIPC, X_T2, gotplt_offset_high); 201 entry[1] = RISCV_RTYPE (SUB, X_T1, X_T1, X_T3); 202 entry[2] = RISCV_ITYPE (LREG, X_T3, X_T2, gotplt_offset_low); 203 entry[3] = RISCV_ITYPE (ADDI, X_T1, X_T1, -(PLT_HEADER_SIZE + 12)); 204 entry[4] = RISCV_ITYPE (ADDI, X_T0, X_T2, gotplt_offset_low); 205 entry[5] = RISCV_ITYPE (SRLI, X_T1, X_T1, 4 - RISCV_ELF_LOG_WORD_BYTES); 206 entry[6] = RISCV_ITYPE (LREG, X_T0, X_T0, RISCV_ELF_WORD_BYTES); 207 entry[7] = RISCV_ITYPE (JALR, 0, X_T3, 0); 208} 209 210/* Generate a PLT entry. */ 211 212static void 213riscv_make_plt_entry (bfd_vma got, bfd_vma addr, uint32_t *entry) 214{ 215 /* auipc t3, %hi(.got.plt entry) 216 l[w|d] t3, %lo(.got.plt entry)(t3) 217 jalr t1, t3 218 nop */ 219 220 entry[0] = RISCV_UTYPE (AUIPC, X_T3, RISCV_PCREL_HIGH_PART (got, addr)); 221 entry[1] = RISCV_ITYPE (LREG, X_T3, X_T3, RISCV_PCREL_LOW_PART (got, addr)); 222 entry[2] = RISCV_ITYPE (JALR, X_T1, X_T3, 0); 223 entry[3] = RISCV_NOP; 224} 225 226/* Create an entry in an RISC-V ELF linker hash table. */ 227 228static struct bfd_hash_entry * 229link_hash_newfunc (struct bfd_hash_entry *entry, 230 struct bfd_hash_table *table, const char *string) 231{ 232 /* Allocate the structure if it has not already been allocated by a 233 subclass. */ 234 if (entry == NULL) 235 { 236 entry = 237 bfd_hash_allocate (table, 238 sizeof (struct riscv_elf_link_hash_entry)); 239 if (entry == NULL) 240 return entry; 241 } 242 243 /* Call the allocation method of the superclass. */ 244 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 245 if (entry != NULL) 246 { 247 struct riscv_elf_link_hash_entry *eh; 248 249 eh = (struct riscv_elf_link_hash_entry *) entry; 250 eh->dyn_relocs = NULL; 251 eh->tls_type = GOT_UNKNOWN; 252 } 253 254 return entry; 255} 256 257/* Create a RISC-V ELF linker hash table. */ 258 259static struct bfd_link_hash_table * 260riscv_elf_link_hash_table_create (bfd *abfd) 261{ 262 struct riscv_elf_link_hash_table *ret; 263 bfd_size_type amt = sizeof (struct riscv_elf_link_hash_table); 264 265 ret = (struct riscv_elf_link_hash_table *) bfd_zmalloc (amt); 266 if (ret == NULL) 267 return NULL; 268 269 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc, 270 sizeof (struct riscv_elf_link_hash_entry), 271 RISCV_ELF_DATA)) 272 { 273 free (ret); 274 return NULL; 275 } 276 277 return &ret->elf.root; 278} 279 280/* Create the .got section. */ 281 282static bfd_boolean 283riscv_elf_create_got_section (bfd *abfd, struct bfd_link_info *info) 284{ 285 flagword flags; 286 asection *s, *s_got; 287 struct elf_link_hash_entry *h; 288 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 289 struct elf_link_hash_table *htab = elf_hash_table (info); 290 291 /* This function may be called more than once. */ 292 if (htab->sgot != NULL) 293 return TRUE; 294 295 flags = bed->dynamic_sec_flags; 296 297 s = bfd_make_section_anyway_with_flags (abfd, 298 (bed->rela_plts_and_copies_p 299 ? ".rela.got" : ".rel.got"), 300 (bed->dynamic_sec_flags 301 | SEC_READONLY)); 302 if (s == NULL 303 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 304 return FALSE; 305 htab->srelgot = s; 306 307 s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 308 if (s == NULL 309 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 310 return FALSE; 311 htab->sgot = s; 312 313 /* The first bit of the global offset table is the header. */ 314 s->size += bed->got_header_size; 315 316 if (bed->want_got_plt) 317 { 318 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags); 319 if (s == NULL 320 || !bfd_set_section_alignment (abfd, s, 321 bed->s->log_file_align)) 322 return FALSE; 323 htab->sgotplt = s; 324 325 /* Reserve room for the header. */ 326 s->size += GOTPLT_HEADER_SIZE; 327 } 328 329 if (bed->want_got_sym) 330 { 331 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 332 section. We don't do this in the linker script because we don't want 333 to define the symbol if we are not creating a global offset 334 table. */ 335 h = _bfd_elf_define_linkage_sym (abfd, info, s_got, 336 "_GLOBAL_OFFSET_TABLE_"); 337 elf_hash_table (info)->hgot = h; 338 if (h == NULL) 339 return FALSE; 340 } 341 342 return TRUE; 343} 344 345/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and 346 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our 347 hash table. */ 348 349static bfd_boolean 350riscv_elf_create_dynamic_sections (bfd *dynobj, 351 struct bfd_link_info *info) 352{ 353 struct riscv_elf_link_hash_table *htab; 354 355 htab = riscv_elf_hash_table (info); 356 BFD_ASSERT (htab != NULL); 357 358 if (!riscv_elf_create_got_section (dynobj, info)) 359 return FALSE; 360 361 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 362 return FALSE; 363 364 if (!bfd_link_pic (info)) 365 { 366 htab->sdyntdata = 367 bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn", 368 SEC_ALLOC | SEC_THREAD_LOCAL); 369 } 370 371 if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss 372 || (!bfd_link_pic (info) && (!htab->elf.srelbss || !htab->sdyntdata))) 373 abort (); 374 375 return TRUE; 376} 377 378/* Copy the extra info we tack onto an elf_link_hash_entry. */ 379 380static void 381riscv_elf_copy_indirect_symbol (struct bfd_link_info *info, 382 struct elf_link_hash_entry *dir, 383 struct elf_link_hash_entry *ind) 384{ 385 struct riscv_elf_link_hash_entry *edir, *eind; 386 387 edir = (struct riscv_elf_link_hash_entry *) dir; 388 eind = (struct riscv_elf_link_hash_entry *) ind; 389 390 if (eind->dyn_relocs != NULL) 391 { 392 if (edir->dyn_relocs != NULL) 393 { 394 struct riscv_elf_dyn_relocs **pp; 395 struct riscv_elf_dyn_relocs *p; 396 397 /* Add reloc counts against the indirect sym to the direct sym 398 list. Merge any entries against the same section. */ 399 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 400 { 401 struct riscv_elf_dyn_relocs *q; 402 403 for (q = edir->dyn_relocs; q != NULL; q = q->next) 404 if (q->sec == p->sec) 405 { 406 q->pc_count += p->pc_count; 407 q->count += p->count; 408 *pp = p->next; 409 break; 410 } 411 if (q == NULL) 412 pp = &p->next; 413 } 414 *pp = edir->dyn_relocs; 415 } 416 417 edir->dyn_relocs = eind->dyn_relocs; 418 eind->dyn_relocs = NULL; 419 } 420 421 if (ind->root.type == bfd_link_hash_indirect 422 && dir->got.refcount <= 0) 423 { 424 edir->tls_type = eind->tls_type; 425 eind->tls_type = GOT_UNKNOWN; 426 } 427 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 428} 429 430static bfd_boolean 431riscv_elf_record_tls_type (bfd *abfd, struct elf_link_hash_entry *h, 432 unsigned long symndx, char tls_type) 433{ 434 char *new_tls_type = &_bfd_riscv_elf_tls_type (abfd, h, symndx); 435 436 *new_tls_type |= tls_type; 437 if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL)) 438 { 439 (*_bfd_error_handler) 440 (_("%B: `%s' accessed both as normal and thread local symbol"), 441 abfd, h ? h->root.root.string : "<local>"); 442 return FALSE; 443 } 444 return TRUE; 445} 446 447static bfd_boolean 448riscv_elf_record_got_reference (bfd *abfd, struct bfd_link_info *info, 449 struct elf_link_hash_entry *h, long symndx) 450{ 451 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 452 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 453 454 if (htab->elf.sgot == NULL) 455 { 456 if (!riscv_elf_create_got_section (htab->elf.dynobj, info)) 457 return FALSE; 458 } 459 460 if (h != NULL) 461 { 462 h->got.refcount += 1; 463 return TRUE; 464 } 465 466 /* This is a global offset table entry for a local symbol. */ 467 if (elf_local_got_refcounts (abfd) == NULL) 468 { 469 bfd_size_type size = symtab_hdr->sh_info * (sizeof (bfd_vma) + 1); 470 if (!(elf_local_got_refcounts (abfd) = bfd_zalloc (abfd, size))) 471 return FALSE; 472 _bfd_riscv_elf_local_got_tls_type (abfd) 473 = (char *) (elf_local_got_refcounts (abfd) + symtab_hdr->sh_info); 474 } 475 elf_local_got_refcounts (abfd) [symndx] += 1; 476 477 return TRUE; 478} 479 480static bfd_boolean 481bad_static_reloc (bfd *abfd, unsigned r_type, struct elf_link_hash_entry *h) 482{ 483 (*_bfd_error_handler) 484 (_("%B: relocation %s against `%s' can not be used when making a shared " 485 "object; recompile with -fPIC"), 486 abfd, riscv_elf_rtype_to_howto (r_type)->name, 487 h != NULL ? h->root.root.string : "a local symbol"); 488 bfd_set_error (bfd_error_bad_value); 489 return FALSE; 490} 491/* Look through the relocs for a section during the first phase, and 492 allocate space in the global offset table or procedure linkage 493 table. */ 494 495static bfd_boolean 496riscv_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, 497 asection *sec, const Elf_Internal_Rela *relocs) 498{ 499 struct riscv_elf_link_hash_table *htab; 500 Elf_Internal_Shdr *symtab_hdr; 501 struct elf_link_hash_entry **sym_hashes; 502 const Elf_Internal_Rela *rel; 503 asection *sreloc = NULL; 504 505 if (bfd_link_relocatable (info)) 506 return TRUE; 507 508 htab = riscv_elf_hash_table (info); 509 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 510 sym_hashes = elf_sym_hashes (abfd); 511 512 if (htab->elf.dynobj == NULL) 513 htab->elf.dynobj = abfd; 514 515 for (rel = relocs; rel < relocs + sec->reloc_count; rel++) 516 { 517 unsigned int r_type; 518 unsigned long r_symndx; 519 struct elf_link_hash_entry *h; 520 521 r_symndx = ELFNN_R_SYM (rel->r_info); 522 r_type = ELFNN_R_TYPE (rel->r_info); 523 524 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 525 { 526 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), 527 abfd, r_symndx); 528 return FALSE; 529 } 530 531 if (r_symndx < symtab_hdr->sh_info) 532 h = NULL; 533 else 534 { 535 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 536 while (h->root.type == bfd_link_hash_indirect 537 || h->root.type == bfd_link_hash_warning) 538 h = (struct elf_link_hash_entry *) h->root.u.i.link; 539 540 /* PR15323, ref flags aren't set for references in the same 541 object. */ 542 h->root.non_ir_ref = 1; 543 } 544 545 switch (r_type) 546 { 547 case R_RISCV_TLS_GD_HI20: 548 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx) 549 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_GD)) 550 return FALSE; 551 break; 552 553 case R_RISCV_TLS_GOT_HI20: 554 if (bfd_link_pic (info)) 555 info->flags |= DF_STATIC_TLS; 556 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx) 557 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_IE)) 558 return FALSE; 559 break; 560 561 case R_RISCV_GOT_HI20: 562 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx) 563 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_NORMAL)) 564 return FALSE; 565 break; 566 567 case R_RISCV_CALL_PLT: 568 /* This symbol requires a procedure linkage table entry. We 569 actually build the entry in adjust_dynamic_symbol, 570 because this might be a case of linking PIC code without 571 linking in any dynamic objects, in which case we don't 572 need to generate a procedure linkage table after all. */ 573 574 if (h != NULL) 575 { 576 h->needs_plt = 1; 577 h->plt.refcount += 1; 578 } 579 break; 580 581 case R_RISCV_CALL: 582 case R_RISCV_JAL: 583 case R_RISCV_BRANCH: 584 case R_RISCV_RVC_BRANCH: 585 case R_RISCV_RVC_JUMP: 586 case R_RISCV_PCREL_HI20: 587 /* In shared libraries, these relocs are known to bind locally. */ 588 if (bfd_link_pic (info)) 589 break; 590 goto static_reloc; 591 592 case R_RISCV_TPREL_HI20: 593 if (!bfd_link_executable (info)) 594 return bad_static_reloc (abfd, r_type, h); 595 if (h != NULL) 596 riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_LE); 597 goto static_reloc; 598 599 case R_RISCV_HI20: 600 if (bfd_link_pic (info)) 601 return bad_static_reloc (abfd, r_type, h); 602 /* Fall through. */ 603 604 case R_RISCV_COPY: 605 case R_RISCV_JUMP_SLOT: 606 case R_RISCV_RELATIVE: 607 case R_RISCV_64: 608 case R_RISCV_32: 609 /* Fall through. */ 610 611 static_reloc: 612 /* This reloc might not bind locally. */ 613 if (h != NULL) 614 h->non_got_ref = 1; 615 616 if (h != NULL && !bfd_link_pic (info)) 617 { 618 /* We may need a .plt entry if the function this reloc 619 refers to is in a shared lib. */ 620 h->plt.refcount += 1; 621 } 622 623 /* If we are creating a shared library, and this is a reloc 624 against a global symbol, or a non PC relative reloc 625 against a local symbol, then we need to copy the reloc 626 into the shared library. However, if we are linking with 627 -Bsymbolic, we do not need to copy a reloc against a 628 global symbol which is defined in an object we are 629 including in the link (i.e., DEF_REGULAR is set). At 630 this point we have not seen all the input files, so it is 631 possible that DEF_REGULAR is not set now but will be set 632 later (it is never cleared). In case of a weak definition, 633 DEF_REGULAR may be cleared later by a strong definition in 634 a shared library. We account for that possibility below by 635 storing information in the relocs_copied field of the hash 636 table entry. A similar situation occurs when creating 637 shared libraries and symbol visibility changes render the 638 symbol local. 639 640 If on the other hand, we are creating an executable, we 641 may need to keep relocations for symbols satisfied by a 642 dynamic library if we manage to avoid copy relocs for the 643 symbol. */ 644 if ((bfd_link_pic (info) 645 && (sec->flags & SEC_ALLOC) != 0 646 && (! riscv_elf_rtype_to_howto (r_type)->pc_relative 647 || (h != NULL 648 && (! info->symbolic 649 || h->root.type == bfd_link_hash_defweak 650 || !h->def_regular)))) 651 || (!bfd_link_pic (info) 652 && (sec->flags & SEC_ALLOC) != 0 653 && h != NULL 654 && (h->root.type == bfd_link_hash_defweak 655 || !h->def_regular))) 656 { 657 struct riscv_elf_dyn_relocs *p; 658 struct riscv_elf_dyn_relocs **head; 659 660 /* When creating a shared object, we must copy these 661 relocs into the output file. We create a reloc 662 section in dynobj and make room for the reloc. */ 663 if (sreloc == NULL) 664 { 665 sreloc = _bfd_elf_make_dynamic_reloc_section 666 (sec, htab->elf.dynobj, RISCV_ELF_LOG_WORD_BYTES, 667 abfd, /*rela?*/ TRUE); 668 669 if (sreloc == NULL) 670 return FALSE; 671 } 672 673 /* If this is a global symbol, we count the number of 674 relocations we need for this symbol. */ 675 if (h != NULL) 676 head = &((struct riscv_elf_link_hash_entry *) h)->dyn_relocs; 677 else 678 { 679 /* Track dynamic relocs needed for local syms too. 680 We really need local syms available to do this 681 easily. Oh well. */ 682 683 asection *s; 684 void *vpp; 685 Elf_Internal_Sym *isym; 686 687 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 688 abfd, r_symndx); 689 if (isym == NULL) 690 return FALSE; 691 692 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 693 if (s == NULL) 694 s = sec; 695 696 vpp = &elf_section_data (s)->local_dynrel; 697 head = (struct riscv_elf_dyn_relocs **) vpp; 698 } 699 700 p = *head; 701 if (p == NULL || p->sec != sec) 702 { 703 bfd_size_type amt = sizeof *p; 704 p = ((struct riscv_elf_dyn_relocs *) 705 bfd_alloc (htab->elf.dynobj, amt)); 706 if (p == NULL) 707 return FALSE; 708 p->next = *head; 709 *head = p; 710 p->sec = sec; 711 p->count = 0; 712 p->pc_count = 0; 713 } 714 715 p->count += 1; 716 p->pc_count += riscv_elf_rtype_to_howto (r_type)->pc_relative; 717 } 718 719 break; 720 721 case R_RISCV_GNU_VTINHERIT: 722 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 723 return FALSE; 724 break; 725 726 case R_RISCV_GNU_VTENTRY: 727 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 728 return FALSE; 729 break; 730 731 default: 732 break; 733 } 734 } 735 736 return TRUE; 737} 738 739static asection * 740riscv_elf_gc_mark_hook (asection *sec, 741 struct bfd_link_info *info, 742 Elf_Internal_Rela *rel, 743 struct elf_link_hash_entry *h, 744 Elf_Internal_Sym *sym) 745{ 746 if (h != NULL) 747 switch (ELFNN_R_TYPE (rel->r_info)) 748 { 749 case R_RISCV_GNU_VTINHERIT: 750 case R_RISCV_GNU_VTENTRY: 751 return NULL; 752 } 753 754 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 755} 756 757/* Update the got entry reference counts for the section being removed. */ 758 759static bfd_boolean 760riscv_elf_gc_sweep_hook (bfd *abfd, 761 struct bfd_link_info *info, 762 asection *sec, 763 const Elf_Internal_Rela *relocs) 764{ 765 const Elf_Internal_Rela *rel, *relend; 766 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd); 767 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd); 768 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd); 769 770 if (bfd_link_relocatable (info)) 771 return TRUE; 772 773 elf_section_data (sec)->local_dynrel = NULL; 774 775 for (rel = relocs, relend = relocs + sec->reloc_count; rel < relend; rel++) 776 { 777 unsigned long r_symndx; 778 struct elf_link_hash_entry *h = NULL; 779 780 r_symndx = ELFNN_R_SYM (rel->r_info); 781 if (r_symndx >= symtab_hdr->sh_info) 782 { 783 struct riscv_elf_link_hash_entry *eh; 784 struct riscv_elf_dyn_relocs **pp; 785 struct riscv_elf_dyn_relocs *p; 786 787 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 788 while (h->root.type == bfd_link_hash_indirect 789 || h->root.type == bfd_link_hash_warning) 790 h = (struct elf_link_hash_entry *) h->root.u.i.link; 791 eh = (struct riscv_elf_link_hash_entry *) h; 792 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 793 if (p->sec == sec) 794 { 795 /* Everything must go for SEC. */ 796 *pp = p->next; 797 break; 798 } 799 } 800 801 switch (ELFNN_R_TYPE (rel->r_info)) 802 { 803 case R_RISCV_GOT_HI20: 804 case R_RISCV_TLS_GOT_HI20: 805 case R_RISCV_TLS_GD_HI20: 806 if (h != NULL) 807 { 808 if (h->got.refcount > 0) 809 h->got.refcount--; 810 } 811 else 812 { 813 if (local_got_refcounts && 814 local_got_refcounts[r_symndx] > 0) 815 local_got_refcounts[r_symndx]--; 816 } 817 break; 818 819 case R_RISCV_HI20: 820 case R_RISCV_PCREL_HI20: 821 case R_RISCV_COPY: 822 case R_RISCV_JUMP_SLOT: 823 case R_RISCV_RELATIVE: 824 case R_RISCV_64: 825 case R_RISCV_32: 826 case R_RISCV_BRANCH: 827 case R_RISCV_CALL: 828 case R_RISCV_JAL: 829 case R_RISCV_RVC_BRANCH: 830 case R_RISCV_RVC_JUMP: 831 if (bfd_link_pic (info)) 832 break; 833 /* Fall through. */ 834 835 case R_RISCV_CALL_PLT: 836 if (h != NULL) 837 { 838 if (h->plt.refcount > 0) 839 h->plt.refcount--; 840 } 841 break; 842 843 default: 844 break; 845 } 846 } 847 848 return TRUE; 849} 850 851/* Adjust a symbol defined by a dynamic object and referenced by a 852 regular object. The current definition is in some section of the 853 dynamic object, but we're not including those sections. We have to 854 change the definition to something the rest of the link can 855 understand. */ 856 857static bfd_boolean 858riscv_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 859 struct elf_link_hash_entry *h) 860{ 861 struct riscv_elf_link_hash_table *htab; 862 struct riscv_elf_link_hash_entry * eh; 863 struct riscv_elf_dyn_relocs *p; 864 bfd *dynobj; 865 asection *s, *srel; 866 867 htab = riscv_elf_hash_table (info); 868 BFD_ASSERT (htab != NULL); 869 870 dynobj = htab->elf.dynobj; 871 872 /* Make sure we know what is going on here. */ 873 BFD_ASSERT (dynobj != NULL 874 && (h->needs_plt 875 || h->type == STT_GNU_IFUNC 876 || h->u.weakdef != NULL 877 || (h->def_dynamic 878 && h->ref_regular 879 && !h->def_regular))); 880 881 /* If this is a function, put it in the procedure linkage table. We 882 will fill in the contents of the procedure linkage table later 883 (although we could actually do it here). */ 884 if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt) 885 { 886 if (h->plt.refcount <= 0 887 || SYMBOL_CALLS_LOCAL (info, h) 888 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 889 && h->root.type == bfd_link_hash_undefweak)) 890 { 891 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an 892 input file, but the symbol was never referred to by a dynamic 893 object, or if all references were garbage collected. In such 894 a case, we don't actually need to build a PLT entry. */ 895 h->plt.offset = (bfd_vma) -1; 896 h->needs_plt = 0; 897 } 898 899 return TRUE; 900 } 901 else 902 h->plt.offset = (bfd_vma) -1; 903 904 /* If this is a weak symbol, and there is a real definition, the 905 processor independent code will have arranged for us to see the 906 real definition first, and we can just use the same value. */ 907 if (h->u.weakdef != NULL) 908 { 909 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 910 || h->u.weakdef->root.type == bfd_link_hash_defweak); 911 h->root.u.def.section = h->u.weakdef->root.u.def.section; 912 h->root.u.def.value = h->u.weakdef->root.u.def.value; 913 return TRUE; 914 } 915 916 /* This is a reference to a symbol defined by a dynamic object which 917 is not a function. */ 918 919 /* If we are creating a shared library, we must presume that the 920 only references to the symbol are via the global offset table. 921 For such cases we need not do anything here; the relocations will 922 be handled correctly by relocate_section. */ 923 if (bfd_link_pic (info)) 924 return TRUE; 925 926 /* If there are no references to this symbol that do not use the 927 GOT, we don't need to generate a copy reloc. */ 928 if (!h->non_got_ref) 929 return TRUE; 930 931 /* If -z nocopyreloc was given, we won't generate them either. */ 932 if (info->nocopyreloc) 933 { 934 h->non_got_ref = 0; 935 return TRUE; 936 } 937 938 eh = (struct riscv_elf_link_hash_entry *) h; 939 for (p = eh->dyn_relocs; p != NULL; p = p->next) 940 { 941 s = p->sec->output_section; 942 if (s != NULL && (s->flags & SEC_READONLY) != 0) 943 break; 944 } 945 946 /* If we didn't find any dynamic relocs in read-only sections, then 947 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 948 if (p == NULL) 949 { 950 h->non_got_ref = 0; 951 return TRUE; 952 } 953 954 /* We must allocate the symbol in our .dynbss section, which will 955 become part of the .bss section of the executable. There will be 956 an entry for this symbol in the .dynsym section. The dynamic 957 object will contain position independent code, so all references 958 from the dynamic object to this symbol will go through the global 959 offset table. The dynamic linker will use the .dynsym entry to 960 determine the address it must put in the global offset table, so 961 both the dynamic object and the regular object will refer to the 962 same memory location for the variable. */ 963 964 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker 965 to copy the initial value out of the dynamic object and into the 966 runtime process image. We need to remember the offset into the 967 .rel.bss section we are going to use. */ 968 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 969 { 970 s = htab->elf.sdynrelro; 971 srel = htab->elf.sreldynrelro; 972 } 973 else 974 { 975 s = htab->elf.sdynbss; 976 srel = htab->elf.srelbss; 977 } 978 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 979 { 980 srel->size += sizeof (ElfNN_External_Rela); 981 h->needs_copy = 1; 982 } 983 984 if (eh->tls_type & ~GOT_NORMAL) 985 return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdyntdata); 986 987 return _bfd_elf_adjust_dynamic_copy (info, h, s); 988} 989 990/* Allocate space in .plt, .got and associated reloc sections for 991 dynamic relocs. */ 992 993static bfd_boolean 994allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 995{ 996 struct bfd_link_info *info; 997 struct riscv_elf_link_hash_table *htab; 998 struct riscv_elf_link_hash_entry *eh; 999 struct riscv_elf_dyn_relocs *p; 1000 1001 if (h->root.type == bfd_link_hash_indirect) 1002 return TRUE; 1003 1004 info = (struct bfd_link_info *) inf; 1005 htab = riscv_elf_hash_table (info); 1006 BFD_ASSERT (htab != NULL); 1007 1008 if (htab->elf.dynamic_sections_created 1009 && h->plt.refcount > 0) 1010 { 1011 /* Make sure this symbol is output as a dynamic symbol. 1012 Undefined weak syms won't yet be marked as dynamic. */ 1013 if (h->dynindx == -1 1014 && !h->forced_local) 1015 { 1016 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1017 return FALSE; 1018 } 1019 1020 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)) 1021 { 1022 asection *s = htab->elf.splt; 1023 1024 if (s->size == 0) 1025 s->size = PLT_HEADER_SIZE; 1026 1027 h->plt.offset = s->size; 1028 1029 /* Make room for this entry. */ 1030 s->size += PLT_ENTRY_SIZE; 1031 1032 /* We also need to make an entry in the .got.plt section. */ 1033 htab->elf.sgotplt->size += GOT_ENTRY_SIZE; 1034 1035 /* We also need to make an entry in the .rela.plt section. */ 1036 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela); 1037 1038 /* If this symbol is not defined in a regular file, and we are 1039 not generating a shared library, then set the symbol to this 1040 location in the .plt. This is required to make function 1041 pointers compare as equal between the normal executable and 1042 the shared library. */ 1043 if (! bfd_link_pic (info) 1044 && !h->def_regular) 1045 { 1046 h->root.u.def.section = s; 1047 h->root.u.def.value = h->plt.offset; 1048 } 1049 } 1050 else 1051 { 1052 h->plt.offset = (bfd_vma) -1; 1053 h->needs_plt = 0; 1054 } 1055 } 1056 else 1057 { 1058 h->plt.offset = (bfd_vma) -1; 1059 h->needs_plt = 0; 1060 } 1061 1062 if (h->got.refcount > 0) 1063 { 1064 asection *s; 1065 bfd_boolean dyn; 1066 int tls_type = riscv_elf_hash_entry (h)->tls_type; 1067 1068 /* Make sure this symbol is output as a dynamic symbol. 1069 Undefined weak syms won't yet be marked as dynamic. */ 1070 if (h->dynindx == -1 1071 && !h->forced_local) 1072 { 1073 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1074 return FALSE; 1075 } 1076 1077 s = htab->elf.sgot; 1078 h->got.offset = s->size; 1079 dyn = htab->elf.dynamic_sections_created; 1080 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE)) 1081 { 1082 /* TLS_GD needs two dynamic relocs and two GOT slots. */ 1083 if (tls_type & GOT_TLS_GD) 1084 { 1085 s->size += 2 * RISCV_ELF_WORD_BYTES; 1086 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela); 1087 } 1088 1089 /* TLS_IE needs one dynamic reloc and one GOT slot. */ 1090 if (tls_type & GOT_TLS_IE) 1091 { 1092 s->size += RISCV_ELF_WORD_BYTES; 1093 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela); 1094 } 1095 } 1096 else 1097 { 1098 s->size += RISCV_ELF_WORD_BYTES; 1099 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)) 1100 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela); 1101 } 1102 } 1103 else 1104 h->got.offset = (bfd_vma) -1; 1105 1106 eh = (struct riscv_elf_link_hash_entry *) h; 1107 if (eh->dyn_relocs == NULL) 1108 return TRUE; 1109 1110 /* In the shared -Bsymbolic case, discard space allocated for 1111 dynamic pc-relative relocs against symbols which turn out to be 1112 defined in regular objects. For the normal shared case, discard 1113 space for pc-relative relocs that have become local due to symbol 1114 visibility changes. */ 1115 1116 if (bfd_link_pic (info)) 1117 { 1118 if (SYMBOL_CALLS_LOCAL (info, h)) 1119 { 1120 struct riscv_elf_dyn_relocs **pp; 1121 1122 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 1123 { 1124 p->count -= p->pc_count; 1125 p->pc_count = 0; 1126 if (p->count == 0) 1127 *pp = p->next; 1128 else 1129 pp = &p->next; 1130 } 1131 } 1132 1133 /* Also discard relocs on undefined weak syms with non-default 1134 visibility. */ 1135 if (eh->dyn_relocs != NULL 1136 && h->root.type == bfd_link_hash_undefweak) 1137 { 1138 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 1139 eh->dyn_relocs = NULL; 1140 1141 /* Make sure undefined weak symbols are output as a dynamic 1142 symbol in PIEs. */ 1143 else if (h->dynindx == -1 1144 && !h->forced_local) 1145 { 1146 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1147 return FALSE; 1148 } 1149 } 1150 } 1151 else 1152 { 1153 /* For the non-shared case, discard space for relocs against 1154 symbols which turn out to need copy relocs or are not 1155 dynamic. */ 1156 1157 if (!h->non_got_ref 1158 && ((h->def_dynamic 1159 && !h->def_regular) 1160 || (htab->elf.dynamic_sections_created 1161 && (h->root.type == bfd_link_hash_undefweak 1162 || h->root.type == bfd_link_hash_undefined)))) 1163 { 1164 /* Make sure this symbol is output as a dynamic symbol. 1165 Undefined weak syms won't yet be marked as dynamic. */ 1166 if (h->dynindx == -1 1167 && !h->forced_local) 1168 { 1169 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1170 return FALSE; 1171 } 1172 1173 /* If that succeeded, we know we'll be keeping all the 1174 relocs. */ 1175 if (h->dynindx != -1) 1176 goto keep; 1177 } 1178 1179 eh->dyn_relocs = NULL; 1180 1181 keep: ; 1182 } 1183 1184 /* Finally, allocate space. */ 1185 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1186 { 1187 asection *sreloc = elf_section_data (p->sec)->sreloc; 1188 sreloc->size += p->count * sizeof (ElfNN_External_Rela); 1189 } 1190 1191 return TRUE; 1192} 1193 1194/* Find any dynamic relocs that apply to read-only sections. */ 1195 1196static bfd_boolean 1197readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf) 1198{ 1199 struct riscv_elf_link_hash_entry *eh; 1200 struct riscv_elf_dyn_relocs *p; 1201 1202 eh = (struct riscv_elf_link_hash_entry *) h; 1203 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1204 { 1205 asection *s = p->sec->output_section; 1206 1207 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1208 { 1209 ((struct bfd_link_info *) inf)->flags |= DF_TEXTREL; 1210 return FALSE; 1211 } 1212 } 1213 return TRUE; 1214} 1215 1216static bfd_boolean 1217riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 1218{ 1219 struct riscv_elf_link_hash_table *htab; 1220 bfd *dynobj; 1221 asection *s; 1222 bfd *ibfd; 1223 1224 htab = riscv_elf_hash_table (info); 1225 BFD_ASSERT (htab != NULL); 1226 dynobj = htab->elf.dynobj; 1227 BFD_ASSERT (dynobj != NULL); 1228 1229 if (elf_hash_table (info)->dynamic_sections_created) 1230 { 1231 /* Set the contents of the .interp section to the interpreter. */ 1232 if (bfd_link_executable (info) && !info->nointerp) 1233 { 1234 s = bfd_get_linker_section (dynobj, ".interp"); 1235 BFD_ASSERT (s != NULL); 1236 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1; 1237 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER; 1238 } 1239 } 1240 1241 /* Set up .got offsets for local syms, and space for local dynamic 1242 relocs. */ 1243 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 1244 { 1245 bfd_signed_vma *local_got; 1246 bfd_signed_vma *end_local_got; 1247 char *local_tls_type; 1248 bfd_size_type locsymcount; 1249 Elf_Internal_Shdr *symtab_hdr; 1250 asection *srel; 1251 1252 if (! is_riscv_elf (ibfd)) 1253 continue; 1254 1255 for (s = ibfd->sections; s != NULL; s = s->next) 1256 { 1257 struct riscv_elf_dyn_relocs *p; 1258 1259 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next) 1260 { 1261 if (!bfd_is_abs_section (p->sec) 1262 && bfd_is_abs_section (p->sec->output_section)) 1263 { 1264 /* Input section has been discarded, either because 1265 it is a copy of a linkonce section or due to 1266 linker script /DISCARD/, so we'll be discarding 1267 the relocs too. */ 1268 } 1269 else if (p->count != 0) 1270 { 1271 srel = elf_section_data (p->sec)->sreloc; 1272 srel->size += p->count * sizeof (ElfNN_External_Rela); 1273 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 1274 info->flags |= DF_TEXTREL; 1275 } 1276 } 1277 } 1278 1279 local_got = elf_local_got_refcounts (ibfd); 1280 if (!local_got) 1281 continue; 1282 1283 symtab_hdr = &elf_symtab_hdr (ibfd); 1284 locsymcount = symtab_hdr->sh_info; 1285 end_local_got = local_got + locsymcount; 1286 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd); 1287 s = htab->elf.sgot; 1288 srel = htab->elf.srelgot; 1289 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 1290 { 1291 if (*local_got > 0) 1292 { 1293 *local_got = s->size; 1294 s->size += RISCV_ELF_WORD_BYTES; 1295 if (*local_tls_type & GOT_TLS_GD) 1296 s->size += RISCV_ELF_WORD_BYTES; 1297 if (bfd_link_pic (info) 1298 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE))) 1299 srel->size += sizeof (ElfNN_External_Rela); 1300 } 1301 else 1302 *local_got = (bfd_vma) -1; 1303 } 1304 } 1305 1306 /* Allocate global sym .plt and .got entries, and space for global 1307 sym dynamic relocs. */ 1308 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info); 1309 1310 if (htab->elf.sgotplt) 1311 { 1312 struct elf_link_hash_entry *got; 1313 got = elf_link_hash_lookup (elf_hash_table (info), 1314 "_GLOBAL_OFFSET_TABLE_", 1315 FALSE, FALSE, FALSE); 1316 1317 /* Don't allocate .got.plt section if there are no GOT nor PLT 1318 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */ 1319 if ((got == NULL 1320 || !got->ref_regular_nonweak) 1321 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE) 1322 && (htab->elf.splt == NULL 1323 || htab->elf.splt->size == 0) 1324 && (htab->elf.sgot == NULL 1325 || (htab->elf.sgot->size 1326 == get_elf_backend_data (output_bfd)->got_header_size))) 1327 htab->elf.sgotplt->size = 0; 1328 } 1329 1330 /* The check_relocs and adjust_dynamic_symbol entry points have 1331 determined the sizes of the various dynamic sections. Allocate 1332 memory for them. */ 1333 for (s = dynobj->sections; s != NULL; s = s->next) 1334 { 1335 if ((s->flags & SEC_LINKER_CREATED) == 0) 1336 continue; 1337 1338 if (s == htab->elf.splt 1339 || s == htab->elf.sgot 1340 || s == htab->elf.sgotplt 1341 || s == htab->elf.sdynbss 1342 || s == htab->elf.sdynrelro) 1343 { 1344 /* Strip this section if we don't need it; see the 1345 comment below. */ 1346 } 1347 else if (strncmp (s->name, ".rela", 5) == 0) 1348 { 1349 if (s->size != 0) 1350 { 1351 /* We use the reloc_count field as a counter if we need 1352 to copy relocs into the output file. */ 1353 s->reloc_count = 0; 1354 } 1355 } 1356 else 1357 { 1358 /* It's not one of our sections. */ 1359 continue; 1360 } 1361 1362 if (s->size == 0) 1363 { 1364 /* If we don't need this section, strip it from the 1365 output file. This is mostly to handle .rela.bss and 1366 .rela.plt. We must create both sections in 1367 create_dynamic_sections, because they must be created 1368 before the linker maps input sections to output 1369 sections. The linker does that before 1370 adjust_dynamic_symbol is called, and it is that 1371 function which decides whether anything needs to go 1372 into these sections. */ 1373 s->flags |= SEC_EXCLUDE; 1374 continue; 1375 } 1376 1377 if ((s->flags & SEC_HAS_CONTENTS) == 0) 1378 continue; 1379 1380 /* Allocate memory for the section contents. Zero the memory 1381 for the benefit of .rela.plt, which has 4 unused entries 1382 at the beginning, and we don't want garbage. */ 1383 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 1384 if (s->contents == NULL) 1385 return FALSE; 1386 } 1387 1388 if (elf_hash_table (info)->dynamic_sections_created) 1389 { 1390 /* Add some entries to the .dynamic section. We fill in the 1391 values later, in riscv_elf_finish_dynamic_sections, but we 1392 must add the entries now so that we get the correct size for 1393 the .dynamic section. The DT_DEBUG entry is filled in by the 1394 dynamic linker and used by the debugger. */ 1395#define add_dynamic_entry(TAG, VAL) \ 1396 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1397 1398 if (bfd_link_executable (info)) 1399 { 1400 if (!add_dynamic_entry (DT_DEBUG, 0)) 1401 return FALSE; 1402 } 1403 1404 if (htab->elf.srelplt->size != 0) 1405 { 1406 if (!add_dynamic_entry (DT_PLTGOT, 0) 1407 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1408 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1409 || !add_dynamic_entry (DT_JMPREL, 0)) 1410 return FALSE; 1411 } 1412 1413 if (!add_dynamic_entry (DT_RELA, 0) 1414 || !add_dynamic_entry (DT_RELASZ, 0) 1415 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela))) 1416 return FALSE; 1417 1418 /* If any dynamic relocs apply to a read-only section, 1419 then we need a DT_TEXTREL entry. */ 1420 if ((info->flags & DF_TEXTREL) == 0) 1421 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info); 1422 1423 if (info->flags & DF_TEXTREL) 1424 { 1425 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1426 return FALSE; 1427 } 1428 } 1429#undef add_dynamic_entry 1430 1431 return TRUE; 1432} 1433 1434#define TP_OFFSET 0 1435#define DTP_OFFSET 0x800 1436 1437/* Return the relocation value for a TLS dtp-relative reloc. */ 1438 1439static bfd_vma 1440dtpoff (struct bfd_link_info *info, bfd_vma address) 1441{ 1442 /* If tls_sec is NULL, we should have signalled an error already. */ 1443 if (elf_hash_table (info)->tls_sec == NULL) 1444 return 0; 1445 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET; 1446} 1447 1448/* Return the relocation value for a static TLS tp-relative relocation. */ 1449 1450static bfd_vma 1451tpoff (struct bfd_link_info *info, bfd_vma address) 1452{ 1453 /* If tls_sec is NULL, we should have signalled an error already. */ 1454 if (elf_hash_table (info)->tls_sec == NULL) 1455 return 0; 1456 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET; 1457} 1458 1459/* Return the global pointer's value, or 0 if it is not in use. */ 1460 1461static bfd_vma 1462riscv_global_pointer_value (struct bfd_link_info *info) 1463{ 1464 struct bfd_link_hash_entry *h; 1465 1466 h = bfd_link_hash_lookup (info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE); 1467 if (h == NULL || h->type != bfd_link_hash_defined) 1468 return 0; 1469 1470 return h->u.def.value + sec_addr (h->u.def.section); 1471} 1472 1473/* Emplace a static relocation. */ 1474 1475static bfd_reloc_status_type 1476perform_relocation (const reloc_howto_type *howto, 1477 const Elf_Internal_Rela *rel, 1478 bfd_vma value, 1479 asection *input_section, 1480 bfd *input_bfd, 1481 bfd_byte *contents) 1482{ 1483 if (howto->pc_relative) 1484 value -= sec_addr (input_section) + rel->r_offset; 1485 value += rel->r_addend; 1486 1487 switch (ELFNN_R_TYPE (rel->r_info)) 1488 { 1489 case R_RISCV_HI20: 1490 case R_RISCV_TPREL_HI20: 1491 case R_RISCV_PCREL_HI20: 1492 case R_RISCV_GOT_HI20: 1493 case R_RISCV_TLS_GOT_HI20: 1494 case R_RISCV_TLS_GD_HI20: 1495 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))) 1496 return bfd_reloc_overflow; 1497 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)); 1498 break; 1499 1500 case R_RISCV_LO12_I: 1501 case R_RISCV_GPREL_I: 1502 case R_RISCV_TPREL_LO12_I: 1503 case R_RISCV_TPREL_I: 1504 case R_RISCV_PCREL_LO12_I: 1505 value = ENCODE_ITYPE_IMM (value); 1506 break; 1507 1508 case R_RISCV_LO12_S: 1509 case R_RISCV_GPREL_S: 1510 case R_RISCV_TPREL_LO12_S: 1511 case R_RISCV_TPREL_S: 1512 case R_RISCV_PCREL_LO12_S: 1513 value = ENCODE_STYPE_IMM (value); 1514 break; 1515 1516 case R_RISCV_CALL: 1517 case R_RISCV_CALL_PLT: 1518 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))) 1519 return bfd_reloc_overflow; 1520 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)) 1521 | (ENCODE_ITYPE_IMM (value) << 32); 1522 break; 1523 1524 case R_RISCV_JAL: 1525 if (!VALID_UJTYPE_IMM (value)) 1526 return bfd_reloc_overflow; 1527 value = ENCODE_UJTYPE_IMM (value); 1528 break; 1529 1530 case R_RISCV_BRANCH: 1531 if (!VALID_SBTYPE_IMM (value)) 1532 return bfd_reloc_overflow; 1533 value = ENCODE_SBTYPE_IMM (value); 1534 break; 1535 1536 case R_RISCV_RVC_BRANCH: 1537 if (!VALID_RVC_B_IMM (value)) 1538 return bfd_reloc_overflow; 1539 value = ENCODE_RVC_B_IMM (value); 1540 break; 1541 1542 case R_RISCV_RVC_JUMP: 1543 if (!VALID_RVC_J_IMM (value)) 1544 return bfd_reloc_overflow; 1545 value = ENCODE_RVC_J_IMM (value); 1546 break; 1547 1548 case R_RISCV_RVC_LUI: 1549 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value))) 1550 return bfd_reloc_overflow; 1551 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)); 1552 break; 1553 1554 case R_RISCV_32: 1555 case R_RISCV_64: 1556 case R_RISCV_ADD8: 1557 case R_RISCV_ADD16: 1558 case R_RISCV_ADD32: 1559 case R_RISCV_ADD64: 1560 case R_RISCV_SUB6: 1561 case R_RISCV_SUB8: 1562 case R_RISCV_SUB16: 1563 case R_RISCV_SUB32: 1564 case R_RISCV_SUB64: 1565 case R_RISCV_SET6: 1566 case R_RISCV_SET8: 1567 case R_RISCV_SET16: 1568 case R_RISCV_SET32: 1569 case R_RISCV_TLS_DTPREL32: 1570 case R_RISCV_TLS_DTPREL64: 1571 break; 1572 1573 default: 1574 return bfd_reloc_notsupported; 1575 } 1576 1577 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset); 1578 word = (word & ~howto->dst_mask) | (value & howto->dst_mask); 1579 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset); 1580 1581 return bfd_reloc_ok; 1582} 1583 1584/* Remember all PC-relative high-part relocs we've encountered to help us 1585 later resolve the corresponding low-part relocs. */ 1586 1587typedef struct 1588{ 1589 bfd_vma address; 1590 bfd_vma value; 1591} riscv_pcrel_hi_reloc; 1592 1593typedef struct riscv_pcrel_lo_reloc 1594{ 1595 asection * input_section; 1596 struct bfd_link_info * info; 1597 reloc_howto_type * howto; 1598 const Elf_Internal_Rela * reloc; 1599 bfd_vma addr; 1600 const char * name; 1601 bfd_byte * contents; 1602 struct riscv_pcrel_lo_reloc * next; 1603} riscv_pcrel_lo_reloc; 1604 1605typedef struct 1606{ 1607 htab_t hi_relocs; 1608 riscv_pcrel_lo_reloc *lo_relocs; 1609} riscv_pcrel_relocs; 1610 1611static hashval_t 1612riscv_pcrel_reloc_hash (const void *entry) 1613{ 1614 const riscv_pcrel_hi_reloc *e = entry; 1615 return (hashval_t)(e->address >> 2); 1616} 1617 1618static bfd_boolean 1619riscv_pcrel_reloc_eq (const void *entry1, const void *entry2) 1620{ 1621 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2; 1622 return e1->address == e2->address; 1623} 1624 1625static bfd_boolean 1626riscv_init_pcrel_relocs (riscv_pcrel_relocs *p) 1627{ 1628 1629 p->lo_relocs = NULL; 1630 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash, 1631 riscv_pcrel_reloc_eq, free); 1632 return p->hi_relocs != NULL; 1633} 1634 1635static void 1636riscv_free_pcrel_relocs (riscv_pcrel_relocs *p) 1637{ 1638 riscv_pcrel_lo_reloc *cur = p->lo_relocs; 1639 1640 while (cur != NULL) 1641 { 1642 riscv_pcrel_lo_reloc *next = cur->next; 1643 free (cur); 1644 cur = next; 1645 } 1646 1647 htab_delete (p->hi_relocs); 1648} 1649 1650static bfd_boolean 1651riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr, bfd_vma value) 1652{ 1653 riscv_pcrel_hi_reloc entry = {addr, value - addr}; 1654 riscv_pcrel_hi_reloc **slot = 1655 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT); 1656 1657 BFD_ASSERT (*slot == NULL); 1658 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc)); 1659 if (*slot == NULL) 1660 return FALSE; 1661 **slot = entry; 1662 return TRUE; 1663} 1664 1665static bfd_boolean 1666riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p, 1667 asection *input_section, 1668 struct bfd_link_info *info, 1669 reloc_howto_type *howto, 1670 const Elf_Internal_Rela *reloc, 1671 bfd_vma addr, 1672 const char *name, 1673 bfd_byte *contents) 1674{ 1675 riscv_pcrel_lo_reloc *entry; 1676 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc)); 1677 if (entry == NULL) 1678 return FALSE; 1679 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr, 1680 name, contents, p->lo_relocs}; 1681 p->lo_relocs = entry; 1682 return TRUE; 1683} 1684 1685static bfd_boolean 1686riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p) 1687{ 1688 riscv_pcrel_lo_reloc *r; 1689 1690 for (r = p->lo_relocs; r != NULL; r = r->next) 1691 { 1692 bfd *input_bfd = r->input_section->owner; 1693 1694 riscv_pcrel_hi_reloc search = {r->addr, 0}; 1695 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search); 1696 if (entry == NULL) 1697 { 1698 ((*r->info->callbacks->reloc_overflow) 1699 (r->info, NULL, r->name, r->howto->name, (bfd_vma) 0, 1700 input_bfd, r->input_section, r->reloc->r_offset)); 1701 return TRUE; 1702 } 1703 1704 perform_relocation (r->howto, r->reloc, entry->value, r->input_section, 1705 input_bfd, r->contents); 1706 } 1707 1708 return TRUE; 1709} 1710 1711/* Relocate a RISC-V ELF section. 1712 1713 The RELOCATE_SECTION function is called by the new ELF backend linker 1714 to handle the relocations for a section. 1715 1716 The relocs are always passed as Rela structures. 1717 1718 This function is responsible for adjusting the section contents as 1719 necessary, and (if generating a relocatable output file) adjusting 1720 the reloc addend as necessary. 1721 1722 This function does not have to worry about setting the reloc 1723 address or the reloc symbol index. 1724 1725 LOCAL_SYMS is a pointer to the swapped in local symbols. 1726 1727 LOCAL_SECTIONS is an array giving the section in the input file 1728 corresponding to the st_shndx field of each local symbol. 1729 1730 The global hash table entry for the global symbols can be found 1731 via elf_sym_hashes (input_bfd). 1732 1733 When generating relocatable output, this function must handle 1734 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 1735 going to be the section symbol corresponding to the output 1736 section, which means that the addend must be adjusted 1737 accordingly. */ 1738 1739static bfd_boolean 1740riscv_elf_relocate_section (bfd *output_bfd, 1741 struct bfd_link_info *info, 1742 bfd *input_bfd, 1743 asection *input_section, 1744 bfd_byte *contents, 1745 Elf_Internal_Rela *relocs, 1746 Elf_Internal_Sym *local_syms, 1747 asection **local_sections) 1748{ 1749 Elf_Internal_Rela *rel; 1750 Elf_Internal_Rela *relend; 1751 riscv_pcrel_relocs pcrel_relocs; 1752 bfd_boolean ret = FALSE; 1753 asection *sreloc = elf_section_data (input_section)->sreloc; 1754 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 1755 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd); 1756 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 1757 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd); 1758 1759 if (!riscv_init_pcrel_relocs (&pcrel_relocs)) 1760 return FALSE; 1761 1762 relend = relocs + input_section->reloc_count; 1763 for (rel = relocs; rel < relend; rel++) 1764 { 1765 unsigned long r_symndx; 1766 struct elf_link_hash_entry *h; 1767 Elf_Internal_Sym *sym; 1768 asection *sec; 1769 bfd_vma relocation; 1770 bfd_reloc_status_type r = bfd_reloc_ok; 1771 const char *name; 1772 bfd_vma off, ie_off; 1773 bfd_boolean unresolved_reloc, is_ie = FALSE; 1774 bfd_vma pc = sec_addr (input_section) + rel->r_offset; 1775 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type; 1776 reloc_howto_type *howto = riscv_elf_rtype_to_howto (r_type); 1777 const char *msg = NULL; 1778 1779 if (r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY) 1780 continue; 1781 1782 /* This is a final link. */ 1783 r_symndx = ELFNN_R_SYM (rel->r_info); 1784 h = NULL; 1785 sym = NULL; 1786 sec = NULL; 1787 unresolved_reloc = FALSE; 1788 if (r_symndx < symtab_hdr->sh_info) 1789 { 1790 sym = local_syms + r_symndx; 1791 sec = local_sections[r_symndx]; 1792 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1793 } 1794 else 1795 { 1796 bfd_boolean warned, ignored; 1797 1798 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1799 r_symndx, symtab_hdr, sym_hashes, 1800 h, sec, relocation, 1801 unresolved_reloc, warned, ignored); 1802 if (warned) 1803 { 1804 /* To avoid generating warning messages about truncated 1805 relocations, set the relocation's address to be the same as 1806 the start of this section. */ 1807 if (input_section->output_section != NULL) 1808 relocation = input_section->output_section->vma; 1809 else 1810 relocation = 0; 1811 } 1812 } 1813 1814 if (sec != NULL && discarded_section (sec)) 1815 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 1816 rel, 1, relend, howto, 0, contents); 1817 1818 if (bfd_link_relocatable (info)) 1819 continue; 1820 1821 if (h != NULL) 1822 name = h->root.root.string; 1823 else 1824 { 1825 name = (bfd_elf_string_from_elf_section 1826 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 1827 if (name == NULL || *name == '\0') 1828 name = bfd_section_name (input_bfd, sec); 1829 } 1830 1831 switch (r_type) 1832 { 1833 case R_RISCV_NONE: 1834 case R_RISCV_RELAX: 1835 case R_RISCV_TPREL_ADD: 1836 case R_RISCV_COPY: 1837 case R_RISCV_JUMP_SLOT: 1838 case R_RISCV_RELATIVE: 1839 /* These require nothing of us at all. */ 1840 continue; 1841 1842 case R_RISCV_HI20: 1843 case R_RISCV_BRANCH: 1844 case R_RISCV_RVC_BRANCH: 1845 case R_RISCV_RVC_LUI: 1846 case R_RISCV_LO12_I: 1847 case R_RISCV_LO12_S: 1848 case R_RISCV_SET6: 1849 case R_RISCV_SET8: 1850 case R_RISCV_SET16: 1851 case R_RISCV_SET32: 1852 /* These require no special handling beyond perform_relocation. */ 1853 break; 1854 1855 case R_RISCV_GOT_HI20: 1856 if (h != NULL) 1857 { 1858 bfd_boolean dyn, pic; 1859 1860 off = h->got.offset; 1861 BFD_ASSERT (off != (bfd_vma) -1); 1862 dyn = elf_hash_table (info)->dynamic_sections_created; 1863 pic = bfd_link_pic (info); 1864 1865 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h) 1866 || (pic && SYMBOL_REFERENCES_LOCAL (info, h))) 1867 { 1868 /* This is actually a static link, or it is a 1869 -Bsymbolic link and the symbol is defined 1870 locally, or the symbol was forced to be local 1871 because of a version file. We must initialize 1872 this entry in the global offset table. Since the 1873 offset must always be a multiple of the word size, 1874 we use the least significant bit to record whether 1875 we have initialized it already. 1876 1877 When doing a dynamic link, we create a .rela.got 1878 relocation entry to initialize the value. This 1879 is done in the finish_dynamic_symbol routine. */ 1880 if ((off & 1) != 0) 1881 off &= ~1; 1882 else 1883 { 1884 bfd_put_NN (output_bfd, relocation, 1885 htab->elf.sgot->contents + off); 1886 h->got.offset |= 1; 1887 } 1888 } 1889 else 1890 unresolved_reloc = FALSE; 1891 } 1892 else 1893 { 1894 BFD_ASSERT (local_got_offsets != NULL 1895 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1896 1897 off = local_got_offsets[r_symndx]; 1898 1899 /* The offset must always be a multiple of the word size. 1900 So, we can use the least significant bit to record 1901 whether we have already processed this entry. */ 1902 if ((off & 1) != 0) 1903 off &= ~1; 1904 else 1905 { 1906 if (bfd_link_pic (info)) 1907 { 1908 asection *s; 1909 Elf_Internal_Rela outrel; 1910 1911 /* We need to generate a R_RISCV_RELATIVE reloc 1912 for the dynamic linker. */ 1913 s = htab->elf.srelgot; 1914 BFD_ASSERT (s != NULL); 1915 1916 outrel.r_offset = sec_addr (htab->elf.sgot) + off; 1917 outrel.r_info = 1918 ELFNN_R_INFO (0, R_RISCV_RELATIVE); 1919 outrel.r_addend = relocation; 1920 relocation = 0; 1921 riscv_elf_append_rela (output_bfd, s, &outrel); 1922 } 1923 1924 bfd_put_NN (output_bfd, relocation, 1925 htab->elf.sgot->contents + off); 1926 local_got_offsets[r_symndx] |= 1; 1927 } 1928 } 1929 relocation = sec_addr (htab->elf.sgot) + off; 1930 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation)) 1931 r = bfd_reloc_overflow; 1932 break; 1933 1934 case R_RISCV_ADD8: 1935 case R_RISCV_ADD16: 1936 case R_RISCV_ADD32: 1937 case R_RISCV_ADD64: 1938 { 1939 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd, 1940 contents + rel->r_offset); 1941 relocation = old_value + relocation; 1942 } 1943 break; 1944 1945 case R_RISCV_SUB6: 1946 case R_RISCV_SUB8: 1947 case R_RISCV_SUB16: 1948 case R_RISCV_SUB32: 1949 case R_RISCV_SUB64: 1950 { 1951 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd, 1952 contents + rel->r_offset); 1953 relocation = old_value - relocation; 1954 } 1955 break; 1956 1957 case R_RISCV_CALL_PLT: 1958 case R_RISCV_CALL: 1959 case R_RISCV_JAL: 1960 case R_RISCV_RVC_JUMP: 1961 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE) 1962 { 1963 /* Refer to the PLT entry. */ 1964 relocation = sec_addr (htab->elf.splt) + h->plt.offset; 1965 unresolved_reloc = FALSE; 1966 } 1967 break; 1968 1969 case R_RISCV_TPREL_HI20: 1970 relocation = tpoff (info, relocation); 1971 break; 1972 1973 case R_RISCV_TPREL_LO12_I: 1974 case R_RISCV_TPREL_LO12_S: 1975 relocation = tpoff (info, relocation); 1976 break; 1977 1978 case R_RISCV_TPREL_I: 1979 case R_RISCV_TPREL_S: 1980 relocation = tpoff (info, relocation); 1981 if (VALID_ITYPE_IMM (relocation + rel->r_addend)) 1982 { 1983 /* We can use tp as the base register. */ 1984 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 1985 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 1986 insn |= X_TP << OP_SH_RS1; 1987 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 1988 } 1989 else 1990 r = bfd_reloc_overflow; 1991 break; 1992 1993 case R_RISCV_GPREL_I: 1994 case R_RISCV_GPREL_S: 1995 { 1996 bfd_vma gp = riscv_global_pointer_value (info); 1997 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend); 1998 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp)) 1999 { 2000 /* We can use x0 or gp as the base register. */ 2001 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 2002 insn &= ~(OP_MASK_RS1 << OP_SH_RS1); 2003 if (!x0_base) 2004 { 2005 rel->r_addend -= gp; 2006 insn |= X_GP << OP_SH_RS1; 2007 } 2008 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 2009 } 2010 else 2011 r = bfd_reloc_overflow; 2012 break; 2013 } 2014 2015 case R_RISCV_PCREL_HI20: 2016 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, 2017 relocation + rel->r_addend)) 2018 r = bfd_reloc_overflow; 2019 break; 2020 2021 case R_RISCV_PCREL_LO12_I: 2022 case R_RISCV_PCREL_LO12_S: 2023 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info, 2024 howto, rel, relocation, name, 2025 contents)) 2026 continue; 2027 r = bfd_reloc_overflow; 2028 break; 2029 2030 case R_RISCV_TLS_DTPREL32: 2031 case R_RISCV_TLS_DTPREL64: 2032 relocation = dtpoff (info, relocation); 2033 break; 2034 2035 case R_RISCV_32: 2036 case R_RISCV_64: 2037 if ((input_section->flags & SEC_ALLOC) == 0) 2038 break; 2039 2040 if ((bfd_link_pic (info) 2041 && (h == NULL 2042 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2043 || h->root.type != bfd_link_hash_undefweak) 2044 && (! howto->pc_relative 2045 || !SYMBOL_CALLS_LOCAL (info, h))) 2046 || (!bfd_link_pic (info) 2047 && h != NULL 2048 && h->dynindx != -1 2049 && !h->non_got_ref 2050 && ((h->def_dynamic 2051 && !h->def_regular) 2052 || h->root.type == bfd_link_hash_undefweak 2053 || h->root.type == bfd_link_hash_undefined))) 2054 { 2055 Elf_Internal_Rela outrel; 2056 bfd_boolean skip_static_relocation, skip_dynamic_relocation; 2057 2058 /* When generating a shared object, these relocations 2059 are copied into the output file to be resolved at run 2060 time. */ 2061 2062 outrel.r_offset = 2063 _bfd_elf_section_offset (output_bfd, info, input_section, 2064 rel->r_offset); 2065 skip_static_relocation = outrel.r_offset != (bfd_vma) -2; 2066 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2; 2067 outrel.r_offset += sec_addr (input_section); 2068 2069 if (skip_dynamic_relocation) 2070 memset (&outrel, 0, sizeof outrel); 2071 else if (h != NULL && h->dynindx != -1 2072 && !(bfd_link_pic (info) 2073 && SYMBOLIC_BIND (info, h) 2074 && h->def_regular)) 2075 { 2076 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type); 2077 outrel.r_addend = rel->r_addend; 2078 } 2079 else 2080 { 2081 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE); 2082 outrel.r_addend = relocation + rel->r_addend; 2083 } 2084 2085 riscv_elf_append_rela (output_bfd, sreloc, &outrel); 2086 if (skip_static_relocation) 2087 continue; 2088 } 2089 break; 2090 2091 case R_RISCV_TLS_GOT_HI20: 2092 is_ie = TRUE; 2093 /* Fall through. */ 2094 2095 case R_RISCV_TLS_GD_HI20: 2096 if (h != NULL) 2097 { 2098 off = h->got.offset; 2099 h->got.offset |= 1; 2100 } 2101 else 2102 { 2103 off = local_got_offsets[r_symndx]; 2104 local_got_offsets[r_symndx] |= 1; 2105 } 2106 2107 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx); 2108 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD)); 2109 /* If this symbol is referenced by both GD and IE TLS, the IE 2110 reference's GOT slot follows the GD reference's slots. */ 2111 ie_off = 0; 2112 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE)) 2113 ie_off = 2 * GOT_ENTRY_SIZE; 2114 2115 if ((off & 1) != 0) 2116 off &= ~1; 2117 else 2118 { 2119 Elf_Internal_Rela outrel; 2120 int indx = 0; 2121 bfd_boolean need_relocs = FALSE; 2122 2123 if (htab->elf.srelgot == NULL) 2124 abort (); 2125 2126 if (h != NULL) 2127 { 2128 bfd_boolean dyn, pic; 2129 dyn = htab->elf.dynamic_sections_created; 2130 pic = bfd_link_pic (info); 2131 2132 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h) 2133 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h))) 2134 indx = h->dynindx; 2135 } 2136 2137 /* The GOT entries have not been initialized yet. Do it 2138 now, and emit any relocations. */ 2139 if ((bfd_link_pic (info) || indx != 0) 2140 && (h == NULL 2141 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2142 || h->root.type != bfd_link_hash_undefweak)) 2143 need_relocs = TRUE; 2144 2145 if (tls_type & GOT_TLS_GD) 2146 { 2147 if (need_relocs) 2148 { 2149 outrel.r_offset = sec_addr (htab->elf.sgot) + off; 2150 outrel.r_addend = 0; 2151 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN); 2152 bfd_put_NN (output_bfd, 0, 2153 htab->elf.sgot->contents + off); 2154 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 2155 if (indx == 0) 2156 { 2157 BFD_ASSERT (! unresolved_reloc); 2158 bfd_put_NN (output_bfd, 2159 dtpoff (info, relocation), 2160 (htab->elf.sgot->contents + off + 2161 RISCV_ELF_WORD_BYTES)); 2162 } 2163 else 2164 { 2165 bfd_put_NN (output_bfd, 0, 2166 (htab->elf.sgot->contents + off + 2167 RISCV_ELF_WORD_BYTES)); 2168 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN); 2169 outrel.r_offset += RISCV_ELF_WORD_BYTES; 2170 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 2171 } 2172 } 2173 else 2174 { 2175 /* If we are not emitting relocations for a 2176 general dynamic reference, then we must be in a 2177 static link or an executable link with the 2178 symbol binding locally. Mark it as belonging 2179 to module 1, the executable. */ 2180 bfd_put_NN (output_bfd, 1, 2181 htab->elf.sgot->contents + off); 2182 bfd_put_NN (output_bfd, 2183 dtpoff (info, relocation), 2184 (htab->elf.sgot->contents + off + 2185 RISCV_ELF_WORD_BYTES)); 2186 } 2187 } 2188 2189 if (tls_type & GOT_TLS_IE) 2190 { 2191 if (need_relocs) 2192 { 2193 bfd_put_NN (output_bfd, 0, 2194 htab->elf.sgot->contents + off + ie_off); 2195 outrel.r_offset = sec_addr (htab->elf.sgot) 2196 + off + ie_off; 2197 outrel.r_addend = 0; 2198 if (indx == 0) 2199 outrel.r_addend = tpoff (info, relocation); 2200 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN); 2201 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 2202 } 2203 else 2204 { 2205 bfd_put_NN (output_bfd, tpoff (info, relocation), 2206 htab->elf.sgot->contents + off + ie_off); 2207 } 2208 } 2209 } 2210 2211 BFD_ASSERT (off < (bfd_vma) -2); 2212 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0); 2213 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation)) 2214 r = bfd_reloc_overflow; 2215 unresolved_reloc = FALSE; 2216 break; 2217 2218 default: 2219 r = bfd_reloc_notsupported; 2220 } 2221 2222 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 2223 because such sections are not SEC_ALLOC and thus ld.so will 2224 not process them. */ 2225 if (unresolved_reloc 2226 && !((input_section->flags & SEC_DEBUGGING) != 0 2227 && h->def_dynamic) 2228 && _bfd_elf_section_offset (output_bfd, info, input_section, 2229 rel->r_offset) != (bfd_vma) -1) 2230 { 2231 (*_bfd_error_handler) 2232 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 2233 input_bfd, 2234 input_section, 2235 (long) rel->r_offset, 2236 howto->name, 2237 h->root.root.string); 2238 continue; 2239 } 2240 2241 if (r == bfd_reloc_ok) 2242 r = perform_relocation (howto, rel, relocation, input_section, 2243 input_bfd, contents); 2244 2245 switch (r) 2246 { 2247 case bfd_reloc_ok: 2248 continue; 2249 2250 case bfd_reloc_overflow: 2251 info->callbacks->reloc_overflow 2252 (info, (h ? &h->root : NULL), name, howto->name, 2253 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 2254 break; 2255 2256 case bfd_reloc_undefined: 2257 info->callbacks->undefined_symbol 2258 (info, name, input_bfd, input_section, rel->r_offset, 2259 TRUE); 2260 break; 2261 2262 case bfd_reloc_outofrange: 2263 msg = _("internal error: out of range error"); 2264 break; 2265 2266 case bfd_reloc_notsupported: 2267 msg = _("internal error: unsupported relocation error"); 2268 break; 2269 2270 case bfd_reloc_dangerous: 2271 msg = _("internal error: dangerous relocation"); 2272 break; 2273 2274 default: 2275 msg = _("internal error: unknown error"); 2276 break; 2277 } 2278 2279 if (msg) 2280 info->callbacks->warning 2281 (info, msg, name, input_bfd, input_section, rel->r_offset); 2282 goto out; 2283 } 2284 2285 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs); 2286out: 2287 riscv_free_pcrel_relocs (&pcrel_relocs); 2288 return ret; 2289} 2290 2291/* Finish up dynamic symbol handling. We set the contents of various 2292 dynamic sections here. */ 2293 2294static bfd_boolean 2295riscv_elf_finish_dynamic_symbol (bfd *output_bfd, 2296 struct bfd_link_info *info, 2297 struct elf_link_hash_entry *h, 2298 Elf_Internal_Sym *sym) 2299{ 2300 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 2301 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 2302 2303 if (h->plt.offset != (bfd_vma) -1) 2304 { 2305 /* We've decided to create a PLT entry for this symbol. */ 2306 bfd_byte *loc; 2307 bfd_vma i, header_address, plt_idx, got_address; 2308 uint32_t plt_entry[PLT_ENTRY_INSNS]; 2309 Elf_Internal_Rela rela; 2310 2311 BFD_ASSERT (h->dynindx != -1); 2312 2313 /* Calculate the address of the PLT header. */ 2314 header_address = sec_addr (htab->elf.splt); 2315 2316 /* Calculate the index of the entry. */ 2317 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE; 2318 2319 /* Calculate the address of the .got.plt entry. */ 2320 got_address = riscv_elf_got_plt_val (plt_idx, info); 2321 2322 /* Find out where the .plt entry should go. */ 2323 loc = htab->elf.splt->contents + h->plt.offset; 2324 2325 /* Fill in the PLT entry itself. */ 2326 riscv_make_plt_entry (got_address, header_address + h->plt.offset, 2327 plt_entry); 2328 for (i = 0; i < PLT_ENTRY_INSNS; i++) 2329 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i); 2330 2331 /* Fill in the initial value of the .got.plt entry. */ 2332 loc = htab->elf.sgotplt->contents 2333 + (got_address - sec_addr (htab->elf.sgotplt)); 2334 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc); 2335 2336 /* Fill in the entry in the .rela.plt section. */ 2337 rela.r_offset = got_address; 2338 rela.r_addend = 0; 2339 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT); 2340 2341 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela); 2342 bed->s->swap_reloca_out (output_bfd, &rela, loc); 2343 2344 if (!h->def_regular) 2345 { 2346 /* Mark the symbol as undefined, rather than as defined in 2347 the .plt section. Leave the value alone. */ 2348 sym->st_shndx = SHN_UNDEF; 2349 /* If the symbol is weak, we do need to clear the value. 2350 Otherwise, the PLT entry would provide a definition for 2351 the symbol even if the symbol wasn't defined anywhere, 2352 and so the symbol would never be NULL. */ 2353 if (!h->ref_regular_nonweak) 2354 sym->st_value = 0; 2355 } 2356 } 2357 2358 if (h->got.offset != (bfd_vma) -1 2359 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE))) 2360 { 2361 asection *sgot; 2362 asection *srela; 2363 Elf_Internal_Rela rela; 2364 2365 /* This symbol has an entry in the GOT. Set it up. */ 2366 2367 sgot = htab->elf.sgot; 2368 srela = htab->elf.srelgot; 2369 BFD_ASSERT (sgot != NULL && srela != NULL); 2370 2371 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1); 2372 2373 /* If this is a -Bsymbolic link, and the symbol is defined 2374 locally, we just want to emit a RELATIVE reloc. Likewise if 2375 the symbol was forced to be local because of a version file. 2376 The entry in the global offset table will already have been 2377 initialized in the relocate_section function. */ 2378 if (bfd_link_pic (info) 2379 && (info->symbolic || h->dynindx == -1) 2380 && h->def_regular) 2381 { 2382 asection *sec = h->root.u.def.section; 2383 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE); 2384 rela.r_addend = (h->root.u.def.value 2385 + sec->output_section->vma 2386 + sec->output_offset); 2387 } 2388 else 2389 { 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 2428static bfd_boolean 2429riscv_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 2468static bfd_boolean 2469riscv_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 != TRUE) 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 riscv_make_plt_header (sec_addr (htab->elf.sgotplt), 2501 sec_addr (splt), plt_header); 2502 2503 for (i = 0; i < PLT_HEADER_INSNS; i++) 2504 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i); 2505 } 2506 2507 elf_section_data (splt->output_section)->this_hdr.sh_entsize 2508 = PLT_ENTRY_SIZE; 2509 } 2510 2511 if (htab->elf.sgotplt) 2512 { 2513 asection *output_section = htab->elf.sgotplt->output_section; 2514 2515 if (bfd_is_abs_section (output_section)) 2516 { 2517 (*_bfd_error_handler) 2518 (_("discarded output section: `%A'"), htab->elf.sgotplt); 2519 return FALSE; 2520 } 2521 2522 if (htab->elf.sgotplt->size > 0) 2523 { 2524 /* Write the first two entries in .got.plt, needed for the dynamic 2525 linker. */ 2526 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents); 2527 bfd_put_NN (output_bfd, (bfd_vma) 0, 2528 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE); 2529 } 2530 2531 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE; 2532 } 2533 2534 if (htab->elf.sgot) 2535 { 2536 asection *output_section = htab->elf.sgot->output_section; 2537 2538 if (htab->elf.sgot->size > 0) 2539 { 2540 /* Set the first entry in the global offset table to the address of 2541 the dynamic section. */ 2542 bfd_vma val = sdyn ? sec_addr (sdyn) : 0; 2543 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents); 2544 } 2545 2546 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE; 2547 } 2548 2549 return TRUE; 2550} 2551 2552/* Return address for Ith PLT stub in section PLT, for relocation REL 2553 or (bfd_vma) -1 if it should not be included. */ 2554 2555static bfd_vma 2556riscv_elf_plt_sym_val (bfd_vma i, const asection *plt, 2557 const arelent *rel ATTRIBUTE_UNUSED) 2558{ 2559 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE; 2560} 2561 2562static enum elf_reloc_type_class 2563riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 2564 const asection *rel_sec ATTRIBUTE_UNUSED, 2565 const Elf_Internal_Rela *rela) 2566{ 2567 switch (ELFNN_R_TYPE (rela->r_info)) 2568 { 2569 case R_RISCV_RELATIVE: 2570 return reloc_class_relative; 2571 case R_RISCV_JUMP_SLOT: 2572 return reloc_class_plt; 2573 case R_RISCV_COPY: 2574 return reloc_class_copy; 2575 default: 2576 return reloc_class_normal; 2577 } 2578} 2579 2580/* Merge backend specific data from an object file to the output 2581 object file when linking. */ 2582 2583static bfd_boolean 2584_bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 2585{ 2586 bfd *obfd = info->output_bfd; 2587 flagword new_flags = elf_elfheader (ibfd)->e_flags; 2588 flagword old_flags = elf_elfheader (obfd)->e_flags; 2589 2590 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd)) 2591 return TRUE; 2592 2593 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0) 2594 { 2595 (*_bfd_error_handler) 2596 (_("%B: ABI is incompatible with that of the selected emulation:\n" 2597 " target emulation `%s' does not match `%s'"), 2598 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd)); 2599 return FALSE; 2600 } 2601 2602 if (!_bfd_elf_merge_object_attributes (ibfd, info)) 2603 return FALSE; 2604 2605 if (! elf_flags_init (obfd)) 2606 { 2607 elf_flags_init (obfd) = TRUE; 2608 elf_elfheader (obfd)->e_flags = new_flags; 2609 return TRUE; 2610 } 2611 2612 /* Disallow linking different float ABIs. */ 2613 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI) 2614 { 2615 (*_bfd_error_handler) 2616 (_("%B: can't link hard-float modules with soft-float modules"), ibfd); 2617 goto fail; 2618 } 2619 2620 /* Allow linking RVC and non-RVC, and keep the RVC flag. */ 2621 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC; 2622 2623 return TRUE; 2624 2625fail: 2626 bfd_set_error (bfd_error_bad_value); 2627 return FALSE; 2628} 2629 2630/* Delete some bytes from a section while relaxing. */ 2631 2632static bfd_boolean 2633riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count) 2634{ 2635 unsigned int i, symcount; 2636 bfd_vma toaddr = sec->size; 2637 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd); 2638 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2639 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 2640 struct bfd_elf_section_data *data = elf_section_data (sec); 2641 bfd_byte *contents = data->this_hdr.contents; 2642 2643 /* Actually delete the bytes. */ 2644 sec->size -= count; 2645 memmove (contents + addr, contents + addr + count, toaddr - addr - count); 2646 2647 /* Adjust the location of all of the relocs. Note that we need not 2648 adjust the addends, since all PC-relative references must be against 2649 symbols, which we will adjust below. */ 2650 for (i = 0; i < sec->reloc_count; i++) 2651 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr) 2652 data->relocs[i].r_offset -= count; 2653 2654 /* Adjust the local symbols defined in this section. */ 2655 for (i = 0; i < symtab_hdr->sh_info; i++) 2656 { 2657 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i; 2658 if (sym->st_shndx == sec_shndx) 2659 { 2660 /* If the symbol is in the range of memory we just moved, we 2661 have to adjust its value. */ 2662 if (sym->st_value > addr && sym->st_value <= toaddr) 2663 sym->st_value -= count; 2664 2665 /* If the symbol *spans* the bytes we just deleted (i.e. its 2666 *end* is in the moved bytes but its *start* isn't), then we 2667 must adjust its size. */ 2668 if (sym->st_value <= addr 2669 && sym->st_value + sym->st_size > addr 2670 && sym->st_value + sym->st_size <= toaddr) 2671 sym->st_size -= count; 2672 } 2673 } 2674 2675 /* Now adjust the global symbols defined in this section. */ 2676 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym)) 2677 - symtab_hdr->sh_info); 2678 2679 for (i = 0; i < symcount; i++) 2680 { 2681 struct elf_link_hash_entry *sym_hash = sym_hashes[i]; 2682 2683 if ((sym_hash->root.type == bfd_link_hash_defined 2684 || sym_hash->root.type == bfd_link_hash_defweak) 2685 && sym_hash->root.u.def.section == sec) 2686 { 2687 /* As above, adjust the value if needed. */ 2688 if (sym_hash->root.u.def.value > addr 2689 && sym_hash->root.u.def.value <= toaddr) 2690 sym_hash->root.u.def.value -= count; 2691 2692 /* As above, adjust the size if needed. */ 2693 if (sym_hash->root.u.def.value <= addr 2694 && sym_hash->root.u.def.value + sym_hash->size > addr 2695 && sym_hash->root.u.def.value + sym_hash->size <= toaddr) 2696 sym_hash->size -= count; 2697 } 2698 } 2699 2700 return TRUE; 2701} 2702 2703typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *, 2704 struct bfd_link_info *, 2705 Elf_Internal_Rela *, 2706 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *); 2707 2708/* Relax AUIPC + JALR into JAL. */ 2709 2710static bfd_boolean 2711_bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec, 2712 struct bfd_link_info *link_info, 2713 Elf_Internal_Rela *rel, 2714 bfd_vma symval, 2715 bfd_vma max_alignment, 2716 bfd_vma reserve_size ATTRIBUTE_UNUSED, 2717 bfd_boolean *again) 2718{ 2719 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 2720 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset); 2721 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH; 2722 bfd_vma auipc, jalr; 2723 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC; 2724 2725 /* If the call crosses section boundaries, an alignment directive could 2726 cause the PC-relative offset to later increase. */ 2727 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section) 2728 foff += (foff < 0 ? -max_alignment : max_alignment); 2729 2730 /* See if this function call can be shortened. */ 2731 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero)) 2732 return TRUE; 2733 2734 /* Shorten the function call. */ 2735 BFD_ASSERT (rel->r_offset + 8 <= sec->size); 2736 2737 auipc = bfd_get_32 (abfd, contents + rel->r_offset); 2738 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4); 2739 rd = (jalr >> OP_SH_RD) & OP_MASK_RD; 2740 rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32; 2741 2742 if (rvc && (rd == 0 || rd == X_RA)) 2743 { 2744 /* Relax to C.J[AL] rd, addr. */ 2745 r_type = R_RISCV_RVC_JUMP; 2746 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL; 2747 len = 2; 2748 } 2749 else if (VALID_UJTYPE_IMM (foff)) 2750 { 2751 /* Relax to JAL rd, addr. */ 2752 r_type = R_RISCV_JAL; 2753 auipc = MATCH_JAL | (rd << OP_SH_RD); 2754 } 2755 else /* near_zero */ 2756 { 2757 /* Relax to JALR rd, x0, addr. */ 2758 r_type = R_RISCV_LO12_I; 2759 auipc = MATCH_JALR | (rd << OP_SH_RD); 2760 } 2761 2762 /* Replace the R_RISCV_CALL reloc. */ 2763 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type); 2764 /* Replace the AUIPC. */ 2765 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset); 2766 2767 /* Delete unnecessary JALR. */ 2768 *again = TRUE; 2769 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len); 2770} 2771 2772/* Traverse all output sections and return the max alignment. */ 2773 2774static bfd_vma 2775_bfd_riscv_get_max_alignment (asection *sec) 2776{ 2777 unsigned int max_alignment_power = 0; 2778 asection *o; 2779 2780 for (o = sec->output_section->owner->sections; o != NULL; o = o->next) 2781 { 2782 if (o->alignment_power > max_alignment_power) 2783 max_alignment_power = o->alignment_power; 2784 } 2785 2786 return (bfd_vma) 1 << max_alignment_power; 2787} 2788 2789/* Relax non-PIC global variable references. */ 2790 2791static bfd_boolean 2792_bfd_riscv_relax_lui (bfd *abfd, 2793 asection *sec, 2794 asection *sym_sec, 2795 struct bfd_link_info *link_info, 2796 Elf_Internal_Rela *rel, 2797 bfd_vma symval, 2798 bfd_vma max_alignment, 2799 bfd_vma reserve_size, 2800 bfd_boolean *again) 2801{ 2802 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 2803 bfd_vma gp = riscv_global_pointer_value (link_info); 2804 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC; 2805 2806 /* Mergeable symbols and code might later move out of range. */ 2807 if (sym_sec->flags & (SEC_MERGE | SEC_CODE)) 2808 return TRUE; 2809 2810 BFD_ASSERT (rel->r_offset + 4 <= sec->size); 2811 2812 if (gp) 2813 { 2814 /* If gp and the symbol are in the same output section, then 2815 consider only that section's alignment. */ 2816 struct bfd_link_hash_entry *h = 2817 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, 2818 TRUE); 2819 if (h->u.def.section->output_section == sym_sec->output_section) 2820 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power; 2821 } 2822 2823 /* Is the reference in range of x0 or gp? 2824 Valid gp range conservatively because of alignment issue. */ 2825 if (VALID_ITYPE_IMM (symval) 2826 || (symval >= gp 2827 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size)) 2828 || (symval < gp 2829 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size))) 2830 { 2831 unsigned sym = ELFNN_R_SYM (rel->r_info); 2832 switch (ELFNN_R_TYPE (rel->r_info)) 2833 { 2834 case R_RISCV_LO12_I: 2835 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I); 2836 return TRUE; 2837 2838 case R_RISCV_LO12_S: 2839 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S); 2840 return TRUE; 2841 2842 case R_RISCV_HI20: 2843 /* We can delete the unnecessary LUI and reloc. */ 2844 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE); 2845 *again = TRUE; 2846 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4); 2847 2848 default: 2849 abort (); 2850 } 2851 } 2852 2853 /* Can we relax LUI to C.LUI? Alignment might move the section forward; 2854 account for this assuming page alignment at worst. */ 2855 if (use_rvc 2856 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20 2857 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval)) 2858 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE))) 2859 { 2860 /* Replace LUI with C.LUI if legal (i.e., rd != x2/sp). */ 2861 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset); 2862 if (((lui >> OP_SH_RD) & OP_MASK_RD) == X_SP) 2863 return TRUE; 2864 2865 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI; 2866 bfd_put_32 (abfd, lui, contents + rel->r_offset); 2867 2868 /* Replace the R_RISCV_HI20 reloc. */ 2869 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI); 2870 2871 *again = TRUE; 2872 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2); 2873 } 2874 2875 return TRUE; 2876} 2877 2878/* Relax non-PIC TLS references. */ 2879 2880static bfd_boolean 2881_bfd_riscv_relax_tls_le (bfd *abfd, 2882 asection *sec, 2883 asection *sym_sec ATTRIBUTE_UNUSED, 2884 struct bfd_link_info *link_info, 2885 Elf_Internal_Rela *rel, 2886 bfd_vma symval, 2887 bfd_vma max_alignment ATTRIBUTE_UNUSED, 2888 bfd_vma reserve_size ATTRIBUTE_UNUSED, 2889 bfd_boolean *again) 2890{ 2891 /* See if this symbol is in range of tp. */ 2892 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0) 2893 return TRUE; 2894 2895 BFD_ASSERT (rel->r_offset + 4 <= sec->size); 2896 switch (ELFNN_R_TYPE (rel->r_info)) 2897 { 2898 case R_RISCV_TPREL_LO12_I: 2899 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I); 2900 return TRUE; 2901 2902 case R_RISCV_TPREL_LO12_S: 2903 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S); 2904 return TRUE; 2905 2906 case R_RISCV_TPREL_HI20: 2907 case R_RISCV_TPREL_ADD: 2908 /* We can delete the unnecessary instruction and reloc. */ 2909 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE); 2910 *again = TRUE; 2911 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4); 2912 2913 default: 2914 abort (); 2915 } 2916} 2917 2918/* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */ 2919 2920static bfd_boolean 2921_bfd_riscv_relax_align (bfd *abfd, asection *sec, 2922 asection *sym_sec ATTRIBUTE_UNUSED, 2923 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 2924 Elf_Internal_Rela *rel, 2925 bfd_vma symval, 2926 bfd_vma max_alignment ATTRIBUTE_UNUSED, 2927 bfd_vma reserve_size ATTRIBUTE_UNUSED, 2928 bfd_boolean *again ATTRIBUTE_UNUSED) 2929{ 2930 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents; 2931 bfd_vma alignment = 1, pos; 2932 while (alignment <= rel->r_addend) 2933 alignment *= 2; 2934 2935 symval -= rel->r_addend; 2936 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment; 2937 bfd_vma nop_bytes = aligned_addr - symval; 2938 2939 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */ 2940 sec->sec_flg0 = TRUE; 2941 2942 /* Make sure there are enough NOPs to actually achieve the alignment. */ 2943 if (rel->r_addend < nop_bytes) 2944 return FALSE; 2945 2946 /* Delete the reloc. */ 2947 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE); 2948 2949 /* If the number of NOPs is already correct, there's nothing to do. */ 2950 if (nop_bytes == rel->r_addend) 2951 return TRUE; 2952 2953 /* Write as many RISC-V NOPs as we need. */ 2954 for (pos = 0; pos < (nop_bytes & -4); pos += 4) 2955 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos); 2956 2957 /* Write a final RVC NOP if need be. */ 2958 if (nop_bytes % 4 != 0) 2959 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos); 2960 2961 /* Delete the excess bytes. */ 2962 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes, 2963 rel->r_addend - nop_bytes); 2964} 2965 2966/* Relax a section. Pass 0 shortens code sequences unless disabled. 2967 Pass 1, which cannot be disabled, handles code alignment directives. */ 2968 2969static bfd_boolean 2970_bfd_riscv_relax_section (bfd *abfd, asection *sec, 2971 struct bfd_link_info *info, 2972 bfd_boolean *again) 2973{ 2974 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd); 2975 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info); 2976 struct bfd_elf_section_data *data = elf_section_data (sec); 2977 Elf_Internal_Rela *relocs; 2978 bfd_boolean ret = FALSE; 2979 unsigned int i; 2980 bfd_vma max_alignment, reserve_size = 0; 2981 2982 *again = FALSE; 2983 2984 if (bfd_link_relocatable (info) 2985 || sec->sec_flg0 2986 || (sec->flags & SEC_RELOC) == 0 2987 || sec->reloc_count == 0 2988 || (info->disable_target_specific_optimizations 2989 && info->relax_pass == 0)) 2990 return TRUE; 2991 2992 /* Read this BFD's relocs if we haven't done so already. */ 2993 if (data->relocs) 2994 relocs = data->relocs; 2995 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 2996 info->keep_memory))) 2997 goto fail; 2998 2999 max_alignment = _bfd_riscv_get_max_alignment (sec); 3000 3001 /* Examine and consider relaxing each reloc. */ 3002 for (i = 0; i < sec->reloc_count; i++) 3003 { 3004 asection *sym_sec; 3005 Elf_Internal_Rela *rel = relocs + i; 3006 relax_func_t relax_func; 3007 int type = ELFNN_R_TYPE (rel->r_info); 3008 bfd_vma symval; 3009 3010 if (info->relax_pass == 0) 3011 { 3012 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT) 3013 relax_func = _bfd_riscv_relax_call; 3014 else if (type == R_RISCV_HI20 3015 || type == R_RISCV_LO12_I 3016 || type == R_RISCV_LO12_S) 3017 relax_func = _bfd_riscv_relax_lui; 3018 else if (type == R_RISCV_TPREL_HI20 3019 || type == R_RISCV_TPREL_ADD 3020 || type == R_RISCV_TPREL_LO12_I 3021 || type == R_RISCV_TPREL_LO12_S) 3022 relax_func = _bfd_riscv_relax_tls_le; 3023 else 3024 continue; 3025 3026 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */ 3027 if (i == sec->reloc_count - 1 3028 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX 3029 || rel->r_offset != (rel + 1)->r_offset) 3030 continue; 3031 3032 /* Skip over the R_RISCV_RELAX. */ 3033 i++; 3034 } 3035 else if (type == R_RISCV_ALIGN) 3036 relax_func = _bfd_riscv_relax_align; 3037 else 3038 continue; 3039 3040 data->relocs = relocs; 3041 3042 /* Read this BFD's contents if we haven't done so already. */ 3043 if (!data->this_hdr.contents 3044 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents)) 3045 goto fail; 3046 3047 /* Read this BFD's symbols if we haven't done so already. */ 3048 if (symtab_hdr->sh_info != 0 3049 && !symtab_hdr->contents 3050 && !(symtab_hdr->contents = 3051 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr, 3052 symtab_hdr->sh_info, 3053 0, NULL, NULL, NULL))) 3054 goto fail; 3055 3056 /* Get the value of the symbol referred to by the reloc. */ 3057 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info) 3058 { 3059 /* A local symbol. */ 3060 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents 3061 + ELFNN_R_SYM (rel->r_info)); 3062 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size 3063 ? 0 : isym->st_size - rel->r_addend; 3064 3065 if (isym->st_shndx == SHN_UNDEF) 3066 sym_sec = sec, symval = sec_addr (sec) + rel->r_offset; 3067 else 3068 { 3069 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd)); 3070 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section; 3071 if (sec_addr (sym_sec) == 0) 3072 continue; 3073 symval = sec_addr (sym_sec) + isym->st_value; 3074 } 3075 } 3076 else 3077 { 3078 unsigned long indx; 3079 struct elf_link_hash_entry *h; 3080 3081 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info; 3082 h = elf_sym_hashes (abfd)[indx]; 3083 3084 while (h->root.type == bfd_link_hash_indirect 3085 || h->root.type == bfd_link_hash_warning) 3086 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3087 3088 if (h->plt.offset != MINUS_ONE) 3089 symval = sec_addr (htab->elf.splt) + h->plt.offset; 3090 else if (h->root.u.def.section->output_section == NULL 3091 || (h->root.type != bfd_link_hash_defined 3092 && h->root.type != bfd_link_hash_defweak)) 3093 continue; 3094 else 3095 symval = sec_addr (h->root.u.def.section) + h->root.u.def.value; 3096 3097 if (h->type != STT_FUNC) 3098 reserve_size = 3099 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend; 3100 sym_sec = h->root.u.def.section; 3101 } 3102 3103 symval += rel->r_addend; 3104 3105 if (!relax_func (abfd, sec, sym_sec, info, rel, symval, 3106 max_alignment, reserve_size, again)) 3107 goto fail; 3108 } 3109 3110 ret = TRUE; 3111 3112fail: 3113 if (relocs != data->relocs) 3114 free (relocs); 3115 3116 return ret; 3117} 3118 3119#if ARCH_SIZE == 32 3120# define PRSTATUS_SIZE 0 /* FIXME */ 3121# define PRSTATUS_OFFSET_PR_CURSIG 12 3122# define PRSTATUS_OFFSET_PR_PID 24 3123# define PRSTATUS_OFFSET_PR_REG 72 3124# define ELF_GREGSET_T_SIZE 128 3125# define PRPSINFO_SIZE 128 3126# define PRPSINFO_OFFSET_PR_PID 16 3127# define PRPSINFO_OFFSET_PR_FNAME 32 3128# define PRPSINFO_OFFSET_PR_PSARGS 48 3129#else 3130# define PRSTATUS_SIZE 376 3131# define PRSTATUS_OFFSET_PR_CURSIG 12 3132# define PRSTATUS_OFFSET_PR_PID 32 3133# define PRSTATUS_OFFSET_PR_REG 112 3134# define ELF_GREGSET_T_SIZE 256 3135# define PRPSINFO_SIZE 136 3136# define PRPSINFO_OFFSET_PR_PID 24 3137# define PRPSINFO_OFFSET_PR_FNAME 40 3138# define PRPSINFO_OFFSET_PR_PSARGS 56 3139#endif 3140 3141/* Support for core dump NOTE sections. */ 3142 3143static bfd_boolean 3144riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 3145{ 3146 switch (note->descsz) 3147 { 3148 default: 3149 return FALSE; 3150 3151 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */ 3152 /* pr_cursig */ 3153 elf_tdata (abfd)->core->signal 3154 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG); 3155 3156 /* pr_pid */ 3157 elf_tdata (abfd)->core->lwpid 3158 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID); 3159 break; 3160 } 3161 3162 /* Make a ".reg/999" section. */ 3163 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE, 3164 note->descpos + PRSTATUS_OFFSET_PR_REG); 3165} 3166 3167static bfd_boolean 3168riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 3169{ 3170 switch (note->descsz) 3171 { 3172 default: 3173 return FALSE; 3174 3175 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */ 3176 /* pr_pid */ 3177 elf_tdata (abfd)->core->pid 3178 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID); 3179 3180 /* pr_fname */ 3181 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup 3182 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16); 3183 3184 /* pr_psargs */ 3185 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup 3186 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80); 3187 break; 3188 } 3189 3190 /* Note that for some reason, a spurious space is tacked 3191 onto the end of the args in some (at least one anyway) 3192 implementations, so strip it off if it exists. */ 3193 3194 { 3195 char *command = elf_tdata (abfd)->core->command; 3196 int n = strlen (command); 3197 3198 if (0 < n && command[n - 1] == ' ') 3199 command[n - 1] = '\0'; 3200 } 3201 3202 return TRUE; 3203} 3204 3205/* Set the right mach type. */ 3206static bfd_boolean 3207riscv_elf_object_p (bfd *abfd) 3208{ 3209 /* There are only two mach types in RISCV currently. */ 3210 if (strcmp (abfd->xvec->name, "elf32-littleriscv") == 0) 3211 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv32); 3212 else 3213 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv64); 3214 3215 return TRUE; 3216} 3217 3218 3219#define TARGET_LITTLE_SYM riscv_elfNN_vec 3220#define TARGET_LITTLE_NAME "elfNN-littleriscv" 3221 3222#define elf_backend_reloc_type_class riscv_reloc_type_class 3223 3224#define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup 3225#define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create 3226#define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup 3227#define bfd_elfNN_bfd_merge_private_bfd_data \ 3228 _bfd_riscv_elf_merge_private_bfd_data 3229 3230#define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol 3231#define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections 3232#define elf_backend_check_relocs riscv_elf_check_relocs 3233#define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol 3234#define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections 3235#define elf_backend_relocate_section riscv_elf_relocate_section 3236#define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol 3237#define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections 3238#define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook 3239#define elf_backend_gc_sweep_hook riscv_elf_gc_sweep_hook 3240#define elf_backend_plt_sym_val riscv_elf_plt_sym_val 3241#define elf_backend_grok_prstatus riscv_elf_grok_prstatus 3242#define elf_backend_grok_psinfo riscv_elf_grok_psinfo 3243#define elf_backend_object_p riscv_elf_object_p 3244#define elf_info_to_howto_rel NULL 3245#define elf_info_to_howto riscv_info_to_howto_rela 3246#define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section 3247 3248#define elf_backend_init_index_section _bfd_elf_init_1_index_section 3249 3250#define elf_backend_can_gc_sections 1 3251#define elf_backend_can_refcount 1 3252#define elf_backend_want_got_plt 1 3253#define elf_backend_plt_readonly 1 3254#define elf_backend_plt_alignment 4 3255#define elf_backend_want_plt_sym 1 3256#define elf_backend_got_header_size (ARCH_SIZE / 8) 3257#define elf_backend_want_dynrelro 1 3258#define elf_backend_rela_normal 1 3259#define elf_backend_default_execstack 0 3260 3261#include "elfNN-target.h" 3262