Mercurial > hg > graal-compiler
annotate src/os_cpu/linux_x86/vm/os_linux_x86.cpp @ 2030:fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
Summary: The concurrent marking thread can complete its operation and increment the full GC counter during a Full GC. This causes the nesting of increments to the start and end of Full GCs that we are expecting to be wrong. the fix is for the marking thread to join the suspendible thread set before incrementing the counter so that it's blocked until the Full GC (or any other safepoint) is finished. The change also includes some minor code cleanup (I renamed a parameter).
Reviewed-by: brutisso, ysr
| author | tonyp |
|---|---|
| date | Tue, 14 Dec 2010 16:19:44 -0500 |
| parents | 828eafbd85cc |
| children | 06f017f7daa7 d70fe6ab4436 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1907 | 2 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 // no precompiled headers |
| 26 #include "assembler_x86.inline.hpp" | |
| 27 #include "classfile/classLoader.hpp" | |
| 28 #include "classfile/systemDictionary.hpp" | |
| 29 #include "classfile/vmSymbols.hpp" | |
| 30 #include "code/icBuffer.hpp" | |
| 31 #include "code/vtableStubs.hpp" | |
| 32 #include "interpreter/interpreter.hpp" | |
| 33 #include "jvm_linux.h" | |
| 34 #include "memory/allocation.inline.hpp" | |
| 35 #include "mutex_linux.inline.hpp" | |
| 36 #include "nativeInst_x86.hpp" | |
| 37 #include "os_share_linux.hpp" | |
| 38 #include "prims/jniFastGetField.hpp" | |
| 39 #include "prims/jvm.h" | |
| 40 #include "prims/jvm_misc.hpp" | |
| 41 #include "runtime/arguments.hpp" | |
| 42 #include "runtime/extendedPC.hpp" | |
| 43 #include "runtime/frame.inline.hpp" | |
| 44 #include "runtime/interfaceSupport.hpp" | |
| 45 #include "runtime/java.hpp" | |
| 46 #include "runtime/javaCalls.hpp" | |
| 47 #include "runtime/mutexLocker.hpp" | |
| 48 #include "runtime/osThread.hpp" | |
| 49 #include "runtime/sharedRuntime.hpp" | |
| 50 #include "runtime/stubRoutines.hpp" | |
| 51 #include "runtime/timer.hpp" | |
| 52 #include "thread_linux.inline.hpp" | |
| 53 #include "utilities/events.hpp" | |
| 54 #include "utilities/vmError.hpp" | |
| 55 #ifdef COMPILER1 | |
| 56 #include "c1/c1_Runtime1.hpp" | |
| 57 #endif | |
| 58 #ifdef COMPILER2 | |
| 59 #include "opto/runtime.hpp" | |
| 60 #endif | |
| 0 | 61 |
| 62 // put OS-includes here | |
| 63 # include <sys/types.h> | |
| 64 # include <sys/mman.h> | |
| 65 # include <pthread.h> | |
| 66 # include <signal.h> | |
| 67 # include <errno.h> | |
| 68 # include <dlfcn.h> | |
| 69 # include <stdlib.h> | |
| 70 # include <stdio.h> | |
| 71 # include <unistd.h> | |
| 72 # include <sys/resource.h> | |
| 73 # include <pthread.h> | |
| 74 # include <sys/stat.h> | |
| 75 # include <sys/time.h> | |
| 76 # include <sys/utsname.h> | |
| 77 # include <sys/socket.h> | |
| 78 # include <sys/wait.h> | |
| 79 # include <pwd.h> | |
| 80 # include <poll.h> | |
| 81 # include <ucontext.h> | |
| 82 # include <fpu_control.h> | |
| 83 | |
| 84 #ifdef AMD64 | |
| 85 #define REG_SP REG_RSP | |
| 86 #define REG_PC REG_RIP | |
| 87 #define REG_FP REG_RBP | |
| 88 #define SPELL_REG_SP "rsp" | |
| 89 #define SPELL_REG_FP "rbp" | |
| 90 #else | |
| 91 #define REG_SP REG_UESP | |
| 92 #define REG_PC REG_EIP | |
| 93 #define REG_FP REG_EBP | |
| 94 #define SPELL_REG_SP "esp" | |
| 95 #define SPELL_REG_FP "ebp" | |
| 96 #endif // AMD64 | |
| 97 | |
| 98 address os::current_stack_pointer() { | |
|
50
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
99 #ifdef SPARC_WORKS |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
100 register void *esp; |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
101 __asm__("mov %%"SPELL_REG_SP", %0":"=r"(esp)); |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
102 return (address) ((char*)esp + sizeof(long)*2); |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
103 #else |
| 0 | 104 register void *esp __asm__ (SPELL_REG_SP); |
| 105 return (address) esp; | |
|
50
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
106 #endif |
| 0 | 107 } |
| 108 | |
| 109 char* os::non_memory_address_word() { | |
| 110 // Must never look like an address returned by reserve_memory, | |
| 111 // even in its subfields (as defined by the CPU immediate fields, | |
| 112 // if the CPU splits constants across multiple instructions). | |
| 113 | |
| 114 return (char*) -1; | |
| 115 } | |
| 116 | |
| 117 void os::initialize_thread() { | |
| 118 // Nothing to do. | |
| 119 } | |
| 120 | |
| 121 address os::Linux::ucontext_get_pc(ucontext_t * uc) { | |
| 122 return (address)uc->uc_mcontext.gregs[REG_PC]; | |
| 123 } | |
| 124 | |
| 125 intptr_t* os::Linux::ucontext_get_sp(ucontext_t * uc) { | |
| 126 return (intptr_t*)uc->uc_mcontext.gregs[REG_SP]; | |
| 127 } | |
| 128 | |
| 129 intptr_t* os::Linux::ucontext_get_fp(ucontext_t * uc) { | |
| 130 return (intptr_t*)uc->uc_mcontext.gregs[REG_FP]; | |
| 131 } | |
| 132 | |
| 133 // For Forte Analyzer AsyncGetCallTrace profiling support - thread | |
| 134 // is currently interrupted by SIGPROF. | |
| 135 // os::Solaris::fetch_frame_from_ucontext() tries to skip nested signal | |
| 136 // frames. Currently we don't do that on Linux, so it's the same as | |
| 137 // os::fetch_frame_from_context(). | |
| 138 ExtendedPC os::Linux::fetch_frame_from_ucontext(Thread* thread, | |
| 139 ucontext_t* uc, intptr_t** ret_sp, intptr_t** ret_fp) { | |
| 140 | |
| 141 assert(thread != NULL, "just checking"); | |
| 142 assert(ret_sp != NULL, "just checking"); | |
| 143 assert(ret_fp != NULL, "just checking"); | |
| 144 | |
| 145 return os::fetch_frame_from_context(uc, ret_sp, ret_fp); | |
| 146 } | |
| 147 | |
| 148 ExtendedPC os::fetch_frame_from_context(void* ucVoid, | |
| 149 intptr_t** ret_sp, intptr_t** ret_fp) { | |
| 150 | |
| 151 ExtendedPC epc; | |
| 152 ucontext_t* uc = (ucontext_t*)ucVoid; | |
| 153 | |
| 154 if (uc != NULL) { | |
| 155 epc = ExtendedPC(os::Linux::ucontext_get_pc(uc)); | |
| 156 if (ret_sp) *ret_sp = os::Linux::ucontext_get_sp(uc); | |
| 157 if (ret_fp) *ret_fp = os::Linux::ucontext_get_fp(uc); | |
| 158 } else { | |
| 159 // construct empty ExtendedPC for return value checking | |
| 160 epc = ExtendedPC(NULL); | |
| 161 if (ret_sp) *ret_sp = (intptr_t *)NULL; | |
| 162 if (ret_fp) *ret_fp = (intptr_t *)NULL; | |
| 163 } | |
| 164 | |
| 165 return epc; | |
| 166 } | |
| 167 | |
| 168 frame os::fetch_frame_from_context(void* ucVoid) { | |
| 169 intptr_t* sp; | |
| 170 intptr_t* fp; | |
| 171 ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp); | |
| 172 return frame(sp, fp, epc.pc()); | |
| 173 } | |
| 174 | |
| 175 // By default, gcc always save frame pointer (%ebp/%rbp) on stack. It may get | |
| 176 // turned off by -fomit-frame-pointer, | |
| 177 frame os::get_sender_for_C_frame(frame* fr) { | |
| 178 return frame(fr->sender_sp(), fr->link(), fr->sender_pc()); | |
| 179 } | |
| 180 | |
| 181 intptr_t* _get_previous_fp() { | |
|
50
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
182 #ifdef SPARC_WORKS |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
183 register intptr_t **ebp; |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
184 __asm__("mov %%"SPELL_REG_FP", %0":"=r"(ebp)); |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
185 #else |
| 0 | 186 register intptr_t **ebp __asm__ (SPELL_REG_FP); |
|
50
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
187 #endif |
| 0 | 188 return (intptr_t*) *ebp; // we want what it points to. |
| 189 } | |
| 190 | |
| 191 | |
| 192 frame os::current_frame() { | |
| 193 intptr_t* fp = _get_previous_fp(); | |
| 194 frame myframe((intptr_t*)os::current_stack_pointer(), | |
| 195 (intptr_t*)fp, | |
| 196 CAST_FROM_FN_PTR(address, os::current_frame)); | |
| 197 if (os::is_first_C_frame(&myframe)) { | |
| 198 // stack is not walkable | |
| 199 return frame(NULL, NULL, NULL); | |
| 200 } else { | |
| 201 return os::get_sender_for_C_frame(&myframe); | |
| 202 } | |
| 203 } | |
| 204 | |
| 205 // Utility functions | |
| 206 | |
| 207 // From IA32 System Programming Guide | |
| 208 enum { | |
| 209 trap_page_fault = 0xE | |
| 210 }; | |
| 211 | |
| 212 extern "C" void Fetch32PFI () ; | |
| 213 extern "C" void Fetch32Resume () ; | |
| 214 #ifdef AMD64 | |
| 215 extern "C" void FetchNPFI () ; | |
| 216 extern "C" void FetchNResume () ; | |
| 217 #endif // AMD64 | |
| 218 | |
| 219 extern "C" int | |
| 220 JVM_handle_linux_signal(int sig, | |
| 221 siginfo_t* info, | |
| 222 void* ucVoid, | |
| 223 int abort_if_unrecognized) { | |
| 224 ucontext_t* uc = (ucontext_t*) ucVoid; | |
| 225 | |
| 226 Thread* t = ThreadLocalStorage::get_thread_slow(); | |
| 227 | |
| 228 SignalHandlerMark shm(t); | |
| 229 | |
| 230 // Note: it's not uncommon that JNI code uses signal/sigset to install | |
| 231 // then restore certain signal handler (e.g. to temporarily block SIGPIPE, | |
| 232 // or have a SIGILL handler when detecting CPU type). When that happens, | |
| 233 // JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To | |
| 234 // avoid unnecessary crash when libjsig is not preloaded, try handle signals | |
| 235 // that do not require siginfo/ucontext first. | |
| 236 | |
| 237 if (sig == SIGPIPE || sig == SIGXFSZ) { | |
| 238 // allow chained handler to go first | |
| 239 if (os::Linux::chained_handler(sig, info, ucVoid)) { | |
| 240 return true; | |
| 241 } else { | |
| 242 if (PrintMiscellaneous && (WizardMode || Verbose)) { | |
| 243 char buf[64]; | |
| 244 warning("Ignoring %s - see bugs 4229104 or 646499219", | |
| 245 os::exception_name(sig, buf, sizeof(buf))); | |
| 246 } | |
| 247 return true; | |
| 248 } | |
| 249 } | |
| 250 | |
| 251 JavaThread* thread = NULL; | |
| 252 VMThread* vmthread = NULL; | |
| 253 if (os::Linux::signal_handlers_are_installed) { | |
| 254 if (t != NULL ){ | |
| 255 if(t->is_Java_thread()) { | |
| 256 thread = (JavaThread*)t; | |
| 257 } | |
| 258 else if(t->is_VM_thread()){ | |
| 259 vmthread = (VMThread *)t; | |
| 260 } | |
| 261 } | |
| 262 } | |
| 263 /* | |
| 264 NOTE: does not seem to work on linux. | |
| 265 if (info == NULL || info->si_code <= 0 || info->si_code == SI_NOINFO) { | |
| 266 // can't decode this kind of signal | |
| 267 info = NULL; | |
| 268 } else { | |
| 269 assert(sig == info->si_signo, "bad siginfo"); | |
| 270 } | |
| 271 */ | |
| 272 // decide if this trap can be handled by a stub | |
| 273 address stub = NULL; | |
| 274 | |
| 275 address pc = NULL; | |
| 276 | |
| 277 //%note os_trap_1 | |
| 278 if (info != NULL && uc != NULL && thread != NULL) { | |
| 279 pc = (address) os::Linux::ucontext_get_pc(uc); | |
| 280 | |
| 281 if (pc == (address) Fetch32PFI) { | |
| 282 uc->uc_mcontext.gregs[REG_PC] = intptr_t(Fetch32Resume) ; | |
| 283 return 1 ; | |
| 284 } | |
| 285 #ifdef AMD64 | |
| 286 if (pc == (address) FetchNPFI) { | |
| 287 uc->uc_mcontext.gregs[REG_PC] = intptr_t (FetchNResume) ; | |
| 288 return 1 ; | |
| 289 } | |
| 290 #endif // AMD64 | |
| 291 | |
| 292 // Handle ALL stack overflow variations here | |
| 293 if (sig == SIGSEGV) { | |
| 294 address addr = (address) info->si_addr; | |
| 295 | |
| 296 // check if fault address is within thread stack | |
| 297 if (addr < thread->stack_base() && | |
| 298 addr >= thread->stack_base() - thread->stack_size()) { | |
| 299 // stack overflow | |
| 300 if (thread->in_stack_yellow_zone(addr)) { | |
| 301 thread->disable_stack_yellow_zone(); | |
| 302 if (thread->thread_state() == _thread_in_Java) { | |
| 303 // Throw a stack overflow exception. Guard pages will be reenabled | |
| 304 // while unwinding the stack. | |
| 305 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW); | |
| 306 } else { | |
| 307 // Thread was in the vm or native code. Return and try to finish. | |
| 308 return 1; | |
| 309 } | |
| 310 } else if (thread->in_stack_red_zone(addr)) { | |
| 311 // Fatal red zone violation. Disable the guard pages and fall through | |
| 312 // to handle_unexpected_exception way down below. | |
| 313 thread->disable_stack_red_zone(); | |
| 314 tty->print_raw_cr("An irrecoverable stack overflow has occurred."); | |
| 315 } else { | |
| 316 // Accessing stack address below sp may cause SEGV if current | |
| 317 // thread has MAP_GROWSDOWN stack. This should only happen when | |
| 318 // current thread was created by user code with MAP_GROWSDOWN flag | |
| 319 // and then attached to VM. See notes in os_linux.cpp. | |
| 320 if (thread->osthread()->expanding_stack() == 0) { | |
| 321 thread->osthread()->set_expanding_stack(); | |
| 322 if (os::Linux::manually_expand_stack(thread, addr)) { | |
| 323 thread->osthread()->clear_expanding_stack(); | |
| 324 return 1; | |
| 325 } | |
| 326 thread->osthread()->clear_expanding_stack(); | |
| 327 } else { | |
| 328 fatal("recursive segv. expanding stack."); | |
| 329 } | |
| 330 } | |
| 331 } | |
| 332 } | |
| 333 | |
| 334 if (thread->thread_state() == _thread_in_Java) { | |
| 335 // Java thread running in Java code => find exception handler if any | |
| 336 // a fault inside compiled code, the interpreter, or a stub | |
| 337 | |
| 338 if (sig == SIGSEGV && os::is_poll_address((address)info->si_addr)) { | |
| 339 stub = SharedRuntime::get_poll_stub(pc); | |
| 340 } else if (sig == SIGBUS /* && info->si_code == BUS_OBJERR */) { | |
| 341 // BugId 4454115: A read from a MappedByteBuffer can fault | |
| 342 // here if the underlying file has been truncated. | |
| 343 // Do not crash the VM in such a case. | |
| 344 CodeBlob* cb = CodeCache::find_blob_unsafe(pc); | |
| 345 nmethod* nm = cb->is_nmethod() ? (nmethod*)cb : NULL; | |
| 346 if (nm != NULL && nm->has_unsafe_access()) { | |
| 347 stub = StubRoutines::handler_for_unsafe_access(); | |
| 348 } | |
| 349 } | |
| 350 else | |
| 351 | |
| 352 #ifdef AMD64 | |
| 353 if (sig == SIGFPE && | |
| 354 (info->si_code == FPE_INTDIV || info->si_code == FPE_FLTDIV)) { | |
| 355 stub = | |
| 356 SharedRuntime:: | |
| 357 continuation_for_implicit_exception(thread, | |
| 358 pc, | |
| 359 SharedRuntime:: | |
| 360 IMPLICIT_DIVIDE_BY_ZERO); | |
| 361 #else | |
| 362 if (sig == SIGFPE /* && info->si_code == FPE_INTDIV */) { | |
| 363 // HACK: si_code does not work on linux 2.2.12-20!!! | |
| 364 int op = pc[0]; | |
| 365 if (op == 0xDB) { | |
| 366 // FIST | |
| 367 // TODO: The encoding of D2I in i486.ad can cause an exception | |
| 368 // prior to the fist instruction if there was an invalid operation | |
| 369 // pending. We want to dismiss that exception. From the win_32 | |
| 370 // side it also seems that if it really was the fist causing | |
| 371 // the exception that we do the d2i by hand with different | |
| 372 // rounding. Seems kind of weird. | |
| 373 // NOTE: that we take the exception at the NEXT floating point instruction. | |
| 374 assert(pc[0] == 0xDB, "not a FIST opcode"); | |
| 375 assert(pc[1] == 0x14, "not a FIST opcode"); | |
| 376 assert(pc[2] == 0x24, "not a FIST opcode"); | |
| 377 return true; | |
| 378 } else if (op == 0xF7) { | |
| 379 // IDIV | |
| 380 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO); | |
| 381 } else { | |
| 382 // TODO: handle more cases if we are using other x86 instructions | |
| 383 // that can generate SIGFPE signal on linux. | |
| 384 tty->print_cr("unknown opcode 0x%X with SIGFPE.", op); | |
| 385 fatal("please update this code."); | |
| 386 } | |
| 387 #endif // AMD64 | |
| 388 } else if (sig == SIGSEGV && | |
| 389 !MacroAssembler::needs_explicit_null_check((intptr_t)info->si_addr)) { | |
| 390 // Determination of interpreter/vtable stub/compiled code null exception | |
| 391 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); | |
| 392 } | |
| 393 } else if (thread->thread_state() == _thread_in_vm && | |
| 394 sig == SIGBUS && /* info->si_code == BUS_OBJERR && */ | |
| 395 thread->doing_unsafe_access()) { | |
| 396 stub = StubRoutines::handler_for_unsafe_access(); | |
| 397 } | |
| 398 | |
| 399 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in | |
| 400 // and the heap gets shrunk before the field access. | |
| 401 if ((sig == SIGSEGV) || (sig == SIGBUS)) { | |
| 402 address addr = JNI_FastGetField::find_slowcase_pc(pc); | |
| 403 if (addr != (address)-1) { | |
| 404 stub = addr; | |
| 405 } | |
| 406 } | |
| 407 | |
| 408 // Check to see if we caught the safepoint code in the | |
| 409 // process of write protecting the memory serialization page. | |
| 410 // It write enables the page immediately after protecting it | |
| 411 // so we can just return to retry the write. | |
| 412 if ((sig == SIGSEGV) && | |
| 413 os::is_memory_serialize_page(thread, (address) info->si_addr)) { | |
| 414 // Block current thread until the memory serialize page permission restored. | |
| 415 os::block_on_serialize_page_trap(); | |
| 416 return true; | |
| 417 } | |
| 418 } | |
| 419 | |
| 420 #ifndef AMD64 | |
| 421 // Execution protection violation | |
| 422 // | |
| 423 // This should be kept as the last step in the triage. We don't | |
| 424 // have a dedicated trap number for a no-execute fault, so be | |
| 425 // conservative and allow other handlers the first shot. | |
| 426 // | |
| 427 // Note: We don't test that info->si_code == SEGV_ACCERR here. | |
| 428 // this si_code is so generic that it is almost meaningless; and | |
| 429 // the si_code for this condition may change in the future. | |
| 430 // Furthermore, a false-positive should be harmless. | |
| 431 if (UnguardOnExecutionViolation > 0 && | |
| 432 (sig == SIGSEGV || sig == SIGBUS) && | |
| 433 uc->uc_mcontext.gregs[REG_TRAPNO] == trap_page_fault) { | |
| 434 int page_size = os::vm_page_size(); | |
| 435 address addr = (address) info->si_addr; | |
| 436 address pc = os::Linux::ucontext_get_pc(uc); | |
| 437 // Make sure the pc and the faulting address are sane. | |
| 438 // | |
| 439 // If an instruction spans a page boundary, and the page containing | |
| 440 // the beginning of the instruction is executable but the following | |
| 441 // page is not, the pc and the faulting address might be slightly | |
| 442 // different - we still want to unguard the 2nd page in this case. | |
| 443 // | |
| 444 // 15 bytes seems to be a (very) safe value for max instruction size. | |
| 445 bool pc_is_near_addr = | |
| 446 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15); | |
| 447 bool instr_spans_page_boundary = | |
| 448 (align_size_down((intptr_t) pc ^ (intptr_t) addr, | |
| 449 (intptr_t) page_size) > 0); | |
| 450 | |
| 451 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) { | |
| 452 static volatile address last_addr = | |
| 453 (address) os::non_memory_address_word(); | |
| 454 | |
| 455 // In conservative mode, don't unguard unless the address is in the VM | |
| 456 if (addr != last_addr && | |
| 457 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) { | |
| 458 | |
|
477
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
196
diff
changeset
|
459 // Set memory to RWX and retry |
| 0 | 460 address page_start = |
| 461 (address) align_size_down((intptr_t) addr, (intptr_t) page_size); | |
|
477
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
196
diff
changeset
|
462 bool res = os::protect_memory((char*) page_start, page_size, |
|
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
196
diff
changeset
|
463 os::MEM_PROT_RWX); |
| 0 | 464 |
| 465 if (PrintMiscellaneous && Verbose) { | |
| 466 char buf[256]; | |
| 467 jio_snprintf(buf, sizeof(buf), "Execution protection violation " | |
| 468 "at " INTPTR_FORMAT | |
| 469 ", unguarding " INTPTR_FORMAT ": %s, errno=%d", addr, | |
| 470 page_start, (res ? "success" : "failed"), errno); | |
| 471 tty->print_raw_cr(buf); | |
| 472 } | |
| 473 stub = pc; | |
| 474 | |
| 475 // Set last_addr so if we fault again at the same address, we don't end | |
| 476 // up in an endless loop. | |
| 477 // | |
| 478 // There are two potential complications here. Two threads trapping at | |
| 479 // the same address at the same time could cause one of the threads to | |
| 480 // think it already unguarded, and abort the VM. Likely very rare. | |
| 481 // | |
| 482 // The other race involves two threads alternately trapping at | |
| 483 // different addresses and failing to unguard the page, resulting in | |
| 484 // an endless loop. This condition is probably even more unlikely than | |
| 485 // the first. | |
| 486 // | |
| 487 // Although both cases could be avoided by using locks or thread local | |
| 488 // last_addr, these solutions are unnecessary complication: this | |
| 489 // handler is a best-effort safety net, not a complete solution. It is | |
| 490 // disabled by default and should only be used as a workaround in case | |
| 491 // we missed any no-execute-unsafe VM code. | |
| 492 | |
| 493 last_addr = addr; | |
| 494 } | |
| 495 } | |
| 496 } | |
| 497 #endif // !AMD64 | |
| 498 | |
| 499 if (stub != NULL) { | |
| 500 // save all thread context in case we need to restore it | |
| 501 if (thread != NULL) thread->set_saved_exception_pc(pc); | |
| 502 | |
| 503 uc->uc_mcontext.gregs[REG_PC] = (greg_t)stub; | |
| 504 return true; | |
| 505 } | |
| 506 | |
| 507 // signal-chaining | |
| 508 if (os::Linux::chained_handler(sig, info, ucVoid)) { | |
| 509 return true; | |
| 510 } | |
| 511 | |
| 512 if (!abort_if_unrecognized) { | |
| 513 // caller wants another chance, so give it to him | |
| 514 return false; | |
| 515 } | |
| 516 | |
| 517 if (pc == NULL && uc != NULL) { | |
| 518 pc = os::Linux::ucontext_get_pc(uc); | |
| 519 } | |
| 520 | |
| 521 // unmask current signal | |
| 522 sigset_t newset; | |
| 523 sigemptyset(&newset); | |
| 524 sigaddset(&newset, sig); | |
| 525 sigprocmask(SIG_UNBLOCK, &newset, NULL); | |
| 526 | |
| 527 VMError err(t, sig, pc, info, ucVoid); | |
| 528 err.report_and_die(); | |
| 529 | |
| 530 ShouldNotReachHere(); | |
| 531 } | |
| 532 | |
| 533 void os::Linux::init_thread_fpu_state(void) { | |
| 534 #ifndef AMD64 | |
| 535 // set fpu to 53 bit precision | |
| 536 set_fpu_control_word(0x27f); | |
| 537 #endif // !AMD64 | |
| 538 } | |
| 539 | |
| 540 int os::Linux::get_fpu_control_word(void) { | |
| 541 #ifdef AMD64 | |
| 542 return 0; | |
| 543 #else | |
| 544 int fpu_control; | |
| 545 _FPU_GETCW(fpu_control); | |
| 546 return fpu_control & 0xffff; | |
| 547 #endif // AMD64 | |
| 548 } | |
| 549 | |
| 550 void os::Linux::set_fpu_control_word(int fpu_control) { | |
| 551 #ifndef AMD64 | |
| 552 _FPU_SETCW(fpu_control); | |
| 553 #endif // !AMD64 | |
| 554 } | |
| 555 | |
| 556 // Check that the linux kernel version is 2.4 or higher since earlier | |
| 557 // versions do not support SSE without patches. | |
| 558 bool os::supports_sse() { | |
| 559 #ifdef AMD64 | |
| 560 return true; | |
| 561 #else | |
| 562 struct utsname uts; | |
| 563 if( uname(&uts) != 0 ) return false; // uname fails? | |
| 564 char *minor_string; | |
| 565 int major = strtol(uts.release,&minor_string,10); | |
| 566 int minor = strtol(minor_string+1,NULL,10); | |
| 567 bool result = (major > 2 || (major==2 && minor >= 4)); | |
| 568 #ifndef PRODUCT | |
| 569 if (PrintMiscellaneous && Verbose) { | |
| 570 tty->print("OS version is %d.%d, which %s support SSE/SSE2\n", | |
| 571 major,minor, result ? "DOES" : "does NOT"); | |
| 572 } | |
| 573 #endif | |
| 574 return result; | |
| 575 #endif // AMD64 | |
| 576 } | |
| 577 | |
| 578 bool os::is_allocatable(size_t bytes) { | |
| 579 #ifdef AMD64 | |
| 580 // unused on amd64? | |
| 581 return true; | |
| 582 #else | |
| 583 | |
| 584 if (bytes < 2 * G) { | |
| 585 return true; | |
| 586 } | |
| 587 | |
| 588 char* addr = reserve_memory(bytes, NULL); | |
| 589 | |
| 590 if (addr != NULL) { | |
| 591 release_memory(addr, bytes); | |
| 592 } | |
| 593 | |
| 594 return addr != NULL; | |
| 595 #endif // AMD64 | |
| 596 } | |
| 597 | |
| 598 //////////////////////////////////////////////////////////////////////////////// | |
| 599 // thread stack | |
| 600 | |
| 601 #ifdef AMD64 | |
| 602 size_t os::Linux::min_stack_allowed = 64 * K; | |
| 603 | |
| 604 // amd64: pthread on amd64 is always in floating stack mode | |
| 605 bool os::Linux::supports_variable_stack_size() { return true; } | |
| 606 #else | |
| 607 size_t os::Linux::min_stack_allowed = (48 DEBUG_ONLY(+4))*K; | |
| 608 | |
|
50
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
609 #ifdef __GNUC__ |
| 0 | 610 #define GET_GS() ({int gs; __asm__ volatile("movw %%gs, %w0":"=q"(gs)); gs&0xffff;}) |
|
50
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
611 #endif |
| 0 | 612 |
| 613 // Test if pthread library can support variable thread stack size. LinuxThreads | |
| 614 // in fixed stack mode allocates 2M fixed slot for each thread. LinuxThreads | |
| 615 // in floating stack mode and NPTL support variable stack size. | |
| 616 bool os::Linux::supports_variable_stack_size() { | |
| 617 if (os::Linux::is_NPTL()) { | |
| 618 // NPTL, yes | |
| 619 return true; | |
| 620 | |
| 621 } else { | |
| 622 // Note: We can't control default stack size when creating a thread. | |
| 623 // If we use non-default stack size (pthread_attr_setstacksize), both | |
| 624 // floating stack and non-floating stack LinuxThreads will return the | |
| 625 // same value. This makes it impossible to implement this function by | |
| 626 // detecting thread stack size directly. | |
| 627 // | |
| 628 // An alternative approach is to check %gs. Fixed-stack LinuxThreads | |
| 629 // do not use %gs, so its value is 0. Floating-stack LinuxThreads use | |
| 630 // %gs (either as LDT selector or GDT selector, depending on kernel) | |
| 631 // to access thread specific data. | |
| 632 // | |
| 633 // Note that %gs is a reserved glibc register since early 2001, so | |
| 634 // applications are not allowed to change its value (Ulrich Drepper from | |
| 635 // Redhat confirmed that all known offenders have been modified to use | |
| 636 // either %fs or TSD). In the worst case scenario, when VM is embedded in | |
| 637 // a native application that plays with %gs, we might see non-zero %gs | |
| 638 // even LinuxThreads is running in fixed stack mode. As the result, we'll | |
| 639 // return true and skip _thread_safety_check(), so we may not be able to | |
| 640 // detect stack-heap collisions. But otherwise it's harmless. | |
| 641 // | |
|
50
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
642 #ifdef __GNUC__ |
| 0 | 643 return (GET_GS() != 0); |
|
50
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
644 #else |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
645 return false; |
|
485d403e94e1
6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents:
0
diff
changeset
|
646 #endif |
| 0 | 647 } |
| 648 } | |
| 649 #endif // AMD64 | |
| 650 | |
| 651 // return default stack size for thr_type | |
| 652 size_t os::Linux::default_stack_size(os::ThreadType thr_type) { | |
| 653 // default stack size (compiler thread needs larger stack) | |
| 654 #ifdef AMD64 | |
| 655 size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M); | |
| 656 #else | |
| 657 size_t s = (thr_type == os::compiler_thread ? 2 * M : 512 * K); | |
| 658 #endif // AMD64 | |
| 659 return s; | |
| 660 } | |
| 661 | |
| 662 size_t os::Linux::default_guard_size(os::ThreadType thr_type) { | |
| 663 // Creating guard page is very expensive. Java thread has HotSpot | |
| 664 // guard page, only enable glibc guard page for non-Java threads. | |
| 665 return (thr_type == java_thread ? 0 : page_size()); | |
| 666 } | |
| 667 | |
| 668 // Java thread: | |
| 669 // | |
| 670 // Low memory addresses | |
| 671 // +------------------------+ | |
| 672 // | |\ JavaThread created by VM does not have glibc | |
| 673 // | glibc guard page | - guard, attached Java thread usually has | |
| 674 // | |/ 1 page glibc guard. | |
| 675 // P1 +------------------------+ Thread::stack_base() - Thread::stack_size() | |
| 676 // | |\ | |
| 677 // | HotSpot Guard Pages | - red and yellow pages | |
| 678 // | |/ | |
| 679 // +------------------------+ JavaThread::stack_yellow_zone_base() | |
| 680 // | |\ | |
| 681 // | Normal Stack | - | |
| 682 // | |/ | |
| 683 // P2 +------------------------+ Thread::stack_base() | |
| 684 // | |
| 685 // Non-Java thread: | |
| 686 // | |
| 687 // Low memory addresses | |
| 688 // +------------------------+ | |
| 689 // | |\ | |
| 690 // | glibc guard page | - usually 1 page | |
| 691 // | |/ | |
| 692 // P1 +------------------------+ Thread::stack_base() - Thread::stack_size() | |
| 693 // | |\ | |
| 694 // | Normal Stack | - | |
| 695 // | |/ | |
| 696 // P2 +------------------------+ Thread::stack_base() | |
| 697 // | |
| 698 // ** P1 (aka bottom) and size ( P2 = P1 - size) are the address and stack size returned from | |
| 699 // pthread_attr_getstack() | |
| 700 | |
| 701 static void current_stack_region(address * bottom, size_t * size) { | |
| 702 if (os::Linux::is_initial_thread()) { | |
| 703 // initial thread needs special handling because pthread_getattr_np() | |
| 704 // may return bogus value. | |
| 705 *bottom = os::Linux::initial_thread_stack_bottom(); | |
| 706 *size = os::Linux::initial_thread_stack_size(); | |
| 707 } else { | |
| 708 pthread_attr_t attr; | |
| 709 | |
| 710 int rslt = pthread_getattr_np(pthread_self(), &attr); | |
| 711 | |
| 712 // JVM needs to know exact stack location, abort if it fails | |
| 713 if (rslt != 0) { | |
| 714 if (rslt == ENOMEM) { | |
| 715 vm_exit_out_of_memory(0, "pthread_getattr_np"); | |
| 716 } else { | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
579
diff
changeset
|
717 fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt)); |
| 0 | 718 } |
| 719 } | |
| 720 | |
| 721 if (pthread_attr_getstack(&attr, (void **)bottom, size) != 0) { | |
| 722 fatal("Can not locate current stack attributes!"); | |
| 723 } | |
| 724 | |
| 725 pthread_attr_destroy(&attr); | |
| 726 | |
| 727 } | |
| 728 assert(os::current_stack_pointer() >= *bottom && | |
| 729 os::current_stack_pointer() < *bottom + *size, "just checking"); | |
| 730 } | |
| 731 | |
| 732 address os::current_stack_base() { | |
| 733 address bottom; | |
| 734 size_t size; | |
| 735 current_stack_region(&bottom, &size); | |
| 736 return (bottom + size); | |
| 737 } | |
| 738 | |
| 739 size_t os::current_stack_size() { | |
| 740 // stack size includes normal stack and HotSpot guard pages | |
| 741 address bottom; | |
| 742 size_t size; | |
| 743 current_stack_region(&bottom, &size); | |
| 744 return size; | |
| 745 } | |
| 746 | |
| 747 ///////////////////////////////////////////////////////////////////////////// | |
| 748 // helper functions for fatal error handler | |
| 749 | |
| 750 void os::print_context(outputStream *st, void *context) { | |
| 751 if (context == NULL) return; | |
| 752 | |
| 753 ucontext_t *uc = (ucontext_t*)context; | |
| 754 st->print_cr("Registers:"); | |
| 755 #ifdef AMD64 | |
| 756 st->print( "RAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RAX]); | |
| 757 st->print(", RBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBX]); | |
| 758 st->print(", RCX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RCX]); | |
| 759 st->print(", RDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDX]); | |
| 760 st->cr(); | |
| 761 st->print( "RSP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSP]); | |
| 762 st->print(", RBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBP]); | |
| 763 st->print(", RSI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSI]); | |
| 764 st->print(", RDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDI]); | |
| 765 st->cr(); | |
| 766 st->print( "R8 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R8]); | |
| 767 st->print(", R9 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R9]); | |
| 768 st->print(", R10=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R10]); | |
| 769 st->print(", R11=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R11]); | |
| 770 st->cr(); | |
| 771 st->print( "R12=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R12]); | |
| 772 st->print(", R13=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R13]); | |
| 773 st->print(", R14=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R14]); | |
| 774 st->print(", R15=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R15]); | |
| 775 st->cr(); | |
| 776 st->print( "RIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RIP]); | |
| 1907 | 777 st->print(", EFLAGS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EFL]); |
| 0 | 778 st->print(", CSGSFS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_CSGSFS]); |
| 779 st->print(", ERR=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ERR]); | |
| 780 st->cr(); | |
| 781 st->print(" TRAPNO=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_TRAPNO]); | |
| 782 #else | |
| 783 st->print( "EAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EAX]); | |
| 784 st->print(", EBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EBX]); | |
| 785 st->print(", ECX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ECX]); | |
| 786 st->print(", EDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EDX]); | |
| 787 st->cr(); | |
| 788 st->print( "ESP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_UESP]); | |
| 789 st->print(", EBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EBP]); | |
| 790 st->print(", ESI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ESI]); | |
| 791 st->print(", EDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EDI]); | |
| 792 st->cr(); | |
| 793 st->print( "EIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EIP]); | |
| 1907 | 794 st->print(", EFLAGS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EFL]); |
| 0 | 795 st->print(", CR2=" INTPTR_FORMAT, uc->uc_mcontext.cr2); |
| 796 #endif // AMD64 | |
| 797 st->cr(); | |
| 798 st->cr(); | |
| 799 | |
| 800 intptr_t *sp = (intptr_t *)os::Linux::ucontext_get_sp(uc); | |
| 801 st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", sp); | |
| 802 print_hex_dump(st, (address)sp, (address)(sp + 8*sizeof(intptr_t)), sizeof(intptr_t)); | |
| 803 st->cr(); | |
| 804 | |
| 805 // Note: it may be unsafe to inspect memory near pc. For example, pc may | |
| 806 // point to garbage if entry point in an nmethod is corrupted. Leave | |
| 807 // this at the end, and hope for the best. | |
| 808 address pc = os::Linux::ucontext_get_pc(uc); | |
| 809 st->print_cr("Instructions: (pc=" PTR_FORMAT ")", pc); | |
| 1907 | 810 print_hex_dump(st, pc - 32, pc + 32, sizeof(char)); |
| 811 } | |
| 812 | |
| 813 void os::print_register_info(outputStream *st, void *context) { | |
| 814 if (context == NULL) return; | |
| 815 | |
| 816 ucontext_t *uc = (ucontext_t*)context; | |
| 817 | |
| 818 st->print_cr("Register to memory mapping:"); | |
| 819 st->cr(); | |
| 820 | |
| 821 // this is horrendously verbose but the layout of the registers in the | |
| 822 // context does not match how we defined our abstract Register set, so | |
| 823 // we can't just iterate through the gregs area | |
| 824 | |
| 825 // this is only for the "general purpose" registers | |
| 826 | |
| 827 #ifdef AMD64 | |
| 828 st->print("RAX="); print_location(st, uc->uc_mcontext.gregs[REG_RAX]); | |
| 829 st->print("RBX="); print_location(st, uc->uc_mcontext.gregs[REG_RBX]); | |
| 830 st->print("RCX="); print_location(st, uc->uc_mcontext.gregs[REG_RCX]); | |
| 831 st->print("RDX="); print_location(st, uc->uc_mcontext.gregs[REG_RDX]); | |
| 832 st->print("RSP="); print_location(st, uc->uc_mcontext.gregs[REG_RSP]); | |
| 833 st->print("RBP="); print_location(st, uc->uc_mcontext.gregs[REG_RBP]); | |
| 834 st->print("RSI="); print_location(st, uc->uc_mcontext.gregs[REG_RSI]); | |
| 835 st->print("RDI="); print_location(st, uc->uc_mcontext.gregs[REG_RDI]); | |
| 836 st->print("R8 ="); print_location(st, uc->uc_mcontext.gregs[REG_R8]); | |
| 837 st->print("R9 ="); print_location(st, uc->uc_mcontext.gregs[REG_R9]); | |
| 838 st->print("R10="); print_location(st, uc->uc_mcontext.gregs[REG_R10]); | |
| 839 st->print("R11="); print_location(st, uc->uc_mcontext.gregs[REG_R11]); | |
| 840 st->print("R12="); print_location(st, uc->uc_mcontext.gregs[REG_R12]); | |
| 841 st->print("R13="); print_location(st, uc->uc_mcontext.gregs[REG_R13]); | |
| 842 st->print("R14="); print_location(st, uc->uc_mcontext.gregs[REG_R14]); | |
| 843 st->print("R15="); print_location(st, uc->uc_mcontext.gregs[REG_R15]); | |
| 844 #else | |
| 845 st->print("EAX="); print_location(st, uc->uc_mcontext.gregs[REG_EAX]); | |
| 846 st->print("EBX="); print_location(st, uc->uc_mcontext.gregs[REG_EBX]); | |
| 847 st->print("ECX="); print_location(st, uc->uc_mcontext.gregs[REG_ECX]); | |
| 848 st->print("EDX="); print_location(st, uc->uc_mcontext.gregs[REG_EDX]); | |
| 849 st->print("ESP="); print_location(st, uc->uc_mcontext.gregs[REG_ESP]); | |
| 850 st->print("EBP="); print_location(st, uc->uc_mcontext.gregs[REG_EBP]); | |
| 851 st->print("ESI="); print_location(st, uc->uc_mcontext.gregs[REG_ESI]); | |
| 852 st->print("EDI="); print_location(st, uc->uc_mcontext.gregs[REG_EDI]); | |
| 853 #endif // AMD64 | |
| 854 | |
| 855 st->cr(); | |
| 0 | 856 } |
| 857 | |
| 858 void os::setup_fpu() { | |
| 859 #ifndef AMD64 | |
| 860 address fpu_cntrl = StubRoutines::addr_fpu_cntrl_wrd_std(); | |
| 861 __asm__ volatile ( "fldcw (%0)" : | |
| 862 : "r" (fpu_cntrl) : "memory"); | |
| 863 #endif // !AMD64 | |
| 864 } |