Revert of Provide a tagged allocation top pointer.

src/heap/spaces.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_HEAP_SPACES_H_
 #define V8_HEAP_SPACES_H_
 
 #include <list>
 
 #include "src/allocation.h"
@@ skipping 1617 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 // A space has a circular list of pages. The next page can be accessed via
 // Page::next_page() call.
 
 // An abstraction of allocation and relocation pointers in a page-structured
 // space.
 class AllocationInfo {
  public:
-  AllocationInfo() { Reset(nullptr, nullptr); }
-  AllocationInfo(Address top, Address limit) { Reset(top, limit); }
+  AllocationInfo() : top_(nullptr), limit_(nullptr) {}
+  AllocationInfo(Address top, Address limit) : top_(top), limit_(limit) {}
 
   void Reset(Address top, Address limit) {
     set_top(top);
     set_limit(limit);
   }
 
-  inline void set_top(Address top) {
-    SLOW_DCHECK((reinterpret_cast<intptr_t>(top) & kHeapObjectTagMask) == 0);
-    top_ = reinterpret_cast<intptr_t>(top) + kHeapObjectTag;
+  INLINE(void set_top(Address top)) {
+    SLOW_DCHECK(top == NULL ||
+                (reinterpret_cast<intptr_t>(top) & kHeapObjectTagMask) == 0);
+    top_ = top;
   }
 
-  inline Address top() const {
-    SLOW_DCHECK((top_ & kHeapObjectTagMask) == kHeapObjectTag);
-    return reinterpret_cast<Address>(top_ - kHeapObjectTag);
+  INLINE(Address top()) const {
+    SLOW_DCHECK(top_ == NULL ||
+                (reinterpret_cast<intptr_t>(top_) & kHeapObjectTagMask) == 0);
+    return top_;
   }
 
-  Address* top_address() { return reinterpret_cast<Address*>(&top_); }
+  Address* top_address() { return &top_; }
 
-  inline void set_limit(Address limit) {
-    limit_ = reinterpret_cast<intptr_t>(limit);
+  INLINE(void set_limit(Address limit)) {
+    limit_ = limit;
   }
 
-  inline Address limit() const { return reinterpret_cast<Address>(limit_); }
+  INLINE(Address limit()) const {
+    return limit_;
+  }
 
-  Address* limit_address() { return reinterpret_cast<Address*>(&limit_); }
+  Address* limit_address() { return &limit_; }
+
+#ifdef DEBUG
+  bool VerifyPagedAllocation() {
+    return (Page::FromAllocationAreaAddress(top_) ==
+            Page::FromAllocationAreaAddress(limit_)) &&
+           (top_ <= limit_);
+  }
+#endif
 
  private:
-  // Current tagged allocation top.
-  intptr_t top_;
-  // Current untagged allocation limit.
-  intptr_t limit_;
+  // Current allocation top.
+  Address top_;
+  // Current allocation limit.
+  Address limit_;
 };
 
 
 // An abstraction of the accounting statistics of a page-structured space.
 //
 // The stats are only set by functions that ensure they stay balanced. These
 // functions increase or decrease one of the non-capacity stats in conjunction
 // with capacity, or else they always balance increases and decreases to the
 // non-capacity stats.
 class AllocationStats BASE_EMBEDDED {
@@ skipping 1448 matching lines @@
     count = 0;
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_H_