GetOperand() public method

Gets the operand by index.
public GetOperand ( int index ) : Operand
index int The index.
return Operand
Exemplo n.º 1
0
        /// <summary>
        /// Performs stage specific processing on the compiler context.
        /// </summary>
        void IMethodCompilerStage.Run()
        {
            if (AreExceptions)
                return;

            foreach (var block in this.basicBlocks)
            {
                if (block.Label == Int32.MaxValue)
                    continue;

                for (var context = new Context(this.instructionSet, block); !context.EndOfInstruction; context.GotoNext())
                {
                    if (context.Instruction is PhiInstruction)
                        this.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);
                    }

                    for (var i = 0; i < context.ResultCount; ++i)
                    {
                        var op = context.GetResult(i);
                        if (op is SsaOperand)
                            context.SetResult(i, (op as SsaOperand).Operand);
                    }
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Replaces the intrinsic call site
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="typeSystem">The type system.</param>
        void IIntrinsicPlatformMethod.ReplaceIntrinsicCall(Context context, BaseMethodCompiler methodCompiler)
        {
            Operand v0 = context.Operand1;
            Operand v1 = context.Operand2;
            Operand v2 = context.Operand3;
            Operand v3 = context.GetOperand(3);

            Operand esp = Operand.CreateCPURegister(methodCompiler.TypeSystem.BuiltIn.I4, GeneralPurposeRegister.ESP);
            Operand ebp = Operand.CreateCPURegister(methodCompiler.TypeSystem.BuiltIn.I4, GeneralPurposeRegister.EBP);

            Operand eax = Operand.CreateCPURegister(methodCompiler.TypeSystem.BuiltIn.I4, GeneralPurposeRegister.EAX);
            Operand ebx = Operand.CreateCPURegister(methodCompiler.TypeSystem.BuiltIn.I4, GeneralPurposeRegister.EBX);
            Operand ecx = Operand.CreateCPURegister(methodCompiler.TypeSystem.BuiltIn.I4, GeneralPurposeRegister.ECX);

            Operand exceptionRegister = Operand.CreateCPURegister(methodCompiler.TypeSystem.BuiltIn.Object, methodCompiler.Architecture.ExceptionRegister);

            // Move all virtual registers into physical registers - necessary since stack frame pointer will change
            context.SetInstruction(X86.Mov, eax, v0);
            context.AppendInstruction(X86.Mov, ebx, v1);
            context.AppendInstruction(X86.Mov, ecx, v2);
            context.AppendInstruction(X86.Mov, exceptionRegister, v3);

            // Update the frame and stack registers
            context.AppendInstruction(X86.Mov, ebp, ecx);
            context.AppendInstruction(X86.Mov, esp, ebx);
            context.AppendInstruction(X86.Jmp, null, eax);

            // future - common code (refactor opportunity)
            context.GotoNext();

            // Remove all remaining instructions in block and clear next block list
            while (!context.IsBlockEndInstruction)
            {
                if (!context.IsEmpty)
                {
                    context.SetInstruction(X86.Nop);
                }
                context.GotoNext();
            }

            var nextBlocks = context.Block.NextBlocks;

            foreach (var next in nextBlocks)
            {
                next.PreviousBlocks.Remove(context.Block);
            }

            nextBlocks.Clear();
        }
Exemplo n.º 3
0
        /// <summary>
        /// Returns a <see cref="System.String"/> that represents this instance.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns>
        /// A <see cref="System.String"/> that represents this instance.
        /// </returns>
        public virtual string ToString(Context context)
        {
            StringBuilder s = new StringBuilder(ToString());

            if (context.Other is IR.ConditionCode)
            {
                s.Append(" [");
                s.Append(GetConditionString(context.ConditionCode));
                s.Append("]");
            }

            string mod = GetModifier(context);
            if (mod != null)
            {
                s.Append(" [");
                s.Append(mod);
                s.Append("]");
            }

            if (context.ResultCount != 0)
            {
                s.Append(" ");
                s.Append(context.Result);
            }

            if (context.ResultCount > 0 && context.OperandCount > 0)
            {
                s.Append(" <-");
            }

            for (int i = 0; (i < 3) && (i < context.OperandCount); i++)
            {
                s.Append(" ");
                s.Append(context.GetOperand(i));
                s.Append(",");
            }

            if (context.OperandCount > 3)
            {
                s.Append(" [more]");
            }
            else if (context.OperandCount > 0)
            {
                s.Length = s.Length - 1;
            }

            if (context.BranchTargets != null)
            {
                for (int i = 0; (i < 2) && (i < context.BranchTargets.Length); i++)
                {
                    s.Append(String.Format(@" L_{0:X4},", context.BranchTargets[i]));
                }

                if (context.BranchTargets.Length > 2)
                {
                    s.Append(" [more]");
                }
                else if (context.BranchTargets.Length > 0)
                {
                    s.Length = s.Length - 1;
                }
            }

            if (context.InvokeTarget != null)
            {
                s.Append(" {");
                s.Append(context.InvokeTarget.ToString());
                s.Append("}");
            }

            if (context.RuntimeField != null)
            {
                s.Append(" {");
                s.Append(context.RuntimeField.ToString());
                s.Append("}");
            }

            return s.ToString();
        }
Exemplo n.º 4
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="block"></param>
        private void RenameVariables(BasicBlock block)
        {
            for (var context = new Context(this.instructionSet, block); !context.EndOfInstruction; context.GotoNext())
            {
                if (!(context.Instruction is PhiInstruction))
                {
                    for (var i = 0; i < context.OperandCount; ++i)
                    {
                        var op = context.GetOperand(i);
                        if (!(op is StackOperand))
                            continue;
                        var name = NameForOperand(context.GetOperand(i));
                        if (!this.variableInformation.ContainsKey(name))
                            throw new Exception(name + " is not in dictionary [block = " + block + "]");
                        var index = this.variableInformation[name].Stack.Peek();
                        context.SetOperand(i, new SsaOperand(context.GetOperand(i), index));
                    }
                }

                if (PhiPlacementStage.IsAssignmentToStackVariable(context))
                {
                    var name = NameForOperand(context.Result);
                    var index = this.variableInformation[name].Count;
                    context.SetResult(new SsaOperand(context.Result, index));
                    this.variableInformation[name].Stack.Push(index);
                    ++this.variableInformation[name].Count;
                }
            }

            foreach (var s in block.NextBlocks)
            {
                var j = this.WhichPredecessor(s, block);
                for (var context = new Context(this.instructionSet, s); !context.EndOfInstruction; context.GotoNext())
                {
                    if (!(context.Instruction is PhiInstruction))
                        continue;
                    var name = NameForOperand(context.GetOperand(j));
                    if (this.variableInformation[name].Stack.Count > 0)
                    {
                        var index = this.variableInformation[name].Stack.Peek();
                        context.SetOperand(j, new SsaOperand(context.GetOperand(j), index));
                    }
                }
            }

            foreach (var s in this.dominanceCalculationStage.GetChildren(block))
            {
                this.RenameVariables(s);
            }

            for (var context = new Context(this.instructionSet, block); !context.EndOfInstruction; context.GotoNext())
            {
                if (PhiPlacementStage.IsAssignmentToStackVariable(context))
                {
                    var instName = context.Label + "." + context.Index;
                    var op = this.oldLefHandSide[instName];
                    var name = NameForOperand(op);
                    this.variableInformation[name].Stack.Pop();
                }
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Returns a <see cref="System.String"/> that represents this instance.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns>
        /// A <see cref="System.String"/> that represents this instance.
        /// </returns>
        public virtual string ToString(Context context)
        {
            StringBuilder s = new StringBuilder(ToString());

            if (context.ConditionCode != ConditionCode.Undefined)
            {
                s.Append(" [");
                s.Append(GetConditionString(context.ConditionCode));
                s.Append("]");
            }

            if (context.MosaType != null)
            {
                s.Append(" [");
                s.Append(context.MosaType.FullName);
                s.Append("]");
            }

            if (context.MosaField != null)
            {
                s.Append(" [");
                s.Append(context.MosaField.FullName);
                s.Append("]");
            }

            string mod = GetModifier(context);
            if (mod != null)
            {
                s.Append(" [");
                s.Append(mod);
                s.Append("]");
            }

            if (context.ResultCount != 0)
            {
                s.Append(" ");
                s.Append(context.Result);

                if (context.ResultCount == 2)
                {
                    s.Append(" : ");
                    s.Append(context.Result2);
                }
            }
            if (context.ResultCount > 0 && context.OperandCount > 0)
            {
                s.Append(" <=");
            }

            for (int i = 0; i < context.OperandCount; i++)
            {
                s.Append(" ");
                s.Append(context.GetOperand(i));
                s.Append(",");
            }

            if (context.OperandCount > 0)
            {
                s.Length = s.Length - 1;
            }

            if (context.BranchTargets != null)
            {
                for (int i = 0; (i < 2) && (i < context.BranchTargets.Length); i++)
                {
                    s.Append(String.Format(@" L_{0:X4},", context.BranchTargets[i]));
                }

                if (context.BranchTargets.Length > 2)
                {
                    s.Append(" [more]");
                }
                else if (context.BranchTargets.Length > 0)
                {
                    s.Length = s.Length - 1;
                }
            }

            if (context.MosaMethod != null)
            {
                s.Append(" {");
                s.Append(context.MosaMethod.FullName);
                s.Append("}");
            }

            if (context.MosaField != null)
            {
                s.Append(" {");
                s.Append(context.MosaField.FullName);
                s.Append("}");
            }

            return s.ToString();
        }
        /// <summary>
        /// Assigns the operands from CIL stack.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="currentStack">The current stack.</param>
        private void AssignOperandsFromCILStack(Context ctx, Stack<Operand> currentStack)
        {
            for (int index = ctx.OperandCount - 1; index >= 0; --index)
            {
                if (ctx.GetOperand(index) != null)
                    continue;

                ctx.SetOperand(index, currentStack.Pop());
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// Pops the operands of an instruction from the evaluation stack.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <returns>The number of operands popped.</returns>
        private int PopOperands(Context ctx)
        {
            for (int i = ctx.OperandCount - 1; i > -1; i--)
            {
                Operand op = ctx.GetOperand(i);
                Operand evalOp = evaluationStack.Pop();
                Debug.Assert(ReferenceEquals(evalOp, op), @"Operand's are not equal?");
            }

            return ctx.OperandCount;
        }
Exemplo n.º 8
0
        /// <summary>
        /// Processes the phi instruction.
        /// </summary>
        /// <param name="block">The block.</param>
        /// <param name="context">The context.</param>
        private void ProcessPhiInstruction(BasicBlock block, Context context)
        {
            for (var predecessorIndex = 0; predecessorIndex < block.PreviousBlocks.Count; ++predecessorIndex)
            {
                var predecessor = block.PreviousBlocks[predecessorIndex];
                var operand = context.GetOperand(predecessorIndex);

                this.InsertCopyStatement(predecessor, context.Result, operand);
            }
            context.Remove();
        }