tests: validate USDT note integrity under linker GC and COMDAT dedup

Add two regression tests for USDT note integrity when the linker
removes probe site code:

  - gc_sections defines probes in an uncalled function and is built
    with -ffunction-sections and -Wl,--gc-sections, validating that
    garbage-collected probe code doesn't leave dangling notes behind
    (and that live probes' base/semaphore references survive, which
    is asserted by the BASE*/SEMA* stubs in USDT_SPECS);
  - cxx_comdat triggers a USDT in a C++ inline function instantiated
    in two translation units, validating that COMDAT deduplication
    discards the corresponding note copy instead of failing the link
    (BFD ld) or leaving a dangling note (LLD).

Detection is implemented in check-usdt-locs.awk, which run_test.sh
now runs for every test binary (and shared library): each USDT note's
location must fall inside an executable PT_LOAD segment of its ELF
file, mirroring the lookup tracing tools perform at attach time
(e.g., libbpf's find_elf_seg()); a location outside any executable
segment means the note's relocation was resolved against a section
discarded by the linker.

Author: anakryiko

tests/Makefile

@@ -80,6 +80,10 @@ $(OBJDIR)/long_nop_usdt.o: CFLAGS += -w
 $(OBJDIR)/cxx_arg_types.opp: CXXFLAGS += -w
 $(OBJDIR)/cxx_long_nop_usdt.opp: CXXFLAGS += -w
 
+# gc_sections validates USDT note integrity under linker section GC
+$(OBJDIR)/gc_sections.o: CFLAGS += -ffunction-sections -fdata-sections
+$(OBJDIR)/gc_sections: LDFLAGS += -Wl,--gc-sections
+
 $(OBJDIR)/%.o: %.c $(wildcard *.h) | $(OBJDIR)
 	$(call msg,CC,$@)
 	$(Q)$(CC) $(CFLAGS) -g -c $< -o $@

tests/check-usdt-locs.awk

@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: BSD-2-Clause
+#
+# Validate that every USDT note's location falls inside an executable
+# PT_LOAD segment of its ELF file, mirroring the lookup tracing tools
+# perform (e.g., libbpf's find_elf_seg()). A location that lands in no
+# segment means the note's relocation was resolved against a section the
+# linker discarded (garbage-collected or deduplicated COMDAT), leaving a
+# dangling note that breaks probe attachment.
+#
+# Input is the concatenated output of `readelf -lW <file>` and
+# `readelf -n <file>` for a single ELF file:
+#
+#   LOAD  0x000000 0x0000000000400000 0x0000000000400000 0x0004f8 0x0004f8 R E 0x1000
+#   ...
+#     Provider: test
+#     Name: kept
+#     Location: 0x0000000000401234, Base: ..., Semaphore: ...
+#
+# Exits non-zero listing each dangling note.
+
+BEGIN { nsegs = 0; }
+
+# readelf -lW prints the flag column with a space inside it ("R E"), so it is
+# split across fields; the trailing align column is always last. Reconstruct
+# the flags from everything between memsz ($6) and align ($NF).
+$1 == "LOAD" {
+	flags = "";
+	for (i = 7; i < NF; i++)
+		flags = flags $i;
+	if (flags ~ /E/) {
+		seg_start[nsegs] = strtonum($3);
+		seg_end[nsegs] = seg_start[nsegs] + strtonum($6);
+		nsegs++;
+	}
+}
+
+/Provider:/ { grp = $2; }
+/Name:/ { name = $2; }
+
+/Location:/ {
+	loc = strtonum($2);
+	for (i = 0; i < nsegs; i++) {
+		if (loc >= seg_start[i] && loc < seg_end[i])
+			next;
+	}
+	printf "%s:%s location 0x%x is in no executable segment (dangling note)\n",
+	       grp, name, loc;
+	bad = 1;
+}
+
+END {
+	exit bad;
+}

tests/cxx_comdat.h

@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+#ifndef __CXX_COMDAT_H__
+#define __CXX_COMDAT_H__
+
+#include "../usdt.h"
+#include "common.h"
+
+/*
+ * A USDT inside a C++ inline function defined in a header: every TU that
+ * uses it emits its own out-of-line copy in a COMDAT group, the linker keeps
+ * one copy and discards the rest. The .note.stapsdt entry emitted next to
+ * each copy is not part of that COMDAT group, so the notes of the discarded
+ * copies are left referencing a discarded section:
+ *   - BFD ld fails the link outright ("`.text._Z...' referenced in section
+ *     `.note.stapsdt' ... defined in discarded section");
+ *   - LLD silently resolves the note's location to 0 + addend, producing a
+ *     dangling note (caught by run_test.sh's location validity check).
+ *
+ * noinline forces the out-of-line COMDAT copy to exist at any optimization
+ * level; a fully inlined copy would produce a valid note at every inline
+ * site instead.
+ */
+inline __attribute__((noinline)) void cxx_comdat_probe(int x)
+{
+	USDT(test, comdat, x);
+}
+
+extern void cxx_comdat_other_func(int x);
+
+#endif /* __CXX_COMDAT_H__ */

tests/cxx_comdat1.cpp

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: BSD-2-Clause
+#include <cstdio>
+#include "common.h"
+#include "cxx_comdat.h"
+
+/*
+ * See cxx_comdat.h: both this file and cxx_comdat2.cpp instantiate
+ * cxx_comdat_probe()'s out-of-line COMDAT copy; the linker discards one of
+ * them and its .note.stapsdt entry must go with it (and not dangle or fail
+ * the link). One or two comdat notes may legitimately survive depending on
+ * the linker, so USDT_SPECS pins down just the first one; run_test.sh
+ * rejects dangling leftovers.
+ */
+
+int main(int argc, char **argv)
+{
+	if (handle_args(argc, argv))
+		return 0;
+
+	cxx_comdat_probe(1);
+	cxx_comdat_other_func(2);
+
+	return 0;
+}
+
+const char *USDT_SPECS =
+"test:comdat base=* sema=0 argn=1 args=*.\n"
+"...\n"
+;

tests/cxx_comdat2.cpp

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: BSD-2-Clause
+#include "common.h"
+#include "cxx_comdat.h"
+
+void __optimize cxx_comdat_other_func(int x)
+{
+	cxx_comdat_probe(x);
+}

tests/gc_sections.c

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: BSD-2-Clause
+#include <stdio.h>
+#include "common.h"
+#include "../usdt.h"
+
+/*
+ * Validate USDT note integrity when the linker garbage-collects sections.
+ * This test is compiled with -ffunction-sections -fdata-sections and linked
+ * with -Wl,--gc-sections (see Makefile).
+ *
+ * gc_collected_func() is never called, so its section is eligible for
+ * collection. .note.stapsdt is a non-SHF_ALLOC section and linkers differ in
+ * whether references from it keep sections alive:
+ *   - BFD ld treats them as GC roots, so the unused function (and its
+ *     semaphore) survive and the note stays valid;
+ *   - LLD does not follow them: the function is collected and the note's
+ *     relocation against the collected section silently resolves to
+ *     0 + addend, leaving a dangling note whose "location" is the nop's
+ *     offset inside the discarded section (tiny bogus value). The implicit
+ *     semaphore in .probes and the .stapsdt.base section are collected the
+ *     same way, zeroing the note's semaphore/base fields.
+ * Tools iterating notes then trip on the dangling entry; e.g. libbpf fails
+ * the entire probe, including its valid same-name copies.
+ *
+ * run_test.sh fails any test whose binary contains a note whose location
+ * falls in no executable segment, which is what this test is really
+ * asserting.
+ * Which of gc_collected_func()'s notes survive (and with what semaphore
+ * values) is linker-dependent, so USDT_SPECS only pins down the live
+ * probes and accepts anything extra. The BASE* and SEMA* stubs (as opposed
+ * to plain *) assert that the kept probes' .stapsdt.base and semaphore
+ * references stayed intact (LLD used to garbage-collect those sections and
+ * zero out the fields even in surviving notes).
+ */
+
+void gc_collected_func(int x)
+{
+	USDT(test, collected, x);
+	USDT_WITH_SEMA(test, collected_sema, x);
+}
+
+int main(int argc, char **argv)
+{
+	if (handle_args(argc, argv))
+		return 0;
+
+	USDT(test, kept, 1);
+	USDT_WITH_SEMA(test, kept_sema, 2);
+
+	return 0;
+}
+
+const char *USDT_SPECS =
+"...\n"
+"test:kept base=BASE* sema=0 argn=1 args=*.\n"
+"test:kept_sema base=BASE* sema=SEMA* argn=1 args=*.\n"
+"...\n"
+;

tests/run_test.sh

@@ -29,13 +29,20 @@ TEST_BTOUT=$TEST_BIN.act_bt_out.txt
 TEST_OUT_SPEC=$TEST_BIN.exp_out.txt
 TEST_OUT=$TEST_BIN.act_out.txt
 
-$TEST_BIN -U > $TEST_USDTS_SPEC
+TEST_ELFS=$TEST_BIN
 if [ "${SHARED:-0}" -eq 1 ] && [ -e "$TEST_LIB" ]; then
-	# append lib's USDT notes to USDTs from executable
-	$readelf -n $TEST_BIN $TEST_LIB 2>/dev/null | $awk -f fetch-usdts.awk > $TEST_USDTS_OUT
-else
-	$readelf -n $TEST_BIN 2>/dev/null | $awk -f fetch-usdts.awk > $TEST_USDTS_OUT
+	# check lib's USDT notes along with executable's
+	TEST_ELFS="$TEST_ELFS $TEST_LIB"
 fi
+
+$TEST_BIN -U > $TEST_USDTS_SPEC
+$readelf -n $TEST_ELFS 2>/dev/null | $awk -f fetch-usdts.awk > $TEST_USDTS_OUT
+for elf in $TEST_ELFS; do
+	if ! { $readelf -lW $elf; $readelf -n $elf; } 2>/dev/null | $awk -f check-usdt-locs.awk; then
+		echo "DANGLING USDT NOTES in $elf (probe code discarded by linker, note left behind)"
+		exit 1
+	fi
+done
 if ! $awk -f check-match.awk $TEST_USDTS_SPEC $TEST_USDTS_OUT; then
 	echo "USDT SPECS MISMATCH:"
 	echo "EXPECTED:"