public void CollectTypes()
{
desc.MeetDataType(program.Globals, factory.CreatePointer(
factory.CreateStructureType(),
program.Platform.PointerType.Size));
CollectSegmentTypes();
foreach (Procedure p in program.Procedures.Values)
{
proc = p;
CollectProcedureSignature(p);
foreach (Statement stm in p.Statements)
{
if (eventListener.IsCanceled())
{
return;
}
try
{
stm.Instruction.Accept(this);
}
catch (Exception ex)
{
eventListener.Error(
eventListener.CreateStatementNavigator(program, stm),
ex,
"An error occurred while processing the statement {0}.",
stm);
}
}
}
}
public void CollectTypes()
{
CollectGlobalType();
CollectUserGlobalVariableTypes();
CollectImageSymbols();
int cProc = program.Procedures.Count;
int i = 0;
foreach (Procedure proc in program.Procedures.Values)
{
eventListener.ShowProgress("Collecting data types.", i++, cProc);
CollectProcedureSignature(proc);
foreach (Statement stm in proc.Statements)
{
if (eventListener.IsCanceled())
{
return;
}
try
{
this.stmCur = stm;
stm.Instruction.Accept(this);
}
catch (Exception ex)
{
eventListener.Error(
eventListener.CreateStatementNavigator(program, stm),
ex,
"An error occurred while processing the statement {0}.",
stm);
}
}
}
}
public void CollectTypes()
{
desc.MeetDataType(program.Globals, factory.CreatePointer(
factory.CreateStructureType(),
program.Platform.PointerType.BitSize));
CollectUserGlobalVariableTypes(store.SegmentTypes);
int cProc = program.Procedures.Count;
int i = 0;
foreach (Procedure proc in program.Procedures.Values)
{
eventListener.ShowProgress("Collecting data types.", i++, cProc);
CollectProcedureSignature(proc);
foreach (Statement stm in proc.Statements)
{
if (eventListener.IsCanceled())
{
return;
}
try
{
this.stmCur = stm;
stm.Instruction.Accept(this);
}
catch (Exception ex)
{
eventListener.Error(
eventListener.CreateStatementNavigator(program, stm),
ex,
"An error occurred while processing the statement {0}.",
stm);
}
}
}
}
/// <summary>
/// Rewrites indirect call statements to applications using
/// user-defined data. Also generates statements that adjust
/// the stack pointer according to the calling convention.
/// </summary>
/// <returns>True if statements were changed.</returns>
public bool Rewrite()
{
changed = false;
foreach (Statement stm in proc.Statements.ToList())
{
if (stm.Instruction is CallInstruction ci)
{
try
{
RewriteCall(stm, ci);
}
catch (Exception ex)
{
eventListener.Error(
eventListener.CreateStatementNavigator(program, stm),
ex,
"Indirect call rewriter encountered an error while processing the statement {0}.",
stm);
}
}
}
return(changed);
}
public void Rewrite()
{
foreach (Statement stm in proc.Statements)
{
CallInstruction ci = stm.Instruction as CallInstruction;
if (ci != null)
{
try
{
RewriteCall(stm, ci);
throw new NotImplementedException("bleh"); //$DEBUG
}
catch (Exception ex)
{
eventListener.Error(
eventListener.CreateStatementNavigator(program, stm),
ex,
"Indirect call rewriter encountered an error while processing the statement {0}.",
stm);
}
}
}
}
public void Transform()
{
foreach (var s in ssaIds.ToList())
{
sidGrf = s;
if (!IsLocallyDefinedFlagGroup(sidGrf))
{
continue;
}
if (sidGrf.DefStatement !.Instruction is AliasAssignment)
{
continue;
}
var uses = new HashSet <Statement>();
this.aliases.Clear();
ClosureOfUsingStatements(sidGrf, uses, aliases);
trace.Inform("CCE: Tracing {0}", sidGrf.DefStatement.Instruction);
foreach (var u in uses)
{
try
{
useStm = u;
trace.Inform("CCE: used {0}", useStm.Instruction);
useStm.Instruction.Accept(this);
trace.Inform("CCE: now {0}", useStm.Instruction);
}
catch (Exception ex)
{
var loc = listener.CreateStatementNavigator(program, u);
listener.Error(loc, ex, "An error occurred while eliminating condition codes in procedure {0}.", ssa.Procedure.Name);
}
}
}
}
/// <summary>
/// Processes procedures individually, building complex expression trees out
/// of the simple, close-to-the-machine code generated by the disassembly.
/// </summary>
/// <param name="rl"></param>
public void BuildExpressionTrees()
{
int i = 0;
foreach (Procedure proc in program.Procedures.Values)
{
if (eventListener.IsCanceled())
{
break;
}
eventListener.ShowProgress("Building complex expressions.", i, program.Procedures.Values.Count);
++i;
try
{
var sst = BuildSsaTransform(proc);
var ssa = sst.SsaState;
var fuser = new UnalignedMemoryAccessFuser(ssa);
fuser.Transform();
var vp = new ValuePropagator(program.SegmentMap, ssa, importResolver, eventListener);
sst.RenameFrameAccesses = true;
var icrw = new IndirectCallRewriter(program, ssa, eventListener);
while (!eventListener.IsCanceled() && icrw.Rewrite())
{
vp.Transform();
sst.Transform();
}
var cce = new ConditionCodeEliminator(ssa, program.Platform);
cce.Transform();
//var cd = new ConstDivisionImplementedByMultiplication(ssa);
//cd.Transform();
DeadCode.Eliminate(proc, ssa);
vp.Transform();
DeadCode.Eliminate(proc, ssa);
// Build expressions. A definition with a single use can be subsumed
// into the using expression.
var coa = new Coalescer(proc, ssa);
coa.Transform();
DeadCode.Eliminate(proc, ssa);
vp.Transform();
var liv = new LinearInductionVariableFinder(
proc,
ssa.Identifiers,
new BlockDominatorGraph(proc.ControlGraph, proc.EntryBlock));
liv.Find();
foreach (KeyValuePair <LinearInductionVariable, LinearInductionVariableContext> de in liv.Contexts)
{
var str = new StrengthReduction(ssa, de.Key, de.Value);
str.ClassifyUses();
str.ModifyUses();
}
var opt = new OutParameterTransformer(proc, ssa.Identifiers);
opt.Transform();
DeadCode.Eliminate(proc, ssa);
// Definitions with multiple uses and variables joined by PHI functions become webs.
var web = new WebBuilder(proc, ssa.Identifiers, program.InductionVariables);
web.Transform();
ssa.ConvertBack(false);
}
catch (StatementCorrelatedException stex)
{
eventListener.Error(
eventListener.CreateStatementNavigator(program, stex.Statement),
stex,
"An error occurred during data flow analysis.");
}
catch (Exception ex)
{
eventListener.Error(
new NullCodeLocation(proc.Name),
ex,
"An error occurred during data flow analysis.");
}
}
}
