public override void Render(ImageMapSegment segment, Program program, Formatter formatter)
{
var entries = shdr.sh_size / shdr.sh_entsize;
var symtab = (int)shdr.sh_link;
var rdr = loader.CreateReader(shdr.sh_offset);
for (int i = 0; i < entries; ++i)
{
uint iName;
if (!rdr.TryReadUInt32(out iName))
return;
uint value;
if (!rdr.TryReadUInt32(out value))
return;
uint size;
if (!rdr.TryReadUInt32(out size))
return;
byte info;
if (!rdr.TryReadByte(out info))
return;
byte other;
if (!rdr.TryReadByte(out other))
return;
ushort shIndex;
if (!rdr.TryReadUInt16(out shIndex))
return;
string symStr = loader.GetStrPtr(symtab, iName);
string segName = loader.GetSectionName(shIndex);
formatter.Write("{0,-40} {1:X8} {2:X8} {3:X2} {4}", symStr, value, size, info & 0xFF, segName);
formatter.WriteLine();
}
}
public override void Render(ImageSegment segment, Program program, Formatter formatter)
{
var entries = shdr.Size / shdr.EntrySize;
var symtab = shdr.LinkedSection;
var rdr = loader.CreateReader(shdr.FileOffset);
for (ulong i = 0; i < entries; ++i)
{
uint offset;
if (!rdr.TryReadUInt32(out offset))
return;
uint info;
if (!rdr.TryReadUInt32(out info))
return;
uint sym = info >> 8;
string symStr = loader.GetSymbolName(symtab, sym);
formatter.Write("{0:X8} {1,3} {2:X8} {3}", offset, info & 0xFF, sym, symStr);
formatter.WriteLine();
}
}
public override void Render(ImageMapSegment segment, Program program, Formatter formatter)
{
var entries = shdr.sh_size / shdr.sh_entsize;
var symtab = (int)shdr.sh_link;
var rdr = loader.CreateReader(shdr.sh_offset);
for (int i = 0; i < entries; ++i)
{
uint offset;
if (!rdr.TryReadUInt32(out offset))
return;
uint info;
if (!rdr.TryReadUInt32(out info))
return;
uint sym = info >> 8;
string symStr = loader.GetSymbol(symtab, (int)sym);
formatter.Write("{0:X8} {1,3} {2:X8} {3}", offset, info & 0xFF, sym, symStr);
formatter.WriteLine();
}
}
public override void Render(ImageSegment segment, Program program, Formatter formatter)
{
// Get the entry that has the segment# for the string table.
var dynStrtab = loader.GetDynEntries64(shdr.FileOffset).Where(d => d.d_tag == DT_STRTAB).FirstOrDefault();
if (dynStrtab == null)
return;
this.strtabSection = loader.GetSectionInfoByAddr64(dynStrtab.d_ptr);
foreach (var entry in loader.GetDynEntries64(shdr.FileOffset))
{
DtFormat fmt;
string entryName;
Entry dser;
if (!entries.TryGetValue(entry.d_tag, out dser))
{
entryName = string.Format("{0:X8} ", entry.d_tag);
fmt = DtFormat.Hexadecimal;
}
else
{
entryName = dser.Name;
fmt = dser.Format;
}
RenderEntry(entryName, fmt, entry, formatter);
formatter.WriteLine();
}
}
public override void Render(ImageMapSegment segment, Program program, Formatter formatter)
{
// Get the entry that has the segment# for the string table.
var dynStrtab = loader.GetDynEntries(shdr.sh_offset).Where(d => d.d_tag == DT_STRTAB).FirstOrDefault();
if (dynStrtab == null)
return;
var strtabSection = loader.GetSectionInfoByAddr(dynStrtab.d_ptr);
foreach (var entry in loader.GetDynEntries(shdr.sh_offset))
{
switch (entry.d_tag)
{
default:
formatter.Write("{0,-12} {1:X8}", entry.d_tag, entry.d_val);
break;
case DT_DEBUG:
formatter.Write("{0,-12} {1:X8}", "DT_DEBUG", entry.d_val);
break;
case DT_FINI:
formatter.Write("{0,-12} ", "DT_FINI");
formatter.WriteHyperlink(string.Format("{0:X8}", entry.d_ptr), Address.Ptr32(entry.d_ptr));
break;
case DT_HASH:
formatter.Write("{0,-12} ", "DT_HASH");
formatter.WriteHyperlink(string.Format("{0:X8}", entry.d_ptr), Address.Ptr32(entry.d_ptr));
break;
case DT_INIT:
formatter.Write("{0,-12} ", "DT_INIT");
formatter.WriteHyperlink(string.Format("{0:X8}", entry.d_ptr), Address.Ptr32(entry.d_ptr));
break;
case DT_JMPREL:
formatter.Write("{0,-12} ", "DT_JMPREL");
formatter.WriteHyperlink(string.Format("{0:X8}", entry.d_ptr), Address.Ptr32(entry.d_ptr));
break;
case DT_NEEDED:
formatter.Write("{0,-12} {1}", "DT_NEEDED", loader.ReadAsciiString(loader.RawImage, strtabSection.sh_offset + entry.d_ptr));
break;
case DT_STRSZ:
formatter.Write("{0,-12} {1:X}", "DT_STRSZ", entry.d_val);
break;
case DT_STRTAB:
formatter.Write("{0,-12} ", "DT_STRTAB");
formatter.WriteHyperlink(string.Format("{0:X8}", entry.d_ptr), Address.Ptr32(entry.d_ptr));
break;
case DT_SYMENT:
formatter.Write("{0,-12} {1}", "DT_SYMENTTRTAB", entry.d_val);
break;
case DT_SYMTAB:
formatter.Write("{0,-12} ", "DT_SYMTAB");
formatter.WriteHyperlink(string.Format("{0:X8}", entry.d_ptr), Address.Ptr32(entry.d_ptr));
break;
}
formatter.WriteLine();
}
}
private void WriteEntry(TypeVariable tv, DataType dt, Formatter writer)
{
writer.Write("{0}: ", tv);
if (dt != null)
{
dt.Accept(new TypeGraphWriter(writer));
WriteExpressionOf(tv, writer);
}
writer.WriteLine();
}
public void WriteEntry(TypeVariable tv, Formatter writer)
{
writer.Write(tv.Name);
writer.Write(":");
WriteExpressionOf(tv, writer);
writer.WriteLine();
writer.Write(" Class: ");
writer.WriteLine(tv.Class.Name);
writer.Write(" DataType: ");
writer.WriteLine(tv.DataType);
writer.Write(" OrigDataType: ");
writer.WriteLine(tv.OriginalDataType);
}
public override void WriteLine()
{
WritePrefix();
w.WriteLine();
needPrefix = true;
}
public void Emit(string fnName, EmitFlags f, Formatter fmt, CodeFormatter w, TypeFormatter t)
{
bool emitStorage = (f & EmitFlags.ArgumentKind) == EmitFlags.ArgumentKind;
if (emitStorage)
{
if (ReturnValue != null)
{
w.WriteFormalArgumentType(ReturnValue, emitStorage);
fmt.Write(" ");
}
else
{
fmt.Write("void ");
}
fmt.Write("{0}(", fnName);
}
else
{
if (ReturnValue == null)
fmt.Write("void {0}", fnName);
else
{
t.Write(ReturnValue.DataType, fnName); //$TODO: won't work with fn's that return pointers to functions or arrays.
}
fmt.Write("(");
}
var sep = "";
if (Parameters != null)
{
for (int i = 0; i < Parameters.Length; ++i)
{
fmt.Write(sep);
sep = ", ";
w.WriteFormalArgument(Parameters[i], emitStorage, t);
}
}
fmt.Write(")");
if ((f & EmitFlags.LowLevelInfo) == EmitFlags.LowLevelInfo)
{
fmt.WriteLine();
fmt.Write("// stackDelta: {0}; fpuStackDelta: {1}; fpuMaxParam: {2}", StackDelta, FpuStackDelta, FpuStackArgumentMax);
fmt.WriteLine();
}
}
public override void Render(ImageMapSegment segment, Program program, Formatter formatter)
{
var entries = shdr.sh_size / shdr.sh_entsize;
var symtab = (int)shdr.sh_link;
var rdr = loader.CreateReader(shdr.sh_offset);
for (ulong i = 0; i < entries; ++i)
{
ulong offset;
if (!rdr.TryReadUInt64(out offset))
return;
ulong info;
if (!rdr.TryReadUInt64(out info))
return;
ulong addend;
if (!rdr.TryReadUInt64(out addend))
return;
ulong sym = info >> 32;
string symStr = loader.GetSymbol64(symtab, (int)sym);
formatter.Write("{0:X8} {1,3} {2:X8} {3:X16} {4} ({5})", offset, info & 0xFFFFFFFF, sym, addend, symStr, sym);
formatter.WriteLine();
}
}
public void VisitPointer(Pointer ptr)
{
switch (ptr.Size)
{
case 2:
fmt.WriteKeyword("dw");
fmt.Write("\t");
fmt.Write(string.Format("0x{0:X4}", rdr.ReadByte()));
fmt.WriteLine();
return;
case 4:
fmt.WriteKeyword("dd");
fmt.Write("\t");
fmt.Write(string.Format("0x{0:X8}", rdr.ReadUInt32()));
fmt.WriteLine();
return;
case 8:
fmt.WriteKeyword("dq");
fmt.Write("\t");
fmt.Write(string.Format("0x{0:X16}", rdr.ReadUInt64()));
fmt.WriteLine();
return;
}
}
public void Dump(Program program, Formatter formatter)
{
var map = program.SegmentMap;
ImageSegment segment = null;
foreach (ImageMapItem i in program.ImageMap.Items.Values)
{
if (!map.IsValidAddress(i.Address))
continue;
ImageSegment seg;
if (!map.TryFindSegment(i.Address, out seg))
continue;
if (seg != segment)
{
segment = seg;
formatter.WriteLine(";;; Segment {0} ({1})", seg.Name, seg.Address);
}
ImageMapBlock block = i as ImageMapBlock;
if (block != null)
{
formatter.WriteLine();
Procedure proc;
if (program.Procedures.TryGetValue(block.Address, out proc))
{
formatter.WriteComment(string.Format(
";; {0}: {1}", proc.Name, block.Address));
formatter.WriteLine();
formatter.Write(proc.Name);
formatter.Write(" ");
formatter.Write("proc");
formatter.WriteLine();
}
else
{
formatter.Write(block.Block.Name);
formatter.Write(":");
formatter.WriteLine();
}
DumpAssembler(program.SegmentMap, block.Address, block.Address + block.Size, formatter);
continue;
}
ImageMapVectorTable table = i as ImageMapVectorTable;
if (table != null)
{
formatter.WriteLine(";; Code vector at {0} ({1} bytes)",
table.Address, table.Size);
foreach (Address addr in table.Addresses)
{
formatter.WriteLine("\t{0}", addr != null ? addr.ToString() : "-- null --");
}
DumpData(program.SegmentMap, i.Address, i.Size, formatter);
}
else
{
var segLast = segment.Address + segment.Size;
var size = segLast - i.Address;
size = Math.Min(i.Size, size);
if (i.DataType == null || i.DataType is UnknownType ||
i.DataType is CodeType)
{
DumpData(program.SegmentMap, i.Address, size, formatter);
}
else
{
DumpTypedData(program.SegmentMap, i, formatter);
}
}
}
}
public void DumpAssembler(SegmentMap map, Address addrStart, Address addrLast, Formatter formatter)
{
ImageSegment segment;
if (!map.TryFindSegment(addrStart, out segment))
return;
var dasm = arch.CreateDisassembler(arch.CreateImageReader(segment.MemoryArea, addrStart));
try
{
var writer = new InstrWriter(formatter);
foreach (var instr in dasm)
{
if (instr.Address >= addrLast)
break;
if (!DumpAssemblerLine(segment.MemoryArea, instr, writer))
break;
}
}
catch (Exception ex)
{
formatter.WriteLine(ex.Message);
formatter.WriteLine();
}
}
public void DumpData(SegmentMap map, Address address, long cbBytes, Formatter stm)
{
ulong cSkip = address.ToLinear() & 0x0F;
ImageSegment segment;
if (!map.TryFindSegment(address, out segment) || segment.MemoryArea == null)
return;
ImageReader rdr = arch.CreateImageReader(segment.MemoryArea, address);
while (cbBytes > 0)
{
StringBuilder sb = new StringBuilder(0x12);
try
{
stm.Write("{0} ", rdr.Address);
for (int i = 0; i < 16; ++i)
{
if (cbBytes > 0 && cSkip == 0)
{
byte b = rdr.ReadByte();
stm.Write("{0:X2} ", b);
sb.Append(0x20 <= b && b < 0x7F
? (char) b
: '.');
--cbBytes;
}
else
{
stm.Write(" ");
if (cSkip > 0)
sb.Append(' ');
--cSkip;
}
}
}
catch
{
stm.WriteLine();
stm.WriteLine(";;; ...end of image");
return;
}
stm.WriteLine(sb.ToString());
}
}
