Typedefing llil identifiers as ExprId

1 files changed, 69 insertions, 69 deletions

diff --git a/lowlevelil.cpp b/lowlevelil.cpp
index 97abb8af..e4c65b3a 100644
--- a/lowlevelil.cpp
+++ b/lowlevelil.cpp
@@ -38,392 +38,392 @@ void LowLevelILFunction::SetCurrentAddress(uint64_t addr)
 }
 
 
-size_t LowLevelILFunction::AddExpr(BNLowLevelILOperation operation, size_t size, uint32_t flags,
-                                   uint64_t a, uint64_t b, uint64_t c, uint64_t d)
+ExprId LowLevelILFunction::AddExpr(BNLowLevelILOperation operation, size_t size, uint32_t flags,
+                                   ExprId a, ExprId b, ExprId c, ExprId d)
 {
 	return BNLowLevelILAddExpr(m_func, operation, size, flags, a, b, c, d);
 }
 
 
-size_t LowLevelILFunction::AddInstruction(size_t expr)
+ExprId LowLevelILFunction::AddInstruction(size_t expr)
 {
 	return BNLowLevelILAddInstruction(m_func, expr);
 }
 
 
-size_t LowLevelILFunction::Nop()
+ExprId LowLevelILFunction::Nop()
 {
 	return AddExpr(LLIL_NOP, 0, 0);
 }
 
 
-size_t LowLevelILFunction::SetRegister(size_t size, uint32_t reg, uint64_t val)
+ExprId LowLevelILFunction::SetRegister(size_t size, uint32_t reg, ExprId val)
 {
 	return AddExpr(LLIL_SET_REG, size, 0, reg, val);
 }
 
 
-size_t LowLevelILFunction::SetRegisterSplit(size_t size, uint32_t high, uint32_t low, uint64_t val)
+ExprId LowLevelILFunction::SetRegisterSplit(size_t size, uint32_t high, uint32_t low, ExprId val)
 {
 	return AddExpr(LLIL_SET_REG_SPLIT, size, 0, high, low, val);
 }
 
 
-size_t LowLevelILFunction::SetFlag(uint32_t flag, uint64_t val)
+ExprId LowLevelILFunction::SetFlag(uint32_t flag, ExprId val)
 {
 	return AddExpr(LLIL_SET_FLAG, 0, 0, flag, val);
 }
 
 
-size_t LowLevelILFunction::Load(size_t size, uint64_t addr)
+ExprId LowLevelILFunction::Load(size_t size, ExprId addr)
 {
 	return AddExpr(LLIL_LOAD, size, 0, addr);
 }
 
 
-size_t LowLevelILFunction::Store(size_t size, uint64_t addr, uint64_t val)
+ExprId LowLevelILFunction::Store(size_t size, ExprId addr, ExprId val)
 {
 	return AddExpr(LLIL_STORE, size, 0, addr, val);
 }
 
 
-size_t LowLevelILFunction::Push(size_t size, uint64_t val)
+ExprId LowLevelILFunction::Push(size_t size, ExprId val)
 {
 	return AddExpr(LLIL_PUSH, size, 0, val);
 }
 
 
-size_t LowLevelILFunction::Pop(size_t size)
+ExprId LowLevelILFunction::Pop(size_t size)
 {
 	return AddExpr(LLIL_POP, size, 0);
 }
 
 
-size_t LowLevelILFunction::Register(size_t size, uint32_t reg)
+ExprId LowLevelILFunction::Register(size_t size, uint32_t reg)
 {
 	return AddExpr(LLIL_REG, size, 0, reg);
 }
 
 
-size_t LowLevelILFunction::Const(size_t size, uint64_t val)
+ExprId LowLevelILFunction::Const(size_t size, uint64_t val)
 {
 	return AddExpr(LLIL_CONST, size, 0, val);
 }
 
 
-size_t LowLevelILFunction::Flag(uint32_t reg)
+ExprId LowLevelILFunction::Flag(uint32_t reg)
 {
 	return AddExpr(LLIL_FLAG, 0, 0, reg);
 }
 
 
