Merging with dev

1 files changed, 406 insertions, 37 deletions

diff --git a/lowlevelilinstruction.h b/lowlevelilinstruction.h
index 169c7a60..675baa3c 100644
--- a/lowlevelilinstruction.h
+++ b/lowlevelilinstruction.h
@@ -49,12 +49,36 @@ namespace BinaryNinja
 	struct LowLevelILOneOperandInstruction;
 	struct LowLevelILTwoOperandInstruction;
 	struct LowLevelILTwoOperandWithCarryInstruction;
-	struct LowLevelILDoublePrecisionInstruction;
 	struct LowLevelILLabel;
 	struct MediumLevelILInstruction;
 	class LowLevelILOperand;
 	class LowLevelILOperandList;
 
+	struct RegisterOrFlag
+	{
+		bool isFlag;
+		uint32_t index;
+
+		RegisterOrFlag();
+		RegisterOrFlag(bool flag, uint32_t i);
+
+		bool IsRegister() const { return !isFlag; }
+		bool IsFlag() const { return isFlag; }
+		uint32_t GetRegister() const;
+		uint32_t GetFlag() const;
+
+		RegisterOrFlag& operator=(const RegisterOrFlag& v);
+		bool operator==(const RegisterOrFlag& v) const;
+		bool operator!=(const RegisterOrFlag& v) const;
+		bool operator<(const RegisterOrFlag& v) const;
+
+		uint64_t ToIdentifier() const;
+		static RegisterOrFlag FromIdentifier(uint64_t id);
+
+		static RegisterOrFlag Register(uint32_t reg) { return RegisterOrFlag(false, reg); }
+		static RegisterOrFlag Flag(uint32_t flag) { return RegisterOrFlag(true, flag); }
+	};
+
 	struct SSARegister
 	{
 		uint32_t reg;
@@ -70,6 +94,21 @@ namespace BinaryNinja
 		bool operator<(const SSARegister& v) const;
 	};
 
+	struct SSARegisterStack
+	{
+		uint32_t regStack;
+		size_t version;
+
+		SSARegisterStack();
+		SSARegisterStack(uint32_t r, size_t i);
+		SSARegisterStack(const SSARegisterStack& v);
+
+		SSARegisterStack& operator=(const SSARegisterStack& v);
+		bool operator==(const SSARegisterStack& v) const;
+		bool operator!=(const SSARegisterStack& v) const;
+		bool operator<(const SSARegisterStack& v) const;
+	};
+
 	struct SSAFlag
 	{
 		uint32_t flag;
@@ -85,46 +124,80 @@ namespace BinaryNinja
 		bool operator<(const SSAFlag& v) const;
 	};
 
+	struct SSARegisterOrFlag
+	{
+		RegisterOrFlag regOrFlag;
+		size_t version;
+
+		SSARegisterOrFlag();
+		SSARegisterOrFlag(const RegisterOrFlag& rf, size_t i);
+		SSARegisterOrFlag(const SSARegister& v);
+		SSARegisterOrFlag(const SSAFlag& v);
+		SSARegisterOrFlag(const SSARegisterOrFlag& v);
+
+		SSARegisterOrFlag& operator=(const SSARegisterOrFlag& v);
+		bool operator==(const SSARegisterOrFlag& v) const;
+		bool operator!=(const SSARegisterOrFlag& v) const;
+		bool operator<(const SSARegisterOrFlag& v) const;
+	};
+
 	enum LowLevelILOperandType
 	{
 		IntegerLowLevelOperand,
 		IndexLowLevelOperand,
 		ExprLowLevelOperand,
 		RegisterLowLevelOperand,
+		RegisterStackLowLevelOperand,
 		FlagLowLevelOperand,
 		FlagConditionLowLevelOperand,
+		IntrinsicLowLevelOperand,
+		SemanticFlagClassLowLevelOperand,
+		SemanticFlagGroupLowLevelOperand,
 		SSARegisterLowLevelOperand,
+		SSARegisterStackLowLevelOperand,
 		SSAFlagLowLevelOperand,
 		IndexListLowLevelOperand,
+		ExprListLowLevelOperand,
+		RegisterOrFlagListLowLevelOperand,
 		SSARegisterListLowLevelOperand,
-		SSAFlagListLowLevelOperand
+		SSARegisterStackListLowLevelOperand,
+		SSAFlagListLowLevelOperand,
+		SSARegisterOrFlagListLowLevelOperand,
+		RegisterStackAdjustmentsLowLevelOperand
 	};
 
 	enum LowLevelILOperandUsage
 	{
 		SourceExprLowLevelOperandUsage,
 		SourceRegisterLowLevelOperandUsage,
+		SourceRegisterStackLowLevelOperandUsage,
 		SourceFlagLowLevelOperandUsage,
 		SourceSSARegisterLowLevelOperandUsage,
+		SourceSSARegisterStackLowLevelOperandUsage,
 		SourceSSAFlagLowLevelOperandUsage,
 		DestExprLowLevelOperandUsage,
 		DestRegisterLowLevelOperandUsage,
+		DestRegisterStackLowLevelOperandUsage,
 		DestFlagLowLevelOperandUsage,
 		DestSSARegisterLowLevelOperandUsage,
+		DestSSARegisterStackLowLevelOperandUsage,
 		DestSSAFlagLowLevelOperandUsage,
+		SemanticFlagClassLowLevelOperandUsage,
+		SemanticFlagGroupLowLevelOperandUsage,
 		PartialRegisterLowLevelOperandUsage,
+		PartialSSARegisterStackSourceLowLevelOperandUsage,
 		StackSSARegisterLowLevelOperandUsage,
 		StackMemoryVersionLowLevelOperandUsage,
+		TopSSARegisterLowLevelOperandUsage,
 		LeftExprLowLevelOperandUsage,
 		RightExprLowLevelOperandUsage,
 		CarryExprLowLevelOperandUsage,
-		HighExprLowLevelOperandUsage,
-		LowExprLowLevelOperandUsage,
 		ConditionExprLowLevelOperandUsage,
 		HighRegisterLowLevelOperandUsage,
 		HighSSARegisterLowLevelOperandUsage,
 		LowRegisterLowLevelOperandUsage,
 		LowSSARegisterLowLevelOperandUsage,
+		IntrinsicLowLevelOperandUsage,
 		ConstantLowLevelOperandUsage,
 		VectorLowLevelOperandUsage,
 		StackAdjustmentLowLevelOperandUsage,
@@ -137,11 +210,15 @@ namespace BinaryNinja
 		FlagConditionLowLevelOperandUsage,
 		OutputSSARegistersLowLevelOperandUsage,
 		OutputMemoryVersionLowLevelOperandUsage,
-		ParameterSSARegistersLowLevelOperandUsage,
+		ParameterExprsLowLevelOperandUsage,
 		SourceSSARegistersLowLevelOperandUsage,
+		SourceSSARegisterStacksLowLevelOperandUsage,
 		SourceSSAFlagsLowLevelOperandUsage,
+		OutputRegisterOrFlagListLowLevelOperandUsage,
+		OutputSSARegisterOrFlagListLowLevelOperandUsage,
 		SourceMemoryVersionsLowLevelOperandUsage,
-		TargetListLowLevelOperandUsage
+		TargetListLowLevelOperandUsage,
+		RegisterStackAdjustmentsLowLevelOperandUsage
 	};
 }
 
@@ -166,6 +243,24 @@ namespace std
 	};
 
 #ifdef BINARYNINJACORE_LIBRARY
+	template<> struct hash<BinaryNinjaCore::SSARegisterStack>
+#else
+	template<> struct hash<BinaryNinja::SSARegisterStack>
+#endif
+	{
+#ifdef BINARYNINJACORE_LIBRARY
+		typedef BinaryNinjaCore::SSARegisterStack argument_type;
+#else
+		typedef BinaryNinja::SSARegisterStack argument_type;
+#endif
+		typedef uint64_t result_type;
+		result_type operator()(argument_type const& value) const
+		{
+			return ((result_type)value.regStack) ^ ((result_type)value.version << 32);
+		}
+	};
+
+#ifdef BINARYNINJACORE_LIBRARY
 	template<> struct hash<BinaryNinjaCore::SSAFlag>
 #else
 	template<> struct hash<BinaryNinja::SSAFlag>
@@ -288,6 +383,63 @@ namespace BinaryNinja
 		operator std::vector<size_t>() const;
 	};
 
+	class LowLevelILInstructionList
+	{
+		struct ListIterator
+		{
+			LowLevelILIntegerList::const_iterator pos;
+			size_t instructionIndex;
+			bool operator==(const ListIterator& a) const { return pos == a.pos; }
+			bool operator!=(const ListIterator& a) const { return pos != a.pos; }
+			bool operator<(const ListIterator& a) const { return pos < a.pos; }
+			ListIterator& operator++() { ++pos; return *this; }
+			const LowLevelILInstruction operator*();
+		};
+
+		LowLevelILIntegerList m_list;
+		size_t m_instructionIndex;
+
+	public:
+		typedef ListIterator const_iterator;
+
+		LowLevelILInstructionList(LowLevelILFunction* func, const BNLowLevelILInstruction& instr,
+			size_t count, size_t instrIndex);
+
+		const_iterator begin() const;
+		const_iterator end() const;
+		size_t size() const;
+		const LowLevelILInstruction operator[](size_t i) const;
+
+		operator std::vector<LowLevelILInstruction>() const;
+	};
+
+	class LowLevelILRegisterOrFlagList
+	{
+		struct ListIterator
+		{
+			LowLevelILIntegerList::const_iterator pos;
+			bool operator==(const ListIterator& a) const { return pos == a.pos; }
+			bool operator!=(const ListIterator& a) const { return pos != a.pos; }
+			bool operator<(const ListIterator& a) const { return pos < a.pos; }
+			ListIterator& operator++() { ++pos; return *this; }
+			const RegisterOrFlag operator*();
+		};
+
+		LowLevelILIntegerList m_list;
+
+	public:
+		typedef ListIterator const_iterator;
+
+		LowLevelILRegisterOrFlagList(LowLevelILFunction* func, const BNLowLevelILInstruction& instr, size_t count);
+
+		const_iterator begin() const;
+		const_iterator end() const;
+		size_t size() const;
+		const RegisterOrFlag operator[](size_t i) const;
+
+		operator std::vector<RegisterOrFlag>() const;
+	};
+
 	class LowLevelILSSARegisterList
 	{
 		struct ListIterator
@@ -315,6 +467,33 @@ namespace BinaryNinja
 		operator std::vector<SSARegister>() const;
 	};
 
+	class LowLevelILSSARegisterStackList
+	{
+		struct ListIterator
+		{
+			LowLevelILIntegerList::const_iterator pos;
+			bool operator==(const ListIterator& a) const { return pos == a.pos; }
+			bool operator!=(const ListIterator& a) const { return pos != a.pos; }
+			bool operator<(const ListIterator& a) const { return pos < a.pos; }
+			ListIterator& operator++() { ++pos; ++pos; return *this; }
+			const SSARegisterStack operator*();
+		};
+
+		LowLevelILIntegerList m_list;
+
+	public:
+		typedef ListIterator const_iterator;
+
+		LowLevelILSSARegisterStackList(LowLevelILFunction* func, const BNLowLevelILInstruction& instr, size_t count);
+
+		const_iterator begin() const;
+		const_iterator end() const;
+		size_t size() const;
+		const SSARegisterStack operator[](size_t i) const;
+
+		operator std::vector<SSARegisterStack>() const;
+	};
+
 	class LowLevelILSSAFlagList
 	{
 		struct ListIterator
@@ -342,6 +521,33 @@ namespace BinaryNinja
 		operator std::vector<SSAFlag>() const;
 	};
 
