Merge pull request #4472 from ftechz/ccrx-support

Add support for Renesas CC-RX toolchain support
pull/4494/head
Dylan Baker 6 years ago committed by GitHub
commit 1d60a6a2ed
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 20
      cross/ccrx.txt
  2. 42
      docs/markdown/Reference-tables.md
  3. 16
      docs/markdown/snippets/ccrx_toolchain_support.md
  4. 2
      mesonbuild/backend/backends.py
  5. 18
      mesonbuild/backend/ninjabackend.py
  6. 12
      mesonbuild/build.py
  7. 6
      mesonbuild/compilers/__init__.py
  8. 43
      mesonbuild/compilers/c.py
  9. 128
      mesonbuild/compilers/compilers.py
  10. 29
      mesonbuild/compilers/cpp.py
  11. 20
      mesonbuild/environment.py
  12. 51
      mesonbuild/linkers.py

@ -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'

@ -5,26 +5,27 @@
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 |
| intel | Intel compiler | msvc on windows, otherwise gcc |
| llvm | LLVM-based compiler (Swift, D) | |
| mono | Xamarin C# compiler | |
| dmd | D lang reference compiler | |
| rustc | Rust compiler | |
| valac | Vala compiler | |
| pathscale | The Pathscale Fortran compiler | |
| pgi | The Portland Fortran compiler | |
| sun | Sun Fortran compiler | |
| g95 | The G95 Fortran compiler | |
| open64 | The Open64 Fortran Compiler | |
| nagfor | The NAG Fortran compiler | |
| lcc | Elbrus C/C++/Fortran Compiler | |
| arm | ARM compiler | |
| armclang | ARMCLANG compiler | |
| Value | Compiler family | Argument syntax |
| ----- | --------------- | --------------- |
| gcc | The GNU Compiler Collection | gcc |
| clang | The Clang compiler | gcc |
| msvc | Microsoft Visual Studio | msvc |
| intel | Intel compiler | msvc on windows, otherwise gcc |
| llvm | LLVM-based compiler (Swift, D) | |
| mono | Xamarin C# compiler | |
| dmd | D lang reference compiler | |
| rustc | Rust compiler | |
| valac | Vala compiler | |
| pathscale | The Pathscale Fortran compiler | |
| pgi | The Portland Fortran compiler | |
| sun | Sun Fortran compiler | |
| g95 | The G95 Fortran compiler | |
| open64 | The Open64 Fortran Compiler | |
| nagfor | The NAG Fortran compiler | |
| 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.

@ -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.

@ -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

@ -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

@ -1347,12 +1347,14 @@ class Executable(BuildTarget):
if (for_windows(is_cross, environment) or
for_cygwin(is_cross, environment) or 'cs' in self.compilers):
self.suffix = 'exe'
elif ('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:
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'
else:
self.suffix = ''
self.suffix = ''
self.filename = self.name
if self.suffix:
self.filename += '.' + self.suffix

@ -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

@ -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]

@ -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

@ -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 []

@ -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

@ -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 []

Loading…
Cancel
Save