private void loadVar(Node downNode, PointerValue ptr, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVar(this.varsHash[ptr]));
this.AddTask(downNode.Next, ptrUpNode);
}
internal void AddTask(Node downNode, PointerToNode ptrUpNode)
{
ObjectHashtable objHash;
MemoSpecState memo = this.state.Memorize(this.varsHash, out objHash);
this.AddTask(downNode, new Data(memo, objHash, ptrUpNode));
}
private void storeVar(Node downNode, PointerValue ptr, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(this.varsHash[ptr]));
ptr.SetZeroValue();
this.AddTask(downNode.Next, ptrUpNode);
}
private static PointerToNode initVariable(Variable varUp, PointerToNode ptrUp)
{
// Postprocessor dows not support LoadVarAddr
return(ptrUp);
if (varUp.Type.IsValueType)
{
ptrUp = new PointerToNode(ptrUp.Node = new LoadVarAddr(varUp));
return(new PointerToNode(ptrUp.Node = new InitValue(varUp.Type)));
}
else
{
ptrUp = new PointerToNode(ptrUp.Node = new LoadConst(null));
return(new PointerToNode(ptrUp.Node = new StoreVar(varUp)));
}
}
protected override void DispatchNode(Node downNode, object o)
{
Data data = o as Data;
MemoSpecState memo = data.MemoSpecState;
PointerToNode ptrUpNode = data.PointerToNode;
this.state.Recall(memo, data.ObjectHashtable);
BTType btType = Annotation.GetNodeBTType(downNode);
if (btType == BTType.Static)
{
Node nextDownNode = this.state.InterpretNode(downNode);
this.AddTask(nextDownNode, ptrUpNode);
}
else
{
Variable[] vars1;
Node upNode;
Variable[] vars2;
this.getUpNode(downNode, memo, out vars1, out upNode, out vars2);
if (upNode != null)
{
SpecializingVisitor.createSubstitution(vars2, vars1, ptrUpNode, upNode);
}
else if (btType == BTType.eXclusive)
{
this.CallVisitorMethod(downNode, data);
}
else
{
upNode = ptrUpNode.Node = downNode.Clone();
for (int i = 0; i < downNode.NextArray.Count; i++)
{
this.AddTask(downNode.NextArray[i], new PointerToNode(upNode, i));
}
}
}
if (ptrUpNode.Node != null)
{
this.setUpAndDownNode(downNode, memo, ptrUpNode.Node);
}
}
protected override void VisitNewObject(NewObject downNode, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
AnnotatedMethod method = Annotation.GetAnnotatedMethod(downNode);
Node upNode;
ArrayList list = new ArrayList();
for (int i = method.ParamVals.Count - 1; i > 0; i--)
{
if (Annotation.GetValueBTType(method.ParamVals[i].Val) == BTType.Static)
{
list.Add(this.state.Stack.Pop());
}
}
if (Annotation.GetValueBTType(method.ParamVals[0].Val) == BTType.Static)
{
Type objtype = downNode.Constructor.DeclaringType;
ObjectReferenceValue obj = new ObjectReferenceValue(FormatterServices.GetUninitializedObject(objtype));
FieldInfo[] fldInfos = ReflectionUtils.GetAllFields(objtype);
BTType[] btTypes = Annotation.GetObjectFieldBTTypes(downNode);
for (int i = 0; i < fldInfos.Length; i++)
{
if (btTypes[i] == BTType.Dynamic)
{
Variable varUp = this.mbbUp.Variables.CreateVar(fldInfos[i].FieldType, VariableKind.Local);
this.varsHash[new PointerToObjectFieldValue(obj.Obj, fldInfos[i])] = varUp;
ptrUpNode = SpecializingVisitor.initVariable(varUp, ptrUpNode);
}
}
list.Add(obj);
this.state.Stack.Push(obj);
upNode = new CallMethod(downNode.Constructor, false, false);
}
else
{
upNode = new NewObject(downNode.Constructor);
}
list.Reverse();
Value[] args = list.ToArray(typeof(Value)) as Value[];
this.callMethod(downNode, method, ptrUpNode, upNode, args);
}
protected override void VisitNewArray(NewArray downNode, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
StructValue idx = this.state.Stack.Pop() as StructValue;
Array arr = Array.CreateInstance(downNode.Type, SpecializingVisitor.toInt(idx));
ObjectReferenceValue obj = new ObjectReferenceValue(arr);
if (Annotation.GetArrayElementsBTType(downNode) == BTType.Dynamic)
{
for (int i = 0; i < SpecializingVisitor.toInt(idx); i++)
{
Variable varUp = this.mbbUp.Variables.CreateVar(downNode.Type, VariableKind.Local);
this.varsHash[new PointerToElementValue(arr, i)] = varUp;
ptrUpNode = SpecializingVisitor.initVariable(varUp, ptrUpNode);
}
}
this.state.Stack.Push(obj);
this.AddTask(downNode.Next, ptrUpNode);
}
protected override void VisitCallMethod(CallMethod downNode, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
bool isVirtCall = downNode.IsVirtCall && downNode.Method.IsVirtual;
AnnotatedMethod aMethod;
if (isVirtCall)
{
aMethod = Annotation.GetAnyAnnotatedMethod(downNode);
}
else
{
aMethod = Annotation.GetAnnotatedMethod(downNode);
}
ArrayList list = new ArrayList();
for (int i = aMethod.ParamVals.Count - 1; i >= 0; i--)
{
if (Annotation.GetValueBTType(aMethod.ParamVals[i].Val) == BTType.Static)
{
list.Add(this.state.Stack.Pop());
}
}
list.Reverse();
Value[] args = list.ToArray(typeof(Value)) as Value[];
MethodBase sMethod;
if (isVirtCall)
{
sMethod = (aMethod = Annotation.GetAnnotatedMethod(downNode, args[0].Type)).SourceMethod;
}
else
{
sMethod = aMethod.SourceMethod;
}
this.callMethod(downNode, aMethod, ptrUpNode, new CallMethod(sMethod, false, downNode.IsTailCall), args);
}
protected override void VisitLift(Lift downNode, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
LiftTask task = downNode.Task;
if (task is StackLiftTask)
{
int depth = (task as StackLiftTask).Depth;
ptrUpNode = new PointerToNode(ptrUpNode.Node = SpecializingVisitor.liftValue(this.state.Stack[depth]));
this.state.Stack.RemoveAt(depth);
}
else
{
Variable var = (task as VariableLiftTask).Variable;
ptrUpNode = new PointerToNode(ptrUpNode.Node = SpecializingVisitor.liftValue(this.state.Pool[var].Val));
PointerValue ptr = new PointerToLocationValue(this.state.Pool[var]);
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(this.varsHash[ptr]));
ptr.SetZeroValue();
}
this.AddTask(downNode.Next, ptrUpNode);
}
private void loadVar(Node downNode, PointerValue ptr, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVar(this.varsHash[ptr]));
this.AddTask(downNode.Next, ptrUpNode);
}
private void storeVar(Node downNode, PointerValue ptr, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(this.varsHash[ptr]));
ptr.SetZeroValue();
this.AddTask(downNode.Next, ptrUpNode);
}
private static PointerToNode initVariable(Variable varUp, PointerToNode ptrUp)
{
// Postprocessor dows not support LoadVarAddr
return ptrUp;
if (varUp.Type.IsValueType)
{
ptrUp = new PointerToNode(ptrUp.Node = new LoadVarAddr(varUp));
return new PointerToNode(ptrUp.Node = new InitValue(varUp.Type));
}
else
{
ptrUp = new PointerToNode(ptrUp.Node = new LoadConst(null));
return new PointerToNode(ptrUp.Node = new StoreVar(varUp));
}
}
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);
}
}
protected override void VisitLift(Lift downNode, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
LiftTask task = downNode.Task;
if (task is StackLiftTask)
{
int depth = (task as StackLiftTask).Depth;
ptrUpNode = new PointerToNode(ptrUpNode.Node = SpecializingVisitor.liftValue(this.state.Stack[depth]));
this.state.Stack.RemoveAt(depth);
}
else
{
Variable var = (task as VariableLiftTask).Variable;
ptrUpNode = new PointerToNode(ptrUpNode.Node = SpecializingVisitor.liftValue(this.state.Pool[var].Val));
PointerValue ptr = new PointerToLocationValue(this.state.Pool[var]);
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(this.varsHash[ptr]));
ptr.SetZeroValue();
}
this.AddTask(downNode.Next, ptrUpNode);
}
private static void createSubstitution(Variable[] vars1, Variable[] vars2, PointerToNode ptrUpNode, Node upNode)
{
if (vars1.Length != vars2.Length)
throw new InternalException();
int length = vars1.Length;
Hashtable hash12 = new Hashtable();
Hashtable hash21 = new Hashtable();
Hashtable processed = new Hashtable();
for (int i=0; i<length; i++)
{
hash12[vars1[i]] = vars2[i];
hash21[vars2[i]] = vars1[i];
}
for (int i=0; i<length; i++)
{
Variable var1 = vars1[i];
Variable var2 = hash12[var1] as Variable;
if (var2 == var1)
continue;
if (processed.ContainsKey(var1))
continue;
Variable Var = var1;
bool isLoop = false;
//Searching for the beginning of the chain
for (;;)
{
if (hash21[var1] == null)
break; //the beginning of the chain;
var2 = var1;
var1 = hash21[var2] as Variable;
if(var1 == Var)//the loop
{
isLoop = true;
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVar(Var));
Var = hash21[Var] as Variable;
hash12.Remove(Var);
//we break the loop at 'Var' to have a chain
break;
}
}
//processing the chain, loops are already broken
for ( ;var2 != null; )
{
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVar(var2));
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(var1));
processed[var1] = null; //mark var1 as 'processed'
var1 = var2;
var2 = hash12[var1] as Variable;
}
if (isLoop)
{
//restore the loop
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(Var));
processed[Var] = null; //mark Var as 'processed'
}
}
ptrUpNode.Node = upNode;
}
internal void AddTask(Node downNode, PointerToNode ptrUpNode)
{
ObjectHashtable objHash;
MemoSpecState memo = this.state.Memorize(this.varsHash, out objHash);
this.AddTask(downNode, new Data(memo, objHash, ptrUpNode));
}
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);
}
private static void createSubstitution(Variable[] vars1, Variable[] vars2, PointerToNode ptrUpNode, Node upNode)
{
if (vars1.Length != vars2.Length)
{
throw new InternalException();
}
int length = vars1.Length;
Hashtable hash12 = new Hashtable();
Hashtable hash21 = new Hashtable();
Hashtable processed = new Hashtable();
for (int i = 0; i < length; i++)
{
hash12[vars1[i]] = vars2[i];
hash21[vars2[i]] = vars1[i];
}
for (int i = 0; i < length; i++)
{
Variable var1 = vars1[i];
Variable var2 = hash12[var1] as Variable;
if (var2 == var1)
{
continue;
}
if (processed.ContainsKey(var1))
{
continue;
}
Variable Var = var1;
bool isLoop = false;
//Searching for the beginning of the chain
for (;;)
{
if (hash21[var1] == null)
{
break; //the beginning of the chain;
}
var2 = var1;
var1 = hash21[var2] as Variable;
if (var1 == Var)//the loop
{
isLoop = true;
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVar(Var));
Var = hash21[Var] as Variable;
hash12.Remove(Var);
//we break the loop at 'Var' to have a chain
break;
}
}
//processing the chain, loops are already broken
for ( ; var2 != null;)
{
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVar(var2));
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(var1));
processed[var1] = null; //mark var1 as 'processed'
var1 = var2;
var2 = hash12[var1] as Variable;
}
if (isLoop)
{
//restore the loop
ptrUpNode = new PointerToNode(ptrUpNode.Node = new StoreVar(Var));
processed[Var] = null; //mark Var as 'processed'
}
}
ptrUpNode.Node = upNode;
}
internal Data(MemoSpecState memo, ObjectHashtable objHash, PointerToNode ptrUpNode)
{
this.MemoSpecState = memo;
this.ObjectHashtable = objHash;
this.PointerToNode = ptrUpNode;
}
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 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);
}
internal Data(MemoSpecState memo, ObjectHashtable objHash, PointerToNode ptrUpNode)
{
this.MemoSpecState = memo;
this.ObjectHashtable = objHash;
this.PointerToNode = ptrUpNode;
}
