public static void ForEach(MethodBodyBlock method, ForEachCallback handler)
{
GraphProcessor graphProcessor = new GraphProcessor();
Visitor visitor = new ForEachVisitor(graphProcessor, handler);
visitor.AddTask(method, null);
graphProcessor.Process();
}
private void ReConstruct() //Andrew
{
mbb.RemoveOption(BasicBlock.BASIC_BLOCK_OPTION);
GraphProcessor processor = new GraphProcessor();
BasicBlocksBuilder builder = new BasicBlocksBuilder(processor);
entry = builder.createBasicBlock();
builder.AddTask(mbb, entry);
processor.Process();
blockList = builder.BlockList;
}
protected Visitor(GraphProcessor graphProcessor, int priority, VisitorTaskCollection tasks)
{
this.graphProcessor = graphProcessor;
this.priority = priority;
this.tasks = tasks;
if (graphProcessor != null)
{
graphProcessor.addVisitor(this);
}
}
public BasicBlocksGraph(MethodBodyBlock methodBodyBlock)
{
mbb = methodBodyBlock;
mbb.RemoveOption(BasicBlock.BASIC_BLOCK_OPTION);
GraphProcessor processor = new GraphProcessor();
BasicBlocksBuilder builder = new BasicBlocksBuilder(processor);
entry = builder.createBasicBlock();
builder.AddTask(methodBodyBlock, entry);
processor.Process();
blockList = builder.BlockList;
}
public AnnotatedAssemblyHolder(AssemblyHolder sourceHolder, WhiteList whiteList)
: base(sourceHolder)
{
this.aMethods = new Hashtable();
this.GraphProcessor = new GraphProcessor();
this.WhiteList = whiteList;
foreach (MethodBase method in this.SourceHolder.getMethods())
if (method.IsDefined(typeof(SpecializeAttribute), false))
ControllingVisitor.AddAnnotatedMethodUser(this.AnnotateMethod(this.GetAnnotatedMethod(method)));
this.GraphProcessor.Process();
}
public static bool Check(MethodBodyBlock method)
{
//TODO: Will check parents consistency, if give up to do it automatically
RemoveStackTypes(method);
GraphProcessor graphProcessor = new GraphProcessor();
VerifierVisitor verifierVisitor = new VerifierVisitor(graphProcessor);
verifierVisitor.AddTask(method,new StackTypes());
try
{
graphProcessor.Process();
}
catch(VerifierException)
{
RemoveStackTypes(method);
return(false);
}
return(true);
}
public static bool Check(MethodBodyBlock method)
{
//TODO: Will check parents consistency, if give up to do it automatically
RemoveStackTypes(method);
GraphProcessor graphProcessor = new GraphProcessor();
VerifierVisitor verifierVisitor = new VerifierVisitor(graphProcessor);
verifierVisitor.AddTask(method, new StackTypes());
try
{
graphProcessor.Process();
}
catch (VerifierException)
{
RemoveStackTypes(method);
return(false);
}
return(true);
}
public EmitterVisitor(GraphProcessor processor, ILGenerator generator, MethodBodyBlock method)
: base(processor, new Tasks())
{
this.tasks = base.tasks as Tasks;
tasks.SetVisitor(this);
paramMapper = method.Variables.ParameterMapper;
this.labels = Labeler.LabelNodes(method,generator);
this.generator = generator;
alreadyVisited = new Hashtable();
locals = new Hashtable();
AddTask(method,null);
foreach(Variable var in method.Variables)
{
if(var.Kind == VariableKind.Local)
locals[var] = generator.DeclareLocal(var.Type);
}
extraVars = new Hashtable();
boolVar = null;
wasDumped = new Hashtable();;
wasDumpedFlag = false;
prevHasNext = true;
}
protected QueueVisitor(GraphProcessor graphProcessor, int priority)
: base(graphProcessor, priority, new VisitorTaskQueue())
{
}
protected QueueVisitor(GraphProcessor graphProcessor, int priority) : base(graphProcessor, priority, new VisitorTaskQueue())
{
}
protected QueueVisitor(GraphProcessor graphProcessor) : base(graphProcessor, new VisitorTaskQueue())
{
}
public IReadonlyNodeArray CollectGarbage()
{
foreach (Node n in ChildArray)
n.needed = false;
GraphProcessor graphProcessor = new GraphProcessor();
GCVisitor gcVisitor = new GCVisitor(graphProcessor);
foreach (Node n in NextArray)
gcVisitor.AddTask(n, null);
graphProcessor.Process();
NodeArray arr = new NodeArray();
foreach (Node n in ChildArray)
if (! n.needed)
arr.Add(n);
return arr;
}
private void callMethod(Node downNode, AnnotatedMethod method, PointerToNode ptrUpNode, Node upNode, Value[] args)
{
if (method.SourceMethod.IsDefined(typeof(InlineAttribute), false) && ! (upNode is NewObject))
{
MethodBodyBlock mbbDown = this.holder.AnnotatedHolder[method];
SpecState state = new SpecState(mbbDown.Variables.Count);
int varCount = 0;
int argCount = 0;
foreach (Variable varDown in mbbDown.Variables.ParameterMapper)
{
state.Pool[varDown] = new Location(varDown.Type);
Variable varUp = this.mbbUp.Variables.CreateVar(varDown.Type, VariableKind.Local);
this.varsHash[new PointerToLocationValue(state.Pool[varDown])] = varUp;
if (Annotation.GetValueBTType(method.ParamVals[varCount++].Val) == BTType.Static)
{
state.Pool[varDown].Val = args[argCount];
state.Stack.Push(args[argCount++]);
}
else
{
Node upNext = new StoreVar(varUp);
Node upPrevNext = ptrUpNode.Node;
ptrUpNode.Node = upNext;
upNext.Next = upPrevNext;
}
}
while (ptrUpNode.Node != null)
ptrUpNode = new PointerToNode(ptrUpNode.Node);
foreach (Variable varDown in mbbDown.Variables)
if (! state.Pool.ContainsVar(varDown))
{
state.Pool[varDown] = new Location(varDown.Type);
Variable varUp = this.mbbUp.Variables.CreateVar(varDown.Type, VariableKind.Local);
this.varsHash[new PointerToLocationValue(state.Pool[varDown])] = varUp;
ptrUpNode = SpecializingVisitor.initVariable(varUp, ptrUpNode);
}
int depth = state.Stack.Count + 1;
GraphProcessor graphProc = new GraphProcessor();
SpecializingVisitor visitor = new SpecializingVisitor(graphProc, this.holder, this.mbbUp, state, this.varsHash);
visitor.AddTask(mbbDown.Next, ptrUpNode);
graphProc.Process();
foreach (Data newData in visitor.exitData)
{
state.Recall(newData.MemoSpecState, newData.ObjectHashtable);
if (state.Stack.Count == depth)
this.state.Stack.Push(state.Stack.Pop());
this.AddTask(downNode.Next, newData.PointerToNode);
}
}
else
{
ObjectHashtable objHash = new ObjectHashtable();
MemoState memoArgs = new MemoState(args, objHash);
PointerValue[] ptrs = this.varsHash.GetPointers(objHash);
for (int i = 0; i < ptrs.Length; i++)
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVarAddr(this.varsHash[ptrs[i]]));
ptrUpNode = new PointerToNode(ptrUpNode.Node = upNode);
ResidualMethod callMethod = new ResidualMethod(method, memoArgs, args, ptrs);
Specialization.SetResidualMethod(upNode, callMethod);
this.holder.SpecializeMethod(callMethod);
this.AddTask(downNode.Next, ptrUpNode);
}
}
public static Value InterpretMethod(MethodBodyHolder holder,
MethodBodyBlock body, ParameterValues paramVals, out Exception exc,
string indent)
{
exc = null;
GraphProcessor graphProcessor = new GraphProcessor();
IntVisitor visitor = new IntVisitor(graphProcessor,holder,indent);
visitor.state = new State(body.Variables.Count);
int paramCount = 0;
foreach (Variable var in body.Variables.ParameterMapper)
visitor.state.Pool[var] = paramVals[paramCount++];
visitor.AddTask(body);
graphProcessor.Process();
Value result = null;
if (visitor.unhandledException != null)
exc = visitor.unhandledException;
else if (body.ReturnType != typeof(void))
result = visitor.state.Stack.Pop().FromStack(body.ReturnType);
return result;
}
public VerifierVisitor(GraphProcessor graphProcessor)
: base(graphProcessor,new VisitorTaskQueue())
{
}
public ForEachVisitor(GraphProcessor processor, ForEachCallback handler)
: base(processor)
{
alreadyVisited = new Hashtable();
this.handler = handler;
}
protected QueueVisitor(GraphProcessor graphProcessor)
: base(graphProcessor, new VisitorTaskQueue())
{
}
protected Visitor(GraphProcessor graphProcessor, int priority, VisitorTaskCollection tasks)
{
this.graphProcessor = graphProcessor;
this.priority = priority;
this.tasks = tasks;
if (graphProcessor != null)
graphProcessor.addVisitor(this);
}
protected VisitorEX(GraphProcessor graphProcessor, int priority, VisitorTaskCollection tasks)
: base(graphProcessor, priority, tasks)
{
}
public ForEachVisitor(GraphProcessor processor, ForEachCallback handler) : base(processor)
{
alreadyVisited = new Hashtable();
this.handler = handler;
}
public VerifierVisitor(GraphProcessor graphProcessor) : base(graphProcessor, new VisitorTaskQueue())
{
}
internal static void SpecializeMethod(ResidualAssemblyHolder holder, ResidualMethod method)
{
Value[] args = method.Arguments;
PointerValue[] ptrs = method.Pointers;
MethodBodyBlock mbbDown = holder.AnnotatedHolder[method.AnnotatedMethod];
MethodBodyBlock mbbUp = new MethodBodyBlock(mbbDown.ReturnType);
holder.AddMethod(method, mbbUp);
SpecState state = new SpecState(mbbDown.Variables.Count);
VariablesHashtable varsHash = new VariablesHashtable();
int varCount = 0;
int argCount = 0;
foreach (Variable varDown in mbbDown.Variables.ParameterMapper)
{
state.Pool[varDown] = new Location(varDown.Type);
Variable varUp;
if (Annotation.GetValueBTType(method.AnnotatedMethod.ParamVals[varCount++].Val) == BTType.Static)
{
state.Pool[varDown].Val = args[argCount++];
varUp = mbbUp.Variables.CreateVar(varDown.Type, VariableKind.Local);
}
else
varUp = mbbUp.Variables.CreateVar(varDown.Type, VariableKind.Parameter);
varsHash[new PointerToLocationValue(state.Pool[varDown])] = varUp;
}
foreach (Variable varDown in mbbDown.Variables)
if (! state.Pool.ContainsVar(varDown))
{
state.Pool[varDown] = new Location(varDown.Type);
Variable varUp = mbbUp.Variables.CreateVar(varDown.Type, VariableKind.Local);
varsHash[new PointerToLocationValue(state.Pool[varDown])] = varUp;
}
PointerToNode ptrUpNode = new PointerToNode(mbbUp);
Node dummyUp = new DummyNode(mbbUp);
Node upNode = dummyUp;
for (int i = 0; i < ptrs.Length; i++)
{
Type ptrType = ptrs[i].Type;
Type type = ptrType.GetElementType();
Variable newVar1 = mbbUp.Variables.CreateVar(ptrType, VariableKind.Parameter);
Variable newVar2 = mbbUp.Variables.CreateVar(type, VariableKind.Local);
varsHash[ptrs[i]] = newVar2;
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVar(newVar1));
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadIndirect(type));
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(newVar2));
upNode = upNode.Next = new LoadVar(newVar1);
upNode = upNode.Next = new LoadVar(newVar2);
upNode = upNode.Next = new StoreIndirect(type);
}
upNode.Next = new Leave();
upNode = dummyUp.Next;
dummyUp.RemoveFromGraph();
GraphProcessor graphProc = new GraphProcessor();
SpecializingVisitor visitor = new SpecializingVisitor(graphProc, holder, mbbUp, state, varsHash);
visitor.AddTask(mbbDown.Next, ptrUpNode);
graphProc.Process();
visitor.SetLastNode(upNode);
}
public static void ForEach(MethodBodyBlock method, ForEachCallback handler)
{
GraphProcessor graphProcessor = new GraphProcessor();
Visitor visitor = new ForEachVisitor(graphProcessor,handler);
visitor.AddTask(method,null);
graphProcessor.Process();
}
protected VisitorEX(GraphProcessor graphProcessor, VisitorTaskCollection tasks)
: base(graphProcessor, tasks)
{
}
internal IntVisitor(GraphProcessor graphProcessor, MethodBodyHolder holder, string indent)
: base(graphProcessor)
{
this.holder = holder;
this.indent = indent;
}
public BasicBlocksGraph(MethodBodyBlock methodBodyBlock)
{
mbb = methodBodyBlock;
mbb.RemoveOption(BasicBlock.BASIC_BLOCK_OPTION);
GraphProcessor processor = new GraphProcessor();
BasicBlocksBuilder builder = new BasicBlocksBuilder(processor);
entry = builder.createBasicBlock();
builder.AddTask(methodBodyBlock,entry);
processor.Process();
blockList = builder.BlockList;
}
protected StackVisitor(GraphProcessor graphProcessor)
: base(graphProcessor, new VisitorTaskStack())
{
}
internal SpecializingVisitor(GraphProcessor graphProcessor, ResidualAssemblyHolder holder, MethodBodyBlock mbbUp, SpecState state, VariablesHashtable varsHash)
: base(graphProcessor)
{
this.holder = holder;
this.mbbUp = mbbUp;
this.state = state;
this.varsHash = varsHash;
this.upDownNodes = new Hashtable();
this.exitData = new ArrayList();
}
public BasicBlocksBuilder(GraphProcessor graphProcessor) :
base(graphProcessor)
{
blockList = new BasicBlockArray();
}
protected StackVisitor(GraphProcessor graphProcessor, int priority)
: base(graphProcessor, priority, new VisitorTaskStack())
{
}
public BasicBlocksBuilder(GraphProcessor graphProcessor)
: base(graphProcessor)
{
blockList = new BasicBlockArray();
}
protected StackVisitor(GraphProcessor graphProcessor) : base(graphProcessor, new VisitorTaskStack())
{
}
//Andrew
private void ReConstruct()
{
mbb.RemoveOption(BasicBlock.BASIC_BLOCK_OPTION);
GraphProcessor processor = new GraphProcessor();
BasicBlocksBuilder builder = new BasicBlocksBuilder(processor);
entry = builder.createBasicBlock();
builder.AddTask(mbb,entry);
processor.Process();
blockList = builder.BlockList;
}
protected StackVisitor(GraphProcessor graphProcessor, int priority) : base(graphProcessor, priority, new VisitorTaskStack())
{
}
public GCVisitor(GraphProcessor graphProcessor)
: base(graphProcessor)
{
}
public static void Emit(ILGenerator generator, MethodBodyBlock method)
{
GraphProcessor graphProcessor = new GraphProcessor();
EmitterVisitor visitor = new EmitterVisitor(graphProcessor, generator, method);
graphProcessor.Process();
}
