Upload Kmake

deps/v8/test/unittests/diagnostics/eh-frame-iterator-unittest.cc

@@ -0,0 +1,65 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/diagnostics/eh-frame.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace internal {
+
+// Test enabled only on supported architectures.
+#if defined(V8_TARGET_ARCH_X64) || defined(V8_TARGET_ARCH_ARM) || \
+    defined(V8_TARGET_ARCH_ARM64)
+
+namespace {
+
+class EhFrameIteratorTest : public testing::Test {};
+
+}  // namespace
+
+TEST_F(EhFrameIteratorTest, Values) {
+  // Assuming little endian.
+  static const uint8_t kEncoded[] = {0xDE, 0xC0, 0xAD, 0xDE, 0xEF, 0xBE, 0xFF};
+  EhFrameIterator iterator(&kEncoded[0], &kEncoded[0] + sizeof(kEncoded));
+  EXPECT_EQ(0xDEADC0DE, iterator.GetNextUInt32());
+  EXPECT_EQ(0xBEEF, iterator.GetNextUInt16());
+  EXPECT_EQ(0xFF, iterator.GetNextByte());
+  EXPECT_TRUE(iterator.Done());
+}
+
+TEST_F(EhFrameIteratorTest, Skip) {
+  static const uint8_t kEncoded[] = {0xDE, 0xAD, 0xC0, 0xDE};
+  EhFrameIterator iterator(&kEncoded[0], &kEncoded[0] + sizeof(kEncoded));
+  iterator.Skip(2);
+  EXPECT_EQ(2, iterator.GetCurrentOffset());
+  EXPECT_EQ(0xC0, iterator.GetNextByte());
+  iterator.Skip(1);
+  EXPECT_TRUE(iterator.Done());
+}
+
+TEST_F(EhFrameIteratorTest, ULEB128Decoding) {
+  static const uint8_t kEncoded[] = {0xE5, 0x8E, 0x26};
+  EhFrameIterator iterator(&kEncoded[0], &kEncoded[0] + sizeof(kEncoded));
+  EXPECT_EQ(624485u, iterator.GetNextULeb128());
+  EXPECT_TRUE(iterator.Done());
+}
+
+TEST_F(EhFrameIteratorTest, SLEB128DecodingPositive) {
+  static const uint8_t kEncoded[] = {0xE5, 0x8E, 0x26};
+  EhFrameIterator iterator(&kEncoded[0], &kEncoded[0] + sizeof(kEncoded));
+  EXPECT_EQ(624485, iterator.GetNextSLeb128());
+  EXPECT_TRUE(iterator.Done());
+}
+
+TEST_F(EhFrameIteratorTest, SLEB128DecodingNegative) {
+  static const uint8_t kEncoded[] = {0x9B, 0xF1, 0x59};
+  EhFrameIterator iterator(&kEncoded[0], &kEncoded[0] + sizeof(kEncoded));
+  EXPECT_EQ(-624485, iterator.GetNextSLeb128());
+  EXPECT_TRUE(iterator.Done());
+}
+
+#endif
+
+}  // namespace internal
+}  // namespace v8

deps/v8/test/unittests/diagnostics/eh-frame-writer-unittest.cc

