Make set/get_volatile check the type of value.

Author: nlewycky

Diff for: src/values/instruction_value.rs

@@ -184,17 +184,31 @@ impl InstructionValue {
 
     // SubTypes: Only apply to memory access instructions
     /// Returns whether or not a memory access instruction is volatile.
-    pub fn get_volatile(&self) -> bool {
+    pub fn get_volatile(&self) -> Result<bool, &'static str> {
+        let value_ref = self.as_value_ref();
         unsafe {
-            LLVMGetVolatile(self.as_value_ref()) == 1
+            // Although cmpxchg and atomicrmw can have volatile, LLVM's C API
+            // does not export that functionality.
+            if LLVMIsALoadInst(value_ref).is_null() &&
+                LLVMIsAStoreInst(value_ref).is_null() {
+                return Err("Value is not a load or store.");
+            }
+            Ok(LLVMGetVolatile(value_ref) == 1)
         }
     }
 
     // SubTypes: Only apply to memory access instructions
     /// Sets whether or not a memory access instruction is volatile.
-    pub fn set_volatile(&self, volatile: bool) {
+    pub fn set_volatile(&self, volatile: bool) -> Result<(), &'static str> {
+        let value_ref = self.as_value_ref();
         unsafe {
-            LLVMSetVolatile(self.as_value_ref(), volatile as i32)
+            // Although cmpxchg and atomicrmw can have volatile, LLVM's C API
+            // does not export that functionality.
+            if LLVMIsALoadInst(value_ref).is_null() &&
+                LLVMIsAStoreInst(value_ref).is_null() {
+                return Err("Value is not a load or store.");
+            }
+            Ok(LLVMSetVolatile(value_ref, volatile as i32))
         }
     }
 

Diff for: tests/all/test_instruction_values.rs

@@ -279,16 +279,16 @@ fn test_mem_instructions() {
     let load = builder.build_load(arg1, "");
     let load_instruction = load.as_instruction_value().unwrap();
 
-    assert_eq!(store_instruction.get_volatile(), false);
-    assert_eq!(load_instruction.get_volatile(), false);
-    store_instruction.set_volatile(true);
-    load_instruction.set_volatile(true);
-    assert_eq!(store_instruction.get_volatile(), true);
-    assert_eq!(load_instruction.get_volatile(), true);
-    store_instruction.set_volatile(false);
-    load_instruction.set_volatile(false);
-    assert_eq!(store_instruction.get_volatile(), false);
-    assert_eq!(load_instruction.get_volatile(), false);
+    assert_eq!(store_instruction.get_volatile().unwrap(), false);
+    assert_eq!(load_instruction.get_volatile().unwrap(), false);
+    store_instruction.set_volatile(true).unwrap();
+    load_instruction.set_volatile(true).unwrap();
+    assert_eq!(store_instruction.get_volatile().unwrap(), true);
+    assert_eq!(load_instruction.get_volatile().unwrap(), true);
+    store_instruction.set_volatile(false).unwrap();
+    load_instruction.set_volatile(false).unwrap();
+    assert_eq!(store_instruction.get_volatile().unwrap(), false);
+    assert_eq!(load_instruction.get_volatile().unwrap(), false);
 
     assert_eq!(store_instruction.get_alignment().unwrap(), 0);
     assert_eq!(load_instruction.get_alignment().unwrap(), 0);
@@ -305,6 +305,8 @@ fn test_mem_instructions() {
     assert_eq!(store_instruction.get_alignment().unwrap(), 0);
 
     let fadd_instruction = builder.build_float_add(load.into_float_value(), f32_val, "").as_instruction_value().unwrap();
+    assert!(fadd_instruction.get_volatile().is_err());
+    assert!(fadd_instruction.set_volatile(false).is_err());
     assert!(fadd_instruction.get_alignment().is_err());
     assert!(fadd_instruction.set_alignment(16).is_err());
 }