Add API for tracing regions.

Author: vgvassilev

lib/CppInterOp/Tracing.cpp

@@ -13,6 +13,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <cassert>
@@ -68,5 +69,45 @@ std::string TraceInfo::writeToFile(const std::string& Version) {
   return std::string(Path);
 }
 
+std::string TraceInfo::StartRegion() {
+  m_RegionStart = m_Log.size();
+  m_InRegion = true;
+
+  llvm::SmallString<128> TmpDir;
+  llvm::sys::path::system_temp_directory(/*ErasedOnReboot=*/true, TmpDir);
+  llvm::SmallString<128> Path;
+  llvm::sys::path::append(Path, TmpDir, "cppinterop-reproducer-%%%%%%.cpp");
+  int FD;
+  std::error_code EC = llvm::sys::fs::createUniqueFile(Path, FD, Path);
+  if (EC)
+    return "";
+  llvm::sys::Process::SafelyCloseFileDescriptor(FD);
+  m_RegionPath = std::string(Path);
+  return m_RegionPath;
+}
+
+void TraceInfo::StopRegion(const std::string& Version) {
+  if (!m_InRegion)
+    return;
+  m_InRegion = false;
+
+  std::error_code EC;
+  llvm::raw_fd_ostream OS(m_RegionPath, EC);
+  if (EC)
+    return;
+
+  OS << "// CppInterOp trace region\n";
+  std::string Ver = Version.empty() ? CppImpl::GetVersion() : Version;
+  WriteVersionComment(OS, Ver);
+  OS << "// Generated automatically.\n";
+  OS << "#include <CppInterOp/CppInterOp.h>\n\n";
+  OS << "void reproducer() {\n";
+  for (size_t i = m_RegionStart; i < m_Log.size(); ++i)
+    OS << m_Log[i] << "\n";
+  OS << "}\n\n";
+  OS << "int main() { reproducer(); return 0; }\n";
+  OS.flush();
+}
+
 } // namespace Tracing
 } // namespace CppInterOp

lib/CppInterOp/Tracing.h

