Merge branch 'peron/funcall-cxx-call-chains' into 'master'

Instrument.C(funcall): Instrument C++ method calls with generic witness

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

Fixes C++ case of #397

Author: RenjiSann

testsuite/tests/instr-cov/c_cpp_function_call_cov/cpp/nested-method-calls/src/pkg.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <cstdlib>
+
+class A
+{
+  int _x;
+
+public:
+  A (int x) : _x (x){};
+
+  int
+  get_x () const
+  {
+    return this->_x;
+  }
+};
+
+class B
+{
+  A _a;
+
+public:
+  B (A a) : _a (a){};
+
+  A
+  get_a () const
+  {
+    // Purposely exit early after dumping the buffers.
+    /* GNATCOV_DUMP_BUFFERS */
+    exit (0);
+    return this->_a;
+  }
+};

testsuite/tests/instr-cov/c_cpp_function_call_cov/cpp/nested-method-calls/src/test_exiting_method.cpp

@@ -0,0 +1,19 @@
+#include "pkg.h"
+
+int
+main (void)
+{
+  A a (5); // # var-decl
+  B b (a); // # var-decl
+
+  // .get_a() exits the program with 0 status code.
+  b            // # var-ref
+    .get_a (); // # method-call
+
+  // Program should not reach this point.
+}
+
+//# test_exiting_method.cpp
+// /var-decl/    l+ ## 0
+// /var-ref/     l+ ## 0
+// /method-call/ l+ ## 0

testsuite/tests/instr-cov/c_cpp_function_call_cov/cpp/nested-method-calls/src/test_shortcut_method_chain.cpp

@@ -0,0 +1,21 @@
+#include "pkg.h"
+
+int
+main (void)
+{
+  A a (5); // # var-decl
+  B b (a); // # var-decl
+
+  // .get_a() exits the program with 0 status code.
+  b            // # var-ref
+    .get_a ()  // # method-call
+    .get_x (); // # not-reached
+
+  /* GNATCOV_DUMP_BUFFERS */
+}
+
+//# test_shortcut_method_chain.cpp
+// /var-decl/    l+ ## 0
+// /var-ref/     l+ ## 0
+// /method-call/ l+ ## 0
+// /not-reached/ l! ## c-

testsuite/tests/instr-cov/c_cpp_function_call_cov/cpp/nested-method-calls/src/test_simple_call.cpp

@@ -0,0 +1,17 @@
+#include "pkg.h"
+
+int
+main (void)
+{
+  A a (5); // # var-decl
+
+  a            // # var-ref
+    .get_x (); // # method-call
+
+  /* GNATCOV_DUMP_BUFFERS */
+}
+
+//# test_simple_call.cpp
+// /var-decl/    l+ ## 0
+// /var-ref/     l+ ## 0
+// /method-call/ l+ ## 0

testsuite/tests/instr-cov/c_cpp_function_call_cov/cpp/nested-method-calls/test.py

@@ -0,0 +1,13 @@
+"""
+This test ensures that method call instrumentation behaves correctly and
+produces the expected coverage.
+"""
+
+from SCOV.tc import TestCase
+from SCOV.tctl import CAT, CovControl
+from SUITE.context import thistest
+
+TestCase(category=CAT.stmt, fun_call_lvl=True).run(
+    covcontrol=CovControl(dump_trigger="manual")
+)
+thistest.result()

testsuite/tests/instr-cov/c_cpp_function_call_cov/cpp/non-prefixed-method-calls/src/test_non_prefix.cpp

@@ -0,0 +1,29 @@
+class A
+{
+  int _x;
+
+public:
+  A (int x) : _x (x){};
+
+  int
+  get_x () const
+  {
+    return this->_x;
+  }
+
+  int
+  get_x_plus_one () const
+  {
+    return get_x () + 1; // # non-prefix-call
+  }
+};
+
+int
+main (void)
+{
+  A (5).get_x_plus_one (); // # method-call
+}
+
+//# test_non_prefix.cpp
+// /non-prefix-call/ l+ ## 0
+// /method-call/     l+ ## 0

testsuite/tests/instr-cov/c_cpp_function_call_cov/cpp/non-prefixed-method-calls/test.py

@@ -0,0 +1,11 @@
+"""
+This test makes sure that the instrumentation of non-prefixed method calls
+works correctly.
+"""
+
+from SCOV.tc import TestCase
+from SCOV.tctl import CAT
+from SUITE.context import thistest
+
+TestCase(category=CAT.stmt, fun_call_lvl=True).run()
+thistest.result()

tools/gnatcov/clang-extensions.adb

@@ -85,6 +85,19 @@ package body Clang.Extensions is
       return Is_Instrumentable_Call_Expr_C (C) /= 0;
    end Is_Instrumentable_Call_Expr;
 
+   -------------------------------
+   --  Is_CXX_Member_Call_Expr  --
+   -------------------------------
+
+   function Is_Prefixed_CXX_Member_Call_Expr (C : Cursor_T) return Boolean is
+      function Is_CXX_Member_Call_Expr_C (C : Cursor_T) return unsigned
+        with
+          Import, Convention => C,
+          External_Name => "clang_isPrefixedCXXMemberCallExpr";
+   begin
+      return Is_CXX_Member_Call_Expr_C (C) /= 0;
+   end Is_Prefixed_CXX_Member_Call_Expr;
+
    --------------------
    -- Get_Opcode_Str --
    --------------------

tools/gnatcov/clang-extensions.ads

@@ -130,6 +130,33 @@ package Clang.Extensions is
    --  TODO??? Actually decide what to do for the rest, so Ctor/Dtor call
    --          coverage makes sense.
 
