Allow a ParseInfo without a script for %SetCode users

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 <memory>
 #include <sstream>
 
@@ skipping 527 matching lines @@
     json_of << "\",\n\"phases\":[";
   }
 
   return pipeline_statistics;
 }
 
 }  // namespace
 
 class PipelineCompilationJob final : public CompilationJob {
  public:
-  PipelineCompilationJob(Isolate* isolate, Handle<JSFunction> function)
+  PipelineCompilationJob(ParseInfo* parse_info, Handle<JSFunction> function)
       // Note that the CompilationInfo is not initialized at the time we pass it
       // to the CompilationJob constructor, but it is not dereferenced there.
-      : CompilationJob(isolate, &info_, "TurboFan"),
-        parse_info_(handle(function->shared())),
-        zone_stats_(isolate->allocator()),
-        info_(parse_info_.zone(), &parse_info_, function),
+      : CompilationJob(parse_info->isolate(), &info_, "TurboFan"),
+        parse_info_(parse_info),
+        zone_stats_(parse_info->isolate()->allocator()),
+        info_(parse_info_.get()->zone(), parse_info_.get(), function),
         pipeline_statistics_(CreatePipelineStatistics(info(), &zone_stats_)),
         data_(&zone_stats_, info(), pipeline_statistics_.get()),
         pipeline_(&data_),
         linkage_(nullptr) {}
 
  protected:
   Status PrepareJobImpl() final;
   Status ExecuteJobImpl() final;
   Status FinalizeJobImpl() final;
 
  private:
-  ParseInfo parse_info_;
+  std::unique_ptr<ParseInfo> parse_info_;
   ZoneStats zone_stats_;
   CompilationInfo info_;
   std::unique_ptr<PipelineStatistics> pipeline_statistics_;
   PipelineData data_;
   PipelineImpl pipeline_;
   Linkage* linkage_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineCompilationJob);
 };
 
@@ skipping 1166 matching lines @@
     json_of << "{\"function\":\"" << info->GetDebugName().get()
             << "\", \"source\":\"\",\n\"phases\":[";
   }
   // TODO(rossberg): Should this really be untyped?
   pipeline.RunPrintAndVerify("Machine", true);
 
   return pipeline.ScheduleAndGenerateCode(call_descriptor);
 }
 
 // static
-CompilationJob* Pipeline::NewCompilationJob(Handle<JSFunction> function) {
-  return new PipelineCompilationJob(function->GetIsolate(), function);
+CompilationJob* Pipeline::NewCompilationJob(Handle<JSFunction> function,
+                                            bool has_script) {
+  Isolate* isolate = function->shared()->GetIsolate();

[Michael Starzinger, 2017/02/15 14:51:48]

nit: The isolate is only used for the handle allocation below the work involved
is exactly the same is if were were to just use the general handle constructor,
but it's easier to read:

Handle<SharedFunctionInfo> shared(function->shared());

[mvstanton, 2017/02/15 15:18:46]

Done.

+  Handle<SharedFunctionInfo> shared = handle(function->shared(), isolate);
+  ParseInfo* p;

[Michael Starzinger, 2017/02/15 14:51:48]

nit: s/p/parse_info/

[mvstanton, 2017/02/15 15:18:47]

Done.

+  if (!has_script) {
+    p = ParseInfo::AllocateWithoutScript(shared);
+  } else {
+    p = new ParseInfo(shared);
+  }
+  return new PipelineCompilationJob(p, function);
 }
 
 // static
 CompilationJob* Pipeline::NewWasmCompilationJob(
     CompilationInfo* info, JSGraph* jsgraph, CallDescriptor* descriptor,
     SourcePositionTable* source_positions,
     ZoneVector<trap_handler::ProtectedInstructionData>* protected_instructions,
     bool allow_signalling_nan) {
   return new PipelineWasmCompilationJob(
       info, jsgraph, descriptor, source_positions, protected_instructions,
@@ skipping 254 matching lines @@
   data->DeleteRegisterAllocationZone();
 }
 
 CompilationInfo* PipelineImpl::info() const { return data_->info(); }
 
 Isolate* PipelineImpl::isolate() const { return info()->isolate(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8