Enable stub generation using Hydrogen/Lithium (again)

src/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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 #include "hydrogen.h"
 
 #include "codegen.h"
+#include "elements-hydrogen.h"

[Jakob Kummerow, 2012/11/19 12:36:00]

remove

[danno, 2012/11/26 17:16:18]

Done.

 #include "full-codegen.h"
 #include "hashmap.h"
 #include "lithium-allocator.h"
 #include "parser.h"
 #include "scopeinfo.h"
 #include "scopes.h"
 #include "stub-cache.h"
 
 #if V8_TARGET_ARCH_IA32
 #include "ia32/lithium-codegen-ia32.h"
@@ skipping 88 matching lines @@
   }
 
   return instr;
 }
 
 
 HSimulate* HBasicBlock::CreateSimulate(BailoutId ast_id) {
   ASSERT(HasEnvironment());
   HEnvironment* environment = last_environment();
   ASSERT(ast_id.IsNone() ||
+         ast_id == BailoutId::StubEntry() ||
          environment->closure()->shared()->VerifyBailoutId(ast_id));
 
   int push_count = environment->push_count();
   int pop_count = environment->pop_count();
 
   HSimulate* instr = new(zone()) HSimulate(ast_id, pop_count, zone());
   for (int i = push_count - 1; i >= 0; --i) {
     instr->AddPushedValue(environment->ExpressionStackAt(i));
   }
   for (int i = 0; i < environment->assigned_variables()->length(); ++i) {
@@ skipping 118 matching lines @@
     if (IsLoopHeader()) {
       ASSERT(phis()->length() == incoming_env->length());
       for (int i = 0; i < phis_.length(); ++i) {
         phis_[i]->AddInput(incoming_env->values()->at(i));
       }
     } else {
       last_environment()->AddIncomingEdge(this, pred->last_environment());
     }
   } else if (!HasEnvironment() && !IsFinished()) {
     ASSERT(!IsLoopHeader());
-    SetInitialEnvironment(pred->last_environment()->Copy());
+    HEnvironment* last = pred->last_environment();

[Jakob Kummerow, 2012/11/19 12:36:00]

remove this change?

[danno, 2012/11/26 17:16:18]

Done.

+    SetInitialEnvironment(last->Copy());
   }
 
   predecessors_.Add(pred, zone());
 }
 
 
 void HBasicBlock::AddDominatedBlock(HBasicBlock* block) {
   ASSERT(!dominated_blocks_.Contains(block));
   // Keep the list of dominated blocks sorted such that if there is two
   // succeeding block in this list, the predecessor is before the successor.
@@ skipping 402 matching lines @@
       entry_block_(NULL),
       blocks_(8, info->zone()),
       values_(16, info->zone()),
       phi_list_(NULL),
       uint32_instructions_(NULL),
       info_(info),
       zone_(info->zone()),
       is_recursive_(false),
       use_optimistic_licm_(false),
       type_change_checksum_(0) {
-  start_environment_ =
-      new(zone_) HEnvironment(NULL, info->scope(), info->closure(), zone_);
+  if (info->IsStub()) {
+    start_environment_ =
+        new(zone_) HEnvironment(zone_);
+  } else {
+    start_environment_ =
+        new(zone_) HEnvironment(NULL, info->scope(), info->closure(), zone_);
+  }
   start_environment_->set_ast_id(BailoutId::FunctionEntry());
   entry_block_ = CreateBasicBlock();
   entry_block_->SetInitialEnvironment(start_environment_);
 }
 
 
 HBasicBlock* HGraph::CreateBasicBlock() {
   HBasicBlock* result = new(zone()) HBasicBlock(this);
   blocks_.Add(result, zone());
   return result;
 }
 
 
 void HGraph::Canonicalize() {
   if (!FLAG_use_canonicalizing) return;
   HPhase phase("H_Canonicalize", this);
   for (int i = 0; i < blocks()->length(); ++i) {
     HInstruction* instr = blocks()->at(i)->first();
     while (instr != NULL) {
       HValue* value = instr->Canonicalize();
       if (value != instr) instr->DeleteAndReplaceWith(value);
       instr = instr->next();
     }
   }
 }
-
 // Block ordering was implemented with two mutually recursive methods,
 // HGraph::Postorder and HGraph::PostorderLoopBlocks.
 // The recursion could lead to stack overflow so the algorithm has been
 // implemented iteratively.
 // At a high level the algorithm looks like this:
 //
 // Postorder(block, loop_header) : {
 //   if (block has already been visited or is of another loop) return;
 //   mark block as visited;
 //   if (block is a loop header) {
@@ skipping 5285 matching lines @@
 }
 
 
 HInstruction* HGraphBuilder::BuildLoadKeyedGeneric(HValue* object,
                                                    HValue* key) {
   HValue* context = environment()->LookupContext();
   return new(zone()) HLoadKeyedGeneric(context, object, key);
 }
 
 
