volatile flag for store/load

Author: ARF1

docs/source/user-guide/ir/ir-builder.rst

@@ -459,26 +459,44 @@ Memory
      *typ*. If *size* is not given, a stack slot for 1 value is
      allocated.
 
-* .. method:: IRBuilder.load(ptr, name='', align=None)
+* .. method:: IRBuilder.load(ptr, name='', align=None, atomic_ordering=None, volatile=False)
 
      Load value from pointer *ptr*. If *align* is passed, it should
      be a Python integer specifying the guaranteed pointer
      alignment.
+     
+     If *volatile* is truthy, the load is marked as volatile.
 
-* .. method:: IRBuilder.store(value, ptr, align=None)
+     If *atomic_ordering* and *align* are specified, the load is marked as 
+     atomic.
+
+* .. method:: IRBuilder.store(value, ptr, align=None, atomic_ordering=None, volatile=False)
 
      Store *value* to pointer *ptr*. If *align* is passed, it should
      be a Python integer specifying the guaranteed pointer
      alignment.
+     
+     If *volatile* is truthy, the load is marked as volatile.
+
+     If *atomic_ordering* and *align* are specified, the load is marked as 
+     atomic.
 
 * .. method:: IRBuilder.load_atomic(ptr, ordering, align, name='')
 
+     .. deprecated:: 0.33.0
+
+        Use :func:`IRBuilder.load` with parameter `atomic_ordering` instead.
+
      Load value from pointer *ptr* as an atomic operation with the given
      *ordering*. *align* must be a Python integer specifying the guaranteed
      pointer alignment.
 
 * .. method:: IRBuilder.store_atomic(value, ptr, ordering, align)
 
+     .. deprecated:: 0.33.0
+
+        Use :func:`IRBuilder.store` with parameter `atomic_ordering` instead.
+
      Store *value* to pointer *ptr* as an atomic operation with the given
      *ordering*. *align* must be a Python integer specifying the guaranteed
      pointer alignment.

llvmlite/ir/builder.py

@@ -724,19 +724,22 @@ def alloca(self, typ, size=None, name=''):
         self._insert(al)
         return al
 
-    def load(self, ptr, name='', align=None, atomic_ordering=None):
+    def load(self, ptr, name='', align=None, atomic_ordering=None,
+             volatile=False):
         """
         Load value from pointer, with optional guaranteed alignment:
             name = *ptr
         """
         if not isinstance(ptr.type, types.PointerType):
             msg = "cannot load from value of type %s (%r): not a pointer"
             raise TypeError(msg % (ptr.type, str(ptr)))
-        ld = instructions.LoadInstr(self.block, ptr, name, align, atomic_ordering)
+        ld = instructions.LoadInstr(self.block, ptr, name, align,
+                                    atomic_ordering, volatile)
         self._insert(ld)
         return ld
 
