numba-cuda 0.12.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

numba_cuda/numba/cuda/simulator/bf16.py

@@ -0,0 +1 @@
+bfloat16 = None

numba_cuda/numba/cuda/simulator/compiler.py

@@ -7,3 +7,4 @@ compile = None
 compile_for_current_device = None
 compile_ptx = None
 compile_ptx_for_current_device = None
+declare_device_function = None

numba_cuda/numba/cuda/simulator/cudadrv/driver.py

@@ -3,6 +3,8 @@ Most of the driver API is unsupported in the simulator, but some stubs are
 provided to allow tests to import correctly.
 """
 
+from numba import config
+
 
 def device_memset(dst, val, size, stream=0):
     dst.view("u1")[:size].fill(bytes([val])[0])
@@ -60,3 +62,8 @@ def launch_kernel(*args, **kwargs):
 
 
 USE_NV_BINDING = False
+
+PyNvJitLinker = None
+
+if config.ENABLE_CUDASIM:
+    config.CUDA_ENABLE_PYNVJITLINK = False

numba_cuda/numba/cuda/simulator/cudadrv/libs.py

@@ -1,2 +1,6 @@
 def check_static_lib(lib):
     raise FileNotFoundError("Linking libraries not supported by cudasim")
+
+
+def get_cuda_include_dir():
+    raise FileNotFoundError("CUDA includes not supported by cudasim")

numba_cuda/numba/cuda/simulator/cudadrv/linkable_code.py

@@ -0,0 +1,57 @@
+class LinkableCode:
+    """An object that holds code to be linked from memory.
+
+    :param data: A buffer containing the data to link.
+    :param name: The name of the file to be referenced in any compilation or
+                 linking errors that may be produced.
+    """
+
+    def __init__(self, data, name=None):
+        self.data = data
+        self._name = name
+
+    @property
+    def name(self):
+        return self._name or self.default_name
+
+
+class PTXSource(LinkableCode):
+    """PTX source code in memory."""
+
+    default_name = "<unnamed-ptx>"
+
+
+class CUSource(LinkableCode):
+    """CUDA C/C++ source code in memory."""
+
+    default_name = "<unnamed-cu>"
+
+
+class Fatbin(LinkableCode):
+    """An ELF Fatbin in memory."""
+
+    default_name = "<unnamed-fatbin>"
+
+
+class Cubin(LinkableCode):
+    """An ELF Cubin in memory."""
+
+    default_name = "<unnamed-cubin>"
+
+
+class Archive(LinkableCode):
+    """An archive of objects in memory."""
+
+    default_name = "<unnamed-archive>"
+
+
+class Object(LinkableCode):
+    """An object file in memory."""
+
+    default_name = "<unnamed-object>"
+
+
+class LTOIR(LinkableCode):
+    """An LTOIR file in memory."""
+
+    default_name = "<unnamed-ltoir>"

numba_cuda/numba/cuda/simulator/cudadrv/nvrtc.py

@@ -0,0 +1,8 @@
+"""
+NVVM is not supported in the simulator, but stubs are provided to allow tests
+to import correctly.
+"""
+
+
+def compile(src, name, cc, ltoir=False):
+    raise RuntimeError("NVRTC is not supported in the simulator")

numba_cuda/numba/cuda/simulator/kernel.py

@@ -78,7 +78,7 @@ class FakeCUDAKernel(object):
         functools.update_wrapper(self, fn)
 
     def __call__(self, *args):
-        if self._device:
+        if self._device or _kernel_context:
             with swapped_cuda_module(self.fn, _get_kernel_context()):
                 return self.fn(*args)
 

numba_cuda/numba/cuda/simulator/kernelapi.py

@@ -63,7 +63,10 @@ class FakeCUDALocal(object):
     CUDA Local arrays
     """
 
-    def array(self, shape, dtype):
+    def array(self, shape, dtype, alignment=None):
+        if alignment is not None:
+            raise RuntimeError("Array alignment is not supported in cudasim")
+
         if isinstance(dtype, types.Type):
             dtype = numpy_support.as_dtype(dtype)
         return np.empty(shape, dtype)
