Mercurial > hg > truffle
diff src/os_cpu/solaris_x86/vm/threadLS_solaris_x86.cpp @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | c18cbe5936b8 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/os_cpu/solaris_x86/vm/threadLS_solaris_x86.cpp Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,191 @@ +/* + * Copyright 1998-2007 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +#include "incls/_precompiled.incl" +#include "incls/_threadLS_solaris_x86.cpp.incl" + +#ifdef AMD64 +extern "C" Thread* fs_load(ptrdiff_t tlsOffset); +extern "C" intptr_t fs_thread(); +#else +// From solaris_i486.s +extern "C" Thread* gs_load(ptrdiff_t tlsOffset); +extern "C" intptr_t gs_thread(); +#endif // AMD64 + +// tlsMode encoding: +// +// pd_tlsAccessUndefined : uninitialized +// pd_tlsAccessSlow : not available +// pd_tlsAccessIndirect : +// old-style indirect access - present in "T1" libthread. +// use thr_slot_sync_allocate() to attempt to allocate a slot. +// pd_tlsAccessDirect : +// new-style direct access - present in late-model "T2" libthread. +// Allocate the offset (slot) via _thr_slot_offset() or by +// defining an IE- or LE-mode TLS/TSD slot in the launcher and then passing +// that offset into libjvm.so. +// See http://sac.eng/Archives/CaseLog/arc/PSARC/2003/159/. +// +// Note that we have a capability gap - some early model T2 forms +// (e.g., unpatched S9) have neither _thr_slot_sync_allocate() nor +// _thr_slot_offset(). In that case we revert to the usual +// thr_getspecific accessor. +// + +static ThreadLocalStorage::pd_tlsAccessMode tlsMode = ThreadLocalStorage::pd_tlsAccessUndefined ; +static ptrdiff_t tlsOffset = 0 ; +static thread_key_t tlsKey ; + +typedef int (*TSSA_Entry) (ptrdiff_t *, int, int) ; +typedef ptrdiff_t (*TSO_Entry) (int) ; + +ThreadLocalStorage::pd_tlsAccessMode ThreadLocalStorage::pd_getTlsAccessMode () +{ + guarantee (tlsMode != pd_tlsAccessUndefined, "tlsMode not set") ; + return tlsMode ; +} + +ptrdiff_t ThreadLocalStorage::pd_getTlsOffset () { + guarantee (tlsMode != pd_tlsAccessUndefined, "tlsMode not set") ; + return tlsOffset ; +} + +// TODO: Consider the following improvements: +// +// 1. Convert from thr_*specific* to pthread_*specific*. +// The pthread_ forms are slightly faster. Also, the +// pthread_ forms have a pthread_key_delete() API which +// would aid in clean JVM shutdown and the eventual goal +// of permitting a JVM to reinstantiate itself withing a process. +// +// 2. See ThreadLocalStorage::init(). We end up allocating +// two TLS keys during VM startup. That's benign, but we could collapse +// down to one key without too much trouble. +// +// 3. MacroAssembler::get_thread() currently emits calls to thr_getspecific(). +// Modify get_thread() to call Thread::current() instead. +// +// 4. Thread::current() currently uses a cache keyed by %gs:[0]. +// (The JVM has PSARC permission to use %g7/%gs:[0] +// as an opaque temporally unique thread identifier). +// For C++ access to a thread's reflexive "self" pointer we +// should consider using one of the following: +// a. a radix tree keyed by %esp - as in EVM. +// This requires two loads (the 2nd dependent on the 1st), but +// is easily inlined and doesn't require a "miss" slow path. +// b. a fast TLS/TSD slot allocated by _thr_slot_offset +// or _thr_slot_sync_allocate. +// +// 5. 'generate_code_for_get_thread' is a misnomer. +// We should change it to something more general like +// pd_ThreadSelf_Init(), for instance. +// + +static void AllocateTLSOffset () +{ + int rslt ; + TSSA_Entry tssa ; + TSO_Entry tso ; + ptrdiff_t off ; + + guarantee (tlsMode == ThreadLocalStorage::pd_tlsAccessUndefined, "tlsMode not set") ; + tlsMode = ThreadLocalStorage::pd_tlsAccessSlow ; + tlsOffset = 0 ; +#ifndef AMD64 + + tssa = (TSSA_Entry) dlsym (RTLD_DEFAULT, "thr_slot_sync_allocate") ; + if (tssa != NULL) { + off = -1 ; + rslt = (*tssa)(&off, NULL, NULL) ; // (off,dtor,darg) + if (off != -1) { + tlsOffset = off ; + tlsMode = ThreadLocalStorage::pd_tlsAccessIndirect ; + return ; + } + } + + rslt = thr_keycreate (&tlsKey, NULL) ; + if (rslt != 0) { + tlsMode = ThreadLocalStorage::pd_tlsAccessSlow ; // revert to slow mode + return ; + } + + tso = (TSO_Entry) dlsym (RTLD_DEFAULT, "_thr_slot_offset") ; + if (tso != NULL) { + off = (*tso)(tlsKey) ; + if (off >= 0) { + tlsOffset = off ; + tlsMode = ThreadLocalStorage::pd_tlsAccessDirect ; + return ; + } + } + + // Failure: Too bad ... we've allocated a TLS slot we don't need and there's + // no provision in the ABI for returning the slot. + // + // If we didn't find a slot then then: + // 1. We might be on liblwp. + // 2. We might be on T2 libthread, but all "fast" slots are already + // consumed + // 3. We might be on T1, and all TSD (thr_slot_sync_allocate) slots are + // consumed. + // 4. We might be on T2 libthread, but it's be re-architected + // so that fast slots are no longer g7-relative. + // + + tlsMode = ThreadLocalStorage::pd_tlsAccessSlow ; + return ; +#endif // AMD64 +} + +void ThreadLocalStorage::generate_code_for_get_thread() { + AllocateTLSOffset() ; +} + +void ThreadLocalStorage::set_thread_in_slot(Thread *thread) { + guarantee (tlsMode != pd_tlsAccessUndefined, "tlsMode not set") ; + if (tlsMode == pd_tlsAccessIndirect) { +#ifdef AMD64 + intptr_t tbase = fs_thread(); +#else + intptr_t tbase = gs_thread(); +#endif // AMD64 + *((Thread**) (tbase + tlsOffset)) = thread ; + } else + if (tlsMode == pd_tlsAccessDirect) { + thr_setspecific (tlsKey, (void *) thread) ; + // set with thr_setspecific and then readback with gs_load to validate. +#ifdef AMD64 + guarantee (thread == fs_load(tlsOffset), "tls readback failure") ; +#else + guarantee (thread == gs_load(tlsOffset), "tls readback failure") ; +#endif // AMD64 + } +} + + +extern "C" Thread* get_thread() { + return ThreadLocalStorage::thread(); +}