[linux.git] / arch / riscv / kernel / module.c

/*
 *  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 2 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.
 *
 *  Copyright (C) 2017 Zihao Yu
 */

#include <linux/elf.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/moduleloader.h>

static int apply_r_riscv_32_rela(struct module *me, u32 *location, Elf_Addr v)
{
	if (v != (u32)v) {
		pr_err("%s: value %016llx out of range for 32-bit field\n",
		       me->name, (long long)v);
		return -EINVAL;
	}
	*location = v;
	return 0;
}

static int apply_r_riscv_64_rela(struct module *me, u32 *location, Elf_Addr v)
{
	*(u64 *)location = v;
	return 0;
}

static int apply_r_riscv_branch_rela(struct module *me, u32 *location,
				     Elf_Addr v)
{
	ptrdiff_t offset = (void *)v - (void *)location;
	u32 imm12 = (offset & 0x1000) << (31 - 12);
	u32 imm11 = (offset & 0x800) >> (11 - 7);
	u32 imm10_5 = (offset & 0x7e0) << (30 - 10);
	u32 imm4_1 = (offset & 0x1e) << (11 - 4);

	*location = (*location & 0x1fff07f) | imm12 | imm11 | imm10_5 | imm4_1;
	return 0;
}

static int apply_r_riscv_jal_rela(struct module *me, u32 *location,
				  Elf_Addr v)
{
	ptrdiff_t offset = (void *)v - (void *)location;
	u32 imm20 = (offset & 0x100000) << (31 - 20);
	u32 imm19_12 = (offset & 0xff000);
	u32 imm11 = (offset & 0x800) << (20 - 11);
	u32 imm10_1 = (offset & 0x7fe) << (30 - 10);

	*location = (*location & 0xfff) | imm20 | imm19_12 | imm11 | imm10_1;
	return 0;
}

static int apply_r_riscv_rcv_branch_rela(struct module *me, u32 *location,
					 Elf_Addr v)
{
	ptrdiff_t 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)
{
	ptrdiff_t 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)
{
	ptrdiff_t offset = (void *)v - (void *)location;
	s32 hi20;

	if (offset != (s32)offset) {
		pr_err(
		  "%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
		  me->name, (long long)v, location);
		return -EINVAL;
	}

	hi20 = (offset + 0x800) & 0xfffff000;
	*location = (*location & 0xfff) | hi20;
	return 0;
}

static int apply_r_riscv_pcrel_lo12_i_rela(struct module *me, u32 *location,
					   Elf_Addr v)
{
	/*
	 * v is the lo12 value to fill. It is calculated before calling this
	 * handler.
	 */
	*location = (*location & 0xfffff) | ((v & 0xfff) << 20);
	return 0;
}

