Add guard pages in front of platform allocations

src/spaces.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 362 matching lines @@
       LOG(isolate_,
           StringEvent("MemoryAllocator::AllocateRawMemory",
                       "V8 Executable Allocation capacity exceeded"));
       return NULL;
     }
     // Allocate executable memory either from code range or from the
     // OS.
     if (isolate_->code_range()->exists()) {
       mem = isolate_->code_range()->AllocateRawMemory(requested, allocated);
     } else {
+#ifdef ENABLE_HEAP_PROTECTION
+      mem = OS::Allocate(requested + Page::kPageSize, allocated, true);
+      OS::Guard(mem, Page::kPageSize);
+      *allocated -= Page::kPageSize;
+      mem = static_cast<char*>(mem) + Page::kPageSize;
+#else  // ENABLE_HEAP_PROTECTION
       mem = OS::Allocate(requested, allocated, true);
+#endif  // ENABLE_HEAP_PROTECTION
     }
     // Update executable memory size.
     size_executable_ += static_cast<int>(*allocated);
   } else {
     mem = OS::Allocate(requested, allocated, false);
   }
   int alloced = static_cast<int>(*allocated);
   size_ += alloced;
 
 #ifdef DEBUG
   ZapBlock(reinterpret_cast<Address>(mem), alloced);
 #endif
   isolate_->counters()->memory_allocated()->Increment(alloced);
   return mem;
 }
 
 
 void MemoryAllocator::FreeRawMemory(void* mem,
                                     size_t length,
                                     Executability executable) {
 #ifdef DEBUG
   ZapBlock(reinterpret_cast<Address>(mem), length);
 #endif
   if (isolate_->code_range()->contains(static_cast<Address>(mem))) {
     isolate_->code_range()->FreeRawMemory(mem, length);
   } else {
-    OS::Free(mem, length);
+#ifdef ENABLE_HEAP_PROTECTION
+    size_t guardsize = (executable == EXECUTABLE) ? Page::kPageSize : 0;
+    OS::Free(static_cast<char*>(mem) - guardsize, length + guardsize);
+#else  // ENABLE_HEAP_PROTECTION
+    OS::Free(static_cast<char*>(mem), length);
+#endif  // ENABLE_HEAP_PROTECTION
   }
   isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(length));
   size_ -= static_cast<int>(length);
   if (executable == EXECUTABLE) size_executable_ -= static_cast<int>(length);
 
   ASSERT(size_ >= 0);
   ASSERT(size_executable_ >= 0);
 }
 
 
@@ skipping 2715 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal