Use MemoryChunk-based allocation for deoptimization entry code

src/spaces.h

Index: src/spaces.h
===================================================================
--- src/spaces.h	(revision 13290)
+++ src/spaces.h	(working copy)
@@ -888,7 +888,9 @@
   // 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:
@@ -1039,10 +1041,33 @@
   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,