Mercurial > hg > graal-compiler
annotate src/share/vm/opto/type.hpp @ 10185:d50cc62e94ff
8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t
Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime.
Reviewed-by: twisti, johnc
Contributed-by: Martin Doerr <martin.doerr@sap.com>
| author | johnc |
|---|---|
| date | Wed, 24 Apr 2013 14:48:43 -0700 |
| parents | beebba0acc11 |
| children | 6f3fd5150b67 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
2 * Copyright (c) 1997, 2012, 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:
1080
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1080
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:
1080
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OPTO_TYPE_HPP |
| 26 #define SHARE_VM_OPTO_TYPE_HPP | |
| 27 | |
| 28 #include "libadt/port.hpp" | |
| 29 #include "opto/adlcVMDeps.hpp" | |
| 30 #include "runtime/handles.hpp" | |
| 31 | |
| 0 | 32 // Portions of code courtesy of Clifford Click |
| 33 | |
| 34 // Optimization - Graph Style | |
| 35 | |
| 36 | |
| 37 // This class defines a Type lattice. The lattice is used in the constant | |
| 38 // propagation algorithms, and for some type-checking of the iloc code. | |
| 39 // Basic types include RSD's (lower bound, upper bound, stride for integers), | |
| 40 // float & double precision constants, sets of data-labels and code-labels. | |
| 41 // The complete lattice is described below. Subtypes have no relationship to | |
| 42 // up or down in the lattice; that is entirely determined by the behavior of | |
| 43 // the MEET/JOIN functions. | |
| 44 | |
| 45 class Dict; | |
| 46 class Type; | |
| 47 class TypeD; | |
| 48 class TypeF; | |
| 49 class TypeInt; | |
| 50 class TypeLong; | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
51 class TypeNarrowPtr; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
52 class TypeNarrowOop; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
53 class TypeNarrowKlass; |
| 0 | 54 class TypeAry; |
| 55 class TypeTuple; | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
56 class TypeVect; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
57 class TypeVectS; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
58 class TypeVectD; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
59 class TypeVectX; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
60 class TypeVectY; |
| 0 | 61 class TypePtr; |
| 62 class TypeRawPtr; | |
| 63 class TypeOopPtr; | |
| 64 class TypeInstPtr; | |
| 65 class TypeAryPtr; | |
| 66 class TypeKlassPtr; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
67 class TypeMetadataPtr; |
| 0 | 68 |
| 69 //------------------------------Type------------------------------------------- | |
| 70 // Basic Type object, represents a set of primitive Values. | |
| 71 // Types are hash-cons'd into a private class dictionary, so only one of each | |
| 72 // different kind of Type exists. Types are never modified after creation, so | |
| 73 // all their interesting fields are constant. | |
| 74 class Type { | |
| 3939 | 75 friend class VMStructs; |
| 76 | |
| 0 | 77 public: |
| 78 enum TYPES { | |
| 79 Bad=0, // Type check | |
| 80 Control, // Control of code (not in lattice) | |
| 81 Top, // Top of the lattice | |
| 82 Int, // Integer range (lo-hi) | |
| 83 Long, // Long integer range (lo-hi) | |
| 84 Half, // Placeholder half of doubleword | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
85 NarrowOop, // Compressed oop pointer |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
86 NarrowKlass, // Compressed klass pointer |
| 0 | 87 |
| 88 Tuple, // Method signature or object layout | |
| 89 Array, // Array types | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
90 VectorS, // 32bit Vector types |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
91 VectorD, // 64bit Vector types |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
92 VectorX, // 128bit Vector types |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
93 VectorY, // 256bit Vector types |
| 0 | 94 |
| 95 AnyPtr, // Any old raw, klass, inst, or array pointer | |
| 96 RawPtr, // Raw (non-oop) pointers | |
| 97 OopPtr, // Any and all Java heap entities | |
| 98 InstPtr, // Instance pointers (non-array objects) | |
| 99 AryPtr, // Array pointers | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
100 // (Ptr order matters: See is_ptr, isa_ptr, is_oopptr, isa_oopptr.) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
101 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
102 MetadataPtr, // Generic metadata |
| 0 | 103 KlassPtr, // Klass pointers |
| 104 | |
| 105 Function, // Function signature | |
| 106 Abio, // Abstract I/O | |
| 107 Return_Address, // Subroutine return address | |
| 108 Memory, // Abstract store | |
| 109 FloatTop, // No float value | |
| 110 FloatCon, // Floating point constant | |
| 111 FloatBot, // Any float value | |
| 112 DoubleTop, // No double value | |
| 113 DoubleCon, // Double precision constant | |
| 114 DoubleBot, // Any double value | |
| 115 Bottom, // Bottom of lattice | |
| 116 lastype // Bogus ending type (not in lattice) | |
| 117 }; | |
| 118 | |
| 119 // Signal values for offsets from a base pointer | |
| 120 enum OFFSET_SIGNALS { | |
| 121 OffsetTop = -2000000000, // undefined offset | |
| 122 OffsetBot = -2000000001 // any possible offset | |
| 123 }; | |
| 124 | |
| 125 // Min and max WIDEN values. | |
| 126 enum WIDEN { | |
| 127 WidenMin = 0, | |
| 128 WidenMax = 3 | |
| 129 }; | |
| 130 | |
| 131 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
132 typedef struct { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
133 const TYPES dual_type; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
134 const BasicType basic_type; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
135 const char* msg; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
136 const bool isa_oop; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
137 const int ideal_reg; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
138 const relocInfo::relocType reloc; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
139 } TypeInfo; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
140 |
| 0 | 141 // Dictionary of types shared among compilations. |
| 142 static Dict* _shared_type_dict; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
143 static TypeInfo _type_info[]; |
| 0 | 144 |
| 145 static int uhash( const Type *const t ); | |
| 146 // Structural equality check. Assumes that cmp() has already compared | |
| 147 // the _base types and thus knows it can cast 't' appropriately. | |
| 148 virtual bool eq( const Type *t ) const; | |
| 149 | |
| 150 // Top-level hash-table of types | |
| 151 static Dict *type_dict() { | |
| 152 return Compile::current()->type_dict(); | |
| 153 } | |
| 154 | |
| 155 // DUAL operation: reflect around lattice centerline. Used instead of | |
| 156 // join to ensure my lattice is symmetric up and down. Dual is computed | |
| 157 // lazily, on demand, and cached in _dual. | |
| 158 const Type *_dual; // Cached dual value | |
| 159 // Table for efficient dualing of base types | |
| 160 static const TYPES dual_type[lastype]; | |
| 161 | |
| 162 protected: | |
| 163 // Each class of type is also identified by its base. | |
| 164 const TYPES _base; // Enum of Types type | |
| 165 | |
| 166 Type( TYPES t ) : _dual(NULL), _base(t) {} // Simple types | |
| 167 // ~Type(); // Use fast deallocation | |
| 168 const Type *hashcons(); // Hash-cons the type | |
| 169 | |
| 170 public: | |
| 171 | |
| 172 inline void* operator new( size_t x ) { | |
| 173 Compile* compile = Compile::current(); | |
| 174 compile->set_type_last_size(x); | |
| 175 void *temp = compile->type_arena()->Amalloc_D(x); | |
| 176 compile->set_type_hwm(temp); | |
| 177 return temp; | |
| 178 } | |
| 179 inline void operator delete( void* ptr ) { | |
| 180 Compile* compile = Compile::current(); | |
| 181 compile->type_arena()->Afree(ptr,compile->type_last_size()); | |
| 182 } | |
| 183 | |
| 184 // Initialize the type system for a particular compilation. | |
| 185 static void Initialize(Compile* compile); | |
| 186 | |
| 187 // Initialize the types shared by all compilations. | |
| 188 static void Initialize_shared(Compile* compile); | |
| 189 | |
| 190 TYPES base() const { | |
| 191 assert(_base > Bad && _base < lastype, "sanity"); | |
| 192 return _base; | |
| 193 } | |
| 194 | |
| 195 // Create a new hash-consd type | |
| 196 static const Type *make(enum TYPES); | |
| 197 // Test for equivalence of types | |
| 198 static int cmp( const Type *const t1, const Type *const t2 ); | |
| 199 // Test for higher or equal in lattice | |
| 200 int higher_equal( const Type *t ) const { return !cmp(meet(t),t); } | |
| 201 | |
| 202 // MEET operation; lower in lattice. | |
| 203 const Type *meet( const Type *t ) const; | |
| 204 // WIDEN: 'widens' for Ints and other range types | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
205 virtual const Type *widen( const Type *old, const Type* limit ) const { return this; } |
| 0 | 206 // NARROW: complement for widen, used by pessimistic phases |
| 207 virtual const Type *narrow( const Type *old ) const { return this; } | |
| 208 | |
| 209 // DUAL operation: reflect around lattice centerline. Used instead of | |
| 210 // join to ensure my lattice is symmetric up and down. | |
| 211 const Type *dual() const { return _dual; } | |
| 212 | |
| 213 // Compute meet dependent on base type | |
| 214 virtual const Type *xmeet( const Type *t ) const; | |
| 215 virtual const Type *xdual() const; // Compute dual right now. | |
| 216 | |
| 217 // JOIN operation; higher in lattice. Done by finding the dual of the | |
| 218 // meet of the dual of the 2 inputs. | |
| 219 const Type *join( const Type *t ) const { | |
| 220 return dual()->meet(t->dual())->dual(); } | |
| 221 | |
| 222 // Modified version of JOIN adapted to the needs Node::Value. | |
| 223 // Normalizes all empty values to TOP. Does not kill _widen bits. | |
| 224 // Currently, it also works around limitations involving interface types. | |
| 225 virtual const Type *filter( const Type *kills ) const; | |
| 226 | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
227 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
228 // One type is interface, the other is oop |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
229 virtual bool interface_vs_oop(const Type *t) const; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
230 #endif |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
231 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
232 // Returns true if this pointer points at memory which contains a |
| 163 | 233 // compressed oop references. |
| 234 bool is_ptr_to_narrowoop() const; | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
235 bool is_ptr_to_narrowklass() const; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
236 |
| 0 | 237 // Convenience access |
| 238 float getf() const; | |
| 239 double getd() const; | |
| 240 | |
| 241 const TypeInt *is_int() const; | |
| 242 const TypeInt *isa_int() const; // Returns NULL if not an Int | |
| 243 const TypeLong *is_long() const; | |
| 244 const TypeLong *isa_long() const; // Returns NULL if not a Long | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
245 const TypeD *isa_double() const; // Returns NULL if not a Double{Top,Con,Bot} |
| 0 | 246 const TypeD *is_double_constant() const; // Asserts it is a DoubleCon |
| 247 const TypeD *isa_double_constant() const; // Returns NULL if not a DoubleCon | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
248 const TypeF *isa_float() const; // Returns NULL if not a Float{Top,Con,Bot} |
| 0 | 249 const TypeF *is_float_constant() const; // Asserts it is a FloatCon |
| 250 const TypeF *isa_float_constant() const; // Returns NULL if not a FloatCon | |
| 251 const TypeTuple *is_tuple() const; // Collection of fields, NOT a pointer | |
| 252 const TypeAry *is_ary() const; // Array, NOT array pointer | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
253 const TypeVect *is_vect() const; // Vector |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
254 const TypeVect *isa_vect() const; // Returns NULL if not a Vector |
| 0 | 255 const TypePtr *is_ptr() const; // Asserts it is a ptr type |
| 256 const TypePtr *isa_ptr() const; // Returns NULL if not ptr type | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
257 const TypeRawPtr *isa_rawptr() const; // NOT Java oop |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
258 const TypeRawPtr *is_rawptr() const; // Asserts is rawptr |
| 163 | 259 const TypeNarrowOop *is_narrowoop() const; // Java-style GC'd pointer |
| 260 const TypeNarrowOop *isa_narrowoop() const; // Returns NULL if not oop ptr type | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
261 const TypeNarrowKlass *is_narrowklass() const; // compressed klass pointer |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
262 const TypeNarrowKlass *isa_narrowklass() const;// Returns NULL if not oop ptr type |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
263 const TypeOopPtr *isa_oopptr() const; // Returns NULL if not oop ptr type |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
264 const TypeOopPtr *is_oopptr() const; // Java-style GC'd pointer |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
265 const TypeInstPtr *isa_instptr() const; // Returns NULL if not InstPtr |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
266 const TypeInstPtr *is_instptr() const; // Instance |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
267 const TypeAryPtr *isa_aryptr() const; // Returns NULL if not AryPtr |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
268 const TypeAryPtr *is_aryptr() const; // Array oop |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
269 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
270 const TypeMetadataPtr *isa_metadataptr() const; // Returns NULL if not oop ptr type |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
271 const TypeMetadataPtr *is_metadataptr() const; // Java-style GC'd pointer |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
272 const TypeKlassPtr *isa_klassptr() const; // Returns NULL if not KlassPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
273 const TypeKlassPtr *is_klassptr() const; // assert if not KlassPtr |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
274 |
| 0 | 275 virtual bool is_finite() const; // Has a finite value |
| 276 virtual bool is_nan() const; // Is not a number (NaN) | |
| 277 | |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
278 // Returns this ptr type or the equivalent ptr type for this compressed pointer. |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
279 const TypePtr* make_ptr() const; |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
280 |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
281 // Returns this oopptr type or the equivalent oopptr type for this compressed pointer. |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
282 // Asserts if the underlying type is not an oopptr or narrowoop. |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
283 const TypeOopPtr* make_oopptr() const; |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
284 |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
285 // Returns this compressed pointer or the equivalent compressed version |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
286 // of this pointer type. |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
287 const TypeNarrowOop* make_narrowoop() const; |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
288 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
289 // Returns this compressed klass pointer or the equivalent |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
290 // compressed version of this pointer type. |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
291 const TypeNarrowKlass* make_narrowklass() const; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
292 |
| 0 | 293 // Special test for register pressure heuristic |
| 294 bool is_floatingpoint() const; // True if Float or Double base type | |
| 295 | |
| 296 // Do you have memory, directly or through a tuple? | |
| 297 bool has_memory( ) const; | |
| 298 | |
| 299 // TRUE if type is a singleton | |
| 300 virtual bool singleton(void) const; | |
| 301 | |
| 302 // TRUE if type is above the lattice centerline, and is therefore vacuous | |
| 303 virtual bool empty(void) const; | |
| 304 | |
| 305 // Return a hash for this type. The hash function is public so ConNode | |
| 306 // (constants) can hash on their constant, which is represented by a Type. | |
| 307 virtual int hash() const; | |
| 308 | |
| 309 // Map ideal registers (machine types) to ideal types | |
| 310 static const Type *mreg2type[]; | |
| 311 | |
| 312 // Printing, statistics | |
| 313 #ifndef PRODUCT | |
| 314 void dump_on(outputStream *st) const; | |
| 315 void dump() const { | |
| 316 dump_on(tty); | |
| 317 } | |
| 318 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 319 static void dump_stats(); | |
| 320 #endif | |
| 321 void typerr(const Type *t) const; // Mixing types error | |
| 322 | |
| 323 // Create basic type | |
| 324 static const Type* get_const_basic_type(BasicType type) { | |
| 325 assert((uint)type <= T_CONFLICT && _const_basic_type[type] != NULL, "bad type"); | |
| 326 return _const_basic_type[type]; | |
| 327 } | |
| 328 | |
| 329 // Mapping to the array element's basic type. | |
| 330 BasicType array_element_basic_type() const; | |
| 331 | |
| 332 // Create standard type for a ciType: | |
| 333 static const Type* get_const_type(ciType* type); | |
| 334 | |
| 335 // Create standard zero value: | |
| 336 static const Type* get_zero_type(BasicType type) { | |
| 337 assert((uint)type <= T_CONFLICT && _zero_type[type] != NULL, "bad type"); | |
| 338 return _zero_type[type]; | |
| 339 } | |
| 340 | |
| 341 // Report if this is a zero value (not top). | |
| 342 bool is_zero_type() const { | |
| 343 BasicType type = basic_type(); | |
| 344 if (type == T_VOID || type >= T_CONFLICT) | |
| 345 return false; | |
| 346 else | |
| 347 return (this == _zero_type[type]); | |
| 348 } | |
| 349 | |
| 350 // Convenience common pre-built types. | |
| 351 static const Type *ABIO; | |
| 352 static const Type *BOTTOM; | |
| 353 static const Type *CONTROL; | |
| 354 static const Type *DOUBLE; | |
| 355 static const Type *FLOAT; | |
| 356 static const Type *HALF; | |
| 357 static const Type *MEMORY; | |
| 358 static const Type *MULTI; | |
| 359 static const Type *RETURN_ADDRESS; | |
| 360 static const Type *TOP; | |
| 361 | |
| 362 // Mapping from compiler type to VM BasicType | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
363 BasicType basic_type() const { return _type_info[_base].basic_type; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
364 int ideal_reg() const { return _type_info[_base].ideal_reg; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
365 const char* msg() const { return _type_info[_base].msg; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
366 bool isa_oop_ptr() const { return _type_info[_base].isa_oop; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
367 relocInfo::relocType reloc() const { return _type_info[_base].reloc; } |
| 0 | 368 |
| 369 // Mapping from CI type system to compiler type: | |
| 370 static const Type* get_typeflow_type(ciType* type); | |
| 371 | |
| 372 private: | |
| 373 // support arrays | |
| 374 static const BasicType _basic_type[]; | |
| 375 static const Type* _zero_type[T_CONFLICT+1]; | |
| 376 static const Type* _const_basic_type[T_CONFLICT+1]; | |
| 377 }; | |
| 378 | |
| 379 //------------------------------TypeF------------------------------------------ | |
| 380 // Class of Float-Constant Types. | |
| 381 class TypeF : public Type { | |
| 382 TypeF( float f ) : Type(FloatCon), _f(f) {}; | |
| 383 public: | |
| 384 virtual bool eq( const Type *t ) const; | |
| 385 virtual int hash() const; // Type specific hashing | |
| 386 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 387 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 388 public: | |
| 389 const float _f; // Float constant | |
| 390 | |
| 391 static const TypeF *make(float f); | |
| 392 | |
| 393 virtual bool is_finite() const; // Has a finite value | |
| 394 virtual bool is_nan() const; // Is not a number (NaN) | |
| 395 | |
| 396 virtual const Type *xmeet( const Type *t ) const; | |
| 397 virtual const Type *xdual() const; // Compute dual right now. | |
| 398 // Convenience common pre-built types. | |
| 399 static const TypeF *ZERO; // positive zero only | |
| 400 static const TypeF *ONE; | |
| 401 #ifndef PRODUCT | |
| 402 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 403 #endif | |
| 404 }; | |
| 405 | |
| 406 //------------------------------TypeD------------------------------------------ | |
| 407 // Class of Double-Constant Types. | |
| 408 class TypeD : public Type { | |
| 409 TypeD( double d ) : Type(DoubleCon), _d(d) {}; | |
| 410 public: | |
| 411 virtual bool eq( const Type *t ) const; | |
| 412 virtual int hash() const; // Type specific hashing | |
| 413 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 414 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 415 public: | |
| 416 const double _d; // Double constant | |
| 417 | |
| 418 static const TypeD *make(double d); | |
| 419 | |
| 420 virtual bool is_finite() const; // Has a finite value | |
| 421 virtual bool is_nan() const; // Is not a number (NaN) | |
| 422 | |
| 423 virtual const Type *xmeet( const Type *t ) const; | |
| 424 virtual const Type *xdual() const; // Compute dual right now. | |
| 425 // Convenience common pre-built types. | |
| 426 static const TypeD *ZERO; // positive zero only | |
| 427 static const TypeD *ONE; | |
| 428 #ifndef PRODUCT | |
| 429 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 430 #endif | |
| 431 }; | |
| 432 | |
| 433 //------------------------------TypeInt---------------------------------------- | |
| 434 // Class of integer ranges, the set of integers between a lower bound and an | |
| 435 // upper bound, inclusive. | |
| 436 class TypeInt : public Type { | |
| 437 TypeInt( jint lo, jint hi, int w ); | |
| 438 public: | |
| 439 virtual bool eq( const Type *t ) const; | |
| 440 virtual int hash() const; // Type specific hashing | |
| 441 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 442 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 443 public: | |
| 444 const jint _lo, _hi; // Lower bound, upper bound | |
| 445 const short _widen; // Limit on times we widen this sucker | |
| 446 | |
| 447 static const TypeInt *make(jint lo); | |
| 448 // must always specify w | |
| 449 static const TypeInt *make(jint lo, jint hi, int w); | |
| 450 | |
| 451 // Check for single integer | |
| 452 int is_con() const { return _lo==_hi; } | |
| 453 bool is_con(int i) const { return is_con() && _lo == i; } | |
| 454 jint get_con() const { assert( is_con(), "" ); return _lo; } | |
| 455 | |
| 456 virtual bool is_finite() const; // Has a finite value | |
| 457 | |
| 458 virtual const Type *xmeet( const Type *t ) const; | |
| 459 virtual const Type *xdual() const; // Compute dual right now. | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
460 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
| 0 | 461 virtual const Type *narrow( const Type *t ) const; |
| 462 // Do not kill _widen bits. | |
| 463 virtual const Type *filter( const Type *kills ) const; | |
| 464 // Convenience common pre-built types. | |
| 465 static const TypeInt *MINUS_1; | |
| 466 static const TypeInt *ZERO; | |
| 467 static const TypeInt *ONE; | |
| 468 static const TypeInt *BOOL; | |
| 469 static const TypeInt *CC; | |
| 470 static const TypeInt *CC_LT; // [-1] == MINUS_1 | |
| 471 static const TypeInt *CC_GT; // [1] == ONE | |
| 472 static const TypeInt *CC_EQ; // [0] == ZERO | |
| 473 static const TypeInt *CC_LE; // [-1,0] | |
| 474 static const TypeInt *CC_GE; // [0,1] == BOOL (!) | |
| 475 static const TypeInt *BYTE; | |
| 624 | 476 static const TypeInt *UBYTE; |
| 0 | 477 static const TypeInt *CHAR; |
| 478 static const TypeInt *SHORT; | |
| 479 static const TypeInt *POS; | |
| 480 static const TypeInt *POS1; | |
| 481 static const TypeInt *INT; | |
| 482 static const TypeInt *SYMINT; // symmetric range [-max_jint..max_jint] | |
| 483 #ifndef PRODUCT | |
| 484 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 485 #endif | |
| 486 }; | |
| 487 | |
| 488 | |
| 489 //------------------------------TypeLong--------------------------------------- | |
| 490 // Class of long integer ranges, the set of integers between a lower bound and | |
| 491 // an upper bound, inclusive. | |
| 492 class TypeLong : public Type { | |
| 493 TypeLong( jlong lo, jlong hi, int w ); | |
| 494 public: | |
| 495 virtual bool eq( const Type *t ) const; | |
| 496 virtual int hash() const; // Type specific hashing | |
| 497 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 498 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 499 public: | |
| 500 const jlong _lo, _hi; // Lower bound, upper bound | |
| 501 const short _widen; // Limit on times we widen this sucker | |
| 502 | |
| 503 static const TypeLong *make(jlong lo); | |
| 504 // must always specify w | |
| 505 static const TypeLong *make(jlong lo, jlong hi, int w); | |
| 506 | |
| 507 // Check for single integer | |
| 508 int is_con() const { return _lo==_hi; } | |
| 145 | 509 bool is_con(int i) const { return is_con() && _lo == i; } |
| 0 | 510 jlong get_con() const { assert( is_con(), "" ); return _lo; } |
| 511 | |
| 512 virtual bool is_finite() const; // Has a finite value | |
| 513 | |
| 514 virtual const Type *xmeet( const Type *t ) const; | |
| 515 virtual const Type *xdual() const; // Compute dual right now. | |
|
1009
03b336640699
6885584: A particular class structure causes large allocation spike for jit
never
parents:
992
diff
changeset
|
516 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
| 0 | 517 virtual const Type *narrow( const Type *t ) const; |
| 518 // Do not kill _widen bits. | |
| 519 virtual const Type *filter( const Type *kills ) const; | |
| 520 // Convenience common pre-built types. | |
| 521 static const TypeLong *MINUS_1; | |
| 522 static const TypeLong *ZERO; | |
| 523 static const TypeLong *ONE; | |
| 524 static const TypeLong *POS; | |
| 525 static const TypeLong *LONG; | |
| 526 static const TypeLong *INT; // 32-bit subrange [min_jint..max_jint] | |
| 527 static const TypeLong *UINT; // 32-bit unsigned [0..max_juint] | |
| 528 #ifndef PRODUCT | |
| 529 virtual void dump2( Dict &d, uint, outputStream *st ) const;// Specialized per-Type dumping | |
| 530 #endif | |
| 531 }; | |
| 532 | |
| 533 //------------------------------TypeTuple-------------------------------------- | |
| 534 // Class of Tuple Types, essentially type collections for function signatures | |
| 535 // and class layouts. It happens to also be a fast cache for the HotSpot | |
| 536 // signature types. | |
| 537 class TypeTuple : public Type { | |
| 538 TypeTuple( uint cnt, const Type **fields ) : Type(Tuple), _cnt(cnt), _fields(fields) { } | |
| 539 public: | |
| 540 virtual bool eq( const Type *t ) const; | |
| 541 virtual int hash() const; // Type specific hashing | |
| 542 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 543 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 544 | |
| 545 public: | |
| 546 const uint _cnt; // Count of fields | |
| 547 const Type ** const _fields; // Array of field types | |
| 548 | |
| 549 // Accessors: | |
| 550 uint cnt() const { return _cnt; } | |
| 551 const Type* field_at(uint i) const { | |
| 552 assert(i < _cnt, "oob"); | |
| 553 return _fields[i]; | |
| 554 } | |
| 555 void set_field_at(uint i, const Type* t) { | |
| 556 assert(i < _cnt, "oob"); | |
| 557 _fields[i] = t; | |
| 558 } | |
| 559 | |
| 560 static const TypeTuple *make( uint cnt, const Type **fields ); | |
| 561 static const TypeTuple *make_range(ciSignature *sig); | |
| 562 static const TypeTuple *make_domain(ciInstanceKlass* recv, ciSignature *sig); | |
| 563 | |
| 564 // Subroutine call type with space allocated for argument types | |
| 565 static const Type **fields( uint arg_cnt ); | |
| 566 | |
| 567 virtual const Type *xmeet( const Type *t ) const; | |
| 568 virtual const Type *xdual() const; // Compute dual right now. | |
| 569 // Convenience common pre-built types. | |
| 570 static const TypeTuple *IFBOTH; | |
| 571 static const TypeTuple *IFFALSE; | |
| 572 static const TypeTuple *IFTRUE; | |
| 573 static const TypeTuple *IFNEITHER; | |
| 574 static const TypeTuple *LOOPBODY; | |
| 575 static const TypeTuple *MEMBAR; | |
| 576 static const TypeTuple *STORECONDITIONAL; | |
| 577 static const TypeTuple *START_I2C; | |
| 578 static const TypeTuple *INT_PAIR; | |
| 579 static const TypeTuple *LONG_PAIR; | |
| 580 #ifndef PRODUCT | |
| 581 virtual void dump2( Dict &d, uint, outputStream *st ) const; // Specialized per-Type dumping | |
| 582 #endif | |
| 583 }; | |
| 584 | |
| 585 //------------------------------TypeAry---------------------------------------- | |
| 586 // Class of Array Types | |
| 587 class TypeAry : public Type { | |
| 588 TypeAry( const Type *elem, const TypeInt *size) : Type(Array), | |
| 589 _elem(elem), _size(size) {} | |
| 590 public: | |
| 591 virtual bool eq( const Type *t ) const; | |
| 592 virtual int hash() const; // Type specific hashing | |
| 593 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 594 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 595 | |
| 596 private: | |
| 597 const Type *_elem; // Element type of array | |
| 598 const TypeInt *_size; // Elements in array | |
| 599 friend class TypeAryPtr; | |
| 600 | |
| 601 public: | |
| 602 static const TypeAry *make( const Type *elem, const TypeInt *size); | |
| 603 | |
| 604 virtual const Type *xmeet( const Type *t ) const; | |
| 605 virtual const Type *xdual() const; // Compute dual right now. | |
| 606 bool ary_must_be_exact() const; // true if arrays of such are never generic | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
607 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
608 // One type is interface, the other is oop |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
609 virtual bool interface_vs_oop(const Type *t) const; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
610 #endif |
| 0 | 611 #ifndef PRODUCT |
| 612 virtual void dump2( Dict &d, uint, outputStream *st ) const; // Specialized per-Type dumping | |
| 613 #endif | |
| 614 }; | |
| 615 | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
616 //------------------------------TypeVect--------------------------------------- |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
617 // Class of Vector Types |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
618 class TypeVect : public Type { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
619 const Type* _elem; // Vector's element type |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
620 const uint _length; // Elements in vector (power of 2) |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
621 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
622 protected: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
623 TypeVect(TYPES t, const Type* elem, uint length) : Type(t), |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
624 _elem(elem), _length(length) {} |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
625 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
626 public: |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
627 const Type* element_type() const { return _elem; } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
628 BasicType element_basic_type() const { return _elem->array_element_basic_type(); } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
629 uint length() const { return _length; } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
630 uint length_in_bytes() const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
631 return _length * type2aelembytes(element_basic_type()); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
632 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
633 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
634 virtual bool eq(const Type *t) const; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
635 virtual int hash() const; // Type specific hashing |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
636 virtual bool singleton(void) const; // TRUE if type is a singleton |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
637 virtual bool empty(void) const; // TRUE if type is vacuous |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
638 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
639 static const TypeVect *make(const BasicType elem_bt, uint length) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
640 // Use bottom primitive type. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
641 return make(get_const_basic_type(elem_bt), length); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
642 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
643 // Used directly by Replicate nodes to construct singleton vector. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
644 static const TypeVect *make(const Type* elem, uint length); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
645 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
646 virtual const Type *xmeet( const Type *t) const; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
647 virtual const Type *xdual() const; // Compute dual right now. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
648 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
649 static const TypeVect *VECTS; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
650 static const TypeVect *VECTD; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
651 static const TypeVect *VECTX; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
652 static const TypeVect *VECTY; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
653 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
654 #ifndef PRODUCT |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
655 virtual void dump2(Dict &d, uint, outputStream *st) const; // Specialized per-Type dumping |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
656 #endif |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
657 }; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
658 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
659 class TypeVectS : public TypeVect { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
660 friend class TypeVect; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
661 TypeVectS(const Type* elem, uint length) : TypeVect(VectorS, elem, length) {} |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
662 }; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
663 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
664 class TypeVectD : public TypeVect { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
665 friend class TypeVect; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
666 TypeVectD(const Type* elem, uint length) : TypeVect(VectorD, elem, length) {} |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
667 }; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
668 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
669 class TypeVectX : public TypeVect { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
670 friend class TypeVect; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
671 TypeVectX(const Type* elem, uint length) : TypeVect(VectorX, elem, length) {} |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
672 }; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
673 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
674 class TypeVectY : public TypeVect { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
675 friend class TypeVect; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
676 TypeVectY(const Type* elem, uint length) : TypeVect(VectorY, elem, length) {} |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
677 }; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
678 |
| 0 | 679 //------------------------------TypePtr---------------------------------------- |
| 680 // Class of machine Pointer Types: raw data, instances or arrays. | |
| 681 // If the _base enum is AnyPtr, then this refers to all of the above. | |
| 682 // Otherwise the _base will indicate which subset of pointers is affected, | |
| 683 // and the class will be inherited from. | |
| 684 class TypePtr : public Type { | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
685 friend class TypeNarrowPtr; |
| 0 | 686 public: |
| 687 enum PTR { TopPTR, AnyNull, Constant, Null, NotNull, BotPTR, lastPTR }; | |
| 688 protected: | |
| 689 TypePtr( TYPES t, PTR ptr, int offset ) : Type(t), _ptr(ptr), _offset(offset) {} | |
| 690 virtual bool eq( const Type *t ) const; | |
| 691 virtual int hash() const; // Type specific hashing | |
| 692 static const PTR ptr_meet[lastPTR][lastPTR]; | |
| 693 static const PTR ptr_dual[lastPTR]; | |
| 694 static const char * const ptr_msg[lastPTR]; | |
| 695 | |
| 696 public: | |
| 697 const int _offset; // Offset into oop, with TOP & BOT | |
| 698 const PTR _ptr; // Pointer equivalence class | |
| 699 | |
| 700 const int offset() const { return _offset; } | |
| 701 const PTR ptr() const { return _ptr; } | |
| 702 | |
| 703 static const TypePtr *make( TYPES t, PTR ptr, int offset ); | |
| 704 | |
| 705 // Return a 'ptr' version of this type | |
| 706 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 707 | |
| 708 virtual intptr_t get_con() const; | |
| 709 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
710 int xadd_offset( intptr_t offset ) const; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
711 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 712 |
| 713 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 714 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 715 virtual const Type *xmeet( const Type *t ) const; | |
| 716 int meet_offset( int offset ) const; | |
| 717 int dual_offset( ) const; | |
| 718 virtual const Type *xdual() const; // Compute dual right now. | |
| 719 | |
| 720 // meet, dual and join over pointer equivalence sets | |
| 721 PTR meet_ptr( const PTR in_ptr ) const { return ptr_meet[in_ptr][ptr()]; } | |
| 722 PTR dual_ptr() const { return ptr_dual[ptr()]; } | |
| 723 | |
| 724 // This is textually confusing unless one recalls that | |
| 725 // join(t) == dual()->meet(t->dual())->dual(). | |
| 726 PTR join_ptr( const PTR in_ptr ) const { | |
| 727 return ptr_dual[ ptr_meet[ ptr_dual[in_ptr] ] [ dual_ptr() ] ]; | |
| 728 } | |
| 729 | |
| 730 // Tests for relation to centerline of type lattice: | |
| 731 static bool above_centerline(PTR ptr) { return (ptr <= AnyNull); } | |
| 732 static bool below_centerline(PTR ptr) { return (ptr >= NotNull); } | |
| 733 // Convenience common pre-built types. | |
| 734 static const TypePtr *NULL_PTR; | |
| 735 static const TypePtr *NOTNULL; | |
| 736 static const TypePtr *BOTTOM; | |
| 737 #ifndef PRODUCT | |
| 738 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 739 #endif | |
| 740 }; | |
| 741 | |
| 742 //------------------------------TypeRawPtr------------------------------------- | |
| 743 // Class of raw pointers, pointers to things other than Oops. Examples | |
| 744 // include the stack pointer, top of heap, card-marking area, handles, etc. | |
| 745 class TypeRawPtr : public TypePtr { | |
| 746 protected: | |
| 747 TypeRawPtr( PTR ptr, address bits ) : TypePtr(RawPtr,ptr,0), _bits(bits){} | |
| 748 public: | |
| 749 virtual bool eq( const Type *t ) const; | |
| 750 virtual int hash() const; // Type specific hashing | |
| 751 | |
| 752 const address _bits; // Constant value, if applicable | |
| 753 | |
| 754 static const TypeRawPtr *make( PTR ptr ); | |
| 755 static const TypeRawPtr *make( address bits ); | |
| 756 | |
| 757 // Return a 'ptr' version of this type | |
| 758 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 759 | |
| 760 virtual intptr_t get_con() const; | |
| 761 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
762 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 763 |
| 764 virtual const Type *xmeet( const Type *t ) const; | |
| 765 virtual const Type *xdual() const; // Compute dual right now. | |
| 766 // Convenience common pre-built types. | |
| 767 static const TypeRawPtr *BOTTOM; | |
| 768 static const TypeRawPtr *NOTNULL; | |
| 769 #ifndef PRODUCT | |
| 770 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 771 #endif | |
| 772 }; | |
| 773 | |
| 774 //------------------------------TypeOopPtr------------------------------------- | |
| 775 // Some kind of oop (Java pointer), either klass or instance or array. | |
| 776 class TypeOopPtr : public TypePtr { | |
| 777 protected: | |
| 163 | 778 TypeOopPtr( TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id ); |
| 0 | 779 public: |
| 780 virtual bool eq( const Type *t ) const; | |
| 781 virtual int hash() const; // Type specific hashing | |
| 782 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 783 enum { | |
| 223 | 784 InstanceTop = -1, // undefined instance |
| 785 InstanceBot = 0 // any possible instance | |
| 0 | 786 }; |
| 787 protected: | |
| 788 | |
| 789 // Oop is NULL, unless this is a constant oop. | |
| 790 ciObject* _const_oop; // Constant oop | |
| 791 // If _klass is NULL, then so is _sig. This is an unloaded klass. | |
| 792 ciKlass* _klass; // Klass object | |
| 793 // Does the type exclude subclasses of the klass? (Inexact == polymorphic.) | |
| 794 bool _klass_is_exact; | |
| 163 | 795 bool _is_ptr_to_narrowoop; |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
796 bool _is_ptr_to_narrowklass; |
| 0 | 797 |
| 223 | 798 // If not InstanceTop or InstanceBot, indicates that this is |
| 799 // a particular instance of this type which is distinct. | |
| 800 // This is the the node index of the allocation node creating this instance. | |
| 801 int _instance_id; | |
| 0 | 802 |
| 803 static const TypeOopPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact); | |
| 804 | |
| 223 | 805 int dual_instance_id() const; |
| 806 int meet_instance_id(int uid) const; | |
| 0 | 807 |
| 808 public: | |
| 809 // Creates a type given a klass. Correctly handles multi-dimensional arrays | |
| 810 // Respects UseUniqueSubclasses. | |
| 811 // If the klass is final, the resulting type will be exact. | |
| 812 static const TypeOopPtr* make_from_klass(ciKlass* klass) { | |
| 813 return make_from_klass_common(klass, true, false); | |
| 814 } | |
| 815 // Same as before, but will produce an exact type, even if | |
| 816 // the klass is not final, as long as it has exactly one implementation. | |
| 817 static const TypeOopPtr* make_from_klass_unique(ciKlass* klass) { | |
| 818 return make_from_klass_common(klass, true, true); | |
| 819 } | |
| 820 // Same as before, but does not respects UseUniqueSubclasses. | |
| 821 // Use this only for creating array element types. | |
| 822 static const TypeOopPtr* make_from_klass_raw(ciKlass* klass) { | |
| 823 return make_from_klass_common(klass, false, false); | |
| 824 } | |
| 825 // Creates a singleton type given an object. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
826 // If the object cannot be rendered as a constant, |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
827 // may return a non-singleton type. |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
828 // If require_constant, produce a NULL if a singleton is not possible. |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
829 static const TypeOopPtr* make_from_constant(ciObject* o, bool require_constant = false); |
| 0 | 830 |
| 831 // Make a generic (unclassed) pointer to an oop. | |
| 992 | 832 static const TypeOopPtr* make(PTR ptr, int offset, int instance_id); |
| 0 | 833 |
| 834 ciObject* const_oop() const { return _const_oop; } | |
| 835 virtual ciKlass* klass() const { return _klass; } | |
| 836 bool klass_is_exact() const { return _klass_is_exact; } | |
| 163 | 837 |
| 838 // Returns true if this pointer points at memory which contains a | |
| 839 // compressed oop references. | |
| 840 bool is_ptr_to_narrowoop_nv() const { return _is_ptr_to_narrowoop; } | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
841 bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; } |
| 163 | 842 |
| 223 | 843 bool is_known_instance() const { return _instance_id > 0; } |
| 844 int instance_id() const { return _instance_id; } | |
| 845 bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; } | |
| 0 | 846 |
| 847 virtual intptr_t get_con() const; | |
| 848 | |
| 849 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 850 | |
| 851 virtual const Type *cast_to_exactness(bool klass_is_exact) const; | |
| 852 | |
| 223 | 853 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
| 0 | 854 |
| 855 // corresponding pointer to klass, for a given instance | |
| 856 const TypeKlassPtr* as_klass_type() const; | |
| 857 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
858 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 859 |
| 860 virtual const Type *xmeet( const Type *t ) const; | |
| 861 virtual const Type *xdual() const; // Compute dual right now. | |
| 862 | |
| 863 // Do not allow interface-vs.-noninterface joins to collapse to top. | |
| 864 virtual const Type *filter( const Type *kills ) const; | |
| 865 | |
| 866 // Convenience common pre-built type. | |
| 867 static const TypeOopPtr *BOTTOM; | |
| 868 #ifndef PRODUCT | |
| 869 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 870 #endif | |
| 871 }; | |
| 872 | |
| 873 //------------------------------TypeInstPtr------------------------------------ | |
| 874 // Class of Java object pointers, pointing either to non-array Java instances | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
875 // or to a Klass* (including array klasses). |
| 0 | 876 class TypeInstPtr : public TypeOopPtr { |
| 877 TypeInstPtr( PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id ); | |
| 878 virtual bool eq( const Type *t ) const; | |
| 879 virtual int hash() const; // Type specific hashing | |
| 880 | |
| 881 ciSymbol* _name; // class name | |
| 882 | |
| 883 public: | |
| 884 ciSymbol* name() const { return _name; } | |
| 885 | |
| 886 bool is_loaded() const { return _klass->is_loaded(); } | |
| 887 | |
| 888 // Make a pointer to a constant oop. | |
| 889 static const TypeInstPtr *make(ciObject* o) { | |
| 890 return make(TypePtr::Constant, o->klass(), true, o, 0); | |
| 891 } | |
| 892 // Make a pointer to a constant oop with offset. | |
| 893 static const TypeInstPtr *make(ciObject* o, int offset) { | |
| 894 return make(TypePtr::Constant, o->klass(), true, o, offset); | |
| 895 } | |
| 896 | |
| 897 // Make a pointer to some value of type klass. | |
| 898 static const TypeInstPtr *make(PTR ptr, ciKlass* klass) { | |
| 899 return make(ptr, klass, false, NULL, 0); | |
| 900 } | |
| 901 | |
| 902 // Make a pointer to some non-polymorphic value of exactly type klass. | |
| 903 static const TypeInstPtr *make_exact(PTR ptr, ciKlass* klass) { | |
| 904 return make(ptr, klass, true, NULL, 0); | |
| 905 } | |
| 906 | |
| 907 // Make a pointer to some value of type klass with offset. | |
| 908 static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) { | |
| 909 return make(ptr, klass, false, NULL, offset); | |
| 910 } | |
| 911 | |
| 912 // Make a pointer to an oop. | |
| 223 | 913 static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot ); |
| 0 | 914 |
| 915 // If this is a java.lang.Class constant, return the type for it or NULL. | |
| 916 // Pass to Type::get_const_type to turn it to a type, which will usually | |
| 917 // be a TypeInstPtr, but may also be a TypeInt::INT for int.class, etc. | |
| 918 ciType* java_mirror_type() const; | |
| 919 | |
| 920 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 921 | |
| 922 virtual const Type *cast_to_exactness(bool klass_is_exact) const; | |
| 923 | |
| 223 | 924 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
| 0 | 925 |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
926 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 927 |
| 928 virtual const Type *xmeet( const Type *t ) const; | |
| 929 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const; | |
| 930 virtual const Type *xdual() const; // Compute dual right now. | |
| 931 | |
| 932 // Convenience common pre-built types. | |
| 933 static const TypeInstPtr *NOTNULL; | |
| 934 static const TypeInstPtr *BOTTOM; | |
| 935 static const TypeInstPtr *MIRROR; | |
| 936 static const TypeInstPtr *MARK; | |
| 937 static const TypeInstPtr *KLASS; | |
| 938 #ifndef PRODUCT | |
| 939 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping | |
| 940 #endif | |
| 941 }; | |
| 942 | |
| 943 //------------------------------TypeAryPtr------------------------------------- | |
| 944 // Class of Java array pointers | |
| 945 class TypeAryPtr : public TypeOopPtr { | |
| 1761 | 946 TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id), _ary(ary) { |
| 947 #ifdef ASSERT | |
| 948 if (k != NULL) { | |
| 949 // Verify that specified klass and TypeAryPtr::klass() follow the same rules. | |
| 950 ciKlass* ck = compute_klass(true); | |
| 1792 | 951 if (k != ck) { |
| 1761 | 952 this->dump(); tty->cr(); |
| 953 tty->print(" k: "); | |
| 954 k->print(); tty->cr(); | |
| 955 tty->print("ck: "); | |
| 956 if (ck != NULL) ck->print(); | |
| 957 else tty->print("<NULL>"); | |
| 958 tty->cr(); | |
| 959 assert(false, "unexpected TypeAryPtr::_klass"); | |
| 960 } | |
| 961 } | |
| 962 #endif | |
| 963 } | |
| 0 | 964 virtual bool eq( const Type *t ) const; |
| 965 virtual int hash() const; // Type specific hashing | |
| 966 const TypeAry *_ary; // Array we point into | |
| 967 | |
| 1761 | 968 ciKlass* compute_klass(DEBUG_ONLY(bool verify = false)) const; |
| 969 | |
| 0 | 970 public: |
| 971 // Accessors | |
| 972 ciKlass* klass() const; | |
| 973 const TypeAry* ary() const { return _ary; } | |
| 974 const Type* elem() const { return _ary->_elem; } | |
| 975 const TypeInt* size() const { return _ary->_size; } | |
| 976 | |
| 223 | 977 static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot); |
| 0 | 978 // Constant pointer to array |
| 223 | 979 static const TypeAryPtr *make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot); |
| 0 | 980 |
| 981 // Return a 'ptr' version of this type | |
| 982 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 983 | |
| 984 virtual const Type *cast_to_exactness(bool klass_is_exact) const; | |
| 985 | |
| 223 | 986 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
| 0 | 987 |
| 988 virtual const TypeAryPtr* cast_to_size(const TypeInt* size) const; | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
989 virtual const TypeInt* narrow_size_type(const TypeInt* size) const; |
| 0 | 990 |
| 991 virtual bool empty(void) const; // TRUE if type is vacuous | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
992 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 993 |
| 994 virtual const Type *xmeet( const Type *t ) const; | |
| 995 virtual const Type *xdual() const; // Compute dual right now. | |
| 996 | |
| 997 // Convenience common pre-built types. | |
| 998 static const TypeAryPtr *RANGE; | |
| 999 static const TypeAryPtr *OOPS; | |
| 163 | 1000 static const TypeAryPtr *NARROWOOPS; |
| 0 | 1001 static const TypeAryPtr *BYTES; |
| 1002 static const TypeAryPtr *SHORTS; | |
| 1003 static const TypeAryPtr *CHARS; | |
| 1004 static const TypeAryPtr *INTS; | |
| 1005 static const TypeAryPtr *LONGS; | |
| 1006 static const TypeAryPtr *FLOATS; | |
| 1007 static const TypeAryPtr *DOUBLES; | |
| 1008 // selects one of the above: | |
| 1009 static const TypeAryPtr *get_array_body_type(BasicType elem) { | |
| 1010 assert((uint)elem <= T_CONFLICT && _array_body_type[elem] != NULL, "bad elem type"); | |
| 1011 return _array_body_type[elem]; | |
| 1012 } | |
| 1013 static const TypeAryPtr *_array_body_type[T_CONFLICT+1]; | |
| 1014 // sharpen the type of an int which is used as an array size | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1015 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1016 // One type is interface, the other is oop |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1017 virtual bool interface_vs_oop(const Type *t) const; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
1018 #endif |
| 0 | 1019 #ifndef PRODUCT |
| 1020 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping | |
| 1021 #endif | |
| 1022 }; | |
| 1023 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1024 //------------------------------TypeMetadataPtr------------------------------------- |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1025 // Some kind of metadata, either Method*, MethodData* or CPCacheOop |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1026 class TypeMetadataPtr : public TypePtr { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1027 protected: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1028 TypeMetadataPtr(PTR ptr, ciMetadata* metadata, int offset); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1029 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1030 virtual bool eq( const Type *t ) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1031 virtual int hash() const; // Type specific hashing |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1032 virtual bool singleton(void) const; // TRUE if type is a singleton |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1033 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1034 private: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1035 ciMetadata* _metadata; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1036 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1037 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1038 static const TypeMetadataPtr* make(PTR ptr, ciMetadata* m, int offset); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1039 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1040 static const TypeMetadataPtr* make(ciMethod* m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1041 static const TypeMetadataPtr* make(ciMethodData* m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1042 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1043 ciMetadata* metadata() const { return _metadata; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1044 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1045 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1046 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1047 virtual const TypePtr *add_offset( intptr_t offset ) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1048 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1049 virtual const Type *xmeet( const Type *t ) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1050 virtual const Type *xdual() const; // Compute dual right now. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1051 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1052 virtual intptr_t get_con() const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1053 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1054 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1055 virtual const Type *filter( const Type *kills ) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1056 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1057 // Convenience common pre-built types. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1058 static const TypeMetadataPtr *BOTTOM; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1059 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1060 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1061 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1062 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1063 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1064 |
| 0 | 1065 //------------------------------TypeKlassPtr----------------------------------- |
| 1066 // Class of Java Klass pointers | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1067 class TypeKlassPtr : public TypePtr { |
| 0 | 1068 TypeKlassPtr( PTR ptr, ciKlass* klass, int offset ); |
| 1069 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1070 public: |
| 0 | 1071 virtual bool eq( const Type *t ) const; |
| 1072 virtual int hash() const; // Type specific hashing | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1073 virtual bool singleton(void) const; // TRUE if type is a singleton |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1074 private: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1075 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1076 static const TypeKlassPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1077 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1078 ciKlass* _klass; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1079 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1080 // Does the type exclude subclasses of the klass? (Inexact == polymorphic.) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1081 bool _klass_is_exact; |
| 0 | 1082 |
| 1083 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1084 ciSymbol* name() const { return klass()->name(); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1085 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1086 ciKlass* klass() const { return _klass; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1087 bool klass_is_exact() const { return _klass_is_exact; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1088 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1089 bool is_loaded() const { return klass()->is_loaded(); } |
| 0 | 1090 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1091 // Creates a type given a klass. Correctly handles multi-dimensional arrays |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1092 // Respects UseUniqueSubclasses. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1093 // If the klass is final, the resulting type will be exact. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1094 static const TypeKlassPtr* make_from_klass(ciKlass* klass) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1095 return make_from_klass_common(klass, true, false); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1096 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1097 // Same as before, but will produce an exact type, even if |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1098 // the klass is not final, as long as it has exactly one implementation. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1099 static const TypeKlassPtr* make_from_klass_unique(ciKlass* klass) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1100 return make_from_klass_common(klass, true, true); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1101 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1102 // Same as before, but does not respects UseUniqueSubclasses. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1103 // Use this only for creating array element types. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1104 static const TypeKlassPtr* make_from_klass_raw(ciKlass* klass) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1105 return make_from_klass_common(klass, false, false); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1106 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1107 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1108 // Make a generic (unclassed) pointer to metadata. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1109 static const TypeKlassPtr* make(PTR ptr, int offset); |
| 555 | 1110 |
| 0 | 1111 // ptr to klass 'k' |
| 1112 static const TypeKlassPtr *make( ciKlass* k ) { return make( TypePtr::Constant, k, 0); } | |
| 1113 // ptr to klass 'k' with offset | |
| 1114 static const TypeKlassPtr *make( ciKlass* k, int offset ) { return make( TypePtr::Constant, k, offset); } | |
| 1115 // ptr to klass 'k' or sub-klass | |
| 1116 static const TypeKlassPtr *make( PTR ptr, ciKlass* k, int offset); | |
| 1117 | |
| 1118 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 1119 | |
| 1120 virtual const Type *cast_to_exactness(bool klass_is_exact) const; | |
| 1121 | |
| 1122 // corresponding pointer to instance, for a given class | |
| 1123 const TypeOopPtr* as_instance_type() const; | |
| 1124 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
1125 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 1126 virtual const Type *xmeet( const Type *t ) const; |
| 1127 virtual const Type *xdual() const; // Compute dual right now. | |
| 1128 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1129 virtual intptr_t get_con() const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1130 |
| 0 | 1131 // Convenience common pre-built types. |
| 1132 static const TypeKlassPtr* OBJECT; // Not-null object klass or below | |
| 1133 static const TypeKlassPtr* OBJECT_OR_NULL; // Maybe-null version of same | |
| 1134 #ifndef PRODUCT | |
| 1135 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping | |
| 1136 #endif | |
| 1137 }; | |
| 1138 | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1139 class TypeNarrowPtr : public Type { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1140 protected: |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1141 const TypePtr* _ptrtype; // Could be TypePtr::NULL_PTR |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1142 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1143 TypeNarrowPtr(TYPES t, const TypePtr* ptrtype): _ptrtype(ptrtype), |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1144 Type(t) { |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1145 assert(ptrtype->offset() == 0 || |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1146 ptrtype->offset() == OffsetBot || |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1147 ptrtype->offset() == OffsetTop, "no real offsets"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1148 } |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1149 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1150 virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const = 0; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1151 virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const = 0; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1152 virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const = 0; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1153 virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const = 0; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1154 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1155 virtual bool eq( const Type *t ) const; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1156 virtual int hash() const; // Type specific hashing |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1157 virtual bool singleton(void) const; // TRUE if type is a singleton |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1158 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1159 virtual const Type *xmeet( const Type *t ) const; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1160 virtual const Type *xdual() const; // Compute dual right now. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1161 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1162 virtual intptr_t get_con() const; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1163 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1164 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1165 virtual const Type *filter( const Type *kills ) const; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1166 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1167 virtual bool empty(void) const; // TRUE if type is vacuous |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1168 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1169 // returns the equivalent ptr type for this compressed pointer |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1170 const TypePtr *get_ptrtype() const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1171 return _ptrtype; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1172 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1173 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1174 #ifndef PRODUCT |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1175 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1176 #endif |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1177 }; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1178 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1179 //------------------------------TypeNarrowOop---------------------------------- |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1180 // A compressed reference to some kind of Oop. This type wraps around |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1181 // a preexisting TypeOopPtr and forwards most of it's operations to |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1182 // the underlying type. It's only real purpose is to track the |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1183 // oopness of the compressed oop value when we expose the conversion |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1184 // between the normal and the compressed form. |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1185 class TypeNarrowOop : public TypeNarrowPtr { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1186 protected: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1187 TypeNarrowOop( const TypePtr* ptrtype): TypeNarrowPtr(NarrowOop, ptrtype) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1188 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1189 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1190 virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1191 return t->isa_narrowoop(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1192 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1193 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1194 virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1195 return t->is_narrowoop(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1196 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1197 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1198 virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1199 return new TypeNarrowOop(t); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1200 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1201 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1202 virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1203 return (const TypeNarrowPtr*)((new TypeNarrowOop(t))->hashcons()); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1204 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1205 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1206 public: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1207 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1208 static const TypeNarrowOop *make( const TypePtr* type); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1209 |
|
2379
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
1972
diff
changeset
|
1210 static const TypeNarrowOop* make_from_constant(ciObject* con, bool require_constant = false) { |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
1972
diff
changeset
|
1211 return make(TypeOopPtr::make_from_constant(con, require_constant)); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1212 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1213 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1214 static const TypeNarrowOop *BOTTOM; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1215 static const TypeNarrowOop *NULL_PTR; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1216 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1217 #ifndef PRODUCT |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1218 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1219 #endif |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1220 }; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1221 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1222 //------------------------------TypeNarrowKlass---------------------------------- |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1223 // A compressed reference to klass pointer. This type wraps around a |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1224 // preexisting TypeKlassPtr and forwards most of it's operations to |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1225 // the underlying type. |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1226 class TypeNarrowKlass : public TypeNarrowPtr { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1227 protected: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1228 TypeNarrowKlass( const TypePtr* ptrtype): TypeNarrowPtr(NarrowKlass, ptrtype) { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1229 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1230 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1231 virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1232 return t->isa_narrowklass(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1233 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1234 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1235 virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1236 return t->is_narrowklass(); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1237 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1238 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1239 virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1240 return new TypeNarrowKlass(t); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1241 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1242 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1243 virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1244 return (const TypeNarrowPtr*)((new TypeNarrowKlass(t))->hashcons()); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1245 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1246 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1247 public: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1248 static const TypeNarrowKlass *make( const TypePtr* type); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1249 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1250 // static const TypeNarrowKlass *BOTTOM; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1251 static const TypeNarrowKlass *NULL_PTR; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1252 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1253 #ifndef PRODUCT |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1254 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1255 #endif |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1256 }; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1257 |
| 0 | 1258 //------------------------------TypeFunc--------------------------------------- |
| 1259 // Class of Array Types | |
| 1260 class TypeFunc : public Type { | |
| 1261 TypeFunc( const TypeTuple *domain, const TypeTuple *range ) : Type(Function), _domain(domain), _range(range) {} | |
| 1262 virtual bool eq( const Type *t ) const; | |
| 1263 virtual int hash() const; // Type specific hashing | |
| 1264 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 1265 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 1266 public: | |
| 1267 // Constants are shared among ADLC and VM | |
| 1268 enum { Control = AdlcVMDeps::Control, | |
| 1269 I_O = AdlcVMDeps::I_O, | |
| 1270 Memory = AdlcVMDeps::Memory, | |
| 1271 FramePtr = AdlcVMDeps::FramePtr, | |
| 1272 ReturnAdr = AdlcVMDeps::ReturnAdr, | |
| 1273 Parms = AdlcVMDeps::Parms | |
| 1274 }; | |
| 1275 | |
| 1276 const TypeTuple* const _domain; // Domain of inputs | |
| 1277 const TypeTuple* const _range; // Range of results | |
| 1278 | |
| 1279 // Accessors: | |
| 1280 const TypeTuple* domain() const { return _domain; } | |
| 1281 const TypeTuple* range() const { return _range; } | |
| 1282 | |
| 1283 static const TypeFunc *make(ciMethod* method); | |
| 1284 static const TypeFunc *make(ciSignature signature, const Type* extra); | |
| 1285 static const TypeFunc *make(const TypeTuple* domain, const TypeTuple* range); | |
| 1286 | |
| 1287 virtual const Type *xmeet( const Type *t ) const; | |
| 1288 virtual const Type *xdual() const; // Compute dual right now. | |
| 1289 | |
| 1290 BasicType return_type() const; | |
| 1291 | |
| 1292 #ifndef PRODUCT | |
| 1293 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping | |
| 1294 #endif | |
| 1295 // Convenience common pre-built types. | |
| 1296 }; | |
| 1297 | |
| 1298 //------------------------------accessors-------------------------------------- | |
| 163 | 1299 inline bool Type::is_ptr_to_narrowoop() const { |
| 1300 #ifdef _LP64 | |
| 1301 return (isa_oopptr() != NULL && is_oopptr()->is_ptr_to_narrowoop_nv()); | |
| 1302 #else | |
| 1303 return false; | |
| 1304 #endif | |
| 1305 } | |
| 1306 | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1307 inline bool Type::is_ptr_to_narrowklass() const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1308 #ifdef _LP64 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1309 return (isa_oopptr() != NULL && is_oopptr()->is_ptr_to_narrowklass_nv()); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1310 #else |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1311 return false; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1312 #endif |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1313 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1314 |
| 0 | 1315 inline float Type::getf() const { |
| 1316 assert( _base == FloatCon, "Not a FloatCon" ); | |
| 1317 return ((TypeF*)this)->_f; | |
| 1318 } | |
| 1319 | |
| 1320 inline double Type::getd() const { | |
| 1321 assert( _base == DoubleCon, "Not a DoubleCon" ); | |
| 1322 return ((TypeD*)this)->_d; | |
| 1323 } | |
| 1324 | |
| 1325 inline const TypeInt *Type::is_int() const { | |
| 1326 assert( _base == Int, "Not an Int" ); | |
| 1327 return (TypeInt*)this; | |
| 1328 } | |
| 1329 | |
| 1330 inline const TypeInt *Type::isa_int() const { | |
| 1331 return ( _base == Int ? (TypeInt*)this : NULL); | |
| 1332 } | |
| 1333 | |
| 1334 inline const TypeLong *Type::is_long() const { | |
| 1335 assert( _base == Long, "Not a Long" ); | |
| 1336 return (TypeLong*)this; | |
| 1337 } | |
| 1338 | |
| 1339 inline const TypeLong *Type::isa_long() const { | |
| 1340 return ( _base == Long ? (TypeLong*)this : NULL); | |
| 1341 } | |
| 1342 | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1343 inline const TypeF *Type::isa_float() const { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1344 return ((_base == FloatTop || |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1345 _base == FloatCon || |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1346 _base == FloatBot) ? (TypeF*)this : NULL); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1347 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1348 |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1349 inline const TypeF *Type::is_float_constant() const { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1350 assert( _base == FloatCon, "Not a Float" ); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1351 return (TypeF*)this; |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1352 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1353 |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1354 inline const TypeF *Type::isa_float_constant() const { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1355 return ( _base == FloatCon ? (TypeF*)this : NULL); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1356 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1357 |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1358 inline const TypeD *Type::isa_double() const { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1359 return ((_base == DoubleTop || |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1360 _base == DoubleCon || |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1361 _base == DoubleBot) ? (TypeD*)this : NULL); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1362 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1363 |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1364 inline const TypeD *Type::is_double_constant() const { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1365 assert( _base == DoubleCon, "Not a Double" ); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1366 return (TypeD*)this; |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1367 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1368 |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1369 inline const TypeD *Type::isa_double_constant() const { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1370 return ( _base == DoubleCon ? (TypeD*)this : NULL); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1371 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6848
diff
changeset
|
1372 |
| 0 | 1373 inline const TypeTuple *Type::is_tuple() const { |
| 1374 assert( _base == Tuple, "Not a Tuple" ); | |
| 1375 return (TypeTuple*)this; | |
| 1376 } | |
| 1377 | |
| 1378 inline const TypeAry *Type::is_ary() const { | |
| 1379 assert( _base == Array , "Not an Array" ); | |
| 1380 return (TypeAry*)this; | |
| 1381 } | |
| 1382 | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1383 inline const TypeVect *Type::is_vect() const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1384 assert( _base >= VectorS && _base <= VectorY, "Not a Vector" ); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1385 return (TypeVect*)this; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1386 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1387 |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1388 inline const TypeVect *Type::isa_vect() const { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1389 return (_base >= VectorS && _base <= VectorY) ? (TypeVect*)this : NULL; |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1390 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
3939
diff
changeset
|
1391 |
| 0 | 1392 inline const TypePtr *Type::is_ptr() const { |
| 1393 // AnyPtr is the first Ptr and KlassPtr the last, with no non-ptrs between. | |
| 1394 assert(_base >= AnyPtr && _base <= KlassPtr, "Not a pointer"); | |
| 1395 return (TypePtr*)this; | |
| 1396 } | |
| 1397 | |
| 1398 inline const TypePtr *Type::isa_ptr() const { | |
| 1399 // AnyPtr is the first Ptr and KlassPtr the last, with no non-ptrs between. | |
| 1400 return (_base >= AnyPtr && _base <= KlassPtr) ? (TypePtr*)this : NULL; | |
| 1401 } | |
| 1402 | |
| 1403 inline const TypeOopPtr *Type::is_oopptr() const { | |
| 1404 // OopPtr is the first and KlassPtr the last, with no non-oops between. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1405 assert(_base >= OopPtr && _base <= AryPtr, "Not a Java pointer" ) ; |
| 0 | 1406 return (TypeOopPtr*)this; |
| 1407 } | |
| 1408 | |
| 1409 inline const TypeOopPtr *Type::isa_oopptr() const { | |
| 1410 // OopPtr is the first and KlassPtr the last, with no non-oops between. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1411 return (_base >= OopPtr && _base <= AryPtr) ? (TypeOopPtr*)this : NULL; |
| 0 | 1412 } |
| 1413 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1414 inline const TypeRawPtr *Type::isa_rawptr() const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1415 return (_base == RawPtr) ? (TypeRawPtr*)this : NULL; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1416 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1417 |
| 0 | 1418 inline const TypeRawPtr *Type::is_rawptr() const { |
| 1419 assert( _base == RawPtr, "Not a raw pointer" ); | |
| 1420 return (TypeRawPtr*)this; | |
| 1421 } | |
| 1422 | |
| 1423 inline const TypeInstPtr *Type::isa_instptr() const { | |
| 1424 return (_base == InstPtr) ? (TypeInstPtr*)this : NULL; | |
| 1425 } | |
| 1426 | |
| 1427 inline const TypeInstPtr *Type::is_instptr() const { | |
| 1428 assert( _base == InstPtr, "Not an object pointer" ); | |
| 1429 return (TypeInstPtr*)this; | |
| 1430 } | |
| 1431 | |
| 1432 inline const TypeAryPtr *Type::isa_aryptr() const { | |
| 1433 return (_base == AryPtr) ? (TypeAryPtr*)this : NULL; | |
| 1434 } | |
| 1435 | |
| 1436 inline const TypeAryPtr *Type::is_aryptr() const { | |
| 1437 assert( _base == AryPtr, "Not an array pointer" ); | |
| 1438 return (TypeAryPtr*)this; | |
| 1439 } | |
| 1440 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1441 inline const TypeNarrowOop *Type::is_narrowoop() const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1442 // OopPtr is the first and KlassPtr the last, with no non-oops between. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1443 assert(_base == NarrowOop, "Not a narrow oop" ) ; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1444 return (TypeNarrowOop*)this; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1445 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1446 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1447 inline const TypeNarrowOop *Type::isa_narrowoop() const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1448 // OopPtr is the first and KlassPtr the last, with no non-oops between. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1449 return (_base == NarrowOop) ? (TypeNarrowOop*)this : NULL; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1450 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1451 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1452 inline const TypeNarrowKlass *Type::is_narrowklass() const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1453 assert(_base == NarrowKlass, "Not a narrow oop" ) ; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1454 return (TypeNarrowKlass*)this; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1455 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1456 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1457 inline const TypeNarrowKlass *Type::isa_narrowklass() const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1458 return (_base == NarrowKlass) ? (TypeNarrowKlass*)this : NULL; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1459 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1460 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1461 inline const TypeMetadataPtr *Type::is_metadataptr() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1462 // MetadataPtr is the first and CPCachePtr the last |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1463 assert(_base == MetadataPtr, "Not a metadata pointer" ) ; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1464 return (TypeMetadataPtr*)this; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1465 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1466 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1467 inline const TypeMetadataPtr *Type::isa_metadataptr() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1468 return (_base == MetadataPtr) ? (TypeMetadataPtr*)this : NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1469 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6179
diff
changeset
|
1470 |
| 0 | 1471 inline const TypeKlassPtr *Type::isa_klassptr() const { |
| 1472 return (_base == KlassPtr) ? (TypeKlassPtr*)this : NULL; | |
| 1473 } | |
| 1474 | |
| 1475 inline const TypeKlassPtr *Type::is_klassptr() const { | |
| 1476 assert( _base == KlassPtr, "Not a klass pointer" ); | |
| 1477 return (TypeKlassPtr*)this; | |
| 1478 } | |
| 1479 | |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1480 inline const TypePtr* Type::make_ptr() const { |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1481 return (_base == NarrowOop) ? is_narrowoop()->get_ptrtype() : |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1482 ((_base == NarrowKlass) ? is_narrowklass()->get_ptrtype() : |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1483 (isa_ptr() ? is_ptr() : NULL)); |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1484 } |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1485 |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1486 inline const TypeOopPtr* Type::make_oopptr() const { |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1487 return (_base == NarrowOop) ? is_narrowoop()->get_ptrtype()->is_oopptr() : is_oopptr(); |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1488 } |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1489 |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1490 inline const TypeNarrowOop* Type::make_narrowoop() const { |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1491 return (_base == NarrowOop) ? is_narrowoop() : |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1492 (isa_ptr() ? TypeNarrowOop::make(is_ptr()) : NULL); |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1493 } |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1494 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1495 inline const TypeNarrowKlass* Type::make_narrowklass() const { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1496 return (_base == NarrowKlass) ? is_narrowklass() : |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1497 (isa_ptr() ? TypeNarrowKlass::make(is_ptr()) : NULL); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1498 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
1499 |
| 0 | 1500 inline bool Type::is_floatingpoint() const { |
| 1501 if( (_base == FloatCon) || (_base == FloatBot) || | |
| 1502 (_base == DoubleCon) || (_base == DoubleBot) ) | |
| 1503 return true; | |
| 1504 return false; | |
| 1505 } | |
| 1506 | |
| 1507 | |
| 1508 // =============================================================== | |
| 1509 // Things that need to be 64-bits in the 64-bit build but | |
| 1510 // 32-bits in the 32-bit build. Done this way to get full | |
| 1511 // optimization AND strong typing. | |
| 1512 #ifdef _LP64 | |
| 1513 | |
| 1514 // For type queries and asserts | |
| 1515 #define is_intptr_t is_long | |
| 1516 #define isa_intptr_t isa_long | |
| 1517 #define find_intptr_t_type find_long_type | |
| 1518 #define find_intptr_t_con find_long_con | |
| 1519 #define TypeX TypeLong | |
| 1520 #define Type_X Type::Long | |
| 1521 #define TypeX_X TypeLong::LONG | |
| 1522 #define TypeX_ZERO TypeLong::ZERO | |
| 1523 // For 'ideal_reg' machine registers | |
| 1524 #define Op_RegX Op_RegL | |
| 1525 // For phase->intcon variants | |
| 1526 #define MakeConX longcon | |
| 1527 #define ConXNode ConLNode | |
| 1528 // For array index arithmetic | |
| 1529 #define MulXNode MulLNode | |
| 1530 #define AndXNode AndLNode | |
| 1531 #define OrXNode OrLNode | |
| 1532 #define CmpXNode CmpLNode | |
| 1533 #define SubXNode SubLNode | |
| 1534 #define LShiftXNode LShiftLNode | |
| 1535 // For object size computation: | |
| 1536 #define AddXNode AddLNode | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1537 #define RShiftXNode RShiftLNode |
| 0 | 1538 // For card marks and hashcodes |
| 1539 #define URShiftXNode URShiftLNode | |
|
420
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1540 // UseOptoBiasInlining |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1541 #define XorXNode XorLNode |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1542 #define StoreXConditionalNode StoreLConditionalNode |
| 0 | 1543 // Opcodes |
| 1544 #define Op_LShiftX Op_LShiftL | |
| 1545 #define Op_AndX Op_AndL | |
| 1546 #define Op_AddX Op_AddL | |
| 1547 #define Op_SubX Op_SubL | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
827
diff
changeset
|
1548 #define Op_XorX Op_XorL |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
827
diff
changeset
|
1549 #define Op_URShiftX Op_URShiftL |
| 0 | 1550 // conversions |
| 1551 #define ConvI2X(x) ConvI2L(x) | |
| 1552 #define ConvL2X(x) (x) | |
| 1553 #define ConvX2I(x) ConvL2I(x) | |
| 1554 #define ConvX2L(x) (x) | |
| 1555 | |
| 1556 #else | |
| 1557 | |
| 1558 // For type queries and asserts | |
| 1559 #define is_intptr_t is_int | |
| 1560 #define isa_intptr_t isa_int | |
| 1561 #define find_intptr_t_type find_int_type | |
| 1562 #define find_intptr_t_con find_int_con | |
| 1563 #define TypeX TypeInt | |
| 1564 #define Type_X Type::Int | |
| 1565 #define TypeX_X TypeInt::INT | |
| 1566 #define TypeX_ZERO TypeInt::ZERO | |
| 1567 // For 'ideal_reg' machine registers | |
| 1568 #define Op_RegX Op_RegI | |
| 1569 // For phase->intcon variants | |
| 1570 #define MakeConX intcon | |
| 1571 #define ConXNode ConINode | |
| 1572 // For array index arithmetic | |
| 1573 #define MulXNode MulINode | |
| 1574 #define AndXNode AndINode | |
| 1575 #define OrXNode OrINode | |
| 1576 #define CmpXNode CmpINode | |
| 1577 #define SubXNode SubINode | |
| 1578 #define LShiftXNode LShiftINode | |
| 1579 // For object size computation: | |
| 1580 #define AddXNode AddINode | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1581 #define RShiftXNode RShiftINode |
| 0 | 1582 // For card marks and hashcodes |
| 1583 #define URShiftXNode URShiftINode | |
|
420
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1584 // UseOptoBiasInlining |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1585 #define XorXNode XorINode |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1586 #define StoreXConditionalNode StoreIConditionalNode |
| 0 | 1587 // Opcodes |
| 1588 #define Op_LShiftX Op_LShiftI | |
| 1589 #define Op_AndX Op_AndI | |
| 1590 #define Op_AddX Op_AddI | |
| 1591 #define Op_SubX Op_SubI | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
827
diff
changeset
|
1592 #define Op_XorX Op_XorI |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
827
diff
changeset
|
1593 #define Op_URShiftX Op_URShiftI |
| 0 | 1594 // conversions |
| 1595 #define ConvI2X(x) (x) | |
| 1596 #define ConvL2X(x) ConvL2I(x) | |
| 1597 #define ConvX2I(x) (x) | |
| 1598 #define ConvX2L(x) ConvI2L(x) | |
| 1599 | |
| 1600 #endif | |
| 1972 | 1601 |
| 1602 #endif // SHARE_VM_OPTO_TYPE_HPP |