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")