System.Reflection.Emit.ILGenerator.Emit(System.Reflection.Emit.OpCode)

Here are the examples of the csharp api System.Reflection.Emit.ILGenerator.Emit(System.Reflection.Emit.OpCode) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1695 Examples 7

19 Source : ILGeneratorExtensions.cs
with MIT License
from akaskela

public static void Return(this ILGenerator generator)
        {
            generator.Emit(OpCodes.Ret);
        }

19 Source : DynamicReflectionDelegateFactory.cs
with MIT License
from akaskela

internal static void GenerateCreateSetFieldIL(FieldInfo fieldInfo, ILGenerator generator)
        {
            if (!fieldInfo.IsStatic)
            {
                generator.PushInstance(fieldInfo.DeclaringType);
            }

            generator.Emit(OpCodes.Ldarg_1);
            generator.UnboxIfNeeded(fieldInfo.FieldType);

            if (!fieldInfo.IsStatic)
            {
                generator.Emit(OpCodes.Stfld, fieldInfo);
            }
            else
            {
                generator.Emit(OpCodes.Stsfld, fieldInfo);
            }

            generator.Return();
        }

19 Source : DynamicReflectionDelegateFactory.cs
with MIT License
from akaskela

internal static void GenerateCreateSetPropertyIL(PropertyInfo propertyInfo, ILGenerator generator)
        {
            MethodInfo setMethod = propertyInfo.GetSetMethod(true);
            if (!setMethod.IsStatic)
            {
                generator.PushInstance(propertyInfo.DeclaringType);
            }

            generator.Emit(OpCodes.Ldarg_1);
            generator.UnboxIfNeeded(propertyInfo.PropertyType);
            generator.CallMethod(setMethod);
            generator.Return();
        }

19 Source : ILGeneratorExtensions.cs
with MIT License
from akaskela

public static void PushInstance(this ILGenerator generator, Type type)
        {
            generator.Emit(OpCodes.Ldarg_0);
            if (type.IsValueType())
            {
                generator.Emit(OpCodes.Unbox, type);
            }
            else
            {
                generator.Emit(OpCodes.Castclreplaced, type);
            }
        }

19 Source : Util.cs
with MIT License
from albahari

public static Func<object, object> GenDynamicField (FieldInfo fld)
		{
			DynamicMethod dynMeth;
			if (fld.DeclaringType.IsInterface)
				dynMeth = new DynamicMethod ("", typeof (object), new[] { typeof (object) });
			else
				dynMeth = new DynamicMethod ("", typeof (object), new[] { typeof (object) }, fld.DeclaringType);
			ILGenerator gen = dynMeth.GetILGenerator ();
			gen.Emit (OpCodes.Ldarg_0);

			if (fld.DeclaringType.IsValueType)
			{
				gen.DeclareLocal (fld.DeclaringType);
				gen.Emit (OpCodes.Unbox_Any, fld.DeclaringType);
				gen.Emit (OpCodes.Stloc_0);
				gen.Emit (OpCodes.Ldloca_S, 0);
			}
			else
				gen.Emit (OpCodes.Castclreplaced, fld.DeclaringType);

			gen.Emit (OpCodes.Ldfld, fld);
			if (fld.FieldType.IsValueType) gen.Emit (OpCodes.Box, fld.FieldType);
			gen.Emit (OpCodes.Ret);
			return (Func<object, object>)dynMeth.CreateDelegate (typeof (Func<object, object>));
		}

19 Source : Util.cs
with MIT License
from albahari

public static Func<object, object> GenDynamicProp (PropertyInfo prop)
		{
			//return x => prop.GetValue (x);
			DynamicMethod dynMeth;
			if (prop.DeclaringType.IsInterface)
				dynMeth = new DynamicMethod ("", typeof (object), new[] { typeof (object) });
			else
				dynMeth = new DynamicMethod ("", typeof (object), new[] { typeof (object) }, prop.DeclaringType);
			ILGenerator gen = dynMeth.GetILGenerator ();
			gen.Emit (OpCodes.Ldarg_0);

			if (prop.DeclaringType.IsValueType)
			{
				gen.DeclareLocal (prop.DeclaringType);
				gen.Emit (OpCodes.Unbox_Any, prop.DeclaringType);
				gen.Emit (OpCodes.Stloc_0);
				gen.Emit (OpCodes.Ldloca_S, 0);
				gen.Emit (OpCodes.Call, prop.GetGetMethod (true));
			}
			else
			{
				gen.Emit (OpCodes.Castclreplaced, prop.DeclaringType);
				gen.Emit (OpCodes.Callvirt, prop.GetGetMethod (true));
			}
			if (prop.PropertyType.IsValueType) gen.Emit (OpCodes.Box, prop.PropertyType);
			gen.Emit (OpCodes.Ret);
			return (Func<object, object>)dynMeth.CreateDelegate (typeof (Func<object, object>));
		}

19 Source : ReflectionUtils.cs
with MIT License
from alelievr

public static Delegate CreateGenericGetterDelegate(Type childType, FieldInfo field)
		{
			//Create the delegate type that takes our node type in parameter
			var delegateType = typeof(ChildFieldGetter<>).MakeGenericType(new Type[] { childType });

			//Get the child field from base clreplaced
			FieldInfo fi = childType.GetField(field.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);

			#if NET_4_6
				ParameterExpression targetExp = Expression.Parameter(childType, "target");

				// Expression.Property can be used here as well
				MemberExpression fieldExp = Expression.Field(targetExp, fi);

				var l = Expression.Lambda(delegateType, fieldExp, targetExp).Compile();
				Debug.Log("here: " + l);
				return l;
			#else
	
				//Create a new method which return the field fi
				DynamicMethod dm = new DynamicMethod("Get" + fi.Name, typeof(object), new Type[] { childType }, childType);
				ILGenerator il = dm.GetILGenerator();
				// Load the instance of the object (argument 0) onto the stack
				il.Emit(OpCodes.Ldarg_0);
				// Load the value of the object's field (fi) onto the stack
				il.Emit(OpCodes.Ldfld, fi);
				// return the value on the top of the stack
				il.Emit(OpCodes.Ret);
	
				return dm.CreateDelegate(delegateType);
			#endif
		}

19 Source : ReflectionUtils.cs
with MIT License
from alelievr

public static Delegate CreateGenericSetterDelegate(Type childType, FieldInfo field)
		{
			//Create the delegate type that takes our node type in parameter
			var delegateType = typeof(ChildFieldSetter<,>).MakeGenericType(new Type[] { childType, field.FieldType });

			//Get the child field from base clreplaced
			FieldInfo fi = childType.GetField(field.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);

			#if NET_4_6
				ParameterExpression targetExp = Expression.Parameter(childType, "target");
				ParameterExpression valueExp = Expression.Parameter(fi.FieldType, "value");

				// Expression.Property can be used here as well
				MemberExpression fieldExp = Expression.Field(targetExp, fi);
				BinaryExpression replacedignExp = Expression.replacedign(fieldExp, valueExp);

				return Expression.Lambda(delegateType, replacedignExp, targetExp, valueExp).Compile();
			#else
				//Create a new method which return the field fi
				DynamicMethod dm = new DynamicMethod("Set" + fi.Name, typeof(object), new Type[] { childType, typeof(object) }, true);
				ILGenerator il = dm.GetILGenerator();
				// Load the instance of the object (argument 0) and the replacing value onto the stack
				il.Emit(OpCodes.Ldarg_0);
				il.Emit(OpCodes.Ldarg_1);
				if (fi.FieldType.IsValueType)
					il.Emit(OpCodes.Unbox_Any, fi.FieldType);
				// Set the value of the field to the value on top of the stack
				il.Emit(OpCodes.Stfld, fi);
				il.Emit(OpCodes.Ret);
	
				return dm.CreateDelegate(delegateType);
			#endif
		}

19 Source : Instruction.cs
with MIT License
from alexanderkyte

public override void Emit (IEnumerator<WebreplacedemblyInstruction> cursor, ILGenerator ilgen, WebreplacedemblyCodeParser top_level)
		{
			switch (Opcode) {
				case 0x0: // unreachable
					// Fixme: make this catchable / offer options at exception time
					ilgen.ThrowException (typeof (System.ExecutionEngineException));
					return;
				case 0x01: // nop
					ilgen.Emit (OpCodes.Nop);
					return;

				case 0x02: // block
					label = ilgen.DefineLabel ();
					ilgen.MarkLabel (label);
					return;

				case 0x03: // loop
					label = ilgen.DefineLabel ();
					ilgen.MarkLabel (label);
					return;

				case 0x04: // if 
					var fallthrough_label = ilgen.DefineLabel ();

					WebreplacedemblyInstruction curr = cursor.Current;
					if (curr != this)
						throw new Exception (String.Format ("Cursor has preplaceded us while we were emitting instruction"));
					if (curr != if_block)
						throw new Exception (String.Format ("if block limits not correctly parsed"));

					if (this.else_block != null) {
						Label else_label = ilgen.DefineLabel ();
						ilgen.Emit (OpCodes.Brfalse, else_label);

						Console.WriteLine ("GREP: if: {0}", this.if_block.ToString ());
						Console.WriteLine ("GREP: else: {0}", this.else_block.ToString ());
						Console.WriteLine ("GREP: fallthrough: {0}", this.fallthrough_block.ToString ());

						while (curr != this.else_block) {
							var good = cursor.MoveNext ();
							if (!good)
								throw new Exception ("if/else block limits not correctly parsed");
							curr = cursor.Current;
							curr.Emit (cursor, ilgen, top_level);
						}
						if (if_block == else_block)
							ilgen.Emit (OpCodes.Nop);

						ilgen.Emit (OpCodes.Br, fallthrough_label);


						// We emit the else block
						ilgen.MarkLabel (else_label);
						while (curr != this.fallthrough_block) {
							var good = cursor.MoveNext ();
							if (!good)
								throw new Exception ("Else/fallthrough block limits not correctly parsed");
							curr = cursor.Current;
							curr.Emit (cursor, ilgen, top_level);
						}
						if (else_block == fallthrough_block)
							ilgen.Emit (OpCodes.Nop);

						// Falls through to fallthrough by default
					} else {
						// No else block

						Console.WriteLine ("GREP: if: {0}", this.if_block.ToString ());
						Console.WriteLine ("GREP: fallthrough: {0}", this.fallthrough_block.ToString ());

						ilgen.Emit (OpCodes.Brfalse, fallthrough_label);
						if (if_block == fallthrough_block)
							ilgen.Emit (OpCodes.Nop);
						while (curr != this.fallthrough_block) {
								Console.WriteLine ("Between if and fallthrough: {0} < {1}", cursor.Current.ToString (), fallthrough_block.ToString ());
								var good = cursor.MoveNext ();
								if (!good)
									throw new Exception ("if/fallthrough block limits not correctly parsed");
								curr = cursor.Current;
								curr.Emit (cursor, ilgen, top_level);
						}
					}

					// Start fallthrough symbol, for rest of code
					ilgen.MarkLabel (fallthrough_label);
					return;

				case 0x05: // Else
					ilgen.Emit (OpCodes.Nop);
					return;

				case 0x0b: // End
					// loops fall through
					if (this.dest == null && !this.loops) {
						// ends function body, has implicit return
						ilgen.Emit (OpCodes.Ret);
					}
					//else {
						//ilgen.Emit (OpCodes.Nop);
					//}
					return;

				// Br
				case 0x0c:
					ilgen.Emit (OpCodes.Br, this.dest.GetLabel ());
					return;

				// Br_if
				case 0x0d:
					ilgen.Emit (OpCodes.Brtrue, this.dest.GetLabel ());
					return;

				// Br_table
				case 0x0e:
					Label defaultCase = ilgen.DefineLabel();
					Label endOfBlock = ilgen.DefineLabel();
					var jumpTable = new Label [this.table.Length];

					for (int i=0; i < this.table.Length; i++) {
						jumpTable [i] = ilgen.DefineLabel();
					}

					ilgen.Emit (OpCodes.Switch, jumpTable);
					ilgen.Emit (OpCodes.Br_S, defaultCase); 

					for (int i=0; i < jumpTable.Length; i++) {
						// Case incoming argument is equal to i
						ilgen.MarkLabel (jumpTable [i]);
						ilgen.Emit (OpCodes.Br_S, this.table[i].dest.GetLabel ());
					}

					ilgen.MarkLabel (defaultCase);
					ilgen.Emit(OpCodes.Br_S, jumpTable [Convert.ToInt32 (this.default_target)]);

					ilgen.MarkLabel(endOfBlock);

					return;

				case 0x0f:
					ilgen.Emit (OpCodes.Ret);
					return;

				//// Call
				case 0x10:
					//ilgen.Emit (OpCodes.Nop);
					//return;

				//case 0x11:
					//return ilgen.Emit (OpCodes.Nop);

				default:
					throw new Exception (String.Format("Should not be reached: {0:X}", Opcode));
			}
			return;
		}

19 Source : Instruction.cs
with MIT License
from alexanderkyte

void EmitGetter (ILGenerator ilgen, int num_params)
		{
			// Fixme: use packed encodings (_s) and the opcodes that mention the index

			if ((int) index < num_params) {
				Console.WriteLine ("ldarg {0}", index);
				// The +1 is because the first argument is the "this" argument
				switch (index) {
					case 0:
						ilgen.Emit (OpCodes.Ldarg_1);
						break;
					case 1:
						ilgen.Emit (OpCodes.Ldarg_2);
						break;
					case 2:
						ilgen.Emit (OpCodes.Ldarg_3);
						break;
					default:
						throw new Exception ("Should not be reached");
						break;
				}
			} else {
				//Console.WriteLine ("ldloc {0}", labelIndex);
				int labelIndex = (int) index - num_params;
				switch (labelIndex) {
					case 0:
						ilgen.Emit (OpCodes.Ldloc_0);
						break;
					case 1:
						ilgen.Emit (OpCodes.Ldloc_1);
						break;
					case 2:
						ilgen.Emit (OpCodes.Ldloc_2);
						break;
					case 3:
						ilgen.Emit (OpCodes.Ldloc_3);
						break;
					default:
						ilgen.Emit (OpCodes.Ldloc, labelIndex);
						break;
				}
			}
		}

19 Source : Instruction.cs
with MIT License
from alexanderkyte

public override void Emit (IEnumerator<WebreplacedemblyInstruction> cursor, ILGenerator ilgen, WebreplacedemblyCodeParser top_level)
		{
			String method;
			switch (Opcode) {
				case 0x28:
					method = "Load32Bitreplacedigned32";
					break;
				case 0x29:
					method = "Load64Bitreplacedigned64";
					break;
				case 0x2a:
					method = "LoadSingle";
					break;
				case 0x2b:
					method = "LoadDouble";
					break;
				case 0x2c:
					method = "LoadSigned8Bitreplacedigned32";
					break;
				case 0x2d:
					method = "LoadUnsigned8Bitreplacedigned32";
					break;
				case 0x2e:
					method = "LoadSigned16Bitreplacedigned32";
					break;
				case 0x2f:
					method = "LoadUnsigned16Bitreplacedigned32";
					break;
				case 0x30:
					method = "LoadSigned8Bitreplacedigned64";
					break;
				case 0x31:
					method = "LoadUnsigned8Bitreplacedigned64";
					break;
				case 0x32:
					method = "LoadSigned16Bitreplacedigned64";
					break;
				case 0x33:
					method = "LoadUnsigned16Bitreplacedigned64";
					break;
				case 0x34:
					method = "LoadSigned32Bitreplacedigned64";
					break;
				case 0x35:
					method = "LoadUnsigned32Bitreplacedigned64";
					break;

				case 0x36:
					method = "Store32BitFrom32";
					break;
				case 0x37:
					method = "Store64BitFrom32";
					break;
				case 0x38:
					method = "StoreSingle";
					break;
				case 0x39:
					method = "StoreDouble";
					break;

				case 0x3a:
					method = "Store8BitFrom32";
					break;
				case 0x3b:
					method = "Store16BitFrom32";
					break;
				case 0x3c:
					method = "Store8BitFrom64";
					break;
				case 0x3d:
					method = "Store16BitFrom64";
					break;
				case 0x3e:
					method = "Store32BitFrom64";
					break;

				case 0x3f:
					method = "CurrentMemory";
					break;
				case 0x40:
					method = "GrowMemory";
					break;
				default:
					throw new Exception (String.Format("Should not be reached: {0:X}", Opcode));
			}

			// Our opcode has an offset to apply to this address on top of the stack
			// FIXME: we ignore alignment
			ilgen.Emit (OpCodes.Ldc_I4, Convert.ToInt32 (offset));
			ilgen.Emit (OpCodes.Add);

			// Now we want to set ourselves up for a call
			var method_info = typeof (WebreplacedemblyModule).GetMethod (method, BindingFlags.Instance | BindingFlags.NonPublic);
			if (method_info == null)
				throw new Exception (String.Format("Could not find {0} in runtime", method));
			var call_types = new List<Type> ();

			foreach (var param_info in method_info.GetParameters ())
				call_types.Add (param_info.ParameterType);

			ShiftThisArgToFront (ilgen, call_types.ToArray ());
			ilgen.Emit(OpCodes.Call, method_info);

			return;
		}

19 Source : Instruction.cs
with MIT License
from alexanderkyte

