Add C++ instrumentation support

This commit adds the main chunks of C++ instrumentation support.

We also use this as an opportunity to refactor parts of the
instrumentation process, to avoid quite a lot of code duplication.

TN: V816-018
Change-Id: Idaf4be20c0df9b532008a914a7b08f08366fb87c

Author: Jugst3r

testsuite/SUITE/tutils.py

@@ -605,14 +605,14 @@ def xcov(args, out=None, err=None, inp=None, env=None, register_failure=True,
     covcmd = args[0]
     covargs = args[1:]
 
-    # gnatcov testsuite exercises C instrumentation, which is not activated by
-    # default.
+    # gnatcov testsuite exercises C/C++ instrumentation, which are not
+    # activated by default.
     if (
         auto_languages
         and not thistest.options.qualif_level
         and covcmd == "instrument"
     ):
-        covargs = ['--restricted-to-languages=Ada,C'] + covargs
+        covargs = ['--restricted-to-languages=Ada,C,C++'] + covargs
 
     if thistest.options.all_warnings:
         covargs = ['--all-warnings'] + covargs

tools/gnatcov/clang-wrapper.cc

@@ -30,7 +30,9 @@
 #include "clang-c/Index.h"
 #include "clang-c/Rewrite.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/ParentMapContext.h"
+#include "clang/AST/StmtCXX.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/ASTUnit.h"
@@ -96,24 +98,55 @@ clang_getBody (CXCursor C)
   if (clang_isDeclaration (C.kind))
     {
       if (const Decl *D = cxcursor::getCursorDecl (C))
-        if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
-          if (FD->doesThisDeclarationHaveABody ())
-            return MakeCXCursorWithNull (FD->getBody (), C);
+        switch (D->getKind ())
+          {
+          case Decl::FunctionTemplate:
+            return MakeCXCursorWithNull (
+              cast<FunctionTemplateDecl> (D)->getTemplatedDecl ()->getBody (),
+              C);
+          case Decl::Function:
+          case Decl::CXXMethod:
+          case Decl::CXXConstructor:
+          case Decl::CXXDestructor:
+          case Decl::CXXConversion:
+            {
+              const FunctionDecl *FD = cast<FunctionDecl> (D);
+              if (FD->doesThisDeclarationHaveABody ())
+                return MakeCXCursorWithNull (FD->getBody (), C);
+              break;
+            }
+          default:
+            return MakeCXCursorWithNull (D->getBody (), C);
+          }
     }
   else if (clang_isStatement (C.kind))
-    if (const Stmt *S = cxcursor::getCursorStmt (C))
-      switch (S->getStmtClass ())
+    {
+      if (const Stmt *S = cxcursor::getCursorStmt (C))
+        switch (S->getStmtClass ())
+          {
+            case Stmt::WhileStmtClass:
+              return MakeCXCursorWithNull (cast<WhileStmt> (S)->getBody (), C);
+            case Stmt::ForStmtClass:
+              return MakeCXCursorWithNull (cast<ForStmt> (S)->getBody (), C);
+            case Stmt::CXXForRangeStmtClass:
+              return MakeCXCursorWithNull
+                (cast<CXXForRangeStmt> (S)->getBody (), C);
+            case Stmt::DoStmtClass:
+              return MakeCXCursorWithNull (cast<DoStmt> (S)->getBody (), C);
+            case Stmt::SwitchStmtClass:
+              return MakeCXCursorWithNull (cast<SwitchStmt> (S)->getBody (), C);
+            default:
+              return clang_getNullCursor ();
+          }
+    }
+  else if (clang_isExpression (C.kind))
+    if (const Expr *E = cxcursor::getCursorExpr (C))
+      switch (E->getStmtClass ())
         {
-        default:
-          return clang_getNullCursor ();
-        case Stmt::WhileStmtClass:
-          return MakeCXCursorWithNull (cast<WhileStmt> (S)->getBody (), C);
-        case Stmt::ForStmtClass:
-          return MakeCXCursorWithNull (cast<ForStmt> (S)->getBody (), C);
-        case Stmt::DoStmtClass:
-          return MakeCXCursorWithNull (cast<DoStmt> (S)->getBody (), C);
-        case Stmt::SwitchStmtClass:
-          return MakeCXCursorWithNull (cast<SwitchStmt> (S)->getBody (), C);
+          case Expr::LambdaExprClass:
+            return MakeCXCursorWithNull (cast<LambdaExpr> (E)->getBody (), C);
+          default:
+            return clang_getNullCursor ();
         }
   return clang_getNullCursor ();
 }