static int apply_r_riscv_pcrel_lo12_s_rela(struct module *me, u32 *location,
					   Elf_Addr v)
{
	/*
	 * v is the lo12 value to fill. It is calculated before calling this
	 * handler.
	 */
	u32 imm11_5 = (v & 0xfe0) << (31 - 11);
	u32 imm4_0 = (v & 0x1f) << (11 - 4);

	*location = (*location & 0x1fff07f) | imm11_5 | imm4_0;
	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, (long long)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)
{
	ptrdiff_t 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, (long long)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)
{
	ptrdiff_t offset = (void *)v - (void *)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, (long long)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)
{
	ptrdiff_t 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",
		  me->name, (long long)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_relax_rela(struct module *me, u32 *location,
				    Elf_Addr v)
{
	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_32]			= apply_r_riscv_32_rela,
	[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,
		       unsigned int symindex, unsigned int relsec,
		       struct module *me)
{
	Elf_Rela *rel = (void *) sechdrs[relsec].sh_addr;
	int (*handler)(struct module *me, u32 *location, Elf_Addr v);
	Elf_Sym *sym;
	u32 *location;
	unsigned int i, type;
	Elf_Addr v;
	int res;

	pr_debug("Applying relocate section %u to %u\n", relsec,
	       sechdrs[relsec].sh_info);

	for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
		/* This is where to make the change */
		location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
			+ rel[i].r_offset;
		/* This is the symbol it is referring to */
		sym = (Elf_Sym *)sechdrs[symindex].sh_addr
			+ ELF_RISCV_R_SYM(rel[i].r_info);
		if (IS_ERR_VALUE(sym->st_value)) {
			/* Ignore unresolved weak symbol */
			if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
				continue;
			pr_warning("%s: Unknown symbol %s\n",
				   me->name, strtab + sym->st_name);
			return -ENOENT;
		}

		type = ELF_RISCV_R_TYPE(rel[i].r_info);

		if (type < ARRAY_SIZE(reloc_handlers_rela))
			handler = reloc_handlers_rela[type];
		else
			handler = NULL;

		if (!handler) {
			pr_err("%s: Unknown relocation type %u\n",
			       me->name, type);
			return -EINVAL;
		}

		v = sym->st_value + rel[i].r_addend;

		if (type == R_RISCV_PCREL_LO12_I || type == R_RISCV_PCREL_LO12_S) {
			unsigned int j;

			for (j = 0; j < sechdrs[relsec].sh_size / sizeof(*rel); j++) {
				unsigned long hi20_loc =
					sechdrs[sechdrs[relsec].sh_info].sh_addr
					+ rel[j].r_offset;
				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);
					unsigned long hi20_sym_val =
						hi20_sym->st_value
						+ rel[j].r_addend;

					/* Calculate lo12 */
					size_t 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 relocation information\n",
				  me->name);
				return -EINVAL;
			}
		}

		res = handler(me, location, v);
		if (res)
			return res;
	}

	return 0;
}
Commit	Line	Data
e2c0cdfb PD	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License as published by
	4	* the Free Software Foundation; either version 2 of the License, or
	5	* (at your option) any later version.
	6	*
	7	* This program is distributed in the hope that it will be useful,
	8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	10	* GNU General Public License for more details.
	11	*
	12	* Copyright (C) 2017 Zihao Yu
	13	*/
	14
	15	#include <linux/elf.h>
	16	#include <linux/err.h>
	17	#include <linux/errno.h>
	18	#include <linux/moduleloader.h>
	19
77aa85de AS	20	static int apply_r_riscv_32_rela(struct module me, u32 location, Elf_Addr v)
	21	{
	22	if (v != (u32)v) {
	23	pr_err("%s: value %016llx out of range for 32-bit field\n",
ef3a6140	24	me->name, (long long)v);
77aa85de AS	25	return -EINVAL;
	26	}
	27	*location = v;
	28	return 0;
	29	}
	30
e2c0cdfb PD	31	static int apply_r_riscv_64_rela(struct module me, u32 location, Elf_Addr v)
	32	{
	33	(u64 )location = v;
	34	return 0;
	35	}
	36
	37	static int apply_r_riscv_branch_rela(struct module me, u32 location,
	38	Elf_Addr v)
	39	{
7df85002	40	ptrdiff_t offset = (void )v - (void )location;
e2c0cdfb PD	41	u32 imm12 = (offset & 0x1000) << (31 - 12);
	42	u32 imm11 = (offset & 0x800) >> (11 - 7);
	43	u32 imm10_5 = (offset & 0x7e0) << (30 - 10);
	44	u32 imm4_1 = (offset & 0x1e) << (11 - 4);
	45
	46	location = (location & 0x1fff07f) \| imm12 \| imm11 \| imm10_5 \| imm4_1;
	47	return 0;
	48	}
	49
	50	static int apply_r_riscv_jal_rela(struct module me, u32 location,
	51	Elf_Addr v)
	52	{
7df85002	53	ptrdiff_t offset = (void )v - (void )location;
e2c0cdfb PD	54	u32 imm20 = (offset & 0x100000) << (31 - 20);
	55	u32 imm19_12 = (offset & 0xff000);
	56	u32 imm11 = (offset & 0x800) << (20 - 11);
	57	u32 imm10_1 = (offset & 0x7fe) << (30 - 10);
	58
	59	location = (location & 0xfff) \| imm20 \| imm19_12 \| imm11 \| imm10_1;
	60	return 0;
	61	}
	62
