void InternalApplyString(LispEnvironment& aEnvironment, LispPtr& aResult,
const LispString* aOperator,LispPtr& aArgs)
{
if (!InternalIsString(aOperator))
throw LispErrNotString();
LispObject *head =
LispAtom::New(aEnvironment, *SymbolName(aEnvironment, *aOperator));
head->Nixed() = (aArgs);
LispPtr body(LispSubList::New(head));
aEnvironment.iEvaluator->Eval(aEnvironment, aResult, body);
}
void CELF<ELFSTRUCTURES>::Dump(int options) {
if (options & DUMP_FILEHDR) {
// File header
printf("\nDump of ELF file %s", FileName);
printf("\n-----------------------------------------------");
printf("\nFile size: %i", GetDataSize());
printf("\nFile header:");
printf("\nFile class: %s, Data encoding: %s, ELF version %i, ABI: %s, ABI version %i",
Lookup(ELFFileClassNames, FileHeader.e_ident[EI_CLASS]),
Lookup(ELFDataEncodeNames, FileHeader.e_ident[EI_DATA]),
FileHeader.e_ident[EI_VERSION],
Lookup(ELFABINames, FileHeader.e_ident[EI_OSABI]),
FileHeader.e_ident[EI_ABIVERSION]);
printf("\nFile type: %s, Machine: %s, version: %i",
Lookup(ELFFileTypeNames, FileHeader.e_type),
Lookup(ELFMachineNames, FileHeader.e_machine),
FileHeader.e_version);
printf("\nNumber of sections: %2i, Processor flags: 0x%X",
NSections, FileHeader.e_flags);
}
if (options & DUMP_SECTHDR) {
// Dump section headers
printf("\n\nSection headers:");
for (uint32 sc = 0; sc < NSections; sc++) {
// Get copy of 32-bit header or converted 64-bit header
TELF_SectionHeader sheader = SectionHeaders[sc];
int entrysize = (uint32)(sheader.sh_entsize);
uint32 namei = sheader.sh_name;
if (namei >= SecStringTableLen) {err.submit(2112); break;}
printf("\n%2i Name: %-18s Type: %s", sc, SecStringTable + namei,
Lookup(ELFSectionTypeNames, sheader.sh_type));
if (sheader.sh_flags) {
printf("\n Flags: 0x%X:", uint32(sheader.sh_flags));
for (int fi = 1; fi < (1 << 30); fi <<= 1) {
if (uint32(sheader.sh_flags) & fi) {
printf(" %s", Lookup(ELFSectionFlagNames,fi));
}
}
}
if (sheader.sh_addr) {
printf("\n Address: 0x%X", uint32(sheader.sh_addr));
}
if (sheader.sh_offset || sheader.sh_size) {
printf("\n FileOffset: 0x%X, Size: 0x%X",
uint32(sheader.sh_offset), uint32(sheader.sh_size));
}
if (sheader.sh_addralign) {
printf("\n Alignment: 0x%X", uint32(sheader.sh_addralign));
}
if (sheader.sh_entsize) {
printf("\n Entry size: 0x%X", uint32(sheader.sh_entsize));
switch (sheader.sh_type) {
case SHT_DYNAMIC:
printf("\n String table: %i", sheader.sh_link);
break;
case SHT_HASH:
printf("\n Symbol table: %i", sheader.sh_link);
break;
case SHT_REL: case SHT_RELA:
printf("\n Symbol table: %i, Reloc. section: %i",
sheader.sh_link, sheader.sh_info);
break;
case SHT_SYMTAB: case SHT_DYNSYM:
printf("\n Symbol string table: %i, First global symbol: %i",
sheader.sh_link, sheader.sh_info);
break;
default:
if (sheader.sh_link) {
printf("\n Link: %i", sheader.sh_link);
}
if (sheader.sh_info) {
printf("\n Info: %i", sheader.sh_info);
}
}
}
if (sheader.sh_type == SHT_STRTAB && (options & DUMP_STRINGTB)) {
// Print string table
printf("\n String table:");
char * p = Buf() + uint32(sheader.sh_offset) + 1;
uint32 nread = 1, len;
while (nread < uint32(sheader.sh_size)) {
len = (uint32)strlen(p);
printf(" >>%s<<", p);
nread += len + 1;
p += len + 1;
}
}
if ((sheader.sh_type==SHT_SYMTAB || sheader.sh_type==SHT_DYNSYM) && (options & DUMP_SYMTAB)) {
// Dump symbol table
// Find associated string table
if (sheader.sh_link >= (uint32)NSections) {err.submit(2035); sheader.sh_link = 0;}
int8 * strtab = Buf() + uint32(SectionHeaders[sheader.sh_link].sh_offset);
// Find symbol table
uint32 symtabsize = (uint32)(sheader.sh_size);
int8 * symtab = Buf() + uint32(sheader.sh_offset);
int8 * symtabend = symtab + symtabsize;
if (entrysize < sizeof(TELF_Symbol)) {err.submit(2033); entrysize = sizeof(TELF_Symbol);}
printf("\n Symbols:");
// Loop through symbol table
int symi; // Symbol number
for (symi = 0; symtab < symtabend; symtab += entrysize, symi++) {
// Copy 32 bit symbol table entry or convert 64 bit entry
TELF_Symbol sym = *(TELF_Symbol*)symtab;
int type = sym.st_type;
int binding = sym.st_bind;
if (*(strtab + sym.st_name)) {
printf("\n %2i Name: %s,", symi, strtab + sym.st_name);}
else {
printf("\n %2i Unnamed,", symi);}
if (sym.st_value || type == STT_OBJECT || type == STT_FUNC || type == STT_GNU_IFUNC || int16(sym.st_shndx) < 0)
printf(" Value: 0x%X", uint32(sym.st_value));
if (sym.st_size) printf(" Size: %i", uint32(sym.st_size));
if (sym.st_other) printf(" Other: 0x%X", sym.st_other);
if (int16(sym.st_shndx) >= 0) printf(" Section: %i", sym.st_shndx);
else { // Special segment values
switch (int16(sym.st_shndx)) {
case SHN_ABS:
printf(" Absolute,"); break;
case SHN_COMMON:
printf(" Common,"); break;
case SHN_XINDEX:
printf(" Index in extra table,"); break;
default:
printf(" Section: 0x%X", sym.st_shndx);
}
}
if (sym.st_type || sym.st_bind) {
printf(" Type: %s, Binding: %s",
Lookup(ELFSymbolTypeNames, type),
Lookup(ELFSymbolBindingNames, binding));
}
}
}
if ((sheader.sh_type==SHT_REL || sheader.sh_type==SHT_RELA ) && (options & DUMP_RELTAB)) {
printf("\n Relocations:");
int8 * reltab = Buf() + uint32(sheader.sh_offset);
int8 * reltabend = reltab + uint32(sheader.sh_size);
int expectedentrysize = sheader.sh_type == SHT_RELA ?
sizeof(TELF_Relocation) : // Elf32_Rela, Elf64_Rela
sizeof(TELF_Relocation) - WordSize/8; // Elf32_Rel, Elf64_Rel
if (entrysize < expectedentrysize) {err.submit(2033); entrysize = expectedentrysize;}
// Loop through entries
for (; reltab < reltabend; reltab += entrysize) {
// Copy relocation table entry with or without addend
TELF_Relocation rel; rel.r_addend = 0;
memcpy(&rel, reltab, entrysize);
printf ("\n Offset: 0x%X, Symbol: %i, Name: %s\n Type: %s",
uint32(rel.r_offset), rel.r_sym, SymbolName(rel.r_sym),
(WordSize == 32) ?
Lookup (ELF32RelocationNames, rel.r_type) :
Lookup (ELF64RelocationNames, rel.r_type));
if (rel.r_addend) printf (", Addend: 0x%X", uint32(rel.r_addend));
// Find inline addend
TELF_SectionHeader relsheader = SectionHeaders[sheader.sh_info];
uint32 relsoffset = uint32(relsheader.sh_offset);
if (relsoffset+rel.r_offset < GetDataSize()) {
int32 * piaddend = (int32*)(Buf()+relsoffset+rel.r_offset);
if (* piaddend) printf (", Inline addend: 0x%X", * piaddend);
}
}
}
}
}
}
