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 == "Cortex-M7F" or target.core == "Cortex-M7FD": cpuchoice = "Cortex-M7" elif target.core.startswith("Cortex-M23"): cpuchoice = "8-M.baseline" elif target.core.startswith("Cortex-M33"): cpuchoice = "8-M.mainline" else: cpuchoice = target.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", cpuchoice] # custom c flags c_flags_cmd = ["--cpu", cpuchoice] c_flags_cmd.extend(["--thumb", "--dlib_config", "DLib_Config_Full.h"]) # custom c++ cmd flags cxx_flags_cmd = ["--c++", "--no_rtti", "--no_exceptions"] if target.core == "Cortex-M7FD": asm_flags_cmd += ["--fpu", "VFPv5"] c_flags_cmd.append("--fpu=VFPv5") elif target.core == "Cortex-M7F": asm_flags_cmd += ["--fpu", "VFPv5_sp"] c_flags_cmd.append("--fpu=VFPv5_sp") elif target.core == "Cortex-M23" or target.core == "Cortex-M33": self.flags["asm"] += ["--cmse"] self.flags["common"] += ["--cmse"] # Create Secure library if target.core == "Cortex-M23" or self.target.core == "Cortex-M33": secure_file = join(build_dir, "cmse_lib.o") self.flags["ld"] += ["--import_cmse_lib_out=%s" % secure_file] IAR_BIN = join(TOOLCHAIN_PATHS['IAR'], "bin") main_cc = join(IAR_BIN, "iccarm") self.asm = [join(IAR_BIN, "iasmarm") ] + asm_flags_cmd + self.flags["asm"] self.cc = [main_cc] self.cppc = [main_cc] self.cc += self.flags["common"] + c_flags_cmd + self.flags["c"] self.cppc += self.flags[ "common"] + c_flags_cmd + cxx_flags_cmd + 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, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M0+": cpu = "Cortex-M0" elif target.core == "Cortex-M4F": cpu = "Cortex-M4.fp" elif target.core == "Cortex-M7F": cpu = "Cortex-M7.fp.sp" else: cpu = target.core main_cc = join(ARM_BIN, "armcc") self.flags = copy.deepcopy(self.DEFAULT_FLAGS) self.flags['common'] += ["--cpu=%s" % cpu] if "save-asm" in self.options: self.flags['common'].extend(["--asm", "--interleave"]) if "debug-info" in self.options: self.flags['common'].append("-g") self.flags['c'].append("-O0") else: self.flags['c'].append("-O3") self.asm = [main_cc] + self.flags['common'] + self.flags['asm'] if not "analyze" in self.options: self.cc = [main_cc] + self.flags['common'] + self.flags['c'] self.cppc = [ main_cc ] + self.flags['common'] + self.flags['c'] + self.flags['cxx'] else: self.cc = [ join(GOANNA_PATH, "goannacc"), "--with-cc=" + main_cc.replace('\\', '/'), "--dialect=armcc", '--output-format="%s"' % self.GOANNA_FORMAT ] + self.flags['common'] + self.flags['c'] self.cppc = [ join(GOANNA_PATH, "goannac++"), "--with-cxx=" + main_cc.replace('\\', '/'), "--dialect=armcc", '--output-format="%s"' % self.GOANNA_FORMAT ] + self.flags['common'] + self.flags['c'] + self.flags['cxx'] self.ld = [join(ARM_BIN, "armlink")] self.sys_libs = [] self.ar = join(ARM_BIN, "armar") self.elf2bin = join(ARM_BIN, "fromelf")
def __init__(self, target, notify=None, macros=None, silent=False, extra_verbose=False, build_profile=None, build_dir=None): mbedToolchain.__init__(self, target, notify, macros, silent, build_dir=build_dir, extra_verbose=extra_verbose, build_profile=build_profile) 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") ARM_INC = join(TOOLCHAIN_PATHS['ARM'], "include") 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.ar = join(ARM_BIN, "armar") self.elf2bin = join(ARM_BIN, "fromelf")
def __init__(self, target, notify=None, macros=None, silent=False, extra_verbose=False, build_profile=None, build_dir=None): mbedToolchain.__init__(self, target, notify, macros, silent, build_dir=build_dir, extra_verbose=extra_verbose, build_profile=build_profile) if target.core == "Cortex-M7F" or target.core == "Cortex-M7FD": cpuchoice = "Cortex-M7" else: cpuchoice = target.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 if target.core == "Cortex-M4F": asm_flags_cmd = [ "--cpu", "Cortex-M4F" ] else: asm_flags_cmd = [ "--cpu", cpuchoice ] # custom c flags if target.core == "Cortex-M4F": c_flags_cmd = [ "--cpu", "Cortex-M4F" ] else: c_flags_cmd = [ "--cpu", cpuchoice ] c_flags_cmd.extend([ "--thumb", "--dlib_config", "DLib_Config_Full.h" ]) # custom c++ cmd flags cxx_flags_cmd = [ "--c++", "--no_rtti", "--no_exceptions" ] if target.core == "Cortex-M7FD": asm_flags_cmd += ["--fpu", "VFPv5"] c_flags_cmd.append("--fpu=VFPv5") elif target.core == "Cortex-M7F": asm_flags_cmd += ["--fpu", "VFPv5_sp"] c_flags_cmd.append("--fpu=VFPv5_sp") IAR_BIN = join(TOOLCHAIN_PATHS['IAR'], "bin") main_cc = join(IAR_BIN, "iccarm") self.asm = [join(IAR_BIN, "iasmarm")] + asm_flags_cmd + self.flags["asm"] self.cc = [main_cc] self.cppc = [main_cc] self.cc += self.flags["common"] + c_flags_cmd + self.flags["c"] self.cppc += self.flags["common"] + c_flags_cmd + cxx_flags_cmd + self.flags["cxx"] self.ld = [join(IAR_BIN, "ilinkarm")] self.ar = join(IAR_BIN, "iarchive") self.elf2bin = join(IAR_BIN, "ielftool")
def __init__(self, target, *args, **kwargs): mbedToolchain.__init__(self, target, *args, **kwargs) if not set( ("ARM", "ARMC6")).intersection(set(target.supported_toolchains)): raise NotSupportedException( "ARM/ARMC6 compiler support is required for ARMC6 build") if target.core.lower().endswith("fd"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-2]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-2]) elif target.core.lower().endswith("f"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-1]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-1]) elif target.core.lower().endswith("ns"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-3]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-3]) else: self.flags['common'].append("-mcpu=%s" % target.core.lower()) self.flags['ld'].append("--cpu=%s" % target.core.lower()) if target.core == "Cortex-M4F": self.flags['common'].append("-mfpu=fpv4-sp-d16") self.flags['common'].append("-mfloat-abi=hard") elif target.core == "Cortex-M7F": self.flags['common'].append("-mfpu=fpv5-sp-d16") self.flags['common'].append("-mfloat-abi=softfp") elif target.core == "Cortex-M7FD": self.flags['common'].append("-mfpu=fpv5-d16") self.flags['common'].append("-mfloat-abi=softfp") elif target.core.startswith("Cortex-M23"): self.flags['common'].append("-march=armv8-m.base") elif target.core.startswith("Cortex-M33"): self.flags['common'].append("-march=armv8-m.main") if target.core == "Cortex-M23" or target.core == "Cortex-M33": self.flags['common'].append("-mcmse") asm_cpu = { "Cortex-M0+": "Cortex-M0", "Cortex-M4F": "Cortex-M4.fp", "Cortex-M7F": "Cortex-M7.fp.sp", "Cortex-M7FD": "Cortex-M7.fp.dp", "Cortex-M23-NS": "Cortex-M23", "Cortex-M33-NS": "Cortex-M33" }.get(target.core, target.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.flags['asm'] self.ld = [join(TOOLCHAIN_PATHS["ARMC6"], "armlink") ] + self.flags['ld'] self.ar = [join(TOOLCHAIN_PATHS["ARMC6"], "armar")] self.elf2bin = join(TOOLCHAIN_PATHS["ARMC6"], "fromelf")
def __init__(self, target, notify=None, macros=None, silent=False, extra_verbose=False, build_profile=None): mbedToolchain.__init__(self, target, notify, macros, silent, extra_verbose=extra_verbose, build_profile=build_profile) if target.core == "Cortex-M7F" or target.core == "Cortex-M7FD": cpuchoice = "Cortex-M7" else: cpuchoice = target.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 if target.core == "Cortex-M4F": asm_flags_cmd = ["--cpu", "Cortex-M4F"] else: asm_flags_cmd = ["--cpu", cpuchoice] # custom c flags if target.core == "Cortex-M4F": c_flags_cmd = [ "--cpu", "Cortex-M4F", "--thumb", "--dlib_config", join(TOOLCHAIN_PATHS['IAR'], "inc", "c", "DLib_Config_Full.h") ] else: c_flags_cmd = [ "--cpu", cpuchoice, "--thumb", "--dlib_config", join(TOOLCHAIN_PATHS['IAR'], "inc", "c", "DLib_Config_Full.h") ] # custom c++ cmd flags cxx_flags_cmd = ["--c++", "--no_rtti", "--no_exceptions"] if target.core == "Cortex-M7FD": asm_flags_cmd += ["--fpu", "VFPv5"] c_flags_cmd.append("--fpu=VFPv5") elif target.core == "Cortex-M7F": asm_flags_cmd += ["--fpu", "VFPv5_sp"] c_flags_cmd.append("--fpu=VFPv5_sp") IAR_BIN = join(TOOLCHAIN_PATHS['IAR'], "bin") main_cc = join(IAR_BIN, "iccarm") self.asm = [join(IAR_BIN, "iasmarm") ] + asm_flags_cmd + self.flags["asm"] self.cc = [main_cc] self.cppc = [main_cc] self.cc += self.flags["common"] + c_flags_cmd + self.flags["c"] self.cppc += self.flags[ "common"] + c_flags_cmd + cxx_flags_cmd + self.flags["cxx"] self.ld = [join(IAR_BIN, "ilinkarm")] 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") ] + asm_flags_cmd + self.flags["asm"] self.cc = [main_cc] self.cppc = [main_cc] self.cc += self.flags["common"] + c_flags_cmd + self.flags["c"] self.cppc += self.flags[ "common"] + c_flags_cmd + cxx_flags_cmd + 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, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) 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") ARM_INC = join(TOOLCHAIN_PATHS['ARM'], "include") main_cc = join(ARM_BIN, "armcc") self.flags['common'] += ["--cpu=%s" % cpu] if "save-asm" in self.options: self.flags['common'].extend(["--asm", "--interleave"]) if "debug-info" in self.options: self.flags['common'].append("-g") self.flags['c'].append("-O0") else: self.flags['c'].append("-O3") self.asm = [main_cc] + self.flags['common'] + self.flags['asm'] + [ "-I \"" + ARM_INC + "\"" ] self.cc = [main_cc] + self.flags['common'] + self.flags['c'] + [ "-I \"" + ARM_INC + "\"" ] self.cppc = [ main_cc ] + self.flags['common'] + self.flags['c'] + self.flags['cxx'] + [ "-I \"" + ARM_INC + "\"" ] self.ld = [join(ARM_BIN, "armlink")] self.sys_libs = [] self.ar = join(ARM_BIN, "armar") self.elf2bin = join(ARM_BIN, "fromelf")
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") ARM_INC = join(TOOLCHAIN_PATHS['ARM'], "include") 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
def __init__(self, target, notify=None, macros=None, silent=False, extra_verbose=False, build_profile=None): mbedToolchain.__init__(self, target, notify, macros, silent, extra_verbose=extra_verbose, build_profile=build_profile) 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") ARM_INC = join(TOOLCHAIN_PATHS['ARM'], "include") main_cc = join(ARM_BIN, "armcc") self.flags['common'] += ["--cpu=%s" % cpu] self.asm = [main_cc] + self.flags['common'] + self.flags['asm'] + [ "-I \"" + ARM_INC + "\"" ] self.cc = [main_cc] + self.flags['common'] + self.flags['c'] + [ "-I \"" + ARM_INC + "\"" ] self.cppc = [ main_cc ] + self.flags['common'] + self.flags['c'] + self.flags['cxx'] + [ "-I \"" + ARM_INC + "\"" ] self.ld = [join(ARM_BIN, "armlink")] self.sys_libs = [] self.ar = join(ARM_BIN, "armar") self.elf2bin = join(ARM_BIN, "fromelf")
def __init__(self, target, notify=None, macros=None, silent=False, extra_verbose=False, build_profile=None, build_dir=None): mbedToolchain.__init__(self, target, notify, macros, silent, build_dir=build_dir, extra_verbose=extra_verbose, 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 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") ARM_INC = join(TOOLCHAIN_PATHS['ARM'], "include") 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
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M0+": cpu = "Cortex-M0" elif target.core == "Cortex-M4F": cpu = "Cortex-M4.fp" elif target.core == "Cortex-M7F": cpu = "Cortex-M7.fp.sp" else: cpu = target.core main_cc = join(ARM_BIN, "armcc") common = ["-c", "--cpu=%s" % cpu, "--gnu", "-Otime", "--split_sections", "--apcs=interwork", "--brief_diagnostics", "--restrict", "--multibyte_chars" ] if "save-asm" in self.options: common.extend(["--asm", "--interleave"]) if "debug-info" in self.options: common.append("-O0") else: common.append("-O3") # add debug symbols for all builds common.append("-g") common_c = [ "--md", "--no_depend_system_headers", '-I%s' % ARM_INC ] self.asm = [main_cc] + common + ['-I%s' % ARM_INC] if not "analyze" in self.options: self.cc = [main_cc] + common + common_c + ["--c99"] self.cppc = [main_cc] + common + common_c + ["--cpp", "--no_rtti"] else: self.cc = [join(GOANNA_PATH, "goannacc"), "--with-cc=" + main_cc.replace('\\', '/'), "--dialect=armcc", '--output-format="%s"' % self.GOANNA_FORMAT] + common + common_c + ["--c99"] self.cppc= [join(GOANNA_PATH, "goannac++"), "--with-cxx=" + main_cc.replace('\\', '/'), "--dialect=armcc", '--output-format="%s"' % self.GOANNA_FORMAT] + common + common_c + ["--cpp", "--no_rtti"] self.ld = [join(ARM_BIN, "armlink")] self.sys_libs = [] self.ar = join(ARM_BIN, "armar") self.elf2bin = join(ARM_BIN, "fromelf")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M7F": cpuchoice = "Cortex-M7" else: cpuchoice = target.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", cpuchoice ] # custom c flags c_flags_cmd = [ "--cpu", cpuchoice, "--thumb", "--dlib_config", join(IAR_PATH, "inc", "c", "DLib_Config_Full.h") ] # custom c++ cmd flags cxx_flags_cmd = [ "--c++", "--no_rtti", "--no_exceptions" ] if target.core == "Cortex-M7F": asm_flags_cmd += ["--fpu", "VFPv5_sp"] c_flags_cmd.append("--fpu=VFPv5_sp") if "debug-info" in self.options: c_flags_cmd.append("-r") c_flags_cmd.append("-On") else: c_flags_cmd.append("-Oh") IAR_BIN = join(IAR_PATH, "bin") main_cc = join(IAR_BIN, "iccarm") self.asm = [join(IAR_BIN, "iasmarm")] + asm_flags_cmd + self.flags["asm"] if not "analyze" in self.options: self.cc = [main_cc] self.cppc = [main_cc] else: self.cc = [join(GOANNA_PATH, "goannacc"), '--with-cc="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT] self.cppc = [join(GOANNA_PATH, "goannac++"), '--with-cxx="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT] self.cc += self.flags["common"] + c_flags_cmd + self.flags["c"] self.cppc += self.flags["common"] + c_flags_cmd + cxx_flags_cmd + self.flags["cxx"] self.ld = join(IAR_BIN, "ilinkarm") self.ar = join(IAR_BIN, "iarchive") self.elf2bin = join(IAR_BIN, "ielftool")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) 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 if not TOOLCHAIN_PATHS['ARM']: exe = find_executable('armcc') if exe: TOOLCHAIN_PATHS['ARM'] = dirname(dirname(exe)) ARM_BIN = join(TOOLCHAIN_PATHS['ARM'], "bin") ARM_INC = join(TOOLCHAIN_PATHS['ARM'], "include") main_cc = join(ARM_BIN, "armcc") self.flags['common'] += ["--cpu=%s" % cpu] if "save-asm" in self.options: self.flags['common'].extend(["--asm", "--interleave"]) if "debug-info" in self.options: self.flags['common'].append("-g") self.flags['c'].append("-O0") else: self.flags['c'].append("-O3") self.asm = [main_cc] + self.flags['common'] + self.flags['asm'] + ["-I \""+ARM_INC+"\""] self.cc = [main_cc] + self.flags['common'] + self.flags['c'] + ["-I \""+ARM_INC+"\""] self.cppc = [main_cc] + self.flags['common'] + self.flags['c'] + self.flags['cxx'] + ["-I \""+ARM_INC+"\""] self.ld = [join(ARM_BIN, "armlink")] self.sys_libs = [] self.ar = join(ARM_BIN, "armar") self.elf2bin = join(ARM_BIN, "fromelf") self.toolchain_path = TOOLCHAIN_PATHS['ARM']
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_lib", "std") == "small": if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']: self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD") if "--library_type=microlib" not in self.flags['ld']: self.flags['ld'].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") ARM_INC = join(TOOLCHAIN_PATHS['ARM'], "include") 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
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) 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") ARM_INC = join(TOOLCHAIN_PATHS["ARM"], "include") main_cc = join(ARM_BIN, "armcc") self.flags["common"] += ["--cpu=%s" % cpu] if "save-asm" in self.options: self.flags["common"].extend(["--asm", "--interleave"]) if "debug-info" in self.options: self.flags["common"].append("-g") self.flags["c"].append("-O0") else: self.flags["c"].append("-O3") self.asm = [main_cc] + self.flags["common"] + self.flags["asm"] + ['-I "' + ARM_INC + '"'] self.cc = [main_cc] + self.flags["common"] + self.flags["c"] + ['-I "' + ARM_INC + '"'] self.cppc = [main_cc] + self.flags["common"] + self.flags["c"] + self.flags["cxx"] + ['-I "' + ARM_INC + '"'] self.ld = [join(ARM_BIN, "armlink")] self.sys_libs = [] self.ar = join(ARM_BIN, "armar") self.elf2bin = join(ARM_BIN, "fromelf")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M7F": cpuchoice = "Cortex-M7" else: cpuchoice = target.core self.flags["common"] += [ "--cpu=%s" % cpuchoice, "--thumb", "--dlib_config", join(IAR_PATH, "inc", "c", "DLib_Config_Full.h"), ] if target.core == "Cortex-M7F": self.flags["common"].append("--fpu=VFPv5_sp") if "debug-info" in self.options: self.flags["common"].append("-r") self.flags["common"].append("-On") else: self.flags["common"].append("-Oh") IAR_BIN = join(IAR_PATH, "bin") main_cc = join(IAR_BIN, "iccarm") self.flags["asm"] += ["--cpu", cpuchoice] if target.core == "Cortex-M7F": self.flags["asm"] += ["--fpu", "VFPv5_sp"] self.asm = [join(IAR_BIN, "iasmarm")] + self.flags["asm"] if not "analyze" in self.options: self.cc = [main_cc] self.cppc = [main_cc] else: self.cc = [join(GOANNA_PATH, "goannacc"), '--with-cc="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT] self.cppc = [join(GOANNA_PATH, "goannac++"), '--with-cxx="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT] self.cc += self.flags["common"] + self.flags["c"] self.cppc += self.flags["common"] + self.flags["cxx"] self.ld = join(IAR_BIN, "ilinkarm") self.ar = join(IAR_BIN, "iarchive") self.elf2bin = join(IAR_BIN, "ielftool")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M0+": cpu = "Cortex-M0" elif target.core == "Cortex-M4F": cpu = "Cortex-M4.fp" elif target.core == "Cortex-M7F": cpu = "Cortex-M7.fp.sp" else: cpu = target.core main_cc = join(ARM_BIN, "armcc") self.flags['common'] += ["--cpu=%s" % cpu] if "save-asm" in self.options: self.flags['common'].extend(["--asm", "--interleave"]) if "debug-info" in self.options: self.flags['common'].append("-g") self.flags['c'].append("-O0") else: self.flags['c'].append("-O3") self.asm = [main_cc] + self.flags['common'] + self.flags['asm'] if not "analyze" in self.options: self.cc = [main_cc] + self.flags['common'] + self.flags['c'] self.cppc = [main_cc] + self.flags['common'] + self.flags['c'] + self.flags['cxx'] else: self.cc = [join(GOANNA_PATH, "goannacc"), "--with-cc=" + main_cc.replace('\\', '/'), "--dialect=armcc", '--output-format="%s"' % self.GOANNA_FORMAT] + self.flags['common'] + self.flags['c'] self.cppc= [join(GOANNA_PATH, "goannac++"), "--with-cxx=" + main_cc.replace('\\', '/'), "--dialect=armcc", '--output-format="%s"' % self.GOANNA_FORMAT] + self.flags['common'] + self.flags['c'] + self.flags['cxx'] self.ld = [join(ARM_BIN, "armlink")] self.sys_libs = [] self.ar = join(ARM_BIN, "armar") self.elf2bin = join(ARM_BIN, "fromelf")
def __init__(self, target, notify=None, macros=None, silent=False, extra_verbose=False, build_profile=None): mbedToolchain.__init__(self, target, notify, macros, silent, extra_verbose=extra_verbose, build_profile=build_profile) 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"): # Legacy 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 == "Cortex-M0+": cpu = "cortex-m0plus" elif target.core == "Cortex-M4F": cpu = "cortex-m4" elif target.core == "Cortex-M7F": cpu = "cortex-m7" elif target.core == "Cortex-M7FD": cpu = "cortex-m7" else: cpu = target.core.lower() self.cpu = ["-mcpu=%s" % cpu] if target.core.startswith("Cortex-M"): self.cpu.append("-mthumb") # FPU handling, M7 possibly to have double FPU if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": self.cpu.append("-mfpu=fpv5-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.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")
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"): # Legacy 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 == "Cortex-M0+": self.cpu = ["-mcpu=cortex-m0plus"] elif target.core.startswith("Cortex-M4"): self.cpu = ["-mcpu=cortex-m4"] elif target.core.startswith("Cortex-M7"): self.cpu = ["-mcpu=cortex-m7"] elif target.core.startswith("Cortex-M23"): self.cpu = ["-mcpu=cortex-m23"] elif target.core.startswith("Cortex-M33FD"): self.cpu = ["-mcpu=cortex-m33"] elif target.core.startswith("Cortex-M33F"): self.cpu = ["-mcpu=cortex-m33+nodsp"] elif target.core.startswith("Cortex-M33"): self.cpu = ["-march=armv8-m.main"] else: self.cpu = ["-mcpu={}".format(target.core.lower())] if target.core.startswith("Cortex-M"): self.cpu.append("-mthumb") # FPU handling, M7 possibly to have double FPU if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": self.cpu.append("-mfpu=fpv5-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7FD": self.cpu.append("-mfpu=fpv5-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core.startswith("Cortex-M33F"): self.cpu.append("-mfpu=fpv5-sp-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") if ((target.core.startswith("Cortex-M23") or target.core.startswith("Cortex-M33")) and not target.core.endswith("-NS")): self.cpu.append("-mcmse") self.flags["ld"].extend([ "-Wl,--cmse-implib", "-Wl,--out-implib=%s" % join(build_dir, "cmse_lib.o") ]) # Add linking time preprocessor macro DOMAIN_NS if ((target.core.startswith("Cortex-M23") or target.core.startswith("Cortex-M33")) and target.core.endswith("-NS")): self.flags["ld"].append("-DDOMAIN_NS=1") 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, options=None, notify=None, macros=None, silent=False, tool_path="", extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M0+": cpu = "cortex-m0plus" elif target.core == "Cortex-M4F": cpu = "cortex-m4" elif target.core == "Cortex-M7F": cpu = "cortex-m7" else: cpu = target.core.lower() self.cpu = ["-mcpu=%s" % cpu] if target.core.startswith("Cortex"): self.cpu.append("-mthumb") if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": 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") # Note: We are using "-O2" instead of "-Os" to avoid this known GCC bug: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46762 common_flags = [ "-c", "-Wall", "-Wextra", "-Wno-unused-parameter", "-Wno-missing-field-initializers", "-fmessage-length=0", "-fno-exceptions", "-fno-builtin", "-ffunction-sections", "-fdata-sections", "-fno-delete-null-pointer-checks", "-fomit-frame-pointer" ] + self.cpu if "save-asm" in self.options: common_flags.append("-save-temps") if "debug-info" in self.options: common_flags.append("-g") common_flags.append("-O0") else: common_flags.append("-O2") main_cc = join(tool_path, "arm-none-eabi-gcc") main_cppc = join(tool_path, "arm-none-eabi-g++") self.asm = [main_cc, "-x", "assembler-with-cpp"] + common_flags if not "analyze" in self.options: self.cc = [main_cc, "-std=gnu99"] + common_flags self.cppc = [main_cppc, "-std=gnu++98", "-fno-rtti"] + common_flags else: self.cc = [ join(GOANNA_PATH, "goannacc"), "--with-cc=" + main_cc.replace('\\', '/'), "-std=gnu99", "--dialect=gnu", '--output-format="%s"' % self.GOANNA_FORMAT ] + common_flags self.cppc = [ join(GOANNA_PATH, "goannac++"), "--with-cxx=" + main_cppc.replace('\\', '/'), "-std=gnu++98", "-fno-rtti", "--dialect=gnu", '--output-format="%s"' % self.GOANNA_FORMAT ] + common_flags self.ld = [ join(tool_path, "arm-none-eabi-gcc"), "-Wl,--gc-sections", "-Wl,--wrap,main" ] + self.cpu self.sys_libs = ["stdc++", "supc++", "m", "c", "gcc"] self.ar = join(tool_path, "arm-none-eabi-ar") self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")
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 not set(("ARM", "ARMC6")).intersection(set(target.supported_toolchains)): raise NotSupportedException("ARM/ARMC6 compiler support is required for ARMC6 build") if target.core.lower().endswith("fd"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-2]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-2]) self.SHEBANG += " -mcpu=%s" % target.core.lower()[:-2] elif target.core.lower().endswith("f"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-1]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-1]) self.SHEBANG += " -mcpu=%s" % target.core.lower()[:-1] elif target.core.lower().endswith("ns"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-3]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-3]) self.SHEBANG += " -mcpu=%s" % target.core.lower()[:-3] else: self.flags['common'].append("-mcpu=%s" % target.core.lower()) self.flags['ld'].append("--cpu=%s" % target.core.lower()) self.SHEBANG += " -mcpu=%s" % target.core.lower() if target.core == "Cortex-M4F": self.flags['common'].append("-mfpu=fpv4-sp-d16") self.flags['common'].append("-mfloat-abi=hard") elif target.core == "Cortex-M7F": self.flags['common'].append("-mfpu=fpv5-sp-d16") self.flags['common'].append("-mfloat-abi=softfp") elif target.core == "Cortex-M7FD": self.flags['common'].append("-mfpu=fpv5-d16") self.flags['common'].append("-mfloat-abi=softfp") elif target.core.startswith("Cortex-M23"): self.flags['common'].append("-march=armv8-m.base") elif target.core.startswith("Cortex-M33"): self.flags['common'].append("-march=armv8-m.main") if target.core == "Cortex-M23" or target.core == "Cortex-M33": self.flags['common'].append("-mcmse") # Create Secure library if ((target.core == "Cortex-M23" or self.target.core == "Cortex-M33") and kwargs.get('build_dir', False)): 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 == "Cortex-M23-NS" or self.target.core == "Cortex-M33-NS": define_string = self.make_ld_define("__DOMAIN_NS", 1) self.flags["ld"].append(define_string) asm_cpu = { "Cortex-M0+": "Cortex-M0", "Cortex-M4F": "Cortex-M4.fp", "Cortex-M7F": "Cortex-M7.fp.sp", "Cortex-M7FD": "Cortex-M7.fp.dp", "Cortex-M23-NS": "Cortex-M23", "Cortex-M33-NS": "Cortex-M33" }.get(target.core, target.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.flags['asm'] self.ld = [join(TOOLCHAIN_PATHS["ARMC6"], "armlink")] + self.flags['ld'] self.ar = [join(TOOLCHAIN_PATHS["ARMC6"], "armar")] self.elf2bin = join(TOOLCHAIN_PATHS["ARMC6"], "fromelf")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M7F": cpuchoice = "Cortex-M7" else: cpuchoice = target.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", cpuchoice] # custom c flags c_flags_cmd = [ "--cpu", cpuchoice, "--thumb", "--dlib_config", join(IAR_PATH, "inc", "c", "DLib_Config_Full.h") ] # custom c++ cmd flags cxx_flags_cmd = ["--c++", "--no_rtti", "--no_exceptions"] if target.core == "Cortex-M7F": asm_flags_cmd += ["--fpu", "VFPv5_sp"] c_flags_cmd.append("--fpu=VFPv5_sp") if "debug-info" in self.options: c_flags_cmd.append("-r") c_flags_cmd.append("-On") else: c_flags_cmd.append("-Oh") IAR_BIN = join(IAR_PATH, "bin") main_cc = join(IAR_BIN, "iccarm") self.asm = [join(IAR_BIN, "iasmarm") ] + asm_flags_cmd + self.flags["asm"] if not "analyze" in self.options: self.cc = [main_cc] self.cppc = [main_cc] else: self.cc = [ join(GOANNA_PATH, "goannacc"), '--with-cc="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT ] self.cppc = [ join(GOANNA_PATH, "goannac++"), '--with-cxx="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT ] self.cc += self.flags["common"] + c_flags_cmd + self.flags["c"] self.cppc += self.flags[ "common"] + c_flags_cmd + cxx_flags_cmd + self.flags["cxx"] self.ld = join(IAR_BIN, "ilinkarm") self.ar = join(IAR_BIN, "iarchive") self.elf2bin = join(IAR_BIN, "ielftool")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M7F": cpuchoice = "Cortex-M7" else: cpuchoice = target.core self.flags["common"] += [ "--cpu=%s" % cpuchoice, "--thumb", "--dlib_config", join(IAR_PATH, "inc", "c", "DLib_Config_Full.h"), ] if target.core == "Cortex-M7F": self.flags["common"].append("--fpu=VFPv5_sp") if "debug-info" in self.options: self.flags["common"].append("-r") self.flags["common"].append("-On") else: self.flags["common"].append("-Oh") IAR_BIN = join(IAR_PATH, "bin") main_cc = join(IAR_BIN, "iccarm") self.flags["asm"] += ["--cpu", cpuchoice] if target.core == "Cortex-M7F": self.flags["asm"] += ["--fpu", "VFPv5_sp"] self.asm = [join(IAR_BIN, "iasmarm")] + self.flags["asm"] if not "analyze" in self.options: self.cc = [main_cc] self.cppc = [main_cc] else: self.cc = [ join(GOANNA_PATH, "goannacc"), '--with-cc="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT ] self.cppc = [ join(GOANNA_PATH, "goannac++"), '--with-cxx="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT ] self.cc += self.flags["common"] + self.flags["c"] self.cppc += self.flags["common"] + self.flags["cxx"] self.ld = join(IAR_BIN, "ilinkarm") self.ar = join(IAR_BIN, "iarchive") self.elf2bin = join(IAR_BIN, "ielftool")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M7F" or target.core == "Cortex-M7FD": cpuchoice = "Cortex-M7" else: cpuchoice = target.core if not TOOLCHAIN_PATHS['IAR']: exe = find_executable('iccarm') if exe: TOOLCHAIN_PATHS['IAR'] = dirname(dirname(exe)) # 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 if target.core == "Cortex-M4F": asm_flags_cmd = [ "--cpu", "Cortex-M4F" ] else: asm_flags_cmd = [ "--cpu", cpuchoice ] # custom c flags if target.core == "Cortex-M4F": c_flags_cmd = [ "--cpu", "Cortex-M4F", "--thumb", "--dlib_config", join(TOOLCHAIN_PATHS['IAR'], "inc", "c", "DLib_Config_Full.h") ] else: c_flags_cmd = [ "--cpu", cpuchoice, "--thumb", "--dlib_config", join(TOOLCHAIN_PATHS['IAR'], "inc", "c", "DLib_Config_Full.h") ] # custom c++ cmd flags cxx_flags_cmd = [ "--c++", "--no_rtti", "--no_exceptions" ] if target.core == "Cortex-M7FD": asm_flags_cmd += ["--fpu", "VFPv5"] c_flags_cmd.append("--fpu=VFPv5") elif target.core == "Cortex-M7F": asm_flags_cmd += ["--fpu", "VFPv5_sp"] c_flags_cmd.append("--fpu=VFPv5_sp") if "debug-info" in self.options: c_flags_cmd.append("-r") c_flags_cmd.append("-On") else: c_flags_cmd.append("-Oh") IAR_BIN = join(TOOLCHAIN_PATHS['IAR'], "bin") main_cc = join(IAR_BIN, "iccarm") self.asm = [join(IAR_BIN, "iasmarm")] + asm_flags_cmd + self.flags["asm"] self.cc = [main_cc] self.cppc = [main_cc] self.cc += self.flags["common"] + c_flags_cmd + self.flags["c"] self.cppc += self.flags["common"] + c_flags_cmd + cxx_flags_cmd + self.flags["cxx"] self.ld = join(IAR_BIN, "ilinkarm") self.ar = join(IAR_BIN, "iarchive") self.elf2bin = join(IAR_BIN, "ielftool") self.toolchain_path = TOOLCHAIN_PATHS['IAR']
def __init__(self, target, notify=None, macros=None, silent=False, tool_path="", extra_verbose=False, build_profile=None): mbedToolchain.__init__(self, target, notify, macros, silent, extra_verbose=extra_verbose, build_profile=build_profile) if target.core == "Cortex-M0+": cpu = "cortex-m0plus" elif target.core == "Cortex-M4F": cpu = "cortex-m4" elif target.core == "Cortex-M7F": cpu = "cortex-m7" elif target.core == "Cortex-M7FD": cpu = "cortex-m7" else: cpu = target.core.lower() self.cpu = ["-mcpu=%s" % cpu] if target.core.startswith("Cortex"): self.cpu.append("-mthumb") # FPU handling, M7 possibly to have double FPU if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": self.cpu.append("-mfpu=fpv5-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.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"] self.ar = join(tool_path, "arm-none-eabi-ar") self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, tool_path="", extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M0+": cpu = "cortex-m0plus" elif target.core == "Cortex-M4F": cpu = "cortex-m4" elif target.core == "Cortex-M7F": cpu = "cortex-m7" else: cpu = target.core.lower() self.cpu = ["-mcpu=%s" % cpu] if target.core.startswith("Cortex"): self.cpu.append("-mthumb") if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": 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") # Note: We are using "-O2" instead of "-Os" to avoid this known GCC bug: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46762 self.flags["common"] += self.cpu if "save-asm" in self.options: self.flags["common"].append("-save-temps") if "debug-info" in self.options: self.flags["common"].append("-g") self.flags["common"].append("-O0") else: self.flags["common"].append("-O2") 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"] if not "analyze" in self.options: self.cc = [main_cc] self.cppc = [main_cppc] else: self.cc = [ join(GOANNA_PATH, "goannacc"), "--with-cc=" + main_cc.replace('\\', '/'), "--dialect=gnu", '--output-format="%s"' % self.GOANNA_FORMAT ] self.cppc = [ join(GOANNA_PATH, "goannac++"), "--with-cxx=" + main_cppc.replace('\\', '/'), "--dialect=gnu", '--output-format="%s"' % self.GOANNA_FORMAT ] 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"] self.ar = join(tool_path, "arm-none-eabi-ar") self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")
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.flags['asm'] self.ld = [join(TOOLCHAIN_PATHS["ARMC6"], "armlink") ] + self.flags['ld'] self.ar = join(TOOLCHAIN_PATHS["ARMC6"], "armar") self.elf2bin = join(TOOLCHAIN_PATHS["ARMC6"], "fromelf")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, tool_path="", extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M0+": cpu = "cortex-m0plus" elif target.core == "Cortex-M4F": cpu = "cortex-m4" elif target.core == "Cortex-M7F": cpu = "cortex-m7" elif target.core == "Cortex-M7FD": cpu = "cortex-m7" else: cpu = target.core.lower() self.cpu = ["-mcpu=%s" % cpu] if target.core.startswith("Cortex"): self.cpu.append("-mthumb") # FPU handling, M7 possibly to have double FPU if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": self.cpu.append("-mfpu=fpv5-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.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") # Note: We are using "-O2" instead of "-Os" to avoid this known GCC bug: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46762 self.flags["common"] += self.cpu if "save-asm" in self.options: self.flags["common"].append("-save-temps") if "debug-info" in self.options: self.flags["common"].append("-g") self.flags["common"].append("-O0") else: self.flags["common"].append("-Os") 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"] self.ar = join(tool_path, "arm-none-eabi-ar") self.elf2bin = join(tool_path, "arm-none-eabi-objcopy") if tool_path: self.toolchain_path = main_cc else: self.toolchain_path = find_executable("arm-none-eabi-gcc") or ''
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 CORE_ARCH[target.core] < 8: self.notify.cc_info({ 'severity': "Error", 'file': "", 'line': "", 'col': "", 'message': "ARMC6 does not support ARM architecture v{}" " targets".format(CORE_ARCH[target.core]), 'text': '', 'target_name': self.target.name, 'toolchain_name': self.name }) if not set( ("ARM", "ARMC6")).intersection(set(target.supported_toolchains)): raise NotSupportedException( "ARM/ARMC6 compiler support is required for ARMC6 build") 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.flags['asm'] self.ld = [join(TOOLCHAIN_PATHS["ARMC6"], "armlink") ] + self.flags['ld'] self.ar = join(TOOLCHAIN_PATHS["ARMC6"], "armar") self.elf2bin = join(TOOLCHAIN_PATHS["ARMC6"], "fromelf")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, tool_path="", extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M0+": cpu = "cortex-m0plus" elif target.core == "Cortex-M4F": cpu = "cortex-m4" elif target.core == "Cortex-M7F": cpu = "cortex-m7" elif target.core == "Cortex-M7FD": cpu = "cortex-m7" else: cpu = target.core.lower() self.cpu = ["-mcpu=%s" % cpu] if target.core.startswith("Cortex"): self.cpu.append("-mthumb") # FPU handling, M7 possibly to have double FPU if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": self.cpu.append("-mfpu=fpv5-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.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") # Note: We are using "-O2" instead of "-Os" to avoid this known GCC bug: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46762 self.flags["common"] += self.cpu if "save-asm" in self.options: self.flags["common"].append("-save-temps") if "debug-info" in self.options: self.flags["common"].append("-g") self.flags["common"].append("-O0") else: self.flags["common"].append("-Os") 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"] self.ar = join(tool_path, "arm-none-eabi-ar") self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M7F": cpuchoice = "Cortex-M7" else: cpuchoice = target.core c_flags = [ "--cpu=%s" % cpuchoice, "--thumb", "--dlib_config", join(IAR_PATH, "inc", "c", "DLib_Config_Full.h"), "-e", # Enable IAR language extension "--no_wrap_diagnostics", # Pa050: No need to be notified about "non-native end of line sequence" # Pa084: Pointless integer comparison -> checks for the values of an enum, but we use values outside of the enum to notify errors (ie: NC). # Pa093: Implicit conversion from float to integer (ie: wait_ms(85.4) -> wait_ms(85)) # Pa082: Operation involving two values from two registers (ie: (float)(*obj->MR)/(float)(LPC_PWM1->MR0)) "--diag_suppress=Pa050,Pa084,Pa093,Pa082", ] if target.core == "Cortex-M7F": c_flags.append("--fpu=VFPv5_sp") if "debug-info" in self.options: c_flags.append("-On") else: c_flags.append("-Oh") # add debug symbols for all builds c_flags.append("-r") IAR_BIN = join(IAR_PATH, "bin") main_cc = join(IAR_BIN, "iccarm") self.asm = [join(IAR_BIN, "iasmarm")] + ["--cpu", cpuchoice] if not "analyze" in self.options: self.cc = [main_cc] + c_flags self.cppc = [main_cc, "--c++", "--no_rtti", "--no_exceptions" ] + c_flags else: self.cc = [ join(GOANNA_PATH, "goannacc"), '--with-cc="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT ] + c_flags self.cppc = [ join(GOANNA_PATH, "goannac++"), '--with-cxx="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT ] + ["--c++", "--no_rtti", "--no_exceptions"] + c_flags self.ld = join(IAR_BIN, "ilinkarm") self.ar = join(IAR_BIN, "iarchive") self.elf2bin = join(IAR_BIN, "ielftool")
def __init__(self, target, notify=None, macros=None, silent=False, extra_verbose=False, build_profile=None, build_dir=None): mbedToolchain.__init__(self, target, notify, macros, silent, extra_verbose=extra_verbose, 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"): # Legacy 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 == "Cortex-M0+": cpu = "cortex-m0plus" elif target.core == "Cortex-M4F": cpu = "cortex-m4" elif target.core == "Cortex-M7F": cpu = "cortex-m7" elif target.core == "Cortex-M7FD": cpu = "cortex-m7" else: cpu = target.core.lower() self.cpu = ["-mcpu=%s" % cpu] if target.core.startswith("Cortex-M"): self.cpu.append("-mthumb") # FPU handling, M7 possibly to have double FPU if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": self.cpu.append("-mfpu=fpv5-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.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")
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 not set( ("ARM", "ARMC6")).intersection(set(target.supported_toolchains)): raise NotSupportedException( "ARM/ARMC6 compiler support is required for ARMC6 build") if target.core.lower().endswith("fd"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-2]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-2]) self.SHEBANG += " -mcpu=%s" % target.core.lower()[:-2] elif target.core.lower().endswith("f"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-1]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-1]) self.SHEBANG += " -mcpu=%s" % target.core.lower()[:-1] elif target.core.lower().endswith("ns"): self.flags['common'].append("-mcpu=%s" % target.core.lower()[:-3]) self.flags['ld'].append("--cpu=%s" % target.core.lower()[:-3]) self.SHEBANG += " -mcpu=%s" % target.core.lower()[:-3] else: self.flags['common'].append("-mcpu=%s" % target.core.lower()) self.flags['ld'].append("--cpu=%s" % target.core.lower()) self.SHEBANG += " -mcpu=%s" % target.core.lower() if target.core == "Cortex-M4F": self.flags['common'].append("-mfpu=fpv4-sp-d16") self.flags['common'].append("-mfloat-abi=hard") elif target.core == "Cortex-M7F": self.flags['common'].append("-mfpu=fpv5-sp-d16") self.flags['common'].append("-mfloat-abi=softfp") elif target.core == "Cortex-M7FD": self.flags['common'].append("-mfpu=fpv5-d16") self.flags['common'].append("-mfloat-abi=softfp") elif target.core.startswith("Cortex-M23"): self.flags['common'].append("-march=armv8-m.base") elif target.core.startswith("Cortex-M33"): self.flags['common'].append("-march=armv8-m.main") if target.core == "Cortex-M23" or target.core == "Cortex-M33": self.flags['common'].append("-mcmse") # Create Secure library if ((target.core == "Cortex-M23" or self.target.core == "Cortex-M33") and kwargs.get('build_dir', False)): 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 == "Cortex-M23-NS" or self.target.core == "Cortex-M33-NS": define_string = self.make_ld_define("__DOMAIN_NS", 1) self.flags["ld"].append(define_string) asm_cpu = { "Cortex-M0+": "Cortex-M0", "Cortex-M4F": "Cortex-M4.fp", "Cortex-M7F": "Cortex-M7.fp.sp", "Cortex-M7FD": "Cortex-M7.fp.dp", "Cortex-M23-NS": "Cortex-M23", "Cortex-M33-NS": "Cortex-M33" }.get(target.core, target.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.flags['asm'] self.ld = [join(TOOLCHAIN_PATHS["ARMC6"], "armlink") ] + self.flags['ld'] self.ar = [join(TOOLCHAIN_PATHS["ARMC6"], "armar")] self.elf2bin = join(TOOLCHAIN_PATHS["ARMC6"], "fromelf")
def __init__(self, target, options=None, notify=None, macros=None, silent=False, tool_path="", extra_verbose=False): mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose) if target.core == "Cortex-M0+": cpu = "cortex-m0plus" elif target.core == "Cortex-M4F": cpu = "cortex-m4" elif target.core == "Cortex-M7F": cpu = "cortex-m7" else: cpu = target.core.lower() self.cpu = ["-mcpu=%s" % cpu] if target.core.startswith("Cortex"): self.cpu.append("-mthumb") if target.core == "Cortex-M4F": self.cpu.append("-mfpu=fpv4-sp-d16") self.cpu.append("-mfloat-abi=softfp") elif target.core == "Cortex-M7F": 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") # Note: We are using "-O2" instead of "-Os" to avoid this known GCC bug: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46762 self.flags["common"] += self.cpu if "save-asm" in self.options: self.flags["common"].append("-save-temps") if "debug-info" in self.options: self.flags["common"].append("-g") self.flags["common"].append("-O0") else: self.flags["common"].append("-O2") 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"] if not "analyze" in self.options: self.cc = [main_cc] self.cppc =[main_cppc] else: self.cc = [join(GOANNA_PATH, "goannacc"), "--with-cc=" + main_cc.replace('\\', '/'), "--dialect=gnu", '--output-format="%s"' % self.GOANNA_FORMAT] self.cppc= [join(GOANNA_PATH, "goannac++"), "--with-cxx=" + main_cppc.replace('\\', '/'), "--dialect=gnu", '--output-format="%s"' % self.GOANNA_FORMAT] 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"] self.ar = join(tool_path, "arm-none-eabi-ar") self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")