//--------------------------------------------------------------------------
static void read_dyninfo(ulong offset, ulong size)
{
qlseek(li, offset);
const int entsize = elf64 ? sizeof(Elf64_Dyn) : sizeof(Elf32_Dyn);
for(int i = 1; i < size; i += entsize )
{
Elf64_Dyn dyn;
if ( elf64 )
{
if(lread8bytes(li, &dyn.d_tag, mf) ||
lread8bytes(li, &dyn.d_un, mf)) errstruct();
}
else
{
ulong tag, val;
if(lread4bytes(li, &tag, mf) ||
lread4bytes(li, &val, mf)) errstruct();
dyn.d_tag = tag;
dyn.d_un = val;
}
switch ( WC4(dyn.d_tag) )
{
case DT_STRTAB:
dynstr_off = map_ea(dyn.d_un);
break;
case DT_SYMTAB:
dynsym_off = map_ea(dyn.d_un);
break;
case DT_REL:
dynrel_off = map_ea(dyn.d_un);
break;
case DT_RELA:
dynrela_off = map_ea(dyn.d_un);
break;
case DT_STRSZ:
dynstr_size = ulong(dyn.d_un);
break;
case DT_RELSZ:
dynrel_size = ulong(dyn.d_un);
break;
case DT_RELASZ:
dynrela_size = ulong(dyn.d_un);
break;
}
}
ulong off = dynstr_off;
if ( dynrel_off ) off = qmin(dynrel_off, off);
if ( dynrela_off ) off = qmin(dynrela_off, off);
dynsym_size = off - dynsym_off;
}
static void read_dyninfo(size_t offset, size_t size, dyninfo_t *dyninfo)
{
if ( size == 0 )
return;
qlseek(li, offset);
const int entsize = elf64 ? sizeof(Elf64_Dyn) : sizeof(Elf32_Dyn);
for ( int i=0; i < size; i+=entsize )
{
Elf64_Dyn d;
if ( elf64 )
{
if ( qlread(li, &d, sizeof(d)) != sizeof(d) )
errstruct();
if ( mf )
{
d.d_tag = swap64(d.d_tag);
d.d_un = swap64(d.d_un);
}
}
else
{
Elf32_Dyn d32;
if ( qlread(li, &d32, sizeof(d32)) != sizeof(d32) )
errstruct();
if ( mf )
{
d.d_tag = swap32(d32.d_tag);
d.d_un = swap32(d32.d_un.d_val);
}
else
{
d.d_tag = d32.d_tag;
d.d_un = d32.d_un.d_val;
}
}
dyninfo->push_back(d);
if ( d.d_tag == DT_NULL )
break;
}
}
//--------------------------------------------------------------------------
static void load_sht64(void)
{
register int i;
register Elf64_Shdr *sh;
qlseek(li, ulong(e_shoff));
for(i = 0, sh = shdr64; i < e_shnum; i++, sh++) {
if(lread4bytes(li, &sh->sh_name, mf) ||
lread4bytes(li, &sh->sh_type, mf) ||
lread8bytes(li, &sh->sh_flags, mf) ||
lread8bytes(li, &sh->sh_addr, mf) ||
lread8bytes(li, &sh->sh_offset, mf) ||
lread8bytes(li, &sh->sh_size, mf) ||
lread4bytes(li, &sh->sh_link, mf) ||
lread4bytes(li, &sh->sh_info, mf) ||
lread8bytes(li, &sh->sh_addralign, mf) ||
lread8bytes(li, &sh->sh_entsize, mf)) errstruct();
}
}
static void load_sht32(void)
{
register int i;
register Elf32_Shdr *sh;
qlseek(li, uint32(ehdr.e_shoff));
for(i = 0, sh = shdr32; i < ehdr.e_shnum; i++, sh++) {
if(lread4bytes(li, &sh->sh_name, mf) ||
lread4bytes(li, &sh->sh_type, mf) ||
lread4bytes(li, &sh->sh_flags, mf) ||
lread4bytes(li, (uint32*)&sh->sh_addr, mf) ||
lread4bytes(li, &sh->sh_offset, mf) ||
lread4bytes(li, &sh->sh_size, mf) ||
lread4bytes(li, &sh->sh_link, mf) ||
lread4bytes(li, &sh->sh_info, mf) ||
lread4bytes(li, &sh->sh_addralign, mf) ||
lread4bytes(li, &sh->sh_entsize, mf)) errstruct();
}
}
