Use MemoryChunk-based allocation for deoptimization entry code

src/spaces.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 870 matching lines @@
   bool contains(Address address) {
     if (this == NULL || code_range_ == NULL) return false;
     Address start = static_cast<Address>(code_range_->address());
     return start <= address && address < start + code_range_->size();
   }
 
   // Allocates a chunk of memory from the large-object portion of
   // the code range.  On platforms with no separate code range, should
   // not be called.
   MUST_USE_RESULT Address AllocateRawMemory(const size_t requested,
-                                            size_t* allocated);
+                                            size_t* allocated,
+                                            bool commit = true);

[danno, 2013/01/15 09:41:18]

Please add an enum for this new flag so that it's clear from the caller site
what the flag does, e.g.

enum AllocateRawMemoryCommitMode {
  RESERVE_MEMORY
  RESERVE_AND_COMMIT_MEMORY,
}

+  bool CommitRawMemory(Address start, size_t size);
   void FreeRawMemory(Address buf, size_t length);
 
  private:
   Isolate* isolate_;
 
   // The reserved range of virtual memory that all code objects are put in.
   VirtualMemory* code_range_;
   // Plain old data class, just a struct plus a constructor.
   class FreeBlock {
    public:
@@ skipping 130 matching lines @@
   }
 
 #ifdef DEBUG
   // Reports statistic info of the space.
   void ReportStatistics();
 #endif
 
   MemoryChunk* AllocateChunk(intptr_t body_size,
                              Executability executable,
                              Space* space);
+  Address ReserveChunk(size_t requested,

[danno, 2013/01/15 09:41:18]

I have a fundamental concern with the increase in size to the API here, which
doesn't seem necessary, and seems to expose the same functionality in multiple
ways. ReserveAlignedMemory, CommitAlignedMemory and AllocateAlignedMemory are
fine. But is it necessary to add all the calls associated with MemoryChunk? 

Instead of all of these new "public" APIs, how about just adding a parameter to
AllocateChunk called "initial_commit_size". Then add a method on the MemoryChunk
itself to change the committed amount on a pre-existing chunk?

+                       Executability executable,
+                       VirtualMemory* controller);
+  Address ReserveChunk(size_t requested, size_t* reserved);
+  MemoryChunk* CommitChunkShared(Heap* heap,
+                                 Address base,
+                                 size_t chunk_size,
+                                 Address area_start,
+                                 Address area_end,
+                                 Executability executable,
+                                 Space* owner,
+                                 VirtualMemory* reservation);
+  MemoryChunk* CommitChunk(size_t body_size,
+                           Executability executable,
+                           VirtualMemory* reservation,
+                           Space* owner);
+  MemoryChunk* CommitChunk(size_t body_size,
+                           Address base,
+                           size_t chunk_size,
+                           Space* owner);
 
   Address ReserveAlignedMemory(size_t requested,
                                size_t alignment,
+                               Executability executable,
                                VirtualMemory* controller);
+  Address CommitAlignedMemory(VirtualMemory* controller,
+                              Executability executable);
   Address AllocateAlignedMemory(size_t requested,
                                 size_t alignment,
                                 Executability executable,
                                 VirtualMemory* controller);
 
   void FreeMemory(VirtualMemory* reservation, Executability executable);
   void FreeMemory(Address addr, size_t size, Executability executable);
 
   // Commit a contiguous block of memory from the initial chunk.  Assumes that
   // the address is not NULL, the size is greater than zero, and that the
@@ skipping 1707 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_