Convert buildtype to optimization and debug options (#3489)

9 files changed, 239 insertions, 40 deletions

diff --git a/mesonbuild/compilers/c.py b/mesonbuild/compilers/c.py
index 1a0d6b2..c7092b8 100644
--- a/mesonbuild/compilers/c.py
+++ b/mesonbuild/compilers/c.py
@@ -30,8 +30,6 @@ from .compilers import (
     GCC_MINGW,
     get_largefile_args,
     gnu_winlibs,
-    msvc_buildtype_args,
-    msvc_buildtype_linker_args,
     msvc_winlibs,
     vs32_instruction_set_args,
     vs64_instruction_set_args,
@@ -1197,6 +1195,13 @@ class VisualStudioCCompiler(CCompiler):
     ignore_libs = gnu_compiler_internal_libs
     internal_libs = ()
 
+    crt_args = {'none': [],
+                'md': ['/MD'],
+                'mdd': ['/MDd'],
+                'mt': ['/MT'],
+                'mtd': ['/MTd'],
+                }
+
     def __init__(self, exelist, version, is_cross, exe_wrap, is_64):
         CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
         self.id = 'msvc'
@@ -1206,7 +1211,7 @@ class VisualStudioCCompiler(CCompiler):
         self.warn_args = {'1': ['/W2'],
                           '2': ['/W3'],
                           '3': ['/W4']}
-        self.base_options = ['b_pch', 'b_ndebug'] # FIXME add lto, pgo and the like
+        self.base_options = ['b_pch', 'b_ndebug', 'b_vscrt'] # FIXME add lto, pgo and the like
         self.is_64 = is_64
 
     # Override CCompiler.get_always_args
@@ -1225,10 +1230,10 @@ class VisualStudioCCompiler(CCompiler):
         return ['/MDd']
 
     def get_buildtype_args(self, buildtype):
-        return msvc_buildtype_args[buildtype]
+        return compilers.msvc_buildtype_args[buildtype]
 
     def get_buildtype_linker_args(self, buildtype):
-        return msvc_buildtype_linker_args[buildtype]
+        return compilers.msvc_buildtype_linker_args[buildtype]
 
     def get_pch_suffix(self):
         return 'pch'
@@ -1258,6 +1263,12 @@ class VisualStudioCCompiler(CCompiler):
             return ['/Fe' + target]
         return ['/Fo' + target]
 
+    def get_optimization_args(self, optimization_level):
+        return compilers.msvc_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug):
+        return compilers.msvc_debug_args[is_debug]
+
     def get_dependency_gen_args(self, outtarget, outfile):
         return []
 
@@ -1440,6 +1451,24 @@ class VisualStudioCCompiler(CCompiler):
             return []
         return os.environ['INCLUDE'].split(os.pathsep)
 
+    def get_crt_compile_args(self, crt_val, buildtype):
+        if crt_val in self.crt_args:
+            return self.crt_args[crt_val]
+        assert(crt_val == 'from_buildtype')
+        # Match what build type flags used to do.
+        if buildtype == 'plain':
+            return []
+        elif buildtype == 'debug':
+            return self.crt_args['mdd']
+        elif buildtype == 'debugoptimized':
+            return self.crt_args['md']
+        elif buildtype == 'release':
+            return self.crt_args['md']
+        elif buildtype == 'minsize':
+            return self.crt_args['md']
+        else:
+            assert(buildtype == 'custom')
+            raise EnvironmentException('Requested C runtime based on buildtype, but buildtype is "custom".')
 
 class ArmCCompiler(ArmCompiler, CCompiler):
     def __init__(self, exelist, version, is_cross, exe_wrapper=None, **kwargs):
diff --git a/mesonbuild/compilers/compilers.py b/mesonbuild/compilers/compilers.py
index 97cca47..b8ae399 100644
--- a/mesonbuild/compilers/compilers.py
+++ b/mesonbuild/compilers/compilers.py
@@ -124,12 +124,10 @@ def is_library(fname):
     return suffix in lib_suffixes
 
 gnulike_buildtype_args = {'plain': [],
-                          # -O0 is passed for improved debugging information with gcc
-                          # See https://github.com/mesonbuild/meson/pull/509
-                          'debug': ['-O0', '-g'],
-                          'debugoptimized': ['-O2', '-g'],
-                          'release': ['-O3'],
-                          'minsize': ['-Os', '-g']}
+                          'debug': [],
+                          'debugoptimized': [],
+                          'release': [],
+                          'minsize': []}
 
 armclang_buildtype_args = {'plain': [],
                            'debug': ['-O0', '-g'],
@@ -145,10 +143,10 @@ arm_buildtype_args = {'plain': [],
                       }
 
 msvc_buildtype_args = {'plain': [],
-                       'debug': ["/MDd", "/ZI", "/Ob0", "/Od", "/RTC1"],
-                       'debugoptimized': ["/MD", "/Zi", "/O2", "/Ob1"],
-                       'release': ["/MD", "/O2", "/Ob2"],
-                       'minsize': ["/MD", "/Zi", "/Os", "/Ob1"],
+                       'debug': ["/ZI", "/Ob0", "/Od", "/RTC1"],
+                       'debugoptimized': ["/Zi", "/Ob1"],
+                       'release': ["/Ob2"],
+                       'minsize': ["/Zi", "/Ob1"],
                        }
 
 apple_buildtype_linker_args = {'plain': [],
@@ -190,44 +188,44 @@ java_buildtype_args = {'plain': [],
                        }
 
 rust_buildtype_args = {'plain': [],
-                       'debug': ['-C', 'debuginfo=2'],
-                       'debugoptimized': ['-C', 'debuginfo=2', '-C', 'opt-level=2'],
-                       'release': ['-C', 'opt-level=3'],
-                       'minsize': [], # In a future release: ['-C', 'opt-level=s'],
+                       'debug': [],
+                       'debugoptimized': [],
+                       'release': [],
+                       'minsize': [],
                        }
 
 d_gdc_buildtype_args = {'plain': [],
-                        'debug': ['-g', '-O0'],
-                        'debugoptimized': ['-g', '-O'],
+                        'debug': [],
+                        'debugoptimized': ['-O'],
                         'release': ['-O3', '-frelease'],
                         'minsize': [],
                         }
 
 d_ldc_buildtype_args = {'plain': [],
-                        'debug': ['-g', '-O0'],
-                        'debugoptimized': ['-g', '-O'],
+                        'debug': [],
+                        'debugoptimized': ['-O'],
                         'release': ['-O3', '-release'],
                         'minsize': [],
                         }
 
 d_dmd_buildtype_args = {'plain': [],
-                        'debug': ['-g'],
-                        'debugoptimized': ['-g', '-O'],
+                        'debug': [],
+                        'debugoptimized': ['-O'],
                         'release': ['-O', '-release'],
                         'minsize': [],
                         }
 
 mono_buildtype_args = {'plain': [],
-                       'debug': ['-debug'],
-                       'debugoptimized': ['-debug', '-optimize+'],
+                       'debug': [],
+                       'debugoptimized': ['-optimize+'],
                        'release': ['-optimize+'],
                        'minsize': [],
                        }
 
 swift_buildtype_args = {'plain': [],
-                        'debug': ['-g'],
-                        'debugoptimized': ['-g', '-O'],
-                        'release': ['-O'],
+                        'debug': [],
+                        'debugoptimized': [],
+                        'release': [],
                         'minsize': [],
                         }
 
@@ -248,6 +246,36 @@ clang_color_args = {'auto': ['-Xclang', '-fcolor-diagnostics'],
                     'never': ['-Xclang', '-fno-color-diagnostics'],
                     }
 
+clike_optimization_args = {'0': [],
+                           'g': [],
+                           '1': ['-O1'],
+                           '2': ['-O2'],
+                           '3': ['-O3'],
+                           's': ['-Os'],
+                           }
+
+gnu_optimization_args = {'0': [],
+                         'g': ['-Og'],
+                         '1': ['-O1'],
+                         '2': ['-O2'],
+                         '3': ['-O3'],
+                         's': ['-Os'],
+                         }
+
+msvc_optimization_args = {'0': [],
+                          'g': ['/O0'],
+                          '1': ['/O1'],
+                          '2': ['/O2'],
+                          '3': ['/O3'],
+                          's': ['/Os'],
+                          }
+
+clike_debug_args = {False: [],
+                    True: ['-g']}
+
+msvc_debug_args = {False: [],
+                   True: []} # Fixme!
+
 base_options = {'b_pch': coredata.UserBooleanOption('b_pch', 'Use precompiled headers', True),
                 'b_lto': coredata.UserBooleanOption('b_lto', 'Use link time optimization', False),
                 'b_sanitize': coredata.UserComboOption('b_sanitize',
@@ -273,6 +301,9 @@ base_options = {'b_pch': coredata.UserBooleanOption('b_pch', 'Use precompiled he
                 'b_bitcode': coredata.UserBooleanOption('b_bitcode',
                                                         'Generate and embed bitcode (only macOS and iOS)',
                                                         False),
+                'b_vscrt': coredata.UserComboOption('b_vscrt', 'VS run-time library type to use.',
+                                                    ['none', 'md', 'mdd', 'mt', 'mtd', 'from_buildtype'],
+                                                    'from_buildtype'),
                 }
 
 gnulike_instruction_set_args = {'mmx': ['-mmmx'],
@@ -380,6 +411,15 @@ def get_base_compile_args(options, compiler):
     # This does not need a try...except
     if option_enabled(compiler.base_options, options, 'b_bitcode'):
         args.append('-fembed-bitcode')
+    try:
+        crt_val = options['b_vscrt'].value
+        buildtype = options['buildtype'].value
+        try:
+            args += compiler.get_crt_compile_args(crt_val, buildtype)
+        except AttributeError:
+            pass
+    except KeyError:
+        pass
     return args
 
 def get_base_link_args(options, linker, is_shared_module):
@@ -1250,6 +1290,12 @@ class GnuCompiler:
     def get_buildtype_args(self, buildtype):
         return gnulike_buildtype_args[buildtype]
 
+    def get_optimization_args(self, optimization_level):
+        return gnu_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug):
+        return clike_debug_args[is_debug]
+
     def get_buildtype_linker_args(self, buildtype):
         if self.gcc_type == GCC_OSX:
             return apple_buildtype_linker_args[buildtype]
@@ -1371,6 +1417,12 @@ class ClangCompiler:
             return apple_buildtype_linker_args[buildtype]
         return gnulike_buildtype_linker_args[buildtype]
 
+    def get_optimization_args(self, optimization_level):
+        return clike_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug):
+        return clike_debug_args[is_debug]
+
     def get_pch_suffix(self):
         return 'pch'
 
diff --git a/mesonbuild/compilers/cpp.py b/mesonbuild/compilers/cpp.py
index 2280f46..6483e54 100644
--- a/mesonbuild/compilers/cpp.py
+++ b/mesonbuild/compilers/cpp.py
@@ -242,7 +242,7 @@ class VisualStudioCPPCompiler(VisualStudioCCompiler, CPPCompiler):
     def __init__(self, exelist, version, is_cross, exe_wrap, is_64):
         CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
         VisualStudioCCompiler.__init__(self, exelist, version, is_cross, exe_wrap, is_64)
-        self.base_options = ['b_pch'] # FIXME add lto, pgo and the like
+        self.base_options = ['b_pch', 'b_vscrt'] # FIXME add lto, pgo and the like
 
     def get_options(self):
         opts = CPPCompiler.get_options(self)
diff --git a/mesonbuild/compilers/cs.py b/mesonbuild/compilers/cs.py
index e17cd4e..a6c74d2 100644
--- a/mesonbuild/compilers/cs.py
+++ b/mesonbuild/compilers/cs.py
@@ -19,6 +19,14 @@ from ..mesonlib import is_windows
 
 from .compilers import Compiler, mono_buildtype_args
 
+cs_optimization_args = {'0': [],
+                        'g': [],
+                        '1': ['-optimize+'],
+                        '2': ['-optimize+'],
+                        '3': ['-optimize+'],
+                        's': ['-optimize+'],
+                        }
+
 class CsCompiler(Compiler):
     def __init__(self, exelist, version, id, runner=None):
         self.language = 'cs'
@@ -118,6 +126,11 @@ class CsCompiler(Compiler):
     def get_buildtype_args(self, buildtype):
         return mono_buildtype_args[buildtype]
 
+    def get_debug_args(self, is_debug):
+        return ['-debug'] if is_debug else []
+
+    def get_optimization_args(self, optimization_level):
+        return cs_optimization_args[optimization_level]
 
 class MonoCompiler(CsCompiler):
     def __init__(self, exelist, version):
diff --git a/mesonbuild/compilers/d.py b/mesonbuild/compilers/d.py
index f0f3d54..93dca0e 100644
--- a/mesonbuild/compilers/d.py
+++ b/mesonbuild/compilers/d.py
@@ -23,6 +23,8 @@ from .compilers import (
     d_ldc_buildtype_args,
     get_gcc_soname_args,
     gnu_color_args,
+    gnu_optimization_args,
+    clike_debug_args,
     Compiler,
     CompilerArgs,
 )
@@ -41,6 +43,22 @@ d_feature_args = {'gcc':  {'unittest': '-funittest',
                            }
                   }
 
+ldc_optimization_args = {'0': [],
+                         'g': [],
+                         '1': ['-O1'],
+                         '2': ['-O2'],
+                         '3': ['-O3'],
+                         's': ['-Os'],
+                         }
+
+dmd_optimization_args = {'0': [],
+                         'g': [],
+                         '1': ['-O1'],
+                         '2': ['-O2'],
+                         '3': ['-O3'],
+                         's': ['-Os'],
+                         }
+
 class DCompiler(Compiler):
     def __init__(self, exelist, version, is_cross, **kwargs):
         self.language = 'd'
@@ -238,6 +256,8 @@ class DCompiler(Compiler):
 
         return dcargs
 
+    def get_debug_args(self, is_debug):
+        return clike_debug_args[is_debug]
 
 class GnuDCompiler(DCompiler):
     def __init__(self, exelist, version, is_cross, **kwargs):
@@ -288,6 +308,8 @@ class GnuDCompiler(DCompiler):
     def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
         return self.build_unix_rpath_args(build_dir, from_dir, rpath_paths, build_rpath, install_rpath)
 
+    def get_optimization_args(self, optimization_level):
+        return gnu_optimization_args[optimization_level]
 
 class LLVMDCompiler(DCompiler):
     def __init__(self, exelist, version, is_cross, **kwargs):
@@ -342,6 +364,9 @@ class LLVMDCompiler(DCompiler):
     def unix_args_to_native(cls, args):
         return cls.translate_args_to_nongnu(args)
 
+    def get_optimization_args(self, optimization_level):
+        return ldc_optimization_args[optimization_level]
+
 
 class DmdDCompiler(DCompiler):
     def __init__(self, exelist, version, is_cross, **kwargs):
@@ -392,3 +417,6 @@ class DmdDCompiler(DCompiler):
     @classmethod
     def unix_args_to_native(cls, args):
         return cls.translate_args_to_nongnu(args)
+
+    def get_optimization_args(self, optimization_level):
+        return dmd_optimization_args[optimization_level]
diff --git a/mesonbuild/compilers/fortran.py b/mesonbuild/compilers/fortran.py
index d6e41e3..5648a6f 100644
--- a/mesonbuild/compilers/fortran.py
+++ b/mesonbuild/compilers/fortran.py
@@ -15,12 +15,20 @@
 from .c import CCompiler
 from .compilers import (
     ICC_STANDARD,
+    apple_buildtype_linker_args,
+    gnulike_buildtype_args,
+    gnulike_buildtype_linker_args,
+    gnu_optimization_args,
+    clike_debug_args,
     Compiler,
     GnuCompiler,
     ElbrusCompiler,
     IntelCompiler,
 )
 
+from mesonbuild.mesonlib import EnvironmentException, is_osx
+import subprocess, os
+
 class FortranCompiler(Compiler):
     library_dirs_cache = CCompiler.library_dirs_cache
     program_dirs_cache = CCompiler.library_dirs_cache
@@ -61,6 +69,48 @@ class FortranCompiler(Compiler):
     def get_soname_args(self, *args):
         return CCompiler.get_soname_args(self, *args)
 
+    def sanity_check(self, work_dir, environment):
+        source_name = os.path.join(work_dir, 'sanitycheckf.f90')
+        binary_name = os.path.join(work_dir, 'sanitycheckf')
+        with open(source_name, 'w') as ofile:
+            ofile.write('''program prog
+     print *, "Fortran compilation is working."
+end program prog
+''')
+        extra_flags = self.get_cross_extra_flags(environment, link=True)
+        pc = subprocess.Popen(self.exelist + extra_flags + [source_name, '-o', binary_name])
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
+        if self.is_cross:
+            if self.exe_wrapper is None:
+                # Can't check if the binaries run so we have to assume they do
+                return
+            cmdlist = self.exe_wrapper + [binary_name]
+        else:
+            cmdlist = [binary_name]
+        pe = subprocess.Popen(cmdlist, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException('Executables created by Fortran compiler %s are not runnable.' % self.name_string())
+
+    def get_std_warn_args(self, level):
+        return FortranCompiler.std_warn_args
+
+    def get_buildtype_args(self, buildtype):
+        return gnulike_buildtype_args[buildtype]
+
+    def get_optimization_args(self, optimization_level):
+        return gnu_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug):
+        return clike_debug_args[is_debug]
+
+    def get_buildtype_linker_args(self, buildtype):
+        if is_osx():
+            return apple_buildtype_linker_args[buildtype]
+        return gnulike_buildtype_linker_args[buildtype]
+
     def split_shlib_to_parts(self, fname):
         return CCompiler.split_shlib_to_parts(self, fname)
 
@@ -151,13 +201,6 @@ class FortranCompiler(Compiler):
     def gen_import_library_args(self, implibname):
         return CCompiler.gen_import_library_args(self, implibname)
 
-    def sanity_check(self, work_dir, environment):
-        code = '''program main
-            integer :: ret = 0
-            call exit(ret)
-        end program main'''
-        return CCompiler.sanity_check_impl(self, work_dir, environment, 'sanitycheckf.f90', code)
-
     def _get_compiler_check_args(self, env, extra_args, dependencies, mode='compile'):
         return CCompiler._get_compiler_check_args(self, env, extra_args, dependencies, mode='compile')
 
diff --git a/mesonbuild/compilers/rust.py b/mesonbuild/compilers/rust.py
index d1a05ed..93c2917 100644
--- a/mesonbuild/compilers/rust.py
+++ b/mesonbuild/compilers/rust.py
@@ -16,7 +16,15 @@ import subprocess, os.path
 
 from ..mesonlib import EnvironmentException, Popen_safe
 
-from .compilers import Compiler, rust_buildtype_args
+from .compilers import Compiler, rust_buildtype_args, clike_debug_args
+
+rust_optimization_args = {'0': [],
+                          'g': ['-C', '--opt-level=0'],
+                          '1': ['-C', '--opt-level=1'],
+                          '2': ['-C', '--opt-level=2'],
+                          '3': ['-C', '--opt-level=3'],
+                          's': ['-C', '--opt-level=s'],
+                          }
 
 class RustCompiler(Compiler):
     def __init__(self, exelist, version, is_cross, exe_wrapper=None):
@@ -68,3 +76,9 @@ class RustCompiler(Compiler):
         cmd = self.exelist + ['--print', 'sysroot']
         p, stdo, stde = Popen_safe(cmd)
         return stdo.split('\n')[0]
+
+    def get_debug_args(self, is_debug):
+        return clike_debug_args[is_debug]
+
+    def get_optimization_args(self, optimization_level):
+        return rust_optimization_args[optimization_level]
diff --git a/mesonbuild/compilers/swift.py b/mesonbuild/compilers/swift.py
index 59997d6..4d5dd0c 100644
--- a/mesonbuild/compilers/swift.py
+++ b/mesonbuild/compilers/swift.py
@@ -16,7 +16,15 @@ import subprocess, os.path
 
 from ..mesonlib import EnvironmentException
 
-from .compilers import Compiler, swift_buildtype_args
+from .compilers import Compiler, swift_buildtype_args, clike_debug_args
+
+swift_optimization_args = {'0': [],
+                           'g': [],
+                           '1': ['-O'],
+                           '2': ['-O'],
+                           '3': ['-O'],
+                           's': ['-O'],
+                           }
 
 class SwiftCompiler(Compiler):
     def __init__(self, exelist, version):
@@ -97,3 +105,9 @@ class SwiftCompiler(Compiler):
             raise EnvironmentException('Swift compiler %s can not compile programs.' % self.name_string())
         if subprocess.call(output_name) != 0:
             raise EnvironmentException('Executables created by Swift compiler %s are not runnable.' % self.name_string())
+
+    def get_debug_args(self, is_debug):
+        return clike_debug_args[is_debug]
+
+    def get_optimization_args(self, optimization_level):
+        return swift_optimization_args[optimization_level]
diff --git a/mesonbuild/compilers/vala.py b/mesonbuild/compilers/vala.py
index 6194d1a..46bb210 100644
--- a/mesonbuild/compilers/vala.py
+++ b/mesonbuild/compilers/vala.py
@@ -34,6 +34,12 @@ class ValaCompiler(Compiler):
     def needs_static_linker(self):
         return False # Because compiles into C.
 
+    def get_optimization_args(self, optimization_level):
+        return []
+
+    def get_debug_args(self, is_debug):
+        return ['--debug']
+
     def get_output_args(self, target):
         return [] # Because compiles into C.