C# Compiler.IsRuntimeMethod方法代码示例

        public override int GetSize(Compiler compiler, Instruction instruction)
        {
            // Get destination
            MethodReference destinationRef = instruction.Operand as MethodReference;
            string methodName = Util.GetFriendlyMethodName(destinationRef);

            // See below
            if (compiler.IsRuntimeMethod(methodName))
                return 2;

            return 3;
        }

        public override int GetSize(Compiler compiler, Instruction instruction)
        {
            // Get .ctor method from operand and get the class associated with it
            MethodReference ctor = instruction.Operand as MethodReference;
            TypeReference type = ctor.DeclaringType;

            // See below, if native type, this is just a CALL (3 or 2)
            // Else, this is a NEWOBJ (4)
            if (Util.IsNativeType(type))
            {
                string methodName = Util.GetFriendlyMethodName(ctor);
                if (compiler.IsRuntimeMethod(methodName))
                    return 2;

                return 3;
            }
            else
            {
                return 4;
            }
        }

        public override void Process(Compiler compiler, MethodData methodData, Instruction instruction)
        {
            // Get destination
            MethodReference destinationRef = instruction.Operand as MethodReference;
            string methodName = Util.GetFriendlyMethodName(destinationRef);

            // Check if it's a special method that should be caught here
            if (methodName == "ILVM_Asm_Execute2")
            {
                // IL code at this point will look like this
                // LOAD STRING "<assembly code>"
                // LOAD REGS
                // CALL ASM.EXECUTE

                // So we must check if two instructions before this the assembly code is loaded
                // else we need to throw an error
                Instruction ldstr = instruction.Previous.Previous;
                if (ldstr.OpCode != OpCodes.Ldstr)
                {
                    throw new Exception("Assembly code needs to be directly in the call");
                }
                else
                {
                    // Prepare assembler
                    string code = ldstr.Operand as string;
                    Assembler asm = compiler.Assembler;
                    int offset = asm.GetOffset();

                    // Since this is used as a "method" we need to place a return at the end
                    asm.HandleCode(code);
                    asm.HandleInstruction("ret");
                    int codeSize = asm.GetOffset() - offset;

                    // Write instruction followed by asm offset and asm size
                    methodData.AddInstruction(Ops.OP_RUNTIME_ASM);
                    methodData.AddInstruction(offset);
                    methodData.AddInstruction(codeSize);
                }
                return;
            }

            // If it's implemented in runtime, emit a special seperate instruction for this
            if (compiler.IsRuntimeMethod(methodName))
            {
                // Write instruction followed by the runtime method ID
                methodData.AddInstruction(Ops.OP_RUNTIME_CALL);
                methodData.AddInstruction(compiler.GetRuntimeMethodID(methodName));
            }
            else
            {
                // Get definition from reference
                MethodDefinition destination = destinationRef.Resolve();

                // Lookup the method, if it isn't processed yet, process it
                int methodId = compiler.GetMethodID(destination);
                if (methodId == -1)
                    methodId = compiler.ProcessMethod(destination);

                // If the method is not static, we pass "this" as argument, so we count 1 parameter extra
                int paramCount = destinationRef.Parameters.Count;
                if (!destination.IsStatic)
                    paramCount++;

                // Write instruction followed by the method ID
                methodData.AddInstruction(instruction.OpCode.Value);
                methodData.AddInstruction(methodId);
                methodData.AddInstruction(paramCount);
            }
        }