56ea45ae ZL	63	static int apply_r_riscv_rcv_branch_rela(struct module me, u32 location,
	64	Elf_Addr v)
	65	{
7df85002	66	ptrdiff_t offset = (void )v - (void )location;
56ea45ae ZL	67	u16 imm8 = (offset & 0x100) << (12 - 8);
	68	u16 imm7_6 = (offset & 0xc0) >> (6 - 5);
	69	u16 imm5 = (offset & 0x20) >> (5 - 2);
	70	u16 imm4_3 = (offset & 0x18) << (12 - 5);
	71	u16 imm2_1 = (offset & 0x6) << (12 - 10);
	72
	73	(u16 )location = ((u16 )location & 0xe383) \|
	74	imm8 \| imm7_6 \| imm5 \| imm4_3 \| imm2_1;
	75	return 0;
	76	}
	77
	78	static int apply_r_riscv_rvc_jump_rela(struct module me, u32 location,
	79	Elf_Addr v)
	80	{
7df85002	81	ptrdiff_t offset = (void )v - (void )location;
56ea45ae ZL	82	u16 imm11 = (offset & 0x800) << (12 - 11);
	83	u16 imm10 = (offset & 0x400) >> (10 - 8);
	84	u16 imm9_8 = (offset & 0x300) << (12 - 11);
	85	u16 imm7 = (offset & 0x80) >> (7 - 6);
	86	u16 imm6 = (offset & 0x40) << (12 - 11);
	87	u16 imm5 = (offset & 0x20) >> (5 - 2);
	88	u16 imm4 = (offset & 0x10) << (12 - 5);
	89	u16 imm3_1 = (offset & 0xe) << (12 - 10);
	90
	91	(u16 )location = ((u16 )location & 0xe003) \|
	92	imm11 \| imm10 \| imm9_8 \| imm7 \| imm6 \| imm5 \| imm4 \| imm3_1;
	93	return 0;
	94	}
	95
e2c0cdfb PD	96	static int apply_r_riscv_pcrel_hi20_rela(struct module me, u32 location,
	97	Elf_Addr v)
	98	{
7df85002	99	ptrdiff_t offset = (void )v - (void )location;
e2c0cdfb PD	100	s32 hi20;
	101
	102	if (offset != (s32)offset) {
	103	pr_err(
	104	"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
ef3a6140	105	me->name, (long long)v, location);
e2c0cdfb PD	106	return -EINVAL;
	107	}
	108
	109	hi20 = (offset + 0x800) & 0xfffff000;
	110	location = (location & 0xfff) \| hi20;
	111	return 0;
	112	}
	113
	114	static int apply_r_riscv_pcrel_lo12_i_rela(struct module me, u32 location,
	115	Elf_Addr v)
	116	{
	117	/*
	118	* v is the lo12 value to fill. It is calculated before calling this
	119	* handler.
	120	*/
	121	location = (location & 0xfffff) \| ((v & 0xfff) << 20);
	122	return 0;
	123	}
	124
	125	static int apply_r_riscv_pcrel_lo12_s_rela(struct module me, u32 location,
	126	Elf_Addr v)
	127	{
	128	/*
	129	* v is the lo12 value to fill. It is calculated before calling this
	130	* handler.
	131	*/
	132	u32 imm11_5 = (v & 0xfe0) << (31 - 11);
	133	u32 imm4_0 = (v & 0x1f) << (11 - 4);
	134
	135	location = (location & 0x1fff07f) \| imm11_5 \| imm4_0;
	136	return 0;
	137	}
	138
e7456e69 ZL	139	static int apply_r_riscv_hi20_rela(struct module me, u32 location,
	140	Elf_Addr v)
	141	{
	142	s32 hi20;
	143
	144	if (IS_ENABLED(CMODEL_MEDLOW)) {
	145	pr_err(
	146	"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
ef3a6140	147	me->name, (long long)v, location);
e7456e69 ZL	148	return -EINVAL;
	149	}
	150
	151	hi20 = ((s32)v + 0x800) & 0xfffff000;
	152	location = (location & 0xfff) \| hi20;
	153	return 0;
	154	}
	155
	156	static int apply_r_riscv_lo12_i_rela(struct module me, u32 location,
	157	Elf_Addr v)
	158	{
	159	/* Skip medlow checking because of filtering by HI20 already */
	160	s32 hi20 = ((s32)v + 0x800) & 0xfffff000;
	161	s32 lo12 = ((s32)v - hi20);
	162	location = (location & 0xfffff) \| ((lo12 & 0xfff) << 20);
	163	return 0;
	164	}
	165
	166	static int apply_r_riscv_lo12_s_rela(struct module me, u32 location,
	167	Elf_Addr v)
	168	{
	169	/* Skip medlow checking because of filtering by HI20 already */
	170	s32 hi20 = ((s32)v + 0x800) & 0xfffff000;
	171	s32 lo12 = ((s32)v - hi20);
	172	u32 imm11_5 = (lo12 & 0xfe0) << (31 - 11);
	173	u32 imm4_0 = (lo12 & 0x1f) << (11 - 4);
	174	location = (location & 0x1fff07f) \| imm11_5 \| imm4_0;
	175	return 0;
	176	}
	177
da975dd4 ZL	178	static int apply_r_riscv_got_hi20_rela(struct module me, u32 location,
	179	Elf_Addr v)
	180	{
7df85002	181	ptrdiff_t offset = (void )v - (void )location;
da975dd4 ZL	182	s32 hi20;
	183
	184	/* Always emit the got entry */
	185	if (IS_ENABLED(CONFIG_MODULE_SECTIONS)) {
	186	offset = module_emit_got_entry(me, v);
	187	offset = (void )offset - (void )location;
	188	} else {
	189	pr_err(
	190	"%s: can not generate the GOT entry for symbol = %016llx from PC = %p\n",
ef3a6140	191	me->name, (long long)v, location);
da975dd4 ZL	192	return -EINVAL;
	193	}
	194
	195	hi20 = (offset + 0x800) & 0xfffff000;
	196	location = (location & 0xfff) \| hi20;
	197	return 0;
	198	}
	199
e2c0cdfb PD	200	static int apply_r_riscv_call_plt_rela(struct module me, u32 location,
	201	Elf_Addr v)
	202	{
7df85002	203	ptrdiff_t offset = (void )v - (void )location;
e2c0cdfb PD	204	s32 fill_v = offset;
	205	u32 hi20, lo12;
	206
	207	if (offset != fill_v) {
da975dd4 ZL	208	/* Only emit the plt entry if offset over 32-bit range */
	209	if (IS_ENABLED(CONFIG_MODULE_SECTIONS)) {
	210	offset = module_emit_plt_entry(me, v);
	211	offset = (void )offset - (void )location;
	212	} else {
	213	pr_err(
	214	"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
ef3a6140	215	me->name, (long long)v, location);
da975dd4 ZL	216	return -EINVAL;
da975dd4 ZL	217	}
e2c0cdfb PD	218	}
	219
	220	hi20 = (offset + 0x800) & 0xfffff000;
	221	lo12 = (offset - hi20) & 0xfff;
	222	location = (location & 0xfff) \| hi20;
	223	(location + 1) = ((location + 1) & 0xfffff) \| (lo12 << 20);
	224	return 0;
	225	}
	226
