public FpuStackReturnGuesser(SsaState ssa, DecompilerEventListener listener) { this.ssa = ssa; this.ssam = new SsaMutator(ssa); this.ssaIdTransformer = new SsaIdentifierTransformer(ssa); this.listener = listener; }
public IndirectCallRewriter( Program program, SsaState ssa, DecompilerEventListener eventListener) { this.program = program; this.proc = ssa.Procedure; this.ssa = ssa; this.asc = new IndirectCallTypeAscender(program); this.expander = new IndirectCallExpander(ssa); this.ssaIdTransformer = new SsaIdentifierTransformer(ssa); this.eventListener = eventListener; this.ssam = new SsaMutator(ssa); }
private Statement?stmCur; //$REFACTOR: try to make this a context paramter. public ValuePropagator( SegmentMap segmentMap, SsaState ssa, CallGraph callGraph, IDynamicLinker dynamicLinker, DecompilerEventListener eventListener) { this.ssa = ssa; this.callGraph = callGraph; this.arch = ssa.Procedure.Architecture; this.eventListener = eventListener; this.ssam = new SsaMutator(ssa); this.evalCtx = new SsaEvaluationContext(arch, ssa.Identifiers, dynamicLinker); this.eval = new ExpressionSimplifier(segmentMap, evalCtx, eventListener); }
/// <summary> /// Rewrites CALL instructions to function applications. /// </summary> /// <remarks> /// Converts an instruction: /// <code> /// call procExpr /// </code> /// to one of: /// <code> /// ax = procExpr(bindings); /// procEexpr(bindings); /// </code> /// </remarks> /// <param name="ssaCaller">SSA state of the 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> public bool RewriteCall(SsaState ssaCaller, Statement stm, CallInstruction call) { if (call.Callee is ProcedureConstant callee) { var procCallee = callee.Procedure; var sigCallee = procCallee.Signature; var fn = new ProcedureConstant(platform.PointerType, procCallee); if (sigCallee == null || !sigCallee.ParametersValid) { return(false); } if (stm.LinearAddress == 0x000000000001e32) { stm.ToString(); //$DEBUG } ApplicationBuilder ab = CreateApplicationBuilder(ssaCaller, stm, call, fn); var instr = ab.CreateInstruction(sigCallee, procCallee.Characteristics); var instrOld = stm.Instruction; stm.Instruction = instr; var ssam = new SsaMutator(ssaCaller); ssam.AdjustSsa(stm, call); return(true); } else { return(false); #if NOT_READY_YET //$TODO // We have an indirect call with an unknown signature. // Use the guessed `uses` and `defs` to construct a signature. // It's likely going to be wrong, but it can be overridden with // user-provided metadata. var sigCallee = MakeSignature(ssaCaller, call.Uses, call.Definitions); var ab = CreateApplicationBuilder(ssaCaller, stm, call, call.Callee); var instr = ab.CreateInstruction(sigCallee, Core.Serialization.DefaultProcedureCharacteristics.Instance); stm.Instruction = instr; var ssam = new SsaMutator(ssaCaller); ssam.AdjustSsa(stm, call); return(true); #endif } }
private void BypassRegisterOffsets(Dictionary <Procedure, int?> savedSps, RegisterStorage register) { foreach (var ssa in this.ssas.Values) { var callStms = ssa.Procedure.Statements .Where(stm => stm.Instruction is CallInstruction) .ToList(); var ssam = new SsaMutator(ssa); foreach (var stm in callStms) { var call = (CallInstruction)stm.Instruction; if (!((call.Callee as ProcedureConstant)?.Procedure is Procedure proc)) { continue; } if (savedSps.TryGetValue(proc, out var delta) && delta.HasValue) { ssam.AdjustRegisterAfterCall(stm, call, register, delta.Value); } } } }
public FpuStackReturnGuesser(SsaState ssa) { this.ssa = ssa; this.ssam = new SsaMutator(ssa); this.ssaIdTransformer = new SsaIdentifierTransformer(ssa); }