internal MemoSpecState Memorize(VariablesHashtable varsHash, out ObjectHashtable objHash)
{
MemoState memo = this.state.Memorize(out objHash);
PointerValue[] ptrs = varsHash.GetPointers(objHash);
Variable[] vars = new Variable[ptrs.Length];
for (int i = 0; i < vars.Length; i++)
{
vars[i] = varsHash[ptrs[i] as PointerValue] as Variable;
}
return(new MemoSpecState(memo, vars));
}
internal PointerValue[] GetPointers(ObjectHashtable objHash)
{
ArrayList ptrs = new ArrayList();
foreach (PointerValue ptr in this.hash.Keys)
{
if (objHash.ContainsKey(ptr.GetHeapObject()))
{
ptrs.Add(ptr);
}
}
ptrs.Sort(new PtrComparer(objHash));
return(ptrs.ToArray(typeof(PointerValue)) as PointerValue[]);
}
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);
}
}
internal Data(MemoSpecState memo, ObjectHashtable objHash, PointerToNode ptrUpNode)
{
this.MemoSpecState = memo;
this.ObjectHashtable = objHash;
this.PointerToNode = ptrUpNode;
}
internal void Recall(MemoSpecState memo, ObjectHashtable objHash)
{
this.state.Recall(memo.MemoState, objHash);
}
internal PtrComparer(ObjectHashtable objHash)
{
this.objHash = objHash;
}
