private void DeserializeAddrInfos(IVirtualMemoryManager memory, ulong address, ulong size)
{
ulong endAddress = address + size;
while (address < endAddress)
{
AddrInfoSerializedHeader header = memory.Read <AddrInfoSerializedHeader>(address);
if (header.Magic != SfdnsresContants.AddrInfoMagic)
{
break;
}
address += (ulong)Unsafe.SizeOf <AddrInfoSerializedHeader>() + header.AddressLength;
// ai_canonname
string canonname = string.Empty;
while (true)
{
byte chr = memory.Read <byte>(address++);
if (chr == 0)
{
break;
}
canonname += (char)chr;
}
}
}
private ElfSymbol GetSymbol32(IVirtualMemoryManager memory, ulong address, ulong strTblAddr)
{
ElfSymbol32 sym = memory.Read <ElfSymbol32>(address);
uint nameIndex = sym.NameOffset;
string name = string.Empty;
for (int chr; (chr = memory.Read <byte>(strTblAddr + nameIndex++)) != 0;)
{
name += (char)chr;
}
return(new ElfSymbol(name, sym.Info, sym.Other, sym.SectionIndex, sym.ValueAddress, sym.Size));
}
public unsafe static T Read <T>(IVirtualMemoryManager memory, ulong position) where T : struct
{
long size = Marshal.SizeOf <T>();
byte[] data = new byte[size];
memory.Read(position, data);
fixed(byte *ptr = data)
{
return(Marshal.PtrToStructure <T>((IntPtr)ptr));
}
}
private static void DeserializeAddrInfos(IVirtualMemoryManager memory, ulong address, ulong size)
{
ulong endAddress = address + size;
while (address < endAddress)
{
AddrInfoSerializedHeader header = memory.Read <AddrInfoSerializedHeader>(address);
if (header.Magic != SfdnsresContants.AddrInfoMagic)
{
break;
}
address += (ulong)Unsafe.SizeOf <AddrInfoSerializedHeader>() + header.AddressLength;
// ai_canonname
string canonname = MemoryHelper.ReadAsciiString(memory, address);
}
}
public static string ReadAsciiString(IVirtualMemoryManager memory, ulong position, long maxSize = -1)
{
using (MemoryStream ms = new MemoryStream())
{
for (long offs = 0; offs < maxSize || maxSize == -1; offs++)
{
byte value = memory.Read <byte>(position + (ulong)offs);
if (value == 0)
{
break;
}
ms.WriteByte(value);
}
return(Encoding.ASCII.GetString(ms.ToArray()));
}
}
private uint Read(IVirtualMemoryManager memoryManager, ulong bufferAddress, uint countMax, Span <int> outBuffer, uint count, uint readOffset, uint updateCount)
{
if (countMax == 0 || bufferAddress == 0)
{
return(0);
}
uint targetReadOffset = readOffset + AuxiliaryBufferInfo.GetReadOffset(memoryManager, BufferInfo.ReturnBufferInfo);
if (targetReadOffset > countMax)
{
return(0);
}
uint remaining = count;
uint outBufferOffset = 0;
while (remaining != 0)
{
uint countToWrite = Math.Min(countMax - targetReadOffset, remaining);
memoryManager.Read(bufferAddress + targetReadOffset * sizeof(int), MemoryMarshal.Cast <int, byte>(outBuffer.Slice((int)outBufferOffset, (int)countToWrite)));
targetReadOffset = (targetReadOffset + countToWrite) % countMax;
remaining -= countToWrite;
outBufferOffset += countToWrite;
}
if (updateCount != 0)
{
uint newReadOffset = (AuxiliaryBufferInfo.GetReadOffset(memoryManager, BufferInfo.ReturnBufferInfo) + updateCount) % countMax;
AuxiliaryBufferInfo.SetReadOffset(memoryManager, BufferInfo.ReturnBufferInfo, newReadOffset);
}
return(count);
}
private void LoadMod0Symbols(IVirtualMemoryManager memory, ulong textOffset)
{
ulong mod0Offset = textOffset + memory.Read <uint>(textOffset + 4);
if (mod0Offset < textOffset || !memory.IsMapped(mod0Offset) || (mod0Offset & 3) != 0)
{
return;
}
Dictionary <ElfDynamicTag, ulong> dynamic = new Dictionary <ElfDynamicTag, ulong>();
int mod0Magic = memory.Read <int>(mod0Offset + 0x0);
if (mod0Magic != Mod0)
{
return;
}
ulong dynamicOffset = memory.Read <uint>(mod0Offset + 0x4) + mod0Offset;
ulong bssStartOffset = memory.Read <uint>(mod0Offset + 0x8) + mod0Offset;
ulong bssEndOffset = memory.Read <uint>(mod0Offset + 0xc) + mod0Offset;
ulong ehHdrStartOffset = memory.Read <uint>(mod0Offset + 0x10) + mod0Offset;
ulong ehHdrEndOffset = memory.Read <uint>(mod0Offset + 0x14) + mod0Offset;
ulong modObjOffset = memory.Read <uint>(mod0Offset + 0x18) + mod0Offset;
bool isAArch32 = memory.Read <ulong>(dynamicOffset) > 0xFFFFFFFF || memory.Read <ulong>(dynamicOffset + 0x10) > 0xFFFFFFFF;
while (true)
{
ulong tagVal;
ulong value;
if (isAArch32)
{
tagVal = memory.Read <uint>(dynamicOffset + 0);
value = memory.Read <uint>(dynamicOffset + 4);
dynamicOffset += 0x8;
}
else
{
tagVal = memory.Read <ulong>(dynamicOffset + 0);
value = memory.Read <ulong>(dynamicOffset + 8);
dynamicOffset += 0x10;
}
ElfDynamicTag tag = (ElfDynamicTag)tagVal;
if (tag == ElfDynamicTag.DT_NULL)
{
break;
}
dynamic[tag] = value;
}
if (!dynamic.TryGetValue(ElfDynamicTag.DT_STRTAB, out ulong strTab) ||
!dynamic.TryGetValue(ElfDynamicTag.DT_SYMTAB, out ulong symTab) ||
!dynamic.TryGetValue(ElfDynamicTag.DT_SYMENT, out ulong symEntSize))
{
return;
}
ulong strTblAddr = textOffset + strTab;
ulong symTblAddr = textOffset + symTab;
List <ElfSymbol> symbols = new List <ElfSymbol>();
while (symTblAddr < strTblAddr)
{
ElfSymbol sym = isAArch32 ? GetSymbol32(memory, symTblAddr, strTblAddr) : GetSymbol64(memory, symTblAddr, strTblAddr);
symbols.Add(sym);
symTblAddr += symEntSize;
}
lock (_images)
{
_images.Add(new Image(textOffset, symbols.OrderBy(x => x.Value).ToArray()));
}
}
public static uint GetTotalSampleCount(IVirtualMemoryManager manager, ulong bufferAddress)
{
return(manager.Read <uint>(bufferAddress + TotalSampleCountPosition));
}
public static uint GetWriteOffset(IVirtualMemoryManager manager, ulong bufferAddress)
{
return(manager.Read <uint>(bufferAddress + WriteOffsetPosition));
}