-    def store(self, value, ptr, align=None, atomic_ordering=None):
+    def store(self, value, ptr, align=None, atomic_ordering=None,
+              volatile=False):
         """
         Store value to pointer, with optional guaranteed alignment:
             *ptr = name
@@ -747,7 +750,8 @@ def store(self, value, ptr, align=None, atomic_ordering=None):
         if ptr.type.pointee != value.type:
             raise TypeError("cannot store %s to %s: mismatching types"
                             % (value.type, ptr.type))
-        st = instructions.StoreInstr(self.block, value, ptr, align, atomic_ordering)
+        st = instructions.StoreInstr(self.block, value, ptr, align,
+                                     atomic_ordering, volatile)
         self._insert(st)
         return st
 

llvmlite/ir/instructions.py

@@ -390,75 +390,65 @@ def descr(self, buf):
 
 
 class LoadInstr(Instruction):
-    def __init__(self, parent, ptr, name='', align=None, atomic_ordering=None):
+    def __init__(self, parent, ptr, name='', align=None, atomic_ordering=None,
+                 volatile=False):
         if atomic_ordering is not None and align is None:
             msg = "atomic load requires the align paramter to be specified"
             raise ValueError(msg)
         super(LoadInstr, self).__init__(parent, ptr.type.pointee, "load",
                                         [ptr], name=name)
         self.align = align
         self.atomic_ordering = atomic_ordering
+        self.volatile = volatile
 
     def descr(self, buf):
         [val] = self.operands
-        if self.atomic_ordering is None:
-            if self.align is not None:
-                align = ', align %d' % (self.align)
-            else:
-                align = ''
-            buf.append("load {0}, {1} {2}{3}{4}\n".format(
-                val.type.pointee,
-                val.type,
-                val.get_reference(),
-                align,
-                self._stringify_metadata(leading_comma=True),
-            ))
-        else:
-            buf.append("load atomic {0}, {1} {2} {3}, align {4}{5}\n".format(
-                val.type.pointee,
-                val.type,
-                val.get_reference(),
-                self.atomic_ordering,
-                self.align,
-                self._stringify_metadata(leading_comma=True),
-            ))
+
+        flags = []
+        if self.atomic_ordering is not None:
+            flags.append('atomic')
+        if self.volatile:
+            flags.append('volatile')
+
+        opname = ' '.join(['load'] + flags)
+        ordering = ('' if self.atomic_ordering is None
+                    else f' {self.atomic_ordering}')
+        align = '' if self.align is None else f', align {self.align}'
+        metadata = self._stringify_metadata(leading_comma=True)
+
+        buf.append(f"{opname} {val.type.pointee}, {val.type} "
+                   f"{val.get_reference()}{ordering}{align}{metadata}\n")
 
 
 class StoreInstr(Instruction):
-    def __init__(self, parent, val, ptr, align=None, atomic_ordering=None):
+    def __init__(self, parent, val, ptr, align=None, atomic_ordering=None,
+                 volatile=False):
         if atomic_ordering is not None and align is None:
             msg = "atomic store requires the align paramter to be specified"
             raise ValueError(msg)
         super(StoreInstr, self).__init__(parent, types.VoidType(), "store",
                                          [val, ptr])
         self.align = align
         self.atomic_ordering = atomic_ordering
+        self.volatile = volatile
 
     def descr(self, buf):
         val, ptr = self.operands
-        if self.atomic_ordering is None:
-            if self.align is not None:
-                align = ', align %d' % (self.align)
-            else:
-                align = ''
-            buf.append("store {0} {1}, {2} {3}{4}{5}\n".format(
-                val.type,
-                val.get_reference(),
-                ptr.type,
-                ptr.get_reference(),
-                align,
-                self._stringify_metadata(leading_comma=True),
-            ))
-        else:
-            buf.append("store atomic {0} {1}, {2} {3} {4}, align {5}{6}\n".format(
-                val.type,
-                val.get_reference(),
-                ptr.type,
-                ptr.get_reference(),
-                self.atomic_ordering,
-                self.align,
-                self._stringify_metadata(leading_comma=True),
-            ))
+
+        flags = []
+        if self.atomic_ordering is not None:
+            flags.append('atomic')
+        if self.volatile:
+            flags.append('volatile')
+
+        opname = ' '.join(['store'] + flags)
+        ordering = ('' if self.atomic_ordering is None
+                    else f' {self.atomic_ordering}')
+        align = '' if self.align is None else f', align {self.align}'
+        metadata = self._stringify_metadata(leading_comma=True)
+
+        buf.append(f"{opname} {val.type} {val.get_reference()}, {ptr.type} "
+                   f"{ptr.get_reference()}{ordering}{align}{metadata}\n")
 
 
 class LoadAtomicInstr(LoadInstr):

llvmlite/tests/test_ir.py

@@ -805,11 +805,23 @@ def test_mem_ops(self):
         self.assertEqual(h.type, ir.VoidType())
         i = builder.load(c, 'i', align=1)
         self.assertEqual(i.type, int32)
-        # Atomics
-        j = builder.store_atomic(b, c, ordering="seq_cst", align=4)
+        # Volatile
+        j = builder.store(b, c, align=1, volatile=True)
         self.assertEqual(j.type, ir.VoidType())
-        k = builder.load_atomic(c, ordering="seq_cst", align=4, name='k')
+        k = builder.load(c, 'k', align=1, volatile=True)
         self.assertEqual(k.type, int32)
+        # Atomics
+        l = builder.store(b, c, atomic_ordering="seq_cst", align=4)
+        self.assertEqual(l.type, ir.VoidType())
+        m = builder.load(c, atomic_ordering="seq_cst", align=4, name='m')
+        self.assertEqual(m.type, int32)
+        # Atomics Volatile
+        o = builder.store(b, c, atomic_ordering="seq_cst",
+                          align=4, volatile=True)
+        self.assertEqual(o.type, ir.VoidType())
+        p = builder.load(c, atomic_ordering="seq_cst",
+                         align=4, name='p', volatile=True)
+        self.assertEqual(p.type, int32)
         # Not pointer types
         with self.assertRaises(TypeError):
             builder.store(b, a)
@@ -830,8 +842,12 @@ def test_mem_ops(self):
                 %"g" = load i32, i32* %"c"
                 store i32 %".2", i32* %"c", align 1
                 %"i" = load i32, i32* %"c", align 1
+                store volatile i32 %".2", i32* %"c", align 1
+                %"k" = load volatile i32, i32* %"c", align 1
                 store atomic i32 %".2", i32* %"c" seq_cst, align 4
-                %"k" = load atomic i32, i32* %"c" seq_cst, align 4
+                %"m" = load atomic i32, i32* %"c" seq_cst, align 4
+                store atomic volatile i32 %".2", i32* %"c" seq_cst, align 4
+                %"p" = load atomic volatile i32, i32* %"c" seq_cst, align 4
             """)
 
     def test_gep(self):