Merge pull request rust-lang#190 from wasmerio/volatile-atomics

Get/set of volatile on atomicrmw and cmpxchg was added in LLVM 10.

Author: TheDan64

src/values/instruction_value.rs

@@ -4,6 +4,8 @@ use llvm_sys::core::{LLVMGetAlignment, LLVMSetAlignment, LLVMGetInstructionOpcod
 use llvm_sys::core::{LLVMGetOrdering, LLVMSetOrdering};
 #[llvm_versions(3.9..=latest)]
 use llvm_sys::core::LLVMInstructionRemoveFromParent;
+#[llvm_versions(10.0..=latest)]
+use llvm_sys::core::{LLVMIsAAtomicRMWInst, LLVMIsAAtomicCmpXchgInst};
 use llvm_sys::LLVMOpcode;
 use llvm_sys::prelude::LLVMValueRef;
 
@@ -113,6 +115,14 @@ impl<'ctx> InstructionValue<'ctx> {
     fn is_a_alloca_inst(self) -> bool {
         !unsafe { LLVMIsAAllocaInst(self.as_value_ref()) }.is_null()
     }
+    #[llvm_versions(10.0..=latest)]
+    fn is_a_atomicrmw_inst(self) -> bool {
+        !unsafe { LLVMIsAAtomicRMWInst(self.as_value_ref()) }.is_null()
+    }
+    #[llvm_versions(10.0..=latest)]
+    fn is_a_cmpxchg_inst(self) -> bool {
+        !unsafe { LLVMIsAAtomicCmpXchgInst(self.as_value_ref()) }.is_null()
+    }
 
     pub(crate) fn new(instruction_value: LLVMValueRef) -> Self {
         debug_assert!(!instruction_value.is_null());
@@ -203,25 +213,49 @@ impl<'ctx> InstructionValue<'ctx> {
 
     // SubTypes: Only apply to memory access instructions
     /// Returns whether or not a memory access instruction is volatile.
+    #[llvm_versions(3.6..=9.0)]
     pub fn get_volatile(self) -> Result<bool, &'static str> {
         // Although cmpxchg and atomicrmw can have volatile, LLVM's C API
-        // does not export that functionality.
+        // does not export that functionality until 10.0.
         if !self.is_a_load_inst() && !self.is_a_store_inst() {
             return Err("Value is not a load or store.");
         }
         Ok(unsafe { LLVMGetVolatile(self.as_value_ref()) } == 1)
     }
 
+    // SubTypes: Only apply to memory access instructions
+    /// Returns whether or not a memory access instruction is volatile.
+    #[llvm_versions(10.0..=latest)]
+    pub fn get_volatile(self) -> Result<bool, &'static str> {
+        if !self.is_a_load_inst() && !self.is_a_store_inst() &&
+           !self.is_a_atomicrmw_inst() && !self.is_a_cmpxchg_inst() {
+            return Err("Value is not a load, store, atomicrmw or cmpxchg.");
+        }
+        Ok(unsafe { LLVMGetVolatile(self.as_value_ref()) } == 1)
+    }
+
     // SubTypes: Only apply to memory access instructions
     /// Sets whether or not a memory access instruction is volatile.
+    #[llvm_versions(3.6..=9.0)]
     pub fn set_volatile(self, volatile: bool) -> Result<(), &'static str> {
         // Although cmpxchg and atomicrmw can have volatile, LLVM's C API
-        // does not export that functionality.
+        // does not export that functionality until 10.0.
         if !self.is_a_load_inst() && !self.is_a_store_inst() {
             return Err("Value is not a load or store.");
         }
         Ok(unsafe { LLVMSetVolatile(self.as_value_ref(), volatile as i32) })
     }
+    
+    // SubTypes: Only apply to memory access instructions
+    /// Sets whether or not a memory access instruction is volatile.
+    #[llvm_versions(10.0..=latest)]
+    pub fn set_volatile(self, volatile: bool) -> Result<(), &'static str> {
+        if !self.is_a_load_inst() && !self.is_a_store_inst() &&
+           !self.is_a_atomicrmw_inst() && !self.is_a_cmpxchg_inst() {
+            return Err("Value is not a load, store, atomicrmw or cmpxchg.");
+        }
+        Ok(unsafe { LLVMSetVolatile(self.as_value_ref(), volatile as i32) })
+    }
 
     // SubTypes: Only apply to memory access and alloca instructions
     /// Returns alignment on a memory access instruction or alloca.

tests/all/test_instruction_values.rs

@@ -1,6 +1,6 @@
-use inkwell::{AddressSpace, AtomicOrdering, IntPredicate, FloatPredicate};
 use inkwell::context::Context;
 use inkwell::values::{BasicValue, InstructionOpcode::*};
+use inkwell::{AddressSpace, AtomicOrdering, AtomicRMWBinOp, FloatPredicate, IntPredicate};
 
 #[test]
 fn test_operands() {
@@ -249,6 +249,60 @@ fn test_instructions() {
     assert_eq!(instruction_clone, instruction_clone_copy);
 }
 
+#[llvm_versions(10.0..=latest)]
+#[test]
+fn test_volatile_atomicrmw_cmpxchg() {
+    let context = Context::create();
+    let module = context.create_module("testing");
+    let builder = context.create_builder();
+
+    let void_type = context.void_type();
+    let i32_type = context.i32_type();
+    let i32_ptr_type = i32_type.ptr_type(AddressSpace::Generic);
+    let fn_type = void_type.fn_type(&[i32_ptr_type.into(), i32_type.into()], false);
+
+    let function = module.add_function("mem_inst", fn_type, None);
+    let basic_block = context.append_basic_block(function, "entry");
+
+    builder.position_at_end(basic_block);
+
+    let arg1 = function.get_first_param().unwrap().into_pointer_value();
+    let arg2 = function.get_nth_param(1).unwrap().into_int_value();
+
+    assert!(arg1.get_first_use().is_none());
+    assert!(arg2.get_first_use().is_none());
+
+    let i32_val = i32_type.const_int(7, false);
+
+    let atomicrmw = builder
+        .build_atomicrmw(AtomicRMWBinOp::Add, arg1, arg2, AtomicOrdering::Unordered)
+        .unwrap()
+        .as_instruction_value()
+        .unwrap();
+    let cmpxchg = builder
+        .build_cmpxchg(
+            arg1,
+            arg2,
+            i32_val,
+            AtomicOrdering::Monotonic,
+            AtomicOrdering::Monotonic,
+        )
+        .unwrap()
+        .as_instruction_value()
+        .unwrap();
+
+    assert_eq!(atomicrmw.get_volatile().unwrap(), false);
+    assert_eq!(cmpxchg.get_volatile().unwrap(), false);
+    atomicrmw.set_volatile(true).unwrap();
+    cmpxchg.set_volatile(true).unwrap();
+    assert_eq!(atomicrmw.get_volatile().unwrap(), true);
+    assert_eq!(cmpxchg.get_volatile().unwrap(), true);
+    atomicrmw.set_volatile(false).unwrap();
+    cmpxchg.set_volatile(false).unwrap();
+    assert_eq!(atomicrmw.get_volatile().unwrap(), false);
+    assert_eq!(cmpxchg.get_volatile().unwrap(), false);
+}
+
 #[test]
 fn test_mem_instructions() {
     let context = Context::create();