+	class LowLevelILSSARegisterOrFlagList
+	{
+		struct ListIterator
+		{
+			LowLevelILIntegerList::const_iterator pos;
+			bool operator==(const ListIterator& a) const { return pos == a.pos; }
+			bool operator!=(const ListIterator& a) const { return pos != a.pos; }
+			bool operator<(const ListIterator& a) const { return pos < a.pos; }
+			ListIterator& operator++() { ++pos; ++pos; return *this; }
+			const SSARegisterOrFlag operator*();
+		};
+
+		LowLevelILIntegerList m_list;
+
+	public:
+		typedef ListIterator const_iterator;
+
+		LowLevelILSSARegisterOrFlagList(LowLevelILFunction* func, const BNLowLevelILInstruction& instr, size_t count);
+
+		const_iterator begin() const;
+		const_iterator end() const;
+		size_t size() const;
+		const SSARegisterOrFlag operator[](size_t i) const;
+
+		operator std::vector<SSARegisterOrFlag>() const;
+	};
+
 	struct LowLevelILInstructionBase: public BNLowLevelILInstruction
 	{
 #ifdef BINARYNINJACORE_LIBRARY
@@ -365,13 +571,21 @@ namespace BinaryNinja
 		BNLowLevelILFlagCondition GetRawOperandAsFlagCondition(size_t operand) const;
 		LowLevelILInstruction GetRawOperandAsExpr(size_t operand) const;
 		SSARegister GetRawOperandAsSSARegister(size_t operand) const;
+		SSARegisterStack GetRawOperandAsSSARegisterStack(size_t operand) const;
+		SSARegisterStack GetRawOperandAsPartialSSARegisterStackSource(size_t operand) const;
 		SSAFlag GetRawOperandAsSSAFlag(size_t operand) const;
 		LowLevelILIndexList GetRawOperandAsIndexList(size_t operand) const;
+		LowLevelILInstructionList GetRawOperandAsExprList(size_t operand) const;
+		LowLevelILRegisterOrFlagList GetRawOperandAsRegisterOrFlagList(size_t operand) const;
 		LowLevelILSSARegisterList GetRawOperandAsSSARegisterList(size_t operand) const;
+		LowLevelILSSARegisterStackList GetRawOperandAsSSARegisterStackList(size_t operand) const;
 		LowLevelILSSAFlagList GetRawOperandAsSSAFlagList(size_t operand) const;
+		LowLevelILSSARegisterOrFlagList GetRawOperandAsSSARegisterOrFlagList(size_t operand) const;
+		std::map<uint32_t, int32_t> GetRawOperandAsRegisterStackAdjustments(size_t operand) const;
 
 		void UpdateRawOperand(size_t operandIndex, ExprId value);
 		void UpdateRawOperandAsSSARegisterList(size_t operandIndex, const std::vector<SSARegister>& regs);
+		void UpdateRawOperandAsSSARegisterOrFlagList(size_t operandIndex, const std::vector<SSARegisterOrFlag>& outputs);
 
 		RegisterValue GetValue() const;
 		PossibleValueSet GetPossibleValues() const;
@@ -428,10 +642,6 @@ namespace BinaryNinja
 		{
 			return *(LowLevelILTwoOperandWithCarryInstruction*)this;
 		}
-		LowLevelILDoublePrecisionInstruction& AsDoublePrecision()
-		{
-			return *(LowLevelILDoublePrecisionInstruction*)this;
-		}
 
 		template <BNLowLevelILOperation N>
 		const LowLevelILInstructionAccessor<N>& As() const
@@ -456,10 +666,6 @@ namespace BinaryNinja
 		{
 			return *(const LowLevelILTwoOperandWithCarryInstruction*)this;
 		}
-		const LowLevelILDoublePrecisionInstruction& AsDoublePrecision() const
-		{
-			return *(const LowLevelILDoublePrecisionInstruction*)this;
-		}
 	};
 
 	struct LowLevelILInstruction: public LowLevelILInstructionBase
@@ -478,26 +684,32 @@ namespace BinaryNinja
 		// Templated accessors for instruction operands, use these for efficient access to a known instruction
 		template <BNLowLevelILOperation N> LowLevelILInstruction GetSourceExpr() const { return As<N>().GetSourceExpr(); }
 		template <BNLowLevelILOperation N> uint32_t GetSourceRegister() const { return As<N>().GetSourceRegister(); }
+		template <BNLowLevelILOperation N> uint32_t GetSourceRegisterStack() const { return As<N>().GetSourceRegisterStack(); }
 		template <BNLowLevelILOperation N> uint32_t GetSourceFlag() const { return As<N>().GetSourceFlag(); }
 		template <BNLowLevelILOperation N> SSARegister GetSourceSSARegister() const { return As<N>().GetSourceSSARegister(); }
+		template <BNLowLevelILOperation N> SSARegisterStack GetSourceSSARegisterStack() const { return As<N>().GetSourceSSARegisterStack(); }
 		template <BNLowLevelILOperation N> SSAFlag GetSourceSSAFlag() const { return As<N>().GetSourceSSAFlag(); }
 		template <BNLowLevelILOperation N> LowLevelILInstruction GetDestExpr() const { return As<N>().GetDestExpr(); }
 		template <BNLowLevelILOperation N> uint32_t GetDestRegister() const { return As<N>().GetDestRegister(); }
