Merging with dev

1 files changed, 1244 insertions, 79 deletions

diff --git a/lowlevelilinstruction.cpp b/lowlevelilinstruction.cpp
index d85e4f17..8fb87a9e 100644
--- a/lowlevelilinstruction.cpp
+++ b/lowlevelilinstruction.cpp
@@ -37,27 +37,34 @@ unordered_map<LowLevelILOperandUsage, LowLevelILOperandType>
 	LowLevelILInstructionBase::operandTypeForUsage = {
 		{SourceExprLowLevelOperandUsage, ExprLowLevelOperand},
 		{SourceRegisterLowLevelOperandUsage, RegisterLowLevelOperand},
+		{SourceRegisterStackLowLevelOperandUsage, RegisterStackLowLevelOperand},
 		{SourceFlagLowLevelOperandUsage, FlagLowLevelOperand},
 		{SourceSSARegisterLowLevelOperandUsage, SSARegisterLowLevelOperand},
+		{SourceSSARegisterStackLowLevelOperandUsage, SSARegisterStackLowLevelOperand},
 		{SourceSSAFlagLowLevelOperandUsage, SSAFlagLowLevelOperand},
 		{DestExprLowLevelOperandUsage, ExprLowLevelOperand},
 		{DestRegisterLowLevelOperandUsage, RegisterLowLevelOperand},
+		{DestRegisterStackLowLevelOperandUsage, RegisterStackLowLevelOperand},
 		{DestFlagLowLevelOperandUsage, FlagLowLevelOperand},
 		{DestSSARegisterLowLevelOperandUsage, SSARegisterLowLevelOperand},
+		{DestSSARegisterStackLowLevelOperandUsage, SSARegisterStackLowLevelOperand},
 		{DestSSAFlagLowLevelOperandUsage, SSAFlagLowLevelOperand},
+		{SemanticFlagClassLowLevelOperandUsage, SemanticFlagClassLowLevelOperand},
+		{SemanticFlagGroupLowLevelOperandUsage, SemanticFlagGroupLowLevelOperand},
 		{PartialRegisterLowLevelOperandUsage, RegisterLowLevelOperand},
+		{PartialSSARegisterStackSourceLowLevelOperandUsage, SSARegisterStackLowLevelOperand},
 		{StackSSARegisterLowLevelOperandUsage, SSARegisterLowLevelOperand},
 		{StackMemoryVersionLowLevelOperandUsage, IndexLowLevelOperand},
+		{TopSSARegisterLowLevelOperandUsage, SSARegisterLowLevelOperand},
 		{LeftExprLowLevelOperandUsage, ExprLowLevelOperand},
 		{RightExprLowLevelOperandUsage, ExprLowLevelOperand},
 		{CarryExprLowLevelOperandUsage, ExprLowLevelOperand},
-		{HighExprLowLevelOperandUsage, ExprLowLevelOperand},
-		{LowExprLowLevelOperandUsage, ExprLowLevelOperand},
 		{ConditionExprLowLevelOperandUsage, ExprLowLevelOperand},
 		{HighRegisterLowLevelOperandUsage, RegisterLowLevelOperand},
 		{HighSSARegisterLowLevelOperandUsage, SSARegisterLowLevelOperand},
 		{LowRegisterLowLevelOperandUsage, RegisterLowLevelOperand},
 		{LowSSARegisterLowLevelOperandUsage, SSARegisterLowLevelOperand},
+		{IntrinsicLowLevelOperandUsage, IntrinsicLowLevelOperand},
 		{ConstantLowLevelOperandUsage, IntegerLowLevelOperand},
 		{VectorLowLevelOperandUsage, IntegerLowLevelOperand},
 		{StackAdjustmentLowLevelOperandUsage, IntegerLowLevelOperand},
@@ -70,11 +77,15 @@ unordered_map<LowLevelILOperandUsage, LowLevelILOperandType>
 		{FlagConditionLowLevelOperandUsage, FlagConditionLowLevelOperand},
 		{OutputSSARegistersLowLevelOperandUsage, SSARegisterListLowLevelOperand},
 		{OutputMemoryVersionLowLevelOperandUsage, IndexLowLevelOperand},
-		{ParameterSSARegistersLowLevelOperandUsage, SSARegisterListLowLevelOperand},
+		{ParameterExprsLowLevelOperandUsage, ExprListLowLevelOperand},
 		{SourceSSARegistersLowLevelOperandUsage, SSARegisterListLowLevelOperand},
+		{SourceSSARegisterStacksLowLevelOperandUsage, SSARegisterStackListLowLevelOperand},
 		{SourceSSAFlagsLowLevelOperandUsage, SSAFlagListLowLevelOperand},
+		{OutputRegisterOrFlagListLowLevelOperandUsage, RegisterOrFlagListLowLevelOperand},
+		{OutputSSARegisterOrFlagListLowLevelOperandUsage, SSARegisterOrFlagListLowLevelOperand},
 		{SourceMemoryVersionsLowLevelOperandUsage, IndexListLowLevelOperand},
-		{TargetListLowLevelOperandUsage, IndexListLowLevelOperand}
+		{TargetListLowLevelOperandUsage, IndexListLowLevelOperand},
+		{RegisterStackAdjustmentsLowLevelOperandUsage, RegisterStackAdjustmentsLowLevelOperand}
 	};
 
 
@@ -95,6 +106,15 @@ unordered_map<BNLowLevelILOperation, vector<LowLevelILOperandUsage>>
 			SourceExprLowLevelOperandUsage}},
 		{LLIL_SET_REG_SPLIT_SSA, {HighSSARegisterLowLevelOperandUsage,
 			LowSSARegisterLowLevelOperandUsage, SourceExprLowLevelOperandUsage}},
+		{LLIL_SET_REG_STACK_REL, {DestRegisterStackLowLevelOperandUsage, DestExprLowLevelOperandUsage,
+			SourceExprLowLevelOperandUsage}},
+		{LLIL_REG_STACK_PUSH, {DestRegisterStackLowLevelOperandUsage, SourceExprLowLevelOperandUsage}},
+		{LLIL_SET_REG_STACK_REL_SSA, {DestSSARegisterStackLowLevelOperandUsage,
+			PartialSSARegisterStackSourceLowLevelOperandUsage, DestExprLowLevelOperandUsage,
+			TopSSARegisterLowLevelOperandUsage, SourceExprLowLevelOperandUsage}},
+		{LLIL_SET_REG_STACK_ABS_SSA, {DestSSARegisterStackLowLevelOperandUsage,
+			PartialSSARegisterStackSourceLowLevelOperandUsage, DestRegisterLowLevelOperandUsage,
+			SourceExprLowLevelOperandUsage}},
 		{LLIL_SET_FLAG, {DestFlagLowLevelOperandUsage, SourceExprLowLevelOperandUsage}},
 		{LLIL_SET_FLAG_SSA, {DestSSAFlagLowLevelOperandUsage, SourceExprLowLevelOperandUsage}},
 		{LLIL_LOAD, {SourceExprLowLevelOperandUsage}},
@@ -105,6 +125,20 @@ unordered_map<BNLowLevelILOperation, vector<LowLevelILOperandUsage>>
 		{LLIL_REG, {SourceRegisterLowLevelOperandUsage}},
 		{LLIL_REG_SSA, {SourceSSARegisterLowLevelOperandUsage}},
 		{LLIL_REG_SSA_PARTIAL, {SourceSSARegisterLowLevelOperandUsage, PartialRegisterLowLevelOperandUsage}},
+		{LLIL_REG_SPLIT, {HighRegisterLowLevelOperandUsage, LowRegisterLowLevelOperandUsage}},
+		{LLIL_REG_SPLIT_SSA, {HighSSARegisterLowLevelOperandUsage, LowSSARegisterLowLevelOperandUsage}},
+		{LLIL_REG_STACK_REL, {SourceRegisterStackLowLevelOperandUsage, SourceExprLowLevelOperandUsage}},
+		{LLIL_REG_STACK_POP, {SourceRegisterStackLowLevelOperandUsage}},
+		{LLIL_REG_STACK_FREE_REG, {DestRegisterLowLevelOperandUsage}},
+		{LLIL_REG_STACK_FREE_REL, {DestRegisterStackLowLevelOperandUsage, DestExprLowLevelOperandUsage}},
+		{LLIL_REG_STACK_REL_SSA, {SourceSSARegisterStackLowLevelOperandUsage, TopSSARegisterLowLevelOperandUsage,
+			SourceExprLowLevelOperandUsage}},
+		{LLIL_REG_STACK_ABS_SSA, {SourceSSARegisterStackLowLevelOperandUsage, SourceRegisterLowLevelOperandUsage}},
+		{LLIL_REG_STACK_FREE_REL_SSA, {DestSSARegisterStackLowLevelOperandUsage,
+			PartialSSARegisterStackSourceLowLevelOperandUsage, DestExprLowLevelOperandUsage,
+			TopSSARegisterLowLevelOperandUsage}},
+		{LLIL_REG_STACK_FREE_ABS_SSA, {DestSSARegisterStackLowLevelOperandUsage,
+			PartialSSARegisterStackSourceLowLevelOperandUsage, DestRegisterLowLevelOperandUsage}},
 		{LLIL_FLAG, {SourceFlagLowLevelOperandUsage}},
 		{LLIL_FLAG_BIT, {SourceFlagLowLevelOperandUsage, BitIndexLowLevelOperandUsage}},
 		{LLIL_FLAG_SSA, {SourceSSAFlagLowLevelOperandUsage}},
@@ -112,24 +146,28 @@ unordered_map<BNLowLevelILOperation, vector<LowLevelILOperandUsage>>
 		{LLIL_JUMP, {DestExprLowLevelOperandUsage}},
 		{LLIL_JUMP_TO, {DestExprLowLevelOperandUsage, TargetListLowLevelOperandUsage}},
 		{LLIL_CALL, {DestExprLowLevelOperandUsage}},
-		{LLIL_CALL_STACK_ADJUST, {DestExprLowLevelOperandUsage, StackAdjustmentLowLevelOperandUsage}},
+		{LLIL_CALL_STACK_ADJUST, {DestExprLowLevelOperandUsage, StackAdjustmentLowLevelOperandUsage,
+			RegisterStackAdjustmentsLowLevelOperandUsage}},
 		{LLIL_RET, {DestExprLowLevelOperandUsage}},
 		{LLIL_IF, {ConditionExprLowLevelOperandUsage, TrueTargetLowLevelOperandUsage,
 			FalseTargetLowLevelOperandUsage}},
 		{LLIL_GOTO, {TargetLowLevelOperandUsage}},
-		{LLIL_FLAG_COND, {FlagConditionLowLevelOperandUsage}},
+		{LLIL_FLAG_COND, {FlagConditionLowLevelOperandUsage, SemanticFlagClassLowLevelOperandUsage}},
+		{LLIL_FLAG_GROUP, {SemanticFlagGroupLowLevelOperandUsage}},
 		{LLIL_TRAP, {VectorLowLevelOperandUsage}},
 		{LLIL_CALL_SSA, {OutputSSARegistersLowLevelOperandUsage, OutputMemoryVersionLowLevelOperandUsage,
 			DestExprLowLevelOperandUsage, StackSSARegisterLowLevelOperandUsage,
-			StackMemoryVersionLowLevelOperandUsage, ParameterSSARegistersLowLevelOperandUsage}},
+			StackMemoryVersionLowLevelOperandUsage, ParameterExprsLowLevelOperandUsage}},
 		{LLIL_SYSCALL_SSA, {OutputSSARegistersLowLevelOperandUsage, OutputMemoryVersionLowLevelOperandUsage,
 			StackSSARegisterLowLevelOperandUsage, StackMemoryVersionLowLevelOperandUsage,
-			ParameterSSARegistersLowLevelOperandUsage}},
+			ParameterExprsLowLevelOperandUsage}},
 		{LLIL_REG_PHI, {DestSSARegisterLowLevelOperandUsage, SourceSSARegistersLowLevelOperandUsage}},
+		{LLIL_REG_STACK_PHI, {DestSSARegisterStackLowLevelOperandUsage, SourceSSARegisterStacksLowLevelOperandUsage}},
 		{LLIL_FLAG_PHI, {DestSSAFlagLowLevelOperandUsage, SourceSSAFlagsLowLevelOperandUsage}},
 		{LLIL_MEM_PHI, {DestMemoryVersionLowLevelOperandUsage, SourceMemoryVersionsLowLevelOperandUsage}},
 		{LLIL_CONST, {ConstantLowLevelOperandUsage}},
 		{LLIL_CONST_PTR, {ConstantLowLevelOperandUsage}},
+		{LLIL_FLOAT_CONST, {ConstantLowLevelOperandUsage}},
 		{LLIL_ADD, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
 		{LLIL_SUB, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
 		{LLIL_AND, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
@@ -163,10 +201,10 @@ unordered_map<BNLowLevelILOperation, vector<LowLevelILOperandUsage>>
 		{LLIL_SBB, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage, CarryExprLowLevelOperandUsage}},
 		{LLIL_RLC, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage, CarryExprLowLevelOperandUsage}},
 		{LLIL_RRC, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage, CarryExprLowLevelOperandUsage}},
-		{LLIL_DIVU_DP, {HighExprLowLevelOperandUsage, LowExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
-		{LLIL_DIVS_DP, {HighExprLowLevelOperandUsage, LowExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
-		{LLIL_MODU_DP, {HighExprLowLevelOperandUsage, LowExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
-		{LLIL_MODS_DP, {HighExprLowLevelOperandUsage, LowExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_DIVU_DP, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_DIVS_DP, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_MODU_DP, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_MODS_DP, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
 		{LLIL_PUSH, {SourceExprLowLevelOperandUsage}},
 		{LLIL_NEG, {SourceExprLowLevelOperandUsage}},
 		{LLIL_NOT, {SourceExprLowLevelOperandUsage}},
@@ -174,19 +212,45 @@ unordered_map<BNLowLevelILOperation, vector<LowLevelILOperandUsage>>
 		{LLIL_ZX, {SourceExprLowLevelOperandUsage}},
 		{LLIL_LOW_PART, {SourceExprLowLevelOperandUsage}},
 		{LLIL_BOOL_TO_INT, {SourceExprLowLevelOperandUsage}},
-		{LLIL_UNIMPL_MEM, {SourceExprLowLevelOperandUsage}}
+		{LLIL_INTRINSIC, {OutputRegisterOrFlagListLowLevelOperandUsage, IntrinsicLowLevelOperandUsage,
+			ParameterExprsLowLevelOperandUsage}},
+		{LLIL_INTRINSIC_SSA, {OutputSSARegisterOrFlagListLowLevelOperandUsage, IntrinsicLowLevelOperandUsage,
+			ParameterExprsLowLevelOperandUsage}},
+		{LLIL_UNIMPL_MEM, {SourceExprLowLevelOperandUsage}},
+		{LLIL_FADD, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FSUB, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FMUL, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FDIV, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FSQRT, {SourceExprLowLevelOperandUsage}},
+		{LLIL_FNEG, {SourceExprLowLevelOperandUsage}},
+		{LLIL_FABS, {SourceExprLowLevelOperandUsage}},
+		{LLIL_FLOAT_TO_INT, {SourceExprLowLevelOperandUsage}},
+		{LLIL_INT_TO_FLOAT, {SourceExprLowLevelOperandUsage}},
+		{LLIL_FLOAT_CONV, {SourceExprLowLevelOperandUsage}},
+		{LLIL_ROUND_TO_INT, {SourceExprLowLevelOperandUsage}},
+		{LLIL_FLOOR, {SourceExprLowLevelOperandUsage}},
+		{LLIL_CEIL, {SourceExprLowLevelOperandUsage}},
+		{LLIL_FTRUNC, {SourceExprLowLevelOperandUsage}},
+		{LLIL_FCMP_E, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FCMP_NE, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FCMP_LT, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FCMP_LE, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FCMP_GE, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FCMP_GT, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}},
+		{LLIL_FCMP_UO, {LeftExprLowLevelOperandUsage, RightExprLowLevelOperandUsage}}
 	};
 
 
-static unordered_map<BNLowLevelILOperation, unordered_map<LowLevelILOperandUsage, size_t>>
-	GetOperandIndexForOperandUsages()
+static unordered_map<BNLowLevelILOperation, unordered_map<LowLevelILOperandUsage, size_t>> GetOperandIndexForOperandUsages()
 {
 	unordered_map<BNLowLevelILOperation, unordered_map<LowLevelILOperandUsage, size_t>> result;
+	result.reserve(LowLevelILInstructionBase::operationOperandUsage.size());
 	for (auto& operation : LowLevelILInstructionBase::operationOperandUsage)
 	{
 		result[operation.first] = unordered_map<LowLevelILOperandUsage, size_t>();
 
 		size_t operand = 0;
+		result[operation.first].reserve(operation.second.size());
 		for (auto usage : operation.second)
 		{
 			result[operation.first][usage] = operand;
@@ -194,10 +258,12 @@ static unordered_map<BNLowLevelILOperation, unordered_map<LowLevelILOperandUsage
 			{
 			case HighSSARegisterLowLevelOperandUsage:
 			case LowSSARegisterLowLevelOperandUsage:
+			case PartialSSARegisterStackSourceLowLevelOperandUsage:
+			case TopSSARegisterLowLevelOperandUsage:
 				// Represented as subexpression, so only takes one slot even though it is an SSA register
 				operand++;
 				break;
-			case ParameterSSARegistersLowLevelOperandUsage:
+			case ParameterExprsLowLevelOperandUsage:
 				// Represented as subexpression, so only takes one slot even though it is a list
 				operand++;
 				break;
@@ -207,14 +273,22 @@ static unordered_map<BNLowLevelILOperation, unordered_map<LowLevelILOperandUsage
 			case StackSSARegisterLowLevelOperandUsage:
 				// StackMemoryVersionLowLevelOperandUsage follows at same operand
 				break;
+			case DestSSARegisterStackLowLevelOperandUsage:
+				// PartialSSARegisterStackSourceLowLevelOperandUsage follows at same operand
+				break;
 			default:
 				switch (LowLevelILInstructionBase::operandTypeForUsage[usage])
 				{
 				case SSARegisterLowLevelOperand:
+				case SSARegisterStackLowLevelOperand:
 				case SSAFlagLowLevelOperand:
 				case IndexListLowLevelOperand:
 				case SSARegisterListLowLevelOperand:
+				case SSARegisterStackListLowLevelOperand:
 				case SSAFlagListLowLevelOperand:
+				case RegisterStackAdjustmentsLowLevelOperand:
+				case RegisterOrFlagListLowLevelOperand:
+				case SSARegisterOrFlagListLowLevelOperand:
 					// SSA registers/flags and lists take two operand slots
 					operand += 2;
 					break;
@@ -234,6 +308,72 @@ unordered_map<BNLowLevelILOperation, unordered_map<LowLevelILOperandUsage, size_
 	LowLevelILInstructionBase::operationOperandIndex = GetOperandIndexForOperandUsages();
 
 
+RegisterOrFlag::RegisterOrFlag(): isFlag(false), index(BN_INVALID_REGISTER)
+{
+}
+
+
+RegisterOrFlag::RegisterOrFlag(bool flag, uint32_t i): isFlag(flag), index(i)
+{
+}
+
+
+uint32_t RegisterOrFlag::GetRegister() const
+{
+	if (isFlag)
+		throw LowLevelILInstructionAccessException();
+	return index;
+}
+
+
+uint32_t RegisterOrFlag::GetFlag() const
+{
+	if (!isFlag)
+		throw LowLevelILInstructionAccessException();
+	return index;
+}
+
+
+RegisterOrFlag& RegisterOrFlag::operator=(const RegisterOrFlag& v)
+{
+	isFlag = v.isFlag;
+	index = v.index;
+	return *this;
+}
+
+
+bool RegisterOrFlag::operator==(const RegisterOrFlag& v) const
+{
+	if (isFlag != v.isFlag)
+		return false;
+	return index == v.index;
+}
+
+
+bool RegisterOrFlag::operator!=(const RegisterOrFlag& v) const
+{
+	return !((*this) == v);
+}
+
+
+bool RegisterOrFlag::operator<(const RegisterOrFlag& v) const
+{
+	return ToIdentifier() < v.ToIdentifier();
+}
+
+
+uint64_t RegisterOrFlag::ToIdentifier() const
+{
+	return ((uint64_t)index) | (isFlag ? (1LL << 32) : 0);
+}
+
+
+RegisterOrFlag RegisterOrFlag::FromIdentifier(uint64_t id)
+{
+	return RegisterOrFlag((id & (1LL << 32)) != 0, (uint32_t)id);
+}
+
+
 SSARegister::SSARegister(): reg(BN_INVALID_REGISTER), version(0)
 {
 }
@@ -281,6 +421,53 @@ bool SSARegister::operator<(const SSARegister& v) const
 }
 
 
+SSARegisterStack::SSARegisterStack(): regStack(BN_INVALID_REGISTER), version(0)
+{
+}
+
+
+SSARegisterStack::SSARegisterStack(const uint32_t r, size_t i): regStack(r), version(i)
+{
+}
+
+
+SSARegisterStack::SSARegisterStack(const SSARegisterStack& v): regStack(v.regStack), version(v.version)
+{
+}
+
+
+SSARegisterStack& SSARegisterStack::operator=(const SSARegisterStack& v)
+{
+	regStack = v.regStack;
+	version = v.version;
+	return *this;
+}
+
+
+bool SSARegisterStack::operator==(const SSARegisterStack& v) const
+{
+	if (regStack != v.regStack)
+		return false;
+	return version == v.version;
+}
+
+
+bool SSARegisterStack::operator!=(const SSARegisterStack& v) const
+{
+	return !((*this) == v);
+}
+
+
+bool SSARegisterStack::operator<(const SSARegisterStack& v) const
+{
+	if (regStack < v.regStack)
+		return true;
+	if (v.regStack < regStack)
+		return false;
+	return version < v.version;
+}
+
+
 SSAFlag::SSAFlag(): flag(BN_INVALID_REGISTER), version(0)
 {
 }
@@ -328,6 +515,63 @@ bool SSAFlag::operator<(const SSAFlag& v) const
 }
 
 
+SSARegisterOrFlag::SSARegisterOrFlag(): version(0)
+{
+}
+
+
+SSARegisterOrFlag::SSARegisterOrFlag(const RegisterOrFlag& rf, size_t i): regOrFlag(rf), version(i)
+{
+}
+
+
+SSARegisterOrFlag::SSARegisterOrFlag(const SSARegister& v): regOrFlag(false, v.reg), version(v.version)
+{
+}
+
+
+SSARegisterOrFlag::SSARegisterOrFlag(const SSAFlag& v): regOrFlag(true, v.flag), version(v.version)
+{
+}
+
+
+SSARegisterOrFlag::SSARegisterOrFlag(const SSARegisterOrFlag& v): regOrFlag(v.regOrFlag), version(v.version)
+{
+}
+
+
+SSARegisterOrFlag& SSARegisterOrFlag::operator=(const SSARegisterOrFlag& v)
+{
+	regOrFlag = v.regOrFlag;
+	version = v.version;
+	return *this;
+}
+
+
+bool SSARegisterOrFlag::operator==(const SSARegisterOrFlag& v) const
+{
+	if (regOrFlag != v.regOrFlag)
+		return false;
+	return version == v.version;
+}
+
+
+bool SSARegisterOrFlag::operator!=(const SSARegisterOrFlag& v) const
+{
+	return !((*this) == v);
+}
+
+
+bool SSARegisterOrFlag::operator<(const SSARegisterOrFlag& v) const
+{
+	if (regOrFlag < v.regOrFlag)
+		return true;
+	if (v.regOrFlag < regOrFlag)
+		return false;
+	return version < v.version;
+}
+
+
 bool LowLevelILIntegerList::ListIterator::operator==(const ListIterator& a) const
 {
 	return count == a.count;
@@ -377,7 +621,7 @@ uint64_t LowLevelILIntegerList::ListIterator::operator*()
 
 
 LowLevelILIntegerList::LowLevelILIntegerList(LowLevelILFunction* func,
-	const BNLowLevelILInstruction& instr, size_t count)
+const BNLowLevelILInstruction& instr, size_t count)
 {
 	m_start.function = func;
 #ifdef BINARYNINJACORE_LIBRARY
@@ -486,6 +730,118 @@ LowLevelILIndexList::operator vector<size_t>() const
 }
 
 
+const LowLevelILInstruction LowLevelILInstructionList::ListIterator::operator*()
+{
+	return LowLevelILInstruction(pos.GetFunction(), pos.GetFunction()->GetRawExpr((size_t)*pos),
+		(size_t)*pos, instructionIndex);
+}
+
+
+LowLevelILInstructionList::LowLevelILInstructionList(LowLevelILFunction* func,
+	const BNLowLevelILInstruction& instr, size_t count, size_t instrIndex):
+	m_list(func, instr, count), m_instructionIndex(instrIndex)
+{
+}
+
+
+LowLevelILInstructionList::const_iterator LowLevelILInstructionList::begin() const
+{
+	const_iterator result;
+	result.pos = m_list.begin();
+	result.instructionIndex = m_instructionIndex;
+	return result;
+}
+
+
+LowLevelILInstructionList::const_iterator LowLevelILInstructionList::end() const
+{
+	const_iterator result;
+	result.pos = m_list.end();
+	result.instructionIndex = m_instructionIndex;
+	return result;
+}
+
+
+size_t LowLevelILInstructionList::size() const
+{
+	return m_list.size();
+}
+
+
+const LowLevelILInstruction LowLevelILInstructionList::operator[](size_t i) const
+{
+	if (i >= size())
+		throw LowLevelILInstructionAccessException();
+	auto iter = begin();
+	for (size_t j = 0; j < i; j++)
+		++iter;
+	return *iter;
+}
+
+
+LowLevelILInstructionList::operator vector<LowLevelILInstruction>() const
+{
+	vector<LowLevelILInstruction> result;
+	for (auto i : *this)
+		result.push_back(i);
+	return result;
+}
+
+
+const RegisterOrFlag LowLevelILRegisterOrFlagList::ListIterator::operator*()
+{
+	return RegisterOrFlag::FromIdentifier(*pos);
+}
+
+
+LowLevelILRegisterOrFlagList::LowLevelILRegisterOrFlagList(LowLevelILFunction* func,
+	const BNLowLevelILInstruction& instr, size_t count): m_list(func, instr, count)
+{
+}
+
+
+LowLevelILRegisterOrFlagList::const_iterator LowLevelILRegisterOrFlagList::begin() const
+{
+	const_iterator result;
+	result.pos = m_list.begin();
+	return result;
+}
+
+
+LowLevelILRegisterOrFlagList::const_iterator LowLevelILRegisterOrFlagList::end() const
+{
+	const_iterator result;
+	result.pos = m_list.end();
+	return result;
+}
+
+
+size_t LowLevelILRegisterOrFlagList::size() const
+{
+	return m_list.size();
+}
+
+
+const RegisterOrFlag LowLevelILRegisterOrFlagList::operator[](size_t i) const
+{
+	if (i >= size())
+		throw LowLevelILInstructionAccessException();
+	auto iter = begin();
+	for (size_t j = 0; j < i; j++)
+		++iter;
+	return *iter;
+}
+
+
+LowLevelILRegisterOrFlagList::operator vector<RegisterOrFlag>() const
+{
+	vector<RegisterOrFlag> result;
+	for (auto& i : *this)
+		result.push_back(i);
+	return result;
+}
+
+
 const SSARegister LowLevelILSSARegisterList::ListIterator::operator*()
 {
 	LowLevelILIntegerList::const_iterator cur = pos;
@@ -544,6 +900,64 @@ LowLevelILSSARegisterList::operator vector<SSARegister>() const
 }
 
 
+const SSARegisterStack LowLevelILSSARegisterStackList::ListIterator::operator*()
+{
+	LowLevelILIntegerList::const_iterator cur = pos;
+	uint32_t regStack = (uint32_t)*cur;
+	++cur;
+	size_t version = (size_t)*cur;
+	return SSARegisterStack(regStack, version);
+}
+
+
+LowLevelILSSARegisterStackList::LowLevelILSSARegisterStackList(LowLevelILFunction* func,
+	const BNLowLevelILInstruction& instr, size_t count): m_list(func, instr, count & (~1))
+{
+}
+
+
+LowLevelILSSARegisterStackList::const_iterator LowLevelILSSARegisterStackList::begin() const
+{
+	const_iterator result;
+	result.pos = m_list.begin();
+	return result;
+}
+
+
+LowLevelILSSARegisterStackList::const_iterator LowLevelILSSARegisterStackList::end() const
+{
+	const_iterator result;
+	result.pos = m_list.end();
+	return result;
+}
+
+
+size_t LowLevelILSSARegisterStackList::size() const
+{
+	return m_list.size() / 2;
+}
+
+
+const SSARegisterStack LowLevelILSSARegisterStackList::operator[](size_t i) const
+{
+	if (i >= size())
+		throw LowLevelILInstructionAccessException();
+	auto iter = begin();
+	for (size_t j = 0; j < i; j++)
+		++iter;
+	return *iter;
+}
+
+
+LowLevelILSSARegisterStackList::operator vector<SSARegisterStack>() const
+{
+	vector<SSARegisterStack> result;
+	for (auto& i : *this)
+		result.push_back(i);
+	return result;
+}
+
+
 const SSAFlag LowLevelILSSAFlagList::ListIterator::operator*()
 {
 	LowLevelILIntegerList::const_iterator cur = pos;
@@ -602,6 +1016,64 @@ LowLevelILSSAFlagList::operator vector<SSAFlag>() const
 }
 
 
+const SSARegisterOrFlag LowLevelILSSARegisterOrFlagList::ListIterator::operator*()
+{
+	LowLevelILIntegerList::const_iterator cur = pos;
+	RegisterOrFlag rf = RegisterOrFlag::FromIdentifier(*cur);
+	++cur;
+	size_t version = (size_t)*cur;
+	return SSARegisterOrFlag(rf, version);
+}
+
+
+LowLevelILSSARegisterOrFlagList::LowLevelILSSARegisterOrFlagList(LowLevelILFunction* func,
+	const BNLowLevelILInstruction& instr, size_t count): m_list(func, instr, count & (~1))
+{
+}
+
+
+LowLevelILSSARegisterOrFlagList::const_iterator LowLevelILSSARegisterOrFlagList::begin() const
+{
+	const_iterator result;
+	result.pos = m_list.begin();
+	return result;
+}
+
+
+LowLevelILSSARegisterOrFlagList::const_iterator LowLevelILSSARegisterOrFlagList::end() const
+{
+	const_iterator result;
+	result.pos = m_list.end();
+	return result;
+}
+
+
+size_t LowLevelILSSARegisterOrFlagList::size() const
+{
+	return m_list.size() / 2;
+}
+
+
+const SSARegisterOrFlag LowLevelILSSARegisterOrFlagList::operator[](size_t i) const
+{
+	if (i >= size())
+		throw LowLevelILInstructionAccessException();
+	auto iter = begin();
+	for (size_t j = 0; j < i; j++)
+		++iter;
+	return *iter;
+}
+
+
+LowLevelILSSARegisterOrFlagList::operator vector<SSARegisterOrFlag>() const
+{
+	vector<SSARegisterOrFlag> result;
+	for (auto& i : *this)
+		result.push_back(i);
+	return result;
+}
+
+
 LowLevelILOperand::LowLevelILOperand(const LowLevelILInstruction& instr,
 	LowLevelILOperandUsage usage, size_t operandIndex):
 	m_instr(instr), m_usage(usage), m_operandIndex(operandIndex)
@@ -649,6 +1121,14 @@ uint32_t LowLevelILOperand::GetRegister() const
 }
 
 
+uint32_t LowLevelILOperand::GetRegisterStack() const
+{
+	if (m_type != RegisterStackLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsRegister(m_operandIndex);
+}
+
+
 uint32_t LowLevelILOperand::GetFlag() const
 {
 	if (m_type != FlagLowLevelOperand)
@@ -665,17 +1145,53 @@ BNLowLevelILFlagCondition LowLevelILOperand::GetFlagCondition() const
 }
 
 
+uint32_t LowLevelILOperand::GetSemanticFlagClass() const
+{
+	if (m_type != SemanticFlagClassLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsRegister(m_operandIndex);
+}
+
+
+uint32_t LowLevelILOperand::GetSemanticFlagGroup() const
+{
+	if (m_type != SemanticFlagGroupLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsRegister(m_operandIndex);
+}
+
+
+uint32_t LowLevelILOperand::GetIntrinsic() const
+{
+	if (m_type != IntrinsicLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsRegister(m_operandIndex);
+}
+
+
 SSARegister LowLevelILOperand::GetSSARegister() const
 {
 	if (m_type != SSARegisterLowLevelOperand)
 		throw LowLevelILInstructionAccessException();
 	if ((m_usage == HighSSARegisterLowLevelOperandUsage) || (m_usage == LowSSARegisterLowLevelOperandUsage) ||
-		(m_usage == StackSSARegisterLowLevelOperandUsage))
+		(m_usage == StackSSARegisterLowLevelOperandUsage) || (m_usage == TopSSARegisterLowLevelOperandUsage))
 		return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsSSARegister(0);
 	return m_instr.GetRawOperandAsSSARegister(m_operandIndex);
 }
 
 
+SSARegisterStack LowLevelILOperand::GetSSARegisterStack() const
+{
+	if (m_type != SSARegisterStackLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	if (m_usage == DestSSARegisterStackLowLevelOperandUsage)
+		return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsSSARegisterStack(0);
+	if (m_usage == PartialSSARegisterStackSourceLowLevelOperandUsage)
+		return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsPartialSSARegisterStackSource(0);
+	return m_instr.GetRawOperandAsSSARegisterStack(m_operandIndex);
+}
+
+
 SSAFlag LowLevelILOperand::GetSSAFlag() const
 {
 	if (m_type != SSAFlagLowLevelOperand)
@@ -692,18 +1208,40 @@ LowLevelILIndexList LowLevelILOperand::GetIndexList() const
 }
 
 
+LowLevelILInstructionList LowLevelILOperand::GetExprList() const
+{
+	if (m_type != ExprListLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsExprList(0);
+}
+
+
+LowLevelILRegisterOrFlagList LowLevelILOperand::GetRegisterOrFlagList() const
+{
+	if (m_type != RegisterOrFlagListLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsRegisterOrFlagList(m_operandIndex);
+}
+
+
 LowLevelILSSARegisterList LowLevelILOperand::GetSSARegisterList() const
 {
 	if (m_type != SSARegisterListLowLevelOperand)
 		throw LowLevelILInstructionAccessException();
 	if (m_usage == OutputSSARegistersLowLevelOperandUsage)
 		return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsSSARegisterList(1);
-	if (m_usage == ParameterSSARegistersLowLevelOperandUsage)
-		return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsSSARegisterList(0);
 	return m_instr.GetRawOperandAsSSARegisterList(m_operandIndex);
 }
 
 
+LowLevelILSSARegisterStackList LowLevelILOperand::GetSSARegisterStackList() const
+{
+	if (m_type != SSARegisterStackListLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsSSARegisterStackList(m_operandIndex);
+}
+
+
 LowLevelILSSAFlagList LowLevelILOperand::GetSSAFlagList() const
 {
 	if (m_type != SSAFlagListLowLevelOperand)
@@ -712,6 +1250,22 @@ LowLevelILSSAFlagList LowLevelILOperand::GetSSAFlagList() const
 }
 
 
+LowLevelILSSARegisterOrFlagList LowLevelILOperand::GetSSARegisterOrFlagList() const
+{
+	if (m_type != SSARegisterOrFlagListLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsSSARegisterOrFlagList(m_operandIndex);
+}
+
+
+map<uint32_t, int32_t> LowLevelILOperand::GetRegisterStackAdjustments() const
+{
+	if (m_type != RegisterStackAdjustmentsLowLevelOperand)
+		throw LowLevelILInstructionAccessException();
+	return m_instr.GetRawOperandAsRegisterStackAdjustments(m_operandIndex);
+}
+
+
 const LowLevelILOperand LowLevelILOperandList::ListIterator::operator*()
 {
 	LowLevelILOperandUsage usage = *pos;
@@ -869,6 +1423,18 @@ SSARegister LowLevelILInstructionBase::GetRawOperandAsSSARegister(size_t operand
 }
 
 
+SSARegisterStack LowLevelILInstructionBase::GetRawOperandAsSSARegisterStack(size_t operand) const
+{
+	return SSARegisterStack((uint32_t)operands[operand], (size_t)operands[operand + 1]);
+}
+
+
+SSARegisterStack LowLevelILInstructionBase::GetRawOperandAsPartialSSARegisterStackSource(size_t operand) const
+{
+	return SSARegisterStack((uint32_t)operands[operand], (size_t)operands[operand + 2]);
+}
+
+
 SSAFlag LowLevelILInstructionBase::GetRawOperandAsSSAFlag(size_t operand) const
 {
 	return SSAFlag((uint32_t)operands[operand], (size_t)operands[operand + 1]);
@@ -881,18 +1447,61 @@ LowLevelILIndexList LowLevelILInstructionBase::GetRawOperandAsIndexList(size_t o
 }
 
 
+LowLevelILInstructionList LowLevelILInstructionBase::GetRawOperandAsExprList(size_t operand) const
+{
+	return LowLevelILInstructionList(function, function->GetRawExpr(operands[operand + 1]), operands[operand],
+		instructionIndex);
+}
+
+
+LowLevelILRegisterOrFlagList LowLevelILInstructionBase::GetRawOperandAsRegisterOrFlagList(size_t operand) const
+{
+	return LowLevelILRegisterOrFlagList(function, function->GetRawExpr(operands[operand + 1]), operands[operand]);
+}
+
+
 LowLevelILSSARegisterList LowLevelILInstructionBase::GetRawOperandAsSSARegisterList(size_t operand) const
 {
 	return LowLevelILSSARegisterList(function, function->GetRawExpr(operands[operand + 1]), operands[operand]);
 }
 
 
+LowLevelILSSARegisterStackList LowLevelILInstructionBase::GetRawOperandAsSSARegisterStackList(size_t operand) const
+{
+	return LowLevelILSSARegisterStackList(function, function->GetRawExpr(operands[operand + 1]), operands[operand]);
+}
+
+
 LowLevelILSSAFlagList LowLevelILInstructionBase::GetRawOperandAsSSAFlagList(size_t operand) const
 {
 	return LowLevelILSSAFlagList(function, function->GetRawExpr(operands[operand + 1]), operands[operand]);
 }
 
 
+LowLevelILSSARegisterOrFlagList LowLevelILInstructionBase::GetRawOperandAsSSARegisterOrFlagList(size_t operand) const
+{
+	return LowLevelILSSARegisterOrFlagList(function, function->GetRawExpr(operands[operand + 1]), operands[operand]);
+}
+
+
+map<uint32_t, int32_t> LowLevelILInstructionBase::GetRawOperandAsRegisterStackAdjustments(size_t operand) const
+{
+	LowLevelILIntegerList list(function, function->GetRawExpr(operands[operand + 1]), operands[operand]);
+	map<uint32_t, int32_t> result;
+	for (auto i = list.begin(); i != list.end(); )
+	{
+		uint32_t regStack = (uint32_t)*i;
+		++i;
+		if (i == list.end())
+			break;
+		int32_t adjust = (int32_t)*i;
+		++i;
+		result[regStack] = adjust;
+	}
+	return result;
+}
+
+
 void LowLevelILInstructionBase::UpdateRawOperand(size_t operandIndex, ExprId value)
 {
 	operands[operandIndex] = value;
@@ -907,6 +1516,14 @@ void LowLevelILInstructionBase::UpdateRawOperandAsSSARegisterList(size_t operand
 }
 
 
+void LowLevelILInstructionBase::UpdateRawOperandAsSSARegisterOrFlagList(size_t operandIndex,
+	const vector<SSARegisterOrFlag>& outputs)
+{
+	UpdateRawOperand(operandIndex, outputs.size() * 2);
+	UpdateRawOperand(operandIndex + 1, function->AddSSARegisterOrFlagList(outputs));
+}
+
+
 RegisterValue LowLevelILInstructionBase::GetValue() const
 {
 	return function->GetExprValue(*(const LowLevelILInstruction*)this);
@@ -1130,12 +1747,38 @@ void LowLevelILInstruction::VisitExprs(const std::function<bool(const LowLevelIL
 	case LLIL_SET_REG_SPLIT_SSA:
 		GetSourceExpr<LLIL_SET_REG_SPLIT_SSA>().VisitExprs(func);
 		break;
+	case LLIL_SET_REG_STACK_REL:
+		GetDestExpr<LLIL_SET_REG_STACK_REL>().VisitExprs(func);
+		GetSourceExpr<LLIL_SET_REG_STACK_REL>().VisitExprs(func);
+		break;
+	case LLIL_REG_STACK_PUSH:
+		GetSourceExpr<LLIL_REG_STACK_PUSH>().VisitExprs(func);
+		break;
+	case LLIL_SET_REG_STACK_REL_SSA:
+		GetDestExpr<LLIL_SET_REG_STACK_REL_SSA>().VisitExprs(func);
+		GetSourceExpr<LLIL_SET_REG_STACK_REL_SSA>().VisitExprs(func);
+		break;
+	case LLIL_SET_REG_STACK_ABS_SSA:
+		GetSourceExpr<LLIL_SET_REG_STACK_ABS_SSA>().VisitExprs(func);
+		break;
 	case LLIL_SET_FLAG:
 		GetSourceExpr<LLIL_SET_FLAG>().VisitExprs(func);
 		break;
 	case LLIL_SET_FLAG_SSA:
 		GetSourceExpr<LLIL_SET_FLAG_SSA>().VisitExprs(func);
 		break;
+	case LLIL_REG_STACK_REL:
+		GetSourceExpr<LLIL_REG_STACK_REL>().VisitExprs(func);
+		break;
+	case LLIL_REG_STACK_FREE_REL:
+		GetDestExpr<LLIL_REG_STACK_FREE_REL>().VisitExprs(func);
+		break;
+	case LLIL_REG_STACK_REL_SSA:
+		GetSourceExpr<LLIL_REG_STACK_REL_SSA>().VisitExprs(func);
+		break;
+	case LLIL_REG_STACK_FREE_REL_SSA:
+		GetDestExpr<LLIL_REG_STACK_FREE_REL_SSA>().VisitExprs(func);
+		break;
 	case LLIL_LOAD:
 		GetSourceExpr<LLIL_LOAD>().VisitExprs(func);
 		break;
@@ -1167,6 +1810,12 @@ void LowLevelILInstruction::VisitExprs(const std::function<bool(const LowLevelIL
 		break;
 	case LLIL_CALL_SSA:
 		GetDestExpr<LLIL_CALL_SSA>().VisitExprs(func);
+		for (auto& i : GetParameterExprs<LLIL_CALL_SSA>())
+			i.VisitExprs(func);
+		break;
+	case LLIL_SYSCALL_SSA:
+		for (auto& i : GetParameterExprs<LLIL_SYSCALL_SSA>())
+			i.VisitExprs(func);
 		break;
 	case LLIL_RET:
 		GetDestExpr<LLIL_RET>().VisitExprs(func);
@@ -1179,6 +1828,16 @@ void LowLevelILInstruction::VisitExprs(const std::function<bool(const LowLevelIL
 	case LLIL_LOW_PART:
 	case LLIL_BOOL_TO_INT:
 	case LLIL_UNIMPL_MEM:
+	case LLIL_FSQRT:
+	case LLIL_FNEG:
+	case LLIL_FABS:
+	case LLIL_FLOAT_TO_INT:
+	case LLIL_INT_TO_FLOAT:
+	case LLIL_FLOAT_CONV:
+	case LLIL_ROUND_TO_INT:
+	case LLIL_FLOOR:
+	case LLIL_CEIL:
+	case LLIL_FTRUNC:
 		AsOneOperand().GetSourceExpr().VisitExprs(func);
 		break;
 	case LLIL_ADD:
@@ -1198,6 +1857,10 @@ void LowLevelILInstruction::VisitExprs(const std::function<bool(const LowLevelIL
 	case LLIL_DIVS:
 	case LLIL_MODU:
 	case LLIL_MODS:
+	case LLIL_DIVU_DP:
+	case LLIL_DIVS_DP:
+	case LLIL_MODU_DP:
+	case LLIL_MODS_DP:
 	case LLIL_CMP_E:
 	case LLIL_CMP_NE:
 	case LLIL_CMP_SLT:
@@ -1210,6 +1873,17 @@ void LowLevelILInstruction::VisitExprs(const std::function<bool(const LowLevelIL
 	case LLIL_CMP_UGT:
 	case LLIL_TEST_BIT:
 	case LLIL_ADD_OVERFLOW:
+	case LLIL_FADD:
+	case LLIL_FSUB:
+	case LLIL_FMUL:
+	case LLIL_FDIV:
+	case LLIL_FCMP_E:
+	case LLIL_FCMP_NE:
+	case LLIL_FCMP_LT:
+	case LLIL_FCMP_LE:
+	case LLIL_FCMP_GE:
+	case LLIL_FCMP_GT:
+	case LLIL_FCMP_UO:
 		AsTwoOperand().GetLeftExpr().VisitExprs(func);
 		AsTwoOperand().GetRightExpr().VisitExprs(func);
 		break;
@@ -1221,13 +1895,13 @@ void LowLevelILInstruction::VisitExprs(const std::function<bool(const LowLevelIL
 		AsTwoOperandWithCarry().GetRightExpr().VisitExprs(func);
 		AsTwoOperandWithCarry().GetCarryExpr().VisitExprs(func);
 		break;
-	case LLIL_DIVU_DP:
-	case LLIL_DIVS_DP:
-	case LLIL_MODU_DP:
-	case LLIL_MODS_DP:
-		AsDoublePrecision().GetHighExpr().VisitExprs(func);
-		AsDoublePrecision().GetLowExpr().VisitExprs(func);
-		AsDoublePrecision().GetRightExpr().VisitExprs(func);
+	case LLIL_INTRINSIC:
+		for (auto& i : GetParameterExprs<LLIL_INTRINSIC>())
+			i.VisitExprs(func);
+		break;
+	case LLIL_INTRINSIC_SSA:
+		for (auto& i : GetParameterExprs<LLIL_INTRINSIC_SSA>())
+			i.VisitExprs(func);
 		break;
 	default:
 		break;
@@ -1247,6 +1921,7 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 	const std::function<ExprId(const LowLevelILInstruction& subExpr)>& subExprHandler) const
 {
 	vector<BNLowLevelILLabel*> labelList;
+	vector<ExprId> params;
 	BNLowLevelILLabel* labelA;
 	BNLowLevelILLabel* labelB;
 	switch (operation)
@@ -1270,6 +1945,25 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 		return dest->SetRegisterSplitSSA(size, GetHighSSARegister<LLIL_SET_REG_SPLIT_SSA>(),
 			GetLowSSARegister<LLIL_SET_REG_SPLIT_SSA>(),
 			subExprHandler(GetSourceExpr<LLIL_SET_REG_SPLIT_SSA>()), *this);
+	case LLIL_SET_REG_STACK_REL:
+		return dest->SetRegisterStackTopRelative(size, GetDestRegisterStack<LLIL_SET_REG_STACK_REL>(),
+			subExprHandler(GetDestExpr<LLIL_SET_REG_STACK_REL>()),
+			subExprHandler(GetSourceExpr<LLIL_SET_REG_STACK_REL>()), flags, *this);
+	case LLIL_REG_STACK_PUSH:
+		return dest->RegisterStackPush(size, GetDestRegisterStack<LLIL_REG_STACK_PUSH>(),
+			subExprHandler(GetSourceExpr<LLIL_REG_STACK_PUSH>()), flags, *this);
+	case LLIL_SET_REG_STACK_REL_SSA:
+		return dest->SetRegisterStackTopRelativeSSA(size, GetDestSSARegisterStack<LLIL_SET_REG_STACK_REL_SSA>().regStack,
+			GetDestSSARegisterStack<LLIL_SET_REG_STACK_REL_SSA>().version,
+			GetSourceSSARegisterStack<LLIL_SET_REG_STACK_REL_SSA>().version,
+			subExprHandler(GetDestExpr<LLIL_SET_REG_STACK_REL_SSA>()), GetTopSSARegister<LLIL_SET_REG_STACK_REL_SSA>(),
+			subExprHandler(GetSourceExpr<LLIL_SET_REG_STACK_REL_SSA>()), *this);
+	case LLIL_SET_REG_STACK_ABS_SSA:
+		return dest->SetRegisterStackAbsoluteSSA(size, GetDestSSARegisterStack<LLIL_SET_REG_STACK_ABS_SSA>().regStack,
+			GetDestSSARegisterStack<LLIL_SET_REG_STACK_ABS_SSA>().version,
+			GetSourceSSARegisterStack<LLIL_SET_REG_STACK_ABS_SSA>().version,
+			GetDestRegister<LLIL_SET_REG_STACK_ABS_SSA>(),
+			subExprHandler(GetSourceExpr<LLIL_SET_REG_STACK_ABS_SSA>()), *this);
 	case LLIL_SET_FLAG:
 		return dest->SetFlag(GetDestFlag<LLIL_SET_FLAG>(), subExprHandler(GetSourceExpr<LLIL_SET_FLAG>()), *this);
 	case LLIL_SET_FLAG_SSA:
@@ -1294,6 +1988,40 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 	case LLIL_REG_SSA_PARTIAL:
 		return dest->RegisterSSAPartial(size, GetSourceSSARegister<LLIL_REG_SSA_PARTIAL>(),
 			GetPartialRegister<LLIL_REG_SSA_PARTIAL>(), *this);
+	case LLIL_REG_SPLIT:
+		return dest->RegisterSplit(size, GetHighRegister<LLIL_REG_SPLIT>(),
+			GetLowRegister<LLIL_REG_SPLIT>(), *this);
+	case LLIL_REG_SPLIT_SSA:
+		return dest->RegisterSplitSSA(size, GetHighSSARegister<LLIL_REG_SPLIT_SSA>(),
+			GetLowSSARegister<LLIL_REG_SPLIT_SSA>(), *this);
+	case LLIL_REG_STACK_REL:
+		return dest->RegisterStackTopRelative(size, GetSourceRegisterStack<LLIL_REG_STACK_REL>(),
+			subExprHandler(GetSourceExpr<LLIL_REG_STACK_REL>()), *this);
+	case LLIL_REG_STACK_POP:
+		return dest->RegisterStackPop(size, GetSourceRegisterStack<LLIL_REG_STACK_POP>(), flags, *this);
+	case LLIL_REG_STACK_FREE_REG:
+		return dest->RegisterStackFreeReg(GetDestRegister<LLIL_REG_STACK_FREE_REG>(), *this);
+	case LLIL_REG_STACK_FREE_REL:
+		return dest->RegisterStackFreeTopRelative(GetDestRegisterStack<LLIL_REG_STACK_FREE_REL>(),
+			subExprHandler(GetDestExpr<LLIL_REG_STACK_FREE_REL>()), *this);
+	case LLIL_REG_STACK_REL_SSA:
+		return dest->RegisterStackTopRelativeSSA(size, GetSourceSSARegisterStack<LLIL_REG_STACK_REL_SSA>(),
+			subExprHandler(GetSourceExpr<LLIL_REG_STACK_REL_SSA>()),
+			GetTopSSARegister<LLIL_REG_STACK_REL_SSA>(), *this);
+	case LLIL_REG_STACK_ABS_SSA:
+		return dest->RegisterStackAbsoluteSSA(size, GetSourceSSARegisterStack<LLIL_REG_STACK_ABS_SSA>(),
+			GetSourceRegister<LLIL_REG_STACK_ABS_SSA>(), *this);
+	case LLIL_REG_STACK_FREE_REL_SSA:
+		return dest->RegisterStackFreeTopRelativeSSA(GetDestSSARegisterStack<LLIL_REG_STACK_FREE_REL_SSA>().regStack,
+			GetDestSSARegisterStack<LLIL_REG_STACK_FREE_REL_SSA>().version,
+			GetSourceSSARegisterStack<LLIL_REG_STACK_FREE_REL_SSA>().version,
+			subExprHandler(GetDestExpr<LLIL_REG_STACK_FREE_REL_SSA>()),
+			GetTopSSARegister<LLIL_REG_STACK_FREE_REL_SSA>(), *this);
+	case LLIL_REG_STACK_FREE_ABS_SSA:
+		return dest->RegisterStackFreeAbsoluteSSA(GetDestSSARegisterStack<LLIL_REG_STACK_FREE_ABS_SSA>().regStack,
+			GetDestSSARegisterStack<LLIL_REG_STACK_FREE_ABS_SSA>().version,
+			GetSourceSSARegisterStack<LLIL_REG_STACK_FREE_ABS_SSA>().version,
+			GetDestRegister<LLIL_REG_STACK_FREE_ABS_SSA>(), *this);
 	case LLIL_FLAG:
 		return dest->Flag(GetSourceFlag<LLIL_FLAG>(), *this);
 	case LLIL_FLAG_SSA:
@@ -1308,7 +2036,7 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 		return dest->Call(subExprHandler(GetDestExpr<LLIL_CALL>()), *this);
 	case LLIL_CALL_STACK_ADJUST:
 		return dest->CallStackAdjust(subExprHandler(GetDestExpr<LLIL_CALL_STACK_ADJUST>()),
-			GetStackAdjustment<LLIL_CALL_STACK_ADJUST>(), *this);
+			GetStackAdjustment<LLIL_CALL_STACK_ADJUST>(), GetRegisterStackAdjustments<LLIL_CALL_STACK_ADJUST>(), *this);
 	case LLIL_RET:
 		return dest->Return(subExprHandler(GetDestExpr<LLIL_RET>()), *this);
 	case LLIL_JUMP_TO:
@@ -1335,19 +2063,28 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 			return dest->Undefined(*this);
 		return dest->If(subExprHandler(GetConditionExpr<LLIL_IF>()), *labelA, *labelB, *this);
 	case LLIL_FLAG_COND:
-		return dest->FlagCondition(GetFlagCondition<LLIL_FLAG_COND>(), *this);
+		return dest->FlagCondition(GetFlagCondition<LLIL_FLAG_COND>(), GetSemanticFlagClass<LLIL_FLAG_COND>(), *this);
+	case LLIL_FLAG_GROUP:
+		return dest->FlagGroup(GetSemanticFlagGroup<LLIL_FLAG_GROUP>(), *this);
 	case LLIL_TRAP:
 		return dest->Trap(GetVector<LLIL_TRAP>(), *this);
 	case LLIL_CALL_SSA:
+		for (auto& i : GetParameterExprs<LLIL_CALL_SSA>())
+			params.push_back(subExprHandler(i));
 		return dest->CallSSA(GetOutputSSARegisters<LLIL_CALL_SSA>(), subExprHandler(GetDestExpr<LLIL_CALL_SSA>()),
-			GetParameterSSARegisters<LLIL_CALL_SSA>(), GetStackSSARegister<LLIL_CALL_SSA>(),
-			GetDestMemoryVersion<LLIL_CALL_SSA>(), GetSourceMemoryVersion<LLIL_CALL_SSA>(), *this);
+			params, GetStackSSARegister<LLIL_CALL_SSA>(), GetDestMemoryVersion<LLIL_CALL_SSA>(),
+			GetSourceMemoryVersion<LLIL_CALL_SSA>(), *this);
 	case LLIL_SYSCALL_SSA:
+		for (auto& i : GetParameterExprs<LLIL_SYSCALL_SSA>())
+			params.push_back(subExprHandler(i));
 		return dest->SystemCallSSA(GetOutputSSARegisters<LLIL_SYSCALL_SSA>(),
-			GetParameterSSARegisters<LLIL_SYSCALL_SSA>(), GetStackSSARegister<LLIL_SYSCALL_SSA>(),
-			GetDestMemoryVersion<LLIL_SYSCALL_SSA>(), GetSourceMemoryVersion<LLIL_SYSCALL_SSA>(), *this);
+			params, GetStackSSARegister<LLIL_SYSCALL_SSA>(), GetDestMemoryVersion<LLIL_SYSCALL_SSA>(),
+			GetSourceMemoryVersion<LLIL_SYSCALL_SSA>(), *this);
 	case LLIL_REG_PHI:
 		return dest->RegisterPhi(GetDestSSARegister<LLIL_REG_PHI>(), GetSourceSSARegisters<LLIL_REG_PHI>(), *this);
+	case LLIL_REG_STACK_PHI:
+		return dest->RegisterStackPhi(GetDestSSARegisterStack<LLIL_REG_STACK_PHI>(),
+			GetSourceSSARegisterStacks<LLIL_REG_STACK_PHI>(), *this);
 	case LLIL_FLAG_PHI:
 		return dest->FlagPhi(GetDestSSAFlag<LLIL_FLAG_PHI>(), GetSourceSSAFlags<LLIL_FLAG_PHI>(), *this);
 	case LLIL_MEM_PHI:
@@ -1356,6 +2093,8 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 		return dest->Const(size, GetConstant<LLIL_CONST>(), *this);
 	case LLIL_CONST_PTR:
 		return dest->ConstPointer(size, GetConstant<LLIL_CONST_PTR>(), *this);
+	case LLIL_FLOAT_CONST:
+		return dest->FloatConstRaw(size, GetConstant<LLIL_FLOAT_CONST>(), *this);
 	case LLIL_POP:
 	case LLIL_NORET:
 	case LLIL_SYSCALL:
@@ -1371,6 +2110,16 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 	case LLIL_LOW_PART:
 	case LLIL_BOOL_TO_INT:
 	case LLIL_UNIMPL_MEM:
+	case LLIL_FSQRT:
+	case LLIL_FNEG:
+	case LLIL_FABS:
+	case LLIL_FLOAT_TO_INT:
+	case LLIL_INT_TO_FLOAT:
+	case LLIL_FLOAT_CONV:
+	case LLIL_ROUND_TO_INT:
+	case LLIL_FLOOR:
+	case LLIL_CEIL:
+	case LLIL_FTRUNC:
 		return dest->AddExprWithLocation(operation, *this, size, flags,
 			subExprHandler(AsOneOperand().GetSourceExpr()));
 	case LLIL_ADD:
@@ -1390,6 +2139,10 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 	case LLIL_DIVS:
 	case LLIL_MODU:
 	case LLIL_MODS:
+	case LLIL_DIVU_DP:
+	case LLIL_DIVS_DP:
+	case LLIL_MODU_DP:
+	case LLIL_MODS_DP:
 	case LLIL_CMP_E:
 	case LLIL_CMP_NE:
 	case LLIL_CMP_SLT:
@@ -1402,6 +2155,18 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 	case LLIL_CMP_UGT:
 	case LLIL_TEST_BIT:
 	case LLIL_ADD_OVERFLOW:
+	case LLIL_FADD:
+	case LLIL_FSUB:
+	case LLIL_FMUL:
+	case LLIL_FDIV:
+	case LLIL_FCMP_E:
+	case LLIL_FCMP_NE:
+	case LLIL_FCMP_LT:
+	case LLIL_FCMP_LE:
+	case LLIL_FCMP_GE:
+	case LLIL_FCMP_GT:
+	case LLIL_FCMP_O:
+	case LLIL_FCMP_UO:
 		return dest->AddExprWithLocation(operation, *this, size, flags,
 			subExprHandler(AsTwoOperand().GetLeftExpr()), subExprHandler(AsTwoOperand().GetRightExpr()));
 	case LLIL_ADC:
@@ -1412,14 +2177,16 @@ ExprId LowLevelILInstruction::CopyTo(LowLevelILFunction* dest,
 			subExprHandler(AsTwoOperandWithCarry().GetLeftExpr()),
 			subExprHandler(AsTwoOperandWithCarry().GetRightExpr()),
 			subExprHandler(AsTwoOperandWithCarry().GetCarryExpr()));
-	case LLIL_DIVU_DP:
-	case LLIL_DIVS_DP:
-	case LLIL_MODU_DP:
-	case LLIL_MODS_DP:
-		return dest->AddExprWithLocation(operation, *this, size, flags,
-			subExprHandler(AsDoublePrecision().GetHighExpr()),
-			subExprHandler(AsDoublePrecision().GetLowExpr()),
-			subExprHandler(AsDoublePrecision().GetRightExpr()));
+	case LLIL_INTRINSIC:
+		for (auto& i : GetParameterExprs<LLIL_INTRINSIC>())
+			params.push_back(subExprHandler(i));
+		return dest->Intrinsic(GetOutputRegisterOrFlagList<LLIL_INTRINSIC>(), GetIntrinsic<LLIL_INTRINSIC>(),
+			params, flags, *this);
+	case LLIL_INTRINSIC_SSA:
+		for (auto& i : GetParameterExprs<LLIL_INTRINSIC_SSA>())
+			params.push_back(subExprHandler(i));
+		return dest->IntrinsicSSA(GetOutputSSARegisterOrFlagList<LLIL_INTRINSIC_SSA>(), GetIntrinsic<LLIL_INTRINSIC_SSA>(),
+			params, *this);
 	default:
 		throw LowLevelILInstructionAccessException();
 	}
@@ -1457,6 +2224,15 @@ uint32_t LowLevelILInstruction::GetSourceRegister() const
 }
 
 
+uint32_t LowLevelILInstruction::GetSourceRegisterStack() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(SourceRegisterStackLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsRegister(operandIndex);
+	throw LowLevelILInstructionAccessException();
+}
+
+
 uint32_t LowLevelILInstruction::GetSourceFlag() const
 {
 	size_t operandIndex;
@@ -1475,6 +2251,17 @@ SSARegister LowLevelILInstruction::GetSourceSSARegister() const
 }
 
 
+SSARegisterStack LowLevelILInstruction::GetSourceSSARegisterStack() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(PartialSSARegisterStackSourceLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsExpr(operandIndex).GetRawOperandAsPartialSSARegisterStackSource(0);
+	if (GetOperandIndexForUsage(SourceSSARegisterStackLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsSSARegisterStack(operandIndex);
+	throw LowLevelILInstructionAccessException();
+}
+
+
 SSAFlag LowLevelILInstruction::GetSourceSSAFlag() const
 {
 	size_t operandIndex;
@@ -1502,6 +2289,15 @@ uint32_t LowLevelILInstruction::GetDestRegister() const
 }
 
 
+uint32_t LowLevelILInstruction::GetDestRegisterStack() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(DestRegisterStackLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsRegister(operandIndex);
+	throw LowLevelILInstructionAccessException();
+}
+
+
 uint32_t LowLevelILInstruction::GetDestFlag() const
 {
 	size_t operandIndex;
@@ -1520,6 +2316,15 @@ SSARegister LowLevelILInstruction::GetDestSSARegister() const
 }
 
 
+SSARegisterStack LowLevelILInstruction::GetDestSSARegisterStack() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(DestSSARegisterStackLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsExpr(operandIndex).GetRawOperandAsSSARegisterStack(0);
+	throw LowLevelILInstructionAccessException();
+}
+
+
 SSAFlag LowLevelILInstruction::GetDestSSAFlag() const
 {
 	size_t operandIndex;
@@ -1529,64 +2334,73 @@ SSAFlag LowLevelILInstruction::GetDestSSAFlag() const
 }
 
 
-uint32_t LowLevelILInstruction::GetPartialRegister() const
+uint32_t LowLevelILInstruction::GetSemanticFlagClass() const
 {
 	size_t operandIndex;
-	if (GetOperandIndexForUsage(PartialRegisterLowLevelOperandUsage, operandIndex))
+	if (GetOperandIndexForUsage(SemanticFlagClassLowLevelOperandUsage, operandIndex))
 		return GetRawOperandAsRegister(operandIndex);
 	throw LowLevelILInstructionAccessException();
 }
 
 
-SSARegister LowLevelILInstruction::GetStackSSARegister() const
+uint32_t LowLevelILInstruction::GetSemanticFlagGroup() const
 {
 	size_t operandIndex;
-	if (GetOperandIndexForUsage(StackSSARegisterLowLevelOperandUsage, operandIndex))
-		return GetRawOperandAsExpr(operandIndex).GetRawOperandAsSSARegister(0);
+	if (GetOperandIndexForUsage(SemanticFlagGroupLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsRegister(operandIndex);
 	throw LowLevelILInstructionAccessException();
 }
 
 
-LowLevelILInstruction LowLevelILInstruction::GetLeftExpr() const
+uint32_t LowLevelILInstruction::GetPartialRegister() const
 {
 	size_t operandIndex;
-	if (GetOperandIndexForUsage(LeftExprLowLevelOperandUsage, operandIndex))
-		return GetRawOperandAsExpr(operandIndex);
+	if (GetOperandIndexForUsage(PartialRegisterLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsRegister(operandIndex);
 	throw LowLevelILInstructionAccessException();
 }
 
 
-LowLevelILInstruction LowLevelILInstruction::GetRightExpr() const
+SSARegister LowLevelILInstruction::GetStackSSARegister() const
 {
 	size_t operandIndex;
-	if (GetOperandIndexForUsage(RightExprLowLevelOperandUsage, operandIndex))
-		return GetRawOperandAsExpr(operandIndex);
+	if (GetOperandIndexForUsage(StackSSARegisterLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsExpr(operandIndex).GetRawOperandAsSSARegister(0);
 	throw LowLevelILInstructionAccessException();
 }
 
 
-LowLevelILInstruction LowLevelILInstruction::GetCarryExpr() const
+SSARegister LowLevelILInstruction::GetTopSSARegister() const
 {
 	size_t operandIndex;
-	if (GetOperandIndexForUsage(CarryExprLowLevelOperandUsage, operandIndex))
+	if (GetOperandIndexForUsage(TopSSARegisterLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsExpr(operandIndex).GetRawOperandAsSSARegister(0);
+	throw LowLevelILInstructionAccessException();
+}
+
+
+LowLevelILInstruction LowLevelILInstruction::GetLeftExpr() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(LeftExprLowLevelOperandUsage, operandIndex))
 		return GetRawOperandAsExpr(operandIndex);
 	throw LowLevelILInstructionAccessException();
 }
 
 
-LowLevelILInstruction LowLevelILInstruction::GetHighExpr() const
+LowLevelILInstruction LowLevelILInstruction::GetRightExpr() const
 {
 	size_t operandIndex;
-	if (GetOperandIndexForUsage(HighExprLowLevelOperandUsage, operandIndex))
+	if (GetOperandIndexForUsage(RightExprLowLevelOperandUsage, operandIndex))
 		return GetRawOperandAsExpr(operandIndex);
 	throw LowLevelILInstructionAccessException();
 }
 
 
-LowLevelILInstruction LowLevelILInstruction::GetLowExpr() const
+LowLevelILInstruction LowLevelILInstruction::GetCarryExpr() const
 {
 	size_t operandIndex;
-	if (GetOperandIndexForUsage(LowExprLowLevelOperandUsage, operandIndex))
+	if (GetOperandIndexForUsage(CarryExprLowLevelOperandUsage, operandIndex))
 		return GetRawOperandAsExpr(operandIndex);
 	throw LowLevelILInstructionAccessException();
 }
@@ -1637,6 +2451,15 @@ SSARegister LowLevelILInstruction::GetLowSSARegister() const
 }
 
 
+uint32_t LowLevelILInstruction::GetIntrinsic() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(IntrinsicLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsRegister(operandIndex);
+	throw LowLevelILInstructionAccessException();
+}
+
+
 int64_t LowLevelILInstruction::GetConstant() const
 {
 	size_t operandIndex;
@@ -1740,11 +2563,11 @@ LowLevelILSSARegisterList LowLevelILInstruction::GetOutputSSARegisters() const
 }
 
 
-LowLevelILSSARegisterList LowLevelILInstruction::GetParameterSSARegisters() const
+LowLevelILInstructionList LowLevelILInstruction::GetParameterExprs() const
 {
 	size_t operandIndex;
-	if (GetOperandIndexForUsage(ParameterSSARegistersLowLevelOperandUsage, operandIndex))
-		return GetRawOperandAsExpr(operandIndex).GetRawOperandAsSSARegisterList(0);
+	if (GetOperandIndexForUsage(ParameterExprsLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsExpr(operandIndex).GetRawOperandAsExprList(0);
 	throw LowLevelILInstructionAccessException();
 }
 
@@ -1758,6 +2581,15 @@ LowLevelILSSARegisterList LowLevelILInstruction::GetSourceSSARegisters() const
 }
 
 
+LowLevelILSSARegisterStackList LowLevelILInstruction::GetSourceSSARegisterStacks() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(SourceSSARegisterStacksLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsSSARegisterStackList(operandIndex);
+	throw LowLevelILInstructionAccessException();
+}
+
+
 LowLevelILSSAFlagList LowLevelILInstruction::GetSourceSSAFlags() const
 {
 	size_t operandIndex;
@@ -1767,6 +2599,24 @@ LowLevelILSSAFlagList LowLevelILInstruction::GetSourceSSAFlags() const
 }
 
 
+LowLevelILRegisterOrFlagList LowLevelILInstruction::GetOutputRegisterOrFlagList() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(OutputRegisterOrFlagListLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsRegisterOrFlagList(operandIndex);
+	throw LowLevelILInstructionAccessException();
+}
+
+
+LowLevelILSSARegisterOrFlagList LowLevelILInstruction::GetOutputSSARegisterOrFlagList() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(OutputSSARegisterOrFlagListLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsSSARegisterOrFlagList(operandIndex);
+	throw LowLevelILInstructionAccessException();
+}
+
+
 LowLevelILIndexList LowLevelILInstruction::GetSourceMemoryVersions() const
 {
 	size_t operandIndex;
@@ -1785,6 +2635,15 @@ LowLevelILIndexList LowLevelILInstruction::GetTargetList() const
 }
 
 
+map<uint32_t, int32_t> LowLevelILInstruction::GetRegisterStackAdjustments() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(RegisterStackAdjustmentsLowLevelOperandUsage, operandIndex))
+		return GetRawOperandAsRegisterStackAdjustments(operandIndex);
+	throw LowLevelILInstructionAccessException();
+}
+
+
 ExprId LowLevelILFunction::Nop(const ILSourceLocation& loc)
 {
 	return AddExprWithLocation(LLIL_NOP, loc, 0, 0);
@@ -1828,6 +2687,39 @@ ExprId LowLevelILFunction::SetRegisterSplitSSA(size_t size, const SSARegister& h
 }
 
 
+ExprId LowLevelILFunction::SetRegisterStackTopRelative(size_t size, uint32_t regStack, ExprId entry,
+	ExprId val, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_SET_REG_STACK_REL, loc, size, flags, regStack, entry, val);
+}
+
+
+ExprId LowLevelILFunction::RegisterStackPush(size_t size, uint32_t regStack, ExprId val,
+	uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_PUSH, loc, size, flags, regStack, val);
+}
+
+
+ExprId LowLevelILFunction::SetRegisterStackTopRelativeSSA(size_t size, uint32_t regStack,
+	size_t destVersion, size_t srcVersion, ExprId entry, const SSARegister& top,
+	ExprId val, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_SET_REG_STACK_REL_SSA, loc, size, 0,
+		AddExprWithLocation(LLIL_REG_STACK_DEST_SSA, loc, size, 0, regStack, destVersion, srcVersion),
+		entry, AddExprWithLocation(LLIL_REG_SSA, loc, 0, 0, top.reg, top.version), val);
+}
+
+
+ExprId LowLevelILFunction::SetRegisterStackAbsoluteSSA(size_t size, uint32_t regStack,
+	size_t destVersion, size_t srcVersion, uint32_t reg, ExprId val, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_SET_REG_STACK_ABS_SSA, loc, size, 0,
+		AddExprWithLocation(LLIL_REG_STACK_DEST_SSA, loc, size, 0, regStack, destVersion, srcVersion),
+		reg, val);
+}
+
+
 ExprId LowLevelILFunction::SetFlag(uint32_t flag, ExprId val, const ILSourceLocation& loc)
 {
 	return AddExprWithLocation(LLIL_SET_FLAG, loc, 0, 0, flag, val);
@@ -1899,6 +2791,77 @@ ExprId LowLevelILFunction::RegisterSSAPartial(size_t size, const SSARegister& fu
 }
 
 
+ExprId LowLevelILFunction::RegisterSplit(size_t size, uint32_t high, uint32_t low, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_SPLIT, loc, size, 0, high, low);
+}
+
+
+ExprId LowLevelILFunction::RegisterSplitSSA(size_t size, const SSARegister& high, const SSARegister& low,
+	const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_SPLIT_SSA, loc, size, 0, high.reg, high.version, low.reg, low.version);
+}
+
+
+ExprId LowLevelILFunction::RegisterStackTopRelative(size_t size, uint32_t regStack, ExprId entry,
+	const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_REL, loc, size, 0, regStack, entry);
+}
+
+
+ExprId LowLevelILFunction::RegisterStackPop(size_t size, uint32_t regStack, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_POP, loc, size, flags, regStack);
+}
+
+
+ExprId LowLevelILFunction::RegisterStackFreeReg(uint32_t reg, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_FREE_REG, loc, 0, 0, reg);
+}
+
+
+ExprId LowLevelILFunction::RegisterStackFreeTopRelative(uint32_t regStack, ExprId entry, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_FREE_REG, loc, 0, 0, regStack, entry);
+}
+
+
+ExprId LowLevelILFunction::RegisterStackTopRelativeSSA(size_t size, const SSARegisterStack& regStack, ExprId entry,
+	const SSARegister& top, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_REL_SSA, loc, size, 0, regStack.regStack, regStack.version, entry,
+		AddExprWithLocation(LLIL_REG_SSA, loc, 0, 0, top.reg, top.version));
+}
+
+
+ExprId LowLevelILFunction::RegisterStackAbsoluteSSA(size_t size, const SSARegisterStack& regStack, uint32_t reg,
+	const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_ABS_SSA, loc, size, 0, regStack.regStack, regStack.version, reg);
+}
+
+
+ExprId LowLevelILFunction::RegisterStackFreeTopRelativeSSA(uint32_t regStack,
+	size_t destVersion, size_t srcVersion, ExprId entry, const SSARegister& top,
+	const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_FREE_REL_SSA, loc, 0, 0,
+		AddExprWithLocation(LLIL_REG_STACK_DEST_SSA, loc, 0, 0, regStack, destVersion, srcVersion),
+		entry, AddExprWithLocation(LLIL_REG_SSA, loc, 0, 0, top.reg, top.version));
+}
+
+
+ExprId LowLevelILFunction::RegisterStackFreeAbsoluteSSA(uint32_t regStack,
+	size_t destVersion, size_t srcVersion, uint32_t reg, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_FREE_ABS_SSA, loc, 0, 0,
+		AddExprWithLocation(LLIL_REG_STACK_DEST_SSA, loc, 0, 0, regStack, destVersion, srcVersion), reg);
+}
+
+
 ExprId LowLevelILFunction::Const(size_t size, uint64_t val, const ILSourceLocation& loc)
 {
 	return AddExprWithLocation(LLIL_CONST, loc, size, 0, val);
@@ -1911,6 +2874,36 @@ ExprId LowLevelILFunction::ConstPointer(size_t size, uint64_t val, const ILSourc
 }
 
 
+ExprId LowLevelILFunction::FloatConstRaw(size_t size, uint64_t val, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FLOAT_CONST, loc, size, 0, val);
+}
+
+
+ExprId LowLevelILFunction::FloatConstSingle(float val, const ILSourceLocation& loc)
+{
+	union
+	{
+		float f;
+		uint32_t i;
+	} bits;
+	bits.f = val;
+	return AddExprWithLocation(LLIL_FLOAT_CONST, loc, 4, 0, bits.i);
+}
+
+
+ExprId LowLevelILFunction::FloatConstDouble(double val, const ILSourceLocation& loc)
+{
+	union
+	{
+		double f;
+		uint64_t i;
+	} bits;
+	bits.f = val;
+	return AddExprWithLocation(LLIL_FLOAT_CONST, loc, 8, 0, bits.i);
+}
+
+
 ExprId LowLevelILFunction::Flag(uint32_t flag, const ILSourceLocation& loc)
 {
 	return AddExprWithLocation(LLIL_FLAG, loc, 0, 0, flag);
@@ -2054,10 +3047,10 @@ ExprId LowLevelILFunction::DivUnsigned(size_t size, ExprId a, ExprId b, uint32_t
 }
 
 
-ExprId LowLevelILFunction::DivDoublePrecUnsigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags,
+ExprId LowLevelILFunction::DivDoublePrecUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags,
 	const ILSourceLocation& loc)
 {
-	return AddExprWithLocation(LLIL_DIVU_DP, loc, size, flags, high, low, div);
+	return AddExprWithLocation(LLIL_DIVU_DP, loc, size, flags, a, b);
 }
 
 
@@ -2067,10 +3060,10 @@ ExprId LowLevelILFunction::DivSigned(size_t size, ExprId a, ExprId b, uint32_t f
 }
 
 
-ExprId LowLevelILFunction::DivDoublePrecSigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags,
+ExprId LowLevelILFunction::DivDoublePrecSigned(size_t size, ExprId a, ExprId b, uint32_t flags,
 	const ILSourceLocation& loc)
 {
-	return AddExprWithLocation(LLIL_DIVS_DP, loc, size, flags, high, low, div);
+	return AddExprWithLocation(LLIL_DIVS_DP, loc, size, flags, a, b);
 }
 
 
@@ -2081,10 +3074,10 @@ ExprId LowLevelILFunction::ModUnsigned(size_t size, ExprId a, ExprId b, uint32_t
 }
 
 
-ExprId LowLevelILFunction::ModDoublePrecUnsigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags,
+ExprId LowLevelILFunction::ModDoublePrecUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags,
 	const ILSourceLocation& loc)
 {
-	return AddExprWithLocation(LLIL_MODU_DP, loc, size, flags, high, low, div);
+	return AddExprWithLocation(LLIL_MODU_DP, loc, size, flags, a, b);
 }
 
 
@@ -2094,10 +3087,10 @@ ExprId LowLevelILFunction::ModSigned(size_t size, ExprId a, ExprId b, uint32_t f
 }
 
 
-ExprId LowLevelILFunction::ModDoublePrecSigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags,
+ExprId LowLevelILFunction::ModDoublePrecSigned(size_t size, ExprId a, ExprId b, uint32_t flags,
 	const ILSourceLocation& loc)
 {
-	return AddExprWithLocation(LLIL_MODS_DP, loc, size, flags, high, low, div);
+	return AddExprWithLocation(LLIL_MODS_DP, loc, size, flags, a, b);
 }
 
 
@@ -2150,33 +3143,41 @@ ExprId LowLevelILFunction::Call(ExprId dest, const ILSourceLocation& loc)
 }
 
 
-ExprId LowLevelILFunction::CallStackAdjust(ExprId dest, size_t adjust, const ILSourceLocation& loc)
+ExprId LowLevelILFunction::CallStackAdjust(ExprId dest, size_t adjust,
+	const std::map<uint32_t, int32_t>& regStackAdjust, const ILSourceLocation& loc)
 {
-	return AddExprWithLocation(LLIL_CALL_STACK_ADJUST, loc, 0, 0, dest, adjust);
+	vector<size_t> list;
+	for (auto& i : regStackAdjust)
+	{
+		list.push_back(i.first);
+		list.push_back(i.second);
+	}
+	return AddExprWithLocation(LLIL_CALL_STACK_ADJUST, loc, 0, 0, dest, adjust, list.size(),
+		AddIndexList(list));
 }
 
 
-ExprId LowLevelILFunction::CallSSA(const vector<SSARegister>& output, ExprId dest, const vector<SSARegister>& params,
+ExprId LowLevelILFunction::CallSSA(const vector<SSARegister>& output, ExprId dest, const vector<ExprId>& params,
 	const SSARegister& stack, size_t newMemoryVer, size_t prevMemoryVer, const ILSourceLocation& loc)
 {
 	return AddExprWithLocation(LLIL_CALL_SSA, loc, 0, 0,
 		AddExprWithLocation(LLIL_CALL_OUTPUT_SSA, loc, 0, 0, newMemoryVer,
 			output.size() * 2, AddSSARegisterList(output)), dest,
 		AddExprWithLocation(LLIL_CALL_STACK_SSA, loc, 0, 0, stack.reg, stack.version, prevMemoryVer),
-		AddExprWithLocation(LLIL_CALL_PARAM_SSA, loc, 0, 0,
-			params.size() * 2, AddSSARegisterList(params)));
+		AddExprWithLocation(LLIL_CALL_PARAM, loc, 0, 0,
+			params.size(), AddOperandList(params)));
 }
 
 
-ExprId LowLevelILFunction::SystemCallSSA(const vector<SSARegister>& output, const vector<SSARegister>& params,
+ExprId LowLevelILFunction::SystemCallSSA(const vector<SSARegister>& output, const vector<ExprId>& params,
 	const SSARegister& stack, size_t newMemoryVer, size_t prevMemoryVer, const ILSourceLocation& loc)
 {
 	return AddExprWithLocation(LLIL_SYSCALL_SSA, loc, 0, 0,
 		AddExprWithLocation(LLIL_CALL_OUTPUT_SSA, loc, 0, 0, newMemoryVer,
 			output.size() * 2, AddSSARegisterList(output)),
 		AddExprWithLocation(LLIL_CALL_STACK_SSA, loc, 0, 0, stack.reg, stack.version, prevMemoryVer),
-		AddExprWithLocation(LLIL_CALL_PARAM_SSA, loc, 0, 0,
-			params.size() * 2, AddSSARegisterList(params)));
+		AddExprWithLocation(LLIL_CALL_PARAM, loc, 0, 0,
+			params.size(), AddOperandList(params)));
 }
 
 
@@ -2192,9 +3193,15 @@ ExprId LowLevelILFunction::NoReturn(const ILSourceLocation& loc)
 }
 
 
-ExprId LowLevelILFunction::FlagCondition(BNLowLevelILFlagCondition cond, const ILSourceLocation& loc)
+ExprId LowLevelILFunction::FlagCondition(BNLowLevelILFlagCondition cond, uint32_t semClass, const ILSourceLocation& loc)
 {
-	return AddExprWithLocation(LLIL_FLAG_COND, loc, 0, 0, (ExprId)cond);
+	return AddExprWithLocation(LLIL_FLAG_COND, loc, 0, 0, (ExprId)cond, semClass);
+}
+
+
+ExprId LowLevelILFunction::FlagGroup(uint32_t semGroup, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FLAG_GROUP, loc, 0, 0, semGroup);
 }
 
 
@@ -2276,6 +3283,24 @@ ExprId LowLevelILFunction::SystemCall(const ILSourceLocation& loc)
 }
 
 
+ExprId LowLevelILFunction::Intrinsic(const vector<RegisterOrFlag>& outputs, uint32_t intrinsic,
+	const vector<ExprId>& params, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_INTRINSIC, loc, 0, flags,
+		outputs.size(), AddRegisterOrFlagList(outputs), intrinsic,
+		AddExprWithLocation(LLIL_CALL_PARAM, loc, 0, 0, params.size(), AddOperandList(params)));
+}
+
+
+ExprId LowLevelILFunction::IntrinsicSSA(const vector<SSARegisterOrFlag>& outputs, uint32_t intrinsic,
+	const vector<ExprId>& params, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_INTRINSIC_SSA, loc, 0, 0,
+		outputs.size() * 2, AddSSARegisterOrFlagList(outputs), intrinsic,
+		AddExprWithLocation(LLIL_CALL_PARAM, loc, 0, 0, params.size(), AddOperandList(params)));
+}
+
+
 ExprId LowLevelILFunction::Breakpoint(const ILSourceLocation& loc)
 {
 	return AddExprWithLocation(LLIL_BP, loc, 0, 0);
@@ -2314,6 +3339,14 @@ ExprId LowLevelILFunction::RegisterPhi(const SSARegister& dest, const vector<SSA
 }
 
 
+ExprId LowLevelILFunction::RegisterStackPhi(const SSARegisterStack& dest, const vector<SSARegisterStack>& sources,
+	const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_REG_STACK_PHI, loc, 0, 0, dest.regStack, dest.version,
+		sources.size() * 2, AddSSARegisterStackList(sources));
+}
+
+
 ExprId LowLevelILFunction::FlagPhi(const SSAFlag& dest, const vector<SSAFlag>& sources,
 	const ILSourceLocation& loc)
 {
@@ -2326,3 +3359,135 @@ ExprId LowLevelILFunction::MemoryPhi(size_t dest, const vector<size_t>& sources,
 {
 	return AddExprWithLocation(LLIL_MEM_PHI, loc, 0, 0, dest, sources.size(), AddIndexList(sources));
 }
+
+
+ExprId LowLevelILFunction::FloatAdd(size_t size, ExprId a, ExprId b, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FADD, loc, size, flags, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatSub(size_t size, ExprId a, ExprId b, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FSUB, loc, size, flags, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatMult(size_t size, ExprId a, ExprId b, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FMUL, loc, size, flags, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatDiv(size_t size, ExprId a, ExprId b, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FDIV, loc, size, flags, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatSqrt(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FSQRT, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::FloatNeg(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FNEG, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::FloatAbs(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FABS, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::FloatToInt(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FLOAT_TO_INT, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::IntToFloat(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_INT_TO_FLOAT, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::FloatConvert(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FLOAT_CONV, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::RoundToInt(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_ROUND_TO_INT, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::Floor(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FLOOR, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::Ceil(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_CEIL, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::FloatTrunc(size_t size, ExprId a, uint32_t flags, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FTRUNC, loc, size, flags, a);
+}
+
+
+ExprId LowLevelILFunction::FloatCompareEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FCMP_E, loc, size, 0, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatCompareNotEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FCMP_NE, loc, size, 0, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatCompareLessThan(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FCMP_LT, loc, size, 0, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatCompareLessEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FCMP_LE, loc, size, 0, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatCompareGreaterEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FCMP_GE, loc, size, 0, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatCompareGreaterThan(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FCMP_GT, loc, size, 0, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatCompareOrdered(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FCMP_O, loc, size, 0, a, b);
+}
+
+
+ExprId LowLevelILFunction::FloatCompareUnordered(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(LLIL_FCMP_UO, loc, size, 0, a, b);
+}