Rename ASSERT* to DCHECK*.

src/gdb-jit.cc

 // Copyright 2010 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.
 
 #ifdef ENABLE_GDB_JIT_INTERFACE
 #include "src/v8.h"
 
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
 #include "src/compiler.h"
@@ skipping 97 matching lines @@
 
   DebugObject* debug_object() { return debug_object_; }
 
   byte* buffer() { return buffer_; }
 
   void Align(uintptr_t align) {
     uintptr_t delta = position_ % align;
     if (delta == 0) return;
     uintptr_t padding = align - delta;
     Ensure(position_ += padding);
-    ASSERT((position_ % align) == 0);
+    DCHECK((position_ % align) == 0);
   }
 
   void WriteULEB128(uintptr_t value) {
     do {
       uint8_t byte = value & 0x7F;
       value >>= 7;
       if (value != 0) byte |= 0x80;
       Write<uint8_t>(byte);
     } while (value != 0);
   }
@@ skipping 19 matching lines @@
     do {
       Write<char>(*str);
     } while (*str++);
   }
 
  private:
   template<typename T> friend class Slot;
 
   template<typename T>
   T* RawSlotAt(uintptr_t offset) {
-    ASSERT(offset < capacity_ && offset + sizeof(T) <= capacity_);
+    DCHECK(offset < capacity_ && offset + sizeof(T) <= capacity_);
     return reinterpret_cast<T*>(&buffer_[offset]);
   }
 
   DebugObject* debug_object_;
   uintptr_t position_;
   uintptr_t capacity_;
   byte* buffer_;
 };
 
 class ELFStringTable;
@@ skipping 55 matching lines @@
 
   MachOSection(const char* name,
                const char* segment,
                uintptr_t align,
                uint32_t flags)
     : name_(name),
       segment_(segment),
       align_(align),
       flags_(flags) {
     if (align_ != 0) {
-      ASSERT(IsPowerOf2(align));
+      DCHECK(IsPowerOf2(align));
       align_ = WhichPowerOf2(align_);
     }
   }
 
   virtual ~MachOSection() { }
 
   virtual void PopulateHeader(Writer::Slot<Header> header) {
     header->addr = 0;
     header->size = 0;
     header->offset = 0;
     header->align = align_;
     header->reloff = 0;
     header->nreloc = 0;
     header->flags = flags_;
     header->reserved1 = 0;
     header->reserved2 = 0;
     memset(header->sectname, 0, sizeof(header->sectname));
     memset(header->segname, 0, sizeof(header->segname));
-    ASSERT(strlen(name_) < sizeof(header->sectname));
-    ASSERT(strlen(segment_) < sizeof(header->segname));
+    DCHECK(strlen(name_) < sizeof(header->sectname));
+    DCHECK(strlen(segment_) < sizeof(header->segname));
     strncpy(header->sectname, name_, sizeof(header->sectname));
     strncpy(header->segname, segment_, sizeof(header->segname));
   }
 
  private:
   const char* name_;
   const char* segment_;
   uintptr_t align_;
   uint32_t flags_;
 };
