Revert "[compiler] Temporarily turn some DCHECKs into CHECKs."

This reverts commit f52b4b3b.

Reason for revert: Makes benchmarks time out:
https://crbug.com/834655

Original change's description:
> [compiler] Temporarily turn some DCHECKs into CHECKs.
> 
> This turns most DCHECKs in the register allocator code into CHECKs,
> which hopefully will tell us more about the crashes in crbug 831822.
> 
> This CL will eventually be reverted again.
> 
> Bug: chromium:831822
> Change-Id: I123ed507949ecab50bb0aaaf9e91978c9c2d8d65
> Reviewed-on: https://chromium-review.googlesource.com/1016762
> Commit-Queue: Georg Neis <neis@chromium.org>
> Reviewed-by: Sigurd Schneider <sigurds@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#52673}

TBR=neis@chromium.org,sigurds@chromium.org

Change-Id: Ic2b37a3ce04516c5871b801015153ce84e622e90
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: chromium:831822
Reviewed-on: https://chromium-review.googlesource.com/1018860Reviewed-by: Michael Achenbach <machenbach@chromium.org>
Commit-Queue: Michael Achenbach <machenbach@chromium.org>
Cr-Commit-Position: refs/heads/master@{#52679}

src/compiler/register-allocator.h

@@ -59,7 +59,7 @@ class LifetimePosition final {
   // Returns the index of the instruction to which this lifetime position
   // corresponds.
   int ToInstructionIndex() const {
-    CHECK(IsValid());
+    DCHECK(IsValid());
     return value_ / kStep;
   }
 
@@ -75,38 +75,38 @@ class LifetimePosition final {
 
   // Returns the lifetime position for the current START.
   LifetimePosition Start() const {
-    CHECK(IsValid());
+    DCHECK(IsValid());
     return LifetimePosition(value_ & ~(kHalfStep - 1));
   }
 
   // Returns the lifetime position for the current gap START.
   LifetimePosition FullStart() const {
-    CHECK(IsValid());
+    DCHECK(IsValid());
     return LifetimePosition(value_ & ~(kStep - 1));
   }
 
   // Returns the lifetime position for the current END.
   LifetimePosition End() const {
-    CHECK(IsValid());
+    DCHECK(IsValid());
     return LifetimePosition(Start().value_ + kHalfStep / 2);
   }
 
   // Returns the lifetime position for the beginning of the next START.
   LifetimePosition NextStart() const {
-    CHECK(IsValid());
+    DCHECK(IsValid());
     return LifetimePosition(Start().value_ + kHalfStep);
   }
 
   // Returns the lifetime position for the beginning of the next gap START.
   LifetimePosition NextFullStart() const {
-    CHECK(IsValid());
+    DCHECK(IsValid());
     return LifetimePosition(FullStart().value_ + kStep);
   }
 
   // Returns the lifetime position for the beginning of the previous START.
   LifetimePosition PrevStart() const {
-    CHECK(IsValid());
-    CHECK_LE(kHalfStep, value_);
+    DCHECK(IsValid());
+    DCHECK_LE(kHalfStep, value_);
     return LifetimePosition(Start().value_ - kHalfStep);
   }
 
@@ -177,7 +177,7 @@ class UseInterval final : public ZoneObject {
  public:
   UseInterval(LifetimePosition start, LifetimePosition end)
       : start_(start), end_(end), next_(nullptr) {
-    CHECK(start < end);
+    DCHECK(start < end);
   }
 
   LifetimePosition start() const { return start_; }
@@ -400,17 +400,17 @@ class V8_EXPORT_PRIVATE LiveRange : public NON_EXPORTED_BASE(ZoneObject) {
   }
 
   UsePosition* current_hint_position() const {
-    CHECK(current_hint_position_ == FirstHintPosition());
+    DCHECK(current_hint_position_ == FirstHintPosition());
     return current_hint_position_;
   }
 
   LifetimePosition Start() const {
-    CHECK(!IsEmpty());
+    DCHECK(!IsEmpty());
     return first_interval()->start();
   }
 
   LifetimePosition End() const {
-    CHECK(!IsEmpty());
+    DCHECK(!IsEmpty());
     return last_interval_->end();
   }
 
@@ -534,17 +534,17 @@ class V8_EXPORT_PRIVATE TopLevelLiveRange final : public LiveRange {
   }
   SpillType spill_type() const { return SpillTypeField::decode(bits_); }
   InstructionOperand* GetSpillOperand() const {
-    CHECK_EQ(SpillType::kSpillOperand, spill_type());
+    DCHECK_EQ(SpillType::kSpillOperand, spill_type());
     return spill_operand_;
   }
 
   SpillRange* GetAllocatedSpillRange() const {
-    CHECK_NE(SpillType::kSpillOperand, spill_type());
+    DCHECK_NE(SpillType::kSpillOperand, spill_type());
     return spill_range_;
   }
 
   SpillRange* GetSpillRange() const {
-    CHECK_EQ(SpillType::kSpillRange, spill_type());
+    DCHECK_EQ(SpillType::kSpillRange, spill_type());
     return spill_range_;
   }
   bool HasNoSpillType() const {
@@ -590,7 +590,7 @@ class V8_EXPORT_PRIVATE TopLevelLiveRange final : public LiveRange {
   TopLevelLiveRange* splintered_from() const { return splintered_from_; }
   bool IsSplinter() const { return splintered_from_ != nullptr; }
   bool MayRequireSpillRange() const {
-    CHECK(!IsSplinter());
+    DCHECK(!IsSplinter());
     return !HasSpillOperand() && spill_range_ == nullptr;
   }
   void UpdateSpillRangePostMerge(TopLevelLiveRange* merged);
@@ -617,13 +617,13 @@ class V8_EXPORT_PRIVATE TopLevelLiveRange final : public LiveRange {
   struct SpillMoveInsertionList;
 
   SpillMoveInsertionList* GetSpillMoveInsertionLocations() const {
-    CHECK(!IsSpilledOnlyInDeferredBlocks());
+    DCHECK(!IsSpilledOnlyInDeferredBlocks());
     return spill_move_insertion_locations_;
   }
   TopLevelLiveRange* splinter() const { return splinter_; }
   void SetSplinter(TopLevelLiveRange* splinter) {
-    CHECK_NULL(splinter_);
-    CHECK_NOT_NULL(splinter);
+    DCHECK_NULL(splinter_);
+    DCHECK_NOT_NULL(splinter);
 
     splinter_ = splinter;
     splinter->relative_id_ = GetNextChildId();
@@ -635,12 +635,12 @@ class V8_EXPORT_PRIVATE TopLevelLiveRange final : public LiveRange {
   bool has_preassigned_slot() const { return has_preassigned_slot_; }
 
   void AddBlockRequiringSpillOperand(RpoNumber block_id) {
-    CHECK(IsSpilledOnlyInDeferredBlocks());
+    DCHECK(IsSpilledOnlyInDeferredBlocks());
     GetListOfBlocksRequiringSpillOperands()->Add(block_id.ToInt());
   }
 
   BitVector* GetListOfBlocksRequiringSpillOperands() const {
-    CHECK(IsSpilledOnlyInDeferredBlocks());
+    DCHECK(IsSpilledOnlyInDeferredBlocks());
     return list_of_blocks_requiring_spill_operands_;
   }
 
@@ -700,11 +700,11 @@ class SpillRange final : public ZoneObject {
   bool HasSlot() const { return assigned_slot_ != kUnassignedSlot; }
 
   void set_assigned_slot(int index) {
-    CHECK_EQ(kUnassignedSlot, assigned_slot_);
+    DCHECK_EQ(kUnassignedSlot, assigned_slot_);
     assigned_slot_ = index;
   }
   int assigned_slot() {
-    CHECK_NE(kUnassignedSlot, assigned_slot_);
+    DCHECK_NE(kUnassignedSlot, assigned_slot_);
     return assigned_slot_;
   }
   const ZoneVector<TopLevelLiveRange*>& live_ranges() const {
@@ -743,7 +743,7 @@ class RegisterAllocationData final : public ZoneObject {
     // For hinting.
     int assigned_register() const { return assigned_register_; }
     void set_assigned_register(int register_code) {
-      CHECK_EQ(assigned_register_, kUnassignedRegister);
+      DCHECK_EQ(assigned_register_, kUnassignedRegister);
       assigned_register_ = register_code;
     }
     void UnsetAssignedRegister() { assigned_register_ = kUnassignedRegister; }
@@ -1110,7 +1110,9 @@ class LinearScanAllocator final : public RegisterAllocator {
   ZoneVector<LiveRange*> active_live_ranges_;
   ZoneVector<LiveRange*> inactive_live_ranges_;
 
+#ifdef DEBUG
   LifetimePosition allocation_finger_;
+#endif
 
   DISALLOW_COPY_AND_ASSIGN(LinearScanAllocator);
 };

test/unittests/compiler/regalloc/live-range-unittest.cc

@@ -71,7 +71,7 @@ TEST_F(LiveRangeUnitTest, InvalidConstruction) {
   // Build a range manually, because the builder guards against empty cases.
   TopLevelLiveRange* range =
       new (zone()) TopLevelLiveRange(1, MachineRepresentation::kTagged);
-  ASSERT_DEATH_IF_SUPPORTED(
+  V8_ASSERT_DEBUG_DEATH(
       range->AddUseInterval(LifetimePosition::FromInt(0),
                             LifetimePosition::FromInt(0), zone()),
       ".*");
@@ -79,7 +79,7 @@ TEST_F(LiveRangeUnitTest, InvalidConstruction) {
 
 TEST_F(LiveRangeUnitTest, SplitInvalidStart) {
   TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 1);
-  ASSERT_DEATH_IF_SUPPORTED(Split(range, 0), ".*");
+  V8_ASSERT_DEBUG_DEATH(Split(range, 0), ".*");
 }
 
 TEST_F(LiveRangeUnitTest, DISABLE_IN_RELEASE(InvalidSplitEnd)) {
@@ -308,7 +308,7 @@ TEST_F(LiveRangeUnitTest, MergeMultipleIntervalsOutside) {
 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsInside) {
   TopLevelLiveRange* range =
       TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build();
-  ASSERT_DEATH_IF_SUPPORTED(Splinter(range, 3, 5), ".*");
+  V8_ASSERT_DEBUG_DEATH(Splinter(range, 3, 5), ".*");
 }
 
 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsLeft) {