Пример #1
0
 public BinaryFunc(FuncName name, OpCode opcode, Type returnType)
 {
     Name = name;
     _case = 0;
     _opcode = opcode;        
     _returnType = returnType;
 }
Пример #2
0
 public void EmitIf(OpCode comparasionOpcode, bool not = false)
 {
     _generator
         .Emit(comparasionOpcode)
         .EmitIf(!not, a => a.Brfalse(_ifFalse))
         .EmitIf(not, a => a.Brtrue(_ifFalse));
 }
Пример #3
0
        static DynamicMethodDefinition()
        {
            foreach (FieldInfo field in typeof(System.Reflection.Emit.OpCodes).GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                System.Reflection.Emit.OpCode reflOpCode = (System.Reflection.Emit.OpCode)field.GetValue(null);
                _ReflOpCodes[reflOpCode.Value] = reflOpCode;
            }

            foreach (FieldInfo field in typeof(Mono.Cecil.Cil.OpCodes).GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                Mono.Cecil.Cil.OpCode cecilOpCode = (Mono.Cecil.Cil.OpCode)field.GetValue(null);
                _CecilOpCodes[cecilOpCode.Value] = cecilOpCode;
            }

            foreach (MethodInfo method in typeof(ILGenerator).GetMethods())
            {
                if (method.Name != "Emit")
                {
                    continue;
                }

                ParameterInfo[] args = method.GetParameters();
                if (args.Length != 2)
                {
                    continue;
                }

                if (args[0].ParameterType != typeof(System.Reflection.Emit.OpCode))
                {
                    continue;
                }
                _Emitters[args[1].ParameterType] = method;
            }
        }
Пример #4
0
 public void Emit(OpCode code, ConstructorInfo constructor)
 {
     if (code == OpCodes.Newobj)
     {
         instructions.Add((args) => EmitInternal(code, constructor));
     }
 }
Пример #5
0
        internal OperatorToken(Operator op)
        {
            switch (op)
            {
                case Operator.Add:
                    _opCode = OpCodes.Add;
                    break;
                case Operator.Subtract:
                    _opCode = OpCodes.Sub;
                    break;
                case Operator.Multiply:
                    _opCode = OpCodes.Mul;
                    break;
                case Operator.Divide:
                    _opCode = OpCodes.Div;
                    break;
                case Operator.Power:
                    _opCode = OpCodes.Call;
                    break;
                case Operator.Modulus:
                    _opCode = OpCodes.Rem;
                    break;
                default:
                    throw new ArgumentException("Unknown operator.");
            }

            Operator = op;
        }
Пример #6
0
 private static void EmitIndexedInstruction(this ILGenerator il, OpCode[] index, int argument) {
     if (argument < index.Length - 1) {
         il.Emit(index[argument]);
         return;
     }
     il.Emit(index[index.Length - 1], argument);
 }
Пример #7
0
        int GetOperandSize(OpCode o, int pos)
        {
            switch (o.OperandType)
            {
                case OperandType.ShortInlineBrTarget: return 1;
                case OperandType.ShortInlineI: return 1;
                case OperandType.ShortInlineR: return 4;
                case OperandType.ShortInlineVar: return 1;
                case OperandType.InlineVar: return 2;
                case OperandType.InlineType: return 4;
                case OperandType.InlineTok: return 4;
                case OperandType.InlineString: return 4;
                case OperandType.InlineSig: return 4;
                case OperandType.InlineR: return 8;
                case OperandType.InlineNone: return 0;
                case OperandType.InlineMethod: return 4;
                case OperandType.InlineI8: return 8;
                case OperandType.InlineI: return 4;
                case OperandType.InlineField: return 4;
                case OperandType.InlineBrTarget: return 4;
                case OperandType.InlineSwitch:
                    return 4 + 4 * BitConverter.ToInt32(code, pos);
            }

            throw new NotImplementedException();
        }
        private void Emit(OpCode opCode, [NotNull] MethodReference methodRefernce)
        {
            var type           = GetRuntimeType(methodRefernce.DeclaringType);
            var parameterTypes = methodRefernce.Parameters.Select(param => GetRuntimeType(param.ParameterType)).ToArray();

            if (methodRefernce.Name == Ctor)
            {
                var constructor = type.GetConstructor(parameterTypes);
                if (constructor == null)
                {
                    throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Constructor {0} not found", methodRefernce.ToString()));
                }

                _ilGenerator.Emit(opCode, constructor);
                return;
            }

            var method = type.GetMethod(methodRefernce.Name, parameterTypes);

            if (method == null)
            {
                throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Method: {0} not found", methodRefernce.ToString()));
            }

            _ilGenerator.Emit(opCode, method);
        }
