/*	$OpenBSD: rtld_machine.c,v 1.35 2022/01/08 06:49:42 guenther Exp $ */

/*
 * Copyright (c) 1998-2004 Opsycon AB, Sweden.
 *
 * 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.
 *
 */

#define _DYN_LOADER

#include <sys/types.h>
#include <sys/exec_elf.h>
#include <sys/syscall.h>
#include <sys/unistd.h>

#include <machine/reloc.h>

#include "util.h"
#include "resolve.h"

int64_t pcookie __attribute__((section(".openbsd.randomdata"))) __dso_hidden;

static inline void
_dl_reloc_ent(Elf_Addr r_addr, Elf_Addr value)
{
	if ((r_addr & 7) == 0)
		*(u_int64_t *)r_addr += value;
	else {
		/*
		 * XXX Handle non aligned relocs. .eh_frame
		 * XXX in libstdc++ seems to have them...
		 */
		u_int64_t robj;

		_dl_bcopy((char *)r_addr, &robj, sizeof(robj));
		robj += value;
		_dl_bcopy(&robj, (char *)r_addr, sizeof(robj));
	}
}

int
_dl_md_reloc(elf_object_t *object, int rel, int relsz)
{
	int	i;
	int	numrel;
	int	fails = 0;
	Elf_Addr loff;
	Elf_Rel  *relocs;
	const Elf_Sym *sym, *this;
	Elf_Addr prev_value = 0;
	const Elf_Sym *prev_sym = NULL;

	loff = object->obj_base;
	numrel = object->Dyn.info[relsz] / sizeof(Elf_Rel);
	relocs = (Elf_Rel *)(object->Dyn.info[rel]);

	if (relocs == NULL)
		return 0;

	DL_DEB(("relocating %d\n", numrel));
	for (i = 0; i < numrel; i++, relocs++) {
		Elf_Addr r_addr = relocs->r_offset + loff;
		const char *symn;

		if (ELF_R_SYM(relocs->r_info) == 0xffffff)
			continue;

		sym = object->dyn.symtab;
		sym += ELF_R_SYM(relocs->r_info);
		symn = object->dyn.strtab + sym->st_name;

		this = NULL;
		if (ELF_R_SYM(relocs->r_info)) {
			if (sym == prev_sym)
				this = sym;	/* XXX non-NULL */
			else if (!(ELF_ST_BIND(sym->st_info) == STB_LOCAL &&
			    ELF_ST_TYPE (sym->st_info) == STT_NOTYPE)) {
				struct sym_res sr;

				sr = _dl_find_symbol(symn,
				    SYM_SEARCH_ALL | SYM_WARNNOTFOUND | SYM_PLT,
				    sym, object);

				if (sr.sym == NULL) {
					if (ELF_ST_BIND(sym->st_info) !=
					    STB_WEAK)
						fails++;
					continue;
				}
				prev_sym = sym;
				prev_value = sr.obj->obj_base +
				    sr.sym->st_value;
				this = sym;	/* XXX non-NULL */
			}
		}

		switch (ELF_R_TYPE(relocs->r_info)) {
		case R_MIPS_REL32_64:
			if (ELF_ST_BIND(sym->st_info) == STB_LOCAL &&
			    (ELF_ST_TYPE(sym->st_info) == STT_SECTION ||
			    ELF_ST_TYPE(sym->st_info) == STT_NOTYPE) )
				_dl_reloc_ent(r_addr, loff + sym->st_value);
			else if (this)
				_dl_reloc_ent(r_addr, prev_value);
			break;

		case R_MIPS_NONE:
			break;

		default:
			_dl_die("unsupported relocation '%llu'",
			    ELF_R_TYPE(relocs->r_info));
		}
	}

	DL_DEB(("done %d fails\n", fails));
	return fails;
}

extern void _dl_bind_start(void);

/*
 *	Relocate the Global Offset Table (GOT). Currently we don't
 *	do lazy evaluation here because the GNU linker doesn't
 *	follow the ABI spec which says that if an external symbol
 *	is referenced by other relocations than CALL16 and 26 it
 *	should not be given a stub and have a zero value in the
 *	symbol table. By not doing so, we can't use pointers to
 *	external functions and use them in comparisons...
 */
