Added support for covnerting FunctionValue to GlobalValue

Which ultimately allows for conversion to PointerValue

Author: TheDan64

src/module.rs

@@ -1329,8 +1329,7 @@ impl Module {
     // SubTypes: Might need to return Option<BVE, MV<Enum>, or MV<String>>
     #[llvm_versions(7.0 => latest)]
     pub fn get_flag(&self, key: &str) -> Option<MetadataValue> {
-        use llvm_sys::core::{LLVMGetTypeKind, LLVMTypeOf, LLVMMetadataAsValue};
-        use llvm_sys::LLVMTypeKind;
+        use llvm_sys::core::{LLVMTypeOf, LLVMMetadataAsValue};
 
         let flag = unsafe {
             LLVMGetModuleFlag(self.module.get(), key.as_ptr() as *const i8, key.len())
@@ -1347,8 +1346,6 @@ impl Module {
             LLVMMetadataAsValue(*ctx.context, flag)
         };
 
-        let value = unsafe { LLVMGetTypeKind(LLVMTypeOf(flag_value)) };
-
         Some(MetadataValue::new(flag_value))
     }
 

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, LLVMGetIntrinsicID, LLVMGetFunctionCallConv, LLVMSetFunctionCallConv, LLVMGetGC, LLVMSetGC, LLVMSetLinkage, LLVMSetParamAlignment, LLVMGetParams, LLVMIsDeclaration};
+use llvm_sys::core::{LLVMIsAFunction, LLVMIsConstant, LLVMGetLinkage, LLVMTypeOf, LLVMGetPreviousFunction, LLVMGetNextFunction, LLVMGetParam, LLVMCountParams, LLVMGetLastParam, LLVMCountBasicBlocks, LLVMGetFirstParam, LLVMGetNextParam, LLVMGetBasicBlocks, LLVMGetReturnType, LLVMAppendBasicBlock, LLVMDeleteFunction, LLVMGetElementType, LLVMGetLastBasicBlock, LLVMGetFirstBasicBlock, LLVMGetEntryBasicBlock, LLVMGetIntrinsicID, LLVMGetFunctionCallConv, LLVMSetFunctionCallConv, LLVMGetGC, LLVMSetGC, LLVMSetLinkage, LLVMSetParamAlignment, LLVMGetParams};
 #[llvm_versions(3.7 => latest)]
 use llvm_sys::core::{LLVMGetPersonalityFn, LLVMSetPersonalityFn};
 #[llvm_versions(3.9 => latest)]
@@ -17,7 +17,7 @@ use module::Linkage;
 use support::LLVMString;
 use types::{BasicTypeEnum, FunctionType};
 use values::traits::AsValueRef;
-use values::{BasicValueEnum, Value, MetadataValue};
+use values::{BasicValueEnum, GlobalValue, Value, MetadataValue};
 
 #[derive(PartialEq, Eq, Clone, Copy)]
 pub struct FunctionValue {
@@ -540,31 +540,11 @@ impl FunctionValue {
         }
     }
 
-    /// Determines whether or not a `FunctionValue` is a declaration based on
-    /// whether or not it contains a body definition whatsoever
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use inkwell::context::Context;
-    ///
-    /// let context = Context::create();
-    /// let builder = context.create_builder();
-    /// let module = context.create_module("my_mod");
-    /// let void_type = context.void_type();
-    /// let fn_type = void_type.fn_type(&[], false);
-    /// let fn_value = module.add_function("my_func", fn_type, None);
-    ///
-    /// assert!(fn_value.is_declaration());
-    ///
-    /// fn_value.append_basic_block("entry");
-    ///
-    /// assert!(!fn_value.is_declaration());
-    /// ```
-    pub fn is_declaration(&self) -> bool {
-        unsafe {
-            LLVMIsDeclaration(self.as_value_ref()) != 0
-        }
+    /// Gets the `GlobalValue` version of this `FunctionValue`. This allows
+    /// you to further inspect its global properties or even convert it to
+    /// a `PointerValue`.
+    pub fn as_global_value(&self) -> GlobalValue {
+        GlobalValue::new(self.as_value_ref())
     }
 }
 

src/values/global_value.rs

@@ -7,6 +7,7 @@ use llvm_sys::prelude::LLVMValueRef;
 use std::ffi::{CString, CStr};
 
 use {GlobalVisibility, ThreadLocalMode, DLLStorageClass};
+use support::LLVMString;
 #[llvm_versions(7.0 => latest)]
 use comdat::Comdat;
 use values::traits::AsValueRef;
@@ -120,7 +121,26 @@ impl GlobalValue {
     }
 
     // SubType: This should be moved into the type. GlobalValue<Initialized/Uninitialized>
-    // TODO: FunctionValues as well?
+    /// Determines whether or not a `GlobalValue` is a declaration or a definition.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use inkwell::context::Context;
+    ///
+    /// let context = Context::create();
+    /// let builder = context.create_builder();
+    /// let module = context.create_module("my_mod");
+    /// let void_type = context.void_type();
+    /// let fn_type = void_type.fn_type(&[], false);
+    /// let fn_value = module.add_function("my_func", fn_type, None);
+    ///
+    /// assert!(fn_value.as_global_value().is_declaration());
+    ///
+    /// fn_value.append_basic_block("entry");
+    ///
+    /// assert!(!fn_value.as_global_value().is_declaration());
+    /// ```
     pub fn is_declaration(&self) -> bool {
         unsafe {
             LLVMIsDeclaration(self.as_value_ref()) == 1
@@ -256,6 +276,10 @@ impl GlobalValue {
             LLVMSetUnnamedAddress(self.as_value_ref(), address.as_llvm_enum())
         }
     }
+
+    pub fn print_to_string(&self) -> LLVMString {
+        self.global_value.print_to_string()
+    }
 }
 
 impl AsValueRef for GlobalValue {

tests/all/test_values.rs

@@ -974,13 +974,13 @@ fn test_phi_values() {
     let fn_type = void_type.fn_type(&[bool_type.into()], false);
     let fn_value = module.add_function("my_func", fn_type, None);
 
-    assert!(fn_value.is_declaration());
+    assert!(fn_value.as_global_value().is_declaration());
 
     let entry_block = fn_value.append_basic_block("entry");
     let then_block = fn_value.append_basic_block("then");
     let else_block = fn_value.append_basic_block("else");
 
-    assert!(!fn_value.is_declaration());
+    assert!(!fn_value.as_global_value().is_declaration());
 
     builder.position_at_end(&entry_block);
 
@@ -1186,3 +1186,38 @@ fn test_consts() {
     assert!(i32_param.get_zero_extended_constant().is_none());
     assert!(f32_param.get_constant().is_none());
 }
+
+#[test]
+fn test_function_value_to_global_to_pointer() {
+    let context = Context::create();
+    let builder = context.create_builder();
+    let module = context.create_module("my_mod");
+    let void_type = context.void_type();
+    let fn_type = void_type.fn_type(&[], false);
+    let fn_value = module.add_function("my_func", fn_type, None);
+
+    let fn_global_value = fn_value.as_global_value();
+
+    assert!(fn_global_value.is_declaration());
+
+    let bb = fn_value.append_basic_block("entry");
+
+    builder.position_at_end(&bb);
+    builder.build_return(None);
+
+    assert!(!fn_global_value.is_declaration());
+    assert_eq!(fn_global_value.get_dll_storage_class(), DLLStorageClass::Default);
+
+    fn_global_value.set_dll_storage_class(DLLStorageClass::Export);
+
+    assert_eq!(fn_global_value.get_dll_storage_class(), DLLStorageClass::Export);
+    assert!(fn_global_value.get_thread_local_mode().is_none());
+    assert_eq!(fn_global_value.get_visibility(), GlobalVisibility::Default);
+
+    let fn_ptr_value = fn_global_value.as_pointer_value();
+    let fn_ptr_type = fn_ptr_value.get_type();
+
+    assert!(!fn_ptr_value.is_null());
+    assert_eq!(*fn_ptr_value.get_name(), *CString::new("my_func").unwrap());
+    assert!(module.verify().is_ok());
+}