@@ skipping 171 matching lines @@
 
     // First entry in the string table should be an empty string.
     WriteString("");
   }
 
   void DetachWriter() {
     writer_ = NULL;
   }
 
   virtual void WriteBody(Writer::Slot<Header> header, Writer* w) {
-    ASSERT(writer_ == NULL);
+    DCHECK(writer_ == NULL);
     header->offset = offset_;
     header->size = size_;
   }
 
  private:
   void WriteString(const char* str) {
     uintptr_t written = 0;
     do {
       writer_->Write(*str);
       written++;
@@ skipping 72 matching lines @@
     uint32_t flags;
   };
 
   enum MachOLoadCommandCmd {
     LC_SEGMENT_32 = 0x00000001u,
     LC_SEGMENT_64 = 0x00000019u
   };
 
 
   Writer::Slot<MachOHeader> WriteHeader(Writer* w) {
-    ASSERT(w->position() == 0);
+    DCHECK(w->position() == 0);
     Writer::Slot<MachOHeader> header = w->CreateSlotHere<MachOHeader>();
 #if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
     header->magic = 0xFEEDFACEu;
     header->cputype = 7;  // i386
     header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
 #elif V8_TARGET_ARCH_X64
     header->magic = 0xFEEDFACFu;
     header->cputype = 7 | 0x01000000;  // i386 | 64-bit ABI
     header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
     header->reserved = 0;
@@ skipping 91 matching lines @@
     uint16_t header_size;
     uint16_t pht_entry_size;
     uint16_t pht_entry_num;
     uint16_t sht_entry_size;
     uint16_t sht_entry_num;
     uint16_t sht_strtab_index;
   };
 
 
   void WriteHeader(Writer* w) {
-    ASSERT(w->position() == 0);
+    DCHECK(w->position() == 0);
     Writer::Slot<ELFHeader> header = w->CreateSlotHere<ELFHeader>();
 #if (V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_X87 || \
      (V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_32_BIT))
     const uint8_t ident[16] =
         { 0x7f, 'E', 'L', 'F', 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 #elif V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_64_BIT
     const uint8_t ident[16] =
         { 0x7f, 'E', 'L', 'F', 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 #else
 #error Unsupported target architecture.
@@ skipping 22 matching lines @@
     header->header_size = sizeof(ELFHeader);
     header->pht_entry_size = 0;
     header->pht_entry_num = 0;
     header->sht_entry_size = sizeof(ELFSection::Header);
     header->sht_entry_num = sections_.length();
     header->sht_strtab_index = 1;
   }
 
   void WriteSectionTable(Writer* w) {
     // Section headers table immediately follows file header.
-    ASSERT(w->position() == sizeof(ELFHeader));
+    DCHECK(w->position() == sizeof(ELFHeader));
 
     Writer::Slot<ELFSection::Header> headers =
         w->CreateSlotsHere<ELFSection::Header>(sections_.length());
 
     // String table for section table is the first section.
     ELFStringTable* strtab = static_cast<ELFStringTable*>(SectionAt(1));
     strtab->AttachWriter(w);
     for (int i = 0, length = sections_.length();
          i < length;
          i++) {
@@ skipping 275 matching lines @@
   bool IsLineInfoAvailable() {
     return !script_.is_null() &&
         script_->source()->IsString() &&
         script_->HasValidSource() &&
         script_->name()->IsString() &&
         lineinfo_ != NULL;
   }
 
 #if V8_TARGET_ARCH_X64
   uintptr_t GetStackStateStartAddress(StackState state) const {
-    ASSERT(state < STACK_STATE_MAX);
+    DCHECK(state < STACK_STATE_MAX);
     return stack_state_start_addresses_[state];
   }
 
   void SetStackStateStartAddress(StackState state, uintptr_t addr) {
-    ASSERT(state < STACK_STATE_MAX);
+    DCHECK(state < STACK_STATE_MAX);
     stack_state_start_addresses_[state] = addr;
   }
 #endif
 
   SmartArrayPointer<char> GetFilename() {
     return String::cast(script_->name())->ToCString();
   }
 
   int GetScriptLineNumber(int pos) {
     return script_->GetLineNumber(pos) + 1;
@@ skipping 142 matching lines @@
       StringBuilder builder(buffer.start(), buffer.length());
 
       for (int slot = 0; slot < slots; ++slot) {
         w->WriteULEB128(current_abbreviation++);
         builder.Reset();
         builder.AddFormatted("slot%d", slot);
         w->WriteString(builder.Finalize());
       }
 
       // See contexts.h for more information.
-      ASSERT(Context::MIN_CONTEXT_SLOTS == 4);
-      ASSERT(Context::CLOSURE_INDEX == 0);
-      ASSERT(Context::PREVIOUS_INDEX == 1);
-      ASSERT(Context::EXTENSION_INDEX == 2);
-      ASSERT(Context::GLOBAL_OBJECT_INDEX == 3);
+      DCHECK(Context::MIN_CONTEXT_SLOTS == 4);
+      DCHECK(Context::CLOSURE_INDEX == 0);
+      DCHECK(Context::PREVIOUS_INDEX == 1);
+      DCHECK(Context::EXTENSION_INDEX == 2);
+      DCHECK(Context::GLOBAL_OBJECT_INDEX == 3);
       w->WriteULEB128(current_abbreviation++);
       w->WriteString(".closure");
       w->WriteULEB128(current_abbreviation++);
       w->WriteString(".previous");
       w->WriteULEB128(current_abbreviation++);
       w->WriteString(".extension");
       w->WriteULEB128(current_abbreviation++);
       w->WriteString(".global");
 
       for (int context_slot = 0;
@@ skipping 127 matching lines @@
       w->WriteULEB128(DW_AT_LOCATION);
       w->WriteULEB128(DW_FORM_BLOCK4);
     }
     w->WriteULEB128(0);
     w->WriteULEB128(0);
   }
 
   bool WriteBodyInternal(Writer* w) {
     int current_abbreviation = 1;
     bool extra_info = desc_->IsInfoAvailable();
-    ASSERT(desc_->IsLineInfoAvailable());
+    DCHECK(desc_->IsLineInfoAvailable());
     w->WriteULEB128(current_abbreviation++);
     w->WriteULEB128(DW_TAG_COMPILE_UNIT);
     w->Write<uint8_t>(extra_info ? DW_CHILDREN_YES : DW_CHILDREN_NO);
     w->WriteULEB128(DW_AT_NAME);
     w->WriteULEB128(DW_FORM_STRING);
     w->WriteULEB128(DW_AT_LOW_PC);
     w->WriteULEB128(DW_FORM_ADDR);
     w->WriteULEB128(DW_AT_HIGH_PC);
     w->WriteULEB128(DW_FORM_ADDR);
     w->WriteULEB128(DW_AT_STMT_LIST);
@@ skipping 150 matching lines @@
     intptr_t pc = 0;
     intptr_t line = 1;
     bool is_statement = true;
 
     List<LineInfo::PCInfo>* pc_info = desc_->lineinfo()->pc_info();
     pc_info->Sort(&ComparePCInfo);
 
     int pc_info_length = pc_info->length();
     for (int i = 0; i < pc_info_length; i++) {
       LineInfo::PCInfo* info = &pc_info->at(i);
-      ASSERT(info->pc_ >= pc);
+      DCHECK(info->pc_ >= pc);
 
       // Reduce bloating in the debug line table by removing duplicate line
       // entries (per DWARF2 standard).
       intptr_t  new_line = desc_->GetScriptLineNumber(info->pos_);
       if (new_line == line) {
         continue;
       }
 
       // Mark statement boundaries.  For a better debugging experience, mark
       // the last pc address in the function as a statement (e.g. "}"), so that
@@ skipping 149 matching lines @@
                                     Writer::Slot<uint32_t>* length_slot,
                                     int initial_position) {
   uint32_t align = (w->position() - initial_position) % kPointerSize;
 
   if (align != 0) {
     for (uint32_t i = 0; i < (kPointerSize - align); i++) {
       w->Write<uint8_t>(DW_CFA_NOP);
     }
   }
 
-  ASSERT((w->position() - initial_position) % kPointerSize == 0);
+  DCHECK((w->position() - initial_position) % kPointerSize == 0);
   length_slot->set(w->position() - initial_position);
 }
 
 
 UnwindInfoSection::UnwindInfoSection(CodeDescription* desc)
 #ifdef __ELF
     : ELFSection(".eh_frame", TYPE_X86_64_UNWIND, 1),
 #else
     : MachOSection("__eh_frame", "__TEXT", sizeof(uintptr_t),
                    MachOSection::S_REGULAR),
@@ skipping 419 matching lines @@
 
   if (!FLAG_gdbjit_full && !code_desc.IsLineInfoAvailable()) {
     delete lineinfo;
     GetEntries()->Remove(code, HashForCodeObject(code));
     return;
   }
 
   AddUnwindInfo(&code_desc);
   Isolate* isolate = code->GetIsolate();
   JITCodeEntry* entry = CreateELFObject(&code_desc, isolate);
-  ASSERT(!IsLineInfoTagged(entry));
+  DCHECK(!IsLineInfoTagged(entry));
 
   delete lineinfo;
   e->value = entry;
 
   const char* name_hint = NULL;
   bool should_dump = false;
   if (FLAG_gdbjit_dump) {
     if (strlen(FLAG_gdbjit_dump_filter) == 0) {
       name_hint = name;
       should_dump = true;
@@ skipping 40 matching lines @@
   }
 
   for (int i = 0; i < dead_codes.length(); i++) {
     RemoveCode(dead_codes.at(i));
   }
 }
 
 
 static void RegisterDetailedLineInfo(Code* code, LineInfo* line_info) {
   base::LockGuard<base::Mutex> lock_guard(mutex.Pointer());
-  ASSERT(!IsLineInfoTagged(line_info));
+  DCHECK(!IsLineInfoTagged(line_info));
   HashMap::Entry* e = GetEntries()->Lookup(code, HashForCodeObject(code), true);
-  ASSERT(e->value == NULL);
+  DCHECK(e->value == NULL);
   e->value = TagLineInfo(line_info);
 }
 
 
 void GDBJITInterface::EventHandler(const v8::JitCodeEvent* event) {
   if (!FLAG_gdbjit) return;
   switch (event->type) {
     case v8::JitCodeEvent::CODE_ADDED: {
       Code* code = Code::GetCodeFromTargetAddress(
           reinterpret_cast<Address>(event->code_start));
@@ skipping 34 matching lines @@
           reinterpret_cast<Address>(event->code_start));
       RegisterDetailedLineInfo(code, line_info);
       break;
     }
   }
 }
 
 
 } }  // namespace v8::internal
 #endif