#line 1 "elfnn-loongarch.c"

/* LoongArch-specific support for 64-bit ELF.

   Copyright (C) 2021-2025 Free Software Foundation, Inc.

   Contributed by Loongson Ltd.

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; see the file COPYING3.  If not,

   see <http://www.gnu.org/licenses/>.  */

#include "ansidecl.h"

#include "sysdep.h"

#include "bfd.h"

#include "libbfd.h"

#define ARCH_SIZE 64

#include "elf-bfd.h"

#include "objalloc.h"

#include "splay-tree.h"

#include "elf/loongarch.h"

#include "elfxx-loongarch.h"

#include "opcode/loongarch.h"

static bool

loongarch_info_to_howto_rela (bfd *abfd, arelent *cache_ptr,

            Elf_Internal_Rela *dst)

{

  cache_ptr->howto = loongarch_elf_rtype_to_howto (abfd,

               ELF64_R_TYPE (dst->r_info));

  return cache_ptr->howto != NULL;

}

/* LoongArch ELF linker hash entry.  */

struct loongarch_elf_link_hash_entry

{

  struct elf_link_hash_entry elf;

#define GOT_UNKNOWN 0

#define GOT_NORMAL  1

#define GOT_TLS_GD  2

#define GOT_TLS_IE  4

#define GOT_TLS_LE  8

#define GOT_TLS_GDESC 16

#define GOT_TLS_GD_BOTH_P(tls_type) \

  ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GDESC))

#define GOT_TLS_GD_ANY_P(tls_type) \

  ((tls_type & GOT_TLS_GD) || (tls_type & GOT_TLS_GDESC))

  char tls_type;

};

#define loongarch_elf_hash_entry(ent) \

  ((struct loongarch_elf_link_hash_entry *) (ent))

struct _bfd_loongarch_elf_obj_tdata

{

  struct elf_obj_tdata root;

  /* The tls_type for each local got entry.  */

  char *local_got_tls_type;

};

#define _bfd_loongarch_elf_tdata(abfd)  \

  ((struct _bfd_loongarch_elf_obj_tdata *) (abfd)->tdata.any)

#define _bfd_loongarch_elf_local_got_tls_type(abfd) \

  (_bfd_loongarch_elf_tdata (abfd)->local_got_tls_type)

#define _bfd_loongarch_elf_tls_type(abfd, h, symndx)      \

  (*((h) != NULL              \

     ? &loongarch_elf_hash_entry (h)->tls_type        \

     : &_bfd_loongarch_elf_local_got_tls_type (abfd)[symndx]))

#define is_loongarch_elf(bfd)           \

  (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \

   && elf_tdata (bfd) != NULL            \

   && elf_object_id (bfd) == LARCH_ELF_DATA)

static bool

elf64_loongarch_object (bfd *abfd)

{

  return bfd_elf_allocate_object (abfd,

          sizeof (struct _bfd_loongarch_elf_obj_tdata));

}

struct relr_entry

{

  asection *sec;

  bfd_vma off;

};

struct loongarch_elf_link_hash_table

{

  struct elf_link_hash_table elf;

  /* Short-cuts to get to dynamic linker sections.  */

  asection *sdyntdata;

  /* Small local sym to section mapping cache.  */

  struct sym_cache sym_cache;

  /* Used by local STT_GNU_IFUNC symbols.  */

  htab_t loc_hash_table;

  void *loc_hash_memory;

  /* The max alignment of output sections.  */

  bfd_vma max_alignment;

  /* The data segment phase, don't relax the section

     when it is exp_seg_relro_adjust.  */

  int *data_segment_phase;

  /* Array of relative relocs to be emitted in DT_RELR format.  */

  bfd_size_type relr_alloc;

  bfd_size_type relr_count;

  struct relr_entry *relr;

  /* Sorted output addresses of above relative relocs.  */

  bfd_vma *relr_sorted;

  /* Layout recomputation count.  */

  bfd_size_type relr_layout_iter;

  /* In BFD DT_RELR is implemented as a "relaxation."  If in a relax trip

     size_relative_relocs is updating the layout, relax_section may see

     a partially updated state (some sections have vma updated but the

     others do not), and it's unsafe to do the normal relaxation.  */

  bool layout_mutating_for_relr;

  /* Pending relaxation (byte deletion) operations meant for roughly

     sequential access.  */

  splay_tree pending_delete_ops;

};

struct loongarch_elf_section_data

{

  struct bfd_elf_section_data elf;

  /* &htab->relr[i] where i is the smallest number s.t.

     elf_section_data (htab->relr[i].sec) == &elf.

     NULL if there exists no such i.  */

  struct relr_entry *relr;

};

/* We need an additional field in elf_section_data to handle complex

   interactions between DT_RELR and relaxation.  */

static bool

loongarch_elf_new_section_hook (bfd *abfd, asection *sec)

{

  struct loongarch_elf_section_data *sdata;

  sdata = bfd_zalloc (abfd, sizeof (*sdata));

  if (!sdata)

    return false;

  sec->used_by_bfd = sdata;

  return _bfd_elf_new_section_hook (abfd, sec);

}

#define loongarch_elf_section_data(x) \

  ((struct loongarch_elf_section_data *) elf_section_data (x))

/* Get the LoongArch ELF linker hash table from a link_info structure.  */

#define loongarch_elf_hash_table(p)         \

    ((struct loongarch_elf_link_hash_table *) ((p)->hash))    \

#define MINUS_ONE ((bfd_vma) 0 - 1)

#define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)

#define LARCH_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)

#define LARCH_ELF_WORD_BYTES (1 << LARCH_ELF_LOG_WORD_BYTES)

#define PLT_HEADER_INSNS 8

#define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)

#define PLT_ENTRY_INSNS 4

#define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)

#define GOT_ENTRY_SIZE (LARCH_ELF_WORD_BYTES)

/* Reserve two entries of GOTPLT for ld.so, one is used for PLT

   resolver _dl_runtime_resolve, the other is used for link map.  */

#define GOTPLT_HEADER_SIZE (GOT_ENTRY_SIZE * 2)

#define elf_backend_want_got_plt 1

#define elf_backend_plt_readonly 1

#define elf_backend_want_plt_sym 1

#define elf_backend_plt_alignment 4

#define elf_backend_can_gc_sections 1

#define elf_backend_can_refcount 1

#define elf_backend_want_got_sym 1

#define elf_backend_got_header_size (GOT_ENTRY_SIZE * 1)

#define elf_backend_want_dynrelro 1

#define elf_backend_rela_normal 1

#define elf_backend_default_execstack 0

#define IS_LOONGARCH_TLS_TRANS_RELOC(R_TYPE)  \

  ((R_TYPE) == R_LARCH_TLS_DESC_PC_HI20        \

   || (R_TYPE) == R_LARCH_TLS_DESC_PC_LO12    \

   || (R_TYPE) == R_LARCH_TLS_DESC_LD        \

   || (R_TYPE) == R_LARCH_TLS_DESC_CALL        \

   || (R_TYPE) == R_LARCH_TLS_IE_PC_HI20      \

   || (R_TYPE) == R_LARCH_TLS_IE_PC_LO12)

#define IS_OUTDATED_TLS_LE_RELOC(R_TYPE)  \

  ((R_TYPE) == R_LARCH_TLS_LE_HI20    \

   || (R_TYPE) == R_LARCH_TLS_LE_LO12   \

   || (R_TYPE) == R_LARCH_TLS_LE64_LO20   \

   || (R_TYPE) == R_LARCH_TLS_LE64_HI12)

#define IS_CALL_RELOC(R_TYPE)   \

  ((R_TYPE) == R_LARCH_B26    \

   ||(R_TYPE) == R_LARCH_CALL36)

/* If TLS GD/IE need dynamic relocations, INDX will be the dynamic indx,

   and set NEED_RELOC to true used in allocate_dynrelocs and

   loongarch_elf_relocate_section for TLS GD/IE.  */

#define LARCH_TLS_GD_IE_NEED_DYN_RELOC(INFO, DYN, H, INDX, NEED_RELOC) \

  do \

    { \

      if ((H) != NULL \

    && (H)->dynindx != -1 \

    && WILL_CALL_FINISH_DYNAMIC_SYMBOL ((DYN), \

            bfd_link_pic (INFO), (H))) \

      (INDX) = (H)->dynindx; \

      if (((H) == NULL \

      || ELF_ST_VISIBILITY ((H)->other) == STV_DEFAULT \

      || (H)->root.type != bfd_link_hash_undefweak) \

      && (!bfd_link_executable (INFO) \

        || (INDX) != 0)) \

      (NEED_RELOC) = true; \

    } \

    while (0)

/* TL;DR always use it in this file instead when you want to type

   SYMBOL_REFERENCES_LOCAL.

   It's like SYMBOL_REFERENCES_LOCAL, but it returns true for local

   protected functions.  It happens to be same as SYMBOL_CALLS_LOCAL but

   let's not reuse SYMBOL_CALLS_LOCAL or "CALLS" may puzzle people.

   We do generate a PLT entry when someone attempts to la.pcrel an external

   function.  But we never really implemented "R_LARCH_COPY", thus we've

   never supported la.pcrel an external symbol unless the loaded address is

   only used for locating a function to be called.  Thus the PLT entry is

   a normal PLT entry, not intended to be a so-called "canonical PLT entry"

   on the ports supporting copy relocation.  So attempting to la.pcrel an

   external function will just break pointer equality, even it's a

   STV_DEFAULT function:

   $ cat t.c

   #include <assert.h>

   void check(void *p) {assert(p == check);}

   $ cat main.c

   extern void check(void *);

   int main(void) { check(check); }

   $ cc t.c -fPIC -shared -o t.so

   $ cc main.c -mdirect-extern-access t.so -Wl,-rpath=. -fpie -pie

   $ ./a.out

   a.out: t.c:2: check: Assertion `p == check' failed.

   Aborted

   Thus handling STV_PROTECTED function specially just fixes nothing:

   adding -fvisibility=protected compiling t.c will not magically fix

   the inequality.  The only possible and correct fix is not to use

   -mdirect-extern-access.

   So we should remove this special handling, because it's only an

   unsuccessful workaround for invalid code and it's penalizing valid

   code.  */

#define LARCH_REF_LOCAL(info, h) \

  (_bfd_elf_symbol_refs_local_p ((h), (info), true))

/* Generate a PLT header.  */

static bool

loongarch_make_plt_header (bfd_vma got_plt_addr, bfd_vma plt_header_addr,

         uint32_t *entry)

{

  bfd_vma pcrel = got_plt_addr - plt_header_addr;

  bfd_vma hi, lo;

  if (pcrel + 0x80000800 > 0xffffffff)

    {

      _bfd_error_handler (_("%#" PRIx64 " invaild imm"), (uint64_t) pcrel);

      bfd_set_error (bfd_error_bad_value);

      return false;

    }

  hi = ((pcrel + 0x800) >> 12) & 0xfffff;

  lo = pcrel & 0xfff;

  /* pcaddu12i  $t2, %hi(%pcrel(.got.plt))

     sub.[wd]   $t1, $t1, $t3

     ld.[wd]    $t3, $t2, %lo(%pcrel(.got.plt)) # _dl_runtime_resolve

     addi.[wd]  $t1, $t1, -(PLT_HEADER_SIZE + 12)

     addi.[wd]  $t0, $t2, %lo(%pcrel(.got.plt))

     srli.[wd]  $t1, $t1, log2(16 / GOT_ENTRY_SIZE)

     ld.[wd]    $t0, $t0, GOT_ENTRY_SIZE

     jirl   $r0, $t3, 0 */

  if (GOT_ENTRY_SIZE == 8)

    {

      entry[0] = 0x1c00000e | (hi & 0xfffff) << 5;

      entry[1] = 0x0011bdad;

      entry[2] = 0x28c001cf | (lo & 0xfff) << 10;

      entry[3] = 0x02c001ad | ((-(PLT_HEADER_SIZE + 12)) & 0xfff) << 10;

      entry[4] = 0x02c001cc | (lo & 0xfff) << 10;

      entry[5] = 0x004501ad | (4 - LARCH_ELF_LOG_WORD_BYTES) << 10;

      entry[6] = 0x28c0018c | GOT_ENTRY_SIZE << 10;

      entry[7] = 0x4c0001e0;

    }

  else

    {

      entry[0] = 0x1c00000e | (hi & 0xfffff) << 5;

      entry[1] = 0x00113dad;

      entry[2] = 0x288001cf | (lo & 0xfff) << 10;

      entry[3] = 0x028001ad | ((-(PLT_HEADER_SIZE + 12)) & 0xfff) << 10;

      entry[4] = 0x028001cc | (lo & 0xfff) << 10;

      entry[5] = 0x004481ad | (4 - LARCH_ELF_LOG_WORD_BYTES) << 10;

      entry[6] = 0x2880018c | GOT_ENTRY_SIZE << 10;

      entry[7] = 0x4c0001e0;

    }

  return true;

}

/* Generate a PLT entry.  */

static bool

loongarch_make_plt_entry (bfd_vma got_plt_entry_addr, bfd_vma plt_entry_addr,

        uint32_t *entry)

{

  bfd_vma pcrel = got_plt_entry_addr - plt_entry_addr;

  bfd_vma hi, lo;

  if (pcrel + 0x80000800 > 0xffffffff)

    {

      _bfd_error_handler (_("%#" PRIx64 " invaild imm"), (uint64_t) pcrel);

      bfd_set_error (bfd_error_bad_value);

      return false;

    }

  hi = ((pcrel + 0x800) >> 12) & 0xfffff;

  lo = pcrel & 0xfff;

  entry[0] = 0x1c00000f | (hi & 0xfffff) << 5;

  entry[1] = ((GOT_ENTRY_SIZE == 8 ? 0x28c001ef : 0x288001ef)

        | (lo & 0xfff) << 10);

  entry[2] = 0x4c0001ed;  /* jirl $r13, $15, 0 */

  entry[3] = 0x03400000;  /* nop */

  return true;

}

/* Create an entry in an LoongArch ELF linker hash table.  */

static struct bfd_hash_entry *

link_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table,

       const char *string)

{

  struct loongarch_elf_link_hash_entry *eh;

  /* Allocate the structure if it has not already been allocated by a

     subclass.  */

  if (entry == NULL)

    {

      entry = bfd_hash_allocate (table, sizeof (*eh));

      if (entry == NULL)

  return entry;

    }

  /* Call the allocation method of the superclass.  */

  entry = _bfd_elf_link_hash_newfunc (entry, table, string);

  if (entry != NULL)

    {

      eh = (struct loongarch_elf_link_hash_entry *) entry;

      eh->tls_type = GOT_UNKNOWN;

    }

  return entry;

}

/* Compute a hash of a local hash entry.  We use elf_link_hash_entry

  for local symbol so that we can handle local STT_GNU_IFUNC symbols

  as global symbol.  We reuse indx and dynstr_index for local symbol

  hash since they aren't used by global symbols in this backend.  */

static hashval_t

elf64_loongarch_local_htab_hash (const void *ptr)

{

  struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) ptr;

  return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);

}

/* Compare local hash entries.  */

static int

elf64_loongarch_local_htab_eq (const void *ptr1, const void *ptr2)

{

  struct elf_link_hash_entry *h1 = (struct elf_link_hash_entry *) ptr1;

  struct elf_link_hash_entry *h2 = (struct elf_link_hash_entry *) ptr2;

  return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;

}

/* Find and/or create a hash entry for local symbol.  */

static struct elf_link_hash_entry *

elf64_loongarch_get_local_sym_hash (struct loongarch_elf_link_hash_table *htab,

            bfd *abfd, const Elf_Internal_Rela *rel,

            bool create)

{

  struct loongarch_elf_link_hash_entry e, *ret;

  asection *sec = abfd->sections;

  hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id, ELF64_R_SYM (rel->r_info));

  void **slot;

  e.elf.indx = sec->id;

  e.elf.dynstr_index = ELF64_R_SYM (rel->r_info);

  slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,

           create ? INSERT : NO_INSERT);

  if (!slot)

    return NULL;

  if (*slot)

    {

      ret = (struct loongarch_elf_link_hash_entry *) *slot;

      return &ret->elf;

    }

  ret = ((struct loongarch_elf_link_hash_entry *)

   objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,

       sizeof (struct loongarch_elf_link_hash_entry)));

  if (ret)

    {

      memset (ret, 0, sizeof (*ret));

      ret->elf.indx = sec->id;

      ret->elf.pointer_equality_needed = 0;

      ret->elf.dynstr_index = ELF64_R_SYM (rel->r_info);

      ret->elf.dynindx = -1;

      ret->elf.needs_plt = 0;

      ret->elf.plt.refcount = -1;

      ret->elf.got.refcount = -1;

      ret->elf.def_dynamic = 0;

      ret->elf.def_regular = 1;

      ret->elf.ref_dynamic = 0; /* This should be always 0 for local.  */

      ret->elf.ref_regular = 0;

      ret->elf.forced_local = 1;

      ret->elf.root.type = bfd_link_hash_defined;

      *slot = ret;

    }

  return &ret->elf;

}

/* Destroy an LoongArch elf linker hash table.  */

static void

elf64_loongarch_link_hash_table_free (bfd *obfd)

{

  struct loongarch_elf_link_hash_table *ret;

  ret = (struct loongarch_elf_link_hash_table *) obfd->link.hash;

  if (ret->loc_hash_table)

    htab_delete (ret->loc_hash_table);

  if (ret->loc_hash_memory)

    objalloc_free ((struct objalloc *) ret->loc_hash_memory);

  _bfd_elf_link_hash_table_free (obfd);

}

/* Create a LoongArch ELF linker hash table.  */

static struct bfd_link_hash_table *

loongarch_elf_link_hash_table_create (bfd *abfd)

{

  struct loongarch_elf_link_hash_table *ret;

  bfd_size_type amt = sizeof (struct loongarch_elf_link_hash_table);

  ret = (struct loongarch_elf_link_hash_table *) bfd_zmalloc (amt);

  if (ret == NULL)

    return NULL;

  if (!_bfd_elf_link_hash_table_init

      (&ret->elf, abfd, link_hash_newfunc,

       sizeof (struct loongarch_elf_link_hash_entry)))

    {

      free (ret);

      return NULL;

    }

  ret->max_alignment = MINUS_ONE;

  ret->loc_hash_table = htab_try_create (1024, elf64_loongarch_local_htab_hash,

           elf64_loongarch_local_htab_eq, NULL);

  ret->loc_hash_memory = objalloc_create ();

  if (!ret->loc_hash_table || !ret->loc_hash_memory)

    {

      elf64_loongarch_link_hash_table_free (abfd);

      return NULL;

    }

  ret->elf.root.hash_table_free = elf64_loongarch_link_hash_table_free;

  return &ret->elf.root;

}

/* Merge backend specific data from an object file to the output

   object file when linking.  */

static bool

elf64_loongarch_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)

{

  bfd *obfd = info->output_bfd;

  flagword in_flags = elf_elfheader (ibfd)->e_flags;

  flagword out_flags = elf_elfheader (obfd)->e_flags;

  if (!is_loongarch_elf (ibfd) || !is_loongarch_elf (obfd))

    return true;

  if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)

    {

      _bfd_error_handler (_("%pB: ABI is incompatible with that of "

          "the selected emulation:\n"

          "  target emulation `%s' does not match `%s'"),

        ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));

      return false;

    }

  if (!_bfd_elf_merge_object_attributes (ibfd, info))

    return false;

  /* If the input BFD is not a dynamic object and it does not contain any

     non-data sections, do not account its ABI.  For example, various

     packages produces such data-only relocatable objects with

     `ld -r -b binary` or `objcopy`, and these objects have zero e_flags.

     But they are compatible with all ABIs.  */

  if (!(ibfd->flags & DYNAMIC))

    {

      asection *sec;

      bool have_code_sections = false;

      for (sec = ibfd->sections; sec != NULL; sec = sec->next)

  if ((bfd_section_flags (sec)

       & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))

      == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))

    {

      have_code_sections = true;

      break;

    }

      if (!have_code_sections)

  return true;

    }

  if (!elf_flags_init (obfd))

    {

      elf_flags_init (obfd) = true;

      elf_elfheader (obfd)->e_flags = in_flags;

      return true;

    }

  else if (out_flags != in_flags)

    {

      if ((EF_LOONGARCH_IS_OBJ_V0 (out_flags)

     && EF_LOONGARCH_IS_OBJ_V1 (in_flags))

    || (EF_LOONGARCH_IS_OBJ_V0 (in_flags)

        && EF_LOONGARCH_IS_OBJ_V1 (out_flags)))

  {

    elf_elfheader (obfd)->e_flags |= EF_LOONGARCH_OBJABI_V1;

    out_flags = elf_elfheader (obfd)->e_flags;

    in_flags = out_flags;

  }

    }

  /* Disallow linking different ABIs.  */

  /* Only check relocation version.

     The obj_v0 is compatible with obj_v1.  */

  if (EF_LOONGARCH_ABI(out_flags ^ in_flags) & EF_LOONGARCH_ABI_MASK)

    {

      _bfd_error_handler (_("%pB: can't link different ABI object."), ibfd);

      goto fail;

    }

  return true;

 fail:

  bfd_set_error (bfd_error_bad_value);

  return false;

}

/* Create the .got section.  */

static bool

loongarch_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)

{

  flagword flags;

  char *name;

  asection *s, *s_got;

  struct elf_link_hash_entry *h;

  const struct elf_backend_data *bed = get_elf_backend_data (abfd);

  struct elf_link_hash_table *htab = elf_hash_table (info);

  /* This function may be called more than once.  */

  if (htab->sgot != NULL)

    return true;

  flags = bed->dynamic_sec_flags;

  name = bed->rela_plts_and_copies_p ? ".rela.got" : ".rel.got";

  s = bfd_make_section_anyway_with_flags (abfd, name, flags | SEC_READONLY);

  if (s == NULL || !bfd_set_section_alignment (s, bed->s->log_file_align))

    return false;

  htab->srelgot = s;

  s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);

  if (s == NULL || !bfd_set_section_alignment (s, bed->s->log_file_align))

    return false;

  htab->sgot = s;

  /* The first bit of the global offset table is the header.  */

  s->size += bed->got_header_size;

  if (bed->want_got_plt)

    {

      s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);

      if (s == NULL || !bfd_set_section_alignment (s, bed->s->log_file_align))

  return false;

      htab->sgotplt = s;

      /* Reserve room for the header.  */

      s->size = GOTPLT_HEADER_SIZE;

    }

  if (bed->want_got_sym)

    {

      /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got

   section.  We don't do this in the linker script because we don't want

   to define the symbol if we are not creating a global offset table.  */

      h = _bfd_elf_define_linkage_sym (abfd, info, s_got,

               "_GLOBAL_OFFSET_TABLE_");

      elf_hash_table (info)->hgot = h;

      if (h == NULL)

  return false;

    }

  return true;

}

/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and

   .rela.bss sections in DYNOBJ, and set up shortcuts to them in our

   hash table.  */

static bool

loongarch_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)

