From fa1484d1c76b19b116cc72bd709899c89863703f Mon Sep 17 00:00:00 2001 From: dudcom Date: Fri, 14 Nov 2025 12:06:59 +0000 Subject: [PATCH 1/2] removing testing lines --- .dockerignore | 56 ++++--------- Sources/Agentic_System/rises-the-fog.py | 5 +- Sources/setup.py | 102 ++++++++++++++---------- docker-compose.master.yml | 4 +- 4 files changed, 81 insertions(+), 86 deletions(-) diff --git a/.dockerignore b/.dockerignore index 3119bd419..1defbd8a5 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,49 +1,23 @@ -# Git .git .gitignore - -# Build artifacts -.build/ -*.xcodeproj -*.xcworkspace - -# Swift Package Manager -.swiftpm/ -Package.resolved - -# Documentation -Docs/ -*.md -!README.md - -# Tests -Tests/ - -# Docker files (except the one we're using) -Cloud/Docker/ -Cloud/GCE/ -Cloud/Triage/ - -# V8 source (will be built in container) -v8/ - -# Temporary files -*.tmp *.log -.DS_Store -Thumbs.db - -# IDE files +*.err +logs/ +corpus/ +.venv/ +__pycache__/ +*.pyc +*.pyo +*.pyd +.Python +build/ +dist/ +*.egg-info/ .vscode/ .idea/ *.swp *.swo - -# OS files +*~ .DS_Store -.DS_Store? -._* -.Spotlight-V100 -.Trashes -ehthumbs.db -Thumbs.db +.build/ +Package.resolved diff --git a/Sources/Agentic_System/rises-the-fog.py b/Sources/Agentic_System/rises-the-fog.py index 710f30c33..716283e44 100644 --- a/Sources/Agentic_System/rises-the-fog.py +++ b/Sources/Agentic_System/rises-the-fog.py @@ -46,15 +46,16 @@ def __init__(self): # self.ebg = EBG(self.model, api_key=self.openai_api_key, anthropic_api_key=self.anthropic_api_key) -def run(): +def run(force_logging: bool = False): site.addsitedir(Path(__file__).parent.parent) #smolagent-fork - parser = argparse.ArgumentParser(description="Rise the FoG agentic system") parser.add_argument("--debug", action="store_true", help="Enable debug logging to fog logs") args = parser.parse_args() + #force logging + args.debug = force_logging if args.debug: log_dir = Path(__file__).parent / 'agents' / 'fog_logs' diff --git a/Sources/setup.py b/Sources/setup.py index 7aa7d08c9..3c91134d7 100644 --- a/Sources/setup.py +++ b/Sources/setup.py @@ -1,45 +1,65 @@ -# import Agentic_System.rises_the_fog as fog import subprocess import os +import sys +from pathlib import Path +from concurrent.futures import ThreadPoolExecutor +import importlib.util +import rises_the_fog as fog -# fog.run() - -def revert_to_original(): - script_dir = os.path.dirname(os.path.abspath(__file__)) - a = os.path.join(script_dir, "Agentic_System/orginals/ProgramTemplateWeights.swift") - b = os.path.join(script_dir, "Fuzzilli/CodeGen/ProgramTemplateWeights.swift") - os.rename(a, b) - a = os.path.join(script_dir, "Agentic_System/orginals/ProgramTemplates.swift") - b = os.path.join(script_dir, "Fuzzilli/CodeGen/ProgramTemplates.swift") - os.rename(a, b) - - -def write_sql(reuslt: bool): - if reuslt: - with open("sql.sql", "r") as f: - sql = f.read() - else: - with open("sql.sql", "r") as f: - sql = f.read() - - return sql - -result = subprocess.run(["swift", "build"], capture_output=True, text=True) -if result.returncode == 0: - write_sql(True) - print("Build templates succeeded") -else: - write_sql(False) - revert_to_original() - print("Build templates failed") - print(result.stdout) - print(result.stderr) - r2 = subprocess.run(["swift", "build"], capture_output=True, text=True) - if r2.returncode == 0: - print("Build reverted succeeded") - else: - print("safety revert failed") - print(r2.stdout) - print(r2.stderr) - exit(1) +# script_dir = Path(__file__).parent +# print(script_dir) +# fog_module_path = script_dir / "rises-the-fog.py" +# spec = importlib.util.spec_from_file_location("rises_the_fog", fog_module_path) +# fog = importlib.util.module_from_spec(spec) +# spec.loader.exec_module(fog) + +#export V8_PATH=/usr/share/vrigatoni/v8_2/v8/out/ +#export D8_PATH=/usr/share/vrigatoni/v8_2/v8/out/fuzzbuild/d8 +#export FUZZILLI_TOOL_BIN=/mnt/vdb/fuzzillai/.build/x86_64-unknown-linux-gnu/debug/FuzzILTool +#export FUZZILLI_PATH=/mnt/vdb/fuzzilla + +with ThreadPoolExecutor(max_workers=16) as executor: + futures = [executor.submit(fog.run, force_logging=True) for _ in range(16)] + for i, future in enumerate(futures): + print(f"started: {i}") + future.result() + +# def revert_to_original(): +# script_dir = os.path.dirname(os.path.abspath(__file__)) +# a = os.path.join(script_dir, "Agentic_System/orginals/ProgramTemplateWeights.swift") +# b = os.path.join(script_dir, "Fuzzilli/CodeGen/ProgramTemplateWeights.swift") +# os.rename(a, b) +# a = os.path.join(script_dir, "Agentic_System/orginals/ProgramTemplates.swift") +# b = os.path.join(script_dir, "Fuzzilli/CodeGen/ProgramTemplates.swift") +# os.rename(a, b) + + +# def write_sql(reuslt: bool): +# if reuslt: +# with open("sql.sql", "r") as f: +# sql = f.read() +# else: +# with open("sql.sql", "r") as f: +# sql = f.read() + +# return sql + +# result = subprocess.run(["swift", "build"], capture_output=True, text=True) +# if result.returncode == 0: +# write_sql(True) +# print("Build templates succeeded") +# else: +# write_sql(False) +# revert_to_original() +# print("Build templates failed") +# print(result.stdout) +# print(result.stderr) +# r2 = subprocess.run(["swift", "build"], capture_output=True, text=True) +# if r2.returncode == 0: +# print("Build reverted succeeded") +# else: +# print("safety revert failed") +# print(r2.stdout) +# print(r2.stderr) +# exit(1) diff --git a/docker-compose.master.yml b/docker-compose.master.yml index c0f3c714f..18f09203b 100644 --- a/docker-compose.master.yml +++ b/docker-compose.master.yml @@ -21,12 +21,12 @@ services: retries: 5 restart: unless-stopped networks: - - fuzzing-network + - fuzzilli-network volumes: postgres_master_data: networks: - fuzzing-network: + fuzzilli-network: driver: bridge From cdd7c9e9fb249b398a24652765ea19d46117043d Mon Sep 17 00:00:00 2001 From: Zia-Rashid Date: Wed, 3 Dec 2025 01:19:27 +0000 Subject: [PATCH 2/2] v8 diffs, can be applied to updated builds of v8 (allegedly) --- v8_patch/cov-cc.diff | 177 +++++++++++++++++++++++++++++++ v8_patch/cov-h.diff | 23 ++++ v8_patch/opt-comp-info-h.diff | 109 +++++++++++++++++++ v8_patch/pipeline-cc.diff | 193 ++++++++++++++++++++++++++++++++++ 4 files changed, 502 insertions(+) create mode 100644 v8_patch/cov-cc.diff create mode 100644 v8_patch/cov-h.diff create mode 100644 v8_patch/opt-comp-info-h.diff create mode 100644 v8_patch/pipeline-cc.diff diff --git a/v8_patch/cov-cc.diff b/v8_patch/cov-cc.diff new file mode 100644 index 000000000..c09558e37 --- /dev/null +++ b/v8_patch/cov-cc.diff @@ -0,0 +1,177 @@ +diff --git a/src/fuzzilli/cov.cc b/src/fuzzilli/cov.cc +index bf8b6925993..c5e049a516f 100644 +--- a/src/fuzzilli/cov.cc ++++ b/src/fuzzilli/cov.cc +@@ -1,9 +1,16 @@ + // Copyright 2020 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. ++// Use of this source code is governed by a BSD-style license that can ++// be found in the LICENSE file. + + #include "src/fuzzilli/cov.h" + ++// Include V8 headers first to avoid macro conflicts ++#include "src/base/platform/memory.h" ++#include "src/objects/feedback-vector.h" ++#include "src/sandbox/hardware-support.h" ++ ++// Include system headers after V8 headers ++#include + #include + #include + #include +@@ -14,14 +21,31 @@ + #include + #include + +-#include "src/base/platform/memory.h" +-#include "src/sandbox/hardware-support.h" +- +-#define SHM_SIZE 0x100000 ++#define SHM_SIZE 0x202000 + #define MAX_EDGES ((SHM_SIZE - 4) * 8) ++#define MAX_FEEDBACK_NEXUS 100000 ++ ++ ++struct FeedbackNexusData { ++ uint32_t vector_address; // Address of FeedbackVector in V8 heap ++ uint32_t ic_state; // InlineCacheState ++}; ++ ++struct optimization_turbofan_data { ++ uint32_t flags; // Flags used for optimization passes in PipelineImpl::OptimizeTurbofanGraph ++ //uint32_t address_code; ++ //uint32_t address_shared_info; ++ //uint8_t bailout_reason; ++ //bool is_osr; ++}; + + struct shmem_data { + uint32_t num_edges; ++ uint32_t feedback_nexus_count; ++ uint32_t max_feedback_nexus; ++ uint32_t turbofan_flags; ++ uint64_t turbofan_optimization_bits; ++ FeedbackNexusData feedback_nexus_data[MAX_FEEDBACK_NEXUS]; + unsigned char edges[]; + }; + +@@ -83,6 +107,12 @@ extern "C" void __sanitizer_cov_trace_pc_guard_init(uint32_t* start, + + shmem->num_edges = static_cast(stop - start); + builtins_start = 1 + shmem->num_edges; ++ ++ // Initialize feedback nexus fields ++ shmem->feedback_nexus_count = 0; ++ shmem->max_feedback_nexus = MAX_FEEDBACK_NEXUS; ++ memset(shmem->feedback_nexus_data, 0, sizeof(FeedbackNexusData) * MAX_FEEDBACK_NEXUS); ++ + fprintf(stderr, + "[COV] edge counters initialized. Shared memory: %s with %u edges\n", + shm_key, shmem->num_edges); +@@ -115,12 +145,15 @@ void sanitizer_cov_prepare_for_hardware_sandbox() { + #endif + + uint32_t sanitizer_cov_count_discovered_edges() { ++ // Calculate offset to edges array (after feedback nexus data) ++ unsigned char* edges_ptr = (unsigned char*)shmem + offsetof(struct shmem_data, edges); ++ + uint32_t on_edges_counter = 0; + for (uint32_t i = 1; i < builtins_start; ++i) { + const uint32_t byteIndex = i >> 3; // Divide by 8 using a shift operation + const uint32_t bitIndex = i & 7; // Modulo 8 using a bitwise AND operation + +- if (shmem->edges[byteIndex] & (1 << bitIndex)) { ++ if (edges_ptr[byteIndex] & (1 << bitIndex)) { + ++on_edges_counter; + } + } +@@ -128,14 +161,26 @@ uint32_t sanitizer_cov_count_discovered_edges() { + } + + extern "C" void __sanitizer_cov_trace_pc_guard(uint32_t* guard) { +- // There's a small race condition here: if this function executes in two +- // threads for the same edge at the same time, the first thread might disable +- // the edge (by setting the guard to zero) before the second thread fetches +- // the guard value (and thus the index). However, our instrumentation ignores +- // the first edge (see libcoverage.c) and so the race is unproblematic. ++ /* ++ // There's a small race condition here: if this function executes in two ++ // threads for the same edge at the same time, the first thread might disable ++ // the edge (by setting the guard to zero) before the second thread fetches ++ // the guard value (and thus the index). However, our instrumentation ignores ++ // the first edge (see libcoverage.c) and so the race is unproblematic. ++ uint32_t index = *guard; ++ shmem->edges[index / 8] |= 1 << (index % 8); ++ *guard = 0; ++ */ ++ if (!guard || *guard == 0) return; // guard already cleared — possible race + uint32_t index = *guard; +- shmem->edges[index / 8] |= 1 << (index % 8); + *guard = 0; ++ ++ // Check again in case another thread zeroed it just now (race hit) ++ if (index == 0) return; ++ ++ // Calculate offset to edges array (after feedback nexus data) ++ unsigned char* edges_ptr = (unsigned char*)shmem + offsetof(struct shmem_data, edges); ++ edges_ptr[index / 8] |= 1 << (index % 8); + } + + void cov_init_builtins_edges(uint32_t num_edges) { +@@ -161,12 +206,53 @@ void cov_update_builtins_basic_block_coverage( + fprintf(stderr, "[COV] Error: Size of builtins cov map changed.\n"); + exit(-1); + } ++ ++ // Calculate offset to edges array (after feedback nexus data) ++ unsigned char* edges_ptr = (unsigned char*)shmem + offsetof(struct shmem_data, edges); ++ + for (uint32_t i = 0; i < cov_map.size(); ++i) { + if (cov_map[i]) { + const uint32_t byteIndex = (i + builtins_start) >> 3; + const uint32_t bitIndex = (i + builtins_start) & 7; + +- shmem->edges[byteIndex] |= (1 << bitIndex); ++ edges_ptr[byteIndex] |= (1 << bitIndex); + } + } + } ++ ++ ++void cov_serialize_feedback_nexus(v8::internal::FeedbackNexus* nexus, FeedbackNexusData* data) { ++ if (!nexus || !data) return; ++ data->vector_address = static_cast(reinterpret_cast(nexus->vector().ptr())); ++ data->ic_state = static_cast(nexus->ic_state()); ++} ++ ++void cov_add_feedback_nexus(v8::internal::FeedbackNexus* nexus) { ++ if (!shmem || !nexus) return; ++ ++ // Check if we have space ++ if (shmem->feedback_nexus_count >= MAX_FEEDBACK_NEXUS) { ++ fprintf(stderr, "[COV] Warning: Feedback nexus buffer full, dropping entry\n"); ++ return; ++ } ++ cov_serialize_feedback_nexus(nexus, ++ &shmem->feedback_nexus_data[shmem->feedback_nexus_count]); ++ shmem->feedback_nexus_count++; ++ ++ // printf("[COV] Added feedback nexus: %p\n", nexus); ++ // printf("[COV] Feedback nexus count: %d\n", shmem->feedback_nexus_count); ++ // printf("[COV] Feedback nexus data: %p\n", shmem->feedback_nexus_data); ++ // printf("[COV] Feedback nexus data: %p\n", shmem->feedback_nexus_data[shmem->feedback_nexus_count]); ++ // printf("[COV] Feedback nexus data: %p\n", shmem->feedback_nexus_data[shmem->feedback_nexus_count].vector_address); ++ // printf("[COV] Feedback nexus data: %p\n", shmem->feedback_nexus_data[shmem->feedback_nexus_count].ic_state); ++} ++ ++void cov_set_turbofan_optimization_bits(uint64_t bit) { ++ if (!shmem) return; ++ shmem->turbofan_optimization_bits |= bit; ++} ++ ++void cov_set_maglev_optimization_bits(uint64_t /*bit*/) { ++ // No-op: maglev bitmap is not exported in shmem layout. ++} ++// } // namespace v8 diff --git a/v8_patch/cov-h.diff b/v8_patch/cov-h.diff new file mode 100644 index 000000000..64c2ae53c --- /dev/null +++ b/v8_patch/cov-h.diff @@ -0,0 +1,23 @@ +diff --git a/src/fuzzilli/cov.h b/src/fuzzilli/cov.h +index b48645576fc..090ac49186c 100644 +--- a/src/fuzzilli/cov.h ++++ b/src/fuzzilli/cov.h +@@ -19,4 +19,18 @@ void sanitizer_cov_prepare_for_hardware_sandbox(); + void cov_init_builtins_edges(uint32_t num_edges); + void cov_update_builtins_basic_block_coverage(const std::vector& cov_map); + ++// Forward declaration for FeedbackNexus ++namespace v8 { ++namespace internal { ++class FeedbackNexus; ++} ++} ++ ++// Global function declaration ++void cov_add_feedback_nexus(v8::internal::FeedbackNexus* nexus); ++ ++// Track optimization passes for maglev and turbofan ++void cov_set_turbofan_optimization_bits(uint64_t bit); ++void cov_set_maglev_optimization_bits(uint64_t bit); ++ + #endif // V8_FUZZILLI_COV_H_ diff --git a/v8_patch/opt-comp-info-h.diff b/v8_patch/opt-comp-info-h.diff new file mode 100644 index 000000000..dc55a9d1e --- /dev/null +++ b/v8_patch/opt-comp-info-h.diff @@ -0,0 +1,109 @@ +diff --git a/src/codegen/optimized-compilation-info.h b/src/codegen/optimized-compilation-info.h +index cf7dd4d6365..96b7d312cfb 100644 +--- a/src/codegen/optimized-compilation-info.h ++++ b/src/codegen/optimized-compilation-info.h +@@ -6,6 +6,7 @@ + #define V8_CODEGEN_OPTIMIZED_COMPILATION_INFO_H_ + + #include ++#include + + #include "src/base/vector.h" + #include "src/codegen/bailout-reason.h" +@@ -99,6 +100,87 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final { + FLAGS(DEF_SETTER) + #undef DEF_SETTER + ++ // Optimization tracing bitmap ++ // ++ // This bitmap tracks which compiler optimizations/passes are ran for a given ++ // optimized compilation. Bits correspond to major TurboFan/TurboShaft ++ // pipeline phases. ++ // ++ // phases (from pipeline passes in src/compiler/pipeline.cc): ++ // - BrokerInitAndSerialization: HeapBrokerInitializationPhase ++ // - GraphCreation: ++ // - GraphBuilderPhase ++ // - InliningPhase ++ // - Lowering and typed optimizations: ++ // - EarlyGraphTrimmingPhase ++ // - TyperPhase ++ // - TypedLoweringPhase ++ // - LoopPeelingPhase or LoopExitEliminationPhase ++ // - LoadEliminationPhase ++ // - EscapeAnalysisPhase ++ // - TypeAssertionsPhase ++ // - SimplifiedLoweringPhase ++ // - JS <-> Wasm related (conditional): ++ // - JSWasmInliningPhase ++ // - WasmTypingPhase ++ // - WasmGCOptimizationPhase ++ // - JSWasmLoweringPhase ++ // - WasmOptimizationPhase ++ // - Post-typing cleanup: ++ // - UntyperPhase (debug-only) ++ // - Generic lowering and early block optimizations: ++ // - GenericLoweringPhase ++ // - EarlyOptimizationPhase ++ // - Backend (scheduling/ISel/RA/codegen): ++ // - ComputeScheduledGraph/Scheduling ++ // - InstructionSelection ++ // - RegisterAllocation ++ // - CodeGeneration ++ // ++ enum class OptimizationBit : int { ++ kBrokerInitAndSerialization = 0, ++ kGraphBuilder, ++ kInlining, ++ kEarlyGraphTrimming, ++ kTyper, ++ kTypedLowering, ++ kLoopPeeling, ++ kLoopExitElimination, ++ kLoadElimination, ++ kEscapeAnalysis, ++ kTypeAssertions, ++ kSimplifiedLowering, ++ kJSWasmInlining, ++ kWasmTyping, ++ kWasmGCOptimization, ++ kJSWasmLowering, ++ kWasmOptimization, ++ kUntyper, ++ kGenericLowering, ++ kEarlyOptimization, ++ kScheduledGraph, ++ kInstructionSelection, ++ kRegisterAllocation, ++ kCodeGeneration ++ }; ++ ++ // set a bit indicating an optimization phase ran during this compilation ++ void SetOptimizationBit(OptimizationBit bit) { ++ const int index = static_cast(bit); ++ const int word = index / 64; ++ const int offset = index % 64; ++ optimization_bits_[word] |= (uint64_t{1} << offset); ++ } ++ ++ // query whether a given optimization phase bit is set ++ bool HasOptimizationBit(OptimizationBit bit) const { ++ const int index = static_cast(bit); ++ const int word = index / 64; ++ const int offset = index % 64; ++ return (optimization_bits_[word] & (uint64_t{1} << offset)) != 0; ++ } ++ ++ + // Construct a compilation info for optimized compilation. + OptimizedCompilationInfo(Zone* zone, Isolate* isolate, + IndirectHandle shared, +@@ -354,6 +436,8 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final { + // handles above. The only difference is that is created in the + // CanonicalHandleScope(i.e step 1) is different). + std::unique_ptr canonical_handles_; ++ // Two 64-bit words give space for up to 128 optimization bits. ++ std::array optimization_bits_ = {0, 0}; + }; + + } // namespace internal diff --git a/v8_patch/pipeline-cc.diff b/v8_patch/pipeline-cc.diff new file mode 100644 index 000000000..21de65cc0 --- /dev/null +++ b/v8_patch/pipeline-cc.diff @@ -0,0 +1,193 @@ +diff --git a/src/compiler/pipeline.cc b/src/compiler/pipeline.cc +index 7a6a69eaf3d..ac5ee2a1ce5 100644 +--- a/src/compiler/pipeline.cc ++++ b/src/compiler/pipeline.cc +@@ -104,6 +104,7 @@ + #include "src/logging/runtime-call-stats-scope.h" + #include "src/logging/runtime-call-stats.h" + #include "src/objects/code-kind.h" ++#include "src/fuzzilli/cov.h" + #include "src/objects/shared-function-info.h" + #include "src/objects/string-inl.h" + #include "src/tracing/trace-event.h" +@@ -491,6 +492,9 @@ TurbofanPipelineStatistics* CreatePipelineStatistics( + // Run Turboshaft instruction selection. + if (!turboshaft_pipeline.PrepareForInstructionSelection()) return false; + if (!turboshaft_pipeline.SelectInstructions(linkage)) return false; ++ // Mark instruction selection complete. ++ turbofan_pipeline->info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kInstructionSelection); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kInstructionSelection)); + // We can release the graph now. + turboshaft_data->ClearGraphComponent(); + +@@ -498,9 +502,13 @@ TurbofanPipelineStatistics* CreatePipelineStatistics( + linkage->GetIncomingDescriptor())) { + return false; + } ++ turbofan_pipeline->info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kRegisterAllocation); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kRegisterAllocation)); + if (!turboshaft_pipeline.AssembleCode(linkage)) { + return false; + } ++ turbofan_pipeline->info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kCodeGeneration); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kCodeGeneration)); + return true; + } + +@@ -1952,6 +1959,8 @@ bool PipelineImpl::InitializeHeapBroker() { + } + + RUN_MAYBE_ABORT(HeapBrokerInitializationPhase); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kBrokerInitAndSerialization); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kBrokerInitAndSerialization)); + data->broker()->StopSerializing(); + data->EndPhaseKind(); + return !info()->was_cancelled(); +@@ -1966,10 +1975,14 @@ bool PipelineImpl::CreateGraph(Linkage* linkage) { + + RUN_MAYBE_ABORT(GraphBuilderPhase, linkage); + RunPrintAndVerify(GraphBuilderPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kGraphBuilder); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kGraphBuilder)); + + // Perform function context specialization and inlining (if enabled). + RUN_MAYBE_ABORT(InliningPhase); + RunPrintAndVerify(InliningPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kInlining); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kInlining)); + + // Determine the Typer operation flags. + { +@@ -2000,37 +2013,52 @@ bool PipelineImpl::OptimizeTurbofanGraph(Linkage* linkage) { + // Trim the graph before typing to ensure all nodes are typed. + RUN_MAYBE_ABORT(EarlyGraphTrimmingPhase); + RunPrintAndVerify(EarlyGraphTrimmingPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kEarlyGraphTrimming); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kEarlyGraphTrimming)); + + // Type the graph and keep the Typer running such that new nodes get + // automatically typed when they are created. + RUN_MAYBE_ABORT(TyperPhase, data->CreateTyper()); + RunPrintAndVerify(TyperPhase::phase_name()); +- ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kTyper); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kTyper)); + RUN_MAYBE_ABORT(TypedLoweringPhase); + RunPrintAndVerify(TypedLoweringPhase::phase_name()); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kTypedLowering); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kTypedLowering)); + + if (data->info()->loop_peeling()) { + RUN_MAYBE_ABORT(LoopPeelingPhase); + RunPrintAndVerify(LoopPeelingPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kLoopPeeling); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kLoopPeeling)); + } else { + RUN_MAYBE_ABORT(LoopExitEliminationPhase); + RunPrintAndVerify(LoopExitEliminationPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kLoopExitElimination); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kLoopExitElimination)); + } + + if (v8_flags.turbo_load_elimination) { + RUN_MAYBE_ABORT(LoadEliminationPhase); + RunPrintAndVerify(LoadEliminationPhase::phase_name()); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kLoadElimination); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kLoadElimination)); + } + data->DeleteTyper(); + + if (v8_flags.turbo_escape) { + RUN_MAYBE_ABORT(EscapeAnalysisPhase); + RunPrintAndVerify(EscapeAnalysisPhase::phase_name()); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kEscapeAnalysis); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kEscapeAnalysis)); + } + + if (v8_flags.assert_types) { + RUN_MAYBE_ABORT(TypeAssertionsPhase); + RunPrintAndVerify(TypeAssertionsPhase::phase_name()); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kTypeAssertions); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kTypeAssertions)); + } + + // Perform simplified lowering. This has to run w/o the Typer decorator, +@@ -2038,30 +2066,39 @@ bool PipelineImpl::OptimizeTurbofanGraph(Linkage* linkage) { + // types might even conflict with the representation/truncation logic. + RUN_MAYBE_ABORT(SimplifiedLoweringPhase, linkage); + RunPrintAndVerify(SimplifiedLoweringPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kSimplifiedLowering); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kSimplifiedLowering)); + + #if V8_ENABLE_WEBASSEMBLY + if (data->has_js_wasm_calls()) { + DCHECK(data->info()->inline_js_wasm_calls()); + RUN_MAYBE_ABORT(JSWasmInliningPhase); + RunPrintAndVerify(JSWasmInliningPhase::phase_name(), true); +- ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kJSWasmInlining); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kJSWasmInlining)); + RUN_MAYBE_ABORT(WasmTypingPhase, -1); + RunPrintAndVerify(WasmTypingPhase::phase_name(), true); +- ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kWasmTyping); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kWasmTyping)); + if (v8_flags.wasm_opt) { + RUN_MAYBE_ABORT(WasmGCOptimizationPhase, + data->wasm_native_module_for_inlining()->module(), + data->jsgraph()); + RunPrintAndVerify(WasmGCOptimizationPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kWasmGCOptimization); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kWasmGCOptimization)); + } + RUN_MAYBE_ABORT(JSWasmLoweringPhase); + RunPrintAndVerify(JSWasmLoweringPhase::phase_name(), true); +- ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kJSWasmLowering); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kJSWasmLowering)); + if (v8_flags.turbo_optimize_inlined_js_wasm_wrappers && v8_flags.wasm_opt) { + wasm::WasmDetectedFeatures detected({wasm::WasmDetectedFeature::gc}); + RUN_MAYBE_ABORT(WasmOptimizationPhase, + MachineOperatorReducer::kSilenceSignallingNan, detected); + RunPrintAndVerify(WasmOptimizationPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kWasmOptimization); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kWasmOptimization)); + } + } + #endif // V8_ENABLE_WEBASSEMBLY +@@ -2077,12 +2114,15 @@ bool PipelineImpl::OptimizeTurbofanGraph(Linkage* linkage) { + #ifdef DEBUG + RUN_MAYBE_ABORT(UntyperPhase); + RunPrintAndVerify(UntyperPhase::phase_name(), true); ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kUntyper); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kUntyper)); + #endif + + // Run generic lowering pass. + RUN_MAYBE_ABORT(GenericLoweringPhase); + RunPrintAndVerify(GenericLoweringPhase::phase_name(), true); +- ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kGenericLowering); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kGenericLowering)); + data->BeginPhaseKind("V8.TFBlockBuilding"); + + data->InitializeFrameData(linkage->GetIncomingDescriptor()); +@@ -2090,14 +2130,16 @@ bool PipelineImpl::OptimizeTurbofanGraph(Linkage* linkage) { + // Run early optimization pass. + RUN_MAYBE_ABORT(EarlyOptimizationPhase); + RunPrintAndVerify(EarlyOptimizationPhase::phase_name(), true); +- ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kEarlyOptimization); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kEarlyOptimization)); + data->source_positions()->RemoveDecorator(); + if (data->info()->trace_turbo_json()) { + data->node_origins()->RemoveDecorator(); + } + + if (!ComputeScheduledGraph()) return false; +- ++ info()->SetOptimizationBit(OptimizedCompilationInfo::OptimizationBit::kScheduledGraph); ++ cov_set_turbofan_optimization_bits(1ull << static_cast(OptimizedCompilationInfo::OptimizationBit::kScheduledGraph)); + return !info()->was_cancelled(); + } + \ No newline at end of file