@@ -0,0 +1,473 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/diagnostics/eh-frame.h"
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace internal {
+
+// Test enabled only on supported architectures.
+#if defined(V8_TARGET_ARCH_X64) || defined(V8_TARGET_ARCH_ARM) || \
+    defined(V8_TARGET_ARCH_ARM64)
+
+namespace {
+
+class EhFrameWriterTest : public TestWithZone {
+ protected:
+  // Being a 7bit positive integer, this also serves as its ULEB128 encoding.
+  static const int kTestRegisterCode = 0;
+
+  static EhFrameIterator MakeIterator(EhFrameWriter* writer) {
+    CodeDesc desc;
+    writer->GetEhFrame(&desc);
+    DCHECK_GT(desc.unwinding_info_size, 0);
+    return EhFrameIterator(desc.unwinding_info,
+                           desc.unwinding_info + desc.unwinding_info_size);
+  }
+};
+
+const int EhFrameWriterTest::kTestRegisterCode;
+
+}  // namespace
+
+TEST_F(EhFrameWriterTest, Alignment) {
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(42 * EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  ASSERT_EQ(0, EhFrameConstants::kEhFrameHdrSize % 4);
+  ASSERT_EQ(0, EhFrameConstants::kEhFrameTerminatorSize % 4);
+  EXPECT_EQ(0, (iterator.GetBufferSize() - EhFrameConstants::kEhFrameHdrSize -
+                EhFrameConstants::kEhFrameTerminatorSize) %
+                   kSystemPointerSize);
+}
+
+TEST_F(EhFrameWriterTest, FDEHeader) {
+  static const int kProcedureSize = 0x5678ABCD;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.Finish(kProcedureSize);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  int cie_size = iterator.GetNextUInt32();
+  iterator.Skip(cie_size);
+
+  int fde_size = iterator.GetNextUInt32();
+  EXPECT_EQ(iterator.GetBufferSize(),
+            fde_size + cie_size + EhFrameConstants::kEhFrameTerminatorSize +
+                EhFrameConstants::kEhFrameHdrSize + 2 * kInt32Size);
+
+  int backwards_offset_to_cie_offset = iterator.GetCurrentOffset();
+  int backwards_offset_to_cie = iterator.GetNextUInt32();
+  EXPECT_EQ(backwards_offset_to_cie_offset, backwards_offset_to_cie);
+
+  int procedure_address_offset = iterator.GetCurrentOffset();
+  int procedure_address = iterator.GetNextUInt32();
+  EXPECT_EQ(-(procedure_address_offset + RoundUp(kProcedureSize, 8)),
+            procedure_address);
+
+  int procedure_size = iterator.GetNextUInt32();
+  EXPECT_EQ(kProcedureSize, procedure_size);
+}
+
+TEST_F(EhFrameWriterTest, SetOffset) {
+  static const uint32_t kOffset = 0x0BADC0DE;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.SetBaseAddressOffset(kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kDefCfaOffset,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kOffset, iterator.GetNextULeb128());
+}
+
+TEST_F(EhFrameWriterTest, IncreaseOffset) {
+  static const uint32_t kFirstOffset = 121;
+  static const uint32_t kSecondOffset = 16;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.SetBaseAddressOffset(kFirstOffset);
+  writer.IncreaseBaseAddressOffset(kSecondOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kDefCfaOffset,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kFirstOffset, iterator.GetNextULeb128());
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kDefCfaOffset,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kFirstOffset + kSecondOffset, iterator.GetNextULeb128());
+}
+
+TEST_F(EhFrameWriterTest, SetRegister) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.SetBaseAddressRegister(test_register);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kDefCfaRegister,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(static_cast<uint32_t>(kTestRegisterCode),
+            iterator.GetNextULeb128());
+}
+
+TEST_F(EhFrameWriterTest, SetRegisterAndOffset) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+  static const uint32_t kOffset = 0x0BADC0DE;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.SetBaseAddressRegisterAndOffset(test_register, kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kDefCfa, iterator.GetNextOpcode());
+  EXPECT_EQ(static_cast<uint32_t>(kTestRegisterCode),
+            iterator.GetNextULeb128());
+  EXPECT_EQ(kOffset, iterator.GetNextULeb128());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding6bit) {
+  static const int kOffset = 42;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(kOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ((1 << 6) | kOffset, iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding6bitDelta) {
+  static const int kFirstOffset = 42;
+  static const int kSecondOffset = 62;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(kFirstOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.AdvanceLocation(kSecondOffset *
+                         EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ((1 << 6) | kFirstOffset, iterator.GetNextByte());
+  EXPECT_EQ((1 << 6) | (kSecondOffset - kFirstOffset), iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding8bit) {
+  static const int kOffset = 0x42;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(kOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kAdvanceLoc1,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kOffset, iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding8bitDelta) {
+  static const int kFirstOffset = 0x10;
+  static const int kSecondOffset = 0x70;
+  static const int kThirdOffset = 0xB5;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(kFirstOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.AdvanceLocation(kSecondOffset *
+                         EhFrameConstants::kCodeAlignmentFactor);
+  writer.AdvanceLocation(kThirdOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ((1 << 6) | kFirstOffset, iterator.GetNextByte());
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kAdvanceLoc1,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kSecondOffset - kFirstOffset, iterator.GetNextByte());
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kAdvanceLoc1,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kThirdOffset - kSecondOffset, iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding16bit) {
+  static const int kOffset = kMaxUInt8 + 42;
+  ASSERT_LT(kOffset, kMaxUInt16);
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(kOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kAdvanceLoc2,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kOffset, iterator.GetNextUInt16());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding16bitDelta) {
+  static const int kFirstOffset = 0x41;
+  static const int kSecondOffset = kMaxUInt8 + 0x42;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(kFirstOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.AdvanceLocation(kSecondOffset *
+                         EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kAdvanceLoc1,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kFirstOffset, iterator.GetNextByte());
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kAdvanceLoc2,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kSecondOffset - kFirstOffset, iterator.GetNextUInt16());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding32bit) {
+  static const uint32_t kOffset = kMaxUInt16 + 42;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(kOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kAdvanceLoc4,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kOffset, iterator.GetNextUInt32());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding32bitDelta) {
+  static const uint32_t kFirstOffset = kMaxUInt16 + 0x42;
+  static const uint32_t kSecondOffset = kMaxUInt16 + 0x67;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.AdvanceLocation(kFirstOffset * EhFrameConstants::kCodeAlignmentFactor);
+  writer.AdvanceLocation(kSecondOffset *
+                         EhFrameConstants::kCodeAlignmentFactor);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kAdvanceLoc4,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kFirstOffset, iterator.GetNextUInt32());
+
+  EXPECT_EQ((1 << 6) | (kSecondOffset - kFirstOffset), iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, SaveRegisterUnsignedOffset) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+  static const int kOffset =
+      EhFrameConstants::kDataAlignmentFactor > 0 ? 12344 : -12344;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.RecordRegisterSavedToStack(test_register, kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ((2 << 6) | kTestRegisterCode, iterator.GetNextByte());
+  EXPECT_EQ(
+      static_cast<uint32_t>(kOffset / EhFrameConstants::kDataAlignmentFactor),
+      iterator.GetNextULeb128());
+}
+
+TEST_F(EhFrameWriterTest, SaveRegisterSignedOffset) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+  static const int kOffset =
+      EhFrameConstants::kDataAlignmentFactor < 0 ? 12344 : -12344;
+
+  ASSERT_EQ(kOffset % EhFrameConstants::kDataAlignmentFactor, 0);
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.RecordRegisterSavedToStack(test_register, kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kOffsetExtendedSf,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(static_cast<uint32_t>(kTestRegisterCode),
+            iterator.GetNextULeb128());
+  EXPECT_EQ(kOffset / EhFrameConstants::kDataAlignmentFactor,
+            iterator.GetNextSLeb128());
+}
+
+TEST_F(EhFrameWriterTest, RegisterNotModified) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.RecordRegisterNotModified(test_register);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kSameValue,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(static_cast<uint32_t>(kTestRegisterCode),
+            iterator.GetNextULeb128());
+}
+
+TEST_F(EhFrameWriterTest, RegisterFollowsInitialRule) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.RecordRegisterFollowsInitialRule(test_register);
+  writer.Finish(100);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+  iterator.SkipToFdeDirectives();
+
+  EXPECT_EQ((3 << 6) | kTestRegisterCode, iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, EhFrameHdrLayout) {
+  static const int kCodeSize = 10;
+  static const int kPaddingSize = 6;
+
+  EhFrameWriter writer(zone());
+  writer.Initialize();
+  writer.Finish(kCodeSize);
+
+  EhFrameIterator iterator = MakeIterator(&writer);
+
+  // Skip the .eh_frame.
+
+  int encoded_cie_size = iterator.GetNextUInt32();
+  iterator.Skip(encoded_cie_size);
+  int cie_size = encoded_cie_size + kInt32Size;
+
+  int encoded_fde_size = iterator.GetNextUInt32();
+  iterator.Skip(encoded_fde_size);
+  int fde_size = encoded_fde_size + kInt32Size;
+
+  iterator.Skip(EhFrameConstants::kEhFrameTerminatorSize);
+
+  int eh_frame_size =
+      cie_size + fde_size + EhFrameConstants::kEhFrameTerminatorSize;
+
+  //
+  // Plugging some numbers in the DSO layout shown in eh-frame.cc:
+  //
+  //  |      ...      |
+  //  +---------------+ <-- (E) ---------
+  //  |               |                 ^
+  //  |  Instructions |  10 bytes       | .text
+  //  |               |                 v
+  //  +---------------+ <----------------
+  //  |///////////////|
+  //  |////Padding////|   6 bytes
+  //  |///////////////|
+  //  +---------------+ <---(D)----------
+  //  |               |                 ^
+  //  |      CIE      | cie_size bytes* |
+  //  |               |                 |
+  //  +---------------+ <-- (C)         |
+  //  |               |                 | .eh_frame
+  //  |      FDE      | fde_size bytes  |
+  //  |               |                 |
+  //  +---------------+                 |
+  //  |   terminator  |   4 bytes       v
+  //  +---------------+ <-- (B) ---------
+  //  |    version    |                 ^
+  //  +---------------+   4 bytes       |
+  //  |   encoding    |                 |
+  //  |  specifiers   |                 |
+  //  +---------------+ <---(A)         | .eh_frame_hdr
+  //  |   offset to   |                 |
+  //  |   .eh_frame   |                 |
+  //  +---------------+                 |
+  //  |      ...      |                ...
+  //
+  //  (*) the size of the CIE is platform dependent.
+  //
+
+  int eh_frame_hdr_version = iterator.GetNextByte();
+  EXPECT_EQ(EhFrameConstants::kEhFrameHdrVersion, eh_frame_hdr_version);
+
+  // .eh_frame pointer encoding specifier.
+  EXPECT_EQ(EhFrameConstants::kSData4 | EhFrameConstants::kPcRel,
+            iterator.GetNextByte());
+
+  // Lookup table size encoding specifier.
+  EXPECT_EQ(EhFrameConstants::kUData4, iterator.GetNextByte());
+
+  // Lookup table pointers encoding specifier.
+  EXPECT_EQ(EhFrameConstants::kSData4 | EhFrameConstants::kDataRel,
+            iterator.GetNextByte());
+
+  // A -> D
+  int offset_to_eh_frame = iterator.GetNextUInt32();
+  EXPECT_EQ(-(EhFrameConstants::kFdeVersionSize +
+              EhFrameConstants::kFdeEncodingSpecifiersSize + eh_frame_size),
+            offset_to_eh_frame);
+
+  int lut_entries = iterator.GetNextUInt32();
+  EXPECT_EQ(1, lut_entries);
+
+  // B -> E
+  int offset_to_procedure = iterator.GetNextUInt32();
+  EXPECT_EQ(-(eh_frame_size + kPaddingSize + kCodeSize), offset_to_procedure);
+
+  // B -> C
+  int offset_to_fde = iterator.GetNextUInt32();
+  EXPECT_EQ(-(fde_size + EhFrameConstants::kEhFrameTerminatorSize),
+            offset_to_fde);
+}
+
+#endif
+
+}  // namespace internal
+}  // namespace v8

deps/v8/test/unittests/diagnostics/etw-control-unittest.cc

@@ -0,0 +1,488 @@
+// Copyright 2024 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <windows.h>
+#undef INITGUID
+#define INITGUID
+#include <guiddef.h>
+
+#include <memory>
+#include <thread>  // NOLINT(build/c++11)
+
+#include "src/diagnostics/etw-isolate-load-script-data-win.h"
+#include "src/diagnostics/etw-isolate-operations-win.h"
+#include "src/diagnostics/etw-jit-metadata-win.h"
+#include "src/diagnostics/etw-jit-win.h"
+#include "src/flags/flags.h"
+#include "src/libplatform/etw/etw-provider-win.h"
+#include "test/unittests/test-utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace internal {
+namespace ETWJITInterface {
+
+using EtwControlTest = TestWithContext;
+
+DEFINE_GUID(v8_etw_guid, 0x57277741, 0x3638, 0x4A4B, 0xBD, 0xBA, 0x0A, 0xC6,
+            0xE4, 0x5D, 0xA5, 0x6C);
+
+void WINAPI ETWEnableCallback(LPCGUID /* source_id */, ULONG is_enabled,
+                              UCHAR level, ULONGLONG match_any_keyword,
+                              ULONGLONG match_all_keyword,
+                              PEVENT_FILTER_DESCRIPTOR filter_data,
+                              PVOID /* callback_context */);
+
+class EtwIsolateOperationsMock : public EtwIsolateOperations {
+ public:
+  MOCK_METHOD(void, SetEtwCodeEventHandler, (Isolate*, uint32_t), (override));
+  MOCK_METHOD(void, ResetEtwCodeEventHandler, (Isolate*), (override));
+
+  MOCK_METHOD(FilterETWSessionByURLResult, RunFilterETWSessionByURLCallback,
+              (Isolate*, const std::string&), (override));
+  MOCK_METHOD(void, RequestInterrupt, (Isolate*, InterruptCallback, void*),
+              (override));
+  MOCK_METHOD(bool, HeapReadOnlySpaceWritable, (Isolate*), (override));
+  MOCK_METHOD(std::optional<Tagged<GcSafeCode>>,
+              HeapGcSafeTryFindCodeForInnerPointer, (Isolate*, Address),
+              (override));
+};
+
+TEST_F(EtwControlTest, Enable) {
+  v8_flags.enable_etw_stack_walking = true;
+
+  // Set the flag below for helpful debug spew
+  // v8_flags.etw_trace_debug = true;
+
+  testing::NiceMock<EtwIsolateOperationsMock> etw_isolate_operations_mock;
+  EtwIsolateOperations::SetInstanceForTesting(&etw_isolate_operations_mock);
+
+  Isolate* isolate = reinterpret_cast<Isolate*>(this->isolate());
+  IsolateLoadScriptData::AddIsolate(isolate);
+
+  std::thread isolate_thread;
+  EXPECT_CALL(etw_isolate_operations_mock,
+              SetEtwCodeEventHandler(testing::Eq(isolate),
+                                     testing::Eq(kJitCodeEventDefault)))
+      .Times(2);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              SetEtwCodeEventHandler(testing::Eq(isolate),
+                                     testing::Eq(kJitCodeEventEnumExisting |
+                                                 ETWJITInterface::kEtwRundown)))
+      .Times(1);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              ResetEtwCodeEventHandler(testing::Eq(isolate)))
+      .Times(1);
+  ON_CALL(etw_isolate_operations_mock,
+          RequestInterrupt(testing::Eq(isolate), testing::_, testing::_))
+      .WillByDefault(testing::Invoke(
+          [&isolate_thread](Isolate* isolate, InterruptCallback callback,
+                            void* data) {
+            isolate_thread = std::thread([isolate, callback, data]() {
+              callback(reinterpret_cast<v8::Isolate*>(isolate), data);
+            });
+          }));
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ nullptr, /*callback_context*/ nullptr);
+  ASSERT_TRUE(has_active_etw_tracing_session_or_custom_filter);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlCaptureState, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ nullptr, /*callback_context*/ nullptr);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ nullptr, /*callback_context*/ nullptr);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlDisable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ nullptr, /*callback_context*/ nullptr);
+  ASSERT_FALSE(has_active_etw_tracing_session_or_custom_filter);
+  isolate_thread.join();
+
+  EtwIsolateOperations::SetInstanceForTesting(nullptr);
+}
+
+TEST_F(EtwControlTest, EnableWithFilterData) {
+  v8_flags.enable_etw_stack_walking = true;
+
+  // Set the flag below for helpful debug spew
+  // v8_flags.etw_trace_debug = true;
+
+  testing::NiceMock<EtwIsolateOperationsMock> etw_isolate_operations_mock;
+  EtwIsolateOperations::SetInstanceForTesting(&etw_isolate_operations_mock);
+
+  Isolate* isolate = reinterpret_cast<Isolate*>(this->isolate());
+  IsolateLoadScriptData::AddIsolate(isolate);
+
+  std::thread isolate_thread;
+  constexpr char origin_filter[] =
+      "{\"version\": 2.0, \"description\": \"\", \"filtered_urls\": "
+      "[\"https://.*example.com\"], \"trace_interpreter_frames\": true}";
+  EXPECT_CALL(etw_isolate_operations_mock,
+              RunFilterETWSessionByURLCallback(testing::Eq(isolate),
+                                               testing::Eq(origin_filter)))
+      .Times(3);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              SetEtwCodeEventHandler(testing::Eq(isolate),
+                                     testing::Eq(kJitCodeEventDefault)))
+      .Times(2);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              SetEtwCodeEventHandler(testing::Eq(isolate),
+                                     testing::Eq(kJitCodeEventEnumExisting |
+                                                 ETWJITInterface::kEtwRundown)))
+      .Times(1);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              ResetEtwCodeEventHandler(testing::Eq(isolate)))
+      .Times(1);
+  ON_CALL(etw_isolate_operations_mock,
+          RunFilterETWSessionByURLCallback(testing::Eq(isolate),
+                                           testing::Eq(origin_filter)))
+      .WillByDefault(
+          testing::Return<FilterETWSessionByURLResult>({true, true}));
+  ON_CALL(etw_isolate_operations_mock,
+          RequestInterrupt(testing::Eq(isolate), testing::_, testing::_))
+      .WillByDefault(testing::Invoke(
+          [&isolate_thread](Isolate* isolate, InterruptCallback callback,
+                            void* data) {
+            isolate_thread = std::thread([isolate, callback, data]() {
+              callback(reinterpret_cast<v8::Isolate*>(isolate), data);
+            });
+          }));
+
+  EVENT_FILTER_DESCRIPTOR event_filter_descriptor;
+  struct SchematizedTestFilter : public EVENT_FILTER_HEADER {
+    char data[0];
+  };
+
+  size_t schematized_test_filter_size =
+      sizeof(SchematizedTestFilter) + sizeof(origin_filter) - 1 /*remove '\0'*/;
+
+  std::unique_ptr<SchematizedTestFilter> schematized_test_filter;
+  schematized_test_filter.reset(reinterpret_cast<SchematizedTestFilter*>(
+      new unsigned char[schematized_test_filter_size]));
+  std::memset(schematized_test_filter.get(), 0 /*fill*/,
+              schematized_test_filter_size);
+  std::memcpy(schematized_test_filter->data, origin_filter,
+              sizeof(origin_filter) - 1 /*remove '\0'*/);
+  schematized_test_filter->Size =
+      static_cast<ULONG>(schematized_test_filter_size);
+
+  event_filter_descriptor.Ptr =
+      reinterpret_cast<ULONGLONG>(schematized_test_filter.get());
+  event_filter_descriptor.Type = EVENT_FILTER_TYPE_SCHEMATIZED;
+  event_filter_descriptor.Size =
+      static_cast<ULONG>(schematized_test_filter_size);
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  ASSERT_TRUE(has_active_etw_tracing_session_or_custom_filter);
+  isolate_thread.join();
+  ASSERT_TRUE(isolate->interpreted_frames_native_stack());
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlCaptureState, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlDisable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ nullptr, /*callback_context*/ nullptr);
+  ASSERT_FALSE(has_active_etw_tracing_session_or_custom_filter);
+  isolate_thread.join();
+
+  EtwIsolateOperations::SetInstanceForTesting(nullptr);
+}
+
+TEST_F(EtwControlTest, EnableWithNonMatchingFilterData) {
+  v8_flags.enable_etw_stack_walking = true;
+
+  // Set the flag below for helpful debug spew
+  // v8_flags.etw_trace_debug = true;
+
+  testing::NiceMock<EtwIsolateOperationsMock> etw_isolate_operations_mock;
+  EtwIsolateOperations::SetInstanceForTesting(&etw_isolate_operations_mock);
+
+  Isolate* isolate = reinterpret_cast<Isolate*>(this->isolate());
+  IsolateLoadScriptData::AddIsolate(isolate);
+
+  std::thread isolate_thread;
+  constexpr char origin_filter[] =
+      "{\"version\": 2.0, \"description\": \"\", \"filtered_urls\": "
+      "[\"https://.*example.com\"], \"trace_interpreter_frames\": true}";
+  EXPECT_CALL(etw_isolate_operations_mock,
+              RunFilterETWSessionByURLCallback(testing::Eq(isolate),
+                                               testing::Eq(origin_filter)))
+      .Times(3);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              SetEtwCodeEventHandler(testing::Eq(isolate),
+                                     testing::Eq(kJitCodeEventEnumExisting)))
+      .Times(0);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              ResetEtwCodeEventHandler(testing::Eq(isolate)))
+      .Times(1);
+  ON_CALL(etw_isolate_operations_mock,
+          RequestInterrupt(testing::Eq(isolate), testing::_, testing::_))
+      .WillByDefault(testing::Invoke(
+          [&isolate_thread](Isolate* isolate, InterruptCallback callback,
+                            void* data) {
+            isolate_thread = std::thread([isolate, callback, data]() {
+              callback(reinterpret_cast<v8::Isolate*>(isolate), data);
+            });
+          }));
+
+  EVENT_FILTER_DESCRIPTOR event_filter_descriptor;
+  struct SchematizedTestFilter : public EVENT_FILTER_HEADER {
+    char data[0];
+  };
+
+  size_t schematized_test_filter_size =
+      sizeof(SchematizedTestFilter) + sizeof(origin_filter) - 1 /*remove '\0'*/;
+
+  std::unique_ptr<SchematizedTestFilter> schematized_test_filter;
+  schematized_test_filter.reset(reinterpret_cast<SchematizedTestFilter*>(
+      new unsigned char[schematized_test_filter_size]));
+  std::memset(schematized_test_filter.get(), 0 /*fill*/,
+              schematized_test_filter_size);
+  std::memcpy(schematized_test_filter->data, origin_filter,
+              sizeof(origin_filter) - 1 /*remove '\0'*/);
+  schematized_test_filter->Size =
+      static_cast<ULONG>(schematized_test_filter_size);
+
+  event_filter_descriptor.Ptr =
+      reinterpret_cast<ULONGLONG>(schematized_test_filter.get());
+  event_filter_descriptor.Type = EVENT_FILTER_TYPE_SCHEMATIZED;
+  event_filter_descriptor.Size =
+      static_cast<ULONG>(schematized_test_filter_size);
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  ASSERT_TRUE(has_active_etw_tracing_session_or_custom_filter);
+  isolate_thread.join();
+  ASSERT_FALSE(isolate->interpreted_frames_native_stack());
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlCaptureState, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlDisable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ nullptr, /*callback_context*/ nullptr);
+  ASSERT_FALSE(has_active_etw_tracing_session_or_custom_filter);
+  isolate_thread.join();
+
+  EtwIsolateOperations::SetInstanceForTesting(nullptr);
+}
+
+TEST_F(EtwControlTest, EnableWithCustomFilterOnly) {
+  v8_flags.enable_etw_stack_walking = false;
+  v8_flags.enable_etw_by_custom_filter_only = true;
+
+  // Set the flag below for helpful debug spew
+  // v8_flags.etw_trace_debug = true;
+
+  testing::NiceMock<EtwIsolateOperationsMock> etw_isolate_operations_mock;
+  EtwIsolateOperations::SetInstanceForTesting(&etw_isolate_operations_mock);
+
+  Isolate* isolate = reinterpret_cast<Isolate*>(this->isolate());
+  IsolateLoadScriptData::AddIsolate(isolate);
+
+  std::thread isolate_thread;
+  constexpr char origin_filter[] =
+      "{\"version\": 2.0, \"description\": \"\", \"filtered_urls\": "
+      "[\"https://.*example.com\"], \"trace_interpreter_frames\": true}";
+  EXPECT_CALL(etw_isolate_operations_mock,
+              RunFilterETWSessionByURLCallback(testing::Eq(isolate),
+                                               testing::Eq(origin_filter)))
+      .Times(3);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              SetEtwCodeEventHandler(testing::Eq(isolate),
+                                     testing::Eq(kJitCodeEventDefault)))
+      .Times(2);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              SetEtwCodeEventHandler(testing::Eq(isolate),
+                                     testing::Eq(kJitCodeEventEnumExisting |
+                                                 ETWJITInterface::kEtwRundown)))
+      .Times(1);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              ResetEtwCodeEventHandler(testing::Eq(isolate)))
+      .Times(1);
+  ON_CALL(etw_isolate_operations_mock,
+          RunFilterETWSessionByURLCallback(testing::Eq(isolate),
+                                           testing::Eq(origin_filter)))
+      .WillByDefault(
+          testing::Return<FilterETWSessionByURLResult>({true, true}));
+  ON_CALL(etw_isolate_operations_mock,
+          RequestInterrupt(testing::Eq(isolate), testing::_, testing::_))
+      .WillByDefault(testing::Invoke(
+          [&isolate_thread](Isolate* isolate, InterruptCallback callback,
+                            void* data) {
+            isolate_thread = std::thread([isolate, callback, data]() {
+              callback(reinterpret_cast<v8::Isolate*>(isolate), data);
+            });
+          }));
+
+  EVENT_FILTER_DESCRIPTOR event_filter_descriptor;
+  struct SchematizedTestFilter : public EVENT_FILTER_HEADER {
+    char data[0];
+  };
+
+  size_t schematized_test_filter_size =
+      sizeof(SchematizedTestFilter) + sizeof(origin_filter) - 1 /*remove '\0'*/;
+
+  std::unique_ptr<SchematizedTestFilter> schematized_test_filter;
+  schematized_test_filter.reset(reinterpret_cast<SchematizedTestFilter*>(
+      new unsigned char[schematized_test_filter_size]));
+  std::memset(schematized_test_filter.get(), 0 /*fill*/,
+              schematized_test_filter_size);
+  std::memcpy(schematized_test_filter->data, origin_filter,
+              sizeof(origin_filter) - 1 /*remove '\0'*/);
+  schematized_test_filter->Size =
+      static_cast<ULONG>(schematized_test_filter_size);
+
+  event_filter_descriptor.Ptr =
+      reinterpret_cast<ULONGLONG>(schematized_test_filter.get());
+  event_filter_descriptor.Type = EVENT_FILTER_TYPE_SCHEMATIZED;
+  event_filter_descriptor.Size =
+      static_cast<ULONG>(schematized_test_filter_size);
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  ASSERT_TRUE(has_active_etw_tracing_session_or_custom_filter);
+  isolate_thread.join();
+  ASSERT_TRUE(isolate->interpreted_frames_native_stack());
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlCaptureState, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  isolate_thread.join();
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlDisable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ nullptr, /*callback_context*/ nullptr);
+  ASSERT_FALSE(has_active_etw_tracing_session_or_custom_filter);
+  isolate_thread.join();
+
+  EtwIsolateOperations::SetInstanceForTesting(nullptr);
+}
+
+TEST_F(EtwControlTest, EnableWithNonMatchingCustomFilterOnly) {
+  v8_flags.enable_etw_stack_walking = false;
+  v8_flags.enable_etw_by_custom_filter_only = true;
+
+  // Set the flag below for helpful debug spew
+  // v8_flags.etw_trace_debug = true;
+
+  testing::NiceMock<EtwIsolateOperationsMock> etw_isolate_operations_mock;
+  EtwIsolateOperations::SetInstanceForTesting(&etw_isolate_operations_mock);
+
+  Isolate* isolate = reinterpret_cast<Isolate*>(this->isolate());
+  IsolateLoadScriptData::AddIsolate(isolate);
+
+  std::thread isolate_thread;
+  constexpr char origin_filter[] =
+      "{\"version\": 2.0, \"description\": \"\", \"filtered_urls\": "
+      "[\"https://.*example.com\"], \"trace_interpreter_frames\": true}";
+  EXPECT_CALL(etw_isolate_operations_mock,
+              RunFilterETWSessionByURLCallback(testing::Eq(isolate),
+                                               testing::Eq(origin_filter)))
+      .Times(1);
+  EXPECT_CALL(etw_isolate_operations_mock,
+              SetEtwCodeEventHandler(testing::Eq(isolate),
+                                     testing::Eq(kJitCodeEventEnumExisting)))
+      .Times(0);
+  ON_CALL(etw_isolate_operations_mock,
+          RunFilterETWSessionByURLCallback(testing::Eq(isolate),
+                                           testing::Eq(origin_filter)))
+      .WillByDefault(
+          testing::Return<FilterETWSessionByURLResult>({false, true}));
+  ON_CALL(etw_isolate_operations_mock,
+          RequestInterrupt(testing::Eq(isolate), testing::_, testing::_))
+      .WillByDefault(testing::Invoke(
+          [&isolate_thread](Isolate* isolate, InterruptCallback callback,
+                            void* data) {
+            isolate_thread = std::thread([isolate, callback, data]() {
+              callback(reinterpret_cast<v8::Isolate*>(isolate), data);
+            });
+          }));
+
+  EVENT_FILTER_DESCRIPTOR event_filter_descriptor;
+  struct SchematizedTestFilter : public EVENT_FILTER_HEADER {
+    char data[0];
+  };
+
+  size_t schematized_test_filter_size =
+      sizeof(SchematizedTestFilter) + sizeof(origin_filter) - 1 /*remove '\0'*/;
+
+  std::unique_ptr<SchematizedTestFilter> schematized_test_filter;
+  schematized_test_filter.reset(reinterpret_cast<SchematizedTestFilter*>(
+      new unsigned char[schematized_test_filter_size]));
+  std::memset(schematized_test_filter.get(), 0 /*fill*/,
+              schematized_test_filter_size);
+  std::memcpy(schematized_test_filter->data, origin_filter,
+              sizeof(origin_filter) - 1 /*remove '\0'*/);
+  schematized_test_filter->Size =
+      static_cast<ULONG>(schematized_test_filter_size);
+
+  event_filter_descriptor.Ptr =
+      reinterpret_cast<ULONGLONG>(schematized_test_filter.get());
+  event_filter_descriptor.Type = EVENT_FILTER_TYPE_SCHEMATIZED;
+  event_filter_descriptor.Size =
+      static_cast<ULONG>(schematized_test_filter_size);
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlEnable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ &event_filter_descriptor,
+                    /*callback_context*/ nullptr);
+  isolate_thread.join();
+  ASSERT_TRUE(has_active_etw_tracing_session_or_custom_filter);
+  ASSERT_FALSE(isolate->interpreted_frames_native_stack());
+
+  ETWEnableCallback(&v8_etw_guid, kEtwControlDisable, /*level*/ 5,
+                    /*match_any_keyword*/ ~0, /*match_all_keyword*/ 0,
+                    /*filter_data*/ nullptr, /*callback_context*/ nullptr);
+  isolate_thread.join();
+  ASSERT_FALSE(has_active_etw_tracing_session_or_custom_filter);
+  ASSERT_FALSE(isolate->interpreted_frames_native_stack());
+
+  EtwIsolateOperations::SetInstanceForTesting(nullptr);
+}
+
+}  // namespace ETWJITInterface
+}  // namespace internal
+}  // namespace v8

