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