public override void Emit (IEnumerator<WebreplacedemblyInstruction> cursor, ILGenerator ilgen, WebreplacedemblyCodeParser top_level)
		{
			switch (Opcode) {
				case 0x41:
					switch (operand_i32) {
						case 0:
							ilgen.Emit (OpCodes.Ldc_I4_0);
							break;
						case 1:
							ilgen.Emit (OpCodes.Ldc_I4_1);
							break;
						case 2:
							ilgen.Emit (OpCodes.Ldc_I4_2);
							break;
						case 3:
							ilgen.Emit (OpCodes.Ldc_I4_3);
							break;
						case 4:
							ilgen.Emit (OpCodes.Ldc_I4_4);
							break;
						case 5:
							ilgen.Emit (OpCodes.Ldc_I4_5);
							break;
						case 6:
							ilgen.Emit (OpCodes.Ldc_I4_6);
							break;
						case 7:
							ilgen.Emit (OpCodes.Ldc_I4_7);
							break;
						case 8:
							ilgen.Emit (OpCodes.Ldc_I4_8);
							break;
						default:
							ilgen.Emit (OpCodes.Ldc_I4, operand_i32);
							break;
					}
					return;
				case 0x42:
					ilgen.Emit (OpCodes.Ldc_I8, operand_i64);
					return;
				case 0x43:
					ilgen.Emit (OpCodes.Ldc_R4, operand_f32);
					return;
				case 0x44:
					ilgen.Emit (OpCodes.Ldc_R8, operand_f64);
					return;

				case 0x45:
					ilgen.Emit (OpCodes.Ldc_I4_0);
					ilgen.Emit (OpCodes.Ceq);
					return;
				case 0x46:
					ilgen.Emit (OpCodes.Ceq);
					return;
				case 0x47:
					ilgen.Emit (OpCodes.Ceq);
					ilgen.Emit (OpCodes.Neg);
					return;

				case 0x48:
					ilgen.Emit (OpCodes.Clt);
					return;

				case 0x49:
					ilgen.Emit (OpCodes.Clt_Un);
					return;

				case 0x4a:
					ilgen.Emit (OpCodes.Cgt);
					return;

				case 0x4b:
					ilgen.Emit (OpCodes.Cgt_Un);
					return;

				//case 0x4c: 
					//// Less than or equal, signed
					//// first - last > 0
					//// sub.ovf.un
					//return "i32.le_s";

				//case 0x4d:
					//// Less than or equal, unsigned
					//// first - last > 0
					//// sub.ovf.un
					//return "i32.le_u";

				//case 0x4e:
					//return "i32.ge_s";

				//case 0x4f:
					//return "i32.ge_u";

				//case 0x50:
					//return "i64.eqz";
				//case 0x51:
					//return "i64.eq";
				//case 0x52:
					//return "i64.ne";
				//case 0x53:
					//return "i64.lt_s";
				//case 0x54:
					//return "i64.lt_u";
				case 0x55: // i64.gt_s
					ilgen.Emit (OpCodes.Cgt);
					return;

				//case 0x56:
					//return "i64.gt_u";
				//case 0x57:
					//return "i64.le_s";
				//case 0x58:
					//return "i64.le_u";
				//case 0x59:
					//return "i64.ge_s";
				//case 0x5a:
					//return "i64.ge_u";

				//case 0x5b:
					//return "f32.eq";
				//case 0x5c:
					//return "f32.ne";
				//case 0x5d:
					//return "f32.lt";
				case 0x5e:
					ilgen.Emit (OpCodes.Cgt);
					return;
				//case 0x5f:
					//return "f32.le";
				//case 0x60:
					//return "f32.ge";
				//case 0x61:
					//return "f64.eq";
				//case 0x62:
					//return "f64.ne";
				//case 0x63:
					//return "f64.lt";
				//case 0x64:
					//return "f64.gt";
				//case 0x65:
					//return "f64.le";
				//case 0x66:
					//return "f64.ge";
				//case 0x67:
					//return "i32.clz";
				case 0x68:
					// We will use Reiser's CTZ implementation here.
					//int lookup_table = new int [] { -1, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18 };
					//return (-n & n) % 37
					//return "i32.ctz";
					
					// It's int->int so NOP is an okay mock
					ilgen.Emit (OpCodes.Nop);
					return;

				//case 0x69:
					//return "i32.popcnt";
				case 0x6a:
					ilgen.Emit (OpCodes.Add);
					return;
				case 0x6b:
					ilgen.Emit (OpCodes.Sub);
					return;
				case 0x6c:
					ilgen.Emit (OpCodes.Mul);
					return;
				//case 0x6d:
					//return "i32.div_s";
				//case 0x6e:
					//return "i32.div_u";
				//case 0x6f:
					//return "i32.rem_s";
				//case 0x70:
					//return "i32.rem_u";

				//case 0x71:
					//return "i32.and";
				//case 0x72:
					//return "i32.or";
				//case 0x73:
					//return "i32.xor";
				//case 0x74:
					//return "i32.shl";
				//case 0x75:
					//return "i32.shr_s";
				//case 0x76:
					//return "i32.shr_u";
				//case 0x77:
					//return "i32.rotl";
				//case 0x78:
					//return "i32.rotr";
				//case 0x79:
					//return "i64.clz";
				//case 0x7a:
					//return "i64.ctz";
				//case 0x7b:
					//return "i64.popcnt";
				case 0x7c:
					ilgen.Emit (OpCodes.Add);
					return;
				case 0x7d:
					ilgen.Emit (OpCodes.Sub);
					return;
				case 0x7e:
					ilgen.Emit (OpCodes.Mul);
					return;
				//case 0x7f:
					//return "i64.div_s";
				//case 0x80:
					//return "i64.div_u";
				//case 0x81:
					//return "i64.rem_s";
				//case 0x82:
					//return "i64.rem_u";
				//case 0x83:
					//return "i64.and";
				//case 0x84:
					//return "i64.or";
				//case 0x85:
					//return "i64.xor";
				//case 0x86:
					//return "i64.shl";
				//case 0x87:
					//return "i64.shr_s";
				//case 0x88:
					//return "i64.shr_u";
				//case 0x89:
					//return "i64.rotl";
				//case 0x8a:
					//return "i64.rotr";
				//case 0x8b:
					//return "f32.abs";
				//case 0x8c:
					//return "f32.neg";
				//case 0x8d:
					//return "f32.ceil";
				//case 0x8e:
					//return "f32.floor";
				//case 0x8f:
					//return "f32.trunc";
				//case 0x90:
					//return "f32.nearest";
				//case 0x91:
					//return "f32.sqrt";
				//case 0x92:
					//return "f32.add";
				//case 0x93:
					//return "f32.sub";
				//case 0x94:
					//return "f32.mul";
				//case 0x95:
					//return "f32.div";
				//case 0x96:
					//return "f32.min";
				//case 0x97:
					//return "f32.max";
				//case 0x98:
					//return "f32.copysign";
				//case 0x99:
					//return "f64.abs";
				//case 0x9a:
					//return "f64.neg";
				//case 0x9b:
					//return "f64.ceil";
				//case 0x9c:
					//return "f64.floor";
				//case 0x9d:
					//return "f64.trunc";
				//case 0x9e:
					//return "f64.nearest";
				//case 0x9f:
					//return "f64.sqrt";
				//case 0xa0:
					//return "f64.add";
				//case 0xa1:
					//return "f64.sub";
				//case 0xa2:
					//return "f64.mul";
				//case 0xa3:
					//return "f64.div";
				//case 0xa4:
					//return "f64.min";
				//case 0xa5:
					//return "f64.max";
				//case 0xa6:
					//return "f64.copysign";
				//case 0xa7:
					//return "i32.wrap/i64";
				//case 0xa8:
					//return "i32.trunc_s/f32";
				//case 0xa9:
					//return "i32.trunc_u/f32";
				//case 0xaa:
					//return "i32.trunc_s/f64";
				//case 0xab:
					//return "i32.trunc_u/f64";

				case 0xac:
					ilgen.Emit (OpCodes.Conv_Ovf_I8);
					return;

				//case 0xad:
					//return "i64.extend_u/i32";
				//case 0xae:
					//return "i64.trunc_s/f32";
				//case 0xaf:
					//return "i64.trunc_u/f32";
				//case 0xb0:
					//return "i64.trunc_s/f64";
				//case 0xb1:
					//return "i64.trunc_u/f64";
				//case 0xb2:
					//return "f32.convert_s/i32";
				//case 0xb3:
					//return "f32.convert_u/i32";
				//case 0xb4:
					//return "f32.convert_s/i64";
				//case 0xb5:
					//return "f32.convert_u/i64";
				//case 0xb6:
					//return "f32.demote/f64";
				//case 0xb7:
					//return "f64.convert_s/i32";
				//case 0xb8:
					//return "f64.convert_u/i32";
				case 0xb9:
					ilgen.Emit (OpCodes.Conv_R8);
					return;

				//case 0xba:
					//return "f64.convert_u/i64";
				//case 0xbb:
					//return "f64.promote/f32";
				//case 0xbc:
					//return "i32.reinterpret/f32";
				//case 0xbd:
					//return "i64.reinterpret/f64";
				//case 0xbe:
					//return "f32.reinterpret/i32";
				//case 0xbf:
					//return "f64.reinterpret/i64";
				default:
					throw new Exception (String.Format("Should not be reached: {0:X}", Opcode));
			}
		}

19 Source : Parser.cs
with MIT License
from alexanderkyte

public Type
		Emit (string outputName, string outputFilePath)
		{
			// Make sure we are finished parsing.
			Task.WaitAll (work);

			replacedemblyName aName = new replacedemblyName (String.Format ("{0}Proxy", outputName));
			replacedemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicreplacedembly (aName, replacedemblyBuilderAccess.RunAndSave);

			// FIXME: always want to provide debug info or not?
			ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, outputFilePath);

			TypeBuilder tb = mb.DefineType (outputName, TypeAttributes.Public, typeof (WebreplacedemblyModule));

			var constructor = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, new Type []{});
			var ctor_gen = constructor.GetILGenerator();

			// the constructor gets the "this" pointer
			ctor_gen.Emit(OpCodes.Ldarg_0);

			// Next arg is the size
			if (mem != null)
				ctor_gen.Emit(OpCodes.Ldc_I4, mem.limit.min);
			else
				ctor_gen.Emit(OpCodes.Ldc_I4_0);

			ctor_gen.Emit(OpCodes.Call, typeof (WebreplacedemblyModule).GetConstructor (new Type[] { typeof (int) }));
			ctor_gen.Emit(OpCodes.Ret);

			// Compute exports
			var export_table = new Dictionary<int, string> ();
			if (exports != null) {
				foreach (var exp in exports) {
					if (exp.kind == 0x0) // function export
						export_table [Convert.ToInt32 (exp.index)] = exp.name;
				}
			}

			// fixme: imports / exports?
			for (int i=0; i < exprs.Length; i++) {
				var fn = exprs [i];
				var type = types [fn_to_type [i]];
				string fn_name;
				if (export_table.ContainsKey (i))
					fn_name = export_table [i];
				else
					fn_name = String.Format ("Function{0}", i);
				var emitted = fn.Emit (type, tb, fn_name);
			}

			var goal = tb.CreateType ();

			if (outputFilePath != null)
				ab.Save (outputFilePath);

			return goal;
		}

19 Source : Instruction.cs
with MIT License
from alexanderkyte

