chore: annotate inline parameter follow-ups

Author: swananan

e2e-tests/tests/optimized_inline_call_value_execution.rs

@@ -6,7 +6,15 @@ use std::path::Path;
 use std::time::Duration;
 
 // Keep this on the first executable line after consume_pair() returns.
+// This is intentionally a negative regression point: at this PC the inline
+// parameters have already fallen out of their own location-list coverage, so
+// we only assert that GhostScope does not misreport them as consume_pair's
+// argument registers. We do not expect post-call value recovery to work until
+// full DW_OP_entry_value + caller-side call-site evaluation is implemented.
 const INLINE_AFTER_CALL_TRACE_LINE: u32 = 19;
+// TODO(positive_test): Add a companion positive test on a pre-call line where
+// original_x/original_y are still covered by their own location lists and can
+// be asserted with exact values without relying on entry_value support.
 
 async fn spawn_inline_call_value_program(
     binary_path: &Path,

ghostscope-dwarf/src/index/block_index.rs

@@ -282,6 +282,7 @@ impl<'a> BlockIndexBuilder<'a> {
                         bn.ranges = ranges;
                     }
                     if let Some(a) = e.attr(gimli::constants::DW_AT_entry_pc) {
+                        // TODO(dwarf5): Also handle DebugAddrIndex-backed DW_AT_entry_pc.
                         if let gimli::AttributeValue::Addr(addr) = a.value() {
                             bn.entry_pc = Some(addr);
                         }

ghostscope-dwarf/src/objfile/variables.rs

@@ -344,6 +344,15 @@ impl LoadedObjfile {
                     }
                 }
 
+                // Keep the parser's direct DWARF result for inline parameters as-is.
+                // We intentionally do not remap optimized inline params from nested
+                // call_site_parameter DIEs here: those describe the callee's argument
+                // locations/values, not the inline function's original parameters, and
+                // using them here caused false aliases like "original_x = RDI".
+                // TODO(inline_params): If we want to recover optimized inline params in
+                // these cases, it has to come from a complete DW_OP_entry_value path that
+                // evaluates caller-side call-site values, not from the inline body's own
+                // nested call-site subtree.
                 let mut seen_param_names: std::collections::HashSet<String> =
                     std::collections::HashSet::new();
                 let mut filtered: Vec<crate::VariableWithEvaluation> =

ghostscope-dwarf/src/parser/expression_evaluator.rs

@@ -202,8 +202,12 @@ impl ExpressionEvaluator {
                 debug!("Found DW_OP_stack_value - this is a computed value");
             }
             match &op {
-                // Support DW_OP_entry_value minimally for inline parameters:
-                // If inner expression is a single DW_OP_reg*, treat it as a direct value.
+                // TODO(entry_value): This is only a minimal fallback.
+                // For inline parameters, a correct DW_OP_entry_value implementation must
+                // walk back to the caller and evaluate the matching call_site_parameter's
+                // DW_AT_call_value / DW_AT_GNU_call_site_value. Merely stripping
+                // entry_value(reg) to a bare register only preserves the simplest cases
+                // where the parameter is still equivalent to the entry register.
                 Operation::EntryValue { expression } => {
                     let mut inner = *expression;
                     let mut inner_ops: Vec<Operation<_>> = Vec::new();

ghostscope-dwarf/src/parser/fast_parser.rs

@@ -544,6 +544,7 @@ impl<'a> DwarfParser<'a> {
                     attrs.ranges_attr = Some(value);
                 }
                 gimli::constants::DW_AT_entry_pc => {
+                    // TODO(dwarf5): Also handle DebugAddrIndex-backed DW_AT_entry_pc.
                     if let gimli::AttributeValue::Addr(addr) = value {
                         attrs.entry_pc = Some(addr);
                     }