#pragma once
|
|
#include "TemporaryMemoryArena.h"
|
|
#include "../metadata/Image.h"
|
#include "../interpreter/Instruction.h"
|
#include "../interpreter/Engine.h"
|
#include "../metadata/MetadataUtil.h"
|
#include "../metadata/Opcodes.h"
|
#include "../metadata/MetadataModule.h"
|
#include "../interpreter/Instruction.h"
|
#include "../interpreter/Interpreter.h"
|
#include "../interpreter/InterpreterModule.h"
|
|
#include "Transform.h"
|
|
namespace hybridclr
|
{
|
namespace transform
|
{
|
using namespace hybridclr::metadata;
|
using namespace hybridclr::interpreter;
|
|
struct IRBasicBlock
|
{
|
bool visited;
|
bool inPending;
|
uint32_t ilOffset;
|
uint32_t codeOffset;
|
std::vector<interpreter::IRCommon*> insts;
|
};
|
|
struct ArgVarInfo
|
{
|
const Il2CppType* type;
|
Il2CppClass* klass;
|
int32_t argOffset; // StackObject index
|
int32_t argLocOffset;
|
};
|
|
struct LocVarInfo
|
{
|
const Il2CppType* type;
|
Il2CppClass* klass;
|
int32_t locOffset;
|
};
|
|
enum class EvalStackReduceDataType
|
{
|
I4,
|
I8,
|
R4,
|
R8,
|
Other,
|
};
|
|
struct EvalStackVarInfo
|
{
|
EvalStackReduceDataType reduceType;
|
int32_t byteSize;
|
int32_t locOffset;
|
};
|
|
#if HYBRIDCLR_ARCH_64
|
#define NATIVE_INT_OP opI8
|
constexpr EvalStackReduceDataType NATIVE_INT_REDUCE_TYPE = EvalStackReduceDataType::I8;
|
#else
|
#define NATIVE_INT_OP opI4
|
constexpr EvalStackReduceDataType NATIVE_INT_REDUCE_TYPE = EvalStackReduceDataType::I4;
|
#endif
|
|
#define CreateIR(varName, typeName) IR##typeName* varName = pool.AllocIR<IR##typeName>(); varName->type = HiOpcodeEnum::typeName;
|
#define CreateAddIR(varName, typeName) IR##typeName* varName = pool.AllocIR<IR##typeName>(); varName->type = HiOpcodeEnum::typeName; curbb->insts.push_back(varName);
|
|
enum class LocationDescType
|
{
|
I1,
|
U1,
|
I2,
|
U2,
|
I4,
|
I8,
|
Ref,
|
S,
|
StructContainsRef,
|
};
|
|
#if HYBRIDCLR_ARCH_64
|
#define NATIVE_INT_DESC_TYPE LocationDescType::I8
|
#else
|
#define NATIVE_INT_DESC_TYPE LocationDescType::I4
|
#endif
|
|
struct LocationDescInfo
|
{
|
LocationDescType type;
|
int32_t size;
|
};
|
|
|
|
struct FlowInfo
|
{
|
uint32_t curStackSize;
|
uint32_t offset;
|
std::vector<EvalStackVarInfo> evalStack;
|
};
|
|
const int32_t MAX_STACK_SIZE = (2 << 16) - 1;
|
const int32_t MAX_VALUE_TYPE_SIZE = (2 << 16) - 1;
|
|
EvalStackReduceDataType GetEvalStackReduceDataType(const Il2CppType* type);
|
int32_t GetSizeByReduceType(EvalStackReduceDataType type);
|
|
template<typename T>
|
void AllocResolvedData(std::vector<uint64_t>& resolvedDatas, int32_t size, int32_t& index, T*& buf)
|
{
|
if (size > 0)
|
{
|
int32_t oldSize = index = (int32_t)resolvedDatas.size();
|
resolvedDatas.resize(oldSize + size);
|
buf = (T*)&resolvedDatas[oldSize];
|
}
|
else
|
{
|
index = 0;
|
buf = nullptr;
|
}
|
}
|
|
inline IRCommon* CreateInitLocals(TemporaryMemoryArena& pool, uint32_t size)
|
{
|
CreateIR(ir, InitLocals_n_4);
|
ir->size = size;
|
return ir;
|
}
|
|
IRCommon* CreateLoadExpandDataToStackVarVar(TemporaryMemoryArena& pool, int32_t dstOffset, int32_t srcOffset, const Il2CppType* type, int32_t size);
|
IRCommon* CreateAssignVarVar(TemporaryMemoryArena& pool, int32_t dstOffset, int32_t srcOffset, int32_t size);
|
LocationDescInfo ComputValueTypeDescInfo(int32_t size);
|
|
LocationDescInfo ComputLocationDescInfo(const Il2CppType* type);
|
interpreter::IRCommon* CreateClassLdfld(TemporaryMemoryArena& pool, int32_t dstIdx, int32_t objIdx, const FieldInfo* fieldInfo);
|
|
interpreter::IRCommon* CreateValueTypeLdfld(TemporaryMemoryArena& pool, int32_t dstIdx, int32_t objIdx, const FieldInfo* fieldInfo);
|
interpreter::IRCommon* CreateStfld(TemporaryMemoryArena& pool, int32_t objIdx, const FieldInfo* fieldInfo, int32_t dataIdx);
|
|
interpreter::IRCommon* CreateLdsfld(TemporaryMemoryArena& pool, int32_t dstIdx, const FieldInfo* fieldInfo, uint32_t parent);
|
interpreter::IRCommon* CreateStsfld(TemporaryMemoryArena& pool, const FieldInfo* fieldInfo, uint32_t parent, int32_t dataIdx);
|
interpreter::IRCommon* CreateLdthreadlocal(TemporaryMemoryArena& pool, int32_t dstIdx, const FieldInfo* fieldInfo, uint32_t parent);
|
interpreter::IRCommon* CreateStthreadlocal(TemporaryMemoryArena& pool, const FieldInfo* fieldInfo, uint32_t parent, int32_t dataIdx);
|
|
HiOpcodeEnum CalcGetMdArrElementVarVarOpcode(const Il2CppType* type);
|
|
struct TransformContext
|
{
|
metadata::Image* image;
|
const MethodInfo* methodInfo;
|
metadata::MethodBody& body;
|
|
const Il2CppGenericContext* genericContext;
|
const Il2CppGenericContainer* klassContainer;
|
const Il2CppGenericContainer* methodContainer;
|
int32_t actualParamCount;
|
|
TemporaryMemoryArena& pool;
|
const std::set<uint32_t>& splitOffsets;
|
IRBasicBlock*& curbb;
|
IRBasicBlock** ip2bb;
|
|
ArgVarInfo* args;
|
LocVarInfo* locals;
|
EvalStackVarInfo* evalStack;
|
int32_t evalStackBaseOffset;
|
std::vector<uint64_t>& resolveDatas;
|
Il2CppHashMap<uint32_t, uint32_t, il2cpp::utils::PassThroughHash<uint32_t>>& token2DataIdxs;
|
Il2CppHashMap<const void*, uint32_t, il2cpp::utils::PassThroughHash<const void*>>& ptr2DataIdxs;
|
std::vector<int32_t*>& relocationOffsets;
|
std::vector<std::pair<int32_t, int32_t>>& switchOffsetsInResolveData;
|
std::vector<FlowInfo*>& pendingFlows;
|
int32_t& nextFlowIdx;
|
|
int32_t& maxStackSize;
|
int32_t& curStackSize;
|
const byte* ipBase;
|
const byte*& ip;
|
int32_t& evalStackTop;
|
|
int32_t& prefixFlags;
|
uint32_t& argIdx;
|
int32_t& varKst;
|
int64_t& varKst8;
|
int32_t& brOffset;
|
|
const MethodInfo*& shareMethod;
|
|
static void InitializeInstinctHandlers();
|
|
uint32_t GetOrAddResolveDataIndex(const void* ptr)
|
{
|
auto it = ptr2DataIdxs.find(ptr);
|
if (it != ptr2DataIdxs.end())
|
{
|
return it->second;
|
}
|
else
|
{
|
uint32_t newIndex = (uint32_t)resolveDatas.size();
|
resolveDatas.push_back((uint64_t)ptr);
|
ptr2DataIdxs.insert({ ptr, newIndex });
|
return newIndex;
|
}
|
}
|
|
int32_t GetArgOffset(int32_t idx)
|
{
|
return args[idx].argOffset;
|
}
|
|
int32_t GetArgLocOffset(int32_t idx)
|
{
|
return args[idx].argLocOffset;
|
}
|
|
int32_t GetLocOffset(int32_t idx)
|
{
|
return locals[idx].locOffset;
|
}
|
|
int32_t GetEvalStackOffset(int32_t idx)
|
{
|
return idx < evalStackTop ? evalStack[idx].locOffset : curStackSize;
|
}
|
|
int32_t GetEvalStackTopOffset()
|
{
|
return evalStackTop > 0 ? evalStack[evalStackTop - 1].locOffset : curStackSize;
|
}
|
|
int32_t GetEvalStackNewTopOffset()
|
{
|
return curStackSize;
|
}
|
|
int32_t GetEvalStackOffset_5()
|
{
|
return evalStack[evalStackTop - 5].locOffset;
|
}
|
|
int32_t GetEvalStackOffset_4()
|
{
|
return evalStack[evalStackTop - 4].locOffset;
|
}
|
|
int32_t GetEvalStackOffset_3()
|
{
|
return evalStack[evalStackTop - 3].locOffset;
|
}
|
|
int32_t GetEvalStackOffset_2()
|
{
|
return evalStack[evalStackTop - 2].locOffset;
|
}
|
|
int32_t GetEvalStackOffset_1()
|
{
|
return evalStack[evalStackTop - 1].locOffset;
|
}
|
|
void PushStackByType(const Il2CppType* type)
|
{
|
int32_t byteSize = GetTypeValueSize(type);
|
int32_t stackSize = GetStackSizeByByteSize(byteSize);
|
evalStack[evalStackTop].reduceType = GetEvalStackReduceDataType(type);
|
evalStack[evalStackTop].byteSize = byteSize;
|
evalStack[evalStackTop].locOffset = GetEvalStackNewTopOffset();
|
evalStackTop++;
|
curStackSize += stackSize;
|
maxStackSize = std::max(curStackSize, maxStackSize);
|
IL2CPP_ASSERT(maxStackSize < MAX_STACK_SIZE);
|
}
|
|
void PushStackByReduceType(EvalStackReduceDataType t)
|
{
|
int32_t byteSize = GetSizeByReduceType(t);
|
int32_t stackSize = GetStackSizeByByteSize(byteSize);
|
evalStack[evalStackTop].reduceType = t;
|
evalStack[evalStackTop].byteSize = byteSize;
|
evalStack[evalStackTop].locOffset = GetEvalStackNewTopOffset();
|
evalStackTop++; curStackSize += stackSize;
|
maxStackSize = std::max(curStackSize, maxStackSize);
|
IL2CPP_ASSERT(maxStackSize < MAX_STACK_SIZE);
|
}
|
|
void DuplicateStack()
|
{
|
IL2CPP_ASSERT(evalStackTop > 0);
|
EvalStackVarInfo& oldTop = evalStack[evalStackTop - 1];
|
int32_t stackSize = GetStackSizeByByteSize(oldTop.byteSize);
|
EvalStackVarInfo& newTop = evalStack[evalStackTop++];
|
newTop.reduceType = oldTop.reduceType;
|
newTop.byteSize = oldTop.byteSize;
|
newTop.locOffset = curStackSize;
|
curStackSize += stackSize;
|
maxStackSize = std::max(curStackSize, maxStackSize);
|
IL2CPP_ASSERT(maxStackSize < MAX_STACK_SIZE);
|
}
|
|
void PopStack()
|
{
|
IL2CPP_ASSERT(evalStackTop > 0);
|
--evalStackTop;
|
curStackSize = evalStack[evalStackTop].locOffset;
|
}
|
|
void PopStackN(int32_t n)
|
{
|
IL2CPP_ASSERT(evalStackTop >= n && n >= 0);
|
if (n > 0)
|
{
|
evalStackTop -= n;
|
curStackSize = evalStack[evalStackTop].locOffset;
|
}
|
}
|
|
void PopAllStack()
|
{
|
if (evalStackTop > 0)
|
{
|
evalStackTop = 0;
|
curStackSize = evalStackBaseOffset;
|
}
|
else
|
{
|
IL2CPP_ASSERT(curStackSize == evalStackBaseOffset);
|
}
|
}
|
|
void InsertMemoryBarrier()
|
{
|
if (prefixFlags & (int32_t)PrefixFlags::Volatile)
|
{
|
CreateAddIR(_mb, MemoryBarrier);
|
}
|
}
|
|
void ResetPrefixFlags()
|
{
|
prefixFlags = 0;
|
}
|
|
void Add_ldind(HiOpcodeEnum opCode, EvalStackReduceDataType dataType)
|
{
|
CreateAddIR(ir, LdindVarVar_i1);
|
ir->type = opCode;
|
ir->dst = ir->src = GetEvalStackTopOffset();
|
PopStack();
|
PushStackByReduceType(dataType);
|
InsertMemoryBarrier();
|
ResetPrefixFlags();
|
ip++;
|
}
|
|
void Add_stind(HiOpcodeEnum opCode)
|
{
|
IL2CPP_ASSERT(evalStackTop >= 2);
|
InsertMemoryBarrier();
|
ResetPrefixFlags();
|
CreateAddIR(ir, StindVarVar_i1);
|
ir->type = opCode;
|
ir->dst = evalStack[evalStackTop - 2].locOffset;
|
ir->src = evalStack[evalStackTop - 1].locOffset;
|
PopStackN(2);
|
ip++;
|
}
|
|
void PushOffset(int32_t* offsetPtr)
|
{
|
IL2CPP_ASSERT(splitOffsets.find(*(offsetPtr)) != splitOffsets.end());
|
relocationOffsets.push_back(offsetPtr);
|
}
|
|
void PushBranch(int32_t targetOffset)
|
{
|
IL2CPP_ASSERT(splitOffsets.find(targetOffset) != splitOffsets.end());
|
IRBasicBlock* targetBb = ip2bb[targetOffset];
|
if (!targetBb->inPending)
|
{
|
targetBb->inPending = true;
|
FlowInfo* fi = pool.NewAny<FlowInfo>();
|
fi->offset = targetOffset;
|
fi->curStackSize = curStackSize;
|
if (evalStackTop > 0)
|
{
|
fi->evalStack.insert(fi->evalStack.end(), evalStack, evalStack + evalStackTop);
|
}
|
else
|
{
|
IL2CPP_ASSERT(curStackSize == evalStackBaseOffset);
|
}
|
pendingFlows.push_back(fi);
|
}
|
}
|
|
bool FindNextFlow()
|
{
|
for (; nextFlowIdx < (int32_t)pendingFlows.size(); )
|
{
|
FlowInfo* fi = pendingFlows[nextFlowIdx++];
|
IRBasicBlock* nextBb = ip2bb[fi->offset];
|
if (!nextBb->visited)
|
{
|
ip = ipBase + fi->offset;
|
if (!fi->evalStack.empty()) {
|
|
std::memcpy(evalStack, &fi->evalStack[0], sizeof(EvalStackVarInfo) * fi->evalStack.size());
|
}
|
curStackSize = fi->curStackSize;
|
IL2CPP_ASSERT(curStackSize >= evalStackBaseOffset);
|
evalStackTop = (int32_t)fi->evalStack.size();
|
return true;
|
}
|
}
|
return false;
|
}
|
|
void AddInst(IRCommon* ir)
|
{
|
IL2CPP_ASSERT(ir->type != HiOpcodeEnum::None);
|
curbb->insts.push_back(ir);
|
}
|
|
void AddInst_ldarg(int32_t argIdx)
|
{
|
ArgVarInfo& __arg = args[argIdx];
|
IRCommon* ir = CreateLoadExpandDataToStackVarVar(pool, GetEvalStackNewTopOffset(), __arg.argLocOffset, __arg.type, GetTypeValueSize(__arg.type));
|
AddInst(ir);
|
PushStackByType(__arg.type);
|
}
|
|
bool IsCreateNotNullObjectInstrument(IRCommon* ir)
|
{
|
switch (ir->type)
|
{
|
case HiOpcodeEnum::BoxVarVar:
|
{
|
IRBoxVarVar* irBox = (IRBoxVarVar*)ir;
|
Il2CppClass* klass = ((Il2CppClass*)resolveDatas[irBox->klass]);
|
return IS_CLASS_VALUE_TYPE(klass) && !il2cpp::vm::Class::IsNullable(klass);
|
}
|
case HiOpcodeEnum::NewSystemObjectVar:
|
case HiOpcodeEnum::NewString:
|
case HiOpcodeEnum::NewString_2:
|
case HiOpcodeEnum::NewString_3:
|
case HiOpcodeEnum::CtorDelegate:
|
case HiOpcodeEnum::NewDelegate:
|
//case HiOpcodeEnum::NewClassInterpVar_Ctor_0:
|
//case HiOpcodeEnum::NewClassInterpVar:
|
//case HiOpcodeEnum::NewClassVar:
|
//case HiOpcodeEnum::NewClassVar_Ctor_0:
|
//case HiOpcodeEnum::NewClassVar_NotCtor:
|
case HiOpcodeEnum::NewMdArrVarVar_length:
|
case HiOpcodeEnum::NewMdArrVarVar_length_bound:
|
case HiOpcodeEnum::NewArrVarVar:
|
case HiOpcodeEnum::LdsfldaFromFieldDataVarVar:
|
case HiOpcodeEnum::LdsfldaVarVar:
|
case HiOpcodeEnum::LdthreadlocalaVarVar:
|
case HiOpcodeEnum::LdlocVarAddress:
|
return true;
|
default:
|
return false;
|
}
|
}
|
|
IRCommon* GetLastInstrument()
|
{
|
return curbb->insts.empty() ? nullptr : curbb->insts.back();
|
}
|
|
void RemoveLastInstrument()
|
{
|
IL2CPP_ASSERT(!curbb->insts.empty());
|
curbb->insts.pop_back();
|
}
|
|
void AddInst_ldarga(int32_t argIdx)
|
{
|
IL2CPP_ASSERT(argIdx < actualParamCount);
|
ArgVarInfo& argInfo = args[argIdx];
|
CreateAddIR(ir, LdlocVarAddress);
|
ir->dst = GetEvalStackNewTopOffset();
|
ir->src = argInfo.argLocOffset;
|
PushStackByReduceType(NATIVE_INT_REDUCE_TYPE);
|
}
|
|
void AddInst_starg(int32_t argIdx)
|
{
|
IL2CPP_ASSERT(argIdx < actualParamCount);
|
ArgVarInfo& __arg = args[argIdx];
|
IRCommon* ir = CreateAssignVarVar(pool, __arg.argLocOffset, GetEvalStackTopOffset(), GetTypeValueSize(__arg.type));
|
AddInst(ir);
|
PopStack();
|
}
|
|
void CreateAddInst_ldloc(int32_t locIdx)
|
{
|
LocVarInfo& __loc = locals[locIdx];
|
IRCommon* ir = CreateLoadExpandDataToStackVarVar(pool, GetEvalStackNewTopOffset(), __loc.locOffset, __loc.type, GetTypeValueSize(__loc.type));
|
AddInst(ir);
|
PushStackByType(__loc.type);
|
}
|
|
void CreateAddInst_stloc(int32_t locIdx)
|
{
|
LocVarInfo& __loc = locals[locIdx];
|
IRCommon* ir = CreateAssignVarVar(pool, __loc.locOffset, GetEvalStackTopOffset(), GetTypeValueSize(__loc.type));
|
AddInst(ir);
|
PopStack();
|
}
|
|
void CreateAddInst_ldloca(int32_t locIdx)
|
{
|
CreateAddIR(ir, LdlocVarAddress);
|
LocVarInfo& __loc = locals[locIdx];
|
ir->dst = GetEvalStackNewTopOffset();
|
ir->src = __loc.locOffset;
|
PushStackByReduceType(NATIVE_INT_REDUCE_TYPE);
|
}
|
|
void CreateAddInst_ldc4(int32_t c, EvalStackReduceDataType rtype)
|
{
|
CreateAddIR(ir, LdcVarConst_4);
|
ir->dst = GetEvalStackNewTopOffset();
|
ir->src = c;
|
PushStackByReduceType(rtype);
|
}
|
|
void CreateAddInst_ldc8(int64_t c, EvalStackReduceDataType rtype)
|
{
|
CreateAddIR(ir, LdcVarConst_8);
|
ir->dst = GetEvalStackNewTopOffset();
|
ir->src = c;
|
PushStackByReduceType(rtype);
|
}
|
|
void Add_brtruefalse(bool c, int32_t targetOffset)
|
{
|
EvalStackVarInfo& top = evalStack[evalStackTop - 1];
|
IRCommon* lastIR = GetLastInstrument();
|
if (lastIR == nullptr || !IsCreateNotNullObjectInstrument(lastIR))
|
{
|
if (top.byteSize <= 4)
|
{
|
CreateAddIR(ir, BranchTrueVar_i4);
|
ir->type = c ? HiOpcodeEnum::BranchTrueVar_i4 : HiOpcodeEnum::BranchFalseVar_i4;
|
ir->op = top.locOffset;
|
ir->offset = targetOffset;
|
PushOffset(&ir->offset);
|
}
|
else
|
{
|
CreateAddIR(ir, BranchTrueVar_i8);
|
ir->type = c ? HiOpcodeEnum::BranchTrueVar_i8 : HiOpcodeEnum::BranchFalseVar_i8;
|
ir->op = top.locOffset;
|
ir->offset = targetOffset;
|
PushOffset(&ir->offset);
|
}
|
}
|
else
|
{
|
// optimize instrument sequence like` box T!; brtrue`
|
// this optimization is not semanticly equals to origin instrument because may ommit `Class::InitRuntime`.
|
// but it's ok in most occasions.
|
RemoveLastInstrument();
|
if (c)
|
{
|
// brtrue always true, replace with br
|
CreateAddIR(ir, BranchUncondition_4);
|
ir->offset = targetOffset;
|
PushOffset(&ir->offset);
|
}
|
else
|
{
|
// brfalse always false, run throughtly.
|
}
|
}
|
PopStack();
|
PushBranch(targetOffset);
|
}
|
|
void Add_bc(int32_t ipOffset, int32_t brOffset, int32_t opSize, HiOpcodeEnum opI4, HiOpcodeEnum opI8, HiOpcodeEnum opR4, HiOpcodeEnum opR8)
|
{
|
int32_t targetOffset = ipOffset + brOffset + opSize;
|
EvalStackVarInfo& op1 = evalStack[evalStackTop - 2];
|
EvalStackVarInfo& op2 = evalStack[evalStackTop - 1];
|
IRBranchVarVar_Ceq_i4* ir = pool.AllocIR<IRBranchVarVar_Ceq_i4>();
|
ir->type = (HiOpcodeEnum)0;
|
ir->op1 = op1.locOffset;
|
ir->op2 = op2.locOffset;
|
ir->offset = targetOffset;
|
PushOffset(&ir->offset);
|
switch (op1.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
ir->type = opI4;
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
CreateAddIR(irConv, ConvertVarVar_i4_i8);
|
irConv->dst = irConv->src = op1.locOffset;
|
ir->type = opI8;
|
break;
|
}
|
default:
|
{
|
IL2CPP_ASSERT(false && "I4 not match");
|
break;
|
}
|
}
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
IL2CPP_ASSERT(op2.reduceType == EvalStackReduceDataType::I8);
|
ir->type = opI8;
|
break;
|
}
|
case EvalStackReduceDataType::R4:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::R4:
|
{
|
ir->type = opR4;
|
break;
|
}
|
default:
|
{
|
IL2CPP_ASSERT(false && "R4 not match");
|
break;
|
}
|
}
|
break;
|
}
|
case EvalStackReduceDataType::R8:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::R8:
|
{
|
ir->type = opR8;
|
break;
|
}
|
default:
|
{
|
IL2CPP_ASSERT(false && "R8 not match");
|
break;
|
}
|
}
|
break;
|
}
|
default:
|
{
|
IL2CPP_ASSERT(false && "nothing match");
|
}
|
}
|
AddInst(ir);
|
PopStackN(2);
|
PushBranch(targetOffset);
|
}
|
|
void Add_conv(int32_t dstTypeSize, EvalStackReduceDataType dstReduceType, HiOpcodeEnum opI4, HiOpcodeEnum opI8, HiOpcodeEnum opR4, HiOpcodeEnum opR8)
|
{
|
IL2CPP_ASSERT(evalStackTop > 0);
|
EvalStackVarInfo& top = evalStack[evalStackTop - 1];
|
//if (top.reduceType != dstReduceType)
|
{
|
CreateIR(ir, ConvertVarVar_i4_u4);
|
ir->type = (HiOpcodeEnum)0;
|
ir->dst = ir->src = GetEvalStackTopOffset();
|
switch (top.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
ir->type = opI4;
|
AddInst(ir);
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
ir->type = opI8;
|
AddInst(ir);
|
break;
|
}
|
case EvalStackReduceDataType::R4:
|
{
|
ir->type = opR4;
|
AddInst(ir);
|
break;
|
}
|
case EvalStackReduceDataType::R8:
|
{
|
ir->type = opR8;
|
AddInst(ir);
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("conv");
|
break;
|
}
|
}
|
}
|
|
top.reduceType = dstReduceType;
|
top.byteSize = dstTypeSize;
|
ip++;
|
}
|
|
void Add_conv_ovf(int32_t dstTypeSize, EvalStackReduceDataType dstReduceType, HiOpcodeEnum opI4, HiOpcodeEnum opI8, HiOpcodeEnum opR4, HiOpcodeEnum opR8)
|
{
|
IL2CPP_ASSERT(evalStackTop > 0);
|
EvalStackVarInfo& top = evalStack[evalStackTop - 1];
|
//if (top.reduceType != dstReduceType)
|
{
|
CreateIR(ir, ConvertOverflowVarVar_i4_u4);
|
ir->type = (HiOpcodeEnum)0;
|
ir->dst = ir->src = GetEvalStackTopOffset();
|
switch (top.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
ir->type = opI4;
|
AddInst(ir);
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
ir->type = opI8;
|
AddInst(ir);
|
break;
|
}
|
case EvalStackReduceDataType::R4:
|
{
|
ir->type = opR4;
|
AddInst(ir);
|
break;
|
}
|
case EvalStackReduceDataType::R8:
|
{
|
ir->type = opR8;
|
AddInst(ir);
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("conv_ovf");
|
break;
|
}
|
}
|
}
|
|
top.reduceType = dstReduceType;
|
top.byteSize = dstTypeSize;
|
ip++;
|
}
|
|
void Add_binop(HiOpcodeEnum opI4, HiOpcodeEnum opI8, HiOpcodeEnum opR4, HiOpcodeEnum opR8)
|
{
|
IL2CPP_ASSERT(evalStackTop >= 2);
|
EvalStackVarInfo& op1 = evalStack[evalStackTop - 2];
|
EvalStackVarInfo& op2 = evalStack[evalStackTop - 1];
|
CreateIR(ir, BinOpVarVarVar_Add_i4);
|
ir->op1 = op1.locOffset;
|
ir->op2 = op2.locOffset;
|
ir->ret = op1.locOffset;
|
EvalStackReduceDataType resultType;
|
switch (op1.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
resultType = EvalStackReduceDataType::I4;
|
ir->type = opI4;
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
CreateAddIR(irConv, ConvertVarVar_i4_i8);
|
irConv->dst = irConv->src = op1.locOffset;
|
ir->type = opI8;
|
resultType = EvalStackReduceDataType::I8;
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("Add_bin_op I4 op unknown");
|
resultType = (EvalStackReduceDataType)-1;
|
}
|
}
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
CreateAddIR(irConv, ConvertVarVar_i4_i8);
|
irConv->dst = irConv->src = op2.locOffset;
|
resultType = EvalStackReduceDataType::I8;
|
ir->type = opI8;
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
resultType = EvalStackReduceDataType::I8;
|
ir->type = opI8;
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("Add_bin_op I8 op unknown");
|
resultType = (EvalStackReduceDataType)-1;
|
break;
|
}
|
}
|
break;
|
}
|
case EvalStackReduceDataType::R4:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::R4:
|
{
|
resultType = EvalStackReduceDataType::R4;
|
ir->type = opR4;
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("Add_bin_op R4 op unknown");
|
resultType = (EvalStackReduceDataType)-1;
|
break;
|
}
|
}
|
break;
|
}
|
case EvalStackReduceDataType::R8:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::R8:
|
{
|
resultType = EvalStackReduceDataType::R8;
|
ir->type = opR8;
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("Add_bin_op R8 op unknown");
|
resultType = (EvalStackReduceDataType)-1;
|
break;
|
}
|
}
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("Add_bin_op unknown");
|
resultType = (EvalStackReduceDataType)-1;
|
break;
|
}
|
}
|
PopStack();
|
op1.reduceType = resultType;
|
op1.byteSize = GetSizeByReduceType(resultType);
|
AddInst(ir);
|
ip++;
|
}
|
|
void Add_shiftop(HiOpcodeEnum opI4I4, HiOpcodeEnum opI4I8, HiOpcodeEnum opI8I4, HiOpcodeEnum opI8I8)
|
{
|
IL2CPP_ASSERT(evalStackTop >= 2);
|
EvalStackVarInfo& op1 = evalStack[evalStackTop - 2];
|
EvalStackVarInfo& op2 = evalStack[evalStackTop - 1];
|
CreateAddIR(ir, BitShiftBinOpVarVarVar_Shr_i4_i4);
|
ir->ret = op1.locOffset;
|
ir->value = op1.locOffset;
|
ir->shiftAmount = op2.locOffset;
|
switch (op1.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
ir->type = opI4I4;
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
ir->type = opI4I8;
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("shitf i4");
|
}
|
}
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
ir->type = opI8I4;
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
|
ir->type = opI8I8;
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("shitf i8");
|
break;
|
}
|
}
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("shitf i");
|
break;
|
}
|
}
|
PopStack();
|
ip++;
|
}
|
|
void Add_compare(HiOpcodeEnum opI4, HiOpcodeEnum opI8, HiOpcodeEnum opR4, HiOpcodeEnum opR8)
|
{
|
IL2CPP_ASSERT(evalStackTop >= 2);
|
EvalStackVarInfo& op1 = evalStack[evalStackTop - 2];
|
EvalStackVarInfo& op2 = evalStack[evalStackTop - 1];
|
CreateIR(ir, CompOpVarVarVar_Ceq_i4);
|
ir->c1 = op1.locOffset;
|
ir->c2 = op2.locOffset;
|
ir->ret = op1.locOffset;
|
switch (op1.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
ir->type = opI4;
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
CreateAddIR(irConv, ConvertVarVar_i4_i8);
|
irConv->dst = irConv->src = op1.locOffset;
|
ir->type = opI8;
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("compare i4");
|
break;
|
}
|
}
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
switch (op2.reduceType)
|
{
|
case EvalStackReduceDataType::I4:
|
{
|
CreateAddIR(irConv, ConvertVarVar_i4_i8);
|
irConv->dst = irConv->src = op2.locOffset;
|
ir->type = opI8;
|
break;
|
}
|
case EvalStackReduceDataType::I8:
|
{
|
ir->type = opI8;
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("compare i8");
|
break;
|
}
|
}
|
break;
|
}
|
case EvalStackReduceDataType::R4:
|
{
|
if (op2.reduceType == EvalStackReduceDataType::R4)
|
{
|
ir->type = opR4;
|
}
|
else
|
{
|
RaiseExecutionEngineException("compare r4");
|
}
|
break;
|
}
|
case EvalStackReduceDataType::R8:
|
{
|
if (op2.reduceType == EvalStackReduceDataType::R8)
|
{
|
ir->type = opR8;
|
}
|
else
|
{
|
RaiseExecutionEngineException("compare r8");
|
}
|
break;
|
}
|
default:
|
{
|
RaiseExecutionEngineException("compare");
|
break;
|
}
|
}
|
PopStackN(2);
|
AddInst(ir);
|
PushStackByReduceType(EvalStackReduceDataType::I4);
|
}
|
|
void Add_ldelem(EvalStackReduceDataType resultType, HiOpcodeEnum opI4)
|
{
|
IL2CPP_ASSERT(evalStackTop >= 2);
|
EvalStackVarInfo& arr = evalStack[evalStackTop - 2];
|
EvalStackVarInfo& index = evalStack[evalStackTop - 1];
|
|
CreateAddIR(ir, GetArrayElementVarVar_i1);
|
ir->type = opI4;
|
ir->arr = arr.locOffset;
|
ir->index = index.locOffset;
|
ir->dst = arr.locOffset;
|
|
PopStackN(2);
|
PushStackByReduceType(resultType);
|
ip++;
|
}
|
|
void Add_stelem(HiOpcodeEnum opI4)
|
{
|
IL2CPP_ASSERT(evalStackTop >= 3);
|
EvalStackVarInfo& arr = evalStack[evalStackTop - 3];
|
EvalStackVarInfo& index = evalStack[evalStackTop - 2];
|
EvalStackVarInfo& ele = evalStack[evalStackTop - 1];
|
|
CreateAddIR(ir, SetArrayElementVarVar_i1);
|
ir->type = opI4;
|
ir->arr = arr.locOffset;
|
ir->index = index.locOffset;
|
ir->ele = ele.locOffset;
|
|
PopStackN(3);
|
ip++;
|
}
|
|
|
bool FindFirstLeaveHandlerIndex(const std::vector<ExceptionClause>& exceptionClauses, uint32_t leaveOffset, uint32_t targetOffset, uint16_t& index)
|
{
|
index = 0;
|
for (const ExceptionClause& ec : exceptionClauses)
|
{
|
if (ec.flags == CorILExceptionClauseType::Finally)
|
{
|
if (ec.tryOffset <= leaveOffset && leaveOffset < ec.tryOffset + ec.tryLength)
|
return !(ec.tryOffset <= targetOffset && targetOffset < ec.tryOffset + ec.tryLength);
|
}
|
++index;
|
}
|
return false;
|
}
|
|
bool IsLeaveInTryBlock(const std::vector<ExceptionClause>& exceptionClauses, uint32_t leaveOffset)
|
{
|
for (const ExceptionClause& ec : exceptionClauses)
|
{
|
if (ec.tryOffset <= leaveOffset && leaveOffset < ec.tryOffset + ec.tryLength)
|
{
|
return true;
|
}
|
if (ec.handlerOffsets <= leaveOffset && leaveOffset < ec.handlerOffsets + ec.handlerLength)
|
{
|
return false;
|
}
|
}
|
return false;
|
}
|
|
void Add_leave(uint32_t targetOffset)
|
{
|
uint32_t leaveOffset = (uint32_t)(ip - ipBase);
|
uint16_t firstHandlerIndex;
|
if (FindFirstLeaveHandlerIndex(body.exceptionClauses, leaveOffset, targetOffset, firstHandlerIndex))
|
{
|
CreateAddIR(ir, LeaveEx);
|
ir->target = targetOffset;
|
ir->firstHandlerIndex = firstHandlerIndex;
|
PushOffset(&ir->target);
|
}
|
else if (!IsLeaveInTryBlock(body.exceptionClauses, leaveOffset))
|
{
|
CreateAddIR(ir, LeaveEx_Directly);
|
ir->target = targetOffset;
|
PushOffset(&ir->target);
|
}
|
else
|
{
|
CreateAddIR(ir, BranchUncondition_4);
|
ir->offset = targetOffset;
|
PushOffset(&ir->offset);
|
}
|
PopAllStack();
|
PushBranch(targetOffset);
|
}
|
|
uint16_t FindFirstThrowHandlerIndex(const std::vector<ExceptionClause>& exceptionClauses, uint32_t throwOffset)
|
{
|
uint16_t index = 0;
|
for (const ExceptionClause& ec : exceptionClauses)
|
{
|
if (ec.flags == CorILExceptionClauseType::Finally || ec.flags == CorILExceptionClauseType::Exception || ec.flags == CorILExceptionClauseType::Filter)
|
{
|
if (ec.tryOffset <= throwOffset && throwOffset < ec.tryOffset + ec.tryLength)
|
return index;
|
}
|
++index;
|
}
|
return index;
|
}
|
|
bool TryAddInstinctInstruments(const MethodInfo* method)
|
{
|
return TryAddInstinctInstrumentsByName(method) || TryAddArrayInstinctInstruments(method);
|
}
|
|
bool TryAddInstinctInstrumentsByName(const MethodInfo* method);
|
bool TryAddArrayInstinctInstruments(const MethodInfo* method);
|
|
bool TryAddInstinctCtorInstruments(const MethodInfo* method);
|
|
bool TryAddCallCommonInstruments(const MethodInfo* method, uint32_t methodDataIndex)
|
{
|
bool resolvedIsInstanceMethod = IsInstanceMethod(method);
|
bool add = resolvedIsInstanceMethod ? TryAddCallCommonInstanceInstruments(method, methodDataIndex)
|
: TryAddCallCommonStaticInstruments(method, methodDataIndex);
|
if (add)
|
{
|
int32_t resolvedTotalArgNum = method->parameters_count + resolvedIsInstanceMethod;
|
PopStackN(resolvedTotalArgNum);
|
if (method->return_type->type != IL2CPP_TYPE_VOID)
|
{
|
PushStackByType(method->return_type);
|
}
|
return true;
|
}
|
return false;
|
}
|
|
bool TryAddCallCommonInstanceInstruments(const MethodInfo* method, uint32_t methodDataIndex);
|
bool TryAddCallCommonStaticInstruments(const MethodInfo* method, uint32_t methodDataIndex);
|
};
|
}
|
}
|