protected void ShiftThisArgToFront (ILGenerator ilgen, Type [] args)
		{
			// Right now, we have arguments on the top of the stack.
			// We need to shift them back to preplaced the "this" argument first
			// We are going to make a scope, to give the JIT maximum visibility
			// into the lifetime of the temporaries needed to make this call.
			ilgen.BeginScope ();
			var locals = new List<LocalBuilder> ();

			// Traverse backwards, as last arg is the one that is pushed onto stack
			for (int i=args.Length - 1; i >= 0; i--) {
				Type ty = args [i];
				LocalBuilder myLocalBuilder = ilgen.DeclareLocal(ty);

				// Add backwards
				locals.Add (myLocalBuilder);
				ilgen.Emit (OpCodes.Stloc, myLocalBuilder);
			}

			// Emit load of "this" arg
			ilgen.Emit (OpCodes.Ldarg_0);

			// Since we added  the locals backwards, we traverse
			// "backwards" again, to restore the stack with "this" before all
			// the args
			for (int i=args.Length - 1; i >= 0; i--) {
				ilgen.Emit (OpCodes.Ldloc, locals [i]);
			}

			ilgen.EndScope ();
		}

19 Source : PayloadExtensions.cs
with Apache License 2.0
from alexz76

private static void CreateProperty(TypeBuilder typeBuilder, string propertyName, Type propertyType)
		{
			FieldBuilder fieldBuilder = typeBuilder.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);

			PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
			MethodBuilder getPropMthdBldr = typeBuilder.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
			ILGenerator getIl = getPropMthdBldr.GetILGenerator();

			getIl.Emit(OpCodes.Ldarg_0);
			getIl.Emit(OpCodes.Ldfld, fieldBuilder);
			getIl.Emit(OpCodes.Ret);

			MethodBuilder setPropMthdBldr =
				typeBuilder.DefineMethod("set_" + propertyName,
				  MethodAttributes.Public |
				  MethodAttributes.SpecialName |
				  MethodAttributes.HideBySig,
				  null, new[] { propertyType });

			ILGenerator setIl = setPropMthdBldr.GetILGenerator();
			Label modifyProperty = setIl.DefineLabel();
			Label exitSet = setIl.DefineLabel();

			setIl.MarkLabel(modifyProperty);
			setIl.Emit(OpCodes.Ldarg_0);
			setIl.Emit(OpCodes.Ldarg_1);
			setIl.Emit(OpCodes.Stfld, fieldBuilder);

			setIl.Emit(OpCodes.Nop);
			setIl.MarkLabel(exitSet);
			setIl.Emit(OpCodes.Ret);

			propertyBuilder.SetGetMethod(getPropMthdBldr);
			propertyBuilder.SetSetMethod(setPropMthdBldr);
		}

19 Source : GridifyTypeBuilder.cs
with MIT License
from alirezanet

private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType)
      {
         FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);

         PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
         MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName,
            MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
         ILGenerator getIl = getPropMthdBldr.GetILGenerator();

         getIl.Emit(OpCodes.Ldarg_0);
         getIl.Emit(OpCodes.Ldfld, fieldBuilder);
         getIl.Emit(OpCodes.Ret);

         MethodBuilder setPropMthdBldr =
            tb.DefineMethod("set_" + propertyName,
               MethodAttributes.Public |
               MethodAttributes.SpecialName |
               MethodAttributes.HideBySig,
               null, new[] { propertyType });

         ILGenerator setIl = setPropMthdBldr.GetILGenerator();
         var modifyProperty = setIl.DefineLabel();
         var exitSet = setIl.DefineLabel();

         setIl.MarkLabel(modifyProperty);
         setIl.Emit(OpCodes.Ldarg_0);
         setIl.Emit(OpCodes.Ldarg_1);
         setIl.Emit(OpCodes.Stfld, fieldBuilder);

         setIl.Emit(OpCodes.Nop);
         setIl.MarkLabel(exitSet);
         setIl.Emit(OpCodes.Ret);

         propertyBuilder.SetGetMethod(getPropMthdBldr);
         propertyBuilder.SetSetMethod(setPropMthdBldr);
      }

19 Source : ILGeneratorExtensions.cs
with Apache License 2.0
from allenai

public static void EmitRet(this ILGenerator il)
        {
            il.Emit(OpCodes.Ret);
        }

19 Source : ILGeneratorExtensions.cs
with Apache License 2.0
from allenai

public static void EmitIntZeroReturn(this ILGenerator il)
        {
            il.EmitLdc_I4(0);
            il.Emit(OpCodes.Ret);
        }

19 Source : ILGeneratorExtensions.cs
with Apache License 2.0
from allenai

public static void EmitThrowNotimplemented(this ILGenerator il)
        {
            il.Emit(OpCodes.Newobj, typeof(System.NotImplementedException).GetTypeInfo().DeclaredConstructors.First(x => x.GetParameters().Length == 0));
            il.Emit(OpCodes.Throw);
        }

19 Source : DynamicEnumResolver.cs
with Apache License 2.0
from allenai

private static TypeInfo BuildType(Type enumType)
        {
            Type underlyingType = Enum.GetUnderlyingType(enumType);
            Type formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(enumType);

            using (MonoProtection.EnterRefEmitLock())
            {
                TypeBuilder typeBuilder = Dynamicreplacedembly.Value.DefineType("MessagePack.Formatters." + enumType.FullName.Replace(".", "_") + "Formatter" + Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType });

                // void Serialize(ref MessagePackWriter writer, T value, MessagePackSerializerOptions options);
                {
                    MethodBuilder method = typeBuilder.DefineMethod(
                        "Serialize",
                        MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual,
                        null,
                        new Type[] { typeof(MessagePackWriter).MakeByRefType(), enumType, typeof(MessagePackSerializerOptions) });

                    ILGenerator il = method.GetILGenerator();
                    il.Emit(OpCodes.Ldarg_1);
                    il.Emit(OpCodes.Ldarg_2);
                    il.Emit(OpCodes.Call, typeof(MessagePackWriter).GetRuntimeMethod(nameof(MessagePackWriter.Write), new[] { underlyingType }));
                    il.Emit(OpCodes.Ret);
                }

                // T Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options);
                {
                    MethodBuilder method = typeBuilder.DefineMethod(
                        "Deserialize",
                        MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual,
                        enumType,
                        new Type[] { typeof(MessagePackReader).MakeByRefType(), typeof(MessagePackSerializerOptions) });

                    ILGenerator il = method.GetILGenerator();
                    il.Emit(OpCodes.Ldarg_1);
                    il.Emit(OpCodes.Call, typeof(MessagePackReader).GetRuntimeMethod("Read" + underlyingType.Name, Type.EmptyTypes));
                    il.Emit(OpCodes.Ret);
                }

                return typeBuilder.CreateTypeInfo();
            }
        }

19 Source : DynamicUnionResolver.cs
with Apache License 2.0
from allenai

private static void BuildConstructor(Type type, UnionAttribute[] infos, ConstructorInfo method, FieldBuilder typeToKeyAndJumpMap, FieldBuilder keyToJumpMap, ILGenerator il)
        {
            il.EmitLdarg(0);
            il.Emit(OpCodes.Call, objectCtor);

            {
                il.EmitLdarg(0);
                il.EmitLdc_I4(infos.Length);
                il.Emit(OpCodes.Ldsfld, runtimeTypeHandleEqualityComparer);
                il.Emit(OpCodes.Newobj, typeMapDictionaryConstructor);

                var index = 0;
                foreach (UnionAttribute item in infos)
                {
                    il.Emit(OpCodes.Dup);
                    il.Emit(OpCodes.Ldtoken, item.SubType);
                    il.EmitLdc_I4(item.Key);
                    il.EmitLdc_I4(index);
                    il.Emit(OpCodes.Newobj, intIntKeyValuePairConstructor);
                    il.EmitCall(typeMapDictionaryAdd);

                    index++;
                }

                il.Emit(OpCodes.Stfld, typeToKeyAndJumpMap);
            }

            {
                il.EmitLdarg(0);
                il.EmitLdc_I4(infos.Length);
                il.Emit(OpCodes.Newobj, keyMapDictionaryConstructor);

                var index = 0;
                foreach (UnionAttribute item in infos)
                {
                    il.Emit(OpCodes.Dup);
                    il.EmitLdc_I4(item.Key);
                    il.EmitLdc_I4(index);
                    il.EmitCall(keyMapDictionaryAdd);

                    index++;
                }

                il.Emit(OpCodes.Stfld, keyToJumpMap);
            }

            il.Emit(OpCodes.Ret);
        }

19 Source : DynamicUnionResolver.cs
with Apache License 2.0
from allenai

private static void BuildSerialize(Type type, UnionAttribute[] infos, MethodBuilder method, FieldBuilder typeToKeyAndJumpMap, ILGenerator il)
        {
            // if(value == null) return WriteNil
            Label elseBody = il.DefineLabel();
            Label notFoundType = il.DefineLabel();

            il.EmitLdarg(2);
            il.Emit(OpCodes.Brtrue_S, elseBody);
            il.Emit(OpCodes.Br, notFoundType);
            il.MarkLabel(elseBody);

            // IFormatterResolver resolver = options.Resolver;
            LocalBuilder localResolver = il.DeclareLocal(typeof(IFormatterResolver));
            il.EmitLdarg(3);
            il.EmitCall(getResolverFromOptions);
            il.EmitStloc(localResolver);

            LocalBuilder keyPair = il.DeclareLocal(typeof(KeyValuePair<int, int>));

            il.EmitLoadThis();
            il.EmitLdfld(typeToKeyAndJumpMap);
            il.EmitLdarg(2);
            il.EmitCall(objectGetType);
            il.EmitCall(getTypeHandle);
            il.EmitLdloca(keyPair);
            il.EmitCall(typeMapDictionaryTryGetValue);
            il.Emit(OpCodes.Brfalse, notFoundType);

            // writer.WriteArrayHeader(2, false);
            il.EmitLdarg(1);
            il.EmitLdc_I4(2);
            il.EmitCall(MessagePackWriterTypeInfo.WriteArrayHeader);

            // writer.Write(keyPair.Key)
            il.EmitLdarg(1);
            il.EmitLdloca(keyPair);
            il.EmitCall(intIntKeyValuePairGetKey);
            il.EmitCall(MessagePackWriterTypeInfo.WriteInt32);

            Label loopEnd = il.DefineLabel();

            // switch-case (offset += resolver.GetFormatter.Serialize(with cast)
            var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Attr = x }).ToArray();
            il.EmitLdloca(keyPair);
            il.EmitCall(intIntKeyValuePairGetValue);
            il.Emit(OpCodes.Switch, switchLabels.Select(x => x.Label).ToArray());
            il.Emit(OpCodes.Br, loopEnd); // default

            foreach (var item in switchLabels)
            {
                il.MarkLabel(item.Label);
                il.EmitLdloc(localResolver);
                il.Emit(OpCodes.Call, getFormatterWithVerify.MakeGenericMethod(item.Attr.SubType));

                il.EmitLdarg(1);
                il.EmitLdarg(2);
                if (item.Attr.SubType.GetTypeInfo().IsValueType)
                {
                    il.Emit(OpCodes.Unbox_Any, item.Attr.SubType);
                }
                else
                {
                    il.Emit(OpCodes.Castclreplaced, item.Attr.SubType);
                }

                il.EmitLdarg(3);
                il.Emit(OpCodes.Callvirt, getSerialize(item.Attr.SubType));

                il.Emit(OpCodes.Br, loopEnd);
            }

            // return;
            il.MarkLabel(loopEnd);
            il.Emit(OpCodes.Ret);

            // else, return WriteNil
            il.MarkLabel(notFoundType);
            il.EmitLdarg(1);
            il.EmitCall(MessagePackWriterTypeInfo.WriteNil);
            il.Emit(OpCodes.Ret);
        }