@@ -50,6 +50,8 @@ class TraceInfo {
   unsigned m_VarCount = 0;
 
   std::vector<std::string> m_Log;
+  size_t m_RegionStart = 0; ///< Log index where current region began.
+  bool m_InRegion = false;  ///< True between StartTracing/StopTracing.
 
 public:
   TraceInfo() : m_TG("CppInterOp", "CppInterOp Timing Report") {}
@@ -110,6 +112,16 @@ class TraceInfo {
   /// \param Version optional version string embedded as comments.
   CPPINTEROP_TRACE_API std::string writeToFile(const std::string& Version = "");
 
+  /// Begin a traced region. Returns the path where StopTracing will write.
+  CPPINTEROP_TRACE_API std::string StartRegion();
+
+  /// End the traced region and write only the region's entries to the file.
+  CPPINTEROP_TRACE_API void StopRegion(const std::string& Version = "");
+
+private:
+  std::string m_RegionPath;
+
+public:
   void clear() {
     // Stop any running timers before clearing to avoid triggering
     // TimerGroup's destructor report.

unittests/CppInterOp/TracingTests.cpp

@@ -699,7 +699,7 @@ TEST_F(TracingTest, LogEntriesIncludeTimingAnnotation) {
 }
 
 // ---------------------------------------------------------------------------
-// Tests: all CPPINTEROP_API functions must have INTEROP_TRACE
+// Tests: StartTracing / StopTracing region-based tracing
 // ---------------------------------------------------------------------------
 
 #ifndef EMSCRIPTEN
@@ -709,6 +709,111 @@ static std::string ReadFileToString(const std::string& path) {
           std::istreambuf_iterator<char>()};
 }
 // This test reads source files from the build tree via CPPINTEROP_DIR.
+TEST_F(TracingTest, StartStopTracingWritesToFile) {
+  // StartTracing begins recording; StopTracing writes the file.
+  std::string Path = CppInterOp::Tracing::StartTracing();
+  ASSERT_FALSE(Path.empty());
+
+  // Calls within the region are recorded.
+  VoidFunc();
+  AnnotatedFunction(5);
+
+  CppInterOp::Tracing::StopTracing();
+
+  // The file should exist and contain the traced calls.
+  std::string content = ReadFileToString(Path);
+  ASSERT_FALSE(content.empty());
+  EXPECT_THAT(content, HasSubstr("Cpp::VoidFunc()"));
+  EXPECT_THAT(content, HasSubstr("Cpp::AnnotatedFunction("));
+  EXPECT_THAT(content, HasSubstr("#include <CppInterOp/CppInterOp.h>"));
+
+  llvm::sys::fs::remove(Path);
+}
+
+TEST_F(TracingTest, OnlyRegionCallsAreRecorded) {
+  // Calls before StartTracing should not appear.
+  VoidFunc();
+
+  std::string Path = CppInterOp::Tracing::StartTracing();
+  ASSERT_FALSE(Path.empty());
+
+  AnnotatedFunction(42);
+
+  CppInterOp::Tracing::StopTracing();
+
+  // Calls after StopTracing should not appear either.
+  VoidFunc();
+
+  std::string content = ReadFileToString(Path);
+  // Should contain only the call within the region.
+  EXPECT_THAT(content, HasSubstr("Cpp::AnnotatedFunction(42)"));
+  // VoidFunc was called before and after — should NOT be in the file.
+  // Count occurrences of VoidFunc in the reproducer body.
+  auto bodyStart = content.find("void reproducer()");
+  ASSERT_NE(bodyStart, std::string::npos);
+  std::string body = content.substr(bodyStart);
+  EXPECT_EQ(body.find("VoidFunc"), std::string::npos)
+      << "VoidFunc should not appear in the reproducer body:\n"
+      << body;
+
+  llvm::sys::fs::remove(Path);
+}
+
+TEST_F(TracingTest, StartTracingWithEnvVarNarrowsToRegion) {
+  // When CPPINTEROP_LOG=1 is set (tracing already active from SetUp),
+  // StartTracing/StopTracing should still narrow to just the region.
+  ASSERT_NE(TraceInfo::TheTraceInfo, nullptr);
+
+  // This call is before the region.
+  VoidFunc();
+
+  std::string Path = CppInterOp::Tracing::StartTracing();
+  ASSERT_FALSE(Path.empty());
+
+  AnnotatedFunction(7);
+
+  CppInterOp::Tracing::StopTracing();
+
+  std::string content = ReadFileToString(Path);
+  auto bodyStart = content.find("void reproducer()");
+  ASSERT_NE(bodyStart, std::string::npos);
+  std::string body = content.substr(bodyStart);
+  EXPECT_THAT(body, HasSubstr("Cpp::AnnotatedFunction(7)"));
+  EXPECT_EQ(body.find("VoidFunc"), std::string::npos);
+
+  llvm::sys::fs::remove(Path);
+}
+
+TEST_F(TracingTest, MultipleStartStopRegions) {
+  // Multiple regions should each produce their own file.
+  std::string Path1 = CppInterOp::Tracing::StartTracing();
+  AnnotatedFunction(1);
+  CppInterOp::Tracing::StopTracing();
+
+  std::string Path2 = CppInterOp::Tracing::StartTracing();
+  AnnotatedFunction(2);
+  CppInterOp::Tracing::StopTracing();
+
+  ASSERT_NE(Path1, Path2);
+
+  std::string content1 = ReadFileToString(Path1);
+  std::string content2 = ReadFileToString(Path2);
+
+  EXPECT_THAT(content1, HasSubstr("Cpp::AnnotatedFunction(1)"));
+  EXPECT_THAT(content2, HasSubstr("Cpp::AnnotatedFunction(2)"));
+
+  // Each file should only have its own call.
+  EXPECT_EQ(content1.find("AnnotatedFunction(2)"), std::string::npos);
+  EXPECT_EQ(content2.find("AnnotatedFunction(1)"), std::string::npos);
+
+  llvm::sys::fs::remove(Path1);
+  llvm::sys::fs::remove(Path2);
+}
+
+// ---------------------------------------------------------------------------
+// Tests: all CPPINTEROP_API functions must have INTEROP_TRACE
+// ---------------------------------------------------------------------------
+
 TEST(TracingCoverageTest, AllPublicAPIsAreTraced) {
   // 1. Parse the header to extract all CPPINTEROP_API function names.
   std::string Header =