/*
* 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 <arch.h>
#include <elf_dyn.h>
#include <symbol.h>
#include <rtld.h>
#include <smc.h>
#define __L(ptr) ((uint32_t)(ptr) & 0x0000ffff)
#define __HA(ptr) ((uint32_t)(ptr) >> 16)
// ldis r11, .PLTtable@ha
static inline uint32_t _ldis(unsigned rD, uint16_t imm16)
{
/* Special case of addis: ldis rD,SIMM == addis rD,0,SIMM */
return 0x3C000000 | (rD << 21) | imm16;
}
static inline uint32_t _lwz(unsigned rD, uint16_t disp16, unsigned rA)
{
return 0x80000000 | (rD << 21) | (rA << 16) | disp16;
}
static inline uint32_t _mtctr(unsigned rS)
{
/* mtctr rD == mtspr 9, rD */
return 0x7c0003a6 | (rS << 21) | (9/*CTR*/ << 16);
}
static inline uint32_t _bctr()
{
/* bcctr 0x1f, 0 */
return 0x4c000420 | (0x1f/*always*/ << 21);
}
/* branch */
static inline uint32_t _b(uint32_t *addr, uint32_t *location)
{
uint32_t raddr = ((uint32_t)addr - (uint32_t)location) & 0x03fffffc;
return 0x48000000 | raddr;
}
/*
* Fill in PLT
*/
void module_process_pre_arch(module_t *m)
{
uint32_t *plt;
uint32_t *_plt_ent;
plt = m->dyn.plt_got;
if (!plt) {
/* Module has no PLT */
return;
}
// PLT entries start here. However, each occupies 2 words
_plt_ent = plt + 18;
// By definition of the ppc ABI, there's 1:1 correspondence
// between JMPREL entries and PLT entries
unsigned plt_n = m->dyn.plt_rel_sz / sizeof(elf_rela_t);
uint32_t *_plt_table;
uint32_t *_plt_call;
uint32_t *_plt_resolve;
_plt_resolve = plt;
_plt_call = plt + 6;
_plt_table = plt + 18 + plt_n;
/* .PLTcall: */
plt[6] = _ldis(11, __HA(_plt_table)); // ldis r11, .PLTtable@ha
plt[7] = _lwz(11, __L(_plt_table), 11); // lwz r11, .PLTtable@l(r11)
plt[8] = _mtctr(11); // mtctr r11
plt[9] = _bctr();
/* .PLTi, i = 0..N-1 */
// kputint(-4);
/* for (i = 0; i < plt_n; ++i) {
//_plt_table[i] == function address;
plt[18+i] = _b(_plt_call, &plt[18+i]); // b .PLTcall
}*/
}
void rel_table_process(module_t *m, elf_rel_t *rt, size_t rt_size)
{
/* Unused */
(void)m; (void)rt; (void)rt_size;
}
/**
* Process (fixup) all relocations in a relocation table.
*/
void rela_table_process(module_t *m, elf_rela_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;
uintptr_t r_addend;
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 *plt;
uint32_t *_plt_table;
uint32_t *_plt_ent;
uint32_t plt_n;
uint32_t pidx;
uint32_t t_addr;
uint32_t sym_size;
plt = m->dyn.plt_got;
plt_n = m->dyn.plt_rel_sz / sizeof(elf_rela_t);
_plt_ent = plt+ 18;
_plt_table = plt + 18 + plt_n;
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;
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;
r_addend = rt[i].r_addend;
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);
sym_def = symbol_def_find(str_tab + sym->st_name,
m, &dest);
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;
}
}
switch (rel_type) {
case R_PPC_ADDR16_LO:
DPRINTF("fixup R_PPC_ADDR16_LO (#lo(s+a))\n");
*r_ptr16 = (sym_addr + r_addend) & 0xffff;
break;
case R_PPC_ADDR16_HI:
DPRINTF("fixup R_PPC_ADDR16_HI (#hi(s+a))\n");
*r_ptr16 = (sym_addr + r_addend) >> 16;
break;
case R_PPC_ADDR16_HA:
DPRINTF("fixup R_PPC_ADDR16_HA (#ha(s+a))\n");
t_addr = sym_addr + r_addend;
*r_ptr16 = (t_addr >> 16) + ((t_addr & 0x8000) ? 1 : 0);
break;
case R_PPC_JMP_SLOT:
DPRINTF("fixup R_PPC_JMP_SLOT (b+v)\n");
pidx = (r_ptr - _plt_ent) / 2;
if (pidx >= plt_n) {
DPRINTF("error: proc index out of range\n");
//kputint(0xee00ee0ee00);
while(1);
}
//_plt_table[pidx] = sym_addr;
plt[18+2*pidx] = _b((void *)sym_addr, &plt[18+2*pidx]);
break;
case R_PPC_ADDR32:
DPRINTF("fixup R_PPC_ADDR32 (b+v+a)\n");
*r_ptr = r_addend + sym_addr;
break;
case R_PPC_COPY:
/*
* Copy symbol data from shared object to specified
* location.
*/
DPRINTF("fixup R_PPC_COPY (s)\n");
sym_size = sym->st_size;
if (sym_size != sym_def->st_size) {
printf("warning: mismatched symbol sizes\n"); /* Take the lower value. */
if (sym_size > sym_def->st_size)
sym_size = sym_def->st_size;
}
memcpy(r_ptr
, (const void *)sym_addr
, sym_size
); break;
case R_PPC_RELATIVE:
DPRINTF("fixup R_PPC_RELATIVE (b+a)\n");
*r_ptr = r_addend + m->bias;
break;
case R_PPC_REL24:
// printf("ignore R_PPC_REL24 at 0x%04x\n", (uintptr_t) r_ptr);
*r_ptr = (sym_addr + r_addend - (uint32_t)r_ptr) >> 2;
DPRINTF("fixup R_PPC_REL24 (s+a-p)>>2\n");
/*TODO*/
break;
default:
printf("unknown relocation type %d\n", rel_type
); break;
}
}
/*
* Synchronize the used portion of PLT. This is necessary since
* we are writing instructions.
*/
smc_coherence(&plt[18], plt_n * 2 * sizeof(uint32_t));
}
/** @}
*/