int
_dl_md_reloc_got(elf_object_t *object, int lazy)
{
	int	i, n;
	Elf_Addr loff;
	Elf_Addr *gotp;
	const Elf_Sym  *symp;
	const char *strt;

	if (object->status & STAT_GOT_DONE)
		return 0;

	loff = object->obj_base;
	strt = object->dyn.strtab;
	gotp = object->dyn.pltgot;
	n = object->Dyn.info[DT_MIPS_LOCAL_GOTNO - DT_LOPROC + DT_NUM];

	DL_DEB(("loff: 0x%lx\n", (unsigned long)loff));
	/*
	 *  Set up pointers for run time (lazy) resolving.
	 */
	gotp[0] = (long)_dl_bind_start;
	gotp[1] = (long)object;

	/*  First do all local references. */
	for (i = 2; i < n; i++) {
		gotp[i] += loff;
	}

	gotp += n;

	symp =  object->dyn.symtab;
	symp += object->Dyn.info[DT_MIPS_GOTSYM - DT_LOPROC + DT_NUM];
	n =  object->Dyn.info[DT_MIPS_SYMTABNO - DT_LOPROC + DT_NUM] -
	    object->Dyn.info[DT_MIPS_GOTSYM - DT_LOPROC + DT_NUM];

	/*
	 *  Then do all global references according to the ABI.
	 *  Quickstart is not yet implemented.
	 */
	while (n--) {
		const char *symn = strt + symp->st_name;
		struct sym_res sr;

		if (symp->st_shndx == SHN_UNDEF &&
		    ELF_ST_TYPE(symp->st_info) == STT_FUNC) {
			if (symp->st_value == 0 || !lazy) {
				sr = _dl_find_symbol(symn,
				    SYM_SEARCH_ALL|SYM_NOWARNNOTFOUND|SYM_PLT,
				    symp, object);
				if (sr.sym)
					*gotp = sr.sym->st_value +
					    sr.obj->obj_base;
			} else
				*gotp = symp->st_value + loff;
		} else if (symp->st_shndx == SHN_COMMON ||
			symp->st_shndx == SHN_UNDEF) {
			sr = _dl_find_symbol(symn,
			    SYM_SEARCH_ALL|SYM_NOWARNNOTFOUND|SYM_PLT,
			    symp, object);
			if (sr.sym)
				*gotp = sr.sym->st_value + sr.obj->obj_base;
		} else if ((ELF_ST_TYPE(symp->st_info) == STT_FUNC &&
			symp->st_value != *gotp) ||
			ELF_ST_VISIBILITY(symp->st_other) == STV_PROTECTED) {
			*gotp += loff;
		} else {	/* Resolve all others immediately */
			sr = _dl_find_symbol(symn,
			    SYM_SEARCH_ALL|SYM_NOWARNNOTFOUND|SYM_PLT,
			    symp, object);
			if (sr.sym)
				*gotp = sr.sym->st_value + sr.obj->obj_base;
			else
				*gotp = symp->st_value + loff;
		}
		gotp++;
		symp++;
	}
	object->status |= STAT_GOT_DONE;

	return 0;
}

Elf_Addr
_dl_bind(elf_object_t *object, int symidx)
{
	Elf_Addr *gotp = object->dyn.pltgot;
	struct sym_res sr;
	const Elf_Sym *sym;
	const char *symn;
	int64_t cookie = pcookie;
	struct {
		struct __kbind param;
		Elf_Addr newval;
	} buf;
	int n;

	sym = object->dyn.symtab;
	sym += symidx;
	symn = object->dyn.strtab + sym->st_name;
	n = object->Dyn.info[DT_MIPS_LOCAL_GOTNO - DT_LOPROC + DT_NUM] -
	    object->Dyn.info[DT_MIPS_GOTSYM - DT_LOPROC + DT_NUM];

	sr = _dl_find_symbol(symn, SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_PLT,
	    sym, object);
	if (sr.sym == NULL)
		_dl_die("lazy binding failed!");

	buf.newval = sr.obj->obj_base + sr.sym->st_value;

	if (__predict_false(sr.obj->traced) && _dl_trace_plt(sr.obj, symn))
		return buf.newval;

	buf.param.kb_addr = &gotp[n + symidx];
	buf.param.kb_size = sizeof(Elf_Addr);

	/* directly code the syscall, so that it's actually inline here */
	{
		register long syscall_num __asm("v0") = SYS_kbind;
		register void *arg1 __asm("a0") = &buf;
		register long  arg2 __asm("a1") = sizeof(buf);
		register long  arg3 __asm("a2") = cookie;

		__asm volatile("syscall" : "+r" (syscall_num)
		    : "r" (arg1), "r" (arg2), "r" (arg3)
		    : "v1", "a3", "memory");
	}

	return buf.newval;
}