deps/v8/test/unittests/diagnostics/etw-isolate-capture-state-monitor-win-unittest.cc

@@ -0,0 +1,72 @@
+// Copyright 2024 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/diagnostics/etw-isolate-capture-state-monitor-win.h"
+
+#include <thread>  // NOLINT(build/c++11)
+
+#include "src/base/platform/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace internal {
+namespace ETWJITInterface {
+
+TEST(EtwIsolateCaptureStateMonitorTest, Timeout) {
+  base::Mutex mutex;
+  base::MutexGuard guard(&mutex);
+
+  auto monitor = std::make_shared<EtwIsolateCaptureStateMonitor>(
+      &mutex, 1 /*isolate_count*/);
+  bool completed = monitor->WaitFor(base::TimeDelta::FromSeconds(1));
+
+  ASSERT_FALSE(completed);
+}
+
+TEST(EtwIsolateCaptureStateMonitorTest, TimeoutWithOneNotify) {
+  base::Mutex mutex;
+  base::MutexGuard guard(&mutex);
+
+  auto monitor = std::make_shared<EtwIsolateCaptureStateMonitor>(
+      &mutex, 2 /*isolate_count*/);
+  std::thread t1([monitor]() { monitor->Notify(); });
+
+  bool completed = monitor->WaitFor(base::TimeDelta::FromSeconds(1));
+
+  t1.join();
+
+  ASSERT_FALSE(completed);
+}
+
+TEST(EtwIsolateCaptureStateMonitorTest, Completed) {
+  base::Mutex mutex;
+  base::MutexGuard guard(&mutex);
+
+  auto monitor = std::make_shared<EtwIsolateCaptureStateMonitor>(
+      &mutex, 2 /*isolate_count*/);
+  std::thread t1([monitor]() { monitor->Notify(); });
+  std::thread t2([monitor]() { monitor->Notify(); });
+
+  bool completed = monitor->WaitFor(base::TimeDelta::FromSeconds(10));
+
+  t1.join();
+  t2.join();
+
+  ASSERT_TRUE(completed);
+}
+
+TEST(EtwIsolateCaptureStateMonitorTest, DontBlockOnZeroIsolateCount) {
+  base::Mutex mutex;
+  base::MutexGuard guard(&mutex);
+
+  auto monitor = std::make_shared<EtwIsolateCaptureStateMonitor>(
+      &mutex, 0 /*isolate_count*/);
+  bool completed = monitor->WaitFor(base::TimeDelta::FromSeconds(1));
+
+  ASSERT_TRUE(completed);
+}
+
+}  // namespace ETWJITInterface
+}  // namespace internal
+}  // namespace v8

deps/v8/test/unittests/diagnostics/gdb-jit-unittest.cc

@@ -0,0 +1,58 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/diagnostics/gdb-jit.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace internal {
+namespace GDBJITInterface {
+
+#ifdef ENABLE_GDB_JIT_INTERFACE
+TEST(GDBJITTest, OverlapEntries) {
+  ClearCodeMapForTesting();
+
+  base::AddressRegion ar{10, 10};
+  AddRegionForTesting(ar);
+
+  // Full containment.
+  ASSERT_EQ(1u, NumOverlapEntriesForTesting({11, 2}));
+  // Overlap start.
+  ASSERT_EQ(1u, NumOverlapEntriesForTesting({5, 10}));
+  // Overlap end.
+  ASSERT_EQ(1u, NumOverlapEntriesForTesting({15, 10}));
+
+  // No overlap.
+  // Completely smaller.
+  ASSERT_EQ(0u, NumOverlapEntriesForTesting({5, 5}));
+  // Completely bigger.
+  ASSERT_EQ(0u, NumOverlapEntriesForTesting({20, 10}));
+
+  AddRegionForTesting({20, 10});
+  // Now we have 2 code entries that don't overlap:
+  // [ entry 1 ][entry 2]
+  // ^ 10       ^ 20
+
+  // Overlap none.
+  ASSERT_EQ(0u, NumOverlapEntriesForTesting({0, 5}));
+  ASSERT_EQ(0u, NumOverlapEntriesForTesting({30, 5}));
+
+  // Overlap one.
+  ASSERT_EQ(1u, NumOverlapEntriesForTesting({15, 5}));
+  ASSERT_EQ(1u, NumOverlapEntriesForTesting({20, 5}));
+
+  // Overlap both.
+  ASSERT_EQ(2u, NumOverlapEntriesForTesting({15, 10}));
+  ASSERT_EQ(2u, NumOverlapEntriesForTesting({5, 20}));
+  ASSERT_EQ(2u, NumOverlapEntriesForTesting({15, 20}));
+  ASSERT_EQ(2u, NumOverlapEntriesForTesting({0, 40}));
+
+  ClearCodeMapForTesting();
+}
+#endif
+
+}  // namespace GDBJITInterface
+}  // namespace internal
+}  // namespace v8