Merge branch 'leo/111-ccg_testing' into 'master'

Adapt gnatcov_rts for CCG and add support for CCG testing in the testsuite

See merge request eng/das/cov/gnatcoverage!333

This MR brings various changes related to CCG support:

* A configuration option in gnatcov_rts to be able to ignore the C sources, to be compatible with CCG
* various preparatory changes in the testsuite:
  * The possibility to use an alternate builder in an altrun
  * Missing test.opt settings for native light runtime configuration
* More configurability in libsupport, to be able to override the last chance handler heuristics and pass cargs on the command line
* And a new altrun to be able to build test executables through CCG, for a native target only.

A MR will follow in Anod to schedule a run with CCG.

Part of eng/das/cov/gnatcoverage#111

Author: leocreuse

.gitignore

@@ -24,6 +24,8 @@ lib
 /testsuite/suite.cgpr
 /testsuite/support
 /testsuite/tmp
+/testsuite/altrun/ccg_native/ccg_gnatcov_rts
+/testsuite/altrun/ccg_native/adainclude
 gnatcov-loc.xml
 gnatinspect.db
 README.html

doc/gnatcov/src_traces.rst

@@ -972,6 +972,7 @@ the default coverage runtime library, in practice only one use case is
 supported currently: changing the behavior of the
 ``--dump-channel=base64-stdout`` instrumentation option.
 
+.. _custom_base_64:
 
 Customize the ``base64-stdout`` dump channel
 --------------------------------------------
@@ -1037,3 +1038,71 @@ file so that it implements the interface described in the (unmodified)
      const char *str;
      size_t length;
    };
+
+Building instrumented programs with CCG
+=======================================
+
+Programs instrumented with |gcvins| can be built using the
+`GNAT Pro Common Code Generator <https://docs.adacore.com/live/wave/gnat-ccg/html/gnatccg_ug/gnat_ccg.html>`_
+provided a few modifications are made to the coverage runtime, and
+respecting some limitations in terms of dump-trigger and dump-channel choice.
+
+Customizing the runtime
+-----------------------
+
+Given the workflow associated with CCG, it is not possible to use the |gcvstp|
+command to setup the coverage runtime. Instead, it must be prepared manually.
+
+The coverage runtime contains both Ada and C sources. When using CCG through
+GPRbuild, projects containing C sources are not well handled and some steps of
+the build procedure won't be executed. There thus is an external variable to
+remove all C sources from the project. This means that C sources must be
+manually managed during the executable compilation later on.
+
+The first step is to copy the runtime sources in a dedicated directory. For the
+remainder of this section, it will be denoted by ``ccg_gnatcov_rts``.
+
+.. code-block:: sh
+
+   mkdir ccg_gnatcov_rts
+   cp -r <gnatdas_install_dir>/share/gnatcoverage/gnatcov_rts ccg_gnatcov_rts
+
+Then, C sources not relevant to the coverage runtime for the CCG configuration
+must be deleted:
+
+.. code-block:: sh
+
+   rm ccg_gnatcov_rts/gnatcov_rts_c-base-io.c
+   rm ccg_gnatcov_rts/gnatcov_rts_c-trace-output-files.*
+   rm ccg_gnatcov_rts/gnatcov_rts_c-os_interface.*
+
+Finally, it is necessary to modify the contents of
+``ccg_gnatcov_rts/gnatcov_rts-base_io.adb`` to use an alternate medium on which
+the execution trace will be output. By default this relies on ``GNAT.IO``,
+which is not available in the CCG runtime. It is possible to replace occurrences
+of this unit by ``Ada.Text_IO``, which is supported by CCG, but which relies on
+the C standard function ``putchar``. Otherwise, see :ref:`custom_base_64` for
+more details on the expected interface to dump the coverage trace information.
+
+Building an instrumented program with CCG
+-----------------------------------------
+
+Building an instrumented program with CCG is done in the same manner as with
+any other target, with the exception that GPRbuild must be instructed to use
+the custom coverage runtime prepared in the previous step, and by setting an
+external variable to configure the coverage runtime project for a build with
+CCG:
+
+.. code-block:: sh
+
+   gprbuild -P <user_project.gpr> --src-subdirs=gnatcov-instr \
+     --implicit-with=ccg_gnatcov_rts/gnatcov_rts.gpr \
+     -XGNATCOV_RTS_FOR_CCG=true \
+     <relevant target cargs>
+
+After the generation of C sources is complete, all the coverage runtime C sources
+must be included in the build process of the executable. These can be found
+under ``ccg_gnatcov_rts/`` for the sources already present before the gprbuild
+invocation, and under ``ccg_gnatcov_rts/obj-gnatcov_rts.static`` for the sources
+generated by CCG. The C sources generated from the instrumented Ada sources will
+be available in the object directory of their corresponding project.

testsuite/Qualif/Ada/decision/MixedConstructs/If_ElsAbs/test.opt

@@ -0,0 +1 @@
+c XFAIL Runtime check bug in CCG, see eng/toolchain/gnat-llvm#73

testsuite/Qualif/Ada/stmt/1_Core/13_Representation/MachineCode/Inserts_In_Cond/test.opt

@@ -0,0 +1 @@
+c DEAD ASM inlining not supported by CCG

testsuite/Qualif/Ada/stmt/Robustness/Multinops/test.opt

@@ -0,0 +1 @@
+c DEAD ASM inlining not supported by CCG

testsuite/Qualif/Appendix/Testsuite/Selftest/assert-failure/test.opt

@@ -0,0 +1 @@
+native,RTS_ZFP DEAD Test assumes bin file available on native platform

testsuite/SUITE/context.py

