Make Win64 compile.

src/heap.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 4974 matching lines @@
 
   // Initialize heap spaces and initial maps and objects. Whenever something
   // goes wrong, just return false. The caller should check the results and
   // call Heap::TearDown() to release allocated memory.
   //
   // If the heap is not yet configured (eg, through the API), configure it.
   // Configuration is based on the flags new-space-size (really the semispace
   // size) and old-space-size if set or the initial values of semispace_size_
   // and old_generation_size_ otherwise.
   if (!configured_) {
-    if (!ConfigureHeapDefault()) return false;
+    if (!ConfigureHeapDefault()) {

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

This looks like an unnecessary change.

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

Added to allow a breakpoint at the return.
It's a simple change, so anyone needing it can reintroduce it, so I'll can
revert it again.
In fact, I'll revert the entire file.

+      return false;
+    }
   }
 
   gc_initializer_mutex->Lock();
   static bool initialized_gc = false;
   if (!initialized_gc) {
       initialized_gc = true;
       InitializeScavengingVisitorsTables();
       NewSpaceScavenger::Initialize();
       MarkCompactCollector::Initialize();
   }
   gc_initializer_mutex->Unlock();
 
   MarkMapPointersAsEncoded(false);
 
   // Setup memory allocator.
-  if (!isolate_->memory_allocator()->Setup(MaxReserved(), MaxExecutableSize()))
-      return false;
+  if (!isolate_->memory_allocator()->
+          Setup(MaxReserved(), MaxExecutableSize())) {
+    return false;
+  }
 
   // Setup new space.
   if (!new_space_.Setup(reserved_semispace_size_)) {
     return false;
   }
 
   // Initialize old pointer space.
   old_pointer_space_ =
       new OldSpace(this,
                    max_old_generation_size_,
                    OLD_POINTER_SPACE,
                    NOT_EXECUTABLE);
-  if (old_pointer_space_ == NULL) return false;
-  if (!old_pointer_space_->Setup()) return false;
+  if (old_pointer_space_ == NULL || !old_pointer_space_->Setup()) {
+    return false;
+  }
 
   // Initialize old data space.
   old_data_space_ =
       new OldSpace(this,
                    max_old_generation_size_,
                    OLD_DATA_SPACE,
                    NOT_EXECUTABLE);
-  if (old_data_space_ == NULL) return false;
-  if (!old_data_space_->Setup()) return false;
+  if (old_data_space_ == NULL || !old_data_space_->Setup()) {
+    return false;
+  }
 
   // Initialize the code space, set its maximum capacity to the old
   // generation size. It needs executable memory.
   // On 64-bit platform(s), we put all code objects in a 2 GB range of
   // virtual address space, so that they can call each other with near calls.
   if (code_range_size_ > 0) {
     if (!isolate_->code_range()->Setup(code_range_size_)) {
       return false;
     }
   }
 
   code_space_ =
       new OldSpace(this, max_old_generation_size_, CODE_SPACE, EXECUTABLE);
-  if (code_space_ == NULL) return false;
-  if (!code_space_->Setup()) return false;
+  if (code_space_ == NULL || !code_space_->Setup()) {

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

These all fit on one line.

+    return false;
+  }
 
   // Initialize map space.
   map_space_ = new MapSpace(this,
                             max_old_generation_size_,
                             FLAG_max_map_space_pages,
                             MAP_SPACE);
-  if (map_space_ == NULL) return false;
-  if (!map_space_->Setup()) return false;
+  if (map_space_ == NULL || !map_space_->Setup()) {
+    return false;
+  }
 
   // Initialize global property cell space.
   cell_space_ = new CellSpace(this, max_old_generation_size_, CELL_SPACE);
-  if (cell_space_ == NULL) return false;
-  if (!cell_space_->Setup()) return false;
+  if (cell_space_ == NULL || !cell_space_->Setup()) {
+    return false;
+  }
 
   // The large object code space may contain code or data.  We set the memory
   // to be non-executable here for safety, but this means we need to enable it
   // explicitly when allocating large code objects.
   lo_space_ = new LargeObjectSpace(this, LO_SPACE);
-  if (lo_space_ == NULL) return false;
-  if (!lo_space_->Setup()) return false;
+  if (lo_space_ == NULL || !lo_space_->Setup()) {
+    return false;
+  }
   if (create_heap_objects) {
     // Create initial maps.
-    if (!CreateInitialMaps()) return false;
-    if (!CreateApiObjects()) return false;
+    if (!CreateInitialMaps()) {
+          return false;
+    }
+    if (!CreateApiObjects()) {
+      return false;
+    }
 
     // Create initial objects
-    if (!CreateInitialObjects()) return false;
+    if (!CreateInitialObjects()) {
+      return false;
+    }
 
     global_contexts_list_ = undefined_value();
   }
 
   LOG(isolate_, IntPtrTEvent("heap-capacity", Capacity()));
   LOG(isolate_, IntPtrTEvent("heap-available", Available()));
 
   store_buffer()->Setup();
 
   return true;
 }
 
 
 void Heap::SetStackLimits() {
   ASSERT(isolate_ != NULL);
-  ASSERT(isolate_ == isolate());
+  CHECK_EQ(isolate_, isolate());

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

This should probably have been ASSERT_EQ.

   // On 64 bit machines, pointers are generally out of range of Smis.  We write
   // something that looks like an out of range Smi to the GC.
 
   // Set up the special root array entries containing the stack limits.
   // These are actually addresses, but the tag makes the GC ignore it.
   roots_[kStackLimitRootIndex] =
       reinterpret_cast<Object*>(
           (isolate_->stack_guard()->jslimit() & ~kSmiTagMask) | kSmiTag);
   roots_[kRealStackLimitRootIndex] =
       reinterpret_cast<Object*>(
@@ skipping 899 matching lines @@
   }
   isolate_->heap()->store_buffer()->Filter(MemoryChunk::ABOUT_TO_BE_FREED);
   for (chunk = chunks_queued_for_free_; chunk != NULL; chunk = next) {
     next = chunk->next_chunk();
     isolate_->memory_allocator()->Free(chunk);
   }
   chunks_queued_for_free_ = NULL;
 }
 
 } }  // namespace v8::internal