jdk-sandbox: comparison hotspot/src/os/windows/vm/os

equal deleted inserted replaced

-:a02753d5a0b2
+:d1221849ea3d
 #include <errno.h>
 #include <fcntl.h>
 #include <io.h>
 #include <process.h>              // For _beginthreadex(), _endthreadex()
 #include <imagehlp.h>             // For os::dll_address_to_function_name
-/* for enumerating dll libraries */
+// for enumerating dll libraries
 #include <vdmdbg.h>
 // for timer info max values which include all bits
 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
 static FILETIME process_exit_time;
 static FILETIME process_user_time;
 static FILETIME process_kernel_time;
 #ifdef _M_IA64
 #define __CPU__ ia64
 #elif _M_AMD64
 #define __CPU__ amd64
 #else
 #define __CPU__ i486
 #endif
 // save DLL module handle, used by GetModuleFileName
 HINSTANCE vm_lib_handle;
 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
 switch (reason) {
 case DLL_PROCESS_ATTACH:
 vm_lib_handle = hinst;
-if (ForceTimeHighResolution)
+if (ForceTimeHighResolution) {
 timeBeginPeriod(1L);
+}
 break;
 case DLL_PROCESS_DETACH:
-if (ForceTimeHighResolution)
+if (ForceTimeHighResolution) {
 timeEndPeriod(1L);
+}
 break;
 default:
 break;
 }
 return true;
 // previous UnhandledExceptionFilter, if there is one
 static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);
 void os::init_system_properties_values() {
-/* sysclasspath, java_home, dll_dir */
+// sysclasspath, java_home, dll_dir
 {
 char *home_path;
 char *dll_path;
 char *pslash;
 char *bin = "\\bin";
 if (!getenv("_ALT_JAVA_HOME_DIR", home_dir, MAX_PATH)) {
 os::jvm_path(home_dir, sizeof(home_dir));
 // Found the full path to jvm.dll.
 // Now cut the path to <java_home>/jre if we can.
-*(strrchr(home_dir, '\\')) = '\0';  /* get rid of \jvm.dll */
+*(strrchr(home_dir, '\\')) = '\0';  // get rid of \jvm.dll
 pslash = strrchr(home_dir, '\\');
 if (pslash != NULL) {
-*pslash = '\0';                 /* get rid of \{client|server} */
+*pslash = '\0';                   // get rid of \{client|server}
 pslash = strrchr(home_dir, '\\');
-if (pslash != NULL)
+if (pslash != NULL) {
-*pslash = '\0';             /* get rid of \bin */
+*pslash = '\0';                 // get rid of \bin
+}
 }
 }
 home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1, mtInternal);
-if (home_path == NULL)
+if (home_path == NULL) {
 return;
+}
 strcpy(home_path, home_dir);
 Arguments::set_java_home(home_path);
-dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1, mtInternal);
+dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1,
-if (dll_path == NULL)
+mtInternal);
+if (dll_path == NULL) {
 return;
+}
 strcpy(dll_path, home_dir);
 strcat(dll_path, bin);
 Arguments::set_dll_dir(dll_path);
-if (!set_boot_path('\\', ';'))
+if (!set_boot_path('\\', ';')) {
 return;
 }
+}
-/* library_path */
-#define EXT_DIR "\\lib\\ext"
+// library_path
-#define BIN_DIR "\\bin"
+#define EXT_DIR "\\lib\\ext"
-#define PACKAGE_DIR "\\Sun\\Java"
+#define BIN_DIR "\\bin"
+#define PACKAGE_DIR "\\Sun\\Java"
 {
-/* Win32 library search order (See the documentation for LoadLibrary):
+// Win32 library search order (See the documentation for LoadLibrary):
-*
+//
-* 1. The directory from which application is loaded.
+// 1. The directory from which application is loaded.
-* 2. The system wide Java Extensions directory (Java only)
+// 2. The system wide Java Extensions directory (Java only)
-* 3. System directory (GetSystemDirectory)
+// 3. System directory (GetSystemDirectory)
-* 4. Windows directory (GetWindowsDirectory)
+// 4. Windows directory (GetWindowsDirectory)
-* 5. The PATH environment variable
+// 5. The PATH environment variable
-* 6. The current directory
+// 6. The current directory
-*/
 char *library_path;
 char tmp[MAX_PATH];
 char *path_str = ::getenv("PATH");
 Arguments::set_library_path(library_path);
 FREE_C_HEAP_ARRAY(char, library_path, mtInternal);
 }
-/* Default extensions directory */
+// Default extensions directory
 {
 char path[MAX_PATH];
 char buf[2 * MAX_PATH + 2 * sizeof(EXT_DIR) + sizeof(PACKAGE_DIR) + 1];
 GetWindowsDirectory(path, MAX_PATH);
 sprintf(buf, "%s%s;%s%s%s", Arguments::get_java_home(), EXT_DIR,
 }
 #undef EXT_DIR
 #undef BIN_DIR
 #undef PACKAGE_DIR
-/* Default endorsed standards directory. */
+// Default endorsed standards directory.
 {
 #define ENDORSED_DIR "\\lib\\endorsed"
 size_t len = strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR);
 char * buf = NEW_C_HEAP_ARRAY(char, len, mtInternal);
 sprintf(buf, "%s%s", Arguments::get_java_home(), ENDORSED_DIR);
 Arguments::set_endorsed_dirs(buf);
 #undef ENDORSED_DIR
 }
 #ifndef _WIN64
 // set our UnhandledExceptionFilter and save any previous one
 prev_uef_handler = SetUnhandledExceptionFilter(Handle_FLT_Exception);
 // Invoked from the BREAKPOINT Macro
 extern "C" void breakpoint() {
 os::breakpoint();
 }
-/*
+// RtlCaptureStackBackTrace Windows API may not exist prior to Windows XP.
-* RtlCaptureStackBackTrace Windows API may not exist prior to Windows XP.
+// So far, this method is only used by Native Memory Tracking, which is
-* So far, this method is only used by Native Memory Tracking, which is
+// only supported on Windows XP or later.
-* only supported on Windows XP or later.
+//
-*/
 int os::get_native_stack(address* stack, int frames, int toSkip) {
 #ifdef _NMT_NOINLINE_
-toSkip ++;
+toSkip++;
 #endif
 int captured = Kernel32Dll::RtlCaptureStackBackTrace(toSkip + 1, frames,
 (PVOID*)stack, NULL);
 for (int index = captured; index < frames; index ++) {
 stack[index] = NULL;
 stack_bottom =  (address)minfo.AllocationBase;
 stack_size = minfo.RegionSize;
 // Add up the sizes of all the regions with the same
 // AllocationBase.
-while (1)
+while (1) {
-{
 VirtualQuery(stack_bottom+stack_size, &minfo, sizeof(minfo));
-if (stack_bottom == (address)minfo.AllocationBase)
+if (stack_bottom == (address)minfo.AllocationBase) {
 stack_size += minfo.RegionSize;
-else
+} else {
 break;
+}
 }
 #ifdef _M_IA64
 // IA64 has memory and register stacks
 //
 }
 return 0;
 }
-static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle, int thread_id) {
+static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle,
+int thread_id) {
 // Allocate the OSThread object
 OSThread* osthread = new OSThread(NULL, NULL);
 if (osthread == NULL) return NULL;
 // Initialize support for Java interrupts
 thread->set_osthread(_starting_thread);
 return true;
 }
 // Allocate and initialize a new OSThread
-bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
+bool os::create_thread(Thread* thread, ThreadType thr_type,
+size_t stack_size) {
 unsigned thread_id;
 // Allocate the OSThread object
 OSThread* osthread = new OSThread(NULL, NULL);
 if (osthread == NULL) {
 if (stack_size == 0) {
 switch (thr_type) {
 case os::java_thread:
 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
-if (JavaThread::stack_size_at_create() > 0)
+if (JavaThread::stack_size_at_create() > 0) {
 stack_size = JavaThread::stack_size_at_create();
+}
 break;
 case os::compiler_thread:
 if (CompilerThreadStackSize > 0) {
 stack_size = (size_t)(CompilerThreadStackSize * K);
 break;
 // are not supposed to call CreateThread() directly according to MSDN
 // document because JVM uses C runtime library. The good news is that the
 // flag appears to work with _beginthredex() as well.
 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
 #define STACK_SIZE_PARAM_IS_A_RESERVATION  (0x10000)
 #endif
 HANDLE thread_handle =
 (HANDLE)_beginthreadex(NULL,
 (unsigned)stack_size,
 return false;
 }
 }
 void os::shutdown() {
 // allow PerfMemory to attempt cleanup of any persistent resources
 perfMemory_exit();
 // flush buffered output, finish log files
 ostream_abort();
 abort_hook();
 }
 }
-static BOOL  (WINAPI *_MiniDumpWriteDump)  ( HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, PMINIDUMP_EXCEPTION_INFORMATION,
+static BOOL (WINAPI *_MiniDumpWriteDump)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
-PMINIDUMP_USER_STREAM_INFORMATION, PMINIDUMP_CALLBACK_INFORMATION);
+PMINIDUMP_EXCEPTION_INFORMATION,
+PMINIDUMP_USER_STREAM_INFORMATION,
+PMINIDUMP_CALLBACK_INFORMATION);
 void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize) {
 HINSTANCE dbghelp;
 EXCEPTION_POINTERS ep;
 MINIDUMP_EXCEPTION_INFORMATION mei;
 if (dbghelp == NULL) {
 VMError::report_coredump_status("Failed to load dbghelp.dll", false);
 return;
 }
-_MiniDumpWriteDump = CAST_TO_FN_PTR(
+_MiniDumpWriteDump =
-BOOL(WINAPI *)( HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, PMINIDUMP_EXCEPTION_INFORMATION,
+CAST_TO_FN_PTR(BOOL(WINAPI *)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
-PMINIDUMP_USER_STREAM_INFORMATION, PMINIDUMP_CALLBACK_INFORMATION),
+PMINIDUMP_EXCEPTION_INFORMATION,
-GetProcAddress(dbghelp, "MiniDumpWriteDump"));
+PMINIDUMP_USER_STREAM_INFORMATION,
+PMINIDUMP_CALLBACK_INFORMATION),
+GetProcAddress(dbghelp,
+"MiniDumpWriteDump"));
 if (_MiniDumpWriteDump == NULL) {
 VMError::report_coredump_status("Failed to find MiniDumpWriteDump() in module dbghelp.dll", false);
 return;
 }
 CloseHandle(dumpFile);
 }
-void os::abort(bool dump_core)
+void os::abort(bool dump_core) {
-{
 os::shutdown();
 // no core dump on Windows
 ::exit(1);
 }
 // Directory routines copied from src/win32/native/java/io/dirent_md.c
 //  * dirent_md.c       1.15 00/02/02
 //
 // The declarations for DIR and struct dirent are in jvm_win32.h.
-/* Caller must have already run dirname through JVM_NativePath, which removes
+// Caller must have already run dirname through JVM_NativePath, which removes
-duplicate slashes and converts all instances of '/' into '\\'. */
+// duplicate slashes and converts all instances of '/' into '\\'.
-DIR *
+DIR * os::opendir(const char *dirname) {
-os::opendir(const char *dirname)
-{
 assert(dirname != NULL, "just checking");   // hotspot change
 DIR *dirp = (DIR *)malloc(sizeof(DIR), mtInternal);
 DWORD fattr;                                // hotspot change
 char alt_dirname[4] = { 0, 0, 0, 0 };
 if (dirp == 0) {
 errno = ENOMEM;
 return 0;
 }
-/*
+// Win32 accepts "\" in its POSIX stat(), but refuses to treat it
-* Win32 accepts "\" in its POSIX stat(), but refuses to treat it
+// as a directory in FindFirstFile().  We detect this case here and
-* as a directory in FindFirstFile().  We detect this case here and
+// prepend the current drive name.
-* prepend the current drive name.
+//
-*/
 if (dirname[1] == '\0' && dirname[0] == '\\') {
 alt_dirname[0] = _getdrive() + 'A' - 1;
 alt_dirname[1] = ':';
 alt_dirname[2] = '\\';
 alt_dirname[3] = '\0';
 free(dirp, mtInternal);
 errno = ENOTDIR;
 return 0;
 }
-/* Append "*.*", or possibly "\\*.*", to path */
+// Append "*.*", or possibly "\\*.*", to path
-if (dirp->path[1] == ':'
+if (dirp->path[1] == ':' &&
-&& (dirp->path[2] == '\0'
+(dirp->path[2] == '\0' ||
-|| (dirp->path[2] == '\\' && dirp->path[3] == '\0'))) {
+(dirp->path[2] == '\\' && dirp->path[3] == '\0'))) {
-/* No '\\' needed for cases like "Z:" or "Z:\" */
+// No '\\' needed for cases like "Z:" or "Z:\"
 strcat(dirp->path, "*.*");
 } else {
 strcat(dirp->path, "\\*.*");
 }
 }
 }
 return dirp;
 }
-/* parameter dbuf unused on Windows */
+// parameter dbuf unused on Windows
+struct dirent * os::readdir(DIR *dirp, dirent *dbuf) {
-struct dirent *
-os::readdir(DIR *dirp, dirent *dbuf)
-{
 assert(dirp != NULL, "just checking");      // hotspot change
 if (dirp->handle == INVALID_HANDLE_VALUE) {
 return 0;
 }
 }
 return &dirp->dirent;
 }
-int
+int os::closedir(DIR *dirp) {
-os::closedir(DIR *dirp)
-{
 assert(dirp != NULL, "just checking");      // hotspot change
 if (dirp->handle != INVALID_HANDLE_VALUE) {
 if (!FindClose(dirp->handle)) {
 errno = EBADF;
 return -1;
 // This must be hard coded because it's the system's temporary
 // directory not the java application's temp directory, ala java.io.tmpdir.
 const char* os::get_temp_directory() {
 static char path_buf[MAX_PATH];
-if (GetTempPath(MAX_PATH, path_buf)>0)
+if (GetTempPath(MAX_PATH, path_buf) > 0) {
 return path_buf;
-else{
+} else {
-path_buf[0]='\0';
+path_buf[0] = '\0';
 return path_buf;
 }
 }
 static bool file_exists(const char* filename) {
 // Helper functions for fatal error handler
 #ifdef _WIN64
 // Helper routine which returns true if address in
 // within the NTDLL address space.
 //
-static bool _addr_in_ntdll( address addr )
+static bool _addr_in_ntdll(address addr) {
-{
 HMODULE hmod;
 MODULEINFO minfo;
 hmod = GetModuleHandle("NTDLL.DLL");
 if (hmod == NULL) return false;
-if (!os::PSApiDll::GetModuleInformation( GetCurrentProcess(), hmod,
+if (!os::PSApiDll::GetModuleInformation(GetCurrentProcess(), hmod,
-&minfo, sizeof(MODULEINFO)) )
+&minfo, sizeof(MODULEINFO))) {
 return false;
+}
 if ((addr >= minfo.lpBaseOfDll) &&
-(addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage)))
+(addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage))) {
 return true;
-else
+} else {
 return false;
+}
 }
 #endif
 // Enumerate all modules for a given process ID
 //    unsigned  module_size,
 //    void*     param
 typedef int (*EnumModulesCallbackFunc)(int, char *, address, unsigned, void *);
 // enumerate_modules for Windows NT, using PSAPI
-static int _enumerate_modules_winnt( int pid, EnumModulesCallbackFunc func, void * param)
+static int _enumerate_modules_winnt(int pid, EnumModulesCallbackFunc func,
-{
+void * param) {
 HANDLE   hProcess;
-# define MAX_NUM_MODULES 128
+#define MAX_NUM_MODULES 128
 HMODULE     modules[MAX_NUM_MODULES];
 static char filename[MAX_PATH];
 int         result = 0;
 if (!os::PSApiDll::PSApiAvailable()) {
 return result;
 }
 // enumerate_modules for Windows 95/98/ME, using TOOLHELP
-static int _enumerate_modules_windows( int pid, EnumModulesCallbackFunc func, void *param)
+static int _enumerate_modules_windows(int pid, EnumModulesCallbackFunc func,
-{
+void *param) {
 HANDLE                hSnapShot;
 static MODULEENTRY32  modentry;
 int                   result = 0;
 if (!os::Kernel32Dll::HelpToolsAvailable()) {
 return FALSE;
 }
 // iterate through all modules
 modentry.dwSize = sizeof(MODULEENTRY32);
-bool not_done = os::Kernel32Dll::Module32First( hSnapShot, &modentry ) != 0;
+bool not_done = os::Kernel32Dll::Module32First(hSnapShot, &modentry) != 0;
 while (not_done) {
 // invoke the callback
 result=func(pid, modentry.szExePath, (address)modentry.modBaseAddr,
 modentry.modBaseSize, param);
 if (result) break;
 modentry.dwSize = sizeof(MODULEENTRY32);
-not_done = os::Kernel32Dll::Module32Next( hSnapShot, &modentry ) != 0;
+not_done = os::Kernel32Dll::Module32Next(hSnapShot, &modentry) != 0;
 }
 CloseHandle(hSnapShot);
 return result;
 }
-int enumerate_modules( int pid, EnumModulesCallbackFunc func, void * param )
+int enumerate_modules(int pid, EnumModulesCallbackFunc func, void * param) {
-{
 // Get current process ID if caller doesn't provide it.
 if (!pid) pid = os::current_process_id();
-if (os::win32::is_nt()) return _enumerate_modules_winnt  (pid, func, param);
+if (os::win32::is_nt()) {
-else                    return _enumerate_modules_windows(pid, func, param);
+return _enumerate_modules_winnt  (pid, func, param);
+} else {
+return _enumerate_modules_windows(pid, func, param);
+}
 }
 struct _modinfo {
 address addr;
 char*   full_path;   // point to a char buffer
 }
 // Loads .dll/.so and
 // in case of error it checks if .dll/.so was built for the
 // same architecture as Hotspot is running on
-void * os::dll_load(const char *name, char *ebuf, int ebuflen)
+void * os::dll_load(const char *name, char *ebuf, int ebuflen) {
-{
 void * result = LoadLibrary(name);
-if (result != NULL)
+if (result != NULL) {
-{
 return result;
 }
 DWORD errcode = GetLastError();
 if (errcode == ERROR_MOD_NOT_FOUND) {
-strncpy(ebuf, "Can't find dependent libraries", ebuflen-1);
+strncpy(ebuf, "Can't find dependent libraries", ebuflen - 1);
-ebuf[ebuflen-1]='\0';
+ebuf[ebuflen - 1] = '\0';
 return NULL;
 }
 // Parsing dll below
 // If we can read dll-info and find that dll was built
 // else call os::lasterror to obtain system error message
 // Read system error message into ebuf
 // It may or may not be overwritten below (in the for loop and just above)
 lasterror(ebuf, (size_t) ebuflen);
-ebuf[ebuflen-1]='\0';
+ebuf[ebuflen - 1] = '\0';
-int file_descriptor=::open(name, O_RDONLY | O_BINARY, 0);
+int fd = ::open(name, O_RDONLY | O_BINARY, 0);
-if (file_descriptor<0)
+if (fd < 0) {
-{
 return NULL;
 }
 uint32_t signature_offset;
-uint16_t lib_arch=0;
+uint16_t lib_arch = 0;
-bool failed_to_get_lib_arch=
+bool failed_to_get_lib_arch =
-(
+( // Go to position 3c in the dll
-//Go to position 3c in the dll
+(os::seek_to_file_offset(fd, IMAGE_FILE_PTR_TO_SIGNATURE) < 0)
-(os::seek_to_file_offset(file_descriptor,IMAGE_FILE_PTR_TO_SIGNATURE)<0)
 ||
-// Read loacation of signature
+// Read location of signature
-(sizeof(signature_offset)!=
+(sizeof(signature_offset) !=
-(os::read(file_descriptor, (void*)&signature_offset,sizeof(signature_offset))))
+(os::read(fd, (void*)&signature_offset, sizeof(signature_offset))))
 ||
-//Go to COFF File Header in dll
+// Go to COFF File Header in dll
-//that is located after"signature" (4 bytes long)
+// that is located after "signature" (4 bytes long)
-(os::seek_to_file_offset(file_descriptor,
+(os::seek_to_file_offset(fd,
-signature_offset+IMAGE_FILE_SIGNATURE_LENGTH)<0)
+signature_offset + IMAGE_FILE_SIGNATURE_LENGTH) < 0)
 ||
-//Read field that contains code of architecture
+// Read field that contains code of architecture
-// that dll was build for
+// that dll was built for
-(sizeof(lib_arch)!=
+(sizeof(lib_arch) != (os::read(fd, (void*)&lib_arch, sizeof(lib_arch))))
-(os::read(file_descriptor, (void*)&lib_arch,sizeof(lib_arch))))
 );
-::close(file_descriptor);
+::close(fd);
-if (failed_to_get_lib_arch)
+if (failed_to_get_lib_arch) {
-{
 // file i/o error - report os::lasterror(...) msg
 return NULL;
 }
-typedef struct
+typedef struct {
-{
 uint16_t arch_code;
 char* arch_name;
 } arch_t;
-static const arch_t arch_array[]={
+static const arch_t arch_array[] = {
 {IMAGE_FILE_MACHINE_I386,      (char*)"IA 32"},
 {IMAGE_FILE_MACHINE_AMD64,     (char*)"AMD 64"},
 {IMAGE_FILE_MACHINE_IA64,      (char*)"IA 64"}
 };
 #if   (defined _M_IA64)
-static const uint16_t running_arch=IMAGE_FILE_MACHINE_IA64;
+static const uint16_t running_arch = IMAGE_FILE_MACHINE_IA64;
 #elif (defined _M_AMD64)
-static const uint16_t running_arch=IMAGE_FILE_MACHINE_AMD64;
+static const uint16_t running_arch = IMAGE_FILE_MACHINE_AMD64;
 #elif (defined _M_IX86)
-static const uint16_t running_arch=IMAGE_FILE_MACHINE_I386;
+static const uint16_t running_arch = IMAGE_FILE_MACHINE_I386;
 #else
 #error Method os::dll_load requires that one of following \
 is defined :_M_IA64,_M_AMD64 or _M_IX86
 #endif
 // Obtain a string for printf operation
 // lib_arch_str shall contain string what platform this .dll was built for
 // running_arch_str shall string contain what platform Hotspot was built for
-char *running_arch_str=NULL,*lib_arch_str=NULL;
+char *running_arch_str = NULL, *lib_arch_str = NULL;
-for (unsigned int i=0;i<ARRAY_SIZE(arch_array);i++)
+for (unsigned int i = 0; i < ARRAY_SIZE(arch_array); i++) {
-{
+if (lib_arch == arch_array[i].arch_code) {
-if (lib_arch==arch_array[i].arch_code)
+lib_arch_str = arch_array[i].arch_name;
-lib_arch_str=arch_array[i].arch_name;
+}
-if (running_arch==arch_array[i].arch_code)
+if (running_arch == arch_array[i].arch_code) {
-running_arch_str=arch_array[i].arch_name;
+running_arch_str = arch_array[i].arch_name;
+}
 }
 assert(running_arch_str,
-"Didn't find runing architecture code in arch_array");
+"Didn't find running architecture code in arch_array");
-// If the architure is right
+// If the architecture is right
 // but some other error took place - report os::lasterror(...) msg
-if (lib_arch == running_arch)
+if (lib_arch == running_arch) {
-{
 return NULL;
 }
-if (lib_arch_str!=NULL)
+if (lib_arch_str != NULL) {
-{
+::_snprintf(ebuf, ebuflen - 1,
-::_snprintf(ebuf, ebuflen-1,
 "Can't load %s-bit .dll on a %s-bit platform",
-lib_arch_str,running_arch_str);
+lib_arch_str, running_arch_str);
-}
+} else {
-else
-{
 // don't know what architecture this dll was build for
-::_snprintf(ebuf, ebuflen-1,
+::_snprintf(ebuf, ebuflen - 1,
 "Can't load this .dll (machine code=0x%x) on a %s-bit platform",
-lib_arch,running_arch_str);
+lib_arch, running_arch_str);
 }
 return NULL;
 }
 // looks like jvm.dll is installed there (append a fake suffix
 // hotspot/jvm.dll).
 char* java_home_var = ::getenv("JAVA_HOME");
 if (java_home_var != NULL && java_home_var[0] != 0 &&
 strlen(java_home_var) < (size_t)buflen) {
 strncpy(buf, java_home_var, buflen);
 // determine if this is a legacy image or modules image
 // modules image doesn't have "jre" subdirectory
 size_t len = strlen(buf);
 return 0;
 }
 int os::get_last_error() {
 DWORD error = GetLastError();
-if (error == 0)
+if (error == 0) {
 error = errno;
+}
 return (int)error;
 }
 // sun.misc.Signal
 // NOTE that this is a workaround for an apparent kernel bug where if
 break;
 }
 return FALSE;
 }
-/*
+// The following code is moved from os.cpp for making this
-* The following code is moved from os.cpp for making this
+// code platform specific, which it is by its very nature.
-* code platform specific, which it is by its very nature.
-*/
 // Return maximum OS signal used + 1 for internal use only
 // Used as exit signal for signal_thread
 int os::sigexitnum_pd() {
 return NSIG;
 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed");
 // were we externally suspended while we were waiting?
 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
 if (threadIsSuspended) {
-//
 // The semaphore has been incremented, but while we were waiting
 // another thread suspended us. We don't want to continue running
 // while suspended because that would surprise the thread that
 // suspended us.
-//
 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
 assert(ret != 0, "ReleaseSemaphore() failed");
 thread->java_suspend_self();
 }
 return check_pending_signals(true);
 }
 // Implicit OS exception handling
-LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
+LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo,
+address handler) {
 JavaThread* thread = JavaThread::current();
 // Save pc in thread
 #ifdef _M_IA64
 // Do not blow up if no thread info available.
 if (thread) {
 // included or copied here.
 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
 // Handle NAT Bit consumption on IA64.
 #ifdef _M_IA64
 #define EXCEPTION_REG_NAT_CONSUMPTION    STATUS_REG_NAT_CONSUMPTION
 #endif
 // Windows Vista/2008 heap corruption check
 #define EXCEPTION_HEAP_CORRUPTION        0xC0000374
 // We didn't handle this exception so pass it to the previous
 // UnhandledExceptionFilter.
 return (prev_uef_handler)(exceptionInfo);
 }
 #else // !_WIN64
-/*
+// On Windows, the mxcsr control bits are non-volatile across calls
-On Windows, the mxcsr control bits are non-volatile across calls
+// See also CR 6192333
-See also CR 6192333
+//
-*/
 jint MxCsr = INITIAL_MXCSR;
 // we can't use StubRoutines::addr_mxcsr_std()
 // because in Win64 mxcsr is not saved there
 if (MxCsr != ctx->MxCsr) {
 ctx->MxCsr = MxCsr;
 // Yellow zone violation.  The o/s has unprotected the first yellow
 // zone page for us.  Note:  must call disable_stack_yellow_zone to
 // update the enabled status, even if the zone contains only one page.
 thread->disable_stack_yellow_zone();
 // If not in java code, return and hope for the best.
-return in_java ? Handle_Exception(exceptionInfo,
+return in_java
-SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
+? Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
 :  EXCEPTION_CONTINUE_EXECUTION;
 } else {
 // Fatal red zone violation.
 thread->disable_stack_red_zone();
 tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
 assert(!os::uses_stack_guard_pages(),
 "should be caught by red zone code above.");
 return Handle_Exception(exceptionInfo,
 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
 }
-//
 // Check for safepoint polling and implicit null
 // We only expect null pointers in the stubs (vtable)
 // the rest are checked explicitly now.
-//
 CodeBlob* cb = CodeCache::find_blob(pc);
 if (cb != NULL) {
 if (os::is_poll_address(addr)) {
 address stub = SharedRuntime::get_poll_stub(pc);
 return Handle_Exception(exceptionInfo, stub);
 }
 }
 {
 #ifdef _WIN64
-//
 // If it's a legal stack address map the entire region in
 //
 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,
 !ExecMem);
 return EXCEPTION_CONTINUE_EXECUTION;
-}
+} else
-else
 #endif
 {
 // Null pointer exception.
 #ifdef _M_IA64
 // Process implicit null checks in compiled code. Note: Implicit null checks
 } // switch
 }
 if (((thread->thread_state() == _thread_in_Java) ||
 (thread->thread_state() == _thread_in_native)) &&
-exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
+exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION) {
-{
 LONG result=Handle_FLT_Exception(exceptionInfo);
 if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
 }
 }
 }
 }
 return EXCEPTION_CONTINUE_SEARCH;
 }
-#define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
+#define DEFINE_FAST_GETFIELD(Return, Fieldname, Result)                     \
-Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
+Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env,           \
-__try { \
+jobject obj,           \
-return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
+jfieldID fieldID) {    \
-} __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
+__try {                                                                 \
-} \
+return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env,       \
-return 0; \
+obj,       \
-}
+fieldID);  \
+} __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)        \
+_exception_info())) {         \
+}                                                                       \
+return 0;                                                               \
+}
 DEFINE_FAST_GETFIELD(jboolean, bool,   Boolean)
 DEFINE_FAST_GETFIELD(jbyte,    byte,   Byte)
 DEFINE_FAST_GETFIELD(jchar,    char,   Char)
 DEFINE_FAST_GETFIELD(jshort,   short,  Short)
 // This makes Windows large page support more or less like Solaris ISM, in
 // that the entire heap must be committed upfront. This probably will change
 // in the future, if so the code below needs to be revisited.
 #ifndef MEM_LARGE_PAGES
 #define MEM_LARGE_PAGES 0x20000000
 #endif
 static HANDLE    _hProcess;
 static HANDLE    _hToken;
 bool success = false;
 bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving);
 // print a warning if UseNUMAInterleaving flag is specified on command line
 bool warn_on_failure = use_numa_interleaving_specified;
-# define WARN(msg) if (warn_on_failure) { warning(msg); }
+#define WARN(msg) if (warn_on_failure) { warning(msg); }
 // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages)
 size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
 NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity);
 // this routine is used whenever we need to reserve a contiguous VA range
 // but we need to make separate VirtualAlloc calls for each piece of the range
 // Reasons for doing this:
 //  * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise)
 //  * UseNUMAInterleaving requires a separate node for each piece
-static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, DWORD prot,
+static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags,
-bool should_inject_error=false) {
+DWORD prot,
+bool should_inject_error = false) {
 char * p_buf;
 // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size
 size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
 size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size;
 // print a warning if any large page related flag is specified on command line
 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
 bool success = false;
-# define WARN(msg) if (warn_on_failure) { warning(msg); }
+#define WARN(msg) if (warn_on_failure) { warning(msg); }
 if (resolve_functions_for_large_page_init()) {
 if (request_lock_memory_privilege()) {
 size_t s = os::Kernel32Dll::GetLargePageMinimum();
 if (s) {
 #if defined(IA32) || defined(AMD64)
 bool os::can_execute_large_page_memory() {
 return true;
 }
-char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr, bool exec) {
+char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr,
+bool exec) {
 assert(UseLargePages, "only for large pages");
 if (!is_size_aligned(bytes, os::large_page_size()) || alignment > os::large_page_size()) {
 return NULL; // Fallback to small pages.
 }
 bool os::get_page_info(char *start, page_info* info) {
 return false;
 }
-char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
+char *os::scan_pages(char *start, char* end, page_info* page_expected,
+page_info* page_found) {
 return end;
 }
 char* os::non_memory_address_word() {
 // Must never look like an address returned by reserve_memory,
 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
 jlong limit = (jlong) MAXDWORD;
 while (ms > limit) {
 int res;
-if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
+if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT) {
 return res;
+}
 ms -= limit;
 }
 assert(thread == Thread::current(), "thread consistency check");
 OSThread* osthread = thread->osthread();
 // java_suspend_self() via check_and_wait_while_suspended()
 HANDLE events[1];
 events[0] = osthread->interrupt_event();
 HighResolutionInterval *phri=NULL;
-if (!ForceTimeHighResolution)
+if (!ForceTimeHighResolution) {
 phri = new HighResolutionInterval(ms);
+}
 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
 result = OS_TIMEOUT;
 } else {
 ResetEvent(osthread->interrupt_event());
 osthread->set_interrupted(false);
 result = OS_TIMEOUT;
 }
 return result;
 }
-//
 // Short sleep, direct OS call.
 //
 // ms = 0, means allow others (if any) to run.
 //
 void os::naked_short_sleep(jlong ms) {
 if (!UseThreadPriorities) return OS_OK;
 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
 return ret ? OS_OK : OS_ERR;
 }
-OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
+OSReturn os::get_native_priority(const Thread* const thread,
+int* priority_ptr) {
 if (!UseThreadPriorities) {
 *priority_ptr = java_to_os_priority[NormPriority];
 return OS_OK;
 }
 int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
 // Hint to the underlying OS that a task switch would not be good.
 // Void return because it's a hint and can fail.
 void os::hint_no_preempt() {}
 void os::interrupt(Thread* thread) {
-assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
+assert(!thread->is_Java_thread() || Thread::current() == thread ||
+Threads_lock->owned_by_self(),
 "possibility of dangling Thread pointer");
 OSThread* osthread = thread->osthread();
 osthread->set_interrupted(true);
 // More than one thread can get here with the same value of osthread,
 // to interrupted() to be visible to other threads before we post
 // the interrupt event.
 OrderAccess::release();
 SetEvent(osthread->interrupt_event());
 // For JSR166:  unpark after setting status
-if (thread->is_Java_thread())
+if (thread->is_Java_thread()) {
 ((JavaThread*)thread)->parker()->unpark();
+}
 ParkEvent * ev = thread->_ParkEvent;
 if (ev != NULL) ev->unpark();
 }
 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
 }
 #endif
 }
 // GetCurrentThreadId() returns DWORD
-intx os::current_thread_id()          { return GetCurrentThreadId(); }
+intx os::current_thread_id()  { return GetCurrentThreadId(); }
 static int _initial_pid = 0;
-int os::current_process_id()
+int os::current_process_id() {
-{
 return (_initial_pid ? _initial_pid : _getpid());
 }
-int    os::win32::_vm_page_size       = 0;
+int    os::win32::_vm_page_size              = 0;
 int    os::win32::_vm_allocation_granularity = 0;
-int    os::win32::_processor_type     = 0;
+int    os::win32::_processor_type            = 0;
 // Processor level is not available on non-NT systems, use vm_version instead
-int    os::win32::_processor_level    = 0;
+int    os::win32::_processor_level           = 0;
-julong os::win32::_physical_memory    = 0;
+julong os::win32::_physical_memory           = 0;
-size_t os::win32::_default_stack_size = 0;
+size_t os::win32::_default_stack_size        = 0;
-intx os::win32::_os_thread_limit    = 0;
+intx          os::win32::_os_thread_limit    = 0;
 volatile intx os::win32::_os_thread_count    = 0;
-bool   os::win32::_is_nt              = false;
+bool   os::win32::_is_nt                     = false;
-bool   os::win32::_is_windows_2003    = false;
+bool   os::win32::_is_windows_2003           = false;
-bool   os::win32::_is_windows_server  = false;
+bool   os::win32::_is_windows_server         = false;
-bool   os::win32::_has_performance_count = 0;
+bool   os::win32::_has_performance_count     = 0;
 void os::win32::initialize_system_info() {
 SYSTEM_INFO si;
 GetSystemInfo(&si);
 _vm_page_size    = si.dwPageSize;
 StarvationMonitorInterval = 6000;
 }
 }
-HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) {
+HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf,
+int ebuflen) {
 char path[MAX_PATH];
 DWORD size;
 DWORD pathLen = (DWORD)sizeof(path);
 HINSTANCE result = NULL;
 guarantee(return_page != NULL, "Commit Failed for polling page");
 os::set_polling_page(polling_page);
 #ifndef PRODUCT
-if (Verbose && PrintMiscellaneous)
+if (Verbose && PrintMiscellaneous) {
-tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
+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_READWRITE);
 guarantee(mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
 guarantee(return_page != NULL, "Commit Failed for memory serialize page");
 os::set_memory_serialize_page(mem_serialize_page);
 #ifndef PRODUCT
-if (Verbose && PrintMiscellaneous)
+if (Verbose && PrintMiscellaneous) {
-tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
+tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n",
+(intptr_t)mem_serialize_page);
+}
 #endif
 }
 // Setup Windows Exceptions
 }
 // Mark the polling page as unreadable
 void os::make_polling_page_unreadable(void) {
 DWORD old_status;
-if (!VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status))
+if (!VirtualProtect((char *)_polling_page, os::vm_page_size(),
+PAGE_NOACCESS, &old_status)) {
 fatal("Could not disable polling page");
-};
+}
+}
 // Mark the polling page as readable
 void os::make_polling_page_readable(void) {
 DWORD old_status;
-if (!VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status))
+if (!VirtualProtect((char *)_polling_page, os::vm_page_size(),
+PAGE_READONLY, &old_status)) {
 fatal("Could not enable polling page");
-};
+}
+}
 int os::stat(const char *path, struct stat *sbuf) {
 char pathbuf[MAX_PATH];
 if (strlen(path) > MAX_PATH - 1) {
 FILETIME CreationTime;
 FILETIME ExitTime;
 FILETIME KernelTime;
 FILETIME UserTime;
-if (GetThreadTimes(thread->osthread()->thread_handle(),
+if (GetThreadTimes(thread->osthread()->thread_handle(), &CreationTime,
-&CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
+&ExitTime, &KernelTime, &UserTime) == 0) {
 return -1;
-else
+} else if (user_sys_cpu_time) {
-if (user_sys_cpu_time) {
+return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
-return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
 } else {
 return FT2INT64(UserTime) * 100;
 }
 } else {
 return (jlong) timeGetTime() * 1000000;
 FILETIME CreationTime;
 FILETIME ExitTime;
 FILETIME KernelTime;
 FILETIME UserTime;
-if (GetThreadTimes(GetCurrentThread(),
+if (GetThreadTimes(GetCurrentThread(), &CreationTime, &ExitTime,
-&CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
+&KernelTime, &UserTime) == 0) {
 return false;
-else
+} else {
 return true;
+}
 } else {
 return false;
 }
 }
 }
 // This method is a slightly reworked copy of JDK's sysNativePath
 // from src/windows/hpi/src/path_md.c
-/* Convert a pathname to native format.  On win32, this involves forcing all
+// Convert a pathname to native format.  On win32, this involves forcing all
-separators to be '\\' rather than '/' (both are legal inputs, but Win95
+// separators to be '\\' rather than '/' (both are legal inputs, but Win95
-sometimes rejects '/') and removing redundant separators.  The input path is
+// sometimes rejects '/') and removing redundant separators.  The input path is
-assumed to have been converted into the character encoding used by the local
+// assumed to have been converted into the character encoding used by the local
-system.  Because this might be a double-byte encoding, care is taken to
+// system.  Because this might be a double-byte encoding, care is taken to
-treat double-byte lead characters correctly.
+// treat double-byte lead characters correctly.
+//
-This procedure modifies the given path in place, as the result is never
+// This procedure modifies the given path in place, as the result is never
-longer than the original.  There is no error return; this operation always
+// longer than the original.  There is no error return; this operation always
-succeeds. */
+// succeeds.
 char * os::native_path(char *path) {
 char *src = path, *dst = path, *end = path;
-char *colon = NULL;           /* If a drive specifier is found, this will
+char *colon = NULL;  // If a drive specifier is found, this will
-point to the colon following the drive
+// point to the colon following the drive letter
-letter */
+// Assumption: '/', '\\', ':', and drive letters are never lead bytes
-/* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
+assert(((!::IsDBCSLeadByte('/')) && (!::IsDBCSLeadByte('\\'))
-assert(((!::IsDBCSLeadByte('/'))
+&& (!::IsDBCSLeadByte(':'))), "Illegal lead byte");
-&& (!::IsDBCSLeadByte('\\'))
-&& (!::IsDBCSLeadByte(':'))),
+// Check for leading separators
-"Illegal lead byte");
-/* Check for leading separators */
 #define isfilesep(c) ((c) == '/' || (c) == '\\')
 while (isfilesep(*src)) {
 src++;
 }
 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
-/* Remove leading separators if followed by drive specifier.  This
+// Remove leading separators if followed by drive specifier.  This
-hack is necessary to support file URLs containing drive
+// hack is necessary to support file URLs containing drive
-specifiers (e.g., "file://c:/path").  As a side effect,
+// specifiers (e.g., "file://c:/path").  As a side effect,
-"/c:/path" can be used as an alternative to "c:/path". */
+// "/c:/path" can be used as an alternative to "c:/path".
 *dst++ = *src++;
 colon = dst;
 *dst++ = ':';
 src++;
 } else {
 src = path;
 if (isfilesep(src[0]) && isfilesep(src[1])) {
-/* UNC pathname: Retain first separator; leave src pointed at
+// UNC pathname: Retain first separator; leave src pointed at
-second separator so that further separators will be collapsed
+// second separator so that further separators will be collapsed
-into the second separator.  The result will be a pathname
+// into the second separator.  The result will be a pathname
-beginning with "\\\\" followed (most likely) by a host name. */
+// beginning with "\\\\" followed (most likely) by a host name.
 src = dst = path + 1;
-path[0] = '\\';     /* Force first separator to '\\' */
+path[0] = '\\';     // Force first separator to '\\'
 }
 }
 end = dst;
-/* Remove redundant separators from remainder of path, forcing all
+// Remove redundant separators from remainder of path, forcing all
-separators to be '\\' rather than '/'. Also, single byte space
+// separators to be '\\' rather than '/'. Also, single byte space
-characters are removed from the end of the path because those
+// characters are removed from the end of the path because those
-are not legal ending characters on this operating system.
+// are not legal ending characters on this operating system.
-*/
+//
 while (*src != '\0') {
 if (isfilesep(*src)) {
 *dst++ = '\\'; src++;
 while (isfilesep(*src)) src++;
 if (*src == '\0') {
-/* Check for trailing separator */
+// Check for trailing separator
 end = dst;
-if (colon == dst - 2) break;                      /* "z:\\" */
+if (colon == dst - 2) break;  // "z:\\"
-if (dst == path + 1) break;                       /* "\\" */
+if (dst == path + 1) break;   // "\\"
 if (dst == path + 2 && isfilesep(path[0])) {
-/* "\\\\" is not collapsed to "\\" because "\\\\" marks the
+// "\\\\" is not collapsed to "\\" because "\\\\" marks the
-beginning of a UNC pathname.  Even though it is not, by
+// beginning of a UNC pathname.  Even though it is not, by
-itself, a valid UNC pathname, we leave it as is in order
+// itself, a valid UNC pathname, we leave it as is in order
-to be consistent with the path canonicalizer as well
+// to be consistent with the path canonicalizer as well
-as the win32 APIs, which treat this case as an invalid
+// as the win32 APIs, which treat this case as an invalid
-UNC pathname rather than as an alias for the root
+// UNC pathname rather than as an alias for the root
-directory of the current drive. */
+// directory of the current drive.
 break;
 }
-end = --dst;  /* Path does not denote a root directory, so
+end = --dst;  // Path does not denote a root directory, so
-remove trailing separator */
+// remove trailing separator
 break;
 }
 end = dst;
 } else {
-if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
+if (::IsDBCSLeadByte(*src)) {  // Copy a double-byte character
 *dst++ = *src++;
 if (*src) *dst++ = *src++;
 end = dst;
-} else {         /* Copy a single-byte character */
+} else {  // Copy a single-byte character
 char c = *src++;
 *dst++ = c;
-/* Space is not a legal ending character */
+// Space is not a legal ending character
 if (c != ' ') end = dst;
 }
 }
 }
 *end = '\0';
-/* For "z:", add "." to work around a bug in the C runtime library */
+// For "z:", add "." to work around a bug in the C runtime library
 if (colon == dst - 1) {
 path[2] = '.';
 path[3] = '\0';
 }
 int os::fsync(int fd) {
 HANDLE handle = (HANDLE)::_get_osfhandle(fd);
 if ((!::FlushFileBuffers(handle)) &&
-(GetLastError() != ERROR_ACCESS_DENIED) ) {
+(GetLastError() != ERROR_ACCESS_DENIED)) {
-/* from winerror.h */
+// from winerror.h
 return -1;
 }
 return 0;
 }
 // This code is a copy of JDK's nonSeekAvailable
 // from src/windows/hpi/src/sys_api_md.c
 static int nonSeekAvailable(int fd, long *pbytes) {
-/* This is used for available on non-seekable devices
+// This is used for available on non-seekable devices
-* (like both named and anonymous pipes, such as pipes
+// (like both named and anonymous pipes, such as pipes
-*  connected to an exec'd process).
+//  connected to an exec'd process).
-* Standard Input is a special case.
+// Standard Input is a special case.
-*
-*/
 HANDLE han;
 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
 return FALSE;
 }
 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
-/* PeekNamedPipe fails when at EOF.  In that case we
+// PeekNamedPipe fails when at EOF.  In that case we
-* simply make *pbytes = 0 which is consistent with the
+// simply make *pbytes = 0 which is consistent with the
-* behavior we get on Solaris when an fd is at EOF.
+// behavior we get on Solaris when an fd is at EOF.
-* The only alternative is to raise an Exception,
+// The only alternative is to raise an Exception,
-* which isn't really warranted.
+// which isn't really warranted.
-*/
+//
 if (::GetLastError() != ERROR_BROKEN_PIPE) {
 return FALSE;
 }
 *pbytes = 0;
 }
 // This code is a copy of JDK's stdinAvailable
 // from src/windows/hpi/src/sys_api_md.c
 static int stdinAvailable(int fd, long *pbytes) {
 HANDLE han;
-DWORD numEventsRead = 0;      /* Number of events read from buffer */
+DWORD numEventsRead = 0;  // Number of events read from buffer
-DWORD numEvents = 0;  /* Number of events in buffer */
+DWORD numEvents = 0;      // Number of events in buffer
-DWORD i = 0;          /* Loop index */
+DWORD i = 0;              // Loop index
-DWORD curLength = 0;  /* Position marker */
+DWORD curLength = 0;      // Position marker
-DWORD actualLength = 0;       /* Number of bytes readable */
+DWORD actualLength = 0;   // Number of bytes readable
-BOOL error = FALSE;         /* Error holder */
+BOOL error = FALSE;       // Error holder
-INPUT_RECORD *lpBuffer;     /* Pointer to records of input events */
+INPUT_RECORD *lpBuffer;   // Pointer to records of input events
 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
 return FALSE;
 }
-/* Construct an array of input records in the console buffer */
+// Construct an array of input records in the console buffer
 error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
 if (error == 0) {
 return nonSeekAvailable(fd, pbytes);
 }
-/* lpBuffer must fit into 64K or else PeekConsoleInput fails */
+// lpBuffer must fit into 64K or else PeekConsoleInput fails
 if (numEvents > MAX_INPUT_EVENTS) {
 numEvents = MAX_INPUT_EVENTS;
 }
 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal);
 if (error == 0) {
 os::free(lpBuffer, mtInternal);
 return FALSE;
 }
-/* Examine input records for the number of bytes available */
+// Examine input records for the number of bytes available
 for (i=0; i<numEvents; i++) {
 if (lpBuffer[i].EventType == KEY_EVENT) {
 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
 &(lpBuffer[i].Event);
 CloseHandle(hFile);
 return NULL;
 }
 } else {
 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
-NULL /*file_name*/);
+NULL /* file_name */);
 if (hMap == NULL) {
 if (PrintMiscellaneous && Verbose) {
 DWORD err = GetLastError();
 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.", err);
 }
 os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
 assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
 }
-/*
+// See the caveats for this class in os_windows.hpp
-* See the caveats for this class in os_windows.hpp
+// Protects the callback call so that raised OS EXCEPTIONS causes a jump back
-* 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
-* into this method and returns false. If no OS EXCEPTION was raised, returns
+// true.
-* true.
+// The callback is supposed to provide the method that should be protected.
-* 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?");
 //     1 : signaled - thread is running or ready
 //
 // Another possible encoding of _Event would be
 // with explicit "PARKED" and "SIGNALED" bits.
-int os::PlatformEvent::park (jlong Millis) {
+int os::PlatformEvent::park(jlong Millis) {
 guarantee(_ParkHandle != NULL , "Invariant");
 guarantee(Millis > 0          , "Invariant");
 int v;
 // CONSIDER: defer assigning a CreateEvent() handle to the Event until
 // JSR166
 // -------------------------------------------------------
-/*
+// The Windows implementation of Park is very straightforward: Basic
-* The Windows implementation of Park is very straightforward: Basic
+// operations on Win32 Events turn out to have the right semantics to
-* operations on Win32 Events turn out to have the right semantics to
+// use them directly. We opportunistically resuse the event inherited
-* use them directly. We opportunistically resuse the event inherited
+// from Monitor.
-* from Monitor.
-*/
 void Parker::park(bool isAbsolute, jlong time) {
 guarantee(_ParkEvent != NULL, "invariant");
 // First, demultiplex/decode time arguments
 if (time < 0) { // don't wait
 return;
-}
+} else if (time == 0 && !isAbsolute) {
-else if (time == 0 && !isAbsolute) {
 time = INFINITE;
-}
+} else if (isAbsolute) {
-else if  (isAbsolute) {
 time -= os::javaTimeMillis(); // convert to relative time
-if (time <= 0) // already elapsed
+if (time <= 0) {  // already elapsed
 return;
 }
-else { // relative
+} else { // relative
-time /= 1000000; // Must coarsen from nanos to millis
+time /= 1000000;  // Must coarsen from nanos to millis
-if (time == 0)   // Wait for the minimal time unit if zero
+if (time == 0) {  // Wait for the minimal time unit if zero
 time = 1;
+}
 }
 JavaThread* thread = (JavaThread*)(Thread::current());
 assert(thread->is_Java_thread(), "Must be JavaThread");
 JavaThread *jt = (JavaThread *)thread;
 // Don't wait if interrupted or already triggered
 if (Thread::is_interrupted(thread, false) ||
 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
 ResetEvent(_ParkEvent);
 return;
-}
+} else {
-else {
 ThreadBlockInVM tbivm(jt);
 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
 jt->set_suspend_equivalent();
 WaitForSingleObject(_ParkEvent, time);
 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
 address addr = (address) exceptionRecord->ExceptionInformation[1];
-if (os::is_memory_serialize_page(thread, addr))
+if (os::is_memory_serialize_page(thread, addr)) {
 return EXCEPTION_CONTINUE_EXECUTION;
+}
 }
 return EXCEPTION_CONTINUE_SEARCH;
 }
 return ::setsockopt(fd, level, optname, optval, optlen);
 }
 // WINDOWS CONTEXT Flags for THREAD_SAMPLING
 #if defined(IA32)
-#  define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS)
+#define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS)
 #elif defined (AMD64)
-#  define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
+#define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
 #endif
 // returns true if thread could be suspended,
 // false otherwise
 static bool do_suspend(HANDLE* h) {
 }
 }
 // retrieve a suspend/resume context capable handle
 // from the tid. Caller validates handle return value.
-void get_thread_handle_for_extended_context(HANDLE* h, OSThread::thread_id_t tid) {
+void get_thread_handle_for_extended_context(HANDLE* h,
+OSThread::thread_id_t tid) {
 if (h != NULL) {
 *h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, tid);
 }
 }
-//
 // Thread sampling implementation
 //
 void os::SuspendedThreadTask::internal_do_task() {
 CONTEXT    ctxt;
 HANDLE     h = NULL;
 }
 // Kernel32 API
 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
-typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
+typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn)(HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
-typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG);
+typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn)(PULONG);
-typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG);
+typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn)(UCHAR, PULONGLONG);
 typedef USHORT (WINAPI* RtlCaptureStackBackTrace_Fn)(ULONG, ULONG, PVOID*, PULONG);
 GetLargePageMinimum_Fn      os::Kernel32Dll::_GetLargePageMinimum = NULL;
 VirtualAllocExNuma_Fn       os::Kernel32Dll::_VirtualAllocExNuma = NULL;
 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL;
 initialize();
 }
 return _VirtualAllocExNuma != NULL;
 }
-LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, SIZE_T bytes, DWORD flags, DWORD prot, DWORD node) {
+LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr,
+SIZE_T bytes, DWORD flags,
+DWORD prot, DWORD node) {
 assert(initialized && _VirtualAllocExNuma != NULL,
 "NUMACallsAvailable() not yet called");
 return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node);
 }
 "NUMACallsAvailable() not yet called");
 return _GetNumaHighestNodeNumber(ptr_highest_node_number);
 }
-BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) {
+BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node,
+PULONGLONG proc_mask) {
 assert(initialized && _GetNumaNodeProcessorMask != NULL,
 "NUMACallsAvailable() not yet called");
 return _GetNumaNodeProcessorMask(node, proc_mask);
 }
 USHORT os::Kernel32Dll::RtlCaptureStackBackTrace(ULONG FrameToSkip,
-ULONG FrameToCapture, PVOID* BackTrace, PULONG BackTraceHash) {
+ULONG FrameToCapture,
+PVOID* BackTrace,
+PULONG BackTraceHash) {
 if (!initialized) {
 initialize();
 }
 if (_RtlCaptureStackBackTrace != NULL) {
 // Help tools
 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
 return true;
 }
-inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
+inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,
+DWORD th32ProcessId) {
 return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
 }
-inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
+inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,
+LPMODULEENTRY32 lpme) {
 return ::Module32First(hSnapshot, lpme);
 }
-inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
+inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,
+LPMODULEENTRY32 lpme) {
 return ::Module32Next(hSnapshot, lpme);
 }
 inline BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
 ::GetNativeSystemInfo(lpSystemInfo);
 }
 // PSAPI API
-inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
+inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess,
+HMODULE *lpModule, DWORD cb,
+LPDWORD lpcbNeeded) {
 return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
 }
-inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
+inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess,
+HMODULE hModule,
+LPTSTR lpFilename,
+DWORD nSize) {
 return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
 }
-inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
+inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess,
+HMODULE hModule,
+LPMODULEINFO lpmodinfo,
+DWORD cb) {
 return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
 }
 inline BOOL os::PSApiDll::PSApiAvailable() {
 return true;
 }
 // WinSock2 API
-inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
+inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested,
+LPWSADATA lpWSAData) {
 return ::WSAStartup(wVersionRequested, lpWSAData);
 }
 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
 return ::gethostbyname(name);
 return true;
 }
 // Advapi API
 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
-BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
+BOOL DisableAllPrivileges,
-PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
+PTOKEN_PRIVILEGES NewState,
+DWORD BufferLength,
+PTOKEN_PRIVILEGES PreviousState,
+PDWORD ReturnLength) {
 return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
 BufferLength, PreviousState, ReturnLength);
 }
-inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
+inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle,
+DWORD DesiredAccess,
 PHANDLE TokenHandle) {
 return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
 }
-inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
+inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName,
+LPCTSTR lpName,
+PLUID lpLuid) {
 return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
 }
 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
 return true;
 }
 #else
 // Kernel32 API
 typedef BOOL (WINAPI* SwitchToThread_Fn)(void);
-typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD);
+typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD, DWORD);
-typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32);
+typedef BOOL (WINAPI* Module32First_Fn)(HANDLE, LPMODULEENTRY32);
-typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32);
+typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE, LPMODULEENTRY32);
 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO);
 SwitchToThread_Fn           os::Kernel32Dll::_SwitchToThread = NULL;
 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL;
 Module32First_Fn            os::Kernel32Dll::_Module32First = NULL;
 return _CreateToolhelp32Snapshot != NULL &&
 _Module32First != NULL &&
 _Module32Next != NULL;
 }
-HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
+HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,
+DWORD th32ProcessId) {
 assert(initialized && _CreateToolhelp32Snapshot != NULL,
 "HelpToolsAvailable() not yet called");
 return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
 }
 "HelpToolsAvailable() not yet called");
 return _Module32First(hSnapshot, lpme);
 }
-inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
+inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,
+LPMODULEENTRY32 lpme) {
 assert(initialized && _Module32Next != NULL,
 "HelpToolsAvailable() not yet called");
 return _Module32Next(hSnapshot, lpme);
 }
 // PSAPI API
 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD);
-typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);;
+typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);
 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
 EnumProcessModules_Fn   os::PSApiDll::_EnumProcessModules = NULL;
 GetModuleFileNameEx_Fn  os::PSApiDll::_GetModuleFileNameEx = NULL;
 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL;
 }
 }
-BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
+BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule,
+DWORD cb, LPDWORD lpcbNeeded) {
 assert(initialized && _EnumProcessModules != NULL,
 "PSApiAvailable() not yet called");
 return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
 }
-DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
+DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule,
+LPTSTR lpFilename, DWORD nSize) {
 assert(initialized && _GetModuleFileNameEx != NULL,
 "PSApiAvailable() not yet called");
 return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
 }
-BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
+BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule,
+LPMODULEINFO lpmodinfo, DWORD cb) {
 assert(initialized && _GetModuleInformation != NULL,
 "PSApiAvailable() not yet called");
 return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
 }
 initialized = TRUE;
 }
 }
 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
-BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
+BOOL DisableAllPrivileges,
-PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
+PTOKEN_PRIVILEGES NewState,
+DWORD BufferLength,
+PTOKEN_PRIVILEGES PreviousState,
+PDWORD ReturnLength) {
 assert(initialized && _AdjustTokenPrivileges != NULL,
 "AdvapiAvailable() not yet called");
 return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
 BufferLength, PreviousState, ReturnLength);
 }
-BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
+BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle,
+DWORD DesiredAccess,
 PHANDLE TokenHandle) {
 assert(initialized && _OpenProcessToken != NULL,
 "AdvapiAvailable() not yet called");
 return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
 }
-BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
+BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName,
+LPCTSTR lpName, PLUID lpLuid) {
 assert(initialized && _LookupPrivilegeValue != NULL,
 "AdvapiAvailable() not yet called");
 return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
 }

changeset 26684	d1221849ea3d
parent 26683	a02753d5a0b2
child 26685	aa239a0dfbea