graal-compiler: src/os/windows/vm/os

comparison src/os/windows/vm/os_windows.cpp @ 11173:6b0fd0964b87

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 31 Jul 2013 11:00:54 +0200
parents	836a62f43af9 af21010d1062
children	3cce976666d9

comparison

equal deleted inserted replaced

-:4ea54634f03e
+:6b0fd0964b87
 return 0;
 }
 bool os::dll_address_to_library_name(address addr, char* buf,
 int buflen, int* offset) {
+// buf is not optional, but offset is optional
+assert(buf != NULL, "sanity check");
 // NOTE: the reason we don't use SymGetModuleInfo() is it doesn't always
 //       return the full path to the DLL file, sometimes it returns path
 //       to the corresponding PDB file (debug info); sometimes it only
 //       returns partial path, which makes life painful.
 struct _modinfo mi;
 mi.addr      = addr;
 mi.full_path = buf;
 mi.buflen    = buflen;
 int pid = os::current_process_id();
 if (enumerate_modules(pid, _locate_module_by_addr, (void *)&mi)) {
 // buf already contains path name
 if (offset) *offset = addr - mi.base_addr;
 return true;
-} else {
+}
-if (buf) buf[0] = '\0';
-if (offset) *offset = -1;
+buf[0] = '\0';
-return false;
+if (offset) *offset = -1;
-}
+return false;
 }
 bool os::dll_address_to_function_name(address addr, char *buf,
 int buflen, int *offset) {
+// buf is not optional, but offset is optional
+assert(buf != NULL, "sanity check");
 if (Decoder::decode(addr, buf, buflen, offset)) {
 return true;
 }
 if (offset != NULL)  *offset  = -1;
-if (buf != NULL) buf[0] = '\0';
+buf[0] = '\0';
 return false;
 }
 // save the start and end address of jvm.dll into param[0] and param[1]
 static int _locate_jvm_dll(int pid, char* mod_fname, address base_addr,
 address pc = (address) exceptionInfo->ContextRecord->Rip;
 #else
 address pc = (address) exceptionInfo->ContextRecord->Eip;
 #endif
 Thread* t = ThreadLocalStorage::get_thread_slow();          // slow & steady
+// Handle SafeFetch32 and SafeFetchN exceptions.
+if (StubRoutines::is_safefetch_fault(pc)) {
+return Handle_Exception(exceptionInfo, StubRoutines::continuation_for_safefetch_fault(pc));
+}
 #ifndef _WIN64
 // Execution protection violation - win32 running on AMD64 only
 // Handled first to avoid misdiagnosis as a "normal" access violation;
 // This is safe to do because we have a new/unique ExceptionInformation
 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,
-false );
+!ExecMem);
 return EXCEPTION_CONTINUE_EXECUTION;
 }
 else
 #endif
 {
 }
 return (address)-1;
 }
 #endif
+#ifndef PRODUCT
+void os::win32::call_test_func_with_wrapper(void (*funcPtr)(void)) {
+// Install a win32 structured exception handler around the test
+// function call so the VM can generate an error dump if needed.
+__try {
+(*funcPtr)();
+} __except(topLevelExceptionFilter(
+(_EXCEPTION_POINTERS*)_exception_info())) {
+// Nothing to do.
+}
+}
+#endif
 // Virtual Memory
 int os::vm_page_size() { return os::win32::vm_page_size(); }
 int os::vm_allocation_granularity() {
 return os::win32::vm_allocation_granularity();
 size_of_reserve,  // size of Reserve
 MEM_RESERVE,
 PAGE_READWRITE);
 // If reservation failed, return NULL
 if (p_buf == NULL) return NULL;
-MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC);
+MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, mtNone, CALLER_PC);
 os::release_memory(p_buf, bytes + chunk_size);
 // we still need to round up to a page boundary (in case we are using large pages)
 // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
 // instead we handle this in the bytes_to_rq computation below
 size_t bytes_to_release = bytes - bytes_remaining;
 // NMT has yet to record any individual blocks, so it
 // need to create a dummy 'reserve' record to match
 // the release.
 MemTracker::record_virtual_memory_reserve((address)p_buf,
-bytes_to_release, CALLER_PC);
+bytes_to_release, mtNone, CALLER_PC);
 os::release_memory(p_buf, bytes_to_release);
 }
 #ifdef ASSERT
 if (should_inject_error) {
 if (TracePageSizes && Verbose) {
 count++;
 }
 // Although the memory is allocated individually, it is returned as one.
 // NMT records it as one block.
 address pc = CALLER_PC;
-MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, pc);
 if ((flags & MEM_COMMIT) != 0) {
-MemTracker::record_virtual_memory_commit((address)p_buf, bytes, pc);
+MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, mtNone, pc);
+} else {
+MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, mtNone, pc);
 }
 // made it this far, success
 return p_buf;
 }
 // normal policy just allocate it all at once
 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
 char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
 if (res != NULL) {
 address pc = CALLER_PC;
-MemTracker::record_virtual_memory_reserve((address)res, bytes, pc);
+MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, mtNone, pc);
-MemTracker::record_virtual_memory_commit((address)res, bytes, pc);
 }
 return res;
 }
 }
 bool os::release_memory_special(char* base, size_t bytes) {
 assert(base != NULL, "Sanity check");
-// Memory allocated via reserve_memory_special() is committed
-MemTracker::record_virtual_memory_uncommit((address)base, bytes);
 return release_memory(base, bytes);
 }
 void os::print_statistics() {
+}
+static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec) {
+int err = os::get_last_error();
+char buf[256];
+size_t buf_len = os::lasterror(buf, sizeof(buf));
+warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
+", %d) failed; error='%s' (DOS error/errno=%d)", addr, bytes,
+exec, buf_len != 0 ? buf : "<no_error_string>", err);
 }
 bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
 if (bytes == 0) {
 // Don't bother the OS with noops.
 // unless we have NUMAInterleaving enabled, the range of a commit
 // is always within a reserve covered by a single VirtualAlloc
 // in that case we can just do a single commit for the requested size
 if (!UseNUMAInterleaving) {
-if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) return false;
+if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) {
+NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
+return false;
+}
 if (exec) {
 DWORD oldprot;
 // Windows doc says to use VirtualProtect to get execute permissions
-if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) return false;
+if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) {
+NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
+return false;
+}
 }
 return true;
 } else {
 // when NUMAInterleaving is enabled, the commit might cover a range that
 char * next_alloc_addr = addr;
 while (bytes_remaining > 0) {
 MEMORY_BASIC_INFORMATION alloc_info;
 VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
 size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
-if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT, PAGE_READWRITE) == NULL)
+if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT,
+PAGE_READWRITE) == NULL) {
+NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
+exec);)
 return false;
+}
 if (exec) {
 DWORD oldprot;
-if (!VirtualProtect(next_alloc_addr, bytes_to_rq, PAGE_EXECUTE_READWRITE, &oldprot))
+if (!VirtualProtect(next_alloc_addr, bytes_to_rq,
+PAGE_EXECUTE_READWRITE, &oldprot)) {
+NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
+exec);)
 return false;
+}
 }
 bytes_remaining -= bytes_to_rq;
 next_alloc_addr += bytes_to_rq;
 }
 }
 return true;
 }
 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
 bool exec) {
-return commit_memory(addr, size, exec);
+// alignment_hint is ignored on this OS
+return pd_commit_memory(addr, size, exec);
+}
+void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
+const char* mesg) {
+assert(mesg != NULL, "mesg must be specified");
+if (!pd_commit_memory(addr, size, exec)) {
+warn_fail_commit_memory(addr, size, exec);
+vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
+}
+}
+void os::pd_commit_memory_or_exit(char* addr, size_t size,
+size_t alignment_hint, bool exec,
+const char* mesg) {
+// alignment_hint is ignored on this OS
+pd_commit_memory_or_exit(addr, size, exec, mesg);
 }
 bool os::pd_uncommit_memory(char* addr, size_t bytes) {
 if (bytes == 0) {
 // Don't bother the OS with noops.
 bool os::pd_release_memory(char* addr, size_t bytes) {
 return VirtualFree(addr, 0, MEM_RELEASE) != 0;
 }
 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
-return os::commit_memory(addr, size);
+return os::commit_memory(addr, size, !ExecMem);
 }
 bool os::remove_stack_guard_pages(char* addr, size_t size) {
 return os::uncommit_memory(addr, size);
 }
 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, prot == MEM_PROT_RWX)) {
+if (!is_committed) {
-fatal("cannot commit protection page");
+commit_memory_or_exit(addr, bytes, prot == MEM_PROT_RWX,
+"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:
 //
 // Pages in the region become guard pages. Any attempt to access a guard page
 }
 } else {
 jio_fprintf(stderr,
 "Could not open pause file '%s', continuing immediately.\n", filename);
 }
+}
+os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
+assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
+}
+/*
+* See the caveats for this class in os_windows.hpp
+* Protects the callback call so that raised OS EXCEPTIONS causes a jump back
+* into this method and returns false. If no OS EXCEPTION was raised, returns
+* true.
+* The callback is supposed to provide the method that should be protected.
+*/
+bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
+assert(Thread::current()->is_Watcher_thread(), "Only for WatcherThread");
+assert(!WatcherThread::watcher_thread()->has_crash_protection(),
+"crash_protection already set?");
+bool success = true;
+__try {
+WatcherThread::watcher_thread()->set_crash_protection(this);
+cb.call();
+} __except(EXCEPTION_EXECUTE_HANDLER) {
+// only for protection, nothing to do
+success = false;
+}
+WatcherThread::watcher_thread()->set_crash_protection(NULL);
+return success;
 }
 // An Event wraps a win32 "CreateEvent" kernel handle.
 //
 // We have a number of choices regarding "CreateEvent" win32 handle leakage:

Mercurial > hg > graal-compiler

comparison src/os/windows/vm/os_windows.cpp @ 11173:6b0fd0964b87