| public EnsureRegister ( RegisterStorage reg ) : Identifier | ||
| reg | RegisterStorage | |
| return | Identifier | |
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);
}
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 ApplicationBuilderTests()
{
arch = new X86ArchitectureFlat32();
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 FunctionType(
ret,
new Identifier[] { arg04, arg08, arg0C, regOut });
}
public void W32Mips_Trampoline()
{
var instrs = new List<RtlInstructionCluster>();
var frame = new Frame(PrimitiveType.Pointer32);
var r9 = frame.EnsureRegister(new RegisterStorage("r9", 9, PrimitiveType.Word32));
var rtl = new RtlTrace(0x123460)
{
m => m.Assign(r9, 0x00030000),
m => m.Assign(r9, m.LoadDw(m.IAdd(r9, 0x1234))),
m => m.Goto(r9)
};
var host = mr.Stub<IRewriterHost>();
var services = mr.Stub<IServiceProvider>();
var arch = mr.Stub<IProcessorArchitecture>();
var state = mr.Stub<ProcessorState>();
var addr = Address.Ptr32(0x00031234);
arch.Stub(a => a.CreateFrame()).Return(frame);
arch.Stub(a => a.CreateProcessorState()).Return(state);
arch.Stub(a => a.CreateRewriter(null, null, null, null)).IgnoreArguments().Return(rtl);
arch.Stub(a => a.MakeAddressFromConstant(Arg<Constant>.Is.NotNull)).Return(addr);
host.Stub(h => h.GetImportedProcedure(
Arg<Address>.Is.Equal(addr),
Arg<Address>.Is.NotNull)).Return(new ExternalProcedure("foo", new ProcedureSignature()));
mr.ReplayAll();
var platform = new Win32MipsPlatform(services, arch);
var result = platform.GetTrampolineDestination(new LeImageReader(new byte[0]), host);
Assert.IsNotNull(result);
}
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 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);
}
public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
int ncrn = 0;
int nsaa = 0;
// mem arg forb ret val
var argser = new ArgumentDeserializer(
this,
Architecture,
frame,
Architecture.PointerType.Size,
Architecture.WordWidth.Size);
Identifier ret = null;
if (ss.ReturnValue != null)
{
ret = argser.DeserializeReturnValue(ss.ReturnValue);
}
var args = new List<Identifier>();
if (ss.Arguments != null)
{
foreach (var sArg in ss.Arguments)
{
var dt = sArg.Type.Accept(TypeLoader);
var sizeInWords = (dt.Size + 3) / 4;
if (sizeInWords == 2 && (ncrn & 1) == 1)
++ncrn;
Identifier arg;
if (sizeInWords <= 4 - ncrn)
{
if (sizeInWords == 2)
{
arg = frame.EnsureSequence(
Architecture.GetRegister(argRegs[ncrn]),
Architecture.GetRegister(argRegs[ncrn + 1]),
dt);
ncrn += 2;
}
else
{
arg = frame.EnsureRegister(
Architecture.GetRegister(argRegs[ncrn]));
ncrn += 1;
}
}
else
{
arg = frame.EnsureStackArgument(nsaa, dt);
nsaa += AlignedStackArgumentSize(dt);
}
args.Add(arg);
}
}
return new FunctionType(ret, args.ToArray());
}
public void FrBindMixedParameters()
{
Frame f = new Frame(PrimitiveType.Word16);
Identifier ax = f.EnsureRegister(Registers.ax);
Identifier cx = f.EnsureRegister(Registers.cx);
int stack = PrimitiveType.Word16.Size;
Identifier arg1 = f.EnsureStackLocal(-stack, PrimitiveType.Word16);
ProcedureSignature sig = new ProcedureSignature(
ax,
cx,
new Identifier("arg0", PrimitiveType.Word16, new StackArgumentStorage(0, PrimitiveType.Word16)));
var cs = new CallSite(stack, 0);
ProcedureConstant fn = new ProcedureConstant(PrimitiveType.Pointer32, new PseudoProcedure("bar", sig));
ApplicationBuilder ab = new ApplicationBuilder(arch, f, cs, fn, sig, true);
Instruction instr = ab.CreateInstruction();
using (FileUnitTester fut = new FileUnitTester("Core/FrBindMixedParameters.txt"))
{
f.Write(fut.TextWriter);
fut.TextWriter.WriteLine(instr.ToString());
fut.AssertFilesEqual();
}
}
public Expression VisitRegisterStorage(RegisterStorage reg)
{
return(frame.EnsureRegister(reg));
}
public void Setup()
{
m = new ProcedureBuilder(arch);
frame = m.Frame;
ax = frame.EnsureRegister(new RegisterStorage("ax", 0, 0, PrimitiveType.Word16));
bx = frame.EnsureRegister(new RegisterStorage("bx", 3, 0, PrimitiveType.Word16));
cx = frame.EnsureRegister(new RegisterStorage("cx", 1, 0, PrimitiveType.Word16));
dx = frame.EnsureRegister(new RegisterStorage("dx", 2, 0, PrimitiveType.Word16));
flags = new FlagRegister("flags", PrimitiveType.Word16);
SCZ = frame.EnsureFlagGroup(flags, 7, "SCZ", PrimitiveType.Byte);
CF = frame.EnsureFlagGroup(flags, arch.CarryFlagMask, "C", PrimitiveType.Bool);
rw = new LongAddRewriter(m.Procedure, arch);
Procedure proc = new Procedure("test", frame);
block = new Block(proc, "bloke");
}
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 override Expression CreateStackAccess(Frame frame, int offset, DataType dataType)
{
var rsp = frame.EnsureRegister(Registers.rsp);
return MemoryAccess.Create(rsp, offset, dataType);
}
public override Expression CreateStackAccess(Frame frame, int cbOffset, DataType dataType)
{
return new MemoryAccess(new BinaryExpression(
Operator.IAdd, FramePointerType,
frame.EnsureRegister(StackRegister), Constant.Word32(cbOffset)),
dataType);
}
public void FrEnsureRegister()
{
Frame f = new Frame(PrimitiveType.Word32);
f.EnsureRegister(new RegisterStorage("eax", 0, 0, PrimitiveType.Word32));
Assert.AreEqual("eax", f.Identifiers[2].Name);
Assert.AreSame(PrimitiveType.Word32, f.Identifiers[2].DataType);
}
public void FrSequenceAccess()
{
Frame f = new Frame(PrimitiveType.Word16);
Identifier ax = f.EnsureRegister(Registers.ax);
Identifier dx = f.EnsureRegister(Registers.dx);
Identifier dx_ax = f.EnsureSequence(dx, ax, PrimitiveType.Word32);
SequenceStorage vDx_ax = (SequenceStorage) dx_ax.Storage;
using (FileUnitTester fut = new FileUnitTester("Core/FrSequenceAccess.txt"))
{
f.Write(fut.TextWriter);
fut.TextWriter.WriteLine("Head({0}) = {1}", dx_ax.Name, vDx_ax.Head.Name);
fut.TextWriter.WriteLine("Tail({0}) = {1}", dx_ax.Name, vDx_ax.Tail.Name);
fut.AssertFilesEqual();
}
}
