/*
* Copyright (c) 2008 Jiri Svoboda
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - 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.
*/
/** @addtogroup rtld rtld
* @brief
* @{
*/
/**
* @file
*/
#include <stdio.h>
#include <stdlib.h>
#include <arch.h>
#include <elf_dyn.h>
#include <symbol.h>
#include <rtld.h>
void module_process_pre_arch(module_t *m)
{
elf_symbol_t *sym_table;
elf_symbol_t *sym_def;
elf_symbol_t *sym;
uint32_t gotsym;
uint32_t lgotno;
uint32_t *got;
char *str_tab;
int i, j;
uint32_t sym_addr;
module_t *dest;
got = (uint32_t *) m->dyn.plt_got;
sym_table = m->dyn.sym_tab;
str_tab = m->dyn.str_tab;
gotsym = m->dyn.arch.gotsym;
lgotno = m->dyn.arch.lgotno;
DPRINTF("** Relocate GOT entries **\n");
DPRINTF("MIPS base = 0x%x\n", m->dyn.arch.base);
/*
* Local entries.
*/
for (i = 0; i < gotsym; i++) {
/* FIXME: really subtract MIPS base? */
got[i] += m->bias - m->dyn.arch.base;
}
DPRINTF("sym_ent = %d, gotsym = %d\n", m->dyn.arch.sym_no, gotsym);
DPRINTF("lgotno = %d\n", lgotno);
/*
* Iterate over GOT-mapped symbol entries.
*/
for (j = gotsym; j < m->dyn.arch.sym_no; j++) {
/* Corresponding (global) GOT entry. */
i = lgotno + j - gotsym;
DPRINTF("relocate GOT entry %d\n", i);
// getchar();
// getchar();
sym = &sym_table[j];
if (ELF32_R_TYPE(sym->st_info) == STT_FUNC) {
if (sym->st_shndx == SHN_UNDEF) {
if (sym->st_value == 0) {
/* 1 */
} else {
if (got[i] == sym->st_value) {
/* 2 */
DPRINTF("(2)\n");
got[i] += m->bias - m->dyn.arch.base;
continue;
} else {
/* 3 */
DPRINTF("(3)\n");
got[i] = sym->st_value + m->bias - m->dyn.arch.base;
continue;
}
}
} else {
/* 2 */
DPRINTF("(2)\n");
got[i] += m->bias - m->dyn.arch.base;
continue;
}
} else {
if (sym->st_shndx == SHN_UNDEF ||
sym->st_shndx == SHN_COMMON) {
/* 1 */
} else {
/* 1 */
}
}
DPRINTF("(1) symbol name='%s'\n", str_tab + sym->st_name);
sym_def = symbol_def_find(str_tab + sym->st_name, m, &dest);
if (sym_def) {
sym_addr = symbol_get_addr(sym_def, dest);
DPRINTF("symbol definition found, addr=0x%x\n", sym_addr);
} else {
DPRINTF("symbol definition not found\n");
continue;
}
DPRINTF("write 0x%x at 0x%x\n", sym_addr, (uint32_t) &got[i]);
got[i] = sym_addr;
}
DPRINTF("** Done **\n");
}
/**
* Process (fixup) all relocations in a relocation table.
*/
void rel_table_process(module_t *m, elf_rel_t *rt, size_t rt_size)
{
int i;
size_t rt_entries;
size_t r_offset;
elf_word r_info;
unsigned rel_type;
elf_word sym_idx;
uintptr_t sym_addr;
elf_symbol_t *sym_table;
elf_symbol_t *sym;
uint32_t *r_ptr;
uint16_t *r_ptr16;
char *str_tab;
elf_symbol_t *sym_def;
module_t *dest;
uint32_t *got;
uint32_t gotsym;
uint32_t lgotno;
uint32_t ea;
DPRINTF("parse relocation table\n");
sym_table = m->dyn.sym_tab;
rt_entries = rt_size / sizeof(elf_rela_t);
str_tab = m->dyn.str_tab;
got = (uint32_t *) m->dyn.plt_got;
gotsym = m->dyn.arch.gotsym;
lgotno = m->dyn.arch.lgotno;
DPRINTF("got=0x%lx, gotsym=%d\n", (uintptr_t) got, gotsym);
DPRINTF("address: 0x%x, entries: %d\n", (uintptr_t)rt, rt_entries);
for (i = 0; i < rt_entries; ++i) {
DPRINTF("symbol %d: ", i);
r_offset = rt[i].r_offset;
r_info = rt[i].r_info;
sym_idx = ELF32_R_SYM(r_info);
sym = &sym_table[sym_idx];
DPRINTF("name '%s', value 0x%x, size 0x%x\n",
str_tab + sym->st_name,
sym->st_value,
sym->st_size);
rel_type = ELF32_R_TYPE(r_info);
r_ptr = (uint32_t *)(r_offset + m->bias);
r_ptr16 = (uint16_t *)(r_offset + m->bias);
if (sym->st_name != 0) {
DPRINTF("rel_type: %x, rel_offset: 0x%x\n", rel_type, r_offset);
DPRINTF("dest name: '%s'\n", dest->dyn.soname);
DPRINTF("dest bias: 0x%x\n", dest->bias);
if (sym_def) {
sym_addr = symbol_get_addr(sym_def, dest);
DPRINTF("symbol definition found, addr=0x%x\n", sym_addr);
} else {
DPRINTF("symbol definition not found\n");
continue;
}
}
DPRINTF("switch(%u)\n", rel_type);
switch (rel_type) {
case R_MIPS_NONE:
DPRINTF("Ignoring R_MIPS_NONE\n");
break;
case R_MIPS_REL32:
DPRINTF("fixup R_MIPS_REL32 (r - ea + s)\n");
if (sym_idx < gotsym)
ea = sym_addr;
else
ea = got[lgotno + sym_idx - gotsym];
*r_ptr += sym_addr - ea;
DPRINTF("p = 0x%x, val := 0x%x\n", (uint32_t) r_ptr,
*r_ptr);
// getchar();
break;
/* No other non-TLS relocation types should appear. */
case R_MIPS_TLS_DTPMOD32:
/*
* We can ignore this as long as the only module
* with TLS variables is libc.so.
*/
DPRINTF("Ignoring R_MIPS_DTPMOD32\n");
break;
default:
printf("Error: Unknown relocation type %d.\n", rel_type);
break;
}
}
}
void rela_table_process(module_t *m, elf_rela_t *rt, size_t rt_size)
{
/* Unused */
(void)m; (void)rt; (void)rt_size;
}
/** @}
*/