Rename ASSERT* to DCHECK*.

src/lithium.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_LITHIUM_H_
 #define V8_LITHIUM_H_
 
 #include <set>
 
 #include "src/allocation.h"
@@ skipping 30 matching lines @@
 #define LITHIUM_OPERAND_PREDICATE(name, type, number) \
   bool Is##name() const { return kind() == type; }
   LITHIUM_OPERAND_LIST(LITHIUM_OPERAND_PREDICATE)
   LITHIUM_OPERAND_PREDICATE(Unallocated, UNALLOCATED, 0)
   LITHIUM_OPERAND_PREDICATE(Ignored, INVALID, 0)
 #undef LITHIUM_OPERAND_PREDICATE
   bool Equals(LOperand* other) const { return value_ == other->value_; }
 
   void PrintTo(StringStream* stream);
   void ConvertTo(Kind kind, int index) {
-    if (kind == REGISTER) ASSERT(index >= 0);
+    if (kind == REGISTER) DCHECK(index >= 0);
     value_ = KindField::encode(kind);
     value_ |= index << kKindFieldWidth;
-    ASSERT(this->index() == index);
+    DCHECK(this->index() == index);
   }
 
   // Calls SetUpCache()/TearDownCache() for each subclass.
   static void SetUpCaches();
   static void TearDownCaches();
 
  protected:
   static const int kKindFieldWidth = 3;
   class KindField : public BitField<Kind, 0, kKindFieldWidth> { };
 
@@ skipping 35 matching lines @@
     USED_AT_END
   };
 
   explicit LUnallocated(ExtendedPolicy policy) : LOperand(UNALLOCATED, 0) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(USED_AT_END);
   }
 
   LUnallocated(BasicPolicy policy, int index) : LOperand(UNALLOCATED, 0) {
-    ASSERT(policy == FIXED_SLOT);
+    DCHECK(policy == FIXED_SLOT);
     value_ |= BasicPolicyField::encode(policy);
     value_ |= index << FixedSlotIndexField::kShift;
-    ASSERT(this->fixed_slot_index() == index);
+    DCHECK(this->fixed_slot_index() == index);
   }
 
   LUnallocated(ExtendedPolicy policy, int index) : LOperand(UNALLOCATED, 0) {
-    ASSERT(policy == FIXED_REGISTER || policy == FIXED_DOUBLE_REGISTER);
+    DCHECK(policy == FIXED_REGISTER || policy == FIXED_DOUBLE_REGISTER);
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(USED_AT_END);
     value_ |= FixedRegisterField::encode(index);
   }
 
   LUnallocated(ExtendedPolicy policy, Lifetime lifetime)
       : LOperand(UNALLOCATED, 0) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(lifetime);
   }
 
   LUnallocated* CopyUnconstrained(Zone* zone) {
     LUnallocated* result = new(zone) LUnallocated(ANY);
     result->set_virtual_register(virtual_register());
     return result;
   }
 
   static LUnallocated* cast(LOperand* op) {
-    ASSERT(op->IsUnallocated());
+    DCHECK(op->IsUnallocated());
     return reinterpret_cast<LUnallocated*>(op);
   }
 
   // The encoding used for LUnallocated operands depends on the policy that is
   // stored within the operand. The FIXED_SLOT policy uses a compact encoding
   // because it accommodates a larger pay-load.
   //
   // For FIXED_SLOT policy:
   //     +------------------------------------------+
   //     |       slot_index      |  vreg  | 0 | 001 |
@@ skipping 66 matching lines @@
         extended_policy() == WRITABLE_REGISTER;
   }
 
   // [basic_policy]: Distinguish between FIXED_SLOT and all other policies.
   BasicPolicy basic_policy() const {
     return BasicPolicyField::decode(value_);
   }
 
   // [extended_policy]: Only for non-FIXED_SLOT. The finer-grained policy.
   ExtendedPolicy extended_policy() const {
-    ASSERT(basic_policy() == EXTENDED_POLICY);
+    DCHECK(basic_policy() == EXTENDED_POLICY);
     return ExtendedPolicyField::decode(value_);
   }
 
   // [fixed_slot_index]: Only for FIXED_SLOT.
   int fixed_slot_index() const {
-    ASSERT(HasFixedSlotPolicy());
+    DCHECK(HasFixedSlotPolicy());
     return static_cast<int>(value_) >> FixedSlotIndexField::kShift;
   }
 
   // [fixed_register_index]: Only for FIXED_REGISTER or FIXED_DOUBLE_REGISTER.
   int fixed_register_index() const {
-    ASSERT(HasFixedRegisterPolicy() || HasFixedDoubleRegisterPolicy());
+    DCHECK(HasFixedRegisterPolicy() || HasFixedDoubleRegisterPolicy());
     return FixedRegisterField::decode(value_);
   }
 
   // [virtual_register]: The virtual register ID for this operand.
   int virtual_register() const {
     return VirtualRegisterField::decode(value_);
   }
   void set_virtual_register(unsigned id) {
     value_ = VirtualRegisterField::update(value_, id);
   }
 
   // [lifetime]: Only for non-FIXED_SLOT.
   bool IsUsedAtStart() {
-    ASSERT(basic_policy() == EXTENDED_POLICY);
+    DCHECK(basic_policy() == EXTENDED_POLICY);
     return LifetimeField::decode(value_) == USED_AT_START;
   }
 };
 
 
 class LMoveOperands V8_FINAL BASE_EMBEDDED {
  public:
   LMoveOperands(LOperand* source, LOperand* destination)
       : source_(source), destination_(destination) {
   }
@@ skipping 22 matching lines @@
            (destination_ != NULL && destination_->IsConstantOperand());
   }
 
   bool IsIgnored() const {
     return destination_ != NULL && destination_->IsIgnored();
   }
 
   // We clear both operands to indicate move that's been eliminated.
   void Eliminate() { source_ = destination_ = NULL; }
   bool IsEliminated() const {
-    ASSERT(source_ != NULL || destination_ == NULL);
+    DCHECK(source_ != NULL || destination_ == NULL);
     return source_ == NULL;
   }
 
  private:
   LOperand* source_;
   LOperand* destination_;
 };
 
 
 template<LOperand::Kind kOperandKind, int kNumCachedOperands>
 class LSubKindOperand V8_FINAL : public LOperand {
  public:
   static LSubKindOperand* Create(int index, Zone* zone) {
-    ASSERT(index >= 0);
+    DCHECK(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new(zone) LSubKindOperand(index);
   }
 
   static LSubKindOperand* cast(LOperand* op) {
-    ASSERT(op->kind() == kOperandKind);
+    DCHECK(op->kind() == kOperandKind);
     return reinterpret_cast<LSubKindOperand*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static LSubKindOperand* cache;
 
   LSubKindOperand() : LOperand() { }
@@ skipping 36 matching lines @@
   const ZoneList<LOperand*>* GetNormalizedOperands() {
     for (int i = 0; i < untagged_operands_.length(); ++i) {
       RemovePointer(untagged_operands_[i]);
     }
     untagged_operands_.Clear();
     return &pointer_operands_;
   }
   int lithium_position() const { return lithium_position_; }
 
   void set_lithium_position(int pos) {
-    ASSERT(lithium_position_ == -1);
+    DCHECK(lithium_position_ == -1);
     lithium_position_ = pos;
   }
 
   void RecordPointer(LOperand* op, Zone* zone);
   void RemovePointer(LOperand* op);
   void RecordUntagged(LOperand* op, Zone* zone);
   void PrintTo(StringStream* stream);
 
  private:
   ZoneList<LOperand*> pointer_operands_;
@@ skipping 46 matching lines @@
   Zone* zone() const { return zone_; }
 
   bool has_been_used() const { return has_been_used_; }
   void set_has_been_used() { has_been_used_ = true; }
 
   void AddValue(LOperand* operand,
                 Representation representation,
                 bool is_uint32) {
     values_.Add(operand, zone());
     if (representation.IsSmiOrTagged()) {
-      ASSERT(!is_uint32);
+      DCHECK(!is_uint32);
       is_tagged_.Add(values_.length() - 1, zone());
     }
 
     if (is_uint32) {
       is_uint32_.Add(values_.length() - 1, zone());
     }
   }
 
   bool HasTaggedValueAt(int index) const {
     return is_tagged_.Contains(index);
@@ skipping 10 matching lines @@
     object_mapping_.Add(encoded, zone());
   }
 
   void AddDuplicateObject(int dupe_of) {
     uint32_t encoded = LengthOrDupeField::encode(dupe_of) |
                        IsDuplicateField::encode(true);
     object_mapping_.Add(encoded, zone());
   }
 
   int ObjectDuplicateOfAt(int index) {
-    ASSERT(ObjectIsDuplicateAt(index));
+    DCHECK(ObjectIsDuplicateAt(index));
     return LengthOrDupeField::decode(object_mapping_[index]);
   }
 
   int ObjectLengthAt(int index) {
-    ASSERT(!ObjectIsDuplicateAt(index));
+    DCHECK(!ObjectIsDuplicateAt(index));
     return LengthOrDupeField::decode(object_mapping_[index]);
   }
 
   bool ObjectIsArgumentsAt(int index) {
-    ASSERT(!ObjectIsDuplicateAt(index));
+    DCHECK(!ObjectIsDuplicateAt(index));
     return IsArgumentsField::decode(object_mapping_[index]);
   }
 
   bool ObjectIsDuplicateAt(int index) {
     return IsDuplicateField::decode(object_mapping_[index]);
   }
 
   void Register(int deoptimization_index,
                 int translation_index,
                 int pc_offset) {
-    ASSERT(!HasBeenRegistered());
+    DCHECK(!HasBeenRegistered());
     deoptimization_index_ = deoptimization_index;
     translation_index_ = translation_index;
     pc_offset_ = pc_offset;
   }
   bool HasBeenRegistered() const {
     return deoptimization_index_ != Safepoint::kNoDeoptimizationIndex;
   }
 
   void PrintTo(StringStream* stream);
 
@@ skipping 38 matching lines @@
   explicit ShallowIterator(LEnvironment* env)
       : env_(env),
         limit_(env != NULL ? env->values()->length() : 0),
         current_(0) {
     SkipUninteresting();
   }
 
   bool Done() { return current_ >= limit_; }
 
   LOperand* Current() {
-    ASSERT(!Done());
-    ASSERT(env_->values()->at(current_) != NULL);
+    DCHECK(!Done());
+    DCHECK(env_->values()->at(current_) != NULL);
     return env_->values()->at(current_);
   }
 
   void Advance() {
-    ASSERT(!Done());
+    DCHECK(!Done());
     ++current_;
     SkipUninteresting();
   }
 
   LEnvironment* env() { return env_; }
 
  private:
   bool ShouldSkip(LOperand* op) {
     return op == NULL || op->IsConstantOperand();
   }
@@ skipping 15 matching lines @@
 class DeepIterator V8_FINAL BASE_EMBEDDED {
  public:
   explicit DeepIterator(LEnvironment* env)
       : current_iterator_(env) {
     SkipUninteresting();
   }
 
   bool Done() { return current_iterator_.Done(); }
 
   LOperand* Current() {
-    ASSERT(!current_iterator_.Done());
-    ASSERT(current_iterator_.Current() != NULL);
+    DCHECK(!current_iterator_.Done());
+    DCHECK(current_iterator_.Current() != NULL);
     return current_iterator_.Current();
   }
 
   void Advance() {
     current_iterator_.Advance();
     SkipUninteresting();
   }
 
  private:
   void SkipUninteresting() {
@@ skipping 40 matching lines @@
 
   const ZoneList<Handle<JSFunction> >* inlined_closures() const {
     return &inlined_closures_;
   }
 
   void AddInlinedClosure(Handle<JSFunction> closure) {
     inlined_closures_.Add(closure, zone());
   }
 
   void AddDeprecationDependency(Handle<Map> map) {
-    ASSERT(!map->is_deprecated());
+    DCHECK(!map->is_deprecated());
     if (!map->CanBeDeprecated()) return;
-    ASSERT(!info_->IsStub());
+    DCHECK(!info_->IsStub());
     deprecation_dependencies_.insert(map);
   }
 
   void AddStabilityDependency(Handle<Map> map) {
-    ASSERT(map->is_stable());
+    DCHECK(map->is_stable());
     if (!map->CanTransition()) return;
-    ASSERT(!info_->IsStub());
+    DCHECK(!info_->IsStub());
     stability_dependencies_.insert(map);
   }
 
   Zone* zone() const { return info_->zone(); }
 
   Handle<Code> Codegen();
 
   void set_allocated_double_registers(BitVector* allocated_registers);
   BitVector* allocated_double_registers() {
     return allocated_double_registers_;
@@ skipping 124 matching lines @@
  private:
   InputIterator input_iterator_;
   DeepIterator env_iterator_;
 };
 
 class LInstruction;
 class LCodeGen;
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_H_