Пример #9
0
 public static bool IsTailableCall(OpCode op)
 {
     return
         op == OpCodes.Call ||
         //op == OpCodes.Calli ||
         op == OpCodes.Callvirt;
 }
        private void Emit(OpCode opCode, [NotNull] FieldReference fieldReference)
        {
            var type  = GetRuntimeType(fieldReference.DeclaringType);
            var field = type.GetField(fieldReference.Name);

            _ilGenerator.Emit(opCode, field);
        }
Пример #11
0
        public static int Get(OpCode op, Sigil.Label[] labels = null)
        {
            var baseSize = op.Size;
            int operandSize;

            switch (op.OperandType)
            {
                case OperandType.InlineBrTarget: operandSize = 4; break;
                case OperandType.InlineField: operandSize = 4; break;
                case OperandType.InlineI: operandSize = 4; break;
                case OperandType.InlineI8: operandSize = 8; break;
                case OperandType.InlineMethod: operandSize = 4; break;
                case OperandType.InlineNone: operandSize = 0; break;
                case OperandType.InlineR: operandSize = 8; break;
                case OperandType.InlineSig: operandSize = 4; break;
                case OperandType.InlineString: operandSize = 4; break;
                case OperandType.InlineSwitch: operandSize = 4 + labels.Length * 4; break;
                case OperandType.InlineTok: operandSize = 4; break;
                case OperandType.InlineType: operandSize = 4; break;
                case OperandType.InlineVar: operandSize = 2; break;
                case OperandType.ShortInlineBrTarget: operandSize = 1; break;
                case OperandType.ShortInlineI: operandSize = 1; break;
                case OperandType.ShortInlineR: operandSize = 4; break;
                case OperandType.ShortInlineVar: operandSize = 1; break;
                default: throw new Exception("Unexpected operand type [" + op.OperandType + "]");
            }

            return baseSize + operandSize;
        }
Пример #12
0
        static OpCodeTable()
        {
            short maxOpCodeValue = 0;

            foreach (FieldInfo field in typeof(OpCodes).GetFields())
            {
                NetOpCode netOpCode = (NetOpCode)field.GetValue(null);
                OpCode    opCode    = new OpCode(netOpCode.Value, netOpCode.Name, netOpCode.FlowControl, netOpCode.OperandType);

                _table.Add(opCode.Value, opCode);

                maxOpCodeValue = Math.Max(opCode.Value, maxOpCodeValue);
            }

            _preIncrementOpCode = new OpCode(++maxOpCodeValue, "preInc", FlowControl.Next, OperandType.InlineNone);
            _table.Add(_preIncrementOpCode.Value, _preIncrementOpCode);

            _preDecrementOpCode = new OpCode(++maxOpCodeValue, "preDec", FlowControl.Next, OperandType.InlineNone);
            _table.Add(_preDecrementOpCode.Value, _preDecrementOpCode);

            _postIncrementOpCode = new OpCode(++maxOpCodeValue, "postInc", FlowControl.Next, OperandType.InlineNone);
            _table.Add(_postIncrementOpCode.Value, _postIncrementOpCode);

            _postDecrementOpCode = new OpCode(++maxOpCodeValue, "postDec", FlowControl.Next, OperandType.InlineNone);
            _table.Add(_postDecrementOpCode.Value, _postDecrementOpCode);

            _postIncrementStatementOpCode = new OpCode(++maxOpCodeValue, "postIncStmt", FlowControl.Next, OperandType.InlineNone);
            _table.Add(_postIncrementStatementOpCode.Value, _postIncrementStatementOpCode);

            _postDecrementStatementOpCode = new OpCode(++maxOpCodeValue, "postDecStmt", FlowControl.Next, OperandType.InlineNone);
            _table.Add(_postDecrementStatementOpCode.Value, _postDecrementStatementOpCode);
        }
Пример #13
0
 internal MethodInstruction(int offset, OpCode opCode, int token, ModuleScopeTokenResolver resolver)
 {
     this.offset = offset;
       this.opCode = opCode;
       this.resolver = resolver;
       this.token = token;
 }
Пример #14
0
        public virtual void Emit(OpCode opcode, MethodInfo method)
        {
            _gen.Emit(opcode, method);

            var methodParameters = method.GetParameters();
            var parameters = string.Join(", ", methodParameters.Select(p => p.ParameterType.Name));
            _writer.WriteLine(string.Concat(opcode, ", ", method.Name, "(", parameters, ")"));
        }
Пример #15
0
 public static bool IsPrefix(OpCode op)
 {
     return
         op == OpCodes.Tailcall ||
         op == OpCodes.Readonly ||
         op == OpCodes.Volatile ||
         op == OpCodes.Unaligned;
 }
Пример #16
0
        internal ConversionOpcode(Emit.OpCode opcode) : base(opcode)
        {
            var match = nameRegex.Match(opcode.Name);

            targetDataType    = DataTypeEnum.TryParseNameInOpcode(match.Groups[2].Value).Value;
            isSourceUnsigned  = match.Groups[3].Success;
            isOverflowChecked = match.Groups[1].Success;
        }
Пример #17
0
        public virtual void Emit(OpCode opcode, ConstructorInfo ctor)
        {
            _gen.Emit(opcode, ctor);

            var ctorParameters = ctor.GetParameters();
            var parameters = string.Join(", ", ctorParameters.Select(p => p.ParameterType.Name));
            _writer.WriteLine(string.Concat(opcode, ", ", ctor.Name, "(", parameters, ")"));
        }
Пример #18
0
 public static OpCode ConvertOpCode(ROpCode ropcode)
 {
     if (reflectionToDnlib.TryGetValue(ropcode, out Opcode))
     {
         return(Opcode);
     }
     return(OpCodes.Nop);
 }
Пример #19
0
 private void AdvanceOffsetWithLabel(OpCode opcode) {
     AdvanceOffset(opcode);
     if (OpCodes.TakesSingleByteArgument(opcode)) {
         _offset++;
     } else {
         _offset += 4;
     }
 }
        private void Emit(OpCode opCode, [NotNull] Instruction[] instructionRefs)
        {
            var labels = instructionRefs
                         .Select(instructionRef => _labels[instructionRef.Offset])
                         .ToArray();

            _ilGenerator.Emit(opCode, labels);
        }
Пример #21
0
		public ConditionExpression( OpCode operation, Expression left, Expression right )
		{
			_trueStmts = new ArrayList();
			_falseStmts = new ArrayList();

			_operation = operation;
			_left = left;
			_right = right;
		}
Пример #22
0
 private BranchSet(OpCode brTrue, OpCode brFalse, OpCode brEq, OpCode brNe, OpCode brLt, OpCode brLtUn, OpCode brGt, OpCode brGtUn, OpCode brLe, OpCode brLeUn, OpCode brGe, OpCode brGeUn)
 {
     this.brTrue = brTrue; this.brFalse = brFalse;
     this.brEq = brEq; this.brNe = brNe;
     this.brLt = brLt; this.brLtUn = brLtUn;
     this.brGt = brGt; this.brGtUn = brGtUn;
     this.brLe = brLe; this.brLeUn = brLeUn;
     this.brGe = brGe; this.brGeUn = brGeUn;
 }
Пример #23
0
        private void EmitIlShift(int amount, System.Reflection.Emit.OpCode ilOp)
        {
            if (amount > 0)
            {
                EmitLdc_I4(amount);

                Emit(ilOp);
            }
        }
Пример #24
0
        protected void CheckAndEmit(OpCode? argument)
        {
            if(!argument.HasValue)
            {
                throw new InvalidOperationException();
            }

            generator.Emit(argument.Value);
        }