e1910c72 ZL	227	static int apply_r_riscv_call_rela(struct module me, u32 location,
	228	Elf_Addr v)
	229	{
7df85002	230	ptrdiff_t offset = (void )v - (void )location;
e1910c72 ZL	231	s32 fill_v = offset;
	232	u32 hi20, lo12;
	233
	234	if (offset != fill_v) {
	235	pr_err(
	236	"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
ef3a6140	237	me->name, (long long)v, location);
e1910c72 ZL	238	return -EINVAL;
	239	}
	240
	241	hi20 = (offset + 0x800) & 0xfffff000;
	242	lo12 = (offset - hi20) & 0xfff;
	243	location = (location & 0xfff) \| hi20;
	244	(location + 1) = ((location + 1) & 0xfffff) \| (lo12 << 20);
	245	return 0;
	246	}
	247
e2c0cdfb PD	248	static int apply_r_riscv_relax_rela(struct module me, u32 location,
	249	Elf_Addr v)
	250	{
	251	return 0;
	252	}
	253
29e405cd ZL	254	static int apply_r_riscv_align_rela(struct module me, u32 location,
	255	Elf_Addr v)
	256	{
	257	pr_err(
	258	"%s: The unexpected relocation type 'R_RISCV_ALIGN' from PC = %p\n",
	259	me->name, location);
	260	return -EINVAL;
	261	}
	262
8e691b16 ZL	263	static int apply_r_riscv_add32_rela(struct module me, u32 location,
	264	Elf_Addr v)
	265	{
781c8fe2	266	(u32 )location += (u32)v;
8e691b16 ZL	267	return 0;
	268	}
	269
4aad074c ZL	270	static int apply_r_riscv_sub32_rela(struct module me, u32 location,
	271	Elf_Addr v)
	272	{
781c8fe2	273	(u32 )location -= (u32)v;
4aad074c ZL	274	return 0;
	275	}
	276
