[dragonfly.git] / sys / platform / pc64 / x86_64 / elf_machdep.c

/*-
 * Copyright 1996-1998 John D. Polstra.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $FreeBSD: src/sys/i386/i386/elf_machdep.c,v 1.8 1999/12/21 11:14:02 eivind Exp $
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/linker.h>
#include <machine/elf.h>

/* Process one elf relocation with addend. */
static int
elf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,
    int type, int local, elf_lookup_fn lookup)
{
	Elf64_Addr *where, val;
	Elf32_Addr *where32, val32;
	Elf_Addr addr;
	Elf_Addr addend;
	Elf_Size rtype, symidx;
	const Elf_Rel *rel;
	const Elf_Rela *rela;

	switch (type) {
	case ELF_RELOC_REL:
		rel = (const Elf_Rel *)data;
		where = (Elf_Addr *) (relocbase + rel->r_offset);
		rtype = ELF_R_TYPE(rel->r_info);
		symidx = ELF_R_SYM(rel->r_info);
		/* Addend is 32 bit on 32 bit relocs */
		switch (rtype) {
		case R_X86_64_PC32:
		case R_X86_64_32:
		case R_X86_64_32S:
			addend = *(Elf32_Addr *)where;
			break;
		default:
			addend = *where;
			break;
		}
		break;
	case ELF_RELOC_RELA:
		rela = (const Elf_Rela *)data;
		where = (Elf_Addr *) (relocbase + rela->r_offset);
		addend = rela->r_addend;
		rtype = ELF_R_TYPE(rela->r_info);
		symidx = ELF_R_SYM(rela->r_info);
		break;
	default:
		panic("unknown reloc type %d\n", type);
	}

	switch (rtype) {

		case R_X86_64_NONE:	/* none */
			break;

		case R_X86_64_64:		/* S + A */
			if (lookup(lf, symidx, 1, &addr))
				return -1;
			val = addr + addend;
			if (*where != val)
				*where = val;
			break;

		case R_X86_64_PC32:	/* S + A - P */
			if (lookup(lf, symidx, 1, &addr))
				return -1;
			where32 = (Elf32_Addr *)where;
			val32 = (Elf32_Addr)(addr + addend - (Elf_Addr)where);
			if (*where32 != val32)
				*where32 = val32;
			break;

		case R_X86_64_32:	/* S + A zero extend */
		case R_X86_64_32S:	/* S + A sign extend */
			if (lookup(lf, symidx, 1, &addr))
				return -1;
			val32 = (Elf32_Addr)(addr + addend);
			where32 = (Elf32_Addr *)where;
			if (*where32 != val32)
				*where32 = val32;
			break;

		case R_X86_64_COPY:	/* none */
			/*
			 * There shouldn't be copy relocations in kernel
			 * objects.
			 */
			kprintf("kldload: unexpected R_COPY relocation\n");
			return -1;
			break;

		case R_X86_64_GLOB_DAT:	/* S */
		case R_X86_64_JMP_SLOT:	/* XXX need addend + offset */
			if (lookup(lf, symidx, 1, &addr))
				return -1;
			if (*where != addr)
				*where = addr;
			break;

		case R_X86_64_RELATIVE:	/* B + A */
			addr = relocbase + addend;
			val = addr;
			if (*where != val)
				*where = val;
			break;

		default:
			kprintf("kldload: unexpected relocation type %ld\n",
			       rtype);
			return -1;
	}
	return(0);
}

int
elf_reloc(linker_file_t lf, Elf_Addr relocbase, const void *data, int type,
    elf_lookup_fn lookup)
{

	return (elf_reloc_internal(lf, relocbase, data, type, 0, lookup));
}

int
elf_reloc_local(linker_file_t lf, Elf_Addr relocbase, const void *data,
    int type, elf_lookup_fn lookup)
{

	return (elf_reloc_internal(lf, relocbase, data, type, 1, lookup));
}
Commit	Line	Data
d7f50089 YY	1	/*-
	2	* Copyright 1996-1998 John D. Polstra.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	*
	14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	17	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*
	25	* $FreeBSD: src/sys/i386/i386/elf_machdep.c,v 1.8 1999/12/21 11:14:02 eivind Exp $
d7f50089 YY	26	*/
	27
	28	#include <sys/param.h>
	29	#include <sys/systm.h>
	30	#include <sys/linker.h>
	31	#include <machine/elf.h>
	32
	33	/* Process one elf relocation with addend. */
1c0e3286 SS	34	static int
	35	elf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,
	36	int type, int local, elf_lookup_fn lookup)
