public EquivalenceClassBuilder(TypeFactory factory, TypeStore store) { this.factory = factory; this.store = store; this.signature = null; this.segTypevars = new Dictionary<ushort, TypeVariable>(); }
public void ApplySignatureToProcedure(Address addr, ProcedureSignature sig, Procedure proc) { proc.Signature = sig; int i = 0; var stmts = proc.EntryBlock.Succ[0].Statements; var linAddr = addr.ToLinear(); foreach (var param in sig.Parameters) { var starg = param.Storage as StackArgumentStorage; if (starg != null) { proc.Frame.EnsureStackArgument( starg.StackOffset + sig.ReturnAddressOnStack, param.DataType, param.Name); } else { var paramId = proc.Frame.EnsureIdentifier(param.Storage); paramId.DataType = param.DataType; // Need to take an extra step with parameters being passed // in a register. It's perfectly possible for a user to // create a variable which they want to call 'r2' but which // the calling convention of the machine wants to call 'r1'. // To avoid this, we create a temporary identifier for // the formal parameter, and inject an copy statement in the // entry block that moves the parameter value into the // register. stmts.Insert(i, linAddr, NewMethod(param, paramId)); ++i; } } }
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>(); if (ss.Arguments != null) { for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg) { var sArg = ss.Arguments[iArg]; Identifier arg = argser.Deserialize(sArg); args.Add(arg); } } var sig = new ProcedureSignature(ret, args.ToArray()); return sig; }
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 void ApplyConvention(SerializedSignature ssig, ProcedureSignature sig) { string d = ssig.Convention; if (d == null || d.Length == 0) d = DefaultConvention; sig.StackDelta = 0; sig.FpuStackDelta = FpuStackOffset; }
public void Setup() { this.mr = new MockRepository(); this.arch = new MipsLe32Architecture(); this.typeLoader = mr.Stub<ISerializedTypeVisitor<DataType>>(); this.ssig = null; this.sig = null; }
public void ApplyConvention(SerializedSignature ssig, ProcedureSignature sig) { string d = ssig.Convention; if (d == null || d.Length == 0) d = DefaultConvention; if (d == "stdapi" || d == "__stdcall" || d == "pascal") sig.StackDelta = StackOffset; sig.FpuStackDelta = FpuStackOffset; }
public void ApplyConvention(SerializedSignature ssig, ProcedureSignature sig) { string d = ssig.Convention; if (d == null || d.Length == 0) d = DefaultConvention; sig.StackDelta = Architecture.PointerType.Size; //$BUG: far/near pointers? if (d == "stdapi" || d == "__stdcall" || d == "pascal") sig.StackDelta += StackOffset; sig.FpuStackDelta = FpuStackOffset; sig.ReturnAddressOnStack = Architecture.PointerType.Size; //$BUG: x86 real mode? }
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 PsigValidArguments() { Identifier arg = new Identifier(Registers.eax.Name, Registers.eax.DataType, Registers.eax); ProcedureSignature sig = new ProcedureSignature(null, new Identifier[] { arg }); Assert.IsTrue(sig.ParametersValid); sig = new ProcedureSignature(arg, null); Assert.IsTrue(sig.ParametersValid); sig = new ProcedureSignature(); Assert.IsFalse(sig.ParametersValid); }
private void RewriteFormals(ProcedureSignature sig) { if (sig.ReturnValue != null) sig.ReturnValue.DataType = sig.ReturnValue.TypeVariable.DataType; if (sig.Parameters != null) { foreach (Identifier formalArg in sig.Parameters) { if (formalArg.TypeVariable != null) formalArg.DataType = formalArg.TypeVariable.DataType; } } }
public void EnsureSignatureTypeVariables(ProcedureSignature signature) { if (signature == null || !signature.ParametersValid) return; if (signature.ReturnValue != null) { signature.ReturnValue.Accept(this); } foreach (var param in signature.Parameters) { param.Accept(this); } }
/// <summary> /// Creates an application builder. /// </summary> /// <param name="arch">The processor architecture to use.</param> /// <param name="frame">The Frame of the calling procedure.</param> /// <param name="site">The call site of the calling instruction.</param> /// <param name="callee">The procedure being called.</param> /// <param name="sigCallee">The signature of the procedure being called.</param> /// <param name="ensureVariables">If true, creates variables in the <paramref name="frame"/> if needed.</param> public ApplicationBuilder( IProcessorArchitecture arch, Frame frame, CallSite site, Expression callee, ProcedureSignature sigCallee, bool ensureVariables) { this.arch = arch; this.site = site; this.frame = frame; this.callee = callee; this.sigCallee = sigCallee; this.ensureVariables = ensureVariables; }
public void Test() { Given_ProcedureSerializer("stdapi"); ProcedureSignature sig = new ProcedureSignature( new Identifier("qax", PrimitiveType.Word32, Registers.eax), new Identifier[] { new Identifier("qbx", PrimitiveType.Word32, Registers.ebx) }); SerializedSignature ssig = ser.Serialize(sig); Assert.IsNotNull(ssig.ReturnValue); Assert.AreEqual("qax", ssig.ReturnValue.Name); Register_v1 sreg = (Register_v1) ssig.ReturnValue.Kind; Assert.AreEqual("eax", sreg.Name); }
public void PpcPs_Serialize() { Given_ProcedureSerializer(); ProcedureSignature sig = new ProcedureSignature( new Identifier("qax", PrimitiveType.Word32, arch.Registers[3]), new Identifier[] { new Identifier("qbx", PrimitiveType.Word32, arch.Registers[3]) }); SerializedSignature ssig = ser.Serialize(sig); Assert.IsNotNull(ssig.ReturnValue); Assert.AreEqual("qax", ssig.ReturnValue.Name); Register_v1 sreg = (Register_v1)ssig.ReturnValue.Kind; Assert.AreEqual("r3", sreg.Name); }
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 Build(Program program) { // Special case for the global variables. In essence, // a memory map of all the globals. store.EnsureExpressionTypeVariable(factory, program.Globals, "globals_t"); foreach (Procedure proc in program.Procedures.Values) { this.signature = proc.Signature; EnsureSignatureTypeVariables(this.signature); foreach (Statement stm in proc.Statements) { stm.Instruction.Accept(this); } } }
public void SvAmdPs_Serialize() { Given_ProcedureSerializer(); mr.ReplayAll(); var sig = new ProcedureSignature( new Identifier("rbx", PrimitiveType.Word32, arch.GetRegister("rbx")), new Identifier[] { new Identifier("rbx", PrimitiveType.Word32, arch.GetRegister("rbx")) }); SerializedSignature ssig = ser.Serialize(sig); Assert.IsNotNull(ssig.ReturnValue); Assert.AreEqual("rbx", ssig.ReturnValue.Name); Register_v1 sreg = (Register_v1)ssig.ReturnValue.Kind; Assert.AreEqual("rbx", sreg.Name); }
public override List<Expression> BindArguments(Frame frame, ProcedureSignature sigCallee) { var actuals = new List<Expression>(); int i; for (i = 0; i < sigCallee.Parameters.Length-1; ++i) { var formalArg = sigCallee.Parameters[i]; var actualArg = formalArg.Storage.Accept(this); if (formalArg.Storage is OutArgumentStorage) { actuals.Add(new OutArgument(frame.FramePointer.DataType, actualArg)); } else { actuals.Add(actualArg); } } return actuals; }
public override List <Expression> BindArguments(Frame frame, ProcedureSignature sigCallee) { var actuals = new List <Expression>(); int i; for (i = 0; i < sigCallee.Parameters.Length - 1; ++i) { var formalArg = sigCallee.Parameters[i]; var actualArg = formalArg.Storage.Accept(this); if (formalArg.Storage is OutArgumentStorage) { actuals.Add(new OutArgument(frame.FramePointer.DataType, actualArg)); } else { actuals.Add(actualArg); } } return(actuals); }
public override void VisitApplication(Application appl) { signature = null; appl.Procedure.Accept(this); ProcedureSignature sig = signature; if (sig != null) { if (sig.Parameters.Length != appl.Arguments.Length) throw new InvalidOperationException("Parameter count must match."); } for (int i = 0; i < appl.Arguments.Length; ++i) { appl.Arguments[i].Accept(this); if (sig != null) { EnsureTypeVariable(sig.Parameters[i]); store.MergeClasses(appl.Arguments[i].TypeVariable, sig.Parameters[i].TypeVariable); } } EnsureTypeVariable(appl); }
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 virtual List <Expression> BindArguments(Frame frame, ProcedureSignature sigCallee) { if (sigCallee == null || !sigCallee.ParametersValid) { throw new InvalidOperationException("No signature available; application cannot be constructed."); } this.sigCallee = sigCallee; var actuals = new List <Expression>(); for (int i = 0; i < sigCallee.Parameters.Length; ++i) { var formalArg = sigCallee.Parameters[i]; var actualArg = formalArg.Storage.Accept(this); if (formalArg.Storage is OutArgumentStorage) { actuals.Add(new OutArgument(frame.FramePointer.DataType, actualArg)); } else { actuals.Add(actualArg); } } return(actuals); }
public void AddCallSignature(Address addr, ProcedureSignature sig) { callSignatures[addr] = sig; }
public ExternalProcedure(string name, ProcedureSignature signature, ProcedureCharacteristics chars) : base(name) { this.Signature = signature; this.Characteristics = chars; }
public PrintfApplicationBuilder( IProcessorArchitecture arch, Frame frame, CallSite site, Expression callee, ProcedureSignature sigCallee, bool ensureVariables) : base(arch, frame, site, callee, sigCallee, ensureVariables) { }
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 override void OnAfterCall(Identifier stackReg, ProcedureSignature sigCallee, ExpressionVisitor<Expression> eval) { throw new NotImplementedException(); }
public ExternalProcedure(string name, ProcedureSignature signature) : base(name) { this.Signature = signature; }
public override void OnProcedureLeft(ProcedureSignature sig) { }
public override void OnAfterCall(ProcedureSignature sigCallee) { }
/// <summary> /// Perform any adjustments to the processor's state after returning from a procedure call with the /// specified signature. /// </summary> /// <param name="sigCallee">The signature of the called procedure.</param> public abstract void OnAfterCall(Identifier stackReg, ProcedureSignature sigCallee, ExpressionVisitor <Expression> eval);
public virtual string DetermineCallingConvention(ProcedureSignature signature) { return(null); }
public override void OnAfterCall(Identifier sp, ProcedureSignature sigCallee, ExpressionVisitor<Expression> eval) { }
public override void OnProcedureLeft(ProcedureSignature procedureSignature) { throw new NotImplementedException(); }
public override void OnAfterCall(Identifier sp, ProcedureSignature sigCallee, ExpressionVisitor<Expression> eval) { var spReg = (RegisterStorage) sp.Storage; var spVal = GetValue(spReg); var stackOffset = SetValue( spReg, new BinaryExpression( Operator.IAdd, spVal.DataType, sp, Constant.Create( PrimitiveType.CreateWord(spReg.DataType.Size), sigCallee.StackDelta)).Accept(eval)); if (stackOffset.IsValid) { if (stackOffset.ToInt32() > 0) ErrorListener("Possible stack underflow detected."); } }
public abstract void OnProcedureEntered(); // Some registers need to be updated when a procedure is entered. public abstract void OnProcedureLeft(ProcedureSignature procedureSignature);
public PseudoProcedure(string name, ProcedureSignature sig) : base(name) { this.sig = sig; }
/// <summary> /// Perform any adjustments to the processor's state after returning from a procedure call with the /// specified signature. /// </summary> /// <param name="sigCallee">The signature of the called procedure.</param> public abstract void OnAfterCall(ProcedureSignature sigCallee);