+static HInstruction* AddBlockInstruction(HBasicBlock* current_block,
+                                         HInstruction* instr) {
+  ASSERT(current_block != NULL);
+  current_block->AddInstruction(instr);
+  return instr;
+}
+
+
 HInstruction* HGraphBuilder::BuildExternalArrayElementAccess(
+    HGraph* graph,
+    HBasicBlock* current_block,
     HValue* external_elements,
     HValue* checked_key,
     HValue* val,
     HValue* dependency,
     ElementsKind elements_kind,
-    bool is_store) {
+    bool is_store,
+    Zone* zone) {
   if (is_store) {
     ASSERT(val != NULL);
     switch (elements_kind) {
       case EXTERNAL_PIXEL_ELEMENTS: {
-        val = AddInstruction(new(zone()) HClampToUint8(val));
+        val = AddBlockInstruction(current_block, new(zone) HClampToUint8(val));
         break;
       }
       case EXTERNAL_BYTE_ELEMENTS:
       case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
       case EXTERNAL_SHORT_ELEMENTS:
       case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
       case EXTERNAL_INT_ELEMENTS:
       case EXTERNAL_UNSIGNED_INT_ELEMENTS: {
         if (!val->representation().IsInteger32()) {
-          val = AddInstruction(new(zone()) HChange(
+          val = AddBlockInstruction(current_block, new(zone) HChange(
               val,
               Representation::Integer32(),
               true,  // Truncate to int32.
               false));  // Don't deoptimize undefined (irrelevant here).
         }
         break;
       }
       case EXTERNAL_FLOAT_ELEMENTS:
       case EXTERNAL_DOUBLE_ELEMENTS:
         break;
       case FAST_SMI_ELEMENTS:
       case FAST_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case FAST_HOLEY_SMI_ELEMENTS:
       case FAST_HOLEY_ELEMENTS:
       case FAST_HOLEY_DOUBLE_ELEMENTS:
       case DICTIONARY_ELEMENTS:
       case NON_STRICT_ARGUMENTS_ELEMENTS:
         UNREACHABLE();
         break;
     }
-    return new(zone()) HStoreKeyed(external_elements,
-                                   checked_key,
-                                   val,
-                                   elements_kind);
+    return new(zone) HStoreKeyed(external_elements,
+                                  checked_key,

[Jakob Kummerow, 2012/11/19 12:36:00]

nit: indentation

[danno, 2012/11/26 17:16:18]

Done.

+                                  val,
+                                  elements_kind);
   } else {
     ASSERT(val == NULL);
     HLoadKeyed* load =
-       new(zone()) HLoadKeyed(
+       new(zone) HLoadKeyed(
            external_elements, checked_key, dependency, elements_kind);
     if (FLAG_opt_safe_uint32_operations &&
         elements_kind == EXTERNAL_UNSIGNED_INT_ELEMENTS) {
-      graph()->RecordUint32Instruction(load);
+      graph->RecordUint32Instruction(load);
     }
     return load;
   }
 }
 
 
-HInstruction* HGraphBuilder::BuildFastElementAccess(HValue* elements,
+HInstruction* HGraphBuilder::BuildFastElementAccess(HGraph* graph,
+                                                    HBasicBlock* current_block,
+                                                    HValue* elements,
                                                     HValue* checked_key,
                                                     HValue* val,
                                                     HValue* load_dependency,
                                                     ElementsKind elements_kind,
-                                                    bool is_store) {
+                                                    bool is_store,
+                                                    Zone* zone) {
   if (is_store) {
     ASSERT(val != NULL);
     switch (elements_kind) {
       case FAST_SMI_ELEMENTS:
       case FAST_HOLEY_SMI_ELEMENTS:
         // Smi-only arrays need a smi check.
-        AddInstruction(new(zone()) HCheckSmi(val));
+        AddBlockInstruction(current_block, new(zone) HCheckSmi(val));
         // Fall through.
       case FAST_ELEMENTS:
       case FAST_HOLEY_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case FAST_HOLEY_DOUBLE_ELEMENTS:
-        return new(zone()) HStoreKeyed(
-            elements, checked_key, val, elements_kind);
+        return new(zone) HStoreKeyed(elements, checked_key, val, elements_kind);
       default:
         UNREACHABLE();
         return NULL;
     }
   }
   // It's an element load (!is_store).
-  return new(zone()) HLoadKeyed(elements,
-                                checked_key,
-                                load_dependency,
-                                elements_kind);
+  return new(zone) HLoadKeyed(elements,
+                              checked_key,
+                              load_dependency,
+                              elements_kind);
 }
 
 
 HInstruction* HGraphBuilder::BuildMonomorphicElementAccess(HValue* object,
                                                            HValue* key,
                                                            HValue* val,
                                                            HValue* dependency,
                                                            Handle<Map> map,
                                                            bool is_store) {
   HCheckMaps* mapcheck = new(zone()) HCheckMaps(object, map,
                                                 zone(), dependency);
   AddInstruction(mapcheck);
   if (dependency) {
     mapcheck->ClearGVNFlag(kDependsOnElementsKind);
   }
-  return BuildUncheckedMonomorphicElementAccess(object, key, val,
-                                                mapcheck, map, is_store);
+  return BuildUncheckedMonomorphicElementAccess(
+      graph(),
+      current_block(), object, key, val,
+      mapcheck, map->instance_type() == JS_ARRAY_TYPE,
+      map->elements_kind(), is_store, zone());
 }
 
 
 HInstruction* HGraphBuilder::BuildUncheckedMonomorphicElementAccess(
+    HGraph* graph,
+    HBasicBlock* current_block,
     HValue* object,
     HValue* key,
     HValue* val,
     HCheckMaps* mapcheck,
-    Handle<Map> map,
-    bool is_store) {
+    bool is_js_array,
+    ElementsKind elements_kind,
+    bool is_store,
+    Zone* zone) {
   // No GVNFlag is necessary for ElementsKind if there is an explicit dependency
   // on a HElementsTransition instruction. The flag can also be removed if the
   // map to check has FAST_HOLEY_ELEMENTS, since there can be no further
   // ElementsKind transitions. Finally, the dependency can be removed for stores
   // for FAST_ELEMENTS, since a transition to HOLEY elements won't change the
   // generated store code.
-  if ((map->elements_kind() == FAST_HOLEY_ELEMENTS) ||
-      (map->elements_kind() == FAST_ELEMENTS && is_store)) {
-    mapcheck->ClearGVNFlag(kDependsOnElementsKind);
+  if ((elements_kind == FAST_HOLEY_ELEMENTS) ||
+      (elements_kind == FAST_ELEMENTS && is_store)) {
+    if (mapcheck != NULL) {
+      mapcheck->ClearGVNFlag(kDependsOnElementsKind);
+    }
   }
-  bool fast_smi_only_elements = map->has_fast_smi_elements();
-  bool fast_elements = map->has_fast_object_elements();
+  bool fast_smi_only_elements = IsFastSmiElementsKind(elements_kind);
+  bool fast_elements = IsFastObjectElementsKind(elements_kind);
   HInstruction* elements =
-      AddInstruction(new(zone()) HLoadElements(object, mapcheck));
+      AddBlockInstruction(current_block,
+                          new(zone) HLoadElements(object, mapcheck));
   if (is_store && (fast_elements || fast_smi_only_elements)) {
-    HCheckMaps* check_cow_map = new(zone()) HCheckMaps(
-        elements, isolate()->factory()->fixed_array_map(), zone());
+    HCheckMaps* check_cow_map = new(zone) HCheckMaps(
+        elements, Isolate::Current()->factory()->fixed_array_map(), zone);
     check_cow_map->ClearGVNFlag(kDependsOnElementsKind);
-    AddInstruction(check_cow_map);
+    AddBlockInstruction(current_block, check_cow_map);
   }
   HInstruction* length = NULL;
   HInstruction* checked_key = NULL;
-  if (map->has_external_array_elements()) {
-    length = AddInstruction(new(zone()) HFixedArrayBaseLength(elements));
-    checked_key = AddInstruction(new(zone()) HBoundsCheck(key, length,
-                                                          ALLOW_SMI_KEY));
+  if (IsExternalArrayElementsKind(elements_kind)) {
+    length = AddBlockInstruction(current_block,
+                                 new(zone) HFixedArrayBaseLength(elements));
+    checked_key = AddBlockInstruction(current_block,
+                                      new(zone) HBoundsCheck(key, length,
+                                                             ALLOW_SMI_KEY));
     HLoadExternalArrayPointer* external_elements =
-        new(zone()) HLoadExternalArrayPointer(elements);
-    AddInstruction(external_elements);
-    return BuildExternalArrayElementAccess(
-        external_elements, checked_key, val, mapcheck,
-        map->elements_kind(), is_store);
+        new(zone) HLoadExternalArrayPointer(elements);
+    AddBlockInstruction(current_block, external_elements);
+    return BuildExternalArrayElementAccess(graph,
+        current_block, external_elements, checked_key, val, mapcheck,
+        elements_kind, is_store, zone);
   }
   ASSERT(fast_smi_only_elements ||
          fast_elements ||
-         map->has_fast_double_elements());
-  if (map->instance_type() == JS_ARRAY_TYPE) {
-    length = AddInstruction(new(zone()) HJSArrayLength(object, mapcheck,
-                                                       HType::Smi()));
+         IsFastDoubleElementsKind(elements_kind));
+  if (is_js_array) {
+    length = AddBlockInstruction(current_block,
+                                 new(zone) HJSArrayLength(object, mapcheck,
+                                                          HType::Smi()));
   } else {
-    length = AddInstruction(new(zone()) HFixedArrayBaseLength(elements));
+    length = AddBlockInstruction(current_block,
+                                 new(zone) HFixedArrayBaseLength(elements));
   }
-  checked_key = AddInstruction(new(zone()) HBoundsCheck(key, length,
-                                                        ALLOW_SMI_KEY));
-  return BuildFastElementAccess(elements, checked_key, val, mapcheck,
-                                map->elements_kind(), is_store);
+  checked_key = AddBlockInstruction(current_block,
+                                    new(zone) HBoundsCheck(key, length,
+                                                           ALLOW_SMI_KEY));
+  return BuildFastElementAccess(graph, current_block,
+                                elements, checked_key, val, mapcheck,
+                                elements_kind, is_store, zone);
 }
 
 
 HInstruction* HGraphBuilder::TryBuildConsolidatedElementLoad(
     HValue* object,
     HValue* key,
     HValue* val,
     SmallMapList* maps) {
   // For polymorphic loads of similar elements kinds (i.e. all tagged or all
   // double), always use the "worst case" code without a transition.  This is
@@ skipping 31 matching lines @@
             most_general_consolidated_map->elements_kind(),
             map->elements_kind())) {
       most_general_consolidated_map = map;
     }
   }
   if (!has_double_maps && !has_smi_or_object_maps) return NULL;
 
   HCheckMaps* check_maps = new(zone()) HCheckMaps(object, maps, zone());
   AddInstruction(check_maps);
   HInstruction* instr = BuildUncheckedMonomorphicElementAccess(
-      object, key, val, check_maps, most_general_consolidated_map, false);
+      graph(),
+      current_block(), object, key, val, check_maps,
+      most_general_consolidated_map->instance_type() == JS_ARRAY_TYPE,
+      most_general_consolidated_map->elements_kind(),
+      false, zone());
   return instr;
 }
 
 
 HValue* HGraphBuilder::HandlePolymorphicElementAccess(HValue* object,
                                                       HValue* key,
                                                       HValue* val,
                                                       Expression* prop,
                                                       BailoutId ast_id,
                                                       int position,
@@ skipping 149 matching lines @@
         typecheck->SetSuccessorAt(1, if_fastobject);
         current_block()->Finish(typecheck);
 
         set_current_block(if_jsarray);
         HInstruction* length;
         length = AddInstruction(new(zone()) HJSArrayLength(object, typecheck,
                                                            HType::Smi()));
         checked_key = AddInstruction(new(zone()) HBoundsCheck(key, length,
                                                               ALLOW_SMI_KEY));
         access = AddInstruction(BuildFastElementAccess(
-            elements, checked_key, val, elements_kind_branch,
-            elements_kind, is_store));
+            graph(),
+            current_block(), elements, checked_key, val, elements_kind_branch,
+            elements_kind, is_store, zone()));
         if (!is_store) {
           Push(access);
         }
 
         *has_side_effects |= access->HasObservableSideEffects();
         if (position != -1) {
           access->set_position(position);
         }
         if_jsarray->Goto(join);
 
         set_current_block(if_fastobject);
         length = AddInstruction(new(zone()) HFixedArrayBaseLength(elements));
         checked_key = AddInstruction(new(zone()) HBoundsCheck(key, length,
                                                               ALLOW_SMI_KEY));
         access = AddInstruction(BuildFastElementAccess(
+            graph(),
+            current_block(),
             elements, checked_key, val, elements_kind_branch,
-            elements_kind, is_store));
+            elements_kind, is_store, zone()));
       } else if (elements_kind == DICTIONARY_ELEMENTS) {
         if (is_store) {
           access = AddInstruction(BuildStoreKeyedGeneric(object, key, val));
         } else {
           access = AddInstruction(BuildLoadKeyedGeneric(object, key));
         }
       } else {  // External array elements.
         access = AddInstruction(BuildExternalArrayElementAccess(
-            external_elements, checked_key, val, elements_kind_branch,
-            elements_kind, is_store));
+            graph(),
+            current_block(), external_elements, checked_key, val,
+            elements_kind_branch,
+            elements_kind, is_store, zone()));
       }
       *has_side_effects |= access->HasObservableSideEffects();
       if (position != RelocInfo::kNoPosition) access->set_position(position);
       if (!is_store) {
         Push(access);
       }
       current_block()->Goto(join);
       set_current_block(if_false);
     }
   }