19 Source : DynamicUnionResolver.cs
with Apache License 2.0
from allenai

private static void BuildDeserialize(Type type, UnionAttribute[] infos, MethodBuilder method, FieldBuilder keyToJumpMap, ILGenerator il)
        {
            // if(MessagePackBinary.TryReadNil()) { return null; }
            Label falseLabel = il.DefineLabel();
            il.EmitLdarg(1);
            il.EmitCall(MessagePackReaderTypeInfo.TryReadNil);
            il.Emit(OpCodes.Brfalse_S, falseLabel);

            il.Emit(OpCodes.Ldnull);
            il.Emit(OpCodes.Ret);

            il.MarkLabel(falseLabel);

            // IFormatterResolver resolver = options.Resolver;
            LocalBuilder localResolver = il.DeclareLocal(typeof(IFormatterResolver));
            il.EmitLdarg(2);
            il.EmitCall(getResolverFromOptions);
            il.EmitStloc(localResolver);

            // read-array header and validate, reader.ReadArrayHeader() != 2) throw;
            Label rightLabel = il.DefineLabel();
            var reader = new ArgumentField(il, 1);
            reader.EmitLdarg();
            il.EmitCall(MessagePackReaderTypeInfo.ReadArrayHeader);
            il.EmitLdc_I4(2);
            il.Emit(OpCodes.Beq_S, rightLabel);
            il.Emit(OpCodes.Ldstr, "Invalid Union data was detected. Type:" + type.FullName);
            il.Emit(OpCodes.Newobj, invalidOperationExceptionConstructor);
            il.Emit(OpCodes.Throw);

            il.MarkLabel(rightLabel);

            // read key
            LocalBuilder key = il.DeclareLocal(typeof(int));
            reader.EmitLdarg();
            il.EmitCall(MessagePackReaderTypeInfo.ReadInt32);
            il.EmitStloc(key);

            // is-sequential don't need else convert key to jump-table value
            if (!IsZeroStartSequential(infos))
            {
                Label endKeyMapGet = il.DefineLabel();
                il.EmitLdarg(0);
                il.EmitLdfld(keyToJumpMap);
                il.EmitLdloc(key);
                il.EmitLdloca(key);
                il.EmitCall(keyMapDictionaryTryGetValue);
                il.Emit(OpCodes.Brtrue_S, endKeyMapGet);
                il.EmitLdc_I4(-1);
                il.EmitStloc(key);

                il.MarkLabel(endKeyMapGet);
            }

            // switch->read
            LocalBuilder result = il.DeclareLocal(type);
            Label loopEnd = il.DefineLabel();
            il.Emit(OpCodes.Ldnull);
            il.EmitStloc(result);
            il.Emit(OpCodes.Ldloc, key);

            var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Attr = x }).ToArray();
            il.Emit(OpCodes.Switch, switchLabels.Select(x => x.Label).ToArray());

            // default
            reader.EmitLdarg();
            il.EmitCall(MessagePackReaderTypeInfo.Skip);
            il.Emit(OpCodes.Br, loopEnd);

            foreach (var item in switchLabels)
            {
                il.MarkLabel(item.Label);
                il.EmitLdloc(localResolver);
                il.EmitCall(getFormatterWithVerify.MakeGenericMethod(item.Attr.SubType));
                il.EmitLdarg(1);
                il.EmitLdarg(2);
                il.EmitCall(getDeserialize(item.Attr.SubType));
                if (item.Attr.SubType.GetTypeInfo().IsValueType)
                {
                    il.Emit(OpCodes.Box, item.Attr.SubType);
                }

                il.Emit(OpCodes.Stloc, result);
                il.Emit(OpCodes.Br, loopEnd);
            }

            il.MarkLabel(loopEnd);

            il.Emit(OpCodes.Ldloc, result);
            il.Emit(OpCodes.Ret);
        }

19 Source : ILGeneratorExtensions.cs
with Apache License 2.0
from allenai

public static void EmitNullReturn(this ILGenerator il)
        {
            il.Emit(OpCodes.Ldnull);
            il.Emit(OpCodes.Ret);
        }

19 Source : ILGeneratorExtensions.cs
with Apache License 2.0
from allenai

public static void EmitIncrementFor(this ILGenerator il, LocalBuilder conditionGreater, Action<LocalBuilder> emitBody)
        {
            Label loopBegin = il.DefineLabel();
            Label condtionLabel = il.DefineLabel();

            // var i = 0
            LocalBuilder forI = il.DeclareLocal(typeof(int));
            il.EmitLdc_I4(0);
            il.EmitStloc(forI);
            il.Emit(OpCodes.Br, condtionLabel);

            il.MarkLabel(loopBegin);
            emitBody(forI);

            // i++
            il.EmitLdloc(forI);
            il.EmitLdc_I4(1);
            il.Emit(OpCodes.Add);
            il.EmitStloc(forI);

            //// i < ***
            il.MarkLabel(condtionLabel);
            il.EmitLdloc(forI);
            il.EmitLdloc(conditionGreater);
            il.Emit(OpCodes.Blt, loopBegin);
        }

19 Source : ILGeneratorExtensions.cs
with Apache License 2.0
from allenai

public static void EmitPop(this ILGenerator il, int count)
        {
            for (int i = 0; i < count; i++)
            {
                il.Emit(OpCodes.Pop);
            }
        }

19 Source : EmitMemberAccessor.cs
with MIT License
from AllocZero

private static DynamicMethod CreatePropertyGetter(PropertyInfo propertyInfo, Type runtimePropertyType)
        {
            MethodInfo? realMethod = propertyInfo.GetMethod;
            Debug.replacedert(realMethod != null);

            Type? declaringType = propertyInfo.DeclaringType;
            Debug.replacedert(declaringType != null);

            Type declaredPropertyType = propertyInfo.PropertyType;

            DynamicMethod dynamicMethod = CreateGetterMethod(propertyInfo.Name, runtimePropertyType);
            ILGenerator generator = dynamicMethod.GetILGenerator();

            generator.Emit(OpCodes.Ldarg_0);

            if (declaringType.IsValueType)
            {
                generator.Emit(OpCodes.Unbox, declaringType);
                generator.Emit(OpCodes.Call, realMethod);
            }
            else
            {
                generator.Emit(OpCodes.Castclreplaced, declaringType);
                generator.Emit(OpCodes.Callvirt, realMethod);
            }

            // declaredPropertyType: Type of the property
            // runtimePropertyType:  <T> of JsonConverter / JsonPropertyInfo

            if (declaredPropertyType != runtimePropertyType && declaredPropertyType.IsValueType)
            {
                generator.Emit(OpCodes.Box, declaredPropertyType);
            }

            generator.Emit(OpCodes.Ret);

            return dynamicMethod;
        }

19 Source : EmitMemberAccessor.cs
with MIT License
from AllocZero

private static DynamicMethod CreatePropertySetter(PropertyInfo propertyInfo, Type runtimePropertyType)
        {
            MethodInfo? realMethod = propertyInfo.SetMethod;
            Debug.replacedert(realMethod != null);

            Type? declaringType = propertyInfo.DeclaringType;
            Debug.replacedert(declaringType != null);

            Type declaredPropertyType = propertyInfo.PropertyType;

            DynamicMethod dynamicMethod = CreateSetterMethod(propertyInfo.Name, runtimePropertyType);
            ILGenerator generator = dynamicMethod.GetILGenerator();

            generator.Emit(OpCodes.Ldarg_0);
            generator.Emit(declaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclreplaced, declaringType);
            generator.Emit(OpCodes.Ldarg_1);

            // declaredPropertyType: Type of the property
            // runtimePropertyType:  <T> of JsonConverter / JsonPropertyInfo

            if (declaredPropertyType != runtimePropertyType && declaredPropertyType.IsValueType)
            {
                generator.Emit(OpCodes.Unbox_Any, declaredPropertyType);
            }

            generator.Emit(declaringType.IsValueType ? OpCodes.Call : OpCodes.Callvirt, realMethod);
            generator.Emit(OpCodes.Ret);

            return dynamicMethod;
        }

19 Source : EmitMemberAccessor.cs
with MIT License
from AllocZero

