Merge pull request rust-lang#261 from tarberd/feature_type_attributes

Add type attribute api.

Author: TheDan64

Cargo.toml

@@ -101,7 +101,7 @@ llvm-sys-80 = { package = "llvm-sys", version = "80.3", optional = true }
 llvm-sys-90 = { package = "llvm-sys", version = "90.2", optional = true }
 llvm-sys-100 = { package = "llvm-sys", version = "100.2", optional = true }
 llvm-sys-110 = { package = "llvm-sys", version = "110.0", optional = true }
-llvm-sys-120 = { package = "llvm-sys", version = "120.0", optional = true }
+llvm-sys-120 = { package = "llvm-sys", version = "120.2", optional = true }
 once_cell = "1.4.1"
 parking_lot = "0.11"
 regex = "1"

src/attributes.rs

@@ -4,10 +4,14 @@
 use llvm_sys::prelude::LLVMAttributeRef;
 #[llvm_versions(3.9..=latest)]
 use llvm_sys::core::{LLVMGetEnumAttributeKindForName, LLVMGetLastEnumAttributeKind, LLVMGetEnumAttributeKind, LLVMGetEnumAttributeValue, LLVMGetStringAttributeKind, LLVMGetStringAttributeValue, LLVMIsEnumAttribute, LLVMIsStringAttribute};
+#[llvm_versions(12.0..=latest)]
+use llvm_sys::core::{LLVMGetTypeAttributeValue, LLVMIsTypeAttribute};
 
 #[llvm_versions(3.9..=latest)]
 use std::ffi::CStr;
 
+use crate::types::AnyTypeEnum;
+
 // SubTypes: Attribute<Enum>, Attribute<String>
 /// Functions, function parameters, and return types can have `Attribute`s to indicate
 /// how they should be treated by optimizations and code generation.
@@ -67,6 +71,30 @@ impl Attribute {
         }
     }
 
+    /// Determines whether or not an `Attribute` is a type attribute. This method will
+    /// likely be removed in the future in favor of `Attribute`s being generically
+    /// defined.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use inkwell::context::Context;
+    /// use inkwell::attributes::Attribute;
+    ///
+    /// let context = Context::create();
+    /// let kind_id = Attribute::get_named_enum_kind_id("sret");
+    /// let type_attribute = context.create_type_attribute(
+    ///     kind_id,
+    ///     context.i32_type().into(),
+    /// );
+    ///
+    /// assert!(type_attribute.is_type());
+    /// ```
+    #[llvm_versions(12.0..=latest)]
+    pub fn is_type(self) -> bool {
+        unsafe { LLVMIsTypeAttribute(self.attribute) == 1 }
+    }
+
     /// Gets the enum kind id associated with a builtin name.
     ///
     /// # Example
@@ -191,6 +219,34 @@ impl Attribute {
             CStr::from_ptr(cstr_ptr)
         }
     }
+
+    /// Gets the type associated with a type attribute.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use inkwell::context::Context;
+    /// use inkwell::attributes::Attribute;
+    /// use inkwell::types::AnyType;
+    ///
+    /// let context = Context::create();
+    /// let kind_id = Attribute::get_named_enum_kind_id("sret");
+    /// let any_type = context.i32_type().as_any_type_enum();
+    /// let type_attribute = context.create_type_attribute(
+    ///     kind_id,
+    ///     any_type,
+    /// );
+    ///
+    /// assert!(type_attribute.is_type());
+    /// assert_eq!(type_attribute.get_type_value(), any_type);
+    /// assert_ne!(type_attribute.get_type_value(), context.i64_type().as_any_type_enum());
+    /// ```
+    #[llvm_versions(12.0..=latest)]
+    pub fn get_type_value(&self) -> AnyTypeEnum {
+        assert!(self.is_type()); // FIXME: SubTypes
+
+        unsafe { AnyTypeEnum::new(LLVMGetTypeAttributeValue(self.attribute)) }
+    }
 }
 
 /// An `AttributeLoc` determines where on a function an attribute is assigned to.

src/context.rs

@@ -7,6 +7,8 @@ use llvm_sys::core::{LLVMCreateEnumAttribute, LLVMCreateStringAttribute};
 use llvm_sys::core::{LLVMConstInlineAsm};
 #[llvm_versions(7.0..=latest)]
 use llvm_sys::core::{LLVMGetInlineAsm};
+#[llvm_versions(12.0..=latest)]
+use llvm_sys::core::{LLVMCreateTypeAttribute};
 #[llvm_versions(7.0..=latest)]
 use crate::InlineAsmDialect;
 use llvm_sys::prelude::{LLVMContextRef, LLVMTypeRef, LLVMValueRef, LLVMDiagnosticInfoRef};
@@ -25,7 +27,7 @@ use crate::memory_buffer::MemoryBuffer;
 use crate::module::Module;
 use crate::support::{to_c_str, LLVMString};
 use crate::targets::TargetData;
-use crate::types::{BasicTypeEnum, FloatType, IntType, StructType, VoidType, AsTypeRef, FunctionType};
+use crate::types::{AnyTypeEnum, BasicTypeEnum, FloatType, IntType, StructType, VoidType, AsTypeRef, FunctionType};
 use crate::values::{AsValueRef, BasicMetadataValueEnum, BasicValueEnum, FunctionValue, StructValue, MetadataValue, VectorValue, PointerValue};
 
 use std::marker::PhantomData;
@@ -905,6 +907,37 @@ impl Context {
         }
     }
 
+    /// Create an enum `Attribute` with an `AnyTypeEnum` attached to it.
+    ///
+    /// # Example
+    /// ```rust
+    /// use inkwell::context::Context;
+    /// use inkwell::attributes::Attribute;
+    /// use inkwell::types::AnyType;
+    ///
+    /// let context = Context::create();
+    /// let kind_id = Attribute::get_named_enum_kind_id("sret");
+    /// let any_type = context.i32_type().as_any_type_enum();
+    /// let type_attribute = context.create_type_attribute(
+    ///     kind_id,
+    ///     any_type,
+    /// );
+    ///
+    /// assert!(type_attribute.is_type());
+    /// assert_eq!(type_attribute.get_type_value(), any_type);
+    /// assert_ne!(type_attribute.get_type_value(), context.i64_type().as_any_type_enum());
+    /// ```
+    #[llvm_versions(12.0..=latest)]
+    pub fn create_type_attribute(&self, kind_id: u32, type_ref: AnyTypeEnum) -> Attribute {
+        unsafe {
+            Attribute::new(LLVMCreateTypeAttribute(
+                self.context,
+                kind_id,
+                type_ref.as_type_ref(),
+            ))
+        }
+    }
+
     /// Creates a const string which may be null terminated.
     ///
     /// # Example

tests/all/test_attributes.rs

@@ -40,6 +40,44 @@ fn test_string_attributes() {
     assert_eq!(string_attribute.get_string_value().to_str(), Ok("my_val"));
 }
 
+#[llvm_versions(12.0..=latest)]
+#[test]
+fn test_type_attribute() {
+    use inkwell::types::{AnyType, BasicType};
+    use inkwell::AddressSpace;
+
+    let context = Context::create();
+    let kind_id = Attribute::get_named_enum_kind_id("sret");
+
+    let any_types = [
+        context.i32_type().as_any_type_enum(),
+        context.f32_type().as_any_type_enum(),
+        context.void_type().as_any_type_enum(),
+        context.i32_type().vec_type(1).as_any_type_enum(),
+        context.i32_type().array_type(1).as_any_type_enum(),
+        context.i32_type().fn_type(&[], false).as_any_type_enum(),
+        context
+            .i32_type()
+            .ptr_type(AddressSpace::Local)
+            .as_any_type_enum(),
+        context
+            .struct_type(&[context.i32_type().as_basic_type_enum()], false)
+            .as_any_type_enum(),
+    ];
+
+    let different_type = context.i128_type().as_any_type_enum();
+    assert!(!any_types.contains(&different_type));
+
+    for any_type in &any_types {
+        let type_attribute = context.create_type_attribute(kind_id, *any_type);
+        assert!(type_attribute.is_type());
+        assert!(!type_attribute.is_enum());
+        assert!(!type_attribute.is_string());
+        assert_eq!(type_attribute.get_type_value(), *any_type);
+        assert_ne!(type_attribute.get_type_value(), different_type);
+    }
+}
+
 #[test]
 fn test_attributes_on_function_values() {
     let context = Context::create();