Add more safe points in compiler

runtime/vm/compiler.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 817 matching lines @@
         // position of the inlined call until later. A side effect of this
         // is that the length of |inline_id_to_function| is always larger
         // than the length of |inline_id_to_token_pos| by one.
         // Top scope function has no caller (-1). We do this because we expect
         // all token positions to be at an inlined call.
         caller_inline_id.Add(-1);
         CSTAT_TIMER_SCOPE(thread(), graphoptimizer_timer);
 
         JitOptimizer optimizer(flow_graph);
 
-        optimizer.ApplyICData();
+        {
+          NOT_IN_PRODUCT(TimelineDurationScope tds(thread(), compiler_timeline,
+                                                   "ApplyICData"));
+          optimizer.ApplyICData();
+          SafepointOperationScope safepoint_scope(thread());

[Vyacheslav Egorov (Google), 2017/03/23 10:24:02]

Here and below:

I think you need 

thread()->CheckForSafepoint() 

instead: you want to enter safepoint if one is requested, you don't want to
safepoint other threads.

[erikcorry, 2017/03/27 10:23:28]

Done.

+        }
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge operations.
         // Run early in order to have more opportunity to optimize left shifts.
         flow_graph->TryOptimizePatterns();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         FlowGraphInliner::SetInliningId(flow_graph, 0);
 
         // Inlining (mutates the flow graph)
@@ skipping 10 matching lines @@
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
           FlowGraphInliner inliner(flow_graph, &inline_id_to_function,
                                    &inline_id_to_token_pos, &caller_inline_id,
                                    use_speculative_inlining,
                                    /*inlining_black_list=*/NULL,
                                    /*precompiler=*/NULL);
           inliner.Inline();
           // Use lists are maintained and validated by the inliner.
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
+          SafepointOperationScope safepoint_scope(thread());
         }
 
         // Propagate types and eliminate more type tests.
         FlowGraphTypePropagator::Propagate(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         {
           NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "ApplyClassIds"));
           // Use propagated class-ids to optimize further.
@@ skipping 92 matching lines @@
           // it depends on the numbering of loads from the previous
           // load-elimination.
           if (FLAG_loop_invariant_code_motion) {
             flow_graph->RenameUsesDominatedByRedefinitions();
             DEBUG_ASSERT(flow_graph->VerifyRedefinitions());
             LICM licm(flow_graph);
             licm.Optimize();
             DEBUG_ASSERT(flow_graph->VerifyUseLists());
           }
           flow_graph->RemoveRedefinitions();
+          SafepointOperationScope safepoint_scope(thread());
         }
 
         // Optimize (a << b) & c patterns, merge operations.
         // Run after CSE in order to have more opportunity to merge
         // instructions that have same inputs.
         flow_graph->TryOptimizePatterns();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         {
           NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
@@ skipping 59 matching lines @@
         // Attempt to sink allocations of temporary non-escaping objects to
         // the deoptimization path.
         AllocationSinking* sinking = NULL;
         if (FLAG_allocation_sinking &&
             (flow_graph->graph_entry()->SuccessorCount() == 1)) {
           NOT_IN_PRODUCT(TimelineDurationScope tds2(
               thread(), compiler_timeline, "AllocationSinking::Optimize"));
           // TODO(fschneider): Support allocation sinking with try-catch.
           sinking = new AllocationSinking(flow_graph);
           sinking->Optimize();
+          SafepointOperationScope safepoint_scope(thread());
         }
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         DeadCodeElimination::EliminateDeadPhis(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         FlowGraphTypePropagator::Propagate(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         {
@@ skipping 29 matching lines @@
         // to be later used by the inliner.
         FlowGraphInliner::CollectGraphInfo(flow_graph, true);
 
         flow_graph->RemoveRedefinitions();
         {
           NOT_IN_PRODUCT(TimelineDurationScope tds2(thread(), compiler_timeline,
                                                     "AllocateRegisters"));
           // Perform register allocation on the SSA graph.
           FlowGraphAllocator allocator(*flow_graph);
           allocator.AllocateRegisters();
+          SafepointOperationScope safepoint_scope(thread());
         }
 
         if (reorder_blocks) {
           NOT_IN_PRODUCT(TimelineDurationScope tds(
               thread(), compiler_timeline, "BlockScheduler::ReorderBlocks"));
           block_scheduler.ReorderBlocks();
         }
 
         if (print_flow_graph) {
           FlowGraphPrinter::PrintGraph("After Optimizations", flow_graph);
@@ skipping 1178 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart