private void UpdateDisplay(ulong address, byte[] memory)
{
instructions.Clear();
var mode = ArchitectureMode.x86_32; // todo:
using (var disasm = new Disassembler(memory, mode, address, true, Vendor.Any))
{
var translator = new SharpDisasm.Translators.IntelTranslator()
{
IncludeAddress = false,
IncludeBinary = false
};
foreach (var instruction in disasm.Disassemble())
{
var entry = new InstructionEntry()
{
IP = instruction.Offset,
Length = instruction.Length,
Instruction = translator.Translate(instruction)
};
instructions.Add(entry);
}
}
}
private void UpdateDisplay(ulong address, byte[] memory)
{
if (address != Platform.InstructionPointer.Value)
{
return;
}
var mode = ArchitectureMode.x86_32; // todo:
try
{
using (var disasm = new Disassembler(memory, mode, address, true))
{
var translator = new SharpDisasm.Translators.IntelTranslator()
{
IncludeAddress = false,
IncludeBinary = false
};
foreach (var instruction in disasm.Disassemble())
{
var asm = translator.Translate(instruction);
tbInstruction.Text = asm;
break;
}
}
}
catch
{
tbInstruction.Text = "Unable to decode!";
}
}
private void UpdateDisplay(ulong address, byte[] memory)
{
instructions.Clear();
var mode = ArchitectureMode.x86_32; // todo:
using (var disasm = new Disassembler(memory, mode, address, true, Vendor.Any))
{
var translator = new SharpDisasm.Translators.IntelTranslator()
{
IncludeAddress = false,
IncludeBinary = false
};
foreach (var instruction in disasm.Disassemble())
{
var text = translator.Translate(instruction);
var info = string.Empty;
var value = ParseAddress(text);
if (value != 0)
{
var symbol = DebugSource.GetFirstSymbolsStartingAt(value);
if (symbol != null)
{
info = symbol.Name;
}
}
var entry = new MethodInstructionEntry()
{
IP = instruction.Offset,
Length = instruction.Length,
Instruction = text,
Info = info
};
instructions.Add(entry);
}
}
}
protected void TraceDisassembly()
{
var trace = CreateTraceLog();
if (trace == null)
{
return;
}
// Determine the architecture mode
ArchitectureMode mode;
if (Architecture is Platform.x86.Architecture)
{
mode = ArchitectureMode.x86_32;
}
else if (Architecture is Platform.x64.Architecture)
{
mode = ArchitectureMode.x86_64;
}
else
{
trace.Log($"Unable to disassemble binary for machine type: {Architecture.ElfMachineType}");
return;
}
// Create a byte array from the symbol stream
var symbol = Linker.GetSymbol(Method.FullName);
var stream = symbol.Stream;
var oldPosition = stream.Position;
var length = (int)stream.Length;
var byteArray = new byte[length];
stream.Position = 0;
stream.Read(byteArray, 0, length);
stream.Position = oldPosition;
try
{
// Create the disassembler
using (var disasm = new Disassembler(byteArray, mode, 0, true))
{
// Need a new instance of translator every time as they aren't thread safe
var translator = new SharpDisasm.Translators.IntelTranslator()
{
// Configure the translator to output instruction addresses and instruction binary as hex
IncludeAddress = true,
IncludeBinary = true
};
// Disassemble each instruction and output to trace
foreach (var instruction in disasm.Disassemble())
{
var asString = translator.Translate(instruction);
trace.Log(asString);
}
}
}
catch (Exception e)
{
trace.Log($"Unable to continue disassembly, error encountered\r\n{e}");
PostEvent(CompilerEvent.Error, $"Failed disassembly for method {MethodCompiler.Method}");
}
}
protected void TraceDisassembly()
{
var trace = CreateTraceLog();
if (!trace.Active)
{
return;
}
// Determine the architecture mode
ArchitectureMode mode;
switch (this.Architecture.MachineType)
{
case Compiler.Linker.Elf.MachineType.Intel386:
mode = ArchitectureMode.x86_32;
break;
case Compiler.Linker.Elf.MachineType.IA_64:
mode = ArchitectureMode.x86_64;
break;
case Compiler.Linker.Elf.MachineType.ARM:
default:
trace.Log($"Unable to disassemble binary for machine type: {this.Architecture.MachineType}");
return;
}
// Create a byte array from the symbol stream
var symbol = MethodCompiler.Linker.FindSymbol(MethodCompiler.Method.FullName, SectionKind.Text);
var stream = symbol.Stream;
var oldPosition = stream.Position;
var length = (int)stream.Length;
var byteArray = new byte[length];
stream.Position = 0;
stream.Read(byteArray, 0, length);
stream.Position = oldPosition;
try
{
// Create the disassembler
using (var disasm = new Disassembler(byteArray, mode, 0, true))
{
// Need a new instance of translator every time as they aren't thread safe
var translator = new SharpDisasm.Translators.IntelTranslator();
// Configure the translator to output instruction addresses and instruction binary as hex
translator.IncludeAddress = true;
translator.IncludeBinary = true;
// Disassemble each instruction and output to trace
foreach (var instruction in disasm.Disassemble())
{
var asString = translator.Translate(instruction);
trace.Log(asString);
}
}
}
catch (Exception e)
{
trace.Log($"Unable to continue disassembly, error encountered\r\n{e.ToString()}");
NewCompilerTraceEvent(CompilerEvent.Error, $"Failed disassembly for method {this.MethodCompiler.Method}");
}
}
protected override void Run()
{
var trace = CreateTraceLog();
if (!trace.Active)
return;
// Determine the architecture mode
ArchitectureMode mode;
switch (this.Architecture.MachineType)
{
case Compiler.Linker.Elf.MachineType.Intel386:
mode = ArchitectureMode.x86_32;
break;
case Compiler.Linker.Elf.MachineType.IA_64:
mode = ArchitectureMode.x86_64;
break;
case Compiler.Linker.Elf.MachineType.ARM:
default:
trace.Log($"Unable to disassemble binary for machine type: {this.Architecture.MachineType}");
return;
}
// Create a byte array from the symbol stream
var symbol = MethodCompiler.Linker.FindSymbol(MethodCompiler.Method.FullName, SectionKind.Text);
var stream = symbol.Stream;
var oldPosition = stream.Position;
var length = (int)stream.Length;
var byteArray = new byte[length];
stream.Position = 0;
stream.Read(byteArray, 0, length);
stream.Position = oldPosition;
try
{
// Create the disassembler
using (var disasm = new Disassembler(byteArray, mode, 0, true))
{
// Need a new instance of translator every time as they aren't thread safe
var translator = new SharpDisasm.Translators.IntelTranslator();
// Configure the translator to output instruction addresses and instruction binary as hex
translator.IncludeAddress = true;
translator.IncludeBinary = true;
// Disassemble each instruction and output to trace
foreach (var instruction in disasm.Disassemble())
{
var asString = translator.Translate(instruction);
trace.Log(asString);
}
}
}
catch (Exception e)
{
trace.Log($"Unable to continue disassembly, error encountered\r\n{e.ToString()}");
NewCompilerTraceEvent(CompilerEvent.Error, $"Failed disassembly for method {this.MethodCompiler.Method}");
}
}
