mirror of https://gitee.com/openkylin/linux.git
RISC-V: Fixes to module loading
This cleans up the module support that was commited earlier to work with what's actually emitted from our GCC port as it lands upstream. Most of the work here is adding new relocations to the kernel. There's some limitations on module loading imposed by the kernel: * The kernel doesn't support linker relaxation, which is necessary to support R_RISCV_ALIGN. In order to get reliable module building you're going to need to a GCC that supports the new '-mno-relax', which IIRC isn't going to be out until 8.1.0. It's somewhat unlikely that R_RISCV_ALIGN will appear in a module even without '-mno-relax' support, so issues shouldn't be common. * There is no large code model for RISC-V, which means modules must be loaded within a 32-bit signed offset of the kernel. We don't currently have any mechanism for ensuring this memory remains free or moving pages around, so issues here might be common. I fixed a singcle merge conflict in arch/riscv/kernel/Makefile.
This commit is contained in:
Palmer Dabbelt
commit
7a8e7da422
|
|
@ -134,6 +134,10 @@ choice
|
|||
bool "medium any code model"
|
||||
endchoice
|
||||
|
||||
config MODULE_SECTIONS
|
||||
bool
|
||||
select HAVE_MOD_ARCH_SPECIFIC
|
||||
|
||||
choice
|
||||
prompt "Maximum Physical Memory"
|
||||
default MAXPHYSMEM_2GB if 32BIT
|
||||
|
|
@ -144,6 +148,7 @@ choice
|
|||
bool "2GiB"
|
||||
config MAXPHYSMEM_128GB
|
||||
depends on 64BIT && CMODEL_MEDANY
|
||||
select MODULE_SECTIONS if MODULES
|
||||
bool "128GiB"
|
||||
endchoice
|
||||
|
||||
|
|
|
|||
|
|
@ -59,6 +59,11 @@ endif
|
|||
ifeq ($(CONFIG_CMODEL_MEDANY),y)
|
||||
KBUILD_CFLAGS += -mcmodel=medany
|
||||
endif
|
||||
ifeq ($(CONFIG_MODULE_SECTIONS),y)
|
||||
KBUILD_LDFLAGS_MODULE += -T $(srctree)/arch/riscv/kernel/module.lds
|
||||
endif
|
||||
|
||||
KBUILD_CFLAGS_MODULE += $(call cc-option,-mno-relax)
|
||||
|
||||
# GCC versions that support the "-mstrict-align" option default to allowing
|
||||
# unaligned accesses. While unaligned accesses are explicitly allowed in the
|
||||
|
|
|
|||
|
|
@ -73,3 +73,5 @@ CONFIG_NFS_V4_2=y
|
|||
CONFIG_ROOT_NFS=y
|
||||
# CONFIG_RCU_TRACE is not set
|
||||
CONFIG_CRYPTO_USER_API_HASH=y
|
||||
CONFIG_MODULES=y
|
||||
CONFIG_MODULE_UNLOAD=y
|
||||
|
|
|
|||
|
|
@ -0,0 +1,113 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
/* Copyright (C) 2017 Andes Technology Corporation */
|
||||
|
||||
#ifndef _ASM_RISCV_MODULE_H
|
||||
#define _ASM_RISCV_MODULE_H
|
||||
|
||||
#include <asm-generic/module.h>
|
||||
|
||||
#define MODULE_ARCH_VERMAGIC "riscv"
|
||||
|
||||
u64 module_emit_got_entry(struct module *mod, u64 val);
|
||||
u64 module_emit_plt_entry(struct module *mod, u64 val);
|
||||
|
||||
#ifdef CONFIG_MODULE_SECTIONS
|
||||
struct mod_section {
|
||||
struct elf64_shdr *shdr;
|
||||
int num_entries;
|
||||
int max_entries;
|
||||
};
|
||||
|
||||
struct mod_arch_specific {
|
||||
struct mod_section got;
|
||||
struct mod_section plt;
|
||||
struct mod_section got_plt;
|
||||
};
|
||||
|
||||
struct got_entry {
|
||||
u64 symbol_addr; /* the real variable address */
|
||||
};
|
||||
|
||||
static inline struct got_entry emit_got_entry(u64 val)
|
||||
{
|
||||
return (struct got_entry) {val};
|
||||
}
|
||||
|
||||
static inline struct got_entry *get_got_entry(u64 val,
|
||||
const struct mod_section *sec)
|
||||
{
|
||||
struct got_entry *got = (struct got_entry *)sec->shdr->sh_addr;
|
||||
int i;
|
||||
for (i = 0; i < sec->num_entries; i++) {
|
||||
if (got[i].symbol_addr == val)
|
||||
return &got[i];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct plt_entry {
|
||||
/*
|
||||
* Trampoline code to real target address. The return address
|
||||
* should be the original (pc+4) before entring plt entry.
|
||||
*/
|
||||
u32 insn_auipc; /* auipc t0, 0x0 */
|
||||
u32 insn_ld; /* ld t1, 0x10(t0) */
|
||||
u32 insn_jr; /* jr t1 */
|
||||
};
|
||||
|
||||
#define OPC_AUIPC 0x0017
|
||||
#define OPC_LD 0x3003
|
||||
#define OPC_JALR 0x0067
|
||||
#define REG_T0 0x5
|
||||
#define REG_T1 0x6
|
||||
|
||||
static inline struct plt_entry emit_plt_entry(u64 val, u64 plt, u64 got_plt)
|
||||
{
|
||||
/*
|
||||
* U-Type encoding:
|
||||
* +------------+----------+----------+
|
||||
* | imm[31:12] | rd[11:7] | opc[6:0] |
|
||||
* +------------+----------+----------+
|
||||
*
|
||||
* I-Type encoding:
|
||||
* +------------+------------+--------+----------+----------+
|
||||
* | imm[31:20] | rs1[19:15] | funct3 | rd[11:7] | opc[6:0] |
|
||||
* +------------+------------+--------+----------+----------+
|
||||
*
|
||||
*/
|
||||
u64 offset = got_plt - plt;
|
||||
u32 hi20 = (offset + 0x800) & 0xfffff000;
|
||||
u32 lo12 = (offset - hi20);
|
||||
return (struct plt_entry) {
|
||||
OPC_AUIPC | (REG_T0 << 7) | hi20,
|
||||
OPC_LD | (lo12 << 20) | (REG_T0 << 15) | (REG_T1 << 7),
|
||||
OPC_JALR | (REG_T1 << 15)
|
||||
};
|
||||
}
|
||||
|
||||
static inline int get_got_plt_idx(u64 val, const struct mod_section *sec)
|
||||
{
|
||||
struct got_entry *got_plt = (struct got_entry *)sec->shdr->sh_addr;
|
||||
int i;
|
||||
for (i = 0; i < sec->num_entries; i++) {
|
||||
if (got_plt[i].symbol_addr == val)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static inline struct plt_entry *get_plt_entry(u64 val,
|
||||
const struct mod_section *sec_plt,
|
||||
const struct mod_section *sec_got_plt)
|
||||
{
|
||||
struct plt_entry *plt = (struct plt_entry *)sec_plt->shdr->sh_addr;
|
||||
int got_plt_idx = get_got_plt_idx(val, sec_got_plt);
|
||||
if (got_plt_idx >= 0)
|
||||
return plt + got_plt_idx;
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#endif /* CONFIG_MODULE_SECTIONS */
|
||||
|
||||
#endif /* _ASM_RISCV_MODULE_H */
|
||||
|
|
@ -79,5 +79,12 @@ typedef union __riscv_fp_state elf_fpregset_t;
|
|||
#define R_RISCV_TPREL_I 49
|
||||
#define R_RISCV_TPREL_S 50
|
||||
#define R_RISCV_RELAX 51
|
||||
#define R_RISCV_SUB6 52
|
||||
#define R_RISCV_SET6 53
|
||||
#define R_RISCV_SET8 54
|
||||
#define R_RISCV_SET16 55
|
||||
#define R_RISCV_SET32 56
|
||||
#define R_RISCV_32_PCREL 57
|
||||
|
||||
|
||||
#endif /* _UAPI_ASM_ELF_H */
|
||||
|
|
|
|||
|
|
@ -34,6 +34,7 @@ CFLAGS_setup.o := -mcmodel=medany
|
|||
obj-$(CONFIG_SMP) += smpboot.o
|
||||
obj-$(CONFIG_SMP) += smp.o
|
||||
obj-$(CONFIG_MODULES) += module.o
|
||||
obj-$(CONFIG_MODULE_SECTIONS) += module-sections.o
|
||||
|
||||
obj-$(CONFIG_FUNCTION_TRACER) += mcount.o ftrace.o
|
||||
obj-$(CONFIG_DYNAMIC_FTRACE) += mcount-dyn.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,156 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0
|
||||
*
|
||||
* Copyright (C) 2014-2017 Linaro Ltd. <ard.biesheuvel@linaro.org>
|
||||
*
|
||||
* Copyright (C) 2018 Andes Technology Corporation <zong@andestech.com>
|
||||
*/
|
||||
|
||||
#include <linux/elf.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
|
||||
u64 module_emit_got_entry(struct module *mod, u64 val)
|
||||
{
|
||||
struct mod_section *got_sec = &mod->arch.got;
|
||||
int i = got_sec->num_entries;
|
||||
struct got_entry *got = get_got_entry(val, got_sec);
|
||||
|
||||
if (got)
|
||||
return (u64)got;
|
||||
|
||||
/* There is no duplicate entry, create a new one */
|
||||
got = (struct got_entry *)got_sec->shdr->sh_addr;
|
||||
got[i] = emit_got_entry(val);
|
||||
|
||||
got_sec->num_entries++;
|
||||
BUG_ON(got_sec->num_entries > got_sec->max_entries);
|
||||
|
||||
return (u64)&got[i];
|
||||
}
|
||||
|
||||
u64 module_emit_plt_entry(struct module *mod, u64 val)
|
||||
{
|
||||
struct mod_section *got_plt_sec = &mod->arch.got_plt;
|
||||
struct got_entry *got_plt;
|
||||
struct mod_section *plt_sec = &mod->arch.plt;
|
||||
struct plt_entry *plt = get_plt_entry(val, plt_sec, got_plt_sec);
|
||||
int i = plt_sec->num_entries;
|
||||
|
||||
if (plt)
|
||||
return (u64)plt;
|
||||
|
||||
/* There is no duplicate entry, create a new one */
|
||||
got_plt = (struct got_entry *)got_plt_sec->shdr->sh_addr;
|
||||
got_plt[i] = emit_got_entry(val);
|
||||
plt = (struct plt_entry *)plt_sec->shdr->sh_addr;
|
||||
plt[i] = emit_plt_entry(val, (u64)&plt[i], (u64)&got_plt[i]);
|
||||
|
||||
plt_sec->num_entries++;
|
||||
got_plt_sec->num_entries++;
|
||||
BUG_ON(plt_sec->num_entries > plt_sec->max_entries);
|
||||
|
||||
return (u64)&plt[i];
|
||||
}
|
||||
|
||||
static int is_rela_equal(const Elf64_Rela *x, const Elf64_Rela *y)
|
||||
{
|
||||
return x->r_info == y->r_info && x->r_addend == y->r_addend;
|
||||
}
|
||||
|
||||
static bool duplicate_rela(const Elf64_Rela *rela, int idx)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < idx; i++) {
|
||||
if (is_rela_equal(&rela[i], &rela[idx]))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static void count_max_entries(Elf64_Rela *relas, int num,
|
||||
unsigned int *plts, unsigned int *gots)
|
||||
{
|
||||
unsigned int type, i;
|
||||
|
||||
for (i = 0; i < num; i++) {
|
||||
type = ELF64_R_TYPE(relas[i].r_info);
|
||||
if (type == R_RISCV_CALL_PLT) {
|
||||
if (!duplicate_rela(relas, i))
|
||||
(*plts)++;
|
||||
} else if (type == R_RISCV_GOT_HI20) {
|
||||
if (!duplicate_rela(relas, i))
|
||||
(*gots)++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int module_frob_arch_sections(Elf_Ehdr *ehdr, Elf_Shdr *sechdrs,
|
||||
char *secstrings, struct module *mod)
|
||||
{
|
||||
unsigned int num_plts = 0;
|
||||
unsigned int num_gots = 0;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Find the empty .got and .plt sections.
|
||||
*/
|
||||
for (i = 0; i < ehdr->e_shnum; i++) {
|
||||
if (!strcmp(secstrings + sechdrs[i].sh_name, ".plt"))
|
||||
mod->arch.plt.shdr = sechdrs + i;
|
||||
else if (!strcmp(secstrings + sechdrs[i].sh_name, ".got"))
|
||||
mod->arch.got.shdr = sechdrs + i;
|
||||
else if (!strcmp(secstrings + sechdrs[i].sh_name, ".got.plt"))
|
||||
mod->arch.got_plt.shdr = sechdrs + i;
|
||||
}
|
||||
|
||||
if (!mod->arch.plt.shdr) {
|
||||
pr_err("%s: module PLT section(s) missing\n", mod->name);
|
||||
return -ENOEXEC;
|
||||
}
|
||||
if (!mod->arch.got.shdr) {
|
||||
pr_err("%s: module GOT section(s) missing\n", mod->name);
|
||||
return -ENOEXEC;
|
||||
}
|
||||
if (!mod->arch.got_plt.shdr) {
|
||||
pr_err("%s: module GOT.PLT section(s) missing\n", mod->name);
|
||||
return -ENOEXEC;
|
||||
}
|
||||
|
||||
/* Calculate the maxinum number of entries */
|
||||
for (i = 0; i < ehdr->e_shnum; i++) {
|
||||
Elf64_Rela *relas = (void *)ehdr + sechdrs[i].sh_offset;
|
||||
int num_rela = sechdrs[i].sh_size / sizeof(Elf64_Rela);
|
||||
Elf64_Shdr *dst_sec = sechdrs + sechdrs[i].sh_info;
|
||||
|
||||
if (sechdrs[i].sh_type != SHT_RELA)
|
||||
continue;
|
||||
|
||||
/* ignore relocations that operate on non-exec sections */
|
||||
if (!(dst_sec->sh_flags & SHF_EXECINSTR))
|
||||
continue;
|
||||
|
||||
count_max_entries(relas, num_rela, &num_plts, &num_gots);
|
||||
}
|
||||
|
||||
mod->arch.plt.shdr->sh_type = SHT_NOBITS;
|
||||
mod->arch.plt.shdr->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
|
||||
mod->arch.plt.shdr->sh_addralign = L1_CACHE_BYTES;
|
||||
mod->arch.plt.shdr->sh_size = (num_plts + 1) * sizeof(struct plt_entry);
|
||||
mod->arch.plt.num_entries = 0;
|
||||
mod->arch.plt.max_entries = num_plts;
|
||||
|
||||
mod->arch.got.shdr->sh_type = SHT_NOBITS;
|
||||
mod->arch.got.shdr->sh_flags = SHF_ALLOC;
|
||||
mod->arch.got.shdr->sh_addralign = L1_CACHE_BYTES;
|
||||
mod->arch.got.shdr->sh_size = (num_gots + 1) * sizeof(struct got_entry);
|
||||
mod->arch.got.num_entries = 0;
|
||||
mod->arch.got.max_entries = num_gots;
|
||||
|
||||
mod->arch.got_plt.shdr->sh_type = SHT_NOBITS;
|
||||
mod->arch.got_plt.shdr->sh_flags = SHF_ALLOC;
|
||||
mod->arch.got_plt.shdr->sh_addralign = L1_CACHE_BYTES;
|
||||
mod->arch.got_plt.shdr->sh_size = (num_plts + 1) * sizeof(struct got_entry);
|
||||
mod->arch.got_plt.num_entries = 0;
|
||||
mod->arch.got_plt.max_entries = num_plts;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -49,6 +49,39 @@ static int apply_r_riscv_jal_rela(struct module *me, u32 *location,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_rcv_branch_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
s64 offset = (void *)v - (void *)location;
|
||||
u16 imm8 = (offset & 0x100) << (12 - 8);
|
||||
u16 imm7_6 = (offset & 0xc0) >> (6 - 5);
|
||||
u16 imm5 = (offset & 0x20) >> (5 - 2);
|
||||
u16 imm4_3 = (offset & 0x18) << (12 - 5);
|
||||
u16 imm2_1 = (offset & 0x6) << (12 - 10);
|
||||
|
||||
*(u16 *)location = (*(u16 *)location & 0xe383) |
|
||||
imm8 | imm7_6 | imm5 | imm4_3 | imm2_1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_rvc_jump_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
s64 offset = (void *)v - (void *)location;
|
||||
u16 imm11 = (offset & 0x800) << (12 - 11);
|
||||
u16 imm10 = (offset & 0x400) >> (10 - 8);
|
||||
u16 imm9_8 = (offset & 0x300) << (12 - 11);
|
||||
u16 imm7 = (offset & 0x80) >> (7 - 6);
|
||||
u16 imm6 = (offset & 0x40) << (12 - 11);
|
||||
u16 imm5 = (offset & 0x20) >> (5 - 2);
|
||||
u16 imm4 = (offset & 0x10) << (12 - 5);
|
||||
u16 imm3_1 = (offset & 0xe) << (12 - 10);
|
||||
|
||||
*(u16 *)location = (*(u16 *)location & 0xe003) |
|
||||
imm11 | imm10 | imm9_8 | imm7 | imm6 | imm5 | imm4 | imm3_1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_pcrel_hi20_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
|
|
@ -92,6 +125,67 @@ static int apply_r_riscv_pcrel_lo12_s_rela(struct module *me, u32 *location,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_hi20_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
s32 hi20;
|
||||
|
||||
if (IS_ENABLED(CMODEL_MEDLOW)) {
|
||||
pr_err(
|
||||
"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
|
||||
me->name, v, location);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
hi20 = ((s32)v + 0x800) & 0xfffff000;
|
||||
*location = (*location & 0xfff) | hi20;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_lo12_i_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
/* Skip medlow checking because of filtering by HI20 already */
|
||||
s32 hi20 = ((s32)v + 0x800) & 0xfffff000;
|
||||
s32 lo12 = ((s32)v - hi20);
|
||||
*location = (*location & 0xfffff) | ((lo12 & 0xfff) << 20);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_lo12_s_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
/* Skip medlow checking because of filtering by HI20 already */
|
||||
s32 hi20 = ((s32)v + 0x800) & 0xfffff000;
|
||||
s32 lo12 = ((s32)v - hi20);
|
||||
u32 imm11_5 = (lo12 & 0xfe0) << (31 - 11);
|
||||
u32 imm4_0 = (lo12 & 0x1f) << (11 - 4);
|
||||
*location = (*location & 0x1fff07f) | imm11_5 | imm4_0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_got_hi20_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
s64 offset = (void *)v - (void *)location;
|
||||
s32 hi20;
|
||||
|
||||
/* Always emit the got entry */
|
||||
if (IS_ENABLED(CONFIG_MODULE_SECTIONS)) {
|
||||
offset = module_emit_got_entry(me, v);
|
||||
offset = (void *)offset - (void *)location;
|
||||
} else {
|
||||
pr_err(
|
||||
"%s: can not generate the GOT entry for symbol = %016llx from PC = %p\n",
|
||||
me->name, v, location);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
hi20 = (offset + 0x800) & 0xfffff000;
|
||||
*location = (*location & 0xfff) | hi20;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_call_plt_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
|
|
@ -99,6 +193,33 @@ static int apply_r_riscv_call_plt_rela(struct module *me, u32 *location,
|
|||
s32 fill_v = offset;
|
||||
u32 hi20, lo12;
|
||||
|
||||
if (offset != fill_v) {
|
||||
/* Only emit the plt entry if offset over 32-bit range */
|
||||
if (IS_ENABLED(CONFIG_MODULE_SECTIONS)) {
|
||||
offset = module_emit_plt_entry(me, v);
|
||||
offset = (void *)offset - (void *)location;
|
||||
} else {
|
||||
pr_err(
|
||||
"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
|
||||
me->name, v, location);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
hi20 = (offset + 0x800) & 0xfffff000;
|
||||
lo12 = (offset - hi20) & 0xfff;
|
||||
*location = (*location & 0xfff) | hi20;
|
||||
*(location + 1) = (*(location + 1) & 0xfffff) | (lo12 << 20);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_call_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
s64 offset = (void *)v - (void *)location;
|
||||
s32 fill_v = offset;
|
||||
u32 hi20, lo12;
|
||||
|
||||
if (offset != fill_v) {
|
||||
pr_err(
|
||||
"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
|
||||
|
|
@ -119,16 +240,49 @@ static int apply_r_riscv_relax_rela(struct module *me, u32 *location,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_align_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
pr_err(
|
||||
"%s: The unexpected relocation type 'R_RISCV_ALIGN' from PC = %p\n",
|
||||
me->name, location);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_add32_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
*(u32 *)location += (*(u32 *)v);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int apply_r_riscv_sub32_rela(struct module *me, u32 *location,
|
||||
Elf_Addr v)
|
||||
{
|
||||
*(u32 *)location -= (*(u32 *)v);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int (*reloc_handlers_rela[]) (struct module *me, u32 *location,
|
||||
Elf_Addr v) = {
|
||||
[R_RISCV_64] = apply_r_riscv_64_rela,
|
||||
[R_RISCV_BRANCH] = apply_r_riscv_branch_rela,
|
||||
[R_RISCV_JAL] = apply_r_riscv_jal_rela,
|
||||
[R_RISCV_RVC_BRANCH] = apply_r_riscv_rcv_branch_rela,
|
||||
[R_RISCV_RVC_JUMP] = apply_r_riscv_rvc_jump_rela,
|
||||
[R_RISCV_PCREL_HI20] = apply_r_riscv_pcrel_hi20_rela,
|
||||
[R_RISCV_PCREL_LO12_I] = apply_r_riscv_pcrel_lo12_i_rela,
|
||||
[R_RISCV_PCREL_LO12_S] = apply_r_riscv_pcrel_lo12_s_rela,
|
||||
[R_RISCV_HI20] = apply_r_riscv_hi20_rela,
|
||||
[R_RISCV_LO12_I] = apply_r_riscv_lo12_i_rela,
|
||||
[R_RISCV_LO12_S] = apply_r_riscv_lo12_s_rela,
|
||||
[R_RISCV_GOT_HI20] = apply_r_riscv_got_hi20_rela,
|
||||
[R_RISCV_CALL_PLT] = apply_r_riscv_call_plt_rela,
|
||||
[R_RISCV_CALL] = apply_r_riscv_call_rela,
|
||||
[R_RISCV_RELAX] = apply_r_riscv_relax_rela,
|
||||
[R_RISCV_ALIGN] = apply_r_riscv_align_rela,
|
||||
[R_RISCV_ADD32] = apply_r_riscv_add32_rela,
|
||||
[R_RISCV_SUB32] = apply_r_riscv_sub32_rela,
|
||||
};
|
||||
|
||||
int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
|
||||
|
|
@ -184,25 +338,38 @@ int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
|
|||
u64 hi20_loc =
|
||||
sechdrs[sechdrs[relsec].sh_info].sh_addr
|
||||
+ rel[j].r_offset;
|
||||
/* Find the corresponding HI20 PC-relative relocation entry */
|
||||
if (hi20_loc == sym->st_value) {
|
||||
u32 hi20_type = ELF_RISCV_R_TYPE(rel[j].r_info);
|
||||
|
||||
/* Find the corresponding HI20 relocation entry */
|
||||
if (hi20_loc == sym->st_value
|
||||
&& (hi20_type == R_RISCV_PCREL_HI20
|
||||
|| hi20_type == R_RISCV_GOT_HI20)) {
|
||||
s32 hi20, lo12;
|
||||
Elf_Sym *hi20_sym =
|
||||
(Elf_Sym *)sechdrs[symindex].sh_addr
|
||||
+ ELF_RISCV_R_SYM(rel[j].r_info);
|
||||
u64 hi20_sym_val =
|
||||
hi20_sym->st_value
|
||||
+ rel[j].r_addend;
|
||||
|
||||
/* Calculate lo12 */
|
||||
s64 offset = hi20_sym_val - hi20_loc;
|
||||
s32 hi20 = (offset + 0x800) & 0xfffff000;
|
||||
s32 lo12 = offset - hi20;
|
||||
u64 offset = hi20_sym_val - hi20_loc;
|
||||
if (IS_ENABLED(CONFIG_MODULE_SECTIONS)
|
||||
&& hi20_type == R_RISCV_GOT_HI20) {
|
||||
offset = module_emit_got_entry(
|
||||
me, hi20_sym_val);
|
||||
offset = offset - hi20_loc;
|
||||
}
|
||||
hi20 = (offset + 0x800) & 0xfffff000;
|
||||
lo12 = offset - hi20;
|
||||
v = lo12;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (j == sechdrs[relsec].sh_size / sizeof(*rel)) {
|
||||
pr_err(
|
||||
"%s: Can not find HI20 PC-relative relocation information\n",
|
||||
"%s: Can not find HI20 relocation information\n",
|
||||
me->name);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,8 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
/* Copyright (C) 2017 Andes Technology Corporation */
|
||||
|
||||
SECTIONS {
|
||||
.plt (NOLOAD) : { BYTE(0) }
|
||||
.got (NOLOAD) : { BYTE(0) }
|
||||
.got.plt (NOLOAD) : { BYTE(0) }
|
||||
}
|
||||
Loading…
Reference in New Issue