Initial support for more BasicBlock, FunctionValue, & InstructionValue methods

Author: TheDan64

src/basic_block.rs

@@ -1,4 +1,4 @@
-use llvm_sys::core::{LLVMGetBasicBlockParent, LLVMGetBasicBlockTerminator, LLVMGetNextBasicBlock, LLVMInsertBasicBlock, LLVMIsABasicBlock, LLVMIsConstant, LLVMMoveBasicBlockAfter, LLVMMoveBasicBlockBefore, LLVMPrintTypeToString, LLVMPrintValueToString, LLVMTypeOf, LLVMDeleteBasicBlock, LLVMGetPreviousBasicBlock};
+use llvm_sys::core::{LLVMGetBasicBlockParent, LLVMGetBasicBlockTerminator, LLVMGetNextBasicBlock, LLVMInsertBasicBlock, LLVMIsABasicBlock, LLVMIsConstant, LLVMMoveBasicBlockAfter, LLVMMoveBasicBlockBefore, LLVMPrintTypeToString, LLVMPrintValueToString, LLVMTypeOf, LLVMDeleteBasicBlock, LLVMGetPreviousBasicBlock, LLVMRemoveBasicBlockFromParent, LLVMGetFirstInstruction, LLVMGetLastInstruction};
 use llvm_sys::prelude::{LLVMValueRef, LLVMBasicBlockRef};
 
 use values::{FunctionValue, InstructionValue};
@@ -86,12 +86,43 @@ impl BasicBlock {
         BasicBlock::new(bb).expect("Prepending basic block should never fail")
     }
 
