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
19
Source : ILGeneratorExtensions.cs
with MIT License
from akaskela
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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