C# Context.GotoNext方法代码示例

        protected override void Run()
        {
            Dictionary<Operand, int> list = new Dictionary<Operand, int>();

            foreach (var block in this.BasicBlocks)
            {
                for (var context = new Context(this.InstructionSet, block); !context.IsBlockEndInstruction; context.GotoNext())
                {
                    context.Marked = false;

                    if (context.Result == null)
                        continue;

                    int index = 0;

                    if (list.TryGetValue(context.Result, out index))
                    {
                        InstructionSet.Data[index].Marked = true;
                        context.Marked = true;
                    }
                    else
                    {
                        list.Add(context.Result, context.Index);
                    }
                }
            }
        }

        /// <summary>
        /// Performs stage specific processing on the compiler context.
        /// </summary>
        void IMethodCompilerStage.Run()
        {
            // Unable to optimize SSA w/ exceptions or finally handlers present
            if (basicBlocks.HeadBlocks.Count != 1)
                return;

            // initialize worklist
            foreach (BasicBlock block in basicBlocks)
            {
                for (Context ctx = new Context(instructionSet, block); !ctx.EndOfInstruction; ctx.GotoNext())
                {
                    if (ctx.IsEmpty)
                        continue;

                    if (ctx.ResultCount == 0 && ctx.OperandCount == 0)
                        continue;

                    Do(ctx);

                    while (worklist.Count != 0)
                    {
                        int index = worklist.Pop();
                        Context ctx2 = new Context(instructionSet, index);
                        Do(ctx2);
                    }
                }
            }

            UpdateCounter("SSAOptimizations.IRInstructionRemoved", instructionsRemoved);
            worklist = null;
        }

        protected override void Run()
        {
            // Remove Nops
            foreach (var block in BasicBlocks)
            {
                for (var ctx = new Context(InstructionSet, block); !ctx.IsBlockEndInstruction; ctx.GotoNext())
                {
                    if (ctx.IsEmpty)
                        continue;

                    if (ctx.Instruction == IRInstruction.Nop)
                    {
                        ctx.Remove();
                        continue;
                    }
                }
            }

            // copied from EmptyBlockRemovalStage.cs
            foreach (var block in BasicBlocks)
            {
                // don't process other unusual blocks (header blocks, return block, etc.)
                if (block.NextBlocks.Count == 0 || block.PreviousBlocks.Count == 0)
                    continue;

                // don't remove block if it jumps back to itself
                if (block.PreviousBlocks.Contains(block))
                    continue;

                if (!IsEmptyBlockWithSingleJump(block))
                    continue;

                RemoveEmptyBlockWithSingleJump(block);
            }
        }

        private void InsertBlockProtectInstructions()
        {
            foreach (var handler in MethodCompiler.Method.ExceptionHandlers)
            {
                var tryBlock = BasicBlocks.GetByLabel(handler.TryStart);

                var tryHandler = BasicBlocks.GetByLabel(handler.HandlerStart);

                var context = new Context(tryBlock);

                while (context.IsEmpty || context.Instruction == IRInstruction.TryStart)
                {
                    context.GotoNext();
                }

                context.AppendInstruction(IRInstruction.TryStart, tryHandler);

                context = new Context(tryHandler);

                if (handler.ExceptionHandlerType == ExceptionHandlerType.Finally)
                {
                    var exceptionObject = AllocateVirtualRegister(exceptionType);
                    var finallyOperand = AllocateVirtualRegister(TypeSystem.BuiltIn.I4);

                    context.AppendInstruction2(IRInstruction.FinallyStart, exceptionObject, finallyOperand);
                }
            }
        }

        protected override void Run()
        {
            finalVirtualRegisters = new Dictionary<Operand, Operand>();

            foreach (var block in BasicBlocks)
            {
                for (var context = new Context(InstructionSet, block); !context.IsBlockEndInstruction; context.GotoNext())
                {
                    if (context.Instruction == IRInstruction.Phi)
                    {
                        Debug.Assert(context.OperandCount == context.BasicBlock.PreviousBlocks.Count);

                        ProcessPhiInstruction(context);
                    }

                    for (var i = 0; i < context.OperandCount; ++i)
                    {
                        var op = context.GetOperand(i);

                        if (op != null && op.IsSSA)
                        {
                            context.SetOperand(i, GetFinalVirtualRegister(op));
                        }
                    }

                    if (context.Result != null && context.Result.IsSSA)
                    {
                        context.Result = GetFinalVirtualRegister(context.Result);
                    }
                }
            }

            finalVirtualRegisters = null;
        }

        /// <summary>
        /// Performs stage specific processing on the compiler context.
        /// </summary>
        void IMethodCompilerStage.Run()
        {
            Dictionary<Operand, int> list = new Dictionary<Operand, int>();

            foreach (var block in this.basicBlocks)
            {
                for (var context = new Context(this.instructionSet, block); !context.EndOfInstruction; context.GotoNext())
                {
                    context.Marked = false;

                    if (context.Result == null)
                        continue;

                    int index = 0;

                    if (list.TryGetValue(context.Result, out index))
                    {
                        instructionSet.Data[index].Marked = true;
                        context.Marked = true;
                    }
                    else
                    {
                        list.Add(context.Result, context.Index);
                    }
                }
            }
        }

        /// <summary>
        /// Collects the variables in exceptions.
        /// </summary>
        private void CollectVariablesInExceptions()
        {
            if (basicBlocks.HeadBlocks.Count == 1)
                return;

            foreach (var head in basicBlocks.HeadBlocks)
            {
                if (head == basicBlocks.PrologueBlock)
                    continue;

                foreach (BasicBlock block in basicBlocks.GetConnectedBlocksStartingAtHead(head))
                {
                    for (Context ctx = new Context(instructionSet, block); !ctx.EndOfInstruction; ctx.GotoNext())
                    {
                        if (ctx.IsEmpty)
                            continue;

                        foreach (var operand in ctx.Operands)
                            if (operand.IsLocalVariable)
                                localVariablesInExceptions.AddIfNew(operand);

                        if (ctx.Result != null)
                            if (ctx.Result.IsLocalVariable)
                                localVariablesInExceptions.AddIfNew(ctx.Result);
                    }

                    // quick out
                    if (localVariablesInExceptions.Count == methodCompiler.StackLayout.LocalVariableCount)
                        return;
                }
            }
        }

        private void InsertBlockProtectInstructions()
        {
            foreach (var handler in MethodCompiler.Method.ExceptionHandlers)
            {
                var tryBlock = BasicBlocks.GetByLabel(handler.TryStart);

                var tryHandler = BasicBlocks.GetByLabel(handler.HandlerStart);

                var context = new Context(InstructionSet, tryBlock);

                while (context.IsEmpty || context.Instruction == IRInstruction.TryStart)
                {
                    context.GotoNext();
                }

                context.AppendInstruction(IRInstruction.TryStart, tryHandler);

                context = new Context(InstructionSet, tryHandler);

                if (handler.HandlerType == ExceptionHandlerType.Exception)
                {
                    var exceptionObject = MethodCompiler.CreateVirtualRegister(handler.Type);

                    context.AppendInstruction(IRInstruction.ExceptionStart, exceptionObject);
                }
                else if (handler.HandlerType == ExceptionHandlerType.Finally)
                {
                    context.AppendInstruction(IRInstruction.FinallyStart);
                }
            }
        }

 protected override void Run()
 {
     for (int index = 0; index < BasicBlocks.Count; index++)
         for (Context ctx = new Context(InstructionSet, BasicBlocks[index]); !ctx.IsBlockEndInstruction; ctx.GotoNext())
             if (!ctx.IsEmpty)
                 ctx.Clone().Visit(this);
 }

        /// <summary>
        /// Performs stage specific processing on the compiler context.
        /// </summary>
        void IMethodCompilerStage.Run()
        {
            foreach (var block in this.basicBlocks)
            {
                for (var ctx = new Context(instructionSet, block); !ctx.EndOfInstruction; ctx.GotoNext())
                {
                    if (ctx.IsEmpty)
                        continue;

                    RegisterBitmap inputRegisters = new RegisterBitmap();
                    RegisterBitmap outputRegisters = new RegisterBitmap();

                    GetRegisterUsage(ctx, ref inputRegisters, ref outputRegisters);

                    Debug.WriteLine(String.Format("L_{0:X4}: {1}", ctx.Label, ctx.Instruction.ToString(ctx)));

                    if (outputRegisters.HasValue)
                    {
                        Debug.Write("\t OUTPUT: ");
                        Debug.Write(GetRegisterNames(outputRegisters));
                    }

                    if (inputRegisters.HasValue)
                    {
                        Debug.Write("\t INPUT: ");
                        Debug.Write(GetRegisterNames(inputRegisters));
                    }

                    if (inputRegisters.HasValue | outputRegisters.HasValue)
                    {
                        Debug.WriteLine("");
                    }
                }
            }
        }

        /// <summary>
        /// Performs stage specific processing on the compiler context.
        /// </summary>
        void IMethodCompilerStage.Run()
        {
            foreach (var block in basicBlocks)
            {
                if (block.Label == BasicBlock.EpilogueLabel)
                    continue;

                for (var context = new Context(instructionSet, block); !context.EndOfInstruction; context.GotoNext())
                {
                    if (context.Instruction is IR.Phi)
                        ProcessPhiInstruction(block, context);

                    for (var i = 0; i < context.OperandCount; ++i)
                    {
                        var op = context.GetOperand(i);
                        if (op is SsaOperand)
                            context.SetOperand(i, (op as SsaOperand).Operand);
                    }

                    if (context.Result != null)
                    {
                        if (context.Result is SsaOperand)
                            context.Result = (context.Result as SsaOperand).Operand;
                    }
                }
            }
        }

 /// <summary>
 /// Performs stage specific processing on the compiler context.
 /// </summary>
 public virtual void Run()
 {
     for (int index = 0; index < basicBlocks.Count; index++)
         for (Context ctx = new Context(instructionSet, basicBlocks[index]); !ctx.EndOfInstruction; ctx.GotoNext())
             if (!ctx.IsEmpty)
                 ctx.Clone().Visit(this);
 }

        /// <summary>
        /// Performs stage specific processing on the compiler context.
        /// </summary>
        void IMethodCompilerStage.Run()
        {
            //Trace("METHOD: " + this.methodCompiler.FullName);

            // Initialize arrays
            top = new RegisterBitmap[basicBlocks.Count];
            bottom = new RegisterBitmap[basicBlocks.Count];
            analyzed = new BitArray(basicBlocks.Count);
            traversed = new BitArray(basicBlocks.Count);
            usage = new RegisterBitmap[instructionSet.Size];

            foreach (var block in basicBlocks)
            {
                AnalyzeBlock(block);
            }

            Trace("METHOD: " + this.methodCompiler.Method.FullName);
            Trace(string.Empty);

            var registers = new Dictionary<int, Register>();
            foreach (var register in architecture.RegisterSet)
                registers.Add(register.Index, register);

            StringBuilder line = new StringBuilder();
            for (int l = 0; l < 3; l++)
            {
                line.Append("[");
                for (int r = 15; r >= 0; r--)
                {
                    line.Append(registers[r].ToString()[l]);
                }

                line.Append("]");
            }
            Trace(line.ToString());

            foreach (var block in this.basicBlocks)
            {
                Trace(String.Format("Block #{0} - Label L_{1:X4}", block.Index, block.Label));

                Trace("[" + top[block.Sequence].ToString().Substring(64 - 16, 16) + "] Top");

                for (var ctx = new Context(instructionSet, block); !ctx.EndOfInstruction; ctx.GotoNext())
                {
                    if (ctx.IsEmpty)
                        continue;

                    Trace("[" + usage[ctx.Index].ToString().Substring(64 - 16, 16) + "] " + String.Format("L_{0:X4}: {1}", ctx.Label, ctx.Instruction.ToString(ctx)));
                }

                Trace("[" + bottom[block.Sequence].ToString().Substring(64 - 16, 16) + "] Bottom");
                Trace(string.Empty);
            }

            return;
        }

 private Context GetFirstContext(BasicBlock block)
 {
     for (Context context = new Context(InstructionSet, block); !context.IsBlockEndInstruction; context.GotoNext())
     {
         if (context.IsBlockStartInstruction)
             continue;
         return context;
     }
     return null;
 }

        protected override void Run()
        {
            for (int index = 0; index < BasicBlocks.Count; index++)
                for (Context ctx = new Context(InstructionSet, BasicBlocks[index]); !ctx.IsBlockEndInstruction; ctx.GotoNext())
                    if (!ctx.IsEmpty)
                        ProcessInstruction(ctx.Clone());

            for (int index = 0; index < BasicBlocks.Count; index++)
                for (Context ctx = new Context(InstructionSet, BasicBlocks[index]); !ctx.IsBlockEndInstruction; ctx.GotoNext())
                    if (!ctx.IsEmpty)
                        ReplaceOperands(ctx.Clone());

            repl.Clear();
        }