Merge pull request #4472 from ftechz/ccrx-support

Add support for Renesas CC-RX toolchain support

cross/ccrx.txt

@@ -0,0 +1,20 @@
+# This file assumes that path to the Renesas CC-RX toolchain is added
+# to the environment(PATH) variable, so that Meson can find
+# ccrx and rlink while building.
+[binaries]
+c = 'ccrx'
+cpp = 'ccrx'
+ar = 'rlink'
+strip = 'rlink'
+
+[properties]
+# The '--cpu' option with the appropriate target type should be mentioned
+# to cross compile c/c++ code with ccrx,.
+c_args      = ['--cpu=rx600']
+cpp_args    = ['--cpu=rx600']
+
+[host_machine]
+system = 'bare metal'      # Update with your system name - bare metal/OS.
+cpu_family = 'rx'
+cpu = 'rx600'
+endian = 'little'

docs/markdown/Reference-tables.md

@@ -6,7 +6,7 @@ These are return values of the `get_id` (Compiler family) and
 `get_argument_syntax` (Argument syntax) method in a compiler object.
 
 | Value     | Compiler family                  | Argument syntax                |
-| -----     | ----------------               | -------------------------------|
+| -----     | ---------------                  | ---------------                |
 | gcc       | The GNU Compiler Collection      | gcc                            |
 | clang     | The Clang compiler               | gcc                            |
 | msvc      | Microsoft Visual Studio          | msvc                           |
@@ -25,6 +25,7 @@ These are return values of the `get_id` (Compiler family) and
 | lcc       | Elbrus C/C++/Fortran Compiler    |                                |
 | arm       | ARM compiler                     |                                |
 | armclang  | ARMCLANG compiler                |                                |
+| ccrx      | Renesas RX Family C/C++ compiler |                                |
 
 ## Script environment variables
 
@@ -62,6 +63,7 @@ set in the cross file.
 | sparc               | 32 bit SPARC          |
 | sparc64             | SPARC v9 processor    |
 | s390x               | IBM zSystem s390x     |
+| rx                  | Renesas RX 32 bit MCU |
 
 Any cpu family not listed in the above list is not guaranteed to
 remain stable in future releases.

docs/markdown/snippets/ccrx_toolchain_support.md

@@ -0,0 +1,16 @@
+## CC-RX compiler for C and CPP
+
+Cross-compilation is now supported for Renesas RX targets with the CC-RX compiler.
+
+The environment path should be set properly for the CC-RX compiler executables.
+The `-cpu` option with the appropriate value should be mentioned in the cross-file as shown in the snippet below.
+
+```ini
+[properties]
+c_args      = ['-cpu=rx600']
+cpp_args    = ['-cpu=rx600']
+```
+
+The default extension of the executable output is `.abs`.
+Other target specific arguments to the compiler and linker will need to be added explicitly from the cross-file(`c_args`/`c_link_args`/`cpp_args`/`cpp_link_args`) or some other way.
+Refer to the CC-RX User's manual for additional compiler and linker options.

mesonbuild/backend/backends.py

@@ -607,6 +607,8 @@ class Backend:
                 continue
             if compiler.get_language() == 'd':
                 arg = '-Wl,' + arg
+            else:
+                arg = compiler.get_linker_lib_prefix() + arg
             args.append(arg)
         return args
 

mesonbuild/backend/ninjabackend.py

@@ -1537,7 +1537,7 @@ rule FORTRAN_DEP_HACK%s
             command_template = ' command = {executable} $ARGS {cross_args} {output_args} {compile_only_args} $in\n'
         command = command_template.format(
             executable=' '.join([ninja_quote(i) for i in compiler.get_exelist()]),
-            cross_args=' '.join(self.get_cross_info_lang_args(compiler.language, is_cross)),
+            cross_args=' '.join(compiler.get_cross_extra_flags(self.environment, False)) if is_cross else '',
             output_args=' '.join(compiler.get_output_args('$out')),
             compile_only_args=' '.join(compiler.get_compile_only_args())
         )
@@ -1548,14 +1548,6 @@ rule FORTRAN_DEP_HACK%s
         outfile.write('\n')
         self.created_llvm_ir_rule = True
 
-    def get_cross_info_lang_args(self, lang, is_cross):
-        if is_cross:
-            try:
-                return self.environment.cross_info.config['properties'][lang + '_args']
-            except KeyError:
-                pass
-        return []
-
     def generate_compile_rule_for(self, langname, compiler, is_cross, outfile):
         if langname == 'java':
             if not is_cross:
@@ -1589,7 +1581,11 @@ rule FORTRAN_DEP_HACK%s
             if d != '$out' and d != '$in':
                 d = quote_func(d)
             quoted_depargs.append(d)
-        cross_args = self.get_cross_info_lang_args(langname, is_cross)
+
+        if is_cross:
+            cross_args = compiler.get_cross_extra_flags(self.environment, False)
+        else:
+            cross_args = ''
         if compiler.can_linker_accept_rsp():
             command_template = ''' command = {executable} @$out.rsp
  rspfile = $out.rsp
@@ -1628,7 +1624,7 @@ rule FORTRAN_DEP_HACK%s
         cross_args = []
         if is_cross:
             try:
-                cross_args = self.environment.cross_info.config['properties'][langname + '_args']
+                cross_args = compiler.get_cross_extra_flags(self.environment, False)
             except KeyError:
                 pass
 

mesonbuild/build.py

@@ -1347,10 +1347,12 @@ class Executable(BuildTarget):
             if (for_windows(is_cross, environment) or
                     for_cygwin(is_cross, environment) or 'cs' in self.compilers):
                 self.suffix = 'exe'
-            else:
+            elif ('c' in self.compilers and self.compilers['c'].get_id().startswith('arm') or
-                if ('c' in self.compilers and self.compilers['c'].get_id().startswith('arm') or
                   'cpp' in self.compilers and self.compilers['cpp'].get_id().startswith('arm')):
                 self.suffix = 'axf'
+            elif ('c' in self.compilers and self.compilers['c'].get_id().startswith('ccrx') or
+                  'cpp' in self.compilers and self.compilers['cpp'].get_id().startswith('ccrx')):
+                self.suffix = 'abs'
             else:
                 self.suffix = ''
         self.filename = self.name

mesonbuild/compilers/__init__.py

@@ -78,6 +78,9 @@ __all__ = [
     'PathScaleFortranCompiler',
     'PGIFortranCompiler',
     'RustCompiler',
+    'CcrxCCompiler',
+    'CcrxCompiler',
+    'CcrxCPPCompiler',
     'SunFortranCompiler',
     'SwiftCompiler',
     'ValaCompiler',
@@ -110,6 +113,7 @@ from .compilers import (
     CompilerArgs,
     GnuCompiler,
     IntelCompiler,
+    CcrxCompiler,
 )
 from .c import (
     CCompiler,
@@ -120,6 +124,7 @@ from .c import (
     GnuCCompiler,
     ElbrusCCompiler,
     IntelCCompiler,
+    CcrxCCompiler,
     VisualStudioCCompiler,
 )
 from .cpp import (
@@ -131,6 +136,7 @@ from .cpp import (
     GnuCPPCompiler,
     ElbrusCPPCompiler,
     IntelCPPCompiler,
+    CcrxCPPCompiler,
     VisualStudioCPPCompiler,
 )
 from .cs import MonoCompiler, VisualStudioCsCompiler

mesonbuild/compilers/c.py

@@ -46,6 +46,7 @@ from .compilers import (
     ElbrusCompiler,
     IntelCompiler,
     RunResult,
+    CcrxCompiler,
 )
 
 gnu_compiler_internal_libs = ('m', 'c', 'pthread', 'dl', 'rt')
@@ -1584,3 +1585,45 @@ class ArmCCompiler(ArmCompiler, CCompiler):
         if std.value != 'none':
             args.append('--' + std.value)
         return args
+
+class CcrxCCompiler(CcrxCompiler, CCompiler):
+    def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, **kwargs):
+        CCompiler.__init__(self, exelist, version, is_cross, exe_wrapper, **kwargs)
+        CcrxCompiler.__init__(self, compiler_type)
+
+    # Override CCompiler.get_always_args
+    def get_always_args(self):
+        return ['-nologo']
+
+    def get_options(self):
+        opts = CCompiler.get_options(self)
+        opts.update({'c_std': coredata.UserComboOption('c_std', 'C language standard to use',
+                                                       ['none', 'c89', 'c99'],
+                                                       'none')})
+        return opts
+
+    def get_option_compile_args(self, options):
+        args = []
+        std = options['c_std']
+        if std.value == 'c89':
+            args.append('-lang=c')
+        elif std.value == 'c99':
+            args.append('-lang=c99')
+        return args
+
+    def get_compile_only_args(self):
+        return []
+
+    def get_no_optimization_args(self):
+        return ['-optimize=0']
+
+    def get_output_args(self, target):
+        return ['-output=obj=%s' % target]
+
+    def get_linker_output_args(self, outputname):
+        return ['-output=%s' % outputname]
+
+    def get_include_args(self, path, is_system):
+        if path == '':
+            path = '.'
+        return ['-include=' + path]

mesonbuild/compilers/compilers.py

@@ -147,6 +147,14 @@ arm_buildtype_args = {'plain': [],
                       'custom': [],
                       }
 
+ccrx_buildtype_args = {'plain': [],
+                       'debug': [],
+                       'debugoptimized': [],
+                       'release': [],
+                       'minsize': [],
+                       'custom': [],
+                       }
+
 msvc_buildtype_args = {'plain': [],
                        'debug': ["/ZI", "/Ob0", "/Od", "/RTC1"],
                        'debugoptimized': ["/Zi", "/Ob1"],
@@ -179,6 +187,14 @@ arm_buildtype_linker_args = {'plain': [],
                              'custom': [],
                              }
 
+ccrx_buildtype_linker_args = {'plain': [],
+                              'debug': [],
+                              'debugoptimized': [],
+                              'release': [],
+                              'minsize': [],
+                              'custom': [],
+                              }
+
 msvc_buildtype_linker_args = {'plain': [],
                               'debug': [],
                               'debugoptimized': [],
@@ -295,6 +311,14 @@ gnu_optimization_args = {'0': [],
                          's': ['-Os'],
                          }
 
+ccrx_optimization_args = {'0': ['-optimize=0'],
+                          'g': ['-optimize=0'],
+                          '1': ['-optimize=1'],
+                          '2': ['-optimize=2'],
+                          '3': ['-optimize=max'],
+                          's': ['-optimize=2', '-size']
+                          }
+
 msvc_optimization_args = {'0': [],
                           'g': ['/O0'],
                           '1': ['/O1'],
@@ -309,6 +333,9 @@ clike_debug_args = {False: [],
 msvc_debug_args = {False: [],
                    True: []} # Fixme!
 
+ccrx_debug_args = {False: [],
+                   True: ['-debug']}
+
 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',
@@ -871,6 +898,9 @@ class Compiler:
     def get_linker_always_args(self):
         return []
 
+    def get_linker_lib_prefix(self):
+        return ''
+
     def gen_import_library_args(self, implibname):
         """
         Used only on Windows for libraries that need an import library.
@@ -1244,6 +1274,8 @@ class CompilerType(enum.Enum):
 
     ARM_WIN = 30
 
+    CCRX_WIN = 40
+
     @property
     def is_standard_compiler(self):
         return self.name in ('GCC_STANDARD', 'CLANG_STANDARD', 'ICC_STANDARD')
@@ -1254,7 +1286,7 @@ class CompilerType(enum.Enum):
 
     @property
     def is_windows_compiler(self):
-        return self.name in ('GCC_MINGW', 'GCC_CYGWIN', 'CLANG_MINGW', 'ICC_WIN', 'ARM_WIN')
+        return self.name in ('GCC_MINGW', 'GCC_CYGWIN', 'CLANG_MINGW', 'ICC_WIN', 'ARM_WIN', 'CCRX_WIN')
 
 
 def get_macos_dylib_install_name(prefix, shlib_name, suffix, soversion):
@@ -1804,3 +1836,97 @@ class ArmCompiler:
 
     def get_debug_args(self, is_debug):
         return clike_debug_args[is_debug]
+
+class CcrxCompiler:
+    def __init__(self, compiler_type):
+        if not self.is_cross:
+            raise EnvironmentException('ccrx supports only cross-compilation.')
+        # Check whether 'rlink.exe' is available in path
+        self.linker_exe = 'rlink.exe'
+        args = '--version'
+        try:
+            p, stdo, stderr = Popen_safe(self.linker_exe, args)
+        except OSError as e:
+            err_msg = 'Unknown linker\nRunning "{0}" gave \n"{1}"'.format(' '.join([self.linker_exe] + [args]), e)
+            raise EnvironmentException(err_msg)
+        self.id = 'ccrx'
+        self.compiler_type = compiler_type
+        # Assembly
+        self.can_compile_suffixes.update('s')
+        default_warn_args = []
+        self.warn_args = {'1': default_warn_args,
+                          '2': default_warn_args + [],
+                          '3': default_warn_args + []}
+
+    def can_linker_accept_rsp(self):
+        return False
+
+    def get_pic_args(self):
+        # PIC support is not enabled by default for CCRX,
+        # if users want to use it, they need to add the required arguments explicitly
+        return []
+
+    def get_buildtype_args(self, buildtype):
+        return ccrx_buildtype_args[buildtype]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return ccrx_buildtype_linker_args[buildtype]
+
+    # Override CCompiler.get_std_shared_lib_link_args
+    def get_std_shared_lib_link_args(self):
+        return []
+
+    def get_pch_suffix(self):
+        return 'pch'
+
+    def get_pch_use_args(self, pch_dir, header):
+        return []
+
+    # Override CCompiler.get_dependency_gen_args
+    def get_dependency_gen_args(self, outtarget, outfile):
+        return []
+
+    # Override CCompiler.build_rpath_args
+    def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
+        return []
+
+    def thread_flags(self, env):
+        return []
+
+    def thread_link_flags(self, env):
+        return []
+
+    def get_linker_exelist(self):
+        return [self.linker_exe]
+
+    def get_linker_lib_prefix(self):
+        return '-lib='
+
+    def get_coverage_args(self):
+        return []
+
+    def get_coverage_link_args(self):
+        return []
+
+    def get_optimization_args(self, optimization_level):
+        return ccrx_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug):
+        return ccrx_debug_args[is_debug]
+
+    @classmethod
+    def unix_args_to_native(cls, args):
+        result = []
+        for i in args:
+            if i.startswith('-D'):
+                i = '-define=' + i[2:]
+            if i.startswith('-I'):
+                i = '-include=' + i[2:]
+            if i.startswith('-Wl,-rpath='):
+                continue
+            elif i == '--print-search-dirs':
+                continue
+            elif i.startswith('-L'):
+                continue
+            result.append(i)
+        return result

mesonbuild/compilers/cpp.py

@@ -30,6 +30,7 @@ from .compilers import (
     IntelCompiler,
     ArmCompiler,
     ArmclangCompiler,
+    CcrxCompiler,
 )
 from .c_function_attributes import CXX_FUNC_ATTRIBUTES
 
@@ -412,3 +413,31 @@ class ArmCPPCompiler(ArmCompiler, CPPCompiler):
 
     def get_compiler_check_args(self):
         return []
+
+
+class CcrxCPPCompiler(CcrxCompiler, CPPCompiler):
+    def __init__(self, exelist, version, compiler_type, is_cross, exe_wrap=None, **kwargs):
+        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap, **kwargs)
+        CcrxCompiler.__init__(self, compiler_type)
+
+    # Override CCompiler.get_always_args
+    def get_always_args(self):
+        return ['-nologo', '-lang=cpp']
+
+    def get_option_compile_args(self, options):
+        return []
+
+    def get_compile_only_args(self):
+        return []
+
+    def get_output_args(self, target):
+        return ['-output=obj=%s' % target]
+
+    def get_linker_output_args(self, outputname):
+        return ['-output=%s' % outputname]
+
+    def get_option_link_args(self, options):
+        return []
+
+    def get_compiler_check_args(self):
+        return []

mesonbuild/environment.py

@@ -15,7 +15,7 @@
 import configparser, os, platform, re, sys, shlex, shutil, subprocess
 
 from . import coredata
-from .linkers import ArLinker, ArmarLinker, VisualStudioLinker, DLinker
+from .linkers import ArLinker, ArmarLinker, VisualStudioLinker, DLinker, CcrxLinker
 from . import mesonlib
 from .mesonlib import MesonException, EnvironmentException, PerMachine, Popen_safe
 from . import mlog
@@ -61,6 +61,8 @@ from .compilers import (
     PathScaleFortranCompiler,
     PGIFortranCompiler,
     RustCompiler,
+    CcrxCCompiler,
+    CcrxCPPCompiler,
     SunFortranCompiler,
     ValaCompiler,
     VisualStudioCCompiler,
@@ -82,6 +84,7 @@ known_cpu_families = (
     'ppc64',
     'riscv32',
     'riscv64',
+    'rx',
     's390x',
     'sparc',
     'sparc64',
@@ -563,6 +566,8 @@ class Environment:
                 arg = '/?'
             elif 'armcc' in compiler[0]:
                 arg = '--vsn'
+            elif 'ccrx' in compiler[0]:
+                arg = '-v'
             else:
                 arg = '--version'
             try:
@@ -570,8 +575,12 @@ class Environment:
             except OSError as e:
                 popen_exceptions[' '.join(compiler + [arg])] = e
                 continue
-            version = search_version(out)
+
+            if 'ccrx' in compiler[0]:
+                out = err
+
             full_version = out.split('\n', 1)[0]
+            version = search_version(out)
 
             guess_gcc_or_lcc = False
             if 'Free Software Foundation' in out:
@@ -659,6 +668,11 @@ class Environment:
                 compiler_type = CompilerType.ARM_WIN
                 cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler
                 return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
+            if 'RX Family' in out:
+                compiler_type = CompilerType.CCRX_WIN
+                cls = CcrxCCompiler if lang == 'c' else CcrxCPPCompiler
+                return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
+
         self._handle_exceptions(popen_exceptions, compilers)
 
     def detect_c_compiler(self, want_cross):
@@ -955,6 +969,8 @@ class Environment:
                 return DLinker(linker, compiler.arch)
             if 'GDC' in out and ' based on D ' in out:
                 return DLinker(linker, compiler.arch)
+            if err.startswith('Renesas') and ('rlink' in linker or 'rlink.exe' in linker):
+                return CcrxLinker(linker)
             if p.returncode == 0:
                 return ArLinker(linker)
             if p.returncode == 1 and err.startswith('usage'): # OSX

mesonbuild/linkers.py

@@ -192,3 +192,54 @@ class DLinker(StaticLinker):
 
     def get_link_debugfile_args(self, targetfile):
         return []
+
+class CcrxLinker(StaticLinker):
+
+    def __init__(self, exelist):
+        self.exelist = exelist
+        self.id = 'rlink'
+        pc, stdo = Popen_safe(self.exelist + ['-h'])[0:2]
+        self.std_args = []
+
+    def can_linker_accept_rsp(self):
+        return False
+
+    def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
+        return []
+
+    def get_exelist(self):
+        return self.exelist[:]
+
+    def get_std_link_args(self):
+        return self.std_args
+
+    def get_output_args(self, target):
+        return ['-output=%s' % target]
+
+    def get_buildtype_linker_args(self, buildtype):
+        return []
+
+    def get_linker_always_args(self):
+        return ['-nologo', '-form=library']
+
+    def get_coverage_link_args(self):
+        return []
+
+    def get_always_args(self):
+        return []
+
+    def thread_link_flags(self, env):
+        return []
+
+    def openmp_flags(self):
+        return []
+
+    def get_option_link_args(self, options):
+        return []
+
+    @classmethod
+    def unix_args_to_native(cls, args):
+        return args[:]
+
+    def get_link_debugfile_args(self, targetfile):
+        return []