Пример #25
0
		public DynamicMethodBody Emit(OpCode opcode)
		{
			ExecutePreEmitActions();
	#if DEBUG
			Console.WriteLine(string.Format("\t{0}", opcode));
	#endif
			Emitter.Emit(opcode);

			return this;
		}
        public void EmitCall(OpCode opCode, MethodInfo mi)
        {
            ProcessCommand(
                opCode, 
                (mi.GetParameters().Length + 1) * -1 + (mi.ReturnType == typeof(void) ? 0 : 1), 
                mi.ToString()
                );

            ilGenerator.EmitCall(opCode, mi, null);
        }
Пример #27
0
        internal ElementReferenceOpcode(Emit.OpCode opcode) : base(opcode)
        {
            string name     = opcode.Name;
            int    dotIndex = name.LastIndexOf('.');

            if (dotIndex >= 0)
            {
                dataType = DataTypeEnum.TryParseNameInOpcode(name.Substring(dotIndex + 1));
            }
        }
Пример #28
0
        private OpCodeKb(OpCodeFamilyKb familyKb, OpCode? opcode)
        {
            FamilyKb = familyKb;
            _opCode = opcode;

            Tags = new HashSet<String>();
            Meta = new Dictionary<String, String>();
            Fields = new Dictionary<String, FieldSpec>();
            Props = new Dictionary<String, PropertySpec>();
            Prefixes = new Dictionary<String, PrefixSpec>();
        }
Пример #29
0
 internal void EmitInternal(OpCode code, ConstructorInfo constructor)
 {
     if (code == OpCodes.Newobj)
     {
         var parameterCount = constructor.GetParameters().Length;
         object[] arguments = Pop(parameterCount);
         Type type = constructor.DeclaringType;
         object instance = Activator.CreateInstance(type, arguments);
         stack.Push(instance);
     }
 }
Пример #30
0
		public DynamicMethodBody Emit(OpCode opcode, Label arg)
		{
			ExecutePreEmitActions();
	#if DEBUG
						Console.WriteLine("\t{0} IL_{1}", opcode, arg.GetHashCode());
				#endif
			
			Emitter.Emit(opcode, arg);

			return this;
		}
Пример #31
0
		public DynamicMethodBody Emit(OpCode opcode, string arg)
		{
			ExecutePreEmitActions();
	#if DEBUG
						Console.WriteLine("\t{0} \"{1}\"", opcode, arg);
				#endif
			
			Emitter.Emit(opcode, arg);

			return this;
		}
		public DynamicMethodBody Emit(OpCode opcode, TypeReference arg)
		{
			ExecutePreEmitActions();
#if DEBUG
			Console.WriteLine("\t{0} {1}", opcode, arg);
#endif

			Emitter.Emit(opcode, arg);

			return this;
		}
Пример #33
0
 public static Parser<IEnumerable<Instruction>, Instruction> OpCode(OpCode opcode)
 {
     return input =>
     {
         var l = input.ToList();
         if (l.Count >= 1 && l[0].OpCode == opcode)
         {
             return Parsers.Result(l[0], l.Skip(1));
         }
         return null;
     };
 }
Пример #34
0
		public DynamicMethodBody Emit(OpCode opcode, double arg)
        {
			ExecutePreEmitActions();
			#if DEBUG
						Console.WriteLine("\t{0} {1}", opcode, arg);
						#endif
			
			methodInfoField.GetILEmitter()
                .Emit(opcode, arg);

            return this;
        }
Пример #35
0
 private static void EmitSpecific(short val, IReadOnlyDictionary<short, OpCode> map, OpCode generalCode, ILGenerator body)
 {
     OpCode code;
     if (map.TryGetValue(val, out code))
     {
         body.Emit(code);
     }
     else
     {
         body.Emit(generalCode, val);
     }
 }
Пример #36
0
        internal LabelInfo(ILGen il, LabelTarget node, bool canReturn) {
            _ilg = il;
            Node = node;
            Label = il.DefineLabel();
            _canReturn = canReturn;
            if (node != null && node.Type != typeof(void)) {
                Value = il.DeclareLocal(node.Type);
            }

            // Until we have more information, default to a leave instruction, which always works
            _opCode = OpCodes.Leave;
        }