-    // REVIEW: Could potentially be unsafe if there are existing references. Might need a global ref counter
-    pub fn delete(self) {
+    pub fn get_first_instruction(&self) -> Option<InstructionValue> {
+        let value = unsafe {
+            LLVMGetFirstInstruction(self.basic_block)
+        };
+
+        if value.is_null() {
+            return None;
+        }
+
+        Some(InstructionValue::new(value))
+    }
+
+    pub fn get_last_instruction(&self) -> Option<InstructionValue> {
+        let value = unsafe {
+            LLVMGetLastInstruction(self.basic_block)
+        };
+
+        if value.is_null() {
+            return None;
+        }
+
+        Some(InstructionValue::new(value))
+    }
+
+    // REVIEW: Potentially unsafe if parent was deleted
+    pub fn remove_from_function(&self) {
         unsafe {
-            LLVMDeleteBasicBlock(self.basic_block)
+            LLVMRemoveBasicBlockFromParent(self.basic_block)
         }
     }
+
+    // REVIEW: Could potentially be unsafe if there are existing references. Might need a global ref counter
+    pub unsafe fn delete(self) {
+        // unsafe {
+        LLVMDeleteBasicBlock(self.basic_block)
+        // }
+    }
 }
 
 impl fmt::Debug for BasicBlock {

src/values/fn_value.rs

@@ -1,5 +1,5 @@
 use llvm_sys::analysis::{LLVMVerifierFailureAction, LLVMVerifyFunction, LLVMViewFunctionCFG, LLVMViewFunctionCFGOnly};
-use llvm_sys::core::{LLVMIsAFunction, LLVMIsConstant, LLVMGetLinkage, LLVMTypeOf, LLVMGetPreviousFunction, LLVMGetNextFunction, LLVMGetParam, LLVMCountParams, LLVMGetLastParam, LLVMCountBasicBlocks, LLVMGetFirstParam, LLVMGetNextParam, LLVMGetBasicBlocks, LLVMGetReturnType, LLVMAppendBasicBlock, LLVMDeleteFunction, LLVMGetElementType, LLVMGetLastBasicBlock, LLVMGetFirstBasicBlock, LLVMGetEntryBasicBlock};
+use llvm_sys::core::{LLVMIsAFunction, LLVMIsConstant, LLVMGetLinkage, LLVMTypeOf, LLVMGetPreviousFunction, LLVMGetNextFunction, LLVMGetParam, LLVMCountParams, LLVMGetLastParam, LLVMCountBasicBlocks, LLVMGetFirstParam, LLVMGetNextParam, LLVMGetBasicBlocks, LLVMGetReturnType, LLVMAppendBasicBlock, LLVMDeleteFunction, LLVMGetElementType, LLVMGetLastBasicBlock, LLVMGetFirstBasicBlock, LLVMGetEntryBasicBlock, LLVMGetPersonalityFn, LLVMSetPersonalityFn, LLVMGetIntrinsicID, LLVMGetFunctionCallConv, LLVMSetFunctionCallConv, LLVMGetGC, LLVMSetGC};
 use llvm_sys::prelude::{LLVMValueRef, LLVMBasicBlockRef};
 
 use std::ffi::{CStr, CString};
@@ -248,6 +248,60 @@ impl FunctionValue {
     pub fn set_metadata(&self, metadata: &MetadataValue, kind_id: u32) {
         self.fn_value.set_metadata(metadata, kind_id)
     }
+
+    // TODOC: How this works as an exception handler
+    // TODO: LLVM 3.9+
+    // pub fn has_personality_function(&self) -> bool {
+    //     unsafe {
+    //         LLVMHasPersonalityFunction(self.as_value_ref())
+    //     }
+    // }
+
+    pub fn get_personality_function(&self) -> Option<FunctionValue> {
+        let value = unsafe {
+            LLVMGetPersonalityFn(self.as_value_ref())
+        };
+
+        FunctionValue::new(value)
+    }
+
+    pub fn set_personality_function(&self, personality_fn: &FunctionValue) {
+        unsafe {
+            LLVMSetPersonalityFn(self.as_value_ref(), personality_fn.as_value_ref())
+        }
+    }
+
+    pub fn get_intrinsic_id(&self) -> u32 {
+        unsafe {
+            LLVMGetIntrinsicID(self.as_value_ref())
+        }
+    }
+
+    pub fn get_call_conventions(&self) -> u32 {
+        unsafe {
+            LLVMGetFunctionCallConv(self.as_value_ref())
+        }
+    }
+
+    pub fn set_call_conventions(&self, call_conventions: u32) {
+        unsafe {
+            LLVMSetFunctionCallConv(self.as_value_ref(), call_conventions)
+        }
+    }
+
+    pub fn get_gc(&self) -> &CStr {
+        unsafe {
+            CStr::from_ptr(LLVMGetGC(self.as_value_ref()))
+        }
+    }
+
+    pub fn set_gc(&self, gc: &str) {
+        let c_string = CString::new(gc).expect("Conversion to CString failed unexpectedly");
+
+        unsafe {
+            LLVMSetGC(self.as_value_ref(), c_string.as_ptr())
+        }
+    }
 }
 
 impl AsValueRef for FunctionValue {

src/values/instruction_value.rs

@@ -1,7 +1,8 @@
-use llvm_sys::core::{LLVMGetInstructionOpcode, LLVMIsTailCall};
+use llvm_sys::core::{LLVMGetInstructionOpcode, LLVMIsTailCall, LLVMGetPreviousInstruction, LLVMGetNextInstruction, LLVMGetInstructionParent, LLVMInstructionEraseFromParent};
 use llvm_sys::LLVMOpcode;
 use llvm_sys::prelude::LLVMValueRef;
 
+use basic_block::BasicBlock;
 use values::traits::AsValueRef;
 use values::Value;
 
@@ -176,6 +177,50 @@ impl InstructionValue {
         InstructionOpcode::new(opcode)
     }
 
+    pub fn get_previous_instruction(&self) -> Option<Self> {
+        let value = unsafe {
+            LLVMGetPreviousInstruction(self.as_value_ref())
+        };
+
+        if value.is_null() {
+            return None;
+        }
+
+        Some(InstructionValue::new(value))
+    }
+
+    pub fn get_next_instruction(&self) -> Option<Self> {
+        let value = unsafe {
+            LLVMGetNextInstruction(self.as_value_ref())
+        };
+
+        if value.is_null() {
+            return None;
+        }
+
+        Some(InstructionValue::new(value))
+    }
+
+    // REVIEW: Potentially unsafe if parent BB or grandparent fn were removed?
+    // REVIEW: Is this actually an erase and should be (self)?
+    pub fn remove_from_basic_block(&self) {
+        unsafe {
+            LLVMInstructionEraseFromParent(self.as_value_ref())
+        }
+    }
+
+    // REVIEW: Potentially unsafe is parent BB or grandparent fn was deleted
+    // REVIEW: Should this *not* be an option? Parent should always exist,
+    // but I doubt LLVM returns null if the parent BB (or grandparent FN)
+    // was deleted... Invalid memory is more likely
+    pub fn get_parent(&self) -> Option<BasicBlock> {
+        let value = unsafe {
+            LLVMGetInstructionParent(self.as_value_ref())
+        };
+
+        BasicBlock::new(value)
+    }
+
     // REVIEW: See if necessary to check opcode == Call first.
     // Does it always return false otherwise?
     pub fn is_tail_call(&self) -> bool {