-size_t LowLevelILFunction::Add(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::Add(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_ADD, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::AddCarry(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::AddCarry(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_ADC, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::Sub(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::Sub(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_SUB, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::SubBorrow(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::SubBorrow(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_SBB, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::And(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::And(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_AND, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::Or(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::Or(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_OR, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::Xor(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::Xor(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_XOR, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::ShiftLeft(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::ShiftLeft(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_LSL, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::LogicalShiftRight(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::LogicalShiftRight(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_LSR, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::ArithShiftRight(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::ArithShiftRight(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_ASR, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::RotateLeft(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::RotateLeft(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_ROL, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::RotateLeftCarry(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::RotateLeftCarry(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_RLC, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::RotateRight(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::RotateRight(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_ROR, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::RotateRightCarry(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::RotateRightCarry(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_RRC, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::Mult(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::Mult(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_MUL, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::MultDoublePrecUnsigned(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::MultDoublePrecUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_MULU_DP, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::MultDoublePrecSigned(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::MultDoublePrecSigned(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_MULS_DP, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::DivUnsigned(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::DivUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_DIVU, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::DivDoublePrecUnsigned(size_t size, uint64_t high, uint64_t low, uint64_t div, uint32_t flags)
+ExprId LowLevelILFunction::DivDoublePrecUnsigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags)
 {
 	return AddExpr(LLIL_DIVU_DP, size, flags, high, low, div);
 }
 
 
-size_t LowLevelILFunction::DivSigned(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::DivSigned(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_DIVS, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::DivDoublePrecSigned(size_t size, uint64_t high, uint64_t low, uint64_t div, uint32_t flags)
+ExprId LowLevelILFunction::DivDoublePrecSigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags)
 {
 	return AddExpr(LLIL_DIVS_DP, size, flags, high, low, div);
 }
 
 
-size_t LowLevelILFunction::ModUnsigned(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::ModUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_MODU, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::ModDoublePrecUnsigned(size_t size, uint64_t high, uint64_t low, uint64_t div, uint32_t flags)
+ExprId LowLevelILFunction::ModDoublePrecUnsigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags)
 {
 	return AddExpr(LLIL_MODU_DP, size, flags, high, low, div);
 }
 
 
-size_t LowLevelILFunction::ModSigned(size_t size, uint64_t a, uint64_t b, uint32_t flags)
+ExprId LowLevelILFunction::ModSigned(size_t size, ExprId a, ExprId b, uint32_t flags)
 {
 	return AddExpr(LLIL_MODS, size, flags, a, b);
 }
 
 
-size_t LowLevelILFunction::ModDoublePrecSigned(size_t size, uint64_t high, uint64_t low, uint64_t div, uint32_t flags)
+ExprId LowLevelILFunction::ModDoublePrecSigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags)
 {
 	return AddExpr(LLIL_MODS_DP, size, flags, high, low, div);
 }
 
 
-size_t LowLevelILFunction::Neg(size_t size, uint64_t a, uint32_t flags)
+ExprId LowLevelILFunction::Neg(size_t size, ExprId a, uint32_t flags)
 {
 	return AddExpr(LLIL_NEG, size, flags, a);
 }
 
 
-size_t LowLevelILFunction::Not(size_t size, uint64_t a, uint32_t flags)
+ExprId LowLevelILFunction::Not(size_t size, ExprId a, uint32_t flags)
 {
 	return AddExpr(LLIL_NOT, size, flags, a);
 }
 
 
-size_t LowLevelILFunction::SignExtend(size_t size, uint64_t a)
+ExprId LowLevelILFunction::SignExtend(size_t size, ExprId a)
 {
 	return AddExpr(LLIL_SX, size, 0, a);
 }
 
 
-size_t LowLevelILFunction::ZeroExtend(size_t size, uint64_t a)
+ExprId LowLevelILFunction::ZeroExtend(size_t size, ExprId a)
 {
 	return AddExpr(LLIL_ZX, size, 0, a);
 }
 
 
-size_t LowLevelILFunction::Jump(uint64_t dest)
+ExprId LowLevelILFunction::Jump(ExprId dest)
 {
 	return AddExpr(LLIL_JUMP, 0, 0, dest);
 }
 
 
-size_t LowLevelILFunction::Call(uint64_t dest)
+ExprId LowLevelILFunction::Call(ExprId dest)
 {
 	return AddExpr(LLIL_CALL, 0, 0, dest);
 }
 
 
-size_t LowLevelILFunction::Return(size_t dest)
+ExprId LowLevelILFunction::Return(size_t dest)
 {
 	return AddExpr(LLIL_RET, 0, 0, dest);
 }
 
 
-size_t LowLevelILFunction::NoReturn()
+ExprId LowLevelILFunction::NoReturn()
 {
 	return AddExpr(LLIL_NORET, 0, 0);
 }
 
 
-size_t LowLevelILFunction::FlagCondition(BNLowLevelILFlagCondition cond)
+ExprId LowLevelILFunction::FlagCondition(BNLowLevelILFlagCondition cond)
 {
-	return AddExpr(LLIL_FLAG_COND, 0, 0, (uint64_t)cond);
+	return AddExpr(LLIL_FLAG_COND, 0, 0, (ExprId)cond);
 }
 
 
-size_t LowLevelILFunction::CompareEqual(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareEqual(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_E, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareNotEqual(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareNotEqual(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_NE, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareSignedLessThan(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareSignedLessThan(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_SLT, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareUnsignedLessThan(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareUnsignedLessThan(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_ULT, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareSignedLessEqual(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareSignedLessEqual(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_SLE, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareUnsignedLessEqual(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareUnsignedLessEqual(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_ULE, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareSignedGreaterEqual(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareSignedGreaterEqual(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_SGE, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareUnsignedGreaterEqual(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareUnsignedGreaterEqual(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_UGE, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareSignedGreaterThan(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareSignedGreaterThan(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_SGT, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::CompareUnsignedGreaterThan(size_t size, uint64_t a, uint64_t b)
+ExprId LowLevelILFunction::CompareUnsignedGreaterThan(size_t size, ExprId a, ExprId b)
 {
 	return AddExpr(LLIL_CMP_UGT, size, 0, a, b);
 }
 
 
-size_t LowLevelILFunction::SystemCall()
+ExprId LowLevelILFunction::SystemCall()
 {
 	return AddExpr(LLIL_SYSCALL, 0, 0);
 }
 
 
-size_t LowLevelILFunction::Breakpoint()
+ExprId LowLevelILFunction::Breakpoint()
 {
 	return AddExpr(LLIL_BP, 0, 0);
 }
 
 
-size_t LowLevelILFunction::Trap(uint32_t num)
+ExprId LowLevelILFunction::Trap(uint32_t num)
 {
 	return AddExpr(LLIL_TRAP, 0, 0, num);
 }
 
 
-size_t LowLevelILFunction::Undefined()
+ExprId LowLevelILFunction::Undefined()
 {
 	return AddExpr(LLIL_UNDEF, 0, 0);
 }
 
 
-size_t LowLevelILFunction::Unimplemented()
+ExprId LowLevelILFunction::Unimplemented()
 {
 	return AddExpr(LLIL_UNIMPL, 0, 0);
 }
 
 
-size_t LowLevelILFunction::UnimplementedMemoryRef(size_t size, uint64_t addr)
+ExprId LowLevelILFunction::UnimplementedMemoryRef(size_t size, ExprId addr)
 {
 	return AddExpr(LLIL_UNIMPL_MEM, size, 0, addr);
 }
 
 
-size_t LowLevelILFunction::Goto(BNLowLevelILLabel& label)
+ExprId LowLevelILFunction::Goto(BNLowLevelILLabel& label)
 {
 	return BNLowLevelILGoto(m_func, &label);
 }
 
 
-size_t LowLevelILFunction::If(uint64_t operand, BNLowLevelILLabel& t, BNLowLevelILLabel& f)
+ExprId LowLevelILFunction::If(ExprId operand, BNLowLevelILLabel& t, BNLowLevelILLabel& f)
 {
 	return BNLowLevelILIf(m_func, operand, &t, &f);
 }
@@ -453,13 +453,13 @@ size_t LowLevelILFunction::GetInstructionCount() const
 }
 
 
-void LowLevelILFunction::AddLabelForAddress(Architecture* arch, uint64_t addr)
+void LowLevelILFunction::AddLabelForAddress(Architecture* arch, ExprId addr)
 {
 	BNAddLowLevelILLabelForAddress(m_func, arch->GetArchitectureObject(), addr);
 }
 
 
-BNLowLevelILLabel* LowLevelILFunction::GetLabelForAddress(Architecture* arch, uint64_t addr)
+BNLowLevelILLabel* LowLevelILFunction::GetLabelForAddress(Architecture* arch, ExprId addr)
 {
 	return BNGetLowLevelILLabelForAddress(m_func, arch->GetArchitectureObject(), addr);
 }