/* $NetBSD: rmreloc.c,v 1.3 2007/03/04 05:59:07 christos Exp $ */ /* * Copyright 1996 John D. Polstra. * Copyright 1996 Matt Thomas * Copyright 2002 Charles M. Hannum * 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. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Polstra. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * 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. */ /* * rmreloc.c - relocate an ELFish RISC OS relocatable module. */ /* * This code is a heavily hacked version of parts of: * lib/libexec/ld.elf_so/headers.c * lib/libexec/ld.elf_so/arch/arm/mdreloc.c * * At present it only deals with DT_REL tables containing R_ARM_NONE * and R_ARM_RELATIVE relocations, because those are all that my * linker emits. More can be added as needed. Note that this has to * handle relocating already-relocated code, e.g. after *RMTidy, so * most relocations have to reference oldbase, which ld.elf_so just * assumes is zero. There may be a cleverer way to do this. */ #include #include #include #define ELFSIZE 32 #include #include os_error *relocate_self(Elf_Dyn *, void *, void *); #define assert(x) /* nothing */ /* * While relocating ourselves, we must not refer to any global variables. * This includes _DYNAMIC -- the startup code finds it for us and passes * it to us along with the base address of the module. */ typedef struct { void * relocbase; /* Reloc const = mapbase - *vaddrbase */ Elf_Dyn *dynamic; /* Dynamic section */ const Elf_Rel *rel; /* Relocation entries */ const Elf_Rel *rellim; /* Limit of Relocation entries */ } Obj_Entry; #define rdbg(x) /* nothing */ /* * It is possible for the compiler to emit relocations for unaligned data. * We handle this situation with these inlines. */ #define RELOC_ALIGNED_P(x) \ (((uintptr_t)(x) & (sizeof(void *) - 1)) == 0) static inline Elf_Addr load_ptr(void *where) { Elf_Addr res; memcpy(&res, where, sizeof(res)); return (res); } static inline void store_ptr(void *where, Elf_Addr val) { memcpy(where, &val, sizeof(val)); } static struct os_error bad_reloc = { 0, "Unhandled ELF redirection" }; os_error * relocate_self(Elf_Dyn *dynamic, void *oldbase, void *newbase) { Elf_Dyn *dynp; Obj_Entry o = { 0 }; Obj_Entry *obj; const Elf_Rel *rel; Elf_Addr relsz = 0; obj = &o; obj->dynamic = dynamic; obj->relocbase = newbase; for (dynp = obj->dynamic; dynp->d_tag != DT_NULL; ++dynp) { switch (dynp->d_tag) { case DT_REL: obj->rel = (const Elf_Rel *) (obj->relocbase + dynp->d_un.d_ptr); break; case DT_RELSZ: relsz = dynp->d_un.d_val; break; case DT_RELENT: assert(dynp->d_un.d_val == sizeof(Elf_Rel)); break; } } obj->rellim = (const Elf_Rel *)((void *)obj->rel + relsz); for (rel = obj->rel; rel < obj->rellim; rel++) { Elf_Addr *where; Elf_Addr tmp; where = (Elf_Addr *)(obj->relocbase + rel->r_offset); switch (ELF_R_TYPE(rel->r_info)) { case R_TYPE(NONE): break; case R_TYPE(RELATIVE): /* word32 B + A */ if (__predict_true(RELOC_ALIGNED_P(where))) { tmp = *where + (Elf_Addr)obj->relocbase - (Elf_Addr)oldbase; *where = tmp; } else { tmp = load_ptr(where) + (Elf_Addr)obj->relocbase - (Elf_Addr)oldbase; store_ptr(where, tmp); } rdbg(("RELATIVE in %s --> %p", obj->path, (void *)tmp)); break; default: return &bad_reloc; } } return NULL; }