def __init__(self,
target,
notify=None,
macros=None,
build_profile=None,
build_dir=None,
coverage_patterns=None):
mbedToolchain.__init__(self,
target,
notify,
macros,
build_dir=build_dir,
build_profile=build_profile)
if target.core not in self.SUPPORTED_CORES:
raise NotSupportedException(
"this compiler does not support the core %s" % target.core)
self.check_c_lib_supported(target, "arm")
if (getattr(target, "default_toolchain", "ARM") == "uARM"
or getattr(target, "c_lib", "std") == "small"):
if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']:
self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD")
if "-D__MICROLIB" not in self.flags['common']:
self.flags['common'].append("-D__MICROLIB")
if "--library_type=microlib" not in self.flags['ld']:
self.flags['ld'].append("--library_type=microlib")
if "--library_type=microlib" not in self.flags['common']:
self.flags['common'].append("--library_type=microlib")
self.check_and_add_minimal_printf(target)
cpu = {
"Cortex-M0+": "Cortex-M0plus",
"Cortex-M4F": "Cortex-M4.fp.sp",
"Cortex-M7F": "Cortex-M7.fp.sp",
"Cortex-M7FD": "Cortex-M7.fp.dp"
}.get(target.core, target.core)
ARM_BIN = join(TOOLCHAIN_PATHS['ARM'], "bin")
main_cc = join(ARM_BIN, "armcc")
self.flags['common'] += ["--cpu=%s" % cpu]
self.asm = [main_cc] + self.flags['common'] + self.flags['asm']
self.cc = [main_cc] + self.flags['common'] + self.flags['c']
self.cppc = ([main_cc] + self.flags['common'] + self.flags['c'] +
self.flags['cxx'])
self.ld = [join(ARM_BIN, "armlink")] + self.flags['ld']
self.ar = join(ARM_BIN, "armar")
self.elf2bin = join(ARM_BIN, "fromelf")
self.SHEBANG += " --cpu=%s" % cpu
self.product_name = None
def __init__(self,
target,
notify=None,
macros=None,
build_profile=None,
build_dir=None):
mbedToolchain.__init__(self,
target,
notify,
macros,
build_dir=build_dir,
build_profile=build_profile)
if target.core not in self.SUPPORTED_CORES:
raise NotSupportedException(
"this compiler does not support the core %s" % target.core)
if getattr(target, "default_toolchain", "ARM") == "uARM":
if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']:
self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD")
if "-D__MICROLIB" not in self.flags['common']:
self.flags['common'].append("-D__MICROLIB")
if "--library_type=microlib" not in self.flags['ld']:
self.flags['ld'].append("--library_type=microlib")
if "--library_type=microlib" not in self.flags['common']:
self.flags['common'].append("--library_type=microlib")
if target.core == "Cortex-M0+":
cpu = "Cortex-M0"
elif target.core == "Cortex-M4F":
cpu = "Cortex-M4.fp"
elif target.core == "Cortex-M7FD":
cpu = "Cortex-M7.fp.dp"
elif target.core == "Cortex-M7F":
cpu = "Cortex-M7.fp.sp"
else:
cpu = target.core
ARM_BIN = join(TOOLCHAIN_PATHS['ARM'], "bin")
main_cc = join(ARM_BIN, "armcc")
self.flags['common'] += ["--cpu=%s" % cpu]
self.asm = [main_cc] + self.flags['common'] + self.flags['asm']
self.cc = [main_cc] + self.flags['common'] + self.flags['c']
self.cppc = ([main_cc] + self.flags['common'] + self.flags['c'] +
self.flags['cxx'])
self.ld = [join(ARM_BIN, "armlink")] + self.flags['ld']
self.ar = join(ARM_BIN, "armar")
self.elf2bin = join(ARM_BIN, "fromelf")
self.SHEBANG += " --cpu=%s" % cpu
self.product_name = None
def __init__(self,
target,
notify=None,
macros=None,
build_profile=None,
build_dir=None,
coverage_patterns=None):
mbedToolchain.__init__(self,
target,
notify,
macros,
build_profile=build_profile,
build_dir=build_dir,
coverage_patterns=coverage_patterns)
tool_path = TOOLCHAIN_PATHS['GCC_ARM']
# Add flags for current size setting
c_lib = "std"
if hasattr(target, "c_lib"):
self.check_c_lib_supported(target, "gcc_arm")
c_lib = target.c_lib
elif hasattr(target, "default_build"):
c_lib = target.default_build
if c_lib == "small":
common_flags = ["-DMBED_RTOS_SINGLE_THREAD", "-D__NEWLIB_NANO"]
self.flags["common"].extend(common_flags)
self.flags["ld"].append("--specs=nano.specs")
self.check_and_add_minimal_printf(target)
if getattr(target, "printf_lib", "std") == "minimal-printf":
minimal_printf_wraps = [
"-Wl,--wrap,printf",
"-Wl,--wrap,sprintf",
"-Wl,--wrap,snprintf",
"-Wl,--wrap,vprintf",
"-Wl,--wrap,vsprintf",
"-Wl,--wrap,vsnprintf",
"-Wl,--wrap,fprintf",
"-Wl,--wrap,vfprintf",
]
# Add the linker option to wrap the f\v\s\printf functions if not
# already added.
for minimal_printf_wrap in minimal_printf_wraps:
if minimal_printf_wrap not in self.flags["ld"]:
self.flags["ld"].append(minimal_printf_wrap)
self.cpu = []
if target.is_TrustZone_secure_target:
# Enable compiler security extensions
self.cpu.append("-mcmse")
# Output secure import library
self.flags["ld"].extend([
"-Wl,--cmse-implib",
"-Wl,--out-implib=%s" % join(build_dir, "cmse_lib.o")
])
if target.is_TrustZone_non_secure_target:
# Add linking time preprocessor macro DOMAIN_NS
# (DOMAIN_NS is passed to compiler and assembler via CORTEX_SYMBOLS
# in mbedToolchain.get_symbols)
self.flags["ld"].append("-DDOMAIN_NS=1")
core = target.core_without_NS
cpu = {
"Cortex-M0+": "cortex-m0plus",
"Cortex-M4F": "cortex-m4",
"Cortex-M7F": "cortex-m7",
"Cortex-M7FD": "cortex-m7",
"Cortex-M33": "cortex-m33+nodsp",
"Cortex-M33E": "cortex-m33",
"Cortex-M33F": "cortex-m33+nodsp",
"Cortex-M33FE": "cortex-m33"
}.get(core, core)
if cpu == "cortex-m33+nodsp":
self.cpu.append("-march=armv8-m.main")
elif cpu == "cortex-m33":
self.cpu.append("-march=armv8-m.main+dsp")
else:
self.cpu.append("-mcpu={}".format(cpu.lower()))
if target.core.startswith("Cortex-M"):
self.cpu.append("-mthumb")
# FPU handling, M7 possibly to have double FPU
if core == "Cortex-M4F":
self.cpu.append("-mfpu=fpv4-sp-d16")
self.cpu.append("-mfloat-abi=softfp")
elif core == "Cortex-M7F" or core.startswith("Cortex-M33F"):
self.cpu.append("-mfpu=fpv5-sp-d16")
self.cpu.append("-mfloat-abi=softfp")
elif core == "Cortex-M7FD":
self.cpu.append("-mfpu=fpv5-d16")
self.cpu.append("-mfloat-abi=softfp")
if target.core == "Cortex-A9":
self.cpu.append("-mthumb-interwork")
self.cpu.append("-marm")
self.cpu.append("-march=armv7-a")
self.cpu.append("-mfpu=vfpv3")
self.cpu.append("-mfloat-abi=hard")
self.cpu.append("-mno-unaligned-access")
self.flags["common"] += self.cpu
self.coverage_supported = True
main_cc = join(tool_path, "arm-none-eabi-gcc")
main_cppc = join(tool_path, "arm-none-eabi-g++")
self.asm = [main_cc] + self.flags['asm'] + self.flags["common"]
self.cc = [main_cc]
self.cppc = [main_cppc]
self.cc += self.flags['c'] + self.flags['common']
self.cppc += self.flags['cxx'] + self.flags['common']
self.flags['ld'] += self.cpu
self.ld = [join(tool_path, "arm-none-eabi-gcc")] + self.flags['ld']
self.sys_libs = ["stdc++", "supc++", "m", "c", "gcc", "nosys"]
self.preproc = [join(tool_path, "arm-none-eabi-cpp"), "-E", "-P"]
self.ar = join(tool_path, "arm-none-eabi-ar")
self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")
self.use_distcc = (bool(getenv("DISTCC_POTENTIAL_HOSTS", False))
and not getenv("MBED_DISABLE_DISTCC", False))
# create copies of gcc/ld options as coverage build options, and injects extra coverage options
self.coverage_cc = self.cc + ["--coverage", "-DENABLE_LIBGCOV_PORT"]
self.coverage_cppc = self.cppc + [
"--coverage", "-DENABLE_LIBGCOV_PORT"
]
self.coverage_ld = self.ld + [
'--coverage', '-Wl,--wrap,GREENTEA_SETUP',
'-Wl,--wrap,_Z25GREENTEA_TESTSUITE_RESULTi'
]
# for gcc coverage options remove MBED_DEBUG macro (this is required by code coverage function)
for flag in ["-DMBED_DEBUG"]:
if flag in self.coverage_cc:
self.coverage_cc.remove(flag)
if flag in self.coverage_cppc:
self.coverage_cppc.remove(flag)
# for lg coverage options remove exit wrapper (this is required by code coverage function)
for flag in ['-Wl,--wrap,exit', '-Wl,--wrap,atexit']:
if flag in self.coverage_ld:
self.coverage_ld.remove(flag)
def __init__(self, target, *args, **kwargs):
mbedToolchain.__init__(self, target, *args, **kwargs)
if target.core not in self.SUPPORTED_CORES:
raise NotSupportedException(
"this compiler does not support the core %s" % target.core)
if int(target.build_tools_metadata["version"]) > 0:
if not set(("ARM", "ARMC6", "uARM")).intersection(set(
target.supported_toolchains
)):
raise NotSupportedException(
"ARM/ARMC6 compiler support is required for ARMC6 build"
)
else:
if not set(("ARM", "ARMC6")).intersection(set(
target.supported_toolchains
)):
raise NotSupportedException(
"ARM/ARMC6 compiler support is required for ARMC6 build"
)
self.check_c_lib_supported(target, "arm")
if (
getattr(target, "default_toolchain", "ARMC6") == "uARM"
or getattr(target, "default_lib", "std") == "small"
):
if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']:
self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD")
if "-D__MICROLIB" not in self.flags['common']:
self.flags['common'].append("-D__MICROLIB")
if "--library_type=microlib" not in self.flags['ld']:
self.flags['ld'].append("--library_type=microlib")
if "-Wl,--library_type=microlib" not in self.flags['c']:
self.flags['c'].append("-Wl,--library_type=microlib")
if "-Wl,--library_type=microlib" not in self.flags['cxx']:
self.flags['cxx'].append("-Wl,--library_type=microlib")
if "--library_type=microlib" not in self.flags['asm']:
self.flags['asm'].append("--library_type=microlib")
self.check_and_add_minimal_printf(target)
if target.is_TrustZone_secure_target:
if kwargs.get('build_dir', False):
# Output secure import library
build_dir = kwargs['build_dir']
secure_file = join(build_dir, "cmse_lib.o")
self.flags["ld"] += ["--import_cmse_lib_out=%s" % secure_file]
# Enable compiler security extensions
self.flags['cxx'].append("-mcmse")
self.flags['c'].append("-mcmse")
if target.is_TrustZone_non_secure_target:
# Add linking time preprocessor macro DOMAIN_NS
# (DOMAIN_NS is passed to compiler and assembler via CORTEX_SYMBOLS
# in mbedToolchain.get_symbols)
define_string = self.make_ld_define("DOMAIN_NS", "0x1")
self.flags["ld"].append(define_string)
core = target.core_without_NS
cpu = {
"Cortex-M0+": "cortex-m0plus",
"Cortex-M4F": "cortex-m4",
"Cortex-M7F": "cortex-m7",
"Cortex-M7FD": "cortex-m7",
"Cortex-M33": "cortex-m33+nodsp",
"Cortex-M33F": "cortex-m33+nodsp",
"Cortex-M33E": "cortex-m33",
"Cortex-M33FE": "cortex-m33"}.get(core, core)
cpu = cpu.lower()
self.flags['common'].append("-mcpu=%s" % cpu)
self.SHEBANG += " -mcpu=%s" % cpu
# FPU handling
if core in ["Cortex-M4", "Cortex-M7", "Cortex-M33", "Cortex-M33E"]:
self.flags['common'].append("-mfpu=none")
elif core == "Cortex-M4F":
self.flags['common'].append("-mfpu=fpv4-sp-d16")
self.flags['common'].append("-mfloat-abi=hard")
elif core == "Cortex-M7F" or core.startswith("Cortex-M33F"):
self.flags['common'].append("-mfpu=fpv5-sp-d16")
self.flags['common'].append("-mfloat-abi=hard")
elif core == "Cortex-M7FD":
self.flags['common'].append("-mfpu=fpv5-d16")
self.flags['common'].append("-mfloat-abi=hard")
asm_ld_cpu = {
"Cortex-M0+": "Cortex-M0plus",
"Cortex-M4": "Cortex-M4.no_fp",
"Cortex-M4F": "Cortex-M4",
"Cortex-M7": "Cortex-M7.no_fp",
"Cortex-M7F": "Cortex-M7.fp.sp",
"Cortex-M7FD": "Cortex-M7",
"Cortex-M33": "Cortex-M33.no_dsp.no_fp",
"Cortex-M33E": "Cortex-M33.no_fp",
"Cortex-M33F": "Cortex-M33.no_dsp",
"Cortex-M33FE": "Cortex-M33"}.get(core, core)
self.flags['asm'].append("--cpu=%s" % asm_ld_cpu)
self.flags['ld'].append("--cpu=%s" % asm_ld_cpu)
self.cc = ([join(TOOLCHAIN_PATHS["ARMC6"], "armclang")] +
self.flags['common'] + self.flags['c'])
self.cppc = ([join(TOOLCHAIN_PATHS["ARMC6"], "armclang")] +
self.flags['common'] + self.flags['cxx'])
self.asm = [join(TOOLCHAIN_PATHS["ARMC6"], "armasm")]
self.asm += self.flags['asm']
self.ld = [join(TOOLCHAIN_PATHS["ARMC6"], "armlink")]
self.ld += self.flags['ld']
self.ar = join(TOOLCHAIN_PATHS["ARMC6"], "armar")
self.elf2bin = join(TOOLCHAIN_PATHS["ARMC6"], "fromelf")
# Adding this for safety since this inherits the `version_check`
# function but does not call the constructor of ARM_STD, so the
# `product_name` variable is not initialized.
self.product_name = None
def __init__(self,
target,
notify=None,
macros=None,
build_profile=None,
build_dir=None):
mbedToolchain.__init__(self,
target,
notify,
macros,
build_profile=build_profile,
build_dir=build_dir)
# Add flags for current size setting
default_lib = "std"
if hasattr(target, "default_lib"):
default_lib = target.default_lib
elif hasattr(target, "default_build"):
default_lib = target.default_build
if default_lib == "small":
self.flags["common"].append("-DMBED_RTOS_SINGLE_THREAD")
self.flags["ld"].append("--specs=nano.specs")
if target.core == "IMXGAP8":
tool_path = TOOLCHAIN_PATHS['GCC_RISCV']
self.cpu = ["-march=rv32imcxgap8", "-mPE=8", "-mFC=1"]
else:
tool_path = TOOLCHAIN_PATHS['GCC_ARM']
if target.is_TrustZone_secure_target:
# Enable compiler security extensions
self.cpu.append("-mcmse")
# Output secure import library
self.flags["ld"].extend([
"-Wl,--cmse-implib",
"-Wl,--out-implib=%s" % join(build_dir, "cmse_lib.o")
])
if target.is_TrustZone_non_secure_target:
# Add linking time preprocessor macro DOMAIN_NS
# (DOMAIN_NS is passed to compiler and assembler via CORTEX_SYMBOLS
# in mbedToolchain.get_symbols)
self.flags["ld"].append("-DDOMAIN_NS=1")
core = target.core_without_NS
cpu = {
"Cortex-M0+": "cortex-m0plus",
"Cortex-M4F": "cortex-m4",
"Cortex-M7F": "cortex-m7",
"Cortex-M7FD": "cortex-m7",
"Cortex-M33": "cortex-m33+nodsp",
"Cortex-M33E": "cortex-m33",
"Cortex-M33F": "cortex-m33+nodsp",
"Cortex-M33FE": "cortex-m33"
}.get(core, core)
if cpu == "cortex-m33+nodsp":
self.cpu.append("-march=armv8-m.main")
elif cpu == "cortex-m33":
self.cpu.append("-march=armv8-m.main+dsp")
else:
self.cpu.append("-mcpu={}".format(cpu.lower()))
if target.core.startswith("Cortex-M"):
self.cpu.append("-mthumb")
# FPU handling, M7 possibly to have double FPU
if core == "Cortex-M4F":
self.cpu.append("-mfpu=fpv4-sp-d16")
self.cpu.append("-mfloat-abi=softfp")
elif core == "Cortex-M7F" or core.startswith("Cortex-M33F"):
self.cpu.append("-mfpu=fpv5-sp-d16")
self.cpu.append("-mfloat-abi=softfp")
elif core == "Cortex-M7FD":
self.cpu.append("-mfpu=fpv5-d16")
self.cpu.append("-mfloat-abi=softfp")
if target.core == "Cortex-A9":
self.cpu.append("-mthumb-interwork")
self.cpu.append("-marm")
self.cpu.append("-march=armv7-a")
self.cpu.append("-mfpu=vfpv3")
self.cpu.append("-mfloat-abi=hard")
self.cpu.append("-mno-unaligned-access")
self.flags["common"] += self.cpu
if target.core == "IMXGAP8":
main_cc = join(tool_path, "riscv32-unknown-elf-gcc")
main_cppc = join(tool_path, "riscv32-unknown-elf-g++")
else:
main_cc = join(tool_path, "arm-none-eabi-gcc")
main_cppc = join(tool_path, "arm-none-eabi-g++")
self.asm = [main_cc] + self.flags['asm'] + self.flags["common"]
self.cc = [main_cc]
self.cppc = [main_cppc]
self.cc += self.flags['c'] + self.flags['common']
self.cppc += self.flags['cxx'] + self.flags['common']
self.flags['ld'] += self.cpu
if target.core == "IMXGAP8":
self.ld = [join(tool_path, "riscv32-unknown-elf-gcc")
] + self.flags['ld']
self.sys_libs = ["stdc++", "m", "c", "gcc", "nosys"]
self.preproc = [
join(tool_path, "riscv32-unknown-elf-cpp"), "-E", "-P"
]
self.ar = join(tool_path, "riscv32-unknown-elf-ar")
self.elf2bin = join(tool_path, "riscv32-unknown-elf-objcopy")
else:
self.ld = [join(tool_path, "arm-none-eabi-gcc")] + self.flags['ld']
self.sys_libs = ["stdc++", "supc++", "m", "c", "gcc", "nosys"]
self.preproc = [join(tool_path, "arm-none-eabi-cpp"), "-E", "-P"]
self.ar = join(tool_path, "arm-none-eabi-ar")
self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")
self.use_distcc = (bool(getenv("DISTCC_POTENTIAL_HOSTS", False))
and not getenv("MBED_DISABLE_DISTCC", False))
def __init__(self, target, *args, **kwargs):
mbedToolchain.__init__(self, target, *args, **kwargs)
if target.core not in self.SUPPORTED_CORES:
raise NotSupportedException(
"this compiler does not support the core %s" % target.core)
if int(target.build_tools_metadata["version"]) > 0:
if not set(("ARM", "ARMC6", "uARM")).intersection(
set(target.supported_toolchains)):
raise NotSupportedException(
"ARM/ARMC6 compiler support is required for ARMC6 build")
else:
if not set(("ARM", "ARMC6")).intersection(
set(target.supported_toolchains)):
raise NotSupportedException(
"ARM/ARMC6 compiler support is required for ARMC6 build")
if getattr(target, "default_toolchain", "ARMC6") == "uARM":
if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']:
self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD")
if "-D__MICROLIB" not in self.flags['common']:
self.flags['common'].append("-D__MICROLIB")
if "--library_type=microlib" not in self.flags['ld']:
self.flags['ld'].append("--library_type=microlib")
if "-Wl,--library_type=microlib" not in self.flags['c']:
self.flags['c'].append("-Wl,--library_type=microlib")
if "-Wl,--library_type=microlib" not in self.flags['cxx']:
self.flags['cxx'].append("-Wl,--library_type=microlib")
if "--library_type=microlib" not in self.flags['asm']:
self.flags['asm'].append("--library_type=microlib")
core = target.core
if CORE_ARCH[target.core] == 8:
if ((not target.core.endswith("-NS"))
and kwargs.get('build_dir', False)):
# Create Secure library
build_dir = kwargs['build_dir']
secure_file = join(build_dir, "cmse_lib.o")
self.flags["ld"] += ["--import_cmse_lib_out=%s" % secure_file]
# Add linking time preprocessor macro DOMAIN_NS
if target.core.endswith("-NS"):
define_string = self.make_ld_define("DOMAIN_NS", "0x1")
self.flags["ld"].append(define_string)
core = target.core[:-3]
else:
# Add secure build flag
self.flags['cxx'].append("-mcmse")
self.flags['c'].append("-mcmse")
cpu = {
"Cortex-M0+": "cortex-m0plus",
"Cortex-M4F": "cortex-m4",
"Cortex-M7F": "cortex-m7",
"Cortex-M7FD": "cortex-m7",
"Cortex-M33": "cortex-m33+nodsp",
"Cortex-M33F": "cortex-m33+nodsp",
"Cortex-M33FE": "cortex-m33"
}.get(core, core)
cpu = cpu.lower()
self.flags['common'].append("-mcpu=%s" % cpu)
self.SHEBANG += " -mcpu=%s" % cpu
# FPU handling
if core == "Cortex-M4F":
self.flags['common'].append("-mfpu=fpv4-sp-d16")
self.flags['common'].append("-mfloat-abi=hard")
self.flags['ld'].append("--cpu=cortex-m4")
elif core == "Cortex-M7F":
self.flags['common'].append("-mfpu=fpv5-sp-d16")
self.flags['common'].append("-mfloat-abi=hard")
self.flags['ld'].append("--cpu=cortex-m7.fp.sp")
elif core == "Cortex-M7FD":
self.flags['common'].append("-mfpu=fpv5-d16")
self.flags['common'].append("-mfloat-abi=hard")
self.flags['ld'].append("--cpu=cortex-m7")
elif core == "Cortex-M33F":
self.flags['common'].append("-mfpu=fpv5-sp-d16")
self.flags['common'].append("-mfloat-abi=hard")
self.flags['ld'].append("--cpu=cortex-m33.no_dsp")
elif core == "Cortex-M33":
self.flags['common'].append("-mfpu=none")
self.flags['ld'].append("--cpu=cortex-m33.no_dsp.no_fp")
else:
self.flags['ld'].append("--cpu=%s" % cpu)
asm_cpu = {
"Cortex-M0+": "Cortex-M0",
"Cortex-M4F": "Cortex-M4.fp",
"Cortex-M7F": "Cortex-M7.fp.sp",
"Cortex-M7FD": "Cortex-M7.fp.dp",
"Cortex-M33": "Cortex-M33.no_dsp.no_fp",
"Cortex-M33F": "Cortex-M33.no_dsp",
"Cortex-M33FE": "Cortex-M33"
}.get(core, core)
self.flags['asm'].append("--cpu=%s" % asm_cpu)
self.cc = ([join(TOOLCHAIN_PATHS["ARMC6"], "armclang")] +
self.flags['common'] + self.flags['c'])
self.cppc = ([join(TOOLCHAIN_PATHS["ARMC6"], "armclang")] +
self.flags['common'] + self.flags['cxx'])
self.asm = [join(TOOLCHAIN_PATHS["ARMC6"], "armasm")]
self.asm += self.flags['asm']
self.ld = [join(TOOLCHAIN_PATHS["ARMC6"], "armlink")]
self.ld += self.flags['ld']
self.ar = join(TOOLCHAIN_PATHS["ARMC6"], "armar")
self.elf2bin = join(TOOLCHAIN_PATHS["ARMC6"], "fromelf")
# Adding this for safety since this inherits the `version_check`
# function but does not call the constructor of ARM_STD, so the
# `product_name` variable is not initialized.
self.product_name = None
def __init__(self, target, notify=None, macros=None, build_profile=None,
build_dir=None):
mbedToolchain.__init__(
self,
target,
notify,
macros,
build_profile=build_profile,
build_dir=build_dir
)
tool_path = TOOLCHAIN_PATHS['GCC_ARM']
# Add flags for current size setting
default_lib = "std"
if hasattr(target, "default_lib"):
default_lib = target.default_lib
elif hasattr(target, "default_build"):
default_lib = target.default_build
if default_lib == "small":
self.flags["common"].append("-DMBED_RTOS_SINGLE_THREAD")
self.flags["ld"].append("--specs=nano.specs")
core = target.core
self.cpu = []
if CORE_ARCH[target.core] == 8:
# Add linking time preprocessor macro DOMAIN_NS
if target.core.endswith("-NS"):
self.flags["ld"].append("-DDOMAIN_NS=1")
core = target.core[:-3]
else:
self.cpu.append("-mcmse")
self.flags["ld"].extend([
"-Wl,--cmse-implib",
"-Wl,--out-implib=%s" % join(build_dir, "cmse_lib.o")
])
cpu = {
"Cortex-M0+": "cortex-m0plus",
"Cortex-M4F": "cortex-m4",
"Cortex-M7F": "cortex-m7",
"Cortex-M7FD": "cortex-m7",
"Cortex-M33": "cortex-m33+nodsp",
"Cortex-M33E": "cortex-m33",
"Cortex-M33F": "cortex-m33+nodsp",
"Cortex-M33FE": "cortex-m33"}.get(core, core)
if cpu == "cortex-m33+nodsp":
self.cpu.append("-march=armv8-m.main")
elif cpu == "cortex-m33":
self.cpu.append("-march=armv8-m.main+dsp")
else:
self.cpu.append("-mcpu={}".format(cpu.lower()))
if target.core.startswith("Cortex-M"):
self.cpu.append("-mthumb")
# FPU handling, M7 possibly to have double FPU
if core == "Cortex-M4F":
self.cpu.append("-mfpu=fpv4-sp-d16")
self.cpu.append("-mfloat-abi=softfp")
elif core == "Cortex-M7F" or core.startswith("Cortex-M33F"):
self.cpu.append("-mfpu=fpv5-sp-d16")
self.cpu.append("-mfloat-abi=softfp")
elif core == "Cortex-M7FD":
self.cpu.append("-mfpu=fpv5-d16")
self.cpu.append("-mfloat-abi=softfp")
if target.core == "Cortex-A9":
self.cpu.append("-mthumb-interwork")
self.cpu.append("-marm")
self.cpu.append("-march=armv7-a")
self.cpu.append("-mfpu=vfpv3")
self.cpu.append("-mfloat-abi=hard")
self.cpu.append("-mno-unaligned-access")
self.flags["common"] += self.cpu
main_cc = join(tool_path, "arm-none-eabi-gcc")
main_cppc = join(tool_path, "arm-none-eabi-g++")
self.asm = [main_cc] + self.flags['asm'] + self.flags["common"]
self.cc = [main_cc]
self.cppc = [main_cppc]
self.cc += self.flags['c'] + self.flags['common']
self.cppc += self.flags['cxx'] + self.flags['common']
self.flags['ld'] += self.cpu
self.ld = [join(tool_path, "arm-none-eabi-gcc")] + self.flags['ld']
self.sys_libs = ["stdc++", "supc++", "m", "c", "gcc", "nosys"]
self.preproc = [join(tool_path, "arm-none-eabi-cpp"), "-E", "-P"]
self.ar = join(tool_path, "arm-none-eabi-ar")
self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")
self.use_distcc = (bool(getenv("DISTCC_POTENTIAL_HOSTS", False))
and not getenv("MBED_DISABLE_DISTCC", False))
def __init__(self, target, notify=None, macros=None, build_profile=None,
build_dir=None, coverage_patterns=None):
mbedToolchain.__init__(
self,
target,
notify,
macros,
build_dir=build_dir,
build_profile=build_profile
)
self.check_c_lib_supported(target, "iar")
if target.is_TrustZone_secure_target:
# Enable compiler security extensions
self.flags["asm"] += ["--cmse"]
self.flags["common"] += ["--cmse"]
# Output secure import library
secure_file = join(build_dir, "cmse_lib.o")
self.flags["ld"] += ["--import_cmse_lib_out=%s" % secure_file]
if target.is_TrustZone_non_secure_target:
# Add linking time preprocessor macro DOMAIN_NS
# (DOMAIN_NS is passed to compiler and assembler via CORTEX_SYMBOLS
# in mbedToolchain.get_symbols)
define_string = self.make_ld_define("DOMAIN_NS", "0x1")
self.flags["ld"].append(define_string)
self.check_and_add_minimal_printf(target)
core = target.core_without_NS
cpu = {
"Cortex-M7F": "Cortex-M7.fp.sp",
"Cortex-M7FD": "Cortex-M7.fp.dp",
"Cortex-M33": "Cortex-M33.no_dsp",
"Cortex-M33E": "Cortex-M33",
"Cortex-M33F": "Cortex-M33.fp.no_dsp",
"Cortex-M33FE": "Cortex-M33.fp"}.get(core, core)
# flags_cmd are used only by our scripts, the project files have them
# already defined, using this flags results in the errors (duplication)
# asm accepts --cpu Core or --fpu FPU, not like c/c++ --cpu=Core
asm_flags_cmd = ["--cpu", cpu]
# custom c flags
c_flags_cmd = ["--cpu", cpu]
c_flags_cmd.extend([
"--thumb", "--dlib_config", "DLib_Config_Full.h"
])
# custom c++ cmd flags
cxx_flags_cmd = [
"--c++", "--no_rtti", "--no_exceptions"
]
IAR_BIN = join(TOOLCHAIN_PATHS['IAR'], "bin")
main_cc = join(IAR_BIN, "iccarm")
self.asm = [join(IAR_BIN, "iasmarm")]
self.asm += asm_flags_cmd
self.asm += self.flags["asm"]
self.cc = [main_cc]
self.cc += self.flags["common"]
self.cc += c_flags_cmd
self.cc += self.flags["c"]
self.cppc = [main_cc]
self.cppc += self.flags["common"]
self.cppc += c_flags_cmd
self.cppc += cxx_flags_cmd
self.cppc += self.flags["cxx"]
self.ld = [join(IAR_BIN, "ilinkarm")] + self.flags['ld']
self.ar = join(IAR_BIN, "iarchive")
self.elf2bin = join(IAR_BIN, "ielftool")
def __init__(self,
target,
notify=None,
macros=None,
build_profile=None,
build_dir=None):
mbedToolchain.__init__(self,
target,
notify,
macros,
build_dir=build_dir,
build_profile=build_profile)
core = target.core
if CORE_ARCH[target.core] == 8:
# Add linking time preprocessor macro DOMAIN_NS
if target.core.endswith("-NS"):
define_string = self.make_ld_define("DOMAIN_NS", "0x1")
self.flags["ld"].append(define_string)
core = target.core[:-3]
else:
# Create Secure library
self.flags["asm"] += ["--cmse"]
self.flags["common"] += ["--cmse"]
secure_file = join(build_dir, "cmse_lib.o")
self.flags["ld"] += ["--import_cmse_lib_out=%s" % secure_file]
cpu = {
"Cortex-M7FD": "Cortex-M7.fp.dp",
"Cortex-M7F": "Cortex-M7.fp.sp",
"Cortex-M33": "Cortex-M33.no_dsp",
"Cortex-M33F": "Cortex-M33.fp.no_dsp",
"Cortex-M33FE": "Cortex-M33.fp"
}.get(core, core)
# flags_cmd are used only by our scripts, the project files have them
# already defined, using this flags results in the errors (duplication)
# asm accepts --cpu Core or --fpu FPU, not like c/c++ --cpu=Core
asm_flags_cmd = ["--cpu", cpu]
# custom c flags
c_flags_cmd = ["--cpu", cpu]
c_flags_cmd.extend(["--thumb", "--dlib_config", "DLib_Config_Full.h"])
# custom c++ cmd flags
cxx_flags_cmd = ["--c++", "--no_rtti", "--no_exceptions"]
IAR_BIN = join(TOOLCHAIN_PATHS['IAR'], "bin")
main_cc = join(IAR_BIN, "iccarm")
self.asm = [join(IAR_BIN, "iasmarm")]
self.asm += asm_flags_cmd
self.asm += self.flags["asm"]
self.cc = [main_cc]
self.cc += self.flags["common"]
self.cc += c_flags_cmd
self.cc += self.flags["c"]
self.cppc = [main_cc]
self.cppc += self.flags["common"]
self.cppc += c_flags_cmd
self.cppc += cxx_flags_cmd
self.cppc += self.flags["cxx"]
self.ld = [join(IAR_BIN, "ilinkarm")] + self.flags['ld']
self.ar = join(IAR_BIN, "iarchive")
self.elf2bin = join(IAR_BIN, "ielftool")