@@ -295,17 +328,36 @@ clang_getOperatorLoc (CXCursor C)
   return cxloc::translateSourceLocation (CXXUnit->getASTContext (), sloc);
 }
 
-/* If the given expression is a paren expression, return the outermost
-   expression inside that is not a paren expression.  */
+/* If the given expression is a wrapping expression (i.e. a parenthesized
+   expression, a cast expression etc.), return the outermost expression inside
+   that is not a wrapping expression.  */
 
 extern "C" CXCursor
 clang_unwrap (CXCursor C)
 {
   if (clang_isExpression (C.kind))
     if (const Stmt *S = cxcursor::getCursorStmt (C))
-      if (S->getStmtClass () == Stmt::ParenExprClass)
-        return clang_unwrap (
-            MakeCXCursorWithNull (cast<ParenExpr> (S)->getSubExpr (), C));
+      switch (S->getStmtClass ())
+        {
+          case Stmt::ParenExprClass:
+            return clang_unwrap
+              (MakeCXCursorWithNull (cast<ParenExpr> (S)->getSubExpr (), C));
+          case Expr::ConstantExprClass:
+          case Expr::ExprWithCleanupsClass:
+            return clang_unwrap
+              (MakeCXCursorWithNull (cast<FullExpr> (S)->getSubExpr (), C));
+          case Expr::ImplicitCastExprClass:
+          case Expr::CStyleCastExprClass:
+          case Expr::CXXFunctionalCastExprClass:
+          case Expr::CXXStaticCastExprClass:
+          case Expr::CXXDynamicCastExprClass:
+          case Expr::CXXReinterpretCastExprClass:
+          case Expr::CXXConstCastExprClass:
+          case Expr::CXXAddrspaceCastExprClass:
+            return clang_unwrap
+              (MakeCXCursorWithNull (cast<CastExpr> (S)->getSubExpr (), C));
+
+        }
   return C;
 }
 

tools/gnatcov/command_line.ads

@@ -143,7 +143,8 @@ package Command_Line is
       Opt_Shared_Object,
       Opt_Restricted_To_Languages,
       Opt_Annotation_Format,
-      Opt_C_Opts);
+      Opt_C_Opts,
+      Opt_CPP_Opts);
    --  Set of string list options we support. More complete descriptions below.
 
    package Parser is new Argparse
@@ -1088,7 +1089,16 @@ package Command_Line is
              "List of additional compiler switches to analayze C source"
              & " files.",
            Commands  => (Cmd_Instrument => True, others => False),
-           Internal  => False)
+           Internal  => False),
+
+        Opt_CPP_Opts => Create
+          (Long_Name    => "--c++-opts",
+           Pattern      => "[COMMA-SEPARATED-OPTIONS]",
+           Help         =>
+             "List of additional compiler switches to analayze C++ source"
+             & " files.",
+           Commands     => (Cmd_Instrument => True, others => False),
+           Internal     => False)
      );
 
    procedure Bool_Callback

tools/gnatcov/instrument-ada_unit.adb

@@ -46,7 +46,6 @@ with SCOs;
 with Slocs;
 with Snames;              use Snames;
 with Strings;             use Strings;
-with Switches;
 with Table;
 with Text_Files;          use Text_Files;
 

tools/gnatcov/instrument-ada_unit.ads

@@ -31,6 +31,7 @@ with Libadalang.Rewriting; use Libadalang.Rewriting;
 with Instrument.Base_Types; use Instrument.Base_Types;
 with Instrument.Common;     use Instrument.Common;
 with SC_Obligations;        use SC_Obligations;
+with Switches;
 with Types;                 use Types;
 
 package Instrument.Ada_Unit is
@@ -39,6 +40,10 @@ package Instrument.Ada_Unit is
      null record;
    --  Instrumentation primitives for Ada
 
+   overriding function Language
+     (Self : Ada_Instrumenter_Type) return Switches.Src_Supported_Language
+   is (Switches.Ada_Language);
+
    overriding procedure Instrument_Unit
      (Self      : Ada_Instrumenter_Type;
       CU_Name   : Compilation_Unit_Name;

tools/gnatcov/instrument-base_types.adb

@@ -35,7 +35,8 @@ package body Instrument.Base_Types is
    begin
       return (case Language is
               when Ada_Language => Unit_Based_Language,
-              when C_Language   => File_Based_Language);
+              when C_Language
+                 | CPP_Language => File_Based_Language);
    end Language_Kind;
 
    ------------