BoundsCheck should be extended to support array_bounds_checks_elimination

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 3288 matching lines @@
     ASSERT(new_check->index()->representation().IsInteger32());
 
     if (new_offset > upper_offset_) {
       upper_offset_ = new_offset;
     } else if (new_offset < lower_offset_) {
       lower_offset_ = new_offset;
     } else {
       ASSERT(false);
     }
 
-    BuildOffsetAdd(&added_index_,
-                   &added_index_offset_,
-                   Key()->IndexBase(),
-                   new_check->index()->representation(),
-                   lower_offset_);
-    Check()->SetOperandAt(0, added_index_);
-    BuildOffsetAdd(&added_length_,
-                   &added_length_offset_,
-                   Key()->Length(),
-                   new_check->length()->representation(),
-                   lower_offset_ - upper_offset_);
-    Check()->SetOperandAt(1, added_length_);
-
+    Check()->SetOperandAt(0, Key()->IndexBase());
+    Check()->set_offset(lower_offset_, upper_offset_);
     new_check->DeleteAndReplaceWith(NULL);
   }
 
-  void RemoveZeroOperations() {
-    RemoveZeroAdd(&added_index_, &added_index_offset_);
-    RemoveZeroAdd(&added_length_, &added_length_offset_);
-  }
-
   BoundsCheckBbData(BoundsCheckKey* key,
                     int32_t lower_offset,
                     int32_t upper_offset,
                     HBasicBlock* bb,
                     HBoundsCheck* check,
                     BoundsCheckBbData* next_in_bb,
                     BoundsCheckBbData* father_in_dt)
   : key_(key),
     lower_offset_(lower_offset),
     upper_offset_(upper_offset),
     basic_block_(bb),
     check_(check),
-    added_index_offset_(NULL),
-    added_index_(NULL),
-    added_length_offset_(NULL),
-    added_length_(NULL),
     next_in_bb_(next_in_bb),
-    father_in_dt_(father_in_dt) { }
+    father_in_dt_(father_in_dt) {
+    ASSERT(check->index()->representation().IsInteger32());
+  }
 
  private:
   BoundsCheckKey* key_;
   int32_t lower_offset_;
   int32_t upper_offset_;
   HBasicBlock* basic_block_;
   HBoundsCheck* check_;
-  HConstant* added_index_offset_;
-  HAdd* added_index_;
-  HConstant* added_length_offset_;
-  HAdd* added_length_;
   BoundsCheckBbData* next_in_bb_;
   BoundsCheckBbData* father_in_dt_;
-
-  void BuildOffsetAdd(HAdd** add,
-                      HConstant** constant,
-                      HValue* original_value,
-                      Representation representation,
-                      int32_t new_offset) {
-    HConstant* new_constant = new(BasicBlock()->zone())
-        HConstant(Handle<Object>(Smi::FromInt(new_offset)),
-                  Representation::Integer32());
-    if (*add == NULL) {
-      new_constant->InsertBefore(Check());
-      *add = new(BasicBlock()->zone()) HAdd(NULL,
-                                            original_value,
-                                            new_constant);
-      (*add)->AssumeRepresentation(representation);
-      (*add)->InsertBefore(Check());
-    } else {
-      new_constant->InsertBefore(*add);
-      (*constant)->DeleteAndReplaceWith(new_constant);
-    }
-    *constant = new_constant;
-  }
-
-  void RemoveZeroAdd(HAdd** add, HConstant** constant) {
-    if (*add != NULL && (*constant)->Integer32Value() == 0) {
-      (*add)->DeleteAndReplaceWith((*add)->left());
-      (*constant)->DeleteAndReplaceWith(NULL);
-    }
-  }
 };
 
 
 static bool BoundsCheckKeyMatch(void* key1, void* key2) {
   BoundsCheckKey* k1 = static_cast<BoundsCheckKey*>(key1);
   BoundsCheckKey* k2 = static_cast<BoundsCheckKey*>(key2);
   return k1->IndexBase() == k2->IndexBase() && k1->Length() == k2->Length();
 }
 
 
@@ skipping 71 matching lines @@
     }
   }
 
   for (int i = 0; i < bb->dominated_blocks()->length(); ++i) {
     EliminateRedundantBoundsChecks(bb->dominated_blocks()->at(i), table);
   }
 
   for (BoundsCheckBbData* data = bb_data_list;
        data != NULL;
        data = data->NextInBasicBlock()) {
-    data->RemoveZeroOperations();
     if (data->FatherInDominatorTree()) {
       table->Insert(data->Key(), data->FatherInDominatorTree(), zone());
     } else {
       table->Delete(data->Key());
     }
   }
 }
 
 
 void HGraph::EliminateRedundantBoundsChecks() {
@@ skipping 5950 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal