Abcd for performance check.

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 413 matching lines @@
 }
 #endif
 
 
 void HLoopInformation::RegisterBackEdge(HBasicBlock* block) {
   this->back_edges_.Add(block, block->zone());
   AddBlock(block);
 }
 
 
+void HLoopInformation::ProcessEdge(HBasicBlock* destination) {
+  HLoopInformation* target_loop = destination->current_loop();
+  if (IsNestedInThisLoop(target_loop)) return;
+
+  HLoopInformation* current_loop = this;
+  // TODO(mmassi) When we will support try..catch we will need to break out of
+  // this loop when we meet the catch block.
+  // From a correctness PoV we're safe anyway, but unnecessarily marking loops
+  // as having additional exits could prevent hoisting of bounds checks.
+  while (current_loop != NULL) {
+    if (target_loop == current_loop) return;
+    current_loop->exits_count_++;
+    current_loop = current_loop->parent_loop();
+  }
+}
+
+
+void HLoopInformation::ProcessThrow() {
+  HLoopInformation* current_loop = this;
+  while (current_loop != NULL) {
+    current_loop->exits_count_++;
+    current_loop = current_loop->parent_loop();
+  }
+}
+
+
 HBasicBlock* HLoopInformation::GetLastBackEdge() const {
   int max_id = -1;
   HBasicBlock* result = NULL;
   for (int i = 0; i < back_edges_.length(); ++i) {
     HBasicBlock* cur = back_edges_[i];
     if (cur->block_id() > max_id) {
       max_id = cur->block_id();
       result = cur;
     }
   }
@@ skipping 1648 matching lines @@
 HGraph::HGraph(CompilationInfo* info)
     : isolate_(info->isolate()),
       next_block_id_(0),
       entry_block_(NULL),
       blocks_(8, info->zone()),
       values_(16, info->zone()),
       phi_list_(NULL),
       uint32_instructions_(NULL),
       info_(info),
       zone_(info->zone()),
+      evaluated_relations_table_(info->zone()),
       is_recursive_(false),
       use_optimistic_licm_(false),
       has_soft_deoptimize_(false),
       depends_on_empty_array_proto_elements_(false),
       type_change_checksum_(0) {
   if (info->IsStub()) {
     HydrogenCodeStub* stub = info->code_stub();
     CodeStubInterfaceDescriptor* descriptor =
         stub->GetInterfaceDescriptor(isolate_);
     start_environment_ =
@@ skipping 345 matching lines @@
       PostorderProcessor::CreateEntryProcessor(zone(), start, &visited);
   while (postorder != NULL) {
     postorder = postorder->PerformStep(zone(), &visited, &reverse_result);
   }
   blocks_.Rewind(0);
   int index = 0;
   for (int i = reverse_result.length() - 1; i >= 0; --i) {
     HBasicBlock* b = reverse_result[i];
     blocks_.Add(b, zone());
     b->set_block_id(index++);
+
+    HLoopInformation* loop = b->current_loop();
+    if (loop != NULL) {
+      for (int i = 0; i < b->end()->SuccessorCount(); i++) {
+        HBasicBlock* successor = b->end()->SuccessorAt(i);
+        loop->ProcessEdge(successor);
+      }
+
+      for (HInstruction* instruction = b->first();
+           instruction != NULL;
+           instruction = instruction->next()) {
+        if (instruction->IsThrow()) {
+          loop->ProcessThrow();
+        }
+      }
+    }
   }
 }
 
 
 void HGraph::AssignDominators() {
   HPhase phase("H_Assign dominators", this);
   for (int i = 0; i < blocks_.length(); ++i) {
     HBasicBlock* block = blocks_[i];
     if (block->IsLoopHeader()) {
       // Only the first predecessor of a loop header is from outside the loop.
@@ skipping 2438 matching lines @@
     HRangeAnalysis rangeAnalysis(this);
     rangeAnalysis.Analyze();
   }
   ComputeMinusZeroChecks();
 
   // Eliminate redundant stack checks on backwards branches.
   HStackCheckEliminator sce(this);
   sce.Process();
 
   if (FLAG_idefs) SetupInformativeDefinitions();
-  if (FLAG_array_bounds_checks_elimination && !FLAG_idefs) {
+  if (FLAG_array_bounds_checks_elimination) {
     EliminateRedundantBoundsChecks();
   }
   if (FLAG_array_index_dehoisting) DehoistSimpleArrayIndexComputations();
+  RestoreActualValues();
+
   if (FLAG_dead_code_elimination) {
     DeadCodeElimination("H_Eliminate late dead code");
   }
 
-  RestoreActualValues();
 
   return true;
 }
 
 
 void HGraph::SetupInformativeDefinitionsInBlock(HBasicBlock* block) {
   for (int phi_index = 0; phi_index < block->phis()->length(); phi_index++) {
     HPhi* phi = block->phis()->at(phi_index);
     phi->AddInformativeDefinitions();
     phi->SetFlag(HValue::kIDefsProcessingDone);
@@ skipping 11 matching lines @@
 
 // This method is recursive, so if its stack frame is large it could
 // cause a stack overflow.
 // To keep the individual stack frames small we do the actual work inside
 // SetupInformativeDefinitionsInBlock();
 void HGraph::SetupInformativeDefinitionsRecursively(HBasicBlock* block) {
   SetupInformativeDefinitionsInBlock(block);
   for (int i = 0; i < block->dominated_blocks()->length(); ++i) {
     SetupInformativeDefinitionsRecursively(block->dominated_blocks()->at(i));
   }
-
-  for (HInstruction* i = block->first(); i != NULL; i = i->next()) {
-    if (i->IsBoundsCheck()) {
-      HBoundsCheck* check = HBoundsCheck::cast(i);
-      check->ApplyIndexChange();
-    }
-  }
 }
 
 
 void HGraph::SetupInformativeDefinitions() {
   HPhase phase("H_Setup informative definitions", this);
   SetupInformativeDefinitionsRecursively(entry_block());
 }
 
 
 // We try to "factor up" HBoundsCheck instructions towards the root of the
@@ skipping 268 matching lines @@
   void Delete(BoundsCheckKey* key) {
     Remove(key, key->Hash());
   }
 
   explicit BoundsCheckTable(Zone* zone)
       : ZoneHashMap(BoundsCheckKeyMatch, ZoneHashMap::kDefaultHashMapCapacity,
                     ZoneAllocationPolicy(zone)) { }
 };
 
 
+void HGraph::EliminateRedundantBoundsChecksUsingIdefs(HBasicBlock* bb) {
+  for (HInstruction* i = bb->first(); i != NULL; i = i->next()) {
+    if (i->IsBoundsCheck()) {
+      HBoundsCheck* check = HBoundsCheck::cast(i);
+      if (check->index()->TryGuaranteeRange(check->length(), bb)) {
+        check->set_skip_check();
+      }
+    }
+  }
+
+  for (int i = 0; i < bb->dominated_blocks()->length(); ++i) {
+    EliminateRedundantBoundsChecksUsingIdefs(bb->dominated_blocks()->at(i));
+  }
+}
+
+
+void HGraph::ApplyBoundsChecksIndexChanges(HBasicBlock* bb) {
+  for (HInstruction* i = bb->first(); i != NULL; i = i->next()) {
+    if (i->IsBoundsCheck()) {
+      HBoundsCheck* check = HBoundsCheck::cast(i);
+      check->ApplyIndexChange();
+    }
+  }
+
+  for (int i = 0; i < bb->dominated_blocks()->length(); ++i) {
+    ApplyBoundsChecksIndexChanges(bb->dominated_blocks()->at(i));
+  }
+}
+
+
 // Eliminates checks in bb and recursively in the dominated blocks.
 // Also replace the results of check instructions with the original value, if
 // the result is used. This is safe now, since we don't do code motion after
 // this point. It enables better register allocation since the value produced
 // by check instructions is really a copy of the original value.
 void HGraph::EliminateRedundantBoundsChecks(HBasicBlock* bb,
                                             BoundsCheckTable* table) {
   BoundsCheckBbData* bb_data_list = NULL;
 
   for (HInstruction* i = bb->first(); i != NULL; i = i->next()) {
@@ skipping 53 matching lines @@
       table->Insert(data->Key(), data->FatherInDominatorTree(), zone());
     } else {
       table->Delete(data->Key());
     }
   }
 }
 
 
 void HGraph::EliminateRedundantBoundsChecks() {
   HPhase phase("H_Eliminate bounds checks", this);
-  BoundsCheckTable checks_table(zone());
-  EliminateRedundantBoundsChecks(entry_block(), &checks_table);
+  if (FLAG_idefs) {
+    EliminateRedundantBoundsChecksUsingIdefs(entry_block());
+    ApplyBoundsChecksIndexChanges(entry_block());
+  } else {
+    BoundsCheckTable checks_table(zone());
+    EliminateRedundantBoundsChecks(entry_block(), &checks_table);
+  }
 }
 
 
 static void DehoistArrayIndex(ArrayInstructionInterface* array_operation) {
   HValue* index = array_operation->GetKey()->ActualValue();
   if (!index->representation().IsInteger32()) return;
 
   HConstant* constant;
   HValue* subexpression;
   int32_t sign;
@@ skipping 7124 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal