public override Dictionary <int, ElfSymbol> LoadSymbolsSection(ElfSection symSection)
{
ElfImageLoader.trace.Inform("== Symbols from {0} ==", symSection.Name);
var stringtableSection = symSection.LinkedSection !;
var rdr = CreateReader(symSection.FileOffset);
var symbols = new Dictionary <int, ElfSymbol>();
for (ulong i = 0; i < symSection.Size / symSection.EntrySize; ++i)
{
if (!Elf32_Sym.TryLoad(rdr, out var sym))
{
ElfImageLoader.trace.Warn("Unable to load symbol entry {0} from {1}", i, symSection.Name);
continue;
}
var symName = RemoveModuleSuffix(ReadAsciiString(stringtableSection.FileOffset + sym.st_name));
ElfImageLoader.trace.Verbose(" {0,3} {1,-25} {2,-12} {3,6} {4} {5,-15} {6:X8} {7,9}",
i,
string.IsNullOrWhiteSpace(symName) ? "<empty>" : symName,
(ElfSymbolType)(sym.st_info & 0xF),
sym.st_shndx,
GetBindingName((ElfSymbolBinding)(sym.st_info >> 4)),
GetSectionName(sym.st_shndx),
sym.st_value,
sym.st_size);
var name = RemoveModuleSuffix(ReadAsciiString(stringtableSection.FileOffset + sym.st_name));
symbols.Add((int)i, new ElfSymbol(name)
{
Type = (ElfSymbolType)(sym.st_info & 0xF),
SectionIndex = sym.st_shndx,
Value = sym.st_value,
Size = sym.st_size,
});
}
return(symbols);
}
public override Dictionary <int, ElfSymbol> LoadSymbolsSection(ElfSection symSection)
{
ElfImageLoader.trace.Inform("== Symbols from {0} ==", symSection.Name);
var stringtableSection = symSection.LinkedSection;
var rdr = CreateReader(symSection.FileOffset);
var symbols = new Dictionary <int, ElfSymbol>();
for (ulong i = 0; i < symSection.Size / symSection.EntrySize; ++i)
{
var sym = Elf32_Sym.Load(rdr);
var symName = RemoveModuleSuffix(ReadAsciiString(stringtableSection.FileOffset + sym.st_name));
ElfImageLoader.trace.Verbose(" {0,3} {1,-25} {2,-12} {3,6} {4,-15} {5:X8} {6,9}",
i,
string.IsNullOrWhiteSpace(symName) ? "<empty>" : symName,
(ElfSymbolType)(sym.st_info & 0xF),
sym.st_shndx,
GetSectionName(sym.st_shndx),
sym.st_value,
sym.st_size);
symbols.Add((int)i, new ElfSymbol
{
Name = RemoveModuleSuffix(ReadAsciiString(stringtableSection.FileOffset + sym.st_name)),
Type = (ElfSymbolType)(sym.st_info & 0xF),
SectionIndex = sym.st_shndx,
Value = sym.st_value,
Size = sym.st_size,
});
}
return(symbols);
}
public static Elf32_Sym Load(ImageReader rdr)
{
var sym = new Elf32_Sym();
sym.st_name = rdr.ReadUInt32();
sym.st_value = rdr.ReadUInt32();
sym.st_size = rdr.ReadUInt32();
sym.st_info = rdr.ReadByte();
sym.st_other = rdr.ReadByte();
sym.st_shndx = rdr.ReadUInt16();
return sym;
}
public static Elf32_Sym Load(ImageReader rdr)
{
var sym = new Elf32_Sym();
sym.st_name = rdr.ReadUInt32();
sym.st_value = rdr.ReadUInt32();
sym.st_size = rdr.ReadUInt32();
sym.st_info = rdr.ReadByte();
sym.st_other = rdr.ReadByte();
sym.st_shndx = rdr.ReadUInt16();
return(sym);
}
public override ElfSymbol LoadSymbol(ulong offsetSymtab, ulong symbolIndex, ulong entrySize, ulong offsetStringTable)
{
var rdr = CreateReader(offsetSymtab + entrySize * symbolIndex);
var sym = Elf32_Sym.Load(rdr);
return(new ElfSymbol
{
Name = RemoveModuleSuffix(ReadAsciiString(offsetStringTable + sym.st_name)),
Type = (ElfSymbolType)(sym.st_info & 0xF),
Bind = sym.st_info >> 4,
SectionIndex = sym.st_shndx,
Value = sym.st_value,
Size = sym.st_size,
});
}
public static bool TryLoad(EndianImageReader rdr, out Elf32_Sym sym)
{
sym = new Elf32_Sym();
if (
rdr.TryReadUInt32(out sym.st_name) &&
rdr.TryReadUInt32(out sym.st_value) &&
rdr.TryReadUInt32(out sym.st_size) &&
rdr.TryReadByte(out sym.st_info) &&
rdr.TryReadByte(out sym.st_other) &&
rdr.TryReadUInt16(out sym.st_shndx))
{
return(true);
}
else
{
sym = null !;
return(false);
}
}
public override ElfSymbol?LoadSymbol(ulong offsetSymtab, ulong symbolIndex, ulong entrySize, ulong offsetStringTable)
{
var rdr = CreateReader(offsetSymtab + entrySize * symbolIndex);
if (Elf32_Sym.TryLoad(rdr, out var sym))
{
var name = RemoveModuleSuffix(ReadAsciiString(offsetStringTable + sym.st_name));
return(new ElfSymbol(name)
{
Type = (ElfSymbolType)(sym.st_info & 0xF),
Bind = (ElfSymbolBinding)(sym.st_info >> 4),
SectionIndex = sym.st_shndx,
Value = sym.st_value,
Size = sym.st_size,
});
}
else
{
return(null);
}
}
public void RelocateOld(Program program)
{
uint nextFakeLibAddr = ~1u; // See R_386_PC32 below; -1 sometimes used for main
for (int i = 1; i < loader.Sections.Count; ++i)
{
var ps = loader.Sections[i];
if (ps.Type == SectionHeaderType.SHT_REL)
{
// A section such as .rel.dyn or .rel.plt (without an addend field).
// Each entry has 2 words: r_offset and r_info. The r_offset is just the offset from the beginning
// of the section (section given by the section header's sh_info) to the word to be modified.
// r_info has the type in the bottom byte, and a symbol table index in the top 3 bytes.
// A symbol table offset of 0 (STN_UNDEF) means use value 0. The symbol table involved comes from
// the section header's sh_link field.
var pReloc = loader.CreateReader(ps.FileOffset);
ulong size = ps.Size;
// NOTE: the r_offset is different for .o files (ET_REL in the e_type header field) than for exe's
// and shared objects!
uint destNatOrigin = 0;
uint destHostOrigin = 0;
if (loader.Header.e_type == ElfImageLoader.ET_REL)
{
var destSection = loader.Sections[i].RelocatedSection;
destNatOrigin = destSection.Address.ToUInt32();
destHostOrigin = (uint)destSection.FileOffset;
}
var symSection = loader.Sections[i].LinkedSection; // associated symbol table
var strSection = symSection.LinkedSection; // Section index for the string section assoc with this
var pStrSection = strSection.FileOffset;
var symOrigin = symSection.FileOffset;
var relocR = loader.CreateReader(0);
var relocW = loader.CreateWriter(0);
for (uint u = 0; u < size; u += 2 * sizeof(uint))
{
uint r_offset = pReloc.ReadUInt32();
uint info = pReloc.ReadUInt32();
byte relType = (byte)info;
uint symTabIndex = info >> 8;
uint pRelWord; // Pointer to the word to be relocated
if (loader.Header.e_type == ElfImageLoader.ET_REL)
{
pRelWord = destHostOrigin + r_offset;
}
else
{
if (r_offset == 0)
{
continue;
}
var destSec = loader.GetSectionInfoByAddr(r_offset);
pRelWord = ~0u; // destSec.uHostAddr - destSec.uNativeAddr + r_offset;
destNatOrigin = 0;
}
uint A, S = 0, P;
int nsec;
var sym = Elf32_Sym.Load(loader.CreateReader(symOrigin + symTabIndex * Elf32_Sym.Size));
switch (relType)
{
case 0: // R_386_NONE: just ignore (common)
break;
case 1: // R_386_32: S + A
// Read the symTabIndex'th symbol.
S = sym.st_value;
if (loader.Header.e_type == ElfImageLoader.ET_REL)
{
nsec = sym.st_shndx;
if (nsec >= 0 && nsec < loader.Sections.Count)
{
S += loader.Sections[nsec].Address.ToUInt32();
}
}
A = relocR.ReadUInt32(pRelWord);
relocW.WriteUInt32(pRelWord, S + A);
break;
case 2: // R_386_PC32: S + A - P
if (ElfLoader32.ELF32_ST_TYPE(sym.st_info) == ElfLoader.STT_SECTION)
{
nsec = sym.st_shndx;
if (nsec >= 0 && nsec < loader.Sections.Count)
{
S = loader.Sections[nsec].Address.ToUInt32();
}
}
else
{
S = sym.st_value;
if (S == 0)
{
// This means that the symbol doesn't exist in this module, and is not accessed
// through the PLT, i.e. it will be statically linked, e.g. strcmp. We have the
// name of the symbol right here in the symbol table entry, but the only way
// to communicate with the loader is through the target address of the call.
// So we use some very improbable addresses (e.g. -1, -2, etc) and give them entries
// in the symbol table
uint nameOffset = sym.st_name;
string pName = loader.ReadAsciiString(pStrSection + nameOffset);
// this is too slow, I'm just going to assume it is 0
//S = GetAddressByName(pName);
//if (S == (e_type == E_REL ? 0x8000000 : 0)) {
S = nextFakeLibAddr--; // Allocate a new fake address
loader.AddSymbol(S, pName);
//}
}
else if (loader.Header.e_type == ElfImageLoader.ET_REL)
{
nsec = sym.st_shndx;
if (nsec >= 0 && nsec < loader.Sections.Count)
{
S += loader.Sections[nsec].Address.ToUInt32();
}
}
}
A = relocR.ReadUInt32(pRelWord);
P = destNatOrigin + r_offset;
relocW.WriteUInt32(pRelWord, S + A - P);
break;
case 6: // R_386_GLOB_DAT
// This relocation type is used to set a global offset table entry to the address of the
// specified symbol. The special relocation type allows one to determine the
// correspondence between symbols and global offset table entries.
S = sym.st_value;
relocW.WriteUInt32(pRelWord, S);
break;
case 7:
case 8: // R_386_RELATIVE
break; // No need to do anything with these, if a shared object
default:
throw new NotSupportedException("Relocation type " + (int)relType + " not handled yet");
}
}
}
}
}
