Make Win64 compile.

src/incremental-marking.cc

 // 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 379 matching lines @@
 
   RecordWriteStub::Mode mode = is_compacting_ ?
       RecordWriteStub::INCREMENTAL_COMPACTION : RecordWriteStub::INCREMENTAL;
 
   PatchIncrementalMarkingRecordWriteStubs(heap_, mode);
 
   EnsureMarkingDequeIsCommitted();
 
   // Initialize marking stack.
   Address addr = static_cast<Address>(marking_deque_memory_->address());
-  int size = marking_deque_memory_->size();
+  size_t size = marking_deque_memory_->size();
   if (FLAG_force_marking_deque_overflows) size = 64 * kPointerSize;
   marking_deque_.Initialize(addr, addr + size);
 
   // Clear markbits.
   ClearMarkbits();
 
 #ifdef DEBUG
   VerifyMarkbitsAreClean();
 #endif
 
@@ skipping 14 matching lines @@
                           heap_->new_space()->FromSpaceEnd());
   while (it.has_next()) {
     Bitmap::Clear(it.next());
   }
 }
 
 
 void IncrementalMarking::UpdateMarkingDequeAfterScavenge() {
   if (!IsMarking()) return;
 
   intptr_t current = marking_deque_.bottom();

[Erik Corry, 2011/07/15 21:37:33]

I think making all these int instead of intptr_t should obviate the need for the
static cast below.

[Lasse Reichstein, 2011/08/01 12:40:33]

True, there is no need for intptr_t-ness here.

   intptr_t mask = marking_deque_.mask();
   intptr_t limit = marking_deque_.top();
   HeapObject** array = marking_deque_.array();
   intptr_t new_top = current;
 
   Map* filler_map = heap_->one_pointer_filler_map();
 
   while (current != limit) {
     HeapObject* obj = array[current];
     ASSERT(obj->IsHeapObject());
     current = ((current + 1) & mask);
     if (heap_->InNewSpace(obj)) {
       MapWord map_word = obj->map_word();
       if (map_word.IsForwardingAddress()) {
         HeapObject* dest = map_word.ToForwardingAddress();
         array[new_top] = dest;
         new_top = ((new_top + 1) & mask);
         ASSERT(new_top != marking_deque_.bottom());
         ASSERT(Marking::IsGrey(Marking::MarkBitFrom(obj)));
       }
     } else if (obj->map() != filler_map) {
       // Skip one word filler objects that appear on the
       // stack when we perform in place array shift.
       array[new_top] = obj;
       new_top = ((new_top + 1) & mask);
       ASSERT(new_top != marking_deque_.bottom());
       ASSERT(Marking::IsGrey(Marking::MarkBitFrom(obj)));
     }
   }
-  marking_deque_.set_top(new_top);
+  marking_deque_.set_top(static_cast<int>(new_top));
 
   steps_took_since_last_gc_ = 0;
   steps_count_since_last_gc_ = 0;
 }
 
 
 void IncrementalMarking::Hurry() {
   if (state() == MARKING) {
     double start = 0.0;
     if (FLAG_trace_incremental_marking) {
@@ skipping 146 matching lines @@
   if (FLAG_trace_incremental_marking || FLAG_trace_gc) {
     double end = OS::TimeCurrentMillis();
     double delta = (end - start);
     steps_took_ += delta;
     steps_took_since_last_gc_ += delta;
   }
 }
 
 
 } }  // namespace v8::internal