C# Context.SetResult方法代码示例

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

//.........这里部分代码省略.........
                 * 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) {
                            // Darn, need to spill one...
                            rop = SpillRegister(at, res.Type, regs);
                            // We don't need to place a load here, as we're defining the register...
                        }

                        // Assign the register
                        Debug.Assert(null != rop, @"Whoa: Failed to allocate a register operand??");
                        AssignRegister(rop, res, at);
                        ctx.SetResult(opIdx, rop); // FIXME PG - same
                    }
                    else {
                        RegisterOperand rop = res as RegisterOperand;
                        if (rop != null)
                            SpillRegisterIfInUse(ctx, rop);
                    }

                    opIdx++;
                }
            }
        }

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