graal-jvmci-8: src/os/windows/vm/os

comparison src/os/windows/vm/os_windows.cpp @ 656:6bdd6923ba16

6541756: Reduce executable C-heap Summary: Add executable parameters to reserve_memory and commit_memory to reduce executable memory to only the Code Heap. Reviewed-by: xlu, kvn, acorn

author	coleenp
date	Wed, 25 Mar 2009 14:19:20 -0400
parents	bd441136a5ce
children	956304450e80

comparison

equal deleted inserted replaced

-:60bfce711da4
+:6bdd6923ba16
 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
 address addr = (address) exceptionRecord->ExceptionInformation[1];
 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
 addr = (address)((uintptr_t)addr &
 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
-os::commit_memory( (char *)addr, thread->stack_base() - addr );
+os::commit_memory((char *)addr, thread->stack_base() - addr,
+false );
 return EXCEPTION_CONTINUE_EXECUTION;
 }
 else
 #endif
 {
 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
 assert((size_t)addr % os::vm_allocation_granularity() == 0,
 "reserve alignment");
 assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
-char* res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE,
+char* res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
-PAGE_EXECUTE_READWRITE);
 assert(res == NULL || addr == NULL || addr == res,
 "Unexpected address from reserve.");
 return res;
 }
 bool os::can_execute_large_page_memory() {
 return true;
 }
-char* os::reserve_memory_special(size_t bytes, char* addr) {
+char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) {
 if (UseLargePagesIndividualAllocation) {
 if (TracePageSizes && Verbose) {
 tty->print_cr("Reserving large pages individually.");
 }
 return NULL;
 }
 p_buf = (char *) VirtualAlloc(addr,
 size_of_reserve,  // size of Reserve
 MEM_RESERVE,
-PAGE_EXECUTE_READWRITE);
+PAGE_READWRITE);
 // If reservation failed, return NULL
 if (p_buf == NULL) return NULL;
 release_memory(p_buf, bytes + _large_page_size);
 // round up to page boundary.  If the size_of_reserve did not
 p_new = NULL;
 } else {
 p_new = (char *) VirtualAlloc(next_alloc_addr,
 bytes_to_rq,
 MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES,
-PAGE_EXECUTE_READWRITE);
+PAGE_READWRITE);
+if (p_new != NULL && exec) {
+DWORD oldprot;
+// Windows doc says to use VirtualProtect to get execute permissions
+VirtualProtect(next_alloc_addr, bytes_to_rq,
+PAGE_EXECUTE_READWRITE, &oldprot);
+}
 }
 if (p_new == NULL) {
 // Free any allocated pages
 if (next_alloc_addr > p_buf) {
 return p_buf;
 } else {
 // normal policy just allocate it all at once
 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
-char * res = (char *)VirtualAlloc(NULL,
+char * res = (char *)VirtualAlloc(NULL, bytes, flag, PAGE_READWRITE);
-bytes,
+if (res != NULL && exec) {
-flag,
+DWORD oldprot;
-PAGE_EXECUTE_READWRITE);
+// Windows doc says to use VirtualProtect to get execute permissions
+VirtualProtect(res, bytes, PAGE_EXECUTE_READWRITE, &oldprot);
+}
 return res;
 }
 }
 bool os::release_memory_special(char* base, size_t bytes) {
 }
 void os::print_statistics() {
 }
-bool os::commit_memory(char* addr, size_t bytes) {
+bool os::commit_memory(char* addr, size_t bytes, bool exec) {
 if (bytes == 0) {
 // Don't bother the OS with noops.
 return true;
 }
 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
 // Don't attempt to print anything if the OS call fails. We're
 // probably low on resources, so the print itself may cause crashes.
-return VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_EXECUTE_READWRITE) != NULL;
+bool result = VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) != 0;
-}
+if (result != NULL && exec) {
+DWORD oldprot;
-bool os::commit_memory(char* addr, size_t size, size_t alignment_hint) {
+// Windows doc says to use VirtualProtect to get execute permissions
-return commit_memory(addr, size);
+return VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot) != 0;
+} else {
+return result;
+}
+}
+bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
+bool exec) {
+return commit_memory(addr, size, exec);
 }
 bool os::uncommit_memory(char* addr, size_t bytes) {
 if (bytes == 0) {
 // Don't bother the OS with noops.
 DWORD old_status;
 // Strange enough, but on Win32 one can change protection only for committed
 // memory, not a big deal anyway, as bytes less or equal than 64K
-if (!is_committed && !commit_memory(addr, bytes)) {
+if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) {
 fatal("cannot commit protection page");
 }
 // One cannot use os::guard_memory() here, as on Win32 guard page
 // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
 //
 if( Verbose && PrintMiscellaneous )
 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
 #endif
 if (!UseMembar) {
-address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
 guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
-return_page  = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+return_page  = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
 guarantee( return_page != NULL, "Commit Failed for memory serialize page");
 os::set_memory_serialize_page( mem_serialize_page );
 #ifndef PRODUCT

Mercurial > hg > graal-jvmci-8

comparison src/os/windows/vm/os_windows.cpp @ 656:6bdd6923ba16