[PATCH v2 1/5][LoongArch] BFD support.
Paul Hua
paul.hua.gm@gmail.com
Sun Sep 19 14:07:08 GMT 2021
>From 2efe22486033cd07137c1e7129a737f989ebd993 Mon Sep 17 00:00:00 2001
From: Chenghua Xu <xuchenghua@loongson.cn>
Date: Sat, 18 Sep 2021 16:09:01 +0800
Subject: [PATCH 1/5] bfd: LoongArch BFD support.
---
bfd/Makefile.am | 17 +-
bfd/Makefile.in | 21 +-
bfd/archures.c | 5 +
bfd/bfd-in2.h | 48 +
bfd/config.bfd | 15 +
bfd/configure | 2 +
bfd/configure.ac | 2 +
bfd/cpu-loongarch.c | 61 +
bfd/elf-bfd.h | 9 +
bfd/elf.c | 109 ++
bfd/elfnn-loongarch.c | 3264 ++++++++++++++++++++++++++++++++++++
bfd/elfxx-loongarch.c | 655 ++++++++
bfd/elfxx-loongarch.h | 31 +
bfd/libbfd.h | 43 +
bfd/po/BLD-POTFILES.in | 2 +
bfd/po/SRC-POTFILES.in | 1 +
bfd/reloc.c | 89 +
bfd/targets.c | 8 +
include/elf/common.h | 12 +-
include/elf/loongarch.h | 101 ++
include/opcode/loongarch.h | 220 +++
21 files changed, 4712 insertions(+), 3 deletions(-)
create mode 100644 bfd/cpu-loongarch.c
create mode 100644 bfd/elfnn-loongarch.c
create mode 100644 bfd/elfxx-loongarch.c
create mode 100644 bfd/elfxx-loongarch.h
create mode 100644 include/elf/loongarch.h
create mode 100644 include/opcode/loongarch.h
diff --git a/bfd/Makefile.am b/bfd/Makefile.am
index ed2f701805d..097177bae5c 100644
--- a/bfd/Makefile.am
+++ b/bfd/Makefile.am
@@ -118,6 +118,7 @@ ALL_MACHINES = \
cpu-ip2k.lo \
cpu-iq2000.lo \
cpu-lm32.lo \
+ cpu-loongarch.lo \
cpu-m10200.lo \
cpu-m10300.lo \
cpu-m32c.lo \
@@ -202,6 +203,7 @@ ALL_MACHINES_CFILES = \
cpu-ip2k.c \
cpu-iq2000.c \
cpu-lm32.c \
+ cpu-loongarch.c \
cpu-m10200.c \
cpu-m10300.c \
cpu-m32c.c \
@@ -548,6 +550,9 @@ BFD64_BACKENDS = \
elf64-ia64.lo \
elf64-ia64-vms.lo \
elfxx-ia64.lo \
+ elf32-loongarch.lo \
+ elf64-loongarch.lo \
+ elfxx-loongarch.lo \
elfn32-mips.lo \
elf64-mips.lo \
elfxx-mips.lo \
@@ -601,6 +606,7 @@ BFD64_BACKENDS_CFILES = \
elfn32-mips.c \
elfxx-aarch64.c \
elfxx-ia64.c \
+ elfxx-loongarch.c \
elfxx-mips.c \
elfxx-riscv.c \
mach-o-aarch64.c \
@@ -665,6 +671,7 @@ SOURCE_CFILES = \
BUILD_CFILES = \
elf32-aarch64.c elf64-aarch64.c \
elf32-ia64.c elf64-ia64.c \
+ elf32-loongarch.c elf64-loongarch.c \
elf32-riscv.c elf64-riscv.c \
peigen.c pepigen.c pex64igen.c
@@ -686,7 +693,7 @@ SOURCE_HFILES = \
elf-bfd.h elfcode.h elfcore.h elf-hppa.h elf-linker-x86.h \
elf-linux-core.h elf-nacl.h elf-s390.h elf-vxworks.h \
elfxx-aarch64.h elfxx-ia64.h elfxx-mips.h elfxx-riscv.h \
- elfxx-sparc.h elfxx-tilegx.h elfxx-x86.h \
+ elfxx-sparc.h elfxx-tilegx.h elfxx-x86.h elfxx-loongarch.h \
genlink.h go32stub.h \
libaout.h libbfd.h libcoff.h libecoff.h libhppa.h \
libpei.h libxcoff.h \
@@ -842,6 +849,14 @@ elf64-ia64.c : elfnn-ia64.c
echo "#line 1 \"elfnn-ia64.c\"" > $@
$(SED) -e s/NN/64/g < $< >> $@
+elf32-loongarch.c : elfnn-loongarch.c
+ echo "#line 1 \"elfnn-loongarch.c\"" > $@
+ $(SED) -e s/NN/32/g < $< >> $@
+
+elf64-loongarch.c : elfnn-loongarch.c
+ echo "#line 1 \"elfnn-loongarch.c\"" > $@
+ $(SED) -e s/NN/64/g < $< >> $@
+
elf32-riscv.c : elfnn-riscv.c
echo "#line 1 \"elfnn-riscv.c\"" > $@
$(SED) -e s/NN/32/g < $< >> $@
diff --git a/bfd/Makefile.in b/bfd/Makefile.in
index 12807d99760..a76b653247f 100644
--- a/bfd/Makefile.in
+++ b/bfd/Makefile.in
@@ -543,6 +543,7 @@ ALL_MACHINES = \
cpu-ip2k.lo \
cpu-iq2000.lo \
cpu-lm32.lo \
+ cpu-loongarch.lo \
cpu-m10200.lo \
cpu-m10300.lo \
cpu-m32c.lo \
@@ -627,6 +628,7 @@ ALL_MACHINES_CFILES = \
cpu-ip2k.c \
cpu-iq2000.c \
cpu-lm32.c \
+ cpu-loongarch.c \
cpu-m10200.c \
cpu-m10300.c \
cpu-m32c.c \
@@ -975,6 +977,9 @@ BFD64_BACKENDS = \
elf64-ia64.lo \
elf64-ia64-vms.lo \
elfxx-ia64.lo \
+ elf32-loongarch.lo \
+ elf64-loongarch.lo \
+ elfxx-loongarch.lo \
elfn32-mips.lo \
elf64-mips.lo \
elfxx-mips.lo \
@@ -1028,6 +1033,7 @@ BFD64_BACKENDS_CFILES = \
elfn32-mips.c \
elfxx-aarch64.c \
elfxx-ia64.c \
+ elfxx-loongarch.c \
elfxx-mips.c \
elfxx-riscv.c \
mach-o-aarch64.c \
@@ -1091,6 +1097,7 @@ SOURCE_CFILES = \
BUILD_CFILES = \
elf32-aarch64.c elf64-aarch64.c \
elf32-ia64.c elf64-ia64.c \
+ elf32-loongarch.c elf64-loongarch.c \
elf32-riscv.c elf64-riscv.c \
peigen.c pepigen.c pex64igen.c
@@ -1109,7 +1116,7 @@ SOURCE_HFILES = \
elf-bfd.h elfcode.h elfcore.h elf-hppa.h elf-linker-x86.h \
elf-linux-core.h elf-nacl.h elf-s390.h elf-vxworks.h \
elfxx-aarch64.h elfxx-ia64.h elfxx-mips.h elfxx-riscv.h \
- elfxx-sparc.h elfxx-tilegx.h elfxx-x86.h \
+ elfxx-sparc.h elfxx-tilegx.h elfxx-x86.h elfxx-loongarch.h \
genlink.h go32stub.h \
libaout.h libbfd.h libcoff.h libecoff.h libhppa.h \
libpei.h libxcoff.h \
@@ -1349,6 +1356,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-k1om.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-l1om.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-lm32.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-loongarch.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-m10200.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-m10300.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu-m32c.Plo@am__quote@
@@ -1442,6 +1450,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-ip2k.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-iq2000.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-lm32.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-loongarch.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-m32c.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-m32r.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-m68hc11.Plo@am__quote@
@@ -1492,6 +1501,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-hppa.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-ia64-vms.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-ia64.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-loongarch.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-mips.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-mmix.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-nfp.Plo@am__quote@
@@ -1506,6 +1516,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elfn32-mips.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elfxx-aarch64.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elfxx-ia64.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elfxx-loongarch.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elfxx-mips.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elfxx-riscv.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elfxx-sparc.Plo@am__quote@
@@ -1972,6 +1983,14 @@ elf64-ia64.c : elfnn-ia64.c
echo "#line 1 \"elfnn-ia64.c\"" > $@
$(SED) -e s/NN/64/g < $< >> $@
+elf32-loongarch.c : elfnn-loongarch.c
+ echo "#line 1 \"elfnn-loongarch.c\"" > $@
+ $(SED) -e s/NN/32/g < $< >> $@
+
+elf64-loongarch.c : elfnn-loongarch.c
+ echo "#line 1 \"elfnn-loongarch.c\"" > $@
+ $(SED) -e s/NN/64/g < $< >> $@
+
elf32-riscv.c : elfnn-riscv.c
echo "#line 1 \"elfnn-riscv.c\"" > $@
$(SED) -e s/NN/32/g < $< >> $@
diff --git a/bfd/archures.c b/bfd/archures.c
index 31a41a1d863..6c9be913b5f 100644
--- a/bfd/archures.c
+++ b/bfd/archures.c
@@ -555,6 +555,9 @@ DESCRIPTION
.#define bfd_mach_ck807 6
.#define bfd_mach_ck810 7
.#define bfd_mach_ck860 8
+. bfd_arch_loongarch, {* LoongArch *}
+.#define bfd_mach_loongarch32 1
+.#define bfd_mach_loongarch64 2
. bfd_arch_last
. };
*/
@@ -635,6 +638,7 @@ extern const bfd_arch_info_type bfd_iq2000_arch;
extern const bfd_arch_info_type bfd_k1om_arch;
extern const bfd_arch_info_type bfd_l1om_arch;
extern const bfd_arch_info_type bfd_lm32_arch;
+extern const bfd_arch_info_type bfd_loongarch_arch;
extern const bfd_arch_info_type bfd_m32c_arch;
extern const bfd_arch_info_type bfd_m32r_arch;
extern const bfd_arch_info_type bfd_m68hc11_arch;
@@ -724,6 +728,7 @@ static const bfd_arch_info_type * const
bfd_archures_list[] =
&bfd_k1om_arch,
&bfd_l1om_arch,
&bfd_lm32_arch,
+ &bfd_loongarch_arch,
&bfd_m32c_arch,
&bfd_m32r_arch,
&bfd_m68hc11_arch,
diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index a0faeafc3dc..91888ef1852 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -1937,6 +1937,9 @@ enum bfd_architecture
#define bfd_mach_ck807 6
#define bfd_mach_ck810 7
#define bfd_mach_ck860 8
+ bfd_arch_loongarch, /* LoongArch */
+#define bfd_mach_loongarch32 1
+#define bfd_mach_loongarch64 2
bfd_arch_last
};
@@ -6268,6 +6271,51 @@ assembler and not (currently) written to any
object files. */
/* S12Z relocations. */
BFD_RELOC_S12Z_OPR,
+
+/* LARCH relocations. */
+ BFD_RELOC_LARCH_TLS_DTPMOD32,
+ BFD_RELOC_LARCH_TLS_DTPREL32,
+ BFD_RELOC_LARCH_TLS_DTPMOD64,
+ BFD_RELOC_LARCH_TLS_DTPREL64,
+ BFD_RELOC_LARCH_TLS_TPREL32,
+ BFD_RELOC_LARCH_TLS_TPREL64,
+ BFD_RELOC_LARCH_MARK_LA,
+ BFD_RELOC_LARCH_MARK_PCREL,
+ BFD_RELOC_LARCH_SOP_PUSH_PCREL,
+ BFD_RELOC_LARCH_SOP_PUSH_ABSOLUTE,
+ BFD_RELOC_LARCH_SOP_PUSH_DUP,
+ BFD_RELOC_LARCH_SOP_PUSH_GPREL,
+ BFD_RELOC_LARCH_SOP_PUSH_TLS_TPREL,
+ BFD_RELOC_LARCH_SOP_PUSH_TLS_GOT,
+ BFD_RELOC_LARCH_SOP_PUSH_TLS_GD,
+ BFD_RELOC_LARCH_SOP_PUSH_PLT_PCREL,
+ BFD_RELOC_LARCH_SOP_ASSERT,
+ BFD_RELOC_LARCH_SOP_NOT,
+ BFD_RELOC_LARCH_SOP_SUB,
+ BFD_RELOC_LARCH_SOP_SL,
+ BFD_RELOC_LARCH_SOP_SR,
+ BFD_RELOC_LARCH_SOP_ADD,
+ BFD_RELOC_LARCH_SOP_AND,
+ BFD_RELOC_LARCH_SOP_IF_ELSE,
+ BFD_RELOC_LARCH_SOP_POP_32_S_10_5,
+ BFD_RELOC_LARCH_SOP_POP_32_U_10_12,
+ BFD_RELOC_LARCH_SOP_POP_32_S_10_12,
+ BFD_RELOC_LARCH_SOP_POP_32_S_10_16,
+ BFD_RELOC_LARCH_SOP_POP_32_S_10_16_S2,
+ BFD_RELOC_LARCH_SOP_POP_32_S_5_20,
+ BFD_RELOC_LARCH_SOP_POP_32_S_0_5_10_16_S2,
+ BFD_RELOC_LARCH_SOP_POP_32_S_0_10_10_16_S2,
+ BFD_RELOC_LARCH_SOP_POP_32_U,
+ BFD_RELOC_LARCH_ADD8,
+ BFD_RELOC_LARCH_ADD16,
+ BFD_RELOC_LARCH_ADD24,
+ BFD_RELOC_LARCH_ADD32,
+ BFD_RELOC_LARCH_ADD64,
+ BFD_RELOC_LARCH_SUB8,
+ BFD_RELOC_LARCH_SUB16,
+ BFD_RELOC_LARCH_SUB24,
+ BFD_RELOC_LARCH_SUB32,
+ BFD_RELOC_LARCH_SUB64,
BFD_RELOC_UNUSED };
typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
diff --git a/bfd/config.bfd b/bfd/config.bfd
index ab5125796f7..3cf32271333 100644
--- a/bfd/config.bfd
+++ b/bfd/config.bfd
@@ -197,6 +197,7 @@ hppa*) targ_archs=bfd_hppa_arch ;;
i[3-7]86) targ_archs=bfd_i386_arch ;;
ia16) targ_archs=bfd_i386_arch ;;
lm32) targ_archs=bfd_lm32_arch ;;
+loongarch*) targ_archs=bfd_loongarch_arch ;;
m6811*|m68hc11*) targ_archs="bfd_m68hc11_arch bfd_m68hc12_arch
bfd_m9s12x_arch bfd_m9s12xg_arch" ;;
m6812*|m68hc12*) targ_archs="bfd_m68hc12_arch bfd_m68hc11_arch
bfd_m9s12x_arch bfd_m9s12xg_arch" ;;
m68*) targ_archs=bfd_m68k_arch ;;
@@ -1458,6 +1459,20 @@ case "${targ}" in
targ_underscore=yes
;;
+#ifdef BFD64
+ loongarch32-*)
+ targ_defvec=loongarch_elf32_vec
+ targ_selvecs="loongarch_elf32_vec"
+ want64=false
+ ;;
+
+ loongarch64-*)
+ targ_defvec=loongarch_elf64_vec
+ targ_selvecs="loongarch_elf32_vec loongarch_elf64_vec"
+ want64=true
+ ;;
+#endif
+
# END OF targmatch.h
bpf-*-*)
echo "*** Configuration $targ is not fully supported." >&2
diff --git a/bfd/configure b/bfd/configure
index cae69d413d4..1bed19c6a5d 100755
--- a/bfd/configure
+++ b/bfd/configure
@@ -13347,6 +13347,8 @@ do
l1om_elf64_fbsd_vec) tb="$tb elf64-x86-64.lo elfxx-x86.lo
elf-ifunc.lo elf64.lo $elf"; target_size=64 ;;
lm32_elf32_vec) tb="$tb elf32-lm32.lo elf32.lo $elf" ;;
lm32_elf32_fdpic_vec) tb="$tb elf32-lm32.lo elf32.lo $elf" ;;
+ loongarch_elf32_vec) tb="$tb elf32-loongarch.lo
elfxx-loongarch.lo elf32.lo elf-ifunc.lo $elf" ;;
+ loongarch_elf64_vec) tb="$tb elf64-loongarch.lo elf64.lo
elfxx-loongarch.lo elf32.lo elf-ifunc.lo $elf"; target_size=64 ;;
m32c_elf32_vec) tb="$tb elf32-m32c.lo elf32.lo $elf" ;;
m32r_elf32_vec) tb="$tb elf32-m32r.lo elf32.lo $elf" ;;
m32r_elf32_le_vec) tb="$tb elf32-m32r.lo elf32.lo $elf" ;;
diff --git a/bfd/configure.ac b/bfd/configure.ac
index 9ff303ab6e1..50ba391fff3 100644
--- a/bfd/configure.ac
+++ b/bfd/configure.ac
@@ -527,6 +527,8 @@ do
l1om_elf64_fbsd_vec) tb="$tb elf64-x86-64.lo elfxx-x86.lo
elf-ifunc.lo elf64.lo $elf"; target_size=64 ;;
lm32_elf32_vec) tb="$tb elf32-lm32.lo elf32.lo $elf" ;;
lm32_elf32_fdpic_vec) tb="$tb elf32-lm32.lo elf32.lo $elf" ;;
+ loongarch_elf32_vec) tb="$tb elf32-loongarch.lo
elfxx-loongarch.lo elf32.lo elf-ifunc.lo $elf" ;;
+ loongarch_elf64_vec) tb="$tb elf64-loongarch.lo elf64.lo
elfxx-loongarch.lo elf32.lo elf-ifunc.lo $elf"; target_size=64 ;;
m32c_elf32_vec) tb="$tb elf32-m32c.lo elf32.lo $elf" ;;
m32r_elf32_vec) tb="$tb elf32-m32r.lo elf32.lo $elf" ;;
m32r_elf32_le_vec) tb="$tb elf32-m32r.lo elf32.lo $elf" ;;
diff --git a/bfd/cpu-loongarch.c b/bfd/cpu-loongarch.c
new file mode 100644
index 00000000000..bf6702a8328
--- /dev/null
+++ b/bfd/cpu-loongarch.c
@@ -0,0 +1,61 @@
+/* BFD support for LoongArch.
+ Copyright (C) 2021 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 "sysdep.h"
+#include "bfd.h"
+#include "libbfd.h"
+
+static const bfd_arch_info_type bfd_loongarch32_arch =
+{
+ 32, /* 32 bits in a word. */
+ 32, /* 64 bits in an address. */
+ 8, /* 8 bits in a byte. */
+ bfd_arch_loongarch, /* Architecture. */
+ bfd_mach_loongarch32, /* Machine number - 0 for now. */
+ "loongarch32", /* Architecture name. */
+ "Loongarch32", /* Printable name. */
+ 3, /* Section align power. */
+ false, /* This is the default architecture. */
+ bfd_default_compatible, /* Architecture comparison function. */
+ bfd_default_scan, /* String to architecture conversion. */
+ bfd_arch_default_fill, /* Default fill. */
+ NULL, /* Next in list. */
+ 0,
+};
+
+const bfd_arch_info_type bfd_loongarch_arch =
+{
+ 32, /* 32 bits in a word. */
+ 64, /* 64 bits in an address. */
+ 8, /* 8 bits in a byte. */
+ bfd_arch_loongarch, /* Architecture. */
+ /* Machine number of LoongArch64 is larger
+ * so that LoongArch64 is compatible to LoongArch32. */
+ bfd_mach_loongarch64,
+ "loongarch64", /* Architecture name. */
+ "Loongarch64", /* Printable name. */
+ 3, /* Section align power. */
+ true, /* This is the default architecture. */
+ bfd_default_compatible, /* Architecture comparison function. */
+ bfd_default_scan, /* String to architecture conversion. */
+ bfd_arch_default_fill, /* Default fill. */
+ &bfd_loongarch32_arch, /* Next in list. */
+ 0,
+};
diff --git a/bfd/elf-bfd.h b/bfd/elf-bfd.h
index c247d52c615..52053163527 100644
--- a/bfd/elf-bfd.h
+++ b/bfd/elf-bfd.h
@@ -508,6 +508,7 @@ enum elf_target_id
I386_ELF_DATA,
IA64_ELF_DATA,
LM32_ELF_DATA,
+ LARCH_ELF_DATA,
M32R_ELF_DATA,
M68HC11_ELF_DATA,
M68K_ELF_DATA,
@@ -2849,6 +2850,14 @@ extern char *elfcore_write_register_note
(bfd *, char *, int *, const char *, const void *, int);
extern char *elfcore_write_file_note
(bfd *, char *, int *, const void*, int);
+extern char *elfcore_write_loongarch_cpucfg
+ (bfd *, char *, int *, const void*, int);
+extern char *elfcore_write_loongarch_lbt
+ (bfd *, char *, int *, const void*, int);
+extern char *elfcore_write_loongarch_lsx
+ (bfd *, char *, int *, const void*, int);
+extern char *elfcore_write_loongarch_lasx
+ (bfd *, char *, int *, const void*, int);
/* Internal structure which holds information to be included in the
PRPSINFO section of Linux core files.
diff --git a/bfd/elf.c b/bfd/elf.c
index 64e3f35a75c..3558f8595c6 100644
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -9951,6 +9951,30 @@ elfcore_grok_gdb_tdesc (bfd *abfd,
Elf_Internal_Note *note)
return elfcore_make_note_pseudosection (abfd, ".gdb-tdesc", note);
}
+static bool
+elfcore_grok_loongarch_cpucfg (bfd *abfd, Elf_Internal_Note *note)
+{
+ return elfcore_make_note_pseudosection (abfd, ".reg-loongarch-cpucfg", note);
+}
+
+static bool
+elfcore_grok_loongarch_lbt (bfd *abfd, Elf_Internal_Note *note)
+{
+ return elfcore_make_note_pseudosection (abfd, ".reg-loongarch-lbt", note);
+}
+
+static bool
+elfcore_grok_loongarch_lsx (bfd *abfd, Elf_Internal_Note *note)
+{
+ return elfcore_make_note_pseudosection (abfd, ".reg-loongarch-lsx", note);
+}
+
+static bool
+elfcore_grok_loongarch_lasx (bfd *abfd, Elf_Internal_Note *note)
+{
+ return elfcore_make_note_pseudosection (abfd, ".reg-loongarch-lasx", note);
+}
+
#if defined (HAVE_PRPSINFO_T)
typedef prpsinfo_t elfcore_psinfo_t;
#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
@@ -10630,6 +10654,34 @@ elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
else
return true;
+ case NT_LARCH_CPUCFG:
+ if (note->namesz == 6
+ && strcmp (note->namedata, "LINUX") == 0)
+ return elfcore_grok_loongarch_cpucfg (abfd, note);
+ else
+ return true;
+
+ case NT_LARCH_LBT:
+ if (note->namesz == 6
+ && strcmp (note->namedata, "LINUX") == 0)
+ return elfcore_grok_loongarch_lbt (abfd, note);
+ else
+ return true;
+
+ case NT_LARCH_LSX:
+ if (note->namesz == 6
+ && strcmp (note->namedata, "LINUX") == 0)
+ return elfcore_grok_loongarch_lsx (abfd, note);
+ else
+ return true;
+
+ case NT_LARCH_LASX:
+ if (note->namesz == 6
+ && strcmp (note->namedata, "LINUX") == 0)
+ return elfcore_grok_loongarch_lasx (abfd, note);
+ else
+ return true;
+
case NT_PRPSINFO:
case NT_PSINFO:
if (bed->elf_backend_grok_psinfo)
@@ -12021,6 +12073,55 @@ elfcore_write_arc_v2 (bfd *abfd,
note_name, NT_ARC_V2, arc_v2, size);
}
+char *
+elfcore_write_loongarch_cpucfg (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ const void *loongarch_cpucfg,
+ int size)
+{
+ char *note_name = "LINUX";
+ return elfcore_write_note (abfd, buf, bufsiz,
+ note_name, NT_LARCH_CPUCFG,
+ loongarch_cpucfg, size);
+}
+
+char *
+elfcore_write_loongarch_lbt (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ const void *loongarch_lbt,
+ int size)
+{
+ char *note_name = "LINUX";
+ return elfcore_write_note (abfd, buf, bufsiz,
+ note_name, NT_LARCH_LBT, loongarch_lbt, size);
+}
+
+char *
+elfcore_write_loongarch_lsx (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ const void *loongarch_lsx,
+ int size)
+{
+ char *note_name = "LINUX";
+ return elfcore_write_note (abfd, buf, bufsiz,
+ note_name, NT_LARCH_LSX, loongarch_lsx, size);
+}
+
+char *
+elfcore_write_loongarch_lasx (bfd *abfd,
+ char *buf,
+ int *bufsiz,
+ const void *loongarch_lasx,
+ int size)
+{
+ char *note_name = "LINUX";
+ return elfcore_write_note (abfd, buf, bufsiz,
+ note_name, NT_LARCH_LASX, loongarch_lasx, size);
+}
+
/* Write the buffer of csr values in CSRS (length SIZE) into the note
buffer BUF and update *BUFSIZ. ABFD is the bfd the note is being
written into. Return a pointer to the new start of the note buffer, to
@@ -12145,6 +12246,14 @@ elfcore_write_register_note (bfd *abfd,
return elfcore_write_gdb_tdesc (abfd, buf, bufsiz, data, size);
if (strcmp (section, ".reg-riscv-csr") == 0)
return elfcore_write_riscv_csr (abfd, buf, bufsiz, data, size);
+ if (strcmp (section, ".reg-loongarch-cpucfg") == 0)
+ return elfcore_write_loongarch_cpucfg (abfd, buf, bufsiz, data, size);
+ if (strcmp (section, ".reg-loongarch-lbt") == 0)
+ return elfcore_write_loongarch_lbt (abfd, buf, bufsiz, data, size);
+ if (strcmp (section, ".reg-loongarch-lsx") == 0)
+ return elfcore_write_loongarch_lsx (abfd, buf, bufsiz, data, size);
+ if (strcmp (section, ".reg-loongarch-lasx") == 0)
+ return elfcore_write_loongarch_lasx (abfd, buf, bufsiz, data, size);
return NULL;
}
diff --git a/bfd/elfnn-loongarch.c b/bfd/elfnn-loongarch.c
new file mode 100644
index 00000000000..11773b97068
--- /dev/null
+++ b/bfd/elfnn-loongarch.c
@@ -0,0 +1,3264 @@
+/* LoongArch-specific support for NN-bit ELF.
+ Copyright (C) 2021 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 NN
+#include "elf-bfd.h"
+#include "objalloc.h"
+#include "elf/loongarch.h"
+#include "elfxx-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,
+ ELFNN_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;
+
+ /* Track dynamic relocs copied for this symbol. */
+ struct elf_dyn_relocs *dyn_relocs;
+
+#define GOT_UNKNOWN 0
+#define GOT_NORMAL 1
+#define GOT_TLS_GD 2
+#define GOT_TLS_IE 4
+#define GOT_TLS_LE 8
+ 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)
+
+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;
+};
+
+/* Get the LoongArch ELF linker hash table from a link_info structure. */
+#define loongarch_elf_hash_table(p) \
+ (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
+ == LARCH_ELF_DATA \
+ ? ((struct loongarch_elf_link_hash_table *) ((p)->hash)) \
+ : NULL)
+
+#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)
+
+#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 0
+#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 */
+
+/* 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 (_ ("0x%lx invaild imm"), 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 (_ ("0x%lx invaild imm"), 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)
+{
+ /* Allocate the structure if it has not already been allocated by a
+ subclass. */
+ if (entry == NULL)
+ {
+ entry = bfd_hash_allocate (
+ table, sizeof (struct loongarch_elf_link_hash_entry));
+ if (entry == NULL)
+ return entry;
+ }
+
+ /* Call the allocation method of the superclass. */
+ entry = _bfd_elf_link_hash_newfunc (entry, table, string);
+ if (entry != NULL)
+ {
+ struct loongarch_elf_link_hash_entry *eh;
+
+ eh = (struct loongarch_elf_link_hash_entry *) entry;
+ eh->dyn_relocs = NULL;
+ 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
+elfNN_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
+elfNN_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 *
+elfNN_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, ELFNN_R_SYM (rel->r_info));
+ void **slot;
+
+ e.elf.indx = sec->id;
+ e.elf.dynstr_index = ELFNN_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 = ELFNN_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
+elfNN_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), LARCH_ELF_DATA))
+ {
+ free (ret);
+ return NULL;
+ }
+
+ ret->max_alignment = MINUS_ONE;
+
+ ret->loc_hash_table = htab_try_create (1024, elfNN_loongarch_local_htab_hash,
+ elfNN_loongarch_local_htab_eq, NULL);
+ ret->loc_hash_memory = objalloc_create ();
+ if (!ret->loc_hash_table || !ret->loc_hash_memory)
+ {
+ elfNN_loongarch_link_hash_table_free (abfd);
+ return NULL;
+ }
+ ret->elf.root.hash_table_free = elfNN_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
+elfNN_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))
+ {
+ /* Make sure one of ibfd or obfd e_flags must be set. */
+ /* FIXME: EF_LARCH_ABI_LP64 ? . */
+ if (!is_loongarch_elf (ibfd) && !elf_flags_init (obfd))
+ {
+ elf_flags_init (obfd) = true;
+ elf_elfheader (obfd)->e_flags = EF_LARCH_ABI_LP64;
+ }
+
+ if (!is_loongarch_elf (obfd) && !elf_flags_init (ibfd))
+ {
+ elf_flags_init (ibfd) = true;
+ elf_elfheader (ibfd)->e_flags = EF_LARCH_ABI_LP64;
+ }
+
+ 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 (!elf_flags_init (obfd))
+ {
+ elf_flags_init (obfd) = true;
+ elf_elfheader (obfd)->e_flags = in_flags;
+ return true;
+ }
+
+ /* Disallow linking different float ABIs. */
+ if ((out_flags ^ in_flags) & EF_LARCH_ABI)
+ {
+ _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)
+{
+ 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:
+ /* 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 ((*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;
+}
+
+/* Look through the relocs for a section during the first phase, and
+ allocate space in the global offset table or procedure linkage
+ table. */
+
+static bool
+loongarch_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
+ asection *sec, const Elf_Internal_Rela *relocs)
+{
+ struct loongarch_elf_link_hash_table *htab;
+ Elf_Internal_Shdr *symtab_hdr;
+ struct elf_link_hash_entry **sym_hashes;
+ const Elf_Internal_Rela *rel;
+ asection *sreloc = NULL;
+
+ if (bfd_link_relocatable (info))
+ return true;
+
+ htab = loongarch_elf_hash_table (info);
+ symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ sym_hashes = elf_sym_hashes (abfd);
+
+ if (htab->elf.dynobj == NULL)
+ htab->elf.dynobj = abfd;
+
+ for (rel = relocs; rel < relocs + sec->reloc_count; rel++)
+ {
+ unsigned int r_type;
+ unsigned int r_symndx;
+ struct elf_link_hash_entry *h;
+ Elf_Internal_Sym *isym = NULL;
+
+ int need_dynreloc;
+ int only_need_pcrel;
+
+ r_symndx = ELFNN_R_SYM (rel->r_info);
+ r_type = ELFNN_R_TYPE (rel->r_info);
+
+ if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
+ {
+ _bfd_error_handler (_ ("%pB: bad symbol index: %d"), abfd, r_symndx);
+ return false;
+ }
+
+ if (r_symndx < symtab_hdr->sh_info)
+ {
+ /* A local symbol. */
+ isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
+ if (isym == NULL)
+ return false;
+
+ if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
+ {
+ h = elfNN_loongarch_get_local_sym_hash (htab, abfd, rel, true);
+ if (h == NULL)
+ return false;
+
+ h->type = STT_GNU_IFUNC;
+ h->ref_regular = 1;
+ }
+ else
+ h = NULL;
+ }
+ else
+ {
+ h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ while (h->root.type == bfd_link_hash_indirect
+ || h->root.type == bfd_link_hash_warning)
+ h = (struct elf_link_hash_entry *) h->root.u.i.link;
+ }
+
+ if (h && h->type == STT_GNU_IFUNC)
+ {
+ if (htab->elf.dynobj == NULL)
+ htab->elf.dynobj = abfd;
+
+ if (!htab->elf.splt
+ && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
+ /* If '.plt' not represent, create '.iplt' to deal with ifunc. */
+ return false;
+
+ if (h->plt.refcount < 0)
+ h->plt.refcount = 0;
+ h->plt.refcount++;
+ h->needs_plt = 1;
+
+ elf_tdata (info->output_bfd)->has_gnu_osabi |= elf_gnu_osabi_ifunc;
+ }
+
+ need_dynreloc = 0;
+ only_need_pcrel = 0;
+ switch (r_type)
+ {
+ case R_LARCH_SOP_PUSH_GPREL:
+ if (!loongarch_elf_record_tls_and_got_reference (
+ abfd, info, h, r_symndx, GOT_NORMAL))
+ return false;
+ break;
+
+ case R_LARCH_SOP_PUSH_TLS_GD:
+ if (!loongarch_elf_record_tls_and_got_reference (
+ abfd, info, h, r_symndx, GOT_TLS_GD))
+ return false;
+ break;
+
+ case R_LARCH_SOP_PUSH_TLS_GOT:
+ if (bfd_link_pic (info))
+ /* May fail for lazy-bind. */
+ info->flags |= DF_STATIC_TLS;
+
+ if (!loongarch_elf_record_tls_and_got_reference (
+ abfd, info, h, r_symndx, GOT_TLS_IE))
+ return false;
+ break;
+
+ case R_LARCH_SOP_PUSH_TLS_TPREL:
+ if (!bfd_link_executable (info))
+ return false;
+
+ info->flags |= DF_STATIC_TLS;
+
+ if (!loongarch_elf_record_tls_and_got_reference (
+ abfd, info, h, r_symndx, GOT_TLS_LE))
+ return false;
+ break;
+
+ case R_LARCH_SOP_PUSH_ABSOLUTE:
+ if (h != NULL)
+ /* If this reloc is in a read-only section, we might
+ need a copy reloc. We can't check reliably at this
+ stage whether the section is read-only, as input
+ sections have not yet been mapped to output sections.
+ Tentatively set the flag for now, and correct in
+ adjust_dynamic_symbol. */
+ h->non_got_ref = 1;
+ break;
+
+ case R_LARCH_SOP_PUSH_PCREL:
+ if (h != NULL)
+ {
+ h->non_got_ref = 1;
+
+ /* We try to create PLT stub for all non-local function. */
+ if (h->plt.refcount < 0)
+ h->plt.refcount = 0;
+ h->plt.refcount++;
+ }
+ break;
+
+ case R_LARCH_SOP_PUSH_PLT_PCREL:
+ /* This symbol requires a procedure linkage table entry. We
+ actually build the entry in adjust_dynamic_symbol,
+ because this might be a case of linking PIC code without
+ linking in any dynamic objects, in which case we don't
+ need to generate a procedure linkage table after all. */
+ if (h != NULL)
+ {
+ h->needs_plt = 1;
+ if (h->plt.refcount < 0)
+ h->plt.refcount = 0;
+ h->plt.refcount++;
+ }
+ break;
+
+ case R_LARCH_TLS_DTPREL32:
+ case R_LARCH_TLS_DTPREL64:
+ need_dynreloc = 1;
+ only_need_pcrel = 1;
+ break;
+
+ case R_LARCH_JUMP_SLOT:
+ case R_LARCH_32:
+ case R_LARCH_64:
+ need_dynreloc = 1;
+
+ /* If resolved symbol is defined in this object,
+ 1. Under pie, the symbol is known. We convert it
+ into R_LARCH_RELATIVE and need load-addr still.
+ 2. Under pde, the symbol is known and we can discard R_LARCH_NN.
+ 3. Under dll, R_LARCH_NN can't be changed normally, since
+ its defination could be covered by the one in executable.
+ For symbolic, we convert it into R_LARCH_RELATIVE.
+ Thus, only under pde, it needs pcrel only. We discard it. */
+ only_need_pcrel = bfd_link_pde (info);
+
+ if (h != NULL)
+ h->non_got_ref = 1;
+ break;
+
+ case R_LARCH_GNU_VTINHERIT:
+ if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
+ return false;
+ break;
+
+ case R_LARCH_GNU_VTENTRY:
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+ return false;
+ break;
+
+ default:
+ break;
+ }
+
+ /* Record some info for sizing and allocating dynamic entry. */
+ if (need_dynreloc && (sec->flags & SEC_ALLOC))
+ {
+ /* When creating a shared object, we must copy these
+ relocs into the output file. We create a reloc
+ section in dynobj and make room for the reloc. */
+ struct elf_dyn_relocs *p;
+ struct elf_dyn_relocs **head;
+
+ if (sreloc == NULL)
+ {
+ sreloc = _bfd_elf_make_dynamic_reloc_section (
+ sec, htab->elf.dynobj, LARCH_ELF_LOG_WORD_BYTES, abfd,
+ /*rela?*/ true);
+
+ if (sreloc == NULL)
+ return false;
+ }
+
+ /* If this is a global symbol, we count the number of
+ relocations we need for this symbol. */
+ if (h != NULL)
+ head = &((struct loongarch_elf_link_hash_entry *) h)->dyn_relocs;
+ else
+ {
+ /* Track dynamic relocs needed for local syms too.
+ We really need local syms available to do this
+ easily. Oh well. */
+
+ asection *s;
+ void *vpp;
+
+ s = bfd_section_from_elf_index (abfd, isym->st_shndx);
+ if (s == NULL)
+ s = sec;
+
+ vpp = &elf_section_data (s)->local_dynrel;
+ head = (struct elf_dyn_relocs **) vpp;
+ }
+
+ p = *head;
+ if (p == NULL || p->sec != sec)
+ {
+ bfd_size_type amt = sizeof *p;
+ p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj, amt);
+ if (p == NULL)
+ return false;
+ p->next = *head;
+ *head = p;
+ p->sec = sec;
+ p->count = 0;
+ p->pc_count = 0;
+ }
+
+ p->count++;
+ p->pc_count += only_need_pcrel;
+ }
+ }
+
+ return true;
+}
+
+/* Find dynamic relocs for H that apply to read-only sections. */
+
+static asection *
+readonly_dynrelocs (struct elf_link_hash_entry *h)
+{
+ struct elf_dyn_relocs *p;
+
+ for (p = loongarch_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
+ {
+ asection *s = p->sec->output_section;
+
+ if (s != NULL && (s->flags & SEC_READONLY) != 0)
+ return p->sec;
+ }
+ return NULL;
+}
+
+/* Adjust a symbol defined by a dynamic object and referenced by a
+ regular object. The current definition is in some section of the
+ dynamic object, but we're not including those sections. We have to
+ change the definition to something the rest of the link can
+ understand. */
+static bool
+loongarch_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
+ struct elf_link_hash_entry *h)
+{
+ struct loongarch_elf_link_hash_table *htab;
+ struct loongarch_elf_link_hash_entry *eh;
+ bfd *dynobj;
+ asection *s, *srel;
+
+ htab = loongarch_elf_hash_table (info);
+ BFD_ASSERT (htab != NULL);
+
+ dynobj = htab->elf.dynobj;
+
+ /* Make sure we know what is going on here. */
+ BFD_ASSERT (dynobj != NULL
+ && (h->needs_plt || h->type == STT_GNU_IFUNC || h->is_weakalias
+ || (h->def_dynamic && h->ref_regular && !h->def_regular)));
+
+ /* If this is a function, put it in the procedure linkage table. We
+ will fill in the contents of the procedure linkage table later
+ (although we could actually do it here). */
+ if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
+ {
+ if (h->plt.refcount < 0
+ || (h->type != STT_GNU_IFUNC
+ && (SYMBOL_REFERENCES_LOCAL (info, h)
+ || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
+ && h->root.type == bfd_link_hash_undefweak))))
+ {
+ /* This case can occur if we saw a R_LARCH_SOP_PUSH_PLT_PCREL reloc
+ in an input file, but the symbol was never referred to by a
+ dynamic object, or if all references were garbage collected.
+ In such a case, we don't actually need to build a PLT entry. */
+ h->plt.offset = MINUS_ONE;
+ h->needs_plt = 0;
+ }
+ else
+ h->needs_plt = 1;
+
+ return true;
+ }
+ else
+ h->plt.offset = MINUS_ONE;
+
+ /* If this is a weak symbol, and there is a real definition, the
+ processor independent code will have arranged for us to see the
+ real definition first, and we can just use the same value. */
+ if (h->is_weakalias)
+ {
+ struct elf_link_hash_entry *def = weakdef (h);
+ BFD_ASSERT (def->root.type == bfd_link_hash_defined);
+ h->root.u.def.section = def->root.u.def.section;
+ h->root.u.def.value = def->root.u.def.value;
+ return true;
+ }
+
+ /* This is a reference to a symbol defined by a dynamic object which
+ is not a function. */
+
+ /* If we are creating a shared library, we must presume that the
+ only references to the symbol are via the global offset table.
+ For such cases we need not do anything here; the relocations will
+ be handled correctly by relocate_section. */
+ if (bfd_link_dll (info))
+ return true;
+
+ /* If there are no references to this symbol that do not use the
+ GOT, we don't need to generate a copy reloc. */
+ if (!h->non_got_ref)
+ return true;
+
+ /* If -z nocopyreloc was given, we won't generate them either. */
+ if (info->nocopyreloc)
+ {
+ h->non_got_ref = 0;
+ return true;
+ }
+
+ /* If we don't find any dynamic relocs in read-only sections, then
+ we'll be keeping the dynamic relocs and avoiding the copy reloc. */
+ if (!readonly_dynrelocs (h))
+ {
+ h->non_got_ref = 0;
+ return true;
+ }
+
+ /* We must allocate the symbol in our .dynbss section, which will
+ become part of the .bss section of the executable. There will be
+ an entry for this symbol in the .dynsym section. The dynamic
+ object will contain position independent code, so all references
+ from the dynamic object to this symbol will go through the global
+ offset table. The dynamic linker will use the .dynsym entry to
+ determine the address it must put in the global offset table, so
+ both the dynamic object and the regular object will refer to the
+ same memory location for the variable. */
+
+ /* We must generate a R_LARCH_COPY reloc to tell the dynamic linker
+ to copy the initial value out of the dynamic object and into the
+ runtime process image. We need to remember the offset into the
+ .rel.bss section we are going to use. */
+ eh = (struct loongarch_elf_link_hash_entry *) h;
+ if (eh->tls_type & ~GOT_NORMAL)
+ {
+ s = htab->sdyntdata;
+ srel = htab->elf.srelbss;
+ }
+ else if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
+ {
+ s = htab->elf.sdynrelro;
+ srel = htab->elf.sreldynrelro;
+ }
+ else
+ {
+ s = htab->elf.sdynbss;
+ srel = htab->elf.srelbss;
+ }
+ if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
+ {
+ srel->size += sizeof (ElfNN_External_Rela);
+ h->needs_copy = 1;
+ }
+
+ return _bfd_elf_adjust_dynamic_copy (info, h, s);
+}
+
+/* Allocate space in .plt, .got and associated reloc sections for
+ dynamic relocs. */
+
+static bool
+allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
+{
+ struct bfd_link_info *info;
+ struct loongarch_elf_link_hash_table *htab;
+ struct loongarch_elf_link_hash_entry *eh;
+ struct elf_dyn_relocs *p;
+
+ if (h->root.type == bfd_link_hash_indirect)
+ return true;
+
+ eh = (struct loongarch_elf_link_hash_entry *) h;
+ info = (struct bfd_link_info *) inf;
+ htab = loongarch_elf_hash_table (info);
+ BFD_ASSERT (htab != NULL);
+
+ do
+ {
+ asection *plt, *gotplt, *relplt;
+
+ if (!h->needs_plt)
+ break;
+
+ h->needs_plt = 0;
+
+ if (htab->elf.splt)
+ {
+ if (h->dynindx == -1 && !h->forced_local
+ && !bfd_elf_link_record_dynamic_symbol (info, h))
+ return false;
+
+ if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)
+ && h->type != STT_GNU_IFUNC)
+ break;
+
+ plt = htab->elf.splt;
+ gotplt = htab->elf.sgotplt;
+ relplt = htab->elf.srelplt;
+ }
+ else if (htab->elf.iplt)
+ {
+ /* .iplt only for IFUNC. */
+ if (h->type != STT_GNU_IFUNC)
+ break;
+
+ plt = htab->elf.iplt;
+ gotplt = htab->elf.igotplt;
+ relplt = htab->elf.irelplt;
+ }
+ else
+ break;
+
+ if (plt->size == 0)
+ plt->size = PLT_HEADER_SIZE;
+
+ h->plt.offset = plt->size;
+ plt->size += PLT_ENTRY_SIZE;
+ gotplt->size += GOT_ENTRY_SIZE;
+ relplt->size += sizeof (ElfNN_External_Rela);
+
+ h->needs_plt = 1;
+ }
+ while (0);
+
+ if (!h->needs_plt)
+ h->plt.offset = MINUS_ONE;
+
+ if (0 < h->got.refcount)
+ {
+ asection *s;
+ bool dyn;
+ int tls_type = loongarch_elf_hash_entry (h)->tls_type;
+
+ /* Make sure this symbol is output as a dynamic symbol.
+ Undefined weak syms won't yet be marked as dynamic. */
+ if (h->dynindx == -1 && !h->forced_local
+ && !bfd_elf_link_record_dynamic_symbol (info, h))
+ return false;
+
+ s = htab->elf.sgot;
+ h->got.offset = s->size;
+ dyn = htab->elf.dynamic_sections_created;
+ if (tls_type & (GOT_TLS_GD | GOT_TLS_IE))
+ {
+ /* TLS_GD needs two dynamic relocs and two GOT slots. */
+ if (tls_type & GOT_TLS_GD)
+ {
+ s->size += 2 * GOT_ENTRY_SIZE;
+ htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela);
+ }
+
+ /* TLS_IE needs one dynamic reloc and one GOT slot. */
+ if (tls_type & GOT_TLS_IE)
+ {
+ s->size += GOT_ENTRY_SIZE;
+ htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
+ }
+ }
+ else
+ {
+ s->size += GOT_ENTRY_SIZE;
+ if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
+ || h->type == STT_GNU_IFUNC)
+ htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
+ }
+ }
+ else
+ h->got.offset = MINUS_ONE;
+
+ if (eh->dyn_relocs == NULL)
+ return true;
+
+ if (SYMBOL_REFERENCES_LOCAL (info, h))
+ {
+ struct elf_dyn_relocs **pp;
+
+ for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
+ {
+ p->count -= p->pc_count;
+ p->pc_count = 0;
+ if (p->count == 0)
+ *pp = p->next;
+ else
+ pp = &p->next;
+ }
+ }
+
+ if (h->root.type == bfd_link_hash_undefweak)
+ {
+ if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
+ eh->dyn_relocs = NULL;
+ else if (h->dynindx == -1 && !h->forced_local
+ /* Make sure this symbol is output as a dynamic symbol.
+ Undefined weak syms won't yet be marked as dynamic. */
+ && !bfd_elf_link_record_dynamic_symbol (info, h))
+ return false;
+ }
+
+ for (p = eh->dyn_relocs; p != NULL; p = p->next)
+ {
+ asection *sreloc = elf_section_data (p->sec)->sreloc;
+ sreloc->size += p->count * sizeof (ElfNN_External_Rela);
+ }
+
+ return true;
+}
+
+static bool
+elfNN_loongarch_allocate_local_dynrelocs (void **slot, void *inf)
+{
+ struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) *slot;
+
+ if (!h->def_regular || !h->ref_regular || !h->forced_local
+ || h->root.type != bfd_link_hash_defined)
+ abort ();
+
+ return allocate_dynrelocs (h, inf);
+}
+
+/* Set DF_TEXTREL if we find any dynamic relocs that apply to
+ read-only sections. */
+
+static bool
+maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
+{
+ asection *sec;
+
+ if (h->root.type == bfd_link_hash_indirect)
+ return true;
+
+ sec = readonly_dynrelocs (h);
+ if (sec != NULL)
+ {
+ struct bfd_link_info *info = (struct bfd_link_info *) info_p;
+
+ info->flags |= DF_TEXTREL;
+ info->callbacks->minfo (_ ("%pB: dynamic relocation against `%pT' in "
+ "read-only section `%pA'\n"),
+ sec->owner, h->root.root.string, sec);
+
+ /* Not an error, just cut short the traversal. */
+ return false;
+ }
+ return true;
+}
+
+static bool
+loongarch_elf_size_dynamic_sections (bfd *output_bfd,
+ struct bfd_link_info *info)
+{
+ struct loongarch_elf_link_hash_table *htab;
+ bfd *dynobj;
+ asection *s;
+ bfd *ibfd;
+
+ htab = loongarch_elf_hash_table (info);
+ BFD_ASSERT (htab != NULL);
+ dynobj = htab->elf.dynobj;
+ BFD_ASSERT (dynobj != NULL);
+
+ if (htab->elf.dynamic_sections_created)
+ {
+ /* Set the contents of the .interp section to the interpreter. */
+ if (bfd_link_executable (info) && !info->nointerp)
+ {
+ const char *interpreter;
+ flagword flags = elf_elfheader (output_bfd)->e_flags;
+ s = bfd_get_linker_section (dynobj, ".interp");
+ BFD_ASSERT (s != NULL);
+ if ((flags & EF_LARCH_ABI) == EF_LARCH_ABI_LP32)
+ interpreter = "/lib32/ld.so.1";
+ else if ((flags & EF_LARCH_ABI) == EF_LARCH_ABI_LP64)
+ interpreter = "/lib64/ld.so.1";
+ else
+ interpreter = "/lib/ld.so.1";
+ s->contents = (unsigned char *) interpreter;
+ s->size = strlen (interpreter) + 1;
+ }
+ }
+
+ /* Set up .got offsets for local syms, and space for local dynamic
+ relocs. */
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
+ {
+ bfd_signed_vma *local_got;
+ bfd_signed_vma *end_local_got;
+ char *local_tls_type;
+ bfd_size_type locsymcount;
+ Elf_Internal_Shdr *symtab_hdr;
+ asection *srel;
+
+ if (!is_loongarch_elf (ibfd))
+ continue;
+
+ for (s = ibfd->sections; s != NULL; s = s->next)
+ {
+ struct elf_dyn_relocs *p;
+
+ for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
+ {
+ p->count -= p->pc_count;
+ if (!bfd_is_abs_section (p->sec)
+ && bfd_is_abs_section (p->sec->output_section))
+ {
+ /* Input section has been discarded, either because
+ it is a copy of a linkonce section or due to
+ linker script /DISCARD/, so we'll be discarding
+ the relocs too. */
+ }
+ else if (0 < p->count)
+ {
+ srel = elf_section_data (p->sec)->sreloc;
+ srel->size += p->count * sizeof (ElfNN_External_Rela);
+ if ((p->sec->output_section->flags & SEC_READONLY) != 0)
+ info->flags |= DF_TEXTREL;
+ }
+ }
+ }
+
+ local_got = elf_local_got_refcounts (ibfd);
+ if (!local_got)
+ continue;
+
+ symtab_hdr = &elf_symtab_hdr (ibfd);
+ locsymcount = symtab_hdr->sh_info;
+ end_local_got = local_got + locsymcount;
+ local_tls_type = _bfd_loongarch_elf_local_got_tls_type (ibfd);
+ s = htab->elf.sgot;
+ srel = htab->elf.srelgot;
+ for (; local_got < end_local_got; ++local_got, ++local_tls_type)
+ {
+ if (0 < *local_got)
+ {
+ *local_got = s->size;
+ s->size += GOT_ENTRY_SIZE;
+
+ if (*local_tls_type & GOT_TLS_GD)
+ s->size += GOT_ENTRY_SIZE;
+
+ /* If R_LARCH_RELATIVE. */
+ if (bfd_link_pic (info)
+ /* Or R_LARCH_TLS_DTPRELNN or R_LARCH_TLS_TPRELNN. */
+ || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
+ srel->size += sizeof (ElfNN_External_Rela);
+ }
+ else
+ *local_got = MINUS_ONE;
+ }
+ }
+
+ /* Allocate global sym .plt and .got entries, and space for global
+ sym dynamic relocs. */
+ elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
+ /* Allocate .plt and .got entries, and space for local ifunc symbols. */
+ htab_traverse (htab->loc_hash_table,
+ (void *) elfNN_loongarch_allocate_local_dynrelocs, info);
+
+ /* Don't allocate .got.plt section if there are no PLT. */
+ if (htab->elf.sgotplt && htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE
+ && (htab->elf.splt == NULL || htab->elf.splt->size == 0))
+ htab->elf.sgotplt->size = 0;
+
+ /* The check_relocs and adjust_dynamic_symbol entry points have
+ determined the sizes of the various dynamic sections. Allocate
+ memory for them. */
+ for (s = dynobj->sections; s != NULL; s = s->next)
+ {
+ if ((s->flags & SEC_LINKER_CREATED) == 0)
+ continue;
+
+ if (s == htab->elf.splt || s == htab->elf.iplt || s == htab->elf.sgot
+ || s == htab->elf.sgotplt || s == htab->elf.igotplt
+ || s == htab->elf.sdynbss || s == htab->elf.sdynrelro)
+ {
+ /* Strip this section if we don't need it; see the
+ comment below. */
+ }
+ else if (strncmp (s->name, ".rela", 5) == 0)
+ {
+ if (s->size != 0)
+ {
+ /* We use the reloc_count field as a counter if we need
+ to copy relocs into the output file. */
+ s->reloc_count = 0;
+ }
+ }
+ else
+ {
+ /* It's not one of our sections. */
+ continue;
+ }
+
+ if (s->size == 0)
+ {
+ /* If we don't need this section, strip it from the
+ output file. This is mostly to handle .rela.bss and
+ .rela.plt. We must create both sections in
+ create_dynamic_sections, because they must be created
+ before the linker maps input sections to output
+ sections. The linker does that before
+ adjust_dynamic_symbol is called, and it is that
+ function which decides whether anything needs to go
+ into these sections. */
+ s->flags |= SEC_EXCLUDE;
+ continue;
+ }
+
+ if ((s->flags & SEC_HAS_CONTENTS) == 0)
+ continue;
+
+ /* Allocate memory for the section contents. Zero the memory
+ for the benefit of .rela.plt, which has 4 unused entries
+ at the beginning, and we don't want garbage. */
+ s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
+ if (s->contents == NULL)
+ return false;
+ }
+
+ if (elf_hash_table (info)->dynamic_sections_created)
+ {
+ /* Add some entries to the .dynamic section. We fill in the
+ values later, in loongarch_elf_finish_dynamic_sections, but we
+ must add the entries now so that we get the correct size for
+ the .dynamic section. The DT_DEBUG entry is filled in by the
+ dynamic linker and used by the debugger. */
+#define add_dynamic_entry(TAG, VAL) _bfd_elf_add_dynamic_entry (info, TAG, VAL)
+
+ if (bfd_link_executable (info))
+ {
+ if (!add_dynamic_entry (DT_DEBUG, 0))
+ return false;
+ }
+
+ if (htab->elf.srelplt->size != 0)
+ {
+ if (!add_dynamic_entry (DT_PLTGOT, 0)
+ || !add_dynamic_entry (DT_PLTRELSZ, 0)
+ || !add_dynamic_entry (DT_PLTREL, DT_RELA)
+ || !add_dynamic_entry (DT_JMPREL, 0))
+ return false;
+ }
+
+ if (!add_dynamic_entry (DT_RELA, 0)
+ || !add_dynamic_entry (DT_RELASZ, 0)
+ || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
+ return false;
+
+ /* If any dynamic relocs apply to a read-only section,
+ then we need a DT_TEXTREL entry. */
+ if ((info->flags & DF_TEXTREL) == 0)
+ elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
+
+ if (info->flags & DF_TEXTREL)
+ {
+ if (!add_dynamic_entry (DT_TEXTREL, 0))
+ return false;
+ /* Clear the DF_TEXTREL flag. It will be set again if we
+ write out an actual text relocation; we may not, because
+ at this point we do not know whether e.g. any .eh_frame
+ absolute relocations have been converted to PC-relative. */
+ info->flags &= ~DF_TEXTREL;
+ }
+ }
+#undef add_dynamic_entry
+
+ return true;
+}
+
+#define LARCH_LD_STACK_DEPTH 16
+static int64_t larch_opc_stack[LARCH_LD_STACK_DEPTH];
+static size_t larch_stack_top = 0;
+
+static bfd_reloc_status_type
+loongarch_push (int64_t val)
+{
+ if (LARCH_LD_STACK_DEPTH <= larch_stack_top)
+ return bfd_reloc_outofrange;
+ larch_opc_stack[larch_stack_top++] = val;
+ return bfd_reloc_ok;
+}
+
+static bfd_reloc_status_type
+loongarch_pop (int64_t *val)
+{
+ if (larch_stack_top == 0)
+ return bfd_reloc_outofrange;
+ BFD_ASSERT (val);
+ *val = larch_opc_stack[--larch_stack_top];
+ return bfd_reloc_ok;
+}
+
+static bfd_reloc_status_type
+loongarch_top (int64_t *val)
+{
+ if (larch_stack_top == 0)
+ return bfd_reloc_outofrange;
+ BFD_ASSERT (val);
+ *val = larch_opc_stack[larch_stack_top - 1];
+ return bfd_reloc_ok;
+}
+
+static void
+loongarch_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
+{
+ const struct elf_backend_data *bed;
+ bfd_byte *loc;
+
+ bed = get_elf_backend_data (abfd);
+ loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
+ bed->s->swap_reloca_out (abfd, rel, loc);
+}
+
+#define LARCH_RELOC_PERFORM_3OP(op1, op2, op3) \
+ ({ \
+ bfd_reloc_status_type ret = loongarch_pop (&op2); \
+ if (ret == bfd_reloc_ok) \
+ { \
+ ret = loongarch_pop (&op1); \
+ if (ret == bfd_reloc_ok) \
+ ret = loongarch_push (op3); \
+ } \
+ ret; \
+ })
+
+#define LARCH_RELOC_UINT32_BIT_MASK(bitsize) \
+ (~((0x1U << (bitsize)) - 1))
+
+static bfd_reloc_status_type
+loongarch_reloc_rewrite_imm_insn (const Elf_Internal_Rela *rel,
+ const asection *input_section ATTRIBUTE_UNUSED,
+ reloc_howto_type *howto, bfd *input_bfd,
+ bfd_byte *contents, int64_t op,
+ bool is_signed)
+{
+
+ /* Check op low bits if rightshift != 0, before rightshift */
+ if (howto->rightshift
+ && (((0x1U << howto->rightshift) - 1) & op))
+ return bfd_reloc_overflow;
+
+ uint32_t imm = (uint32_t)(int32_t)(op >> howto->rightshift);
+
+ if (is_signed)
+ {
+ if (op >= 0)
+ {
+ if (LARCH_RELOC_UINT32_BIT_MASK (howto->bitsize - 1) & imm)
+ return bfd_reloc_overflow;
+ }
+ else
+ {
+ if ((LARCH_RELOC_UINT32_BIT_MASK (howto->bitsize - 1) & imm)
+ != LARCH_RELOC_UINT32_BIT_MASK (howto->bitsize - 1))
+ return bfd_reloc_overflow;
+ }
+ }
+ else
+ {
+ if (LARCH_RELOC_UINT32_BIT_MASK (howto->bitsize) & imm)
+ return bfd_reloc_overflow;
+ }
+
+
+ int bits = bfd_get_reloc_size (howto) * 8;
+ uint32_t insn = bfd_get (bits, input_bfd, contents + rel->r_offset);
+
+ imm = imm & ((0x1U << howto->bitsize) - 1);
+ imm <<= howto->bitpos;
+ insn = (insn & howto->src_mask)
+ | ((insn & (~(uint32_t) howto->dst_mask)) | imm);
+ bfd_put (bits, input_bfd, insn, contents + rel->r_offset);
+
+ return bfd_reloc_ok;
+}
+
+/* Emplace a static relocation. */
+
+static bfd_reloc_status_type
+perform_relocation (const Elf_Internal_Rela *rel, asection *input_section,
+ reloc_howto_type *howto, bfd_vma value,
+ bfd *input_bfd, bfd_byte *contents)
+{
+
+ uint32_t insn1;
+ int64_t opr1, opr2, opr3;
+ bfd_reloc_status_type r = bfd_reloc_ok;
+ int bits = bfd_get_reloc_size (howto) * 8;
+
+
+ switch (ELFNN_R_TYPE (rel->r_info))
+ {
+ case R_LARCH_SOP_PUSH_PCREL:
+ case R_LARCH_SOP_PUSH_ABSOLUTE:
+ case R_LARCH_SOP_PUSH_GPREL:
+ case R_LARCH_SOP_PUSH_TLS_TPREL:
+ case R_LARCH_SOP_PUSH_TLS_GOT:
+ case R_LARCH_SOP_PUSH_TLS_GD:
+ case R_LARCH_SOP_PUSH_PLT_PCREL:
+ r = loongarch_push (value);
+ break;
+
+ case R_LARCH_SOP_PUSH_DUP:
+ r = loongarch_pop (&opr1);
+ if (r == bfd_reloc_ok)
+ {
+ r = loongarch_push (opr1);
+ if (r == bfd_reloc_ok)
+ r = loongarch_push (opr1);
+ }
+ break;
+
+ case R_LARCH_SOP_ASSERT:
+ r = loongarch_pop (&opr1);
+ if (r != bfd_reloc_ok || opr1 == false)
+ r = bfd_reloc_notsupported;
+ break;
+
+ case R_LARCH_SOP_NOT:
+ r = loongarch_pop (&opr1);
+ if (r == bfd_reloc_ok)
+ r= loongarch_push (!opr1);
+ break;
+
+ case R_LARCH_SOP_SUB:
+ r = LARCH_RELOC_PERFORM_3OP (opr1, opr2, opr1 - opr2);
+ break;
+
+ case R_LARCH_SOP_SL:
+ r = LARCH_RELOC_PERFORM_3OP (opr1, opr2, opr1 << opr2);
+ break;
+
+ case R_LARCH_SOP_SR:
+ r = LARCH_RELOC_PERFORM_3OP (opr1, opr2, opr1 >> opr2);
+ break;
+
+ case R_LARCH_SOP_AND:
+ r = LARCH_RELOC_PERFORM_3OP (opr1, opr2, opr1 & opr2);
+ break;
+
+ case R_LARCH_SOP_ADD:
+ r = LARCH_RELOC_PERFORM_3OP (opr1, opr2, opr1 + opr2);
+ break;
+
+ case R_LARCH_SOP_IF_ELSE:
+ r = loongarch_pop (&opr3);
+ if (r == bfd_reloc_ok)
+ {
+ r = loongarch_pop (&opr2);
+ if (r == bfd_reloc_ok)
+ {
+ r = loongarch_pop (&opr1);
+ if (r == bfd_reloc_ok)
+ r = loongarch_push (opr1 ? opr2 : opr3);
+ }
+ }
+ break;
+
+ case R_LARCH_SOP_POP_32_S_10_5:
+ case R_LARCH_SOP_POP_32_S_10_12:
+ case R_LARCH_SOP_POP_32_S_10_16:
+ case R_LARCH_SOP_POP_32_S_10_16_S2:
+ case R_LARCH_SOP_POP_32_S_5_20:
+ r = loongarch_pop (&opr1);
+ if (r == bfd_reloc_ok)
+ {
+ r = loongarch_reloc_rewrite_imm_insn (rel, input_section,
+ howto, input_bfd,
+ contents, opr1, true);
+ }
+ break;
+
+ case R_LARCH_SOP_POP_32_U_10_12:
+ r = loongarch_pop (&opr1);
+ if (r == bfd_reloc_ok)
+ {
+ r = loongarch_reloc_rewrite_imm_insn (rel, input_section,
+ howto, input_bfd,
+ contents, opr1, false);
+ }
+ break;
+
+ case R_LARCH_SOP_POP_32_S_0_5_10_16_S2:
+ {
+ r = loongarch_pop (&opr1);
+ if (r != bfd_reloc_ok)
+ break;
+
+ if ((opr1 & 0x3) != 0)
+ {
+ r = bfd_reloc_overflow;
+ break;
+ }
+
+ uint32_t imm = opr1 >> howto->rightshift;
+ if ((imm & (~0xfffffU)) && ((imm & (~0xfffffU)) != (~0xfffffU)))
+ {
+ r = bfd_reloc_overflow;
+ break;
+ }
+
+ insn1 = bfd_get (bits, input_bfd, contents + rel->r_offset);
+ insn1 = (insn1 & howto->src_mask)
+ | ((imm & 0xffffU) << 10)
+ | ((imm & 0x1f0000U) >> 16);
+ bfd_put (bits, input_bfd, insn1, contents + rel->r_offset);
+ break;
+ }
+
+ case R_LARCH_SOP_POP_32_S_0_10_10_16_S2:
+ {
+ r = loongarch_pop (&opr1);
+ if (r != bfd_reloc_ok)
+ break;
+
+ if ((opr1 & 0x3) != 0)
+ {
+ r = bfd_reloc_overflow;
+ break;
+ }
+
+ uint32_t imm = opr1 >> howto->rightshift;
+ if ((imm & (~0x1ffffffU)) && (imm & (~0x1ffffffU)) != (~0x1ffffffU))
+ {
+ r = bfd_reloc_overflow;
+ break;
+ }
+
+ insn1 = bfd_get (bits, input_bfd, contents + rel->r_offset);
+ insn1 = (insn1 & howto->src_mask)
+ | ((imm & 0xffffU) << 10)
+ | ((imm & 0x3ff0000U) >> 16);
+ bfd_put (bits, input_bfd, insn1, contents + rel->r_offset);
+ break;
+ }
+
+ case R_LARCH_SOP_POP_32_U:
+ r = loongarch_pop (&opr1);
+ if (r != bfd_reloc_ok)
+ break;
+ if ((uint64_t)opr1 & ~(uint64_t) 0xffffffff)
+ r = bfd_reloc_overflow;
+ if (r != bfd_reloc_ok)
+ break;
+ bfd_put (bits, input_bfd, opr1, contents + rel->r_offset);
+ break;
+
+ case R_LARCH_TLS_DTPREL32:
+ case R_LARCH_32:
+ case R_LARCH_TLS_DTPREL64:
+ case R_LARCH_64:
+ bfd_put (bits, input_bfd, value, contents + rel->r_offset);
+ break;
+
+ case R_LARCH_ADD8:
+ case R_LARCH_ADD16:
+ case R_LARCH_ADD24:
+ case R_LARCH_ADD32:
+ case R_LARCH_ADD64:
+ opr1 = bfd_get (bits, input_bfd, contents + rel->r_offset);
+ bfd_put (bits, input_bfd, opr1 + value,
+ contents + rel->r_offset);
+ break;
+
+ case R_LARCH_SUB8:
+ case R_LARCH_SUB16:
+ case R_LARCH_SUB24:
+ case R_LARCH_SUB32:
+ case R_LARCH_SUB64:
+ opr1 = bfd_get (bits, input_bfd, contents + rel->r_offset);
+ bfd_put (bits, input_bfd, opr1 - value,
+ contents + rel->r_offset);
+ break;
+
+ default:
+ r = bfd_reloc_notsupported;
+ }
+ return r;
+}
+
+#define LARCH_RECENT_RELOC_QUEUE_LENGTH 72
+static struct
+{
+ bfd *bfd;
+ asection *section;
+ bfd_vma r_offset;
+ int r_type;
+ bfd_vma relocation;
+ Elf_Internal_Sym *sym;
+ struct elf_link_hash_entry *h;
+ bfd_vma addend;
+ int64_t top_then;
+} larch_reloc_queue[LARCH_RECENT_RELOC_QUEUE_LENGTH];
+static size_t larch_reloc_queue_head = 0;
+static size_t larch_reloc_queue_tail = 0;
+
+static const char *
+loongarch_sym_name (bfd *input_bfd, struct elf_link_hash_entry *h,
+ Elf_Internal_Sym *sym)
+{
+ const char *ret = NULL;
+ if (sym)
+ ret = bfd_elf_string_from_elf_section (
+ input_bfd, elf_symtab_hdr (input_bfd).sh_link, sym->st_name);
+ else if (h)
+ ret = h->root.root.string;
+
+ if (ret == NULL || *ret == '\0')
+ ret = "<nameless>";
+ return ret;
+}
+
+static void
+loongarch_record_one_reloc (bfd *abfd, asection *section, int r_type,
+ bfd_vma r_offset, Elf_Internal_Sym *sym,
+ struct elf_link_hash_entry *h, bfd_vma addend)
+{
+ if ((larch_reloc_queue_head == 0
+ && larch_reloc_queue_tail == LARCH_RECENT_RELOC_QUEUE_LENGTH - 1)
+ || (larch_reloc_queue_head == larch_reloc_queue_tail + 1))
+ larch_reloc_queue_head =
+ (larch_reloc_queue_head + 1) % LARCH_RECENT_RELOC_QUEUE_LENGTH;
+ larch_reloc_queue[larch_reloc_queue_tail].bfd = abfd;
+ larch_reloc_queue[larch_reloc_queue_tail].section = section;
+ larch_reloc_queue[larch_reloc_queue_tail].r_offset = r_offset;
+ larch_reloc_queue[larch_reloc_queue_tail].r_type = r_type;
+ larch_reloc_queue[larch_reloc_queue_tail].sym = sym;
+ larch_reloc_queue[larch_reloc_queue_tail].h = h;
+ larch_reloc_queue[larch_reloc_queue_tail].addend = addend;
+ loongarch_top (&larch_reloc_queue[larch_reloc_queue_tail].top_then);
+ larch_reloc_queue_tail =
+ (larch_reloc_queue_tail + 1) % LARCH_RECENT_RELOC_QUEUE_LENGTH;
+}
+
+static void
+loongarch_dump_reloc_record (void (*p) (const char *fmt, ...))
+{
+ size_t i = larch_reloc_queue_head;
+ bfd *a_bfd = NULL;
+ asection *section = NULL;
+ bfd_vma r_offset = 0;
+ int inited = 0;
+ p ("Dump relocate record:\n");
+ p ("stack top\t\trelocation name\t\tsymbol");
+ while (i != larch_reloc_queue_tail)
+ {
+ if (a_bfd != larch_reloc_queue[i].bfd
+ || section != larch_reloc_queue[i].section
+ || r_offset != larch_reloc_queue[i].r_offset)
+ {
+ a_bfd = larch_reloc_queue[i].bfd;
+ section = larch_reloc_queue[i].section;
+ r_offset = larch_reloc_queue[i].r_offset;
+ p ("\nat %pB(%pA+0x%v):\n", larch_reloc_queue[i].bfd,
+ larch_reloc_queue[i].section, larch_reloc_queue[i].r_offset);
+ }
+
+ if (!inited)
+ inited = 1, p ("...\n");
+
+ reloc_howto_type *howto =
+ loongarch_elf_rtype_to_howto (larch_reloc_queue[i].bfd,
+ larch_reloc_queue[i].r_type);
+ p ("0x%V %s\t`%s'", (bfd_vma) larch_reloc_queue[i].top_then,
+ howto ? howto->name : "<unknown reloc>",
+ loongarch_sym_name (larch_reloc_queue[i].bfd, larch_reloc_queue[i].h,
+ larch_reloc_queue[i].sym));
+
+ long addend = larch_reloc_queue[i].addend;
+ if (addend < 0)
+ p (" - %ld", -addend);
+ else if (0 < addend)
+ p (" + %ld(0x%v)", addend, larch_reloc_queue[i].addend);
+
+ p ("\n");
+ i = (i + 1) % LARCH_RECENT_RELOC_QUEUE_LENGTH;
+ }
+ p ("\n"
+ "-- Record dump end --\n\n");
+}
+
+
+static bool
+loongarch_reloc_is_fatal (struct bfd_link_info *info,
+ bfd *input_bfd,
+ asection *input_section,
+ Elf_Internal_Rela *rel,
+ reloc_howto_type *howto,
+ bfd_reloc_status_type rtype,
+ bool is_undefweak,
+ const char *name,
+ const char *msg)
+{
+ bool fatal = true;
+ switch (rtype)
+ {
+ /* 'dangerous' means we do it but can't promise it's ok
+ 'unsupport' means out of ability of relocation type
+ 'undefined' means we can't deal with the undefined symbol. */
+ case bfd_reloc_undefined:
+ info->callbacks->undefined_symbol (
+ info, name, input_bfd, input_section, rel->r_offset, true);
+ info->callbacks->info (
+ "%X%pB(%pA+0x%v): error: %s against %s`%s':\n%s\n",
+ input_bfd, input_section, (bfd_vma) rel->r_offset, howto->name,
+ is_undefweak ? "[undefweak] " : "", name, msg);
+ break;
+ case bfd_reloc_dangerous:
+ info->callbacks->info (
+ "%pB(%pA+0x%v): warning: %s against %s`%s':\n%s\n",
+ input_bfd, input_section, (bfd_vma) rel->r_offset, howto->name,
+ is_undefweak ? "[undefweak] " : "", name, msg);
+ fatal = false;
+ break;
+ case bfd_reloc_notsupported:
+ info->callbacks->info (
+ "%X%pB(%pA+0x%v): error: %s against %s`%s':\n%s\n",
+ input_bfd, input_section, (bfd_vma) rel->r_offset, howto->name,
+ is_undefweak ? "[undefweak] " : "", name, msg);
+ break;
+ default:
+ break;
+ }
+ return fatal;
+}
+
+
+
+
+static int
+loongarch_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
+ bfd *input_bfd, asection *input_section,
+ bfd_byte *contents, Elf_Internal_Rela *relocs,
+ Elf_Internal_Sym *local_syms,
+ asection **local_sections)
+{
+ Elf_Internal_Rela *rel;
+ Elf_Internal_Rela *relend;
+ bool fatal = false;
+ asection *sreloc = elf_section_data (input_section)->sreloc;
+ struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);
+ Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
+ struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
+ bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
+ bool is_pic = bfd_link_pic (info);
+ bool is_dyn = elf_hash_table (info)->dynamic_sections_created;
+ asection *plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
+ asection *got = htab->elf.sgot;
+
+ relend = relocs + input_section->reloc_count;
+ for (rel = relocs; rel < relend; rel++)
+ {
+ int r_type = ELFNN_R_TYPE (rel->r_info);
+ unsigned long r_symndx = ELFNN_R_SYM (rel->r_info);
+ bfd_vma pc = sec_addr (input_section) + rel->r_offset;
+ reloc_howto_type *howto = NULL;
+ asection *sec = NULL;
+ Elf_Internal_Sym *sym = NULL;
+ struct elf_link_hash_entry *h = NULL;
+ const char *name;
+ bfd_reloc_status_type r = bfd_reloc_ok;
+ bool is_ie, is_undefweak, unresolved_reloc, defined_local;
+ bool resolved_local, resolved_dynly, resolved_to_const;
+ char tls_type;
+ bfd_vma relocation;
+ bfd_vma off, ie_off;
+ int i, j;
+
+ howto = loongarch_elf_rtype_to_howto (input_bfd, r_type);
+ if (howto == NULL || r_type == R_LARCH_GNU_VTINHERIT
+ || r_type == R_LARCH_GNU_VTENTRY)
+ continue;
+
+ /* This is a final link. */
+ if (r_symndx < symtab_hdr->sh_info)
+ {
+ is_undefweak = false;
+ unresolved_reloc = false;
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ /* Relocate against local STT_GNU_IFUNC symbol. */
+ if (!bfd_link_relocatable (info)
+ && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
+ {
+ h = elfNN_loongarch_get_local_sym_hash (htab, input_bfd, rel,
+ false);
+ if (h == NULL)
+ abort ();
+
+ /* Set STT_GNU_IFUNC symbol value. */
+ h->root.u.def.value = sym->st_value;
+ h->root.u.def.section = sec;
+ }
+ defined_local = true;
+ resolved_local = true;
+ resolved_dynly = false;
+ resolved_to_const = false;
+ if (bfd_link_relocatable (info)
+ && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+ {
+ rel->r_addend += sec->output_offset;
+ }
+ }
+ else
+ {
+ bool warned, ignored;
+
+ RELOC_FOR_GLOBAL_SYMBOL (
+ info, input_bfd, input_section, rel, r_symndx, symtab_hdr,
+ sym_hashes, h, sec, relocation, unresolved_reloc, warned, ignored);
+ /* Here means symbol isn't local symbol only and 'h != NULL'. */
+
+ /* The 'unresolved_syms_in_objects' specify how to deal with undefined
+ symbol. And 'dynamic_undefined_weak' specify what to do when
+ meeting undefweak. */
+
+ if ((is_undefweak = h->root.type == bfd_link_hash_undefweak))
+ {
+ defined_local = false;
+ resolved_local = false;
+ resolved_to_const = !is_dyn || h->dynindx == -1
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h);
+ resolved_dynly = !resolved_local && !resolved_to_const;
+ }
+ else if (warned)
+ {
+ /* Symbol undefined offen means failed already. I don't know why
+ 'warned' here but I guess it want to continue relocating as if
+ no error occures to find other errors as more as possible. */
+
+ /* To avoid generating warning messages about truncated
+ relocations, set the relocation's address to be the same as
+ the start of this section. */
+ relocation = input_section->output_section
+ ? input_section->output_section->vma
+ : 0;
+
+ defined_local = relocation != 0;
+ resolved_local = defined_local;
+ resolved_to_const = !resolved_local;
+ resolved_dynly = false;
+ }
+ else
+ {
+ defined_local = !unresolved_reloc && !ignored;
+ resolved_local =
+ defined_local && SYMBOL_REFERENCES_LOCAL (info, h);
+ resolved_dynly = !resolved_local;
+ resolved_to_const = !resolved_local && !resolved_dynly;
+ }
+ }
+
+ name = loongarch_sym_name (input_bfd, h, sym);
+
+ if (sec != NULL && discarded_section (sec))
+ RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, rel,
+ 1, relend, howto, 0, contents);
+
+ if (bfd_link_relocatable (info))
+ continue;
+
+ /* The r_symndx will be STN_UNDEF (zero) only for relocs against symbols
+ from removed linkonce sections, or sections discarded by a linker
+ script. Also for R_*_SOP_PUSH_ABSOLUTE and PCREL to specify const. */
+ if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
+ resolved_dynly = resolved_local = defined_local = false,
+ resolved_to_const = true;
+
+ if (h && h->type == STT_GNU_IFUNC)
+ {
+ if (h->plt.offset == MINUS_ONE)
+ info->callbacks->info ("%X%pB(%pA+0x%v): error: %s against `%s':\n"
+ "STT_GNU_IFUNC must have PLT stub"
+ "\n",
+ input_bfd, input_section,
+ (bfd_vma) rel->r_offset, howto->name, name);
+ defined_local = true;
+ resolved_local = true;
+ resolved_dynly = false;
+ resolved_to_const = false;
+ relocation = sec_addr (plt) + h->plt.offset;
+ }
+
+ unresolved_reloc = resolved_dynly;
+
+ BFD_ASSERT (resolved_local + resolved_dynly + resolved_to_const == 1);
+
+ BFD_ASSERT (!resolved_dynly || (h && h->dynindx != -1));
+
+ BFD_ASSERT (!resolved_local || defined_local);
+
+ is_ie = false;
+ switch (r_type)
+ {
+ case R_LARCH_MARK_PCREL:
+ case R_LARCH_MARK_LA:
+ case R_LARCH_NONE:
+ r = bfd_reloc_continue;
+ unresolved_reloc = false;
+ break;
+
+ case R_LARCH_32:
+ case R_LARCH_64:
+ if (resolved_dynly || (is_pic && resolved_local))
+ {
+ Elf_Internal_Rela outrel;
+
+ /* When generating a shared object, these relocations are copied
+ into the output file to be resolved at run time. */
+
+ outrel.r_offset = _bfd_elf_section_offset (
+ output_bfd, info, input_section, rel->r_offset);
+
+ unresolved_reloc = !((bfd_vma) -2 <= outrel.r_offset)
+ && (input_section->flags & SEC_ALLOC);
+
+ outrel.r_offset += sec_addr (input_section);
+ if (resolved_dynly)
+ {
+ outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
+ outrel.r_addend = rel->r_addend;
+ }
+ else
+ {
+ outrel.r_info = ELFNN_R_INFO (0, R_LARCH_RELATIVE);
+ outrel.r_addend = relocation + rel->r_addend;
+ }
+
+ if (unresolved_reloc)
+ loongarch_elf_append_rela (output_bfd, sreloc, &outrel);
+ }
+
+ relocation += rel->r_addend;
+ break;
+
+ case R_LARCH_ADD8:
+ case R_LARCH_ADD16:
+ case R_LARCH_ADD24:
+ case R_LARCH_ADD32:
+ case R_LARCH_ADD64:
+ case R_LARCH_SUB8:
+ case R_LARCH_SUB16:
+ case R_LARCH_SUB24:
+ case R_LARCH_SUB32:
+ case R_LARCH_SUB64:
+ if (resolved_dynly)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto, bfd_reloc_undefined,
+ is_undefweak, name,
+ "Can't be resolved dynamically. "
+ "If this procedure is hand-writing assemble,\n"
+ "there must be something like '.dword sym1 - sym2' "
+ "to generate these relocs\n"
+ "and we can't get known link-time address of "
+ "these symbols. ");
+ }
+ else
+ relocation += rel->r_addend;
+
+ break;
+
+ case R_LARCH_TLS_DTPREL32:
+ case R_LARCH_TLS_DTPREL64:
+ if (resolved_dynly)
+ {
+ Elf_Internal_Rela outrel;
+
+ outrel.r_offset = _bfd_elf_section_offset (
+ output_bfd, info, input_section, rel->r_offset);
+
+ unresolved_reloc = !((bfd_vma) -2 <= outrel.r_offset)
+ && (input_section->flags & SEC_ALLOC);
+ outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
+ outrel.r_offset += sec_addr (input_section);
+ outrel.r_addend = rel->r_addend;
+ if (unresolved_reloc)
+ loongarch_elf_append_rela (output_bfd, sreloc, &outrel);
+ break;
+ }
+
+ if (resolved_to_const)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto, bfd_reloc_notsupported,
+ is_undefweak, name,
+ "Internal:");
+ }
+ break;
+ case R_LARCH_SOP_PUSH_TLS_TPREL:
+ if (resolved_local)
+ {
+ if (!elf_hash_table (info)->tls_sec)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto, bfd_reloc_notsupported,
+ is_undefweak, name, "TLS section not be created");
+ }
+ else
+ relocation -= elf_hash_table (info)->tls_sec->vma;
+ }
+ else
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto, bfd_reloc_undefined,
+ is_undefweak, name,
+ "TLS LE just can be resolved local only.");
+ }
+ break;
+
+ case R_LARCH_SOP_PUSH_ABSOLUTE:
+ if (is_undefweak)
+ {
+ if (resolved_dynly)
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_dangerous, is_undefweak, name,
+ "Someone require us to resolve undefweak "
+ "symbol dynamically. \n"
+ "But this reloc can't be done. "
+ "I think I can't throw error "
+ "for this\n"
+ "so I resolved it to 0. "
+ "I suggest to re-compile with '-fpic'. ");
+
+ relocation = 0;
+ unresolved_reloc = false;
+ break;
+ }
+
+ if (resolved_to_const)
+ {
+ relocation += rel->r_addend;
+ break;
+ }
+
+ if (is_pic)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto, bfd_reloc_notsupported,
+ is_undefweak, name,
+ "Under PIC we don't know load address. Re-compile src "
+ "with '-fpic'?");
+ break;
+ }
+
+ if (resolved_dynly)
+ {
+ if (!(plt && h && h->plt.offset != MINUS_ONE))
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto, bfd_reloc_undefined,
+ is_undefweak, name,
+ "Can't be resolved dynamically. Try to re-compile "
+ "src with '-fpic'?");
+ break;
+ }
+
+ if (rel->r_addend != 0)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Shouldn't be with r_addend.");
+ break;
+ }
+
+ relocation = sec_addr (plt) + h->plt.offset;
+ unresolved_reloc = false;
+ break;
+ }
+
+ if (resolved_local)
+ {
+ relocation += rel->r_addend;
+ break;
+ }
+
+ break;
+
+ case R_LARCH_SOP_PUSH_PCREL:
+ case R_LARCH_SOP_PUSH_PLT_PCREL:
+ unresolved_reloc = false;
+
+ if (resolved_to_const)
+ {
+ relocation += rel->r_addend;
+ break;
+ }
+ else if (is_undefweak)
+ {
+ i = 0, j = 0;
+ relocation = 0;
+ if (resolved_dynly)
+ {
+ if (h && h->plt.offset != MINUS_ONE)
+ i = 1, j = 2;
+ else
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_dangerous, is_undefweak, name,
+ "Undefweak need to be resolved dynamically, "
+ "but PLT stub doesn't represent.");
+ }
+ }
+ else
+ {
+ if (!(defined_local || (h && h->plt.offset != MINUS_ONE)))
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_undefined, is_undefweak, name,
+ "PLT stub does not represent and "
+ "symbol not defined.");
+ break;
+ }
+
+ if (resolved_local)
+ i = 0, j = 2;
+ else /* if (resolved_dynly) */
+ {
+ if (!(h && h->plt.offset != MINUS_ONE))
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_dangerous, is_undefweak, name,
+ "Internal: PLT stub doesn't represent. "
+ "Resolve it with pcrel");
+ i = 1, j = 3;
+ }
+ }
+
+ for (; i < j; i++)
+ {
+ if ((i & 1) == 0 && defined_local)
+ {
+ relocation -= pc;
+ relocation += rel->r_addend;
+ break;
+ }
+
+ if ((i & 1) && h && h->plt.offset != MINUS_ONE)
+ {
+ if (rel->r_addend != 0)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "PLT shouldn't be with r_addend.");
+ break;
+ }
+ relocation = sec_addr (plt) + h->plt.offset - pc;
+ break;
+ }
+ }
+ break;
+
+ case R_LARCH_SOP_PUSH_GPREL:
+ unresolved_reloc = false;
+
+ if (rel->r_addend != 0)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Shouldn't be with r_addend.");
+ break;
+ }
+
+ if (h != NULL)
+ {
+ off = h->got.offset;
+
+ if (off == MINUS_ONE)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Internal: GOT entry doesn't represent.");
+ break;
+ }
+
+ if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (is_dyn, is_pic, h)
+ || (is_pic && SYMBOL_REFERENCES_LOCAL (info, h)))
+ {
+ /* This is actually a static link, or it is a
+ -Bsymbolic link and the symbol is defined
+ locally, or the symbol was forced to be local
+ because of a version file. We must initialize
+ this entry in the global offset table. Since the
+ offset must always be a multiple of the word size,
+ we use the least significant bit to record whether
+ we have initialized it already.
+
+ When doing a dynamic link, we create a .rela.got
+ relocation entry to initialize the value. This
+ is done in the finish_dynamic_symbol routine. */
+
+ if (resolved_dynly)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_dangerous, is_undefweak, name,
+ "Internal: here shouldn't dynamic. ");
+ }
+
+ if (!(defined_local || resolved_to_const))
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_undefined, is_undefweak, name,
+ "Internal: ");
+ break;
+ }
+
+ if ((off & 1) != 0)
+ off &= ~1;
+ else
+ {
+ bfd_put_NN (output_bfd, relocation, got->contents + off);
+ h->got.offset |= 1;
+ }
+ }
+ }
+ else
+ {
+ if (!local_got_offsets)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Internal: local got offsets not reporesent.");
+ break;
+ }
+
+ off = local_got_offsets[r_symndx];
+
+ if (off == MINUS_ONE)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Internal: GOT entry doesn't represent.");
+ break;
+ }
+
+ /* The offset must always be a multiple of the word size.
+ So, we can use the least significant bit to record
+ whether we have already processed this entry. */
+ if ((off & 1) != 0)
+ off &= ~1;
+ else
+ {
+ if (is_pic)
+ {
+ asection *s;
+ Elf_Internal_Rela outrel;
+ /* We need to generate a R_LARCH_RELATIVE reloc
+ for the dynamic linker. */
+ s = htab->elf.srelgot;
+ if (!s)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Internal: '.rel.got' not represent");
+ break;
+ }
+
+ outrel.r_offset = sec_addr (got) + off;
+ outrel.r_info = ELFNN_R_INFO (0, R_LARCH_RELATIVE);
+ outrel.r_addend = relocation; /* Link-time addr. */
+ loongarch_elf_append_rela (output_bfd, s, &outrel);
+ }
+
+ bfd_put_NN (output_bfd, relocation, got->contents + off);
+ local_got_offsets[r_symndx] |= 1;
+ }
+ }
+ relocation = off;
+ break;
+
+ case R_LARCH_SOP_PUSH_TLS_GOT:
+ case R_LARCH_SOP_PUSH_TLS_GD:
+ if (r_type == R_LARCH_SOP_PUSH_TLS_GOT)
+ is_ie = true;
+ unresolved_reloc = false;
+
+ if (rel->r_addend != 0)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Shouldn't be with r_addend.");
+ break;
+ }
+
+
+ if (resolved_to_const && is_undefweak && h->dynindx != -1)
+ {
+ /* What if undefweak? Let rtld make a decision. */
+ resolved_to_const = resolved_local = false;
+ resolved_dynly = true;
+ }
+
+ if (resolved_to_const)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Internal: Shouldn't be resolved to const.");
+ break;
+ }
+
+ if (h != NULL)
+ {
+ off = h->got.offset;
+ h->got.offset |= 1;
+ }
+ else
+ {
+ off = local_got_offsets[r_symndx];
+ local_got_offsets[r_symndx] |= 1;
+ }
+
+ if (off == MINUS_ONE)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Internal: TLS GOT entry doesn't represent.");
+ break;
+ }
+
+ tls_type = _bfd_loongarch_elf_tls_type (input_bfd, h, r_symndx);
+
+ /* If this symbol is referenced by both GD and IE TLS, the IE
+ reference's GOT slot follows the GD reference's slots. */
+ ie_off = 0;
+ if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
+ ie_off = 2 * GOT_ENTRY_SIZE;
+
+ if ((off & 1) != 0)
+ off &= ~1;
+ else
+ {
+ bfd_vma tls_block_off = 0;
+ Elf_Internal_Rela outrel;
+
+ if (resolved_local)
+ {
+ if (!elf_hash_table (info)->tls_sec)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_notsupported, is_undefweak, name,
+ "Internal: TLS sec not represent.");
+ break;
+ }
+ tls_block_off =
+ relocation - elf_hash_table (info)->tls_sec->vma;
+ }
+
+ if (tls_type & GOT_TLS_GD)
+ {
+ outrel.r_offset = sec_addr (got) + off;
+ outrel.r_addend = 0;
+ bfd_put_NN (output_bfd, 0, got->contents + off);
+ if (resolved_local && bfd_link_executable (info))
+ bfd_put_NN (output_bfd, 1, got->contents + off);
+ else if (resolved_local /* && !bfd_link_executable (info) */)
+ {
+ outrel.r_info = ELFNN_R_INFO (0, R_LARCH_TLS_DTPMODNN);
+ loongarch_elf_append_rela (output_bfd, htab->elf.srelgot,
+ &outrel);
+ }
+ else /* if (resolved_dynly) */
+ {
+ outrel.r_info =
+ ELFNN_R_INFO (h->dynindx, R_LARCH_TLS_DTPMODNN);
+ loongarch_elf_append_rela (output_bfd, htab->elf.srelgot,
+ &outrel);
+ }
+
+ outrel.r_offset += GOT_ENTRY_SIZE;
+ bfd_put_NN (output_bfd, tls_block_off,
+ got->contents + off + GOT_ENTRY_SIZE);
+ if (resolved_local)
+ /* DTPREL known. */;
+ else /* if (resolved_dynly) */
+ {
+ outrel.r_info =
+ ELFNN_R_INFO (h->dynindx, R_LARCH_TLS_DTPRELNN);
+ loongarch_elf_append_rela (output_bfd, htab->elf.srelgot,
+ &outrel);
+ }
+ }
+
+ if (tls_type & GOT_TLS_IE)
+ {
+ outrel.r_offset = sec_addr (got) + off + ie_off;
+ bfd_put_NN (output_bfd, tls_block_off,
+ got->contents + off + ie_off);
+ if (resolved_local && bfd_link_executable (info))
+ /* TPREL known. */;
+ else if (resolved_local /* && !bfd_link_executable (info) */)
+ {
+ outrel.r_info = ELFNN_R_INFO (0, R_LARCH_TLS_TPRELNN);
+ outrel.r_addend = tls_block_off;
+ loongarch_elf_append_rela (output_bfd, htab->elf.srelgot,
+ &outrel);
+ }
+ else /* if (resolved_dynly) */
+ {
+ outrel.r_info =
+ ELFNN_R_INFO (h->dynindx, R_LARCH_TLS_TPRELNN);
+ outrel.r_addend = 0;
+ loongarch_elf_append_rela (output_bfd, htab->elf.srelgot,
+ &outrel);
+ }
+ }
+ }
+
+ relocation = off + (is_ie ? ie_off : 0);
+ break;
+
+ default:
+ break;
+ }
+
+ if (fatal)
+ break;
+
+ do
+ {
+ /* 'unresolved_reloc' means we haven't done it yet.
+ We need help of dynamic linker to fix this memory location up. */
+ if (!unresolved_reloc)
+ break;
+
+ if (_bfd_elf_section_offset (output_bfd, info, input_section,
+ rel->r_offset) == MINUS_ONE)
+ /* WHY? May because it's invalid so skip checking.
+ But why dynamic reloc a invalid section? */
+ break;
+
+ if (input_section->output_section->flags & SEC_DEBUGGING)
+ {
+ fatal = loongarch_reloc_is_fatal (info, input_bfd,
+ input_section, rel, howto,
+ bfd_reloc_dangerous, is_undefweak, name,
+ "Seems dynamic linker not process "
+ "sections 'SEC_DEBUGGING'. ");
+ }
+ if (!is_dyn)
+ break;
+
+ if ((info->flags & DF_TEXTREL) == 0)
+ if (input_section->output_section->flags & SEC_READONLY)
+ info->flags |= DF_TEXTREL;
+ }
+ while (0);
+
+ if (fatal)
+ break;
+
+ loongarch_record_one_reloc (input_bfd, input_section, r_type,
+ rel->r_offset, sym, h, rel->r_addend);
+
+ if (r != bfd_reloc_continue)
+ r = perform_relocation (rel, input_section, howto, relocation,
+ input_bfd, contents);
+
+ switch (r)
+ {
+ case bfd_reloc_dangerous:
+ case bfd_reloc_continue:
+ case bfd_reloc_ok:
+ continue;
+
+ case bfd_reloc_overflow:
+ /* Overflow value can't be filled in. */
+ loongarch_dump_reloc_record (info->callbacks->info);
+ info->callbacks->reloc_overflow (
+ info, (h ? &h->root : NULL), name, howto->name, rel->r_addend,
+ input_bfd, input_section, rel->r_offset);
+ break;
+
+ case bfd_reloc_outofrange:
+ /* Stack state incorrect. */
+ loongarch_dump_reloc_record (info->callbacks->info);
+ info->callbacks->info (
+ "%X%H: Internal stack state is incorrect.\n"
+ "Want to push to full stack or pop from empty stack?\n",
+ input_bfd, input_section, rel->r_offset);
+ break;
+
+ case bfd_reloc_notsupported:
+ info->callbacks->info ("%X%H: Unknown relocation type.\n", input_bfd,
+ input_section, rel->r_offset);
+ break;
+
+ default:
+ info->callbacks->info ("%X%H: Internal: unknown error.\n", input_bfd,
+ input_section, rel->r_offset);
+ break;
+ }
+
+ fatal = true;
+ break;
+ }
+
+ return !fatal;
+}
+
+/* Finish up dynamic symbol handling. We set the contents of various
+ dynamic sections here. */
+
+static bool
+loongarch_elf_finish_dynamic_symbol (bfd *output_bfd,
+ struct bfd_link_info *info,
+ struct elf_link_hash_entry *h,
+ Elf_Internal_Sym *sym)
+{
+ struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);
+ const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ asection *plt = NULL;
+
+ if (h->plt.offset != MINUS_ONE)
+ {
+ size_t i, plt_idx;
+ asection *gotplt, *relplt;
+ bfd_vma got_address;
+ uint32_t plt_entry[PLT_ENTRY_INSNS];
+ bfd_byte *loc;
+ Elf_Internal_Rela rela;
+
+ plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
+
+ /* One of '.plt' and '.iplt' represents. */
+ BFD_ASSERT (!!htab->elf.splt ^ !!htab->elf.iplt);
+
+ if (htab->elf.splt)
+ {
+ BFD_ASSERT (
+ (h->type == STT_GNU_IFUNC && SYMBOL_REFERENCES_LOCAL (info, h))
+ || h->dynindx != -1);
+
+ plt = htab->elf.splt;
+ gotplt = htab->elf.sgotplt;
+ relplt = htab->elf.srelplt;
+ got_address =
+ sec_addr (gotplt) + GOTPLT_HEADER_SIZE + plt_idx * GOT_ENTRY_SIZE;
+ }
+ else /* if (htab->elf.iplt) */
+ {
+ BFD_ASSERT (h->type == STT_GNU_IFUNC
+ && SYMBOL_REFERENCES_LOCAL (info, h));
+
+ plt = htab->elf.iplt;
+ gotplt = htab->elf.igotplt;
+ relplt = htab->elf.irelplt;
+ got_address = sec_addr (gotplt) + plt_idx * GOT_ENTRY_SIZE;
+ }
+
+ /* Find out where the .plt entry should go. */
+ loc = plt->contents + h->plt.offset;
+
+ /* Fill in the PLT entry itself. */
+ if (!loongarch_make_plt_entry (got_address, sec_addr (plt) +
h->plt.offset,
+ plt_entry))
+ return false;
+
+ for (i = 0; i < PLT_ENTRY_INSNS; i++)
+ bfd_put_32 (output_bfd, plt_entry[i], loc + 4 * i);
+
+ /* Fill in the initial value of the .got.plt entry. */
+ loc = gotplt->contents + (got_address - sec_addr (gotplt));
+ bfd_put_NN (output_bfd, sec_addr (plt), loc);
+
+ rela.r_offset = got_address;
+ if (h->type == STT_GNU_IFUNC && SYMBOL_REFERENCES_LOCAL (info, h))
+ {
+ rela.r_info = ELFNN_R_INFO (0, R_LARCH_IRELATIVE);
+ rela.r_addend = h->root.u.def.value
+ + h->root.u.def.section->output_section->vma
+ + h->root.u.def.section->output_offset;
+ }
+ else
+ {
+ /* Fill in the entry in the .rela.plt section. */
+ rela.r_info = ELFNN_R_INFO (h->dynindx, R_LARCH_JUMP_SLOT);
+ rela.r_addend = 0;
+ }
+
+ loc = relplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
+ bed->s->swap_reloca_out (output_bfd, &rela, loc);
+
+ if (!h->def_regular)
+ {
+ /* Mark the symbol as undefined, rather than as defined in
+ the .plt section. Leave the value alone. */
+ sym->st_shndx = SHN_UNDEF;
+ /* If the symbol is weak, we do need to clear the value.
+ Otherwise, the PLT entry would provide a definition for
+ the symbol even if the symbol wasn't defined anywhere,
+ and so the symbol would never be NULL. */
+ if (!h->ref_regular_nonweak)
+ sym->st_value = 0;
+ }
+ }
+
+ if (h->got.offset != MINUS_ONE
+
+ && /* TLS got entry have been handled in elf_relocate_section. */
+ !(loongarch_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE))
+
+ && /* have allocated got entry but not allocated rela before. */
+ !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
+ {
+ asection *sgot, *srela;
+ Elf_Internal_Rela rela;
+ bfd_vma off = h->got.offset & ~(bfd_vma) 1;
+
+ /* This symbol has an entry in the GOT. Set it up. */
+
+ sgot = htab->elf.sgot;
+ srela = htab->elf.srelgot;
+ BFD_ASSERT (sgot && srela);
+
+ rela.r_offset = sec_addr (sgot) + off;
+
+ if (h->type == STT_GNU_IFUNC)
+ {
+ if (elf_hash_table (info)->dynamic_sections_created
+ && SYMBOL_REFERENCES_LOCAL (info, h))
+ {
+ asection *sec = h->root.u.def.section;
+ rela.r_info = ELFNN_R_INFO (0, R_LARCH_IRELATIVE);
+ rela.r_addend = h->root.u.def.value + sec->output_section->vma
+ + sec->output_offset;
+ bfd_put_NN (output_bfd, 0, sgot->contents + off);
+ }
+ else
+ {
+ BFD_ASSERT (plt);
+ rela.r_info = ELFNN_R_INFO (
+ 0, bfd_link_pic (info) ? R_LARCH_RELATIVE : R_LARCH_NONE);
+ rela.r_addend =
+ plt->output_section->vma + plt->output_offset + h->plt.offset;
+ bfd_put_NN (output_bfd, rela.r_addend, sgot->contents + off);
+ }
+ }
+ else if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
+ {
+ BFD_ASSERT (h->got.offset & 1 /* Has been filled in addr. */);
+ asection *sec = h->root.u.def.section;
+ rela.r_info = ELFNN_R_INFO (0, R_LARCH_RELATIVE);
+ rela.r_addend = h->root.u.def.value + sec->output_section->vma
+ + sec->output_offset;
+ }
+ else
+ {
+ BFD_ASSERT ((h->got.offset & 1) == 0);
+ BFD_ASSERT (h->dynindx != -1);
+ rela.r_info = ELFNN_R_INFO (h->dynindx, R_LARCH_NN);
+ rela.r_addend = 0;
+ }
+
+ loongarch_elf_append_rela (output_bfd, srela, &rela);
+ }
+
+ if (h->needs_copy)
+ {
+ Elf_Internal_Rela rela;
+ asection *s;
+
+ /* This symbols needs a copy reloc. Set it up. */
+ BFD_ASSERT (h->dynindx != -1);
+
+ rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
+ rela.r_info = ELFNN_R_INFO (h->dynindx, R_LARCH_COPY);
+ rela.r_addend = 0;
+ if (h->root.u.def.section == htab->elf.sdynrelro)
+ s = htab->elf.sreldynrelro;
+ else
+ s = htab->elf.srelbss;
+ loongarch_elf_append_rela (output_bfd, s, &rela);
+ }
+
+ /* Mark some specially defined symbols as absolute. */
+ if (h == htab->elf.hdynamic || h == htab->elf.hgot || h == htab->elf.hplt)
+ sym->st_shndx = SHN_ABS;
+
+ return true;
+}
+
+/* Finish up the dynamic sections. */
+
+static bool
+loongarch_finish_dyn (bfd *output_bfd, struct bfd_link_info *info, bfd *dynobj,
+ asection *sdyn)
+{
+ struct loongarch_elf_link_hash_table *htab = loongarch_elf_hash_table (info);
+ const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
+ size_t dynsize = bed->s->sizeof_dyn, skipped_size = 0;
+ bfd_byte *dyncon, *dynconend;
+
+ dynconend = sdyn->contents + sdyn->size;
+ for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
+ {
+ Elf_Internal_Dyn dyn;
+ asection *s;
+ int skipped = 0;
+
+ bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
+
+ switch (dyn.d_tag)
+ {
+ case DT_PLTGOT:
+ s = htab->elf.sgotplt;
+ dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
+ break;
+ case DT_JMPREL:
+ s = htab->elf.srelplt;
+ dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
+ break;
+ case DT_PLTRELSZ:
+ s = htab->elf.srelplt;
+ dyn.d_un.d_val = s->size;
+ break;
+ case DT_TEXTREL:
+ if ((info->flags & DF_TEXTREL) == 0)
+ skipped = 1;
+ break;
+ case DT_FLAGS:
+ if ((info->flags & DF_TEXTREL) == 0)
+ dyn.d_un.d_val &= ~DF_TEXTREL;
+ break;
+ }
+ if (skipped)
+ skipped_size += dynsize;
+ else
+ bed->s->swap_dyn_out (output_bfd, &dyn, dyncon - skipped_size);
+ }
+ /* Wipe out any trailing entries if we shifted down a dynamic tag. */
+ memset (dyncon - skipped_size, 0, skipped_size);
+ return true;
+}
+
+/* Finish up local dynamic symbol handling. We set the contents of
+ various dynamic sections here. */
+
+static bool
+elfNN_loongarch_finish_local_dynamic_symbol (void **slot, void *inf)
+{
+ struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) *slot;
+ struct bfd_link_info *info = (struct bfd_link_info *) inf;
+
+ return loongarch_elf_finish_dynamic_symbol (info->output_bfd, info, h, NULL);
+}
+
+static bool
+loongarch_elf_finish_dynamic_sections (bfd *output_bfd,
+ struct bfd_link_info *info)
+{
+ bfd *dynobj;
+ asection *sdyn, *plt, *gotplt = NULL;
+ struct loongarch_elf_link_hash_table *htab;
+
+ htab = loongarch_elf_hash_table (info);
+ BFD_ASSERT (htab);
+ dynobj = htab->elf.dynobj;
+ sdyn = bfd_get_linker_section (dynobj, ".dynamic");
+
+ if (elf_hash_table (info)->dynamic_sections_created)
+ {
+ BFD_ASSERT (htab->elf.splt && sdyn);
+
+ if (!loongarch_finish_dyn (output_bfd, info, dynobj, sdyn))
+ return false;
+ }
+
+ if ((plt = htab->elf.splt))
+ gotplt = htab->elf.sgotplt;
+ else if ((plt = htab->elf.iplt))
+ gotplt = htab->elf.igotplt;
+
+ if (plt && 0 < plt->size)
+ {
+ size_t i;
+ uint32_t plt_header[PLT_HEADER_INSNS];
+ if (!loongarch_make_plt_header (sec_addr (gotplt), sec_addr (plt),
+ plt_header))
+ return false;
+
+ for (i = 0; i < PLT_HEADER_INSNS; i++)
+ bfd_put_32 (output_bfd, plt_header[i], plt->contents + 4 * i);
+
+ elf_section_data (plt->output_section)->this_hdr.sh_entsize =
+ PLT_ENTRY_SIZE;
+ }
+
+ if (htab->elf.sgotplt)
+ {
+ asection *output_section = htab->elf.sgotplt->output_section;
+
+ if (bfd_is_abs_section (output_section))
+ {
+ _bfd_error_handler (_ ("discarded output section: `%pA'"),
+ htab->elf.sgotplt);
+ return false;
+ }
+
+ if (0 < htab->elf.sgotplt->size)
+ {
+ /* Write the first two entries in .got.plt, needed for the dynamic
+ linker. */
+ bfd_put_NN (output_bfd, MINUS_ONE, htab->elf.sgotplt->contents);
+
+ bfd_put_NN (output_bfd, (bfd_vma) 0,
+ htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
+ }
+
+ elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
+ }
+
+ if (htab->elf.sgot)
+ {
+ asection *output_section = htab->elf.sgot->output_section;
+
+ if (0 < htab->elf.sgot->size)
+ {
+ /* Set the first entry in the global offset table to the address of
+ the dynamic section. */
+ bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
+ bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
+ }
+
+ elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
+ }
+
+ /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
+ htab_traverse (htab->loc_hash_table,
+ (void *) elfNN_loongarch_finish_local_dynamic_symbol, info);
+
+ return true;
+}
+
+/* Return address for Ith PLT stub in section PLT, for relocation REL
+ or (bfd_vma) -1 if it should not be included. */
+
+static bfd_vma
+loongarch_elf_plt_sym_val (bfd_vma i, const asection *plt,
+ const arelent *rel ATTRIBUTE_UNUSED)
+{
+ return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
+}
+
+static enum elf_reloc_type_class
+loongarch_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ const asection *rel_sec ATTRIBUTE_UNUSED,
+ const Elf_Internal_Rela *rela)
+{
+ struct loongarch_elf_link_hash_table *htab;
+ htab = loongarch_elf_hash_table (info);
+
+ if (htab->elf.dynsym != NULL && htab->elf.dynsym->contents != NULL)
+ {
+ /* Check relocation against STT_GNU_IFUNC symbol if there are
+ dynamic symbols. */
+ bfd *abfd = info->output_bfd;
+ const struct elf_backend_data *bed = get_elf_backend_data (abfd);
+ unsigned long r_symndx = ELFNN_R_SYM (rela->r_info);
+ if (r_symndx != STN_UNDEF)
+ {
+ Elf_Internal_Sym sym;
+ if (!bed->s->swap_symbol_in (abfd,
+ htab->elf.dynsym->contents
+ + r_symndx * bed->s->sizeof_sym,
+ 0, &sym))
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler (_ ("%pB symbol number %lu references"
+ " nonexistent SHT_SYMTAB_SHNDX section"),
+ abfd, r_symndx);
+ /* Ideally an error class should be returned here. */
+ }
+ else if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
+ return reloc_class_ifunc;
+ }
+ }
+
+ switch (ELFNN_R_TYPE (rela->r_info))
+ {
+ case R_LARCH_IRELATIVE:
+ return reloc_class_ifunc;
+ case R_LARCH_RELATIVE:
+ return reloc_class_relative;
+ case R_LARCH_JUMP_SLOT:
+ return reloc_class_plt;
+ case R_LARCH_COPY:
+ return reloc_class_copy;
+ default:
+ return reloc_class_normal;
+ }
+}
+
+/* Copy the extra info we tack onto an elf_link_hash_entry. */
+
+static void
+loongarch_elf_copy_indirect_symbol (struct bfd_link_info *info,
+ struct elf_link_hash_entry *dir,
+ struct elf_link_hash_entry *ind)
+{
+ struct loongarch_elf_link_hash_entry *edir, *eind;
+
+ edir = (struct loongarch_elf_link_hash_entry *) dir;
+ eind = (struct loongarch_elf_link_hash_entry *) ind;
+
+ if (eind->dyn_relocs != NULL)
+ {
+ if (edir->dyn_relocs != NULL)
+ {
+ struct elf_dyn_relocs **pp;
+ struct elf_dyn_relocs *p;
+
+ /* Add reloc counts against the indirect sym to the direct sym
+ list. Merge any entries against the same section. */
+ for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
+ {
+ struct elf_dyn_relocs *q;
+
+ for (q = edir->dyn_relocs; q != NULL; q = q->next)
+ if (q->sec == p->sec)
+ {
+ q->pc_count += p->pc_count;
+ q->count += p->count;
+ *pp = p->next;
+ break;
+ }
+ if (q == NULL)
+ pp = &p->next;
+ }
+ *pp = edir->dyn_relocs;
+ }
+
+ edir->dyn_relocs = eind->dyn_relocs;
+ eind->dyn_relocs = NULL;
+ }
+
+ if (ind->root.type == bfd_link_hash_indirect && dir->got.refcount < 0)
+ {
+ edir->tls_type = eind->tls_type;
+ eind->tls_type = GOT_UNKNOWN;
+ }
+ _bfd_elf_link_hash_copy_indirect (info, dir, ind);
+}
+
+#define PRSTATUS_SIZE 0x1d8
+#define PRSTATUS_OFFSET_PR_CURSIG 0xc
+#define PRSTATUS_OFFSET_PR_PID 0x20
+#define ELF_GREGSET_T_SIZE 0x168
+#define PRSTATUS_OFFSET_PR_REG 0x70
+
+/* Support for core dump NOTE sections. */
+
+static bool
+loongarch_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
+{
+ switch (note->descsz)
+ {
+ default:
+ return false;
+
+ /* The sizeof (struct elf_prstatus) on Linux/LoongArch. */
+ case PRSTATUS_SIZE:
+ /* pr_cursig */
+ elf_tdata (abfd)->core->signal =
+ bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
+
+ /* pr_pid */
+ elf_tdata (abfd)->core->lwpid =
+ bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
+ break;
+ }
+
+ /* Make a ".reg/999" section. */
+ return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
+ note->descpos
+ + PRSTATUS_OFFSET_PR_REG);
+}
+
+#define PRPSINFO_SIZE 0x88
+#define PRPSINFO_OFFSET_PR_PID 0x18
+#define PRPSINFO_OFFSET_PR_FNAME 0x28
+#define PRPSINFO_SIZEOF_PR_FNAME 0x10
+#define PRPSINFO_OFFSET_PR_PS_ARGS 0x38
+#define PRPSINFO_SIZEOF_PR_PS_ARGS 0x50
+
+
+static bool
+loongarch_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
+{
+ switch (note->descsz)
+ {
+ default:
+ return false;
+
+ /* The sizeof (prpsinfo_t) on Linux/LoongArch. */
+ case PRPSINFO_SIZE:
+ /* pr_pid */
+ elf_tdata (abfd)->core->pid =
+ bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
+
+ /* pr_fname */
+ elf_tdata (abfd)->core->program = _bfd_elfcore_strndup (
+ abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME,
+ PRPSINFO_SIZEOF_PR_FNAME);
+
+ /* pr_psargs */
+ elf_tdata (abfd)->core->command = _bfd_elfcore_strndup (
+ abfd, note->descdata + PRPSINFO_OFFSET_PR_PS_ARGS,
+ PRPSINFO_SIZEOF_PR_PS_ARGS);
+ break;
+ }
+
+ /* Note that for some reason, a spurious space is tacked
+ onto the end of the args in some (at least one anyway)
+ implementations, so strip it off if it exists. */
+
+ {
+ char *command = elf_tdata (abfd)->core->command;
+ int n = strlen (command);
+
+ if (0 < n && command[n - 1] == ' ')
+ command[n - 1] = '\0';
+ }
+
+ return true;
+}
+
+/* Set the right mach type. */
+static bool
+loongarch_elf_object_p (bfd *abfd)
+{
+ /* There are only two mach types in LoongArch currently. */
+ if (strcmp (abfd->xvec->name, "elf64-loongarch") == 0)
+ bfd_default_set_arch_mach (abfd, bfd_arch_loongarch, bfd_mach_loongarch64);
+ else
+ bfd_default_set_arch_mach (abfd, bfd_arch_loongarch, bfd_mach_loongarch32);
+ return true;
+}
+
+static asection *
+loongarch_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
+ Elf_Internal_Rela *rel,
+ struct elf_link_hash_entry *h,
+ Elf_Internal_Sym *sym)
+{
+ if (h != NULL)
+ switch (ELFNN_R_TYPE (rel->r_info))
+ {
+ case R_LARCH_GNU_VTINHERIT:
+ case R_LARCH_GNU_VTENTRY:
+ return NULL;
+ }
+
+ return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
+}
+
+static bool
+_loongarch_bfd_set_section_contents (bfd *abfd, sec_ptr section,
+ const void *location, file_ptr offset,
+ bfd_size_type conut)
+
+{
+ if (elf_elfheader (abfd)->e_flags == 0)
+ {
+ if (abfd->arch_info->arch == bfd_arch_loongarch)
+ {
+ if (abfd->arch_info->mach == bfd_mach_loongarch32)
+ elf_elfheader (abfd)->e_flags = EF_LARCH_ABI_LP32;
+ else if (abfd->arch_info->mach == bfd_mach_loongarch64)
+ elf_elfheader (abfd)->e_flags = EF_LARCH_ABI_LP64;
+ else
+ return false;
+ }
+ }
+ return _bfd_elf_set_section_contents (abfd, section, location, offset,
+ conut);
+}
+
+#define TARGET_LITTLE_SYM loongarch_elfNN_vec
+#define TARGET_LITTLE_NAME "elfNN-loongarch"
+#define ELF_ARCH bfd_arch_loongarch
+#define ELF_TARGET_ID LARCH_ELF_DATA
+#define ELF_MACHINE_CODE EM_LOONGARCH
+#define ELF_MAXPAGESIZE 0x4000
+#define bfd_elfNN_bfd_reloc_type_lookup loongarch_reloc_type_lookup
+#define bfd_elfNN_bfd_link_hash_table_create \
+ loongarch_elf_link_hash_table_create
+#define bfd_elfNN_bfd_reloc_name_lookup loongarch_reloc_name_lookup
+#define elf_info_to_howto_rel NULL /* Fall through to elf_info_to_howto. */
+#define elf_info_to_howto loongarch_info_to_howto_rela
+#define bfd_elfNN_bfd_merge_private_bfd_data \
+ elfNN_loongarch_merge_private_bfd_data
+
+#define bfd_elfNN_set_section_contents _loongarch_bfd_set_section_contents
+
+#define elf_backend_reloc_type_class loongarch_reloc_type_class
+#define elf_backend_copy_indirect_symbol loongarch_elf_copy_indirect_symbol
+#define elf_backend_create_dynamic_sections \
+ loongarch_elf_create_dynamic_sections
+#define elf_backend_check_relocs loongarch_elf_check_relocs
+#define elf_backend_adjust_dynamic_symbol loongarch_elf_adjust_dynamic_symbol
+#define elf_backend_size_dynamic_sections loongarch_elf_size_dynamic_sections
+#define elf_backend_relocate_section loongarch_elf_relocate_section
+#define elf_backend_finish_dynamic_symbol loongarch_elf_finish_dynamic_symbol
+#define elf_backend_finish_dynamic_sections \
+ loongarch_elf_finish_dynamic_sections
+#define elf_backend_object_p loongarch_elf_object_p
+#define elf_backend_gc_mark_hook loongarch_elf_gc_mark_hook
+#define elf_backend_plt_sym_val loongarch_elf_plt_sym_val
+#define elf_backend_grok_prstatus loongarch_elf_grok_prstatus
+#define elf_backend_grok_psinfo loongarch_elf_grok_psinfo
+
+#include "elfNN-target.h"
diff --git a/bfd/elfxx-loongarch.c b/bfd/elfxx-loongarch.c
new file mode 100644
index 00000000000..5ecfc1160ee
--- /dev/null
+++ b/bfd/elfxx-loongarch.c
@@ -0,0 +1,655 @@
+/* LoongArch-specific support for ELF.
+ Copyright (C) 2021 Free Software Foundation, Inc.
+ Contributed by Loongson Ltd.
+
+ Based on RISC-V target.
+
+ 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 "sysdep.h"
+#include "bfd.h"
+#include "libbfd.h"
+#include "elf-bfd.h"
+#include "elf/loongarch.h"
+#include "elfxx-loongarch.h"
+
+#define ALL_ONES (~ (bfd_vma) 0)
+
+/* This does not include any relocation information, but should be
+ good enough for GDB or objdump to read the file. */
+
+static reloc_howto_type howto_table[] =
+{
+#define LOONGARCH_HOWTO(r_name) \
+ HOWTO (R_LARCH_##r_name, 0, 2, 32, false, 0, complain_overflow_signed, \
+ bfd_elf_generic_reloc, "R_LARCH_" #r_name, false, 0, 0xffffffff, false)
+
+ /* No relocation. */
+ HOWTO (R_LARCH_NONE, /* type */
+ 0, /* rightshift */
+ 3, /* size */
+ 0, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_NONE", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ false), /* pcrel_offset */
+
+ /* 32 bit relocation. */
+ HOWTO (R_LARCH_32, /* type */
+ 0, /* rightshift */
+ 2, /* size */
+ 32, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_32", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset */
+
+ /* 64 bit relocation. */
+ HOWTO (R_LARCH_64, /* type */
+ 0, /* rightshift */
+ 4, /* size */
+ 64, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_64", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ ALL_ONES, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_RELATIVE, /* type */
+ 0, /* rightshift */
+ 2, /* size */
+ 32, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_RELATIVE", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_COPY, /* type */
+ 0, /* rightshift */
+ 0, /* this one is variable size */
+ 0, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_bitfield, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_COPY", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_JUMP_SLOT, /* type */
+ 0, /* rightshift */
+ 4, /* size */
+ 64, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_bitfield, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_JUMP_SLOT", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ false), /* pcrel_offset */
+
+ /* Dynamic TLS relocations. */
+ HOWTO (R_LARCH_TLS_DTPMOD32, /* type */
+ 0, /* rightshift */
+ 2, /* size */
+ 32, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_TLS_DTPMOD32", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_TLS_DTPMOD64, /* type */
+ 0, /* rightshift */
+ 4, /* size */
+ 64, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_TLS_DTPMOD64", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ ALL_ONES, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_TLS_DTPREL32, /* type */
+ 0, /* rightshift */
+ 2, /* size */
+ 32, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_TLS_DTPREL32", /* name */
+ true, /* partial_inplace */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_TLS_DTPREL64, /* type */
+ 0, /* rightshift */
+ 4, /* size */
+ 64, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_TLS_DTPREL64", /* name */
+ true, /* partial_inplace */
+ 0, /* src_mask */
+ ALL_ONES, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_TLS_TPREL32, /* type */
+ 0, /* rightshift */
+ 2, /* size */
+ 32, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_TLS_TPREL32", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_TLS_TPREL64, /* type */
+ 0, /* rightshift */
+ 4, /* size */
+ 64, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_TLS_TPREL64", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ ALL_ONES, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_IRELATIVE, /* type */
+ 0, /* rightshift */
+ 2, /* size */
+ 32, /* bitsize */
+ false, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_LARCH_IRELATIVE", /* name */
+ false, /* partial_inplace */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset */
+
+ HOWTO (R_LARCH_MARK_LA, /* type. */
+ 0, /* rightshift. */
+ 3, /* size. */
+ 0, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_MARK_LA", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask. */
+ 0, /* dst_mask. */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_MARK_PCREL, /* type. */
+ 0, /* rightshift. */
+ 3, /* size. */
+ 0, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_MARK_PCREL", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask. */
+ 0, /* dst_mask. */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_PUSH_PCREL, /* type. */
+ 2, /* rightshift. */
+ 2, /* size. */
+ 32, /* bitsize. */
+ true /* FIXME: somewhat use this. */, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_PUSH_PCREL", /* name. */
+ false, /* partial_inplace. */
+ 0x03ffffff, /* src_mask. */
+ 0x03ffffff, /* dst_mask. */
+ false), /* pcrel_offset. */
+
+ LOONGARCH_HOWTO (SOP_PUSH_ABSOLUTE),
+ LOONGARCH_HOWTO (SOP_PUSH_DUP),
+ LOONGARCH_HOWTO (SOP_PUSH_GPREL),
+ LOONGARCH_HOWTO (SOP_PUSH_TLS_TPREL),
+ LOONGARCH_HOWTO (SOP_PUSH_TLS_GOT),
+ LOONGARCH_HOWTO (SOP_PUSH_TLS_GD),
+ LOONGARCH_HOWTO (SOP_PUSH_PLT_PCREL),
+ LOONGARCH_HOWTO (SOP_ASSERT),
+ LOONGARCH_HOWTO (SOP_NOT),
+ LOONGARCH_HOWTO (SOP_SUB),
+ LOONGARCH_HOWTO (SOP_SL),
+ LOONGARCH_HOWTO (SOP_SR),
+ LOONGARCH_HOWTO (SOP_ADD),
+ LOONGARCH_HOWTO (SOP_AND),
+ LOONGARCH_HOWTO (SOP_IF_ELSE),
+
+ HOWTO (R_LARCH_SOP_POP_32_S_10_5, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 5, /* bitsize. */
+ false, /* pc_relative. */
+ 10, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_S_10_5", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0x7c00, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_POP_32_U_10_12, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 12, /* bitsize. */
+ false, /* pc_relative. */
+ 10, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_U_10_12", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0x3ffc00, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_POP_32_S_10_12, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 12, /* bitsize. */
+ false, /* pc_relative. */
+ 10, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_S_10_12", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0x3ffc00, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_POP_32_S_10_16, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 16, /* bitsize. */
+ false, /* pc_relative. */
+ 10, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_S_10_16", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0x3fffc00, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_POP_32_S_10_16_S2, /* type. */
+ 2, /* rightshift. */
+ 2, /* size. */
+ 16, /* bitsize. */
+ false, /* pc_relative. */
+ 10, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_S_10_16_S2", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0x3fffc00, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_POP_32_S_5_20, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 20, /* bitsize. */
+ false, /* pc_relative. */
+ 5, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_S_5_20", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0x1fffe0, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_POP_32_S_0_5_10_16_S2, /* type. */
+ 2, /* rightshift. */
+ 2, /* size. */
+ 21, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_S_0_5_10_16_S2", /* name. */
+ false, /* partial_inplace. */
+ 0xfc0003e0, /* src_mask */
+ 0xfc0003e0, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_POP_32_S_0_10_10_16_S2, /* type. */
+ 2, /* rightshift. */
+ 2, /* size. */
+ 26, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_S_0_10_10_16_S2", /* name. */
+ false, /* partial_inplace. */
+ 0xfc000000, /* src_mask */
+ 0xfc000000, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SOP_POP_32_U, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 32, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SOP_POP_32_S_U", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_ADD8, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 8, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_ADD8", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_ADD16, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 16, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_ADD16", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_ADD24, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 24, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_ADD24", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_ADD32, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 32, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_ADD32", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_ADD64, /* type. */
+ 0, /* rightshift. */
+ 4, /* size. */
+ 64, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_ADD64", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ ALL_ONES, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SUB8, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 8, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SUB8", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SUB16, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 16, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SUB16", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SUB24, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 24, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SUB24", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SUB32, /* type. */
+ 0, /* rightshift. */
+ 2, /* size. */
+ 32, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SUB32", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ false), /* pcrel_offset. */
+
+ HOWTO (R_LARCH_SUB64, /* type. */
+ 0, /* rightshift. */
+ 4, /* size. */
+ 64, /* bitsize. */
+ false, /* pc_relative. */
+ 0, /* bitpos. */
+ complain_overflow_signed, /* complain_on_overflow. */
+ bfd_elf_generic_reloc, /* special_function. */
+ "R_LARCH_SUB64", /* name. */
+ false, /* partial_inplace. */
+ 0, /* src_mask */
+ ALL_ONES, /* dst_mask */
+ false), /* pcrel_offset. */
+
+};
+
+struct elf_reloc_map
+{
+ bfd_reloc_code_real_type bfd_val;
+ enum elf_loongarch_reloc_type elf_val;
+};
+
+static const struct elf_reloc_map larch_reloc_map[] =
+{
+ { BFD_RELOC_NONE, R_LARCH_NONE },
+ { BFD_RELOC_32, R_LARCH_32 },
+ { BFD_RELOC_64, R_LARCH_64 },
+
+#define LOONGARCH_reloc_map(r_name) \
+ { \
+ BFD_RELOC_LARCH_##r_name, R_LARCH_##r_name \
+ }
+ LOONGARCH_reloc_map (TLS_DTPMOD32),
+ LOONGARCH_reloc_map (TLS_DTPMOD64),
+ LOONGARCH_reloc_map (TLS_DTPREL32),
+ LOONGARCH_reloc_map (TLS_DTPREL64),
+ LOONGARCH_reloc_map (TLS_TPREL32),
+ LOONGARCH_reloc_map (TLS_TPREL64),
+
+ LOONGARCH_reloc_map (MARK_LA),
+ LOONGARCH_reloc_map (MARK_PCREL),
+ LOONGARCH_reloc_map (SOP_PUSH_PCREL),
+ LOONGARCH_reloc_map (SOP_PUSH_ABSOLUTE),
+ LOONGARCH_reloc_map (SOP_PUSH_DUP),
+ LOONGARCH_reloc_map (SOP_PUSH_GPREL),
+ LOONGARCH_reloc_map (SOP_PUSH_TLS_TPREL),
+ LOONGARCH_reloc_map (SOP_PUSH_TLS_GOT),
+ LOONGARCH_reloc_map (SOP_PUSH_TLS_GD),
+ LOONGARCH_reloc_map (SOP_PUSH_PLT_PCREL),
+ LOONGARCH_reloc_map (SOP_ASSERT),
+ LOONGARCH_reloc_map (SOP_NOT),
+ LOONGARCH_reloc_map (SOP_SUB),
+ LOONGARCH_reloc_map (SOP_SL),
+ LOONGARCH_reloc_map (SOP_SR),
+ LOONGARCH_reloc_map (SOP_ADD),
+ LOONGARCH_reloc_map (SOP_AND),
+ LOONGARCH_reloc_map (SOP_IF_ELSE),
+ LOONGARCH_reloc_map (SOP_POP_32_S_10_5),
+ LOONGARCH_reloc_map (SOP_POP_32_U_10_12),
+ LOONGARCH_reloc_map (SOP_POP_32_S_10_12),
+ LOONGARCH_reloc_map (SOP_POP_32_S_10_16),
+ LOONGARCH_reloc_map (SOP_POP_32_S_10_16_S2),
+ LOONGARCH_reloc_map (SOP_POP_32_S_5_20),
+ LOONGARCH_reloc_map (SOP_POP_32_S_0_5_10_16_S2),
+ LOONGARCH_reloc_map (SOP_POP_32_S_0_10_10_16_S2),
+ LOONGARCH_reloc_map (SOP_POP_32_U),
+ LOONGARCH_reloc_map (ADD8),
+ LOONGARCH_reloc_map (ADD16),
+ LOONGARCH_reloc_map (ADD24),
+ LOONGARCH_reloc_map (ADD32),
+ LOONGARCH_reloc_map (ADD64),
+ LOONGARCH_reloc_map (SUB8),
+ LOONGARCH_reloc_map (SUB16),
+ LOONGARCH_reloc_map (SUB24),
+ LOONGARCH_reloc_map (SUB32),
+ LOONGARCH_reloc_map (SUB64),
+};
+
+reloc_howto_type *
+loongarch_elf_rtype_to_howto (bfd *abfd, unsigned int r_type)
+{
+ size_t i;
+ if (r_type >= ARRAY_SIZE (howto_table))
+ {
+ (*_bfd_error_handler) (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return NULL;
+ }
+ for (i = 0; i < ARRAY_SIZE (howto_table); i++)
+ if (howto_table[i].type == r_type)
+ return &howto_table[i];
+ return NULL;
+}
+
+reloc_howto_type *
+loongarch_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+ bfd_reloc_code_real_type code)
+{
+ unsigned int i;
+ for (i = 0; i < ARRAY_SIZE (larch_reloc_map); i++)
+ if (larch_reloc_map[i].bfd_val == code)
+ return loongarch_elf_rtype_to_howto (abfd,
+ (int) larch_reloc_map[i].elf_val);
+
+ return NULL;
+}
+
+reloc_howto_type *
+loongarch_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
+{
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE (howto_table); i++)
+ if (howto_table[i].name && strcasecmp (howto_table[i].name, r_name) == 0)
+ return &howto_table[i];
+
+ return NULL;
+}
diff --git a/bfd/elfxx-loongarch.h b/bfd/elfxx-loongarch.h
new file mode 100644
index 00000000000..7c3984ebab6
--- /dev/null
+++ b/bfd/elfxx-loongarch.h
@@ -0,0 +1,31 @@
+/* LoongArch-specific backend routines.
+ Copyright (C) 2021 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 "elf/common.h"
+#include "elf/internal.h"
+
+extern reloc_howto_type *
+loongarch_elf_rtype_to_howto (bfd *abfd, unsigned int r_type);
+
+extern reloc_howto_type *
+loongarch_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
+
+extern reloc_howto_type *
+loongarch_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name);
diff --git a/bfd/libbfd.h b/bfd/libbfd.h
index 69496411622..41ecd3bc644 100644
--- a/bfd/libbfd.h
+++ b/bfd/libbfd.h
@@ -3416,6 +3416,49 @@ static const char *const
bfd_reloc_code_real_names[] = { "@@uninitialized@@",
"BFD_RELOC_CKCORE_PCREL_BLOOP_IMM4BY4",
"BFD_RELOC_CKCORE_PCREL_BLOOP_IMM12BY4",
"BFD_RELOC_S12Z_OPR",
+ "BFD_RELOC_LARCH_TLS_DTPMOD32",
+ "BFD_RELOC_LARCH_TLS_DTPREL32",
+ "BFD_RELOC_LARCH_TLS_DTPMOD64",
+ "BFD_RELOC_LARCH_TLS_DTPREL64",
+ "BFD_RELOC_LARCH_TLS_TPREL32",
+ "BFD_RELOC_LARCH_TLS_TPREL64",
+ "BFD_RELOC_LARCH_MARK_LA",
+ "BFD_RELOC_LARCH_MARK_PCREL",
+ "BFD_RELOC_LARCH_SOP_PUSH_PCREL",
+ "BFD_RELOC_LARCH_SOP_PUSH_ABSOLUTE",
+ "BFD_RELOC_LARCH_SOP_PUSH_DUP",
+ "BFD_RELOC_LARCH_SOP_PUSH_GPREL",
+ "BFD_RELOC_LARCH_SOP_PUSH_TLS_TPREL",
+ "BFD_RELOC_LARCH_SOP_PUSH_TLS_GOT",
+ "BFD_RELOC_LARCH_SOP_PUSH_TLS_GD",
+ "BFD_RELOC_LARCH_SOP_PUSH_PLT_PCREL",
+ "BFD_RELOC_LARCH_SOP_ASSERT",
+ "BFD_RELOC_LARCH_SOP_NOT",
+ "BFD_RELOC_LARCH_SOP_SUB",
+ "BFD_RELOC_LARCH_SOP_SL",
+ "BFD_RELOC_LARCH_SOP_SR",
+ "BFD_RELOC_LARCH_SOP_ADD",
+ "BFD_RELOC_LARCH_SOP_AND",
+ "BFD_RELOC_LARCH_SOP_IF_ELSE",
+ "BFD_RELOC_LARCH_SOP_POP_32_S_10_5",
+ "BFD_RELOC_LARCH_SOP_POP_32_U_10_12",
+ "BFD_RELOC_LARCH_SOP_POP_32_S_10_12",
+ "BFD_RELOC_LARCH_SOP_POP_32_S_10_16",
+ "BFD_RELOC_LARCH_SOP_POP_32_S_10_16_S2",
+ "BFD_RELOC_LARCH_SOP_POP_32_S_5_20",
+ "BFD_RELOC_LARCH_SOP_POP_32_S_0_5_10_16_S2",
+ "BFD_RELOC_LARCH_SOP_POP_32_S_0_10_10_16_S2",
+ "BFD_RELOC_LARCH_SOP_POP_32_U",
+ "BFD_RELOC_LARCH_ADD8",
+ "BFD_RELOC_LARCH_ADD16",
+ "BFD_RELOC_LARCH_ADD24",
+ "BFD_RELOC_LARCH_ADD32",
+ "BFD_RELOC_LARCH_ADD64",
+ "BFD_RELOC_LARCH_SUB8",
+ "BFD_RELOC_LARCH_SUB16",
+ "BFD_RELOC_LARCH_SUB24",
+ "BFD_RELOC_LARCH_SUB32",
+ "BFD_RELOC_LARCH_SUB64",
"@@overflow: BFD_RELOC_UNUSED@@",
};
#endif
diff --git a/bfd/po/BLD-POTFILES.in b/bfd/po/BLD-POTFILES.in
index f81e2b4037b..0ecbbcff584 100644
--- a/bfd/po/BLD-POTFILES.in
+++ b/bfd/po/BLD-POTFILES.in
@@ -1,10 +1,12 @@
bfdver.h
elf32-aarch64.c
elf32-ia64.c
+elf32-loongarch.c
elf32-riscv.c
elf32-target.h
elf64-aarch64.c
elf64-ia64.c
+elf64-loongarch.c
elf64-riscv.c
elf64-target.h
peigen.c
diff --git a/bfd/po/SRC-POTFILES.in b/bfd/po/SRC-POTFILES.in
index c83b86cd663..d509335b801 100644
--- a/bfd/po/SRC-POTFILES.in
+++ b/bfd/po/SRC-POTFILES.in
@@ -72,6 +72,7 @@ cpu-iq2000.c
cpu-k1om.c
cpu-l1om.c
cpu-lm32.c
+cpu-loongarch.c
cpu-m10200.c
cpu-m10300.c
cpu-m32c.c
diff --git a/bfd/reloc.c b/bfd/reloc.c
index 441ddd8fa2e..5498f43b178 100644
--- a/bfd/reloc.c
+++ b/bfd/reloc.c
@@ -8171,6 +8171,95 @@ ENUM
ENUMDOC
S12Z relocations.
+ENUM
+ BFD_RELOC_LARCH_TLS_DTPMOD32
+ENUMX
+ BFD_RELOC_LARCH_TLS_DTPREL32
+ENUMX
+ BFD_RELOC_LARCH_TLS_DTPMOD64
+ENUMX
+ BFD_RELOC_LARCH_TLS_DTPREL64
+ENUMX
+ BFD_RELOC_LARCH_TLS_TPREL32
+ENUMX
+ BFD_RELOC_LARCH_TLS_TPREL64
+ENUMX
+ BFD_RELOC_LARCH_MARK_LA
+ENUMX
+ BFD_RELOC_LARCH_MARK_PCREL
+ENUMX
+ BFD_RELOC_LARCH_SOP_PUSH_PCREL
+ENUMX
+ BFD_RELOC_LARCH_SOP_PUSH_ABSOLUTE
+ENUMX
+ BFD_RELOC_LARCH_SOP_PUSH_DUP
+ENUMX
+ BFD_RELOC_LARCH_SOP_PUSH_GPREL
+ENUMX
+ BFD_RELOC_LARCH_SOP_PUSH_TLS_TPREL
+ENUMX
+ BFD_RELOC_LARCH_SOP_PUSH_TLS_GOT
+ENUMX
+ BFD_RELOC_LARCH_SOP_PUSH_TLS_GD
+ENUMX
+ BFD_RELOC_LARCH_SOP_PUSH_PLT_PCREL
+ENUMX
+ BFD_RELOC_LARCH_SOP_ASSERT
+ENUMX
+ BFD_RELOC_LARCH_SOP_NOT
+ENUMX
+ BFD_RELOC_LARCH_SOP_SUB
+ENUMX
+ BFD_RELOC_LARCH_SOP_SL
+ENUMX
+ BFD_RELOC_LARCH_SOP_SR
+ENUMX
+ BFD_RELOC_LARCH_SOP_ADD
+ENUMX
+ BFD_RELOC_LARCH_SOP_AND
+ENUMX
+ BFD_RELOC_LARCH_SOP_IF_ELSE
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_S_10_5
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_U_10_12
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_S_10_12
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_S_10_16
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_S_10_16_S2
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_S_5_20
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_S_0_5_10_16_S2
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_S_0_10_10_16_S2
+ENUMX
+ BFD_RELOC_LARCH_SOP_POP_32_U
+ENUMX
+ BFD_RELOC_LARCH_ADD8
+ENUMX
+ BFD_RELOC_LARCH_ADD16
+ENUMX
+ BFD_RELOC_LARCH_ADD24
+ENUMX
+ BFD_RELOC_LARCH_ADD32
+ENUMX
+ BFD_RELOC_LARCH_ADD64
+ENUMX
+ BFD_RELOC_LARCH_SUB8
+ENUMX
+ BFD_RELOC_LARCH_SUB16
+ENUMX
+ BFD_RELOC_LARCH_SUB24
+ENUMX
+ BFD_RELOC_LARCH_SUB32
+ENUMX
+ BFD_RELOC_LARCH_SUB64
+ENUMDOC
+ LARCH relocations.
+
ENDSENUM
BFD_RELOC_UNUSED
CODE_FRAGMENT
diff --git a/bfd/targets.c b/bfd/targets.c
index 89b49e721b4..8f5abb174e2 100644
--- a/bfd/targets.c
+++ b/bfd/targets.c
@@ -768,6 +768,8 @@ extern const bfd_target l1om_elf64_vec;
extern const bfd_target l1om_elf64_fbsd_vec;
extern const bfd_target lm32_elf32_vec;
extern const bfd_target lm32_elf32_fdpic_vec;
+extern const bfd_target loongarch_elf64_vec;
+extern const bfd_target loongarch_elf32_vec;
extern const bfd_target m32c_elf32_vec;
extern const bfd_target m32r_elf32_vec;
extern const bfd_target m32r_elf32_le_vec;
@@ -1359,6 +1361,12 @@ static const bfd_target * const _bfd_target_vector[] =
&z80_elf32_vec,
&z8k_coff_vec,
+
+#ifdef BFD64
+ &loongarch_elf32_vec,
+ &loongarch_elf64_vec,
+#endif
+
#endif /* not SELECT_VECS */
/* Always support S-records, for convenience. */
diff --git a/include/elf/common.h b/include/elf/common.h
index ebfb5541fb2..d96e7422671 100644
--- a/include/elf/common.h
+++ b/include/elf/common.h
@@ -686,8 +686,18 @@
/* note name must be "LINUX". */
#define NT_ARC_V2 0x600 /* ARC HS accumulator/extra registers. */
/* note name must be "LINUX". */
-#define NT_RISCV_CSR 0x900 /* RISC-V Control and Status Registers */
+#define NT_LARCH_CPUCFG 0xa00 /* LoongArch CPU config registers */
+ /* note name must be "LINUX". */
+#define NT_LARCH_CSR 0xa01 /* LoongArch Control State Registers */
+ /* note name must be "LINUX". */
+#define NT_LARCH_LSX 0xa02 /* LoongArch SIMD eXtension registers */
+ /* note name must be "LINUX". */
+#define NT_LARCH_LASX 0xa03 /* LoongArch Advanced SIMD eXtension registers */
+ /* note name must be "LINUX". */
+#define NT_LARCH_LBT 0xa04 /* LoongArch Binary Translation registers */
/* note name must be "CORE". */
+#define NT_RISCV_CSR 0x900 /* RISC-V Control and Status Registers */
+ /* note name must be "LINUX". */
#define NT_SIGINFO 0x53494749 /* Fields of siginfo_t. */
#define NT_FILE 0x46494c45 /* Description of mapped files. */
diff --git a/include/elf/loongarch.h b/include/elf/loongarch.h
new file mode 100644
index 00000000000..3289bc87545
--- /dev/null
+++ b/include/elf/loongarch.h
@@ -0,0 +1,101 @@
+/* Copyright (C) 2021 Free Software Foundation, Inc.
+ Contributed by Loongson Ltd.
+
+ This file is part of GNU Binutils.
+
+ 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/>. */
+
+#ifndef _ELF_LOONGARCH_H
+#define _ELF_LOONGARCH_H
+
+#include "elf/reloc-macros.h"
+#include "libiberty.h"
+
+START_RELOC_NUMBERS (elf_loongarch_reloc_type)
+/* Used by the dynamic linker. */
+RELOC_NUMBER (R_LARCH_NONE, 0)
+RELOC_NUMBER (R_LARCH_32, 1)
+RELOC_NUMBER (R_LARCH_64, 2)
+RELOC_NUMBER (R_LARCH_RELATIVE, 3)
+RELOC_NUMBER (R_LARCH_COPY, 4)
+RELOC_NUMBER (R_LARCH_JUMP_SLOT, 5)
+RELOC_NUMBER (R_LARCH_TLS_DTPMOD32, 6)
+RELOC_NUMBER (R_LARCH_TLS_DTPMOD64, 7)
+RELOC_NUMBER (R_LARCH_TLS_DTPREL32, 8)
+RELOC_NUMBER (R_LARCH_TLS_DTPREL64, 9)
+RELOC_NUMBER (R_LARCH_TLS_TPREL32, 10)
+RELOC_NUMBER (R_LARCH_TLS_TPREL64, 11)
+RELOC_NUMBER (R_LARCH_IRELATIVE, 12)
+
+/* Reserved for future relocs that the dynamic linker must understand. */
+
+/* Used by the static linker for relocating .text. */
+RELOC_NUMBER (R_LARCH_MARK_LA, 20)
+RELOC_NUMBER (R_LARCH_MARK_PCREL, 21)
+
+RELOC_NUMBER (R_LARCH_SOP_PUSH_PCREL, 22)
+
+RELOC_NUMBER (R_LARCH_SOP_PUSH_ABSOLUTE, 23)
+
+RELOC_NUMBER (R_LARCH_SOP_PUSH_DUP, 24)
+RELOC_NUMBER (R_LARCH_SOP_PUSH_GPREL, 25)
+RELOC_NUMBER (R_LARCH_SOP_PUSH_TLS_TPREL, 26)
+RELOC_NUMBER (R_LARCH_SOP_PUSH_TLS_GOT, 27)
+RELOC_NUMBER (R_LARCH_SOP_PUSH_TLS_GD, 28)
+RELOC_NUMBER (R_LARCH_SOP_PUSH_PLT_PCREL, 29)
+
+RELOC_NUMBER (R_LARCH_SOP_ASSERT, 30)
+RELOC_NUMBER (R_LARCH_SOP_NOT, 31)
+RELOC_NUMBER (R_LARCH_SOP_SUB, 32)
+RELOC_NUMBER (R_LARCH_SOP_SL, 33)
+RELOC_NUMBER (R_LARCH_SOP_SR, 34)
+RELOC_NUMBER (R_LARCH_SOP_ADD, 35)
+RELOC_NUMBER (R_LARCH_SOP_AND, 36)
+RELOC_NUMBER (R_LARCH_SOP_IF_ELSE, 37)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_S_10_5, 38)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_U_10_12, 39)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_S_10_12, 40)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_S_10_16, 41)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_S_10_16_S2, 42)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_S_5_20, 43)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_S_0_5_10_16_S2, 44)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_S_0_10_10_16_S2, 45)
+RELOC_NUMBER (R_LARCH_SOP_POP_32_U, 46)
+
+/* Used by the static linker for relocating non .text. */
+RELOC_NUMBER (R_LARCH_ADD8, 47)
+RELOC_NUMBER (R_LARCH_ADD16, 48)
+RELOC_NUMBER (R_LARCH_ADD24, 49)
+RELOC_NUMBER (R_LARCH_ADD32, 50)
+RELOC_NUMBER (R_LARCH_ADD64, 51)
+RELOC_NUMBER (R_LARCH_SUB8, 52)
+RELOC_NUMBER (R_LARCH_SUB16, 53)
+RELOC_NUMBER (R_LARCH_SUB24, 54)
+RELOC_NUMBER (R_LARCH_SUB32, 55)
+RELOC_NUMBER (R_LARCH_SUB64, 56)
+
+/* I don't know what it is. Existing in almost all other arch. */
+RELOC_NUMBER (R_LARCH_GNU_VTINHERIT, 57)
+RELOC_NUMBER (R_LARCH_GNU_VTENTRY, 58)
+
+END_RELOC_NUMBERS (R_LARCH_count)
+
+/* Processor specific flags for the ELF header e_flags field. */
+
+#define EF_LARCH_ABI 0x0003
+#define EF_LARCH_ABI_LP64 0x0003
+#define EF_LARCH_ABI_LP32 0x0001
+
+#endif /* _ELF_LOONGARCH_H */
diff --git a/include/opcode/loongarch.h b/include/opcode/loongarch.h
new file mode 100644
index 00000000000..5c20e38b952
--- /dev/null
+++ b/include/opcode/loongarch.h
@@ -0,0 +1,220 @@
+/* LoongArch assembler/disassembler support.
+
+ Copyright (C) 2021 Free Software Foundation, Inc.
+ Contributed by Loongson Ltd.
+
+ This file is part of GNU Binutils.
+
+ 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/>. */
+
+#ifndef _LOONGARCH_H_
+#define _LOONGARCH_H_
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+ typedef uint32_t insn_t;
+
+ struct loongarch_opcode
+ {
+ const insn_t match;
+ const insn_t mask; /* High 1 byte is main opcode and it must be 0xf. */
+#define LARCH_INSN_OPC(insn) ((insn & 0xf0000000) >> 28)
+ const char *const name;
+
+ /* ACTUAL PARAMETER:
+
+ // BNF with regular expression.
+args : token* end
+
+ // just few char separate 'iden'
+token : ','
+| '('
+| ')'
+| iden // maybe a label (include at least one alphabet),
+ maybe a number, maybe a expr
+| regname
+
+regname : '$' iden
+
+iden : [a-zA-Z0-9\.\+\-]+
+
+end : '\0'
+
+
+FORMAT: A string to describe the format of actual parameter including
+bit field infomation. For example, "r5:5,r0:5,sr10:16<<2" matches
+"$12,$13,12345" and "$4,$7,a_label". That 'sr' means the instruction
+may need relocate. '10:16' means bit field of instruction.
+In a 'format', every 'escape's can be replaced to 'iden' or 'regname'
+acrroding to its meaning. We fill all information needed by
+disassembing and assembing to 'format'.
+
+ // BNF with regular expression.
+format : escape (literal+ escape)* literal* end
+| (literal+ escape)* literal* end
+
+end : '\0' // Get here means parse end.
+
+ // The intersection between any two among FIRST (end), FIRST
+ // (literal) and FIRST (escape) must be empty.
+ // So we can build a simple parser.
+literal : ','
+| '('
+| ')'
+
+ // Double '<'s means the real number is the immediate after shifting left.
+escape : esc_ch bit_field '<' '<' dec2
+| esc_ch bit_field
+| esc_ch // for MACRO. non-macro format must indicate 'bit_field'
+
+ // '|' means to concatenate nonadjacent bit fields
+ // For example, "10:16|0:4" means
+ // "16 bits starting from the 10th bit concatenating with 4 bits
+ // starting from the 0th bit".
+ // This is to say "[25..10]||[3..0]" (little endian).
+b_field : dec2 ':' dec2
+| dec2 ':' dec2 '|' bit_field
+
+esc_ch : 's' 'r' // signed immediate or label need relocate
+| 's' // signed immediate no need relocate
+| 'u' // unsigned immediate
+| 'l' // label needed relocate
+| 'r' // general purpose registers
+| 'f' // FPU registers
+| 'v' // 128 bit SIMD register
+| 'x' // 256 bit SIMD register
+
+dec2 : [1-9][0-9]?
+| 0
+
+*/
+ const char *const format;
+
+ /* MACRO: Indicate how a macro instruction expand for assembling.
+ The main is to replace the '%num'(means the 'num'th 'escape' in
+ 'format') in 'macro' string to get the real instruction.
+
+ Maybe need
+ */
+ const char *const macro;
+ const int *include;
+ const int *exclude;
+
+ const unsigned long pinfo;
+#define USELESS 0x0l
+ };
+
+ struct hash_control;
+
+ struct loongarch_ase
+ {
+ const int *enabled;
+ struct loongarch_opcode *const opcodes;
+ const int *include;
+ const int *exclude;
+
+ /* For disassemble to create main opcode hash table. */
+ const struct loongarch_opcode *opc_htab[16];
+ unsigned char opc_htab_inited;
+
+ /* For GAS to create hash table. */
+ struct htab *name_hash_entry;
+ };
+
+ extern int is_unsigned (const char *);
+ extern int is_signed (const char *);
+ extern int is_label_with_addend (const char *);
+ extern int is_label (const char *);
+ extern int is_branch_label (const char *);
+
+ extern int loongarch_get_bit_field_width (const char *bit_field, char **end);
+ extern int32_t loongarch_decode_imm (const char *bit_field, insn_t insn,
+ int si);
+
+#define MAX_ARG_NUM_PLUS_2 9
+
+ extern size_t loongarch_split_args_by_comma (char *args,
+ const char *arg_strs[]);
+ extern char *loongarch_cat_splited_strs (const char *arg_strs[]);
+ extern insn_t loongarch_foreach_args (
+ const char *format, const char *arg_strs[],
+ int32_t (*helper) (char esc1, char esc2, const char *bit_field,
+ const char *arg, void *context),
+ void *context);
+
+ extern int loongarch_check_format (const char *format);
+ extern int loongarch_check_macro (const char *format, const char *macro);
+
+ extern char *loongarch_expand_macro_with_format_map (
+ const char *format, const char *macro, const char *const arg_strs[],
+ const char *(*map) (char esc1, char esc2, const char *arg),
+ char *(*helper) (const char *const arg_strs[], void *context),
+ void *context);
+ extern char *loongarch_expand_macro (
+ const char *macro, const char *const arg_strs[],
+ char *(*helper) (const char *const arg_strs[], void *context),
+ void *context);
+ extern size_t loongarch_bits_imm_needed (int64_t imm, int si);
+
+ extern void loongarch_eliminate_adjacent_repeat_char (char *dest, char c);
+
+ extern int loongarch_parse_dis_options (const char *opts_in);
+ extern void loongarch_disassemble_one (
+ int64_t pc, insn_t insn,
+ int (*fprintf_func) (void *stream, const char *format, ...), void *stream);
+
+ extern const char *const loongarch_r_normal_name[32];
+ extern const char *const loongarch_r_lp64_name[32];
+ extern const char *const loongarch_r_lp64_name1[32];
+ extern const char *const loongarch_f_normal_name[32];
+ extern const char *const loongarch_f_lp64_name[32];
+ extern const char *const loongarch_f_lp64_name1[32];
+ extern const char *const loongarch_c_normal_name[8];
+ extern const char *const loongarch_cr_normal_name[4];
+ extern const char *const loongarch_v_normal_name[32];
+ extern const char *const loongarch_x_normal_name[32];
+
+ extern struct loongarch_ase loongarch_ASEs[];
+
+ extern struct loongarch_ASEs_option
+ {
+ int ase_fix;
+ int ase_float;
+ int ase_128vec;
+ int ase_256vec;
+
+ int addrwidth_is_32;
+ int addrwidth_is_64;
+ int rlen_is_32;
+ int rlen_is_64;
+ int la_local_with_abs;
+ int la_global_with_pcrel;
+ int la_global_with_abs;
+
+ int abi_is_lp32;
+ int abi_is_lp64;
+ } LARCH_opts;
+
+ extern size_t loongarch_insn_length (insn_t insn);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LOONGARCH_H_ */
--
2.27.0
More information about the Binutils
mailing list