feat(callgrind): capture inline function calls into the callgrind out file

Author: art049

.gitignore

@@ -158,6 +158,8 @@
 /callgrind/tests/clreq
 /callgrind/tests/simwork
 /callgrind/tests/threads
+/callgrind/tests/inline-samefile
+/callgrind/tests/inline-crossfile
 
 # /coregrind/
 /coregrind/*.a

CODSPEED-CHANGELOG.md

@@ -0,0 +1,83 @@
+# CodSpeed Valgrind Changelog
+
+This file documents changes made to Valgrind for CodSpeed integration, beyond the baseline Valgrind distribution.
+
+
+### Callgrind: Inline Function Tracking
+
+**Feature**: Added `cfni=` (call file name inline) markers to Callgrind output to track execution within inlined functions.
+
+**Usage**: Enable with the `--read-inline-info=yes` flag.
+
+**How it works**:
+- Reads DWARF inline location table (`DW_TAG_inlined_subroutine`) from debug info
+- Outputs `cfni=function_name` when entering an inlined function
+- Outputs `cfni=???` when leaving inline code and returning to non-inlined code
+- Tracks transitions between different inlined functions
+- Works seamlessly with file context markers (`fi=`, `fe=`)
+
+**Example 1: Same-file inlining**
+
+Source code:
+```c
+static inline int compute_sum(int x) {
+    int sum = 0;
+    for (int i = 0; i < x; i++) {
+        sum += i;
+    }
+    return sum;
+}
+
+int main() {
+    int result = compute_sum(10);  // This call will be inlined
+    printf("result=%d\n", result);
+    return 0;
+}
+```
+
+Callgrind output (excerpt):
+```
+fn=main
+12 1
+-1 1
+cfni=compute_sum        ← Entering inlined function
+-6 3
+-1 3
++1 4
++1 1
+-1 3
+cfni=???                ← Leaving inlined function
++13 1
++1 3
+cfn=printf             ← Regular function call (not inlined)
+```
+
+**Example 2: Cross-file inlining**
+
+Source files:
+```c
+// helper.h
+static inline int add_five(int x) {
+    return x + 5;
+}
+
+// main.c
+#include "helper.h"
+int main() {
+    int result = add_five(10);  // Inlined from helper.h
+    printf("result=%d\n", result);
+    return 0;
+}
+```
+
+Callgrind output (excerpt):
+```
+fn=main
+fi=helper.h             ← File context changes to header
+cfni=add_five           ← Entering inlined function from header
++2 1
+fe=main.c               ← Returning to original file
+cfni=???                ← Leaving inlined function
++1 3
+cfn=printf
+```

callgrind/dump.c

@@ -344,6 +344,7 @@ static Addr       debug_cache_addr[DEBUG_CACHE_SIZE];
 static file_node* debug_cache_file[DEBUG_CACHE_SIZE];
 static int        debug_cache_line[DEBUG_CACHE_SIZE];
 static Bool       debug_cache_info[DEBUG_CACHE_SIZE];
+static const HChar* debug_cache_inlfn[DEBUG_CACHE_SIZE];
 
 static __inline__
 void init_debug_cache(void)
@@ -354,6 +355,7 @@ void init_debug_cache(void)
 	debug_cache_file[i] = 0;
 	debug_cache_line[i] = 0;
 	debug_cache_info[i] = 0;
+	debug_cache_inlfn[i] = 0;
     }
 }
 
@@ -386,6 +388,15 @@ Bool get_debug_pos(BBCC* bbcc, Addr addr, AddrPos* p)
 	debug_cache_addr[cachepos] = addr;
 	debug_cache_line[cachepos] = p->line;
 	debug_cache_file[cachepos] = p->file;
+
+	/* Query inline info at the same time we query file/line */
+	const HChar* inl_fn = 0;
+	Bool has_inline = VG_(get_inline_fnname)(ep, addr, &inl_fn);
+	if (has_inline) {
+	    debug_cache_inlfn[cachepos] = inl_fn;
+	} else {
+	    debug_cache_inlfn[cachepos] = (const HChar*)(-1);
+	}
     }
 
     /* Address offset from bbcc start address */
@@ -399,6 +410,44 @@ Bool get_debug_pos(BBCC* bbcc, Addr addr, AddrPos* p)
     return found_file_line;
 }
 
+/* Get inline function name for an address, with caching.
+ * Returns True if address is in an inlined function, False otherwise.
+ * If True, *inl_fn will be set to the inline function name.
+ */
+static Bool get_inline_info(Addr addr, const HChar** inl_fn)
+{
+    int cachepos = addr % DEBUG_CACHE_SIZE;
+
+    /* Check cache first - but only if inline info was already queried for this address */
+    if (debug_cache_addr[cachepos] == addr && debug_cache_inlfn[cachepos] != 0) {
+        /* We have cached inline info for this address */
+        if (debug_cache_inlfn[cachepos] == (const HChar*)(-1)) {
+            /* Special marker: no inline function at this address */
+            *inl_fn = 0;
+            return False;
+        }
+        *inl_fn = debug_cache_inlfn[cachepos];
+        return True;
+    }
+
+    DiEpoch ep = VG_(current_DiEpoch)();
+    Bool has_inline = VG_(get_inline_fnname)(ep, addr, inl_fn);
+
+    if (has_inline) {
+        /* Cache the inline function name */
+        debug_cache_inlfn[cachepos] = *inl_fn;
+    } else {
+        *inl_fn = 0;
+        /* Use special marker -1 to indicate "no inline function" */
+        debug_cache_inlfn[cachepos] = (const HChar*)(-1);
+    }
+
+    CLG_DEBUG(3, "  get_inline_info(%#lx): %s\n",
+             addr, has_inline ? *inl_fn : "(not inlined)");
+
+    return has_inline;
+}
+
 
 /* copy file position and init cost */
 static void init_apos(AddrPos* p, Addr addr, Addr bbaddr, file_node* file)
@@ -426,13 +475,15 @@ static void init_fcost(AddrCost* c, Addr addr, Addr bbaddr, file_node* file)
     CLG_(init_cost)( CLG_(sets).full, c->cost );
 }
 
