[maglev] Use v8_flags for accessing flag values

Avoid the deprecated FLAG_* syntax, access flag values via the
{v8_flags} struct instead.

R=leszeks@chromium.org

Bug: v8:12887
Change-Id: I45a24a6297153f279a060079c0ee318545df6817
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3898931Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Commit-Queue: Clemens Backes <clemensb@chromium.org>
Cr-Commit-Position: refs/heads/main@{#83215}

src/maglev/maglev-assembler-inl.h

@@ -252,7 +252,7 @@ inline void MaglevAssembler::JumpToDeferredIf(Condition cond,
                                               Args&&... args) {
   DeferredCodeInfo* deferred_code = PushDeferredCode<Function, Args...>(
       std::forward<Function>(deferred_code_gen), std::forward<Args>(args)...);
-  if (FLAG_code_comments) {
+  if (v8_flags.code_comments) {
     RecordComment("-- Jump to deferred code");
   }
   j(cond, &deferred_code->deferred_code_label);

src/maglev/maglev-code-generator.cc

@@ -637,7 +637,7 @@ class MaglevCodeGeneratingNodeProcessor {
       : masm_(masm) {}
 
   void PreProcessGraph(Graph* graph) {
-    if (FLAG_maglev_break_on_entry) {
+    if (v8_flags.maglev_break_on_entry) {
       __ int3();
     }
 
@@ -764,7 +764,7 @@ class MaglevCodeGeneratingNodeProcessor {
   }
 
   void PreProcessBasicBlock(BasicBlock* block) {
-    if (FLAG_code_comments) {
+    if (v8_flags.code_comments) {
       std::stringstream ss;
       ss << "-- Block b" << graph_labeller()->BlockId(block);
       __ RecordComment(ss.str());
@@ -775,14 +775,14 @@ class MaglevCodeGeneratingNodeProcessor {
 
   template <typename NodeT>
   void Process(NodeT* node, const ProcessingState& state) {
-    if (FLAG_code_comments) {
+    if (v8_flags.code_comments) {
       std::stringstream ss;
       ss << "--   " << graph_labeller()->NodeId(node) << ": "
          << PrintNode(graph_labeller(), node);
       __ RecordComment(ss.str());
     }
 
-    if (FLAG_debug_code) {
+    if (v8_flags.debug_code) {
       __ movq(kScratchRegister, rbp);
       __ subq(kScratchRegister, rsp);
       __ cmpq(kScratchRegister,
@@ -806,7 +806,7 @@ class MaglevCodeGeneratingNodeProcessor {
             compiler::AllocatedOperand::cast(value_node->result().operand());
         // We shouldn't spill nodes which already output to the stack.
         if (!source.IsAnyStackSlot()) {
-          if (FLAG_code_comments) __ RecordComment("--   Spill:");
+          if (v8_flags.code_comments) __ RecordComment("--   Spill:");
           if (source.IsRegister()) {
             __ movq(masm()->GetStackSlot(value_node->spill_slot()),
                     ToRegister(source));
@@ -851,7 +851,7 @@ class MaglevCodeGeneratingNodeProcessor {
         // TODO(leszeks): We should remove dead phis entirely and turn this into
         // a DCHECK.
         if (!phi->has_valid_live_range()) {
-          if (FLAG_code_comments) {
+          if (v8_flags.code_comments) {
             std::stringstream ss;
             ss << "--   * "
                << phi->input(state.block()->predecessor_id()).operand() << " → "
@@ -866,7 +866,7 @@ class MaglevCodeGeneratingNodeProcessor {
         compiler::InstructionOperand source = input.operand();
         compiler::AllocatedOperand target =
             compiler::AllocatedOperand::cast(phi->result().operand());
-        if (FLAG_code_comments) {
+        if (v8_flags.code_comments) {
           std::stringstream ss;
           ss << "--   * " << source << " → " << target << " (n"
              << graph_labeller()->NodeId(phi) << ")";
@@ -889,7 +889,7 @@ class MaglevCodeGeneratingNodeProcessor {
           if (LoadMergeState(state, &node, &merge)) {
             compiler::InstructionOperand source =
                 merge->operand(predecessor_id);
-            if (FLAG_code_comments) {
+            if (v8_flags.code_comments) {
               std::stringstream ss;
               ss << "--   * " << source << " → " << reg;
               __ RecordComment(ss.str());
@@ -909,7 +909,7 @@ class MaglevCodeGeneratingNodeProcessor {
           if (LoadMergeState(state, &node, &merge)) {
             compiler::InstructionOperand source =
                 merge->operand(predecessor_id);
-            if (FLAG_code_comments) {
+            if (v8_flags.code_comments) {
               std::stringstream ss;
               ss << "--   * " << source << " → " << reg;
               __ RecordComment(ss.str());

src/maglev/maglev-compilation-info.cc

@@ -54,12 +54,12 @@ MaglevCompilationInfo::MaglevCompilationInfo(Isolate* isolate,
     : zone_(isolate->allocator(), kMaglevZoneName),
       isolate_(isolate),
       broker_(new compiler::JSHeapBroker(
-          isolate, zone(), FLAG_trace_heap_broker, CodeKind::MAGLEV))
-#define V(Name) , Name##_(FLAG_##Name)
+          isolate, zone(), v8_flags.trace_heap_broker, CodeKind::MAGLEV))
+#define V(Name) , Name##_(v8_flags.Name)
           MAGLEV_COMPILATION_FLAG_LIST(V)
 #undef V
 {
-  DCHECK(FLAG_maglev);
+  DCHECK(v8_flags.maglev);
 
   MaglevCompilationHandleScope compilation(isolate, this);
 

src/maglev/maglev-compiler.cc

@@ -539,13 +539,14 @@ void MaglevCompiler::Compile(LocalIsolate* local_isolate,
   compiler::UnparkedScopeIfNeeded unparked_scope(compilation_info->broker());
 
   // Build graph.
-  if (FLAG_print_maglev_code || FLAG_code_comments || FLAG_print_maglev_graph ||
-      FLAG_trace_maglev_graph_building || FLAG_trace_maglev_regalloc) {
+  if (v8_flags.print_maglev_code || v8_flags.code_comments ||
+      v8_flags.print_maglev_graph || v8_flags.trace_maglev_graph_building ||
+      v8_flags.trace_maglev_regalloc) {
     compilation_info->set_graph_labeller(new MaglevGraphLabeller());
   }
 
-  if (FLAG_print_maglev_code || FLAG_print_maglev_graph ||
-      FLAG_trace_maglev_graph_building || FLAG_trace_maglev_regalloc) {
+  if (v8_flags.print_maglev_code || v8_flags.print_maglev_graph ||
+      v8_flags.trace_maglev_graph_building || v8_flags.trace_maglev_regalloc) {
     MaglevCompilationUnit* top_level_unit =
         compilation_info->toplevel_compilation_unit();
     std::cout << "Compiling " << Brief(*top_level_unit->function().object())
@@ -561,7 +562,7 @@ void MaglevCompiler::Compile(LocalIsolate* local_isolate,
 
   graph_builder.Build();
 
-  if (FLAG_print_maglev_graph) {
+  if (v8_flags.print_maglev_graph) {
     std::cout << "\nAfter graph buiding" << std::endl;
     PrintGraph(std::cout, compilation_info, graph_builder.graph());
   }
@@ -579,7 +580,7 @@ void MaglevCompiler::Compile(LocalIsolate* local_isolate,
     processor.ProcessGraph(graph_builder.graph());
   }
 
-  if (FLAG_print_maglev_graph) {
+  if (v8_flags.print_maglev_graph) {
     std::cout << "After node processor" << std::endl;
     PrintGraph(std::cout, compilation_info, graph_builder.graph());
   }
@@ -587,7 +588,7 @@ void MaglevCompiler::Compile(LocalIsolate* local_isolate,
   StraightForwardRegisterAllocator allocator(compilation_info,
                                              graph_builder.graph());
 
-  if (FLAG_print_maglev_graph) {
+  if (v8_flags.print_maglev_graph) {
     std::cout << "After register allocation" << std::endl;
     PrintGraph(std::cout, compilation_info, graph_builder.graph());
   }
@@ -629,7 +630,7 @@ MaybeHandle<CodeT> MaglevCompiler::GenerateCode(
     return {};
   }
 
-  if (FLAG_print_maglev_code) {
+  if (v8_flags.print_maglev_code) {
     code->Print();
   }
 

src/maglev/maglev-concurrent-dispatcher.cc

@@ -88,7 +88,7 @@ MaglevCompilationJob::MaglevCompilationJob(
     std::unique_ptr<MaglevCompilationInfo>&& info)
     : OptimizedCompilationJob(kMaglevCompilerName, State::kReadyToPrepare),
       info_(std::move(info)) {
-  DCHECK(FLAG_maglev);
+  DCHECK(v8_flags.maglev);
 }
 
 MaglevCompilationJob::~MaglevCompilationJob() = default;
@@ -157,7 +157,7 @@ class MaglevConcurrentDispatcher::JobTask final : public v8::JobTask {
 
 MaglevConcurrentDispatcher::MaglevConcurrentDispatcher(Isolate* isolate)
     : isolate_(isolate) {
-  if (FLAG_concurrent_recompilation && FLAG_maglev) {
+  if (v8_flags.concurrent_recompilation && v8_flags.maglev) {
     job_handle_ = V8::GetCurrentPlatform()->PostJob(
         TaskPriority::kUserVisible, std::make_unique<JobTask>(this));
     DCHECK(is_enabled());

src/maglev/maglev-graph-builder.cc

@@ -133,7 +133,7 @@ void MaglevGraphBuilder::BuildMergeStates() {
     const compiler::LoopInfo& loop_info = offset_and_info.second;
     const compiler::BytecodeLivenessState* liveness = GetInLivenessFor(offset);
     DCHECK_NULL(merge_states_[offset]);
-    if (FLAG_trace_maglev_graph_building) {
+    if (v8_flags.trace_maglev_graph_building) {
       std::cout << "- Creating loop merge state at @" << offset << std::endl;
     }
     merge_states_[offset] = MergePointInterpreterFrameState::NewForLoop(
@@ -150,7 +150,7 @@ void MaglevGraphBuilder::BuildMergeStates() {
           GetInLivenessFor(offset);
       DCHECK_EQ(NumPredecessors(offset), 0);
       DCHECK_NULL(merge_states_[offset]);
-      if (FLAG_trace_maglev_graph_building) {
+      if (v8_flags.trace_maglev_graph_building) {
         std::cout << "- Creating exception merge state at @" << offset
                   << ", context register r" << context_reg.index() << std::endl;
       }
@@ -1966,7 +1966,7 @@ void MaglevGraphBuilder::BuildCallFromRegisters(
       return;
 
     case compiler::ProcessedFeedback::kCall: {
-      if (!FLAG_maglev_inlining) break;
+      if (!v8_flags.maglev_inlining) break;
 
       const compiler::CallFeedback& call_feedback = processed_feedback.AsCall();
       CallFeedbackContent content = call_feedback.call_feedback_content();
@@ -2677,7 +2677,7 @@ void MaglevGraphBuilder::MergeDeadIntoFrameState(int target) {
     // If this merge is the last one which kills a loop merge, remove that
     // merge state.
     if (merge_states_[target]->is_unreachable_loop()) {
-      if (FLAG_trace_maglev_graph_building) {
+      if (v8_flags.trace_maglev_graph_building) {
         std::cout << "! Killing loop merge state at @" << target << std::endl;
       }
       merge_states_[target] = nullptr;
@@ -3059,7 +3059,7 @@ void MaglevGraphBuilder::VisitResumeGenerator() {
       {generator}, JSGeneratorObject::kParametersAndRegistersOffset);
   interpreter::RegisterList registers = iterator_.GetRegisterListOperand(1);
 
-  if (FLAG_maglev_assert) {
+  if (v8_flags.maglev_assert) {
     // Check if register count is invalid, that is, larger than the
     // register file length.
     ValueNode* array_length_smi =

src/maglev/maglev-graph-builder.h

@@ -96,7 +96,7 @@ class MaglevGraphBuilder {
     if (has_graph_labeller()) {
       for (Phi* phi : *merge_states_[offset]->phis()) {
         graph_labeller()->RegisterNode(phi);
-        if (FLAG_trace_maglev_graph_building) {
+        if (v8_flags.trace_maglev_graph_building) {
           std::cout << "  " << phi << "  "
                     << PrintNodeLabel(graph_labeller(), phi) << ": "
                     << PrintNode(graph_labeller(), phi) << std::endl;
@@ -147,7 +147,7 @@ class MaglevGraphBuilder {
     if (has_graph_labeller()) {
       for (Phi* phi : *merge_states_[offset]->phis()) {
         graph_labeller()->RegisterNode(phi);
-        if (FLAG_trace_maglev_graph_building) {
+        if (v8_flags.trace_maglev_graph_building) {
           std::cout << "  " << phi << "  "
                     << PrintNodeLabel(graph_labeller(), phi) << ": "
                     << PrintNode(graph_labeller(), phi) << std::endl;
@@ -174,7 +174,7 @@ class MaglevGraphBuilder {
 
   void MarkBytecodeDead() {
     DCHECK_NULL(current_block_);
-    if (FLAG_trace_maglev_graph_building) {
+    if (v8_flags.trace_maglev_graph_building) {
       std::cout << "== Dead ==\n"
                 << std::setw(4) << iterator_.current_offset() << " : ";
       interpreter::BytecodeDecoder::Decode(std::cout,
@@ -250,7 +250,7 @@ class MaglevGraphBuilder {
         merge_state->Merge(*compilation_unit_, current_interpreter_frame_,
                            graph()->last_block(), offset);
       }
-      if (FLAG_trace_maglev_graph_building) {
+      if (v8_flags.trace_maglev_graph_building) {
         auto detail = merge_state->is_exception_handler() ? "exception handler"
                       : merge_state->is_loop()            ? "loop header"
                                                           : "merge";
@@ -316,7 +316,7 @@ class MaglevGraphBuilder {
     }
 
     DCHECK_NOT_NULL(current_block_);
-    if (FLAG_trace_maglev_graph_building) {
+    if (v8_flags.trace_maglev_graph_building) {
       std::cout << std::setw(4) << iterator_.current_offset() << " : ";
       interpreter::BytecodeDecoder::Decode(std::cout,
                                            iterator_.current_address());
@@ -352,7 +352,7 @@ class MaglevGraphBuilder {
     }
     current_block_->nodes().Add(node);
     if (has_graph_labeller()) graph_labeller()->RegisterNode(node);
-    if (FLAG_trace_maglev_graph_building) {
+    if (v8_flags.trace_maglev_graph_building) {
       std::cout << "  " << node << "  "
                 << PrintNodeLabel(graph_labeller(), node) << ": "
                 << PrintNode(graph_labeller(), node) << std::endl;
@@ -900,7 +900,7 @@ class MaglevGraphBuilder {
     graph()->Add(block);
     if (has_graph_labeller()) {
       graph_labeller()->RegisterBasicBlock(block);
-      if (FLAG_trace_maglev_graph_building) {
+      if (v8_flags.trace_maglev_graph_building) {
         bool kSkipTargets = true;
         std::cout << "  " << control_node << "  "
                   << PrintNodeLabel(graph_labeller(), control_node) << ": "
@@ -938,7 +938,7 @@ class MaglevGraphBuilder {
     DCHECK_NULL(current_block_);
     if (std::is_base_of<ConditionalControlNode, ControlNodeT>::value) {
       if (NumPredecessors(next_block_offset) == 1) {
-        if (FLAG_trace_maglev_graph_building) {
+        if (v8_flags.trace_maglev_graph_building) {
           std::cout << "== New block (single fallthrough) ==" << std::endl;
         }
         StartNewBlock(next_block_offset);

src/maglev/maglev-graph-printer.cc

@@ -45,7 +45,7 @@ void PrintPaddedId(std::ostream& os, MaglevGraphLabeller* graph_labeller,
   for (int i = 0; i < padding_width; ++i) {
     os << padding;
   }
-  if (FLAG_log_colour) os << "\033[0m";
+  if (v8_flags.log_colour) os << "\033[0m";
   if (node->has_id()) {
     os << node->id() << "/";
   }
@@ -158,7 +158,7 @@ void PrintVerticalArrows(std::ostream& os,
       desired_color = (i % 6) + 1;
       c.AddVertical();
     }
-    if (FLAG_log_colour && desired_color != current_color &&
+    if (v8_flags.log_colour && desired_color != current_color &&
         desired_color != -1) {
       os << "\033[0;3" << desired_color << "m";
       current_color = desired_color;
@@ -167,7 +167,7 @@ void PrintVerticalArrows(std::ostream& os,
   }
   // If there are no arrows starting here, clear the color. Otherwise,
   // PrintPaddedId will clear it.
-  if (FLAG_log_colour && arrows_starting_here.empty() &&
+  if (v8_flags.log_colour && arrows_starting_here.empty() &&
       targets_starting_here.empty()) {
     os << "\033[0m";
   }
@@ -342,7 +342,7 @@ void MaglevPrintingVisitor::PreProcessBasicBlock(BasicBlock* block) {
         desired_color = (i % 6) + 1;
         c.AddVertical();
       }
-      if (FLAG_log_colour && current_color != desired_color &&
+      if (v8_flags.log_colour && current_color != desired_color &&
           desired_color != -1) {
         os_ << "\033[0;3" << desired_color << "m";
         current_color = desired_color;
@@ -350,7 +350,7 @@ void MaglevPrintingVisitor::PreProcessBasicBlock(BasicBlock* block) {
       os_ << c;
     }
     os_ << (saw_start ? "►" : " ");
-    if (FLAG_log_colour) os_ << "\033[0m";
+    if (v8_flags.log_colour) os_ << "\033[0m";
   }
 
   int block_id = graph_labeller_->BlockId(block);

src/maglev/maglev-interpreter-frame-state.h

@@ -504,14 +504,14 @@ class MergePointInterpreterFrameState {
       known_node_aspects_->Merge(unmerged.known_node_aspects());
     }
 
-    if (FLAG_trace_maglev_graph_building) {
+    if (v8_flags.trace_maglev_graph_building) {
       std::cout << "Merging..." << std::endl;
     }
     frame_state_.ForEachValue(compilation_unit, [&](ValueNode*& value,
                                                     interpreter::Register reg) {
       CheckIsLoopPhiIfNeeded(compilation_unit, merge_offset, reg, value);
 
-      if (FLAG_trace_maglev_graph_building) {
+      if (v8_flags.trace_maglev_graph_building) {
         std::cout << "  " << reg.ToString() << ": "
                   << PrintNodeLabel(compilation_unit.graph_labeller(), value)
                   << " <- "
@@ -520,7 +520,7 @@ class MergePointInterpreterFrameState {
       }
       value = MergeValue(compilation_unit, reg, value, unmerged.get(reg),
                          merge_offset);
-      if (FLAG_trace_maglev_graph_building) {
+      if (v8_flags.trace_maglev_graph_building) {
         std::cout << " => "
                   << PrintNodeLabel(compilation_unit.graph_labeller(), value)
                   << ": " << PrintNode(compilation_unit.graph_labeller(), value)
@@ -541,14 +541,14 @@ class MergePointInterpreterFrameState {
     DCHECK(is_unmerged_loop());
     predecessors_[predecessor_count_ - 1] = loop_end_block;
 
-    if (FLAG_trace_maglev_graph_building) {
+    if (v8_flags.trace_maglev_graph_building) {
       std::cout << "Merging loop backedge..." << std::endl;
     }
     frame_state_.ForEachValue(compilation_unit, [&](ValueNode* value,
                                                     interpreter::Register reg) {
       CheckIsLoopPhiIfNeeded(compilation_unit, merge_offset, reg, value);
 
-      if (FLAG_trace_maglev_graph_building) {
+      if (v8_flags.trace_maglev_graph_building) {
         std::cout << "  " << reg.ToString() << ": "
                   << PrintNodeLabel(compilation_unit.graph_labeller(), value)
                   << " <- "
@@ -557,7 +557,7 @@ class MergePointInterpreterFrameState {
       }
       MergeLoopValue(compilation_unit, reg, value, loop_end_state.get(reg),
                      merge_offset);
-      if (FLAG_trace_maglev_graph_building) {
+      if (v8_flags.trace_maglev_graph_building) {
         std::cout << " => "
                   << PrintNodeLabel(compilation_unit.graph_labeller(), value)
                   << ": " << PrintNode(compilation_unit.graph_labeller(), value)
@@ -770,7 +770,7 @@ class MergePointInterpreterFrameState {
 
     for (int i = 0; i < predecessors_so_far_; i++) result->set_input(i, merged);
     result->set_input(predecessors_so_far_, unmerged);
-    if (FLAG_trace_maglev_graph_building) {
+    if (v8_flags.trace_maglev_graph_building) {
       for (int i = predecessors_so_far_ + 1; i < predecessor_count_; i++) {
         result->set_input(i, nullptr);
       }
@@ -823,7 +823,7 @@ class MergePointInterpreterFrameState {
     DCHECK_EQ(predecessors_so_far_, 0);
     // Create a new loop phi, which for now is empty.
     Phi* result = Node::New<Phi>(zone, predecessor_count_, reg, merge_offset);
-    if (FLAG_trace_maglev_graph_building) {
+    if (v8_flags.trace_maglev_graph_building) {
       for (int i = 0; i < predecessor_count_; i++) {
         result->set_input(i, nullptr);
       }

src/maglev/maglev-ir.cc

@@ -151,7 +151,7 @@ void AllocateRaw(MaglevAssembler* masm, RegisterSnapshot& register_snapshot,
   // TODO(victorgomes): Call the runtime for large object allocation.
   // TODO(victorgomes): Support double alignment.
   DCHECK_EQ(alignment, kTaggedAligned);
-  if (FLAG_single_generation) {
+  if (v8_flags.single_generation) {
     alloc_type = AllocationType::kOld;
   }
   bool in_new_space = alloc_type == AllocationType::kYoung;
@@ -1386,7 +1386,7 @@ void CheckJSArrayBounds::GenerateCode(MaglevAssembler* masm,
   __ AssertNotSmi(object);
   __ AssertSmi(index);
 
-  if (FLAG_debug_code) {
+  if (v8_flags.debug_code) {
     __ CmpObjectType(object, JS_ARRAY_TYPE, kScratchRegister);
     __ Assert(equal, AbortReason::kUnexpectedValue);
   }
@@ -1408,13 +1408,13 @@ void CheckJSObjectElementsBounds::GenerateCode(MaglevAssembler* masm,
   __ AssertNotSmi(object);
   __ AssertSmi(index);
 
-  if (FLAG_debug_code) {
+  if (v8_flags.debug_code) {
     __ CmpObjectType(object, FIRST_JS_OBJECT_TYPE, kScratchRegister);
     __ Assert(greater_equal, AbortReason::kUnexpectedValue);
   }
   __ LoadAnyTaggedField(kScratchRegister,
                         FieldOperand(object, JSObject::kElementsOffset));
-  if (FLAG_debug_code) {
+  if (v8_flags.debug_code) {
     __ AssertNotSmi(kScratchRegister);
   }
   TaggedRegister length(kScratchRegister);
@@ -1465,7 +1465,7 @@ void CheckedInternalizedString::GenerateCode(MaglevAssembler* masm,
         __ j(zero, &deopt_info->deopt_entry_label);
         __ LoadTaggedPointerField(
             object, FieldOperand(object, ThinString::kActualOffset));
-        if (FLAG_debug_code) {
+        if (v8_flags.debug_code) {
           __ RecordComment("DCHECK IsInternalizedString");
           __ LoadMap(map_tmp, object);
           __ testw(FieldOperand(map_tmp, Map::kInstanceTypeOffset),
@@ -1524,13 +1524,13 @@ void LoadTaggedElement::GenerateCode(MaglevAssembler* masm,
   Register index = ToRegister(index_input());
   Register result_reg = ToRegister(result());
   __ AssertNotSmi(object);
-  if (FLAG_debug_code) {
+  if (v8_flags.debug_code) {
     __ CmpObjectType(object, JS_OBJECT_TYPE, kScratchRegister);
     __ Assert(above_equal, AbortReason::kUnexpectedValue);
   }
   __ DecompressAnyTagged(kScratchRegister,
                          FieldOperand(object, JSObject::kElementsOffset));
-  if (FLAG_debug_code) {
+  if (v8_flags.debug_code) {
     __ CmpObjectType(kScratchRegister, FIXED_ARRAY_TYPE, kScratchRegister);
     __ Assert(equal, AbortReason::kUnexpectedValue);
     // Reload since CmpObjectType clobbered the scratch register.
@@ -1564,13 +1564,13 @@ void LoadDoubleElement::GenerateCode(MaglevAssembler* masm,
   Register index = ToRegister(index_input());
   DoubleRegister result_reg = ToDoubleRegister(result());
   __ AssertNotSmi(object);
-  if (FLAG_debug_code) {
+  if (v8_flags.debug_code) {
     __ CmpObjectType(object, JS_OBJECT_TYPE, kScratchRegister);
     __ Assert(above_equal, AbortReason::kUnexpectedValue);
   }
   __ DecompressAnyTagged(kScratchRegister,
                          FieldOperand(object, JSObject::kElementsOffset));
-  if (FLAG_debug_code) {
+  if (v8_flags.debug_code) {
     __ CmpObjectType(kScratchRegister, FIXED_DOUBLE_ARRAY_TYPE,
                      kScratchRegister);
     __ Assert(equal, AbortReason::kUnexpectedValue);
@@ -2500,7 +2500,7 @@ void LogicalNot::GenerateCode(MaglevAssembler* masm,
   Register object = ToRegister(value());
   Register return_value = ToRegister(result());
 
-  if (FLAG_debug_code) {
+  if (v8_flags.debug_code) {
     // LogicalNot expects either TrueValue or FalseValue.
     Label next;
     __ CompareRoot(object, RootIndex::kFalseValue);
@@ -3479,7 +3479,7 @@ void AttemptOnStackReplacement(MaglevAssembler* masm, Label* return_label,
   }
 
   __ bind(&deopt);
-  if (V8_LIKELY(FLAG_turbofan)) {
+  if (V8_LIKELY(v8_flags.turbofan)) {
     __ EmitEagerDeopt(node, DeoptimizeReason::kPrepareForOnStackReplacement);
   } else {
     // Fall through. With TF disabled we cannot OSR and thus it doesn't make

src/maglev/maglev.cc

@@ -13,7 +13,7 @@ namespace internal {
 
 MaybeHandle<CodeT> Maglev::Compile(Isolate* isolate,
                                    Handle<JSFunction> function) {
-  DCHECK(FLAG_maglev);
+  DCHECK(v8_flags.maglev);
   std::unique_ptr<maglev::MaglevCompilationInfo> info =
       maglev::MaglevCompilationInfo::New(isolate, function);
   maglev::MaglevCompiler::Compile(isolate->main_thread_local_isolate(),