Rename ASSERT* to DCHECK*.

src/compiler/instruction.h

 // Copyright 2014 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_COMPILER_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 55 matching lines @@
   bool Is##name() const { return kind() == type; }
   INSTRUCTION_OPERAND_LIST(INSTRUCTION_OPERAND_PREDICATE)
   INSTRUCTION_OPERAND_PREDICATE(Unallocated, UNALLOCATED, 0)
   INSTRUCTION_OPERAND_PREDICATE(Ignored, INVALID, 0)
 #undef INSTRUCTION_OPERAND_PREDICATE
   bool Equals(InstructionOperand* other) const {
     return value_ == other->value_;
   }
 
   void ConvertTo(Kind kind, int index) {
-    if (kind == REGISTER || kind == DOUBLE_REGISTER) ASSERT(index >= 0);
+    if (kind == REGISTER || kind == DOUBLE_REGISTER) DCHECK(index >= 0);
     value_ = KindField::encode(kind);
     value_ |= index << KindField::kSize;
-    ASSERT(this->index() == index);
+    DCHECK(this->index() == index);
   }
 
   // Calls SetUpCache()/TearDownCache() for each subclass.
   static void SetUpCaches();
   static void TearDownCaches();
 
  protected:
   typedef BitField<Kind, 0, 3> KindField;
 
   unsigned value_;
@@ skipping 30 matching lines @@
 
   explicit UnallocatedOperand(ExtendedPolicy policy)
       : InstructionOperand(UNALLOCATED, 0) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(USED_AT_END);
   }
 
   UnallocatedOperand(BasicPolicy policy, int index)
       : InstructionOperand(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);
   }
 
   UnallocatedOperand(ExtendedPolicy policy, int index)
       : InstructionOperand(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);
   }
 
   UnallocatedOperand(ExtendedPolicy policy, Lifetime lifetime)
       : InstructionOperand(UNALLOCATED, 0) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(lifetime);
   }
 
   UnallocatedOperand* CopyUnconstrained(Zone* zone) {
     UnallocatedOperand* result = new (zone) UnallocatedOperand(ANY);
     result->set_virtual_register(virtual_register());
     return result;
   }
 
   static const UnallocatedOperand* cast(const InstructionOperand* op) {
-    ASSERT(op->IsUnallocated());
+    DCHECK(op->IsUnallocated());
     return static_cast<const UnallocatedOperand*>(op);
   }
 
   static UnallocatedOperand* cast(InstructionOperand* op) {
-    ASSERT(op->IsUnallocated());
+    DCHECK(op->IsUnallocated());
     return static_cast<UnallocatedOperand*>(op);
   }
 
   // The encoding used for UnallocatedOperand 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:
   //     +------------------------------------------+
@@ skipping 53 matching lines @@
   bool HasFixedDoubleRegisterPolicy() const {
     return basic_policy() == EXTENDED_POLICY &&
            extended_policy() == FIXED_DOUBLE_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 MoveOperands V8_FINAL {
  public:
   MoveOperands(InstructionOperand* source, InstructionOperand* destination)
       : source_(source), destination_(destination) {}
 
@@ skipping 19 matching lines @@
            (destination_ != NULL && destination_->IsConstant());
   }
 
   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:
   InstructionOperand* source_;
   InstructionOperand* destination_;
 };
 
 OStream& operator<<(OStream& os, const MoveOperands& mo);
 
 template <InstructionOperand::Kind kOperandKind, int kNumCachedOperands>
 class SubKindOperand V8_FINAL : public InstructionOperand {
  public:
   static SubKindOperand* Create(int index, Zone* zone) {
-    ASSERT(index >= 0);
+    DCHECK(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new (zone) SubKindOperand(index);
   }
 
   static SubKindOperand* cast(InstructionOperand* op) {
-    ASSERT(op->kind() == kOperandKind);
+    DCHECK(op->kind() == kOperandKind);
     return reinterpret_cast<SubKindOperand*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static SubKindOperand* cache;
 
   SubKindOperand() : InstructionOperand() {}
@@ skipping 39 matching lines @@
   const ZoneList<InstructionOperand*>* GetNormalizedOperands() {
     for (int i = 0; i < untagged_operands_.length(); ++i) {
       RemovePointer(untagged_operands_[i]);
     }
     untagged_operands_.Clear();
     return &pointer_operands_;
   }
   int instruction_position() const { return instruction_position_; }
 
   void set_instruction_position(int pos) {
-    ASSERT(instruction_position_ == -1);
+    DCHECK(instruction_position_ == -1);
     instruction_position_ = pos;
   }
 
   void RecordPointer(InstructionOperand* op, Zone* zone);
   void RemovePointer(InstructionOperand* op);
   void RecordUntagged(InstructionOperand* op, Zone* zone);
 
  private:
   friend OStream& operator<<(OStream& os, const PointerMap& pm);
 
   ZoneList<InstructionOperand*> pointer_operands_;
   ZoneList<InstructionOperand*> untagged_operands_;
   int instruction_position_;
 };
 
 OStream& operator<<(OStream& os, const PointerMap& pm);
 
 // TODO(titzer): s/PointerMap/ReferenceMap/
 class Instruction : public ZoneObject {
  public:
   size_t OutputCount() const { return OutputCountField::decode(bit_field_); }
   InstructionOperand* Output() const { return OutputAt(0); }
   InstructionOperand* OutputAt(size_t i) const {
-    ASSERT(i < OutputCount());
+    DCHECK(i < OutputCount());
     return operands_[i];
   }
 
   size_t InputCount() const { return InputCountField::decode(bit_field_); }
   InstructionOperand* InputAt(size_t i) const {
-    ASSERT(i < InputCount());
+    DCHECK(i < InputCount());
     return operands_[OutputCount() + i];
   }
 
   size_t TempCount() const { return TempCountField::decode(bit_field_); }
   InstructionOperand* TempAt(size_t i) const {
-    ASSERT(i < TempCount());
+    DCHECK(i < TempCount());
     return operands_[OutputCount() + InputCount() + i];
   }
 
   InstructionCode opcode() const { return opcode_; }
   ArchOpcode arch_opcode() const { return ArchOpcodeField::decode(opcode()); }
   AddressingMode addressing_mode() const {
     return AddressingModeField::decode(opcode());
   }
   FlagsMode flags_mode() const { return FlagsModeField::decode(opcode()); }
   FlagsCondition flags_condition() const {
     return FlagsConditionField::decode(opcode());
   }
 
   // TODO(titzer): make control and call into flags.
   static Instruction* New(Zone* zone, InstructionCode opcode) {
     return New(zone, opcode, 0, NULL, 0, NULL, 0, NULL);
   }
 
   static Instruction* New(Zone* zone, InstructionCode opcode,
                           size_t output_count, InstructionOperand** outputs,
                           size_t input_count, InstructionOperand** inputs,
                           size_t temp_count, InstructionOperand** temps) {
-    ASSERT(opcode >= 0);
-    ASSERT(output_count == 0 || outputs != NULL);
-    ASSERT(input_count == 0 || inputs != NULL);
-    ASSERT(temp_count == 0 || temps != NULL);
+    DCHECK(opcode >= 0);
+    DCHECK(output_count == 0 || outputs != NULL);
+    DCHECK(input_count == 0 || inputs != NULL);
+    DCHECK(temp_count == 0 || temps != NULL);
     InstructionOperand* none = NULL;
     USE(none);
     int size = static_cast<int>(RoundUp(sizeof(Instruction), kPointerSize) +
                                 (output_count + input_count + temp_count - 1) *
                                     sizeof(none));
     return new (zone->New(size)) Instruction(
         opcode, output_count, outputs, input_count, inputs, temp_count, temps);
   }
 
   // TODO(titzer): another holdover from lithium days; register allocator
@@ skipping 18 matching lines @@
   bool IsSourcePosition() const {
     return opcode() == kSourcePositionInstruction;
   }
 
   bool ClobbersRegisters() const { return IsCall(); }
   bool ClobbersTemps() const { return IsCall(); }
   bool ClobbersDoubleRegisters() const { return IsCall(); }
   PointerMap* pointer_map() const { return pointer_map_; }
 
   void set_pointer_map(PointerMap* map) {
-    ASSERT(NeedsPointerMap());
-    ASSERT_EQ(NULL, pointer_map_);
+    DCHECK(NeedsPointerMap());
+    DCHECK_EQ(NULL, pointer_map_);
     pointer_map_ = map;
   }
 
   // Placement new operator so that we can smash instructions into
   // zone-allocated memory.
   void* operator new(size_t, void* location) { return location; }
 
   void operator delete(void* pointer, void* location) { UNREACHABLE(); }
 
  protected:
@@ skipping 64 matching lines @@
   ParallelMove* GetParallelMove(InnerPosition pos) {
     return parallel_moves_[pos];
   }
 
   static GapInstruction* New(Zone* zone) {
     void* buffer = zone->New(sizeof(GapInstruction));
     return new (buffer) GapInstruction(kGapInstruction);
   }
 
   static GapInstruction* cast(Instruction* instr) {
-    ASSERT(instr->IsGapMoves());
+    DCHECK(instr->IsGapMoves());
     return static_cast<GapInstruction*>(instr);
   }
 
   static const GapInstruction* cast(const Instruction* instr) {
-    ASSERT(instr->IsGapMoves());
+    DCHECK(instr->IsGapMoves());
     return static_cast<const GapInstruction*>(instr);
   }
 
  protected:
   explicit GapInstruction(InstructionCode opcode) : Instruction(opcode) {
     parallel_moves_[BEFORE] = NULL;
     parallel_moves_[START] = NULL;
     parallel_moves_[END] = NULL;
     parallel_moves_[AFTER] = NULL;
   }
@@ skipping 11 matching lines @@
  public:
   BasicBlock* block() const { return block_; }
   Label* label() { return &label_; }
 
   static BlockStartInstruction* New(Zone* zone, BasicBlock* block) {
     void* buffer = zone->New(sizeof(BlockStartInstruction));
     return new (buffer) BlockStartInstruction(block);
   }
 
   static BlockStartInstruction* cast(Instruction* instr) {
-    ASSERT(instr->IsBlockStart());
+    DCHECK(instr->IsBlockStart());
     return static_cast<BlockStartInstruction*>(instr);
   }
 
  private:
   explicit BlockStartInstruction(BasicBlock* block)
       : GapInstruction(kBlockStartInstruction), block_(block) {}
 
   BasicBlock* block_;
   Label label_;
 };
 
 
 class SourcePositionInstruction V8_FINAL : public Instruction {
  public:
   static SourcePositionInstruction* New(Zone* zone, SourcePosition position) {
     void* buffer = zone->New(sizeof(SourcePositionInstruction));
     return new (buffer) SourcePositionInstruction(position);
   }
 
   SourcePosition source_position() const { return source_position_; }
 
   static SourcePositionInstruction* cast(Instruction* instr) {
-    ASSERT(instr->IsSourcePosition());
+    DCHECK(instr->IsSourcePosition());
     return static_cast<SourcePositionInstruction*>(instr);
   }
 
   static const SourcePositionInstruction* cast(const Instruction* instr) {
-    ASSERT(instr->IsSourcePosition());
+    DCHECK(instr->IsSourcePosition());
     return static_cast<const SourcePositionInstruction*>(instr);
   }
 
  private:
   explicit SourcePositionInstruction(SourcePosition source_position)
       : Instruction(kSourcePositionInstruction),
         source_position_(source_position) {
-    ASSERT(!source_position_.IsInvalid());
-    ASSERT(!source_position_.IsUnknown());
+    DCHECK(!source_position_.IsInvalid());
+    DCHECK(!source_position_.IsUnknown());
   }
 
   SourcePosition source_position_;
 };
 
 
 class Constant V8_FINAL {
  public:
   enum Type { kInt32, kInt64, kFloat64, kExternalReference, kHeapObject };
 
   explicit Constant(int32_t v) : type_(kInt32), value_(v) {}
   explicit Constant(int64_t v) : type_(kInt64), value_(v) {}
   explicit Constant(double v) : type_(kFloat64), value_(BitCast<int64_t>(v)) {}
   explicit Constant(ExternalReference ref)
       : type_(kExternalReference), value_(BitCast<intptr_t>(ref)) {}
   explicit Constant(Handle<HeapObject> obj)
       : type_(kHeapObject), value_(BitCast<intptr_t>(obj)) {}
 
   Type type() const { return type_; }
 
   int32_t ToInt32() const {
-    ASSERT_EQ(kInt32, type());
+    DCHECK_EQ(kInt32, type());
     return static_cast<int32_t>(value_);
   }
 
   int64_t ToInt64() const {
     if (type() == kInt32) return ToInt32();
-    ASSERT_EQ(kInt64, type());
+    DCHECK_EQ(kInt64, type());
     return value_;
   }
 
   double ToFloat64() const {
     if (type() == kInt32) return ToInt32();
-    ASSERT_EQ(kFloat64, type());
+    DCHECK_EQ(kFloat64, type());
     return BitCast<double>(value_);
   }
 
   ExternalReference ToExternalReference() const {
-    ASSERT_EQ(kExternalReference, type());
+    DCHECK_EQ(kExternalReference, type());
     return BitCast<ExternalReference>(static_cast<intptr_t>(value_));
   }
 
   Handle<HeapObject> ToHeapObject() const {
-    ASSERT_EQ(kHeapObject, type());
+    DCHECK_EQ(kHeapObject, type());
     return BitCast<Handle<HeapObject> >(static_cast<intptr_t>(value_));
   }
 
  private:
   Type type_;
   int64_t value_;
 };
 
 OStream& operator<<(OStream& os, const Constant& constant);
 
@@ skipping 65 matching lines @@
 
   typedef InstructionDeque::const_iterator const_iterator;
   const_iterator begin() const { return instructions_.begin(); }
   const_iterator end() const { return instructions_.end(); }
 
   GapInstruction* GapAt(int index) const {
     return GapInstruction::cast(InstructionAt(index));
   }
   bool IsGapAt(int index) const { return InstructionAt(index)->IsGapMoves(); }
   Instruction* InstructionAt(int index) const {
-    ASSERT(index >= 0);
-    ASSERT(index < static_cast<int>(instructions_.size()));
+    DCHECK(index >= 0);
+    DCHECK(index < static_cast<int>(instructions_.size()));
     return instructions_[index];
   }
 
   Frame* frame() { return &frame_; }
   Graph* graph() const { return graph_; }
   Isolate* isolate() const { return zone()->isolate(); }
   Linkage* linkage() const { return linkage_; }
   Schedule* schedule() const { return schedule_; }
   const PointerMapDeque* pointer_maps() const { return &pointer_maps_; }
   Zone* zone() const { return graph_->zone(); }
 
   // Used by the code generator while adding instructions.
   int AddInstruction(Instruction* instr, BasicBlock* block);
   void StartBlock(BasicBlock* block);
   void EndBlock(BasicBlock* block);
 
   void AddConstant(int virtual_register, Constant constant) {
-    ASSERT(constants_.find(virtual_register) == constants_.end());
+    DCHECK(constants_.find(virtual_register) == constants_.end());
     constants_.insert(std::make_pair(virtual_register, constant));
   }
   Constant GetConstant(int virtual_register) const {
     ConstantMap::const_iterator it = constants_.find(virtual_register);
-    ASSERT(it != constants_.end());
-    ASSERT_EQ(virtual_register, it->first);
+    DCHECK(it != constants_.end());
+    DCHECK_EQ(virtual_register, it->first);
     return it->second;
   }
 
   typedef ConstantDeque Immediates;
   const Immediates& immediates() const { return immediates_; }
 
   int AddImmediate(Constant constant) {
     int index = static_cast<int>(immediates_.size());
     immediates_.push_back(constant);
     return index;
   }
   Constant GetImmediate(int index) const {
-    ASSERT(index >= 0);
-    ASSERT(index < static_cast<int>(immediates_.size()));
+    DCHECK(index >= 0);
+    DCHECK(index < static_cast<int>(immediates_.size()));
     return immediates_[index];
   }
 
   int AddDeoptimizationEntry(const FrameStateDescriptor& descriptor);
   FrameStateDescriptor GetDeoptimizationEntry(int deoptimization_id);
   int GetDeoptimizationEntryCount();
 
  private:
   friend OStream& operator<<(OStream& os, const InstructionSequence& code);
 
@@ skipping 13 matching lines @@
   DeoptimizationVector deoptimization_entries_;
 };
 
 OStream& operator<<(OStream& os, const InstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_