internal static UnaryMath UnaryRMath(OpCodeValue ocv, Expression operand)
{
var b = false;
operand.Type.MeetWith(new Types.Real(), ref b);
return(new(ocv, operand));
}
public Jump(OpCodeValue code, bool isInTable, int address, bool isConditional)
: base(code)
{
this.Address = address;
this.IsInTable = isInTable;
this.IsConditional = isConditional;
}
public static BinaryMath BinaryRMath(OpCodeValue ocv, Expression left, Expression right)
{
var b = false;
left.Type.MeetWith(new Types.Real(), ref b);
right.Type.MeetWith(new Types.Real(), ref b);
return(new(ocv, left, right));
}
public ConditionalItem(ByteCodeGenerator generator, OpCodeValue opCode, Chain trueChain, Chain falseChain)
: base(generator, PrimativeTypes.Boolean)
{
OpCode = opCode;
TrueJumps = trueChain;
FalseJumps = falseChain;
}
public Key(Type type, string methodName, OpCodeValue callOpCode, Type returnType, Type[] methodParameterTypes, Type[] methodGenericArguments)
{
Type = type;
MethodName = methodName;
CallOpCode = callOpCode;
ReturnType = returnType;
MethodParameterTypes = methodParameterTypes;
MethodGenericArguments = methodGenericArguments;
}
private MethodBuilder(Module resolutionModule, int mdToken, int opCode, string methodName)
{
_resolutionModule = resolutionModule;
_mdToken = mdToken;
_opCode = (OpCodeValue)opCode;
_originalOpCodeValue = opCode;
_methodName = methodName;
_forceMethodDefResolve = false;
}
private MethodBuilder(Assembly resolutionAssembly, int mdToken, int opCode, string methodName)
{
_resolutionAssembly = resolutionAssembly;
_mdToken = mdToken;
_opCode = (OpCodeValue)opCode;
_originalOpCodeValue = opCode;
_methodName = methodName;
_forceMethodDefResolve = false;
}
public static BinaryMath BinaryIMath(OpCodeValue ocv, Expression left, Expression right)
{
var b = false;
if (!left.Type.ResolvesTo <Types.Pointer>())
{
left.Type.MeetWith(new Types.Integer(), ref b);
}
if (!right.Type.ResolvesTo <Types.Pointer>())
{
right.Type.MeetWith(new Types.Integer(), ref b);
}
return(new(ocv, left, right));
}
public unsafe void Arithmetic_LDC_I2_Test(float expected, OpCodeValue actor)
{
using var ctx = CreateContext();
var result = ctx.Execute((gen, _) =>
{
gen.Emit(OpCodes.LDC_I2_S, 12);
gen.Emit(OpCodes.LDC_I2_S, 2);
gen.Emit(OpCodes.all[actor]);
gen.Emit(OpCodes.RET);
});
Validate(result);
Assert.AreEqual(VeinTypeCode.TYPE_R4, (*result.returnValue).type);
Assert.AreEqual(expected, (*result.returnValue).data.f_r4);
}
public unsafe void Arithmetic_Double_Test(int expected, OpCodeValue actor)
{
using var ctx = CreateContext();
var result = ctx.Execute((gen, _) =>
{
gen.Emit(OpCodes.LDC_F8, 12d);
gen.Emit(OpCodes.LDC_F8, 2d);
gen.Emit(OpCodes.all[actor]);
gen.Emit(OpCodes.RET);
});
Validate(result);
Assert.AreEqual(VeinTypeCode.TYPE_R8, (*result.returnValue).type);
Assert.AreEqual((double)expected, (*result.returnValue).data.f);
}
public unsafe void DIV_Test(OpCodeValue op, VeinTypeCode code)
{
using var ctx = CreateContext();
var result = ctx.Execute((gen, _) =>
{
gen.Emit(OpCodes.all[op]);
gen.Emit(OpCodes.all[op]);
gen.Emit(OpCodes.DIV);
gen.Emit(OpCodes.RET);
});
Validate(result);
Assert.AreEqual(code, (*result.returnValue).type);
Assert.AreEqual(5 / 5, (*result.returnValue).data.l);
}
internal OpCode(OpCodeValue bc, NormalizedOpCodeValues normalizedValue, int arg, OpCodeMode reg,
OpCodeModeWide wide, bool cannotThrow)
{
Value = bc;
Mode = reg;
WideMode = wide;
NormalizedValue = normalizedValue;
this.arg = arg;
Flags = OpCodeFlags.FixedArg;
if (cannotThrow)
{
Flags |= OpCodeFlags.CannotThrow;
}
}
/// <summary>
/// Gets a previously cache delegate used to call the specified method,
/// or creates and caches a new delegate if not found.
/// </summary>
/// <param name="type">The <see cref="Type"/> that contains the method.</param>
/// <param name="methodName">The name of the method.</param>
/// <param name="callOpCode">The OpCode to use in the method call.</param>
/// <param name="returnType">The method's return type.</param>
/// <param name="methodParameterTypes">optional types for the method parameters</param>
/// <param name="methodGenericArguments">optional generic type arguments for a generic method</param>
/// <returns>A <see cref="Delegate"/> that can be used to execute the dynamic method.</returns>
public static TDelegate GetOrCreateMethodCallDelegate(
Type type,
string methodName,
OpCodeValue callOpCode,
Type returnType = null,
Type[] methodParameterTypes = null,
Type[] methodGenericArguments = null) =>
Cache.GetOrAdd(
new Key(type, methodName, callOpCode, returnType, methodParameterTypes, methodGenericArguments),
key => CreateMethodCallDelegate(
key.Type,
key.MethodName,
key.CallOpCode,
key.MethodParameterTypes,
key.MethodGenericArguments));
public static int Main()
{
OpCodeValue test = new OpCodeValue();
TestLibrary.TestFramework.BeginTestCase("OpCodeValue");
if (test.RunTests())
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("PASS");
return 100;
}
else
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("FAIL");
return 0;
}
}
public static int Main()
{
OpCodeValue test = new OpCodeValue();
TestLibrary.TestFramework.BeginTestCase("OpCodeValue");
if (test.RunTests())
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("PASS");
return(100);
}
else
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("FAIL");
return(0);
}
}
public Key(
Module callingModule,
int mdToken,
OpCodeValue callOpCode,
Type concreteType,
Type[] explicitParameterTypes,
Type[] methodGenerics,
Type[] declaringTypeGenerics)
{
CallingModuleMetadataToken = callingModule.MetadataToken;
MethodMetadataToken = mdToken;
CallOpCode = callOpCode;
ConcreteTypeName = concreteType.AssemblyQualifiedName;
GenericSpec = "_gArgs_";
if (methodGenerics != null)
{
for (var i = 0; i < methodGenerics.Length; i++)
{
GenericSpec = string.Concat(GenericSpec, $"_{methodGenerics[i].FullName}_");
}
}
GenericSpec = string.Concat(GenericSpec, "_gParams_");
if (declaringTypeGenerics != null)
{
for (var i = 0; i < declaringTypeGenerics.Length; i++)
{
GenericSpec = string.Concat(GenericSpec, $"_{declaringTypeGenerics[i].FullName}_");
}
}
ExplicitParams = string.Empty;
if (explicitParameterTypes != null)
{
ExplicitParams = string.Join("_", explicitParameterTypes.Select(ept => ept.FullName));
}
}
public CountByte(OpCodeValue code, int count) : base(code) => this.Count = count;
// ReSharper restore InconsistentNaming
public static OpCodeValue Negate(OpCodeValue opcode)
{
if (opcode == OpCodeValue.ifnull) return OpCodeValue.ifnonnull;
if (opcode == OpCodeValue.ifnonnull) return OpCodeValue.ifnull;
return (OpCodeValue)(((int)opcode + 1) ^ 1) - 1;
}
public ExternalWord(OpCodeValue code, string segment, int segNum, int offset)
: base(code, offset)
{
this.Segment = segment;
this.SegNumber = segNum;
}
/// <summary>
/// Creates a simple <see cref="DynamicMethod"/> using <see cref="System.Reflection.Emit"/> that
/// calls a method with the specified name and parameter types.
/// </summary>
/// <param name="type">The <see cref="Type"/> that contains the method to call when the returned delegate is executed..</param>
/// <param name="methodName">The name of the method to call when the returned delegate is executed.</param>
/// <param name="callOpCode">The OpCode to use in the method call.</param>
/// <param name="methodParameterTypes">If not null, use method overload that matches the specified parameters.</param>
/// <param name="methodGenericArguments">If not null, use method overload that has the same number of generic arguments.</param>
/// <returns>A <see cref="Delegate"/> that can be used to execute the dynamic method.</returns>
public static TDelegate CreateMethodCallDelegate(
Type type,
string methodName,
OpCodeValue callOpCode,
Type[] methodParameterTypes = null,
Type[] methodGenericArguments = null)
{
Type delegateType = typeof(TDelegate);
Type[] genericTypeArguments = delegateType.GenericTypeArguments;
Type[] parameterTypes;
Type returnType;
if (delegateType.Name.StartsWith("Func`"))
{
// last generic type argument is the return type
int parameterCount = genericTypeArguments.Length - 1;
parameterTypes = new Type[parameterCount];
Array.Copy(genericTypeArguments, parameterTypes, parameterCount);
returnType = genericTypeArguments[parameterCount];
}
else if (delegateType.Name.StartsWith("Action`"))
{
parameterTypes = genericTypeArguments;
returnType = typeof(void);
}
else
{
throw new Exception($"Only Func<> or Action<> are supported in {nameof(CreateMethodCallDelegate)}.");
}
// find any method that matches by name and parameter types
IEnumerable <MethodInfo> methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)
.Where(m => m.Name == methodName);
// if methodParameterTypes was specified, check for a method that matches
if (methodParameterTypes != null)
{
methods = methods.Where(
m =>
{
var ps = m.GetParameters();
if (ps.Length != methodParameterTypes.Length)
{
return(false);
}
for (var i = 0; i < ps.Length; i++)
{
var t1 = ps[i].ParameterType;
var t2 = methodParameterTypes[i];
// generics can be tricky to compare for type equality
// so we will just check the namespace and name
if (t1.Namespace != t2.Namespace || t1.Name != t2.Name)
{
return(false);
}
}
return(true);
});
}
if (methodGenericArguments != null)
{
methods = methods.Where(
m => m.IsGenericMethodDefinition &&
m.GetGenericArguments().Length == methodGenericArguments.Length);
}
MethodInfo methodInfo = methods.FirstOrDefault();
if (methodInfo == null)
{
// method not found
// TODO: logging
return(null);
}
if (methodGenericArguments != null)
{
methodInfo = methodInfo.MakeGenericMethod(methodGenericArguments);
}
Type[] effectiveParameterTypes;
IEnumerable <Type> reflectedParameterTypes = methodInfo.GetParameters()
.Select(p => p.ParameterType);
if (methodInfo.IsStatic)
{
effectiveParameterTypes = reflectedParameterTypes.ToArray();
}
else
{
// for instance methods, insert object's type as first element in array
effectiveParameterTypes = new[] { type }
.Concat(reflectedParameterTypes)
.ToArray();
}
DynamicMethod dynamicMethod = new DynamicMethod(methodInfo.Name, returnType, parameterTypes, ObjectExtensions.Module, skipVisibility: true);
ILGenerator il = dynamicMethod.GetILGenerator();
// load each argument and cast or unbox as necessary
for (ushort argumentIndex = 0; argumentIndex < parameterTypes.Length; argumentIndex++)
{
Type delegateParameterType = parameterTypes[argumentIndex];
Type underlyingParameterType = effectiveParameterTypes[argumentIndex];
switch (argumentIndex)
{
case 0:
il.Emit(OpCodes.Ldarg_0);
break;
case 1:
il.Emit(OpCodes.Ldarg_1);
break;
case 2:
il.Emit(OpCodes.Ldarg_2);
break;
case 3:
il.Emit(OpCodes.Ldarg_3);
break;
default:
il.Emit(OpCodes.Ldarg_S, argumentIndex);
break;
}
if (underlyingParameterType.IsValueType && delegateParameterType == typeof(object))
{
il.Emit(OpCodes.Unbox_Any, underlyingParameterType);
}
else if (underlyingParameterType != delegateParameterType)
{
il.Emit(OpCodes.Castclass, underlyingParameterType);
}
}
if (callOpCode == OpCodeValue.Call || methodInfo.IsStatic)
{
// non-virtual call (e.g. static method, or method override calling overriden implementation)
il.Emit(OpCodes.Call, methodInfo);
}
else if (callOpCode == OpCodeValue.Callvirt)
{
// Note: C# compiler uses CALLVIRT for non-virtual
// instance methods to get the cheap null check
il.Emit(OpCodes.Callvirt, methodInfo);
}
else
{
throw new NotSupportedException($"OpCode {callOpCode} not supported when calling a method.");
}
if (methodInfo.ReturnType.IsValueType && !returnType.IsValueType)
{
il.Emit(OpCodes.Box, methodInfo.ReturnType);
}
else if (methodInfo.ReturnType.IsValueType && returnType.IsValueType && methodInfo.ReturnType != returnType)
{
throw new ArgumentException($"Cannot convert the target method's return type {methodInfo.ReturnType.FullName} (valuetype) to the delegate method's return type {returnType.FullName} (valuetype)");
}
else if (!methodInfo.ReturnType.IsValueType && returnType.IsValueType)
{
throw new ArgumentException($"Cannot reliably convert the target method's return type {methodInfo.ReturnType.FullName} (reference type) to the delegate method's return type {returnType.FullName} (value type)");
}
else if (!methodInfo.ReturnType.IsValueType && !returnType.IsValueType && methodInfo.ReturnType != returnType)
{
il.Emit(OpCodes.Castclass, returnType);
}
il.Emit(OpCodes.Ret);
return((TDelegate)dynamicMethod.CreateDelegate(delegateType));
}
//public void Emit(OpCodeValue opcode, Label l)
//{
// var capacity = opcode == OpCodeValue.goto_w || opcode == OpCodeValue.jsr_w ? 5 : 3;
// EnsureCapacity(capacity);
// var labelValue = l.GetLabelValue();
// var i = labelList[labelValue] - length;
// EmitOp(opcode);
// if (!alive) return;
// if (labelList[labelValue] == -1)
// {
// labelRefs[labelValue].Add(new Tuple<int, int>(length, capacity - 1));
// i = int.MaxValue;
// }
// if (capacity == 5)
// {
// EmitInt(i);
// }
// else
// {
// EmitShort((short)i);
// }
// UpdateStackBranch(opcode);
//}
public void EmitWide(OpCodeValue opcode, short s)
{
if (s > 0xFF)
{
EnsureCapacity(4);
EmitOp(OpCodeValue.wide);
EmitOp(opcode);
EmitShort(s);
}
else
{
EnsureCapacity(2);
EmitOp(opcode);
EmitByte((byte)s);
}
if (!alive) return;
UpdateStackWide(opcode, s);
PostOp();
}
private void EmitOp(OpCodeValue opcode)
{
if (pendingJumps != null)
{
ResolvePendingJumps();
}
if (!alive) return;
if (pendingStackMap)
{
pendingStackMap = false;
EmitStackMapFrame();
}
EmitByte((byte)opcode);
}
internal DhcpPacket(Frame parentFrame, int packetStartIndex, int packetEndIndex)
: base(parentFrame, packetStartIndex, packetEndIndex, "DHCP (Bootstrap protocol)")
{
this.opCode = (OpCodeValue)parentFrame.Data[packetStartIndex];
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("OpCode", this.OpCode.ToString());
}
//skip hardware type
//skip hlen
//skip hops
this.transactionID = Utils.ByteConverter.ToUInt32(parentFrame.Data, packetStartIndex + 4);
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("Transaction ID", "0x" + this.transactionID.ToString("X2"));
}
this.secondsElapsed = Utils.ByteConverter.ToUInt16(parentFrame.Data, packetStartIndex + 8);
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("Seconds elapsed", this.secondsElapsed.ToString());
}
//skip flags (unused in BOOTP)
byte[] ipAddrArray = new byte[4];
Array.ConstrainedCopy(parentFrame.Data, packetStartIndex + 12, ipAddrArray, 0, 4);
clientIpAddress = new System.Net.IPAddress(ipAddrArray);
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("Client IP Address", this.clientIpAddress.ToString());
}
Array.ConstrainedCopy(parentFrame.Data, packetStartIndex + 16, ipAddrArray, 0, 4);//do I need to create a new byte[4] before this one?
yourIpAddress = new System.Net.IPAddress(ipAddrArray);
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("Your IP Address", this.yourIpAddress.ToString());
}
Array.ConstrainedCopy(parentFrame.Data, packetStartIndex + 20, ipAddrArray, 0, 4);
serverIpAddress = new System.Net.IPAddress(ipAddrArray);
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("Server IP Address", this.serverIpAddress.ToString());
}
Array.ConstrainedCopy(parentFrame.Data, packetStartIndex + 24, ipAddrArray, 0, 4);
gatewayIpAddress = new System.Net.IPAddress(ipAddrArray);
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("Gateway IP Address", this.gatewayIpAddress.ToString());
}
byte[] macAddrArray = new byte[6];
Array.ConstrainedCopy(parentFrame.Data, packetStartIndex + 28, macAddrArray, 0, 6);
clientMacAddress = new System.Net.NetworkInformation.PhysicalAddress(macAddrArray);
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("Client MAC Address", this.clientMacAddress.ToString());
}
//skip extra 10 bytes of client hardware address
//Skip 192 octets of 0's. BOOTP legacy
//64 - optional server host name
//128 - boot file name
//skip magic cookie (4 bytes)
optionList = new List <Option>();
int index = packetStartIndex + 240;//0x011A - 0x002A = 0xF0
while (index < packetEndIndex)
{
Option option = new Option(parentFrame.Data, index);
if (option.OptionCode == 0xff)//check for "End Option"
{
break;
}
if (option.OptionCode == 3)//Default Gateway (router)
{
this.gatewayIpAddress = new System.Net.IPAddress(option.OptionValue);
}
else if (option.OptionCode == 53)//extract the DHCP Message Type: 1=Discover, 2=Offer, 3=Request, 5=Ack, 8=Inform
{
if (option.OptionValue != null && option.OptionValue.Length == 1)
{
this.dhcpMessageType = option.OptionValue[0];
}
}
optionList.Add(option);
if (!this.ParentFrame.QuickParse)
{
base.Attributes.Add("DHCP Options", option.OptionCode.ToString());
}
index += option.OptionValue.Length + 2;
}
}
public void Emit(OpCodeValue opcode, int b)
{
EnsureCapacity(2);
EmitOp(opcode);
if (!alive) return;
EmitInt(b);
switch (opcode)
{
case OpCodeValue.goto_w:
MarkDead();
break;
case OpCodeValue.jsr_w:
break;
default:
throw new InvalidOperationException();
}
}
public OpCode(OpCodeValue code) => this.Id = code;
protected Constant(OpCodeValue code) : base(code)
{
}
public ConditionalItem(ByteCodeGenerator generator, OpCodeValue opCode)
: this(generator, opCode, null, null)
{
OpCode = opCode;
}
public GlobalWord(OpCodeValue code, int offset) : base(code, offset)
{
}
public IntermediateWord(OpCodeValue code, int level, int offset) : base(code, offset) => this.Level = level;
protected OffsetWord(OpCodeValue code, int offset)
: base(code) => this.Offset = offset;
public Exit(OpCodeValue code, bool isNormal = true)
: base(code) => this.IsNormal = isNormal;
public void Emit(OpCodeValue opcode, short s)
{
EmitOp(opcode);
if (!alive) return;
EmitShort(s);
UpdateStack2(opcode, s);
}
public Type(OpCodeValue code, int type) : base(code) => this.TypeCode = type;
public int EmitJump(OpCodeValue opcode)
{
if (fatcode)
{
if (opcode == OpCodeValue.@goto || opcode == OpCodeValue.jsr)
{
Emit((OpCodeValue)(opcode + (byte)OpCodeValue.@goto_w - OpCodeValue.@goto), (int)0);
}
else
{
Emit(OpCodes.Negate(opcode), (short)8);
Emit(OpCodeValue.@goto_w, (int)0);
alive = true;
pendingStackMap = true;
}
return length - 5;
}
Emit(opcode, (short)0);
return length - 3;
}
public Chain Branch(OpCodeValue opcode)
{
Chain result = null;
if (opcode == OpCodeValue.@goto)
{
result = pendingJumps;
pendingJumps = null;
}
if (opcode != OpCodeValue.jsr && alive)
{
result = new Chain(EmitJump(opcode), result, state.Clone());
fixedPc = fatcode;
if (opcode == OpCodeValue.@goto) alive = false;
}
return result;
}
public void EmitWide(OpCodeValue opcode, short s1, short s2)
{
EnsureCapacity(6);
if (s1 > 0xFF || s2 < -128 || s2 > 127)
{
EmitOp(OpCodeValue.wide);
EmitOp(opcode);
EmitShort(s1);
EmitShort(s2);
}
else
{
EmitOp(opcode);
EmitByte((byte)s1);
EmitByte((byte)s2);
}
}
private void UpdateStack1(OpCodeValue opcode, byte s)
{
switch (opcode)
{
case OpCodeValue.bipush:
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.ldc:
state.Push(TypeForConstant(Manager.ConstantPool[s - 1]));
break;
case OpCodeValue.lstore:
case OpCodeValue.dstore:
state.Pop(2);
break;
case OpCodeValue.istore:
case OpCodeValue.fstore:
case OpCodeValue.astore:
state.Pop(1);
break;
default:
throw new NotImplementedException();
}
}
private void UpdateStack0(OpCodeValue opcode)
{
switch (opcode)
{
case OpCodeValue.aaload:
{
state.Pop(1);// index
var a = state.Peek();
state.Pop(1);
//sometimes 'null type' is treated as a one-dimensional array type
//see Gen.visitLiteral - we should handle this case OpCodeValue.OpCodeValue.accordingly
var stackType = a == PrimativeTypes.Void ? BuiltinTypes.Object : a;
state.Push(stackType);
}
break;
case OpCodeValue.@goto:
MarkDead();
break;
case OpCodeValue.nop:
case OpCodeValue.ineg:
case OpCodeValue.lneg:
case OpCodeValue.fneg:
case OpCodeValue.dneg:
break;
case OpCodeValue.aconst_null:
state.Push(PrimativeTypes.Void);
break;
case OpCodeValue.iconst_m1:
case OpCodeValue.iconst_0:
case OpCodeValue.iconst_1:
case OpCodeValue.iconst_2:
case OpCodeValue.iconst_3:
case OpCodeValue.iconst_4:
case OpCodeValue.iconst_5:
case OpCodeValue.iload_0:
case OpCodeValue.iload_1:
case OpCodeValue.iload_2:
case OpCodeValue.iload_3:
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.lconst_0:
case OpCodeValue.lconst_1:
case OpCodeValue.lload_0:
case OpCodeValue.lload_1:
case OpCodeValue.lload_2:
case OpCodeValue.lload_3:
state.Push(PrimativeTypes.Long);
break;
case OpCodeValue.fconst_0:
case OpCodeValue.fconst_1:
case OpCodeValue.fconst_2:
case OpCodeValue.fload_0:
case OpCodeValue.fload_1:
case OpCodeValue.fload_2:
case OpCodeValue.fload_3:
state.Push(PrimativeTypes.Float);
break;
case OpCodeValue.dconst_0:
case OpCodeValue.dconst_1:
case OpCodeValue.dload_0:
case OpCodeValue.dload_1:
case OpCodeValue.dload_2:
case OpCodeValue.dload_3:
state.Push(PrimativeTypes.Double);
break;
case OpCodeValue.aload_0:
state.Push(GetVariable(0).Type);
break;
case OpCodeValue.aload_1:
state.Push(GetVariable(1).Type);
break;
case OpCodeValue.aload_2:
state.Push(GetVariable(2).Type);
break;
case OpCodeValue.aload_3:
state.Push(GetVariable(3).Type);
break;
case OpCodeValue.iaload:
case OpCodeValue.baload:
case OpCodeValue.caload:
case OpCodeValue.saload:
state.Pop(2);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.laload:
state.Pop(2);
state.Push(PrimativeTypes.Long);
break;
case OpCodeValue.faload:
state.Pop(2);
state.Push(PrimativeTypes.Float);
break;
case OpCodeValue.daload:
state.Pop(2);
state.Push(PrimativeTypes.Double);
break;
case OpCodeValue.istore_0:
case OpCodeValue.istore_1:
case OpCodeValue.istore_2:
case OpCodeValue.istore_3:
case OpCodeValue.fstore_0:
case OpCodeValue.fstore_1:
case OpCodeValue.fstore_2:
case OpCodeValue.fstore_3:
case OpCodeValue.astore_0:
case OpCodeValue.astore_1:
case OpCodeValue.astore_2:
case OpCodeValue.astore_3:
case OpCodeValue.pop:
case OpCodeValue.lshr:
case OpCodeValue.lshl:
case OpCodeValue.lushr:
state.Pop(1);
break;
case OpCodeValue.areturn:
case OpCodeValue.ireturn:
case OpCodeValue.freturn:
//TODO: Assert.check(state.nlocks == 0);
state.Pop(1);
MarkDead();
break;
case OpCodeValue.athrow:
state.Pop(1);
MarkDead();
break;
case OpCodeValue.lstore_0:
case OpCodeValue.lstore_1:
case OpCodeValue.lstore_2:
case OpCodeValue.lstore_3:
case OpCodeValue.dstore_0:
case OpCodeValue.dstore_1:
case OpCodeValue.dstore_2:
case OpCodeValue.dstore_3:
case OpCodeValue.pop2:
state.Pop(2);
break;
case OpCodeValue.lreturn:
case OpCodeValue.dreturn:
//TODO: Assert.check(state.nlocks == 0);
state.Pop(2);
MarkDead();
break;
case OpCodeValue.dup:
state.Push(state.Peek());
break;
case OpCodeValue.@return:
//TODO: Assert.check(state.nlocks == 0);
MarkDead();
break;
case OpCodeValue.arraylength:
state.Pop(1);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.isub:
case OpCodeValue.iadd:
case OpCodeValue.imul:
case OpCodeValue.idiv:
case OpCodeValue.irem:
case OpCodeValue.ishl:
case OpCodeValue.ishr:
case OpCodeValue.iushr:
case OpCodeValue.iand:
case OpCodeValue.ior:
case OpCodeValue.ixor:
state.Pop(1);
break;
case OpCodeValue.aastore:
state.Pop(3);
break;
case OpCodeValue.land:
case OpCodeValue.lor:
case OpCodeValue.lxor:
case OpCodeValue.lrem:
case OpCodeValue.ldiv:
case OpCodeValue.lmul:
case OpCodeValue.lsub:
case OpCodeValue.ladd:
state.Pop(2);
break;
case OpCodeValue.lcmp:
state.Pop(4);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.l2i:
state.Pop(2);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.i2l:
state.Pop(1);
state.Push(PrimativeTypes.Long);
break;
case OpCodeValue.i2f:
state.Pop(1);
state.Push(PrimativeTypes.Float);
break;
case OpCodeValue.i2d:
state.Pop(1);
state.Push(PrimativeTypes.Double);
break;
case OpCodeValue.l2f:
state.Pop(2);
state.Push(PrimativeTypes.Float);
break;
case OpCodeValue.l2d:
state.Pop(2);
state.Push(PrimativeTypes.Double);
break;
case OpCodeValue.f2i:
state.Pop(1);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.f2l:
state.Pop(1);
state.Push(PrimativeTypes.Long);
break;
case OpCodeValue.f2d:
state.Pop(1);
state.Push(PrimativeTypes.Double);
break;
case OpCodeValue.d2i:
state.Pop(2);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.d2l:
state.Pop(2);
state.Push(PrimativeTypes.Long);
break;
case OpCodeValue.d2f:
state.Pop(2);
state.Push(PrimativeTypes.Float);
break;
case OpCodeValue.tableswitch:
case OpCodeValue.lookupswitch:
state.Pop(1);
// the caller is responsible for patching up the state
break;
case OpCodeValue.dup_x1:
{
Type val1 = state.Pop1();
Type val2 = state.Pop1();
state.Push(val1);
state.Push(val2);
state.Push(val1);
break;
}
case OpCodeValue.bastore:
state.Pop(3);
break;
case OpCodeValue.i2b:
case OpCodeValue.i2c:
case OpCodeValue.i2s:
break;
case OpCodeValue.fmul:
case OpCodeValue.fadd:
case OpCodeValue.fsub:
case OpCodeValue.fdiv:
case OpCodeValue.frem:
state.Pop(1);
break;
case OpCodeValue.castore:
case OpCodeValue.iastore:
case OpCodeValue.fastore:
case OpCodeValue.sastore:
state.Pop(3);
break;
case OpCodeValue.lastore:
case OpCodeValue.dastore:
state.Pop(4);
break;
case OpCodeValue.dup2:
if (state.Peek() != null)
{
var value1 = state.Pop1();
var value2 = state.Pop1();
state.Push(value2);
state.Push(value1);
state.Push(value2);
state.Push(value1);
}
else
{
var value = state.Pop2();
state.Push(value);
state.Push(value);
}
break;
case OpCodeValue.dup2_x1:
if (state.Peek() != null)
{
var value1 = state.Pop1();
var value2 = state.Pop1();
var value3 = state.Pop1();
state.Push(value2);
state.Push(value1);
state.Push(value3);
state.Push(value2);
state.Push(value1);
}
else
{
var value1 = state.Pop2();
var value2 = state.Pop1();
state.Push(value1);
state.Push(value2);
state.Push(value1);
}
break;
case OpCodeValue.dup2_x2:
if (state.Peek() != null)
{
var value1 = state.Pop1();
var value2 = state.Pop1();
if (state.Peek() != null)
{
// form 1
var value3 = state.Pop1();
var value4 = state.Pop1();
state.Push(value2);
state.Push(value1);
state.Push(value4);
state.Push(value3);
state.Push(value2);
state.Push(value1);
}
else
{
// form 3
var value3 = state.Pop2();
state.Push(value2);
state.Push(value1);
state.Push(value3);
state.Push(value2);
state.Push(value1);
}
}
else
{
var value1 = state.Pop2();
if (state.Peek() != null)
{
// form 2
var value2 = state.Pop1();
var value3 = state.Pop1();
state.Push(value1);
state.Push(value3);
state.Push(value2);
state.Push(value1);
}
else
{
// form 4
var value2 = state.Pop2();
state.Push(value1);
state.Push(value2);
state.Push(value1);
}
}
break;
case OpCodeValue.dup_x2:
{
var value1 = state.Pop1();
if (state.Peek() != null)
{
// form 1
var value2 = state.Pop1();
var value3 = state.Pop1();
state.Push(value1);
state.Push(value3);
state.Push(value2);
state.Push(value1);
}
else
{
// form 2
var value2 = state.Pop2();
state.Push(value1);
state.Push(value2);
state.Push(value1);
}
}
break;
case OpCodeValue.fcmpl:
case OpCodeValue.fcmpg:
state.Pop(2);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.dcmpl:
case OpCodeValue.dcmpg:
state.Pop(4);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.swap:
{
Type value1 = state.Pop1();
Type value2 = state.Pop1();
state.Push(value1);
state.Push(value2);
break;
}
case OpCodeValue.dadd:
case OpCodeValue.dsub:
case OpCodeValue.dmul:
case OpCodeValue.ddiv:
case OpCodeValue.drem:
state.Pop(2);
break;
case OpCodeValue.ret:
MarkDead();
break;
case OpCodeValue.wide:
// must be handled by the caller.
return;
case OpCodeValue.monitorenter:
case OpCodeValue.monitorexit:
state.Pop(1);
break;
default:
throw new NotImplementedException();
}
}
private void UpdateStack2(OpCodeValue opcode, short s)
{
switch (opcode)
{
case OpCodeValue.@new:
case OpCodeValue.sipush:
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.ifnull:
case OpCodeValue.ifnonnull:
case OpCodeValue.ifeq:
case OpCodeValue.ifne:
case OpCodeValue.iflt:
case OpCodeValue.ifge:
case OpCodeValue.ifgt:
case OpCodeValue.ifle:
state.Pop(1);
break;
case OpCodeValue.if_icmpeq:
case OpCodeValue.if_icmpne:
case OpCodeValue.if_icmplt:
case OpCodeValue.if_icmpge:
case OpCodeValue.if_icmpgt:
case OpCodeValue.if_icmple:
case OpCodeValue.if_acmpeq:
case OpCodeValue.if_acmpne:
state.Pop(2);
break;
case OpCodeValue.@goto:
MarkDead();
break;
case OpCodeValue.ldc2_w:
state.Push(TypeForConstant(Manager.ConstantPool[s - 1]));
break;
case OpCodeValue.instanceof:
state.Pop(1);
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.ldc_w:
state.Push(TypeForConstant(Manager.ConstantPool[s - 1]));
break;
case OpCodeValue.jsr:
break;
case OpCodeValue.lstore:
case OpCodeValue.dstore:
state.Pop(2);
break;
case OpCodeValue.istore:
case OpCodeValue.fstore:
case OpCodeValue.astore:
state.Pop(1);
break;
default:
throw new NotImplementedException();
}
}
public UnaryMath(OpCodeValue ocv, Expression operand) : base(operand) => this
.Operation = ocv;
private void UpdateStackWide(OpCodeValue opcode, int s)
{
switch (opcode)
{
case OpCodeValue.iload:
state.Push(PrimativeTypes.Int);
break;
case OpCodeValue.lload:
state.Push(PrimativeTypes.Long);
break;
case OpCodeValue.fload:
state.Push(PrimativeTypes.Float);
break;
case OpCodeValue.dload:
state.Push(PrimativeTypes.Double);
break;
case OpCodeValue.aload:
state.Push(GetVariable(s).Type);
break;
case OpCodeValue.lstore:
case OpCodeValue.dstore:
state.Pop(2);
break;
case OpCodeValue.istore:
case OpCodeValue.fstore:
case OpCodeValue.astore:
state.Pop(1);
break;
case OpCodeValue.ret:
MarkDead();
break;
default:
throw new NotImplementedException();
}
}
internal OpCode(OpCodeValue bc, NormalizedOpCodeValues normalizedValue, OpCodeMode reg, OpCodeModeWide wide,
bool cannotThrow)
: this(bc, normalizedValue, 0, reg, wide, cannotThrow)
{
}
public void Emit(OpCodeValue opcode)
{
EnsureCapacity(1);
EmitOp(opcode);
if (!alive) return;
UpdateStack0(opcode);
PostOp();
}
public static bool InRange(this OpCode opcode, OpCodeValue start, OpCodeValue end) => ((ushort)start..(ushort)end).InRange(opcode.Value);
public void Emit(OpCodeValue opcode, byte b)
{
EnsureCapacity(2);
EmitOp(opcode);
if (!alive) return;
EmitByte(b);
UpdateStack1(opcode, b);
PostOp();
}
public CountBig(OpCodeValue code, int count) : base(code, count)
{
}
public BinaryMath(OpCodeValue ocv, Expression left, Expression right) : base(left, right) => this
.Operation = ocv;
internal OpCode(OpCodeValue value, int flags)
{
this.value = value;
this.flags = flags;
}
/// <summary>
/// Execute an asynchronous redis operation.
/// </summary>
/// <typeparam name="T">The result type</typeparam>
/// <param name="multiplexer">The connection multiplexer running the command.</param>
/// <param name="message">The message to send to redis.</param>
/// <param name="processor">The processor to handle the result.</param>
/// <param name="state">The state to use for the task.</param>
/// <param name="server">The server to call.</param>
/// <param name="callOpCode">The <see cref="OpCodeValue"/> used in the original method call.</param>
/// <returns>An asynchronous task.</returns>
private static async Task <T> ExecuteAsyncImplInternal <T>(object multiplexer, object message, object processor, object state, object server, OpCodeValue callOpCode)
{
var genericType = typeof(T);
var multiplexerType = multiplexer.GetType();
var asm = multiplexerType.Assembly;
var messageType = asm.GetType("StackExchange.Redis.Message");
var processorType = asm.GetType("StackExchange.Redis.ResultProcessor`1").MakeGenericType(genericType);
var stateType = typeof(object);
var serverType = asm.GetType("StackExchange.Redis.ServerEndPoint");
var originalMethod = Emit.DynamicMethodBuilder <Func <object, object, object, object, object, Task <T> > >
.CreateMethodCallDelegate(
multiplexerType,
methodName : "ExecuteAsyncImpl",
callOpCode,
methodParameterTypes : new[] { messageType, processorType, stateType, serverType },
methodGenericArguments : new[] { genericType });
using (var scope = CreateScope(multiplexer, message))
{
try
{
return(await originalMethod(multiplexer, message, processor, state, server).ConfigureAwait(false));
}
catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false)
{
// unreachable code
throw;
}
}
}
