Make Win64 compile.

src/mark-compact.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 170 matching lines @@
 
 class MarkingDeque {
  public:
   MarkingDeque()
       : array_(NULL), top_(0), bottom_(0), mask_(0), overflowed_(false) { }
 
   void Initialize(Address low, Address high) {
     HeapObject** obj_low = reinterpret_cast<HeapObject**>(low);
     HeapObject** obj_high = reinterpret_cast<HeapObject**>(high);
     array_ = obj_low;
-    mask_ = RoundDownToPowerOf2(obj_high - obj_low) - 1;
+    mask_ = RoundDownToPowerOf2(static_cast<int>(obj_high - obj_low)) - 1;
     top_ = bottom_ = 0;
     overflowed_ = false;
   }
 
   inline bool IsFull() { return ((top_ + 1) & mask_) == bottom_; }
 
   inline bool IsEmpty() { return top_ == bottom_; }
 
   bool overflowed() const { return overflowed_; }
 
@@ skipping 39 matching lines @@
     if (IsFull()) {
       ASSERT(Marking::IsGrey(Marking::MarkBitFrom(object)));
       SetOverflowed();
     } else {
       bottom_ = ((bottom_ - 1) & mask_);
       array_[bottom_] = object;
     }
   }
 
   HeapObject** array() { return array_; }
-  intptr_t bottom() { return bottom_; }
-  intptr_t top() { return top_; }
-  intptr_t mask() { return mask_; }
-  void set_top(intptr_t top) { top_ = top; }
+  int bottom() { return bottom_; }
+  int top() { return top_; }
+  int mask() { return mask_; }
+  void set_top(int top) { top_ = top; }
 
  private:
   HeapObject** array_;
   // array_[(top - 1) & mask_] is the top element in the deque.  The Deque is
   // empty when top_ == bottom_.  It is full when top_ + 1 == bottom
   // (mod mask + 1).
   int top_;
   int bottom_;
   int mask_;
   bool overflowed_;
@@ skipping 29 matching lines @@
     ASSERT(0 <= idx_ && idx_ < kNumberOfElements);
     slots_[idx_++] = slot;
   }
 
   void UpdateSlots();
 
   SlotsBuffer* next() { return next_; }
 
   static int SizeOfChain(SlotsBuffer* buffer) {
     if (buffer == NULL) return 0;
-    return buffer->idx_ + (buffer->chain_length_ - 1) * kNumberOfElements;
+    return static_cast<int>(buffer->idx_ +
+                            (buffer->chain_length_ - 1) * kNumberOfElements);
   }
 
   inline bool IsFull() {
     return idx_ == kNumberOfElements;
   }
 
   static void UpdateSlotsRecordedIn(SlotsBuffer* buffer) {
     while (buffer != NULL) {
       buffer->UpdateSlots();
       buffer = buffer->next();
@@ skipping 119 matching lines @@
   void EnableCodeFlushing(bool enable);
 
   enum SweeperType {
     CONSERVATIVE,
     LAZY_CONSERVATIVE,
     PRECISE
   };
 
   // Sweep a single page from the given space conservatively.
   // Return a number of reclaimed bytes.
-  static int SweepConservatively(PagedSpace* space, Page* p);
+  static intptr_t SweepConservatively(PagedSpace* space, Page* p);
 
   INLINE(static bool ShouldSkipEvacuationSlotRecording(Object** anchor)) {
     return Page::FromAddress(reinterpret_cast<Address>(anchor))->
         ShouldSkipEvacuationSlotRecording();
   }
 
   INLINE(static bool IsOnEvacuationCandidate(Object* obj)) {
     return Page::FromAddress(reinterpret_cast<Address>(obj))->
         IsEvacuationCandidate();
   }
@@ skipping 252 matching lines @@
 
   List<Page*> evacuation_candidates_;
 
   friend class Heap;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_