private BlockFlow CreateBlockFlow(Block block, Frame frame)
{
return new BlockFlow(
block,
prog.Architecture.CreateRegisterBitset(),
new SymbolicEvaluationContext(prog.Architecture, frame));
}
public override ProcedureSignature Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
return null;
this.argser = new ArgumentSerializer(this, Architecture, frame, ss.Convention);
Identifier ret = null;
int fpuDelta = FpuStackOffset;
FpuStackOffset = 0;
if (ss.ReturnValue != null)
{
ret = argser.DeserializeReturnValue(ss.ReturnValue);
fpuDelta += FpuStackOffset;
}
FpuStackOffset = 0;
var args = new List<Identifier>();
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, iArg, ss.Convention);
args.Add(arg);
}
fpuDelta -= FpuStackOffset;
}
FpuStackOffset = fpuDelta;
var sig = new ProcedureSignature(ret, args.ToArray());
ApplyConvention(ss, sig);
return sig;
}
public RtlStatementStream(uint address, Frame frame)
{
this.linAddress = address;
this.arch = new FakeArchitecture();
this.frame = frame;
this.stms = new List<RtlInstructionCluster>();
}
public override ProcedureSignature Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
return null;
var argser = new ArgumentSerializer(this, Architecture, frame, ss.Convention);
Identifier ret = null;
if (ss.ReturnValue != null)
{
ret = argser.DeserializeReturnValue(ss.ReturnValue);
}
var args = new List<Identifier>();
this.fr = 1;
this.gr = 3;
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
Identifier arg = DeserializeArgument(argser, sArg);
args.Add(arg);
}
}
var sig = new ProcedureSignature(ret, args.ToArray());
return sig;
}
public OperandRewriter(M68kArchitecture arch, RtlEmitter emitter, Frame frame, PrimitiveType dataWidth)
{
this.arch = arch;
this.m = emitter;
this.frame = frame;
this.DataWidth = dataWidth;
}
public void Setup()
{
var arch = new IntelArchitecture(ProcessorMode.Protected32);
f = arch.CreateFrame();
liveness = new IdentifierLiveness(arch);
isLiveHelper = new RegisterLiveness.IsLiveHelper();
}
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host)
{
var linAddr = rdr.Address.ToLinear();
RtlTrace trace;
if (!rewriters.Traces.TryGetValue(rdr.Address, out trace))
NUnit.Framework.Assert.Fail(string.Format("Unexpected request for a rewriter at address {0}", rdr.Address));
return trace;
}
private void CreateSymbolicEvaluator(Frame frame)
{
ctx = new SymbolicEvaluationContext(arch, frame);
se = new SymbolicEvaluator(ctx);
if (esp == null)
esp = Tmp32("esp");
ctx.SetValue(esp, frame.FramePointer);
}
public void RegisterTest()
{
Frame f = new Frame(PrimitiveType.Word16);
Identifier id0 = f.EnsureRegister(Registers.ax);
Identifier id1 = f.EnsureRegister(Registers.bx);
Identifier id2 = f.EnsureRegister(Registers.ax);
Assert.AreEqual(id0, id2);
}
protected override IEnumerable<RtlInstructionCluster> GetInstructionStream(Frame frame, IRewriterHost host)
{
return arch.CreateRewriter(
new LeImageReader(image, 0),
arch.CreateProcessorState(),
frame,
this.host);
}
protected override IEnumerable<RtlInstructionCluster> GetInstructionStream(Frame frame, IRewriterHost host)
{
var addr = Address.Ptr16(10);
var image = new LoadedImage(addr, new byte[1]);
return arch.CreateRewriter(
arch.CreateImageReader(image, addr),
arch.CreateProcessorState(),
frame,
host);
}
private BlockFlow CreateBlockFlow(Block block, Frame frame)
{
var bflow = new BlockFlow(
block,
prog.Architecture.CreateRegisterBitset(),
new SymbolicEvaluationContext(
prog.Architecture,
frame));
flow[block] = bflow;
return bflow;
}
public void FrGrfTest()
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
Frame f = new Frame(PrimitiveType.Word16);
uint iSz = (uint) (FlagM.ZF|FlagM.SF);
Identifier grfSz = f.EnsureFlagGroup(iSz, arch.GrfToString(iSz), PrimitiveType.Byte);
using (FileUnitTester fut = new FileUnitTester("Core/FrGrfTest.txt"))
{
f.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
}
public void Setup()
{
prog = new Program();
prog.Architecture = new IntelArchitecture(ProcessorMode.Protected32);
prog.Platform = new DefaultPlatform(null, prog.Architecture);
m = new ProcedureBuilder();
proc = m.Procedure;
f = proc.Frame;
mpprocflow = new ProgramDataFlow();
terminates = new HashSet<Procedure>();
rl = new RegisterLiveness(prog, mpprocflow, null);
rl.Procedure = proc;
rl.IdentifierLiveness.BitSet = prog.Architecture.CreateRegisterBitset();
}
public ApplicationBuilderTests()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
frame = arch.CreateFrame();
ret = frame.EnsureRegister(Registers.eax);
arg04 = new Identifier("arg04", PrimitiveType.Word32, new StackArgumentStorage(4, PrimitiveType.Word32));
arg08 = new Identifier("arg08", PrimitiveType.Word16, new StackArgumentStorage(8, PrimitiveType.Word16));
arg0C = new Identifier("arg0C", PrimitiveType.Byte, new StackArgumentStorage(0x0C, PrimitiveType.Byte));
regOut = new Identifier("edxOut", PrimitiveType.Word32, new OutArgumentStorage(frame.EnsureRegister(Registers.edx)));
sig = new ProcedureSignature(ret,
new Identifier[] { arg04, arg08, arg0C, regOut })
{
};
}
public void SequenceTest()
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
Frame f = new Frame(PrimitiveType.Word16);
Identifier ax = f.EnsureRegister(Registers.ax);
Identifier dx = f.EnsureRegister(Registers.dx);
Identifier dxax = f.EnsureSequence(dx, ax, PrimitiveType.Word32);
using (FileUnitTester fut = new FileUnitTester("Core/SequenceTest.txt"))
{
f.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
Identifier dxax2 = f.EnsureSequence(dx,ax, PrimitiveType.Word32);
Assert.IsTrue(dxax2 == dxax);
}
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host)
{
return new Z80Rewriter(this, rdr, state, frame, host);
}
public IEnumerable<RtlInstructionCluster> GetTrace(Address addrStart, ProcessorState state, Frame frame)
{
return program.Architecture.CreateRewriter(
CreateReader(addrStart),
state,
frame,
this);
}
public OperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host)
{
this.arch = arch;
this.frame = frame;
this.host = host;
}
public OperandRewriter64(IntelArchitecture arch, Frame frame, IRewriterHost host) : base(arch, frame, host) { }
public abstract OperandRewriter CreateOperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host);
public override OperandRewriter CreateOperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host)
{
return new OperandRewriter64(arch, frame, host);
}
public override Expression CreateStackAccess(Frame frame, int offset, DataType dataType)
{
var rsp = frame.EnsureRegister(Registers.rsp);
return MemoryAccess.Create(rsp, offset, dataType);
}
public void Setup()
{
m = new ProcedureBuilder(arch);
frame = m.Frame;
ax = frame.EnsureRegister(new RegisterStorage("ax", 0, PrimitiveType.Word16));
bx = frame.EnsureRegister(new RegisterStorage("bx", 3, PrimitiveType.Word16));
cx = frame.EnsureRegister(new RegisterStorage("cx", 1, PrimitiveType.Word16));
dx = frame.EnsureRegister(new RegisterStorage("dx", 2, PrimitiveType.Word16));
SCZ = frame.EnsureFlagGroup(7, "SCZ", PrimitiveType.Byte);
CF = frame.EnsureFlagGroup(arch.CarryFlagMask, "C", PrimitiveType.Bool);
rw = new LongAddRewriter(m.Procedure, arch);
Procedure proc = new Procedure("test", frame);
block = new Block(proc, "bloke");
}
public void FrLocals()
{
Frame f = new Frame(PrimitiveType.Word16);
f.EnsureStackLocal(2, PrimitiveType.Word16);
f.EnsureStackLocal(4, PrimitiveType.Word32);
using (FileUnitTester fut = new FileUnitTester("Core/FrLocals.txt"))
{
f.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
Assert.IsNotNull((StackLocalStorage) f.Identifiers[2].Storage);
}
public void FrEnsureRegister()
{
Frame f = new Frame(PrimitiveType.Word32);
f.EnsureRegister(new Mocks.MockMachineRegister("eax", 0, PrimitiveType.Word32));
Assert.AreEqual("eax", f.Identifiers[2].Name);
Assert.AreSame(PrimitiveType.Word32, f.Identifiers[2].DataType);
}
public Expression CreateStackAccess(Frame frame, int cbOffset, DataType dataType)
{
throw new NotImplementedException();
}
public virtual Expression CreateStackAccess(Frame frame, int offset, DataType dataType)
{
var sp = frame.EnsureRegister(Registers.sp);
var ss = frame.EnsureRegister(Registers.ss);
return SegmentedAccess.Create(ss, sp, offset, dataType);
}
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host)
{
return new Pdp11Rewriter(this, new Pdp11Disassembler(rdr, this), frame);
}
public void EnsureOutRegister()
{
Frame f = new Frame(PrimitiveType.Word32);
Identifier r = f.EnsureRegister(new Mocks.MockMachineRegister("r1", 1, PrimitiveType.Word32));
Identifier arg = f.EnsureOutArgument(r, PrimitiveType.Pointer32);
Assert.AreEqual("r1Out", arg.Name);
Assert.AreSame(PrimitiveType.Pointer32, arg.DataType);
}
