protected Packet( OpCode opCode )
{
if( !Enum.IsDefined( typeof( OpCode ), OpCode ) ) {
throw new ArgumentOutOfRangeException( "opCode" );
}
OpCode = opCode;
}
/// <summary>
/// Initializes a new instance of the <see cref="StobjInstruction"/> class.
/// </summary>
/// <param name="opcode">The opcode.</param>
public StobjInstruction(OpCode opcode)
: base(opcode)
{
switch (opcode) {
case OpCode.Stind_i1:
_valueType = new SigType(CilElementType.I1);
break;
case OpCode.Stind_i2:
_valueType = new SigType(CilElementType.I2);
break;
case OpCode.Stind_i4:
_valueType = new SigType(CilElementType.I4);
break;
case OpCode.Stind_i8:
_valueType = new SigType(CilElementType.I8);
break;
case OpCode.Stind_r4:
_valueType = new SigType(CilElementType.R4);
break;
case OpCode.Stind_r8:
_valueType = new SigType(CilElementType.R8);
break;
case OpCode.Stind_i:
_valueType = new SigType(CilElementType.I);
break;
case OpCode.Stind_ref: // FIXME: Really object?
_valueType = new SigType(CilElementType.Object);
break;
default:
throw new NotImplementedException();
}
}
public void Emit_UnknownOpCode_ThrowsNotSupportedException()
{
var ilGenerator = new ILGenerator(null);
var opCode = new OpCode(-1);
ExceptionAssert.Throws<NotSupportedException>(() => ilGenerator.Emit(opCode));
}
public static void WriteCodes(BinaryWriter bw, OpCode[] ops)
{
for (int i = 0; i < ops.Length; i++)
{
bw.Write(ops[i].GetCodes());
}
}
//wicky.patch.start
static OpCodes()
{
//Start from first index to ignore nop (onebyte)
for (int i = 1; i < OneByteOpCode.Length; i++)
{
//arglist: FE 00
if (OneByteOpCode[i].Op2 == 0x00 && OneByteOpCode[i].Code != Code.Arglist)
{
OneByteOpCode[i] = new OpCode(
0xff << 0 | (byte)i << 8 | (byte)Code.Unused << 16 | (byte)FlowControl.Next << 24,
(byte)OpCodeType.Primitive << 0 | (byte)OperandType.InlineNone << 8 | (byte)StackBehaviour.Pop0 << 16 | (byte)StackBehaviour.Push0 << 24);
}
}
//Start from first index to ignore arglist (twobyte)
for (int i = 1; i < TwoBytesOpCode.Length; i++)
{
//arglist: FE 00
if (TwoBytesOpCode[i].Op2 == 0x00 && TwoBytesOpCode[i].Code != Code.Arglist)
{
TwoBytesOpCode[i] = new OpCode(
0xfe << 0 | (byte)i << 8 | (byte)Code.Unused << 16 | (byte)FlowControl.Next << 24,
(byte)OpCodeType.Primitive << 0 | (byte)OperandType.InlineNone << 8 | (byte)StackBehaviour.Pop0 << 16 | (byte)StackBehaviour.Push0 << 24);
}
}
}
public static void AddCodes(NodeBase caller, BlockBase parent, NodeBase target, OpModule codes, string op, Addr32 dest)
{
if (target is TypeOf) target = (target as TypeOf).Target;
var v = target as Variant;
if (v != null && parent.GetFunction(v.Name) == null)
{
var fpname = (target as Variant).Name;
var fpt = Types.GetType(parent, fpname);
if (fpt == null || !fpt.Check())
throw caller.Abort("undefined type: {0}", fpname);
codes.AddCodesV(op, dest, codes.GetTypeObject(fpt));
return;
}
var tt = target.Type;
var tr = tt as TypeReference;
var tts = tt.Type as TypeStruct;
if (tr != null && (tr.IsArray || (tts != null && tts.IsClass)))
{
target.AddCodesV(codes, "mov", null);
var label = new OpCode();
codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
codes.Add(I386.Jcc(Cc.Z, label.Address));
codes.Add(I386.MovRA(Reg32.EAX, Addr32.NewRO(Reg32.EAX, -16)));
codes.Add(label);
codes.AddCodes(op, dest);
}
else
codes.AddCodesV(op, dest, codes.GetTypeObject(tt));
}
static bool IsCall(OpCode opCode)
{
return opCode == OpCodes.Call ||
opCode == OpCodes.Callvirt ||
opCode == OpCodes.Calli ||
opCode == OpCodes.Ldftn;
}
public BinaryOperation(string sOp, Expression x, Expression y)
{
operation = sOp;
opcode = StringToOpCode(sOp);
operand1 = x;
operand2 = y;
}
public Instruction(byte[] code, int offset, int length, OpCode oc, TokenResolver resolver)
{
this.code = code;
this.offset = offset;
this.length = length;
this.oc = oc;
this.resolver = resolver;
}
static void AssertOpCodeSequence(OpCode [] expected, MethodBody body)
{
var opcodes = body.Instructions.Select (i => i.OpCode).ToArray ();
Assert.AreEqual (expected.Length, opcodes.Length);
for (int i = 0; i < opcodes.Length; i++)
Assert.AreEqual (expected [i], opcodes [i]);
}
public CompiledByte(OpCode op, Value a, Value b)
{
ushort[] output = compile(op,a,b);
for (int i = 0; i < output.Length; i++)
{
;
}
}
public Instruction(OpCode opcode, int index, params Operand[] operands)
{
OpCode = opcode;
Operands = operands;
Index = index;
}
public void Add(Token token, OpCode op, string stringValue, params int[] args)
{
List<int> nums = new List<int>(args);
nums.Insert(0, (int)op);
this.byteCode.Add(nums.ToArray());
this.tokens.Add(token);
this.stringArgs.Add(stringValue);
}
private void AddJump(OpCode jumpOp, string jumpLabel)
{
// add the jump and a blank space for the destination
mBytecode.Write(jumpOp, 0);
// patch the destination later
mJumpPatches.Add(new JumpPatch(jumpLabel, mBytecode.Position - 4));
}
private void AddJumpBack(OpCode jumpOp, string jumpLabel)
{
// pop the most recently-added jump with the label
JumpPatch jump = mJumpBackPatches.Last(j => j.Label == jumpLabel);
mJumpBackPatches.Remove(jump);
mBytecode.Write(jumpOp, jump.Location);
}
public ScriptElement(OpCode opCode, Byte[] data = null)
{
this.opCode = opCode;
this.data = data;
if (opCode == OpCode.OP_0)
this.data = new ScriptVarInt(0).ToBytes();
else if (opCode == OpCode.OP_1NEGATE || (OpCode.OP_1 <= opCode && opCode <= OpCode.OP_16))
this.data = new ScriptVarInt((int)opCode - ((int)OpCode.OP_1 - 1)).ToBytes();
}
private BranchSet(OpCode brTrue, OpCode brFalse, OpCode brEq, OpCode brNe, OpCode brLt, OpCode brLtUn, OpCode brGt, OpCode brGtUn, OpCode brLe, OpCode brLeUn, OpCode brGe, OpCode brGeUn)
{
BrTrue = brTrue; BrFalse = brFalse;
BrEq = brEq; BrNe = brNe;
BrLt = brLt; BrLtUn = brLtUn;
BrGt = brGt; BrGtUn = brGtUn;
BrLe = brLe; BrLeUn = brLeUn;
BrGe = brGe; BrGeUn = brGeUn;
}
/// <summary>
/// Adds a binary operator.
/// </summary>
/// <param name="operator">The operator's operation code.</param>
/// <param name="supportedTypes">The supported types on both sides of the operator.</param>
/// <param name="func">The logic to perform this operator.</param>
/// <param name="order">The order the left/right values may appear in.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <see cref="supportedTypes" /> or <see cref="func" /> is null.</exception>
public void AddBinaryOperator(OpCode @operator, Type[] supportedTypes,
Func<EarleValue, EarleValue, EarleValue> func,
EarleOperatorParamOrder order = EarleOperatorParamOrder.Normal)
{
if (supportedTypes == null) throw new ArgumentNullException(nameof(supportedTypes));
if (func == null) throw new ArgumentNullException(nameof(func));
AddBinaryOperator(@operator, supportedTypes, supportedTypes, func, order);
}
internal void Emit(ILGenerator ilgen, OpCode opcode)
{
if (local == null)
{
// it's a temporary local that is only allocated on-demand
local = ilgen.DeclareLocal(type);
}
ilgen.Emit(opcode, local);
}
/// <summary>
/// Initializes a new instance of the <see cref="LdobjInstruction"/> class.
/// </summary>
/// <param name="opcode">The opcode.</param>
public LdobjInstruction(OpCode opcode)
: base(opcode, 1)
{
switch (opcode)
{
case OpCode.Ldind_i1:
typeRef = BuiltInSigType.SByte;
break;
case OpCode.Ldind_i2:
typeRef = BuiltInSigType.Int16;
break;
case OpCode.Ldind_i4:
typeRef = BuiltInSigType.Int32;
break;
case OpCode.Ldind_i8:
typeRef = BuiltInSigType.Int64;
break;
case OpCode.Ldind_u1:
typeRef = BuiltInSigType.Byte;
break;
case OpCode.Ldind_u2:
typeRef = BuiltInSigType.UInt16;
break;
case OpCode.Ldind_u4:
typeRef = BuiltInSigType.UInt32;
break;
case OpCode.Ldind_i:
typeRef = BuiltInSigType.IntPtr;
break;
case OpCode.Ldind_r4:
typeRef = BuiltInSigType.Single;
break;
case OpCode.Ldind_r8:
typeRef = BuiltInSigType.Double;
break;
case OpCode.Ldind_ref: // FIXME: Really object?
typeRef = BuiltInSigType.Object;
break;
case OpCode.Ldobj: // FIXME
typeRef = null; // BuiltInSigType.Object;
break;
default:
throw new NotImplementedException();
}
}
public bool isTwoByte(OpCode code)
{
OpCode[] twobytes = { OpCode.ADDR, OpCode.CLEAR, OpCode.COMPR, OpCode.DIVR,
OpCode.MULR, OpCode.RMO, OpCode.SUBR, OpCode.TIXR,
OpCode.SHIFTL, OpCode.SHIFTR };
if (twobytes.Contains<OpCode>(code))
return true;
else
return false;
}
public int ReadFrom(byte[] buffer, int offset)
{
Immediate = (buffer[offset] & 0x40) != 0;
OpCode = (OpCode)(buffer[offset] & 0x3F);
FinalPdu = (buffer[offset + 1] & 0x80) != 0;
TotalAhsLength = buffer[offset + 4];
DataSegmentLength = Utilities.ToInt32BigEndian(buffer, offset + 4) & 0x00FFFFFF;
InitiatorTaskTag = Utilities.ToUInt32BigEndian(buffer, offset + 16);
return 48;
}
public Instruction(OpCode opcode, object[] arguments)
{
this.opcode = opcode;
this.arguments = arguments;
this.size = -1;
this.position = null;
if(this.arguments == null)
this.arguments = EmptyArguments;
}
private Instruction GetInstruction(Expression exp, OpCode code)
{
Instruction inst;
if (_indexedInsts.TryGetValue(exp, out inst))
return inst;
inst = new Instruction(code);
_indexedInsts.Add(exp, inst);
_insts.Add(inst);
return inst;
}
public BinaryFragmentationFrame(OpCode opCode, byte[] data, int offset, int count, bool isFin = false, bool isMasked = true)
{
BufferValidator.ValidateBuffer(data, offset, count, "data");
_opCode = opCode;
this.Data = data;
this.Offset = offset;
this.Count = count;
this.IsFin = isFin;
this.IsMasked = isMasked;
}
public Statement(string rawLine)
{
string[] pieces = Helpers.SplitWrtQuotes(rawLine);
Op = (OpCode)Enum.Parse(typeof(OpCode), pieces[0]);
for (int i = 1; i < pieces.Length; ++i)
{
Vars.Add(new Variable(pieces[i]));
}
}
public Instruction(OpCode opc, int A, int B, int C, int sBx, uint Bx, int line, int col, string filename)
{
OpCode = opc;
this.A = (byte)A;
this.B = (byte)B;
this.C = (byte)C;
this.sBx = (short)sBx;
this.Bx = (ushort)Bx;
this.line = line;
this.col = col;
this.filename = filename;
}
/// <summary>
/// Initializes a new instance of the <see cref="LdelemInstruction"/> class.
/// </summary>
/// <param name="opcode">The opcode.</param>
public LdelemInstruction(OpCode opcode)
: base(opcode, 1)
{
switch (opcode)
{
case OpCode.Ldelem_i1:
elementType = BuiltInSigType.SByte;
break;
case OpCode.Ldelem_i2:
elementType = BuiltInSigType.Int16;
break;
case OpCode.Ldelem_i4:
elementType = BuiltInSigType.Int32;
break;
case OpCode.Ldelem_i8:
elementType = BuiltInSigType.Int64;
break;
case OpCode.Ldelem_u1:
elementType = BuiltInSigType.Byte;
break;
case OpCode.Ldelem_u2:
elementType = BuiltInSigType.UInt16;
break;
case OpCode.Ldelem_u4:
elementType = BuiltInSigType.UInt32;
break;
case OpCode.Ldelem_i:
elementType = BuiltInSigType.IntPtr;
break;
case OpCode.Ldelem_r4:
elementType = BuiltInSigType.Single;
break;
case OpCode.Ldelem_r8:
elementType = BuiltInSigType.Double;
break;
case OpCode.Ldelem_ref: // FIXME: Really object?
elementType = BuiltInSigType.Object;
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Adds a binary operator.
/// </summary>
/// <param name="operator">The operator's operation code.</param>
/// <param name="supportedLeftTypes">The supported types on the left side of the operator.</param>
/// <param name="supportedRightTypes">The supported types on the right side of the operator.</param>
/// <param name="func">The logic to perform this operator.</param>
/// <param name="order">The order the left/right values may appear in.</param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <see cref="supportedLeftTypes" />,
/// <see cref="supportedRightTypes" /> or <see cref="func" /> is null.
/// </exception>
public void AddBinaryOperator(OpCode @operator, Type[] supportedLeftTypes, Type[] supportedRightTypes,
Func<EarleValue, EarleValue, EarleValue> func,
EarleOperatorParamOrder order = EarleOperatorParamOrder.Normal)
{
if (supportedLeftTypes == null) throw new ArgumentNullException(nameof(supportedLeftTypes));
if (supportedRightTypes == null) throw new ArgumentNullException(nameof(supportedRightTypes));
if (func == null) throw new ArgumentNullException(nameof(func));
foreach (var left in supportedLeftTypes)
foreach (var right in supportedRightTypes)
AddBinaryOperator(@operator, left, right, func, order);
}
public ScriptElement(Byte[] data)
{
this.data = data;
if (0x01 <= data.Length && data.Length <= 0x4b)
this.opCode = (OpCode)data.Length;
else if (data.Length <= Byte.MaxValue)
this.opCode = OpCode.OP_PUSHDATA1;
else if (data.Length <= UInt16.MaxValue)
this.opCode = OpCode.OP_PUSHDATA2;
else
this.opCode = OpCode.OP_PUSHDATA4;
}
internal ILInstruction(int offset, OpCode opCode)
{
Offset = offset;
OpCode = opCode;
}
public CodeMatcher InsertBranchAndAdvance(OpCode opcode, int destination)
{
InsertBranch(opcode, destination);
Pos++;
return(this);
}
/// <summary>
/// Disassembles one instruction
/// </summary>
/// <param name="in_address">Memory address for disassembly start</param>
/// <returns>Disassembled instruction</returns>
public Z80DisassemblerInstruction Disassemble(ushort in_address)
{
OpCode opcode = null;
Z80DisassemblerInstruction dissassembled_instruction = new Z80DisassemblerInstruction();
dissassembled_instruction.Address = in_address;
dissassembled_instruction.NumericOperand = 0;
ushort start_address = in_address;
bool have_displacement = false;
byte displacement = 0;
ushort jump_address = 0;
bool have_jump_address = false;
have_displacement = false;
displacement = 0;
byte opc = ReadByte(in_address++);
switch (opc)
{
case 0xDD:
case 0xFD:
byte next = ReadByte(in_address++);
if ((next | 0x20) == 0xFD || next == 0xED)
{
dissassembled_instruction.Asm = "NOP*";
dissassembled_instruction.TStates = 4;
dissassembled_instruction.TStates2 = 0;
opcode = null;
}
else if (next == 0xCB)
{
displacement = ReadByte(in_address++);
next = ReadByte(in_address++);
opcode = (opc == 0xDD) ? dasm_ddcb[next] : dasm_fdcb[next];
have_displacement = true;
}
else
{
opcode = (opc == 0xDD) ? dasm_dd[next] : dasm_fd[next];
if (opcode.Mnemonic == null) //mirrored instructions
{
opcode = dasm_base[next];
dissassembled_instruction.TStates = 4;
dissassembled_instruction.TStates2 = 4;
}
}
break;
case 0xED:
next = ReadByte(in_address++);
opcode = dasm_ed[next];
if (opcode.Mnemonic == null)
{
dissassembled_instruction.Asm = "NOP*";
dissassembled_instruction.TStates = 8;
opcode = null;
}
break;
case 0xCB:
next = ReadByte(in_address++);
opcode = dasm_cb[next];
break;
default:
opcode = dasm_base[opc];
break;
}
if (opcode != null)
{
dissassembled_instruction.OpCode = opcode;
byte operand_index = 1;
var sb = new StringBuilder();
foreach (var ch in opcode.Mnemonic)
{
switch (ch)
{
case '@':
{
var lo = ReadByte(in_address++);
var hi = ReadByte(in_address++);
ushort val = (ushort)(lo + hi * 0x100);
if ((opcode.Flags & (OpCodeFlags.RefAddr | OpCodeFlags.Jumps)) != 0)
{
sb.Append(FormatAddr(val));
}
else
{
sb.Append(FormatWord(val));
}
dissassembled_instruction.WordVal = val;
jump_address = val;
have_jump_address = true;
dissassembled_instruction.NumericOperand = operand_index;
break;
}
case '$':
case '%':
{
if (!have_displacement)
{
displacement = ReadByte(in_address++);
}
var disp = (displacement & 0x80) != 0 ? -(((~displacement) & 0x7f) + 1) : displacement;
if (ShowRelativeOffsets)
{
if (disp > 0)
{
dissassembled_instruction.Comment = string.Format("+{0}", disp);
}
else
{
dissassembled_instruction.Comment = string.Format("{0}", disp);
}
}
if (ch == '$')
{
if ((sbyte)disp < 0 && sb[sb.Length - 1] == '+')
{
sb.Length--;
}
sb.Append(FormatSignedByte((sbyte)disp));
}
else
{
jump_address = (ushort)(in_address + disp);
have_jump_address = true;
sb.Append(FormatAddr(jump_address));
}
dissassembled_instruction.NumericOperand = operand_index;
break;
}
case '#':
{
var lo = ReadByte(in_address++);
sb.Append(FormatByte(lo));
if (lo >= 0x20 && lo <= 0x7f)
{
dissassembled_instruction.Comment = string.Format("'{0}'", (char)lo);
}
dissassembled_instruction.ByteVal = lo;
dissassembled_instruction.NumericOperand = operand_index;
break;
}
default:
if (ch == ',')
{
operand_index++;
}
sb.Append(ch);
break;
}
}
dissassembled_instruction.Asm = sb.ToString();
dissassembled_instruction.TStates += opcode.TStates;
dissassembled_instruction.TStates2 += opcode.TStates2;
// Return continue address
if ((opcode.Flags & OpCodeFlags.Continues) != 0)
{
dissassembled_instruction.NextAddress1 = in_address;
}
// Return jump target address (if have it)
if ((opcode.Flags & OpCodeFlags.Jumps) != 0 && have_jump_address)
{
dissassembled_instruction.NextAaddress2 = jump_address;
}
}
else
{
dissassembled_instruction.NextAddress1 = in_address;
}
if (dissassembled_instruction.TStates == dissassembled_instruction.TStates2)
{
dissassembled_instruction.TStates2 = 0;
}
dissassembled_instruction.Length = (ushort)(in_address - start_address);
return(dissassembled_instruction);
}
internal static void SET_OPCODE(ref Instruction i, OpCode opcode)
{
i = (Instruction)(i & MASK0(SIZE_OP, POS_OP)) | (((uint)opcode << POS_OP) & MASK1(SIZE_OP, POS_OP));
}
internal static int CREATE_ABx(OpCode o, int a, int bc)
{
int result = (int)(((int)o << POS_OP) | (a << POS_A) | (bc << POS_Bx));
return((int)(((int)o << POS_OP) | (a << POS_A) | (bc << POS_Bx)));
}
public static int testTMode(OpCode m)
{
return(luaP_opmodes[(int)m] & (1 << 7));
}
public static OpArgMask getCMode(OpCode m)
{
return((OpArgMask)((luaP_opmodes[(int)m] >> 2) & 3));
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryBranchInstruction"/> class.
/// </summary>
/// <param name="opcode">The opcode.</param>
public UnaryBranchInstruction(OpCode opcode)
: base(opcode)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RefanyvalInstruction"/> class.
/// </summary>
/// <param name="opcode">The opcode.</param>
public RefanyvalInstruction(OpCode opcode)
: base(opcode)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ArglistInstruction"/> class.
/// </summary>
/// <param name="opcode">The opcode.</param>
public ArglistInstruction(OpCode opcode) : base(opcode)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BreakInstruction"/> class.
/// </summary>
/// <param name="opcode">The opcode.</param>
public BreakInstruction(OpCode opcode)
: base(opcode, 0)
{
}
public static DumpInfo GetInfo(this OpCode op, bool simplify = false)
{
return(new DumpInfo(op, simplify));
}
public CodeMatcher InsertBranch(OpCode opcode, int destination)
{
CreateLabelAt(destination, out var label);
codes.Insert(Pos, new CodeInstruction(opcode, label));
return(this);
}
internal InlineI8Instruction(int offset, OpCode opCode, long value)
: base(offset, opCode)
{
Value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="LdstrInstruction"/> class.
/// </summary>
/// <param name="opCode">The op code.</param>
public LdstrInstruction(OpCode opCode)
: base(opCode)
{
return;
}
protected ZeroParamOp(string aText, OpCode aOpCode) : base(aText)
{
mOpCode = aOpCode;
}
private bool VerificationHelper(OpCode code,
string name,
StackBehaviour pop,
StackBehaviour push,
OperandType oprandType,
OpCodeType type,
int size,
byte s1,
byte s2,
FlowControl ctrl,
string errorno,
string errordesp)
{
bool retVal = true;
string actualName = code.Name;
if (actualName != name)
{
TestLibrary.TestFramework.LogError(errorno + ".0", "Name returns wrong value for OpCode " + errordesp);
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actualName = " + actualName + ", name = " + name);
retVal = false;
}
StackBehaviour actualPop = code.StackBehaviourPop;
if (actualPop != pop)
{
TestLibrary.TestFramework.LogError(errorno + ".1", "StackBehaviourPop returns wrong value for OpCode " + errordesp);
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actualPop = " + actualPop + ", pop = " + pop);
retVal = false;
}
StackBehaviour actualPush = code.StackBehaviourPush;
if (actualPush != push)
{
TestLibrary.TestFramework.LogError(errorno + ".2", "StackBehaviourPush returns wrong value for OpCode " + errordesp);
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actualPush = " + actualPush + ", push = " + push);
retVal = false;
}
OperandType actualOperandType = code.OperandType;
if (actualOperandType != oprandType)
{
TestLibrary.TestFramework.LogError(errorno + ".3", "OperandType returns wrong value for OpCode " + errordesp);
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actualOperandType = " + actualOperandType + ", oprandType = " + oprandType);
retVal = false;
}
OpCodeType actualOpCodeType = code.OpCodeType;
if (actualOpCodeType != type)
{
TestLibrary.TestFramework.LogError(errorno + ".4", "OpCodeType returns wrong value for OpCode " + errordesp);
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actualOpCodeType = " + actualOpCodeType + ", type = " + type);
retVal = false;
}
int actualSize = code.Size;
if (actualSize != size)
{
TestLibrary.TestFramework.LogError(errorno + ".5", "Size returns wrong value for OpCode " + errordesp);
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actualSize = " + actualSize + ", size = " + size);
retVal = false;
}
short expectedValue = 0;
if (size == 2)
{
expectedValue = (short)(s1 << 8 | s2);
}
else
{
expectedValue = (short)s2;
}
short actualValue = code.Value;
if (actualValue != expectedValue)
{
TestLibrary.TestFramework.LogError(errorno + ".6", "Value returns wrong value for OpCode " + errordesp);
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actualValue = " + actualValue + ", s1 = " + s1 + ", s2 = " + s2 + ", expectedValue = " + expectedValue);
retVal = false;
}
FlowControl actualCtrl = code.FlowControl;
if (actualCtrl != ctrl)
{
TestLibrary.TestFramework.LogError(errorno + ".7", "FlowControl returns wrong value for OpCode " + errordesp);
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actualCtrl = " + actualCtrl + ", ctrl = " + ctrl);
retVal = false;
}
return(retVal);
}
record Instruction(OpCode OpCode, ParameterMode[] ParameterModes)
{
public static OpMode getOpMode(OpCode m)
{
return((OpMode)(luaP_opmodes[(int)m] & 3));
}
private Operator(bool isLogical, OpCode opCode, OpCode opCodeUn, OpCode opCodeChk, OpCode opCodeChkUn, bool invertOpResult, BranchInstruction branchOp, string methodName, IMemberInfo[] standardCandidates, SpecificOperatorProvider[] standardTemplates)
{
OpCode = opCode;
OpCodeUn = opCodeUn;
OpCodeChk = opCodeChk;
OpCodeChkUn = opCodeChkUn;
InvertOpResult = invertOpResult;
BranchOp = branchOp;
MethodName = methodName;
_standardCandidates = standardCandidates ?? new IMemberInfo[0];
_standardTemplates = standardTemplates;
IsLogical = isLogical;
}
internal static int CREATE_ABC(OpCode o, int a, int b, int c)
{
return((int)(((int)o << POS_OP) | (a << POS_A) | (b << POS_B) | (c << POS_C)));
}
private void ValidateJump(LabelScopeInfo reference)
{
// Assume we can do a ret/branch
_opCode = _canReturn ? OpCodes.Ret : OpCodes.Br;
// look for a simple jump out
for (LabelScopeInfo j = reference; j != null; j = j.Parent)
{
if (_definitions.Contains(j))
{
// found it, jump is valid!
return;
}
if (j.Kind == LabelScopeKind.Finally ||
j.Kind == LabelScopeKind.Filter)
{
break;
}
if (j.Kind == LabelScopeKind.Try ||
j.Kind == LabelScopeKind.Catch)
{
_opCode = OpCodes.Leave;
}
}
_acrossBlockJump = true;
if (_node != null && _node.Type != typeof(void))
{
throw Error.NonLocalJumpWithValue(_node.Name);
}
if (_definitions.Count > 1)
{
throw Error.AmbiguousJump(_node.Name);
}
// We didn't find an outward jump. Look for a jump across blocks
LabelScopeInfo def = _definitions.First();
LabelScopeInfo common = Helpers.CommonNode(def, reference, b => b.Parent);
// Assume we can do a ret/branch
_opCode = _canReturn ? OpCodes.Ret : OpCodes.Br;
// Validate that we aren't jumping across a finally
for (LabelScopeInfo j = reference; j != common; j = j.Parent)
{
if (j.Kind == LabelScopeKind.Finally)
{
throw Error.ControlCannotLeaveFinally();
}
if (j.Kind == LabelScopeKind.Filter)
{
throw Error.ControlCannotLeaveFilterTest();
}
if (j.Kind == LabelScopeKind.Try ||
j.Kind == LabelScopeKind.Catch)
{
_opCode = OpCodes.Leave;
}
}
// Valdiate that we aren't jumping into a catch or an expression
for (LabelScopeInfo j = def; j != common; j = j.Parent)
{
if (!j.CanJumpInto)
{
if (j.Kind == LabelScopeKind.Expression)
{
throw Error.ControlCannotEnterExpression();
}
else
{
throw Error.ControlCannotEnterTry();
}
}
}
}
internal static void SET_OPCODE(InstructionPtr i, OpCode opcode)
{
SET_OPCODE(ref i.codes[i.pc], opcode);
}
public CompilerInstruction(OpCode inOperation, int?inArg = null)
{
Operation = inOperation;
IntArg = inArg;
}
static ILPattern Field(OpCode opcode)
{
return(new FieldPattern(ILPattern.OpCode(opcode)));
}
/// <summary>Creates a new CodeInstruction with a given opcode and optional operand</summary>
/// <param name="opcode">The code</param>
/// <param name="operand">The operand</param>
///
public CodeInstruction(OpCode opcode, object operand = null)
{
this.opcode = opcode;
this.operand = operand;
}
private static void ResolveField(FieldInfo field, List <FieldBuilder> fields, ILGenerator generator, OpCode code)
{
foreach (var newField in fields)
{
if (newField.DeclaringType.Name == field.DeclaringType.Name && newField.Name == field.Name)
{
// We found a replacement field reference
generator.Emit(code, newField);
return;
}
}
// Generate the exact field reference
generator.Emit(code, field);
}
private static void SetValueOfRefProperty <T>(PropertyInfo p, object instance, Type targetType, Type funcType, OpCode stCode, T value)
{
var getter = p.GetGetMethod();
var name = $"TempSetter{getter.Name}";
var dm = new DynamicMethod(
name,
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard,
typeof(void),
new[] { targetType, typeof(T) },
targetType, true);
var ilg = dm.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Call, getter);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(stCode);
ilg.Emit(OpCodes.Ret);
var del = dm.CreateDelegate(funcType);
del.DynamicInvoke(instance, value);
}
public CodeMatcher SetOpcodeAndAdvance(OpCode opcode)
{
Opcode = opcode;
Pos++;
return(this);
}
ILInstruction Next()
{
Int32 offset = m_position;
OpCode opCode = OpCodes.Nop;
Int32 token = 0;
// read first 1 or 2 bytes as opCode
Byte code = ReadByte();
if (code != 0xFE)
{
opCode = s_OneByteOpCodes[code];
}
else
{
code = ReadByte();
opCode = s_TwoByteOpCodes[code];
}
switch (opCode.OperandType)
{
case OperandType.InlineNone:
return(new InlineNoneInstruction(offset, opCode));
//The operand is an 8-bit integer branch target.
case OperandType.ShortInlineBrTarget:
SByte shortDelta = ReadSByte();
return(new ShortInlineBrTargetInstruction(offset, opCode, shortDelta));
//The operand is a 32-bit integer branch target.
case OperandType.InlineBrTarget:
Int32 delta = ReadInt32();
return(new InlineBrTargetInstruction(offset, opCode, delta));
//The operand is an 8-bit integer: 001F ldc.i4.s, FE12 unaligned.
case OperandType.ShortInlineI:
SByte int8 = ReadSByte();
return(new ShortInlineIInstruction(offset, opCode, int8));
//The operand is a 32-bit integer.
case OperandType.InlineI:
Int32 int32 = ReadInt32();
return(new InlineIInstruction(offset, opCode, int32));
//The operand is a 64-bit integer.
case OperandType.InlineI8:
Int64 int64 = ReadInt64();
return(new InlineI8Instruction(offset, opCode, int64));
//The operand is a 32-bit IEEE floating point number.
case OperandType.ShortInlineR:
Single float32 = ReadSingle();
return(new ShortInlineRInstruction(offset, opCode, float32));
//The operand is a 64-bit IEEE floating point number.
case OperandType.InlineR:
Double float64 = ReadDouble();
return(new InlineRInstruction(offset, opCode, float64));
//The operand is an 8-bit integer containing the ordinal of a local variable or an argument
case OperandType.ShortInlineVar:
Byte index8 = ReadByte();
return(new ShortInlineVarInstruction(offset, opCode, index8));
//The operand is 16-bit integer containing the ordinal of a local variable or an argument.
case OperandType.InlineVar:
UInt16 index16 = ReadUInt16();
return(new InlineVarInstruction(offset, opCode, index16));
//The operand is a 32-bit metadata string token.
case OperandType.InlineString:
token = ReadInt32();
return(new InlineStringInstruction(offset, opCode, token, m_resolver));
//The operand is a 32-bit metadata signature token.
case OperandType.InlineSig:
token = ReadInt32();
return(new InlineSigInstruction(offset, opCode, token, m_resolver));
//The operand is a 32-bit metadata token.
case OperandType.InlineMethod:
token = ReadInt32();
return(new InlineMethodInstruction(offset, opCode, token, m_resolver));
//The operand is a 32-bit metadata token.
case OperandType.InlineField:
token = ReadInt32();
return(new InlineFieldInstruction(m_resolver, offset, opCode, token));
//The operand is a 32-bit metadata token.
case OperandType.InlineType:
token = ReadInt32();
return(new InlineTypeInstruction(offset, opCode, token, m_resolver));
//The operand is a FieldRef, MethodRef, or TypeRef token.
case OperandType.InlineTok:
token = ReadInt32();
return(new InlineTokInstruction(offset, opCode, token, m_resolver));
//The operand is the 32-bit integer argument to a switch instruction.
case OperandType.InlineSwitch:
Int32 cases = ReadInt32();
Int32[] deltas = new Int32[cases];
for (Int32 i = 0; i < cases; i++)
{
deltas[i] = ReadInt32();
}
return(new InlineSwitchInstruction(offset, opCode, deltas));
default:
throw new BadImageFormatException("unexpected OperandType " + opCode.OperandType);
}
}
