public PseudoProcedure EnsurePseudoProcedure(string name, DataType returnType, int arity)
{
if (!pprocs.TryGetValue(name, out PseudoProcedure p))
{
p = new PseudoProcedure(name, returnType, arity);
pprocs.Add(name, p);
}
return(p);
}
public Expression PseudoProcedure(string name, ProcedureCharacteristics c, DataType returnType, params Expression[] args)
{
var ppp = new PseudoProcedure(name, returnType, args.Length);
return(new Application(
new ProcedureConstant(arch.PointerType, ppp),
returnType,
args));
}
public PseudoProcedure EnsurePseudoProcedure(string name, DataType returnType, int arity)
{
if (ppp.TryGetValue(name, out var p))
{
return(p);
}
p = new PseudoProcedure(name, returnType, arity);
ppp.Add(name, p);
return(p);
}
public Expression CallIntrinsic(string name, FunctionType fnType, params Expression[] args)
{
if (!pprocs.TryGetValue(name, out var intrinsic))
{
intrinsic = new PseudoProcedure(name, fnType);
pprocs.Add(name, intrinsic);
}
return(new Application(
new ProcedureConstant(PrimitiveType.Ptr32, intrinsic),
intrinsic.ReturnType, args));
}
public Expression PseudoProc(PseudoProcedure ppp, DataType retType, params Expression[] args)
{
if (args.Length != ppp.Arity)
{
throw new ArgumentOutOfRangeException(
string.Format("Pseudoprocedure {0} expected {1} arguments, but was passed {2}.",
ppp.Name,
ppp.Arity,
args.Length));
}
return(m.Fn(new ProcedureConstant(arch.PointerType, ppp), retType, args));
}
public void Prog_EnsurePseudoProc()
{
PseudoProcedure ppp = program.EnsurePseudoProcedure("foo", VoidType.Instance, 3);
Assert.IsNotNull(ppp);
Assert.AreEqual("foo", ppp.Name);
Assert.AreEqual(1, program.PseudoProcedures.Count);
PseudoProcedure ppp2 = program.EnsurePseudoProcedure("foo", VoidType.Instance, 3);
Assert.IsNotNull(ppp2);
Assert.AreSame(ppp, ppp2);
Assert.AreEqual("foo", ppp.Name);
Assert.AreEqual(1, program.PseudoProcedures.Count);
}
protected void Given_RewriterHost()
{
host = new Mock <IRewriterHost>();
host.Setup(h => h.PseudoProcedure(
It.IsAny <string>(),
It.IsAny <DataType>(),
It.IsAny <Expression[]>()))
.Returns((string n, DataType dt, Expression[] a) =>
{
var fn = new FunctionType();
var ppp = new PseudoProcedure(n, fn);
return(new Application(new ProcedureConstant(fn, ppp),
dt,
a));
});
}
protected void Given_RewriterHost()
{
host = mr.Stub <IRewriterHost>();
host.Stub(h => h.PseudoProcedure(
Arg <string> .Is.Anything,
Arg <DataType> .Is.Anything,
Arg <Expression[]> .Is.Anything))
.Do(new Func <string, DataType, Expression[], Expression>((n, dt, a) =>
{
var fn = new FunctionType();
var ppp = new PseudoProcedure(n, fn);
return(new Application(new ProcedureConstant(fn, ppp),
dt,
a));
}));
}
private void RewriteJmp()
{
if (IsRealModeReboot(instrCur))
{
PseudoProcedure reboot = host.EnsurePseudoProcedure("__bios_reboot", VoidType.Instance, 0);
reboot.Characteristics = new Core.Serialization.ProcedureCharacteristics();
reboot.Characteristics.Terminates = true;
emitter.SideEffect(PseudoProc(reboot, VoidType.Instance));
return;
}
if (instrCur.op1 is ImmediateOperand)
{
Address addr = OperandAsCodeAddress(instrCur.op1);
emitter.Goto(addr);
return;
}
emitter.Goto(SrcOp(instrCur.op1));
}
protected override void BuildBody()
{
var sp = Frame.EnsureRegister(Registers.sp);
var a = Frame.EnsureRegister(Registers.a);
var c = Frame.EnsureRegister(Registers.c);
var h = Frame.EnsureRegister(Registers.h);
var l = Frame.EnsureRegister(Registers.l);
var C = Frame.EnsureFlagGroup(Architecture.GetFlagGroup("C"));
var Z = Frame.EnsureFlagGroup(Architecture.GetFlagGroup("Z"));
var SZC = Frame.EnsureFlagGroup(Architecture.GetFlagGroup("SZC"));
var SZP = Frame.EnsureFlagGroup(Architecture.GetFlagGroup("SZP"));
var rorc = new PseudoProcedure(
PseudoProcedure.RorC,
PrimitiveType.Byte,
3);
Assign(sp, Frame.FramePointer);
Label("m1Loop");
Assign(a, h);
Assign(a, Or(a, a));
Assign(SZC, Cond(a));
Assign(C, Constant.False());
Assign(a, Shr(a, Constant.Byte(1)));
Assign(C, Cond(a));
Assign(h, a);
Assign(a, l);
Assign(a, Fn(rorc, a, Constant.Byte(1), C));
Assign(C, Cond(a));
Assign(l, a);
Assign(c, ISub(c, 1));
Assign(SZP, Cond(c));
BranchIf(Test(ConditionCode.NE, Z), "m1Loop");
Label("m2Done");
MStore(Word32(0x1000), l);
MStore(Word32(0x1001), h);
Return();
}
public void Setup()
{
m = new ProcedureBuilder();
this.rolc_8 = new PseudoProcedure(PseudoProcedure.RolC, PrimitiveType.Byte, 3);
}
public Application Fn(PseudoProcedure ppp, params Expression[] args)
{
return(new Application(new ProcedureConstant(PrimitiveType.Pointer32, ppp), ppp.ReturnType, args));
}
public Application Fn(PseudoProcedure ppp, params Expression[] args)
{
return new Application(new ProcedureConstant(PrimitiveType.Pointer32, ppp), ppp.ReturnType, args);
}
public void Setup()
{
m = new ProcedureBuilder();
this.rolc_8 = new PseudoProcedure(PseudoProcedure.RolC, PrimitiveType.Byte, 3);
arch = new Mock <IProcessorArchitecture>();
}