{

  struct loongarch_elf_link_hash_table *htab;

  htab = loongarch_elf_hash_table (info);

  BFD_ASSERT (htab != NULL);

  if (!loongarch_elf_create_got_section (dynobj, info))

    return false;

  if (!_bfd_elf_create_dynamic_sections (dynobj, info))

    return false;

  if (!bfd_link_pic (info))

    htab->sdyntdata

      = bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn",

              SEC_ALLOC | SEC_THREAD_LOCAL);

  if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss

      || (!bfd_link_pic (info) && (!htab->elf.srelbss || !htab->sdyntdata)))

    abort ();

  return true;

}

static bool

loongarch_elf_record_tls_and_got_reference (bfd *abfd,

              struct bfd_link_info *info,

              struct elf_link_hash_entry *h,

              unsigned long symndx,

              char tls_type,

              bool with_relax_reloc)

{

  struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);

  Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;

  /* This is a global offset table entry for a local symbol.  */

  if (elf_local_got_refcounts (abfd) == NULL)

    {

      bfd_size_type size =

  symtab_hdr->sh_info * (sizeof (bfd_vma) + sizeof (tls_type));

      if (!(elf_local_got_refcounts (abfd) = bfd_zalloc (abfd, size)))

  return false;

      _bfd_loongarch_elf_local_got_tls_type (abfd) =

  (char *) (elf_local_got_refcounts (abfd) + symtab_hdr->sh_info);

    }

  switch (tls_type)

    {

    case GOT_NORMAL:

    case GOT_TLS_GD:

    case GOT_TLS_IE:

    case GOT_TLS_GDESC:

      /* Need GOT.  */

      if (htab->elf.sgot == NULL

    && !loongarch_elf_create_got_section (htab->elf.dynobj, info))

  return false;

      if (h)

  {

    if (h->got.refcount < 0)

      h->got.refcount = 0;

    h->got.refcount++;

  }

      else

  elf_local_got_refcounts (abfd)[symndx]++;

      break;

    case GOT_TLS_LE:

      /* No need for GOT.  */

      break;

    default:

      _bfd_error_handler (_("Internal error: unreachable."));

      return false;

    }

  char *new_tls_type = &_bfd_loongarch_elf_tls_type (abfd, h, symndx);

  *new_tls_type |= tls_type;

  /* If DESC relocs can do transitions and accessed by both IE and DESC,

     transition DESC to IE.  */

  if (with_relax_reloc

      && (*new_tls_type & GOT_TLS_IE) && (*new_tls_type & GOT_TLS_GDESC))

    *new_tls_type &= ~ (GOT_TLS_GDESC);

  if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL))

    {

      _bfd_error_handler (_("%pB: `%s' accessed both as normal and "

          "thread local symbol"),

        abfd,

        h ? h->root.root.string : "<local>");

      return false;

    }

  return true;

}

static unsigned int

loongarch_reloc_got_type (unsigned int r_type)

{

  switch (r_type)

    {

      case R_LARCH_TLS_DESC_PC_HI20:

      case R_LARCH_TLS_DESC_PC_LO12:

      case R_LARCH_TLS_DESC_LD:

      case R_LARCH_TLS_DESC_CALL:

  return GOT_TLS_GDESC;

      case R_LARCH_TLS_IE_PC_HI20:

      case R_LARCH_TLS_IE_PC_LO12:

  return GOT_TLS_IE;

      default:

  break;

    }

  return GOT_UNKNOWN;

}

/* Return true if tls type transition can be performed.  */

static bool

loongarch_can_trans_tls (bfd *input_bfd,

       struct bfd_link_info *info,

       struct elf_link_hash_entry *h,

       unsigned int r_symndx,

       unsigned int r_type)

