internal void addUsage(StoreVar storer, LoadVar loader)
{
usageHash.Add(storer,loader);
}
private bool performPatternReplacing()
{
bool result = false;
foreach (BasicBlock block in blockList)
{
NodeArray body = block.Body;
bool flag = true;
while (flag)
{
flag = false;
for (int i = 0; i < body.Count-1 && ! flag; i++)
{
Node n1 = body[i];
if (n1 is Branch && (n1 as Branch).Next == (n1 as Branch).Alt)
{
result = flag = true;
Node n = newRemoveStackTop(block);
body[i] = n;
n1.ReplaceByNode(n);
n.Next = n1.Next;
n1.RemoveFromGraph();
}
else
{
Node n2 = body[i+1];
if (n1 is StoreVar && n2 is LoadVar &&
(n1 as ManageVar).Var == (n2 as ManageVar).Var)
{
result = flag = true;
Node n = newDuplicateStackTop(block);
body[i] = n;
body[i+1] = n1;
n1.ReplaceByNode(n);
n.Next = n1;
n1.Next = n2.Next;
n2.RemoveFromGraph();
}
else if (detectedDoubleLoading(n1,n2))
{
result = flag = true;
Node n = newDuplicateStackTop(block);
body[i+1] = n;
n2.ReplaceByNode(n);
n.Next = n2.Next;
n2.RemoveFromGraph();
}
else if (detectedDoubleCasting(n1,n2))
{
result = flag = true;
body.RemoveAt(i+1);
n1.Next = n2.Next;
n2.RemoveFromGraph();
}
else if (n1 is StoreVar && n2 is Leave &&
n2.Parent is MethodBodyBlock)
{
result = flag = true;
Node n = newRemoveStackTop(block);
body[i] = n;
n1.ReplaceByNode(n);
n1.RemoveFromGraph();
n.Next = n2;
}
else if (detectedReplacementByPop(n1,n2))
{
result = flag = true;
Node n = newRemoveStackTop(block);
body.RemoveAt(i+1);
body[i] = n;
n1.ReplaceByNode(n);
n1.RemoveFromGraph();
n.Next = n2.Next;
n2.RemoveFromGraph();
}
else if (detectedReplacementByDoublePop(n1,n2))
{
result = flag = true;
Node new1 = newRemoveStackTop(block),
new2 = newRemoveStackTop(block);
body[i] = new1;
body[i+1] = new2;
n1.ReplaceByNode(new1);
n1.RemoveFromGraph();
new1.Next = new2;
new2.Next = n2.Next;
n2.RemoveFromGraph();
}
else if (detectedRemoval(n1,n2))
{
result = flag = true;
body.RemoveAt(i+1);
body.RemoveAt(i);
n1.ReplaceByNode(n2.Next);
n1.RemoveFromGraph();
n2.RemoveFromGraph();
}
else if (detectedInitValueReplacement(n1,n2))
{
result = flag = true;
Variable var = (n1 as LoadVarAddr).Var;
Type type = (n2 as InitValue).Type;
object constant = null;
if (type == typeof(Int64))
constant = (Int64)0;
else if (type == typeof(Single) || type == typeof(Double))
constant = (Double)0;
else
constant = (Int32)0;
Node new1 = new LoadConst(constant),
new2 = new StoreVar(var);
new1.Options[BasicBlock.BASIC_BLOCK_OPTION] = block;
new2.Options[BasicBlock.BASIC_BLOCK_OPTION] = block;
body[i] = new1;
body[i+1] = new2;
n1.ReplaceByNode(new1);
n1.RemoveFromGraph();
new1.Next = new2;
new2.Next = n2.Next;
n2.RemoveFromGraph();
}
else if (i < body.Count-2)
{
Node n3 = body[i+2];
if (i < body.Count-3)
{
Node n4 = body[i+3];
if (detectedOperandExchange(n1,n2,n3,n4))
{
result = flag = true;
Node n = newDuplicateStackTop(block);
body[i] = n;
body[i+1] = n1;
body[i+2] = n2;
body[i+3] = n4;
n3.RemoveFromGraph();
n1.ReplaceByNode(n);
n.Next = n1;
n2.Next = n4;
}
else if (detectedQuadruple1(n1,n2,n3,n4))
{
result = flag = true;
Node n = newDuplicateStackTop(block);
body[i] = n;
body[i+1] = n1;
body[i+2] = n2;
body[i+3] = n3;
n1.ReplaceByNode(n);
n.Next = n1;
n3.Next = n4.Next;
n4.RemoveFromGraph();
}
}
}
}
}
}
}
return result;
}
public LoadVar this[StoreVar storer]
{
get { return usageHash[storer] as LoadVar; }
}
public bool IsUsed(StoreVar storer)
{
return usageHash.ContainsKey(storer);
}
protected internal virtual void VisitStoreVar(StoreVar node, object data)
{
throw new NodeNotSupportedException(node);
}
protected internal override void VisitStoreVar(StoreVar node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessSt(new TypeEx(node.Var.Type), stack);
AddTask(node.Next,stack);
}
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 VisitStoreVar(StoreVar downNode, object o)
{
PointerValue ptr = new PointerToLocationValue(this.state.Pool[downNode.Var]);
this.storeVar(downNode, ptr, o);
}
protected override void VisitStoreVar(StoreVar upNode, object o)
{
State state = o as State;
BTValue val = state.Stack.Pop() as BTValue;
state.Pool[upNode.Var].Val = val;
BTType btType;
if (val.BTType == BTType.Dynamic)
btType = BTType.eXclusive;
else
btType = BTType.Static;
Annotation.SetNodeBTType(upNode, btType);
}
protected override void VisitStoreVar(StoreVar upNode, object o)
{
DepthContainer cnt = o as DepthContainer;
cnt.Depth += 1;
}
protected internal override void VisitStoreVar(StoreVar node, object data)
{
switch(node.Var.Kind)
{
case VariableKind.Local:
{
generator.Emit(OpCodes.Stloc, GetLocal(node.Var));
} break;
case VariableKind.Parameter:
{
int index = GetArgIndex(node.Var);
if(index <= 255)
generator.Emit(OpCodes.Starg_S, (byte)index);
else
generator.Emit(OpCodes.Starg, index);
} break;
case VariableKind.ArgList:
throw new EmissionException(); //Impossible!
}
AddTask(node.Next,null);
}