Silence --trace-turbo a bit and behave graceful in sandbox.

src/compiler/pipeline.cc

 // Copyright 2014 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/compiler/pipeline.h"
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 233 matching lines @@
 
 
 struct TurboCfgFile : public std::ofstream {
   explicit TurboCfgFile(Isolate* isolate)
       : std::ofstream(isolate->GetTurboCfgFileName().c_str(),
                       std::ios_base::app) {}
 };
 
 
 static void TraceSchedule(Schedule* schedule) {
-  if (!FLAG_trace_turbo) return;
+  if (!FLAG_trace_turbo_graph && !FLAG_trace_turbo_scheduler) return;
   OFStream os(stdout);
   os << "-- Schedule --------------------------------------\n" << *schedule;
 }
 
 
 static SmartArrayPointer<char> GetDebugName(CompilationInfo* info) {
   SmartArrayPointer<char> name;
   if (info->IsStub()) {
     if (info->code_stub() != NULL) {
       CodeStub::Major major_key = info->code_stub()->MajorKey();
@@ skipping 374 matching lines @@
       SNPrintF(filename, "turbo-none-%s", phase);
     }
     std::replace(filename.start(), filename.start() + filename.length(), ' ',
                  '_');
 
     {  // Print dot.
       char dot_buffer[256];
       Vector<char> dot_filename(dot_buffer, sizeof(dot_buffer));
       SNPrintF(dot_filename, "%s.dot", filename.start());
       FILE* dot_file = base::OS::FOpen(dot_filename.start(), "w+");
+      if (dot_file == nullptr) return;
       OFStream dot_of(dot_file);
       dot_of << AsDOT(*graph);
       fclose(dot_file);
     }
 
     {  // Print JSON.
       char json_buffer[256];
       Vector<char> json_filename(json_buffer, sizeof(json_buffer));
       SNPrintF(json_filename, "%s.json", filename.start());
       FILE* json_file = base::OS::FOpen(json_filename.start(), "w+");
+      if (json_file == nullptr) return;
       OFStream json_of(json_file);
       json_of << AsJSON(*graph);
       fclose(json_file);
     }
 
     OFStream os(stdout);
     if (FLAG_trace_turbo_graph) {  // Simple textual RPO.
       os << "-- Graph after " << phase << " -- " << std::endl;
       os << AsRPO(*graph);
     }
@@ skipping 142 matching lines @@
     GenerateCode(&linkage);
   }
   Handle<Code> code = data.code();
   info()->SetCode(code);
 
   // Print optimized code.
   v8::internal::CodeGenerator::PrintCode(code, info());
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
-    os << "--------------------------------------------------\n"
+    os << "---------------------------------------------------\n"
        << "Finished compiling method " << GetDebugName(info()).get()
        << " using Turbofan" << std::endl;
   }
 
   return code;
 }
 
 
 Handle<Code> Pipeline::GenerateCodeForTesting(CompilationInfo* info,
                                               Graph* graph,
@@ skipping 143 matching lines @@
   debug_name = GetDebugName(data->info());
 #endif
 
   ZonePool::Scope zone_scope(data->zone_pool());
   data->InitializeRegisterAllocator(zone_scope.zone(), config,
                                     debug_name.get());
 
   Run<MeetRegisterConstraintsPhase>();
   Run<ResolvePhisPhase>();
   Run<BuildLiveRangesPhase>();
-  if (FLAG_trace_turbo) {
+  if (FLAG_trace_turbo_graph) {
     OFStream os(stdout);
     PrintableInstructionSequence printable = {config, data->sequence()};
     os << "----- Instruction sequence before register allocation -----\n"
        << printable;
   }
   DCHECK(!data->register_allocator()->ExistsUseWithoutDefinition());
   Run<AllocateGeneralRegistersPhase>();
   if (!data->register_allocator()->AllocationOk()) {
     data->set_compilation_failed();
     return;
   }
   Run<AllocateDoubleRegistersPhase>();
   if (!data->register_allocator()->AllocationOk()) {
     data->set_compilation_failed();
     return;
   }
   if (FLAG_turbo_reuse_spill_slots) {
     Run<ReuseSpillSlotsPhase>();
   }
   Run<PopulatePointerMapsPhase>();
   Run<ConnectRangesPhase>();
   Run<ResolveControlFlowPhase>();
   Run<OptimizeMovesPhase>();
 
-  if (FLAG_trace_turbo) {
+  if (FLAG_trace_turbo_graph) {
     OFStream os(stdout);
     PrintableInstructionSequence printable = {config, data->sequence()};
     os << "----- Instruction sequence after register allocation -----\n"
        << printable;
   }
 
   if (verifier != nullptr) {
     verifier->VerifyAssignment();
     verifier->VerifyGapMoves();
   }
@@ skipping 10 matching lines @@
 }
 
 
 void Pipeline::TearDown() {
   InstructionOperand::TearDownCaches();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8