@@ -102,7 +105,10 @@ class FakeCUDAShared(object):
         self._dynshared_size = dynshared_size
         self._dynshared = np.zeros(dynshared_size, dtype=np.byte)
 
-    def array(self, shape, dtype):
+    def array(self, shape, dtype, alignment=None):
+        if alignment is not None:
+            raise RuntimeError("Array alignment is not supported in cudasim")
+
         if isinstance(dtype, types.Type):
             dtype = numpy_support.as_dtype(dtype)
         # Dynamic shared memory is requested with size 0 - this all shares the

numba_cuda/numba/cuda/simulator/memory_management/__init__.py

@@ -0,0 +1 @@
+from .nrt import rtsys  # noqa: F401

numba_cuda/numba/cuda/simulator/memory_management/nrt.py

@@ -0,0 +1,6 @@
+from numba import config
+
+rtsys = None
+
+config.CUDA_NRT_STATS = False
+config.CUDA_ENABLE_NRT = False

numba_cuda/numba/cuda/testing.py

@@ -116,20 +116,26 @@ def skip_on_arm(reason):
 def skip_if_cuda_includes_missing(fn):
     # Skip when cuda.h is not available - generally this should indicate
     # whether the CUDA includes are available or not
-    cuda_include_path = libs.get_cuda_include_dir()
+    reason = "CUDA include dir not available on this system"
+    try:
+        cuda_include_path = libs.get_cuda_include_dir()
+    except FileNotFoundError:
+        return unittest.skip(reason)(fn)
     cuda_h = os.path.join(cuda_include_path, "cuda.h")
     cuda_h_file = os.path.exists(cuda_h) and os.path.isfile(cuda_h)
-    reason = "CUDA include dir not available on this system"
     return unittest.skipUnless(cuda_h_file, reason)(fn)
 
 
 def skip_if_curand_kernel_missing(fn):
-    cuda_include_path = libs.get_cuda_include_dir()
+    reason = "curand_kernel.h not available on this system"
+    try:
+        cuda_include_path = libs.get_cuda_include_dir()
+    except FileNotFoundError:
+        return unittest.skip(reason)(fn)
     curand_kernel_h = os.path.join(cuda_include_path, "curand_kernel.h")
     curand_kernel_h_file = os.path.exists(curand_kernel_h) and os.path.isfile(
         curand_kernel_h
     )
-    reason = "curand_kernel.h not available on this system"
     return unittest.skipUnless(curand_kernel_h_file, reason)(fn)
 
 

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_ndarray.py

@@ -476,12 +476,14 @@ class TestArrayMethod(CUDATestCase):
             host_array, dev_array.copy_to_host().astype(dtype)
         )
 
+    @skip_on_cudasim("Simulator does not use __array__()")
     @unittest.skipUnless(IS_NUMPY_2, "NumPy 1.x does not pass copy kwarg")
     def test_np_array_copy_false(self):
         dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))
         with self.assertRaisesRegex(ValueError, "`copy=False` is not"):
             np.array(dev_array, copy=False)
 
+    @skip_on_cudasim("Simulator does not use __array__()")
     @unittest.skipUnless(IS_NUMPY_2, "NumPy 1.x does not pass copy kwarg")
     def test_np_array_copy_true(self):
         dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))

numba_cuda/numba/cuda/tests/cudadrv/test_module_callbacks.py

@@ -5,14 +5,19 @@ import numpy as np
 
 from numba import cuda, config
 from numba.cuda.cudadrv.linkable_code import CUSource
-from numba.cuda.testing import CUDATestCase, ContextResettingTestCase
+from numba.cuda.testing import (
+    CUDATestCase,
+    ContextResettingTestCase,
+    skip_on_cudasim,
+)
 
-from cuda.bindings.driver import cuModuleGetGlobal, cuMemcpyHtoD
+if not config.ENABLE_CUDASIM:
+    from cuda.bindings.driver import cuModuleGetGlobal, cuMemcpyHtoD
 
