13 files changed, 672 insertions, 24 deletions
diff --git a/docs/markdown/Cuda-module.md b/docs/markdown/Cuda-module.md
new file mode 100644
index 0000000..6e7be47
--- /dev/null
+++ b/docs/markdown/Cuda-module.md
@@ -0,0 +1,183 @@
+---
+short-description: CUDA module
+authors:
+    - name: Olexa Bilaniuk
+      years: [2019]
+      has-copyright: false
+...
+
+# Unstable CUDA Module (`unstable-cuda`)
+_Since: 0.50.0_
+
+This module provides helper functionality related to the CUDA Toolkit and
+building code using it.
+
+
+**Note**: this module is unstable. It is only provided as a technology preview.
+Its API may change in arbitrary ways between releases or it might be removed
+from Meson altogether.
+
+
+## Importing the module
+
+The module may be imported as follows:
+
+``` meson
+cuda = import('unstable-cuda')
+```
+
+It offers several useful functions that are enumerated below.
+
+
+## Functions
+
+### `nvcc_arch_flags()`
+_Since: 0.50.0_
+
+``` meson
+cuda.nvcc_arch_flags(nvcc_or_version, ...,
+                     detected: string_or_array)
+```
+
+Returns a list of `-gencode` flags that should be passed to `cuda_args:` in
+order to compile a "fat binary" for the architectures/compute capabilities
+enumerated in the positional argument(s). The flags shall be acceptable to
+the NVCC compiler object `nvcc_or_version`, or its version string.
+
+A set of architectures and/or compute capabilities may be specified by:
+
+- The single positional argument `'All'`, `'Common'` or `'Auto'`
+- As (an array of)
+  - Architecture names (`'Kepler'`, `'Maxwell+Tegra'`, `'Turing'`) and/or
+  - Compute capabilities (`'3.0'`, `'3.5'`, `'5.3'`, `'7.5'`)
+
+A suffix of `+PTX` requests PTX code generation for the given architecture.
+A compute capability given as `A.B(X.Y)` requests PTX generation for an older
+virtual architecture `X.Y` before binary generation for a newer architecture
+`A.B`.
+
+Multiple architectures and compute capabilities may be passed in using
+
+- Multiple positional arguments
+- Lists of strings
+- Space (` `), comma (`,`) or semicolon (`;`)-separated strings
+
+The single-word architectural sets `'All'`, `'Common'` or `'Auto'` cannot be
+mixed with architecture names or compute capabilities. Their interpretation is:
+
+| Name              | Compute Capability |
+|-------------------|--------------------|
+| `'All'`           | All CCs supported by given NVCC compiler. |
+| `'Common'`        | Relatively common CCs supported by given NVCC compiler. Generally excludes Tegra and Tesla devices. |
+| `'Auto'`          | The CCs provided by the `detected:` keyword, filtered for support by given NVCC compiler. |
+
+The supported architecture names and their corresponding compute capabilities
+are:
+
+| Name              | Compute Capability |
+|-------------------|--------------------|
+| `'Fermi'`         | 2.0, 2.1(2.0)      |
+| `'Kepler'`        | 3.0, 3.5           |
+| `'Kepler+Tegra'`  | 3.2                |
+| `'Kepler+Tesla'`  | 3.7                |
+| `'Maxwell'`       | 5.0, 5.2           |
+| `'Maxwell+Tegra'` | 5.3                |
+| `'Pascal'`        | 6.0, 6.1           |
+| `'Pascal+Tegra'`  | 6.2                |
+| `'Volta'`         | 7.0                |
+| `'Volta+Tegra'`   | 7.2                |
+| `'Turing'`        | 7.5                |
+
+
+Examples:
+
+    cuda.nvcc_arch_flags('10.0', '3.0', '3.5', '5.0+PTX')
+    cuda.nvcc_arch_flags('10.0', ['3.0', '3.5', '5.0+PTX'])
+    cuda.nvcc_arch_flags('10.0', [['3.0', '3.5'], '5.0+PTX'])
+    cuda.nvcc_arch_flags('10.0', '3.0 3.5 5.0+PTX')
+    cuda.nvcc_arch_flags('10.0', '3.0,3.5,5.0+PTX')
+    cuda.nvcc_arch_flags('10.0', '3.0;3.5;5.0+PTX')
+    cuda.nvcc_arch_flags('10.0', 'Kepler 5.0+PTX')
+    # Returns ['-gencode', 'arch=compute_30,code=sm_30',
+    #          '-gencode', 'arch=compute_35,code=sm_35',
+    #          '-gencode', 'arch=compute_50,code=sm_50',
+    #          '-gencode', 'arch=compute_50,code=compute_50']
+
+    cuda.nvcc_arch_flags('10.0', '3.5(3.0)')
+    # Returns ['-gencode', 'arch=compute_30,code=sm_35']
+
+    cuda.nvcc_arch_flags('8.0', 'Common')
+    # Returns ['-gencode', 'arch=compute_30,code=sm_30',
+    #          '-gencode', 'arch=compute_35,code=sm_35',
+    #          '-gencode', 'arch=compute_50,code=sm_50',
+    #          '-gencode', 'arch=compute_52,code=sm_52',
+    #          '-gencode', 'arch=compute_60,code=sm_60',
+    #          '-gencode', 'arch=compute_61,code=sm_61',
+    #          '-gencode', 'arch=compute_61,code=compute_61']
+
+    cuda.nvcc_arch_flags('9.2', 'Auto', detected: '6.0 6.0 6.0 6.0')
+    cuda.nvcc_arch_flags('9.2', 'Auto', detected: ['6.0', '6.0', '6.0', '6.0'])
+    # Returns ['-gencode', 'arch=compute_60,code=sm_60']
+
+    cuda.nvcc_arch_flags(nvcc, 'All')
+    # Returns ['-gencode', 'arch=compute_20,code=sm_20',
+    #          '-gencode', 'arch=compute_20,code=sm_21',
+    #          '-gencode', 'arch=compute_30,code=sm_30',
+    #          '-gencode', 'arch=compute_32,code=sm_32',
+    #          '-gencode', 'arch=compute_35,code=sm_35',
+    #          '-gencode', 'arch=compute_37,code=sm_37',
+    #          '-gencode', 'arch=compute_50,code=sm_50', # nvcc.version()  <  7.0
+    #          '-gencode', 'arch=compute_52,code=sm_52',
+    #          '-gencode', 'arch=compute_53,code=sm_53', # nvcc.version() >=  7.0
+    #          '-gencode', 'arch=compute_60,code=sm_60',
+    #          '-gencode', 'arch=compute_61,code=sm_61', # nvcc.version() >=  8.0
+    #          '-gencode', 'arch=compute_70,code=sm_70',
+    #          '-gencode', 'arch=compute_72,code=sm_72', # nvcc.version() >=  9.0
+    #          '-gencode', 'arch=compute_75,code=sm_75'] # nvcc.version() >= 10.0
+
+_Note:_ This function is intended to closely replicate CMake's FindCUDA module
+function `CUDA_SELECT_NVCC_ARCH_FLAGS(out_variable, [list of CUDA compute architectures])`
+
+
+
+### `nvcc_arch_readable()`
+_Since: 0.50.0_
+
+``` meson
+cuda.nvcc_arch_readable(nvcc_or_version, ...,
+                        detected: string_or_array)
+```
+
+Has precisely the same interface as [`nvcc_arch_flags()`](#nvcc_arch_flags),
+but rather than returning a list of flags, it returns a "readable" list of
+architectures that will be compiled for. The output of this function is solely
+intended for informative message printing.
+
+    archs    = '3.0 3.5 5.0+PTX'
+    readable = cuda.nvcc_arch_readable(nvcc, archs)
+    message('Building for architectures ' + ' '.join(readable))
+
+This will print
+
+    Message: Building for architectures sm30 sm35 sm50 compute50
+
+_Note:_ This function is intended to closely replicate CMake's FindCUDA module function
+`CUDA_SELECT_NVCC_ARCH_FLAGS(out_variable, [list of CUDA compute architectures])`
+
+
+
+### `min_driver_version()`
+_Since: 0.50.0_
+
+``` meson
+cuda.min_driver_version(nvcc_or_version)
+```
+
+Returns the minimum NVIDIA proprietary driver version required, on the host
+system, by kernels compiled with the given NVCC compiler or its version string.
+
+The output of this function is generally intended for informative message
+printing, but could be used for assertions or to conditionally enable
+features known to exist within the minimum NVIDIA driver required.
+
+
diff --git a/docs/sitemap.txt b/docs/sitemap.txt
index f80c279..6987641 100644
--- a/docs/sitemap.txt
+++ b/docs/sitemap.txt
@@ -44,6 +44,7 @@ index.md
 			RPM-module.md
 			Simd-module.md
 			Windows-module.md
+			Cuda-module.md
 		Java.md
 		Vala.md
 		D.md
diff --git a/mesonbuild/backend/vs2010backend.py b/mesonbuild/backend/vs2010backend.py
index 80204e4..074c3a9 100644
--- a/mesonbuild/backend/vs2010backend.py
+++ b/mesonbuild/backend/vs2010backend.py
@@ -1161,7 +1161,7 @@ class Vs2010Backend(backends.Backend):
         ET.SubElement(meson_file_group, 'None', Include=os.path.join(proj_to_src_dir, build_filename))
 
         extra_files = target.extra_files
-        if len(headers) + len(gen_hdrs) + len(extra_files) > 0:
+        if len(headers) + len(gen_hdrs) + len(extra_files) + len(pch_sources) > 0:
             inc_hdrs = ET.SubElement(root, 'ItemGroup')
             for h in headers:
                 relpath = os.path.join(down, h.rel_to_builddir(self.build_to_src))
@@ -1171,6 +1171,9 @@ class Vs2010Backend(backends.Backend):
             for h in target.extra_files:
                 relpath = os.path.join(down, h.rel_to_builddir(self.build_to_src))
                 ET.SubElement(inc_hdrs, 'CLInclude', Include=relpath)
+            for lang in pch_sources:
+                h = pch_sources[lang][0]
+                ET.SubElement(inc_hdrs, 'CLInclude', Include=os.path.join(proj_to_src_dir, h))
 
         if len(sources) + len(gen_src) + len(pch_sources) > 0:
             inc_src = ET.SubElement(root, 'ItemGroup')
diff --git a/mesonbuild/build.py b/mesonbuild/build.py
index 7909613..702b338 100644
--- a/mesonbuild/build.py
+++ b/mesonbuild/build.py
@@ -36,6 +36,7 @@ pch_kwargs = set(['c_pch', 'cpp_pch'])
 lang_arg_kwargs = set([
     'c_args',
     'cpp_args',
+    'cuda_args',
     'd_args',
     'd_import_dirs',
     'd_unittest',
@@ -797,13 +798,13 @@ just like those detected with the dependency() function.''')
         for linktarget in lwhole:
             self.link_whole(linktarget)
 
-        c_pchlist, cpp_pchlist, clist, cpplist, cslist, valalist,  objclist, objcpplist, fortranlist, rustlist \
-            = extract_as_list(kwargs, 'c_pch', 'cpp_pch', 'c_args', 'cpp_args', 'cs_args', 'vala_args', 'objc_args',
+        c_pchlist, cpp_pchlist, clist, cpplist, cudalist, cslist, valalist,  objclist, objcpplist, fortranlist, rustlist \
+            = extract_as_list(kwargs, 'c_pch', 'cpp_pch', 'c_args', 'cpp_args', 'cuda_args', 'cs_args', 'vala_args', 'objc_args',
                               'objcpp_args', 'fortran_args', 'rust_args')
 
         self.add_pch('c', c_pchlist)
         self.add_pch('cpp', cpp_pchlist)
-        compiler_args = {'c': clist, 'cpp': cpplist, 'cs': cslist, 'vala': valalist, 'objc': objclist, 'objcpp': objcpplist,
+        compiler_args = {'c': clist, 'cpp': cpplist, 'cuda': cudalist, 'cs': cslist, 'vala': valalist, 'objc': objclist, 'objcpp': objcpplist,
                          'fortran': fortranlist, 'rust': rustlist
                          }
         for key, value in compiler_args.items():
diff --git a/mesonbuild/compilers/vala.py b/mesonbuild/compilers/vala.py
index e64d57f..5303298 100644
--- a/mesonbuild/compilers/vala.py
+++ b/mesonbuild/compilers/vala.py
@@ -49,6 +49,12 @@ class ValaCompiler(Compiler):
     def get_pic_args(self):
         return []
 
+    def get_pie_args(self):
+        return []
+
+    def get_pie_link_args(self):
+        return []
+
     def get_always_args(self):
         return ['-C']
 
diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py
index 7bf149f..b23509a 100644
--- a/mesonbuild/environment.py
+++ b/mesonbuild/environment.py
@@ -766,7 +766,22 @@ class Environment:
             except OSError as e:
                 popen_exceptions[' '.join(compiler + [arg])] = e
                 continue
-            version = search_version(out)
+            # Example nvcc printout:
+            #
+            #     nvcc: NVIDIA (R) Cuda compiler driver
+            #     Copyright (c) 2005-2018 NVIDIA Corporation
+            #     Built on Sat_Aug_25_21:08:01_CDT_2018
+            #     Cuda compilation tools, release 10.0, V10.0.130
+            #
+            # search_version() first finds the "10.0" after "release",
+            # rather than the more precise "10.0.130" after "V".
+            # The patch version number is occasionally important; For
+            # instance, on Linux,
+            #    - CUDA Toolkit 8.0.44 requires NVIDIA Driver 367.48
+            #    - CUDA Toolkit 8.0.61 requires NVIDIA Driver 375.26
+            # Luckily, the "V" also makes it very simple to extract
+            # the full version:
+            version = out.strip().split('V')[-1]
             cls = CudaCompiler
             return cls(ccache + compiler, version, is_cross, exe_wrap)
         raise EnvironmentException('Could not find suitable CUDA compiler: "' + ' '.join(compilers) + '"')
diff --git a/mesonbuild/modules/__init__.py b/mesonbuild/modules/__init__.py
index 6b6aa8b..2df4d7c 100644
--- a/mesonbuild/modules/__init__.py
+++ b/mesonbuild/modules/__init__.py
@@ -58,6 +58,10 @@ class GResourceHeaderTarget(build.CustomTarget):
     def __init__(self, name, subdir, subproject, kwargs):
         super().__init__(name, subdir, subproject, kwargs)
 
+class GResourceObjectTarget(build.CustomTarget):
+    def __init__(self, name, subdir, subproject, kwargs):
+        super().__init__(name, subdir, subproject, kwargs)
+
 class GirTarget(build.CustomTarget):
     def __init__(self, name, subdir, subproject, kwargs):
         super().__init__(name, subdir, subproject, kwargs)
diff --git a/mesonbuild/modules/gnome.py b/mesonbuild/modules/gnome.py
index 2d16956..4473bcb 100644
--- a/mesonbuild/modules/gnome.py
+++ b/mesonbuild/modules/gnome.py
@@ -16,6 +16,8 @@
 functionality such as gobject-introspection, gresources and gtk-doc'''
 
 import os
+import re
+import sys
 import copy
 import shlex
 import subprocess
@@ -25,7 +27,7 @@ from .. import mlog
 from .. import mesonlib
 from .. import compilers
 from .. import interpreter
-from . import GResourceTarget, GResourceHeaderTarget, GirTarget, TypelibTarget, VapiTarget
+from . import GResourceTarget, GResourceHeaderTarget, GResourceObjectTarget, GirTarget, TypelibTarget, VapiTarget
 from . import get_include_args
 from . import ExtensionModule
 from . import ModuleReturnValue
@@ -42,6 +44,8 @@ from ..interpreterbase import noKwargs, permittedKwargs, FeatureNew, FeatureNewK
 # https://bugzilla.gnome.org/show_bug.cgi?id=774368
 gresource_dep_needed_version = '>= 2.51.1'
 
+gresource_ld_binary_needed_version = '>= 2.60'
+
 native_glib_version = None
 girwarning_printed = False
 gdbuswarning_printed = False
@@ -166,7 +170,10 @@ class GnomeModule(ExtensionModule):
             cmd += ['--sourcedir', source_dir]
 
         if 'c_name' in kwargs:
-            cmd += ['--c-name', kwargs.pop('c_name')]
+            c_name = kwargs.pop('c_name')
+            cmd += ['--c-name', c_name]
+        else:
+            c_name = None
         export = kwargs.pop('export', False)
         if not export:
             cmd += ['--internal']
@@ -175,13 +182,19 @@ class GnomeModule(ExtensionModule):
 
         cmd += mesonlib.stringlistify(kwargs.pop('extra_args', []))
 
+        gresource_ld_binary = False
+        if mesonlib.is_linux() and mesonlib.version_compare(glib_version, gresource_ld_binary_needed_version) and not state.environment.is_cross_build():
+            ld_obj = self.interpreter.find_program_impl('ld', required=False)
+            if ld_obj.found():
+                gresource_ld_binary = True
+
         gresource = kwargs.pop('gresource_bundle', False)
-        if gresource:
-            output = args[0] + '.gresource'
-            name = args[0] + '_gresource'
-        else:
-            output = args[0] + '.c'
-            name = args[0] + '_c'
+        if gresource or gresource_ld_binary:
+            g_output = args[0] + '.gresource'
+            g_name = args[0] + '_gresource'
+
+        output = args[0] + '.c'
+        name = args[0] + '_c'
 
         if kwargs.get('install', False) and not gresource:
             raise MesonException('The install kwarg only applies to gresource bundles, see install_header')
@@ -195,18 +208,44 @@ class GnomeModule(ExtensionModule):
         kwargs['input'] = args[1]
         kwargs['output'] = output
         kwargs['depends'] = depends
+        if gresource or gresource_ld_binary:
+            g_kwargs = copy.deepcopy(kwargs)
+            g_kwargs['input'] = args[1]
+            g_kwargs['output'] = g_output
+            g_kwargs['depends'] = depends
         if not mesonlib.version_compare(glib_version, gresource_dep_needed_version):
             # This will eventually go out of sync if dependencies are added
             kwargs['depend_files'] = depend_files
-            kwargs['command'] = cmd
+            if gresource_ld_binary:
+                kwargs['command'] = copy.copy(cmd) + ['--external-data']
+            else:
+                kwargs['command'] = cmd
+            if gresource or gresource_ld_binary:
+                # This will eventually go out of sync if dependencies are added
+                g_kwargs['depend_files'] = depend_files
+                g_kwargs['command'] = cmd
         else:
             depfile = kwargs['output'] + '.d'
-            kwargs['depfile'] = depfile
-            kwargs['command'] = copy.copy(cmd) + ['--dependency-file', '@DEPFILE@']
-        target_c = GResourceTarget(name, state.subdir, state.subproject, kwargs)
+            if gresource_ld_binary:
+                depfile2 = kwargs['output'] + '.2.d'
+                kwargs['depfile'] = depfile2
+                kwargs['command'] = copy.copy(cmd) + ['--external-data', '--dependency-file', '@DEPFILE@']
+            else:
+                kwargs['depfile'] = depfile
+                kwargs['command'] = copy.copy(cmd) + ['--dependency-file', '@DEPFILE@']
+            if gresource or gresource_ld_binary:
+                g_kwargs['depfile'] = depfile
+                g_kwargs['command'] = copy.copy(cmd) + ['--dependency-file', '@DEPFILE@']
+
+        if gresource or gresource_ld_binary:
+            target_g = GResourceTarget(g_name, state.subdir, state.subproject, g_kwargs)
+            if gresource: # Only one target for .gresource files
+                if target_g.get_id() not in self.interpreter.build.targets:
+                    return ModuleReturnValue(target_g, [target_g])
+                else:
+                    return ModuleReturnValue(target_g, [])
 
-        if gresource: # Only one target for .gresource files
-            return ModuleReturnValue(target_c, [target_c])
+        target_c = GResourceTarget(name, state.subdir, state.subproject, kwargs)
 
         h_kwargs = {
             'command': cmd,
@@ -222,9 +261,99 @@ class GnomeModule(ExtensionModule):
             h_kwargs['install_dir'] = kwargs.get('install_dir',
                                                  state.environment.coredata.get_builtin_option('includedir'))
         target_h = GResourceHeaderTarget(args[0] + '_h', state.subdir, state.subproject, h_kwargs)
-        rv = [target_c, target_h]
+
+        if gresource_ld_binary:
+            return self._create_gresource_ld_binary_targets(args, state, ifile, ld_obj, c_name, target_g, g_output, target_c, target_h)
+        else:
+            rv = [target_c, target_h]
+
         return ModuleReturnValue(rv, rv)
 
+    def _create_gresource_ld_binary_targets(self, args, state, ifile, ld_obj, c_name, target_g, g_output, target_c, target_h):
+        if c_name is None:
+            # Create proper c identifier from filename in the way glib-compile-resources does
+            c_name = os.path.basename(ifile).partition('.')[0]
+            c_name = c_name.replace('-', '_')
+            c_name = re.sub(r'^([^(_a-zA-Z)])+', '', c_name)
+            c_name = re.sub(r'([^(_a-zA-Z0-9)])', '', c_name)
+
+        c_name_no_underscores = re.sub(r'^_+', '', c_name)
+
+        ld = ld_obj.get_command()
+        objcopy_object = self.interpreter.find_program_impl('objcopy', required=False)
+        if objcopy_object.found():
+            objcopy = objcopy_object.get_command()
+        else:
+            objcopy = None
+
+        o_kwargs = {
+            'command': [ld, '-r', '-b', 'binary', '@INPUT@', '-o', '@OUTPUT@'],
+            'input': target_g,
+            'output': args[0] + '1.o'
+        }
+
+        target_o = GResourceObjectTarget(args[0] + '1_o', state.subdir, state.subproject, o_kwargs)
+
+        builddir = os.path.join(state.environment.get_build_dir(), state.subdir)
+        linkerscript_name = args[0] + '_map.ld'
+        linkerscript_path = os.path.join(builddir, linkerscript_name)
+        linkerscript_file = open(linkerscript_path, 'w')
+
+        # Create symbol name the way bfd does
+        binary_name = os.path.join(state.subdir, g_output)
+        encoding = sys.getfilesystemencoding()
+        symbol_name = re.sub(rb'([^(_a-zA-Z0-9)])', b'_', binary_name.encode(encoding)).decode(encoding)
+
+        linkerscript_string = '''SECTIONS
+{{
+  .gresource.{} : ALIGN(8)
+  {{
+    {}_resource_data = _binary_{}_start;
+  }}
+  .data :
+  {{
+    *(.data)
+  }}
+}}'''.format(c_name_no_underscores, c_name, symbol_name)
+
+        linkerscript_file.write(linkerscript_string)
+
+        o2_kwargs = {
+            'command': [ld, '-r', '-T', os.path.join(state.subdir, linkerscript_name), '@INPUT@', '-o', '@OUTPUT@'],
+            'input': target_o,
+            'output': args[0] + '2.o',
+        }
+        target_o2 = GResourceObjectTarget(args[0] + '2_o', state.subdir, state.subproject, o2_kwargs)
+
+        if objcopy is not None:
+            objcopy_cmd = [objcopy, '--set-section-flags', '.gresource.' + c_name + '=readonly,alloc,load,data']
+            objcopy_cmd += ['-N', '_binary_' + symbol_name + '_start']
+            objcopy_cmd += ['-N', '_binary_' + symbol_name + '_end']
+            objcopy_cmd += ['-N', '_binary_' + symbol_name + '_size']
+            objcopy_cmd += ['@INPUT@', '@OUTPUT@']
+
+            o3_kwargs = {
+                'command': objcopy_cmd,
+                'input': target_o2,
+                'output': args[0] + '3.o'
+            }
+
+            target_o3 = GResourceObjectTarget(args[0] + '3_o', state.subdir, state.subproject, o3_kwargs)
+
+            rv1 = [target_c, target_h, target_o3]
+            if target_g.get_id() not in self.interpreter.build.targets:
+                rv2 = rv1 + [target_g, target_o, target_o2]
+            else:
+                rv2 = rv1 + [target_o, target_o2]
+        else:
+            rv1 = [target_c, target_h, target_o2]
+            if target_g.get_id() not in self.interpreter.build.targets:
+                rv2 = rv1 + [target_g, target_o]
+            else:
+                rv2 = rv1 + [target_o]
+
+        return ModuleReturnValue(rv1, rv2)
+
     def _get_gresource_dependencies(self, state, input_file, source_dirs, dependencies):
 
         cmd = ['glib-compile-resources',
diff --git a/mesonbuild/modules/python.py b/mesonbuild/modules/python.py
index 1d41165..049c457 100644
--- a/mesonbuild/modules/python.py
+++ b/mesonbuild/modules/python.py
@@ -60,6 +60,7 @@ class PythonDependency(ExternalDependency):
         self.pkgdep = None
         self.variables = python_holder.variables
         self.paths = python_holder.paths
+        self.link_libpython = python_holder.link_libpython
         if mesonlib.version_compare(self.version, '>= 3.0'):
             self.major_version = 3
         else:
@@ -149,11 +150,11 @@ class PythonDependency(ExternalDependency):
             libdirs = []
 
         largs = self.clib_compiler.find_library(libname, environment, libdirs)
-
-        self.is_found = largs is not None
-        if self.is_found:
+        if largs is not None:
             self.link_args = largs
 
+        self.is_found = largs is not None or not self.link_libpython
+
         inc_paths = mesonlib.OrderedSet([
             self.variables.get('INCLUDEPY'),
             self.paths.get('include'),
diff --git a/mesonbuild/modules/unstable_cuda.py b/mesonbuild/modules/unstable_cuda.py
new file mode 100644
index 0000000..941b15a
--- /dev/null
+++ b/mesonbuild/modules/unstable_cuda.py
@@ -0,0 +1,259 @@
+# Copyright 2017 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+
+from ..mesonlib import version_compare
+from ..interpreter import CompilerHolder
+from ..compilers import CudaCompiler
+
+from . import ExtensionModule, ModuleReturnValue
+
+from ..interpreterbase import (
+    flatten, permittedKwargs, noKwargs,
+    InvalidArguments, FeatureNew
+)
+
+class CudaModule(ExtensionModule):
+
+    @FeatureNew('CUDA module', '0.50.0')
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @noKwargs
+    def min_driver_version(self, state, args, kwargs):
+        argerror = InvalidArguments('min_driver_version must have exactly one positional argument: ' +
+                                    'an NVCC compiler object, or its version string.')
+
+        if len(args) != 1:
+            raise argerror
+        else:
+            cuda_version = self._version_from_compiler(args[0])
+            if cuda_version == 'unknown':
+                raise argerror
+
+        driver_version_table = [
+            {'cuda_version': '>=10.0.130', 'windows': '411.31', 'linux': '410.48'},
+            {'cuda_version': '>=9.2.148',  'windows': '398.26', 'linux': '396.37'},
+            {'cuda_version': '>=9.2.88',   'windows': '397.44', 'linux': '396.26'},
+            {'cuda_version': '>=9.1.85',   'windows': '391.29', 'linux': '390.46'},
+            {'cuda_version': '>=9.0.76',   'windows': '385.54', 'linux': '384.81'},
+            {'cuda_version': '>=8.0.61',   'windows': '376.51', 'linux': '375.26'},
+            {'cuda_version': '>=8.0.44',   'windows': '369.30', 'linux': '367.48'},
+            {'cuda_version': '>=7.5.16',   'windows': '353.66', 'linux': '352.31'},
+            {'cuda_version': '>=7.0.28',   'windows': '347.62', 'linux': '346.46'},
+        ]
+
+        driver_version = 'unknown'
+        for d in driver_version_table:
+            if version_compare(cuda_version, d['cuda_version']):
+                driver_version = d.get(state.host_machine.system, d['linux'])
+                break
+
+        return ModuleReturnValue(driver_version, [driver_version])
+
+    @permittedKwargs(['detected'])
+    def nvcc_arch_flags(self, state, args, kwargs):
+        nvcc_arch_args = self._validate_nvcc_arch_args(state, args, kwargs)
+        ret = self._nvcc_arch_flags(*nvcc_arch_args)[0]
+        return ModuleReturnValue(ret, [ret])
+
+    @permittedKwargs(['detected'])
+    def nvcc_arch_readable(self, state, args, kwargs):
+        nvcc_arch_args = self._validate_nvcc_arch_args(state, args, kwargs)
+        ret = self._nvcc_arch_flags(*nvcc_arch_args)[1]
+        return ModuleReturnValue(ret, [ret])
+
+    @staticmethod
+    def _break_arch_string(s):
+        s = re.sub('[ \t,;]+', ';', s)
+        s = s.strip(';').split(';')
+        return s
+
+    @staticmethod
+    def _version_from_compiler(c):
+        if isinstance(c, CompilerHolder):
+            c = c.compiler
+        if isinstance(c, CudaCompiler):
+            return c.version
+        if isinstance(c, str):
+            return c
+        return 'unknown'
+
+    def _validate_nvcc_arch_args(self, state, args, kwargs):
+        argerror = InvalidArguments('The first argument must be an NVCC compiler object, or its version string!')
+
+        if len(args) < 1:
+            raise argerror
+        else:
+            cuda_version = self._version_from_compiler(args[0])
+            if cuda_version == 'unknown':
+                raise argerror
+
+        arch_list = [] if len(args) <= 1 else flatten(args[1:])
+        arch_list = [self._break_arch_string(a) for a in arch_list]
+        arch_list = flatten(arch_list)
+        if len(arch_list) > 1 and not set(arch_list).isdisjoint({'All', 'Common', 'Auto'}):
+            raise InvalidArguments('''The special architectures 'All', 'Common' and 'Auto' must appear alone, as a positional argument!''')
+        arch_list = arch_list[0] if len(arch_list) == 1 else arch_list
+
+        detected = flatten([kwargs.get('detected', [])])
+        detected = [self._break_arch_string(a) for a in detected]
+        detected = flatten(detected)
+        if not set(detected).isdisjoint({'All', 'Common', 'Auto'}):
+            raise InvalidArguments('''The special architectures 'All', 'Common' and 'Auto' must appear alone, as a positional argument!''')
+
+        return cuda_version, arch_list, detected
+
+    def _nvcc_arch_flags(self, cuda_version, cuda_arch_list='Auto', detected=''):
+        """
+        Using the CUDA Toolkit version (the NVCC version) and the target
+        architectures, compute the NVCC architecture flags.
+        """
+
+        cuda_known_gpu_architectures  = ['Fermi', 'Kepler', 'Maxwell']  # noqa: E221
+        cuda_common_gpu_architectures = ['3.0', '3.5', '5.0']           # noqa: E221
+        cuda_limit_gpu_architecture   = None                            # noqa: E221
+        cuda_all_gpu_architectures    = ['3.0', '3.2', '3.5', '5.0']    # noqa: E221
+
+        if version_compare(cuda_version, '<7.0'):
+            cuda_limit_gpu_architecture = '5.2'
+
+        if version_compare(cuda_version, '>=7.0'):
+            cuda_known_gpu_architectures  += ['Kepler+Tegra', 'Kepler+Tesla', 'Maxwell+Tegra']  # noqa: E221
+            cuda_common_gpu_architectures += ['5.2']                                            # noqa: E221
+
+            if version_compare(cuda_version, '<8.0'):
+                cuda_common_gpu_architectures += ['5.2+PTX']  # noqa: E221
+                cuda_limit_gpu_architecture    = '6.0'        # noqa: E221
+
+        if version_compare(cuda_version, '>=8.0'):
+            cuda_known_gpu_architectures  += ['Pascal', 'Pascal+Tegra']  # noqa: E221
+            cuda_common_gpu_architectures += ['6.0', '6.1']              # noqa: E221
+            cuda_all_gpu_architectures    += ['6.0', '6.1', '6.2']       # noqa: E221
+
+            if version_compare(cuda_version, '<9.0'):
+                cuda_common_gpu_architectures += ['6.1+PTX']  # noqa: E221
+                cuda_limit_gpu_architecture    = '7.0'        # noqa: E221
+
+        if version_compare(cuda_version, '>=9.0'):
+            cuda_known_gpu_architectures  += ['Volta', 'Volta+Tegra']              # noqa: E221
+            cuda_common_gpu_architectures += ['7.0', '7.0+PTX']                    # noqa: E221
+            cuda_all_gpu_architectures    += ['7.0', '7.0+PTX', '7.2', '7.2+PTX']  # noqa: E221
+
+            if version_compare(cuda_version, '<10.0'):
+                cuda_limit_gpu_architecture = '7.5'
+
+        if version_compare(cuda_version, '>=10.0'):
+            cuda_known_gpu_architectures  += ['Turing']          # noqa: E221
+            cuda_common_gpu_architectures += ['7.5', '7.5+PTX']  # noqa: E221
+            cuda_all_gpu_architectures    += ['7.5', '7.5+PTX']  # noqa: E221
+
+            if version_compare(cuda_version, '<11.0'):
+                cuda_limit_gpu_architecture = '8.0'
+
+        if not cuda_arch_list:
+            cuda_arch_list = 'Auto'
+
+        if   cuda_arch_list == 'All':     # noqa: E271
+            cuda_arch_list = cuda_known_gpu_architectures
+        elif cuda_arch_list == 'Common':  # noqa: E271
+            cuda_arch_list = cuda_common_gpu_architectures
+        elif cuda_arch_list == 'Auto':    # noqa: E271
+            if detected:
+                if isinstance(detected, list):
+                    cuda_arch_list = detected
+                else:
+                    cuda_arch_list = self._break_arch_string(detected)
+
+                if cuda_limit_gpu_architecture:
+                    filtered_cuda_arch_list = []
+                    for arch in cuda_arch_list:
+                        if arch:
+                            if version_compare(arch, '>=' + cuda_limit_gpu_architecture):
+                                arch = cuda_common_gpu_architectures[-1]
+                            if arch not in filtered_cuda_arch_list:
+                                filtered_cuda_arch_list.append(arch)
+                    cuda_arch_list = filtered_cuda_arch_list
+            else:
+                cuda_arch_list = cuda_common_gpu_architectures
+        elif isinstance(cuda_arch_list, str):
+            cuda_arch_list = self._break_arch_string(cuda_arch_list)
+
+        cuda_arch_list = sorted([x for x in set(cuda_arch_list) if x])
+
+        cuda_arch_bin = []
+        cuda_arch_ptx = []
+        for arch_name in cuda_arch_list:
+            arch_bin = []
+            arch_ptx = []
+            add_ptx = arch_name.endswith('+PTX')
+            if add_ptx:
+                arch_name = arch_name[:-len('+PTX')]
+
+            if re.fullmatch('[0-9]+\\.[0-9](\\([0-9]+\\.[0-9]\\))?', arch_name):
+                arch_bin, arch_ptx = [arch_name], [arch_name]
+            else:
+                arch_bin, arch_ptx = {
+                    'Fermi':         (['2.0', '2.1(2.0)'], []),
+                    'Kepler+Tegra':  (['3.2'],             []),
+                    'Kepler+Tesla':  (['3.7'],             []),
+                    'Kepler':        (['3.0', '3.5'],      ['3.5']),
+                    'Maxwell+Tegra': (['5.3'],             []),
+                    'Maxwell':       (['5.0', '5.2'],      ['5.2']),
+                    'Pascal':        (['6.0', '6.1'],      ['6.1']),
+                    'Pascal+Tegra':  (['6.2'],             []),
+                    'Volta':         (['7.0'],             ['7.0']),
+                    'Volta+Tegra':   (['7.2'],             []),
+                    'Turing':        (['7.5'],             ['7.5']),
+                }.get(arch_name, (None, None))
+
+            if arch_bin is None:
+                raise InvalidArguments('Unknown CUDA Architecture Name {}!'
+                                       .format(arch_name))
+
+            cuda_arch_bin += arch_bin
+
+            if add_ptx:
+                if not arch_ptx:
+                    arch_ptx = arch_bin
+                cuda_arch_ptx += arch_ptx
+
+        cuda_arch_bin = re.sub('\\.', '', ' '.join(cuda_arch_bin))
+        cuda_arch_ptx = re.sub('\\.', '', ' '.join(cuda_arch_ptx))
+        cuda_arch_bin = re.findall('[0-9()]+', cuda_arch_bin)
+        cuda_arch_ptx = re.findall('[0-9]+',   cuda_arch_ptx)
+        cuda_arch_bin = sorted(list(set(cuda_arch_bin)))
+        cuda_arch_ptx = sorted(list(set(cuda_arch_ptx)))
+
+        nvcc_flags = []
+        nvcc_archs_readable = []
+
+        for arch in cuda_arch_bin:
+            m = re.match('([0-9]+)\\(([0-9]+)\\)', arch)
+            if m:
+                nvcc_flags += ['-gencode', 'arch=compute_' + m[2] + ',code=sm_' + m[1]]
+                nvcc_archs_readable += ['sm_' + m[1]]
+            else:
+                nvcc_flags += ['-gencode', 'arch=compute_' + arch + ',code=sm_' + arch]
+                nvcc_archs_readable += ['sm_' + arch]
+
+        for arch in cuda_arch_ptx:
+            nvcc_flags += ['-gencode', 'arch=compute_' + arch + ',code=compute_' + arch]
+            nvcc_archs_readable += ['compute_' + arch]
+
+        return nvcc_flags, nvcc_archs_readable
+
+def initialize(*args, **kwargs):
+    return CudaModule(*args, **kwargs)
diff --git a/run_unittests.py b/run_unittests.py
index fb6cacf..a244bbd 100755
--- a/run_unittests.py
+++ b/run_unittests.py
@@ -3351,7 +3351,7 @@ recommended as it is not supported on some platforms''')
         # Check buildsystem_files
         bs_files = ['meson.build', 'sharedlib/meson.build', 'staticlib/meson.build']
         bs_files = [os.path.join(testdir, x) for x in bs_files]
-        self.assertPathListEqual(res['buildsystem_files'], bs_files)
+        self.assertPathListEqual(list(sorted(res['buildsystem_files'])), list(sorted(bs_files)))
 
         # Check dependencies
         dependencies_to_find = ['threads']
diff --git a/test cases/cuda/3 cudamodule/meson.build b/test cases/cuda/3 cudamodule/meson.build
new file mode 100644
index 0000000..0dc9489
--- /dev/null
+++ b/test cases/cuda/3 cudamodule/meson.build
@@ -0,0 +1,16 @@
+project('cudamodule', 'cuda', version : '1.0.0')
+
+nvcc = meson.get_compiler('cuda')
+cuda = import('unstable-cuda')
+
+arch_flags     = cuda.nvcc_arch_flags(nvcc, 'Auto', detected: ['3.0'])
+arch_readable  = cuda.nvcc_arch_readable(nvcc, 'Auto', detected: ['3.0'])
+driver_version = cuda.min_driver_version(nvcc)
+
+message('NVCC version:   ' + nvcc.version())
+message('NVCC flags:     ' + ' '.join(arch_flags))
+message('NVCC readable:  ' + ' '.join(arch_readable))
+message('Driver version: >=' + driver_version)
+
+exe = executable('prog', 'prog.cu', cuda_args: arch_flags)
+test('cudatest', exe)
diff --git a/test cases/cuda/3 cudamodule/prog.cu b/test cases/cuda/3 cudamodule/prog.cu
new file mode 100644
index 0000000..7eab673
--- /dev/null
+++ b/test cases/cuda/3 cudamodule/prog.cu
@@ -0,0 +1,30 @@
+#include <iostream>
+
+int main(int argc, char **argv) {
+    int cuda_devices = 0;
+    std::cout << "CUDA version: " << CUDART_VERSION << "\n";
+    cudaGetDeviceCount(&cuda_devices);
+    if(cuda_devices == 0) {
+        std::cout << "No Cuda hardware found. Exiting.\n";
+        return 0;
+    }
+    std::cout << "This computer has " << cuda_devices << " Cuda device(s).\n";
+    cudaDeviceProp props;
+    cudaGetDeviceProperties(&props, 0);
+    std::cout << "Properties of device 0.\n\n";
+
+    std::cout << "  Name:            " << props.name << "\n";
+    std::cout << "  Global memory:   " << props.totalGlobalMem << "\n";
+    std::cout << "  Shared memory:   " << props.sharedMemPerBlock << "\n";
+    std::cout << "  Constant memory: " << props.totalConstMem << "\n";
+    std::cout << "  Block registers: " << props.regsPerBlock << "\n";
+
+    std::cout << "  Warp size:         " << props.warpSize << "\n";
+    std::cout << "  Threads per block: " << props.maxThreadsPerBlock << "\n";
+    std::cout << "  Max block dimensions: [ " << props.maxThreadsDim[0] << ", " << props.maxThreadsDim[1]  << ", " << props.maxThreadsDim[2] << " ]" << "\n";
+    std::cout << "  Max grid dimensions:  [ " << props.maxGridSize[0] << ", " << props.maxGridSize[1]  << ", " << props.maxGridSize[2] << " ]" << "\n";
+    std::cout << "\n";
+
+    return 0;
+}
+