Esempio n. 1
0
 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();
 }
Esempio n. 2
0
        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);
        }