Add CompileInfo::GetDebugName()

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/adapters.h"
@@ skipping 332 matching lines @@
       fclose(json_file);
     }
   }
   if (!FLAG_trace_turbo_graph && !FLAG_trace_turbo_scheduler) return;
   OFStream os(stdout);
   os << "-- Schedule --------------------------------------\n" << *schedule;
 }
 
 
 base::SmartArrayPointer<char> GetDebugName(CompilationInfo* info) {
-  if (info->code_stub() != NULL) {
+  if (info->IsBytecodeHandler()) {
+    const char* bytecode_name =
+        interpreter::Bytecodes::ToString(info->bytecode());
+    size_t len = strlen(bytecode_name) + 1;
+    base::SmartArrayPointer<char> name(new char[len]);
+    memcpy(name.get(), bytecode_name, len);
+    return name;
+  } else if (info->code_stub() != NULL) {
     CodeStub::Major major_key = info->code_stub()->MajorKey();
     const char* major_name = CodeStub::MajorName(major_key, false);
     size_t len = strlen(major_name) + 1;
     base::SmartArrayPointer<char> name(new char[len]);
     memcpy(name.get(), major_name, len);
     return name;
   } else {
     AllowHandleDereference allow_deref;
     return info->literal()->debug_name()->ToCString();
   }
@@ skipping 118 matching lines @@
 };
 
 
 struct GraphBuilderPhase {
   static const char* phase_name() { return "graph builder"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
     AstGraphBuilderWithPositions graph_builder(
         temp_zone, data->info(), data->jsgraph(), data->loop_assignment(),
         data->js_type_feedback(), data->source_positions());
-    bool stack_check = !data->info()->IsStub();
+    bool stack_check = !data->info()->IsStub() && !data->info()->IsStub();
     if (!graph_builder.CreateGraph(stack_check)) {
       data->set_compilation_failed();
     }
   }
 };
 
 
 struct InliningPhase {
   static const char* phase_name() { return "inlining"; }
 
@@ skipping 635 matching lines @@
   data.source_positions()->RemoveDecorator();
 
   // Kill the Typer and thereby uninstall the decorator (if any).
   typer.Reset(nullptr);
 
   return ScheduleAndGenerateCode(
       Linkage::ComputeIncoming(data.instruction_zone(), info()));
 }
 
 
+Handle<Code> Pipeline::GenerateCodeForInterpreter(
+    Isolate* isolate, CallDescriptor* call_descriptor, Graph* graph,
+    Schedule* schedule, interpreter::Bytecode bytecode) {
+  CompilationInfo info(bytecode, isolate, graph->zone());
+  return GenerateCodeFromMachineGraph(&info, call_descriptor, graph, schedule);
+}
+
+
 Handle<Code> Pipeline::GenerateCodeForTesting(CompilationInfo* info,
                                               Graph* graph,
                                               Schedule* schedule) {
   CallDescriptor* call_descriptor =
       Linkage::ComputeIncoming(info->zone(), info);
-  return GenerateCodeForTesting(info, call_descriptor, graph, schedule);
+  return GenerateCodeFromMachineGraph(info, call_descriptor, graph, schedule);
 }
 
 
 Handle<Code> Pipeline::GenerateCodeForTesting(Isolate* isolate,
                                               CallDescriptor* call_descriptor,
                                               Graph* graph,
                                               Schedule* schedule) {
   FakeStubForTesting stub(isolate);
   CompilationInfo info(&stub, isolate, graph->zone());
-  return GenerateCodeForTesting(&info, call_descriptor, graph, schedule);
+  return GenerateCodeFromMachineGraph(&info, call_descriptor, graph, schedule);
 }
 
 
-Handle<Code> Pipeline::GenerateCodeForTesting(CompilationInfo* info,
-                                              CallDescriptor* call_descriptor,
-                                              Graph* graph,
-                                              Schedule* schedule) {
+Handle<Code> Pipeline::GenerateCodeFromMachineGraph(
+    CompilationInfo* info, CallDescriptor* call_descriptor, Graph* graph,
+    Schedule* schedule) {
   // Construct a pipeline for scheduling and code generation.
   ZonePool zone_pool;
   PipelineData data(&zone_pool, info, graph, schedule);
   base::SmartPointer<PipelineStatistics> pipeline_statistics;
   if (FLAG_turbo_stats) {
     pipeline_statistics.Reset(new PipelineStatistics(info, &zone_pool));
-    pipeline_statistics->BeginPhaseKind("test codegen");
+    pipeline_statistics->BeginPhaseKind("machine graph codegen");
+  }
+  if (FLAG_trace_turbo) {
+    FILE* json_file = OpenVisualizerLogFile(info, NULL, "json", "w+");
+    if (json_file != nullptr) {
+      OFStream json_of(json_file);
+      json_of << "{\"function\":\"" << GetDebugName(info).get()
+              << "\", \"source\":\"\",\n\"phases\":[";
+      fclose(json_file);
+    }
   }
 
   Pipeline pipeline(info);
   pipeline.data_ = &data;
-  if (data.schedule() == nullptr) {
+  if (data.schedule() == nullptr || info->IsBytecodeHandler()) {
     // TODO(rossberg): Should this really be untyped?
     pipeline.RunPrintAndVerify("Machine", true);
   }
 
   return pipeline.ScheduleAndGenerateCode(call_descriptor);
 }
 
 
 bool Pipeline::AllocateRegistersForTesting(const RegisterConfiguration* config,
                                            InstructionSequence* sequence,
@@ skipping 185 matching lines @@
     tcf << AsC1VRegisterAllocationData("CodeGen",
                                        data->register_allocation_data());
   }
 
   data->DeleteRegisterAllocationZone();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8