+/* Track last inline function to avoid repeated cfni= output */
+static const HChar* last_inline_fn = 0;
 
 /**
  * print position change inside of a BB (last -> curr)
  * this doesn't update last to curr!
  */
 static void fprint_apos(VgFile *fp, AddrPos* curr, AddrPos* last,
-                        file_node* func_file)
+                        file_node* func_file, BBCC* bbcc)
 {
     CLG_ASSERT(curr->file != 0);
     CLG_DEBUG(2, "    print_apos(file '%s', line %u, bb %#lx, addr %#lx) fnFile '%s'\n",
@@ -448,6 +499,24 @@ static void fprint_apos(VgFile *fp, AddrPos* curr, AddrPos* last,
             print_file(fp, "fi=", curr->file);
     }
 
+    /* Check inline function for this position and output cfni= if changed */
+    if (bbcc) {
+        Addr curr_addr = curr->addr + bbcc->bb->obj->offset;
+        const HChar* inline_fn = 0;
+        Bool is_inline = get_inline_info(curr_addr, &inline_fn);
+
+        /* Output cfni= if inline function changed */
+        if (is_inline && inline_fn && inline_fn != last_inline_fn) {
+            VG_(fprintf)(fp, "cfni=%s\n", inline_fn);
+            last_inline_fn = inline_fn;
+        }
+        /* Clear last_inline_fn if we're no longer in inline code */
+        else if (!is_inline && last_inline_fn) {
+            VG_(fprintf)(fp, "cfni=???\n");
+            last_inline_fn = 0;
+        }
+    }
+
     if (CLG_(clo).dump_bbs) {
 	if (curr->line != last->line) {
 	    VG_(fprintf)(fp, "ln=%u\n", curr->line);
@@ -704,8 +773,8 @@ static Bool fprint_bbcc(VgFile *fp, BBCC* bbcc, AddrPos* last)
     /* get debug info of current instruction address and dump cost
      * if CLG_(clo).dump_bbs or file/line has changed
      */
-    if (!get_debug_pos(bbcc, bb_addr(bb) + instr_info->instr_offset, 
-		       &(newCost->p))) {
+    Addr instr_addr = bb_addr(bb) + instr_info->instr_offset;
+    if (!get_debug_pos(bbcc, instr_addr, &(newCost->p))) {
       /* if we don't have debug info, don't switch to file "???" */
       newCost->p.file = bbcc->cxt->fn[0]->file;
     }
@@ -716,8 +785,10 @@ static Bool fprint_bbcc(VgFile *fp, BBCC* bbcc, AddrPos* last)
 
       if (!CLG_(is_zero_cost)( CLG_(sets).full, currCost->cost )) {
 	something_written = True;
-	
-	fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file);
+
+	/* Output file position and inline function markers */
+	fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file, bbcc);
+
 	fprint_fcost(fp, currCost, last);
       }
 
@@ -741,11 +812,11 @@ static Bool fprint_bbcc(VgFile *fp, BBCC* bbcc, AddrPos* last)
 	if (jcc_count>0) {    
 	    if (!CLG_(is_zero_cost)( CLG_(sets).full, currCost->cost )) {
 		/* no need to switch buffers, as position is the same */
-		fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file);
+		fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file, bbcc);
 		fprint_fcost(fp, currCost, last);
 	    }
 	    get_debug_pos(bbcc, bb_addr(bb)+instr_info->instr_offset, &(currCost->p));
-	    fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file);
+	    fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file, bbcc);
 	    something_written = True;
 	    for(jcc=bbcc->jmp[jmp].jcc_list; jcc; jcc=jcc->next_from) {
 		if (((jcc->jmpkind != jk_Call) && (jcc->call_counter >0)) ||
@@ -773,17 +844,17 @@ static Bool fprint_bbcc(VgFile *fp, BBCC* bbcc, AddrPos* last)
   }
 
   if ( (bbcc->skipped &&
-	!CLG_(is_zero_cost)(CLG_(sets).full, bbcc->skipped)) || 
+	!CLG_(is_zero_cost)(CLG_(sets).full, bbcc->skipped)) ||
        (jcc_count>0) ) {
-    
+
     if (!CLG_(is_zero_cost)( CLG_(sets).full, currCost->cost )) {
       /* no need to switch buffers, as position is the same */
-      fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file);
+      fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file, bbcc);
       fprint_fcost(fp, currCost, last);
     }
 
     get_debug_pos(bbcc, bb_jmpaddr(bb), &(currCost->p));
-    fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file);
+    fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file, bbcc);
     something_written = True;
 
     /* first, print skipped costs for calls */
@@ -810,8 +881,8 @@ static Bool fprint_bbcc(VgFile *fp, BBCC* bbcc, AddrPos* last)
   if (CLG_(clo).dump_bbs || CLG_(clo).dump_bb) {
     if (!CLG_(is_zero_cost)( CLG_(sets).full, currCost->cost )) {
       something_written = True;
-      
-      fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file);
+
+      fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file, bbcc);
       fprint_fcost(fp, currCost, last);
     }
     if (CLG_(clo).dump_bbs) VG_(fprintf)(fp, "\n");
@@ -1417,7 +1488,7 @@ static void print_bbccs_of_thread(thread_info* ti)
       if (!CLG_(is_zero_cost)( CLG_(sets).full, ccSum[currSum].cost )) {
 	/* no need to switch buffers, as position is the same */
 	fprint_apos(print_fp, &(ccSum[currSum].p), &lastAPos,
-		    lastFnPos.cxt->fn[0]->file);
+		    lastFnPos.cxt->fn[0]->file, 0);
 	fprint_fcost(print_fp, &ccSum[currSum], &lastAPos);
       }
 
@@ -1437,6 +1508,7 @@ static void print_bbccs_of_thread(thread_info* ti)
       init_fcost(&ccSum[0], 0, 0, 0);
       init_fcost(&ccSum[1], 0, 0, 0);
       currSum = 0;