+		template <BNLowLevelILOperation N> uint32_t GetDestRegisterStack() const { return As<N>().GetDestRegisterStack(); }
 		template <BNLowLevelILOperation N> uint32_t GetDestFlag() const { return As<N>().GetDestFlag(); }
 		template <BNLowLevelILOperation N> SSARegister GetDestSSARegister() const { return As<N>().GetDestSSARegister(); }
+		template <BNLowLevelILOperation N> SSARegisterStack GetDestSSARegisterStack() const { return As<N>().GetDestSSARegisterStack(); }
 		template <BNLowLevelILOperation N> SSAFlag GetDestSSAFlag() const { return As<N>().GetDestSSAFlag(); }
+		template <BNLowLevelILOperation N> uint32_t GetSemanticFlagClass() const { return As<N>().GetSemanticFlagClass(); }
+		template <BNLowLevelILOperation N> uint32_t GetSemanticFlagGroup() const { return As<N>().GetSemanticFlagGroup(); }
 		template <BNLowLevelILOperation N> uint32_t GetPartialRegister() const { return As<N>().GetPartialRegister(); }
 		template <BNLowLevelILOperation N> SSARegister GetStackSSARegister() const { return As<N>().GetStackSSARegister(); }
+		template <BNLowLevelILOperation N> SSARegister GetTopSSARegister() const { return As<N>().GetTopSSARegister(); }
 		template <BNLowLevelILOperation N> LowLevelILInstruction GetLeftExpr() const { return As<N>().GetLeftExpr(); }
 		template <BNLowLevelILOperation N> LowLevelILInstruction GetRightExpr() const { return As<N>().GetRightExpr(); }
 		template <BNLowLevelILOperation N> LowLevelILInstruction GetCarryExpr() const { return As<N>().GetCarryExpr(); }
-		template <BNLowLevelILOperation N> LowLevelILInstruction GetHighExpr() const { return As<N>().GetHighExpr(); }
-		template <BNLowLevelILOperation N> LowLevelILInstruction GetLowExpr() const { return As<N>().GetLowExpr(); }
 		template <BNLowLevelILOperation N> LowLevelILInstruction GetConditionExpr() const { return As<N>().GetConditionExpr(); }
 		template <BNLowLevelILOperation N> uint32_t GetHighRegister() const { return As<N>().GetHighRegister(); }
 		template <BNLowLevelILOperation N> SSARegister GetHighSSARegister() const { return As<N>().GetHighSSARegister(); }
 		template <BNLowLevelILOperation N> uint32_t GetLowRegister() const { return As<N>().GetLowRegister(); }
 		template <BNLowLevelILOperation N> SSARegister GetLowSSARegister() const { return As<N>().GetLowSSARegister(); }
+		template <BNLowLevelILOperation N> uint32_t GetIntrinsic() const { return As<N>().GetIntrinsic(); }
 		template <BNLowLevelILOperation N> int64_t GetConstant() const { return As<N>().GetConstant(); }
 		template <BNLowLevelILOperation N> int64_t GetVector() const { return As<N>().GetVector(); }
 		template <BNLowLevelILOperation N> size_t GetStackAdjustment() const { return As<N>().GetStackAdjustment(); }
@@ -509,21 +721,26 @@ namespace BinaryNinja
 		template <BNLowLevelILOperation N> size_t GetDestMemoryVersion() const { return As<N>().GetDestMemoryVersion(); }
 		template <BNLowLevelILOperation N> BNLowLevelILFlagCondition GetFlagCondition() const { return As<N>().GetFlagCondition(); }
 		template <BNLowLevelILOperation N> LowLevelILSSARegisterList GetOutputSSARegisters() const { return As<N>().GetOutputSSARegisters(); }
-		template <BNLowLevelILOperation N> LowLevelILSSARegisterList GetParameterSSARegisters() const { return As<N>().GetParameterSSARegisters(); }
+		template <BNLowLevelILOperation N> LowLevelILInstructionList GetParameterExprs() const { return As<N>().GetParameterExprs(); }
 		template <BNLowLevelILOperation N> LowLevelILSSARegisterList GetSourceSSARegisters() const { return As<N>().GetSourceSSARegisters(); }
+		template <BNLowLevelILOperation N> LowLevelILSSARegisterStackList GetSourceSSARegisterStacks() const { return As<N>().GetSourceSSARegisterStacks(); }
 		template <BNLowLevelILOperation N> LowLevelILSSAFlagList GetSourceSSAFlags() const { return As<N>().GetSourceSSAFlags(); }
+		template <BNLowLevelILOperation N> LowLevelILRegisterOrFlagList GetOutputRegisterOrFlagList() const { return As<N>().GetOutputRegisterOrFlagList(); }
+		template <BNLowLevelILOperation N> LowLevelILSSARegisterOrFlagList GetOutputSSARegisterOrFlagList() const { return As<N>().GetOutputSSARegisterOrFlagList(); }
 		template <BNLowLevelILOperation N> LowLevelILIndexList GetSourceMemoryVersions() const { return As<N>().GetSourceMemoryVersions(); }
 		template <BNLowLevelILOperation N> LowLevelILIndexList GetTargetList() const { return As<N>().GetTargetList(); }
+		template <BNLowLevelILOperation N> std::map<uint32_t, int32_t> GetRegisterStackAdjustments() const { return As<N>().GetRegisterStackAdjustments(); }
 
 		template <BNLowLevelILOperation N> void SetDestSSAVersion(size_t version) { As<N>().SetDestSSAVersion(version); }
 		template <BNLowLevelILOperation N> void SetSourceSSAVersion(size_t version) { As<N>().SetSourceSSAVersion(version); }
 		template <BNLowLevelILOperation N> void SetHighSSAVersion(size_t version) { As<N>().SetHighSSAVersion(version); }
 		template <BNLowLevelILOperation N> void SetLowSSAVersion(size_t version) { As<N>().SetLowSSAVersion(version); }
 		template <BNLowLevelILOperation N> void SetStackSSAVersion(size_t version) { As<N>().SetStackSSAVersion(version); }