Пример #37
0
 private static System.Reflection.Emit.OpCode SwitchShortOpCodes(System.Reflection.Emit.OpCode code)
 {
     if (code == OpCodes.Bge_Un_S)
     {
         code = OpCodes.Bge_Un;
     }
     if (code == OpCodes.Bne_Un_S)
     {
         code = OpCodes.Bne_Un;
     }
     if (code == OpCodes.Ble_Un_S)
     {
         code = OpCodes.Ble_Un;
     }
     if (code == OpCodes.Ble_S)
     {
         code = OpCodes.Ble;
     }
     if (code == OpCodes.Blt_S)
     {
         code = OpCodes.Blt;
     }
     if (code == OpCodes.Blt_Un_S)
     {
         code = OpCodes.Blt_Un;
     }
     if (code == OpCodes.Beq_S)
     {
         code = OpCodes.Beq;
     }
     if (code == OpCodes.Br_S)
     {
         code = OpCodes.Br;
     }
     if (code == OpCodes.Brtrue_S)
     {
         code = OpCodes.Brtrue;
     }
     if (code == OpCodes.Brfalse_S)
     {
         code = OpCodes.Brfalse;
     }
     if (code == OpCodes.Leave_S)
     {
         code = OpCodes.Leave;
     }
     if (code == OpCodes.Bge_S)
     {
         code = OpCodes.Bge;
     }
     return(code);
 }
Пример #38
0
        private void Emit(OpCode opCode, [NotNull] MethodReference methodReference)
        {
            if (methodReference.Name == Ctor)
            {
                var constructorInfo = _methodMapper.GetConstructor(methodReference);
                _ilGenerator.Emit(opCode, constructorInfo);
                return;
            }

            var method = _methodMapper.GetMethod(methodReference);

            _ilGenerator.Emit(opCode, method);
        }
 /// <summary>
 /// Generates opcodes to call a method (that takes a StreamingContext parameter and has no return value) that has a given attribute type
 /// </summary>
 /// <remarks>
 /// Used to generate method calls for OnSerializingAttribute, OnSerializedAttribute, etc.
 /// </remarks>
 public static void CallSerializationEventMethod( ILGenerator generator, OpCode pushObjectOpCode, OpCode pushStreamingContextOpCode, Type objType, Type attributeType )
 {
     foreach ( MethodInfo method in objType.GetMethods( ) )
     {
         if ( method.GetCustomAttributes( attributeType, false ).Length > 0 )
         {
             generator.Emit( pushObjectOpCode );
             generator.Emit( pushStreamingContextOpCode );
             generator.Emit( OpCodes.Call, method );
             return;
         }
     }
 }
Пример #40
0
        private void EmitWithMethodOperand(System.Reflection.Emit.OpCode opcode, MethodBase methodBase)
        {
            MethodInfo methodInfo = methodBase as MethodInfo;

            if (methodInfo != null)
            {
                generator.Emit(opcode, methodInfo);
            }
            else
            {
                generator.Emit(opcode, (ConstructorInfo)methodBase);
            }
        }
Пример #41
0
        protected override void OnEmit(OpCode opcode, Label arg)
        {
            var value = (int)typeof(Label)
                        .GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
                        .First()
                        .GetValue(arg);

            ProcessInstruction(
                _ilProcessorField.Create(
                    opcode.ToCecil(),
                    _labelsField[value].LabeledInstruction
                    ));
        }
Пример #42
0
        static _DMDEmit()
        {
            foreach (FieldInfo field in typeof(System.Reflection.Emit.OpCodes).GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                System.Reflection.Emit.OpCode reflOpCode = (System.Reflection.Emit.OpCode)field.GetValue(null);
                _ReflOpCodes[reflOpCode.Value] = reflOpCode;
            }

            foreach (FieldInfo field in typeof(Mono.Cecil.Cil.OpCodes).GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                Mono.Cecil.Cil.OpCode cecilOpCode = (Mono.Cecil.Cil.OpCode)field.GetValue(null);
                _CecilOpCodes[cecilOpCode.Value] = cecilOpCode;
            }
        }
