Improve tooling compatibility for alternative configurations []

Author: wchilders-nvidia

dev_tools/pylibs/edgtest/exec/__init__.py

@@ -31,6 +31,8 @@
 from edgtest import runtest
 from edgtest.filter import (
   BuildConstants,
+  GNU_MODE,
+  MICROSOFT_MODE,
   Normalizer as OutputNormalizer
 )
 
@@ -46,6 +48,19 @@
   r'(?:^|(?<=\s))--target(?:=|\s+)(\S+)'
 )
 
+# Match, per target mode, the options that are only accepted by front ends
+# built to support that mode (including abbreviations and --no_ forms) in
+# joined option strings.  The Microsoft options are --microsoft...; the GNU
+# options are --gnu..., --g++, --gcc..., and --clang....
+_MODE_OPTION_REGEXES = {
+  MICROSOFT_MODE: re.compile(
+    r'(^|(?<=\s))--(no_)?microsoft\w*'
+  ),
+  GNU_MODE: re.compile(
+    r'(^|(?<=\s))--(no_)?(gnu\w*|g\+\+|gcc\w*|clang\w*)'
+  )
+}
+
 def get_output_filename(env: Dict[str, str],
                         case_number: int,
                         command_number: int) -> str:
@@ -993,6 +1008,18 @@ def _case_requests_unsupported_target(
       return True
   return False
 
+def _case_requests_unsupported_mode(
+    cmd_opts: List[str],
+    cmd_case_opts: List[str],
+    target_modes: FrozenSet[str]
+) -> bool:
+  '''True if any base/case option needs a target mode the build lacks.'''
+  options_str = ' '.join([*cmd_opts, *cmd_case_opts])
+  for mode, option_regex in _MODE_OPTION_REGEXES.items():
+    if mode not in target_modes and option_regex.search(options_str):
+      return True
+  return False
+
 async def run_test(test_path: Path, *, top_dir: Path, output_dir: Path,
                    env: Dict[str, str], build_constants: BuildConstants,
                    faster_mode: bool, update_recording: bool, debug_mode: bool,
@@ -1120,6 +1147,21 @@ async def run_test(test_path: Path, *, top_dir: Path, output_dir: Path,
           ))
           continue
 
+        if _case_requests_unsupported_mode(
+          cmd_opts,
+          cmd_case_opts,
+          build_constants.target_modes
+        ):
+          # Case requests a Microsoft or GNU mode that this front end was not
+          # built to support.
+          test_results.append(make_requirements_not_met_status(
+            test_path,
+            mode,
+            test_descript.remark,
+            _case_options_tag(case_number, cmd_case_opts)
+          ))
+          continue
+
         case_artifact_dir = tmp_dir / str(case_number)
         case_artifact_dir.mkdir()
 

dev_tools/pylibs/edgtest/filter/__init__.py

@@ -24,6 +24,33 @@
   re.MULTILINE
 )
 
+def _check_config_enables_macro(config_dump: str, macro: str) -> bool:
+  '''True if the dumped configuration defines macro as enabled (1 or TRUE).
+
+  A macro that the dump reports as "not defined" is treated as disabled.
+  '''
+  return re.search(
+    rf'#define[ \t]+{re.escape(macro)}[ \t]+(1|TRUE)\s',
+    config_dump
+  ) is not None
+
+# Target modes whose command-line options are only accepted by front ends
+# built with the corresponding configuration macro.
+MICROSOFT_MODE = 'microsoft'
+GNU_MODE = 'gnu'
+
+_TARGET_MODE_CONFIG_MACROS = {
+  MICROSOFT_MODE: 'MICROSOFT_EXTENSIONS_ALLOWED',
+  GNU_MODE: 'GNU_EXTENSIONS_ALLOWED'
+}
+
+def _parse_target_modes(config_dump: str) -> FrozenSet[str]:
+  '''Collect the target modes (e.g., MICROSOFT_MODE) this build supports.'''
+  return frozenset(
+    mode for mode, macro in _TARGET_MODE_CONFIG_MACROS.items()
+    if _check_config_enables_macro(config_dump, macro)
+  )
+
 def _parse_target_configurations(config_dump: str) -> FrozenSet[str]:
   '''Collect --target names supported by this front-end build.'''
   targets: Set[str] = set(
@@ -37,11 +64,13 @@ def _parse_target_configurations(config_dump: str) -> FrozenSet[str]:
 class BuildConstants:
   def __init__(self, version: str, build_timestamp: str,
                config_dump: str,
-               target_configurations: FrozenSet[str]) -> None:
+               target_configurations: FrozenSet[str],
+               target_modes: FrozenSet[str]) -> None:
     self.version = version
     self.build_timestamp = build_timestamp
     self.config_dump = config_dump
     self.target_configurations = target_configurations
+    self.target_modes = target_modes
 
 async def load_build_constants(compiler_bin: Path) -> BuildConstants:
   config_dump_proc = await asyncio.create_subprocess_exec(
@@ -71,7 +100,8 @@ async def load_build_constants(compiler_bin: Path) -> BuildConstants:
     version_number,
     build_date,
     config_dump,
-    _parse_target_configurations(config_dump)
+    _parse_target_configurations(config_dump),
+    _parse_target_modes(config_dump)
   )
 
 _REGEX_REPLACEMENTS = {

util/eccp.sh

@@ -404,6 +404,11 @@ std_incl=1
 #
 instantiation_mode_specified=0
 #
+# Flag indicating that the --building_runtime option was specified (i.e., the
+# runtime library is being built).
+#
+building_runtime=0
+#
 # Remove #line directives from the generated C
 #
 strip_line_dirs=0
@@ -1934,6 +1939,9 @@ process_option()
         --no_auto_instantiation)
           automatic_instantiation=0
           ;;
+        --building_runtime)
+          building_runtime=1
+          ;;
         -m | --c | --c89 | --c99 | --no_c99 | --c11 | --c18 | --c17 | --c23 | \
         --ms_c11 | --ms_c17 | --ms_c23 | -K | --old_c | --svr4 | --no_svr4 | \
         --gcc | --no_gcc | --upc | --no_upc)
@@ -2541,6 +2549,13 @@ if [ $c_mode -eq 1 ] ; then
   automatic_instantiation=0
 fi
 
+# The runtime library is built without automatic instantiation.  (Front ends
+# configured without AUTOMATIC_TEMPLATE_INSTANTIATION do not accept the
+# options the driver would otherwise pass to support it, e.g., --ii_file.)
+if [ $building_runtime -eq 1 ] ; then
+  automatic_instantiation=0
+fi
+
 # Put the command name on the beginning of the instantiation command line.
 # This is done here because a different name can be supplied on the
 # command line.  This is useful when the compile command is a script that