+      last_inline_fn = 0;  /* reset inline function tracking */
     }
 
     if (CLG_(clo).dump_bbs) {

callgrind/tests/Makefile.am

@@ -4,7 +4,7 @@ include $(top_srcdir)/Makefile.tool-tests.am
 SUBDIRS = .
 DIST_SUBDIRS = .
 
-dist_noinst_SCRIPTS = filter_stderr
+dist_noinst_SCRIPTS = filter_stderr filter_inline
 
 EXTRA_DIST = \
 	ann1.post.exp ann1.stderr.exp ann1.vgtest \
@@ -23,11 +23,18 @@ EXTRA_DIST = \
 	notpower2-use.vgtest notpower2-use.stderr.exp \
 	threads.vgtest threads.stderr.exp \
 	threads-use.vgtest threads-use.stderr.exp \
-	find-source.vgtest find-source.stderr.exp find-source.post.exp
+	find-source.vgtest find-source.stderr.exp find-source.post.exp \
+	inline-samefile.vgtest inline-samefile.stderr.exp inline-samefile.stdout.exp inline-samefile.post.exp \
+	inline-crossfile.vgtest inline-crossfile.stderr.exp inline-crossfile.stdout.exp inline-crossfile.post.exp \
+	inline-crossfile-helper1.h inline-crossfile-helper2.h filter_inline
 
-check_PROGRAMS = clreq simwork threads
+check_PROGRAMS = clreq simwork threads inline-samefile inline-crossfile
 
 AM_CFLAGS   += $(AM_FLAG_M3264_PRI)
 AM_CXXFLAGS += $(AM_FLAG_M3264_PRI)
 
+# Inline tests need -O2 to enable inlining and -g for debug info
+inline_samefile_CFLAGS = $(AM_CFLAGS) -O2 -g
+inline_crossfile_CFLAGS = $(AM_CFLAGS) -O2 -g
+
 threads_LDADD = -lpthread

callgrind/tests/filter_inline

@@ -0,0 +1,41 @@
+#!/bin/sh
+
+# Filter script to extract inline function markers (cfni=) from callgrind output
+# Usage: filter_inline <callgrind.out.file> <test_name>
+
+CGout=$1
+test_name=$2
+
+# Extract the main function section and show the cfni= markers along with file context
+awk '
+/^fn=main$/ {
+    in_main = 1
+    print "=== Main Function Inline Markers ==="
+    next
+}
+
+in_main && /^fn=/ && !/^fn=main$/ {
+    in_main = 0
+}
+
+in_main {
+    # Print file context markers (fi=, fe=), inline markers (cfni=), and function calls (cfn=)
+    if (/^fi=/ || /^fe=/ || /^cfni=/ || /^cfn=/) {
+        # Extract just the filename from file paths for readability
+        if (/^fi=/ || /^fe=/) {
+            marker = substr($0, 1, 3)
+            path = substr($0, 4)
+            # Get basename
+            n = split(path, parts, "/")
+            print marker parts[n]
+        }
+        # Skip address-only cfn= entries (not related to inline tracking)
+        else if (/^cfn=0x/) {
+            # Skip
+        }
+        else {
+            print $0
+        }
+    }
+}
+' "$CGout"

callgrind/tests/inline-crossfile-helper1.h

@@ -0,0 +1,13 @@
+#ifndef HELPER1_H
+#define HELPER1_H
+
+// Inline function from helper1.h
+static inline int compute_sum(int x) {
+    int sum = 0;
+    for (int i = 0; i < x; i++) {
+        sum += i;
+    }
+    return sum;
+}
+
+#endif

callgrind/tests/inline-crossfile-helper2.h

@@ -0,0 +1,13 @@
+#ifndef HELPER2_H
+#define HELPER2_H
+
+// Inline function from helper2.h
+static inline int compute_product(int x) {
+    int prod = 1;
+    for (int i = 1; i <= x; i++) {
+        prod *= i;
+    }
+    return prod;
+}
+
+#endif