Пример #43
0
        internal static void _EmitCallSite(DynamicMethod dm, ILGenerator il, System.Reflection.Emit.OpCode opcode, CallSite csite) {
            /* The mess in this method is heavily based off of the code available at the following links:
             * https://github.com/Microsoft/referencesource/blob/3b1eaf5203992df69de44c783a3eda37d3d4cd10/mscorlib/system/reflection/emit/dynamicmethod.cs#L791
             * https://github.com/Microsoft/referencesource/blob/3b1eaf5203992df69de44c783a3eda37d3d4cd10/mscorlib/system/reflection/emit/dynamicilgenerator.cs#L353
             * https://github.com/mono/mono/blob/82e573122a55482bf6592f36f819597238628385/mcs/class/corlib/System.Reflection.Emit/DynamicMethod.cs#L411
             * https://github.com/mono/mono/blob/82e573122a55482bf6592f36f819597238628385/mcs/class/corlib/System.Reflection.Emit/ILGenerator.cs#L800
             * https://github.com/dotnet/coreclr/blob/0fbd855e38bc3ec269479b5f6bf561dcfd67cbb6/src/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs#L57
             */

            List<object> _tokens = null;
            int _GetTokenForType(Type v) {
                _tokens.Add(v.TypeHandle);
                return _tokens.Count - 1 | 0x02000000 /* (int) MetadataTokenType.TypeDef */;
            }
            int _GetTokenForSig(byte[] v) {
                _tokens.Add(v);
                return _tokens.Count - 1 | 0x11000000 /* (int) MetadataTokenType.Signature */;
            }
#if !NETSTANDARD
            DynamicILInfo _info = null;
            if (DynamicMethodDefinition._IsMono) {
                // GetDynamicILInfo throws "invalid signature" in .NET - let's hope for the best for mono...
                _info = dm.GetDynamicILInfo();
            } else {
#endif
                // For .NET, we need to access DynamicScope m_scope and its List<object> m_tokens
                _tokens = f_DynScope_m_tokens.GetValue(f_DynILGen_m_scope.GetValue(il)) as List<object>;
#if !NETSTANDARD
            }

            int GetTokenForType(Type v) => _info != null ? _info.GetTokenFor(v.TypeHandle) : _GetTokenForType(v);
            int GetTokenForSig(byte[] v) => _info != null ? _info.GetTokenFor(v) : _GetTokenForSig(v);

#else
            int GetTokenForType(Type v) => _GetTokenForType(v);
            int GetTokenForSig(byte[] v) => _GetTokenForSig(v);
#endif

            byte[] signature = new byte[32];
            int currSig = 0;
            int sizeLoc = -1;

            // This expects a MdSigCallingConvention
            AddData((byte) csite.CallingConvention);
            sizeLoc = currSig++;

            List<Type> modReq = new List<Type>();
            List<Type> modOpt = new List<Type>();

            ResolveWithModifiers(csite.ReturnType, out Type returnType, out Type[] returnTypeModReq, out Type[] returnTypeModOpt, modReq, modOpt);
Пример #44
0
        private void EmitZnCheck(System.Reflection.Emit.OpCode ilCmpOp, int flag)
        {
            Emit(OpCodes.Dup);
            Emit(OpCodes.Ldc_I4_0);

            if (CurrOp.RegisterSize != RegisterSize.Int32)
            {
                Emit(OpCodes.Conv_I8);
            }

            Emit(ilCmpOp);

            EmitStflg(flag);
        }
Пример #45
0
 /// <summary>
 /// 将指定的方法或构造函数的指定指令和元数据标记放到 Microsoft 中间语言 (MSIL) 指令流上。
 /// </summary>
 /// <param name="il">IL 指令生成器。</param>
 /// <param name="opCode">要发到流中的 MSIL 指令。</param>
 /// <param name="method">方法或构造函数。</param>
 /// <exception cref="ArgumentNullException"><paramref name="il"/> 为 <c>null</c>。</exception>
 /// <exception cref="ArgumentNullException"><paramref name="method"/> 为 <c>null</c>。</exception>
 public static void Emit(this ILGenerator il, OpCode opCode, MethodBase method)
 {
     CommonExceptions.CheckArgumentNull(il, "il");
     CommonExceptions.CheckArgumentNull(method, "method");
     Contract.EndContractBlock();
     if (method.MemberType == MemberTypes.Constructor)
     {
         il.Emit(opCode, (ConstructorInfo)method);
     }
     else
     {
         il.Emit(opCode, (MethodInfo)method);
     }
 }
Пример #46
0
        protected override void OnEmit(OpCode opcode, Type arg)
        {
            var           ts = _assemblyDefinitionField.MainModule.TypeSystem;
            TypeReference reference;

            if (arg == typeof(int))
            {
                reference = ts.Int32;
            }
            else
            {
                throw new NotSupportedException();
            }

            ProcessInstruction(_ilProcessorField.Create(opcode.ToCecil(), reference));
        }
Пример #47
0
        internal LoadConstantOpcode(Emit.OpCode opcode) : base(opcode)
        {
            char lastChar = opcode.Name[opcode.Name.Length - 1];

            if (lastChar >= '0' && lastChar <= '9')
            {
                constantValue = (sbyte)(lastChar - '0');
                if (opcode.Name[opcode.Name.Length - 2] == 'M')
                {
                    constantValue *= -1;
                }
            }
            else
            {
                constantValue = sbyte.MinValue;
            }
        }
Пример #48
0
 public void Emit(System.Reflection.Emit.OpCode opcode, MethodInfo meth) => generator.Emit(opcode, meth);
Пример #49
0
 public void Emit(System.Reflection.Emit.OpCode opcode, double arg) => generator.Emit(opcode, arg);
Пример #50
0
 public void Emit(System.Reflection.Emit.OpCode opcode, Label[] labels) => generator.Emit(opcode, labels);
Пример #51
0
 public void Emit(System.Reflection.Emit.OpCode opcode, FieldInfo field) => generator.Emit(opcode, field);
Пример #52
0
 public void Emit(System.Reflection.Emit.OpCode ilOp, ILLabel label)
 {
     _ilBlock.Add(new ILOpCodeBranch(ilOp, label));
 }
Пример #53
0
 public void Emit(System.Reflection.Emit.OpCode ilOp)
 {
     _ilBlock.Add(new ILOpCode(ilOp));
 }
Пример #54
0
 public static void Emit(this CecilILGenerator il, OpCode opcode, object operand)
 {
     emitCodeDelegate(il, opcode, operand);
 }
Пример #55
0
 public void Emit(System.Reflection.Emit.OpCode opcode, ConstructorInfo con) => generator.Emit(opcode, con);
Пример #56
0
 internal FieldReferenceOpcode(Emit.OpCode opcode) : base(opcode)
 {
 }
Пример #57
0
 internal BranchOpcode(Emit.OpCode opcode) : base(opcode)
 {
 }
Пример #58
0
 internal BranchOpcode(Emit.OpCode opcode, Comparison comparison)
     : base(opcode)
 {
     this.comparison = comparison;
 }
Пример #59
0
        private static void ResolveMethod(ILGenerator generator, Dictionary <MethodBuilder, MethodInfo> methods, Dictionary <ConstructorBuilder, ConstructorInfo> constructors, VRage.Compiler.IlReader.IlInstruction instruction, System.Reflection.Emit.OpCode code)
        {
            bool found  = false;
            var  method = instruction.Operand as MethodBase;

            if (instruction.Operand is MethodInfo)
            {
                var methodInfo = instruction.Operand as MethodInfo;
                foreach (var met in methods)
                {
                    if (met.Value == methodInfo)
                    {
                        generator.Emit(code, met.Key);
                        found = true;
                        break;
                    }
                }
            }
            if (instruction.Operand is ConstructorInfo)
            {
                var methodInfo = instruction.Operand as ConstructorInfo;
                foreach (var met in constructors)
                {
                    if (met.Value == methodInfo)
                    {
                        generator.Emit(code, met.Key);
                        found = true;
                        break;
                    }
                }
            }
            if (false == found)
            {
                if (method is MethodInfo)
                {
                    generator.Emit(code, method as MethodInfo);
                }
                else if (method is ConstructorInfo)
                {
                    generator.Emit(code, method as ConstructorInfo);
                }
            }
        }
Пример #60
-1
 Instruction(ILReader reader, OpCode op, Operand arg, ushort label)
 {
     this.reader = reader;
     this.OpCode = op;
     this.Operand = arg;
     this.label = (ushort)label;
 }