numba-cuda 0.11.0__tar.gz → 0.13.0__tar.gz

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.11.0
+Version: 0.13.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause

numba_cuda-0.13.0/numba_cuda/VERSION

@@ -0,0 +1 @@
+0.13.0

{numba_cuda-0.11.0/numba_cuda/numba/cuda → numba_cuda-0.13.0/numba_cuda/numba/cuda/_internal}/cuda_bf16.py

@@ -2,7 +2,7 @@
 # Generator Information:
 # Ast_canopy version: 0.3.0
 # Numbast version: 0.3.0
-# Generation command: /home/wangm/numbast/numbast/src/numbast/__main__.py --cfg-path configs/cuda_bf16.yml --output-dir numba_cuda/numba/cuda/
+# Generation command: /home/wangm/numbast/numbast/src/numbast/__main__.py --cfg-path configs/cuda_bf16.yml --output-dir numba_cuda/numba/cuda/_internal
 # Static binding generator parameters: {'cfg_path': 'configs/cuda_bf16.yml', 'output_dir': 'numba_cuda/numba/cuda/', 'entry_point': None, 'retain': None, 'types': None, 'datamodels': None, 'compute_capability': None, 'run_ruff_format': True}
 # Config file path (relative to the path of the generated binding): ../../../../configs/cuda_bf16.yml
 # Cudatoolkit version: (12, 8)

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/api.py

@@ -10,6 +10,7 @@ import numpy as np
 from .cudadrv import devicearray, devices, driver
 from numba.core import config
 from numba.cuda.api_util import prepare_shape_strides_dtype
+from numba.cuda.cudadrv.runtime import get_version
 
 # NDarray device helper
 
@@ -95,6 +96,18 @@ def is_float16_supported():
     return True
 
 
+def is_bfloat16_supported():
+    """Whether bfloat16 are supported.
+
+    bfloat16 are only supported on devices with compute capability >= 8.0 and cuda version >= 12.0
+    """
+    cuda_version = get_version()
+    return current_context().device.supports_bfloat16 and cuda_version >= (
+        12,
+        0,
+    )
+
+
 @require_context
 def to_device(obj, stream=0, copy=True, to=None):
     """to_device(obj, stream=0, copy=True, to=None)

numba_cuda-0.13.0/numba_cuda/numba/cuda/bf16.py

@@ -0,0 +1,112 @@
+from numba.cuda._internal.cuda_bf16 import (
+    _type_class___nv_bfloat16,
+    nv_bfloat16 as bfloat16,
+    htrunc,
+    hceil,
+    hfloor,
+    hrint,
+    hsqrt,
+    hrsqrt,
+    hrcp,
+    hlog,
+    hlog2,
+    hlog10,
+    hcos,
+    hsin,
+    hexp,
+    hexp2,
+    hexp10,
+    htanh,
+    htanh_approx,
+)
+from numba.extending import overload
+
+import math
+
+
+def _make_unary(a, func):
+    if isinstance(a, _type_class___nv_bfloat16):
+        return lambda a: func(a)
+
+
+# Bind low++ bindings to math APIs
+@overload(math.trunc, target="cuda")
+def trunc_ol(a):
+    return _make_unary(a, htrunc)
+
+
+@overload(math.ceil, target="cuda")
+def ceil_ol(a):
+    return _make_unary(a, hceil)
+
+
+@overload(math.floor, target="cuda")
+def floor_ol(a):
+    return _make_unary(a, hfloor)
+
+
+@overload(math.sqrt, target="cuda")
+def sqrt_ol(a):
+    return _make_unary(a, hsqrt)
+
+
+@overload(math.log, target="cuda")
+def log_ol(a):
+    return _make_unary(a, hlog)
+
+
+@overload(math.log10, target="cuda")
+def log10_ol(a):
+    return _make_unary(a, hlog10)
+
+
+@overload(math.cos, target="cuda")
+def cos_ol(a):
+    return _make_unary(a, hcos)
+
+
+@overload(math.sin, target="cuda")
+def sin_ol(a):
+    return _make_unary(a, hsin)
+
+
+@overload(math.tanh, target="cuda")
+def tanh_ol(a):
+    return _make_unary(a, htanh)
+
+
+@overload(math.exp, target="cuda")
+def exp_ol(a):
+    return _make_unary(a, hexp)
+
+
+try:
+    from math import exp2
+
+    @overload(exp2, target="cuda")
+    def exp2_ol(a):
+        return _make_unary(a, hexp2)
+except ImportError:
+    pass
+
+
+__all__ = [
+    "bfloat16",
+    "htrunc",
+    "hceil",
+    "hfloor",
+    "hrint",
+    "hsqrt",
+    "hrsqrt",
+    "hrcp",
+    "hlog",
+    "hlog2",
+    "hlog10",
+    "hcos",
+    "hsin",
+    "htanh",
+    "htanh_approx",
+    "hexp",
+    "hexp2",
+    "hexp10",
+]

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/cg.py

@@ -23,6 +23,7 @@ def _this_grid(typingctx):
     sig = signature(grid_group)
 
     def codegen(context, builder, sig, args):
+        context.active_code_library.use_cooperative = True
         one = context.get_constant(types.int32, 1)
         mod = builder.module
         return builder.call(
@@ -45,6 +46,7 @@ def _grid_group_sync(typingctx, group):
     sig = signature(types.int32, group)
 
     def codegen(context, builder, sig, args):
+        context.active_code_library.use_cooperative = True
         flags = context.get_constant(types.int32, 0)
         mod = builder.module
         return builder.call(

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/codegen.py

@@ -5,7 +5,7 @@ from numba.core.codegen import Codegen, CodeLibrary
 from .cudadrv import devices, driver, nvvm, runtime
 from numba.cuda.cudadrv.libs import get_cudalib
 from numba.cuda.cudadrv.linkable_code import LinkableCode
-from numba.cuda.runtime.nrt import NRT_LIBRARY
+from numba.cuda.memory_management.nrt import NRT_LIBRARY
 
 import os
 import subprocess
@@ -70,6 +70,8 @@ class ExternalCodeLibrary(CodeLibrary):
         self._setup_functions = []
         self._teardown_functions = []
 
+        self.use_cooperative = False
+
     @property
     def modules(self):
         # There are no LLVM IR modules in an ExternalCodeLibrary
@@ -181,6 +183,8 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         self._nvvm_options = nvvm_options
         self._entry_name = entry_name
 
+        self.use_cooperative = False
+
     @property
     def llvm_strs(self):
         if self._llvm_strs is None:
@@ -352,6 +356,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         self._linking_files.update(library._linking_files)
         self._setup_functions.extend(library._setup_functions)
         self._teardown_functions.extend(library._teardown_functions)
+        self.use_cooperative |= library.use_cooperative
 
     def add_linking_file(self, path_or_obj):
         if isinstance(path_or_obj, LinkableCode):
@@ -442,6 +447,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
             nvvm_options=self._nvvm_options,
             needs_cudadevrt=self.needs_cudadevrt,
             nrt=nrt,
+            use_cooperative=self.use_cooperative,
         )
 
     @classmethod
@@ -458,6 +464,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         nvvm_options,
         needs_cudadevrt,
         nrt,
+        use_cooperative,
     ):
         """
         Rebuild an instance.
@@ -472,6 +479,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         instance._max_registers = max_registers
         instance._nvvm_options = nvvm_options
         instance.needs_cudadevrt = needs_cudadevrt
+        instance.use_cooperative = use_cooperative
 
         instance._finalized = True
         if nrt:

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/compiler.py

@@ -797,7 +797,7 @@ def compile_ptx_for_current_device(
     )
 
 
-def declare_device_function(name, restype, argtypes, link):
+def declare_device_function(name, restype, argtypes, link, use_cooperative):
     from .descriptor import cuda_target
 
     typingctx = cuda_target.typing_context
@@ -816,6 +816,7 @@ def declare_device_function(name, restype, argtypes, link):
     lib = ExternalCodeLibrary(f"{name}_externals", targetctx.codegen())
     for file in link:
         lib.add_linking_file(file)
+    lib.use_cooperative = use_cooperative
 
     # ExternalFunctionDescriptor provides a lowering implementation for calling
     # external functions

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/cudadecl.py

@@ -423,7 +423,11 @@ _genfp16_binary_operator(operator.itruediv)
 def _resolve_wrapped_unary(fname):
     link = tuple()
     decl = declare_device_function(
-        f"__numba_wrapper_{fname}", types.float16, (types.float16,), link
+        f"__numba_wrapper_{fname}",
+        types.float16,
+        (types.float16,),
+        link,
+        use_cooperative=False,
     )
     return types.Function(decl)
 
@@ -438,6 +442,7 @@ def _resolve_wrapped_binary(fname):
             types.float16,
         ),
         link,
+        use_cooperative=False,
     )
     return types.Function(decl)
 

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/cudadrv/driver.py

@@ -714,6 +714,10 @@ class Device(object):
     def supports_float16(self):
         return self.compute_capability >= (5, 3)
 
+    @property
+    def supports_bfloat16(self):
+        return self.compute_capability >= (8, 0)
+
 
 def met_requirement_for_device(device):
     if device.compute_capability < MIN_REQUIRED_CC:

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/cudadrv/nvrtc.py

@@ -6,13 +6,21 @@ from numba.cuda.cudadrv.error import (
     NvrtcCompilationError,
     NvrtcSupportError,
 )
+from numba import config
 from numba.cuda.cuda_paths import get_cuda_paths
+from numba.cuda.utils import _readenv
 
 import functools
 import os
 import threading
 import warnings
 
+NVRTC_EXTRA_SEARCH_PATHS = _readenv(
+    "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS", str, ""
+) or getattr(config, "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS", "")
+if not hasattr(config, "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS"):
+    config.CUDA_NVRTC_EXTRA_SEARCH_PATHS = NVRTC_EXTRA_SEARCH_PATHS
+
 # Opaque handle for compilation unit
 nvrtc_program = c_void_p
 
@@ -383,10 +391,24 @@ def compile(src, name, cc, ltoir=False):
     else:
         numba_include = f"-I{os.path.join(numba_cuda_path, 'include', '12')}"
 
-    nrt_path = os.path.join(numba_cuda_path, "runtime")
+    if config.CUDA_NVRTC_EXTRA_SEARCH_PATHS:
+        extra_search_paths = config.CUDA_NVRTC_EXTRA_SEARCH_PATHS.split(":")
+        extra_includes = [f"-I{p}" for p in extra_search_paths]
+    else:
+        extra_includes = []
+
+    nrt_path = os.path.join(numba_cuda_path, "memory_management")
     nrt_include = f"-I{nrt_path}"
 
-    options = [arch, numba_include, *cuda_include, nrt_include, "-rdc", "true"]
+    options = [
+        arch,
+        numba_include,
+        *cuda_include,
+        nrt_include,
+        *extra_includes,
+        "-rdc",
+        "true",
+    ]
 
     if ltoir:
         options.append("-dlto")

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/debuginfo.py

@@ -59,6 +59,33 @@ class CUDADIBuilder(DIBuilder):
         # For other cases, use upstream Numba implementation
         return super()._var_type(lltype, size, datamodel=datamodel)
 
+    def _di_subroutine_type(self, line, function, argmap):
+        # The function call conv needs encoding.
+        llfunc = function
+        md = []
+
+        # Create metadata type for return value
+        if len(llfunc.args) > 0:
+            lltype = llfunc.args[0].type
+            size = self.cgctx.get_abi_sizeof(lltype)
+            mdtype = self._var_type(lltype, size, datamodel=None)
+            md.append(mdtype)
+
+        # Create metadata type for arguments
+        for idx, (name, nbtype) in enumerate(argmap.items()):
+            datamodel = self.cgctx.data_model_manager[nbtype]
+            lltype = self.cgctx.get_value_type(nbtype)
+            size = self.cgctx.get_abi_sizeof(lltype)
+            mdtype = self._var_type(lltype, size, datamodel=datamodel)
+            md.append(mdtype)
+
+        return self.module.add_debug_info(
+            "DISubroutineType",
+            {
+                "types": self.module.add_metadata(md),
+            },
+        )
+
     def mark_variable(
         self,
         builder,

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/decorators.py

@@ -229,7 +229,7 @@ def jit(
                 return disp
 
 
-def declare_device(name, sig, link=None):
+def declare_device(name, sig, link=None, use_cooperative=False):
     """
     Declare the signature of a foreign function. Returns a descriptor that can
     be used to call the function from a Python kernel.
@@ -238,6 +238,7 @@ def declare_device(name, sig, link=None):
     :type name: str
     :param sig: The Numba signature of the function.
     :param link: External code to link when calling the function.
+    :param use_cooperative: External code requires cooperative launch.
     """
     if link is None:
         link = tuple()
@@ -250,6 +251,8 @@ def declare_device(name, sig, link=None):
         msg = "Return type must be provided for device declarations"
         raise TypeError(msg)
 
-    template = declare_device_function(name, restype, argtypes, link)
+    template = declare_device_function(
+        name, restype, argtypes, link, use_cooperative
+    )
 
     return template.key

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/dispatcher.py

@@ -27,8 +27,8 @@ from numba.cuda.errors import (
     normalize_kernel_dimensions,
 )
 from numba.cuda import types as cuda_types
-from numba.cuda.runtime.nrt import rtsys, NRT_LIBRARY
 from numba.cuda.locks import module_init_lock
+from numba.cuda.memory_management.nrt import rtsys, NRT_LIBRARY
 
 from numba import cuda
 from numba import _dispatcher
@@ -151,8 +151,8 @@ class _Kernel(serialize.ReduceMixin):
 
         asm = lib.get_asm_str()
 
-        # A kernel needs cooperative launch if grid_sync is being used.
-        self.cooperative = "cudaCGGetIntrinsicHandle" in asm
+        # The code library contains functions that require cooperative launch.
+        self.cooperative = lib.use_cooperative
         # We need to link against cudadevrt if grid sync is being used.
         if self.cooperative:
             lib.needs_cudadevrt = True

numba_cuda-0.13.0/numba_cuda/numba/cuda/memory_management/__init__.py

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

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/__init__.py

@@ -38,11 +38,20 @@ if config.ENABLE_CUDASIM:
     sys.modules["numba.cuda.cudadrv.devicearray"] = cudadrv.devicearray
     sys.modules["numba.cuda.cudadrv.devices"] = cudadrv.devices
     sys.modules["numba.cuda.cudadrv.driver"] = cudadrv.driver
+    sys.modules["numba.cuda.cudadrv.linkable_code"] = cudadrv.linkable_code
     sys.modules["numba.cuda.cudadrv.runtime"] = cudadrv.runtime
     sys.modules["numba.cuda.cudadrv.drvapi"] = cudadrv.drvapi
     sys.modules["numba.cuda.cudadrv.error"] = cudadrv.error
     sys.modules["numba.cuda.cudadrv.nvvm"] = cudadrv.nvvm
 
-    from . import compiler
+    from . import bf16, compiler, _internal
 
+    sys.modules["numba.cuda.bf16"] = bf16
     sys.modules["numba.cuda.compiler"] = compiler
+    sys.modules["numba.cuda._internal"] = _internal
+    sys.modules["numba.cuda._internal.cuda_bf16"] = _internal.cuda_bf16
+
+    from numba.cuda.simulator import memory_management
+
+    sys.modules["numba.cuda.memory_management"] = memory_management
+    sys.modules["numba.cuda.memory_management.nrt"] = memory_management.nrt

numba_cuda-0.13.0/numba_cuda/numba/cuda/simulator/_internal/__init__.py

@@ -0,0 +1 @@
+from numba.cuda.simulator._internal import cuda_bf16  # noqa: F401

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/api.py

@@ -7,6 +7,15 @@ Contains CUDA API functions
 from contextlib import contextmanager
 
 from .cudadrv.devices import require_context, reset, gpus  # noqa: F401
+from .cudadrv.linkable_code import (
+    PTXSource,  # noqa: F401
+    CUSource,  # noqa: F401
+    Cubin,  # noqa: F401
+    Fatbin,  # noqa: F401
+    Archive,  # noqa: F401
+    Object,  # noqa: F401
+    LTOIR,  # noqa: F401
+)  # noqa: F401
 from .kernel import FakeCUDAKernel
 from numba.core.sigutils import is_signature
 from numba.core import config
@@ -22,6 +31,10 @@ def is_float16_supported():
     return True
 
 
+def is_bfloat16_supported():
+    return False
+
+
 class stream(object):
     """
     The stream API is supported in the simulator - however, all execution
@@ -72,6 +85,10 @@ def list_devices():
     return gpus
 
 
+def get_current_device():
+    return gpus[0].device
+
+
 # Events
 
 

numba_cuda-0.13.0/numba_cuda/numba/cuda/simulator/bf16.py

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

{numba_cuda-0.11.0 → numba_cuda-0.13.0}/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-0.11.0 → numba_cuda-0.13.0}/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-0.11.0 → numba_cuda-0.13.0}/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-0.13.0/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-0.13.0/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-0.11.0 → numba_cuda-0.13.0}/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-0.11.0 → numba_cuda-0.13.0}/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-0.13.0/numba_cuda/numba/cuda/simulator/memory_management/__init__.py

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

numba_cuda-0.13.0/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-0.11.0 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/target.py

@@ -290,7 +290,16 @@ class CUDATargetContext(BaseContext):
 
 
 class CUDACallConv(MinimalCallConv):
-    pass
+    def decorate_function(self, fn, args, fe_argtypes, noalias=False):
+        """
+        Set names and attributes of function arguments.
+        """
+        assert not noalias
+        arginfo = self._get_arg_packer(fe_argtypes)
+        # Do not prefix "arg." on argument name, so that nvvm compiler
+        # can track debug info of argument more accurately
+        arginfo.assign_names(self.get_arguments(fn), args)
+        fn.args[0].name = ".ret"
 
 
 class CUDACABICallConv(BaseCallConv):