{

  char symbol_tls_type;

  unsigned int reloc_got_type;

  /* Only TLS DESC/IE in normal code mode will perform type

     transition.  */

  if (! IS_LOONGARCH_TLS_TRANS_RELOC (r_type))

    return false;

  /* Obtaining tls got type here may occur before

     loongarch_elf_record_tls_and_got_reference, so it is necessary

     to ensure that tls got type has been initialized, otherwise it

     is set to GOT_UNKNOWN.  */

  symbol_tls_type = GOT_UNKNOWN;

  if (_bfd_loongarch_elf_local_got_tls_type (input_bfd) || h)

    symbol_tls_type = _bfd_loongarch_elf_tls_type (input_bfd, h, r_symndx);

  reloc_got_type = loongarch_reloc_got_type (r_type);

  if (symbol_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (reloc_got_type))

    return true;

  if (! bfd_link_executable (info))

      return false;

  if (h && h->root.type == bfd_link_hash_undefweak)

    return false;

  return true;

}

/* The type of relocation that can be transitioned.  */

static unsigned int

loongarch_tls_transition_without_check (struct bfd_link_info *info,

          unsigned int r_type,

          struct elf_link_hash_entry *h)

{

  bool local_exec = bfd_link_executable (info)

        && LARCH_REF_LOCAL (info, h);

  switch (r_type)

    {

      case R_LARCH_TLS_DESC_PC_HI20:

  return (local_exec

    ? R_LARCH_TLS_LE_HI20

    : R_LARCH_TLS_IE_PC_HI20);

      case R_LARCH_TLS_DESC_PC_LO12:

  return (local_exec

    ? R_LARCH_TLS_LE_LO12

    : R_LARCH_TLS_IE_PC_LO12);

      case R_LARCH_TLS_DESC_LD:

      case R_LARCH_TLS_DESC_CALL:

  return R_LARCH_NONE;

      case R_LARCH_TLS_IE_PC_HI20:

  return local_exec ? R_LARCH_TLS_LE_HI20 : r_type;

      case R_LARCH_TLS_IE_PC_LO12:

  return local_exec ? R_LARCH_TLS_LE_LO12 : r_type;

      default:

  break;

    }

  return r_type;

}

static unsigned int

loongarch_tls_transition (bfd *input_bfd,

        struct bfd_link_info *info,

        struct elf_link_hash_entry *h,

        unsigned int r_symndx,

        unsigned int r_type)

{

  if (! loongarch_can_trans_tls (input_bfd, info, h, r_symndx, r_type))

    return r_type;

  return loongarch_tls_transition_without_check (info, r_type, h);

}

static bool

bad_static_reloc (struct bfd_link_info *info,

      bfd *abfd, const Elf_Internal_Rela *rel,

      asection *sec, unsigned r_type,

      struct elf_link_hash_entry *h,

      Elf_Internal_Sym *isym)

{

  reloc_howto_type * r = loongarch_elf_rtype_to_howto (abfd, r_type);

  const char *object;

  const char *pic_opt;

  const char *name = NULL;

  /* If this, the problem is we are referring an external symbol in

     a way only working for local symbols, not PC-relative vs.

   absolute.  */

  bool bad_extern_access =

    (bfd_link_pde (info)

     || r_type == R_LARCH_PCREL20_S2

     || r_type == R_LARCH_PCALA_HI20);

  if (h)

    name = h->root.root.string;

  else if (isym)

    name = bfd_elf_string_from_elf_section (abfd,

              elf_symtab_hdr (abfd).sh_link,

              isym->st_name);

  if (name == NULL || *name == '\0')

    name = "<nameless>";

  if (bfd_link_dll (info))

    {

      object = _("a shared object");

      pic_opt = "-fPIC";

    }

  else

    {

      if (bfd_link_pie (info))

  object = _("a PIE object");

      else

  object = _("a PDE object");

      pic_opt = bad_extern_access ? "-mno-direct-extern-access" : "-fPIE";

    }

  (*_bfd_error_handler)

   (_("%pB:(%pA+%#lx): relocation %s against `%s` can not be used when making "

      "%s; recompile with %s%s"),

    abfd, sec, (long) rel->r_offset, r ? r->name : _("<unknown>"), name,