instr-c: Introduce a generic witness to instrument C++ call chains

Author: RenjiSann

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)
 {

tools/gnatcov/instrument-c.adb

@@ -1367,6 +1367,35 @@ package body Instrument.C is
               (N    => SS.Statement,
                Text => ")",
                Rew  => UIC.Rewriter);
+
+         when Instr_Prefixed_CXXMemberCallExpr =>
+
+            --  In case we are instrumenting a C++ method call `foo.bar()`
+            --  we wrap the base in a generic witness which is an identity
+            --  function and call the method on the witness like so :
+            --
+            --  `witness_generic(buf, id, foo).bar()`
+
+            declare
+               Base_Sloc_Range : constant Source_Range_T :=
+                  Get_CXX_Member_Call_Expr_Base_Sloc_Range (SS.Statement);
+               Witness_Params  : constant String :=
+                  Statement_Buffer_Symbol (UIC.Instrumented_Unit)
+                  & Buffers_Subscript (Buffers_Index) & ", " & Img (Bit);
+            begin
+               CX_Rewriter_Insert_Text_After
+                 (Rew    => UIC.Rewriter,
+                  Loc    => Get_Range_Start (Base_Sloc_Range),
+                  Insert => "gnatcov_rts_witness_generic ("
+                            & Witness_Params & ", ");
+
+               CX_Rewriter_Insert_Text_Before
+                 (Rew    => UIC.Rewriter,
+                  Loc    => Get_Range_End (Base_Sloc_Range),
+                  Insert => ")");
+            end;
+
+            null;
       end case;
    end Insert_Statement_Witness;
 
@@ -1583,54 +1612,6 @@ package body Instrument.C is
       end if;
    end Is_Complex_Decision;
 
-   -----------------------
-   -- Process_Call_Expr --
-   -----------------------
-
-   procedure Process_Call_Expr
-     (UIC : in out C_Unit_Inst_Context; Cursor : Cursor_T);
-
-   procedure Process_Call_Expr
-     (UIC : in out C_Unit_Inst_Context; Cursor : Cursor_T)
-   is
-      function Visit_Call_Expr (C : Cursor_T) return Child_Visit_Result_T;
-
-      function Visit_Call_Expr (C : Cursor_T) return Child_Visit_Result_T is
-      begin
-         if Kind (C) = Cursor_Lambda_Expr then
-            return Child_Visit_Continue;
-         end if;
-
-         if Is_Instrumentable_Call_Expr (C) then
-            Sources_Trace.Trace ("Instrument Call at "
-                                 & Image (Start_Sloc (C)));
-
-            UIC.Pass.Append_SCO
-              (UIC  => UIC,
-               N    => C,
-               C1   => 'c',
-               C2   => 'S',
-               From => Start_Sloc (C),
-               To   => End_Sloc (C),
-               Last => True);
-
-            UIC.Pass.Instrument_Statement
-              (UIC          => UIC,
-               LL_SCO       => SCOs.SCO_Table.Last,
-               Insertion_N  => C,
-               Instr_Scheme => Instr_Expr,
-               Kind         => Call);
-         end if;
-
-         return Child_Visit_Recurse;
-      end Visit_Call_Expr;
-
-   begin
-      if Enabled (Coverage_Options.Fun_Call) then
-         Visit (Cursor, Visit_Call_Expr'Access);
-      end if;
-   end Process_Call_Expr;
-
    ------------------------
    -- Process_Expression --
    ------------------------
@@ -1650,6 +1631,8 @@ package body Instrument.C is
          N   : Cursor_T;
          T   : Character);
 
+      function Process_Call_Expr (C : Cursor_T) return Child_Visit_Result_T;
+
       -------------------------
       -- Process_Lambda_Expr --
       -------------------------
@@ -2030,14 +2013,79 @@ package body Instrument.C is
          Hash_Entries.Free;
       end Process_Decisions;
 
+      -------------------------
+      --  Process_Call_Expr  --
+      -------------------------
+
+      function Process_Call_Expr (C : Cursor_T) return Child_Visit_Result_T is
+      begin
+
+         --  Lambda functions are handled in Process_Lambda_Expr
+
+         if Kind (C) = Cursor_Lambda_Expr then
+            return Child_Visit_Continue;
+         end if;
+
+         if Is_Instrumentable_Call_Expr (C) then
+            Sources_Trace.Trace ("Instrument Call at "
+                                 & Image (Start_Sloc (C)));
+
+            declare
+               From         : Source_Location := Start_Sloc (C);
+               To           : Source_Location := End_Sloc (C);
+               Instr_Scheme : Instr_Scheme_Type := Instr_Expr;
+            begin
+               if Is_Prefixed_CXX_Member_Call_Expr (C) then
+
+                  --  If we are instrumenting a method call like `foo.bar()`,
+                  --  adjust the SCO to `.bar`, and set a specific
+                  --  instrumentation scheme.
+                  --
+                  --  This does not apply to un-prefixed method calls (in other
+                  --  method calls), which are instrumented as regular
+                  --  functions.
+
+                  declare
+                     CX_Source_Range : constant Source_Range_T :=
+                        Get_CXX_Member_Call_Expr_SCO_Sloc_Range (C);
+                  begin
+                     From         := Sloc (Get_Range_Start (CX_Source_Range));
+                     To           := Sloc (Get_Range_End (CX_Source_Range));
+                     Instr_Scheme := Instr_Prefixed_CXXMemberCallExpr;
+                  end;
+               end if;
+
+               UIC.Pass.Append_SCO
+                 (UIC  => UIC,
+                  N    => C,
+                  C1   => 'c',
+                  C2   => 'E',
+                  From => From,
+                  To   => To,
+                  Last => True);
+
+               UIC.Pass.Instrument_Statement
+                 (UIC          => UIC,
+                  LL_SCO       => SCOs.SCO_Table.Last,
+                  Insertion_N  => C,
+                  Instr_Scheme => Instr_Scheme,
+                  Kind         => Call);
+            end;
+         end if;
+
+         return Child_Visit_Recurse;
+      end Process_Call_Expr;
+
    begin
       if UIC.Disable_Coverage then
          return;
       end if;
 
       Process_Decisions (UIC, N, T);
 
-      Process_Call_Expr (UIC, N);
+      if Enabled (Coverage_Options.Fun_Call) then
+         Visit (N, Process_Call_Expr'Access);
+      end if;
 
       Visit (N, Process_Lambda_Expr'Access);
    end Process_Expression;

tools/gnatcov/instrument-c.ads

@@ -160,7 +160,11 @@ package Instrument.C is
    --  Create a C++ instrumenter. See the definition of the
    --  Language_Instrumenter type for the arguments semantic.
 
-   type Instr_Scheme_Type is (Instr_Stmt, Instr_Expr, Instr_In_Compound);
+   type Instr_Scheme_Type is
+     (Instr_Stmt,
+      Instr_Expr,
+      Instr_In_Compound,
+      Instr_Prefixed_CXXMemberCallExpr);
    --  Depending on the statement construct, we can instrument it either with
    --  another statement right before (Instr_Stmt), which is the case for most
    --  statements:
@@ -193,6 +197,12 @@ package Instrument.C is
    --  Function coverage, and particularly useful for functions with empty
    --  bodies in which it is not possible to refer to the body's first
    --  statement to insert a witness statement before it.
+   --
+   --  The variant Instr_Prefixed_CXXMemberCallExpr is expected to be used on
+   --  C++ prefixed method calls like `foo.bar()` or `foo->bar()`.
+   --  It will be instrumented using a generic templated witness to conserve
+   --  the execution order of witnesses in method call chains.
+   --  Note that NON-prefixed method calls are handled like simple functions.
 
    type C_Source_Statement is record
       LL_SCO : Nat;

tools/gnatcov/rts/gnatcov_rts_c-witness.h

@@ -35,6 +35,19 @@ gnatcov_rts_witness (unsigned char *buffer, unsigned bit_id)
   return 1;
 }
 
+#ifdef __cplusplus
+
+template <class T>
+T
+gnatcov_rts_witness_generic (unsigned char *buffer, unsigned int bit_id,
+                             T value)
+{
+  gnatcov_rts_witness (buffer, bit_id);
+  return value;
+}
+
+#endif /* __cplusplus */
+
 /* Decisions */
 
 /* If VALUE is false, set the boolean corresponding to FALSE_BIT to true in