Mercurial > hg > truffle
annotate src/share/vm/opto/type.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | 96ef09c26978 |
| children | 6f3fd5150b67 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6890
diff
changeset
|
2 * Copyright (c) 1997, 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:
1340
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1340
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:
1340
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
26 #include "ci/ciMethodData.hpp" |
| 1972 | 27 #include "ci/ciTypeFlow.hpp" |
| 28 #include "classfile/symbolTable.hpp" | |
| 29 #include "classfile/systemDictionary.hpp" | |
| 30 #include "compiler/compileLog.hpp" | |
| 31 #include "libadt/dict.hpp" | |
| 32 #include "memory/gcLocker.hpp" | |
| 33 #include "memory/oopFactory.hpp" | |
| 34 #include "memory/resourceArea.hpp" | |
| 35 #include "oops/instanceKlass.hpp" | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
36 #include "oops/instanceMirrorKlass.hpp" |
| 1972 | 37 #include "oops/objArrayKlass.hpp" |
| 38 #include "oops/typeArrayKlass.hpp" | |
| 39 #include "opto/matcher.hpp" | |
| 40 #include "opto/node.hpp" | |
| 41 #include "opto/opcodes.hpp" | |
| 42 #include "opto/type.hpp" | |
| 43 | |
| 0 | 44 // Portions of code courtesy of Clifford Click |
| 45 | |
| 46 // Optimization - Graph Style | |
| 47 | |
| 48 // Dictionary of types shared among compilations. | |
| 49 Dict* Type::_shared_type_dict = NULL; | |
| 50 | |
| 51 // Array which maps compiler types to Basic Types | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
52 Type::TypeInfo Type::_type_info[Type::lastype] = { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
53 { Bad, T_ILLEGAL, "bad", false, Node::NotAMachineReg, relocInfo::none }, // Bad |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
54 { Control, T_ILLEGAL, "control", false, 0, relocInfo::none }, // Control |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
55 { Bottom, T_VOID, "top", false, 0, relocInfo::none }, // Top |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
56 { Bad, T_INT, "int:", false, Op_RegI, relocInfo::none }, // Int |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
57 { Bad, T_LONG, "long:", false, Op_RegL, relocInfo::none }, // Long |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
58 { Half, T_VOID, "half", false, 0, relocInfo::none }, // Half |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
59 { Bad, T_NARROWOOP, "narrowoop:", false, Op_RegN, relocInfo::none }, // NarrowOop |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
60 { Bad, T_NARROWKLASS,"narrowklass:", false, Op_RegN, relocInfo::none }, // NarrowKlass |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
61 { Bad, T_ILLEGAL, "tuple:", false, Node::NotAMachineReg, relocInfo::none }, // Tuple |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
62 { Bad, T_ARRAY, "array:", false, Node::NotAMachineReg, relocInfo::none }, // Array |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
63 |
| 6890 | 64 #ifndef SPARC |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
65 { Bad, T_ILLEGAL, "vectors:", false, Op_VecS, relocInfo::none }, // VectorS |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
66 { Bad, T_ILLEGAL, "vectord:", false, Op_VecD, relocInfo::none }, // VectorD |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
67 { Bad, T_ILLEGAL, "vectorx:", false, Op_VecX, relocInfo::none }, // VectorX |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
68 { Bad, T_ILLEGAL, "vectory:", false, Op_VecY, relocInfo::none }, // VectorY |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
69 #else |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
70 { Bad, T_ILLEGAL, "vectors:", false, 0, relocInfo::none }, // VectorS |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
71 { Bad, T_ILLEGAL, "vectord:", false, Op_RegD, relocInfo::none }, // VectorD |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
72 { Bad, T_ILLEGAL, "vectorx:", false, 0, relocInfo::none }, // VectorX |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
73 { Bad, T_ILLEGAL, "vectory:", false, 0, relocInfo::none }, // VectorY |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
74 #endif // IA32 || AMD64 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
75 { Bad, T_ADDRESS, "anyptr:", false, Op_RegP, relocInfo::none }, // AnyPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
76 { Bad, T_ADDRESS, "rawptr:", false, Op_RegP, relocInfo::none }, // RawPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
77 { Bad, T_OBJECT, "oop:", true, Op_RegP, relocInfo::oop_type }, // OopPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
78 { Bad, T_OBJECT, "inst:", true, Op_RegP, relocInfo::oop_type }, // InstPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
79 { Bad, T_OBJECT, "ary:", true, Op_RegP, relocInfo::oop_type }, // AryPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
80 { Bad, T_METADATA, "metadata:", false, Op_RegP, relocInfo::metadata_type }, // MetadataPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
81 { Bad, T_METADATA, "klass:", false, Op_RegP, relocInfo::metadata_type }, // KlassPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
82 { Bad, T_OBJECT, "func", false, 0, relocInfo::none }, // Function |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
83 { Abio, T_ILLEGAL, "abIO", false, 0, relocInfo::none }, // Abio |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
84 { Return_Address, T_ADDRESS, "return_address",false, Op_RegP, relocInfo::none }, // Return_Address |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
85 { Memory, T_ILLEGAL, "memory", false, 0, relocInfo::none }, // Memory |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
86 { FloatBot, T_FLOAT, "float_top", false, Op_RegF, relocInfo::none }, // FloatTop |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
87 { FloatCon, T_FLOAT, "ftcon:", false, Op_RegF, relocInfo::none }, // FloatCon |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
88 { FloatTop, T_FLOAT, "float", false, Op_RegF, relocInfo::none }, // FloatBot |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
89 { DoubleBot, T_DOUBLE, "double_top", false, Op_RegD, relocInfo::none }, // DoubleTop |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
90 { DoubleCon, T_DOUBLE, "dblcon:", false, Op_RegD, relocInfo::none }, // DoubleCon |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
91 { DoubleTop, T_DOUBLE, "double", false, Op_RegD, relocInfo::none }, // DoubleBot |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
92 { Top, T_ILLEGAL, "bottom", false, 0, relocInfo::none } // Bottom |
| 0 | 93 }; |
| 94 | |
| 95 // Map ideal registers (machine types) to ideal types | |
| 96 const Type *Type::mreg2type[_last_machine_leaf]; | |
| 97 | |
| 98 // Map basic types to canonical Type* pointers. | |
| 99 const Type* Type:: _const_basic_type[T_CONFLICT+1]; | |
| 100 | |
| 101 // Map basic types to constant-zero Types. | |
| 102 const Type* Type:: _zero_type[T_CONFLICT+1]; | |
| 103 | |
| 104 // Map basic types to array-body alias types. | |
| 105 const TypeAryPtr* TypeAryPtr::_array_body_type[T_CONFLICT+1]; | |
| 106 | |
| 107 //============================================================================= | |
| 108 // Convenience common pre-built types. | |
| 109 const Type *Type::ABIO; // State-of-machine only | |
| 110 const Type *Type::BOTTOM; // All values | |
| 111 const Type *Type::CONTROL; // Control only | |
| 112 const Type *Type::DOUBLE; // All doubles | |
| 113 const Type *Type::FLOAT; // All floats | |
| 114 const Type *Type::HALF; // Placeholder half of doublewide type | |
| 115 const Type *Type::MEMORY; // Abstract store only | |
| 116 const Type *Type::RETURN_ADDRESS; | |
| 117 const Type *Type::TOP; // No values in set | |
| 118 | |
| 119 //------------------------------get_const_type--------------------------- | |
| 120 const Type* Type::get_const_type(ciType* type) { | |
| 121 if (type == NULL) { | |
| 122 return NULL; | |
| 123 } else if (type->is_primitive_type()) { | |
| 124 return get_const_basic_type(type->basic_type()); | |
| 125 } else { | |
| 126 return TypeOopPtr::make_from_klass(type->as_klass()); | |
| 127 } | |
| 128 } | |
| 129 | |
| 130 //---------------------------array_element_basic_type--------------------------------- | |
| 131 // Mapping to the array element's basic type. | |
| 132 BasicType Type::array_element_basic_type() const { | |
| 133 BasicType bt = basic_type(); | |
| 134 if (bt == T_INT) { | |
| 135 if (this == TypeInt::INT) return T_INT; | |
| 136 if (this == TypeInt::CHAR) return T_CHAR; | |
| 137 if (this == TypeInt::BYTE) return T_BYTE; | |
| 138 if (this == TypeInt::BOOL) return T_BOOLEAN; | |
| 139 if (this == TypeInt::SHORT) return T_SHORT; | |
| 140 return T_VOID; | |
| 141 } | |
| 142 return bt; | |
| 143 } | |
| 144 | |
| 145 //---------------------------get_typeflow_type--------------------------------- | |
| 146 // Import a type produced by ciTypeFlow. | |
| 147 const Type* Type::get_typeflow_type(ciType* type) { | |
| 148 switch (type->basic_type()) { | |
| 149 | |
| 150 case ciTypeFlow::StateVector::T_BOTTOM: | |
| 151 assert(type == ciTypeFlow::StateVector::bottom_type(), ""); | |
| 152 return Type::BOTTOM; | |
| 153 | |
| 154 case ciTypeFlow::StateVector::T_TOP: | |
| 155 assert(type == ciTypeFlow::StateVector::top_type(), ""); | |
| 156 return Type::TOP; | |
| 157 | |
| 158 case ciTypeFlow::StateVector::T_NULL: | |
| 159 assert(type == ciTypeFlow::StateVector::null_type(), ""); | |
| 160 return TypePtr::NULL_PTR; | |
| 161 | |
| 162 case ciTypeFlow::StateVector::T_LONG2: | |
| 163 // The ciTypeFlow pass pushes a long, then the half. | |
| 164 // We do the same. | |
| 165 assert(type == ciTypeFlow::StateVector::long2_type(), ""); | |
| 166 return TypeInt::TOP; | |
| 167 | |
| 168 case ciTypeFlow::StateVector::T_DOUBLE2: | |
| 169 // The ciTypeFlow pass pushes double, then the half. | |
| 170 // Our convention is the same. | |
| 171 assert(type == ciTypeFlow::StateVector::double2_type(), ""); | |
| 172 return Type::TOP; | |
| 173 | |
| 174 case T_ADDRESS: | |
| 175 assert(type->is_return_address(), ""); | |
| 176 return TypeRawPtr::make((address)(intptr_t)type->as_return_address()->bci()); | |
| 177 | |
| 178 default: | |
| 179 // make sure we did not mix up the cases: | |
| 180 assert(type != ciTypeFlow::StateVector::bottom_type(), ""); | |
| 181 assert(type != ciTypeFlow::StateVector::top_type(), ""); | |
| 182 assert(type != ciTypeFlow::StateVector::null_type(), ""); | |
| 183 assert(type != ciTypeFlow::StateVector::long2_type(), ""); | |
| 184 assert(type != ciTypeFlow::StateVector::double2_type(), ""); | |
| 185 assert(!type->is_return_address(), ""); | |
| 186 | |
| 187 return Type::get_const_type(type); | |
| 188 } | |
| 189 } | |
| 190 | |
| 191 | |
| 192 //------------------------------make------------------------------------------- | |
| 193 // Create a simple Type, with default empty symbol sets. Then hashcons it | |
| 194 // and look for an existing copy in the type dictionary. | |
| 195 const Type *Type::make( enum TYPES t ) { | |
| 196 return (new Type(t))->hashcons(); | |
| 197 } | |
| 223 | 198 |
| 0 | 199 //------------------------------cmp-------------------------------------------- |
| 200 int Type::cmp( const Type *const t1, const Type *const t2 ) { | |
| 201 if( t1->_base != t2->_base ) | |
| 202 return 1; // Missed badly | |
| 203 assert(t1 != t2 || t1->eq(t2), "eq must be reflexive"); | |
| 204 return !t1->eq(t2); // Return ZERO if equal | |
| 205 } | |
| 206 | |
| 207 //------------------------------hash------------------------------------------- | |
| 208 int Type::uhash( const Type *const t ) { | |
| 209 return t->hash(); | |
| 210 } | |
| 211 | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
212 #define SMALLINT ((juint)3) // a value too insignificant to consider widening |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
213 |
| 0 | 214 //--------------------------Initialize_shared---------------------------------- |
| 215 void Type::Initialize_shared(Compile* current) { | |
| 216 // This method does not need to be locked because the first system | |
| 217 // compilations (stub compilations) occur serially. If they are | |
| 218 // changed to proceed in parallel, then this section will need | |
| 219 // locking. | |
| 220 | |
| 221 Arena* save = current->type_arena(); | |
| 6197 | 222 Arena* shared_type_arena = new (mtCompiler)Arena(); |
| 0 | 223 |
| 224 current->set_type_arena(shared_type_arena); | |
| 225 _shared_type_dict = | |
| 226 new (shared_type_arena) Dict( (CmpKey)Type::cmp, (Hash)Type::uhash, | |
| 227 shared_type_arena, 128 ); | |
| 228 current->set_type_dict(_shared_type_dict); | |
| 229 | |
| 230 // Make shared pre-built types. | |
| 231 CONTROL = make(Control); // Control only | |
| 232 TOP = make(Top); // No values in set | |
| 233 MEMORY = make(Memory); // Abstract store only | |
| 234 ABIO = make(Abio); // State-of-machine only | |
| 235 RETURN_ADDRESS=make(Return_Address); | |
| 236 FLOAT = make(FloatBot); // All floats | |
| 237 DOUBLE = make(DoubleBot); // All doubles | |
| 238 BOTTOM = make(Bottom); // Everything | |
| 239 HALF = make(Half); // Placeholder half of doublewide type | |
| 240 | |
| 241 TypeF::ZERO = TypeF::make(0.0); // Float 0 (positive zero) | |
| 242 TypeF::ONE = TypeF::make(1.0); // Float 1 | |
| 243 | |
| 244 TypeD::ZERO = TypeD::make(0.0); // Double 0 (positive zero) | |
| 245 TypeD::ONE = TypeD::make(1.0); // Double 1 | |
| 246 | |
| 247 TypeInt::MINUS_1 = TypeInt::make(-1); // -1 | |
| 248 TypeInt::ZERO = TypeInt::make( 0); // 0 | |
| 249 TypeInt::ONE = TypeInt::make( 1); // 1 | |
| 250 TypeInt::BOOL = TypeInt::make(0,1, WidenMin); // 0 or 1, FALSE or TRUE. | |
| 251 TypeInt::CC = TypeInt::make(-1, 1, WidenMin); // -1, 0 or 1, condition codes | |
| 252 TypeInt::CC_LT = TypeInt::make(-1,-1, WidenMin); // == TypeInt::MINUS_1 | |
| 253 TypeInt::CC_GT = TypeInt::make( 1, 1, WidenMin); // == TypeInt::ONE | |
| 254 TypeInt::CC_EQ = TypeInt::make( 0, 0, WidenMin); // == TypeInt::ZERO | |
| 255 TypeInt::CC_LE = TypeInt::make(-1, 0, WidenMin); | |
| 256 TypeInt::CC_GE = TypeInt::make( 0, 1, WidenMin); // == TypeInt::BOOL | |
| 257 TypeInt::BYTE = TypeInt::make(-128,127, WidenMin); // Bytes | |
| 624 | 258 TypeInt::UBYTE = TypeInt::make(0, 255, WidenMin); // Unsigned Bytes |
| 0 | 259 TypeInt::CHAR = TypeInt::make(0,65535, WidenMin); // Java chars |
| 260 TypeInt::SHORT = TypeInt::make(-32768,32767, WidenMin); // Java shorts | |
| 261 TypeInt::POS = TypeInt::make(0,max_jint, WidenMin); // Non-neg values | |
| 262 TypeInt::POS1 = TypeInt::make(1,max_jint, WidenMin); // Positive values | |
| 263 TypeInt::INT = TypeInt::make(min_jint,max_jint, WidenMax); // 32-bit integers | |
| 264 TypeInt::SYMINT = TypeInt::make(-max_jint,max_jint,WidenMin); // symmetric range | |
| 265 // CmpL is overloaded both as the bytecode computation returning | |
| 266 // a trinary (-1,0,+1) integer result AND as an efficient long | |
| 267 // compare returning optimizer ideal-type flags. | |
| 268 assert( TypeInt::CC_LT == TypeInt::MINUS_1, "types must match for CmpL to work" ); | |
| 269 assert( TypeInt::CC_GT == TypeInt::ONE, "types must match for CmpL to work" ); | |
| 270 assert( TypeInt::CC_EQ == TypeInt::ZERO, "types must match for CmpL to work" ); | |
| 271 assert( TypeInt::CC_GE == TypeInt::BOOL, "types must match for CmpL to work" ); | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
272 assert( (juint)(TypeInt::CC->_hi - TypeInt::CC->_lo) <= SMALLINT, "CC is truly small"); |
| 0 | 273 |
| 274 TypeLong::MINUS_1 = TypeLong::make(-1); // -1 | |
| 275 TypeLong::ZERO = TypeLong::make( 0); // 0 | |
| 276 TypeLong::ONE = TypeLong::make( 1); // 1 | |
| 277 TypeLong::POS = TypeLong::make(0,max_jlong, WidenMin); // Non-neg values | |
| 278 TypeLong::LONG = TypeLong::make(min_jlong,max_jlong,WidenMax); // 64-bit integers | |
| 279 TypeLong::INT = TypeLong::make((jlong)min_jint,(jlong)max_jint,WidenMin); | |
| 280 TypeLong::UINT = TypeLong::make(0,(jlong)max_juint,WidenMin); | |
| 281 | |
| 282 const Type **fboth =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 283 fboth[0] = Type::CONTROL; | |
| 284 fboth[1] = Type::CONTROL; | |
| 285 TypeTuple::IFBOTH = TypeTuple::make( 2, fboth ); | |
| 286 | |
| 287 const Type **ffalse =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 288 ffalse[0] = Type::CONTROL; | |
| 289 ffalse[1] = Type::TOP; | |
| 290 TypeTuple::IFFALSE = TypeTuple::make( 2, ffalse ); | |
| 291 | |
| 292 const Type **fneither =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 293 fneither[0] = Type::TOP; | |
| 294 fneither[1] = Type::TOP; | |
| 295 TypeTuple::IFNEITHER = TypeTuple::make( 2, fneither ); | |
| 296 | |
| 297 const Type **ftrue =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 298 ftrue[0] = Type::TOP; | |
| 299 ftrue[1] = Type::CONTROL; | |
| 300 TypeTuple::IFTRUE = TypeTuple::make( 2, ftrue ); | |
| 301 | |
| 302 const Type **floop =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 303 floop[0] = Type::CONTROL; | |
| 304 floop[1] = TypeInt::INT; | |
| 305 TypeTuple::LOOPBODY = TypeTuple::make( 2, floop ); | |
| 306 | |
| 307 TypePtr::NULL_PTR= TypePtr::make( AnyPtr, TypePtr::Null, 0 ); | |
| 308 TypePtr::NOTNULL = TypePtr::make( AnyPtr, TypePtr::NotNull, OffsetBot ); | |
| 309 TypePtr::BOTTOM = TypePtr::make( AnyPtr, TypePtr::BotPTR, OffsetBot ); | |
| 310 | |
| 311 TypeRawPtr::BOTTOM = TypeRawPtr::make( TypePtr::BotPTR ); | |
| 312 TypeRawPtr::NOTNULL= TypeRawPtr::make( TypePtr::NotNull ); | |
| 313 | |
| 314 const Type **fmembar = TypeTuple::fields(0); | |
| 315 TypeTuple::MEMBAR = TypeTuple::make(TypeFunc::Parms+0, fmembar); | |
| 316 | |
| 317 const Type **fsc = (const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 318 fsc[0] = TypeInt::CC; | |
| 319 fsc[1] = Type::MEMORY; | |
| 320 TypeTuple::STORECONDITIONAL = TypeTuple::make(2, fsc); | |
| 321 | |
| 322 TypeInstPtr::NOTNULL = TypeInstPtr::make(TypePtr::NotNull, current->env()->Object_klass()); | |
| 323 TypeInstPtr::BOTTOM = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass()); | |
| 324 TypeInstPtr::MIRROR = TypeInstPtr::make(TypePtr::NotNull, current->env()->Class_klass()); | |
| 325 TypeInstPtr::MARK = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass(), | |
| 326 false, 0, oopDesc::mark_offset_in_bytes()); | |
| 327 TypeInstPtr::KLASS = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass(), | |
| 328 false, 0, oopDesc::klass_offset_in_bytes()); | |
| 992 | 329 TypeOopPtr::BOTTOM = TypeOopPtr::make(TypePtr::BotPTR, OffsetBot, TypeOopPtr::InstanceBot); |
| 0 | 330 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
331 TypeMetadataPtr::BOTTOM = TypeMetadataPtr::make(TypePtr::BotPTR, NULL, OffsetBot); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
332 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
333 TypeNarrowOop::NULL_PTR = TypeNarrowOop::make( TypePtr::NULL_PTR ); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
334 TypeNarrowOop::BOTTOM = TypeNarrowOop::make( TypeInstPtr::BOTTOM ); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
335 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
336 TypeNarrowKlass::NULL_PTR = TypeNarrowKlass::make( TypePtr::NULL_PTR ); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
337 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
338 mreg2type[Op_Node] = Type::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
339 mreg2type[Op_Set ] = 0; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
340 mreg2type[Op_RegN] = TypeNarrowOop::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
341 mreg2type[Op_RegI] = TypeInt::INT; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
342 mreg2type[Op_RegP] = TypePtr::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
343 mreg2type[Op_RegF] = Type::FLOAT; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
344 mreg2type[Op_RegD] = Type::DOUBLE; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
345 mreg2type[Op_RegL] = TypeLong::LONG; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
346 mreg2type[Op_RegFlags] = TypeInt::CC; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
347 |
| 1761 | 348 TypeAryPtr::RANGE = TypeAryPtr::make( TypePtr::BotPTR, TypeAry::make(Type::BOTTOM,TypeInt::POS), NULL /* current->env()->Object_klass() */, false, arrayOopDesc::length_offset_in_bytes()); |
| 163 | 349 |
| 350 TypeAryPtr::NARROWOOPS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeNarrowOop::BOTTOM, TypeInt::POS), NULL /*ciArrayKlass::make(o)*/, false, Type::OffsetBot); | |
| 351 | |
| 352 #ifdef _LP64 | |
| 353 if (UseCompressedOops) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
354 assert(TypeAryPtr::NARROWOOPS->is_ptr_to_narrowoop(), "array of narrow oops must be ptr to narrow oop"); |
| 163 | 355 TypeAryPtr::OOPS = TypeAryPtr::NARROWOOPS; |
| 356 } else | |
| 357 #endif | |
| 358 { | |
| 359 // There is no shared klass for Object[]. See note in TypeAryPtr::klass(). | |
| 360 TypeAryPtr::OOPS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInstPtr::BOTTOM,TypeInt::POS), NULL /*ciArrayKlass::make(o)*/, false, Type::OffsetBot); | |
| 361 } | |
| 0 | 362 TypeAryPtr::BYTES = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::BYTE ,TypeInt::POS), ciTypeArrayKlass::make(T_BYTE), true, Type::OffsetBot); |
| 363 TypeAryPtr::SHORTS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::SHORT ,TypeInt::POS), ciTypeArrayKlass::make(T_SHORT), true, Type::OffsetBot); | |
| 364 TypeAryPtr::CHARS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::CHAR ,TypeInt::POS), ciTypeArrayKlass::make(T_CHAR), true, Type::OffsetBot); | |
| 365 TypeAryPtr::INTS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::INT ,TypeInt::POS), ciTypeArrayKlass::make(T_INT), true, Type::OffsetBot); | |
| 366 TypeAryPtr::LONGS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeLong::LONG ,TypeInt::POS), ciTypeArrayKlass::make(T_LONG), true, Type::OffsetBot); | |
| 367 TypeAryPtr::FLOATS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::FLOAT ,TypeInt::POS), ciTypeArrayKlass::make(T_FLOAT), true, Type::OffsetBot); | |
| 368 TypeAryPtr::DOUBLES = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::DOUBLE ,TypeInt::POS), ciTypeArrayKlass::make(T_DOUBLE), true, Type::OffsetBot); | |
| 369 | |
| 163 | 370 // Nobody should ask _array_body_type[T_NARROWOOP]. Use NULL as assert. |
| 371 TypeAryPtr::_array_body_type[T_NARROWOOP] = NULL; | |
| 0 | 372 TypeAryPtr::_array_body_type[T_OBJECT] = TypeAryPtr::OOPS; |
| 163 | 373 TypeAryPtr::_array_body_type[T_ARRAY] = TypeAryPtr::OOPS; // arrays are stored in oop arrays |
| 0 | 374 TypeAryPtr::_array_body_type[T_BYTE] = TypeAryPtr::BYTES; |
| 375 TypeAryPtr::_array_body_type[T_BOOLEAN] = TypeAryPtr::BYTES; // boolean[] is a byte array | |
| 376 TypeAryPtr::_array_body_type[T_SHORT] = TypeAryPtr::SHORTS; | |
| 377 TypeAryPtr::_array_body_type[T_CHAR] = TypeAryPtr::CHARS; | |
| 378 TypeAryPtr::_array_body_type[T_INT] = TypeAryPtr::INTS; | |
| 379 TypeAryPtr::_array_body_type[T_LONG] = TypeAryPtr::LONGS; | |
| 380 TypeAryPtr::_array_body_type[T_FLOAT] = TypeAryPtr::FLOATS; | |
| 381 TypeAryPtr::_array_body_type[T_DOUBLE] = TypeAryPtr::DOUBLES; | |
| 382 | |
| 383 TypeKlassPtr::OBJECT = TypeKlassPtr::make( TypePtr::NotNull, current->env()->Object_klass(), 0 ); | |
| 384 TypeKlassPtr::OBJECT_OR_NULL = TypeKlassPtr::make( TypePtr::BotPTR, current->env()->Object_klass(), 0 ); | |
| 385 | |
| 386 const Type **fi2c = TypeTuple::fields(2); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
387 fi2c[TypeFunc::Parms+0] = TypeInstPtr::BOTTOM; // Method* |
| 0 | 388 fi2c[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // argument pointer |
| 389 TypeTuple::START_I2C = TypeTuple::make(TypeFunc::Parms+2, fi2c); | |
| 390 | |
| 391 const Type **intpair = TypeTuple::fields(2); | |
| 392 intpair[0] = TypeInt::INT; | |
| 393 intpair[1] = TypeInt::INT; | |
| 394 TypeTuple::INT_PAIR = TypeTuple::make(2, intpair); | |
| 395 | |
| 396 const Type **longpair = TypeTuple::fields(2); | |
| 397 longpair[0] = TypeLong::LONG; | |
| 398 longpair[1] = TypeLong::LONG; | |
| 399 TypeTuple::LONG_PAIR = TypeTuple::make(2, longpair); | |
| 400 | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
401 _const_basic_type[T_NARROWOOP] = TypeNarrowOop::BOTTOM; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
402 _const_basic_type[T_NARROWKLASS] = Type::BOTTOM; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
403 _const_basic_type[T_BOOLEAN] = TypeInt::BOOL; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
404 _const_basic_type[T_CHAR] = TypeInt::CHAR; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
405 _const_basic_type[T_BYTE] = TypeInt::BYTE; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
406 _const_basic_type[T_SHORT] = TypeInt::SHORT; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
407 _const_basic_type[T_INT] = TypeInt::INT; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
408 _const_basic_type[T_LONG] = TypeLong::LONG; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
409 _const_basic_type[T_FLOAT] = Type::FLOAT; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
410 _const_basic_type[T_DOUBLE] = Type::DOUBLE; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
411 _const_basic_type[T_OBJECT] = TypeInstPtr::BOTTOM; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
412 _const_basic_type[T_ARRAY] = TypeInstPtr::BOTTOM; // there is no separate bottom for arrays |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
413 _const_basic_type[T_VOID] = TypePtr::NULL_PTR; // reflection represents void this way |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
414 _const_basic_type[T_ADDRESS] = TypeRawPtr::BOTTOM; // both interpreter return addresses & random raw ptrs |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
415 _const_basic_type[T_CONFLICT] = Type::BOTTOM; // why not? |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
416 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
417 _zero_type[T_NARROWOOP] = TypeNarrowOop::NULL_PTR; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
418 _zero_type[T_NARROWKLASS] = TypeNarrowKlass::NULL_PTR; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
419 _zero_type[T_BOOLEAN] = TypeInt::ZERO; // false == 0 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
420 _zero_type[T_CHAR] = TypeInt::ZERO; // '\0' == 0 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
421 _zero_type[T_BYTE] = TypeInt::ZERO; // 0x00 == 0 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
422 _zero_type[T_SHORT] = TypeInt::ZERO; // 0x0000 == 0 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
423 _zero_type[T_INT] = TypeInt::ZERO; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
424 _zero_type[T_LONG] = TypeLong::ZERO; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
425 _zero_type[T_FLOAT] = TypeF::ZERO; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
426 _zero_type[T_DOUBLE] = TypeD::ZERO; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
427 _zero_type[T_OBJECT] = TypePtr::NULL_PTR; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
428 _zero_type[T_ARRAY] = TypePtr::NULL_PTR; // null array is null oop |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
429 _zero_type[T_ADDRESS] = TypePtr::NULL_PTR; // raw pointers use the same null |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
430 _zero_type[T_VOID] = Type::TOP; // the only void value is no value at all |
| 0 | 431 |
| 432 // get_zero_type() should not happen for T_CONFLICT | |
| 433 _zero_type[T_CONFLICT]= NULL; | |
| 434 | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
435 // Vector predefined types, it needs initialized _const_basic_type[]. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
436 if (Matcher::vector_size_supported(T_BYTE,4)) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
437 TypeVect::VECTS = TypeVect::make(T_BYTE,4); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
438 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
439 if (Matcher::vector_size_supported(T_FLOAT,2)) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
440 TypeVect::VECTD = TypeVect::make(T_FLOAT,2); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
441 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
442 if (Matcher::vector_size_supported(T_FLOAT,4)) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
443 TypeVect::VECTX = TypeVect::make(T_FLOAT,4); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
444 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
445 if (Matcher::vector_size_supported(T_FLOAT,8)) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
446 TypeVect::VECTY = TypeVect::make(T_FLOAT,8); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
447 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
448 mreg2type[Op_VecS] = TypeVect::VECTS; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
449 mreg2type[Op_VecD] = TypeVect::VECTD; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
450 mreg2type[Op_VecX] = TypeVect::VECTX; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
451 mreg2type[Op_VecY] = TypeVect::VECTY; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
452 |
| 0 | 453 // Restore working type arena. |
| 454 current->set_type_arena(save); | |
| 455 current->set_type_dict(NULL); | |
| 456 } | |
| 457 | |
| 458 //------------------------------Initialize------------------------------------- | |
| 459 void Type::Initialize(Compile* current) { | |
| 460 assert(current->type_arena() != NULL, "must have created type arena"); | |
| 461 | |
| 462 if (_shared_type_dict == NULL) { | |
| 463 Initialize_shared(current); | |
| 464 } | |
| 465 | |
| 466 Arena* type_arena = current->type_arena(); | |
| 467 | |
| 468 // Create the hash-cons'ing dictionary with top-level storage allocation | |
| 469 Dict *tdic = new (type_arena) Dict( (CmpKey)Type::cmp,(Hash)Type::uhash, type_arena, 128 ); | |
| 470 current->set_type_dict(tdic); | |
| 471 | |
| 472 // Transfer the shared types. | |
| 473 DictI i(_shared_type_dict); | |
| 474 for( ; i.test(); ++i ) { | |
| 475 Type* t = (Type*)i._value; | |
| 476 tdic->Insert(t,t); // New Type, insert into Type table | |
| 477 } | |
| 478 } | |
| 479 | |
| 480 //------------------------------hashcons--------------------------------------- | |
| 481 // Do the hash-cons trick. If the Type already exists in the type table, | |
| 482 // delete the current Type and return the existing Type. Otherwise stick the | |
| 483 // current Type in the Type table. | |
| 484 const Type *Type::hashcons(void) { | |
| 485 debug_only(base()); // Check the assertion in Type::base(). | |
| 486 // Look up the Type in the Type dictionary | |
| 487 Dict *tdic = type_dict(); | |
| 488 Type* old = (Type*)(tdic->Insert(this, this, false)); | |
| 489 if( old ) { // Pre-existing Type? | |
| 490 if( old != this ) // Yes, this guy is not the pre-existing? | |
| 491 delete this; // Yes, Nuke this guy | |
| 492 assert( old->_dual, "" ); | |
| 493 return old; // Return pre-existing | |
| 494 } | |
| 495 | |
| 496 // Every type has a dual (to make my lattice symmetric). | |
| 497 // Since we just discovered a new Type, compute its dual right now. | |
| 498 assert( !_dual, "" ); // No dual yet | |
| 499 _dual = xdual(); // Compute the dual | |
| 500 if( cmp(this,_dual)==0 ) { // Handle self-symmetric | |
| 501 _dual = this; | |
| 502 return this; | |
| 503 } | |
| 504 assert( !_dual->_dual, "" ); // No reverse dual yet | |
| 505 assert( !(*tdic)[_dual], "" ); // Dual not in type system either | |
| 506 // New Type, insert into Type table | |
| 507 tdic->Insert((void*)_dual,(void*)_dual); | |
| 508 ((Type*)_dual)->_dual = this; // Finish up being symmetric | |
| 509 #ifdef ASSERT | |
| 510 Type *dual_dual = (Type*)_dual->xdual(); | |
| 511 assert( eq(dual_dual), "xdual(xdual()) should be identity" ); | |
| 512 delete dual_dual; | |
| 513 #endif | |
| 514 return this; // Return new Type | |
| 515 } | |
| 516 | |
| 517 //------------------------------eq--------------------------------------------- | |
| 518 // Structural equality check for Type representations | |
| 519 bool Type::eq( const Type * ) const { | |
| 520 return true; // Nothing else can go wrong | |
| 521 } | |
| 522 | |
| 523 //------------------------------hash------------------------------------------- | |
| 524 // Type-specific hashing function. | |
| 525 int Type::hash(void) const { | |
| 526 return _base; | |
| 527 } | |
| 528 | |
| 529 //------------------------------is_finite-------------------------------------- | |
| 530 // Has a finite value | |
| 531 bool Type::is_finite() const { | |
| 532 return false; | |
| 533 } | |
| 534 | |
| 535 //------------------------------is_nan----------------------------------------- | |
| 536 // Is not a number (NaN) | |
| 537 bool Type::is_nan() const { | |
| 538 return false; | |
| 539 } | |
| 540 | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
541 //----------------------interface_vs_oop--------------------------------------- |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
542 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
543 bool Type::interface_vs_oop(const Type *t) const { |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
544 bool result = false; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
545 |
| 992 | 546 const TypePtr* this_ptr = this->make_ptr(); // In case it is narrow_oop |
| 547 const TypePtr* t_ptr = t->make_ptr(); | |
| 548 if( this_ptr == NULL || t_ptr == NULL ) | |
| 549 return result; | |
| 550 | |
| 551 const TypeInstPtr* this_inst = this_ptr->isa_instptr(); | |
| 552 const TypeInstPtr* t_inst = t_ptr->isa_instptr(); | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
553 if( this_inst && this_inst->is_loaded() && t_inst && t_inst->is_loaded() ) { |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
554 bool this_interface = this_inst->klass()->is_interface(); |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
555 bool t_interface = t_inst->klass()->is_interface(); |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
556 result = this_interface ^ t_interface; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
557 } |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
558 |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
559 return result; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
560 } |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
561 #endif |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
562 |
| 0 | 563 //------------------------------meet------------------------------------------- |
| 564 // Compute the MEET of two types. NOT virtual. It enforces that meet is | |
| 565 // commutative and the lattice is symmetric. | |
| 566 const Type *Type::meet( const Type *t ) const { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
567 if (isa_narrowoop() && t->isa_narrowoop()) { |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
568 const Type* result = make_ptr()->meet(t->make_ptr()); |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
569 return result->make_narrowoop(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
570 } |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
571 if (isa_narrowklass() && t->isa_narrowklass()) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
572 const Type* result = make_ptr()->meet(t->make_ptr()); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
573 return result->make_narrowklass(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
574 } |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
575 |
| 0 | 576 const Type *mt = xmeet(t); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
577 if (isa_narrowoop() || t->isa_narrowoop()) return mt; |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
578 if (isa_narrowklass() || t->isa_narrowklass()) return mt; |
| 0 | 579 #ifdef ASSERT |
| 580 assert( mt == t->xmeet(this), "meet not commutative" ); | |
| 581 const Type* dual_join = mt->_dual; | |
| 582 const Type *t2t = dual_join->xmeet(t->_dual); | |
| 583 const Type *t2this = dual_join->xmeet( _dual); | |
| 584 | |
| 585 // Interface meet Oop is Not Symmetric: | |
| 586 // Interface:AnyNull meet Oop:AnyNull == Interface:AnyNull | |
| 587 // Interface:NotNull meet Oop:NotNull == java/lang/Object:NotNull | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
588 |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
589 if( !interface_vs_oop(t) && (t2t != t->_dual || t2this != _dual) ) { |
| 0 | 590 tty->print_cr("=== Meet Not Symmetric ==="); |
| 591 tty->print("t = "); t->dump(); tty->cr(); | |
| 592 tty->print("this= "); dump(); tty->cr(); | |
| 593 tty->print("mt=(t meet this)= "); mt->dump(); tty->cr(); | |
| 594 | |
| 595 tty->print("t_dual= "); t->_dual->dump(); tty->cr(); | |
| 596 tty->print("this_dual= "); _dual->dump(); tty->cr(); | |
| 597 tty->print("mt_dual= "); mt->_dual->dump(); tty->cr(); | |
| 598 | |
| 599 tty->print("mt_dual meet t_dual= "); t2t ->dump(); tty->cr(); | |
| 600 tty->print("mt_dual meet this_dual= "); t2this ->dump(); tty->cr(); | |
| 601 | |
| 602 fatal("meet not symmetric" ); | |
| 603 } | |
| 604 #endif | |
| 605 return mt; | |
| 606 } | |
| 607 | |
| 608 //------------------------------xmeet------------------------------------------ | |
| 609 // Compute the MEET of two types. It returns a new Type object. | |
| 610 const Type *Type::xmeet( const Type *t ) const { | |
| 611 // Perform a fast test for common case; meeting the same types together. | |
| 612 if( this == t ) return this; // Meeting same type-rep? | |
| 613 | |
| 614 // Meeting TOP with anything? | |
| 615 if( _base == Top ) return t; | |
| 616 | |
| 617 // Meeting BOTTOM with anything? | |
| 618 if( _base == Bottom ) return BOTTOM; | |
| 619 | |
| 620 // Current "this->_base" is one of: Bad, Multi, Control, Top, | |
| 621 // Abio, Abstore, Floatxxx, Doublexxx, Bottom, lastype. | |
| 622 switch (t->base()) { // Switch on original type | |
| 623 | |
| 624 // Cut in half the number of cases I must handle. Only need cases for when | |
| 625 // the given enum "t->type" is less than or equal to the local enum "type". | |
| 626 case FloatCon: | |
| 627 case DoubleCon: | |
| 628 case Int: | |
| 629 case Long: | |
| 630 return t->xmeet(this); | |
| 631 | |
| 632 case OopPtr: | |
| 633 return t->xmeet(this); | |
| 634 | |
| 635 case InstPtr: | |
| 636 return t->xmeet(this); | |
| 637 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
638 case MetadataPtr: |
| 0 | 639 case KlassPtr: |
| 640 return t->xmeet(this); | |
| 641 | |
| 642 case AryPtr: | |
| 643 return t->xmeet(this); | |
| 644 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
645 case NarrowOop: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
646 return t->xmeet(this); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
647 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
648 case NarrowKlass: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
649 return t->xmeet(this); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
650 |
| 0 | 651 case Bad: // Type check |
| 652 default: // Bogus type not in lattice | |
| 653 typerr(t); | |
| 654 return Type::BOTTOM; | |
| 655 | |
| 656 case Bottom: // Ye Olde Default | |
| 657 return t; | |
| 658 | |
| 659 case FloatTop: | |
| 660 if( _base == FloatTop ) return this; | |
| 661 case FloatBot: // Float | |
| 662 if( _base == FloatBot || _base == FloatTop ) return FLOAT; | |
| 663 if( _base == DoubleTop || _base == DoubleBot ) return Type::BOTTOM; | |
| 664 typerr(t); | |
| 665 return Type::BOTTOM; | |
| 666 | |
| 667 case DoubleTop: | |
| 668 if( _base == DoubleTop ) return this; | |
| 669 case DoubleBot: // Double | |
| 670 if( _base == DoubleBot || _base == DoubleTop ) return DOUBLE; | |
| 671 if( _base == FloatTop || _base == FloatBot ) return Type::BOTTOM; | |
| 672 typerr(t); | |
| 673 return Type::BOTTOM; | |
| 674 | |
| 675 // These next few cases must match exactly or it is a compile-time error. | |
| 676 case Control: // Control of code | |
| 677 case Abio: // State of world outside of program | |
| 678 case Memory: | |
| 679 if( _base == t->_base ) return this; | |
| 680 typerr(t); | |
| 681 return Type::BOTTOM; | |
| 682 | |
| 683 case Top: // Top of the lattice | |
| 684 return this; | |
| 685 } | |
| 686 | |
| 687 // The type is unchanged | |
| 688 return this; | |
| 689 } | |
| 690 | |
| 691 //-----------------------------filter------------------------------------------ | |
| 692 const Type *Type::filter( const Type *kills ) const { | |
| 693 const Type* ft = join(kills); | |
| 694 if (ft->empty()) | |
| 695 return Type::TOP; // Canonical empty value | |
| 696 return ft; | |
| 697 } | |
| 698 | |
| 699 //------------------------------xdual------------------------------------------ | |
| 700 // Compute dual right now. | |
| 701 const Type::TYPES Type::dual_type[Type::lastype] = { | |
| 702 Bad, // Bad | |
| 703 Control, // Control | |
| 704 Bottom, // Top | |
| 705 Bad, // Int - handled in v-call | |
| 706 Bad, // Long - handled in v-call | |
| 707 Half, // Half | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
708 Bad, // NarrowOop - handled in v-call |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
709 Bad, // NarrowKlass - handled in v-call |
| 0 | 710 |
| 711 Bad, // Tuple - handled in v-call | |
| 712 Bad, // Array - handled in v-call | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
713 Bad, // VectorS - handled in v-call |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
714 Bad, // VectorD - handled in v-call |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
715 Bad, // VectorX - handled in v-call |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
716 Bad, // VectorY - handled in v-call |
| 0 | 717 |
| 718 Bad, // AnyPtr - handled in v-call | |
| 719 Bad, // RawPtr - handled in v-call | |
| 720 Bad, // OopPtr - handled in v-call | |
| 721 Bad, // InstPtr - handled in v-call | |
| 722 Bad, // AryPtr - handled in v-call | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
723 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
724 Bad, // MetadataPtr - handled in v-call |
| 0 | 725 Bad, // KlassPtr - handled in v-call |
| 726 | |
| 727 Bad, // Function - handled in v-call | |
| 728 Abio, // Abio | |
| 729 Return_Address,// Return_Address | |
| 730 Memory, // Memory | |
| 731 FloatBot, // FloatTop | |
| 732 FloatCon, // FloatCon | |
| 733 FloatTop, // FloatBot | |
| 734 DoubleBot, // DoubleTop | |
| 735 DoubleCon, // DoubleCon | |
| 736 DoubleTop, // DoubleBot | |
| 737 Top // Bottom | |
| 738 }; | |
| 739 | |
| 740 const Type *Type::xdual() const { | |
| 741 // Note: the base() accessor asserts the sanity of _base. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
742 assert(_type_info[base()].dual_type != Bad, "implement with v-call"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
743 return new Type(_type_info[_base].dual_type); |
| 0 | 744 } |
| 745 | |
| 746 //------------------------------has_memory------------------------------------- | |
| 747 bool Type::has_memory() const { | |
| 748 Type::TYPES tx = base(); | |
| 749 if (tx == Memory) return true; | |
| 750 if (tx == Tuple) { | |
| 751 const TypeTuple *t = is_tuple(); | |
| 752 for (uint i=0; i < t->cnt(); i++) { | |
| 753 tx = t->field_at(i)->base(); | |
| 754 if (tx == Memory) return true; | |
| 755 } | |
| 756 } | |
| 757 return false; | |
| 758 } | |
| 759 | |
| 760 #ifndef PRODUCT | |
| 761 //------------------------------dump2------------------------------------------ | |
| 762 void Type::dump2( Dict &d, uint depth, outputStream *st ) const { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
763 st->print(_type_info[_base].msg); |
| 0 | 764 } |
| 765 | |
| 766 //------------------------------dump------------------------------------------- | |
| 767 void Type::dump_on(outputStream *st) const { | |
| 768 ResourceMark rm; | |
| 769 Dict d(cmpkey,hashkey); // Stop recursive type dumping | |
| 770 dump2(d,1, st); | |
| 163 | 771 if (is_ptr_to_narrowoop()) { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
772 st->print(" [narrow]"); |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
773 } else if (is_ptr_to_narrowklass()) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
774 st->print(" [narrowklass]"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
775 } |
| 0 | 776 } |
| 777 #endif | |
| 778 | |
| 779 //------------------------------singleton-------------------------------------- | |
| 780 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 781 // constants (Ldi nodes). Singletons are integer, float or double constants. | |
| 782 bool Type::singleton(void) const { | |
| 783 return _base == Top || _base == Half; | |
| 784 } | |
| 785 | |
| 786 //------------------------------empty------------------------------------------ | |
| 787 // TRUE if Type is a type with no values, FALSE otherwise. | |
| 788 bool Type::empty(void) const { | |
| 789 switch (_base) { | |
| 790 case DoubleTop: | |
| 791 case FloatTop: | |
| 792 case Top: | |
| 793 return true; | |
| 794 | |
| 795 case Half: | |
| 796 case Abio: | |
| 797 case Return_Address: | |
| 798 case Memory: | |
| 799 case Bottom: | |
| 800 case FloatBot: | |
| 801 case DoubleBot: | |
| 802 return false; // never a singleton, therefore never empty | |
| 803 } | |
| 804 | |
| 805 ShouldNotReachHere(); | |
| 806 return false; | |
| 807 } | |
| 808 | |
| 809 //------------------------------dump_stats------------------------------------- | |
| 810 // Dump collected statistics to stderr | |
| 811 #ifndef PRODUCT | |
| 812 void Type::dump_stats() { | |
| 813 tty->print("Types made: %d\n", type_dict()->Size()); | |
| 814 } | |
| 815 #endif | |
| 816 | |
| 817 //------------------------------typerr----------------------------------------- | |
| 818 void Type::typerr( const Type *t ) const { | |
| 819 #ifndef PRODUCT | |
| 820 tty->print("\nError mixing types: "); | |
| 821 dump(); | |
| 822 tty->print(" and "); | |
| 823 t->dump(); | |
| 824 tty->print("\n"); | |
| 825 #endif | |
| 826 ShouldNotReachHere(); | |
| 827 } | |
| 828 | |
| 829 | |
| 830 //============================================================================= | |
| 831 // Convenience common pre-built types. | |
| 832 const TypeF *TypeF::ZERO; // Floating point zero | |
| 833 const TypeF *TypeF::ONE; // Floating point one | |
| 834 | |
| 835 //------------------------------make------------------------------------------- | |
| 836 // Create a float constant | |
| 837 const TypeF *TypeF::make(float f) { | |
| 838 return (TypeF*)(new TypeF(f))->hashcons(); | |
| 839 } | |
| 840 | |
| 841 //------------------------------meet------------------------------------------- | |
| 842 // Compute the MEET of two types. It returns a new Type object. | |
| 843 const Type *TypeF::xmeet( const Type *t ) const { | |
| 844 // Perform a fast test for common case; meeting the same types together. | |
| 845 if( this == t ) return this; // Meeting same type-rep? | |
| 846 | |
| 847 // Current "this->_base" is FloatCon | |
| 848 switch (t->base()) { // Switch on original type | |
| 849 case AnyPtr: // Mixing with oops happens when javac | |
| 850 case RawPtr: // reuses local variables | |
| 851 case OopPtr: | |
| 852 case InstPtr: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
853 case AryPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
854 case MetadataPtr: |
| 0 | 855 case KlassPtr: |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
856 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
857 case NarrowKlass: |
| 0 | 858 case Int: |
| 859 case Long: | |
| 860 case DoubleTop: | |
| 861 case DoubleCon: | |
| 862 case DoubleBot: | |
| 863 case Bottom: // Ye Olde Default | |
| 864 return Type::BOTTOM; | |
| 865 | |
| 866 case FloatBot: | |
| 867 return t; | |
| 868 | |
| 869 default: // All else is a mistake | |
| 870 typerr(t); | |
| 871 | |
| 872 case FloatCon: // Float-constant vs Float-constant? | |
| 873 if( jint_cast(_f) != jint_cast(t->getf()) ) // unequal constants? | |
| 874 // must compare bitwise as positive zero, negative zero and NaN have | |
| 875 // all the same representation in C++ | |
| 876 return FLOAT; // Return generic float | |
| 877 // Equal constants | |
| 878 case Top: | |
| 879 case FloatTop: | |
| 880 break; // Return the float constant | |
| 881 } | |
| 882 return this; // Return the float constant | |
| 883 } | |
| 884 | |
| 885 //------------------------------xdual------------------------------------------ | |
| 886 // Dual: symmetric | |
| 887 const Type *TypeF::xdual() const { | |
| 888 return this; | |
| 889 } | |
| 890 | |
| 891 //------------------------------eq--------------------------------------------- | |
| 892 // Structural equality check for Type representations | |
| 893 bool TypeF::eq( const Type *t ) const { | |
| 894 if( g_isnan(_f) || | |
| 895 g_isnan(t->getf()) ) { | |
| 896 // One or both are NANs. If both are NANs return true, else false. | |
| 897 return (g_isnan(_f) && g_isnan(t->getf())); | |
| 898 } | |
| 899 if (_f == t->getf()) { | |
| 900 // (NaN is impossible at this point, since it is not equal even to itself) | |
| 901 if (_f == 0.0) { | |
| 902 // difference between positive and negative zero | |
| 903 if (jint_cast(_f) != jint_cast(t->getf())) return false; | |
| 904 } | |
| 905 return true; | |
| 906 } | |
| 907 return false; | |
| 908 } | |
| 909 | |
| 910 //------------------------------hash------------------------------------------- | |
| 911 // Type-specific hashing function. | |
| 912 int TypeF::hash(void) const { | |
| 913 return *(int*)(&_f); | |
| 914 } | |
| 915 | |
| 916 //------------------------------is_finite-------------------------------------- | |
| 917 // Has a finite value | |
| 918 bool TypeF::is_finite() const { | |
| 919 return g_isfinite(getf()) != 0; | |
| 920 } | |
| 921 | |
| 922 //------------------------------is_nan----------------------------------------- | |
| 923 // Is not a number (NaN) | |
| 924 bool TypeF::is_nan() const { | |
| 925 return g_isnan(getf()) != 0; | |
| 926 } | |
| 927 | |
| 928 //------------------------------dump2------------------------------------------ | |
| 929 // Dump float constant Type | |
| 930 #ifndef PRODUCT | |
| 931 void TypeF::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 932 Type::dump2(d,depth, st); | |
| 933 st->print("%f", _f); | |
| 934 } | |
| 935 #endif | |
| 936 | |
| 937 //------------------------------singleton-------------------------------------- | |
| 938 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 939 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 940 // or a single symbol. | |
| 941 bool TypeF::singleton(void) const { | |
| 942 return true; // Always a singleton | |
| 943 } | |
| 944 | |
| 945 bool TypeF::empty(void) const { | |
| 946 return false; // always exactly a singleton | |
| 947 } | |
| 948 | |
| 949 //============================================================================= | |
| 950 // Convenience common pre-built types. | |
| 951 const TypeD *TypeD::ZERO; // Floating point zero | |
| 952 const TypeD *TypeD::ONE; // Floating point one | |
| 953 | |
| 954 //------------------------------make------------------------------------------- | |
| 955 const TypeD *TypeD::make(double d) { | |
| 956 return (TypeD*)(new TypeD(d))->hashcons(); | |
| 957 } | |
| 958 | |
| 959 //------------------------------meet------------------------------------------- | |
| 960 // Compute the MEET of two types. It returns a new Type object. | |
| 961 const Type *TypeD::xmeet( const Type *t ) const { | |
| 962 // Perform a fast test for common case; meeting the same types together. | |
| 963 if( this == t ) return this; // Meeting same type-rep? | |
| 964 | |
| 965 // Current "this->_base" is DoubleCon | |
| 966 switch (t->base()) { // Switch on original type | |
| 967 case AnyPtr: // Mixing with oops happens when javac | |
| 968 case RawPtr: // reuses local variables | |
| 969 case OopPtr: | |
| 970 case InstPtr: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
971 case AryPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
972 case MetadataPtr: |
| 0 | 973 case KlassPtr: |
|
183
d4dbd9f91680
6711083: 64bit JVM crashes with Internal Error (type.cpp:763) - ShouldNotReachHere() with enabled COOPs
never
parents:
163
diff
changeset
|
974 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
975 case NarrowKlass: |
| 0 | 976 case Int: |
| 977 case Long: | |
| 978 case FloatTop: | |
| 979 case FloatCon: | |
| 980 case FloatBot: | |
| 981 case Bottom: // Ye Olde Default | |
| 982 return Type::BOTTOM; | |
| 983 | |
| 984 case DoubleBot: | |
| 985 return t; | |
| 986 | |
| 987 default: // All else is a mistake | |
| 988 typerr(t); | |
| 989 | |
| 990 case DoubleCon: // Double-constant vs Double-constant? | |
| 991 if( jlong_cast(_d) != jlong_cast(t->getd()) ) // unequal constants? (see comment in TypeF::xmeet) | |
| 992 return DOUBLE; // Return generic double | |
| 993 case Top: | |
| 994 case DoubleTop: | |
| 995 break; | |
| 996 } | |
| 997 return this; // Return the double constant | |
| 998 } | |
| 999 | |
| 1000 //------------------------------xdual------------------------------------------ | |
| 1001 // Dual: symmetric | |
| 1002 const Type *TypeD::xdual() const { | |
| 1003 return this; | |
| 1004 } | |
| 1005 | |
| 1006 //------------------------------eq--------------------------------------------- | |
| 1007 // Structural equality check for Type representations | |
| 1008 bool TypeD::eq( const Type *t ) const { | |
| 1009 if( g_isnan(_d) || | |
| 1010 g_isnan(t->getd()) ) { | |
| 1011 // One or both are NANs. If both are NANs return true, else false. | |
| 1012 return (g_isnan(_d) && g_isnan(t->getd())); | |
| 1013 } | |
| 1014 if (_d == t->getd()) { | |
| 1015 // (NaN is impossible at this point, since it is not equal even to itself) | |
| 1016 if (_d == 0.0) { | |
| 1017 // difference between positive and negative zero | |
| 1018 if (jlong_cast(_d) != jlong_cast(t->getd())) return false; | |
| 1019 } | |
| 1020 return true; | |
| 1021 } | |
| 1022 return false; | |
| 1023 } | |
| 1024 | |
| 1025 //------------------------------hash------------------------------------------- | |
| 1026 // Type-specific hashing function. | |
| 1027 int TypeD::hash(void) const { | |
| 1028 return *(int*)(&_d); | |
| 1029 } | |
| 1030 | |
| 1031 //------------------------------is_finite-------------------------------------- | |
| 1032 // Has a finite value | |
| 1033 bool TypeD::is_finite() const { | |
| 1034 return g_isfinite(getd()) != 0; | |
| 1035 } | |
| 1036 | |
| 1037 //------------------------------is_nan----------------------------------------- | |
| 1038 // Is not a number (NaN) | |
| 1039 bool TypeD::is_nan() const { | |
| 1040 return g_isnan(getd()) != 0; | |
| 1041 } | |
| 1042 | |
| 1043 //------------------------------dump2------------------------------------------ | |
| 1044 // Dump double constant Type | |
| 1045 #ifndef PRODUCT | |
| 1046 void TypeD::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1047 Type::dump2(d,depth,st); | |
| 1048 st->print("%f", _d); | |
| 1049 } | |
| 1050 #endif | |
| 1051 | |
| 1052 //------------------------------singleton-------------------------------------- | |
| 1053 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1054 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 1055 // or a single symbol. | |
| 1056 bool TypeD::singleton(void) const { | |
| 1057 return true; // Always a singleton | |
| 1058 } | |
| 1059 | |
| 1060 bool TypeD::empty(void) const { | |
| 1061 return false; // always exactly a singleton | |
| 1062 } | |
| 1063 | |
| 1064 //============================================================================= | |
| 1065 // Convience common pre-built types. | |
| 1066 const TypeInt *TypeInt::MINUS_1;// -1 | |
| 1067 const TypeInt *TypeInt::ZERO; // 0 | |
| 1068 const TypeInt *TypeInt::ONE; // 1 | |
| 1069 const TypeInt *TypeInt::BOOL; // 0 or 1, FALSE or TRUE. | |
| 1070 const TypeInt *TypeInt::CC; // -1,0 or 1, condition codes | |
| 1071 const TypeInt *TypeInt::CC_LT; // [-1] == MINUS_1 | |
| 1072 const TypeInt *TypeInt::CC_GT; // [1] == ONE | |
| 1073 const TypeInt *TypeInt::CC_EQ; // [0] == ZERO | |
| 1074 const TypeInt *TypeInt::CC_LE; // [-1,0] | |
| 1075 const TypeInt *TypeInt::CC_GE; // [0,1] == BOOL (!) | |
| 1076 const TypeInt *TypeInt::BYTE; // Bytes, -128 to 127 | |
| 624 | 1077 const TypeInt *TypeInt::UBYTE; // Unsigned Bytes, 0 to 255 |
| 0 | 1078 const TypeInt *TypeInt::CHAR; // Java chars, 0-65535 |
| 1079 const TypeInt *TypeInt::SHORT; // Java shorts, -32768-32767 | |
| 1080 const TypeInt *TypeInt::POS; // Positive 32-bit integers or zero | |
| 1081 const TypeInt *TypeInt::POS1; // Positive 32-bit integers | |
| 1082 const TypeInt *TypeInt::INT; // 32-bit integers | |
| 1083 const TypeInt *TypeInt::SYMINT; // symmetric range [-max_jint..max_jint] | |
| 1084 | |
| 1085 //------------------------------TypeInt---------------------------------------- | |
| 1086 TypeInt::TypeInt( jint lo, jint hi, int w ) : Type(Int), _lo(lo), _hi(hi), _widen(w) { | |
| 1087 } | |
| 1088 | |
| 1089 //------------------------------make------------------------------------------- | |
| 1090 const TypeInt *TypeInt::make( jint lo ) { | |
| 1091 return (TypeInt*)(new TypeInt(lo,lo,WidenMin))->hashcons(); | |
| 1092 } | |
| 1093 | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1094 static int normalize_int_widen( jint lo, jint hi, int w ) { |
| 0 | 1095 // Certain normalizations keep us sane when comparing types. |
| 1096 // The 'SMALLINT' covers constants and also CC and its relatives. | |
| 1097 if (lo <= hi) { | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1098 if ((juint)(hi - lo) <= SMALLINT) w = Type::WidenMin; |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1099 if ((juint)(hi - lo) >= max_juint) w = Type::WidenMax; // TypeInt::INT |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1100 } else { |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1101 if ((juint)(lo - hi) <= SMALLINT) w = Type::WidenMin; |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1102 if ((juint)(lo - hi) >= max_juint) w = Type::WidenMin; // dual TypeInt::INT |
| 0 | 1103 } |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1104 return w; |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1105 } |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1106 |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1107 const TypeInt *TypeInt::make( jint lo, jint hi, int w ) { |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1108 w = normalize_int_widen(lo, hi, w); |
| 0 | 1109 return (TypeInt*)(new TypeInt(lo,hi,w))->hashcons(); |
| 1110 } | |
| 1111 | |
| 1112 //------------------------------meet------------------------------------------- | |
| 1113 // Compute the MEET of two types. It returns a new Type representation object | |
| 1114 // with reference count equal to the number of Types pointing at it. | |
| 1115 // Caller should wrap a Types around it. | |
| 1116 const Type *TypeInt::xmeet( const Type *t ) const { | |
| 1117 // Perform a fast test for common case; meeting the same types together. | |
| 1118 if( this == t ) return this; // Meeting same type? | |
| 1119 | |
| 1120 // Currently "this->_base" is a TypeInt | |
| 1121 switch (t->base()) { // Switch on original type | |
| 1122 case AnyPtr: // Mixing with oops happens when javac | |
| 1123 case RawPtr: // reuses local variables | |
| 1124 case OopPtr: | |
| 1125 case InstPtr: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
1126 case AryPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
1127 case MetadataPtr: |
| 0 | 1128 case KlassPtr: |
|
183
d4dbd9f91680
6711083: 64bit JVM crashes with Internal Error (type.cpp:763) - ShouldNotReachHere() with enabled COOPs
never
parents:
163
diff
changeset
|
1129 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
1130 case NarrowKlass: |
| 0 | 1131 case Long: |
| 1132 case FloatTop: | |
| 1133 case FloatCon: | |
| 1134 case FloatBot: | |
| 1135 case DoubleTop: | |
| 1136 case DoubleCon: | |
| 1137 case DoubleBot: | |
| 1138 case Bottom: // Ye Olde Default | |
| 1139 return Type::BOTTOM; | |
| 1140 default: // All else is a mistake | |
| 1141 typerr(t); | |
| 1142 case Top: // No change | |
| 1143 return this; | |
| 1144 case Int: // Int vs Int? | |
| 1145 break; | |
| 1146 } | |
| 1147 | |
| 1148 // Expand covered set | |
| 1149 const TypeInt *r = t->is_int(); | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1150 return make( MIN2(_lo,r->_lo), MAX2(_hi,r->_hi), MAX2(_widen,r->_widen) ); |
| 0 | 1151 } |
| 1152 | |
| 1153 //------------------------------xdual------------------------------------------ | |
| 1154 // Dual: reverse hi & lo; flip widen | |
| 1155 const Type *TypeInt::xdual() const { | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1156 int w = normalize_int_widen(_hi,_lo, WidenMax-_widen); |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1157 return new TypeInt(_hi,_lo,w); |
| 0 | 1158 } |
| 1159 | |
| 1160 //------------------------------widen------------------------------------------ | |
| 1161 // Only happens for optimistic top-down optimizations. | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1162 const Type *TypeInt::widen( const Type *old, const Type* limit ) const { |
| 0 | 1163 // Coming from TOP or such; no widening |
| 1164 if( old->base() != Int ) return this; | |
| 1165 const TypeInt *ot = old->is_int(); | |
| 1166 | |
| 1167 // If new guy is equal to old guy, no widening | |
| 1168 if( _lo == ot->_lo && _hi == ot->_hi ) | |
| 1169 return old; | |
| 1170 | |
| 1171 // If new guy contains old, then we widened | |
| 1172 if( _lo <= ot->_lo && _hi >= ot->_hi ) { | |
| 1173 // New contains old | |
| 1174 // If new guy is already wider than old, no widening | |
| 1175 if( _widen > ot->_widen ) return this; | |
| 1176 // If old guy was a constant, do not bother | |
| 1177 if (ot->_lo == ot->_hi) return this; | |
| 1178 // Now widen new guy. | |
| 1179 // Check for widening too far | |
| 1180 if (_widen == WidenMax) { | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1181 int max = max_jint; |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1182 int min = min_jint; |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1183 if (limit->isa_int()) { |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1184 max = limit->is_int()->_hi; |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1185 min = limit->is_int()->_lo; |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1186 } |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1187 if (min < _lo && _hi < max) { |
| 0 | 1188 // If neither endpoint is extremal yet, push out the endpoint |
| 1189 // which is closer to its respective limit. | |
| 1190 if (_lo >= 0 || // easy common case | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1191 (juint)(_lo - min) >= (juint)(max - _hi)) { |
| 0 | 1192 // Try to widen to an unsigned range type of 31 bits: |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1193 return make(_lo, max, WidenMax); |
| 0 | 1194 } else { |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1195 return make(min, _hi, WidenMax); |
| 0 | 1196 } |
| 1197 } | |
| 1198 return TypeInt::INT; | |
| 1199 } | |
| 1200 // Returned widened new guy | |
| 1201 return make(_lo,_hi,_widen+1); | |
| 1202 } | |
| 1203 | |
| 1204 // If old guy contains new, then we probably widened too far & dropped to | |
| 1205 // bottom. Return the wider fellow. | |
| 1206 if ( ot->_lo <= _lo && ot->_hi >= _hi ) | |
| 1207 return old; | |
| 1208 | |
| 1209 //fatal("Integer value range is not subset"); | |
| 1210 //return this; | |
| 1211 return TypeInt::INT; | |
| 1212 } | |
| 1213 | |
| 1214 //------------------------------narrow--------------------------------------- | |
| 1215 // Only happens for pessimistic optimizations. | |
| 1216 const Type *TypeInt::narrow( const Type *old ) const { | |
| 1217 if (_lo >= _hi) return this; // already narrow enough | |
| 1218 if (old == NULL) return this; | |
| 1219 const TypeInt* ot = old->isa_int(); | |
| 1220 if (ot == NULL) return this; | |
| 1221 jint olo = ot->_lo; | |
| 1222 jint ohi = ot->_hi; | |
| 1223 | |
| 1224 // If new guy is equal to old guy, no narrowing | |
| 1225 if (_lo == olo && _hi == ohi) return old; | |
| 1226 | |
| 1227 // If old guy was maximum range, allow the narrowing | |
| 1228 if (olo == min_jint && ohi == max_jint) return this; | |
| 1229 | |
| 1230 if (_lo < olo || _hi > ohi) | |
| 1231 return this; // doesn't narrow; pretty wierd | |
| 1232 | |
| 1233 // The new type narrows the old type, so look for a "death march". | |
| 1234 // See comments on PhaseTransform::saturate. | |
| 1235 juint nrange = _hi - _lo; | |
| 1236 juint orange = ohi - olo; | |
| 1237 if (nrange < max_juint - 1 && nrange > (orange >> 1) + (SMALLINT*2)) { | |
| 1238 // Use the new type only if the range shrinks a lot. | |
| 1239 // We do not want the optimizer computing 2^31 point by point. | |
| 1240 return old; | |
| 1241 } | |
| 1242 | |
| 1243 return this; | |
| 1244 } | |
| 1245 | |
| 1246 //-----------------------------filter------------------------------------------ | |
| 1247 const Type *TypeInt::filter( const Type *kills ) const { | |
| 1248 const TypeInt* ft = join(kills)->isa_int(); | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1249 if (ft == NULL || ft->empty()) |
| 0 | 1250 return Type::TOP; // Canonical empty value |
| 1251 if (ft->_widen < this->_widen) { | |
| 1252 // Do not allow the value of kill->_widen to affect the outcome. | |
| 1253 // The widen bits must be allowed to run freely through the graph. | |
| 1254 ft = TypeInt::make(ft->_lo, ft->_hi, this->_widen); | |
| 1255 } | |
| 1256 return ft; | |
| 1257 } | |
| 1258 | |
| 1259 //------------------------------eq--------------------------------------------- | |
| 1260 // Structural equality check for Type representations | |
| 1261 bool TypeInt::eq( const Type *t ) const { | |
| 1262 const TypeInt *r = t->is_int(); // Handy access | |
| 1263 return r->_lo == _lo && r->_hi == _hi && r->_widen == _widen; | |
| 1264 } | |
| 1265 | |
| 1266 //------------------------------hash------------------------------------------- | |
| 1267 // Type-specific hashing function. | |
| 1268 int TypeInt::hash(void) const { | |
| 1269 return _lo+_hi+_widen+(int)Type::Int; | |
| 1270 } | |
| 1271 | |
| 1272 //------------------------------is_finite-------------------------------------- | |
| 1273 // Has a finite value | |
| 1274 bool TypeInt::is_finite() const { | |
| 1275 return true; | |
| 1276 } | |
| 1277 | |
| 1278 //------------------------------dump2------------------------------------------ | |
| 1279 // Dump TypeInt | |
| 1280 #ifndef PRODUCT | |
| 1281 static const char* intname(char* buf, jint n) { | |
| 1282 if (n == min_jint) | |
| 1283 return "min"; | |
| 1284 else if (n < min_jint + 10000) | |
| 1285 sprintf(buf, "min+" INT32_FORMAT, n - min_jint); | |
| 1286 else if (n == max_jint) | |
| 1287 return "max"; | |
| 1288 else if (n > max_jint - 10000) | |
| 1289 sprintf(buf, "max-" INT32_FORMAT, max_jint - n); | |
| 1290 else | |
| 1291 sprintf(buf, INT32_FORMAT, n); | |
| 1292 return buf; | |
| 1293 } | |
| 1294 | |
| 1295 void TypeInt::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1296 char buf[40], buf2[40]; | |
| 1297 if (_lo == min_jint && _hi == max_jint) | |
| 1298 st->print("int"); | |
| 1299 else if (is_con()) | |
| 1300 st->print("int:%s", intname(buf, get_con())); | |
| 1301 else if (_lo == BOOL->_lo && _hi == BOOL->_hi) | |
| 1302 st->print("bool"); | |
| 1303 else if (_lo == BYTE->_lo && _hi == BYTE->_hi) | |
| 1304 st->print("byte"); | |
| 1305 else if (_lo == CHAR->_lo && _hi == CHAR->_hi) | |
| 1306 st->print("char"); | |
| 1307 else if (_lo == SHORT->_lo && _hi == SHORT->_hi) | |
| 1308 st->print("short"); | |
| 1309 else if (_hi == max_jint) | |
| 1310 st->print("int:>=%s", intname(buf, _lo)); | |
| 1311 else if (_lo == min_jint) | |
| 1312 st->print("int:<=%s", intname(buf, _hi)); | |
| 1313 else | |
| 1314 st->print("int:%s..%s", intname(buf, _lo), intname(buf2, _hi)); | |
| 1315 | |
| 1316 if (_widen != 0 && this != TypeInt::INT) | |
| 1317 st->print(":%.*s", _widen, "wwww"); | |
| 1318 } | |
| 1319 #endif | |
| 1320 | |
| 1321 //------------------------------singleton-------------------------------------- | |
| 1322 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1323 // constants. | |
| 1324 bool TypeInt::singleton(void) const { | |
| 1325 return _lo >= _hi; | |
| 1326 } | |
| 1327 | |
| 1328 bool TypeInt::empty(void) const { | |
| 1329 return _lo > _hi; | |
| 1330 } | |
| 1331 | |
| 1332 //============================================================================= | |
| 1333 // Convenience common pre-built types. | |
| 1334 const TypeLong *TypeLong::MINUS_1;// -1 | |
| 1335 const TypeLong *TypeLong::ZERO; // 0 | |
| 1336 const TypeLong *TypeLong::ONE; // 1 | |
| 1337 const TypeLong *TypeLong::POS; // >=0 | |
| 1338 const TypeLong *TypeLong::LONG; // 64-bit integers | |
| 1339 const TypeLong *TypeLong::INT; // 32-bit subrange | |
| 1340 const TypeLong *TypeLong::UINT; // 32-bit unsigned subrange | |
| 1341 | |
| 1342 //------------------------------TypeLong--------------------------------------- | |
| 1343 TypeLong::TypeLong( jlong lo, jlong hi, int w ) : Type(Long), _lo(lo), _hi(hi), _widen(w) { | |
| 1344 } | |
| 1345 | |
| 1346 //------------------------------make------------------------------------------- | |
| 1347 const TypeLong *TypeLong::make( jlong lo ) { | |
| 1348 return (TypeLong*)(new TypeLong(lo,lo,WidenMin))->hashcons(); | |
| 1349 } | |
| 1350 | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1351 static int normalize_long_widen( jlong lo, jlong hi, int w ) { |
| 0 | 1352 // Certain normalizations keep us sane when comparing types. |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1353 // The 'SMALLINT' covers constants. |
| 0 | 1354 if (lo <= hi) { |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1355 if ((julong)(hi - lo) <= SMALLINT) w = Type::WidenMin; |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1356 if ((julong)(hi - lo) >= max_julong) w = Type::WidenMax; // TypeLong::LONG |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1357 } else { |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1358 if ((julong)(lo - hi) <= SMALLINT) w = Type::WidenMin; |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1359 if ((julong)(lo - hi) >= max_julong) w = Type::WidenMin; // dual TypeLong::LONG |
| 0 | 1360 } |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1361 return w; |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1362 } |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1363 |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1364 const TypeLong *TypeLong::make( jlong lo, jlong hi, int w ) { |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1365 w = normalize_long_widen(lo, hi, w); |
| 0 | 1366 return (TypeLong*)(new TypeLong(lo,hi,w))->hashcons(); |
| 1367 } | |
| 1368 | |
| 1369 | |
| 1370 //------------------------------meet------------------------------------------- | |
| 1371 // Compute the MEET of two types. It returns a new Type representation object | |
| 1372 // with reference count equal to the number of Types pointing at it. | |
| 1373 // Caller should wrap a Types around it. | |
| 1374 const Type *TypeLong::xmeet( const Type *t ) const { | |
| 1375 // Perform a fast test for common case; meeting the same types together. | |
| 1376 if( this == t ) return this; // Meeting same type? | |
| 1377 | |
| 1378 // Currently "this->_base" is a TypeLong | |
| 1379 switch (t->base()) { // Switch on original type | |
| 1380 case AnyPtr: // Mixing with oops happens when javac | |
| 1381 case RawPtr: // reuses local variables | |
| 1382 case OopPtr: | |
| 1383 case InstPtr: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
1384 case AryPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
1385 case MetadataPtr: |
| 0 | 1386 case KlassPtr: |
|
183
d4dbd9f91680
6711083: 64bit JVM crashes with Internal Error (type.cpp:763) - ShouldNotReachHere() with enabled COOPs
never
parents:
163
diff
changeset
|
1387 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
1388 case NarrowKlass: |
| 0 | 1389 case Int: |
| 1390 case FloatTop: | |
| 1391 case FloatCon: | |
| 1392 case FloatBot: | |
| 1393 case DoubleTop: | |
| 1394 case DoubleCon: | |
| 1395 case DoubleBot: | |
| 1396 case Bottom: // Ye Olde Default | |
| 1397 return Type::BOTTOM; | |
| 1398 default: // All else is a mistake | |
| 1399 typerr(t); | |
| 1400 case Top: // No change | |
| 1401 return this; | |
| 1402 case Long: // Long vs Long? | |
| 1403 break; | |
| 1404 } | |
| 1405 | |
| 1406 // Expand covered set | |
| 1407 const TypeLong *r = t->is_long(); // Turn into a TypeLong | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1408 return make( MIN2(_lo,r->_lo), MAX2(_hi,r->_hi), MAX2(_widen,r->_widen) ); |
| 0 | 1409 } |
| 1410 | |
| 1411 //------------------------------xdual------------------------------------------ | |
| 1412 // Dual: reverse hi & lo; flip widen | |
| 1413 const Type *TypeLong::xdual() const { | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1414 int w = normalize_long_widen(_hi,_lo, WidenMax-_widen); |
|
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1415 return new TypeLong(_hi,_lo,w); |
| 0 | 1416 } |
| 1417 | |
| 1418 //------------------------------widen------------------------------------------ | |
| 1419 // Only happens for optimistic top-down optimizations. | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1420 const Type *TypeLong::widen( const Type *old, const Type* limit ) const { |
| 0 | 1421 // Coming from TOP or such; no widening |
| 1422 if( old->base() != Long ) return this; | |
| 1423 const TypeLong *ot = old->is_long(); | |
| 1424 | |
| 1425 // If new guy is equal to old guy, no widening | |
| 1426 if( _lo == ot->_lo && _hi == ot->_hi ) | |
| 1427 return old; | |
| 1428 | |
| 1429 // If new guy contains old, then we widened | |
| 1430 if( _lo <= ot->_lo && _hi >= ot->_hi ) { | |
| 1431 // New contains old | |
| 1432 // If new guy is already wider than old, no widening | |
| 1433 if( _widen > ot->_widen ) return this; | |
| 1434 // If old guy was a constant, do not bother | |
| 1435 if (ot->_lo == ot->_hi) return this; | |
| 1436 // Now widen new guy. | |
| 1437 // Check for widening too far | |
| 1438 if (_widen == WidenMax) { | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1439 jlong max = max_jlong; |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1440 jlong min = min_jlong; |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1441 if (limit->isa_long()) { |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1442 max = limit->is_long()->_hi; |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1443 min = limit->is_long()->_lo; |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1444 } |
|
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1445 if (min < _lo && _hi < max) { |
| 0 | 1446 // If neither endpoint is extremal yet, push out the endpoint |
| 1447 // which is closer to its respective limit. | |
| 1448 if (_lo >= 0 || // easy common case | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1449 (julong)(_lo - min) >= (julong)(max - _hi)) { |
| 0 | 1450 // Try to widen to an unsigned range type of 32/63 bits: |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1451 if (max >= max_juint && _hi < max_juint) |
| 0 | 1452 return make(_lo, max_juint, WidenMax); |
| 1453 else | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1454 return make(_lo, max, WidenMax); |
| 0 | 1455 } else { |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
1456 return make(min, _hi, WidenMax); |
| 0 | 1457 } |
| 1458 } | |
| 1459 return TypeLong::LONG; | |
| 1460 } | |
| 1461 // Returned widened new guy | |
| 1462 return make(_lo,_hi,_widen+1); | |
| 1463 } | |
| 1464 | |
| 1465 // If old guy contains new, then we probably widened too far & dropped to | |
| 1466 // bottom. Return the wider fellow. | |
| 1467 if ( ot->_lo <= _lo && ot->_hi >= _hi ) | |
| 1468 return old; | |
| 1469 | |
| 1470 // fatal("Long value range is not subset"); | |
| 1471 // return this; | |
| 1472 return TypeLong::LONG; | |
| 1473 } | |
| 1474 | |
| 1475 //------------------------------narrow---------------------------------------- | |
| 1476 // Only happens for pessimistic optimizations. | |
| 1477 const Type *TypeLong::narrow( const Type *old ) const { | |
| 1478 if (_lo >= _hi) return this; // already narrow enough | |
| 1479 if (old == NULL) return this; | |
| 1480 const TypeLong* ot = old->isa_long(); | |
| 1481 if (ot == NULL) return this; | |
| 1482 jlong olo = ot->_lo; | |
| 1483 jlong ohi = ot->_hi; | |
| 1484 | |
| 1485 // If new guy is equal to old guy, no narrowing | |
| 1486 if (_lo == olo && _hi == ohi) return old; | |
| 1487 | |
| 1488 // If old guy was maximum range, allow the narrowing | |
| 1489 if (olo == min_jlong && ohi == max_jlong) return this; | |
| 1490 | |
| 1491 if (_lo < olo || _hi > ohi) | |
| 1492 return this; // doesn't narrow; pretty wierd | |
| 1493 | |
| 1494 // The new type narrows the old type, so look for a "death march". | |
| 1495 // See comments on PhaseTransform::saturate. | |
| 1496 julong nrange = _hi - _lo; | |
| 1497 julong orange = ohi - olo; | |
| 1498 if (nrange < max_julong - 1 && nrange > (orange >> 1) + (SMALLINT*2)) { | |
| 1499 // Use the new type only if the range shrinks a lot. | |
| 1500 // We do not want the optimizer computing 2^31 point by point. | |
| 1501 return old; | |
| 1502 } | |
| 1503 | |
| 1504 return this; | |
| 1505 } | |
| 1506 | |
| 1507 //-----------------------------filter------------------------------------------ | |
| 1508 const Type *TypeLong::filter( const Type *kills ) const { | |
| 1509 const TypeLong* ft = join(kills)->isa_long(); | |
|
1620
d678e3277048
6964479: widen normalization of small int and long values should be symmetric
kvn
parents:
1552
diff
changeset
|
1510 if (ft == NULL || ft->empty()) |
| 0 | 1511 return Type::TOP; // Canonical empty value |
| 1512 if (ft->_widen < this->_widen) { | |
| 1513 // Do not allow the value of kill->_widen to affect the outcome. | |
| 1514 // The widen bits must be allowed to run freely through the graph. | |
| 1515 ft = TypeLong::make(ft->_lo, ft->_hi, this->_widen); | |
| 1516 } | |
| 1517 return ft; | |
| 1518 } | |
| 1519 | |
| 1520 //------------------------------eq--------------------------------------------- | |
| 1521 // Structural equality check for Type representations | |
| 1522 bool TypeLong::eq( const Type *t ) const { | |
| 1523 const TypeLong *r = t->is_long(); // Handy access | |
| 1524 return r->_lo == _lo && r->_hi == _hi && r->_widen == _widen; | |
| 1525 } | |
| 1526 | |
| 1527 //------------------------------hash------------------------------------------- | |
| 1528 // Type-specific hashing function. | |
| 1529 int TypeLong::hash(void) const { | |
| 1530 return (int)(_lo+_hi+_widen+(int)Type::Long); | |
| 1531 } | |
| 1532 | |
| 1533 //------------------------------is_finite-------------------------------------- | |
| 1534 // Has a finite value | |
| 1535 bool TypeLong::is_finite() const { | |
| 1536 return true; | |
| 1537 } | |
| 1538 | |
| 1539 //------------------------------dump2------------------------------------------ | |
| 1540 // Dump TypeLong | |
| 1541 #ifndef PRODUCT | |
| 1542 static const char* longnamenear(jlong x, const char* xname, char* buf, jlong n) { | |
| 1543 if (n > x) { | |
| 1544 if (n >= x + 10000) return NULL; | |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6890
diff
changeset
|
1545 sprintf(buf, "%s+" JLONG_FORMAT, xname, n - x); |
| 0 | 1546 } else if (n < x) { |
| 1547 if (n <= x - 10000) return NULL; | |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6890
diff
changeset
|
1548 sprintf(buf, "%s-" JLONG_FORMAT, xname, x - n); |
| 0 | 1549 } else { |
| 1550 return xname; | |
| 1551 } | |
| 1552 return buf; | |
| 1553 } | |
| 1554 | |
| 1555 static const char* longname(char* buf, jlong n) { | |
| 1556 const char* str; | |
| 1557 if (n == min_jlong) | |
| 1558 return "min"; | |
| 1559 else if (n < min_jlong + 10000) | |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6890
diff
changeset
|
1560 sprintf(buf, "min+" JLONG_FORMAT, n - min_jlong); |
| 0 | 1561 else if (n == max_jlong) |
| 1562 return "max"; | |
| 1563 else if (n > max_jlong - 10000) | |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6890
diff
changeset
|
1564 sprintf(buf, "max-" JLONG_FORMAT, max_jlong - n); |
| 0 | 1565 else if ((str = longnamenear(max_juint, "maxuint", buf, n)) != NULL) |
| 1566 return str; | |
| 1567 else if ((str = longnamenear(max_jint, "maxint", buf, n)) != NULL) | |
| 1568 return str; | |
| 1569 else if ((str = longnamenear(min_jint, "minint", buf, n)) != NULL) | |
| 1570 return str; | |
| 1571 else | |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6890
diff
changeset
|
1572 sprintf(buf, JLONG_FORMAT, n); |
| 0 | 1573 return buf; |
| 1574 } | |
| 1575 | |
| 1576 void TypeLong::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1577 char buf[80], buf2[80]; | |
| 1578 if (_lo == min_jlong && _hi == max_jlong) | |
| 1579 st->print("long"); | |
| 1580 else if (is_con()) | |
| 1581 st->print("long:%s", longname(buf, get_con())); | |
| 1582 else if (_hi == max_jlong) | |
| 1583 st->print("long:>=%s", longname(buf, _lo)); | |
| 1584 else if (_lo == min_jlong) | |
| 1585 st->print("long:<=%s", longname(buf, _hi)); | |
| 1586 else | |
| 1587 st->print("long:%s..%s", longname(buf, _lo), longname(buf2, _hi)); | |
| 1588 | |
| 1589 if (_widen != 0 && this != TypeLong::LONG) | |
| 1590 st->print(":%.*s", _widen, "wwww"); | |
| 1591 } | |
| 1592 #endif | |
| 1593 | |
| 1594 //------------------------------singleton-------------------------------------- | |
| 1595 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1596 // constants | |
| 1597 bool TypeLong::singleton(void) const { | |
| 1598 return _lo >= _hi; | |
| 1599 } | |
| 1600 | |
| 1601 bool TypeLong::empty(void) const { | |
| 1602 return _lo > _hi; | |
| 1603 } | |
| 1604 | |
| 1605 //============================================================================= | |
| 1606 // Convenience common pre-built types. | |
| 1607 const TypeTuple *TypeTuple::IFBOTH; // Return both arms of IF as reachable | |
| 1608 const TypeTuple *TypeTuple::IFFALSE; | |
| 1609 const TypeTuple *TypeTuple::IFTRUE; | |
| 1610 const TypeTuple *TypeTuple::IFNEITHER; | |
| 1611 const TypeTuple *TypeTuple::LOOPBODY; | |
| 1612 const TypeTuple *TypeTuple::MEMBAR; | |
| 1613 const TypeTuple *TypeTuple::STORECONDITIONAL; | |
| 1614 const TypeTuple *TypeTuple::START_I2C; | |
| 1615 const TypeTuple *TypeTuple::INT_PAIR; | |
| 1616 const TypeTuple *TypeTuple::LONG_PAIR; | |
| 1617 | |
| 1618 | |
| 1619 //------------------------------make------------------------------------------- | |
| 1620 // Make a TypeTuple from the range of a method signature | |
| 1621 const TypeTuple *TypeTuple::make_range(ciSignature* sig) { | |
| 1622 ciType* return_type = sig->return_type(); | |
| 1623 uint total_fields = TypeFunc::Parms + return_type->size(); | |
| 1624 const Type **field_array = fields(total_fields); | |
| 1625 switch (return_type->basic_type()) { | |
| 1626 case T_LONG: | |
| 1627 field_array[TypeFunc::Parms] = TypeLong::LONG; | |
| 1628 field_array[TypeFunc::Parms+1] = Type::HALF; | |
| 1629 break; | |
| 1630 case T_DOUBLE: | |
| 1631 field_array[TypeFunc::Parms] = Type::DOUBLE; | |
| 1632 field_array[TypeFunc::Parms+1] = Type::HALF; | |
| 1633 break; | |
| 1634 case T_OBJECT: | |
| 1635 case T_ARRAY: | |
| 1636 case T_BOOLEAN: | |
| 1637 case T_CHAR: | |
| 1638 case T_FLOAT: | |
| 1639 case T_BYTE: | |
| 1640 case T_SHORT: | |
| 1641 case T_INT: | |
| 1642 field_array[TypeFunc::Parms] = get_const_type(return_type); | |
| 1643 break; | |
| 1644 case T_VOID: | |
| 1645 break; | |
| 1646 default: | |
| 1647 ShouldNotReachHere(); | |
| 1648 } | |
| 1649 return (TypeTuple*)(new TypeTuple(total_fields,field_array))->hashcons(); | |
| 1650 } | |
| 1651 | |
| 1652 // Make a TypeTuple from the domain of a method signature | |
| 1653 const TypeTuple *TypeTuple::make_domain(ciInstanceKlass* recv, ciSignature* sig) { | |
| 1654 uint total_fields = TypeFunc::Parms + sig->size(); | |
| 1655 | |
| 1656 uint pos = TypeFunc::Parms; | |
| 1657 const Type **field_array; | |
| 1658 if (recv != NULL) { | |
| 1659 total_fields++; | |
| 1660 field_array = fields(total_fields); | |
| 1661 // Use get_const_type here because it respects UseUniqueSubclasses: | |
| 1662 field_array[pos++] = get_const_type(recv)->join(TypePtr::NOTNULL); | |
| 1663 } else { | |
| 1664 field_array = fields(total_fields); | |
| 1665 } | |
| 1666 | |
| 1667 int i = 0; | |
| 1668 while (pos < total_fields) { | |
| 1669 ciType* type = sig->type_at(i); | |
| 1670 | |
| 1671 switch (type->basic_type()) { | |
| 1672 case T_LONG: | |
| 1673 field_array[pos++] = TypeLong::LONG; | |
| 1674 field_array[pos++] = Type::HALF; | |
| 1675 break; | |
| 1676 case T_DOUBLE: | |
| 1677 field_array[pos++] = Type::DOUBLE; | |
| 1678 field_array[pos++] = Type::HALF; | |
| 1679 break; | |
| 1680 case T_OBJECT: | |
| 1681 case T_ARRAY: | |
| 1682 case T_BOOLEAN: | |
| 1683 case T_CHAR: | |
| 1684 case T_FLOAT: | |
| 1685 case T_BYTE: | |
| 1686 case T_SHORT: | |
| 1687 case T_INT: | |
| 1688 field_array[pos++] = get_const_type(type); | |
| 1689 break; | |
| 1690 default: | |
| 1691 ShouldNotReachHere(); | |
| 1692 } | |
| 1693 i++; | |
| 1694 } | |
| 1695 return (TypeTuple*)(new TypeTuple(total_fields,field_array))->hashcons(); | |
| 1696 } | |
| 1697 | |
| 1698 const TypeTuple *TypeTuple::make( uint cnt, const Type **fields ) { | |
| 1699 return (TypeTuple*)(new TypeTuple(cnt,fields))->hashcons(); | |
| 1700 } | |
| 1701 | |
| 1702 //------------------------------fields----------------------------------------- | |
| 1703 // Subroutine call type with space allocated for argument types | |
| 1704 const Type **TypeTuple::fields( uint arg_cnt ) { | |
| 1705 const Type **flds = (const Type **)(Compile::current()->type_arena()->Amalloc_4((TypeFunc::Parms+arg_cnt)*sizeof(Type*) )); | |
| 1706 flds[TypeFunc::Control ] = Type::CONTROL; | |
| 1707 flds[TypeFunc::I_O ] = Type::ABIO; | |
| 1708 flds[TypeFunc::Memory ] = Type::MEMORY; | |
| 1709 flds[TypeFunc::FramePtr ] = TypeRawPtr::BOTTOM; | |
| 1710 flds[TypeFunc::ReturnAdr] = Type::RETURN_ADDRESS; | |
| 1711 | |
| 1712 return flds; | |
| 1713 } | |
| 1714 | |
| 1715 //------------------------------meet------------------------------------------- | |
| 1716 // Compute the MEET of two types. It returns a new Type object. | |
| 1717 const Type *TypeTuple::xmeet( const Type *t ) const { | |
| 1718 // Perform a fast test for common case; meeting the same types together. | |
| 1719 if( this == t ) return this; // Meeting same type-rep? | |
| 1720 | |
| 1721 // Current "this->_base" is Tuple | |
| 1722 switch (t->base()) { // switch on original type | |
| 1723 | |
| 1724 case Bottom: // Ye Olde Default | |
| 1725 return t; | |
| 1726 | |
| 1727 default: // All else is a mistake | |
| 1728 typerr(t); | |
| 1729 | |
| 1730 case Tuple: { // Meeting 2 signatures? | |
| 1731 const TypeTuple *x = t->is_tuple(); | |
| 1732 assert( _cnt == x->_cnt, "" ); | |
| 1733 const Type **fields = (const Type **)(Compile::current()->type_arena()->Amalloc_4( _cnt*sizeof(Type*) )); | |
| 1734 for( uint i=0; i<_cnt; i++ ) | |
| 1735 fields[i] = field_at(i)->xmeet( x->field_at(i) ); | |
| 1736 return TypeTuple::make(_cnt,fields); | |
| 1737 } | |
| 1738 case Top: | |
| 1739 break; | |
| 1740 } | |
| 1741 return this; // Return the double constant | |
| 1742 } | |
| 1743 | |
| 1744 //------------------------------xdual------------------------------------------ | |
| 1745 // Dual: compute field-by-field dual | |
| 1746 const Type *TypeTuple::xdual() const { | |
| 1747 const Type **fields = (const Type **)(Compile::current()->type_arena()->Amalloc_4( _cnt*sizeof(Type*) )); | |
| 1748 for( uint i=0; i<_cnt; i++ ) | |
| 1749 fields[i] = _fields[i]->dual(); | |
| 1750 return new TypeTuple(_cnt,fields); | |
| 1751 } | |
| 1752 | |
| 1753 //------------------------------eq--------------------------------------------- | |
| 1754 // Structural equality check for Type representations | |
| 1755 bool TypeTuple::eq( const Type *t ) const { | |
| 1756 const TypeTuple *s = (const TypeTuple *)t; | |
| 1757 if (_cnt != s->_cnt) return false; // Unequal field counts | |
| 1758 for (uint i = 0; i < _cnt; i++) | |
| 1759 if (field_at(i) != s->field_at(i)) // POINTER COMPARE! NO RECURSION! | |
| 1760 return false; // Missed | |
| 1761 return true; | |
| 1762 } | |
| 1763 | |
| 1764 //------------------------------hash------------------------------------------- | |
| 1765 // Type-specific hashing function. | |
| 1766 int TypeTuple::hash(void) const { | |
| 1767 intptr_t sum = _cnt; | |
| 1768 for( uint i=0; i<_cnt; i++ ) | |
| 1769 sum += (intptr_t)_fields[i]; // Hash on pointers directly | |
| 1770 return sum; | |
| 1771 } | |
| 1772 | |
| 1773 //------------------------------dump2------------------------------------------ | |
| 1774 // Dump signature Type | |
| 1775 #ifndef PRODUCT | |
| 1776 void TypeTuple::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1777 st->print("{"); | |
| 1778 if( !depth || d[this] ) { // Check for recursive print | |
| 1779 st->print("...}"); | |
| 1780 return; | |
| 1781 } | |
| 1782 d.Insert((void*)this, (void*)this); // Stop recursion | |
| 1783 if( _cnt ) { | |
| 1784 uint i; | |
| 1785 for( i=0; i<_cnt-1; i++ ) { | |
| 1786 st->print("%d:", i); | |
| 1787 _fields[i]->dump2(d, depth-1, st); | |
| 1788 st->print(", "); | |
| 1789 } | |
| 1790 st->print("%d:", i); | |
| 1791 _fields[i]->dump2(d, depth-1, st); | |
| 1792 } | |
| 1793 st->print("}"); | |
| 1794 } | |
| 1795 #endif | |
| 1796 | |
| 1797 //------------------------------singleton-------------------------------------- | |
| 1798 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1799 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 1800 // or a single symbol. | |
| 1801 bool TypeTuple::singleton(void) const { | |
| 1802 return false; // Never a singleton | |
| 1803 } | |
| 1804 | |
| 1805 bool TypeTuple::empty(void) const { | |
| 1806 for( uint i=0; i<_cnt; i++ ) { | |
| 1807 if (_fields[i]->empty()) return true; | |
| 1808 } | |
| 1809 return false; | |
| 1810 } | |
| 1811 | |
| 1812 //============================================================================= | |
| 1813 // Convenience common pre-built types. | |
| 1814 | |
| 1815 inline const TypeInt* normalize_array_size(const TypeInt* size) { | |
| 1816 // Certain normalizations keep us sane when comparing types. | |
| 1817 // We do not want arrayOop variables to differ only by the wideness | |
| 1818 // of their index types. Pick minimum wideness, since that is the | |
| 1819 // forced wideness of small ranges anyway. | |
| 1820 if (size->_widen != Type::WidenMin) | |
| 1821 return TypeInt::make(size->_lo, size->_hi, Type::WidenMin); | |
| 1822 else | |
| 1823 return size; | |
| 1824 } | |
| 1825 | |
| 1826 //------------------------------make------------------------------------------- | |
| 1827 const TypeAry *TypeAry::make( const Type *elem, const TypeInt *size) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1828 if (UseCompressedOops && elem->isa_oopptr()) { |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1829 elem = elem->make_narrowoop(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1830 } |
| 0 | 1831 size = normalize_array_size(size); |
| 1832 return (TypeAry*)(new TypeAry(elem,size))->hashcons(); | |
| 1833 } | |
| 1834 | |
| 1835 //------------------------------meet------------------------------------------- | |
| 1836 // Compute the MEET of two types. It returns a new Type object. | |
| 1837 const Type *TypeAry::xmeet( const Type *t ) const { | |
| 1838 // Perform a fast test for common case; meeting the same types together. | |
| 1839 if( this == t ) return this; // Meeting same type-rep? | |
| 1840 | |
| 1841 // Current "this->_base" is Ary | |
| 1842 switch (t->base()) { // switch on original type | |
| 1843 | |
| 1844 case Bottom: // Ye Olde Default | |
| 1845 return t; | |
| 1846 | |
| 1847 default: // All else is a mistake | |
| 1848 typerr(t); | |
| 1849 | |
| 1850 case Array: { // Meeting 2 arrays? | |
| 1851 const TypeAry *a = t->is_ary(); | |
| 1852 return TypeAry::make(_elem->meet(a->_elem), | |
| 1853 _size->xmeet(a->_size)->is_int()); | |
| 1854 } | |
| 1855 case Top: | |
| 1856 break; | |
| 1857 } | |
| 1858 return this; // Return the double constant | |
| 1859 } | |
| 1860 | |
| 1861 //------------------------------xdual------------------------------------------ | |
| 1862 // Dual: compute field-by-field dual | |
| 1863 const Type *TypeAry::xdual() const { | |
| 1864 const TypeInt* size_dual = _size->dual()->is_int(); | |
| 1865 size_dual = normalize_array_size(size_dual); | |
| 1866 return new TypeAry( _elem->dual(), size_dual); | |
| 1867 } | |
| 1868 | |
| 1869 //------------------------------eq--------------------------------------------- | |
| 1870 // Structural equality check for Type representations | |
| 1871 bool TypeAry::eq( const Type *t ) const { | |
| 1872 const TypeAry *a = (const TypeAry*)t; | |
| 1873 return _elem == a->_elem && | |
| 1874 _size == a->_size; | |
| 1875 } | |
| 1876 | |
| 1877 //------------------------------hash------------------------------------------- | |
| 1878 // Type-specific hashing function. | |
| 1879 int TypeAry::hash(void) const { | |
| 1880 return (intptr_t)_elem + (intptr_t)_size; | |
| 1881 } | |
| 1882 | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1883 //----------------------interface_vs_oop--------------------------------------- |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1884 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1885 bool TypeAry::interface_vs_oop(const Type *t) const { |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1886 const TypeAry* t_ary = t->is_ary(); |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1887 if (t_ary) { |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1888 return _elem->interface_vs_oop(t_ary->_elem); |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1889 } |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1890 return false; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1891 } |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1892 #endif |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1893 |
| 0 | 1894 //------------------------------dump2------------------------------------------ |
| 1895 #ifndef PRODUCT | |
| 1896 void TypeAry::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1897 _elem->dump2(d, depth, st); | |
| 1898 st->print("["); | |
| 1899 _size->dump2(d, depth, st); | |
| 1900 st->print("]"); | |
| 1901 } | |
| 1902 #endif | |
| 1903 | |
| 1904 //------------------------------singleton-------------------------------------- | |
| 1905 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1906 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 1907 // or a single symbol. | |
| 1908 bool TypeAry::singleton(void) const { | |
| 1909 return false; // Never a singleton | |
| 1910 } | |
| 1911 | |
| 1912 bool TypeAry::empty(void) const { | |
| 1913 return _elem->empty() || _size->empty(); | |
| 1914 } | |
| 1915 | |
| 1916 //--------------------------ary_must_be_exact---------------------------------- | |
| 1917 bool TypeAry::ary_must_be_exact() const { | |
| 1918 if (!UseExactTypes) return false; | |
| 1919 // This logic looks at the element type of an array, and returns true | |
| 1920 // if the element type is either a primitive or a final instance class. | |
| 1921 // In such cases, an array built on this ary must have no subclasses. | |
| 1922 if (_elem == BOTTOM) return false; // general array not exact | |
| 1923 if (_elem == TOP ) return false; // inverted general array not exact | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1924 const TypeOopPtr* toop = NULL; |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1925 if (UseCompressedOops && _elem->isa_narrowoop()) { |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1926 toop = _elem->make_ptr()->isa_oopptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1927 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1928 toop = _elem->isa_oopptr(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1929 } |
| 0 | 1930 if (!toop) return true; // a primitive type, like int |
| 1931 ciKlass* tklass = toop->klass(); | |
| 1932 if (tklass == NULL) return false; // unloaded class | |
| 1933 if (!tklass->is_loaded()) return false; // unloaded class | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1934 const TypeInstPtr* tinst; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1935 if (_elem->isa_narrowoop()) |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1936 tinst = _elem->make_ptr()->isa_instptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1937 else |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1938 tinst = _elem->isa_instptr(); |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1939 if (tinst) |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1940 return tklass->as_instance_klass()->is_final(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1941 const TypeAryPtr* tap; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1942 if (_elem->isa_narrowoop()) |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1943 tap = _elem->make_ptr()->isa_aryptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1944 else |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1945 tap = _elem->isa_aryptr(); |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1946 if (tap) |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1947 return tap->ary()->ary_must_be_exact(); |
| 0 | 1948 return false; |
| 1949 } | |
| 1950 | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1951 //==============================TypeVect======================================= |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1952 // Convenience common pre-built types. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1953 const TypeVect *TypeVect::VECTS = NULL; // 32-bit vectors |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1954 const TypeVect *TypeVect::VECTD = NULL; // 64-bit vectors |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1955 const TypeVect *TypeVect::VECTX = NULL; // 128-bit vectors |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1956 const TypeVect *TypeVect::VECTY = NULL; // 256-bit vectors |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1957 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1958 //------------------------------make------------------------------------------- |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1959 const TypeVect* TypeVect::make(const Type *elem, uint length) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1960 BasicType elem_bt = elem->array_element_basic_type(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1961 assert(is_java_primitive(elem_bt), "only primitive types in vector"); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1962 assert(length > 1 && is_power_of_2(length), "vector length is power of 2"); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1963 assert(Matcher::vector_size_supported(elem_bt, length), "length in range"); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1964 int size = length * type2aelembytes(elem_bt); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1965 switch (Matcher::vector_ideal_reg(size)) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1966 case Op_VecS: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1967 return (TypeVect*)(new TypeVectS(elem, length))->hashcons(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1968 case Op_VecD: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1969 case Op_RegD: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1970 return (TypeVect*)(new TypeVectD(elem, length))->hashcons(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1971 case Op_VecX: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1972 return (TypeVect*)(new TypeVectX(elem, length))->hashcons(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1973 case Op_VecY: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1974 return (TypeVect*)(new TypeVectY(elem, length))->hashcons(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1975 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1976 ShouldNotReachHere(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1977 return NULL; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1978 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1979 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1980 //------------------------------meet------------------------------------------- |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1981 // Compute the MEET of two types. It returns a new Type object. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1982 const Type *TypeVect::xmeet( const Type *t ) const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1983 // Perform a fast test for common case; meeting the same types together. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1984 if( this == t ) return this; // Meeting same type-rep? |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1985 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1986 // Current "this->_base" is Vector |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1987 switch (t->base()) { // switch on original type |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1988 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1989 case Bottom: // Ye Olde Default |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1990 return t; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1991 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1992 default: // All else is a mistake |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1993 typerr(t); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1994 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1995 case VectorS: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1996 case VectorD: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1997 case VectorX: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1998 case VectorY: { // Meeting 2 vectors? |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
1999 const TypeVect* v = t->is_vect(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2000 assert( base() == v->base(), ""); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2001 assert(length() == v->length(), ""); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2002 assert(element_basic_type() == v->element_basic_type(), ""); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2003 return TypeVect::make(_elem->xmeet(v->_elem), _length); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2004 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2005 case Top: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2006 break; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2007 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2008 return this; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2009 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2010 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2011 //------------------------------xdual------------------------------------------ |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2012 // Dual: compute field-by-field dual |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2013 const Type *TypeVect::xdual() const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2014 return new TypeVect(base(), _elem->dual(), _length); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2015 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2016 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2017 //------------------------------eq--------------------------------------------- |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2018 // Structural equality check for Type representations |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2019 bool TypeVect::eq(const Type *t) const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2020 const TypeVect *v = t->is_vect(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2021 return (_elem == v->_elem) && (_length == v->_length); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2022 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2023 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2024 //------------------------------hash------------------------------------------- |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2025 // Type-specific hashing function. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2026 int TypeVect::hash(void) const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2027 return (intptr_t)_elem + (intptr_t)_length; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2028 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2029 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2030 //------------------------------singleton-------------------------------------- |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2031 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2032 // constants (Ldi nodes). Vector is singleton if all elements are the same |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2033 // constant value (when vector is created with Replicate code). |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2034 bool TypeVect::singleton(void) const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2035 // There is no Con node for vectors yet. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2036 // return _elem->singleton(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2037 return false; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2038 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2039 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2040 bool TypeVect::empty(void) const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2041 return _elem->empty(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2042 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2043 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2044 //------------------------------dump2------------------------------------------ |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2045 #ifndef PRODUCT |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2046 void TypeVect::dump2(Dict &d, uint depth, outputStream *st) const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2047 switch (base()) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2048 case VectorS: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2049 st->print("vectors["); break; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2050 case VectorD: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2051 st->print("vectord["); break; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2052 case VectorX: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2053 st->print("vectorx["); break; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2054 case VectorY: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2055 st->print("vectory["); break; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2056 default: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2057 ShouldNotReachHere(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2058 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2059 st->print("%d]:{", _length); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2060 _elem->dump2(d, depth, st); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2061 st->print("}"); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2062 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2063 #endif |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2064 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
2376
diff
changeset
|
2065 |
| 0 | 2066 //============================================================================= |
| 2067 // Convenience common pre-built types. | |
| 2068 const TypePtr *TypePtr::NULL_PTR; | |
| 2069 const TypePtr *TypePtr::NOTNULL; | |
| 2070 const TypePtr *TypePtr::BOTTOM; | |
| 2071 | |
| 2072 //------------------------------meet------------------------------------------- | |
| 2073 // Meet over the PTR enum | |
| 2074 const TypePtr::PTR TypePtr::ptr_meet[TypePtr::lastPTR][TypePtr::lastPTR] = { | |
| 2075 // TopPTR, AnyNull, Constant, Null, NotNull, BotPTR, | |
| 2076 { /* Top */ TopPTR, AnyNull, Constant, Null, NotNull, BotPTR,}, | |
| 2077 { /* AnyNull */ AnyNull, AnyNull, Constant, BotPTR, NotNull, BotPTR,}, | |
| 2078 { /* Constant*/ Constant, Constant, Constant, BotPTR, NotNull, BotPTR,}, | |
| 2079 { /* Null */ Null, BotPTR, BotPTR, Null, BotPTR, BotPTR,}, | |
| 2080 { /* NotNull */ NotNull, NotNull, NotNull, BotPTR, NotNull, BotPTR,}, | |
| 2081 { /* BotPTR */ BotPTR, BotPTR, BotPTR, BotPTR, BotPTR, BotPTR,} | |
| 2082 }; | |
| 2083 | |
| 2084 //------------------------------make------------------------------------------- | |
| 2085 const TypePtr *TypePtr::make( TYPES t, enum PTR ptr, int offset ) { | |
| 2086 return (TypePtr*)(new TypePtr(t,ptr,offset))->hashcons(); | |
| 2087 } | |
| 2088 | |
| 2089 //------------------------------cast_to_ptr_type------------------------------- | |
| 2090 const Type *TypePtr::cast_to_ptr_type(PTR ptr) const { | |
| 2091 assert(_base == AnyPtr, "subclass must override cast_to_ptr_type"); | |
| 2092 if( ptr == _ptr ) return this; | |
| 2093 return make(_base, ptr, _offset); | |
| 2094 } | |
| 2095 | |
| 2096 //------------------------------get_con---------------------------------------- | |
| 2097 intptr_t TypePtr::get_con() const { | |
| 2098 assert( _ptr == Null, "" ); | |
| 2099 return _offset; | |
| 2100 } | |
| 2101 | |
| 2102 //------------------------------meet------------------------------------------- | |
| 2103 // Compute the MEET of two types. It returns a new Type object. | |
| 2104 const Type *TypePtr::xmeet( const Type *t ) const { | |
| 2105 // Perform a fast test for common case; meeting the same types together. | |
| 2106 if( this == t ) return this; // Meeting same type-rep? | |
| 2107 | |
| 2108 // Current "this->_base" is AnyPtr | |
| 2109 switch (t->base()) { // switch on original type | |
| 2110 case Int: // Mixing ints & oops happens when javac | |
| 2111 case Long: // reuses local variables | |
| 2112 case FloatTop: | |
| 2113 case FloatCon: | |
| 2114 case FloatBot: | |
| 2115 case DoubleTop: | |
| 2116 case DoubleCon: | |
| 2117 case DoubleBot: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
2118 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2119 case NarrowKlass: |
| 0 | 2120 case Bottom: // Ye Olde Default |
| 2121 return Type::BOTTOM; | |
| 2122 case Top: | |
| 2123 return this; | |
| 2124 | |
| 2125 case AnyPtr: { // Meeting to AnyPtrs | |
| 2126 const TypePtr *tp = t->is_ptr(); | |
| 2127 return make( AnyPtr, meet_ptr(tp->ptr()), meet_offset(tp->offset()) ); | |
| 2128 } | |
| 2129 case RawPtr: // For these, flip the call around to cut down | |
| 2130 case OopPtr: | |
| 2131 case InstPtr: // on the cases I have to handle. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2132 case AryPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2133 case MetadataPtr: |
| 0 | 2134 case KlassPtr: |
| 2135 return t->xmeet(this); // Call in reverse direction | |
| 2136 default: // All else is a mistake | |
| 2137 typerr(t); | |
| 2138 | |
| 2139 } | |
| 2140 return this; | |
| 2141 } | |
| 2142 | |
| 2143 //------------------------------meet_offset------------------------------------ | |
| 2144 int TypePtr::meet_offset( int offset ) const { | |
| 2145 // Either is 'TOP' offset? Return the other offset! | |
| 2146 if( _offset == OffsetTop ) return offset; | |
| 2147 if( offset == OffsetTop ) return _offset; | |
| 2148 // If either is different, return 'BOTTOM' offset | |
| 2149 if( _offset != offset ) return OffsetBot; | |
| 2150 return _offset; | |
| 2151 } | |
| 2152 | |
| 2153 //------------------------------dual_offset------------------------------------ | |
| 2154 int TypePtr::dual_offset( ) const { | |
| 2155 if( _offset == OffsetTop ) return OffsetBot;// Map 'TOP' into 'BOTTOM' | |
| 2156 if( _offset == OffsetBot ) return OffsetTop;// Map 'BOTTOM' into 'TOP' | |
| 2157 return _offset; // Map everything else into self | |
| 2158 } | |
| 2159 | |
| 2160 //------------------------------xdual------------------------------------------ | |
| 2161 // Dual: compute field-by-field dual | |
| 2162 const TypePtr::PTR TypePtr::ptr_dual[TypePtr::lastPTR] = { | |
| 2163 BotPTR, NotNull, Constant, Null, AnyNull, TopPTR | |
| 2164 }; | |
| 2165 const Type *TypePtr::xdual() const { | |
| 2166 return new TypePtr( AnyPtr, dual_ptr(), dual_offset() ); | |
| 2167 } | |
| 2168 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2169 //------------------------------xadd_offset------------------------------------ |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2170 int TypePtr::xadd_offset( intptr_t offset ) const { |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2171 // Adding to 'TOP' offset? Return 'TOP'! |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2172 if( _offset == OffsetTop || offset == OffsetTop ) return OffsetTop; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2173 // Adding to 'BOTTOM' offset? Return 'BOTTOM'! |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2174 if( _offset == OffsetBot || offset == OffsetBot ) return OffsetBot; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2175 // Addition overflows or "accidentally" equals to OffsetTop? Return 'BOTTOM'! |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2176 offset += (intptr_t)_offset; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2177 if (offset != (int)offset || offset == OffsetTop) return OffsetBot; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2178 |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2179 // assert( _offset >= 0 && _offset+offset >= 0, "" ); |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2180 // It is possible to construct a negative offset during PhaseCCP |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2181 |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2182 return (int)offset; // Sum valid offsets |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2183 } |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2184 |
| 0 | 2185 //------------------------------add_offset------------------------------------- |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2186 const TypePtr *TypePtr::add_offset( intptr_t offset ) const { |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2187 return make( AnyPtr, _ptr, xadd_offset(offset) ); |
| 0 | 2188 } |
| 2189 | |
| 2190 //------------------------------eq--------------------------------------------- | |
| 2191 // Structural equality check for Type representations | |
| 2192 bool TypePtr::eq( const Type *t ) const { | |
| 2193 const TypePtr *a = (const TypePtr*)t; | |
| 2194 return _ptr == a->ptr() && _offset == a->offset(); | |
| 2195 } | |
| 2196 | |
| 2197 //------------------------------hash------------------------------------------- | |
| 2198 // Type-specific hashing function. | |
| 2199 int TypePtr::hash(void) const { | |
| 2200 return _ptr + _offset; | |
| 2201 } | |
| 2202 | |
| 2203 //------------------------------dump2------------------------------------------ | |
| 2204 const char *const TypePtr::ptr_msg[TypePtr::lastPTR] = { | |
| 2205 "TopPTR","AnyNull","Constant","NULL","NotNull","BotPTR" | |
| 2206 }; | |
| 2207 | |
| 2208 #ifndef PRODUCT | |
| 2209 void TypePtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 2210 if( _ptr == Null ) st->print("NULL"); | |
| 2211 else st->print("%s *", ptr_msg[_ptr]); | |
| 2212 if( _offset == OffsetTop ) st->print("+top"); | |
| 2213 else if( _offset == OffsetBot ) st->print("+bot"); | |
| 2214 else if( _offset ) st->print("+%d", _offset); | |
| 2215 } | |
| 2216 #endif | |
| 2217 | |
| 2218 //------------------------------singleton-------------------------------------- | |
| 2219 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 2220 // constants | |
| 2221 bool TypePtr::singleton(void) const { | |
| 2222 // TopPTR, Null, AnyNull, Constant are all singletons | |
| 2223 return (_offset != OffsetBot) && !below_centerline(_ptr); | |
| 2224 } | |
| 2225 | |
| 2226 bool TypePtr::empty(void) const { | |
| 2227 return (_offset == OffsetTop) || above_centerline(_ptr); | |
| 2228 } | |
| 2229 | |
| 2230 //============================================================================= | |
| 2231 // Convenience common pre-built types. | |
| 2232 const TypeRawPtr *TypeRawPtr::BOTTOM; | |
| 2233 const TypeRawPtr *TypeRawPtr::NOTNULL; | |
| 2234 | |
| 2235 //------------------------------make------------------------------------------- | |
| 2236 const TypeRawPtr *TypeRawPtr::make( enum PTR ptr ) { | |
| 2237 assert( ptr != Constant, "what is the constant?" ); | |
| 2238 assert( ptr != Null, "Use TypePtr for NULL" ); | |
| 2239 return (TypeRawPtr*)(new TypeRawPtr(ptr,0))->hashcons(); | |
| 2240 } | |
| 2241 | |
| 2242 const TypeRawPtr *TypeRawPtr::make( address bits ) { | |
| 2243 assert( bits, "Use TypePtr for NULL" ); | |
| 2244 return (TypeRawPtr*)(new TypeRawPtr(Constant,bits))->hashcons(); | |
| 2245 } | |
| 2246 | |
| 2247 //------------------------------cast_to_ptr_type------------------------------- | |
| 2248 const Type *TypeRawPtr::cast_to_ptr_type(PTR ptr) const { | |
| 2249 assert( ptr != Constant, "what is the constant?" ); | |
| 2250 assert( ptr != Null, "Use TypePtr for NULL" ); | |
| 2251 assert( _bits==0, "Why cast a constant address?"); | |
| 2252 if( ptr == _ptr ) return this; | |
| 2253 return make(ptr); | |
| 2254 } | |
| 2255 | |
| 2256 //------------------------------get_con---------------------------------------- | |
| 2257 intptr_t TypeRawPtr::get_con() const { | |
| 2258 assert( _ptr == Null || _ptr == Constant, "" ); | |
| 2259 return (intptr_t)_bits; | |
| 2260 } | |
| 2261 | |
| 2262 //------------------------------meet------------------------------------------- | |
| 2263 // Compute the MEET of two types. It returns a new Type object. | |
| 2264 const Type *TypeRawPtr::xmeet( const Type *t ) const { | |
| 2265 // Perform a fast test for common case; meeting the same types together. | |
| 2266 if( this == t ) return this; // Meeting same type-rep? | |
| 2267 | |
| 2268 // Current "this->_base" is RawPtr | |
| 2269 switch( t->base() ) { // switch on original type | |
| 2270 case Bottom: // Ye Olde Default | |
| 2271 return t; | |
| 2272 case Top: | |
| 2273 return this; | |
| 2274 case AnyPtr: // Meeting to AnyPtrs | |
| 2275 break; | |
| 2276 case RawPtr: { // might be top, bot, any/not or constant | |
| 2277 enum PTR tptr = t->is_ptr()->ptr(); | |
| 2278 enum PTR ptr = meet_ptr( tptr ); | |
| 2279 if( ptr == Constant ) { // Cannot be equal constants, so... | |
| 2280 if( tptr == Constant && _ptr != Constant) return t; | |
| 2281 if( _ptr == Constant && tptr != Constant) return this; | |
| 2282 ptr = NotNull; // Fall down in lattice | |
| 2283 } | |
| 2284 return make( ptr ); | |
| 2285 } | |
| 2286 | |
| 2287 case OopPtr: | |
| 2288 case InstPtr: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2289 case AryPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2290 case MetadataPtr: |
| 0 | 2291 case KlassPtr: |
| 2292 return TypePtr::BOTTOM; // Oop meet raw is not well defined | |
| 2293 default: // All else is a mistake | |
| 2294 typerr(t); | |
| 2295 } | |
| 2296 | |
| 2297 // Found an AnyPtr type vs self-RawPtr type | |
| 2298 const TypePtr *tp = t->is_ptr(); | |
| 2299 switch (tp->ptr()) { | |
| 2300 case TypePtr::TopPTR: return this; | |
| 2301 case TypePtr::BotPTR: return t; | |
| 2302 case TypePtr::Null: | |
| 2303 if( _ptr == TypePtr::TopPTR ) return t; | |
| 2304 return TypeRawPtr::BOTTOM; | |
| 2305 case TypePtr::NotNull: return TypePtr::make( AnyPtr, meet_ptr(TypePtr::NotNull), tp->meet_offset(0) ); | |
| 2306 case TypePtr::AnyNull: | |
| 2307 if( _ptr == TypePtr::Constant) return this; | |
| 2308 return make( meet_ptr(TypePtr::AnyNull) ); | |
| 2309 default: ShouldNotReachHere(); | |
| 2310 } | |
| 2311 return this; | |
| 2312 } | |
| 2313 | |
| 2314 //------------------------------xdual------------------------------------------ | |
| 2315 // Dual: compute field-by-field dual | |
| 2316 const Type *TypeRawPtr::xdual() const { | |
| 2317 return new TypeRawPtr( dual_ptr(), _bits ); | |
| 2318 } | |
| 2319 | |
| 2320 //------------------------------add_offset------------------------------------- | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2321 const TypePtr *TypeRawPtr::add_offset( intptr_t offset ) const { |
| 0 | 2322 if( offset == OffsetTop ) return BOTTOM; // Undefined offset-> undefined pointer |
| 2323 if( offset == OffsetBot ) return BOTTOM; // Unknown offset-> unknown pointer | |
| 2324 if( offset == 0 ) return this; // No change | |
| 2325 switch (_ptr) { | |
| 2326 case TypePtr::TopPTR: | |
| 2327 case TypePtr::BotPTR: | |
| 2328 case TypePtr::NotNull: | |
| 2329 return this; | |
| 2330 case TypePtr::Null: | |
|
2115
78e248949382
6876037: CTW fails jdk7/hotspot/src/share/vm/opto/type.cpp:2055. assert(bits,"Use TypePtr for NULL")
kvn
parents:
1972
diff
changeset
|
2331 case TypePtr::Constant: { |
|
78e248949382
6876037: CTW fails jdk7/hotspot/src/share/vm/opto/type.cpp:2055. assert(bits,"Use TypePtr for NULL")
kvn
parents:
1972
diff
changeset
|
2332 address bits = _bits+offset; |
|
78e248949382
6876037: CTW fails jdk7/hotspot/src/share/vm/opto/type.cpp:2055. assert(bits,"Use TypePtr for NULL")
kvn
parents:
1972
diff
changeset
|
2333 if ( bits == 0 ) return TypePtr::NULL_PTR; |
|
78e248949382
6876037: CTW fails jdk7/hotspot/src/share/vm/opto/type.cpp:2055. assert(bits,"Use TypePtr for NULL")
kvn
parents:
1972
diff
changeset
|
2334 return make( bits ); |
|
78e248949382
6876037: CTW fails jdk7/hotspot/src/share/vm/opto/type.cpp:2055. assert(bits,"Use TypePtr for NULL")
kvn
parents:
1972
diff
changeset
|
2335 } |
| 0 | 2336 default: ShouldNotReachHere(); |
| 2337 } | |
| 2338 return NULL; // Lint noise | |
| 2339 } | |
| 2340 | |
| 2341 //------------------------------eq--------------------------------------------- | |
| 2342 // Structural equality check for Type representations | |
| 2343 bool TypeRawPtr::eq( const Type *t ) const { | |
| 2344 const TypeRawPtr *a = (const TypeRawPtr*)t; | |
| 2345 return _bits == a->_bits && TypePtr::eq(t); | |
| 2346 } | |
| 2347 | |
| 2348 //------------------------------hash------------------------------------------- | |
| 2349 // Type-specific hashing function. | |
| 2350 int TypeRawPtr::hash(void) const { | |
| 2351 return (intptr_t)_bits + TypePtr::hash(); | |
| 2352 } | |
| 2353 | |
| 2354 //------------------------------dump2------------------------------------------ | |
| 2355 #ifndef PRODUCT | |
| 2356 void TypeRawPtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 2357 if( _ptr == Constant ) | |
| 2358 st->print(INTPTR_FORMAT, _bits); | |
| 2359 else | |
| 2360 st->print("rawptr:%s", ptr_msg[_ptr]); | |
| 2361 } | |
| 2362 #endif | |
| 2363 | |
| 2364 //============================================================================= | |
| 2365 // Convenience common pre-built type. | |
| 2366 const TypeOopPtr *TypeOopPtr::BOTTOM; | |
| 2367 | |
| 163 | 2368 //------------------------------TypeOopPtr------------------------------------- |
| 2369 TypeOopPtr::TypeOopPtr( TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id ) | |
| 2370 : TypePtr(t, ptr, offset), | |
| 2371 _const_oop(o), _klass(k), | |
| 2372 _klass_is_exact(xk), | |
| 2373 _is_ptr_to_narrowoop(false), | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2374 _is_ptr_to_narrowklass(false), |
| 163 | 2375 _instance_id(instance_id) { |
| 2376 #ifdef _LP64 | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2377 if (_offset != 0) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2378 if (_offset == oopDesc::klass_offset_in_bytes()) { |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2379 _is_ptr_to_narrowklass = UseCompressedKlassPointers; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2380 } else if (klass() == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2381 // Array with unknown body type |
| 163 | 2382 assert(this->isa_aryptr(), "only arrays without klass"); |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2383 _is_ptr_to_narrowoop = UseCompressedOops; |
| 163 | 2384 } else if (this->isa_aryptr()) { |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2385 _is_ptr_to_narrowoop = (UseCompressedOops && klass()->is_obj_array_klass() && |
| 163 | 2386 _offset != arrayOopDesc::length_offset_in_bytes()); |
| 2387 } else if (klass()->is_instance_klass()) { | |
| 2388 ciInstanceKlass* ik = klass()->as_instance_klass(); | |
| 2389 ciField* field = NULL; | |
| 2390 if (this->isa_klassptr()) { | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2391 // Perm objects don't use compressed references |
| 163 | 2392 } else if (_offset == OffsetBot || _offset == OffsetTop) { |
| 2393 // unsafe access | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2394 _is_ptr_to_narrowoop = UseCompressedOops; |
| 163 | 2395 } else { // exclude unsafe ops |
| 2396 assert(this->isa_instptr(), "must be an instance ptr."); | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2397 |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2398 if (klass() == ciEnv::current()->Class_klass() && |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2399 (_offset == java_lang_Class::klass_offset_in_bytes() || |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2400 _offset == java_lang_Class::array_klass_offset_in_bytes())) { |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2401 // Special hidden fields from the Class. |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2402 assert(this->isa_instptr(), "must be an instance ptr."); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2403 _is_ptr_to_narrowoop = false; |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2404 } else if (klass() == ciEnv::current()->Class_klass() && |
|
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6728
diff
changeset
|
2405 _offset >= InstanceMirrorKlass::offset_of_static_fields()) { |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2406 // Static fields |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2407 assert(o != NULL, "must be constant"); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2408 ciInstanceKlass* k = o->as_instance()->java_lang_Class_klass()->as_instance_klass(); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2409 ciField* field = k->get_field_by_offset(_offset, true); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2410 assert(field != NULL, "missing field"); |
| 163 | 2411 BasicType basic_elem_type = field->layout_type(); |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2412 _is_ptr_to_narrowoop = UseCompressedOops && (basic_elem_type == T_OBJECT || |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2413 basic_elem_type == T_ARRAY); |
| 163 | 2414 } else { |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2415 // Instance fields which contains a compressed oop references. |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2416 field = ik->get_field_by_offset(_offset, false); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2417 if (field != NULL) { |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2418 BasicType basic_elem_type = field->layout_type(); |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2419 _is_ptr_to_narrowoop = UseCompressedOops && (basic_elem_type == T_OBJECT || |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2420 basic_elem_type == T_ARRAY); |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2421 } else if (klass()->equals(ciEnv::current()->Object_klass())) { |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2422 // Compile::find_alias_type() cast exactness on all types to verify |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2423 // that it does not affect alias type. |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2424 _is_ptr_to_narrowoop = UseCompressedOops; |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2425 } else { |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2426 // Type for the copy start in LibraryCallKit::inline_native_clone(). |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2427 _is_ptr_to_narrowoop = UseCompressedOops; |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2354
diff
changeset
|
2428 } |
| 163 | 2429 } |
| 2430 } | |
| 2431 } | |
| 2432 } | |
| 2433 #endif | |
| 2434 } | |
| 2435 | |
| 0 | 2436 //------------------------------make------------------------------------------- |
| 2437 const TypeOopPtr *TypeOopPtr::make(PTR ptr, | |
|
958
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
2438 int offset, int instance_id) { |
| 0 | 2439 assert(ptr != Constant, "no constant generic pointers"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2440 ciKlass* k = Compile::current()->env()->Object_klass(); |
| 0 | 2441 bool xk = false; |
| 2442 ciObject* o = NULL; | |
|
958
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
2443 return (TypeOopPtr*)(new TypeOopPtr(OopPtr, ptr, k, xk, o, offset, instance_id))->hashcons(); |
| 0 | 2444 } |
| 2445 | |
| 2446 | |
| 2447 //------------------------------cast_to_ptr_type------------------------------- | |
| 2448 const Type *TypeOopPtr::cast_to_ptr_type(PTR ptr) const { | |
| 2449 assert(_base == OopPtr, "subclass must override cast_to_ptr_type"); | |
| 2450 if( ptr == _ptr ) return this; | |
| 992 | 2451 return make(ptr, _offset, _instance_id); |
| 0 | 2452 } |
| 2453 | |
| 247 | 2454 //-----------------------------cast_to_instance_id---------------------------- |
| 223 | 2455 const TypeOopPtr *TypeOopPtr::cast_to_instance_id(int instance_id) const { |
| 0 | 2456 // There are no instances of a general oop. |
| 2457 // Return self unchanged. | |
| 2458 return this; | |
| 2459 } | |
| 2460 | |
| 2461 //-----------------------------cast_to_exactness------------------------------- | |
| 2462 const Type *TypeOopPtr::cast_to_exactness(bool klass_is_exact) const { | |
| 2463 // There is no such thing as an exact general oop. | |
| 2464 // Return self unchanged. | |
| 2465 return this; | |
| 2466 } | |
| 2467 | |
| 2468 | |
| 2469 //------------------------------as_klass_type---------------------------------- | |
| 2470 // Return the klass type corresponding to this instance or array type. | |
| 2471 // It is the type that is loaded from an object of this type. | |
| 2472 const TypeKlassPtr* TypeOopPtr::as_klass_type() const { | |
| 2473 ciKlass* k = klass(); | |
| 2474 bool xk = klass_is_exact(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2475 if (k == NULL) |
| 0 | 2476 return TypeKlassPtr::OBJECT; |
| 2477 else | |
| 2478 return TypeKlassPtr::make(xk? Constant: NotNull, k, 0); | |
| 2479 } | |
| 2480 | |
| 2481 | |
| 2482 //------------------------------meet------------------------------------------- | |
| 2483 // Compute the MEET of two types. It returns a new Type object. | |
| 2484 const Type *TypeOopPtr::xmeet( const Type *t ) const { | |
| 2485 // Perform a fast test for common case; meeting the same types together. | |
| 2486 if( this == t ) return this; // Meeting same type-rep? | |
| 2487 | |
| 2488 // Current "this->_base" is OopPtr | |
| 2489 switch (t->base()) { // switch on original type | |
| 2490 | |
| 2491 case Int: // Mixing ints & oops happens when javac | |
| 2492 case Long: // reuses local variables | |
| 2493 case FloatTop: | |
| 2494 case FloatCon: | |
| 2495 case FloatBot: | |
| 2496 case DoubleTop: | |
| 2497 case DoubleCon: | |
| 2498 case DoubleBot: | |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
2499 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2500 case NarrowKlass: |
| 0 | 2501 case Bottom: // Ye Olde Default |
| 2502 return Type::BOTTOM; | |
| 2503 case Top: | |
| 2504 return this; | |
| 2505 | |
| 2506 default: // All else is a mistake | |
| 2507 typerr(t); | |
| 2508 | |
| 2509 case RawPtr: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2510 case MetadataPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2511 case KlassPtr: |
| 0 | 2512 return TypePtr::BOTTOM; // Oop meet raw is not well defined |
| 2513 | |
| 2514 case AnyPtr: { | |
| 2515 // Found an AnyPtr type vs self-OopPtr type | |
| 2516 const TypePtr *tp = t->is_ptr(); | |
| 2517 int offset = meet_offset(tp->offset()); | |
| 2518 PTR ptr = meet_ptr(tp->ptr()); | |
| 2519 switch (tp->ptr()) { | |
| 2520 case Null: | |
| 2521 if (ptr == Null) return TypePtr::make(AnyPtr, ptr, offset); | |
| 2522 // else fall through: | |
| 2523 case TopPTR: | |
| 992 | 2524 case AnyNull: { |
| 2525 int instance_id = meet_instance_id(InstanceTop); | |
| 2526 return make(ptr, offset, instance_id); | |
| 2527 } | |
| 0 | 2528 case BotPTR: |
| 2529 case NotNull: | |
| 2530 return TypePtr::make(AnyPtr, ptr, offset); | |
| 2531 default: typerr(t); | |
| 2532 } | |
| 2533 } | |
| 2534 | |
| 2535 case OopPtr: { // Meeting to other OopPtrs | |
| 2536 const TypeOopPtr *tp = t->is_oopptr(); | |
|
958
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
2537 int instance_id = meet_instance_id(tp->instance_id()); |
|
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
2538 return make( meet_ptr(tp->ptr()), meet_offset(tp->offset()), instance_id ); |
| 0 | 2539 } |
| 2540 | |
| 2541 case InstPtr: // For these, flip the call around to cut down | |
| 2542 case AryPtr: | |
| 2543 return t->xmeet(this); // Call in reverse direction | |
| 2544 | |
| 2545 } // End of switch | |
| 2546 return this; // Return the double constant | |
| 2547 } | |
| 2548 | |
| 2549 | |
| 2550 //------------------------------xdual------------------------------------------ | |
| 2551 // Dual of a pure heap pointer. No relevant klass or oop information. | |
| 2552 const Type *TypeOopPtr::xdual() const { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2553 assert(klass() == Compile::current()->env()->Object_klass(), "no klasses here"); |
| 0 | 2554 assert(const_oop() == NULL, "no constants here"); |
| 223 | 2555 return new TypeOopPtr(_base, dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id() ); |
| 0 | 2556 } |
| 2557 | |
| 2558 //--------------------------make_from_klass_common----------------------------- | |
| 2559 // Computes the element-type given a klass. | |
| 2560 const TypeOopPtr* TypeOopPtr::make_from_klass_common(ciKlass *klass, bool klass_change, bool try_for_exact) { | |
| 2561 if (klass->is_instance_klass()) { | |
| 2562 Compile* C = Compile::current(); | |
| 2563 Dependencies* deps = C->dependencies(); | |
| 2564 assert((deps != NULL) == (C->method() != NULL && C->method()->code_size() > 0), "sanity"); | |
| 2565 // Element is an instance | |
| 2566 bool klass_is_exact = false; | |
| 2567 if (klass->is_loaded()) { | |
| 2568 // Try to set klass_is_exact. | |
| 2569 ciInstanceKlass* ik = klass->as_instance_klass(); | |
| 2570 klass_is_exact = ik->is_final(); | |
| 2571 if (!klass_is_exact && klass_change | |
| 2572 && deps != NULL && UseUniqueSubclasses) { | |
| 2573 ciInstanceKlass* sub = ik->unique_concrete_subklass(); | |
| 2574 if (sub != NULL) { | |
| 2575 deps->assert_abstract_with_unique_concrete_subtype(ik, sub); | |
| 2576 klass = ik = sub; | |
| 2577 klass_is_exact = sub->is_final(); | |
| 2578 } | |
| 2579 } | |
| 2580 if (!klass_is_exact && try_for_exact | |
| 2581 && deps != NULL && UseExactTypes) { | |
| 2582 if (!ik->is_interface() && !ik->has_subklass()) { | |
| 2583 // Add a dependence; if concrete subclass added we need to recompile | |
| 2584 deps->assert_leaf_type(ik); | |
| 2585 klass_is_exact = true; | |
| 2586 } | |
| 2587 } | |
| 2588 } | |
| 2589 return TypeInstPtr::make(TypePtr::BotPTR, klass, klass_is_exact, NULL, 0); | |
| 2590 } else if (klass->is_obj_array_klass()) { | |
| 2591 // Element is an object array. Recursively call ourself. | |
| 2592 const TypeOopPtr *etype = TypeOopPtr::make_from_klass_common(klass->as_obj_array_klass()->element_klass(), false, try_for_exact); | |
| 2593 bool xk = etype->klass_is_exact(); | |
| 2594 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS); | |
| 2595 // We used to pass NotNull in here, asserting that the sub-arrays | |
| 2596 // are all not-null. This is not true in generally, as code can | |
| 2597 // slam NULLs down in the subarrays. | |
| 2598 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::BotPTR, arr0, klass, xk, 0); | |
| 2599 return arr; | |
| 2600 } else if (klass->is_type_array_klass()) { | |
| 2601 // Element is an typeArray | |
| 2602 const Type* etype = get_const_basic_type(klass->as_type_array_klass()->element_type()); | |
| 2603 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS); | |
| 2604 // We used to pass NotNull in here, asserting that the array pointer | |
| 2605 // is not-null. That was not true in general. | |
| 2606 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::BotPTR, arr0, klass, true, 0); | |
| 2607 return arr; | |
| 2608 } else { | |
| 2609 ShouldNotReachHere(); | |
| 2610 return NULL; | |
| 2611 } | |
| 2612 } | |
| 2613 | |
| 2614 //------------------------------make_from_constant----------------------------- | |
| 2615 // Make a java pointer from an oop constant | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2616 const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_constant) { |
| 0 | 2617 assert(!o->is_null_object(), "null object not yet handled here."); |
|
6182
765ee2d1674b
7157365: jruby/bench.bench_timeout crashes with JVM internal error
twisti
parents:
6179
diff
changeset
|
2618 ciKlass* klass = o->klass(); |
| 0 | 2619 if (klass->is_instance_klass()) { |
| 2620 // Element is an instance | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2621 if (require_constant) { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2622 if (!o->can_be_constant()) return NULL; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2623 } else if (!o->should_be_constant()) { |
| 0 | 2624 return TypeInstPtr::make(TypePtr::NotNull, klass, true, NULL, 0); |
| 2625 } | |
| 2626 return TypeInstPtr::make(o); | |
| 2627 } else if (klass->is_obj_array_klass()) { | |
| 2628 // Element is an object array. Recursively call ourself. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2629 const Type *etype = |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2630 TypeOopPtr::make_from_klass_raw(klass->as_obj_array_klass()->element_klass()); |
| 0 | 2631 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length())); |
| 2632 // We used to pass NotNull in here, asserting that the sub-arrays | |
| 2633 // are all not-null. This is not true in generally, as code can | |
| 2634 // slam NULLs down in the subarrays. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2635 if (require_constant) { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2636 if (!o->can_be_constant()) return NULL; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2637 } else if (!o->should_be_constant()) { |
| 0 | 2638 return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0); |
| 2639 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2640 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2641 return arr; |
| 0 | 2642 } else if (klass->is_type_array_klass()) { |
| 2643 // Element is an typeArray | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2644 const Type* etype = |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2645 (Type*)get_const_basic_type(klass->as_type_array_klass()->element_type()); |
| 0 | 2646 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length())); |
| 2647 // We used to pass NotNull in here, asserting that the array pointer | |
| 2648 // is not-null. That was not true in general. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2649 if (require_constant) { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2650 if (!o->can_be_constant()) return NULL; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2651 } else if (!o->should_be_constant()) { |
| 0 | 2652 return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0); |
| 2653 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2654 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2655 return arr; |
| 0 | 2656 } |
| 2657 | |
|
6182
765ee2d1674b
7157365: jruby/bench.bench_timeout crashes with JVM internal error
twisti
parents:
6179
diff
changeset
|
2658 fatal("unhandled object type"); |
| 0 | 2659 return NULL; |
| 2660 } | |
| 2661 | |
| 2662 //------------------------------get_con---------------------------------------- | |
| 2663 intptr_t TypeOopPtr::get_con() const { | |
| 2664 assert( _ptr == Null || _ptr == Constant, "" ); | |
| 2665 assert( _offset >= 0, "" ); | |
| 2666 | |
| 2667 if (_offset != 0) { | |
| 2668 // After being ported to the compiler interface, the compiler no longer | |
| 2669 // directly manipulates the addresses of oops. Rather, it only has a pointer | |
| 2670 // to a handle at compile time. This handle is embedded in the generated | |
| 2671 // code and dereferenced at the time the nmethod is made. Until that time, | |
| 2672 // it is not reasonable to do arithmetic with the addresses of oops (we don't | |
| 2673 // have access to the addresses!). This does not seem to currently happen, | |
| 605 | 2674 // but this assertion here is to help prevent its occurence. |
| 0 | 2675 tty->print_cr("Found oop constant with non-zero offset"); |
| 2676 ShouldNotReachHere(); | |
| 2677 } | |
| 2678 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
2679 return (intptr_t)const_oop()->constant_encoding(); |
| 0 | 2680 } |
| 2681 | |
| 2682 | |
| 2683 //-----------------------------filter------------------------------------------ | |
| 2684 // Do not allow interface-vs.-noninterface joins to collapse to top. | |
| 2685 const Type *TypeOopPtr::filter( const Type *kills ) const { | |
| 2686 | |
| 2687 const Type* ft = join(kills); | |
| 2688 const TypeInstPtr* ftip = ft->isa_instptr(); | |
| 2689 const TypeInstPtr* ktip = kills->isa_instptr(); | |
| 555 | 2690 const TypeKlassPtr* ftkp = ft->isa_klassptr(); |
| 2691 const TypeKlassPtr* ktkp = kills->isa_klassptr(); | |
| 0 | 2692 |
| 2693 if (ft->empty()) { | |
| 2694 // Check for evil case of 'this' being a class and 'kills' expecting an | |
| 2695 // interface. This can happen because the bytecodes do not contain | |
| 2696 // enough type info to distinguish a Java-level interface variable | |
| 2697 // from a Java-level object variable. If we meet 2 classes which | |
| 2698 // both implement interface I, but their meet is at 'j/l/O' which | |
| 2699 // doesn't implement I, we have no way to tell if the result should | |
| 2700 // be 'I' or 'j/l/O'. Thus we'll pick 'j/l/O'. If this then flows | |
| 2701 // into a Phi which "knows" it's an Interface type we'll have to | |
| 2702 // uplift the type. | |
| 2703 if (!empty() && ktip != NULL && ktip->is_loaded() && ktip->klass()->is_interface()) | |
| 2704 return kills; // Uplift to interface | |
| 555 | 2705 if (!empty() && ktkp != NULL && ktkp->klass()->is_loaded() && ktkp->klass()->is_interface()) |
| 2706 return kills; // Uplift to interface | |
| 0 | 2707 |
| 2708 return Type::TOP; // Canonical empty value | |
| 2709 } | |
| 2710 | |
| 2711 // If we have an interface-typed Phi or cast and we narrow to a class type, | |
| 2712 // the join should report back the class. However, if we have a J/L/Object | |
| 2713 // class-typed Phi and an interface flows in, it's possible that the meet & | |
| 2714 // join report an interface back out. This isn't possible but happens | |
| 2715 // because the type system doesn't interact well with interfaces. | |
| 2716 if (ftip != NULL && ktip != NULL && | |
| 2717 ftip->is_loaded() && ftip->klass()->is_interface() && | |
| 2718 ktip->is_loaded() && !ktip->klass()->is_interface()) { | |
| 2719 // Happens in a CTW of rt.jar, 320-341, no extra flags | |
|
1335
ae4032fb0a5b
6894807: No ClassCastException for HashAttributeSet constructors if run with -Xcomp
kvn
parents:
1009
diff
changeset
|
2720 assert(!ftip->klass_is_exact(), "interface could not be exact"); |
| 0 | 2721 return ktip->cast_to_ptr_type(ftip->ptr()); |
| 2722 } | |
|
1335
ae4032fb0a5b
6894807: No ClassCastException for HashAttributeSet constructors if run with -Xcomp
kvn
parents:
1009
diff
changeset
|
2723 // Interface klass type could be exact in opposite to interface type, |
|
ae4032fb0a5b
6894807: No ClassCastException for HashAttributeSet constructors if run with -Xcomp
kvn
parents:
1009
diff
changeset
|
2724 // return it here instead of incorrect Constant ptr J/L/Object (6894807). |
| 555 | 2725 if (ftkp != NULL && ktkp != NULL && |
| 2726 ftkp->is_loaded() && ftkp->klass()->is_interface() && | |
|
1335
ae4032fb0a5b
6894807: No ClassCastException for HashAttributeSet constructors if run with -Xcomp
kvn
parents:
1009
diff
changeset
|
2727 !ftkp->klass_is_exact() && // Keep exact interface klass |
| 555 | 2728 ktkp->is_loaded() && !ktkp->klass()->is_interface()) { |
| 2729 return ktkp->cast_to_ptr_type(ftkp->ptr()); | |
| 2730 } | |
| 0 | 2731 |
| 2732 return ft; | |
| 2733 } | |
| 2734 | |
| 2735 //------------------------------eq--------------------------------------------- | |
| 2736 // Structural equality check for Type representations | |
| 2737 bool TypeOopPtr::eq( const Type *t ) const { | |
| 2738 const TypeOopPtr *a = (const TypeOopPtr*)t; | |
| 2739 if (_klass_is_exact != a->_klass_is_exact || | |
| 2740 _instance_id != a->_instance_id) return false; | |
| 2741 ciObject* one = const_oop(); | |
| 2742 ciObject* two = a->const_oop(); | |
| 2743 if (one == NULL || two == NULL) { | |
| 2744 return (one == two) && TypePtr::eq(t); | |
| 2745 } else { | |
| 2746 return one->equals(two) && TypePtr::eq(t); | |
| 2747 } | |
| 2748 } | |
| 2749 | |
| 2750 //------------------------------hash------------------------------------------- | |
| 2751 // Type-specific hashing function. | |
| 2752 int TypeOopPtr::hash(void) const { | |
| 2753 return | |
| 2754 (const_oop() ? const_oop()->hash() : 0) + | |
| 2755 _klass_is_exact + | |
| 2756 _instance_id + | |
| 2757 TypePtr::hash(); | |
| 2758 } | |
| 2759 | |
| 2760 //------------------------------dump2------------------------------------------ | |
| 2761 #ifndef PRODUCT | |
| 2762 void TypeOopPtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 2763 st->print("oopptr:%s", ptr_msg[_ptr]); | |
| 2764 if( _klass_is_exact ) st->print(":exact"); | |
| 2765 if( const_oop() ) st->print(INTPTR_FORMAT, const_oop()); | |
| 2766 switch( _offset ) { | |
| 2767 case OffsetTop: st->print("+top"); break; | |
| 2768 case OffsetBot: st->print("+any"); break; | |
| 2769 case 0: break; | |
| 2770 default: st->print("+%d",_offset); break; | |
| 2771 } | |
| 223 | 2772 if (_instance_id == InstanceTop) |
| 2773 st->print(",iid=top"); | |
| 2774 else if (_instance_id != InstanceBot) | |
| 0 | 2775 st->print(",iid=%d",_instance_id); |
| 2776 } | |
| 2777 #endif | |
| 2778 | |
| 2779 //------------------------------singleton-------------------------------------- | |
| 2780 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 2781 // constants | |
| 2782 bool TypeOopPtr::singleton(void) const { | |
| 2783 // detune optimizer to not generate constant oop + constant offset as a constant! | |
| 2784 // TopPTR, Null, AnyNull, Constant are all singletons | |
| 2785 return (_offset == 0) && !below_centerline(_ptr); | |
| 2786 } | |
| 2787 | |
| 2788 //------------------------------add_offset------------------------------------- | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2789 const TypePtr *TypeOopPtr::add_offset( intptr_t offset ) const { |
| 992 | 2790 return make( _ptr, xadd_offset(offset), _instance_id); |
| 0 | 2791 } |
| 2792 | |
| 223 | 2793 //------------------------------meet_instance_id-------------------------------- |
| 2794 int TypeOopPtr::meet_instance_id( int instance_id ) const { | |
| 2795 // Either is 'TOP' instance? Return the other instance! | |
| 2796 if( _instance_id == InstanceTop ) return instance_id; | |
| 2797 if( instance_id == InstanceTop ) return _instance_id; | |
| 2798 // If either is different, return 'BOTTOM' instance | |
| 2799 if( _instance_id != instance_id ) return InstanceBot; | |
| 2800 return _instance_id; | |
| 0 | 2801 } |
| 2802 | |
| 223 | 2803 //------------------------------dual_instance_id-------------------------------- |
| 2804 int TypeOopPtr::dual_instance_id( ) const { | |
| 2805 if( _instance_id == InstanceTop ) return InstanceBot; // Map TOP into BOTTOM | |
| 2806 if( _instance_id == InstanceBot ) return InstanceTop; // Map BOTTOM into TOP | |
| 2807 return _instance_id; // Map everything else into self | |
| 2808 } | |
| 2809 | |
| 2810 | |
| 0 | 2811 //============================================================================= |
| 2812 // Convenience common pre-built types. | |
| 2813 const TypeInstPtr *TypeInstPtr::NOTNULL; | |
| 2814 const TypeInstPtr *TypeInstPtr::BOTTOM; | |
| 2815 const TypeInstPtr *TypeInstPtr::MIRROR; | |
| 2816 const TypeInstPtr *TypeInstPtr::MARK; | |
| 2817 const TypeInstPtr *TypeInstPtr::KLASS; | |
| 2818 | |
| 2819 //------------------------------TypeInstPtr------------------------------------- | |
| 2820 TypeInstPtr::TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int off, int instance_id) | |
| 2821 : TypeOopPtr(InstPtr, ptr, k, xk, o, off, instance_id), _name(k->name()) { | |
| 2822 assert(k != NULL && | |
| 2823 (k->is_loaded() || o == NULL), | |
| 2824 "cannot have constants with non-loaded klass"); | |
| 2825 }; | |
| 2826 | |
| 2827 //------------------------------make------------------------------------------- | |
| 2828 const TypeInstPtr *TypeInstPtr::make(PTR ptr, | |
| 2829 ciKlass* k, | |
| 2830 bool xk, | |
| 2831 ciObject* o, | |
| 2832 int offset, | |
| 2833 int instance_id) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2834 assert( !k->is_loaded() || k->is_instance_klass(), "Must be for instance"); |
| 0 | 2835 // Either const_oop() is NULL or else ptr is Constant |
| 2836 assert( (!o && ptr != Constant) || (o && ptr == Constant), | |
| 2837 "constant pointers must have a value supplied" ); | |
| 2838 // Ptr is never Null | |
| 2839 assert( ptr != Null, "NULL pointers are not typed" ); | |
| 2840 | |
| 247 | 2841 assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed"); |
| 0 | 2842 if (!UseExactTypes) xk = false; |
| 2843 if (ptr == Constant) { | |
| 2844 // Note: This case includes meta-object constants, such as methods. | |
| 2845 xk = true; | |
| 2846 } else if (k->is_loaded()) { | |
| 2847 ciInstanceKlass* ik = k->as_instance_klass(); | |
| 2848 if (!xk && ik->is_final()) xk = true; // no inexact final klass | |
| 2849 if (xk && ik->is_interface()) xk = false; // no exact interface | |
| 2850 } | |
| 2851 | |
| 2852 // Now hash this baby | |
| 2853 TypeInstPtr *result = | |
| 2854 (TypeInstPtr*)(new TypeInstPtr(ptr, k, xk, o ,offset, instance_id))->hashcons(); | |
| 2855 | |
| 2856 return result; | |
| 2857 } | |
| 2858 | |
| 2859 | |
| 2860 //------------------------------cast_to_ptr_type------------------------------- | |
| 2861 const Type *TypeInstPtr::cast_to_ptr_type(PTR ptr) const { | |
| 2862 if( ptr == _ptr ) return this; | |
| 2863 // Reconstruct _sig info here since not a problem with later lazy | |
| 2864 // construction, _sig will show up on demand. | |
| 223 | 2865 return make(ptr, klass(), klass_is_exact(), const_oop(), _offset, _instance_id); |
| 0 | 2866 } |
| 2867 | |
| 2868 | |
| 2869 //-----------------------------cast_to_exactness------------------------------- | |
| 2870 const Type *TypeInstPtr::cast_to_exactness(bool klass_is_exact) const { | |
| 2871 if( klass_is_exact == _klass_is_exact ) return this; | |
| 2872 if (!UseExactTypes) return this; | |
| 2873 if (!_klass->is_loaded()) return this; | |
| 2874 ciInstanceKlass* ik = _klass->as_instance_klass(); | |
| 2875 if( (ik->is_final() || _const_oop) ) return this; // cannot clear xk | |
| 2876 if( ik->is_interface() ) return this; // cannot set xk | |
| 2877 return make(ptr(), klass(), klass_is_exact, const_oop(), _offset, _instance_id); | |
| 2878 } | |
| 2879 | |
| 247 | 2880 //-----------------------------cast_to_instance_id---------------------------- |
| 223 | 2881 const TypeOopPtr *TypeInstPtr::cast_to_instance_id(int instance_id) const { |
| 2882 if( instance_id == _instance_id ) return this; | |
| 247 | 2883 return make(_ptr, klass(), _klass_is_exact, const_oop(), _offset, instance_id); |
| 0 | 2884 } |
| 2885 | |
| 2886 //------------------------------xmeet_unloaded--------------------------------- | |
| 2887 // Compute the MEET of two InstPtrs when at least one is unloaded. | |
| 2888 // Assume classes are different since called after check for same name/class-loader | |
| 2889 const TypeInstPtr *TypeInstPtr::xmeet_unloaded(const TypeInstPtr *tinst) const { | |
| 2890 int off = meet_offset(tinst->offset()); | |
| 2891 PTR ptr = meet_ptr(tinst->ptr()); | |
| 992 | 2892 int instance_id = meet_instance_id(tinst->instance_id()); |
| 0 | 2893 |
| 2894 const TypeInstPtr *loaded = is_loaded() ? this : tinst; | |
| 2895 const TypeInstPtr *unloaded = is_loaded() ? tinst : this; | |
| 2896 if( loaded->klass()->equals(ciEnv::current()->Object_klass()) ) { | |
| 2897 // | |
| 2898 // Meet unloaded class with java/lang/Object | |
| 2899 // | |
| 2900 // Meet | |
| 2901 // | Unloaded Class | |
| 2902 // Object | TOP | AnyNull | Constant | NotNull | BOTTOM | | |
| 2903 // =================================================================== | |
| 2904 // TOP | ..........................Unloaded......................| | |
| 2905 // AnyNull | U-AN |................Unloaded......................| | |
| 2906 // Constant | ... O-NN .................................. | O-BOT | | |
| 2907 // NotNull | ... O-NN .................................. | O-BOT | | |
| 2908 // BOTTOM | ........................Object-BOTTOM ..................| | |
| 2909 // | |
| 2910 assert(loaded->ptr() != TypePtr::Null, "insanity check"); | |
| 2911 // | |
| 2912 if( loaded->ptr() == TypePtr::TopPTR ) { return unloaded; } | |
| 992 | 2913 else if (loaded->ptr() == TypePtr::AnyNull) { return TypeInstPtr::make( ptr, unloaded->klass(), false, NULL, off, instance_id ); } |
| 0 | 2914 else if (loaded->ptr() == TypePtr::BotPTR ) { return TypeInstPtr::BOTTOM; } |
| 2915 else if (loaded->ptr() == TypePtr::Constant || loaded->ptr() == TypePtr::NotNull) { | |
| 2916 if (unloaded->ptr() == TypePtr::BotPTR ) { return TypeInstPtr::BOTTOM; } | |
| 2917 else { return TypeInstPtr::NOTNULL; } | |
| 2918 } | |
| 2919 else if( unloaded->ptr() == TypePtr::TopPTR ) { return unloaded; } | |
| 2920 | |
| 2921 return unloaded->cast_to_ptr_type(TypePtr::AnyNull)->is_instptr(); | |
| 2922 } | |
| 2923 | |
| 2924 // Both are unloaded, not the same class, not Object | |
| 2925 // Or meet unloaded with a different loaded class, not java/lang/Object | |
| 2926 if( ptr != TypePtr::BotPTR ) { | |
| 2927 return TypeInstPtr::NOTNULL; | |
| 2928 } | |
| 2929 return TypeInstPtr::BOTTOM; | |
| 2930 } | |
| 2931 | |
| 2932 | |
| 2933 //------------------------------meet------------------------------------------- | |
| 2934 // Compute the MEET of two types. It returns a new Type object. | |
| 2935 const Type *TypeInstPtr::xmeet( const Type *t ) const { | |
| 2936 // Perform a fast test for common case; meeting the same types together. | |
| 2937 if( this == t ) return this; // Meeting same type-rep? | |
| 2938 | |
| 2939 // Current "this->_base" is Pointer | |
| 2940 switch (t->base()) { // switch on original type | |
| 2941 | |
| 2942 case Int: // Mixing ints & oops happens when javac | |
| 2943 case Long: // reuses local variables | |
| 2944 case FloatTop: | |
| 2945 case FloatCon: | |
| 2946 case FloatBot: | |
| 2947 case DoubleTop: | |
| 2948 case DoubleCon: | |
| 2949 case DoubleBot: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
2950 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
2951 case NarrowKlass: |
| 0 | 2952 case Bottom: // Ye Olde Default |
| 2953 return Type::BOTTOM; | |
| 2954 case Top: | |
| 2955 return this; | |
| 2956 | |
| 2957 default: // All else is a mistake | |
| 2958 typerr(t); | |
| 2959 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2960 case MetadataPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
2961 case KlassPtr: |
| 0 | 2962 case RawPtr: return TypePtr::BOTTOM; |
| 2963 | |
| 2964 case AryPtr: { // All arrays inherit from Object class | |
| 2965 const TypeAryPtr *tp = t->is_aryptr(); | |
| 2966 int offset = meet_offset(tp->offset()); | |
| 2967 PTR ptr = meet_ptr(tp->ptr()); | |
| 223 | 2968 int instance_id = meet_instance_id(tp->instance_id()); |
| 0 | 2969 switch (ptr) { |
| 2970 case TopPTR: | |
| 2971 case AnyNull: // Fall 'down' to dual of object klass | |
| 2972 if (klass()->equals(ciEnv::current()->Object_klass())) { | |
| 223 | 2973 return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id); |
| 0 | 2974 } else { |
| 2975 // cannot subclass, so the meet has to fall badly below the centerline | |
| 2976 ptr = NotNull; | |
| 223 | 2977 instance_id = InstanceBot; |
| 2978 return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id); | |
| 0 | 2979 } |
| 2980 case Constant: | |
| 2981 case NotNull: | |
| 2982 case BotPTR: // Fall down to object klass | |
| 2983 // LCA is object_klass, but if we subclass from the top we can do better | |
| 2984 if( above_centerline(_ptr) ) { // if( _ptr == TopPTR || _ptr == AnyNull ) | |
| 2985 // If 'this' (InstPtr) is above the centerline and it is Object class | |
| 605 | 2986 // then we can subclass in the Java class hierarchy. |
| 0 | 2987 if (klass()->equals(ciEnv::current()->Object_klass())) { |
| 2988 // that is, tp's array type is a subtype of my klass | |
|
1279
2432acbee618
6930035: C2 type system incorrectly handles case j.l.Object->meet(constant AryPtr)
kvn
parents:
1137
diff
changeset
|
2989 return TypeAryPtr::make(ptr, (ptr == Constant ? tp->const_oop() : NULL), |
|
2432acbee618
6930035: C2 type system incorrectly handles case j.l.Object->meet(constant AryPtr)
kvn
parents:
1137
diff
changeset
|
2990 tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id); |
| 0 | 2991 } |
| 2992 } | |
| 2993 // The other case cannot happen, since I cannot be a subtype of an array. | |
| 2994 // The meet falls down to Object class below centerline. | |
| 2995 if( ptr == Constant ) | |
| 2996 ptr = NotNull; | |
| 223 | 2997 instance_id = InstanceBot; |
| 2998 return make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id ); | |
| 0 | 2999 default: typerr(t); |
| 3000 } | |
| 3001 } | |
| 3002 | |
| 3003 case OopPtr: { // Meeting to OopPtrs | |
| 3004 // Found a OopPtr type vs self-InstPtr type | |
|
958
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3005 const TypeOopPtr *tp = t->is_oopptr(); |
| 0 | 3006 int offset = meet_offset(tp->offset()); |
| 3007 PTR ptr = meet_ptr(tp->ptr()); | |
| 3008 switch (tp->ptr()) { | |
| 3009 case TopPTR: | |
| 223 | 3010 case AnyNull: { |
| 3011 int instance_id = meet_instance_id(InstanceTop); | |
| 0 | 3012 return make(ptr, klass(), klass_is_exact(), |
| 223 | 3013 (ptr == Constant ? const_oop() : NULL), offset, instance_id); |
| 3014 } | |
| 0 | 3015 case NotNull: |
|
958
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3016 case BotPTR: { |
|
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3017 int instance_id = meet_instance_id(tp->instance_id()); |
|
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3018 return TypeOopPtr::make(ptr, offset, instance_id); |
|
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3019 } |
| 0 | 3020 default: typerr(t); |
| 3021 } | |
| 3022 } | |
| 3023 | |
| 3024 case AnyPtr: { // Meeting to AnyPtrs | |
| 3025 // Found an AnyPtr type vs self-InstPtr type | |
| 3026 const TypePtr *tp = t->is_ptr(); | |
| 3027 int offset = meet_offset(tp->offset()); | |
| 3028 PTR ptr = meet_ptr(tp->ptr()); | |
| 3029 switch (tp->ptr()) { | |
| 3030 case Null: | |
| 3031 if( ptr == Null ) return TypePtr::make( AnyPtr, ptr, offset ); | |
| 223 | 3032 // else fall through to AnyNull |
| 0 | 3033 case TopPTR: |
| 223 | 3034 case AnyNull: { |
| 3035 int instance_id = meet_instance_id(InstanceTop); | |
| 0 | 3036 return make( ptr, klass(), klass_is_exact(), |
| 223 | 3037 (ptr == Constant ? const_oop() : NULL), offset, instance_id); |
| 3038 } | |
| 0 | 3039 case NotNull: |
| 3040 case BotPTR: | |
| 3041 return TypePtr::make( AnyPtr, ptr, offset ); | |
| 3042 default: typerr(t); | |
| 3043 } | |
| 3044 } | |
| 3045 | |
| 3046 /* | |
| 3047 A-top } | |
| 3048 / | \ } Tops | |
| 3049 B-top A-any C-top } | |
| 3050 | / | \ | } Any-nulls | |
| 3051 B-any | C-any } | |
| 3052 | | | | |
| 3053 B-con A-con C-con } constants; not comparable across classes | |
| 3054 | | | | |
| 3055 B-not | C-not } | |
| 3056 | \ | / | } not-nulls | |
| 3057 B-bot A-not C-bot } | |
| 3058 \ | / } Bottoms | |
| 3059 A-bot } | |
| 3060 */ | |
| 3061 | |
| 3062 case InstPtr: { // Meeting 2 Oops? | |
| 3063 // Found an InstPtr sub-type vs self-InstPtr type | |
| 3064 const TypeInstPtr *tinst = t->is_instptr(); | |
| 3065 int off = meet_offset( tinst->offset() ); | |
| 3066 PTR ptr = meet_ptr( tinst->ptr() ); | |
| 223 | 3067 int instance_id = meet_instance_id(tinst->instance_id()); |
| 0 | 3068 |
| 3069 // Check for easy case; klasses are equal (and perhaps not loaded!) | |
| 3070 // If we have constants, then we created oops so classes are loaded | |
| 3071 // and we can handle the constants further down. This case handles | |
| 3072 // both-not-loaded or both-loaded classes | |
| 3073 if (ptr != Constant && klass()->equals(tinst->klass()) && klass_is_exact() == tinst->klass_is_exact()) { | |
| 3074 return make( ptr, klass(), klass_is_exact(), NULL, off, instance_id ); | |
| 3075 } | |
| 3076 | |
| 3077 // Classes require inspection in the Java klass hierarchy. Must be loaded. | |
| 3078 ciKlass* tinst_klass = tinst->klass(); | |
| 3079 ciKlass* this_klass = this->klass(); | |
| 3080 bool tinst_xk = tinst->klass_is_exact(); | |
| 3081 bool this_xk = this->klass_is_exact(); | |
| 3082 if (!tinst_klass->is_loaded() || !this_klass->is_loaded() ) { | |
| 3083 // One of these classes has not been loaded | |
| 3084 const TypeInstPtr *unloaded_meet = xmeet_unloaded(tinst); | |
| 3085 #ifndef PRODUCT | |
| 3086 if( PrintOpto && Verbose ) { | |
| 3087 tty->print("meet of unloaded classes resulted in: "); unloaded_meet->dump(); tty->cr(); | |
| 3088 tty->print(" this == "); this->dump(); tty->cr(); | |
| 3089 tty->print(" tinst == "); tinst->dump(); tty->cr(); | |
| 3090 } | |
| 3091 #endif | |
| 3092 return unloaded_meet; | |
| 3093 } | |
| 3094 | |
| 3095 // Handle mixing oops and interfaces first. | |
| 3096 if( this_klass->is_interface() && !tinst_klass->is_interface() ) { | |
| 3097 ciKlass *tmp = tinst_klass; // Swap interface around | |
| 3098 tinst_klass = this_klass; | |
| 3099 this_klass = tmp; | |
| 3100 bool tmp2 = tinst_xk; | |
| 3101 tinst_xk = this_xk; | |
| 3102 this_xk = tmp2; | |
| 3103 } | |
| 3104 if (tinst_klass->is_interface() && | |
| 3105 !(this_klass->is_interface() || | |
| 3106 // Treat java/lang/Object as an honorary interface, | |
| 3107 // because we need a bottom for the interface hierarchy. | |
| 3108 this_klass == ciEnv::current()->Object_klass())) { | |
| 3109 // Oop meets interface! | |
| 3110 | |
| 3111 // See if the oop subtypes (implements) interface. | |
| 3112 ciKlass *k; | |
| 3113 bool xk; | |
| 3114 if( this_klass->is_subtype_of( tinst_klass ) ) { | |
| 3115 // Oop indeed subtypes. Now keep oop or interface depending | |
| 3116 // on whether we are both above the centerline or either is | |
| 3117 // below the centerline. If we are on the centerline | |
| 3118 // (e.g., Constant vs. AnyNull interface), use the constant. | |
| 3119 k = below_centerline(ptr) ? tinst_klass : this_klass; | |
| 3120 // If we are keeping this_klass, keep its exactness too. | |
| 3121 xk = below_centerline(ptr) ? tinst_xk : this_xk; | |
| 3122 } else { // Does not implement, fall to Object | |
| 3123 // Oop does not implement interface, so mixing falls to Object | |
| 3124 // just like the verifier does (if both are above the | |
| 3125 // centerline fall to interface) | |
| 3126 k = above_centerline(ptr) ? tinst_klass : ciEnv::current()->Object_klass(); | |
| 3127 xk = above_centerline(ptr) ? tinst_xk : false; | |
| 3128 // Watch out for Constant vs. AnyNull interface. | |
| 3129 if (ptr == Constant) ptr = NotNull; // forget it was a constant | |
| 247 | 3130 instance_id = InstanceBot; |
| 0 | 3131 } |
| 3132 ciObject* o = NULL; // the Constant value, if any | |
| 3133 if (ptr == Constant) { | |
| 3134 // Find out which constant. | |
| 3135 o = (this_klass == klass()) ? const_oop() : tinst->const_oop(); | |
| 3136 } | |
| 223 | 3137 return make( ptr, k, xk, o, off, instance_id ); |
| 0 | 3138 } |
| 3139 | |
| 3140 // Either oop vs oop or interface vs interface or interface vs Object | |
| 3141 | |
| 3142 // !!! Here's how the symmetry requirement breaks down into invariants: | |
| 3143 // If we split one up & one down AND they subtype, take the down man. | |
| 3144 // If we split one up & one down AND they do NOT subtype, "fall hard". | |
| 3145 // If both are up and they subtype, take the subtype class. | |
| 3146 // If both are up and they do NOT subtype, "fall hard". | |
| 3147 // If both are down and they subtype, take the supertype class. | |
| 3148 // If both are down and they do NOT subtype, "fall hard". | |
| 3149 // Constants treated as down. | |
| 3150 | |
| 3151 // Now, reorder the above list; observe that both-down+subtype is also | |
| 3152 // "fall hard"; "fall hard" becomes the default case: | |
| 3153 // If we split one up & one down AND they subtype, take the down man. | |
| 3154 // If both are up and they subtype, take the subtype class. | |
| 3155 | |
| 3156 // If both are down and they subtype, "fall hard". | |
| 3157 // If both are down and they do NOT subtype, "fall hard". | |
| 3158 // If both are up and they do NOT subtype, "fall hard". | |
| 3159 // If we split one up & one down AND they do NOT subtype, "fall hard". | |
| 3160 | |
| 3161 // If a proper subtype is exact, and we return it, we return it exactly. | |
| 3162 // If a proper supertype is exact, there can be no subtyping relationship! | |
| 3163 // If both types are equal to the subtype, exactness is and-ed below the | |
| 3164 // centerline and or-ed above it. (N.B. Constants are always exact.) | |
| 3165 | |
| 3166 // Check for subtyping: | |
| 3167 ciKlass *subtype = NULL; | |
| 3168 bool subtype_exact = false; | |
| 3169 if( tinst_klass->equals(this_klass) ) { | |
| 3170 subtype = this_klass; | |
| 3171 subtype_exact = below_centerline(ptr) ? (this_xk & tinst_xk) : (this_xk | tinst_xk); | |
| 3172 } else if( !tinst_xk && this_klass->is_subtype_of( tinst_klass ) ) { | |
| 3173 subtype = this_klass; // Pick subtyping class | |
| 3174 subtype_exact = this_xk; | |
| 3175 } else if( !this_xk && tinst_klass->is_subtype_of( this_klass ) ) { | |
| 3176 subtype = tinst_klass; // Pick subtyping class | |
| 3177 subtype_exact = tinst_xk; | |
| 3178 } | |
| 3179 | |
| 3180 if( subtype ) { | |
| 3181 if( above_centerline(ptr) ) { // both are up? | |
| 3182 this_klass = tinst_klass = subtype; | |
| 3183 this_xk = tinst_xk = subtype_exact; | |
| 3184 } else if( above_centerline(this ->_ptr) && !above_centerline(tinst->_ptr) ) { | |
| 3185 this_klass = tinst_klass; // tinst is down; keep down man | |
| 3186 this_xk = tinst_xk; | |
| 3187 } else if( above_centerline(tinst->_ptr) && !above_centerline(this ->_ptr) ) { | |
| 3188 tinst_klass = this_klass; // this is down; keep down man | |
| 3189 tinst_xk = this_xk; | |
| 3190 } else { | |
| 3191 this_xk = subtype_exact; // either they are equal, or we'll do an LCA | |
| 3192 } | |
| 3193 } | |
| 3194 | |
| 3195 // Check for classes now being equal | |
| 3196 if (tinst_klass->equals(this_klass)) { | |
| 3197 // If the klasses are equal, the constants may still differ. Fall to | |
| 3198 // NotNull if they do (neither constant is NULL; that is a special case | |
| 3199 // handled elsewhere). | |
| 3200 ciObject* o = NULL; // Assume not constant when done | |
| 3201 ciObject* this_oop = const_oop(); | |
| 3202 ciObject* tinst_oop = tinst->const_oop(); | |
| 3203 if( ptr == Constant ) { | |
| 3204 if (this_oop != NULL && tinst_oop != NULL && | |
| 3205 this_oop->equals(tinst_oop) ) | |
| 3206 o = this_oop; | |
| 3207 else if (above_centerline(this ->_ptr)) | |
| 3208 o = tinst_oop; | |
| 3209 else if (above_centerline(tinst ->_ptr)) | |
| 3210 o = this_oop; | |
| 3211 else | |
| 3212 ptr = NotNull; | |
| 3213 } | |
| 3214 return make( ptr, this_klass, this_xk, o, off, instance_id ); | |
| 3215 } // Else classes are not equal | |
| 3216 | |
| 3217 // Since klasses are different, we require a LCA in the Java | |
| 3218 // class hierarchy - which means we have to fall to at least NotNull. | |
| 3219 if( ptr == TopPTR || ptr == AnyNull || ptr == Constant ) | |
| 3220 ptr = NotNull; | |
| 247 | 3221 instance_id = InstanceBot; |
| 0 | 3222 |
| 3223 // Now we find the LCA of Java classes | |
| 3224 ciKlass* k = this_klass->least_common_ancestor(tinst_klass); | |
| 223 | 3225 return make( ptr, k, false, NULL, off, instance_id ); |
| 0 | 3226 } // End of case InstPtr |
| 3227 | |
| 3228 } // End of switch | |
| 3229 return this; // Return the double constant | |
| 3230 } | |
| 3231 | |
| 3232 | |
| 3233 //------------------------java_mirror_type-------------------------------------- | |
| 3234 ciType* TypeInstPtr::java_mirror_type() const { | |
| 3235 // must be a singleton type | |
| 3236 if( const_oop() == NULL ) return NULL; | |
| 3237 | |
| 3238 // must be of type java.lang.Class | |
| 3239 if( klass() != ciEnv::current()->Class_klass() ) return NULL; | |
| 3240 | |
| 3241 return const_oop()->as_instance()->java_mirror_type(); | |
| 3242 } | |
| 3243 | |
| 3244 | |
| 3245 //------------------------------xdual------------------------------------------ | |
| 3246 // Dual: do NOT dual on klasses. This means I do NOT understand the Java | |
| 605 | 3247 // inheritance mechanism. |
| 0 | 3248 const Type *TypeInstPtr::xdual() const { |
| 223 | 3249 return new TypeInstPtr( dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id() ); |
| 0 | 3250 } |
| 3251 | |
| 3252 //------------------------------eq--------------------------------------------- | |
| 3253 // Structural equality check for Type representations | |
| 3254 bool TypeInstPtr::eq( const Type *t ) const { | |
| 3255 const TypeInstPtr *p = t->is_instptr(); | |
| 3256 return | |
| 3257 klass()->equals(p->klass()) && | |
| 3258 TypeOopPtr::eq(p); // Check sub-type stuff | |
| 3259 } | |
| 3260 | |
| 3261 //------------------------------hash------------------------------------------- | |
| 3262 // Type-specific hashing function. | |
| 3263 int TypeInstPtr::hash(void) const { | |
| 3264 int hash = klass()->hash() + TypeOopPtr::hash(); | |
| 3265 return hash; | |
| 3266 } | |
| 3267 | |
| 3268 //------------------------------dump2------------------------------------------ | |
| 3269 // Dump oop Type | |
| 3270 #ifndef PRODUCT | |
| 3271 void TypeInstPtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 3272 // Print the name of the klass. | |
| 3273 klass()->print_name_on(st); | |
| 3274 | |
| 3275 switch( _ptr ) { | |
| 3276 case Constant: | |
| 3277 // TO DO: Make CI print the hex address of the underlying oop. | |
| 3278 if (WizardMode || Verbose) { | |
| 3279 const_oop()->print_oop(st); | |
| 3280 } | |
| 3281 case BotPTR: | |
| 3282 if (!WizardMode && !Verbose) { | |
| 3283 if( _klass_is_exact ) st->print(":exact"); | |
| 3284 break; | |
| 3285 } | |
| 3286 case TopPTR: | |
| 3287 case AnyNull: | |
| 3288 case NotNull: | |
| 3289 st->print(":%s", ptr_msg[_ptr]); | |
| 3290 if( _klass_is_exact ) st->print(":exact"); | |
| 3291 break; | |
| 3292 } | |
| 3293 | |
| 3294 if( _offset ) { // Dump offset, if any | |
| 3295 if( _offset == OffsetBot ) st->print("+any"); | |
| 3296 else if( _offset == OffsetTop ) st->print("+unknown"); | |
| 3297 else st->print("+%d", _offset); | |
| 3298 } | |
| 3299 | |
| 3300 st->print(" *"); | |
| 223 | 3301 if (_instance_id == InstanceTop) |
| 3302 st->print(",iid=top"); | |
| 3303 else if (_instance_id != InstanceBot) | |
| 0 | 3304 st->print(",iid=%d",_instance_id); |
| 3305 } | |
| 3306 #endif | |
| 3307 | |
| 3308 //------------------------------add_offset------------------------------------- | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
3309 const TypePtr *TypeInstPtr::add_offset( intptr_t offset ) const { |
| 0 | 3310 return make( _ptr, klass(), klass_is_exact(), const_oop(), xadd_offset(offset), _instance_id ); |
| 3311 } | |
| 3312 | |
| 3313 //============================================================================= | |
| 3314 // Convenience common pre-built types. | |
| 3315 const TypeAryPtr *TypeAryPtr::RANGE; | |
| 3316 const TypeAryPtr *TypeAryPtr::OOPS; | |
| 163 | 3317 const TypeAryPtr *TypeAryPtr::NARROWOOPS; |
| 0 | 3318 const TypeAryPtr *TypeAryPtr::BYTES; |
| 3319 const TypeAryPtr *TypeAryPtr::SHORTS; | |
| 3320 const TypeAryPtr *TypeAryPtr::CHARS; | |
| 3321 const TypeAryPtr *TypeAryPtr::INTS; | |
| 3322 const TypeAryPtr *TypeAryPtr::LONGS; | |
| 3323 const TypeAryPtr *TypeAryPtr::FLOATS; | |
| 3324 const TypeAryPtr *TypeAryPtr::DOUBLES; | |
| 3325 | |
| 3326 //------------------------------make------------------------------------------- | |
| 3327 const TypeAryPtr *TypeAryPtr::make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) { | |
| 3328 assert(!(k == NULL && ary->_elem->isa_int()), | |
| 3329 "integral arrays must be pre-equipped with a class"); | |
| 3330 if (!xk) xk = ary->ary_must_be_exact(); | |
| 247 | 3331 assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed"); |
| 0 | 3332 if (!UseExactTypes) xk = (ptr == Constant); |
| 3333 return (TypeAryPtr*)(new TypeAryPtr(ptr, NULL, ary, k, xk, offset, instance_id))->hashcons(); | |
| 3334 } | |
| 3335 | |
| 3336 //------------------------------make------------------------------------------- | |
| 3337 const TypeAryPtr *TypeAryPtr::make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) { | |
| 3338 assert(!(k == NULL && ary->_elem->isa_int()), | |
| 3339 "integral arrays must be pre-equipped with a class"); | |
| 3340 assert( (ptr==Constant && o) || (ptr!=Constant && !o), "" ); | |
| 3341 if (!xk) xk = (o != NULL) || ary->ary_must_be_exact(); | |
| 247 | 3342 assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed"); |
| 0 | 3343 if (!UseExactTypes) xk = (ptr == Constant); |
| 3344 return (TypeAryPtr*)(new TypeAryPtr(ptr, o, ary, k, xk, offset, instance_id))->hashcons(); | |
| 3345 } | |
| 3346 | |
| 3347 //------------------------------cast_to_ptr_type------------------------------- | |
| 3348 const Type *TypeAryPtr::cast_to_ptr_type(PTR ptr) const { | |
| 3349 if( ptr == _ptr ) return this; | |
| 223 | 3350 return make(ptr, const_oop(), _ary, klass(), klass_is_exact(), _offset, _instance_id); |
| 0 | 3351 } |
| 3352 | |
| 3353 | |
| 3354 //-----------------------------cast_to_exactness------------------------------- | |
| 3355 const Type *TypeAryPtr::cast_to_exactness(bool klass_is_exact) const { | |
| 3356 if( klass_is_exact == _klass_is_exact ) return this; | |
| 3357 if (!UseExactTypes) return this; | |
| 3358 if (_ary->ary_must_be_exact()) return this; // cannot clear xk | |
| 3359 return make(ptr(), const_oop(), _ary, klass(), klass_is_exact, _offset, _instance_id); | |
| 3360 } | |
| 3361 | |
| 247 | 3362 //-----------------------------cast_to_instance_id---------------------------- |
| 223 | 3363 const TypeOopPtr *TypeAryPtr::cast_to_instance_id(int instance_id) const { |
| 3364 if( instance_id == _instance_id ) return this; | |
| 247 | 3365 return make(_ptr, const_oop(), _ary, klass(), _klass_is_exact, _offset, instance_id); |
| 0 | 3366 } |
| 3367 | |
| 3368 //-----------------------------narrow_size_type------------------------------- | |
| 3369 // Local cache for arrayOopDesc::max_array_length(etype), | |
| 3370 // which is kind of slow (and cached elsewhere by other users). | |
| 3371 static jint max_array_length_cache[T_CONFLICT+1]; | |
| 3372 static jint max_array_length(BasicType etype) { | |
| 3373 jint& cache = max_array_length_cache[etype]; | |
| 3374 jint res = cache; | |
| 3375 if (res == 0) { | |
| 3376 switch (etype) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3377 case T_NARROWOOP: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3378 etype = T_OBJECT; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3379 break; |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3380 case T_NARROWKLASS: |
| 0 | 3381 case T_CONFLICT: |
| 3382 case T_ILLEGAL: | |
| 3383 case T_VOID: | |
| 3384 etype = T_BYTE; // will produce conservatively high value | |
| 3385 } | |
| 3386 cache = res = arrayOopDesc::max_array_length(etype); | |
| 3387 } | |
| 3388 return res; | |
| 3389 } | |
| 3390 | |
| 3391 // Narrow the given size type to the index range for the given array base type. | |
| 3392 // Return NULL if the resulting int type becomes empty. | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3393 const TypeInt* TypeAryPtr::narrow_size_type(const TypeInt* size) const { |
| 0 | 3394 jint hi = size->_hi; |
| 3395 jint lo = size->_lo; | |
| 3396 jint min_lo = 0; | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3397 jint max_hi = max_array_length(elem()->basic_type()); |
| 0 | 3398 //if (index_not_size) --max_hi; // type of a valid array index, FTR |
| 3399 bool chg = false; | |
| 3400 if (lo < min_lo) { lo = min_lo; chg = true; } | |
| 3401 if (hi > max_hi) { hi = max_hi; chg = true; } | |
| 605 | 3402 // Negative length arrays will produce weird intermediate dead fast-path code |
| 0 | 3403 if (lo > hi) |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3404 return TypeInt::ZERO; |
| 0 | 3405 if (!chg) |
| 3406 return size; | |
| 3407 return TypeInt::make(lo, hi, Type::WidenMin); | |
| 3408 } | |
| 3409 | |
| 3410 //-------------------------------cast_to_size---------------------------------- | |
| 3411 const TypeAryPtr* TypeAryPtr::cast_to_size(const TypeInt* new_size) const { | |
| 3412 assert(new_size != NULL, ""); | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3413 new_size = narrow_size_type(new_size); |
| 0 | 3414 if (new_size == size()) return this; |
| 3415 const TypeAry* new_ary = TypeAry::make(elem(), new_size); | |
| 223 | 3416 return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _instance_id); |
| 0 | 3417 } |
| 3418 | |
| 3419 | |
| 3420 //------------------------------eq--------------------------------------------- | |
| 3421 // Structural equality check for Type representations | |
| 3422 bool TypeAryPtr::eq( const Type *t ) const { | |
| 3423 const TypeAryPtr *p = t->is_aryptr(); | |
| 3424 return | |
| 3425 _ary == p->_ary && // Check array | |
| 3426 TypeOopPtr::eq(p); // Check sub-parts | |
| 3427 } | |
| 3428 | |
| 3429 //------------------------------hash------------------------------------------- | |
| 3430 // Type-specific hashing function. | |
| 3431 int TypeAryPtr::hash(void) const { | |
| 3432 return (intptr_t)_ary + TypeOopPtr::hash(); | |
| 3433 } | |
| 3434 | |
| 3435 //------------------------------meet------------------------------------------- | |
| 3436 // Compute the MEET of two types. It returns a new Type object. | |
| 3437 const Type *TypeAryPtr::xmeet( const Type *t ) const { | |
| 3438 // Perform a fast test for common case; meeting the same types together. | |
| 3439 if( this == t ) return this; // Meeting same type-rep? | |
| 3440 // Current "this->_base" is Pointer | |
| 3441 switch (t->base()) { // switch on original type | |
| 3442 | |
| 3443 // Mixing ints & oops happens when javac reuses local variables | |
| 3444 case Int: | |
| 3445 case Long: | |
| 3446 case FloatTop: | |
| 3447 case FloatCon: | |
| 3448 case FloatBot: | |
| 3449 case DoubleTop: | |
| 3450 case DoubleCon: | |
| 3451 case DoubleBot: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3452 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3453 case NarrowKlass: |
| 0 | 3454 case Bottom: // Ye Olde Default |
| 3455 return Type::BOTTOM; | |
| 3456 case Top: | |
| 3457 return this; | |
| 3458 | |
| 3459 default: // All else is a mistake | |
| 3460 typerr(t); | |
| 3461 | |
| 3462 case OopPtr: { // Meeting to OopPtrs | |
| 3463 // Found a OopPtr type vs self-AryPtr type | |
|
958
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3464 const TypeOopPtr *tp = t->is_oopptr(); |
| 0 | 3465 int offset = meet_offset(tp->offset()); |
| 3466 PTR ptr = meet_ptr(tp->ptr()); | |
| 3467 switch (tp->ptr()) { | |
| 3468 case TopPTR: | |
| 223 | 3469 case AnyNull: { |
| 3470 int instance_id = meet_instance_id(InstanceTop); | |
| 3471 return make(ptr, (ptr == Constant ? const_oop() : NULL), | |
| 3472 _ary, _klass, _klass_is_exact, offset, instance_id); | |
| 3473 } | |
| 0 | 3474 case BotPTR: |
|
958
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3475 case NotNull: { |
|
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3476 int instance_id = meet_instance_id(tp->instance_id()); |
|
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3477 return TypeOopPtr::make(ptr, offset, instance_id); |
|
c7e94e8fff43
6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents:
827
diff
changeset
|
3478 } |
| 0 | 3479 default: ShouldNotReachHere(); |
| 3480 } | |
| 3481 } | |
| 3482 | |
| 3483 case AnyPtr: { // Meeting two AnyPtrs | |
| 3484 // Found an AnyPtr type vs self-AryPtr type | |
| 3485 const TypePtr *tp = t->is_ptr(); | |
| 3486 int offset = meet_offset(tp->offset()); | |
| 3487 PTR ptr = meet_ptr(tp->ptr()); | |
| 3488 switch (tp->ptr()) { | |
| 3489 case TopPTR: | |
| 3490 return this; | |
| 3491 case BotPTR: | |
| 3492 case NotNull: | |
| 3493 return TypePtr::make(AnyPtr, ptr, offset); | |
| 3494 case Null: | |
| 3495 if( ptr == Null ) return TypePtr::make(AnyPtr, ptr, offset); | |
| 223 | 3496 // else fall through to AnyNull |
| 3497 case AnyNull: { | |
| 3498 int instance_id = meet_instance_id(InstanceTop); | |
| 3499 return make( ptr, (ptr == Constant ? const_oop() : NULL), | |
| 3500 _ary, _klass, _klass_is_exact, offset, instance_id); | |
| 3501 } | |
| 0 | 3502 default: ShouldNotReachHere(); |
| 3503 } | |
| 3504 } | |
| 3505 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3506 case MetadataPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3507 case KlassPtr: |
| 0 | 3508 case RawPtr: return TypePtr::BOTTOM; |
| 3509 | |
| 3510 case AryPtr: { // Meeting 2 references? | |
| 3511 const TypeAryPtr *tap = t->is_aryptr(); | |
| 3512 int off = meet_offset(tap->offset()); | |
| 3513 const TypeAry *tary = _ary->meet(tap->_ary)->is_ary(); | |
| 3514 PTR ptr = meet_ptr(tap->ptr()); | |
| 223 | 3515 int instance_id = meet_instance_id(tap->instance_id()); |
| 0 | 3516 ciKlass* lazy_klass = NULL; |
| 3517 if (tary->_elem->isa_int()) { | |
| 3518 // Integral array element types have irrelevant lattice relations. | |
| 3519 // It is the klass that determines array layout, not the element type. | |
| 3520 if (_klass == NULL) | |
| 3521 lazy_klass = tap->_klass; | |
| 3522 else if (tap->_klass == NULL || tap->_klass == _klass) { | |
| 3523 lazy_klass = _klass; | |
| 3524 } else { | |
| 3525 // Something like byte[int+] meets char[int+]. | |
| 3526 // This must fall to bottom, not (int[-128..65535])[int+]. | |
| 247 | 3527 instance_id = InstanceBot; |
| 0 | 3528 tary = TypeAry::make(Type::BOTTOM, tary->_size); |
| 3529 } | |
| 2351 | 3530 } else // Non integral arrays. |
| 3531 // Must fall to bottom if exact klasses in upper lattice | |
| 3532 // are not equal or super klass is exact. | |
| 3533 if ( above_centerline(ptr) && klass() != tap->klass() && | |
| 3534 // meet with top[] and bottom[] are processed further down: | |
| 3535 tap ->_klass != NULL && this->_klass != NULL && | |
| 3536 // both are exact and not equal: | |
| 3537 ((tap ->_klass_is_exact && this->_klass_is_exact) || | |
| 3538 // 'tap' is exact and super or unrelated: | |
| 3539 (tap ->_klass_is_exact && !tap->klass()->is_subtype_of(klass())) || | |
| 3540 // 'this' is exact and super or unrelated: | |
| 3541 (this->_klass_is_exact && !klass()->is_subtype_of(tap->klass())))) { | |
| 3542 tary = TypeAry::make(Type::BOTTOM, tary->_size); | |
| 3543 return make( NotNull, NULL, tary, lazy_klass, false, off, InstanceBot ); | |
| 0 | 3544 } |
| 2351 | 3545 |
|
1765
114e6b93e9e1
6980978: assert(mt == t->xmeet(this)) failed: meet not commutative
kvn
parents:
1761
diff
changeset
|
3546 bool xk = false; |
| 0 | 3547 switch (tap->ptr()) { |
| 3548 case AnyNull: | |
| 3549 case TopPTR: | |
| 3550 // Compute new klass on demand, do not use tap->_klass | |
| 3551 xk = (tap->_klass_is_exact | this->_klass_is_exact); | |
| 223 | 3552 return make( ptr, const_oop(), tary, lazy_klass, xk, off, instance_id ); |
| 0 | 3553 case Constant: { |
| 3554 ciObject* o = const_oop(); | |
| 3555 if( _ptr == Constant ) { | |
| 3556 if( tap->const_oop() != NULL && !o->equals(tap->const_oop()) ) { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
3557 xk = (klass() == tap->klass()); |
| 0 | 3558 ptr = NotNull; |
| 3559 o = NULL; | |
| 247 | 3560 instance_id = InstanceBot; |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
3561 } else { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
3562 xk = true; |
| 0 | 3563 } |
| 3564 } else if( above_centerline(_ptr) ) { | |
| 3565 o = tap->const_oop(); | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
3566 xk = true; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
3567 } else { |
|
1765
114e6b93e9e1
6980978: assert(mt == t->xmeet(this)) failed: meet not commutative
kvn
parents:
1761
diff
changeset
|
3568 // Only precise for identical arrays |
|
114e6b93e9e1
6980978: assert(mt == t->xmeet(this)) failed: meet not commutative
kvn
parents:
1761
diff
changeset
|
3569 xk = this->_klass_is_exact && (klass() == tap->klass()); |
| 0 | 3570 } |
|
1765
114e6b93e9e1
6980978: assert(mt == t->xmeet(this)) failed: meet not commutative
kvn
parents:
1761
diff
changeset
|
3571 return TypeAryPtr::make( ptr, o, tary, lazy_klass, xk, off, instance_id ); |
| 0 | 3572 } |
| 3573 case NotNull: | |
| 3574 case BotPTR: | |
| 3575 // Compute new klass on demand, do not use tap->_klass | |
| 3576 if (above_centerline(this->_ptr)) | |
| 3577 xk = tap->_klass_is_exact; | |
| 3578 else if (above_centerline(tap->_ptr)) | |
| 3579 xk = this->_klass_is_exact; | |
| 3580 else xk = (tap->_klass_is_exact & this->_klass_is_exact) && | |
| 3581 (klass() == tap->klass()); // Only precise for identical arrays | |
| 223 | 3582 return TypeAryPtr::make( ptr, NULL, tary, lazy_klass, xk, off, instance_id ); |
| 0 | 3583 default: ShouldNotReachHere(); |
| 3584 } | |
| 3585 } | |
| 3586 | |
| 3587 // All arrays inherit from Object class | |
| 3588 case InstPtr: { | |
| 3589 const TypeInstPtr *tp = t->is_instptr(); | |
| 3590 int offset = meet_offset(tp->offset()); | |
| 3591 PTR ptr = meet_ptr(tp->ptr()); | |
| 223 | 3592 int instance_id = meet_instance_id(tp->instance_id()); |
| 0 | 3593 switch (ptr) { |
| 3594 case TopPTR: | |
| 3595 case AnyNull: // Fall 'down' to dual of object klass | |
| 3596 if( tp->klass()->equals(ciEnv::current()->Object_klass()) ) { | |
| 223 | 3597 return TypeAryPtr::make( ptr, _ary, _klass, _klass_is_exact, offset, instance_id ); |
| 0 | 3598 } else { |
| 3599 // cannot subclass, so the meet has to fall badly below the centerline | |
| 3600 ptr = NotNull; | |
| 223 | 3601 instance_id = InstanceBot; |
| 3602 return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id); | |
| 0 | 3603 } |
| 3604 case Constant: | |
| 3605 case NotNull: | |
| 3606 case BotPTR: // Fall down to object klass | |
| 3607 // LCA is object_klass, but if we subclass from the top we can do better | |
| 3608 if (above_centerline(tp->ptr())) { | |
| 3609 // If 'tp' is above the centerline and it is Object class | |
| 605 | 3610 // then we can subclass in the Java class hierarchy. |
| 0 | 3611 if( tp->klass()->equals(ciEnv::current()->Object_klass()) ) { |
| 3612 // that is, my array type is a subtype of 'tp' klass | |
|
1279
2432acbee618
6930035: C2 type system incorrectly handles case j.l.Object->meet(constant AryPtr)
kvn
parents:
1137
diff
changeset
|
3613 return make( ptr, (ptr == Constant ? const_oop() : NULL), |
|
2432acbee618
6930035: C2 type system incorrectly handles case j.l.Object->meet(constant AryPtr)
kvn
parents:
1137
diff
changeset
|
3614 _ary, _klass, _klass_is_exact, offset, instance_id ); |
| 0 | 3615 } |
| 3616 } | |
| 3617 // The other case cannot happen, since t cannot be a subtype of an array. | |
| 3618 // The meet falls down to Object class below centerline. | |
| 3619 if( ptr == Constant ) | |
| 3620 ptr = NotNull; | |
| 223 | 3621 instance_id = InstanceBot; |
| 3622 return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id); | |
| 0 | 3623 default: typerr(t); |
| 3624 } | |
| 3625 } | |
| 3626 } | |
| 3627 return this; // Lint noise | |
| 3628 } | |
| 3629 | |
| 3630 //------------------------------xdual------------------------------------------ | |
| 3631 // Dual: compute field-by-field dual | |
| 3632 const Type *TypeAryPtr::xdual() const { | |
| 223 | 3633 return new TypeAryPtr( dual_ptr(), _const_oop, _ary->dual()->is_ary(),_klass, _klass_is_exact, dual_offset(), dual_instance_id() ); |
| 0 | 3634 } |
| 3635 | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3636 //----------------------interface_vs_oop--------------------------------------- |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3637 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3638 bool TypeAryPtr::interface_vs_oop(const Type *t) const { |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3639 const TypeAryPtr* t_aryptr = t->isa_aryptr(); |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3640 if (t_aryptr) { |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3641 return _ary->interface_vs_oop(t_aryptr->_ary); |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3642 } |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3643 return false; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3644 } |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3645 #endif |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
3646 |
| 0 | 3647 //------------------------------dump2------------------------------------------ |
| 3648 #ifndef PRODUCT | |
| 3649 void TypeAryPtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 3650 _ary->dump2(d,depth,st); | |
| 3651 switch( _ptr ) { | |
| 3652 case Constant: | |
| 3653 const_oop()->print(st); | |
| 3654 break; | |
| 3655 case BotPTR: | |
| 3656 if (!WizardMode && !Verbose) { | |
| 3657 if( _klass_is_exact ) st->print(":exact"); | |
| 3658 break; | |
| 3659 } | |
| 3660 case TopPTR: | |
| 3661 case AnyNull: | |
| 3662 case NotNull: | |
| 3663 st->print(":%s", ptr_msg[_ptr]); | |
| 3664 if( _klass_is_exact ) st->print(":exact"); | |
| 3665 break; | |
| 3666 } | |
| 3667 | |
|
64
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3668 if( _offset != 0 ) { |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3669 int header_size = objArrayOopDesc::header_size() * wordSize; |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3670 if( _offset == OffsetTop ) st->print("+undefined"); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3671 else if( _offset == OffsetBot ) st->print("+any"); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3672 else if( _offset < header_size ) st->print("+%d", _offset); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3673 else { |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3674 BasicType basic_elem_type = elem()->basic_type(); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3675 int array_base = arrayOopDesc::base_offset_in_bytes(basic_elem_type); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3676 int elem_size = type2aelembytes(basic_elem_type); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3677 st->print("[%d]", (_offset - array_base)/elem_size); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3678 } |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3679 } |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3680 st->print(" *"); |
| 223 | 3681 if (_instance_id == InstanceTop) |
| 3682 st->print(",iid=top"); | |
| 3683 else if (_instance_id != InstanceBot) | |
| 0 | 3684 st->print(",iid=%d",_instance_id); |
| 3685 } | |
| 3686 #endif | |
| 3687 | |
| 3688 bool TypeAryPtr::empty(void) const { | |
| 3689 if (_ary->empty()) return true; | |
| 3690 return TypeOopPtr::empty(); | |
| 3691 } | |
| 3692 | |
| 3693 //------------------------------add_offset------------------------------------- | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
3694 const TypePtr *TypeAryPtr::add_offset( intptr_t offset ) const { |
| 0 | 3695 return make( _ptr, _const_oop, _ary, _klass, _klass_is_exact, xadd_offset(offset), _instance_id ); |
| 3696 } | |
| 3697 | |
| 3698 | |
| 3699 //============================================================================= | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3700 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3701 //------------------------------hash------------------------------------------- |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3702 // Type-specific hashing function. |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3703 int TypeNarrowPtr::hash(void) const { |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
3704 return _ptrtype->hash() + 7; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3705 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3706 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3707 bool TypeNarrowPtr::singleton(void) const { // TRUE if type is a singleton |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3708 return _ptrtype->singleton(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3709 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3710 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3711 bool TypeNarrowPtr::empty(void) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3712 return _ptrtype->empty(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3713 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3714 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3715 intptr_t TypeNarrowPtr::get_con() const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3716 return _ptrtype->get_con(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3717 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3718 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3719 bool TypeNarrowPtr::eq( const Type *t ) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3720 const TypeNarrowPtr* tc = isa_same_narrowptr(t); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3721 if (tc != NULL) { |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
3722 if (_ptrtype->base() != tc->_ptrtype->base()) { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3723 return false; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3724 } |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
3725 return tc->_ptrtype->eq(_ptrtype); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3726 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3727 return false; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3728 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3729 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3730 const Type *TypeNarrowPtr::xdual() const { // Compute dual right now. |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3731 const TypePtr* odual = _ptrtype->dual()->is_ptr(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3732 return make_same_narrowptr(odual); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3733 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3734 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3735 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3736 const Type *TypeNarrowPtr::filter( const Type *kills ) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3737 if (isa_same_narrowptr(kills)) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3738 const Type* ft =_ptrtype->filter(is_same_narrowptr(kills)->_ptrtype); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3739 if (ft->empty()) |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3740 return Type::TOP; // Canonical empty value |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3741 if (ft->isa_ptr()) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3742 return make_hash_same_narrowptr(ft->isa_ptr()); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3743 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3744 return ft; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3745 } else if (kills->isa_ptr()) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3746 const Type* ft = _ptrtype->join(kills); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3747 if (ft->empty()) |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3748 return Type::TOP; // Canonical empty value |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3749 return ft; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3750 } else { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3751 return Type::TOP; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3752 } |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3753 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3754 |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3755 //------------------------------xmeet------------------------------------------ |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3756 // Compute the MEET of two types. It returns a new Type object. |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3757 const Type *TypeNarrowPtr::xmeet( const Type *t ) const { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3758 // Perform a fast test for common case; meeting the same types together. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3759 if( this == t ) return this; // Meeting same type-rep? |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3760 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3761 if (t->base() == base()) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3762 const Type* result = _ptrtype->xmeet(t->make_ptr()); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3763 if (result->isa_ptr()) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3764 return make_hash_same_narrowptr(result->is_ptr()); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3765 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3766 return result; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3767 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3768 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3769 // Current "this->_base" is NarrowKlass or NarrowOop |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3770 switch (t->base()) { // switch on original type |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3771 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3772 case Int: // Mixing ints & oops happens when javac |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3773 case Long: // reuses local variables |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3774 case FloatTop: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3775 case FloatCon: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3776 case FloatBot: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3777 case DoubleTop: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3778 case DoubleCon: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3779 case DoubleBot: |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3780 case AnyPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3781 case RawPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3782 case OopPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3783 case InstPtr: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3784 case AryPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3785 case MetadataPtr: |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3786 case KlassPtr: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3787 case NarrowOop: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3788 case NarrowKlass: |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3789 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3790 case Bottom: // Ye Olde Default |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3791 return Type::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3792 case Top: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3793 return this; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3794 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3795 default: // All else is a mistake |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3796 typerr(t); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3797 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3798 } // End of switch |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3799 |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3800 return this; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3801 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3802 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3803 #ifndef PRODUCT |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3804 void TypeNarrowPtr::dump2( Dict & d, uint depth, outputStream *st ) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3805 _ptrtype->dump2(d, depth, st); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3806 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3807 #endif |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3808 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3809 const TypeNarrowOop *TypeNarrowOop::BOTTOM; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3810 const TypeNarrowOop *TypeNarrowOop::NULL_PTR; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3811 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3812 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3813 const TypeNarrowOop* TypeNarrowOop::make(const TypePtr* type) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3814 return (const TypeNarrowOop*)(new TypeNarrowOop(type))->hashcons(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3815 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3816 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3817 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3818 #ifndef PRODUCT |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3819 void TypeNarrowOop::dump2( Dict & d, uint depth, outputStream *st ) const { |
| 417 | 3820 st->print("narrowoop: "); |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3821 TypeNarrowPtr::dump2(d, depth, st); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3822 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3823 #endif |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3824 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3825 const TypeNarrowKlass *TypeNarrowKlass::NULL_PTR; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3826 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3827 const TypeNarrowKlass* TypeNarrowKlass::make(const TypePtr* type) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3828 return (const TypeNarrowKlass*)(new TypeNarrowKlass(type))->hashcons(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3829 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3830 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3831 #ifndef PRODUCT |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3832 void TypeNarrowKlass::dump2( Dict & d, uint depth, outputStream *st ) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3833 st->print("narrowklass: "); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3834 TypeNarrowPtr::dump2(d, depth, st); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3835 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3836 #endif |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3837 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3838 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3839 //------------------------------eq--------------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3840 // Structural equality check for Type representations |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3841 bool TypeMetadataPtr::eq( const Type *t ) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3842 const TypeMetadataPtr *a = (const TypeMetadataPtr*)t; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3843 ciMetadata* one = metadata(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3844 ciMetadata* two = a->metadata(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3845 if (one == NULL || two == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3846 return (one == two) && TypePtr::eq(t); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3847 } else { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3848 return one->equals(two) && TypePtr::eq(t); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3849 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3850 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3851 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3852 //------------------------------hash------------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3853 // Type-specific hashing function. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3854 int TypeMetadataPtr::hash(void) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3855 return |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3856 (metadata() ? metadata()->hash() : 0) + |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3857 TypePtr::hash(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3858 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3859 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3860 //------------------------------singleton-------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3861 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3862 // constants |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3863 bool TypeMetadataPtr::singleton(void) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3864 // detune optimizer to not generate constant metadta + constant offset as a constant! |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3865 // TopPTR, Null, AnyNull, Constant are all singletons |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3866 return (_offset == 0) && !below_centerline(_ptr); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3867 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3868 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3869 //------------------------------add_offset------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3870 const TypePtr *TypeMetadataPtr::add_offset( intptr_t offset ) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3871 return make( _ptr, _metadata, xadd_offset(offset)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3872 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3873 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3874 //-----------------------------filter------------------------------------------ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3875 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3876 const Type *TypeMetadataPtr::filter( const Type *kills ) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3877 const TypeMetadataPtr* ft = join(kills)->isa_metadataptr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3878 if (ft == NULL || ft->empty()) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3879 return Type::TOP; // Canonical empty value |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3880 return ft; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3881 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3882 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3883 //------------------------------get_con---------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3884 intptr_t TypeMetadataPtr::get_con() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3885 assert( _ptr == Null || _ptr == Constant, "" ); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3886 assert( _offset >= 0, "" ); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3887 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3888 if (_offset != 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3889 // After being ported to the compiler interface, the compiler no longer |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3890 // directly manipulates the addresses of oops. Rather, it only has a pointer |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3891 // to a handle at compile time. This handle is embedded in the generated |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3892 // code and dereferenced at the time the nmethod is made. Until that time, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3893 // it is not reasonable to do arithmetic with the addresses of oops (we don't |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3894 // have access to the addresses!). This does not seem to currently happen, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3895 // but this assertion here is to help prevent its occurence. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3896 tty->print_cr("Found oop constant with non-zero offset"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3897 ShouldNotReachHere(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3898 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3899 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3900 return (intptr_t)metadata()->constant_encoding(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3901 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3902 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3903 //------------------------------cast_to_ptr_type------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3904 const Type *TypeMetadataPtr::cast_to_ptr_type(PTR ptr) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3905 if( ptr == _ptr ) return this; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3906 return make(ptr, metadata(), _offset); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3907 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3908 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3909 //------------------------------meet------------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3910 // Compute the MEET of two types. It returns a new Type object. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3911 const Type *TypeMetadataPtr::xmeet( const Type *t ) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3912 // Perform a fast test for common case; meeting the same types together. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3913 if( this == t ) return this; // Meeting same type-rep? |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3914 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3915 // Current "this->_base" is OopPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3916 switch (t->base()) { // switch on original type |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3917 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3918 case Int: // Mixing ints & oops happens when javac |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3919 case Long: // reuses local variables |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3920 case FloatTop: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3921 case FloatCon: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3922 case FloatBot: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3923 case DoubleTop: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3924 case DoubleCon: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3925 case DoubleBot: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3926 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
3927 case NarrowKlass: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3928 case Bottom: // Ye Olde Default |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3929 return Type::BOTTOM; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3930 case Top: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3931 return this; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3932 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3933 default: // All else is a mistake |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3934 typerr(t); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3935 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3936 case AnyPtr: { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3937 // Found an AnyPtr type vs self-OopPtr type |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3938 const TypePtr *tp = t->is_ptr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3939 int offset = meet_offset(tp->offset()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3940 PTR ptr = meet_ptr(tp->ptr()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3941 switch (tp->ptr()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3942 case Null: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3943 if (ptr == Null) return TypePtr::make(AnyPtr, ptr, offset); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3944 // else fall through: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3945 case TopPTR: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3946 case AnyNull: { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3947 return make(ptr, NULL, offset); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3948 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3949 case BotPTR: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3950 case NotNull: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3951 return TypePtr::make(AnyPtr, ptr, offset); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3952 default: typerr(t); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3953 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3954 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3955 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3956 case RawPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3957 case KlassPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3958 case OopPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3959 case InstPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3960 case AryPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3961 return TypePtr::BOTTOM; // Oop meet raw is not well defined |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3962 |
| 6728 | 3963 case MetadataPtr: { |
| 3964 const TypeMetadataPtr *tp = t->is_metadataptr(); | |
| 3965 int offset = meet_offset(tp->offset()); | |
| 3966 PTR tptr = tp->ptr(); | |
| 3967 PTR ptr = meet_ptr(tptr); | |
| 3968 ciMetadata* md = (tptr == TopPTR) ? metadata() : tp->metadata(); | |
| 3969 if (tptr == TopPTR || _ptr == TopPTR || | |
| 3970 metadata()->equals(tp->metadata())) { | |
| 3971 return make(ptr, md, offset); | |
| 3972 } | |
| 3973 // metadata is different | |
| 3974 if( ptr == Constant ) { // Cannot be equal constants, so... | |
| 3975 if( tptr == Constant && _ptr != Constant) return t; | |
| 3976 if( _ptr == Constant && tptr != Constant) return this; | |
| 3977 ptr = NotNull; // Fall down in lattice | |
| 3978 } | |
| 3979 return make(ptr, NULL, offset); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3980 break; |
| 6728 | 3981 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3982 } // End of switch |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3983 return this; // Return the double constant |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3984 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3985 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3986 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3987 //------------------------------xdual------------------------------------------ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3988 // Dual of a pure metadata pointer. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3989 const Type *TypeMetadataPtr::xdual() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3990 return new TypeMetadataPtr(dual_ptr(), metadata(), dual_offset()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3991 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3992 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3993 //------------------------------dump2------------------------------------------ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3994 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3995 void TypeMetadataPtr::dump2( Dict &d, uint depth, outputStream *st ) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3996 st->print("metadataptr:%s", ptr_msg[_ptr]); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3997 if( metadata() ) st->print(INTPTR_FORMAT, metadata()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3998 switch( _offset ) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
3999 case OffsetTop: st->print("+top"); break; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4000 case OffsetBot: st->print("+any"); break; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4001 case 0: break; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4002 default: st->print("+%d",_offset); break; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4003 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4004 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4005 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4006 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4007 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4008 //============================================================================= |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4009 // Convenience common pre-built type. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4010 const TypeMetadataPtr *TypeMetadataPtr::BOTTOM; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4011 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4012 TypeMetadataPtr::TypeMetadataPtr(PTR ptr, ciMetadata* metadata, int offset): |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4013 TypePtr(MetadataPtr, ptr, offset), _metadata(metadata) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4014 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4015 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4016 const TypeMetadataPtr* TypeMetadataPtr::make(ciMethod* m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4017 return make(Constant, m, 0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4018 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4019 const TypeMetadataPtr* TypeMetadataPtr::make(ciMethodData* m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4020 return make(Constant, m, 0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4021 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4022 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4023 //------------------------------make------------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4024 // Create a meta data constant |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4025 const TypeMetadataPtr *TypeMetadataPtr::make(PTR ptr, ciMetadata* m, int offset) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4026 assert(m == NULL || !m->is_klass(), "wrong type"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4027 return (TypeMetadataPtr*)(new TypeMetadataPtr(ptr, m, offset))->hashcons(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4028 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4029 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4030 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4031 //============================================================================= |
| 0 | 4032 // Convenience common pre-built types. |
| 4033 | |
| 4034 // Not-null object klass or below | |
| 4035 const TypeKlassPtr *TypeKlassPtr::OBJECT; | |
| 4036 const TypeKlassPtr *TypeKlassPtr::OBJECT_OR_NULL; | |
| 4037 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4038 //------------------------------TypeKlassPtr----------------------------------- |
| 0 | 4039 TypeKlassPtr::TypeKlassPtr( PTR ptr, ciKlass* klass, int offset ) |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4040 : TypePtr(KlassPtr, ptr, offset), _klass(klass), _klass_is_exact(ptr == Constant) { |
| 0 | 4041 } |
| 4042 | |
| 4043 //------------------------------make------------------------------------------- | |
| 4044 // ptr to klass 'k', if Constant, or possibly to a sub-klass if not a Constant | |
| 4045 const TypeKlassPtr *TypeKlassPtr::make( PTR ptr, ciKlass* k, int offset ) { | |
| 4046 assert( k != NULL, "Expect a non-NULL klass"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4047 assert(k->is_instance_klass() || k->is_array_klass(), "Incorrect type of klass oop"); |
| 0 | 4048 TypeKlassPtr *r = |
| 4049 (TypeKlassPtr*)(new TypeKlassPtr(ptr, k, offset))->hashcons(); | |
| 4050 | |
| 4051 return r; | |
| 4052 } | |
| 4053 | |
| 4054 //------------------------------eq--------------------------------------------- | |
| 4055 // Structural equality check for Type representations | |
| 4056 bool TypeKlassPtr::eq( const Type *t ) const { | |
| 4057 const TypeKlassPtr *p = t->is_klassptr(); | |
| 4058 return | |
| 4059 klass()->equals(p->klass()) && | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4060 TypePtr::eq(p); |
| 0 | 4061 } |
| 4062 | |
| 4063 //------------------------------hash------------------------------------------- | |
| 4064 // Type-specific hashing function. | |
| 4065 int TypeKlassPtr::hash(void) const { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4066 return klass()->hash() + TypePtr::hash(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4067 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4068 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4069 //------------------------------singleton-------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4070 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4071 // constants |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4072 bool TypeKlassPtr::singleton(void) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4073 // detune optimizer to not generate constant klass + constant offset as a constant! |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4074 // TopPTR, Null, AnyNull, Constant are all singletons |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4075 return (_offset == 0) && !below_centerline(_ptr); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4076 } |
| 0 | 4077 |
| 1761 | 4078 //----------------------compute_klass------------------------------------------ |
| 4079 // Compute the defining klass for this class | |
| 4080 ciKlass* TypeAryPtr::compute_klass(DEBUG_ONLY(bool verify)) const { | |
| 4081 // Compute _klass based on element type. | |
| 0 | 4082 ciKlass* k_ary = NULL; |
| 4083 const TypeInstPtr *tinst; | |
| 4084 const TypeAryPtr *tary; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4085 const Type* el = elem(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4086 if (el->isa_narrowoop()) { |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
4087 el = el->make_ptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4088 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4089 |
| 0 | 4090 // Get element klass |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4091 if ((tinst = el->isa_instptr()) != NULL) { |
| 0 | 4092 // Compute array klass from element klass |
| 4093 k_ary = ciObjArrayKlass::make(tinst->klass()); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4094 } else if ((tary = el->isa_aryptr()) != NULL) { |
| 0 | 4095 // Compute array klass from element klass |
| 4096 ciKlass* k_elem = tary->klass(); | |
| 4097 // If element type is something like bottom[], k_elem will be null. | |
| 4098 if (k_elem != NULL) | |
| 4099 k_ary = ciObjArrayKlass::make(k_elem); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4100 } else if ((el->base() == Type::Top) || |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4101 (el->base() == Type::Bottom)) { |
| 0 | 4102 // element type of Bottom occurs from meet of basic type |
| 4103 // and object; Top occurs when doing join on Bottom. | |
| 4104 // Leave k_ary at NULL. | |
| 4105 } else { | |
| 4106 // Cannot compute array klass directly from basic type, | |
| 4107 // since subtypes of TypeInt all have basic type T_INT. | |
| 1761 | 4108 #ifdef ASSERT |
| 4109 if (verify && el->isa_int()) { | |
| 4110 // Check simple cases when verifying klass. | |
| 4111 BasicType bt = T_ILLEGAL; | |
| 4112 if (el == TypeInt::BYTE) { | |
| 4113 bt = T_BYTE; | |
| 4114 } else if (el == TypeInt::SHORT) { | |
| 4115 bt = T_SHORT; | |
| 4116 } else if (el == TypeInt::CHAR) { | |
| 4117 bt = T_CHAR; | |
| 4118 } else if (el == TypeInt::INT) { | |
| 4119 bt = T_INT; | |
| 4120 } else { | |
| 4121 return _klass; // just return specified klass | |
| 4122 } | |
| 4123 return ciTypeArrayKlass::make(bt); | |
| 4124 } | |
| 4125 #endif | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4126 assert(!el->isa_int(), |
| 0 | 4127 "integral arrays must be pre-equipped with a class"); |
| 4128 // Compute array klass directly from basic type | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
4129 k_ary = ciTypeArrayKlass::make(el->basic_type()); |
| 0 | 4130 } |
| 1761 | 4131 return k_ary; |
| 4132 } | |
| 4133 | |
| 4134 //------------------------------klass------------------------------------------ | |
| 4135 // Return the defining klass for this class | |
| 4136 ciKlass* TypeAryPtr::klass() const { | |
| 4137 if( _klass ) return _klass; // Return cached value, if possible | |
| 4138 | |
| 4139 // Oops, need to compute _klass and cache it | |
| 4140 ciKlass* k_ary = compute_klass(); | |
| 0 | 4141 |
|
2354
83f08886981c
7026631: field _klass is incorrectly set for dual type of TypeAryPtr::OOPS
kvn
parents:
2351
diff
changeset
|
4142 if( this != TypeAryPtr::OOPS && this->dual() != TypeAryPtr::OOPS ) { |
| 0 | 4143 // The _klass field acts as a cache of the underlying |
| 4144 // ciKlass for this array type. In order to set the field, | |
| 4145 // we need to cast away const-ness. | |
| 4146 // | |
| 4147 // IMPORTANT NOTE: we *never* set the _klass field for the | |
| 4148 // type TypeAryPtr::OOPS. This Type is shared between all | |
| 4149 // active compilations. However, the ciKlass which represents | |
| 4150 // this Type is *not* shared between compilations, so caching | |
| 4151 // this value would result in fetching a dangling pointer. | |
| 4152 // | |
| 4153 // Recomputing the underlying ciKlass for each request is | |
| 4154 // a bit less efficient than caching, but calls to | |
| 4155 // TypeAryPtr::OOPS->klass() are not common enough to matter. | |
| 4156 ((TypeAryPtr*)this)->_klass = k_ary; | |
| 163 | 4157 if (UseCompressedOops && k_ary != NULL && k_ary->is_obj_array_klass() && |
| 4158 _offset != 0 && _offset != arrayOopDesc::length_offset_in_bytes()) { | |
| 4159 ((TypeAryPtr*)this)->_is_ptr_to_narrowoop = true; | |
| 4160 } | |
| 4161 } | |
| 0 | 4162 return k_ary; |
| 4163 } | |
| 4164 | |
| 4165 | |
| 4166 //------------------------------add_offset------------------------------------- | |
| 4167 // Access internals of klass object | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
4168 const TypePtr *TypeKlassPtr::add_offset( intptr_t offset ) const { |
| 0 | 4169 return make( _ptr, klass(), xadd_offset(offset) ); |
| 4170 } | |
| 4171 | |
| 4172 //------------------------------cast_to_ptr_type------------------------------- | |
| 4173 const Type *TypeKlassPtr::cast_to_ptr_type(PTR ptr) const { | |
|
557
465813e0303a
6794939: assert(_base == OopPtr,"subclass must override cast_to_ptr_type")
kvn
parents:
555
diff
changeset
|
4174 assert(_base == KlassPtr, "subclass must override cast_to_ptr_type"); |
| 0 | 4175 if( ptr == _ptr ) return this; |
| 4176 return make(ptr, _klass, _offset); | |
| 4177 } | |
| 4178 | |
| 4179 | |
| 4180 //-----------------------------cast_to_exactness------------------------------- | |
| 4181 const Type *TypeKlassPtr::cast_to_exactness(bool klass_is_exact) const { | |
| 4182 if( klass_is_exact == _klass_is_exact ) return this; | |
| 4183 if (!UseExactTypes) return this; | |
| 4184 return make(klass_is_exact ? Constant : NotNull, _klass, _offset); | |
| 4185 } | |
| 4186 | |
| 4187 | |
| 4188 //-----------------------------as_instance_type-------------------------------- | |
| 4189 // Corresponding type for an instance of the given class. | |
| 4190 // It will be NotNull, and exact if and only if the klass type is exact. | |
| 4191 const TypeOopPtr* TypeKlassPtr::as_instance_type() const { | |
| 4192 ciKlass* k = klass(); | |
| 4193 bool xk = klass_is_exact(); | |
| 4194 //return TypeInstPtr::make(TypePtr::NotNull, k, xk, NULL, 0); | |
| 4195 const TypeOopPtr* toop = TypeOopPtr::make_from_klass_raw(k); | |
|
8760
96ef09c26978
8009166: [parfait] Null pointer deference in hotspot/src/share/vm/opto/type.cpp
morris
parents:
7623
diff
changeset
|
4196 guarantee(toop != NULL, "need type for given klass"); |
| 0 | 4197 toop = toop->cast_to_ptr_type(TypePtr::NotNull)->is_oopptr(); |
| 4198 return toop->cast_to_exactness(xk)->is_oopptr(); | |
| 4199 } | |
| 4200 | |
| 4201 | |
| 4202 //------------------------------xmeet------------------------------------------ | |
| 4203 // Compute the MEET of two types, return a new Type object. | |
| 4204 const Type *TypeKlassPtr::xmeet( const Type *t ) const { | |
| 4205 // Perform a fast test for common case; meeting the same types together. | |
| 4206 if( this == t ) return this; // Meeting same type-rep? | |
| 4207 | |
| 4208 // Current "this->_base" is Pointer | |
| 4209 switch (t->base()) { // switch on original type | |
| 4210 | |
| 4211 case Int: // Mixing ints & oops happens when javac | |
| 4212 case Long: // reuses local variables | |
| 4213 case FloatTop: | |
| 4214 case FloatCon: | |
| 4215 case FloatBot: | |
| 4216 case DoubleTop: | |
| 4217 case DoubleCon: | |
| 4218 case DoubleBot: | |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
4219 case NarrowOop: |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6735
diff
changeset
|
4220 case NarrowKlass: |
| 0 | 4221 case Bottom: // Ye Olde Default |
| 4222 return Type::BOTTOM; | |
| 4223 case Top: | |
| 4224 return this; | |
| 4225 | |
| 4226 default: // All else is a mistake | |
| 4227 typerr(t); | |
| 4228 | |
| 4229 case AnyPtr: { // Meeting to AnyPtrs | |
| 4230 // Found an AnyPtr type vs self-KlassPtr type | |
| 4231 const TypePtr *tp = t->is_ptr(); | |
| 4232 int offset = meet_offset(tp->offset()); | |
| 4233 PTR ptr = meet_ptr(tp->ptr()); | |
| 4234 switch (tp->ptr()) { | |
| 4235 case TopPTR: | |
| 4236 return this; | |
| 4237 case Null: | |
| 4238 if( ptr == Null ) return TypePtr::make( AnyPtr, ptr, offset ); | |
| 4239 case AnyNull: | |
| 4240 return make( ptr, klass(), offset ); | |
| 4241 case BotPTR: | |
| 4242 case NotNull: | |
| 4243 return TypePtr::make(AnyPtr, ptr, offset); | |
| 4244 default: typerr(t); | |
| 4245 } | |
| 4246 } | |
| 4247 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4248 case RawPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4249 case MetadataPtr: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4250 case OopPtr: |
| 0 | 4251 case AryPtr: // Meet with AryPtr |
| 4252 case InstPtr: // Meet with InstPtr | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4253 return TypePtr::BOTTOM; |
| 0 | 4254 |
| 4255 // | |
| 4256 // A-top } | |
| 4257 // / | \ } Tops | |
| 4258 // B-top A-any C-top } | |
| 4259 // | / | \ | } Any-nulls | |
| 4260 // B-any | C-any } | |
| 4261 // | | | | |
| 4262 // B-con A-con C-con } constants; not comparable across classes | |
| 4263 // | | | | |
| 4264 // B-not | C-not } | |
| 4265 // | \ | / | } not-nulls | |
| 4266 // B-bot A-not C-bot } | |
| 4267 // \ | / } Bottoms | |
| 4268 // A-bot } | |
| 4269 // | |
| 4270 | |
| 4271 case KlassPtr: { // Meet two KlassPtr types | |
| 4272 const TypeKlassPtr *tkls = t->is_klassptr(); | |
| 4273 int off = meet_offset(tkls->offset()); | |
| 4274 PTR ptr = meet_ptr(tkls->ptr()); | |
| 4275 | |
| 4276 // Check for easy case; klasses are equal (and perhaps not loaded!) | |
| 4277 // If we have constants, then we created oops so classes are loaded | |
| 4278 // and we can handle the constants further down. This case handles | |
| 4279 // not-loaded classes | |
| 4280 if( ptr != Constant && tkls->klass()->equals(klass()) ) { | |
| 4281 return make( ptr, klass(), off ); | |
| 4282 } | |
| 4283 | |
| 4284 // Classes require inspection in the Java klass hierarchy. Must be loaded. | |
| 4285 ciKlass* tkls_klass = tkls->klass(); | |
| 4286 ciKlass* this_klass = this->klass(); | |
| 4287 assert( tkls_klass->is_loaded(), "This class should have been loaded."); | |
| 4288 assert( this_klass->is_loaded(), "This class should have been loaded."); | |
| 4289 | |
| 4290 // If 'this' type is above the centerline and is a superclass of the | |
| 4291 // other, we can treat 'this' as having the same type as the other. | |
| 4292 if ((above_centerline(this->ptr())) && | |
| 4293 tkls_klass->is_subtype_of(this_klass)) { | |
| 4294 this_klass = tkls_klass; | |
| 4295 } | |
| 4296 // If 'tinst' type is above the centerline and is a superclass of the | |
| 4297 // other, we can treat 'tinst' as having the same type as the other. | |
| 4298 if ((above_centerline(tkls->ptr())) && | |
| 4299 this_klass->is_subtype_of(tkls_klass)) { | |
| 4300 tkls_klass = this_klass; | |
| 4301 } | |
| 4302 | |
| 4303 // Check for classes now being equal | |
| 4304 if (tkls_klass->equals(this_klass)) { | |
| 4305 // If the klasses are equal, the constants may still differ. Fall to | |
| 4306 // NotNull if they do (neither constant is NULL; that is a special case | |
| 4307 // handled elsewhere). | |
| 4308 if( ptr == Constant ) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4309 if (this->_ptr == Constant && tkls->_ptr == Constant && |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4310 this->klass()->equals(tkls->klass())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4311 else if (above_centerline(this->ptr())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4312 else if (above_centerline(tkls->ptr())); |
| 0 | 4313 else |
| 4314 ptr = NotNull; | |
| 4315 } | |
| 4316 return make( ptr, this_klass, off ); | |
| 4317 } // Else classes are not equal | |
| 4318 | |
| 4319 // Since klasses are different, we require the LCA in the Java | |
| 4320 // class hierarchy - which means we have to fall to at least NotNull. | |
| 4321 if( ptr == TopPTR || ptr == AnyNull || ptr == Constant ) | |
| 4322 ptr = NotNull; | |
| 4323 // Now we find the LCA of Java classes | |
| 4324 ciKlass* k = this_klass->least_common_ancestor(tkls_klass); | |
| 4325 return make( ptr, k, off ); | |
| 4326 } // End of case KlassPtr | |
| 4327 | |
| 4328 } // End of switch | |
| 4329 return this; // Return the double constant | |
| 4330 } | |
| 4331 | |
| 4332 //------------------------------xdual------------------------------------------ | |
| 4333 // Dual: compute field-by-field dual | |
| 4334 const Type *TypeKlassPtr::xdual() const { | |
| 4335 return new TypeKlassPtr( dual_ptr(), klass(), dual_offset() ); | |
| 4336 } | |
| 4337 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4338 //------------------------------get_con---------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4339 intptr_t TypeKlassPtr::get_con() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4340 assert( _ptr == Null || _ptr == Constant, "" ); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4341 assert( _offset >= 0, "" ); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4342 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4343 if (_offset != 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4344 // After being ported to the compiler interface, the compiler no longer |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4345 // directly manipulates the addresses of oops. Rather, it only has a pointer |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4346 // to a handle at compile time. This handle is embedded in the generated |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4347 // code and dereferenced at the time the nmethod is made. Until that time, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4348 // it is not reasonable to do arithmetic with the addresses of oops (we don't |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4349 // have access to the addresses!). This does not seem to currently happen, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4350 // but this assertion here is to help prevent its occurence. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4351 tty->print_cr("Found oop constant with non-zero offset"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4352 ShouldNotReachHere(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4353 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4354 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4355 return (intptr_t)klass()->constant_encoding(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
4356 } |
| 0 | 4357 //------------------------------dump2------------------------------------------ |
| 4358 // Dump Klass Type | |
| 4359 #ifndef PRODUCT | |
| 4360 void TypeKlassPtr::dump2( Dict & d, uint depth, outputStream *st ) const { | |
| 4361 switch( _ptr ) { | |
| 4362 case Constant: | |
| 4363 st->print("precise "); | |
| 4364 case NotNull: | |
| 4365 { | |
| 4366 const char *name = klass()->name()->as_utf8(); | |
| 4367 if( name ) { | |
| 4368 st->print("klass %s: " INTPTR_FORMAT, name, klass()); | |
| 4369 } else { | |
| 4370 ShouldNotReachHere(); | |
| 4371 } | |
| 4372 } | |
| 4373 case BotPTR: | |
| 4374 if( !WizardMode && !Verbose && !_klass_is_exact ) break; | |
| 4375 case TopPTR: | |
| 4376 case AnyNull: | |
| 4377 st->print(":%s", ptr_msg[_ptr]); | |
| 4378 if( _klass_is_exact ) st->print(":exact"); | |
| 4379 break; | |
| 4380 } | |
| 4381 | |
| 4382 if( _offset ) { // Dump offset, if any | |
| 4383 if( _offset == OffsetBot ) { st->print("+any"); } | |
| 4384 else if( _offset == OffsetTop ) { st->print("+unknown"); } | |
| 4385 else { st->print("+%d", _offset); } | |
| 4386 } | |
| 4387 | |
| 4388 st->print(" *"); | |
| 4389 } | |
| 4390 #endif | |
| 4391 | |
| 4392 | |
| 4393 | |
| 4394 //============================================================================= | |
| 4395 // Convenience common pre-built types. | |
| 4396 | |
| 4397 //------------------------------make------------------------------------------- | |
| 4398 const TypeFunc *TypeFunc::make( const TypeTuple *domain, const TypeTuple *range ) { | |
| 4399 return (TypeFunc*)(new TypeFunc(domain,range))->hashcons(); | |
| 4400 } | |
| 4401 | |
| 4402 //------------------------------make------------------------------------------- | |
| 4403 const TypeFunc *TypeFunc::make(ciMethod* method) { | |
| 4404 Compile* C = Compile::current(); | |
| 4405 const TypeFunc* tf = C->last_tf(method); // check cache | |
| 4406 if (tf != NULL) return tf; // The hit rate here is almost 50%. | |
| 4407 const TypeTuple *domain; | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1009
diff
changeset
|
4408 if (method->is_static()) { |
| 0 | 4409 domain = TypeTuple::make_domain(NULL, method->signature()); |
| 4410 } else { | |
| 4411 domain = TypeTuple::make_domain(method->holder(), method->signature()); | |
| 4412 } | |
| 4413 const TypeTuple *range = TypeTuple::make_range(method->signature()); | |
| 4414 tf = TypeFunc::make(domain, range); | |
| 4415 C->set_last_tf(method, tf); // fill cache | |
| 4416 return tf; | |
| 4417 } | |
| 4418 | |
| 4419 //------------------------------meet------------------------------------------- | |
| 4420 // Compute the MEET of two types. It returns a new Type object. | |
| 4421 const Type *TypeFunc::xmeet( const Type *t ) const { | |
| 4422 // Perform a fast test for common case; meeting the same types together. | |
| 4423 if( this == t ) return this; // Meeting same type-rep? | |
| 4424 | |
| 4425 // Current "this->_base" is Func | |
| 4426 switch (t->base()) { // switch on original type | |
| 4427 | |
| 4428 case Bottom: // Ye Olde Default | |
| 4429 return t; | |
| 4430 | |
| 4431 default: // All else is a mistake | |
| 4432 typerr(t); | |
| 4433 | |
| 4434 case Top: | |
| 4435 break; | |
| 4436 } | |
| 4437 return this; // Return the double constant | |
| 4438 } | |
| 4439 | |
| 4440 //------------------------------xdual------------------------------------------ | |
| 4441 // Dual: compute field-by-field dual | |
| 4442 const Type *TypeFunc::xdual() const { | |
| 4443 return this; | |
| 4444 } | |
| 4445 | |
| 4446 //------------------------------eq--------------------------------------------- | |
| 4447 // Structural equality check for Type representations | |
| 4448 bool TypeFunc::eq( const Type *t ) const { | |
| 4449 const TypeFunc *a = (const TypeFunc*)t; | |
| 4450 return _domain == a->_domain && | |
| 4451 _range == a->_range; | |
| 4452 } | |
| 4453 | |
| 4454 //------------------------------hash------------------------------------------- | |
| 4455 // Type-specific hashing function. | |
| 4456 int TypeFunc::hash(void) const { | |
| 4457 return (intptr_t)_domain + (intptr_t)_range; | |
| 4458 } | |
| 4459 | |
| 4460 //------------------------------dump2------------------------------------------ | |
| 4461 // Dump Function Type | |
| 4462 #ifndef PRODUCT | |
| 4463 void TypeFunc::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 4464 if( _range->_cnt <= Parms ) | |
| 4465 st->print("void"); | |
| 4466 else { | |
| 4467 uint i; | |
| 4468 for (i = Parms; i < _range->_cnt-1; i++) { | |
| 4469 _range->field_at(i)->dump2(d,depth,st); | |
| 4470 st->print("/"); | |
| 4471 } | |
| 4472 _range->field_at(i)->dump2(d,depth,st); | |
| 4473 } | |
| 4474 st->print(" "); | |
| 4475 st->print("( "); | |
| 4476 if( !depth || d[this] ) { // Check for recursive dump | |
| 4477 st->print("...)"); | |
| 4478 return; | |
| 4479 } | |
| 4480 d.Insert((void*)this,(void*)this); // Stop recursion | |
| 4481 if (Parms < _domain->_cnt) | |
| 4482 _domain->field_at(Parms)->dump2(d,depth-1,st); | |
| 4483 for (uint i = Parms+1; i < _domain->_cnt; i++) { | |
| 4484 st->print(", "); | |
| 4485 _domain->field_at(i)->dump2(d,depth-1,st); | |
| 4486 } | |
| 4487 st->print(" )"); | |
| 4488 } | |
| 4489 #endif | |
| 4490 | |
| 4491 //------------------------------singleton-------------------------------------- | |
| 4492 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 4493 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 4494 // or a single symbol. | |
| 4495 bool TypeFunc::singleton(void) const { | |
| 4496 return false; // Never a singleton | |
| 4497 } | |
| 4498 | |
| 4499 bool TypeFunc::empty(void) const { | |
| 4500 return false; // Never empty | |
| 4501 } | |
| 4502 | |
| 4503 | |
| 4504 BasicType TypeFunc::return_type() const{ | |
| 4505 if (range()->cnt() == TypeFunc::Parms) { | |
| 4506 return T_VOID; | |
| 4507 } | |
| 4508 return range()->field_at(TypeFunc::Parms)->basic_type(); | |
| 4509 } |