e2c0cdfb PD	277	static int (reloc_handlers_rela[]) (struct module me, u32 *location,
e2c0cdfb PD	278	Elf_Addr v) = {
77aa85de	279	[R_RISCV_32] = apply_r_riscv_32_rela,
e2c0cdfb PD	280	[R_RISCV_64] = apply_r_riscv_64_rela,
	281	[R_RISCV_BRANCH] = apply_r_riscv_branch_rela,
	282	[R_RISCV_JAL] = apply_r_riscv_jal_rela,
56ea45ae ZL	283	[R_RISCV_RVC_BRANCH] = apply_r_riscv_rcv_branch_rela,
56ea45ae ZL	284	[R_RISCV_RVC_JUMP] = apply_r_riscv_rvc_jump_rela,
e2c0cdfb PD	285	[R_RISCV_PCREL_HI20] = apply_r_riscv_pcrel_hi20_rela,
	286	[R_RISCV_PCREL_LO12_I] = apply_r_riscv_pcrel_lo12_i_rela,
	287	[R_RISCV_PCREL_LO12_S] = apply_r_riscv_pcrel_lo12_s_rela,
e7456e69 ZL	288	[R_RISCV_HI20] = apply_r_riscv_hi20_rela,
	289	[R_RISCV_LO12_I] = apply_r_riscv_lo12_i_rela,
	290	[R_RISCV_LO12_S] = apply_r_riscv_lo12_s_rela,
da975dd4	291	[R_RISCV_GOT_HI20] = apply_r_riscv_got_hi20_rela,
e2c0cdfb	292	[R_RISCV_CALL_PLT] = apply_r_riscv_call_plt_rela,
e1910c72	293	[R_RISCV_CALL] = apply_r_riscv_call_rela,
e2c0cdfb	294	[R_RISCV_RELAX] = apply_r_riscv_relax_rela,
29e405cd	295	[R_RISCV_ALIGN] = apply_r_riscv_align_rela,
8e691b16	296	[R_RISCV_ADD32] = apply_r_riscv_add32_rela,
4aad074c	297	[R_RISCV_SUB32] = apply_r_riscv_sub32_rela,
e2c0cdfb PD	298	};
	299
	300	int apply_relocate_add(Elf_Shdr sechdrs, const char strtab,
	301	unsigned int symindex, unsigned int relsec,
	302	struct module *me)
	303	{
	304	Elf_Rela rel = (void ) sechdrs[relsec].sh_addr;
	305	int (handler)(struct module me, u32 *location, Elf_Addr v);
	306	Elf_Sym *sym;
	307	u32 *location;
	308	unsigned int i, type;
	309	Elf_Addr v;
	310	int res;
	311
	312	pr_debug("Applying relocate section %u to %u\n", relsec,
	313	sechdrs[relsec].sh_info);
	314
	315	for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
	316	/* This is where to make the change */
	317	location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
	318	+ rel[i].r_offset;
	319	/* This is the symbol it is referring to */
	320	sym = (Elf_Sym *)sechdrs[symindex].sh_addr
	321	+ ELF_RISCV_R_SYM(rel[i].r_info);
	322	if (IS_ERR_VALUE(sym->st_value)) {
	323	/* Ignore unresolved weak symbol */
	324	if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
	325	continue;
	326	pr_warning("%s: Unknown symbol %s\n",
	327	me->name, strtab + sym->st_name);
	328	return -ENOENT;
	329	}
	330
	331	type = ELF_RISCV_R_TYPE(rel[i].r_info);
	332
	333	if (type < ARRAY_SIZE(reloc_handlers_rela))
	334	handler = reloc_handlers_rela[type];
	335	else
	336	handler = NULL;
	337
	338	if (!handler) {
	339	pr_err("%s: Unknown relocation type %u\n",
	340	me->name, type);
	341	return -EINVAL;
	342	}
	343
	344	v = sym->st_value + rel[i].r_addend;
	345
	346	if (type == R_RISCV_PCREL_LO12_I \|\| type == R_RISCV_PCREL_LO12_S) {
	347	unsigned int j;
	348
	349	for (j = 0; j < sechdrs[relsec].sh_size / sizeof(*rel); j++) {
7df85002	350	unsigned long hi20_loc =
e2c0cdfb PD	351	sechdrs[sechdrs[relsec].sh_info].sh_addr
e2c0cdfb PD	352	+ rel[j].r_offset;
da975dd4 ZL	353	u32 hi20_type = ELF_RISCV_R_TYPE(rel[j].r_info);
	354
	355	/* Find the corresponding HI20 relocation entry */
	356	if (hi20_loc == sym->st_value
	357	&& (hi20_type == R_RISCV_PCREL_HI20
	358	\|\| hi20_type == R_RISCV_GOT_HI20)) {
	359	s32 hi20, lo12;
e2c0cdfb PD	360	Elf_Sym *hi20_sym =
	361	(Elf_Sym *)sechdrs[symindex].sh_addr
	362	+ ELF_RISCV_R_SYM(rel[j].r_info);
7df85002	363	unsigned long hi20_sym_val =
e2c0cdfb PD	364	hi20_sym->st_value
e2c0cdfb PD	365	+ rel[j].r_addend;
da975dd4	366
e2c0cdfb	367	/* Calculate lo12 */
7df85002	368	size_t offset = hi20_sym_val - hi20_loc;
da975dd4 ZL	369	if (IS_ENABLED(CONFIG_MODULE_SECTIONS)
	370	&& hi20_type == R_RISCV_GOT_HI20) {
	371	offset = module_emit_got_entry(
	372	me, hi20_sym_val);
	373	offset = offset - hi20_loc;
	374	}
	375	hi20 = (offset + 0x800) & 0xfffff000;
	376	lo12 = offset - hi20;
e2c0cdfb	377	v = lo12;
da975dd4	378
e2c0cdfb PD	379	break;
	380	}
	381	}
	382	if (j == sechdrs[relsec].sh_size / sizeof(*rel)) {
	383	pr_err(
da975dd4	384	"%s: Can not find HI20 relocation information\n",
e2c0cdfb PD	385	me->name);
	386	return -EINVAL;
	387	}
	388	}
	389
	390	res = handler(me, location, v);
	391	if (res)
	392	return res;
	393	}
	394
	395	return 0;
	396	}