+   function Is_Prefixed_CXX_Member_Call_Expr (C : Cursor_T) return Boolean
+      with Inline;
+   --  Return True if the given cursor is a statement with type
+   --  Stmt::CXXMemberCallExprClass, and if it is a prefixed method call
+   --  (meaning not a method that is called from the body of another method
+   --  in which it is possible to simply omit `this->`).
+
+   function Get_CXX_Member_Call_Expr_SCO_Sloc_Range
+     (C : Cursor_T) return Source_Range_T
+      with
+         Import,
+         Convention => C,
+         External_Name => "clang_getCXXMemberCallExprSCOSlocRange";
+   --  Assume the given cursor is a Stmt::CXXMemberCallExprClass.
+   --  Given the expression is `Foo.Bar(Baz)`, it will return a source range
+   --  containing `.Bar`.
+
+   function Get_CXX_Member_Call_Expr_Base_Sloc_Range
+     (C : Cursor_T) return Source_Range_T
+      with
+         Import,
+         Convention => C,
+         External_Name => "clang_getCXXMemberCallExprBaseSlocRange";
+   --  Assume the given cursor is a Stmt::CXXMemberCallExprClass.
+   --  Given the expression is `Foo.Bar(Baz)`, it will return the source
+   --  range of `Foo`.
+
    function Is_Constexpr (C : Cursor_T) return Boolean with Inline;
 
    function Unwrap (C : Cursor_T) return Cursor_T

tools/gnatcov/clang-wrapper.cc

@@ -20,6 +20,8 @@
 /* Make sure we refer to the static version of symbols on Windows, not to DLL
    importers.  */
 
+#include "clang-c/CXSourceLocation.h"
+#include "clang/AST/Expr.h"
 #define CINDEX_NO_EXPORTS
 
 #include "libclang/CXCursor.h"
@@ -33,6 +35,7 @@
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ParentMapContext.h"
 #include "clang/AST/StmtCXX.h"
+#include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/ASTUnit.h"
@@ -351,7 +354,7 @@ clang_getLBracLocPlusOne (CXCursor C)
   return translateSLoc (TU, S->getLBracLoc ().getLocWithOffset (1));
 }
 
-extern "C" bool
+extern "C" unsigned
 clang_isInstrumentableCallExpr (CXCursor C)
 {
   if (!clang_isExpression (C.kind))
@@ -382,6 +385,76 @@ clang_isInstrumentableCallExpr (CXCursor C)
     }
 }
 
+// Return true if the cursor is C++ Method Call with an explicit base.
+extern "C" unsigned
+clang_isPrefixedCXXMemberCallExpr (CXCursor C)
+{
+  if (!clang_isExpression (C.kind))
+    return false;
+
+  const Expr *E = getCursorExpr (C);
+  if (E->getStmtClass () != Stmt::CXXMemberCallExprClass)
+    return false;
+
+  const CXXMemberCallExpr *MCE = cast<CXXMemberCallExpr> (E);
+  const MemberExpr *ME = cast<MemberExpr> (MCE->getCallee ());
+
+  return !ME->isImplicitAccess ();
+}
+
+extern "C" CXSourceRange
+clang_getCXXMemberCallExprSCOSlocRange (CXCursor C)
+{
+  if (!clang_isExpression (C.kind))
+    return clang_getNullRange ();
+
+  const Expr *E = getCursorExpr (C);
+  if (E->getStmtClass () != Stmt::CXXMemberCallExprClass)
+    return clang_getNullRange ();
+
+  const CXXMemberCallExpr *MCE = cast<CXXMemberCallExpr> (E);
+  const MemberExpr *ME = cast<MemberExpr> (MCE->getCallee ());
+
+  ASTContext &ctx = getContext (C);
+
+  const SourceLocation start_loc = ME->getOperatorLoc ();
+  const SourceLocation end_loc = ME->getMemberLoc ().getLocWithOffset (
+    ((long) ME->getMemberDecl ()->getName ().size ()) - 1);
+
+  // Check for validity on both sides.
+  // Specifically, start loc can fail if there is no operator, if the method
+  // call is made from another method and thus not prefixed by `object.` or
+  // `object->`
+  if (start_loc.isInvalid () || end_loc.isInvalid ())
+    return clang_getNullRange ();
+
+  // Do not use the translateSourceRange wrapper because the token
+  // delimitation is not right for us.
+  return translateSourceRange (
+    ctx.getSourceManager (), ctx.getLangOpts (),
+    CharSourceRange::getCharRange (SourceRange (start_loc, end_loc)));
+}
+
+extern "C" CXSourceRange
+clang_getCXXMemberCallExprBaseSlocRange (CXCursor C)
+{
+  if (!clang_isExpression (C.kind))
+    return clang_getNullRange ();
+
+  const Expr *E = getCursorExpr (C);
+  if (E->getStmtClass () != Stmt::CXXMemberCallExprClass)
+    return clang_getNullRange ();
+
+  const CXXMemberCallExpr *MCE = cast<CXXMemberCallExpr> (E);
+  const MemberExpr *ME = cast<MemberExpr> (MCE->getCallee ());
+
+  const SourceLocation start_loc = ME->getBase ()->getBeginLoc ();
+  const SourceLocation end_loc = ME->getBase ()->getEndLoc ();
+
+  return translateSourceRange (getContext (C),
+                               SourceRange (start_loc, end_loc));
+}
+
 extern "C" CXSourceRange
 clang_getFunctionSignatureSloc (CXCursor C)
 {