-if config.CUDA_USE_NVIDIA_BINDING:
-    from cuda.cuda import CUmodule as cu_module_type
-else:
-    from numba.cuda.cudadrv.drvapi import cu_module as cu_module_type
+    if config.CUDA_USE_NVIDIA_BINDING:
+        from cuda.cuda import CUmodule as cu_module_type
+    else:
+        from numba.cuda.cudadrv.drvapi import cu_module as cu_module_type
 
 
 def wipe_all_modules_in_context():
@@ -32,6 +37,7 @@ def get_hashable_handle_value(handle):
     return handle
 
 
+@skip_on_cudasim("Module loading not implemented in the simulator")
 class TestModuleCallbacksBasic(ContextResettingTestCase):
     def test_basic(self):
         counter = 0
@@ -136,6 +142,7 @@ class TestModuleCallbacksBasic(ContextResettingTestCase):
         self.assertEqual(len(teardown_seen), 2)
 
 
+@skip_on_cudasim("Module loading not implemented in the simulator")
 class TestModuleCallbacksAPICompleteness(CUDATestCase):
     def test_api(self):
         def setup(handle):
@@ -164,6 +171,7 @@ class TestModuleCallbacksAPICompleteness(CUDATestCase):
                 kernel[1, 1]()
 
 
+@skip_on_cudasim("Module loading not implemented in the simulator")
 class TestModuleCallbacks(CUDATestCase):
     def setUp(self):
         super().setUp()
@@ -213,6 +221,7 @@ __device__ int get_num(int &retval) {
         self.assertEqual(arr[0], 42)
 
 
+@skip_on_cudasim("Module loading not implemented in the simulator")
 class TestMultithreadedCallbacks(CUDATestCase):
     def test_concurrent_initialization(self):
         seen_mods = set()

numba_cuda/numba/cuda/tests/cudadrv/test_nvjitlink.py

@@ -267,6 +267,7 @@ class TestLinker(CUDATestCase):
     not PYNVJITLINK_INSTALLED or not TEST_BIN_DIR,
     reason="pynvjitlink not enabled",
 )
+@skip_on_cudasim("Linking unsupported in the simulator")
 class TestLinkerUsage(CUDATestCase):
     """Test that whether pynvjitlink can be enabled by both environment variable
     and modification of config at runtime.
@@ -298,12 +299,12 @@ class TestLinkerUsage(CUDATestCase):
 
     def test_linker_enabled_envvar(self):
         env = os.environ.copy()
-        env["NUMBA_CUDA_ENABLE_PYNVJITLINK"] = "1"
+        env.pop("NUMBA_CUDA_ENABLE_PYNVJITLINK", None)
         run_in_subprocess(self.src.format(config=""), env=env)
 
     def test_linker_disabled_envvar(self):
         env = os.environ.copy()
-        env.pop("NUMBA_CUDA_ENABLE_PYNVJITLINK", None)
+        env["NUMBA_CUDA_ENABLE_PYNVJITLINK"] = "0"
         with self.assertRaisesRegex(
             AssertionError, "LTO and additional flags require PyNvJitLinker"
         ):

numba_cuda/numba/cuda/tests/cudadrv/test_nvvm_driver.py

@@ -30,7 +30,8 @@ class TestNvvmDriver(unittest.TestCase):
             self.skipTest("-gen-lto unavailable in this toolkit version")
 
         nvvmir = self.get_nvvmir()
-        ltoir = nvvm.compile_ir(nvvmir, opt=3, gen_lto=None, arch="compute_52")
+        arch = "compute_%d%d" % nvvm.LOWEST_CURRENT_CC
+        ltoir = nvvm.compile_ir(nvvmir, opt=3, gen_lto=None, arch=arch)
 
         # Verify we correctly passed the option by checking if we got LTOIR
         # from NVVM (by looking for the expected magic number for LTOIR)
@@ -138,9 +139,9 @@ class TestNvvmDriver(unittest.TestCase):
 class TestArchOption(unittest.TestCase):
     def test_get_arch_option(self):
         # Test returning the nearest lowest arch.
-        self.assertEqual(nvvm.get_arch_option(5, 3), "compute_53")
         self.assertEqual(nvvm.get_arch_option(7, 5), "compute_75")
         self.assertEqual(nvvm.get_arch_option(7, 7), "compute_75")
+        self.assertEqual(nvvm.get_arch_option(8, 8), "compute_87")
         # Test known arch.
         supported_cc = nvvm.get_supported_ccs()
         for arch in supported_cc:

numba_cuda/numba/cuda/tests/cudapy/test_array.py

@@ -310,9 +310,6 @@ class TestCudaArray(CUDATestCase):
             check(array_reshape, array_reshape1d, arr, 0)
             check(array_reshape, array_reshape1d, arr, (0,))
             check(array_reshape, array_reshape3d, arr, (1, 0, 2))
-            check_only_shape(array_reshape2d, arr, (0, -1), (0, 0))
-            check_only_shape(array_reshape2d, arr, (4, -1), (4, 0))
-            check_only_shape(array_reshape3d, arr, (-1, 0, 4), (0, 0, 4))
 
         # C-contiguous
         arr = np.arange(24)

numba_cuda/numba/cuda/tests/cudapy/test_array_alignment.py

@@ -3,7 +3,11 @@ import itertools
 import numpy as np
 from numba import cuda
 from numba.core.errors import TypingError
-from numba.cuda.testing import CUDATestCase
+from numba.cuda.testing import (
+    CUDATestCase,
+    skip_on_cudasim,
+    skip_unless_cudasim,
+)
 import unittest
 
 
@@ -65,6 +69,7 @@ for align in (True, False):
 #      with the test_alignment.TestArrayAlignment class.
 
 
+@skip_on_cudasim("Array alignment not supported on cudasim")
 class TestArrayAddressAlignment(CUDATestCase):
     """
     Test cuda.local.array and cuda.shared.array support for an alignment