@@ -459,6 +459,12 @@ def suite_covpgm_for(self, cmd):
         """
         return getattr(thistest.options, 'gnatcov_%s' % cmd, None)
 
+    def suite_gprpgm_for(self, pgm):
+        """
+        Alternate program to launch in lieu of "gpr<tool>",
+        """
+        return getattr(thistest.options, pgm, None)
+
     def support_dir(self):
         return os.path.join(ROOT_DIR, 'support')
 

testsuite/SUITE/control.py

@@ -241,20 +241,29 @@ def __init__(self, runtime_name=None):
         self.has_kernel_runtime = False
         self.has_light_runtime = False
         self.has_exception_propagation = True
+        self.discrs = []
 
         if not self.runtime_name:
             self.has_full_runtime = True
+            self.discrs = ["RTS_FULL"]
         elif 'embedded' in self.runtime_name:
             self.has_ravenscar_runtime = True
+            self.discrs = ["RTS_RAVENSCAR", "RTS_EMBEDDED"]
         elif 'light-tasking' in self.runtime_name:
             self.has_ravenscar_runtime = True
             self.has_exception_propagation = False
+            self.discrs = ["RTS_RAVENSCAR", "RTS_LIGHT_TASKING"]
         elif self.runtime_name.startswith('zfp'):
             self.has_light_runtime = True
             self.has_exception_propagation = False
-        elif self.runtime_name.startswith('light-'):
+            self.discrs = ["RTS_ZFP"]
+        elif (
+            self.runtime_name == "light" 
+            or self.runtime_name.startswith('light-')
+        ):
             self.has_light_runtime = True
             self.has_exception_propagation = False
+            self.discrs = ["RTS_ZFP"]
         elif self.runtime_name == 'kernel':
             self.has_kernel_runtime = True
         else:
@@ -273,12 +282,19 @@ def gnatcov_rts_project(self):
             else 'gnatcov_rts'
         )
 
-def runtime_info(runtime=None):
-    if runtime is None:
-        runtime = env.main_options.RTS
+def _runtime_info(runtime, target):
+    if target == "c":
+        assert not runtime
+        # CCG's runtime has no name, but it is for our purposes equivalent
+        # to a light runtime.
+        runtime = "light"
     return RuntimeInfo(runtime)
 
 
+def runtime_info():
+    return _runtime_info(env.main_options.RTS, env.target.platform)
+
+
 # Target specificities. We don't have many variants but need to match each
 # against a few possible triplets.
 
@@ -381,16 +397,19 @@ def gnatcov_info():
                      ('pre', 'testcase'),
                      ('post', 'testcase'))
 
+# Allowed alternatives for the --gpr<tool> family of command line options
+ALTRUN_GPR = ('gprbuild', )
 
-def altrun_opt_for(p0, p1):
+
+def altrun_opt_for(p0, p1=None):
     """Name of the command line option controlling the ALTRUN (P0, P1) pair."""
-    return "%s_%s" % (p0, p1)
+    return "%s_%s" % (p0, p1) if p1 else p0
 
 
-def altrun_attr_for(p0, p1):
+def altrun_attr_for(p0, p1=None):
     """Name of our internal controlling options attribute for the
     ALTRUN (P0, P1) pair."""
-    return "%s_%s" % (p0, p1)
+    return "%s_%s" % (p0, p1) if p1 else p0
 
 
 def cargs_opt_for(lang):
@@ -419,6 +438,14 @@ def add_shared_options_to(parser, toplevel):
             metavar="CMD",
             help='Use CMD instead of "%s %s"' % (pgm, cmd))
 
+    # --gpr<tool> family
+    for pgm in ALTRUN_GPR:
+        parser.add_argument(
+            f'--{altrun_opt_for(pgm)}', dest=altrun_attr_for(pgm),
+            metavar="CMD",
+            help=f'use CMD instead of "{pgm}"'
+        )
+
     # Valgrind control
     parser.add_argument(
         '--enable-valgrind', dest='enable_valgrind',

testsuite/SUITE/tutils.py

@@ -291,7 +291,12 @@ def gprbuild(project,
     # Now cleanup, do build and check status
     thistest.cleanup(project)
 
-    args = (to_list(BUILDER.BASE_COMMAND) +
+    builder = thistest.suite_gprpgm_for(os.path.basename(BUILDER.BASE_COMMAND))
+
+    if builder is None:
+        builder = BUILDER.BASE_COMMAND
+
+    args = (to_list(builder) +
             ['-P%s' % project] + all_gargs + all_cargs + all_largs)
     p = run_and_log(args, output=out, timeout=thistest.options.timeout)
     if register_failure:
@@ -836,7 +841,7 @@ def run_cov_program(executable, out=None, env=None, exec_args=None,
     inp = None
 
     # If we are in a cross configuration, run the program using GNATemulator
-    if thistest.options.target:
+    if thistest.options.target and thistest.env.target.platform != "c":
         kernel = thistest.options.kernel
         board = thistest.options.board or thistest.env.target.machine
         args.append('{}-gnatemu'.format(thistest.env.target.triplet))
@@ -852,6 +857,14 @@ def run_cov_program(executable, out=None, env=None, exec_args=None,
         # failing. Redirecting the standard input to /dev/null works around
         # this issue.
         inp = DEVNULL
+    else:
+        # Native programs using a light runtime can't set the exit code, and
+        # will often terminate with a non-zero status code even though nothing
+        # went wrong. There is thus no point in checking the exit code in this
+        # configuration.
+        register_failure = (
+            register_failure and not RUNTIME_INFO.has_light_runtime
+        )
 
     args.append(executable)
     args.extend(exec_args)