Add support for enabling DCHECKs in release mode

src/handles.h

 // Copyright 2011 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_HANDLES_H_
 #define V8_HANDLES_H_
 
 #include "src/objects.h"
 
 namespace v8 {
@@ skipping 110 matching lines @@
 
   // TODO(yangguo): Values that contain empty handles should be declared as
   // MaybeHandle to force validation before being used as handles.
   static Handle<T> null() { return Handle<T>(); }
   bool is_null() const { return location_ == NULL; }
 
   // Closes the given scope, but lets this handle escape. See
   // implementation in api.h.
   inline Handle<T> EscapeFrom(v8::EscapableHandleScope* scope);
 
-#ifdef DEBUG
+#ifdef ENABLE_SLOW_DCHECKS
   enum DereferenceCheckMode { INCLUDE_DEFERRED_CHECK, NO_DEFERRED_CHECK };
 
   bool IsDereferenceAllowed(DereferenceCheckMode mode) const;
-#endif  // DEBUG
+#endif  // ENABLE_SLOW_DCHECKS
 
  private:
   T** location_;
 
   // Handles of different classes are allowed to access each other's location_.
   template<class S> friend class Handle;
 };
 
 
 // Convenience wrapper.
@@ skipping 103 matching lines @@
   // since the creation of this DeferredHandleScope.  The Handles are
   // alive as long as the DeferredHandles object is alive.
   DeferredHandles* Detach();
   ~DeferredHandleScope();
 
  private:
   Object** prev_limit_;
   Object** prev_next_;
   HandleScopeImplementer* impl_;
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   bool handles_detached_;
   int prev_level_;
 #endif
 
   friend class HandleScopeImplementer;
 };
 
 
 // Seal off the current HandleScope so that new handles can only be created
 // if a new HandleScope is entered.
@@ skipping 19 matching lines @@
 
   void Initialize() {
     next = limit = NULL;
     level = 0;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_HANDLES_H_