C# Context.SetOperand方法代码示例

        /// <summary>
        /// Replaces the instrinsic call site
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="typeSystem">The type system.</param>
        public void ReplaceIntrinsicCall(Context context, ITypeSystem typeSystem)
        {
            SigType u4 = new SigType(Runtime.Metadata.CilElementType.U4);

            // Retrieve register context
            context.SetInstruction(CPUx86.Instruction.MovInstruction, new RegisterOperand(u4, GeneralPurposeRegister.EAX), new MemoryOperand(u4, GeneralPurposeRegister.ESP, new IntPtr(28)));

            // Restore registers (Note: EAX and EDX are NOT restored!)
            context.AppendInstruction(CPUx86.Instruction.MovInstruction, new RegisterOperand(u4, GeneralPurposeRegister.EDX), new MemoryOperand(u4, GeneralPurposeRegister.EAX, new IntPtr(28)));
            context.AppendInstruction(CPUx86.Instruction.MovInstruction, new RegisterOperand(u4, GeneralPurposeRegister.EBX), new MemoryOperand(u4, GeneralPurposeRegister.EAX, new IntPtr(4)));
            context.AppendInstruction(CPUx86.Instruction.MovInstruction, new RegisterOperand(u4, GeneralPurposeRegister.EDI), new MemoryOperand(u4, GeneralPurposeRegister.EAX, new IntPtr(20)));
            context.AppendInstruction(CPUx86.Instruction.MovInstruction, new RegisterOperand(u4, GeneralPurposeRegister.ESI), new MemoryOperand(u4, GeneralPurposeRegister.EAX, new IntPtr(16)));
            context.AppendInstruction(CPUx86.Instruction.MovInstruction, new RegisterOperand(u4, GeneralPurposeRegister.ESP), new MemoryOperand(u4, GeneralPurposeRegister.EAX, new IntPtr(32)));
            context.AppendInstruction(CPUx86.Instruction.MovInstruction, new RegisterOperand(u4, GeneralPurposeRegister.EBP), new MemoryOperand(u4, GeneralPurposeRegister.EAX, new IntPtr(24)));

            // Jmp to EIP (stored in EDX)
            context.AppendInstruction(CPUx86.Instruction.JmpInstruction);
            context.SetOperand(0, new RegisterOperand(u4, GeneralPurposeRegister.EDX));
        }

        /// <summary>
        /// Assigns registers to operands of the instruction.
        /// </summary>
        /// <param name="ctx">The context.</param>
        private void AssignRegisters(Context ctx)
        {
            // Retrieve the register constraints for the instruction
            IRegisterConstraint rc = null; // _architecture.GetRegisterConstraint(instr);	// FIXME PG - pass context instead???

            // Operand index
            int opIdx;

            if (rc == null && TRACING.TraceWarning)
                Trace.WriteLine(String.Format(@"Failed to get register constraints for instruction {0}!", ctx.Instruction.ToString(ctx)));

            // Only process the instruction, if we have constraints...
            if (rc != null) {
                /* FIXME: Spill used registers, if they are in use :(
                 * It is not as simple as it sounds, as the register may be used by the instruction itself,
                 * but dirty afterwards anyways. So we need to decide this at some later point depending on
                 * the arg list. If the register is also a result reg, and they represent the same operand,
                 * we may get away without spilling... Oo?
                 */
                //Register[] used = rc.GetRegistersUsed();

                opIdx = 0;

                Context at = ctx.Clone();

                foreach (Operand op in ctx.Operands) {
                    // Only allocate registers, if we really have to.
                    if (!rc.IsValidOperand(opIdx, op)) {
                        // The register operand allocated
                        RegisterOperand rop;
                        // List of compatible registers
                        Register[] regs = rc.GetRegistersForOperand(opIdx);
                        Debug.Assert(null != regs, @"IRegisterConstraint.GetRegistersForOperand returned null.");
                        Debug.Assert(0 != regs.Length, @"WTF IRegisterConstraint.GetRegistersForOperand returned zero-length array - what shall we pass then if no register/memory?");

                        // Is this operand in a register?
                        rop = GetRegisterOfOperand(op);
                        if (rop != null && Array.IndexOf(regs, rop.Register) == -1) {
                            // Spill the register...
                            SpillRegister(ctx, op, rop);
                            rop = null;
                        }

                        // Attempt to allocate a free register
                        if (rop == null) {
                            rop = AllocateRegister(regs, op);
                            if (rop != null) {
                                // We need to place a load here... :(
                                InsertMove(ctx, rop, op);
                            }
                        }

                        // Still failed to get one? Spill!
                        if (rop == null) {
                            // Darn, need to spill one... Always use the first one.
                            rop = SpillRegister(at, op.Type, regs);

                            // We need to place a load here... :(
                            InsertMove(at, rop, op);
                        }

                        // Assign the register
                        Debug.Assert(rop != null, @"Whoa: Failed to allocate a register operand??");
                        AssignRegister(rop, op, at);
                        ctx.SetOperand(opIdx, rop); // FIXME PG - opIdx? hmmm. is this phidata?
                    }

                    opIdx++;
                }

                opIdx = 0;
                foreach (Operand res in ctx.Results) {
                    // FIXME: Check support first, spill if register is target and in use
                    if (!rc.IsValidResult(opIdx, res)) {
                        // Is this operand in a register?
                        RegisterOperand rop = GetRegisterOfOperand(res);
                        if (rop == null && !rc.IsValidResult(opIdx, res) && res.Uses.Count == 0)
                            // Do not allocate: Not in a register, allows memory & has no uses... oO wtf?
                            continue;

                        // Retrieve compliant registers
                        Register[] regs = rc.GetRegistersForResult(opIdx);

                        // Do we already have a register?
                        if (rop != null && Array.IndexOf(regs, rop.Register) == -1) {
                            // Hmm, current register doesn't match, release it - since we're overwriting the operand,
                            // we don't need to spill. This should be safe.
                            _activeOperands[rop.Register.Index] = null;
                        }

                        // Allocate a register
                        if (rop == null)
                            rop = AllocateRegister(regs, res);

                        // Do we need to spill?
                        if (rop == null) {
//.........这里部分代码省略.........

        /// <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());
            }
        }

 /// <summary>
 /// Assigns the operands from CIL stack.
 /// </summary>
 /// <param name="ctx">The context.</param>
 /// <param name="currentStack">The current stack.</param>
 private static void AssignOperandsFromCILStack(Context ctx, IList<Operand> currentStack)
 {
     for (int index = ctx.OperandCount - 1; index >= 0; --index)
     {
         if (ctx.GetOperand (index) == null)
         {
             Operand operand = currentStack[currentStack.Count - 1];
             currentStack.RemoveAt (currentStack.Count - 1);
             ctx.SetOperand (index, operand);
         }
     }
 }

        /// <summary>
        /// Replaces the operand.
        /// </summary>
        /// <param name="lr">The lr.</param>
        /// <param name="replacement">The replacement.</param>
        private void ReplaceOperand(LiveRange lr, RegisterOperand replacement)
        {
            int opIdx;

            // Iterate all definition sites first
            foreach (int index in lr.Op.Definitions.ToArray()) {
                Context def = new Context(InstructionSet, index);
                if (def.Offset == lr.Start) {
                    opIdx = 0;
                    foreach (Operand r in def.Results) {
                        // Is this the operand?
                        if (object.ReferenceEquals(r, lr.Op))
                            def.SetResult(opIdx, replacement);

                        opIdx++;
                    }

                    break;
                }
            }

            // Iterate all use sites
            foreach (int index in lr.Op.Uses.ToArray()) {
                Context instr = new Context(InstructionSet, index);

                if (instr.Offset <= lr.Start) {
                    // A use on instr.Offset == lr.Start is one From a previous definition!!
                }
                else if (instr.Offset <= lr.End) {
                    opIdx = 0;
                    foreach (Operand r in instr.Operands) {
                        // Is this the operand?
                        if (object.ReferenceEquals(r, lr.Op))
                            instr.SetOperand(opIdx, replacement);

                        opIdx++;
                    }
                }
                else {
                    break;
                }
            }
        }

        /// <summary>
        /// Replaces the instruction with an internal call.
        /// </summary>
        /// <param name="ctx">The transformation context.</param>
        /// <param name="internalCallTarget">The internal call target.</param>
        private void ReplaceWithInternalCall(Context ctx, VmCall internalCallTarget)
        {
            RuntimeType rt = RuntimeBase.Instance.TypeLoader.GetType(@"Mosa.Runtime.RuntimeBase");
            RuntimeMethod callTarget = FindMethod(rt, internalCallTarget.ToString());

            ctx.ReplaceInstructionOnly(IR.Instruction.CallInstruction);
            ctx.SetOperand(0, SymbolOperand.FromMethod(callTarget));
        }

        /// <summary>
        /// Processes a method call instruction.
        /// </summary>
        /// <param name="ctx">The transformation context.</param>
        /// <param name="destinationOperand">The operand, which holds the call destination.</param>
        /// <param name="resultOperand"></param>
        /// <param name="operands"></param>
        private void ProcessInvokeInstruction(Context ctx, Operand destinationOperand, Operand resultOperand, List<Operand> operands)
        {
            ctx.SetInstruction(Instruction.CallInstruction, (byte)(operands.Count + 1), (byte)(resultOperand != null ? 1 : 0));
            ctx.SetResult(resultOperand);

            int operandIndex = 0;
            ctx.SetOperand(operandIndex++, destinationOperand);
            foreach (Operand op in operands)
            {
                ctx.SetOperand(operandIndex++, op);
            }
        }

        /// <summary>
        /// Visitation function for <see cref="ICILVisitor.Newarr"/>.
        /// </summary>
        /// <param name="ctx">The context.</param>
        public void Newarr(Context ctx)
        {
            Operand thisReference = ctx.Result;
            Debug.Assert(thisReference != null, @"Newobj didn't specify class signature?");

            SZArraySigType arrayType = (SZArraySigType)ctx.Result.Type;
            ClassSigType elementSigType = arrayType.ElementType as ClassSigType;
            RuntimeType elementType = RuntimeBase.Instance.TypeLoader.GetType(this.MethodCompiler.Method, this.MethodCompiler.Assembly, elementSigType.Token);
            Debug.Assert(elementType != null, @"Newarr didn't specify class signature?");

            Operand lengthOperand = ctx.Operand1;
            int elementSize = elementType.Size;

            // HACK: If we can't determine the size now, assume 16 bytes per array element.
            if (elementSize == 0)
            {
                elementSize = 16;
            }

            ReplaceWithInternalCall(ctx, VmCall.AllocateArray);

            ctx.SetOperand(1, new ConstantOperand(BuiltInSigType.IntPtr, 0));
            ctx.SetOperand(2, new ConstantOperand(BuiltInSigType.Int32, elementSize));
            ctx.SetOperand(3, lengthOperand);
            ctx.OperandCount = 4;
        }

        /// <summary>
        /// Replaces the instruction with an internal call.
        /// </summary>
        /// <param name="context">The transformation context.</param>
        /// <param name="internalCallTarget">The internal call target.</param>
        private void ReplaceWithVmCall(Context context, VmCall internalCallTarget)
        {
            RuntimeType type = typeSystem.GetType(@"Mosa.Internal.Runtime");
            Debug.Assert(type != null, "Cannot find Mosa.Internal.Runtime");

            RuntimeMethod method = type.FindMethod(internalCallTarget.ToString());
            Debug.Assert(method != null, "Cannot find method: " + internalCallTarget.ToString());

            context.ReplaceInstructionOnly(IR.Instruction.CallInstruction);
            context.SetOperand(0, SymbolOperand.FromMethod(method));
        }

        /// <summary>
        /// Visitation function for Newarr instruction.
        /// </summary>
        /// <param name="context">The context.</param>
        public void Newarr(Context context)
        {
            Operand thisReference = context.Result;
            Debug.Assert(thisReference != null, @"Newobj didn't specify class signature?");

            SZArraySigType arrayType = (SZArraySigType)context.Result.Type;
            ClassSigType elementSigType = arrayType.ElementType as ClassSigType;
            RuntimeType elementType = typeModule.GetType(elementSigType.Token);
            Debug.Assert(elementType != null, @"Newarr didn't specify class signature?");

            Operand lengthOperand = context.Operand1;
            int elementSize = typeLayout.GetTypeSize(elementType);

            // HACK: If we can't determine the size now, assume 16 bytes per array element.
            if (elementSize == 0)
            {
                elementSize = 16;
            }

            ReplaceWithVmCall(context, VmCall.AllocateArray);

            context.SetOperand(1, new ConstantOperand(BuiltInSigType.IntPtr, 0));
            context.SetOperand(2, new ConstantOperand(BuiltInSigType.Int32, elementSize));
            context.SetOperand(3, lengthOperand);
            context.OperandCount = 4;
        }

        /// <summary>
        /// Replaces the instruction with an internal call.
        /// </summary>
        /// <param name="context">The transformation context.</param>
        /// <param name="internalCallTarget">The internal call target.</param>
        private void ReplaceWithVmCall(Context context, VmCall internalCallTarget)
        {
            RuntimeType rt = typeSystem.GetType(@"Mosa.Vm.Runtime");
            Debug.Assert(rt != null, "@rt / @callTarget=" + internalCallTarget.ToString());

            RuntimeMethod callTarget = rt.FindMethod(internalCallTarget.ToString());
            Debug.Assert(callTarget != null, "@callTarget=" + internalCallTarget.ToString());

            context.ReplaceInstructionOnly(IR.Instruction.CallInstruction);
            context.SetOperand(0, SymbolOperand.FromMethod(callTarget));
        }