@@ skipping 3025 matching lines @@
       outer_(outer),
       entry_(NULL),
       pop_count_(0),
       push_count_(0),
       ast_id_(BailoutId::None()),
       zone_(zone) {
   Initialize(scope->num_parameters() + 1, scope->num_stack_slots(), 0);
 }
 
 
+HEnvironment::HEnvironment(Zone* zone)
+    : values_(0, zone),
+      assigned_variables_(0, zone),
+      frame_type_(STUB),
+      parameter_count_(0),
+      specials_count_(0),
+      local_count_(0),
+      outer_(NULL),
+      entry_(NULL),
+      pop_count_(0),
+      push_count_(0),
+      ast_id_(BailoutId::None()),
+      zone_(zone) {
+  Initialize(0, 0, 0);
+}
+
+
 HEnvironment::HEnvironment(const HEnvironment* other, Zone* zone)
     : values_(0, zone),
       assigned_variables_(0, zone),
       frame_type_(JS_FUNCTION),
       parameter_count_(0),
       specials_count_(1),
       local_count_(0),
       outer_(NULL),
       entry_(NULL),
       pop_count_(0),
@@ skipping 247 matching lines @@
 
 
 void HEnvironment::PrintToStd() {
   HeapStringAllocator string_allocator;
   StringStream trace(&string_allocator);
   PrintTo(&trace);
   PrintF("%s", *trace.ToCString());
 }
 
 
-void HTracer::TraceCompilation(FunctionLiteral* function) {
+void HTracer::TraceCompilation(CompilationInfo* info) {
   Tag tag(this, "compilation");
-  Handle<String> name = function->debug_name();
-  PrintStringProperty("name", *name->ToCString());
-  PrintStringProperty("method", *name->ToCString());
+  if (info->IsOptimizing()) {
+    Handle<String> name = info->function()->debug_name();
+    PrintStringProperty("name", *name->ToCString());
+    PrintStringProperty("method", *name->ToCString());
+  } else {
+    PrintStringProperty("name", "stub");

[Jakob Kummerow, 2012/11/19 12:36:00]

do we have more information here maybe? stub type?

[danno, 2012/11/26 17:16:18]

unfortunately, no.

On 2012/11/19 12:36:00, Jakob wrote:

+    PrintStringProperty("method", "stub");
+  }
   PrintLongProperty("date", static_cast<int64_t>(OS::TimeCurrentMillis()));
 }
 
 
 void HTracer::TraceLithium(const char* name, LChunk* chunk) {
   Trace(name, chunk->graph(), chunk);
 }
 
 
 void HTracer::TraceHydrogen(const char* name, HGraph* graph) {
@@ skipping 295 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal