Added wrappers for LLVMIntPredicate & LLVMRealPredicate

Author: TheDan64

src/basic_block.rs

@@ -110,10 +110,10 @@ impl BasicBlock {
         Some(InstructionValue::new(value))
     }
 
-    // REVIEW: Potentially unsafe if parent was deleted
     // SubTypes: Don't need to call get_parent for a BasicBlock<HasParent>
     pub fn remove_from_function(&self) {
-        if let Some(_) = self.get_parent() {
+        // This method is UB if the parent no longer exists, so we must check for parent (or encode into type system)
+        if self.get_parent().is_some() {
             unsafe {
                 LLVMRemoveBasicBlockFromParent(self.basic_block)
             }

src/builder.rs

@@ -1,8 +1,9 @@
 use either::Either;
 use llvm_sys::core::{LLVMBuildAdd, LLVMBuildAlloca, LLVMBuildAnd, LLVMBuildArrayAlloca, LLVMBuildArrayMalloc, LLVMBuildBr, LLVMBuildCall, LLVMBuildCast, LLVMBuildCondBr, LLVMBuildExtractValue, LLVMBuildFAdd, LLVMBuildFCmp, LLVMBuildFDiv, LLVMBuildFence, LLVMBuildFMul, LLVMBuildFNeg, LLVMBuildFree, LLVMBuildFSub, LLVMBuildGEP, LLVMBuildICmp, LLVMBuildInsertValue, LLVMBuildIsNotNull, LLVMBuildIsNull, LLVMBuildLoad, LLVMBuildMalloc, LLVMBuildMul, LLVMBuildNeg, LLVMBuildNot, LLVMBuildOr, LLVMBuildPhi, LLVMBuildPointerCast, LLVMBuildRet, LLVMBuildRetVoid, LLVMBuildStore, LLVMBuildSub, LLVMBuildUDiv, LLVMBuildUnreachable, LLVMBuildXor, LLVMDisposeBuilder, LLVMGetElementType, LLVMGetInsertBlock, LLVMGetReturnType, LLVMGetTypeKind, LLVMInsertIntoBuilder, LLVMPositionBuilderAtEnd, LLVMTypeOf, LLVMSetTailCall, LLVMBuildExtractElement, LLVMBuildInsertElement, LLVMBuildIntToPtr, LLVMBuildPtrToInt, LLVMInsertIntoBuilderWithName, LLVMClearInsertionPosition, LLVMCreateBuilder, LLVMPositionBuilder, LLVMPositionBuilderBefore, LLVMBuildAggregateRet, LLVMBuildStructGEP, LLVMBuildInBoundsGEP, LLVMBuildPtrDiff, LLVMBuildNSWAdd, LLVMBuildNUWAdd, LLVMBuildNSWSub, LLVMBuildNUWSub, LLVMBuildNSWMul, LLVMBuildNUWMul, LLVMBuildSDiv, LLVMBuildSRem, LLVMBuildURem, LLVMBuildFRem, LLVMBuildNSWNeg, LLVMBuildNUWNeg, LLVMBuildFPToUI, LLVMBuildFPToSI, LLVMBuildSIToFP, LLVMBuildUIToFP, LLVMBuildFPTrunc, LLVMBuildFPExt, LLVMBuildIntCast, LLVMBuildFPCast, LLVMBuildSExtOrBitCast, LLVMBuildZExtOrBitCast, LLVMBuildTruncOrBitCast, LLVMBuildSwitch, LLVMAddCase, LLVMBuildShl, LLVMBuildAShr, LLVMBuildLShr};
 use llvm_sys::prelude::{LLVMBuilderRef, LLVMValueRef};
-use llvm_sys::{LLVMOpcode, LLVMIntPredicate, LLVMTypeKind, LLVMRealPredicate, LLVMAtomicOrdering};
+use llvm_sys::{LLVMOpcode, LLVMTypeKind, LLVMAtomicOrdering};
 
+use {IntPredicate, FloatPredicate};
 use basic_block::BasicBlock;
 use values::{AggregateValue, AsValueRef, BasicValue, BasicValueEnum, PhiValue, FunctionValue, FloatValue, IntValue, PointerValue, VectorValue, InstructionValue};
 use types::{AsTypeRef, BasicType, PointerType, IntType, FloatType};
@@ -740,23 +741,23 @@ impl Builder {
 
     // SubType: <I>(&self, op, lhs: &IntValue<I>, rhs: &IntValue<I>, name) -> IntValue<bool> { ?
     // FIXME: Don't take llvm-sys op enum
-    pub fn build_int_compare(&self, op: LLVMIntPredicate, lhs: &IntValue, rhs: &IntValue, name: &str) -> IntValue {
+    pub fn build_int_compare(&self, op: &IntPredicate, lhs: &IntValue, rhs: &IntValue, name: &str) -> IntValue {
         let c_string = CString::new(name).expect("Conversion to CString failed unexpectedly");
 
         let value = unsafe {
-            LLVMBuildICmp(self.builder, op, lhs.as_value_ref(), rhs.as_value_ref(), c_string.as_ptr())
+            LLVMBuildICmp(self.builder, op.as_llvm_predicate(), lhs.as_value_ref(), rhs.as_value_ref(), c_string.as_ptr())
         };
 
         IntValue::new(value)
     }
 
     // SubType: <F>(&self, op, lhs: &FloatValue<F>, rhs: &FloatValue<F>, name) -> IntValue<bool> { ?
     // FIXME: Don't take llvm-sys op enum
-    pub fn build_float_compare(&self, op: LLVMRealPredicate, lhs: &FloatValue, rhs: &FloatValue, name: &str) -> IntValue {
+    pub fn build_float_compare(&self, op: &FloatPredicate, lhs: &FloatValue, rhs: &FloatValue, name: &str) -> IntValue {
         let c_string = CString::new(name).expect("Conversion to CString failed unexpectedly");
 
         let value = unsafe {
-            LLVMBuildFCmp(self.builder, op, lhs.as_value_ref(), rhs.as_value_ref(), c_string.as_ptr())
+            LLVMBuildFCmp(self.builder, op.as_llvm_predicate(), lhs.as_value_ref(), rhs.as_value_ref(), c_string.as_ptr())
         };
 
         IntValue::new(value)

src/lib.rs

@@ -17,6 +17,8 @@ pub mod targets;
 pub mod types;
 pub mod values;
 
+use llvm_sys::{LLVMIntPredicate, LLVMRealPredicate};
+
 // TODO: Probably move into error handling module
 pub fn enable_llvm_pretty_stack_trace() {
     // use llvm_sys::error_handling::LLVMEnablePrettyStackTrace; // v3.8
@@ -47,6 +49,81 @@ pub fn shutdown_llvm() {
     }
 }
 
+// REVIEW: Maybe this belongs in some sort of prelude?
+pub enum IntPredicate {
+    EQ,
+    NE,
+    UGT,
+    UGE,
+    ULT,
+    ULE,
+    SGT,
+    SGE,
+    SLT,
+    SLE,
+}
+
+impl IntPredicate {
+    pub(crate) fn as_llvm_predicate(&self) -> LLVMIntPredicate {
+        match *self {
+            IntPredicate::EQ => LLVMIntPredicate::LLVMIntEQ,
+            IntPredicate::NE => LLVMIntPredicate::LLVMIntNE,
+            IntPredicate::UGT => LLVMIntPredicate::LLVMIntUGT,
+            IntPredicate::UGE => LLVMIntPredicate::LLVMIntUGE,
+            IntPredicate::ULT => LLVMIntPredicate::LLVMIntULT,
+            IntPredicate::ULE => LLVMIntPredicate::LLVMIntULE,
+            IntPredicate::SGT => LLVMIntPredicate::LLVMIntSGT,
+            IntPredicate::SGE => LLVMIntPredicate::LLVMIntSGE,
+            IntPredicate::SLT => LLVMIntPredicate::LLVMIntSLT,
+            IntPredicate::SLE => LLVMIntPredicate::LLVMIntSLE,
+        }
+    }
+}
+
+// REVIEW: Maybe this belongs in some sort of prelude?
+pub enum FloatPredicate {
+    PredicateFalse,
+    OEQ,
+    OGT,
+    OGE,
+    OLT,
+    OLE,
+    ONE,
+    ORD,
+    UNO,
+    UEQ,
+    UGT,
+    UGE,
+    ULT,
+    ULE,
+    UNE,
+    PredicateTrue,
+}
+
+impl FloatPredicate {
+    pub(crate) fn as_llvm_predicate(&self) -> LLVMRealPredicate {
+        match *self {
+            FloatPredicate::PredicateFalse => LLVMRealPredicate::LLVMRealPredicateFalse,
+            FloatPredicate::OEQ => LLVMRealPredicate::LLVMRealOEQ,
+            FloatPredicate::OGT => LLVMRealPredicate::LLVMRealOGT,
+            FloatPredicate::OGE => LLVMRealPredicate::LLVMRealOGE,
+            FloatPredicate::OLT => LLVMRealPredicate::LLVMRealOLT,
+            FloatPredicate::OLE => LLVMRealPredicate::LLVMRealOLE,
+            FloatPredicate::ONE => LLVMRealPredicate::LLVMRealONE,
+            FloatPredicate::ORD => LLVMRealPredicate::LLVMRealORD,
+            FloatPredicate::UNO => LLVMRealPredicate::LLVMRealUNO,
+            FloatPredicate::UEQ => LLVMRealPredicate::LLVMRealUEQ,
+            FloatPredicate::UGT => LLVMRealPredicate::LLVMRealUGT,
+            FloatPredicate::UGE => LLVMRealPredicate::LLVMRealUGE,
+            FloatPredicate::ULT => LLVMRealPredicate::LLVMRealULT,
+            FloatPredicate::ULE => LLVMRealPredicate::LLVMRealULE,
+            FloatPredicate::UNE => LLVMRealPredicate::LLVMRealUNE,
+            FloatPredicate::PredicateTrue => LLVMRealPredicate::LLVMRealPredicateTrue,
+        }
+    }
+}
+
+
 // Misc Notes
 // Always pass a c_string.as_ptr() call into the function call directly and never
 // before hand. Seems to make a huge difference (stuff stops working) otherwise

src/values/float_value.rs

@@ -1,9 +1,9 @@
 use llvm_sys::core::{LLVMConstFNeg, LLVMConstFAdd, LLVMConstFSub, LLVMConstFMul, LLVMConstFDiv, LLVMConstFRem, LLVMConstFPCast, LLVMConstFPToUI, LLVMConstFPToSI, LLVMConstFPTrunc, LLVMConstFPExt, LLVMConstFCmp};
 use llvm_sys::prelude::LLVMValueRef;
-use llvm_sys::LLVMRealPredicate;
 
 use std::ffi::CStr;
 
+use FloatPredicate;
 use types::{AsTypeRef, FloatType, IntType};
 use values::traits::AsValueRef;
 use values::{InstructionValue, IntValue, Value, MetadataValue};
@@ -159,9 +159,9 @@ impl FloatValue {
     }
 
     // FIXME: Don't take llvm-sys op enum
-    pub fn const_float_compare(&self, op: LLVMRealPredicate, rhs: &FloatValue) -> IntValue {
+    pub fn const_float_compare(&self, op: &FloatPredicate, rhs: &FloatValue) -> IntValue {
         let value = unsafe {
-            LLVMConstFCmp(op, self.as_value_ref(), rhs.as_value_ref())
+            LLVMConstFCmp(op.as_llvm_predicate(), self.as_value_ref(), rhs.as_value_ref())
         };
 
         IntValue::new(value)

src/values/int_value.rs

@@ -1,9 +1,9 @@
 use llvm_sys::core::{LLVMConstNot, LLVMConstNeg, LLVMConstNSWNeg, LLVMConstNUWNeg, LLVMConstAdd, LLVMConstNSWAdd, LLVMConstNUWAdd, LLVMConstSub, LLVMConstNSWSub, LLVMConstNUWSub, LLVMConstMul, LLVMConstNSWMul, LLVMConstNUWMul, LLVMConstUDiv, LLVMConstSDiv, LLVMConstSRem, LLVMConstURem, LLVMConstIntCast, LLVMConstXor, LLVMConstOr, LLVMConstAnd, LLVMConstExactSDiv, LLVMConstShl, LLVMConstLShr, LLVMConstAShr, LLVMConstUIToFP, LLVMConstSIToFP, LLVMConstIntToPtr, LLVMConstTrunc, LLVMConstSExt, LLVMConstZExt, LLVMConstTruncOrBitCast, LLVMConstSExtOrBitCast, LLVMConstZExtOrBitCast, LLVMConstBitCast, LLVMConstICmp};
 use llvm_sys::prelude::LLVMValueRef;
-use llvm_sys::LLVMIntPredicate;
 
 use std::ffi::CStr;
 
+use IntPredicate;
 use types::{AsTypeRef, FloatType, PointerType, IntType};
 use values::traits::AsValueRef;
 use values::{FloatValue, InstructionValue, PointerValue, Value, MetadataValue};
@@ -358,9 +358,9 @@ impl IntValue {
     }
 
     // FIXME: Don't take llvm-sys op enum
-    pub fn const_int_compare(&self, op: LLVMIntPredicate, rhs: &IntValue) -> IntValue {
+    pub fn const_int_compare(&self, op: &IntPredicate, rhs: &IntValue) -> IntValue {
         let value = unsafe {
-            LLVMConstICmp(op, self.as_value_ref(), rhs.as_value_ref())
+            LLVMConstICmp(op.as_llvm_predicate(), self.as_value_ref(), rhs.as_value_ref())
         };
 
         IntValue::new(value)