Conditionally enable --ide=mbed from ARMC6 based on compiler version.

If the Mbed Studio build of ARMC6 is found, add the --ide=mbed to all
necessary executables.

Author: bridadan

tools/toolchains/arm.py

@@ -18,16 +18,17 @@
 from builtins import str  # noqa: F401
 
 import re
+import os
 from copy import copy
-from os.path import join, dirname, splitext, basename, exists, isfile
+from os.path import join, dirname, splitext, basename, exists, isfile, split
 from os import makedirs, write, remove
 from tempfile import mkstemp
 from shutil import rmtree
 from distutils.version import LooseVersion
 
 from tools.targets import CORE_ARCH
 from tools.toolchains.mbed_toolchain import mbedToolchain, TOOLCHAIN_PATHS
-from tools.utils import mkdir, NotSupportedException, run_cmd
+from tools.utils import mkdir, NotSupportedException, ToolException, run_cmd
 
 
 class ARM(mbedToolchain):
@@ -44,6 +45,7 @@ class ARM(mbedToolchain):
         "Cortex-M7", "Cortex-M7F", "Cortex-M7FD", "Cortex-A9"
     ]
     ARMCC_RANGE = (LooseVersion("5.06"), LooseVersion("5.07"))
+    ARMCC_PRODUCT_RE = re.compile(b"Product: (.*)")
     ARMCC_VERSION_RE = re.compile(b"Component: ARM Compiler (\d+\.\d+)")
 
     @staticmethod
@@ -103,11 +105,19 @@ def __init__(self, target, notify=None, macros=None,
 
         self.SHEBANG += " --cpu=%s" % cpu
 
+        self.product_name = None
+
     def version_check(self):
-        stdout, _, retcode = run_cmd([self.cc[0], "--vsn"], redirect=True)
+        # The --ide=mbed removes an instability with checking the version of
+        # the ARMC6 binary that comes with Mbed Studio
+        stdout, _, retcode = run_cmd(
+            [self.cc[0], "--vsn", "--ide=mbed"],
+            redirect=True
+        )
         msg = None
         min_ver, max_ver = self.ARMCC_RANGE
-        match = self.ARMCC_VERSION_RE.search(stdout.encode("utf-8"))
+        output = stdout.encode("utf-8")
+        match = self.ARMCC_VERSION_RE.search(output)
         if match:
             found_version = LooseVersion(match.group(1).decode("utf-8"))
         else:
@@ -132,6 +142,19 @@ def version_check(self):
                 "severity": "WARNING",
             })
 
+        msg = None
+        match = self.ARMCC_PRODUCT_RE.search(output)
+        if match:
+            self.product_name = match.group(1).decode("utf-8")
+        else:
+            self.product_name = None
+
+        if not match or len(match.groups()) != 1:
+            msg = (
+                "Could not detect product name: defaulting to professional "
+                "version of ARMC6"
+            )
+
     def _get_toolchain_labels(self):
         if getattr(self.target, "default_toolchain", "ARM") == "uARM":
             return ["ARM", "ARM_MICRO"]
@@ -275,7 +298,7 @@ def correct_scatter_shebang(self, scatter_file, cur_dir_name=None):
 
                 return new_scatter
 
-    def link(self, output, objects, libraries, lib_dirs, scatter_file):
+    def get_link_command(self, output, objects, libraries, lib_dirs, scatter_file):
         base, _ = splitext(output)
         map_file = base + ".map"
         args = ["-o", output, "--info=totals", "--map", "--list=%s" % map_file]
@@ -294,6 +317,13 @@ def link(self, output, objects, libraries, lib_dirs, scatter_file):
             link_files = self.get_link_file(cmd[1:])
             cmd = [cmd_linker, '--via', link_files]
 
+        return cmd
+
+    def link(self, output, objects, libraries, lib_dirs, scatter_file):
+        cmd = self.get_link_command(
+            output, objects, libraries, lib_dirs, scatter_file
+        )
+
         self.notify.cc_verbose("Link: %s" % ' '.join(cmd))
         self.default_cmd(cmd)
 
@@ -304,12 +334,15 @@ def archive(self, objects, lib_path):
             param = objects
         self.default_cmd([self.ar, '-r', lib_path] + param)
 
+    def get_binary_commands(self, bin_arg, bin, elf):
+        return [self.elf2bin, bin_arg, '-o', bin, elf]
+
     def binary(self, resources, elf, bin):
         _, fmt = splitext(bin)
         # On .hex format, combine multiple .hex files (for multiple load
         # regions) into one
         bin_arg = {".bin": "--bin", ".hex": "--i32combined"}[fmt]
-        cmd = [self.elf2bin, bin_arg, '-o', bin, elf]
+        cmd = self.get_binary_commands(bin_arg, bin, elf)
 
         # remove target binary file/path
         if exists(bin):
@@ -545,12 +578,21 @@ def __init__(self, target, *args, **kwargs):
         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 _get_toolchain_labels(self):
         if getattr(self.target, "default_toolchain", "ARM") == "uARM":
             return ["ARM", "ARM_MICRO", "ARMC6"]
         else:
             return ["ARM", "ARM_STD", "ARMC6"]
 
+    @property
+    def is_mbed_studio_armc6(self):
+        return self.product_name and "Mbed Studio" in self.product_name
+
     def parse_dependencies(self, dep_path):
         return mbedToolchain.parse_dependencies(self, dep_path)
 
@@ -576,10 +618,14 @@ def get_compile_options(self, defines, includes, for_asm=False):
         if config_header:
             opts.extend(self.get_config_option(config_header))
         if for_asm:
-            return [
+            opts = [
                 "--cpreproc",
                 "--cpreproc_opts=%s" % ",".join(self.flags['common'] + opts)
             ]
+
+        if self.is_mbed_studio_armc6:
+            opts.insert(0, "--ide=mbed")
+
         return opts
 
     def assemble(self, source, object, includes):
@@ -594,3 +640,21 @@ def compile(self, cc, source, object, includes):
         cmd.extend(self.get_compile_options(self.get_symbols(), includes))
         cmd.extend(["-o", object, source])
         return [cmd]
+
+    def get_link_command(self, output, objects, libraries, lib_dirs, scatter_file):
+        cmd = ARM.get_link_command(
+            self, output, objects, libraries, lib_dirs, scatter_file
+        )
+
+        if self.is_mbed_studio_armc6:
+            cmd.insert(1, "--ide=mbed")
+
+        return cmd
+
+    def get_binary_commands(self, bin_arg, bin, elf):
+        cmd = ARM.get_binary_commands(self, bin_arg, bin, elf)
+
+        if self.is_mbed_studio_armc6:
+            cmd.insert(1, "--ide=mbed")
+
+        return cmd