Mercurial > hg > truffle
annotate src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp @ 14304:a2866d45e99e
8027454: Do not traverse string table during G1 remark when treating them as strong roots during initial mark
Summary: Do not try to unlink string table entries unconditionally during remark. This is without side effects as the preceding initial mark always uses the string table as strong roots. Needs to be fixed with class unloading during concurrent mark.
Reviewed-by: brutisso, mgerdin
| author | tschatzl |
|---|---|
| date | Mon, 20 Jan 2014 11:47:29 +0100 |
| parents | af21010d1062 |
| children | 2c2a99f6cf83 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 10405 | 2 * Copyright (c) 1999, 2013, 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:
1250
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1250
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:
1250
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 // no precompiled headers |
|
7199
cd3d6a6b95d9
8003240: x86: move MacroAssembler into separate file
twisti
parents:
6842
diff
changeset
|
26 #include "asm/macroAssembler.hpp" |
| 1972 | 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_solaris.h" | |
| 34 #include "memory/allocation.inline.hpp" | |
| 35 #include "mutex_solaris.inline.hpp" | |
| 36 #include "os_share_solaris.hpp" | |
| 37 #include "prims/jniFastGetField.hpp" | |
| 38 #include "prims/jvm.h" | |
| 39 #include "prims/jvm_misc.hpp" | |
| 40 #include "runtime/arguments.hpp" | |
| 41 #include "runtime/extendedPC.hpp" | |
| 42 #include "runtime/frame.inline.hpp" | |
| 43 #include "runtime/interfaceSupport.hpp" | |
| 44 #include "runtime/java.hpp" | |
| 45 #include "runtime/javaCalls.hpp" | |
| 46 #include "runtime/mutexLocker.hpp" | |
| 47 #include "runtime/osThread.hpp" | |
| 48 #include "runtime/sharedRuntime.hpp" | |
| 49 #include "runtime/stubRoutines.hpp" | |
|
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6842
diff
changeset
|
50 #include "runtime/thread.inline.hpp" |
| 1972 | 51 #include "runtime/timer.hpp" |
| 52 #include "utilities/events.hpp" | |
| 53 #include "utilities/vmError.hpp" | |
| 0 | 54 |
| 55 // put OS-includes here | |
| 56 # include <sys/types.h> | |
| 57 # include <sys/mman.h> | |
| 58 # include <pthread.h> | |
| 59 # include <signal.h> | |
| 60 # include <setjmp.h> | |
| 61 # include <errno.h> | |
| 62 # include <dlfcn.h> | |
| 63 # include <stdio.h> | |
| 64 # include <unistd.h> | |
| 65 # include <sys/resource.h> | |
| 66 # include <thread.h> | |
| 67 # include <sys/stat.h> | |
| 68 # include <sys/time.h> | |
| 69 # include <sys/filio.h> | |
| 70 # include <sys/utsname.h> | |
| 71 # include <sys/systeminfo.h> | |
| 72 # include <sys/socket.h> | |
| 73 # include <sys/trap.h> | |
| 74 # include <sys/lwp.h> | |
| 75 # include <pwd.h> | |
| 76 # include <poll.h> | |
| 77 # include <sys/lwp.h> | |
| 78 # include <procfs.h> // see comment in <sys/procfs.h> | |
| 79 | |
| 80 #ifndef AMD64 | |
| 81 // QQQ seems useless at this point | |
| 82 # define _STRUCTURED_PROC 1 // this gets us the new structured proc interfaces of 5.6 & later | |
| 83 #endif // AMD64 | |
| 84 # include <sys/procfs.h> // see comment in <sys/procfs.h> | |
| 85 | |
| 86 | |
| 87 #define MAX_PATH (2 * K) | |
| 88 | |
| 89 // Minimum stack size for the VM. It's easier to document a constant value | |
| 90 // but it's different for x86 and sparc because the page sizes are different. | |
| 91 #ifdef AMD64 | |
| 92 size_t os::Solaris::min_stack_allowed = 224*K; | |
| 93 #define REG_SP REG_RSP | |
| 94 #define REG_PC REG_RIP | |
| 95 #define REG_FP REG_RBP | |
| 96 #else | |
| 97 size_t os::Solaris::min_stack_allowed = 64*K; | |
| 98 #define REG_SP UESP | |
| 99 #define REG_PC EIP | |
| 100 #define REG_FP EBP | |
| 101 // 4900493 counter to prevent runaway LDTR refresh attempt | |
| 102 | |
| 103 static volatile int ldtr_refresh = 0; | |
| 104 // the libthread instruction that faults because of the stale LDTR | |
| 105 | |
| 106 static const unsigned char movlfs[] = { 0x8e, 0xe0 // movl %eax,%fs | |
| 107 }; | |
| 108 #endif // AMD64 | |
| 109 | |
| 110 char* os::non_memory_address_word() { | |
| 111 // Must never look like an address returned by reserve_memory, | |
| 112 // even in its subfields (as defined by the CPU immediate fields, | |
| 113 // if the CPU splits constants across multiple instructions). | |
| 114 return (char*) -1; | |
| 115 } | |
| 116 | |
| 117 // | |
| 118 // Validate a ucontext retrieved from walking a uc_link of a ucontext. | |
| 119 // There are issues with libthread giving out uc_links for different threads | |
| 120 // on the same uc_link chain and bad or circular links. | |
| 121 // | |
| 122 bool os::Solaris::valid_ucontext(Thread* thread, ucontext_t* valid, ucontext_t* suspect) { | |
| 123 if (valid >= suspect || | |
| 124 valid->uc_stack.ss_flags != suspect->uc_stack.ss_flags || | |
| 125 valid->uc_stack.ss_sp != suspect->uc_stack.ss_sp || | |
| 126 valid->uc_stack.ss_size != suspect->uc_stack.ss_size) { | |
| 127 DEBUG_ONLY(tty->print_cr("valid_ucontext: failed test 1");) | |
| 128 return false; | |
| 129 } | |
| 130 | |
| 131 if (thread->is_Java_thread()) { | |
| 132 if (!valid_stack_address(thread, (address)suspect)) { | |
| 133 DEBUG_ONLY(tty->print_cr("valid_ucontext: uc_link not in thread stack");) | |
| 134 return false; | |
| 135 } | |
| 136 if (!valid_stack_address(thread, (address) suspect->uc_mcontext.gregs[REG_SP])) { | |
| 137 DEBUG_ONLY(tty->print_cr("valid_ucontext: stackpointer not in thread stack");) | |
| 138 return false; | |
| 139 } | |
| 140 } | |
| 141 return true; | |
| 142 } | |
| 143 | |
| 144 // We will only follow one level of uc_link since there are libthread | |
| 145 // issues with ucontext linking and it is better to be safe and just | |
| 146 // let caller retry later. | |
| 147 ucontext_t* os::Solaris::get_valid_uc_in_signal_handler(Thread *thread, | |
| 148 ucontext_t *uc) { | |
| 149 | |
| 150 ucontext_t *retuc = NULL; | |
| 151 | |
| 152 if (uc != NULL) { | |
| 153 if (uc->uc_link == NULL) { | |
| 154 // cannot validate without uc_link so accept current ucontext | |
| 155 retuc = uc; | |
| 156 } else if (os::Solaris::valid_ucontext(thread, uc, uc->uc_link)) { | |
| 157 // first ucontext is valid so try the next one | |
| 158 uc = uc->uc_link; | |
| 159 if (uc->uc_link == NULL) { | |
| 160 // cannot validate without uc_link so accept current ucontext | |
| 161 retuc = uc; | |
| 162 } else if (os::Solaris::valid_ucontext(thread, uc, uc->uc_link)) { | |
| 163 // the ucontext one level down is also valid so return it | |
| 164 retuc = uc; | |
| 165 } | |
| 166 } | |
| 167 } | |
| 168 return retuc; | |
| 169 } | |
| 170 | |
| 171 // Assumes ucontext is valid | |
| 172 ExtendedPC os::Solaris::ucontext_get_ExtendedPC(ucontext_t *uc) { | |
| 173 return ExtendedPC((address)uc->uc_mcontext.gregs[REG_PC]); | |
| 174 } | |
| 175 | |
| 176 // Assumes ucontext is valid | |
| 177 intptr_t* os::Solaris::ucontext_get_sp(ucontext_t *uc) { | |
| 178 return (intptr_t*)uc->uc_mcontext.gregs[REG_SP]; | |
| 179 } | |
| 180 | |
| 181 // Assumes ucontext is valid | |
| 182 intptr_t* os::Solaris::ucontext_get_fp(ucontext_t *uc) { | |
| 183 return (intptr_t*)uc->uc_mcontext.gregs[REG_FP]; | |
| 184 } | |
| 185 | |
| 10405 | 186 address os::Solaris::ucontext_get_pc(ucontext_t *uc) { |
| 187 return (address) uc->uc_mcontext.gregs[REG_PC]; | |
| 188 } | |
| 189 | |
| 0 | 190 // For Forte Analyzer AsyncGetCallTrace profiling support - thread |
| 191 // is currently interrupted by SIGPROF. | |
| 192 // | |
| 193 // The difference between this and os::fetch_frame_from_context() is that | |
| 194 // here we try to skip nested signal frames. | |
| 195 ExtendedPC os::Solaris::fetch_frame_from_ucontext(Thread* thread, | |
| 196 ucontext_t* uc, intptr_t** ret_sp, intptr_t** ret_fp) { | |
| 197 | |
| 198 assert(thread != NULL, "just checking"); | |
| 199 assert(ret_sp != NULL, "just checking"); | |
| 200 assert(ret_fp != NULL, "just checking"); | |
| 201 | |
| 202 ucontext_t *luc = os::Solaris::get_valid_uc_in_signal_handler(thread, uc); | |
| 203 return os::fetch_frame_from_context(luc, ret_sp, ret_fp); | |
| 204 } | |
| 205 | |
| 206 ExtendedPC os::fetch_frame_from_context(void* ucVoid, | |
| 207 intptr_t** ret_sp, intptr_t** ret_fp) { | |
| 208 | |
| 209 ExtendedPC epc; | |
| 210 ucontext_t *uc = (ucontext_t*)ucVoid; | |
| 211 | |
| 212 if (uc != NULL) { | |
| 213 epc = os::Solaris::ucontext_get_ExtendedPC(uc); | |
| 214 if (ret_sp) *ret_sp = os::Solaris::ucontext_get_sp(uc); | |
| 215 if (ret_fp) *ret_fp = os::Solaris::ucontext_get_fp(uc); | |
| 216 } else { | |
| 217 // construct empty ExtendedPC for return value checking | |
| 218 epc = ExtendedPC(NULL); | |
| 219 if (ret_sp) *ret_sp = (intptr_t *)NULL; | |
| 220 if (ret_fp) *ret_fp = (intptr_t *)NULL; | |
| 221 } | |
| 222 | |
| 223 return epc; | |
| 224 } | |
| 225 | |
| 226 frame os::fetch_frame_from_context(void* ucVoid) { | |
| 227 intptr_t* sp; | |
| 228 intptr_t* fp; | |
| 229 ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp); | |
| 230 return frame(sp, fp, epc.pc()); | |
| 231 } | |
| 232 | |
| 233 frame os::get_sender_for_C_frame(frame* fr) { | |
| 234 return frame(fr->sender_sp(), fr->link(), fr->sender_pc()); | |
| 235 } | |
| 236 | |
|
5903
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
237 extern "C" intptr_t *_get_current_sp(); // in .il file |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
238 |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
239 address os::current_stack_pointer() { |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
240 return (address)_get_current_sp(); |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
241 } |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
242 |
|
472
7b920868b475
6773838: There is no calling stack for Compiler thread in hs_err file on x86
coleenp
parents:
196
diff
changeset
|
243 extern "C" intptr_t *_get_current_fp(); // in .il file |
| 0 | 244 |
| 245 frame os::current_frame() { | |
|
472
7b920868b475
6773838: There is no calling stack for Compiler thread in hs_err file on x86
coleenp
parents:
196
diff
changeset
|
246 intptr_t* fp = _get_current_fp(); // it's inlined so want current fp |
| 0 | 247 frame myframe((intptr_t*)os::current_stack_pointer(), |
| 248 (intptr_t*)fp, | |
| 249 CAST_FROM_FN_PTR(address, os::current_frame)); | |
| 250 if (os::is_first_C_frame(&myframe)) { | |
| 251 // stack is not walkable | |
|
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
252 frame ret; // This will be a null useless frame |
|
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
253 return ret; |
| 0 | 254 } else { |
| 255 return os::get_sender_for_C_frame(&myframe); | |
| 256 } | |
| 257 } | |
| 258 | |
| 259 static int threadgetstate(thread_t tid, int *flags, lwpid_t *lwp, stack_t *ss, gregset_t rs, lwpstatus_t *lwpstatus) { | |
| 260 char lwpstatusfile[PROCFILE_LENGTH]; | |
| 261 int lwpfd, err; | |
| 262 | |
| 263 if (err = os::Solaris::thr_getstate(tid, flags, lwp, ss, rs)) | |
| 264 return (err); | |
| 265 if (*flags == TRS_LWPID) { | |
| 266 sprintf(lwpstatusfile, "/proc/%d/lwp/%d/lwpstatus", getpid(), | |
| 267 *lwp); | |
| 268 if ((lwpfd = open(lwpstatusfile, O_RDONLY)) < 0) { | |
| 269 perror("thr_mutator_status: open lwpstatus"); | |
| 270 return (EINVAL); | |
| 271 } | |
| 272 if (pread(lwpfd, lwpstatus, sizeof (lwpstatus_t), (off_t)0) != | |
| 273 sizeof (lwpstatus_t)) { | |
| 274 perror("thr_mutator_status: read lwpstatus"); | |
| 275 (void) close(lwpfd); | |
| 276 return (EINVAL); | |
| 277 } | |
| 278 (void) close(lwpfd); | |
| 279 } | |
| 280 return (0); | |
| 281 } | |
| 282 | |
| 283 #ifndef AMD64 | |
| 284 | |
| 285 // Detecting SSE support by OS | |
| 286 // From solaris_i486.s | |
| 287 extern "C" bool sse_check(); | |
| 288 extern "C" bool sse_unavailable(); | |
| 289 | |
| 290 enum { SSE_UNKNOWN, SSE_NOT_SUPPORTED, SSE_SUPPORTED}; | |
| 291 static int sse_status = SSE_UNKNOWN; | |
| 292 | |
| 293 | |
| 294 static void check_for_sse_support() { | |
| 295 if (!VM_Version::supports_sse()) { | |
| 296 sse_status = SSE_NOT_SUPPORTED; | |
| 297 return; | |
| 298 } | |
| 299 // looking for _sse_hw in libc.so, if it does not exist or | |
| 300 // the value (int) is 0, OS has no support for SSE | |
| 301 int *sse_hwp; | |
| 302 void *h; | |
| 303 | |
| 304 if ((h=dlopen("/usr/lib/libc.so", RTLD_LAZY)) == NULL) { | |
| 305 //open failed, presume no support for SSE | |
| 306 sse_status = SSE_NOT_SUPPORTED; | |
| 307 return; | |
| 308 } | |
| 309 if ((sse_hwp = (int *)dlsym(h, "_sse_hw")) == NULL) { | |
| 310 sse_status = SSE_NOT_SUPPORTED; | |
| 311 } else if (*sse_hwp == 0) { | |
| 312 sse_status = SSE_NOT_SUPPORTED; | |
| 313 } | |
| 314 dlclose(h); | |
| 315 | |
| 316 if (sse_status == SSE_UNKNOWN) { | |
| 317 bool (*try_sse)() = (bool (*)())sse_check; | |
| 318 sse_status = (*try_sse)() ? SSE_SUPPORTED : SSE_NOT_SUPPORTED; | |
| 319 } | |
| 320 | |
| 321 } | |
| 322 | |
| 585 | 323 #endif // AMD64 |
| 324 | |
| 0 | 325 bool os::supports_sse() { |
| 585 | 326 #ifdef AMD64 |
| 327 return true; | |
| 328 #else | |
| 0 | 329 if (sse_status == SSE_UNKNOWN) |
| 330 check_for_sse_support(); | |
| 331 return sse_status == SSE_SUPPORTED; | |
| 585 | 332 #endif // AMD64 |
| 0 | 333 } |
| 334 | |
| 335 bool os::is_allocatable(size_t bytes) { | |
| 336 #ifdef AMD64 | |
| 337 return true; | |
| 338 #else | |
| 339 | |
| 340 if (bytes < 2 * G) { | |
| 341 return true; | |
| 342 } | |
| 343 | |
| 344 char* addr = reserve_memory(bytes, NULL); | |
| 345 | |
| 346 if (addr != NULL) { | |
| 347 release_memory(addr, bytes); | |
| 348 } | |
| 349 | |
| 350 return addr != NULL; | |
| 351 #endif // AMD64 | |
| 352 | |
| 353 } | |
| 354 | |
| 2191 | 355 extern "C" JNIEXPORT int |
| 356 JVM_handle_solaris_signal(int sig, siginfo_t* info, void* ucVoid, | |
| 357 int abort_if_unrecognized) { | |
| 0 | 358 ucontext_t* uc = (ucontext_t*) ucVoid; |
| 359 | |
| 360 #ifndef AMD64 | |
| 361 if (sig == SIGILL && info->si_addr == (caddr_t)sse_check) { | |
| 362 // the SSE instruction faulted. supports_sse() need return false. | |
| 363 uc->uc_mcontext.gregs[EIP] = (greg_t)sse_unavailable; | |
| 364 return true; | |
| 365 } | |
| 366 #endif // !AMD64 | |
| 367 | |
| 368 Thread* t = ThreadLocalStorage::get_thread_slow(); // slow & steady | |
| 369 | |
| 11151 | 370 // Must do this before SignalHandlerMark, if crash protection installed we will longjmp away |
| 371 // (no destructors can be run) | |
| 372 os::WatcherThreadCrashProtection::check_crash_protection(sig, t); | |
| 373 | |
| 0 | 374 SignalHandlerMark shm(t); |
| 375 | |
| 376 if(sig == SIGPIPE || sig == SIGXFSZ) { | |
| 377 if (os::Solaris::chained_handler(sig, info, ucVoid)) { | |
| 378 return true; | |
| 379 } else { | |
| 380 if (PrintMiscellaneous && (WizardMode || Verbose)) { | |
| 381 char buf[64]; | |
| 382 warning("Ignoring %s - see 4229104 or 6499219", | |
| 383 os::exception_name(sig, buf, sizeof(buf))); | |
| 384 | |
| 385 } | |
| 386 return true; | |
| 387 } | |
| 388 } | |
| 389 | |
| 390 JavaThread* thread = NULL; | |
| 391 VMThread* vmthread = NULL; | |
| 392 | |
| 393 if (os::Solaris::signal_handlers_are_installed) { | |
| 394 if (t != NULL ){ | |
| 395 if(t->is_Java_thread()) { | |
| 396 thread = (JavaThread*)t; | |
| 397 } | |
| 398 else if(t->is_VM_thread()){ | |
| 399 vmthread = (VMThread *)t; | |
| 400 } | |
| 401 } | |
| 402 } | |
| 403 | |
| 404 guarantee(sig != os::Solaris::SIGinterrupt(), "Can not chain VM interrupt signal, try -XX:+UseAltSigs"); | |
| 405 | |
| 406 if (sig == os::Solaris::SIGasync()) { | |
| 10405 | 407 if(thread || vmthread){ |
| 408 OSThread::SR_handler(t, uc); | |
| 0 | 409 return true; |
| 410 } else if (os::Solaris::chained_handler(sig, info, ucVoid)) { | |
| 411 return true; | |
| 412 } else { | |
| 413 // If os::Solaris::SIGasync not chained, and this is a non-vm and | |
| 414 // non-java thread | |
| 415 return true; | |
| 416 } | |
| 417 } | |
| 418 | |
| 419 if (info == NULL || info->si_code <= 0 || info->si_code == SI_NOINFO) { | |
| 420 // can't decode this kind of signal | |
| 421 info = NULL; | |
| 422 } else { | |
| 423 assert(sig == info->si_signo, "bad siginfo"); | |
| 424 } | |
| 425 | |
| 426 // decide if this trap can be handled by a stub | |
| 427 address stub = NULL; | |
| 428 | |
| 429 address pc = NULL; | |
| 430 | |
| 431 //%note os_trap_1 | |
| 432 if (info != NULL && uc != NULL && thread != NULL) { | |
| 433 // factor me: getPCfromContext | |
| 434 pc = (address) uc->uc_mcontext.gregs[REG_PC]; | |
| 435 | |
| 11127 | 436 if (StubRoutines::is_safefetch_fault(pc)) { |
| 437 uc->uc_mcontext.gregs[REG_PC] = intptr_t(StubRoutines::continuation_for_safefetch_fault(pc)); | |
| 438 return true; | |
| 0 | 439 } |
| 440 | |
| 441 // Handle ALL stack overflow variations here | |
| 442 if (sig == SIGSEGV && info->si_code == SEGV_ACCERR) { | |
| 443 address addr = (address) info->si_addr; | |
| 444 if (thread->in_stack_yellow_zone(addr)) { | |
| 445 thread->disable_stack_yellow_zone(); | |
| 446 if (thread->thread_state() == _thread_in_Java) { | |
| 447 // Throw a stack overflow exception. Guard pages will be reenabled | |
| 448 // while unwinding the stack. | |
| 449 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW); | |
| 450 } else { | |
| 451 // Thread was in the vm or native code. Return and try to finish. | |
| 452 return true; | |
| 453 } | |
| 454 } else if (thread->in_stack_red_zone(addr)) { | |
| 455 // Fatal red zone violation. Disable the guard pages and fall through | |
| 456 // to handle_unexpected_exception way down below. | |
| 457 thread->disable_stack_red_zone(); | |
| 458 tty->print_raw_cr("An irrecoverable stack overflow has occurred."); | |
| 459 } | |
| 460 } | |
| 461 | |
| 462 if (thread->thread_state() == _thread_in_vm) { | |
| 463 if (sig == SIGBUS && info->si_code == BUS_OBJERR && thread->doing_unsafe_access()) { | |
| 464 stub = StubRoutines::handler_for_unsafe_access(); | |
| 465 } | |
| 466 } | |
| 467 | |
| 468 if (thread->thread_state() == _thread_in_Java) { | |
| 469 // Support Safepoint Polling | |
| 470 if ( sig == SIGSEGV && os::is_poll_address((address)info->si_addr)) { | |
| 471 stub = SharedRuntime::get_poll_stub(pc); | |
| 472 } | |
| 473 else if (sig == SIGBUS && info->si_code == BUS_OBJERR) { | |
| 474 // BugId 4454115: A read from a MappedByteBuffer can fault | |
| 475 // here if the underlying file has been truncated. | |
| 476 // Do not crash the VM in such a case. | |
| 477 CodeBlob* cb = CodeCache::find_blob_unsafe(pc); | |
| 478 nmethod* nm = cb->is_nmethod() ? (nmethod*)cb : NULL; | |
| 479 if (nm != NULL && nm->has_unsafe_access()) { | |
| 480 stub = StubRoutines::handler_for_unsafe_access(); | |
| 481 } | |
| 482 } | |
| 483 else | |
| 484 if (sig == SIGFPE && info->si_code == FPE_INTDIV) { | |
| 485 // integer divide by zero | |
| 486 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO); | |
| 487 } | |
| 488 #ifndef AMD64 | |
| 489 else if (sig == SIGFPE && info->si_code == FPE_FLTDIV) { | |
| 490 // floating-point divide by zero | |
| 491 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO); | |
| 492 } | |
| 493 else if (sig == SIGFPE && info->si_code == FPE_FLTINV) { | |
| 494 // The encoding of D2I in i486.ad can cause an exception prior | |
| 495 // to the fist instruction if there was an invalid operation | |
| 496 // pending. We want to dismiss that exception. From the win_32 | |
| 497 // side it also seems that if it really was the fist causing | |
| 498 // the exception that we do the d2i by hand with different | |
| 499 // rounding. Seems kind of weird. QQQ TODO | |
| 500 // Note that we take the exception at the NEXT floating point instruction. | |
| 501 if (pc[0] == 0xDB) { | |
| 502 assert(pc[0] == 0xDB, "not a FIST opcode"); | |
| 503 assert(pc[1] == 0x14, "not a FIST opcode"); | |
| 504 assert(pc[2] == 0x24, "not a FIST opcode"); | |
| 505 return true; | |
| 506 } else { | |
| 507 assert(pc[-3] == 0xDB, "not an flt invalid opcode"); | |
| 508 assert(pc[-2] == 0x14, "not an flt invalid opcode"); | |
| 509 assert(pc[-1] == 0x24, "not an flt invalid opcode"); | |
| 510 } | |
| 511 } | |
| 512 else if (sig == SIGFPE ) { | |
| 513 tty->print_cr("caught SIGFPE, info 0x%x.", info->si_code); | |
| 514 } | |
| 515 #endif // !AMD64 | |
| 516 | |
| 517 // QQQ It doesn't seem that we need to do this on x86 because we should be able | |
| 518 // to return properly from the handler without this extra stuff on the back side. | |
| 519 | |
| 520 else if (sig == SIGSEGV && info->si_code > 0 && !MacroAssembler::needs_explicit_null_check((intptr_t)info->si_addr)) { | |
| 521 // Determination of interpreter/vtable stub/compiled code null exception | |
| 522 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); | |
| 523 } | |
| 524 } | |
| 525 | |
| 526 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in | |
| 527 // and the heap gets shrunk before the field access. | |
| 528 if ((sig == SIGSEGV) || (sig == SIGBUS)) { | |
| 529 address addr = JNI_FastGetField::find_slowcase_pc(pc); | |
| 530 if (addr != (address)-1) { | |
| 531 stub = addr; | |
| 532 } | |
| 533 } | |
| 534 | |
| 535 // Check to see if we caught the safepoint code in the | |
| 536 // process of write protecting the memory serialization page. | |
| 537 // It write enables the page immediately after protecting it | |
| 538 // so we can just return to retry the write. | |
| 539 if ((sig == SIGSEGV) && | |
| 540 os::is_memory_serialize_page(thread, (address)info->si_addr)) { | |
| 541 // Block current thread until the memory serialize page permission restored. | |
| 542 os::block_on_serialize_page_trap(); | |
| 543 return true; | |
| 544 } | |
| 545 } | |
| 546 | |
| 547 // Execution protection violation | |
| 548 // | |
| 549 // Preventative code for future versions of Solaris which may | |
| 550 // enable execution protection when running the 32-bit VM on AMD64. | |
| 551 // | |
| 552 // This should be kept as the last step in the triage. We don't | |
| 553 // have a dedicated trap number for a no-execute fault, so be | |
| 554 // conservative and allow other handlers the first shot. | |
| 555 // | |
| 556 // Note: We don't test that info->si_code == SEGV_ACCERR here. | |
| 557 // this si_code is so generic that it is almost meaningless; and | |
| 558 // the si_code for this condition may change in the future. | |
| 559 // Furthermore, a false-positive should be harmless. | |
| 560 if (UnguardOnExecutionViolation > 0 && | |
| 561 (sig == SIGSEGV || sig == SIGBUS) && | |
| 562 uc->uc_mcontext.gregs[TRAPNO] == T_PGFLT) { // page fault | |
| 563 int page_size = os::vm_page_size(); | |
| 564 address addr = (address) info->si_addr; | |
| 565 address pc = (address) uc->uc_mcontext.gregs[REG_PC]; | |
| 566 // Make sure the pc and the faulting address are sane. | |
| 567 // | |
| 568 // If an instruction spans a page boundary, and the page containing | |
| 569 // the beginning of the instruction is executable but the following | |
| 570 // page is not, the pc and the faulting address might be slightly | |
| 571 // different - we still want to unguard the 2nd page in this case. | |
| 572 // | |
| 573 // 15 bytes seems to be a (very) safe value for max instruction size. | |
| 574 bool pc_is_near_addr = | |
| 575 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15); | |
| 576 bool instr_spans_page_boundary = | |
| 577 (align_size_down((intptr_t) pc ^ (intptr_t) addr, | |
| 578 (intptr_t) page_size) > 0); | |
| 579 | |
| 580 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) { | |
| 581 static volatile address last_addr = | |
| 582 (address) os::non_memory_address_word(); | |
| 583 | |
| 584 // In conservative mode, don't unguard unless the address is in the VM | |
| 585 if (addr != last_addr && | |
| 586 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) { | |
| 587 | |
|
477
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
472
diff
changeset
|
588 // Make memory rwx and retry |
| 0 | 589 address page_start = |
| 590 (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:
472
diff
changeset
|
591 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:
472
diff
changeset
|
592 os::MEM_PROT_RWX); |
| 0 | 593 |
| 594 if (PrintMiscellaneous && Verbose) { | |
| 595 char buf[256]; | |
| 596 jio_snprintf(buf, sizeof(buf), "Execution protection violation " | |
| 597 "at " INTPTR_FORMAT | |
| 598 ", unguarding " INTPTR_FORMAT ": %s, errno=%d", addr, | |
| 599 page_start, (res ? "success" : "failed"), errno); | |
| 600 tty->print_raw_cr(buf); | |
| 601 } | |
| 602 stub = pc; | |
| 603 | |
| 604 // Set last_addr so if we fault again at the same address, we don't end | |
| 605 // up in an endless loop. | |
| 606 // | |
| 607 // There are two potential complications here. Two threads trapping at | |
| 608 // the same address at the same time could cause one of the threads to | |
| 609 // think it already unguarded, and abort the VM. Likely very rare. | |
| 610 // | |
| 611 // The other race involves two threads alternately trapping at | |
| 612 // different addresses and failing to unguard the page, resulting in | |
| 613 // an endless loop. This condition is probably even more unlikely than | |
| 614 // the first. | |
| 615 // | |
| 616 // Although both cases could be avoided by using locks or thread local | |
| 617 // last_addr, these solutions are unnecessary complication: this | |
| 618 // handler is a best-effort safety net, not a complete solution. It is | |
| 619 // disabled by default and should only be used as a workaround in case | |
| 620 // we missed any no-execute-unsafe VM code. | |
| 621 | |
| 622 last_addr = addr; | |
| 623 } | |
| 624 } | |
| 625 } | |
| 626 | |
| 627 if (stub != NULL) { | |
| 628 // save all thread context in case we need to restore it | |
| 629 | |
| 630 if (thread != NULL) thread->set_saved_exception_pc(pc); | |
| 631 // 12/02/99: On Sparc it appears that the full context is also saved | |
| 632 // but as yet, no one looks at or restores that saved context | |
| 633 // factor me: setPC | |
| 634 uc->uc_mcontext.gregs[REG_PC] = (greg_t)stub; | |
| 635 return true; | |
| 636 } | |
| 637 | |
| 638 // signal-chaining | |
| 639 if (os::Solaris::chained_handler(sig, info, ucVoid)) { | |
| 640 return true; | |
| 641 } | |
| 642 | |
| 643 #ifndef AMD64 | |
| 644 // Workaround (bug 4900493) for Solaris kernel bug 4966651. | |
| 645 // Handle an undefined selector caused by an attempt to assign | |
| 646 // fs in libthread getipriptr(). With the current libthread design every 512 | |
| 647 // thread creations the LDT for a private thread data structure is extended | |
| 648 // and thre is a hazard that and another thread attempting a thread creation | |
| 649 // will use a stale LDTR that doesn't reflect the structure's growth, | |
| 650 // causing a GP fault. | |
| 651 // Enforce the probable limit of passes through here to guard against an | |
| 652 // infinite loop if some other move to fs caused the GP fault. Note that | |
| 653 // this loop counter is ultimately a heuristic as it is possible for | |
| 654 // more than one thread to generate this fault at a time in an MP system. | |
| 655 // In the case of the loop count being exceeded or if the poll fails | |
| 656 // just fall through to a fatal error. | |
| 657 // If there is some other source of T_GPFLT traps and the text at EIP is | |
| 658 // unreadable this code will loop infinitely until the stack is exausted. | |
| 659 // The key to diagnosis in this case is to look for the bottom signal handler | |
| 660 // frame. | |
| 661 | |
| 662 if(! IgnoreLibthreadGPFault) { | |
| 663 if (sig == SIGSEGV && uc->uc_mcontext.gregs[TRAPNO] == T_GPFLT) { | |
| 664 const unsigned char *p = | |
| 665 (unsigned const char *) uc->uc_mcontext.gregs[EIP]; | |
| 666 | |
| 667 // Expected instruction? | |
| 668 | |
| 669 if(p[0] == movlfs[0] && p[1] == movlfs[1]) { | |
| 670 | |
| 671 Atomic::inc(&ldtr_refresh); | |
| 672 | |
| 673 // Infinite loop? | |
| 674 | |
| 675 if(ldtr_refresh < ((2 << 16) / PAGESIZE)) { | |
| 676 | |
| 677 // No, force scheduling to get a fresh view of the LDTR | |
| 678 | |
| 679 if(poll(NULL, 0, 10) == 0) { | |
| 680 | |
| 681 // Retry the move | |
| 682 | |
| 683 return false; | |
| 684 } | |
| 685 } | |
| 686 } | |
| 687 } | |
| 688 } | |
| 689 #endif // !AMD64 | |
| 690 | |
| 691 if (!abort_if_unrecognized) { | |
| 692 // caller wants another chance, so give it to him | |
| 693 return false; | |
| 694 } | |
| 695 | |
| 696 if (!os::Solaris::libjsig_is_loaded) { | |
| 697 struct sigaction oldAct; | |
| 698 sigaction(sig, (struct sigaction *)0, &oldAct); | |
| 699 if (oldAct.sa_sigaction != signalHandler) { | |
| 700 void* sighand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) | |
| 701 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); | |
| 605 | 702 warning("Unexpected Signal %d occurred under user-defined signal handler %#lx", sig, (long)sighand); |
| 0 | 703 } |
| 704 } | |
| 705 | |
| 706 if (pc == NULL && uc != NULL) { | |
| 707 pc = (address) uc->uc_mcontext.gregs[REG_PC]; | |
| 708 } | |
| 709 | |
| 710 // unmask current signal | |
| 711 sigset_t newset; | |
| 712 sigemptyset(&newset); | |
| 713 sigaddset(&newset, sig); | |
| 714 sigprocmask(SIG_UNBLOCK, &newset, NULL); | |
| 715 | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
1980
diff
changeset
|
716 // Determine which sort of error to throw. Out of swap may signal |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
1980
diff
changeset
|
717 // on the thread stack, which could get a mapping error when touched. |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
1980
diff
changeset
|
718 address addr = (address) info->si_addr; |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
1980
diff
changeset
|
719 if (sig == SIGBUS && info->si_code == BUS_OBJERR && info->si_errno == ENOMEM) { |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
7206
diff
changeset
|
720 vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "Out of swap space to map in thread stack."); |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
1980
diff
changeset
|
721 } |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
1980
diff
changeset
|
722 |
| 0 | 723 VMError err(t, sig, pc, info, ucVoid); |
| 724 err.report_and_die(); | |
| 725 | |
| 726 ShouldNotReachHere(); | |
| 727 } | |
| 728 | |
| 729 void os::print_context(outputStream *st, void *context) { | |
| 730 if (context == NULL) return; | |
| 731 | |
| 732 ucontext_t *uc = (ucontext_t*)context; | |
| 733 st->print_cr("Registers:"); | |
| 734 #ifdef AMD64 | |
| 735 st->print( "RAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RAX]); | |
| 736 st->print(", RBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBX]); | |
| 737 st->print(", RCX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RCX]); | |
| 738 st->print(", RDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDX]); | |
| 739 st->cr(); | |
| 740 st->print( "RSP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSP]); | |
| 741 st->print(", RBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBP]); | |
| 742 st->print(", RSI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSI]); | |
| 743 st->print(", RDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDI]); | |
| 744 st->cr(); | |
| 1907 | 745 st->print( "R8 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R8]); |
| 746 st->print(", R9 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R9]); | |
| 0 | 747 st->print(", R10=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R10]); |
| 748 st->print(", R11=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R11]); | |
| 1250 | 749 st->cr(); |
| 750 st->print( "R12=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R12]); | |
| 0 | 751 st->print(", R13=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R13]); |
| 752 st->print(", R14=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R14]); | |
| 753 st->print(", R15=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R15]); | |
| 754 st->cr(); | |
| 755 st->print( "RIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RIP]); | |
| 756 st->print(", RFLAGS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RFL]); | |
| 757 #else | |
| 758 st->print( "EAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EAX]); | |
| 759 st->print(", EBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EBX]); | |
| 760 st->print(", ECX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[ECX]); | |
| 761 st->print(", EDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EDX]); | |
| 762 st->cr(); | |
| 763 st->print( "ESP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[UESP]); | |
| 764 st->print(", EBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EBP]); | |
| 765 st->print(", ESI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[ESI]); | |
| 766 st->print(", EDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EDI]); | |
| 767 st->cr(); | |
| 768 st->print( "EIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EIP]); | |
| 769 st->print(", EFLAGS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EFL]); | |
| 770 #endif // AMD64 | |
| 771 st->cr(); | |
| 772 st->cr(); | |
| 773 | |
| 774 intptr_t *sp = (intptr_t *)os::Solaris::ucontext_get_sp(uc); | |
| 775 st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", sp); | |
| 776 print_hex_dump(st, (address)sp, (address)(sp + 8*sizeof(intptr_t)), sizeof(intptr_t)); | |
| 777 st->cr(); | |
| 778 | |
| 779 // Note: it may be unsafe to inspect memory near pc. For example, pc may | |
| 780 // point to garbage if entry point in an nmethod is corrupted. Leave | |
| 781 // this at the end, and hope for the best. | |
| 782 ExtendedPC epc = os::Solaris::ucontext_get_ExtendedPC(uc); | |
| 783 address pc = epc.pc(); | |
| 784 st->print_cr("Instructions: (pc=" PTR_FORMAT ")", pc); | |
| 1907 | 785 print_hex_dump(st, pc - 32, pc + 32, sizeof(char)); |
| 786 } | |
| 787 | |
| 788 void os::print_register_info(outputStream *st, void *context) { | |
| 789 if (context == NULL) return; | |
| 790 | |
| 791 ucontext_t *uc = (ucontext_t*)context; | |
| 792 | |
| 793 st->print_cr("Register to memory mapping:"); | |
| 794 st->cr(); | |
| 795 | |
| 796 // this is horrendously verbose but the layout of the registers in the | |
| 797 // context does not match how we defined our abstract Register set, so | |
| 798 // we can't just iterate through the gregs area | |
| 799 | |
| 800 // this is only for the "general purpose" registers | |
| 801 | |
| 802 #ifdef AMD64 | |
| 803 st->print("RAX="); print_location(st, uc->uc_mcontext.gregs[REG_RAX]); | |
| 804 st->print("RBX="); print_location(st, uc->uc_mcontext.gregs[REG_RBX]); | |
| 805 st->print("RCX="); print_location(st, uc->uc_mcontext.gregs[REG_RCX]); | |
| 806 st->print("RDX="); print_location(st, uc->uc_mcontext.gregs[REG_RDX]); | |
| 807 st->print("RSP="); print_location(st, uc->uc_mcontext.gregs[REG_RSP]); | |
| 808 st->print("RBP="); print_location(st, uc->uc_mcontext.gregs[REG_RBP]); | |
| 809 st->print("RSI="); print_location(st, uc->uc_mcontext.gregs[REG_RSI]); | |
| 810 st->print("RDI="); print_location(st, uc->uc_mcontext.gregs[REG_RDI]); | |
| 811 st->print("R8 ="); print_location(st, uc->uc_mcontext.gregs[REG_R8]); | |
| 812 st->print("R9 ="); print_location(st, uc->uc_mcontext.gregs[REG_R9]); | |
| 813 st->print("R10="); print_location(st, uc->uc_mcontext.gregs[REG_R10]); | |
| 814 st->print("R11="); print_location(st, uc->uc_mcontext.gregs[REG_R11]); | |
| 815 st->print("R12="); print_location(st, uc->uc_mcontext.gregs[REG_R12]); | |
| 816 st->print("R13="); print_location(st, uc->uc_mcontext.gregs[REG_R13]); | |
| 817 st->print("R14="); print_location(st, uc->uc_mcontext.gregs[REG_R14]); | |
| 818 st->print("R15="); print_location(st, uc->uc_mcontext.gregs[REG_R15]); | |
| 819 #else | |
| 820 st->print("EAX="); print_location(st, uc->uc_mcontext.gregs[EAX]); | |
| 821 st->print("EBX="); print_location(st, uc->uc_mcontext.gregs[EBX]); | |
| 822 st->print("ECX="); print_location(st, uc->uc_mcontext.gregs[ECX]); | |
| 823 st->print("EDX="); print_location(st, uc->uc_mcontext.gregs[EDX]); | |
| 824 st->print("ESP="); print_location(st, uc->uc_mcontext.gregs[UESP]); | |
| 825 st->print("EBP="); print_location(st, uc->uc_mcontext.gregs[EBP]); | |
| 826 st->print("ESI="); print_location(st, uc->uc_mcontext.gregs[ESI]); | |
| 827 st->print("EDI="); print_location(st, uc->uc_mcontext.gregs[EDI]); | |
| 828 #endif | |
| 829 | |
| 830 st->cr(); | |
| 0 | 831 } |
| 832 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1624
diff
changeset
|
833 |
| 0 | 834 #ifdef AMD64 |
| 835 void os::Solaris::init_thread_fpu_state(void) { | |
| 836 // Nothing to do | |
| 837 } | |
| 838 #else | |
| 839 // From solaris_i486.s | |
| 840 extern "C" void fixcw(); | |
| 841 | |
| 842 void os::Solaris::init_thread_fpu_state(void) { | |
| 843 // Set fpu to 53 bit precision. This happens too early to use a stub. | |
| 844 fixcw(); | |
| 845 } | |
| 846 | |
| 847 // These routines are the initial value of atomic_xchg_entry(), | |
| 848 // atomic_cmpxchg_entry(), atomic_inc_entry() and fence_entry() | |
| 849 // until initialization is complete. | |
| 850 // TODO - replace with .il implementation when compiler supports it. | |
| 851 | |
| 852 typedef jint xchg_func_t (jint, volatile jint*); | |
| 853 typedef jint cmpxchg_func_t (jint, volatile jint*, jint); | |
| 854 typedef jlong cmpxchg_long_func_t(jlong, volatile jlong*, jlong); | |
| 855 typedef jint add_func_t (jint, volatile jint*); | |
| 856 | |
| 857 jint os::atomic_xchg_bootstrap(jint exchange_value, volatile jint* dest) { | |
| 858 // try to use the stub: | |
| 859 xchg_func_t* func = CAST_TO_FN_PTR(xchg_func_t*, StubRoutines::atomic_xchg_entry()); | |
| 860 | |
| 861 if (func != NULL) { | |
| 862 os::atomic_xchg_func = func; | |
| 863 return (*func)(exchange_value, dest); | |
| 864 } | |
| 865 assert(Threads::number_of_threads() == 0, "for bootstrap only"); | |
| 866 | |
| 867 jint old_value = *dest; | |
| 868 *dest = exchange_value; | |
| 869 return old_value; | |
| 870 } | |
| 871 | |
| 872 jint os::atomic_cmpxchg_bootstrap(jint exchange_value, volatile jint* dest, jint compare_value) { | |
| 873 // try to use the stub: | |
| 874 cmpxchg_func_t* func = CAST_TO_FN_PTR(cmpxchg_func_t*, StubRoutines::atomic_cmpxchg_entry()); | |
| 875 | |
| 876 if (func != NULL) { | |
| 877 os::atomic_cmpxchg_func = func; | |
| 878 return (*func)(exchange_value, dest, compare_value); | |
| 879 } | |
| 880 assert(Threads::number_of_threads() == 0, "for bootstrap only"); | |
| 881 | |
| 882 jint old_value = *dest; | |
| 883 if (old_value == compare_value) | |
| 884 *dest = exchange_value; | |
| 885 return old_value; | |
| 886 } | |
| 887 | |
| 888 jlong os::atomic_cmpxchg_long_bootstrap(jlong exchange_value, volatile jlong* dest, jlong compare_value) { | |
| 889 // try to use the stub: | |
| 890 cmpxchg_long_func_t* func = CAST_TO_FN_PTR(cmpxchg_long_func_t*, StubRoutines::atomic_cmpxchg_long_entry()); | |
| 891 | |
| 892 if (func != NULL) { | |
| 893 os::atomic_cmpxchg_long_func = func; | |
| 894 return (*func)(exchange_value, dest, compare_value); | |
| 895 } | |
| 896 assert(Threads::number_of_threads() == 0, "for bootstrap only"); | |
| 897 | |
| 898 jlong old_value = *dest; | |
| 899 if (old_value == compare_value) | |
| 900 *dest = exchange_value; | |
| 901 return old_value; | |
| 902 } | |
| 903 | |
| 904 jint os::atomic_add_bootstrap(jint add_value, volatile jint* dest) { | |
| 905 // try to use the stub: | |
| 906 add_func_t* func = CAST_TO_FN_PTR(add_func_t*, StubRoutines::atomic_add_entry()); | |
| 907 | |
| 908 if (func != NULL) { | |
| 909 os::atomic_add_func = func; | |
| 910 return (*func)(add_value, dest); | |
| 911 } | |
| 912 assert(Threads::number_of_threads() == 0, "for bootstrap only"); | |
| 913 | |
| 914 return (*dest) += add_value; | |
| 915 } | |
| 916 | |
| 917 xchg_func_t* os::atomic_xchg_func = os::atomic_xchg_bootstrap; | |
| 918 cmpxchg_func_t* os::atomic_cmpxchg_func = os::atomic_cmpxchg_bootstrap; | |
| 919 cmpxchg_long_func_t* os::atomic_cmpxchg_long_func = os::atomic_cmpxchg_long_bootstrap; | |
| 920 add_func_t* os::atomic_add_func = os::atomic_add_bootstrap; | |
| 921 | |
|
1624
726b40449bd2
6939019: Source code adjustments for parfait compilation of hotspot
zgu
parents:
1552
diff
changeset
|
922 extern "C" void _solaris_raw_setup_fpu(address ptr); |
| 0 | 923 void os::setup_fpu() { |
| 924 address fpu_cntrl = StubRoutines::addr_fpu_cntrl_wrd_std(); | |
| 925 _solaris_raw_setup_fpu(fpu_cntrl); | |
| 926 } | |
| 927 #endif // AMD64 | |
|
5903
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
928 |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
929 #ifndef PRODUCT |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
930 void os::verify_stack_alignment() { |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
931 #ifdef AMD64 |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
932 assert(((intptr_t)os::current_stack_pointer() & (StackAlignmentInBytes-1)) == 0, "incorrect stack alignment"); |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
933 #endif |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
934 } |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
935 #endif |