feat(tracegrind): proper nested inline tracking via InlIPCursor stack diffing

Replace flat single-pointer inline tracking with a per-BB inline call
stack built via Valgrind's InlIPCursor API. BB-to-BB transitions now
diff the old and new inline stacks to emit the minimal EXIT/ENTER
sequence, producing correct containment (ENTER outer → ENTER inner →
EXIT inner → EXIT outer) instead of flat transitions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: art049

tracegrind/bb.c

@@ -143,7 +143,8 @@ static BB* new_bb(obj_node* obj, PtrdiffT offset,
    bb->fn          = 0;
    bb->line        = 0;
    bb->is_entry    = 0;
-   bb->inl_fn      = NULL;
+   bb->inl_fns     = NULL;
+   bb->inl_depth   = 0;
    bb->bbcc_list   = 0;
    bb->last_bbcc   = 0;
 
@@ -332,6 +333,8 @@ void TG_(delete_bb)(Addr addr)
     if (bb->bbcc_list == 0) {
 	/* can be safely deleted */
 
+	if (bb->inl_fns) VG_(free)(bb->inl_fns);
+
 	/* Fill the block up with junk and then free it, so we will
 	   hopefully get a segfault if it is used again by mistake. */
 	size = sizeof(BB)

tracegrind/bbcc.c

@@ -831,17 +831,37 @@ void TG_(setup_bbcc)(BB* bb)
 
   TG_(current_state).bbcc = bbcc;
 
-  /* Check for inline function transition */
+  /* Check for inline function transitions */
   if (TG_(current_state).collect) {
       thread_info* ti = TG_(get_current_thread)();
-      if (ti && bb->inl_fn != ti->cur_inl_fn) {
-          if (ti->cur_inl_fn != NULL) {
-              TG_(trace_emit_exit_inlined)(TG_(current_tid), bb, ti->cur_inl_fn);
+      if (ti) {
+          UInt old_depth = ti->cur_inl_depth;
+          UInt new_depth = bb->inl_depth;
+
+          /* Fast path: both empty (most BBs) */
+          if (old_depth != 0 || new_depth != 0) {
+              /* Find longest common prefix */
+              UInt common = 0;
+              UInt min_depth = old_depth < new_depth ? old_depth : new_depth;
+              while (common < min_depth &&
+                     ti->cur_inl_fns[common] == bb->inl_fns[common])
+                  common++;
+
+              /* EXIT from deepest down to common level */
+              for (Int i = (Int)old_depth - 1; i >= (Int)common; i--)
+                  TG_(trace_emit_exit_inlined)(TG_(current_tid), bb,
+                                                ti->cur_inl_fns[i]);
+
+              /* ENTER from common level up to new deepest */
+              for (UInt i = common; i < new_depth; i++)
+                  TG_(trace_emit_enter_inlined)(TG_(current_tid), bb,
+                                                 bb->inl_fns[i]);
+
+              /* Update thread state */
+              for (UInt i = 0; i < new_depth; i++)
+                  ti->cur_inl_fns[i] = bb->inl_fns[i];
+              ti->cur_inl_depth = new_depth;
           }
-          if (bb->inl_fn != NULL) {
-              TG_(trace_emit_enter_inlined)(TG_(current_tid), bb);
-          }
-          ti->cur_inl_fn = bb->inl_fn;
       }
   }
 

tracegrind/callstack.c

@@ -234,13 +234,14 @@ void TG_(push_call_stack)(BBCC* from, UInt jmp, BBCC* to, Addr sp, Bool skip)
 
     /* Emit trace sample on function entry */
     if (!skip && TG_(current_state).collect) {
-	/* Emit EXIT_INLINED if we're entering a new function while inside inlined code */
+	/* Exit entire inline stack, deepest first */
 	thread_info* ti = TG_(get_current_thread)();
-	if (ti && ti->cur_inl_fn != NULL && TG_(current_state).bbcc) {
-	    TG_(trace_emit_exit_inlined)(TG_(current_tid),
-					 TG_(current_state).bbcc->bb,
-					 ti->cur_inl_fn);
-	    ti->cur_inl_fn = NULL;
+	if (ti && ti->cur_inl_depth > 0 && TG_(current_state).bbcc) {
+	    for (Int i = (Int)ti->cur_inl_depth - 1; i >= 0; i--)
+		TG_(trace_emit_exit_inlined)(TG_(current_tid),
+					     TG_(current_state).bbcc->bb,
+					     ti->cur_inl_fns[i]);
+	    ti->cur_inl_depth = 0;
 	}
 	fn_node* to_fn = to->cxt->fn[0];
 	TG_(trace_emit_sample)(TG_(current_tid), True, to_fn);
@@ -343,13 +344,14 @@ void TG_(pop_call_stack)(void)
 
 	/* Emit trace sample on function exit */
 	if (TG_(current_state).collect) {
-	    /* Emit EXIT_INLINED if we're leaving while inside inlined code */
+	    /* Exit entire inline stack, deepest first */
 	    thread_info* ti = TG_(get_current_thread)();
-	    if (ti && ti->cur_inl_fn != NULL && TG_(current_state).bbcc) {
-		TG_(trace_emit_exit_inlined)(TG_(current_tid),
-					     TG_(current_state).bbcc->bb,
-					     ti->cur_inl_fn);
-		ti->cur_inl_fn = NULL;
+	    if (ti && ti->cur_inl_depth > 0 && TG_(current_state).bbcc) {
+		for (Int i = (Int)ti->cur_inl_depth - 1; i >= 0; i--)
+		    TG_(trace_emit_exit_inlined)(TG_(current_tid),
+						 TG_(current_state).bbcc->bb,
+						 ti->cur_inl_fns[i]);
+		ti->cur_inl_depth = 0;
 	    }
 	    TG_(trace_emit_sample)(TG_(current_tid), False, to_fn);
 	}

tracegrind/dump.c

@@ -453,7 +453,7 @@ void TG_(trace_emit_sample)(ThreadId tid, Bool is_enter,
                     deltas, es->size);
 }
 
-void TG_(trace_emit_enter_inlined)(ThreadId tid, BB* bb)
+void TG_(trace_emit_enter_inlined)(ThreadId tid, BB* bb, const HChar* inl_fn)
 {
     Int i;
 
@@ -473,7 +473,7 @@ void TG_(trace_emit_enter_inlined)(ThreadId tid, BB* bb)
 
     TG_(trace_out).seq++;
 
-    const HChar* fn_name = bb->inl_fn;
+    const HChar* fn_name = inl_fn;
     const HChar* obj_name = bb->obj ? bb->obj->name : "???";
     const HChar* file_name = (bb->fn && bb->fn->file) ? bb->fn->file->name : "???";
     UInt line = bb->line;

tracegrind/fn.c

@@ -594,11 +594,30 @@ fn_node* TG_(get_fn_node)(BB* bb)
 
     DiEpoch ep = VG_(current_DiEpoch)();
 
-    /* Check if BB start address is in inlined code */
+    /* Build inline stack for this BB using InlIPCursor */
     {
-        const HChar* inl_fn_name = NULL;
-        VG_(get_inline_fnname)(ep, bb_addr(bb), &inl_fn_name);
-        bb->inl_fn = inl_fn_name;  /* NULL if not inlined */
+        InlIPCursor* iipc = VG_(new_IIPC)(ep, bb_addr(bb));
+        if (iipc) {
+            const HChar* tmp[TG_MAX_INL_DEPTH + 1];
+            Int total = 0;
+            do {
+                const HChar* fn_name = NULL;
+                VG_(get_fnname_inl)(ep, bb_addr(bb), &fn_name, iipc);
+                if (fn_name && total < TG_MAX_INL_DEPTH + 1)
+                    tmp[total++] = fn_name;
+            } while (VG_(next_IIPC)(iipc));
+            VG_(delete_IIPC)(iipc);
+
+            /* tmp[] is innermost-first; last entry is the non-inlined function (skip it) */
+            Int inl_count = total - 1;
+            if (inl_count > 0) {
+                bb->inl_depth = inl_count;
+                bb->inl_fns = VG_(malloc)("tg.bb.inl", inl_count * sizeof(HChar*));
+                /* Reverse into outermost-first order */
+                for (Int i = 0; i < inl_count; i++)
+                    bb->inl_fns[i] = tmp[inl_count - 1 - i];
+            }
+        }
     }
 
     if (0 == VG_(strcmp)(fnname, "???")) {

tracegrind/global.h

@@ -59,6 +59,9 @@
 /* Enable experimental features? */
 #define TG_EXPERIMENTAL 0
 
+/* Maximum depth of inline call stack tracking */
+#define TG_MAX_INL_DEPTH 16
+
 
 /*------------------------------------------------------------*/
 /*--- Command line options                                 ---*/
@@ -301,7 +304,8 @@ struct _BB {
 			   * allocated directly after this struct */
   Bool       cjmp_inverted; /* is last side exit actually fall through? */
 
-  const HChar* inl_fn;    /* inlined function name at BB start, or NULL */
+  const HChar** inl_fns;  /* inlined fn names at BB start (outermost first), or NULL */
+  UInt       inl_depth;  /* number of entries in inl_fns */
 
   UInt       instr_len;
   UInt       cost_count;
@@ -566,8 +570,9 @@ struct _thread_info {
   /* CSV trace: per-thread snapshot of cost at last sample emission */
   FullCost last_sample_cost;
 
-  /* Inline tracking: current inlined function name (NULL if not in inlined code) */
-  const HChar* cur_inl_fn;
+  /* Inline tracking: current inline call stack (outermost first) */
+  const HChar* cur_inl_fns[TG_MAX_INL_DEPTH];
+  UInt cur_inl_depth;
 
   /* thread specific data structure containers */
   fn_array fn_active;
@@ -738,7 +743,7 @@ void TG_(run_post_signal_on_call_stack_bottom)(void);
 void TG_(trace_open_output)(void);
 void TG_(trace_reopen_child)(void);
 void TG_(trace_emit_sample)(ThreadId tid, Bool is_enter, fn_node* fn);
-void TG_(trace_emit_enter_inlined)(ThreadId tid, BB* bb);
+void TG_(trace_emit_enter_inlined)(ThreadId tid, BB* bb, const HChar* inl_fn);
 void TG_(trace_emit_exit_inlined)(ThreadId tid, BB* bb, const HChar* inl_fn);
 void TG_(trace_emit_fork)(ThreadId tid, Int child_pid);
 void TG_(trace_emit_marker)(ThreadId tid, const HChar* marker);

tracegrind/tests/test_nested_inlined.post.exp

@@ -14,8 +14,8 @@ Showing N of N rows
 seq=N | tid=1 | event=MARKER | marker=start
 seq=N | tid=1 | event=ENTER | fn=caller | obj=test_nested_inlined.bin | file=test_nested_inlined.c | line=0 | Ir=N
 seq=N | tid=1 | event=ENTER_INLINED | fn=outer_inline | obj=test_nested_inlined.bin | file=test_nested_inlined.c | line=26 | Ir=N
-seq=N | tid=1 | event=EXIT_INLINED | fn=outer_inline | obj=test_nested_inlined.bin | file=test_nested_inlined.c | line=9 | Ir=N
 seq=N | tid=1 | event=ENTER_INLINED | fn=inner_inline | obj=test_nested_inlined.bin | file=test_nested_inlined.c | line=9 | Ir=N
 seq=N | tid=1 | event=EXIT_INLINED | fn=inner_inline | obj=test_nested_inlined.bin | file=test_nested_inlined.c | line=9 | Ir=N
+seq=N | tid=1 | event=EXIT_INLINED | fn=outer_inline | obj=test_nested_inlined.bin | file=test_nested_inlined.c | line=9 | Ir=N
 seq=N | tid=1 | event=EXIT | fn=caller | obj=test_nested_inlined.bin | file=test_nested_inlined.c | line=0 | Ir=N
 seq=N | tid=1 | event=MARKER | marker=end