d7f50089	37	{
1c0e3286 SS	38	Elf64_Addr *where, val;
1c0e3286 SS	39	Elf32_Addr *where32, val32;
d7f50089 YY	40	Elf_Addr addr;
d7f50089 YY	41	Elf_Addr addend;
1c0e3286	42	Elf_Size rtype, symidx;
d7f50089 YY	43	const Elf_Rel *rel;
	44	const Elf_Rela *rela;
	45
	46	switch (type) {
	47	case ELF_RELOC_REL:
	48	rel = (const Elf_Rel *)data;
	49	where = (Elf_Addr *) (relocbase + rel->r_offset);
d7f50089	50	rtype = ELF_R_TYPE(rel->r_info);
1c0e3286 SS	51	symidx = ELF_R_SYM(rel->r_info);
	52	/* Addend is 32 bit on 32 bit relocs */
	53	switch (rtype) {
	54	case R_X86_64_PC32:
	55	case R_X86_64_32:
	56	case R_X86_64_32S:
	57	addend = (Elf32_Addr )where;
	58	break;
	59	default:
	60	addend = *where;
	61	break;
	62	}
d7f50089 YY	63	break;
	64	case ELF_RELOC_RELA:
	65	rela = (const Elf_Rela *)data;
	66	where = (Elf_Addr *) (relocbase + rela->r_offset);
	67	addend = rela->r_addend;
	68	rtype = ELF_R_TYPE(rela->r_info);
1c0e3286	69	symidx = ELF_R_SYM(rela->r_info);
d7f50089 YY	70	break;
	71	default:
	72	panic("unknown reloc type %d\n", type);
	73	}
	74
	75	switch (rtype) {
	76
	77	case R_X86_64_NONE: /* none */
	78	break;
	79
	80	case R_X86_64_64: /* S + A */
1c0e3286	81	if (lookup(lf, symidx, 1, &addr))
d7f50089	82	return -1;
1c0e3286 SS	83	val = addr + addend;
	84	if (*where != val)
	85	*where = val;
d7f50089 YY	86	break;
	87
	88	case R_X86_64_PC32: /* S + A - P */
1c0e3286	89	if (lookup(lf, symidx, 1, &addr))
d7f50089	90	return -1;
1c0e3286 SS	91	where32 = (Elf32_Addr *)where;
	92	val32 = (Elf32_Addr)(addr + addend - (Elf_Addr)where);
	93	if (*where32 != val32)
	94	*where32 = val32;
	95	break;
	96
	97	case R_X86_64_32: /* S + A zero extend */
	98	case R_X86_64_32S: /* S + A sign extend */
	99	if (lookup(lf, symidx, 1, &addr))
d7f50089	100	return -1;
1c0e3286 SS	101	val32 = (Elf32_Addr)(addr + addend);
	102	where32 = (Elf32_Addr *)where;
	103	if (*where32 != val32)
	104	*where32 = val32;
d7f50089 YY	105	break;
	106
	107	case R_X86_64_COPY: /* none */
	108	/*
	109	* There shouldn't be copy relocations in kernel
	110	* objects.
	111	*/
	112	kprintf("kldload: unexpected R_COPY relocation\n");
	113	return -1;
	114	break;
	115
	116	case R_X86_64_GLOB_DAT: /* S */
1c0e3286 SS	117	case R_X86_64_JMP_SLOT: /* XXX need addend + offset */
1c0e3286 SS	118	if (lookup(lf, symidx, 1, &addr))
d7f50089	119	return -1;
d7f50089 YY	120	if (*where != addr)
	121	*where = addr;
	122	break;
	123
	124	case R_X86_64_RELATIVE: /* B + A */
	125	addr = relocbase + addend;
1c0e3286 SS	126	val = addr;
	127	if (*where != val)
	128	*where = val;
d7f50089 YY	129	break;
	130
	131	default:
1c0e3286	132	kprintf("kldload: unexpected relocation type %ld\n",
d7f50089 YY	133	rtype);
	134	return -1;
	135	}
	136	return(0);
	137	}
1c0e3286 SS	138
	139	int
	140	elf_reloc(linker_file_t lf, Elf_Addr relocbase, const void *data, int type,
	141	elf_lookup_fn lookup)
	142	{
	143
	144	return (elf_reloc_internal(lf, relocbase, data, type, 0, lookup));
	145	}
	146
	147	int
	148	elf_reloc_local(linker_file_t lf, Elf_Addr relocbase, const void *data,
	149	int type, elf_lookup_fn lookup)
	150	{
	151
	152	return (elf_reloc_internal(lf, relocbase, data, type, 1, lookup));
	153	}