Add support for enabling DCHECKs in release mode

src/x64/full-codegen-x64.cc

 // 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.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_X64
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
 #include "src/compiler.h"
 #include "src/debug.h"
 #include "src/full-codegen.h"
 #include "src/ic/ic.h"
 #include "src/isolate-inl.h"
 #include "src/parser.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm_)
 
 
 class JumpPatchSite BASE_EMBEDDED {
  public:
   explicit JumpPatchSite(MacroAssembler* masm) : masm_(masm) {
-#ifdef DEBUG
+#if DCHECK_IS_ON
     info_emitted_ = false;
 #endif
   }
 
   ~JumpPatchSite() {
     DCHECK(patch_site_.is_bound() == info_emitted_);
   }
 
   void EmitJumpIfNotSmi(Register reg,
                         Label* target,
                         Label::Distance near_jump = Label::kFar) {
     __ testb(reg, Immediate(kSmiTagMask));
     EmitJump(not_carry, target, near_jump);   // Always taken before patched.
   }
 
   void EmitJumpIfSmi(Register reg,
                      Label* target,
                      Label::Distance near_jump = Label::kFar) {
     __ testb(reg, Immediate(kSmiTagMask));
     EmitJump(carry, target, near_jump);  // Never taken before patched.
   }
 
   void EmitPatchInfo() {
     if (patch_site_.is_bound()) {
       int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(&patch_site_);
       DCHECK(is_uint8(delta_to_patch_site));
       __ testl(rax, Immediate(delta_to_patch_site));
-#ifdef DEBUG
+#if DCHECK_IS_ON
       info_emitted_ = true;
 #endif
     } else {
       __ nop();  // Signals no inlined code.
     }
   }
 
  private:
   // jc will be patched with jz, jnc will become jnz.
   void EmitJump(Condition cc, Label* target, Label::Distance near_jump) {
     DCHECK(!patch_site_.is_bound() && !info_emitted_);
     DCHECK(cc == carry || cc == not_carry);
     __ bind(&patch_site_);
     __ j(cc, target, near_jump);
   }
 
   MacroAssembler* masm_;
   Label patch_site_;
-#ifdef DEBUG
+#if DCHECK_IS_ON
   bool info_emitted_;
 #endif
 };
 
 
 // Generate code for a JS function.  On entry to the function the receiver
 // and arguments have been pushed on the stack left to right, with the
 // return address on top of them.  The actual argument count matches the
 // formal parameter count expected by the function.
 //
@@ skipping 309 matching lines @@
     }
     EmitProfilingCounterDecrement(weight);
     Label ok;
     __ j(positive, &ok, Label::kNear);
     __ Push(rax);
     __ call(isolate()->builtins()->InterruptCheck(),
             RelocInfo::CODE_TARGET);
     __ Pop(rax);
     EmitProfilingCounterReset();
     __ bind(&ok);
-#ifdef DEBUG
+#if DCHECK_IS_ON
     // Add a label for checking the size of the code used for returning.
     Label check_exit_codesize;
     masm_->bind(&check_exit_codesize);
 #endif
     CodeGenerator::RecordPositions(masm_, function()->end_position() - 1);
     __ RecordJSReturn();
     // Do not use the leave instruction here because it is too short to
     // patch with the code required by the debugger.
     __ movp(rsp, rbp);
     __ popq(rbp);
@@ skipping 4699 matching lines @@
   return previous_;
 }
 
 
 #undef __
 
 
 static const byte kJnsInstruction = 0x79;
 static const byte kNopByteOne = 0x66;
 static const byte kNopByteTwo = 0x90;
-#ifdef DEBUG
+#if DCHECK_IS_ON
 static const byte kCallInstruction = 0xe8;
 #endif
 
 
 void BackEdgeTable::PatchAt(Code* unoptimized_code,
                             Address pc,
                             BackEdgeState target_state,
                             Code* replacement_code) {
   Address call_target_address = pc - kIntSize;
   Address jns_instr_address = call_target_address - 3;
@@ skipping 56 matching lines @@
   DCHECK_EQ(isolate->builtins()->OsrAfterStackCheck()->entry(),
             Assembler::target_address_at(call_target_address,
                                          unoptimized_code));
   return OSR_AFTER_STACK_CHECK;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64