@@ -232,5 +237,24 @@ class TestArrayAddressAlignment(CUDATestCase):
                     print(".", end="", flush=True)
 
 
+@skip_unless_cudasim("Only check for alignment unsupported in the simulator")
+class TestCudasimUnsupportedAlignment(CUDATestCase):
+    def test_local_unsupported(self):
+        @cuda.jit
+        def f():
+            cuda.local.array(1, dtype=np.uint8, alignment=16)
+
+        with self.assertRaisesRegex(RuntimeError, "not supported in cudasim"):
+            f[1, 1]()
+
+    def test_shared_unsupported(self):
+        @cuda.jit
+        def f():
+            cuda.shared.array(1, dtype=np.uint8, alignment=16)
+
+        with self.assertRaisesRegex(RuntimeError, "not supported in cudasim"):
+            f[1, 1]()
+
+
 if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_bfloat16.py

@@ -23,6 +23,15 @@ class TestBfloat16HighLevelBindings(CUDATestCase):
 
     def test_math_bindings(self):
         self.skip_unsupported()
+
+        exp_functions = [math.exp]
+        try:
+            from math import exp2
+
+            exp_functions += [exp2]
+        except ImportError:
+            pass
+
         functions = [
             math.trunc,
             math.ceil,
@@ -33,9 +42,7 @@ class TestBfloat16HighLevelBindings(CUDATestCase):
             math.cos,
             math.sin,
             math.tanh,
-            math.exp,
-            math.exp2,
-        ]
+        ] + exp_functions
 
         for f in functions:
             with self.subTest(func=f):
@@ -49,7 +56,7 @@ class TestBfloat16HighLevelBindings(CUDATestCase):
                 arr = cuda.device_array((1,), dtype="float32")
                 kernel[1, 1](arr)
 
-                if f in (math.exp, math.exp2):
+                if f in exp_functions:
                     self.assertAlmostEqual(arr[0], f(3.14), delta=1e-1)
                 else:
                     self.assertAlmostEqual(arr[0], f(3.14), delta=1e-2)

numba_cuda/numba/cuda/tests/cudapy/test_bfloat16_bindings.py

@@ -2,29 +2,40 @@ import numba.cuda as cuda
 from numba.cuda.testing import unittest, CUDATestCase
 import numpy as np
 
-from numba import int16, int32, int64, uint16, uint32, uint64, float32, float64
+from numba import (
+    config,
+    int16,
+    int32,
+    int64,
+    uint16,
+    uint32,
+    uint64,
+    float32,
+    float64,
+)
 from numba.types import float16
 
-from numba.cuda._internal.cuda_bf16 import (
-    nv_bfloat16,
-    htrunc,
-    hceil,
-    hfloor,
-    hrint,
-    hsqrt,
-    hrsqrt,
-    hrcp,
-    hlog,
-    hlog2,
-    hlog10,
-    hcos,
-    hsin,
-    hexp,
-    hexp2,
-    hexp10,
-    htanh,
-    htanh_approx,
-)
+if not config.ENABLE_CUDASIM:
+    from numba.cuda._internal.cuda_bf16 import (
+        nv_bfloat16,
+        htrunc,
+        hceil,
+        hfloor,
+        hrint,
+        hsqrt,
+        hrsqrt,
+        hrcp,
+        hlog,
+        hlog2,
+        hlog10,
+        hcos,
+        hsin,
+        hexp,
+        hexp2,
+        hexp10,
+        htanh,
+        htanh_approx,
+    )
 
 dtypes = [int16, int32, int64, uint16, uint32, uint64, float32]
 
@@ -263,6 +274,8 @@ class Bfloat16Test(CUDATestCase):
         np.testing.assert_allclose(arr, [8], atol=1e-2)
 
     def test_use_binding_inside_dfunc(self):
+        self.skip_unsupported()
+
         @cuda.jit(device=True)
         def f(arr):
             pi = nv_bfloat16(3.14)

numba_cuda/numba/cuda/tests/cudapy/test_compiler.py

@@ -1,5 +1,5 @@
 from math import sqrt
-from numba import cuda, float32, int16, int32, int64, uint32, void
+from numba import cuda, float32, int16, int32, int64, types, uint32, void
 from numba.cuda import (
     compile,
     compile_for_current_device,
@@ -288,7 +288,7 @@ class TestCompileOnlyTests(unittest.TestCase):
             # Sleep for a variable time
             cuda.nanosleep(x)
 
-        ptx, resty = compile_ptx(use_nanosleep, (uint32,), cc=(7, 0))
+        ptx, resty = compile_ptx(use_nanosleep, (uint32,))
 
         nanosleep_count = 0
         for line in ptx.split("\n"):
@@ -306,5 +306,65 @@ class TestCompileOnlyTests(unittest.TestCase):
         )
 
 
+@skip_on_cudasim("Compilation unsupported in the simulator")
+class TestCompileWithLaunchBounds(unittest.TestCase):
+    def _test_launch_bounds_common(self, launch_bounds):
+        def f():
+            pass
+
+        sig = "void()"
+        ptx, resty = cuda.compile_ptx(f, sig, launch_bounds=launch_bounds)
+        self.assertIsInstance(resty, types.NoneType)
+        self.assertRegex(ptx, r".maxntid\s+128,\s+1,\s+1")
+        return ptx
+
+    def test_launch_bounds_scalar(self):
+        launch_bounds = 128
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertNotIn(".minnctapersm", ptx)
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    def test_launch_bounds_tuple(self):
+        launch_bounds = (128,)
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertNotIn(".minnctapersm", ptx)
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    def test_launch_bounds_with_min_cta(self):
+        launch_bounds = (128, 2)
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertRegex(ptx, r".minnctapersm\s+2")
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    def test_launch_bounds_with_max_cluster_rank(self):
+        def f():
+            pass
+
+        launch_bounds = (128, 2, 4)
+        cc = (9, 0)
+        sig = "void()"
+        ptx, resty = cuda.compile_ptx(
+            f, sig, launch_bounds=launch_bounds, cc=cc
+        )
+        self.assertIsInstance(resty, types.NoneType)
+        self.assertRegex(ptx, r".maxntid\s+128,\s+1,\s+1")
+
+        self.assertRegex(ptx, r".minnctapersm\s+2")
+        self.assertRegex(ptx, r".maxclusterrank\s+4")
+
+    def test_too_many_launch_bounds(self):
+        def f():
+            pass
+
+        sig = "void()"
+        launch_bounds = (128, 2, 4, 8)
+
+        with self.assertRaisesRegex(ValueError, "Got 4 launch bounds:"):
+            cuda.compile_ptx(f, sig, launch_bounds=launch_bounds)
+
+
 if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_cooperative_groups.py

@@ -157,6 +157,7 @@ class TestCudaCooperativeGroups(CUDATestCase):
         self.assertEqual(blocks1d, blocks2d)
         self.assertEqual(blocks1d, blocks3d)
 
+    @skip_on_cudasim("External code unsupported on cudasim")
     @skip_unless_cc_60
     def test_external_cooperative_func(self):
         cudapy_test_path = os.path.dirname(__file__)
@@ -171,12 +172,13 @@ class TestCudaCooperativeGroups(CUDATestCase):
             "cta_barrier", sig=sig, link=[src], use_cooperative=True
         )
 
-        @cuda.jit
+        @cuda.jit("void()")
         def kernel():
             cta_barrier()
 
+        overload = kernel.overloads[()]
         block_size = 32
-        grid_size = 1024
+        grid_size = overload.max_cooperative_grid_blocks(block_size)
 
         kernel[grid_size, block_size]()
 

numba_cuda/numba/cuda/tests/cudapy/test_debuginfo.py

@@ -332,10 +332,10 @@ class TestCudaDebugInfo(CUDATestCase):
 
         @cuda.jit("void(int32, int32)", debug=True, opt=False)
         def f(x, y):
-            z = x  # noqa: F841
-            z = 100  # noqa: F841
-            z = y  # noqa: F841
-            z = True  # noqa: F841
+            z1 = x  # noqa: F841
+            z2 = 100  # noqa: F841
+            z3 = y  # noqa: F841
+            z4 = True  # noqa: F841
 
         llvm_ir = f.inspect_llvm(sig)
         # Verify the call to llvm.dbg.declare is replaced by llvm.dbg.value
@@ -373,6 +373,45 @@ class TestCudaDebugInfo(CUDATestCase):
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNone(match, msg=llvm_ir)
 
+    def test_union_poly_types(self):
+        sig = (types.int32, types.int32)
+
+        @cuda.jit("void(int32, int32)", debug=True, opt=False)
+        def f(x, y):
+            foo = 100  # noqa: F841
+            foo = 2.34  # noqa: F841
+            foo = True  # noqa: F841
+            foo = 200  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+        # Extract the type node id
+        pat1 = r'!DILocalVariable\(.*name: "foo".*type: !(\d+)\)'
+        match = re.compile(pat1).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id = match.group(1)
+        # Verify the union type and extract the elements node id
+        pat2 = rf"!{mdnode_id} = distinct !DICompositeType\(elements: !(\d+),.*size: 64, tag: DW_TAG_union_type\)"  # noqa: E501
+        match = re.compile(pat2).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id = match.group(1)
+        # Extract the member node ids
+        pat3 = r"!{ !(\d+), !(\d+), !(\d+) }"
+        match = re.compile(pat3).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id1 = match.group(1)
+        mdnode_id2 = match.group(2)
+        mdnode_id3 = match.group(3)
+        # Verify the member nodes
+        pat4 = rf'!{mdnode_id1} = !DIDerivedType(.*name: "_bool", size: 8, tag: DW_TAG_member)'  # noqa: E501
+        match = re.compile(pat4).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        pat5 = rf'!{mdnode_id2} = !DIDerivedType(.*name: "_float64", size: 64, tag: DW_TAG_member)'  # noqa: E501
+        match = re.compile(pat5).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        pat6 = rf'!{mdnode_id3} = !DIDerivedType(.*name: "_int64", size: 64, tag: DW_TAG_member)'  # noqa: E501
+        match = re.compile(pat6).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+
 
 if __name__ == "__main__":
     unittest.main()