truffle: src/share/vm/oops/symbol.hpp annotate

annotate src/share/vm/oops/symbol.hpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	cd6b3f1a94ff
children	4ca6dc0799b6

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
14340 cd6b3f1a94ff 8033792: AltHashing used jint for imprecise bit shifting minqi parents: 12264 diff changeset	2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1138 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1138 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: 1138 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	25 #ifndef SHARE_VM_OOPS_SYMBOL_HPP
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	26 #define SHARE_VM_OOPS_SYMBOL_HPP
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "utilities/utf8.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	29 #include "memory/allocation.hpp"
11033 d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	30 #include "runtime/atomic.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	31
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	32 // A Symbol is a canonicalized string.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	33 // All Symbols reside in global SymbolTable and are reference counted.
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	35 // Reference counting
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	36 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	37 // All Symbols are allocated and added to the SymbolTable.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	38 // When a class is unloaded, the reference counts of the Symbol pointers in
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	39 // the ConstantPool and in InstanceKlass (see release_C_heap_structures) are
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	40 // decremented. When the reference count for a Symbol goes to 0, the garbage
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	41 // collector can free the Symbol and remove it from the SymbolTable.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	42 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	43 // 0) Symbols need to be reference counted when a pointer to the Symbol is
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	44 // saved in persistent storage. This does not include the pointer
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	45 // in the SymbolTable bucket (the _literal field in HashtableEntry)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	46 // that points to the Symbol. All other stores of a Symbol*
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	47 // to a field of a persistent variable (e.g., the _name filed in
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	48 // fieldDescriptor or _ptr in a CPSlot) is reference counted.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	49 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	50 // 1) The lookup of a "name" in the SymbolTable either creates a Symbol F for
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	51 // "name" and returns a pointer to F or finds a pre-existing Symbol F for
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	52 // "name" and returns a pointer to it. In both cases the reference count for F
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	53 // is incremented under the assumption that a pointer to F will be created from
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	54 // the return value. Thus the increment of the reference count is on the lookup
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	55 // and not on the assignment to the new Symbol*. That is
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	56 // Symbol* G = lookup()
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	57 // ^ increment on lookup()
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	58 // and not
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	59 // Symbol* G = lookup()
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	60 // ^ increment on assignmnet
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	61 // The reference count must be decremented manually when the copy of the
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	62 // pointer G is destroyed.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	63 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	64 // 2) For a local Symbol* A that is a copy of an existing Symbol* B, the
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	65 // reference counting is elided when the scope of B is greater than the scope
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	66 // of A. For example, in the code fragment
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	67 // below "klass" is passed as a parameter to the method. Symbol* "kn"
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	68 // is a copy of the name in "klass".
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	69 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	70 // Symbol* kn = klass->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	71 // unsigned int d_hash = dictionary()->compute_hash(kn, class_loader);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	72 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	73 // The scope of "klass" is greater than the scope of "kn" so the reference
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	74 // counting for "kn" is elided.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	75 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	76 // Symbol* copied from ConstantPool entries are good candidates for reference
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	77 // counting elision. The ConstantPool entries for a class C exist until C is
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	78 // unloaded. If a Symbol* is copied out of the ConstantPool into Symbol* X,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	79 // the Symbol* in the ConstantPool will in general out live X so the reference
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	80 // counting on X can be elided.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	81 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	82 // For cases where the scope of A is not greater than the scope of B,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	83 // the reference counting is explicitly done. See ciSymbol,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	84 // ResolutionErrorEntry and ClassVerifier for examples.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	85 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	86 // 3) When a Symbol K is created for temporary use, generally for substrings of
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	87 // an existing symbol or to create a new symbol, assign it to a
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	88 // TempNewSymbol. The SymbolTable methods new_symbol(), lookup()
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	89 // and probe() all potentially return a pointer to a new Symbol.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	90 // The allocation (or lookup) of K increments the reference count for K
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	91 // and the destructor decrements the reference count.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	92 //
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	93 // Another example of TempNewSymbol usage is parsed_name used in
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	94 // ClassFileParser::parseClassFile() where parsed_name is used in the cleanup
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	95 // after a failed attempt to load a class. Here parsed_name is a
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	96 // TempNewSymbol (passed in as a parameter) so the reference count on its symbol
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	97 // will be decremented when it goes out of scope.
0 a61af66fc99e Initial load duke parents: diff changeset	98
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	99
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	100 // This cannot be inherited from ResourceObj because it cannot have a vtable.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	101 // Since sometimes this is allocated from Metadata, pick a base allocation
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	102 // type without virtual functions.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	103 class ClassLoaderData;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	104
11033 d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	105 // We separate the fields in SymbolBase from Symbol::_body so that
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	106 // Symbol::size(int) can correctly calculate the space needed.
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	107 class SymbolBase : public MetaspaceObj {
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	108 public:
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	109 ATOMIC_SHORT_PAIR(
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	110 volatile short _refcount, // needs atomic operation
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	111 unsigned short _length // number of UTF8 characters in the symbol (does not need atomic op)
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	112 );
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	113 int _identity_hash;
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	114 };
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	115
d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	116 class Symbol : private SymbolBase {
0 a61af66fc99e Initial load duke parents: diff changeset	117 friend class VMStructs;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	118 friend class SymbolTable;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	119 friend class MoveSymbols;
0 a61af66fc99e Initial load duke parents: diff changeset	120 private:
a61af66fc99e Initial load duke parents: diff changeset	121 jbyte _body[1];
a61af66fc99e Initial load duke parents: diff changeset	122
a61af66fc99e Initial load duke parents: diff changeset	123 enum {
a61af66fc99e Initial load duke parents: diff changeset	124 // max_symbol_length is constrained by type of _length
a61af66fc99e Initial load duke parents: diff changeset	125 max_symbol_length = (1 << 16) -1
a61af66fc99e Initial load duke parents: diff changeset	126 };
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	127
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	128 static int size(int length) {
11033 d9eed26d638a 8009575: Reduce Symbol::_refcount from 4 bytes to 2 bytes iklam parents: 8675 diff changeset	129 size_t sz = heap_word_size(sizeof(SymbolBase) + (length > 0 ? length : 0));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	130 return align_object_size(sz);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	131 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	132
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	133 void byte_at_put(int index, int value) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	134 assert(index >=0 && index < _length, "symbol index overflow");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	135 _body[index] = value;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	136 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	137
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 2426 diff changeset	138 Symbol(const u1* name, int length, int refcount);
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 11033 diff changeset	139 void* operator new(size_t size, int len, TRAPS) throw();
9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 11033 diff changeset	140 void* operator new(size_t size, int len, Arena* arena, TRAPS) throw();
9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 11033 diff changeset	141 void* operator new(size_t size, int len, ClassLoaderData* loader_data, TRAPS) throw();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	142
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	143 void operator delete(void* p);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	144
0 a61af66fc99e Initial load duke parents: diff changeset	145 public:
a61af66fc99e Initial load duke parents: diff changeset	146 // Low-level access (used with care, since not GC-safe)
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	147 const jbyte* base() const { return &_body[0]; }
0 a61af66fc99e Initial load duke parents: diff changeset	148
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	149 int size() { return size(utf8_length()); }
0 a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 // Returns the largest size symbol we can safely hold.
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 2426 diff changeset	152 static int max_length() { return max_symbol_length; }
0 a61af66fc99e Initial load duke parents: diff changeset	153
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 2426 diff changeset	154 int identity_hash() { return _identity_hash; }
0 a61af66fc99e Initial load duke parents: diff changeset	155
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	156 // For symbol table alternate hashing
14340 cd6b3f1a94ff 8033792: AltHashing used jint for imprecise bit shifting minqi parents: 12264 diff changeset	157 unsigned int new_hash(juint seed);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	158
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	159 // Reference counting. See comments above this class for when to use.
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 2426 diff changeset	160 int refcount() const { return _refcount; }
8675 63e54c37ac64 8008959: Fix non-PCH build on Linux, Windows and MacOS X simonis parents: 6972 diff changeset	161 void increment_refcount();
63e54c37ac64 8008959: Fix non-PCH build on Linux, Windows and MacOS X simonis parents: 6972 diff changeset	162 void decrement_refcount();
0 a61af66fc99e Initial load duke parents: diff changeset	163
a61af66fc99e Initial load duke parents: diff changeset	164 int byte_at(int index) const {
a61af66fc99e Initial load duke parents: diff changeset	165 assert(index >=0 && index < _length, "symbol index overflow");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	166 return base()[index];
0 a61af66fc99e Initial load duke parents: diff changeset	167 }
a61af66fc99e Initial load duke parents: diff changeset	168
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	169 const jbyte* bytes() const { return base(); }
0 a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 int utf8_length() const { return _length; }
a61af66fc99e Initial load duke parents: diff changeset	172
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	173 // Compares the symbol with a string.
0 a61af66fc99e Initial load duke parents: diff changeset	174 bool equals(const char* str, int len) const;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	175 bool equals(const char* str) const { return equals(str, (int) strlen(str)); }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	176
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	177 // Tests if the symbol starts with the given prefix.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	178 bool starts_with(const char* prefix, int len) const;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	179 bool starts_with(const char* prefix) const {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	180 return starts_with(prefix, (int) strlen(prefix));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	181 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	182
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	183 // Tests if the symbol starts with the given prefix.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	184 int index_of_at(int i, const char* str, int len) const;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	185 int index_of_at(int i, const char* str) const {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	186 return index_of_at(i, str, (int) strlen(str));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 0 diff changeset	187 }
0 a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189 // Three-way compare for sorting; returns -1/0/1 if receiver is </==/> than arg
a61af66fc99e Initial load duke parents: diff changeset	190 // note that the ordering is not alfabetical
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	191 inline int fast_compare(Symbol* other) const;
0 a61af66fc99e Initial load duke parents: diff changeset	192
a61af66fc99e Initial load duke parents: diff changeset	193 // Returns receiver converted to null-terminated UTF-8 string; string is
a61af66fc99e Initial load duke parents: diff changeset	194 // allocated in resource area, or in the char buffer provided by caller.
a61af66fc99e Initial load duke parents: diff changeset	195 char* as_C_string() const;
a61af66fc99e Initial load duke parents: diff changeset	196 char* as_C_string(char* buf, int size) const;
a61af66fc99e Initial load duke parents: diff changeset	197 // Use buf if needed buffer length is <= size.
a61af66fc99e Initial load duke parents: diff changeset	198 char* as_C_string_flexible_buffer(Thread* t, char* buf, int size) const;
a61af66fc99e Initial load duke parents: diff changeset	199
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	200 // Returns an escaped form of a Java string.
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	201 char* as_quoted_ascii() const;
0 a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 // Returns a null terminated utf8 string in a resource array
a61af66fc99e Initial load duke parents: diff changeset	204 char* as_utf8() const { return as_C_string(); }
a61af66fc99e Initial load duke parents: diff changeset	205 char* as_utf8_flexible_buffer(Thread* t, char* buf, int size) const {
a61af66fc99e Initial load duke parents: diff changeset	206 return as_C_string_flexible_buffer(t, buf, size);
a61af66fc99e Initial load duke parents: diff changeset	207 }
a61af66fc99e Initial load duke parents: diff changeset	208
a61af66fc99e Initial load duke parents: diff changeset	209 jchar* as_unicode(int& length) const;
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 // Treating this symbol as a class name, returns the Java name for the class.
a61af66fc99e Initial load duke parents: diff changeset	212 // String is allocated in resource area if buffer is not provided.
a61af66fc99e Initial load duke parents: diff changeset	213 // See Klass::external_name()
a61af66fc99e Initial load duke parents: diff changeset	214 const char* as_klass_external_name() const;
a61af66fc99e Initial load duke parents: diff changeset	215 const char* as_klass_external_name(char* buf, int size) const;
a61af66fc99e Initial load duke parents: diff changeset	216
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	217 // Printing
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	218 void print_symbol_on(outputStream* st = NULL) const;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	219 void print_on(outputStream* st) const; // First level print
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	220 void print_value_on(outputStream* st) const; // Second level print.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	221
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	222 // printing on default output stream
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	223 void print() { print_on(tty); }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	224 void print_value() { print_value_on(tty); }
0 a61af66fc99e Initial load duke parents: diff changeset	225
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	226 #ifndef PRODUCT
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	227 // Empty constructor to create a dummy symbol object on stack
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	228 // only for getting its vtable pointer.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	229 Symbol() { }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	230
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	231 static int _total_count;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	232 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	233 };
a61af66fc99e Initial load duke parents: diff changeset	234
a61af66fc99e Initial load duke parents: diff changeset	235 // Note: this comparison is used for vtable sorting only; it doesn't matter
a61af66fc99e Initial load duke parents: diff changeset	236 // what order it defines, as long as it is a total, time-invariant order
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	237 // Since Symbol*s are in C_HEAP, their relative order in memory never changes,
0 a61af66fc99e Initial load duke parents: diff changeset	238 // so use address comparison for speed
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	239 int Symbol::fast_compare(Symbol* other) const {
0 a61af66fc99e Initial load duke parents: diff changeset	240 return (((uintptr_t)this < (uintptr_t)other) ? -1
a61af66fc99e Initial load duke parents: diff changeset	241 : ((uintptr_t)this == (uintptr_t) other) ? 0 : 1);
a61af66fc99e Initial load duke parents: diff changeset	242 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	243 #endif // SHARE_VM_OOPS_SYMBOL_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/symbol.hpp @ 14649:f6301b007a16