Merge pull request rust-lang#132 from seanyoung/metadata

Move MetadataValue methods to InstructionValue

Author: TheDan64

src/context.rs

@@ -648,10 +648,21 @@ impl Context {
     /// let f32_zero = f32_type.const_float(0.);
     /// let md_node = context.metadata_node(&[i8_two.into(), f32_zero.into()]);
     /// let f32_one = f32_type.const_float(1.);
+    /// let void_type = context.void_type();
+    ///
+    /// let builder = context.create_builder();
+    /// let module = context.create_module("my_mod");
+    /// let fn_type = void_type.fn_type(&[f32_type.into()], false);
+    /// let fn_value = module.add_function("my_func", fn_type, None);
+    /// let entry_block = fn_value.append_basic_block("entry");
+    ///
+    /// builder.position_at_end(&entry_block);
+    ///
+    /// let ret_instr = builder.build_return(None);
     ///
     /// assert!(md_node.is_node());
     ///
-    /// f32_one.set_metadata(md_node, 0);
+    /// ret_instr.set_metadata(md_node, 0);
     /// ```
     // REVIEW: Maybe more helpful to beginners to call this metadata_tuple?
     // REVIEW: Seems to be unassgned to anything
@@ -678,12 +689,23 @@ impl Context {
     /// let md_string = context.metadata_string("Floats are awesome!");
     /// let f32_type = context.f32_type();
     /// let f32_one = f32_type.const_float(1.);
+    /// let void_type = context.void_type();
+    ///
+    /// let builder = context.create_builder();
+    /// let module = context.create_module("my_mod");
+    /// let fn_type = void_type.fn_type(&[f32_type.into()], false);
+    /// let fn_value = module.add_function("my_func", fn_type, None);
+    /// let entry_block = fn_value.append_basic_block("entry");
+    ///
+    /// builder.position_at_end(&entry_block);
+    ///
+    /// let ret_instr = builder.build_return(None);
     ///
     /// assert!(md_string.is_string());
     ///
-    /// f32_one.set_metadata(md_string, 0);
+    /// ret_instr.set_metadata(md_string, 0);
     /// ```
-    // REVIEW: Seems to be unassgned to anything
+    // REVIEW: Seems to be unassigned to anything
     pub fn metadata_string(&self, string: &str) -> MetadataValue {
         let c_string = CString::new(string).expect("Conversion to CString failed unexpectedly");
 

src/values/array_value.rs

@@ -7,7 +7,7 @@ use std::fmt;
 use crate::support::LLVMString;
 use crate::types::ArrayType;
 use crate::values::traits::AsValueRef;
-use crate::values::{Value, InstructionValue, MetadataValue};
+use crate::values::{Value, InstructionValue};
 
 /// An `ArrayValue` is a block of contiguous constants or variables.
 #[derive(PartialEq, Eq, Clone, Copy, Hash)]
@@ -65,21 +65,6 @@ impl ArrayValue {
         self.array_value.as_instruction()
     }
 
-    /// Determines whether or not this `ArrayValue` has any associated metadata.
-    pub fn has_metadata(&self) -> bool {
-        self.array_value.has_metadata()
-    }
-
-    /// Gets the `MetadataValue` associated with this `ArrayValue` at a specific
-    /// `kind_id`.
-    pub fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
-        self.array_value.get_metadata(kind_id)
-    }
-
-    /// Assigns a `MetadataValue` to this `ArrayValue` at a specific `kind_id`.
-    pub fn set_metadata(&self, metadata: MetadataValue, kind_id: u32) {
-        self.array_value.set_metadata(metadata, kind_id)
-    }
 
     /// Replaces all uses of this value with another value of the same type.
     /// If used incorrectly this may result in invalid IR.

src/values/float_value.rs

@@ -7,7 +7,7 @@ use crate::FloatPredicate;
 use crate::support::LLVMString;
 use crate::types::{AsTypeRef, FloatType, IntType};
 use crate::values::traits::AsValueRef;
-use crate::values::{InstructionValue, IntValue, Value, MetadataValue};
+use crate::values::{InstructionValue, IntValue, Value};
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct FloatValue {
@@ -143,18 +143,6 @@ impl FloatValue {
         FloatValue::new(value)
     }
 
-    pub fn has_metadata(&self) -> bool {
-        self.float_value.has_metadata()
-    }
-
-    pub fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
-        self.float_value.get_metadata(kind_id)
-    }
-
-    pub fn set_metadata(&self, metadata: MetadataValue, kind_id: u32) {
-        self.float_value.set_metadata(metadata, kind_id)
-    }
-
     // SubType: rhs same as lhs; return IntValue<bool>
     pub fn const_compare(&self, op: FloatPredicate, rhs: FloatValue) -> IntValue {
         let value = unsafe {

src/values/fn_value.rs

@@ -17,7 +17,7 @@ use crate::module::Linkage;
 use crate::support::LLVMString;
 use crate::types::{FunctionType, PointerType};
 use crate::values::traits::AsValueRef;
-use crate::values::{BasicValueEnum, GlobalValue, MetadataValue, Value};
+use crate::values::{BasicValueEnum, GlobalValue, Value};
 
 #[derive(PartialEq, Eq, Clone, Copy, Hash)]
 pub struct FunctionValue {
@@ -243,18 +243,6 @@ impl FunctionValue {
         ptr_type.get_element_type().into_function_type()
     }
 
-    pub fn has_metadata(&self) -> bool {
-        self.fn_value.has_metadata()
-    }
-
-    pub fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
-        self.fn_value.get_metadata(kind_id)
-    }
-
-    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
     #[llvm_versions(3.9..=latest)]
     pub fn has_personality_function(&self) -> bool {

src/values/instruction_value.rs

@@ -1,5 +1,5 @@
 use either::{Either, Either::{Left, Right}};
-use llvm_sys::core::{LLVMGetAlignment, LLVMSetAlignment, LLVMGetInstructionOpcode, LLVMIsTailCall, LLVMGetPreviousInstruction, LLVMGetNextInstruction, LLVMGetInstructionParent, LLVMInstructionEraseFromParent, LLVMInstructionClone, LLVMSetVolatile, LLVMGetVolatile, LLVMGetNumOperands, LLVMGetOperand, LLVMGetOperandUse, LLVMSetOperand, LLVMValueAsBasicBlock, LLVMIsABasicBlock, LLVMGetICmpPredicate, LLVMGetFCmpPredicate, LLVMIsAAllocaInst, LLVMIsALoadInst, LLVMIsAStoreInst};
+use llvm_sys::core::{LLVMGetAlignment, LLVMSetAlignment, LLVMGetInstructionOpcode, LLVMIsTailCall, LLVMGetPreviousInstruction, LLVMGetNextInstruction, LLVMGetInstructionParent, LLVMInstructionEraseFromParent, LLVMInstructionClone, LLVMSetVolatile, LLVMGetVolatile, LLVMGetNumOperands, LLVMGetOperand, LLVMGetOperandUse, LLVMSetOperand, LLVMValueAsBasicBlock, LLVMIsABasicBlock, LLVMGetICmpPredicate, LLVMGetFCmpPredicate, LLVMIsAAllocaInst, LLVMIsALoadInst, LLVMIsAStoreInst, LLVMGetMetadata, LLVMHasMetadata, LLVMSetMetadata};
 #[llvm_versions(3.8..=latest)]
 use llvm_sys::core::{LLVMGetOrdering, LLVMSetOrdering};
 #[llvm_versions(3.9..=latest)]
@@ -9,7 +9,7 @@ use llvm_sys::prelude::LLVMValueRef;
 
 use crate::basic_block::BasicBlock;
 use crate::values::traits::AsValueRef;
-use crate::values::{BasicValue, BasicValueEnum, BasicValueUse, Value};
+use crate::values::{BasicValue, BasicValueEnum, BasicValueUse, Value, MetadataValue};
 use crate::{AtomicOrdering, IntPredicate, FloatPredicate};
 
 // REVIEW: Split up into structs for SubTypes on InstructionValues?
@@ -586,6 +586,35 @@ impl InstructionValue {
             None
         }
     }
+
+    /// Determines whether or not this `Instruction` has any associated metadata.
+    pub fn has_metadata(&self) -> bool {
+        unsafe {
+            LLVMHasMetadata(self.instruction_value.value) == 1
+        }
+    }
+
+    /// Gets the `MetadataValue` associated with this `Instruction` at a specific
+    /// `kind_id`.
+    pub fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
+        let metadata_value = unsafe {
+            LLVMGetMetadata(self.instruction_value.value, kind_id)
+        };
+
+        if metadata_value.is_null() {
+            return None;
+        }
+
+        Some(MetadataValue::new(metadata_value))
+    }
+
+    /// Determines whether or not this `Instruction` has any associated metadata
+    /// `kind_id`.
+    pub fn set_metadata(&self, metadata: MetadataValue, kind_id: u32) {
+        unsafe {
+            LLVMSetMetadata(self.instruction_value.value, kind_id, metadata.as_value_ref())
+        }
+    }
 }
 
 impl Clone for InstructionValue {

src/values/int_value.rs

@@ -9,7 +9,7 @@ use crate::IntPredicate;
 use crate::support::LLVMString;
 use crate::types::{AsTypeRef, FloatType, PointerType, IntType};
 use crate::values::traits::AsValueRef;
-use crate::values::{BasicValue, BasicValueEnum, FloatValue, InstructionValue, PointerValue, Value, MetadataValue};
+use crate::values::{BasicValue, BasicValueEnum, FloatValue, InstructionValue, PointerValue, Value};
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct IntValue {
@@ -355,18 +355,6 @@ impl IntValue {
         IntValue::new(value)
     }
 
-    pub fn has_metadata(&self) -> bool {
-        self.int_value.has_metadata()
-    }
-
-    pub fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
-        self.int_value.get_metadata(kind_id)
-    }
-
-    pub fn set_metadata(&self, metadata: MetadataValue, kind_id: u32) {
-        self.int_value.set_metadata(metadata, kind_id)
-    }
-
     // SubType: rhs same as lhs; return IntValue<bool>
     pub fn const_int_compare(&self, op: IntPredicate, rhs: IntValue) -> IntValue {
         let value = unsafe {

src/values/mod.rs

@@ -40,7 +40,7 @@ pub use crate::values::traits::{AnyValue, AggregateValue, BasicValue, IntMathVal
 pub use crate::values::vec_value::VectorValue;
 pub(crate) use crate::values::traits::AsValueRef;
 
-use llvm_sys::core::{LLVMIsConstant, LLVMIsNull, LLVMIsUndef, LLVMPrintTypeToString, LLVMPrintValueToString, LLVMTypeOf, LLVMDumpValue, LLVMIsAInstruction, LLVMGetMetadata, LLVMHasMetadata, LLVMSetMetadata, LLVMReplaceAllUsesWith, LLVMGetFirstUse};
+use llvm_sys::core::{LLVMIsConstant, LLVMIsNull, LLVMIsUndef, LLVMPrintTypeToString, LLVMPrintValueToString, LLVMTypeOf, LLVMDumpValue, LLVMIsAInstruction, LLVMReplaceAllUsesWith, LLVMGetFirstUse};
 use llvm_sys::prelude::{LLVMValueRef, LLVMTypeRef};
 
 use std::ffi::CStr;
@@ -167,32 +167,6 @@ impl Value {
         }
     }
 
-    fn has_metadata(&self) -> bool {
-        unsafe {
-            LLVMHasMetadata(self.value) == 1
-        }
-    }
-
-    // SubTypes: -> Option<MetadataValue<Node>>
-    // TODOC: This always returns a metadata node, which can be used to get its node values
-    fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
-        let metadata_value = unsafe {
-            LLVMGetMetadata(self.value, kind_id)
-        };
-
-        if metadata_value.is_null() {
-            return None;
-        }
-
-        Some(MetadataValue::new(metadata_value))
-    }
-
-    fn set_metadata(&self, metadata: MetadataValue, kind_id: u32) {
-        unsafe {
-            LLVMSetMetadata(self.value, kind_id, metadata.as_value_ref())
-        }
-    }
-
     // REVIEW: I think this is memory safe, though it may result in an IR error
     // if used incorrectly, which is OK.
     fn replace_all_uses_with(&self, other: LLVMValueRef) {

src/values/ptr_value.rs

@@ -5,7 +5,7 @@ use std::ffi::CStr;
 
 use crate::support::LLVMString;
 use crate::types::{AsTypeRef, IntType, PointerType};
-use crate::values::{AsValueRef, InstructionValue, IntValue, Value, MetadataValue};
+use crate::values::{AsValueRef, InstructionValue, IntValue, Value};
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct PointerValue {
@@ -68,18 +68,6 @@ impl PointerValue {
         self.ptr_value.as_instruction()
     }
 
-    pub fn has_metadata(&self) -> bool {
-        self.ptr_value.has_metadata()
-    }
-
-    pub fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
-        self.ptr_value.get_metadata(kind_id)
-    }
-
-    pub fn set_metadata(&self, metadata: MetadataValue, kind_id: u32) {
-        self.ptr_value.set_metadata(metadata, kind_id)
-    }
-
     // REVIEW: Should this be on array value too?
     /// GEP is very likely to segfault if indexes are used incorrectly, and is therefore an unsafe function. Maybe we can change this in the future.
     pub unsafe fn const_gep(&self, ordered_indexes: &[IntValue]) -> PointerValue {

src/values/struct_value.rs

@@ -5,7 +5,7 @@ use std::ffi::CStr;
 use crate::support::LLVMString;
 use crate::types::StructType;
 use crate::values::traits::AsValueRef;
-use crate::values::{InstructionValue, Value, MetadataValue};
+use crate::values::{InstructionValue, Value};
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct StructValue {
@@ -53,18 +53,6 @@ impl StructValue {
         self.struct_value.as_instruction()
     }
 
-    pub fn has_metadata(&self) -> bool {
-        self.struct_value.has_metadata()
-    }
-
-    pub fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
-        self.struct_value.get_metadata(kind_id)
-    }
-
-    pub fn set_metadata(&self, metadata: MetadataValue, kind_id: u32) {
-        self.struct_value.set_metadata(metadata, kind_id)
-    }
-
     pub fn replace_all_uses_with(&self, other: StructValue) {
         self.struct_value.replace_all_uses_with(other.as_value_ref())
     }

src/values/vec_value.rs

@@ -6,7 +6,7 @@ use std::ffi::CStr;
 use crate::support::LLVMString;
 use crate::types::{VectorType};
 use crate::values::traits::AsValueRef;
-use crate::values::{BasicValueEnum, BasicValue, InstructionValue, Value, IntValue, MetadataValue};
+use crate::values::{BasicValueEnum, BasicValue, InstructionValue, Value, IntValue};
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct VectorValue {
@@ -101,18 +101,6 @@ impl VectorValue {
         BasicValueEnum::new(value)
     }
 
-    pub fn has_metadata(&self) -> bool {
-        self.vec_value.has_metadata()
-    }
-
-    pub fn get_metadata(&self, kind_id: u32) -> Option<MetadataValue> {
-        self.vec_value.get_metadata(kind_id)
-    }
-
-    pub fn set_metadata(&self, metadata: MetadataValue, kind_id: u32) {
-        self.vec_value.set_metadata(metadata, kind_id)
-    }
-
     pub fn replace_all_uses_with(&self, other: VectorValue) {
         self.vec_value.replace_all_uses_with(other.as_value_ref())
     }