+		template <BNLowLevelILOperation N> void SetTopSSAVersion(size_t version) { As<N>().SetTopSSAVersion(version); }
 		template <BNLowLevelILOperation N> void SetDestMemoryVersion(size_t version) { As<N>().SetDestMemoryVersion(version); }
 		template <BNLowLevelILOperation N> void SetSourceMemoryVersion(size_t version) { As<N>().SetSourceMemoryVersion(version); }
 		template <BNLowLevelILOperation N> void SetOutputSSARegisters(const std::vector<SSARegister>& regs) { As<N>().SetOutputSSARegisters(regs); }
-		template <BNLowLevelILOperation N> void SetParameterSSARegisters(const std::vector<SSARegister>& regs) { As<N>().SetParameterSSARegisters(regs); }
+		template <BNLowLevelILOperation N> void SetOutputSSARegisterOrFlagList(const std::vector<SSARegisterOrFlag>& outputs) { As<N>().SetOutputSSARegisterOrFlagList(outputs); }
 
 		bool GetOperandIndexForUsage(LowLevelILOperandUsage usage, size_t& operandIndex) const;
 
@@ -531,26 +748,32 @@ namespace BinaryNinja
 		// on type mismatch. These are slower than the templated versions above.
 		LowLevelILInstruction GetSourceExpr() const;
 		uint32_t GetSourceRegister() const;
+		uint32_t GetSourceRegisterStack() const;
 		uint32_t GetSourceFlag() const;
 		SSARegister GetSourceSSARegister() const;
+		SSARegisterStack GetSourceSSARegisterStack() const;
 		SSAFlag GetSourceSSAFlag() const;
 		LowLevelILInstruction GetDestExpr() const;
 		uint32_t GetDestRegister() const;
+		uint32_t GetDestRegisterStack() const;
 		uint32_t GetDestFlag() const;
 		SSARegister GetDestSSARegister() const;
+		SSARegisterStack GetDestSSARegisterStack() const;
 		SSAFlag GetDestSSAFlag() const;
+		uint32_t GetSemanticFlagClass() const;
+		uint32_t GetSemanticFlagGroup() const;
 		uint32_t GetPartialRegister() const;
 		SSARegister GetStackSSARegister() const;
+		SSARegister GetTopSSARegister() const;
 		LowLevelILInstruction GetLeftExpr() const;
 		LowLevelILInstruction GetRightExpr() const;
 		LowLevelILInstruction GetCarryExpr() const;
-		LowLevelILInstruction GetHighExpr() const;
-		LowLevelILInstruction GetLowExpr() const;
 		LowLevelILInstruction GetConditionExpr() const;
 		uint32_t GetHighRegister() const;
 		SSARegister GetHighSSARegister() const;
 		uint32_t GetLowRegister() const;
 		SSARegister GetLowSSARegister() const;
+		uint32_t GetIntrinsic() const;
 		int64_t GetConstant() const;
 		int64_t GetVector() const;
 		size_t GetStackAdjustment() const;
@@ -562,11 +785,15 @@ namespace BinaryNinja
 		size_t GetDestMemoryVersion() const;
 		BNLowLevelILFlagCondition GetFlagCondition() const;
 		LowLevelILSSARegisterList GetOutputSSARegisters() const;
-		LowLevelILSSARegisterList GetParameterSSARegisters() const;
+		LowLevelILInstructionList GetParameterExprs() const;
 		LowLevelILSSARegisterList GetSourceSSARegisters() const;
+		LowLevelILSSARegisterStackList GetSourceSSARegisterStacks() const;
 		LowLevelILSSAFlagList GetSourceSSAFlags() const;
+		LowLevelILRegisterOrFlagList GetOutputRegisterOrFlagList() const;
+		LowLevelILSSARegisterOrFlagList GetOutputSSARegisterOrFlagList() const;
 		LowLevelILIndexList GetSourceMemoryVersions() const;
 		LowLevelILIndexList GetTargetList() const;
+		std::map<uint32_t, int32_t> GetRegisterStackAdjustments() const;
 	};
 
 	class LowLevelILOperand
@@ -587,13 +814,23 @@ namespace BinaryNinja
 		size_t GetIndex() const;
 		LowLevelILInstruction GetExpr() const;
 		uint32_t GetRegister() const;
+		uint32_t GetRegisterStack() const;
 		uint32_t GetFlag() const;
+		uint32_t GetSemanticFlagClass() const;
+		uint32_t GetSemanticFlagGroup() const;
+		uint32_t GetIntrinsic() const;
 		BNLowLevelILFlagCondition GetFlagCondition() const;
 		SSARegister GetSSARegister() const;
+		SSARegisterStack GetSSARegisterStack() const;
 		SSAFlag GetSSAFlag() const;
 		LowLevelILIndexList GetIndexList() const;
+		LowLevelILInstructionList GetExprList() const;
 		LowLevelILSSARegisterList GetSSARegisterList() const;
+		LowLevelILSSARegisterStackList GetSSARegisterStackList() const;
 		LowLevelILSSAFlagList GetSSAFlagList() const;
+		LowLevelILRegisterOrFlagList GetRegisterOrFlagList() const;
+		LowLevelILSSARegisterOrFlagList GetSSARegisterOrFlagList() const;
+		std::map<uint32_t, int32_t> GetRegisterStackAdjustments() const;
 	};
 
 	class LowLevelILOperandList
@@ -651,13 +888,6 @@ namespace BinaryNinja
 		LowLevelILInstruction GetCarryExpr() const { return GetRawOperandAsExpr(2); }
 	};
 
-	struct LowLevelILDoublePrecisionInstruction: public LowLevelILInstructionBase
-	{
-		LowLevelILInstruction GetHighExpr() const { return GetRawOperandAsExpr(0); }
-		LowLevelILInstruction GetLowExpr() const { return GetRawOperandAsExpr(1); }
-		LowLevelILInstruction GetRightExpr() const { return GetRawOperandAsExpr(2); }
-	};
-
 	// Implementations of each instruction to fetch the correct operand value for the valid operands, these
 	// are derived from LowLevelILInstructionBase so that invalid operand accessor functions will generate
 	// a compiler error.
@@ -693,6 +923,37 @@ namespace BinaryNinja
 		void SetHighSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(1, version); }
 		void SetLowSSAVersion(size_t version) { GetRawOperandAsExpr(1).UpdateRawOperand(1, version); }
 	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_SET_REG_STACK_REL>: public LowLevelILInstructionBase
+	{
+		uint32_t GetDestRegisterStack() const { return GetRawOperandAsRegister(0); }
+		LowLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(1); }
+		LowLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(2); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_PUSH>: public LowLevelILInstructionBase
+	{
+		uint32_t GetDestRegisterStack() const { return GetRawOperandAsRegister(0); }
+		LowLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(1); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_SET_REG_STACK_REL_SSA>: public LowLevelILInstructionBase
+	{
+		SSARegisterStack GetDestSSARegisterStack() const { return GetRawOperandAsExpr(0).GetRawOperandAsSSARegisterStack(0); }
+		SSARegisterStack GetSourceSSARegisterStack() const { return GetRawOperandAsExpr(0).GetRawOperandAsPartialSSARegisterStackSource(0); }
+		LowLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(1); }
+		SSARegister GetTopSSARegister() const { return GetRawOperandAsExpr(2).GetRawOperandAsSSARegister(0); }
+		LowLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(3); }
+		void SetDestSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(1, version); }
+		void SetSourceSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(2, version); }
+		void SetTopSSAVersion(size_t version) { GetRawOperandAsExpr(2).UpdateRawOperand(1, version); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_SET_REG_STACK_ABS_SSA>: public LowLevelILInstructionBase
+	{
+		SSARegisterStack GetDestSSARegisterStack() const { return GetRawOperandAsExpr(0).GetRawOperandAsSSARegisterStack(0); }
+		SSARegisterStack GetSourceSSARegisterStack() const { return GetRawOperandAsExpr(0).GetRawOperandAsPartialSSARegisterStackSource(0); }
+		uint32_t GetDestRegister() const { return GetRawOperandAsRegister(1); }
+		LowLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(2); }
+		void SetDestSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(1, version); }
+		void SetSourceSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(2, version); }
+	};
 	template <> struct LowLevelILInstructionAccessor<LLIL_SET_FLAG>: public LowLevelILInstructionBase
 	{
 		uint32_t GetDestFlag() const { return GetRawOperandAsRegister(0); }
@@ -743,6 +1004,56 @@ namespace BinaryNinja
 		uint32_t GetPartialRegister() const { return GetRawOperandAsRegister(2); }
 		void SetSourceSSAVersion(size_t version) { UpdateRawOperand(1, version); }
 	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_REL>: public LowLevelILInstructionBase
+	{
+		uint32_t GetSourceRegisterStack() const { return GetRawOperandAsRegister(0); }
+		LowLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(1); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_POP>: public LowLevelILInstructionBase
+	{
+		uint32_t GetSourceRegisterStack() const { return GetRawOperandAsRegister(0); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_FREE_REG>: public LowLevelILInstructionBase
+	{
+		uint32_t GetDestRegister() const { return GetRawOperandAsRegister(0); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_FREE_REL>: public LowLevelILInstructionBase
+	{
+		uint32_t GetDestRegisterStack() const { return GetRawOperandAsRegister(0); }
+		LowLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(1); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_REL_SSA>: public LowLevelILInstructionBase
+	{
+		SSARegisterStack GetSourceSSARegisterStack() const { return GetRawOperandAsSSARegisterStack(0); }
+		LowLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(2); }
+		SSARegister GetTopSSARegister() const { return GetRawOperandAsExpr(3).GetRawOperandAsSSARegister(0); }
+		void SetSourceSSAVersion(size_t version) { UpdateRawOperand(1, version); }
+		void SetTopSSAVersion(size_t version) { GetRawOperandAsExpr(3).UpdateRawOperand(1, version); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_ABS_SSA>: public LowLevelILInstructionBase
+	{
+		SSARegisterStack GetSourceSSARegisterStack() const { return GetRawOperandAsSSARegisterStack(0); }
+		uint32_t GetSourceRegister() const { return GetRawOperandAsRegister(2); }
+		void SetSourceSSAVersion(size_t version) { UpdateRawOperand(1, version); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_FREE_REL_SSA>: public LowLevelILInstructionBase
+	{
+		SSARegisterStack GetDestSSARegisterStack() const { return GetRawOperandAsExpr(0).GetRawOperandAsSSARegisterStack(0); }
+		SSARegisterStack GetSourceSSARegisterStack() const { return GetRawOperandAsExpr(0).GetRawOperandAsPartialSSARegisterStackSource(0); }
+		LowLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(1); }
+		SSARegister GetTopSSARegister() const { return GetRawOperandAsExpr(2).GetRawOperandAsSSARegister(0); }
+		void SetDestSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(1, version); }
+		void SetSourceSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(2, version); }
+		void SetTopSSAVersion(size_t version) { GetRawOperandAsExpr(2).UpdateRawOperand(1, version); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_FREE_ABS_SSA>: public LowLevelILInstructionBase
+	{
+		SSARegisterStack GetDestSSARegisterStack() const { return GetRawOperandAsExpr(0).GetRawOperandAsSSARegisterStack(0); }
+		SSARegisterStack GetSourceSSARegisterStack() const { return GetRawOperandAsExpr(0).GetRawOperandAsPartialSSARegisterStackSource(0); }
+		uint32_t GetDestRegister() const { return GetRawOperandAsRegister(1); }
+		void SetDestSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(1, version); }
+		void SetSourceSSAVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(2, version); }
+	};
 	template <> struct LowLevelILInstructionAccessor<LLIL_FLAG>: public LowLevelILInstructionBase
 	{
 		uint32_t GetSourceFlag() const { return GetRawOperandAsRegister(0); }
@@ -764,6 +1075,19 @@ namespace BinaryNinja
 		void SetSourceSSAVersion(size_t version) { UpdateRawOperand(1, version); }
 	};
 
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_SPLIT>: public LowLevelILInstructionBase
+	{
+		uint32_t GetHighRegister() const { return GetRawOperandAsRegister(0); }
+		uint32_t GetLowRegister() const { return GetRawOperandAsRegister(1); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_SPLIT_SSA>: public LowLevelILInstructionBase
+	{
+		SSARegister GetHighSSARegister() const { return GetRawOperandAsSSARegister(0); }
+		SSARegister GetLowSSARegister() const { return GetRawOperandAsSSARegister(2); }
+		void SetHighSSAVersion(size_t version) { UpdateRawOperand(1, version); }
+		void SetLowSSAVersion(size_t version) { UpdateRawOperand(3, version); }
+	};
+
 	template <> struct LowLevelILInstructionAccessor<LLIL_JUMP>: public LowLevelILInstructionBase
 	{
 		LowLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(0); }
@@ -781,6 +1105,7 @@ namespace BinaryNinja
 	{
 		LowLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(0); }
 		size_t GetStackAdjustment() const { return (size_t)GetRawOperandAsInteger(1); }
+		std::map<uint32_t, int32_t> GetRegisterStackAdjustments() const { return GetRawOperandAsRegisterStackAdjustments(2); }
 	};
 	template <> struct LowLevelILInstructionAccessor<LLIL_RET>: public LowLevelILInstructionBase
 	{
@@ -801,6 +1126,11 @@ namespace BinaryNinja
 	template <> struct LowLevelILInstructionAccessor<LLIL_FLAG_COND>: public LowLevelILInstructionBase
 	{
 		BNLowLevelILFlagCondition GetFlagCondition() const { return GetRawOperandAsFlagCondition(0); }
+		uint32_t GetSemanticFlagClass() const { return GetRawOperandAsRegister(1); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FLAG_GROUP>: public LowLevelILInstructionBase
+	{
+		uint32_t GetSemanticFlagGroup() const { return GetRawOperandAsRegister(0); }
 	};
 
 	template <> struct LowLevelILInstructionAccessor<LLIL_TRAP>: public LowLevelILInstructionBase
@@ -815,12 +1145,11 @@ namespace BinaryNinja
 		LowLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(1); }
 		SSARegister GetStackSSARegister() const { return GetRawOperandAsExpr(2).GetRawOperandAsSSARegister(0); }
 		size_t GetSourceMemoryVersion() const { return GetRawOperandAsExpr(2).GetRawOperandAsIndex(2); }
-		LowLevelILSSARegisterList GetParameterSSARegisters() const { return GetRawOperandAsExpr(3).GetRawOperandAsSSARegisterList(0); }
+		LowLevelILInstructionList GetParameterExprs() const { return GetRawOperandAsExpr(3).GetRawOperandAsExprList(0); }
 		void SetDestMemoryVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(0, version); }
 		void SetSourceMemoryVersion(size_t version) { GetRawOperandAsExpr(2).UpdateRawOperand(2, version); }
 		void SetStackSSAVersion(size_t version) { GetRawOperandAsExpr(2).UpdateRawOperand(1, version); }
 		void SetOutputSSARegisters(const std::vector<SSARegister>& regs) { GetRawOperandAsExpr(0).UpdateRawOperandAsSSARegisterList(1, regs); }
-		void SetParameterSSARegisters(const std::vector<SSARegister>& regs) { GetRawOperandAsExpr(3).UpdateRawOperandAsSSARegisterList(0, regs); }
 	};
 	template <> struct LowLevelILInstructionAccessor<LLIL_SYSCALL_SSA>: public LowLevelILInstructionBase
 	{
@@ -828,12 +1157,25 @@ namespace BinaryNinja
 		size_t GetDestMemoryVersion() const { return GetRawOperandAsExpr(0).GetRawOperandAsIndex(0); }
 		SSARegister GetStackSSARegister() const { return GetRawOperandAsExpr(1).GetRawOperandAsSSARegister(0); }
 		size_t GetSourceMemoryVersion() const { return GetRawOperandAsExpr(1).GetRawOperandAsIndex(2); }
-		LowLevelILSSARegisterList GetParameterSSARegisters() const { return GetRawOperandAsExpr(2).GetRawOperandAsSSARegisterList(0); }
+		LowLevelILInstructionList GetParameterExprs() const { return GetRawOperandAsExpr(2).GetRawOperandAsExprList(0); }
 		void SetDestMemoryVersion(size_t version) { GetRawOperandAsExpr(0).UpdateRawOperand(0, version); }
 		void SetSourceMemoryVersion(size_t version) { GetRawOperandAsExpr(1).UpdateRawOperand(2, version); }
 		void SetStackSSAVersion(size_t version) { GetRawOperandAsExpr(1).UpdateRawOperand(1, version); }
 		void SetOutputSSARegisters(const std::vector<SSARegister>& regs) { GetRawOperandAsExpr(0).UpdateRawOperandAsSSARegisterList(1, regs); }
-		void SetParameterSSARegisters(const std::vector<SSARegister>& regs) { GetRawOperandAsExpr(2).UpdateRawOperandAsSSARegisterList(0, regs); }
+	};
+
+	template <> struct LowLevelILInstructionAccessor<LLIL_INTRINSIC>: public LowLevelILInstructionBase
+	{
+		LowLevelILRegisterOrFlagList GetOutputRegisterOrFlagList() const { return GetRawOperandAsRegisterOrFlagList(0); }
+		uint32_t GetIntrinsic() const { return GetRawOperandAsRegister(2); }
+		LowLevelILInstructionList GetParameterExprs() const { return GetRawOperandAsExpr(3).GetRawOperandAsExprList(0); }
+	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_INTRINSIC_SSA>: public LowLevelILInstructionBase
+	{
+		LowLevelILSSARegisterOrFlagList GetOutputSSARegisterOrFlagList() const { return GetRawOperandAsSSARegisterOrFlagList(0); }
+		uint32_t GetIntrinsic() const { return GetRawOperandAsRegister(2); }
+		LowLevelILInstructionList GetParameterExprs() const { return GetRawOperandAsExpr(3).GetRawOperandAsExprList(0); }
+		void SetOutputSSARegisterOrFlagList(const std::vector<SSARegisterOrFlag>& outputs) { UpdateRawOperandAsSSARegisterOrFlagList(0, outputs); }
 	};
 
 	template <> struct LowLevelILInstructionAccessor<LLIL_REG_PHI>: public LowLevelILInstructionBase
@@ -841,6 +1183,11 @@ namespace BinaryNinja
 		SSARegister GetDestSSARegister() const { return GetRawOperandAsSSARegister(0); }
 		LowLevelILSSARegisterList GetSourceSSARegisters() const { return GetRawOperandAsSSARegisterList(2); }
 	};
+	template <> struct LowLevelILInstructionAccessor<LLIL_REG_STACK_PHI>: public LowLevelILInstructionBase
+	{
+		SSARegisterStack GetDestSSARegisterStack() const { return GetRawOperandAsSSARegisterStack(0); }
+		LowLevelILSSARegisterStackList GetSourceSSARegisterStacks() const { return GetRawOperandAsSSARegisterStackList(2); }
+	};
 	template <> struct LowLevelILInstructionAccessor<LLIL_FLAG_PHI>: public LowLevelILInstructionBase
 	{
 		SSAFlag GetDestSSAFlag() const { return GetRawOperandAsSSAFlag(0); }
@@ -862,6 +1209,7 @@ namespace BinaryNinja
 
 	template <> struct LowLevelILInstructionAccessor<LLIL_CONST>: public LowLevelILConstantInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_CONST_PTR>: public LowLevelILConstantInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FLOAT_CONST>: public LowLevelILConstantInstruction {};
 
 	template <> struct LowLevelILInstructionAccessor<LLIL_ADD>: public LowLevelILTwoOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_SUB>: public LowLevelILTwoOperandInstruction {};
@@ -880,6 +1228,10 @@ namespace BinaryNinja
 	template <> struct LowLevelILInstructionAccessor<LLIL_DIVS>: public LowLevelILTwoOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_MODU>: public LowLevelILTwoOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_MODS>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_DIVU_DP>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_DIVS_DP>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_MODU_DP>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_MODS_DP>: public LowLevelILTwoOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_CMP_E>: public LowLevelILTwoOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_CMP_NE>: public LowLevelILTwoOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_CMP_SLT>: public LowLevelILTwoOperandInstruction {};
@@ -892,17 +1244,24 @@ namespace BinaryNinja
 	template <> struct LowLevelILInstructionAccessor<LLIL_CMP_UGT>: public LowLevelILTwoOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_TEST_BIT>: public LowLevelILTwoOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_ADD_OVERFLOW>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FADD>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FSUB>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FMUL>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FDIV>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FCMP_E>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FCMP_NE>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FCMP_LT>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FCMP_LE>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FCMP_GE>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FCMP_GT>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FCMP_O>: public LowLevelILTwoOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FCMP_UO>: public LowLevelILTwoOperandInstruction {};
 
 	template <> struct LowLevelILInstructionAccessor<LLIL_ADC>: public LowLevelILTwoOperandWithCarryInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_SBB>: public LowLevelILTwoOperandWithCarryInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_RLC>: public LowLevelILTwoOperandWithCarryInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_RRC>: public LowLevelILTwoOperandWithCarryInstruction {};
 
-	template <> struct LowLevelILInstructionAccessor<LLIL_DIVU_DP>: public LowLevelILDoublePrecisionInstruction {};
-	template <> struct LowLevelILInstructionAccessor<LLIL_DIVS_DP>: public LowLevelILDoublePrecisionInstruction {};
-	template <> struct LowLevelILInstructionAccessor<LLIL_MODU_DP>: public LowLevelILDoublePrecisionInstruction {};
-	template <> struct LowLevelILInstructionAccessor<LLIL_MODS_DP>: public LowLevelILDoublePrecisionInstruction {};
-
 	template <> struct LowLevelILInstructionAccessor<LLIL_PUSH>: public LowLevelILOneOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_NEG>: public LowLevelILOneOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_NOT>: public LowLevelILOneOperandInstruction {};
@@ -911,4 +1270,14 @@ namespace BinaryNinja
 	template <> struct LowLevelILInstructionAccessor<LLIL_LOW_PART>: public LowLevelILOneOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_BOOL_TO_INT>: public LowLevelILOneOperandInstruction {};
 	template <> struct LowLevelILInstructionAccessor<LLIL_UNIMPL_MEM>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FSQRT>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FNEG>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FABS>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FLOAT_TO_INT>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_INT_TO_FLOAT>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FLOAT_CONV>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_ROUND_TO_INT>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FLOOR>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_CEIL>: public LowLevelILOneOperandInstruction {};
+	template <> struct LowLevelILInstructionAccessor<LLIL_FTRUNC>: public LowLevelILOneOperandInstruction {};
 }