public void WriteProcedureConstant()
{
var proc = new Procedure("proc", new Frame(PrimitiveType.Word32));
var pc = new ProcedureConstant(PrimitiveType.Word32, proc);
map.Add(Address.Ptr32(0x42), proc);
pc.Accept(hcf);
Assert.AreEqual("<a href=\"00000042\">proc</a>", sb.ToString());
}
public override void VisitProcedureConstant(ProcedureConstant pc)
{
//$REVIEW: this may be very slow, in which case we will need to add an Address
// field to the Procedure class.
foreach (var de in procedureMap)
{
if (de.Value == pc.Procedure)
{
formatter.WriteHyperlink(pc.Procedure.Name, de.Key.ToString());
return;
}
}
base.VisitProcedureConstant(pc);
}
/// <summary>
/// Rewrites CALL instructions to function applications.
/// </summary>
/// <remarks>
/// Converts an opcode:
/// <code>
/// call procExpr
/// </code>
/// to one of:
/// <code>
/// ax = procExpr(bindings);
/// procEexpr(bindings);
/// </code>
/// </remarks>
/// <param name="proc">Procedure in which the CALL instruction exists</param>
/// <param name="stm">The particular statement of the call instruction</param>
/// <param name="call">The actuall CALL instruction.</param>
/// <returns>True if the conversion was possible, false if the procedure didn't have
/// a signature yet.</returns>
public bool RewriteCall(Procedure proc, Statement stm, CallInstruction call)
{
var callee = call.Callee as ProcedureConstant;
if (callee == null)
return false; //$REVIEW: what happens with indirect calls?
var procCallee = callee.Procedure;
var sigCallee = GetProcedureSignature(procCallee);
var fn = new ProcedureConstant(Program.Platform.PointerType, procCallee);
if (sigCallee == null || !sigCallee.ParametersValid)
return false;
var ab = new ApplicationBuilder(Program.Architecture, proc.Frame, call.CallSite, fn, sigCallee, true);
stm.Instruction = ab.CreateInstruction();
return true;
}
public void ExtpBind()
{
var sig = new ProcedureSignature(
new Identifier(Registers.ax.Name, PrimitiveType.Word16, Registers.ax),
new Identifier [] {
new Identifier(Registers.bx.Name, PrimitiveType.Word16, Registers.bx),
new Identifier(Registers.cl.Name, PrimitiveType.Byte, Registers.cl) } );
var ep = new ExternalProcedure("foo", sig);
Assert.AreEqual("Register word16 foo(Register word16 bx, Register byte cl)", ep.ToString());
var fn = new ProcedureConstant(PrimitiveType.Pointer32, ep);
var arch = new FakeArchitecture();
var frame = arch.CreateFrame();
var ab = new ApplicationBuilder(new FakeArchitecture(), frame, new CallSite(0, 0), fn, ep.Signature, false);
var instr = ab.CreateInstruction();
Assert.AreEqual("ax = foo(bx, cl)", instr.ToString());
}
public void Creation()
{
CallGraph g = new CallGraph();
Procedure p1 = new Procedure("p1000", null);
Procedure p2 = new Procedure("p2000", null);
Procedure p3 = new Procedure("p3000", null);
Procedure p4 = new Procedure("p4000", null);
var pc1 = new ProcedureConstant(PrimitiveType.Pointer32, p1);
var pc2 = new ProcedureConstant(PrimitiveType.Pointer32, p2);
var pc3 = new ProcedureConstant(PrimitiveType.Pointer32, p3);
var pc4 = new ProcedureConstant(PrimitiveType.Pointer32, p4);
Statement s11 = new Statement(0, CreateCall(pc2), p1.EntryBlock);
Statement s12 = new Statement(0, CreateCall(pc2), p1.EntryBlock);
Statement s13 = new Statement(0, CreateCall(pc3), p1.EntryBlock);
p1.EntryBlock.Statements.Add(s11);
p1.EntryBlock.Statements.Add(s12);
p1.EntryBlock.Statements.Add(s13);
Statement s21 = new Statement(0, CreateCall(pc3), p2.EntryBlock);
Statement s22 = new Statement(0, CreateCall(pc4), p2.EntryBlock);
p2.EntryBlock.Statements.Add(s21);
p2.EntryBlock.Statements.Add(s22);
Statement s31 = new Statement(0, CreateCall(pc4), p3.EntryBlock);
p3.EntryBlock.Statements.Add(s31);
Statement s41 = new Statement(0, CreateCall(pc4), p4.EntryBlock);
g.AddEntryPoint(p1);
g.AddEdge(s11, p2);
g.AddEdge(s12, p2);
g.AddEdge(s13, p3);
g.AddEdge(s21, p3);
g.AddEdge(s22, p4);
g.AddEdge(s31, p4);
g.AddEdge(s41, p4); // recursion!
//$TODO: need Count
// Assert.IsTrue(g.Callees(p1).Count == 3);
// Assert.IsTrue(g.CallerStatements(p4).Count == 3);
}
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 DataType VisitProcedureConstant(ProcedureConstant pc)
{
return(pc.DataType);
}
public void VisitProcedureConstant(ProcedureConstant pc)
{
handler.DataTypeTrait(pc, program.Platform.PointerType);
}
public void VpReusedRegistersAtCall()
{
var sExp =
#region Expected
@"r2_1: orig: r2
def: r2_1 = Mem4[0x220200<32>:word32]
uses: r4_1 = r2_1
callee(r2_1)
r2_2: orig: r2
def: r2_2 = callee
r4_1: orig: r4
def: r4_1 = r2_1
r25_1: orig: r25
def: r25_1 = callee
Mem4: orig: Mem0
uses: r2_1 = Mem4[0x220200<32>:word32]
Mem5: orig: Mem0
// SsaProcedureBuilder
// Return size: 0
define SsaProcedureBuilder
SsaProcedureBuilder_entry:
// succ: l1
l1:
r2_1 = Mem4[0x220200<32>:word32]
r4_1 = r2_1
r2_2 = callee
r25_1 = callee
callee(r2_1)
return
// succ: SsaProcedureBuilder_exit
SsaProcedureBuilder_exit:
";
#endregion
var uAddrGotSlot = m.Word32(0x0040000);
var reg2 = new RegisterStorage("r2", 2, 0, PrimitiveType.Word32);
var reg4 = new RegisterStorage("r4", 4, 0, PrimitiveType.Word32);
var reg25 = new RegisterStorage("r25", 25, 0, PrimitiveType.Word32);
var r2_1 = m.Reg("r2_1", reg2);
var r2_2 = m.Reg("r2_2", reg2);
var r4_1 = m.Reg("r4_1", reg4);
var r25_1 = m.Reg("r25_1", reg25);
m.Assign(r2_1, m.Mem32(m.Word32(0x0220200))); // fetch a string pointer perhaps
m.Assign(r4_1, r2_1);
m.Assign(r2_2, m.Mem32(uAddrGotSlot)); // pointer to a function in a lookup table.
m.Assign(r25_1, r2_2);
var stmCall = m.Call(r25_1, 0,
new Identifier[] { r4_1, r2_2 },
new Identifier[] { });
m.Return();
// Initially we don't know what r2_2 is pointing to.
var vp = new ValuePropagator(segmentMap, m.Ssa, program.CallGraph, dynamicLinker.Object, listener);
vp.Transform();
// Later, Reko discovers information about the pointer in 0x400000<32>!
var sigCallee = FunctionType.Action(
new Identifier("r4", PrimitiveType.Word64, reg4));
var callee = new ProcedureConstant(
PrimitiveType.Ptr32,
new ExternalProcedure("callee", sigCallee));
// Add our new found knowledge to the import resolver.
dynamicLinker.Setup(i => i.ResolveToImportedValue(
It.IsNotNull <Statement>(),
uAddrGotSlot)).
Returns(callee);
// Run Value propagation again with the newly gathered information.
vp.Transform();
m.Ssa.Validate(s => Assert.Fail(s));
AssertStringsEqual(sExp, m.Ssa);
}
public virtual void VisitProcedureConstant(ProcedureConstant pc)
{
writer.WriteHyperlink(pc.Procedure.Name, pc.Procedure);
}
public virtual void VisitProcedureConstant(ProcedureConstant pc)
{
}
public void VisitProcedureConstant(ProcedureConstant pc)
{
handler.DataTypeTrait(pc, program.Platform.PointerType);
}
public bool Match(Identifier id)
{
this.id = id;
this.pc = ctx.GetValue(id) as ProcedureConstant;
return pc != null;
}
public SlicerResult VisitProcedureConstant(ProcedureConstant pc, BackwardSlicerContext ctx)
{
throw new NotImplementedException();
}
public override void VisitProcedureConstant(ProcedureConstant pc)
{
EnsureTypeVariable(pc);
VisitProcedure(pc.Procedure);
if (pc.Procedure.Signature != null)
{
store.MergeClasses(pc.TypeVariable, pc.Procedure.Signature.TypeVariable);
signature = pc.Procedure.Signature;
}
}
public virtual Expression VisitProcedureConstant(ProcedureConstant pc)
{
return(pc);
}
public bool VisitProcedureConstant(ProcedureConstant pc) => false;
public void Vafs_X86Sprintf()
{
Given_VaScanner(x86);
Given_StackString(8, "%c");
Assert.IsTrue(vafs.TryScan(addrInstr, x86SprintfSig, printfChr));
var ep = new ExternalProcedure("sprintf", x86SprintfSig);
var pc = new ProcedureConstant(new CodeType(), ep);
var instr = vafs.BuildInstruction(pc, new CallSite(4, 0));
Assert.AreEqual(
"sprintf(Mem0[esp:(ptr char)], Mem0[esp + 4:(ptr char)], " +
"Mem0[esp + 8:char])",
instr.ToString());
var appl = (Application)((SideEffect)instr).Expression;
var sig = ((ProcedureConstant)appl.Procedure).Procedure.Signature;
Assert.AreEqual(
"(fn void ((ptr char), (ptr char), char))",
sig.ToString());
}
public void VisitProcedureConstant(ProcedureConstant pc)
{
js.Write(pc.Procedure.Name);
}
public Result VisitProcedureConstant(ProcedureConstant pc)
{
return(new Result {
Value = pc, PropagatedExpression = pc
});
}
public Expression VisitProcedureConstant(ProcedureConstant pc)
{
throw new NotImplementedException();
}
public BitRange VisitProcedureConstant(ProcedureConstant pc)
{
return(BitRange.Empty);
}
private CallInstruction CreateCall(ProcedureConstant pc)
{
return new CallInstruction(pc, new CallSite(4, 0));
}
public virtual void VisitProcedureConstant(ProcedureConstant pc)
{
writer.WriteHyperlink(pc.Procedure.Name, pc.Procedure);
}
public bool Match(Identifier id)
{
this.id = id;
this.pc = ctx.GetValue(id) as ProcedureConstant;
return(pc != null);
}
public void VpIndirectCall()
{
var callee = CreateExternalProcedure(
"foo",
12,
RegArg(1, "r1"),
StackArg(4),
StackArg(8));
var pc = new ProcedureConstant(PrimitiveType.Ptr32, callee);
var m = new ProcedureBuilder();
var r1 = m.Reg32("r1", 1);
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
m.Assign(sp, m.Frame.FramePointer);
m.Assign(r1, pc);
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Word32(3));
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Mem16(m.Word32(0x1231230)));
m.Call(r1, 4);
m.Return();
arch.Setup(a => a.CreateStackAccess(
It.IsAny <IStorageBinder>(),
It.IsAny <int>(),
It.IsAny <DataType>()))
.Returns((IStorageBinder f, int off, DataType dt) =>
m.Mem(dt, m.IAdd(f.EnsureRegister((RegisterStorage)sp.Storage), off)));
arch.Setup(s => s.CreateFrameApplicationBuilder(
It.IsAny <IStorageBinder>(),
It.IsAny <CallSite>(),
It.IsAny <Expression>()))
.Returns((IStorageBinder binder, CallSite site, Expression c) =>
new FrameApplicationBuilder(arch.Object, binder, site, c, false));
var ssa = RunTest(m);
var sExp =
#region Expected
@"fp:fp
def: def fp
uses: r63_2 = fp
r63_4 = fp - 4<32>
Mem5[fp - 4<32>:word32] = 3<32>
r63_6 = fp - 8<32>
Mem7[fp - 8<32>:word16] = Mem5[0x1231230<32>:word16]
r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
r63_2: orig: r63
def: r63_2 = fp
r1_3: orig: r1
def: r1_3 = foo
r63_4: orig: r63
def: r63_4 = fp - 4<32>
Mem5: orig: Mem0
def: Mem5[fp - 4<32>:word32] = 3<32>
uses: Mem7[fp - 8<32>:word16] = Mem5[0x1231230<32>:word16]
r63_6: orig: r63
def: r63_6 = fp - 8<32>
Mem7: orig: Mem0
def: Mem7[fp - 8<32>:word16] = Mem5[0x1231230<32>:word16]
uses: r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
r1_8: orig: r1
def: r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
// ProcedureBuilder
// Return size: 0
define ProcedureBuilder
ProcedureBuilder_entry:
def fp
// succ: l1
l1:
r63_2 = fp
r1_3 = foo
r63_4 = fp - 4<32>
Mem5[fp - 4<32>:word32] = 3<32>
r63_6 = fp - 8<32>
Mem7[fp - 8<32>:word16] = Mem5[0x1231230<32>:word16]
r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
return
// succ: ProcedureBuilder_exit
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
public bool VisitProcedureConstant(ProcedureConstant pc, TypeVariable tv)
{
//throw new NotImplementedException();
return(false);
}
public void VpIndirectCall()
{
var callee = CreateExternalProcedure("foo", RegArg(1, "r1"), StackArg(4), StackArg(8));
var pc = new ProcedureConstant(PrimitiveType.Pointer32, callee);
var m = new ProcedureBuilder();
var r1 = m.Reg32("r1", 1);
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
m.Assign(r1, pc);
m.Assign(sp, m.ISub(sp, 4));
m.Store(sp, 3);
m.Assign(sp, m.ISub(sp, 4));
m.Store(sp, m.LoadW(m.Word32(0x1231230)));
m.Call(r1, 4);
m.Return();
arch.Stub(a => a.CreateStackAccess(null, 0, null))
.IgnoreArguments()
.Do(new Func<Frame, int, DataType, Expression>((f, off, dt) => m.Load(dt, m.IAdd(sp, off))));
mr.ReplayAll();
var ssa = RunTest(m);
var sExp =
#region Expected
@"r1_0: orig: r1
def: r1_0 = foo
r63:r63
def: def r63
uses: r63_2 = r63 - 0x00000004
Mem3[r63 - 0x00000004:word32] = 0x00000003
r63_4 = r63 - 0x00000008
Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r63_2: orig: r63
def: r63_2 = r63 - 0x00000004
Mem3: orig: Mem0
def: Mem3[r63 - 0x00000004:word32] = 0x00000003
uses: Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r63_4: orig: r63
def: r63_4 = r63 - 0x00000008
Mem5: orig: Mem0
def: Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6: orig: r1
def: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r63_7: orig: r63
Mem8: orig: Mem0
uses: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
Mem9: orig: Mem0
uses: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
// ProcedureBuilder
// Return size: 0
void ProcedureBuilder()
ProcedureBuilder_entry:
def r63
// succ: l1
l1:
r1_0 = foo
r63_2 = r63 - 0x00000004
Mem3[r63 - 0x00000004:word32] = 0x00000003
r63_4 = r63 - 0x00000008
Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
return
// succ: ProcedureBuilder_exit
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
public void FrBindStackParameters()
{
Frame f = new Frame(PrimitiveType.Word16);
f.ReturnAddressSize = 4; // far call.
int stack = 2;
Identifier loc02 = f.EnsureStackLocal(-stack, PrimitiveType.Word16, "wLoc02");
stack += loc02.DataType.Size;
Identifier loc04 = f.EnsureStackLocal(-stack, PrimitiveType.Word16, "wLoc04");
ProcedureSignature sig = new ProcedureSignature(
null, new Identifier[] {
new Identifier("arg0", PrimitiveType.Word16, new StackArgumentStorage(4, PrimitiveType.Word16)),
new Identifier("arg1", PrimitiveType.Word16, new StackArgumentStorage(6, PrimitiveType.Word16)) });
var cs = new CallSite(f.ReturnAddressSize + 2 * 4, 0);
var fn = new ProcedureConstant(PrimitiveType.Pointer32, new PseudoProcedure("foo", sig));
ApplicationBuilder ab = new ApplicationBuilder(arch, f, cs, fn, sig, true);
Instruction instr = ab.CreateInstruction();
using (FileUnitTester fut = new FileUnitTester("Core/FrBindStackParameters.txt"))
{
f.Write(fut.TextWriter);
fut.TextWriter.WriteLine(instr.ToString());
fut.AssertFilesEqual();
}
}
public void VpIndirectCall()
{
var callee = CreateExternalProcedure("foo", RegArg(1, "r1"), StackArg(4), StackArg(8));
var pc = new ProcedureConstant(PrimitiveType.Ptr32, callee);
var m = new ProcedureBuilder();
var r1 = m.Reg32("r1", 1);
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
m.Assign(r1, pc);
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Word32(3));
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Mem16(m.Word32(0x1231230)));
m.Call(r1, 4);
m.Return();
arch.Stub(a => a.CreateStackAccess(null, 0, null))
.IgnoreArguments()
.Do(new Func <IStorageBinder, int, DataType, Expression>((f, off, dt) => m.Mem(dt, m.IAdd(sp, off))));
mr.ReplayAll();
var ssa = RunTest(m);
var sExp =
#region Expected
@"r1_0: orig: r1
def: r1_0 = foo
r63:r63
def: def r63
uses: r63_2 = r63 - 0x00000004
Mem3[r63 - 0x00000004:word32] = 0x00000003
r63_4 = r63 - 0x00000008
Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r63_2: orig: r63
def: r63_2 = r63 - 0x00000004
Mem3: orig: Mem0
def: Mem3[r63 - 0x00000004:word32] = 0x00000003
uses: Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r63_4: orig: r63
def: r63_4 = r63 - 0x00000008
Mem5: orig: Mem0
def: Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6: orig: r1
def: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r63_7: orig: r63
Mem8: orig: Mem0
uses: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
Mem9: orig: Mem0
uses: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
// ProcedureBuilder
// Return size: 0
void ProcedureBuilder()
ProcedureBuilder_entry:
def r63
// succ: l1
l1:
r1_0 = foo
r63_2 = r63 - 0x00000004
Mem3[r63 - 0x00000004:word32] = 0x00000003
r63_4 = r63 - 0x00000008
Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
return
// succ: ProcedureBuilder_exit
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
private CallInstruction CreateCall(ProcedureConstant pc)
{
return(new CallInstruction(pc, new CallSite(4, 0)));
}
public bool VisitProcedureConstant(ProcedureConstant pc)
{
return(false);
}
public Expression VisitProcedureConstant(ProcedureConstant pc)
{
return(new ProcedureConstant(pc.DataType, pc.Procedure));
}
public Statement Call(ProcedureBase callee, int retSizeOnStack)
{
ProcedureConstant c = new ProcedureConstant(PrimitiveType.Pointer32, callee);
CallInstruction ci = new CallInstruction(c, new CallSite(retSizeOnStack, 0));
return Emit(ci);
}
void IExpressionVisitor.VisitProcedureConstant(ProcedureConstant pc)
{
writer.Write("\"");
writer.Write(pc.Procedure.Name);
writer.Write("\"");
}
public virtual void VisitProcedureConstant(ProcedureConstant pc)
{
}
public ValueSet VisitProcedureConstant(ProcedureConstant pc)
{
throw new NotImplementedException();
}
