Fix bugs in generating and printing of Crankshaft stubs

src/code-stubs-hydrogen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 38 matching lines @@
   if (chunk == NULL) {
     FATAL(graph->info()->bailout_reason());
   }
   return chunk;
 }
 
 
 class CodeStubGraphBuilderBase : public HGraphBuilder {
  public:
   CodeStubGraphBuilderBase(Isolate* isolate, HydrogenCodeStub* stub)
-      : HGraphBuilder(&info_), info_(stub, isolate), context_(NULL) {}
+      : HGraphBuilder(&info_), info_(stub, isolate), context_(NULL) {
+    int major_key = stub->MajorKey();
+    descriptor_ = info_.isolate()->code_stub_interface_descriptor(major_key);
+    if (descriptor_->register_param_count_ < 0) {
+      stub->InitializeInterfaceDescriptor(info_.isolate(), descriptor_);
+    }
+    parameters_.Reset(new HParameter*[descriptor_->register_param_count_]);
+  }
   virtual bool BuildGraph();
 
  protected:
   virtual void BuildCodeStub() = 0;
   HParameter* GetParameter(int parameter) { return parameters_[parameter]; }
   CompilationInfo* info() { return &info_; }
   HydrogenCodeStub* stub() { return info_.code_stub(); }
   HContext* context() { return context_; }
   Isolate* isolate() { return info_.isolate(); }
 
  private:
   SmartArrayPointer<HParameter*> parameters_;
   CompilationInfoWithZone info_;
+  CodeStubInterfaceDescriptor* descriptor_;
   HContext* context_;
 };
 
 
 bool CodeStubGraphBuilderBase::BuildGraph() {
   if (FLAG_trace_hydrogen) {
     const char* name = CodeStub::MajorName(stub()->MajorKey(), false);
     PrintF("-----------------------------------------------------------\n");
     PrintF("Compiling stub %s using hydrogen\n", name);
     HTracer::Instance()->TraceCompilation(&info_);
   }
-  HBasicBlock* next_block = graph()->CreateBasicBlock();
-  next_block->SetInitialEnvironment(graph()->start_environment());
-  HGoto* jump = new(zone()) HGoto(next_block);
-  graph()->entry_block()->Finish(jump);
+
+  Zone* zone = this->zone();
+  HEnvironment* start_environment =
+      new(zone) HEnvironment(zone, descriptor_->register_param_count_);
+  HBasicBlock* next_block = CreateBasicBlock(start_environment);
+
+  current_block()->Goto(next_block);
+  next_block->SetJoinId(BailoutId::StubEntry());
   set_current_block(next_block);
 
-  int major_key = stub()->MajorKey();
-  CodeStubInterfaceDescriptor* descriptor =
-      info_.isolate()->code_stub_interface_descriptor(major_key);
-  if (descriptor->register_param_count_ < 0) {
-    stub()->InitializeInterfaceDescriptor(info_.isolate(), descriptor);
-  }
-  parameters_.Reset(new HParameter*[descriptor->register_param_count_]);
-
-  HConstant* undefined_constant = new(zone()) HConstant(
+  HConstant* undefined_constant = new(zone) HConstant(
       isolate()->factory()->undefined_value(), Representation::Tagged());
   AddInstruction(undefined_constant);
   graph()->set_undefined_constant(undefined_constant);
 
-  HGraph* graph = this->graph();
-  Zone* zone = this->zone();
-  for (int i = 0; i < descriptor->register_param_count_; ++i) {
+  int param_count = descriptor_->register_param_count_;
+  for (int i = 0; i < param_count; ++i) {
     HParameter* param =
         new(zone) HParameter(i, HParameter::REGISTER_PARAMETER);
     AddInstruction(param);
-    graph->start_environment()->Push(param);
+    start_environment->Bind(i, param);
     parameters_[i] = param;
   }
 
   context_ = new(zone) HContext();
   AddInstruction(context_);
+  start_environment->Bind(param_count, context_);
 
   AddSimulate(BailoutId::StubEntry());
 
   BuildCodeStub();
 
   return true;
 }
 
 template <class Stub>
 class CodeStubGraphBuilder: public CodeStubGraphBuilderBase {
@@ skipping 52 matching lines @@
 
   HConstant* max_alloc_size =
       new(zone) HConstant(kMinFreeNewSpaceAfterGC, Representation::Integer32());
   AddInstruction(max_alloc_size);
   // Since we're forcing Integer32 representation for this HBoundsCheck,
   // there's no need to Smi-check the index.
   AddInstruction(
       new(zone) HBoundsCheck(array_length, max_alloc_size,
                              DONT_ALLOW_SMI_KEY, Representation::Integer32()));
 
-  current_block()->UpdateEnvironment(new(zone) HEnvironment(zone));
-
   IfBuilder if_builder(this);
 
   if_builder.BeginTrue(array_length, graph()->GetConstant0(), Token::EQ);
 
   // Nothing to do, just change the map.
 
   if_builder.BeginFalse();
 
   HInstruction* elements =
       AddInstruction(new(zone) HLoadElements(js_array, js_array));
@@ skipping 50 matching lines @@
 
 
 Handle<Code> TransitionElementsKindStub::GenerateCode() {
   CodeStubGraphBuilder<TransitionElementsKindStub> builder(this);
   LChunk* chunk = OptimizeGraph(builder.CreateGraph());
   return chunk->Codegen(Code::COMPILED_STUB);
 }
 
 
 } }  // namespace v8::internal