public static Func<object>? CreateConstructor(Type type)
        {
            Debug.replacedert(type != null);
            ConstructorInfo? realMethod = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, binder: null, Type.EmptyTypes, modifiers: null);

            if (type.IsAbstract)
            {
                return null;
            }

            if (realMethod == null && !type.IsValueType)
            {
                return null;
            }

            var dynamicMethod = new DynamicMethod(
                ConstructorInfo.ConstructorName,
                ObjectType,
                Type.EmptyTypes,
                typeof(EmitMemberAccessor).Module,
                skipVisibility: true);

            ILGenerator generator = dynamicMethod.GetILGenerator();

            if (realMethod == null)
            {
                LocalBuilder local = generator.DeclareLocal(type);

                generator.Emit(OpCodes.Ldloca_S, local);
                generator.Emit(OpCodes.Initobj, type);
                generator.Emit(OpCodes.Ldloc, local);
                generator.Emit(OpCodes.Box, type);
            }
            else
            {
                generator.Emit(OpCodes.Newobj, realMethod);
            }

            generator.Emit(OpCodes.Ret);

            return (Func<object>?)dynamicMethod.CreateDelegate(typeof(Func<object>));
        }

19 Source : ILExtensions.cs
with MIT License
from aloneguid

public static void GetArrayLength(this ILGenerator il, LocalBuilder array, LocalBuilder lengthReceiver)
      {
         il.Emit(Ldloc, array.LocalIndex);
         il.Emit(Ldlen);
         il.Emit(Conv_I4);
         il.StLoc(lengthReceiver);
      }

19 Source : MSILGenerator.cs
with MIT License
from aloneguid

private void GenerateCollector(ILGenerator il, Type clreplacedType,
         DataField f,
         MethodInfo getValueMethod,
         MethodInfo addToListMethod,
         MethodInfo addRepLevelMethod,
         TypeConversion conversion)
      {
         //arg 0 - collection of clreplacedes, clr objects
         //arg 1 - data items (typed list)
         //arg 2 - repereplacedions (optional)
         //arg 3 - max repereplacedion level

         //make collection a local variable
         LocalBuilder collection = il.DeclareLocal(clreplacedType);
         il.Emit(Ldarg_0);
         il.Emit(Stloc, collection.LocalIndex);

         using (il.ForEachLoop(clreplacedType, collection, out LocalBuilder currentElement))
         {
            if (f.IsArray)
            {
               //reset repereplacedion level to 0
               LocalBuilder rl = il.DeclareLocal(typeof(int));
               il.Emit(Ldc_I4_0);
               il.StLoc(rl);

               //currentElement is a nested array in this case
               LocalBuilder array = il.DeclareLocal(typeof(object));

               //get array and put into arrayElement
               il.Emit(Ldloc, currentElement.LocalIndex);
               il.Emit(Callvirt, getValueMethod);
               il.Emit(Stloc, array.LocalIndex);

               //enumerate this array
               using (il.ForEachLoop(f.ClrNullableIfHasNullsType, array, out LocalBuilder arrayElement))
               {
                  //store in destination list
                  il.CallVirt(addToListMethod, Ldarg_1, arrayElement);

                  //add repereplacedion level
                  il.CallVirt(addRepLevelMethod, Ldarg_2, rl);

                  //set repereplacedion level to max
                  il.Emit(Ldarg_3);
                  il.StLoc(rl);
               }
            }
            else
            {
               //hold item
               LocalBuilder item = il.DeclareLocal(f.ClrNullableIfHasNullsType);

               //get current value, converting if necessary
               il.Emit(Ldloc, currentElement.LocalIndex);
               il.Emit(Callvirt, getValueMethod);
               if (conversion != null)
               {
                  conversion.Emit(il);
               }
               il.Emit(Stloc, item.LocalIndex);

               //store in destination list
               il.Emit(Ldarg_1);
               il.Emit(Ldloc, item.LocalIndex);
               il.Emit(Callvirt, addToListMethod);
            }
         }

         il.Emit(Ldc_I4_0);
         il.Emit(Ret);
      }

19 Source : MSILGenerator.cs
with MIT License
from aloneguid

private void Generatereplacedigner(ILGenerator il, Type clreplacedType, DataField field,
         MethodInfo setValueMethod,
         MethodInfo getDataMethod,
         MethodInfo getRepsMethod,
         TypeConversion conversion)
      {
         //arg 0 - DataColumn
         //arg 1 - clreplaced intances array (Array)

         if (field.IsArray)
         {
            LocalBuilder repItem = il.DeclareLocal(typeof(int));
            LocalBuilder dce = il.DeclareLocal(typeof(DataColumnEnumerator));

            //we will use DataColumnEnumerator for complex types

            //create an instance of it
            il.Emit(Ldarg_0); //constructor argument
            il.Emit(Newobj, typeof(DataColumnEnumerator).GetTypeInfo().DeclaredConstructors.First());
            il.StLoc(dce);

            LocalBuilder ci = il.DeclareLocal(typeof(int)); //clreplaced index
            LocalBuilder clreplacedInstance = il.DeclareLocal(clreplacedType); //clreplaced instance

            using (il.ForEachLoopFromEnumerator(typeof(object), dce, out LocalBuilder element))
            {
               //element should be an array for simple repeatables

               //get clreplaced instance by index
               il.GetArrayElement(Ldarg_1, ci, true, typeof(Array), clreplacedInstance);

               //replacedign data item to clreplaced property
               il.CallVirt(setValueMethod, clreplacedInstance, element);

               il.Increment(ci);
            }
         }
         else
         {
            //get values
            LocalBuilder data = il.DeclareLocal(typeof(Array));
            il.CallVirt(getDataMethod, Ldarg_0);
            il.StLoc(data);

            //get length of values
            LocalBuilder dataLength = il.DeclareLocal(typeof(int));
            il.GetArrayLength(data, dataLength);

            LocalBuilder dataItem = il.DeclareLocal(field.ClrNullableIfHasNullsType);  //current value
            bool dataIsRef = field.HasNulls && !field.ClrNullableIfHasNullsType.IsSystemNullable();

            LocalBuilder clreplacedInstance = il.DeclareLocal(clreplacedType);

            using (il.ForLoop(dataLength, out LocalBuilder iData))
            {
               //get data value
               il.GetArrayElement(data, iData, dataIsRef, field.ClrNullableIfHasNullsType, dataItem);

               //get clreplaced instance
               il.GetArrayElement(Ldarg_1, iData, true, clreplacedType, clreplacedInstance);

               il.LdLoc(clreplacedInstance);

               //convert if necessary
               if (conversion != null)
               {
                  il.LdLoc(dataItem);
                  conversion.Emit(il);
               }
               else
               {
                  il.Emit(Ldloc, dataItem.LocalIndex);
               }

               //replacedign data item to clreplaced property
               il.Emit(Callvirt, setValueMethod);
            }
         }

         il.Emit(Ret);
      }

19 Source : ILExtensions.cs
with MIT License
from aloneguid

public static IDisposable ForLoop(this ILGenerator il, LocalBuilder max, out LocalBuilder loopCounter)
      {
         loopCounter = il.DeclareLocal(typeof(int)); //loop counter
#if DEBUG
         il.EmitWriteLine("for-begin");
#endif
         il.Emit(Ldc_I4_0);
         il.Emit(Stloc, loopCounter.LocalIndex);

         Label lBody = il.DefineLabel();     //loop body start
         Label lExit = il.DefineLabel();     //final and return

         il.MarkLabel(lBody); //loop body starts here

         //load counter and max and compare them
         il.Emit(Ldloc, loopCounter.LocalIndex);
         il.Emit(Ldloc, max.LocalIndex);
         //il.Emit(Ldc_I4_3);
         il.Emit(Clt);   //1 - less, 0 - equal or more (exit)
         il.Emit(Brfalse, lExit);  //jump on 1

#if DEBUG
         il.EmitWriteLine("  for-loop");
#endif

         // loop body executes here

         LocalBuilder loopCounterAfter = loopCounter;
         return il.After(() =>
         {
            //increment loop counter
            il.Increment(loopCounterAfter);

            //loop again
            il.Emit(Br, lBody);

            il.MarkLabel(lExit);
#if DEBUG
            il.EmitWriteLine("for-end");
#endif
         });
      }

19 Source : ILExtensions.cs
with MIT License
from aloneguid

public static void CallVirt(this ILGenerator il, MethodInfo method, params object[] parameters)
      {
         if(parameters != null)
         {
            foreach(object param in parameters)
            {
               switch (param)
               {
                  case OpCode oc:
                     il.Emit(oc);
                     break;
                  case LocalBuilder lb:
                     il.Emit(Ldloc, lb.LocalIndex);
                     break;
                  default:
                     throw new NotSupportedException("don't know how to treat parameter " + param?.GetType());
               }
            }
         }

         il.Emit(Callvirt, method);
      }

19 Source : ILExtensions.cs
with MIT License
from aloneguid

public static void GetArrayLength(this ILGenerator il, OpCode loadArrayCode, LocalBuilder lengthReceiver)
      {
         il.Emit(loadArrayCode);
         il.Emit(Ldlen);
         il.Emit(Conv_I4);
         il.StLoc(lengthReceiver);
      }

19 Source : ILExtensions.cs
with MIT License
from aloneguid

public static void GetArrayElement(this ILGenerator il, OpCode loadArrayCode, LocalBuilder index, bool loadByRef, Type elementType, LocalBuilder elementReceiver)
      {
         //load data element
         il.Emit(loadArrayCode);  //data array
         il.Emit(Ldloc, index.LocalIndex);  //index
         if (loadByRef)
         {
            il.Emit(Ldelem_Ref);
         }
         else
         {
            il.Emit(Ldelem, elementType);
         }
         il.Emit(Stloc, elementReceiver.LocalIndex);  //data value
      }

19 Source : ILExtensions.cs
with MIT License
from aloneguid

public static void GetArrayElement(this ILGenerator il, LocalBuilder array, LocalBuilder index, bool loadByRef, Type elementType, LocalBuilder elementReceiver)
      {
         //load data element
         il.Emit(Ldloc, array.LocalIndex);  //data array
         il.Emit(Ldloc, index.LocalIndex);  //index
         if (loadByRef)
         {
            il.Emit(Ldelem_Ref);
         }
         else
         {
            il.Emit(Ldelem, elementType);
         }
         il.Emit(Stloc, elementReceiver.LocalIndex);  //data value
      }

19 Source : ILExtensions.cs
with MIT License
from aloneguid

public static void Increment(this ILGenerator il, LocalBuilder inreplacedem)
      {
         //increment loop counter
         il.Emit(Ldc_I4_1);
         il.Emit(Ldloc, inreplacedem.LocalIndex);
         il.Emit(Add);
         il.Emit(Stloc, inreplacedem.LocalIndex);
      }

19 Source : InterfaceProxyBuilder.cs
with MIT License
from amazingalek

private void CreateConstructor(TypeBuilder proxyBuilder, FieldBuilder targetField, Type targetType)
		{
			var constructor = proxyBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard | CallingConventions.HasThis, new[] { targetType });
			var il = constructor.GetILGenerator();

			il.Emit(OpCodes.Ldarg_0); // this
			il.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[0])); // call base constructor
			il.Emit(OpCodes.Ldarg_0);      // this
			il.Emit(OpCodes.Ldarg_1);      // load argument
			il.Emit(OpCodes.Stfld, targetField); // set field to loaded argument
			il.Emit(OpCodes.Ret);
		}

19 Source : InterfaceProxyBuilder.cs
with MIT License
from amazingalek

private void CreateProxyMethodBody(MethodBuilder methodBuilder, MethodInfo target, FieldBuilder instanceField, Type[] argTypes)
		{
			var il = methodBuilder.GetILGenerator();

			// load target instance
			il.Emit(OpCodes.Ldarg_0);
			il.Emit(OpCodes.Ldfld, instanceField);

			// invoke target method on instance
			for (var i = 0; i < argTypes.Length; i++)
			{
				il.Emit(OpCodes.Ldarg, i + 1);
			}
			il.Emit(OpCodes.Call, target);

			// return result
			il.Emit(OpCodes.Ret);
		}

19 Source : Accessor.cs
with MIT License
from andruzzzhka

private static Accessor MakeAccessor(string fieldName)
        {
            var field = typeof(T).GetField(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
            if (field == null)
                throw new MissingFieldException(typeof(T).Name, fieldName);

            var dynMethodName = $"<>_accessor__{fieldName}";
            // unfortunately DynamicMethod doesn't like having a ByRef return type, so reflection it
            var dyn = new DynamicMethod(dynMethodName, typeof(U), new[] { typeof(T).MakeByRefType() }, typeof(FieldAccessor<T, U>), true);
            ReflectionUtil.DynamicMethodReturnType.SetValue(dyn, typeof(U).MakeByRefType());

            var il = dyn.GetILGenerator();
            il.Emit(OpCodes.Ldarg_0);
            if (!typeof(T).IsValueType)
                il.Emit(OpCodes.Ldind_Ref);
            il.Emit(OpCodes.Ldflda, field);
            il.Emit(OpCodes.Ret);

            return (Accessor)dyn.CreateDelegate(typeof(Accessor));
        }

19 Source : Accessor.cs
with MIT License
from andruzzzhka

private static (Getter, Setter) MakeAccessors(string propName)
        {
            var prop = typeof(T).GetProperty(propName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
            if (prop == null)
                throw new MissingMemberException(typeof(T).Name, propName);

            var getM = prop.GetGetMethod(true);
            var setM = prop.GetSetMethod(true);
            Getter getter = null;
            Setter setter = null;

            if (typeof(T).IsValueType)
            {
                if (getM != null)
                    getter = (Getter)Delegate.CreateDelegate(typeof(Getter), getM);
                if (setM != null)
                    setter = (Setter)Delegate.CreateDelegate(typeof(Setter), setM);
            }
            else
            {
                if (getM != null)
                {
                    var dyn = new DynamicMethod($"<>_get__{propName}", typeof(U), new[] { typeof(T).MakeByRefType() }, typeof(PropertyAccessor<T, U>), true);
                    var il = dyn.GetILGenerator();
                    il.Emit(OpCodes.Ldarg_0);
                    il.Emit(OpCodes.Ldind_Ref);
                    il.Emit(OpCodes.Tailcall);
                    il.Emit(getM.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, getM);
                    il.Emit(OpCodes.Ret);
                    getter = (Getter)dyn.CreateDelegate(typeof(Getter));
                }
                if (setM != null)
                {
                    var dyn = new DynamicMethod($"<>_set__{propName}", typeof(void), new[] { typeof(T).MakeByRefType(), typeof(U) }, typeof(PropertyAccessor<T, U>), true);
                    var il = dyn.GetILGenerator();
                    il.Emit(OpCodes.Ldarg_0);
                    il.Emit(OpCodes.Ldind_Ref);
                    il.Emit(OpCodes.Ldarg_1);
                    il.Emit(OpCodes.Tailcall);
                    il.Emit(setM.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, setM);
                    il.Emit(OpCodes.Ret);
                    setter = (Setter)dyn.CreateDelegate(typeof(Setter));
                }
            }

            return (getter, setter);
        }

19 Source : DynamicParameters.cs
with MIT License
from anet-team

public DynamicParameters Output<T>(T target, Expression<Func<T, object>> expression, DbType? dbType = null, int? size = null)
        {
            var failMessage = "Expression must be a property/field chain off of a(n) {0} instance";
            failMessage = string.Format(failMessage, typeof(T).Name);
            Action @throw = () => throw new InvalidOperationException(failMessage);

            // Is it even a MemberExpression?
            var lastMemberAccess = expression.Body as MemberExpression;

            if (lastMemberAccess == null
                || (!(lastMemberAccess.Member is PropertyInfo)
                    && !(lastMemberAccess.Member is FieldInfo)))
            {
                if (expression.Body.NodeType == ExpressionType.Convert
                    && expression.Body.Type == typeof(object)
                    && ((UnaryExpression)expression.Body).Operand is MemberExpression)
                {
                    // It's got to be unboxed
                    lastMemberAccess = (MemberExpression)((UnaryExpression)expression.Body).Operand;
                }
                else
                {
                    @throw();
                }
            }

            // Does the chain consist of MemberExpressions leading to a ParameterExpression of type T?
            MemberExpression diving = lastMemberAccess;
            // Retain a list of member names and the member expressions so we can rebuild the chain.
            List<string> names = new List<string>();
            List<MemberExpression> chain = new List<MemberExpression>();

            do
            {
                // Insert the names in the right order so expression
                // "Post.Author.Name" becomes parameter "PostAuthorName"
                names.Insert(0, diving?.Member.Name);
                chain.Insert(0, diving);

                var constant = diving?.Expression as ParameterExpression;
                diving = diving?.Expression as MemberExpression;

                if (constant != null && constant.Type == typeof(T))
                {
                    break;
                }
                else if (diving == null
                    || (!(diving.Member is PropertyInfo)
                        && !(diving.Member is FieldInfo)))
                {
                    @throw();
                }
            }
            while (diving != null);

            var dynamicParamName = string.Concat(names.ToArray());

            // Before we get all emitty...
            var lookup = string.Join("|", names.ToArray());

            var cache = CachedOutputSetters<T>.Cache;
            var setter = (Action<object, DynamicParameters>)cache[lookup];
            if (setter != null) goto MAKECALLBACK;

            // Come on let's build a method, let's build it, let's build it now!
            var dm = new DynamicMethod("ExpressionParam" + Guid.NewGuid().ToString(), null, new[] { typeof(object), GetType() }, true);
            var il = dm.GetILGenerator();

            il.Emit(OpCodes.Ldarg_0); // [object]
            il.Emit(OpCodes.Castclreplaced, typeof(T));    // [T]

            // Count - 1 to skip the last member access
            var i = 0;
            for (; i < (chain.Count - 1); i++)
            {
                var member = chain[0].Member;

                if (member is PropertyInfo)
                {
                    var get = ((PropertyInfo)member).GetGetMethod(true);
                    il.Emit(OpCodes.Callvirt, get); // [Member{i}]
                }
                else // Else it must be a field!
                {
                    il.Emit(OpCodes.Ldfld, (FieldInfo)member); // [Member{i}]
                }
            }

            var paramGetter = GetType().GetMethod("Get", new Type[] { typeof(string) }).MakeGenericMethod(lastMemberAccess.Type);

            il.Emit(OpCodes.Ldarg_1); // [target] [DynamicParameters]
            il.Emit(OpCodes.Ldstr, dynamicParamName); // [target] [DynamicParameters] [ParamName]
            il.Emit(OpCodes.Callvirt, paramGetter); // [target] [value], it's already typed thanks to generic method

            // GET READY
            var lastMember = lastMemberAccess.Member;
            if (lastMember is PropertyInfo)
            {
                var set = ((PropertyInfo)lastMember).GetSetMethod(true);
                il.Emit(OpCodes.Callvirt, set); // SET
            }
            else
            {
                il.Emit(OpCodes.Stfld, (FieldInfo)lastMember); // SET
            }

            il.Emit(OpCodes.Ret); // GO

            setter = (Action<object, DynamicParameters>)dm.CreateDelegate(typeof(Action<object, DynamicParameters>));
            lock (cache)
            {
                cache[lookup] = setter;
            }

            // Queue the preparation to be fired off when adding parameters to the DbCommand
            MAKECALLBACK:
            (outputCallbacks ?? (outputCallbacks = new List<Action>())).Add(() =>
            {
                // Finally, prep the parameter and attach the callback to it
                var targetMemberType = lastMemberAccess?.Type;
                int sizeToSet = (!size.HasValue && targetMemberType == typeof(string)) ? DbString.DefaultLength : size ?? 0;

                if (parameters.TryGetValue(dynamicParamName, out ParamInfo parameter))
                {
                    parameter.ParameterDirection = parameter.AttachedParam.Direction = ParameterDirection.InputOutput;

                    if (parameter.AttachedParam.Size == 0)
                    {
                        parameter.Size = parameter.AttachedParam.Size = sizeToSet;
                    }
                }
                else
                {
                    dbType = (!dbType.HasValue)
#pragma warning disable 618
                    ? SqlMapper.LookupDbType(targetMemberType, targetMemberType?.Name, true, out SqlMapper.ITypeHandler handler)
#pragma warning restore 618
                    : dbType;

                    // CameFromTemplate property would not apply here because this new param
                    // Still needs to be added to the command
                    Add(dynamicParamName, expression.Compile().Invoke(target), null, ParameterDirection.InputOutput, sizeToSet);
                }

                parameter = parameters[dynamicParamName];
                parameter.OutputCallback = setter;
                parameter.OutputTarget = target;
            });

            return this;
        }

19 Source : CommandDefinition.cs
with MIT License
from anet-team

private static Action<IDbCommand> GetInit(Type commandType)
        {
            if (commandType == null)
                return null; // GIGO
            if (SqlMapper.Link<Type, Action<IDbCommand>>.TryGet(commandInitCache, commandType, out Action<IDbCommand> action))
            {
                return action;
            }
            var bindByName = GetBasicPropertySetter(commandType, "BindByName", typeof(bool));
            var initialLongFetchSize = GetBasicPropertySetter(commandType, "InitialLONGFetchSize", typeof(int));

            action = null;
            if (bindByName != null || initialLongFetchSize != null)
            {
                var method = new DynamicMethod(commandType.Name + "_init", null, new Type[] { typeof(IDbCommand) });
                var il = method.GetILGenerator();

                if (bindByName != null)
                {
                    // .BindByName = true
                    il.Emit(OpCodes.Ldarg_0);
                    il.Emit(OpCodes.Castclreplaced, commandType);
                    il.Emit(OpCodes.Ldc_I4_1);
                    il.EmitCall(OpCodes.Callvirt, bindByName, null);
                }
                if (initialLongFetchSize != null)
                {
                    // .InitialLONGFetchSize = -1
                    il.Emit(OpCodes.Ldarg_0);
                    il.Emit(OpCodes.Castclreplaced, commandType);
                    il.Emit(OpCodes.Ldc_I4_M1);
                    il.EmitCall(OpCodes.Callvirt, initialLongFetchSize, null);
                }
                il.Emit(OpCodes.Ret);
                action = (Action<IDbCommand>)method.CreateDelegate(typeof(Action<IDbCommand>));
            }
            // cache it
            SqlMapper.Link<Type, Action<IDbCommand>>.TryAdd(ref commandInitCache, commandType, ref action);
            return action;
        }

19 Source : MethodTableToTypeConverter.cs
with GNU General Public License v3.0
from anydream

static Type GetTypeNET40(TypeBuilder tb, MethodBuilder mb, IntPtr address) {
			var ilg = mb.GetILGenerator();
			ilg.Emit(SR.Emit.OpCodes.Ret);

			// We need at least one local to make sure the SignatureHelper from ILGenerator is used.
			ilg.DeclareLocal(typeof(int));

			var locals = GetLocalSignature(address);
			var sigHelper = (SignatureHelper)localSignatureFieldInfo.GetValue(ilg);
			sigDoneFieldInfo.SetValue(sigHelper, true);
			currSigFieldInfo.SetValue(sigHelper, locals.Length);
			signatureFieldInfo.SetValue(sigHelper, locals);

			var createdMethod = tb.CreateType().GetMethod(METHOD_NAME, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
			return createdMethod.GetMethodBody().LocalVariables[0].LocalType;
		}

19 Source : ReflectionHandlerFactory.cs
with MIT License
from aquilahkj

private static FastMethodHandler CreateMethodHandler(MethodInfo methodInfo)
        {
            int num;
            var method = new DynamicMethod(string.Empty, typeof(object), new[]
            {
                typeof(object),
                typeof(object[])
            }, methodInfo.DeclaringType.GetTypeInfo().Module);
            var iLGenerator = method.GetILGenerator();
            var parameters = methodInfo.GetParameters();
            var typeArray = new Type[parameters.Length];
            for (num = 0; num < typeArray.Length; num++)
            {
                if (parameters[num].ParameterType.IsByRef)
                {
                    typeArray[num] = parameters[num].ParameterType.GetElementType();
                }
                else
                {
                    typeArray[num] = parameters[num].ParameterType;
                }
            }

            var builderArray = new LocalBuilder[typeArray.Length];
            for (num = 0; num < typeArray.Length; num++)
            {
                builderArray[num] = iLGenerator.DeclareLocal(typeArray[num], true);
            }

            for (num = 0; num < typeArray.Length; num++)
            {
                iLGenerator.Emit(OpCodes.Ldarg_1);
                EmitFastInt(iLGenerator, num);
                iLGenerator.Emit(OpCodes.Ldelem_Ref);
                EmitCastToReference(iLGenerator, typeArray[num]);
                iLGenerator.Emit(OpCodes.Stloc, builderArray[num]);
            }

            if (!methodInfo.IsStatic)
            {
                iLGenerator.Emit(OpCodes.Ldarg_0);
            }

            for (num = 0; num < typeArray.Length; num++)
            {
                iLGenerator.Emit(parameters[num].ParameterType.IsByRef ? OpCodes.Ldloca_S : OpCodes.Ldloc,
                    builderArray[num]);
            }

            iLGenerator.EmitCall(methodInfo.IsStatic ? OpCodes.Call : OpCodes.Callvirt, methodInfo, null);
            if (methodInfo.ReturnType == typeof(void))
            {
                iLGenerator.Emit(OpCodes.Ldnull);
            }
            else
            {
                EmitBoxIfNeeded(iLGenerator, methodInfo.ReturnType);
            }

            for (num = 0; num < typeArray.Length; num++)
            {
                if (parameters[num].ParameterType.IsByRef)
                {
                    iLGenerator.Emit(OpCodes.Ldarg_1);
                    EmitFastInt(iLGenerator, num);
                    iLGenerator.Emit(OpCodes.Ldloc, builderArray[num]);
                    if (builderArray[num].LocalType.GetTypeInfo().IsValueType)
                    {
                        iLGenerator.Emit(OpCodes.Box, builderArray[num].LocalType);
                    }

                    iLGenerator.Emit(OpCodes.Stelem_Ref);
                }
            }

            iLGenerator.Emit(OpCodes.Ret);
            return (FastMethodHandler) method.CreateDelegate(typeof(FastMethodHandler));
        }

19 Source : ReflectionHandlerFactory.cs
with MIT License
from aquilahkj

private static GetValueHandler CreateFieldGetHandler(FieldInfo field)
        {
            var method = new DynamicMethod("", typeof(object), new[] {typeof(object)}, field.DeclaringType);
            var iLGenerator = method.GetILGenerator();
            iLGenerator.Emit(OpCodes.Ldarg_0);
            iLGenerator.Emit(OpCodes.Ldfld, field);
            EmitBoxIfNeeded(iLGenerator, field.FieldType);
            iLGenerator.Emit(OpCodes.Ret);
            return (GetValueHandler) method.CreateDelegate(typeof(GetValueHandler));
        }

19 Source : ReflectionHandlerFactory.cs
with MIT License
from aquilahkj

private static SetValueHandler CreateFieldSetHandler(FieldInfo field)
        {
            var method = new DynamicMethod("", null, new[] {typeof(object), typeof(object)}, field.DeclaringType);
            var iLGenerator = method.GetILGenerator();
            iLGenerator.Emit(OpCodes.Ldarg_0);
            iLGenerator.Emit(OpCodes.Ldarg_1);
            EmitCastToReference(iLGenerator, field.FieldType);
            iLGenerator.Emit(OpCodes.Stfld, field);
            iLGenerator.Emit(OpCodes.Ret);
            return (SetValueHandler) method.CreateDelegate(typeof(SetValueHandler));
        }

19 Source : ReflectionHandlerFactory.cs
with MIT License
from aquilahkj

private static ObjectInstanceHandler CreateInstanceHandler(Type type)
        {
            var method = new DynamicMethod(string.Empty, type, null, type.GetTypeInfo().Module);
            var iLGenerator = method.GetILGenerator();
            iLGenerator.DeclareLocal(type, true);
            iLGenerator.Emit(OpCodes.Newobj, type.GetTypeInfo().GetConstructor(new Type[0]));
            iLGenerator.Emit(OpCodes.Stloc_0);
            iLGenerator.Emit(OpCodes.Ldloc_0);
            iLGenerator.Emit(OpCodes.Ret);
            return (ObjectInstanceHandler) method.CreateDelegate(typeof(ObjectInstanceHandler));
        }

19 Source : ReflectionHandlerFactory.cs
with MIT License
from aquilahkj

private static GetValueHandler CreatePropertyGetHandler(PropertyInfo property)
        {
            var method = new DynamicMethod(string.Empty, typeof(object), new[] {typeof(object)},
                property.DeclaringType.GetTypeInfo().Module);
            var iLGenerator = method.GetILGenerator();
            iLGenerator.Emit(OpCodes.Ldarg_0);
            iLGenerator.EmitCall(OpCodes.Callvirt, property.GetMethod, null);
            EmitBoxIfNeeded(iLGenerator, property.PropertyType);
            iLGenerator.Emit(OpCodes.Ret);
            return (GetValueHandler) method.CreateDelegate(typeof(GetValueHandler));
        }

See More Examples