Revert "Simplify TurboFan's c1visualizer file handling."

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"
 #include "src/compiler/ast-graph-builder.h"
 #include "src/compiler/basic-block-instrumentor.h"
 #include "src/compiler/change-lowering.h"
 #include "src/compiler/code-generator.h"
 #include "src/compiler/control-reducer.h"
 #include "src/compiler/graph-replay.h"
 #include "src/compiler/graph-visualizer.h"
@@ skipping 73 matching lines @@
 
 static inline bool VerifyGraphs() {
 #ifdef DEBUG
   return true;
 #else
   return FLAG_turbo_verify;
 #endif
 }
 
 
-struct TurboCfgFile : public std::ofstream {
-  explicit TurboCfgFile(Isolate* isolate)
-      : std::ofstream(isolate->GetTurboCfgFileName(), std::ios_base::app) {}
-};
+void Pipeline::PrintCompilationStart() {
+  std::ofstream turbo_cfg_stream;
+  OpenTurboCfgFile(&turbo_cfg_stream);
+  turbo_cfg_stream << AsC1VCompilation(info());
+}
+
+
+void Pipeline::OpenTurboCfgFile(std::ofstream* stream) {
+  char buffer[512];
+  Vector<char> filename(buffer, sizeof(buffer));
+  isolate()->GetTurboCfgFileName(filename);
+  stream->open(filename.start(), std::fstream::out | std::fstream::app);
+}
 
 
 void Pipeline::VerifyAndPrintGraph(
     Graph* graph, const char* phase, bool untyped) {
   if (FLAG_trace_turbo) {
     char buffer[256];
     Vector<char> filename(buffer, sizeof(buffer));
     SmartArrayPointer<char> functionname;
     if (!info_->shared_info().is_null()) {
       functionname = info_->shared_info()->DebugName()->ToCString();
@@ skipping 28 matching lines @@
     os << "-- " << phase << " graph printed to file " << filename.start()
        << "\n";
   }
   if (VerifyGraphs()) {
     Verifier::Run(graph,
         FLAG_turbo_types && !untyped ? Verifier::TYPED : Verifier::UNTYPED);
   }
 }
 
 
+void Pipeline::PrintScheduleAndInstructions(
+    const char* phase, const Schedule* schedule,
+    const SourcePositionTable* positions,
+    const InstructionSequence* instructions) {
+  std::ofstream turbo_cfg_stream;
+  OpenTurboCfgFile(&turbo_cfg_stream);
+  turbo_cfg_stream << AsC1V(phase, schedule, positions, instructions);
+}
+
+
+void Pipeline::PrintAllocator(const char* phase,
+                              const RegisterAllocator* allocator) {
+  std::ofstream turbo_cfg_stream;
+  OpenTurboCfgFile(&turbo_cfg_stream);
+  turbo_cfg_stream << AsC1VAllocator(phase, allocator);
+}
+
+
 class AstGraphBuilderWithPositions : public AstGraphBuilder {
  public:
   explicit AstGraphBuilderWithPositions(Zone* local_zone, CompilationInfo* info,
                                         JSGraph* jsgraph,
                                         SourcePositionTable* source_positions)
       : AstGraphBuilder(local_zone, info, jsgraph),
         source_positions_(source_positions) {}
 
   bool CreateGraph() {
     SourcePositionTable::Scope pos(source_positions_,
@@ skipping 38 matching lines @@
   }
 
   if (FLAG_turbo_stats) isolate()->GetTStatistics()->Initialize(info_);
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "---------------------------------------------------\n"
        << "Begin compiling method "
        << info()->function()->debug_name()->ToCString().get()
        << " using Turbofan" << std::endl;
-    TurboCfgFile(isolate()) << AsC1VCompilation(info());
+    PrintCompilationStart();
   }
 
   ZonePool zone_pool(isolate());
 
   // Build the graph.
   Graph graph(zone());
   SourcePositionTable source_positions(&graph);
   source_positions.AddDecorator();
   // TODO(turbofan): there is no need to type anything during initial graph
   // construction.  This is currently only needed for the node cache, which the
@@ skipping 232 matching lines @@
     ZonePool::Scope zone_scope(zone_pool);
     InstructionSelector selector(zone_scope.zone(), linkage, &sequence,
                                  schedule, source_positions);
     selector.SelectInstructions();
   }
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "----- Instruction sequence before register allocation -----\n"
        << sequence;
-    TurboCfgFile(isolate())
-        << AsC1V("CodeGen", schedule, source_positions, &sequence);
+    PrintScheduleAndInstructions("CodeGen", schedule, source_positions,
+                                 &sequence);
   }
 
   // Allocate registers.
   Frame frame;
   {
     int node_count = graph->NodeCount();
     if (node_count > UnallocatedOperand::kMaxVirtualRegisters) {
       linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersForValues);
       return Handle<Code>::null();
     }
     ZonePool::Scope zone_scope(zone_pool);
     RegisterAllocator allocator(zone_scope.zone(), &frame, linkage->info(),
                                 &sequence);
     if (!allocator.Allocate(zone_pool)) {
       linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
       return Handle<Code>::null();
     }
     if (FLAG_trace_turbo) {
-      TurboCfgFile(isolate()) << AsC1VAllocator("CodeGen", &allocator);
+      PrintAllocator("CodeGen", &allocator);
     }
   }
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "----- Instruction sequence after register allocation -----\n"
        << sequence;
   }
 
   // Generate native sequence.
@@ skipping 15 matching lines @@
 }
 
 
 void Pipeline::TearDown() {
   InstructionOperand::TearDownCaches();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8