Mercurial > hg > truffle
annotate src/share/vm/opto/type.hpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | f6f3bb0ee072 |
| children | 8c92982cbbc4 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2379
diff
changeset
|
2 * Copyright (c) 1997, 2011, 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; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
51 class TypeNarrowOop; |
| 0 | 52 class TypeAry; |
| 53 class TypeTuple; | |
| 54 class TypePtr; | |
| 55 class TypeRawPtr; | |
| 56 class TypeOopPtr; | |
| 57 class TypeInstPtr; | |
| 58 class TypeAryPtr; | |
| 59 class TypeKlassPtr; | |
| 60 | |
| 61 //------------------------------Type------------------------------------------- | |
| 62 // Basic Type object, represents a set of primitive Values. | |
| 63 // Types are hash-cons'd into a private class dictionary, so only one of each | |
| 64 // different kind of Type exists. Types are never modified after creation, so | |
| 65 // all their interesting fields are constant. | |
| 66 class Type { | |
| 3939 | 67 friend class VMStructs; |
| 68 | |
| 0 | 69 public: |
| 70 enum TYPES { | |
| 71 Bad=0, // Type check | |
| 72 Control, // Control of code (not in lattice) | |
| 73 Top, // Top of the lattice | |
| 74 Int, // Integer range (lo-hi) | |
| 75 Long, // Long integer range (lo-hi) | |
| 76 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
|
77 NarrowOop, // Compressed oop pointer |
| 0 | 78 |
| 79 Tuple, // Method signature or object layout | |
| 80 Array, // Array types | |
| 81 | |
| 82 AnyPtr, // Any old raw, klass, inst, or array pointer | |
| 83 RawPtr, // Raw (non-oop) pointers | |
| 84 OopPtr, // Any and all Java heap entities | |
| 85 InstPtr, // Instance pointers (non-array objects) | |
| 86 AryPtr, // Array pointers | |
| 87 KlassPtr, // Klass pointers | |
| 88 // (Ptr order matters: See is_ptr, isa_ptr, is_oopptr, isa_oopptr.) | |
| 89 | |
| 90 Function, // Function signature | |
| 91 Abio, // Abstract I/O | |
| 92 Return_Address, // Subroutine return address | |
| 93 Memory, // Abstract store | |
| 94 FloatTop, // No float value | |
| 95 FloatCon, // Floating point constant | |
| 96 FloatBot, // Any float value | |
| 97 DoubleTop, // No double value | |
| 98 DoubleCon, // Double precision constant | |
| 99 DoubleBot, // Any double value | |
| 100 Bottom, // Bottom of lattice | |
| 101 lastype // Bogus ending type (not in lattice) | |
| 102 }; | |
| 103 | |
| 104 // Signal values for offsets from a base pointer | |
| 105 enum OFFSET_SIGNALS { | |
| 106 OffsetTop = -2000000000, // undefined offset | |
| 107 OffsetBot = -2000000001 // any possible offset | |
| 108 }; | |
| 109 | |
| 110 // Min and max WIDEN values. | |
| 111 enum WIDEN { | |
| 112 WidenMin = 0, | |
| 113 WidenMax = 3 | |
| 114 }; | |
| 115 | |
| 116 private: | |
| 117 // Dictionary of types shared among compilations. | |
| 118 static Dict* _shared_type_dict; | |
| 119 | |
| 120 static int uhash( const Type *const t ); | |
| 121 // Structural equality check. Assumes that cmp() has already compared | |
| 122 // the _base types and thus knows it can cast 't' appropriately. | |
| 123 virtual bool eq( const Type *t ) const; | |
| 124 | |
| 125 // Top-level hash-table of types | |
| 126 static Dict *type_dict() { | |
| 127 return Compile::current()->type_dict(); | |
| 128 } | |
| 129 | |
| 130 // DUAL operation: reflect around lattice centerline. Used instead of | |
| 131 // join to ensure my lattice is symmetric up and down. Dual is computed | |
| 132 // lazily, on demand, and cached in _dual. | |
| 133 const Type *_dual; // Cached dual value | |
| 134 // Table for efficient dualing of base types | |
| 135 static const TYPES dual_type[lastype]; | |
| 136 | |
| 137 protected: | |
| 138 // Each class of type is also identified by its base. | |
| 139 const TYPES _base; // Enum of Types type | |
| 140 | |
| 141 Type( TYPES t ) : _dual(NULL), _base(t) {} // Simple types | |
| 142 // ~Type(); // Use fast deallocation | |
| 143 const Type *hashcons(); // Hash-cons the type | |
| 144 | |
| 145 public: | |
| 146 | |
| 147 inline void* operator new( size_t x ) { | |
| 148 Compile* compile = Compile::current(); | |
| 149 compile->set_type_last_size(x); | |
| 150 void *temp = compile->type_arena()->Amalloc_D(x); | |
| 151 compile->set_type_hwm(temp); | |
| 152 return temp; | |
| 153 } | |
| 154 inline void operator delete( void* ptr ) { | |
| 155 Compile* compile = Compile::current(); | |
| 156 compile->type_arena()->Afree(ptr,compile->type_last_size()); | |
| 157 } | |
| 158 | |
| 159 // Initialize the type system for a particular compilation. | |
| 160 static void Initialize(Compile* compile); | |
| 161 | |
| 162 // Initialize the types shared by all compilations. | |
| 163 static void Initialize_shared(Compile* compile); | |
| 164 | |
| 165 TYPES base() const { | |
| 166 assert(_base > Bad && _base < lastype, "sanity"); | |
| 167 return _base; | |
| 168 } | |
| 169 | |
| 170 // Create a new hash-consd type | |
| 171 static const Type *make(enum TYPES); | |
| 172 // Test for equivalence of types | |
| 173 static int cmp( const Type *const t1, const Type *const t2 ); | |
| 174 // Test for higher or equal in lattice | |
| 175 int higher_equal( const Type *t ) const { return !cmp(meet(t),t); } | |
| 176 | |
| 177 // MEET operation; lower in lattice. | |
| 178 const Type *meet( const Type *t ) const; | |
| 179 // 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
|
180 virtual const Type *widen( const Type *old, const Type* limit ) const { return this; } |
| 0 | 181 // NARROW: complement for widen, used by pessimistic phases |
| 182 virtual const Type *narrow( const Type *old ) const { return this; } | |
| 183 | |
| 184 // DUAL operation: reflect around lattice centerline. Used instead of | |
| 185 // join to ensure my lattice is symmetric up and down. | |
| 186 const Type *dual() const { return _dual; } | |
| 187 | |
| 188 // Compute meet dependent on base type | |
| 189 virtual const Type *xmeet( const Type *t ) const; | |
| 190 virtual const Type *xdual() const; // Compute dual right now. | |
| 191 | |
| 192 // JOIN operation; higher in lattice. Done by finding the dual of the | |
| 193 // meet of the dual of the 2 inputs. | |
| 194 const Type *join( const Type *t ) const { | |
| 195 return dual()->meet(t->dual())->dual(); } | |
| 196 | |
| 197 // Modified version of JOIN adapted to the needs Node::Value. | |
| 198 // Normalizes all empty values to TOP. Does not kill _widen bits. | |
| 199 // Currently, it also works around limitations involving interface types. | |
| 200 virtual const Type *filter( const Type *kills ) const; | |
| 201 | |
|
820
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
202 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
203 // One type is interface, the other is oop |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
204 virtual bool interface_vs_oop(const Type *t) const; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
205 #endif |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
206 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
207 // Returns true if this pointer points at memory which contains a |
| 163 | 208 // compressed oop references. |
| 209 bool is_ptr_to_narrowoop() const; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
210 |
| 0 | 211 // Convenience access |
| 212 float getf() const; | |
| 213 double getd() const; | |
| 214 | |
| 215 const TypeInt *is_int() const; | |
| 216 const TypeInt *isa_int() const; // Returns NULL if not an Int | |
| 217 const TypeLong *is_long() const; | |
| 218 const TypeLong *isa_long() const; // Returns NULL if not a Long | |
| 219 const TypeD *is_double_constant() const; // Asserts it is a DoubleCon | |
| 220 const TypeD *isa_double_constant() const; // Returns NULL if not a DoubleCon | |
| 221 const TypeF *is_float_constant() const; // Asserts it is a FloatCon | |
| 222 const TypeF *isa_float_constant() const; // Returns NULL if not a FloatCon | |
| 223 const TypeTuple *is_tuple() const; // Collection of fields, NOT a pointer | |
| 224 const TypeAry *is_ary() const; // Array, NOT array pointer | |
| 225 const TypePtr *is_ptr() const; // Asserts it is a ptr type | |
| 226 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
|
227 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
|
228 const TypeRawPtr *is_rawptr() const; // Asserts is rawptr |
| 163 | 229 const TypeNarrowOop *is_narrowoop() const; // Java-style GC'd pointer |
| 230 const TypeNarrowOop *isa_narrowoop() 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
|
231 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
|
232 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
|
233 const TypeKlassPtr *isa_klassptr() const; // Returns NULL if not KlassPtr |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
234 const TypeKlassPtr *is_klassptr() const; // assert if not KlassPtr |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
235 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
|
236 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
|
237 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
|
238 const TypeAryPtr *is_aryptr() const; // Array oop |
| 0 | 239 virtual bool is_finite() const; // Has a finite value |
| 240 virtual bool is_nan() const; // Is not a number (NaN) | |
| 241 | |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
242 // 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
|
243 const TypePtr* make_ptr() const; |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
244 |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
245 // 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
|
246 // 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
|
247 const TypeOopPtr* make_oopptr() const; |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
248 |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
249 // 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
|
250 // of this pointer type. |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
251 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
|
252 |
| 0 | 253 // Special test for register pressure heuristic |
| 254 bool is_floatingpoint() const; // True if Float or Double base type | |
| 255 | |
| 256 // Do you have memory, directly or through a tuple? | |
| 257 bool has_memory( ) const; | |
| 258 | |
| 259 // Are you a pointer type or not? | |
| 260 bool isa_oop_ptr() const; | |
| 261 | |
| 262 // TRUE if type is a singleton | |
| 263 virtual bool singleton(void) const; | |
| 264 | |
| 265 // TRUE if type is above the lattice centerline, and is therefore vacuous | |
| 266 virtual bool empty(void) const; | |
| 267 | |
| 268 // Return a hash for this type. The hash function is public so ConNode | |
| 269 // (constants) can hash on their constant, which is represented by a Type. | |
| 270 virtual int hash() const; | |
| 271 | |
| 272 // Map ideal registers (machine types) to ideal types | |
| 273 static const Type *mreg2type[]; | |
| 274 | |
| 275 // Printing, statistics | |
| 276 static const char * const msg[lastype]; // Printable strings | |
| 277 #ifndef PRODUCT | |
| 278 void dump_on(outputStream *st) const; | |
| 279 void dump() const { | |
| 280 dump_on(tty); | |
| 281 } | |
| 282 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 283 static void dump_stats(); | |
| 284 static void verify_lastype(); // Check that arrays match type enum | |
| 285 #endif | |
| 286 void typerr(const Type *t) const; // Mixing types error | |
| 287 | |
| 288 // Create basic type | |
| 289 static const Type* get_const_basic_type(BasicType type) { | |
| 290 assert((uint)type <= T_CONFLICT && _const_basic_type[type] != NULL, "bad type"); | |
| 291 return _const_basic_type[type]; | |
| 292 } | |
| 293 | |
| 294 // Mapping to the array element's basic type. | |
| 295 BasicType array_element_basic_type() const; | |
| 296 | |
| 297 // Create standard type for a ciType: | |
| 298 static const Type* get_const_type(ciType* type); | |
| 299 | |
| 300 // Create standard zero value: | |
| 301 static const Type* get_zero_type(BasicType type) { | |
| 302 assert((uint)type <= T_CONFLICT && _zero_type[type] != NULL, "bad type"); | |
| 303 return _zero_type[type]; | |
| 304 } | |
| 305 | |
| 306 // Report if this is a zero value (not top). | |
| 307 bool is_zero_type() const { | |
| 308 BasicType type = basic_type(); | |
| 309 if (type == T_VOID || type >= T_CONFLICT) | |
| 310 return false; | |
| 311 else | |
| 312 return (this == _zero_type[type]); | |
| 313 } | |
| 314 | |
| 315 // Convenience common pre-built types. | |
| 316 static const Type *ABIO; | |
| 317 static const Type *BOTTOM; | |
| 318 static const Type *CONTROL; | |
| 319 static const Type *DOUBLE; | |
| 320 static const Type *FLOAT; | |
| 321 static const Type *HALF; | |
| 322 static const Type *MEMORY; | |
| 323 static const Type *MULTI; | |
| 324 static const Type *RETURN_ADDRESS; | |
| 325 static const Type *TOP; | |
| 326 | |
| 327 // Mapping from compiler type to VM BasicType | |
| 328 BasicType basic_type() const { return _basic_type[_base]; } | |
| 329 | |
| 330 // Mapping from CI type system to compiler type: | |
| 331 static const Type* get_typeflow_type(ciType* type); | |
| 332 | |
| 333 private: | |
| 334 // support arrays | |
| 335 static const BasicType _basic_type[]; | |
| 336 static const Type* _zero_type[T_CONFLICT+1]; | |
| 337 static const Type* _const_basic_type[T_CONFLICT+1]; | |
| 338 }; | |
| 339 | |
| 340 //------------------------------TypeF------------------------------------------ | |
| 341 // Class of Float-Constant Types. | |
| 342 class TypeF : public Type { | |
| 343 TypeF( float f ) : Type(FloatCon), _f(f) {}; | |
| 344 public: | |
| 345 virtual bool eq( const Type *t ) const; | |
| 346 virtual int hash() const; // Type specific hashing | |
| 347 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 348 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 349 public: | |
| 350 const float _f; // Float constant | |
| 351 | |
| 352 static const TypeF *make(float f); | |
| 353 | |
| 354 virtual bool is_finite() const; // Has a finite value | |
| 355 virtual bool is_nan() const; // Is not a number (NaN) | |
| 356 | |
| 357 virtual const Type *xmeet( const Type *t ) const; | |
| 358 virtual const Type *xdual() const; // Compute dual right now. | |
| 359 // Convenience common pre-built types. | |
| 360 static const TypeF *ZERO; // positive zero only | |
| 361 static const TypeF *ONE; | |
| 362 #ifndef PRODUCT | |
| 363 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 364 #endif | |
| 365 }; | |
| 366 | |
| 367 //------------------------------TypeD------------------------------------------ | |
| 368 // Class of Double-Constant Types. | |
| 369 class TypeD : public Type { | |
| 370 TypeD( double d ) : Type(DoubleCon), _d(d) {}; | |
| 371 public: | |
| 372 virtual bool eq( const Type *t ) const; | |
| 373 virtual int hash() const; // Type specific hashing | |
| 374 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 375 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 376 public: | |
| 377 const double _d; // Double constant | |
| 378 | |
| 379 static const TypeD *make(double d); | |
| 380 | |
| 381 virtual bool is_finite() const; // Has a finite value | |
| 382 virtual bool is_nan() const; // Is not a number (NaN) | |
| 383 | |
| 384 virtual const Type *xmeet( const Type *t ) const; | |
| 385 virtual const Type *xdual() const; // Compute dual right now. | |
| 386 // Convenience common pre-built types. | |
| 387 static const TypeD *ZERO; // positive zero only | |
| 388 static const TypeD *ONE; | |
| 389 #ifndef PRODUCT | |
| 390 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 391 #endif | |
| 392 }; | |
| 393 | |
| 394 //------------------------------TypeInt---------------------------------------- | |
| 395 // Class of integer ranges, the set of integers between a lower bound and an | |
| 396 // upper bound, inclusive. | |
| 397 class TypeInt : public Type { | |
| 398 TypeInt( jint lo, jint hi, int w ); | |
| 399 public: | |
| 400 virtual bool eq( const Type *t ) const; | |
| 401 virtual int hash() const; // Type specific hashing | |
| 402 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 403 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 404 public: | |
| 405 const jint _lo, _hi; // Lower bound, upper bound | |
| 406 const short _widen; // Limit on times we widen this sucker | |
| 407 | |
| 408 static const TypeInt *make(jint lo); | |
| 409 // must always specify w | |
| 410 static const TypeInt *make(jint lo, jint hi, int w); | |
| 411 | |
| 412 // Check for single integer | |
| 413 int is_con() const { return _lo==_hi; } | |
| 414 bool is_con(int i) const { return is_con() && _lo == i; } | |
| 415 jint get_con() const { assert( is_con(), "" ); return _lo; } | |
| 416 | |
| 417 virtual bool is_finite() const; // Has a finite value | |
| 418 | |
| 419 virtual const Type *xmeet( const Type *t ) const; | |
| 420 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
|
421 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
| 0 | 422 virtual const Type *narrow( const Type *t ) const; |
| 423 // Do not kill _widen bits. | |
| 424 virtual const Type *filter( const Type *kills ) const; | |
| 425 // Convenience common pre-built types. | |
| 426 static const TypeInt *MINUS_1; | |
| 427 static const TypeInt *ZERO; | |
| 428 static const TypeInt *ONE; | |
| 429 static const TypeInt *BOOL; | |
| 430 static const TypeInt *CC; | |
| 431 static const TypeInt *CC_LT; // [-1] == MINUS_1 | |
| 432 static const TypeInt *CC_GT; // [1] == ONE | |
| 433 static const TypeInt *CC_EQ; // [0] == ZERO | |
| 434 static const TypeInt *CC_LE; // [-1,0] | |
| 435 static const TypeInt *CC_GE; // [0,1] == BOOL (!) | |
| 436 static const TypeInt *BYTE; | |
| 624 | 437 static const TypeInt *UBYTE; |
| 0 | 438 static const TypeInt *CHAR; |
| 439 static const TypeInt *SHORT; | |
| 440 static const TypeInt *POS; | |
| 441 static const TypeInt *POS1; | |
| 442 static const TypeInt *INT; | |
| 443 static const TypeInt *SYMINT; // symmetric range [-max_jint..max_jint] | |
| 444 #ifndef PRODUCT | |
| 445 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 446 #endif | |
| 447 }; | |
| 448 | |
| 449 | |
| 450 //------------------------------TypeLong--------------------------------------- | |
| 451 // Class of long integer ranges, the set of integers between a lower bound and | |
| 452 // an upper bound, inclusive. | |
| 453 class TypeLong : public Type { | |
| 454 TypeLong( jlong lo, jlong hi, int w ); | |
| 455 public: | |
| 456 virtual bool eq( const Type *t ) const; | |
| 457 virtual int hash() const; // Type specific hashing | |
| 458 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 459 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 460 public: | |
| 461 const jlong _lo, _hi; // Lower bound, upper bound | |
| 462 const short _widen; // Limit on times we widen this sucker | |
| 463 | |
| 464 static const TypeLong *make(jlong lo); | |
| 465 // must always specify w | |
| 466 static const TypeLong *make(jlong lo, jlong hi, int w); | |
| 467 | |
| 468 // Check for single integer | |
| 469 int is_con() const { return _lo==_hi; } | |
| 145 | 470 bool is_con(int i) const { return is_con() && _lo == i; } |
| 0 | 471 jlong get_con() const { assert( is_con(), "" ); return _lo; } |
| 472 | |
| 473 virtual bool is_finite() const; // Has a finite value | |
| 474 | |
| 475 virtual const Type *xmeet( const Type *t ) const; | |
| 476 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
|
477 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
| 0 | 478 virtual const Type *narrow( const Type *t ) const; |
| 479 // Do not kill _widen bits. | |
| 480 virtual const Type *filter( const Type *kills ) const; | |
| 481 // Convenience common pre-built types. | |
| 482 static const TypeLong *MINUS_1; | |
| 483 static const TypeLong *ZERO; | |
| 484 static const TypeLong *ONE; | |
| 485 static const TypeLong *POS; | |
| 486 static const TypeLong *LONG; | |
| 487 static const TypeLong *INT; // 32-bit subrange [min_jint..max_jint] | |
| 488 static const TypeLong *UINT; // 32-bit unsigned [0..max_juint] | |
| 489 #ifndef PRODUCT | |
| 490 virtual void dump2( Dict &d, uint, outputStream *st ) const;// Specialized per-Type dumping | |
| 491 #endif | |
| 492 }; | |
| 493 | |
| 494 //------------------------------TypeTuple-------------------------------------- | |
| 495 // Class of Tuple Types, essentially type collections for function signatures | |
| 496 // and class layouts. It happens to also be a fast cache for the HotSpot | |
| 497 // signature types. | |
| 498 class TypeTuple : public Type { | |
| 499 TypeTuple( uint cnt, const Type **fields ) : Type(Tuple), _cnt(cnt), _fields(fields) { } | |
| 500 public: | |
| 501 virtual bool eq( const Type *t ) const; | |
| 502 virtual int hash() const; // Type specific hashing | |
| 503 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 504 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 505 | |
| 506 public: | |
| 507 const uint _cnt; // Count of fields | |
| 508 const Type ** const _fields; // Array of field types | |
| 509 | |
| 510 // Accessors: | |
| 511 uint cnt() const { return _cnt; } | |
| 512 const Type* field_at(uint i) const { | |
| 513 assert(i < _cnt, "oob"); | |
| 514 return _fields[i]; | |
| 515 } | |
| 516 void set_field_at(uint i, const Type* t) { | |
| 517 assert(i < _cnt, "oob"); | |
| 518 _fields[i] = t; | |
| 519 } | |
| 520 | |
| 521 static const TypeTuple *make( uint cnt, const Type **fields ); | |
| 522 static const TypeTuple *make_range(ciSignature *sig); | |
| 523 static const TypeTuple *make_domain(ciInstanceKlass* recv, ciSignature *sig); | |
| 524 | |
| 525 // Subroutine call type with space allocated for argument types | |
| 526 static const Type **fields( uint arg_cnt ); | |
| 527 | |
| 528 virtual const Type *xmeet( const Type *t ) const; | |
| 529 virtual const Type *xdual() const; // Compute dual right now. | |
| 530 // Convenience common pre-built types. | |
| 531 static const TypeTuple *IFBOTH; | |
| 532 static const TypeTuple *IFFALSE; | |
| 533 static const TypeTuple *IFTRUE; | |
| 534 static const TypeTuple *IFNEITHER; | |
| 535 static const TypeTuple *LOOPBODY; | |
| 536 static const TypeTuple *MEMBAR; | |
| 537 static const TypeTuple *STORECONDITIONAL; | |
| 538 static const TypeTuple *START_I2C; | |
| 539 static const TypeTuple *INT_PAIR; | |
| 540 static const TypeTuple *LONG_PAIR; | |
| 541 #ifndef PRODUCT | |
| 542 virtual void dump2( Dict &d, uint, outputStream *st ) const; // Specialized per-Type dumping | |
| 543 #endif | |
| 544 }; | |
| 545 | |
| 546 //------------------------------TypeAry---------------------------------------- | |
| 547 // Class of Array Types | |
| 548 class TypeAry : public Type { | |
| 549 TypeAry( const Type *elem, const TypeInt *size) : Type(Array), | |
| 550 _elem(elem), _size(size) {} | |
| 551 public: | |
| 552 virtual bool eq( const Type *t ) const; | |
| 553 virtual int hash() const; // Type specific hashing | |
| 554 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 555 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 556 | |
| 557 private: | |
| 558 const Type *_elem; // Element type of array | |
| 559 const TypeInt *_size; // Elements in array | |
| 560 friend class TypeAryPtr; | |
| 561 | |
| 562 public: | |
| 563 static const TypeAry *make( const Type *elem, const TypeInt *size); | |
| 564 | |
| 565 virtual const Type *xmeet( const Type *t ) const; | |
| 566 virtual const Type *xdual() const; // Compute dual right now. | |
| 567 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
|
568 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
569 // One type is interface, the other is oop |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
570 virtual bool interface_vs_oop(const Type *t) const; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
571 #endif |
| 0 | 572 #ifndef PRODUCT |
| 573 virtual void dump2( Dict &d, uint, outputStream *st ) const; // Specialized per-Type dumping | |
| 574 #endif | |
| 575 }; | |
| 576 | |
| 577 //------------------------------TypePtr---------------------------------------- | |
| 578 // Class of machine Pointer Types: raw data, instances or arrays. | |
| 579 // If the _base enum is AnyPtr, then this refers to all of the above. | |
| 580 // Otherwise the _base will indicate which subset of pointers is affected, | |
| 581 // and the class will be inherited from. | |
| 582 class TypePtr : public Type { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
583 friend class TypeNarrowOop; |
| 0 | 584 public: |
| 585 enum PTR { TopPTR, AnyNull, Constant, Null, NotNull, BotPTR, lastPTR }; | |
| 586 protected: | |
| 587 TypePtr( TYPES t, PTR ptr, int offset ) : Type(t), _ptr(ptr), _offset(offset) {} | |
| 588 virtual bool eq( const Type *t ) const; | |
| 589 virtual int hash() const; // Type specific hashing | |
| 590 static const PTR ptr_meet[lastPTR][lastPTR]; | |
| 591 static const PTR ptr_dual[lastPTR]; | |
| 592 static const char * const ptr_msg[lastPTR]; | |
| 593 | |
| 594 public: | |
| 595 const int _offset; // Offset into oop, with TOP & BOT | |
| 596 const PTR _ptr; // Pointer equivalence class | |
| 597 | |
| 598 const int offset() const { return _offset; } | |
| 599 const PTR ptr() const { return _ptr; } | |
| 600 | |
| 601 static const TypePtr *make( TYPES t, PTR ptr, int offset ); | |
| 602 | |
| 603 // Return a 'ptr' version of this type | |
| 604 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 605 | |
| 606 virtual intptr_t get_con() const; | |
| 607 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
608 int xadd_offset( intptr_t offset ) const; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
609 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 610 |
| 611 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 612 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 613 virtual const Type *xmeet( const Type *t ) const; | |
| 614 int meet_offset( int offset ) const; | |
| 615 int dual_offset( ) const; | |
| 616 virtual const Type *xdual() const; // Compute dual right now. | |
| 617 | |
| 618 // meet, dual and join over pointer equivalence sets | |
| 619 PTR meet_ptr( const PTR in_ptr ) const { return ptr_meet[in_ptr][ptr()]; } | |
| 620 PTR dual_ptr() const { return ptr_dual[ptr()]; } | |
| 621 | |
| 622 // This is textually confusing unless one recalls that | |
| 623 // join(t) == dual()->meet(t->dual())->dual(). | |
| 624 PTR join_ptr( const PTR in_ptr ) const { | |
| 625 return ptr_dual[ ptr_meet[ ptr_dual[in_ptr] ] [ dual_ptr() ] ]; | |
| 626 } | |
| 627 | |
| 628 // Tests for relation to centerline of type lattice: | |
| 629 static bool above_centerline(PTR ptr) { return (ptr <= AnyNull); } | |
| 630 static bool below_centerline(PTR ptr) { return (ptr >= NotNull); } | |
| 631 // Convenience common pre-built types. | |
| 632 static const TypePtr *NULL_PTR; | |
| 633 static const TypePtr *NOTNULL; | |
| 634 static const TypePtr *BOTTOM; | |
| 635 #ifndef PRODUCT | |
| 636 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 637 #endif | |
| 638 }; | |
| 639 | |
| 640 //------------------------------TypeRawPtr------------------------------------- | |
| 641 // Class of raw pointers, pointers to things other than Oops. Examples | |
| 642 // include the stack pointer, top of heap, card-marking area, handles, etc. | |
| 643 class TypeRawPtr : public TypePtr { | |
| 644 protected: | |
| 645 TypeRawPtr( PTR ptr, address bits ) : TypePtr(RawPtr,ptr,0), _bits(bits){} | |
| 646 public: | |
| 647 virtual bool eq( const Type *t ) const; | |
| 648 virtual int hash() const; // Type specific hashing | |
| 649 | |
| 650 const address _bits; // Constant value, if applicable | |
| 651 | |
| 652 static const TypeRawPtr *make( PTR ptr ); | |
| 653 static const TypeRawPtr *make( address bits ); | |
| 654 | |
| 655 // Return a 'ptr' version of this type | |
| 656 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 657 | |
| 658 virtual intptr_t get_con() const; | |
| 659 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
660 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 661 |
| 662 virtual const Type *xmeet( const Type *t ) const; | |
| 663 virtual const Type *xdual() const; // Compute dual right now. | |
| 664 // Convenience common pre-built types. | |
| 665 static const TypeRawPtr *BOTTOM; | |
| 666 static const TypeRawPtr *NOTNULL; | |
| 667 #ifndef PRODUCT | |
| 668 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 669 #endif | |
| 670 }; | |
| 671 | |
| 672 //------------------------------TypeOopPtr------------------------------------- | |
| 673 // Some kind of oop (Java pointer), either klass or instance or array. | |
| 674 class TypeOopPtr : public TypePtr { | |
| 675 protected: | |
| 163 | 676 TypeOopPtr( TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id ); |
| 0 | 677 public: |
| 678 virtual bool eq( const Type *t ) const; | |
| 679 virtual int hash() const; // Type specific hashing | |
| 680 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 681 enum { | |
| 223 | 682 InstanceTop = -1, // undefined instance |
| 683 InstanceBot = 0 // any possible instance | |
| 0 | 684 }; |
| 685 protected: | |
| 686 | |
| 687 // Oop is NULL, unless this is a constant oop. | |
| 688 ciObject* _const_oop; // Constant oop | |
| 689 // If _klass is NULL, then so is _sig. This is an unloaded klass. | |
| 690 ciKlass* _klass; // Klass object | |
| 691 // Does the type exclude subclasses of the klass? (Inexact == polymorphic.) | |
| 692 bool _klass_is_exact; | |
| 163 | 693 bool _is_ptr_to_narrowoop; |
| 0 | 694 |
| 223 | 695 // If not InstanceTop or InstanceBot, indicates that this is |
| 696 // a particular instance of this type which is distinct. | |
| 697 // This is the the node index of the allocation node creating this instance. | |
| 698 int _instance_id; | |
| 0 | 699 |
| 700 static const TypeOopPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact); | |
| 701 | |
| 223 | 702 int dual_instance_id() const; |
| 703 int meet_instance_id(int uid) const; | |
| 0 | 704 |
| 705 public: | |
| 706 // Creates a type given a klass. Correctly handles multi-dimensional arrays | |
| 707 // Respects UseUniqueSubclasses. | |
| 708 // If the klass is final, the resulting type will be exact. | |
| 709 static const TypeOopPtr* make_from_klass(ciKlass* klass) { | |
| 710 return make_from_klass_common(klass, true, false); | |
| 711 } | |
| 712 // Same as before, but will produce an exact type, even if | |
| 713 // the klass is not final, as long as it has exactly one implementation. | |
| 714 static const TypeOopPtr* make_from_klass_unique(ciKlass* klass) { | |
| 715 return make_from_klass_common(klass, true, true); | |
| 716 } | |
| 717 // Same as before, but does not respects UseUniqueSubclasses. | |
| 718 // Use this only for creating array element types. | |
| 719 static const TypeOopPtr* make_from_klass_raw(ciKlass* klass) { | |
| 720 return make_from_klass_common(klass, false, false); | |
| 721 } | |
| 722 // 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
|
723 // 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
|
724 // may return a non-singleton type. |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
958
diff
changeset
|
725 // 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
|
726 static const TypeOopPtr* make_from_constant(ciObject* o, bool require_constant = false); |
| 0 | 727 |
| 728 // Make a generic (unclassed) pointer to an oop. | |
| 992 | 729 static const TypeOopPtr* make(PTR ptr, int offset, int instance_id); |
| 0 | 730 |
| 731 ciObject* const_oop() const { return _const_oop; } | |
| 732 virtual ciKlass* klass() const { return _klass; } | |
| 733 bool klass_is_exact() const { return _klass_is_exact; } | |
| 163 | 734 |
| 735 // Returns true if this pointer points at memory which contains a | |
| 736 // compressed oop references. | |
| 737 bool is_ptr_to_narrowoop_nv() const { return _is_ptr_to_narrowoop; } | |
| 738 | |
| 223 | 739 bool is_known_instance() const { return _instance_id > 0; } |
| 740 int instance_id() const { return _instance_id; } | |
| 741 bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; } | |
| 0 | 742 |
| 743 virtual intptr_t get_con() const; | |
| 744 | |
| 745 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 746 | |
| 747 virtual const Type *cast_to_exactness(bool klass_is_exact) const; | |
| 748 | |
| 223 | 749 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
| 0 | 750 |
| 751 // corresponding pointer to klass, for a given instance | |
| 752 const TypeKlassPtr* as_klass_type() const; | |
| 753 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
754 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 755 |
| 756 virtual const Type *xmeet( const Type *t ) const; | |
| 757 virtual const Type *xdual() const; // Compute dual right now. | |
| 758 | |
| 759 // Do not allow interface-vs.-noninterface joins to collapse to top. | |
| 760 virtual const Type *filter( const Type *kills ) const; | |
| 761 | |
| 762 // Convenience common pre-built type. | |
| 763 static const TypeOopPtr *BOTTOM; | |
| 764 #ifndef PRODUCT | |
| 765 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; | |
| 766 #endif | |
| 767 }; | |
| 768 | |
| 769 //------------------------------TypeInstPtr------------------------------------ | |
| 770 // Class of Java object pointers, pointing either to non-array Java instances | |
| 771 // or to a klassOop (including array klasses). | |
| 772 class TypeInstPtr : public TypeOopPtr { | |
| 773 TypeInstPtr( PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id ); | |
| 774 virtual bool eq( const Type *t ) const; | |
| 775 virtual int hash() const; // Type specific hashing | |
| 776 | |
| 777 ciSymbol* _name; // class name | |
| 778 | |
| 779 public: | |
| 780 ciSymbol* name() const { return _name; } | |
| 781 | |
| 782 bool is_loaded() const { return _klass->is_loaded(); } | |
| 783 | |
| 784 // Make a pointer to a constant oop. | |
| 785 static const TypeInstPtr *make(ciObject* o) { | |
| 786 return make(TypePtr::Constant, o->klass(), true, o, 0); | |
| 787 } | |
| 788 | |
| 789 // Make a pointer to a constant oop with offset. | |
| 790 static const TypeInstPtr *make(ciObject* o, int offset) { | |
| 791 return make(TypePtr::Constant, o->klass(), true, o, offset); | |
| 792 } | |
| 793 | |
| 794 // Make a pointer to some value of type klass. | |
| 795 static const TypeInstPtr *make(PTR ptr, ciKlass* klass) { | |
| 796 return make(ptr, klass, false, NULL, 0); | |
| 797 } | |
| 798 | |
| 799 // Make a pointer to some non-polymorphic value of exactly type klass. | |
| 800 static const TypeInstPtr *make_exact(PTR ptr, ciKlass* klass) { | |
| 801 return make(ptr, klass, true, NULL, 0); | |
| 802 } | |
| 803 | |
| 804 // Make a pointer to some value of type klass with offset. | |
| 805 static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) { | |
| 806 return make(ptr, klass, false, NULL, offset); | |
| 807 } | |
| 808 | |
| 809 // Make a pointer to an oop. | |
| 223 | 810 static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot ); |
| 0 | 811 |
| 812 // If this is a java.lang.Class constant, return the type for it or NULL. | |
| 813 // Pass to Type::get_const_type to turn it to a type, which will usually | |
| 814 // be a TypeInstPtr, but may also be a TypeInt::INT for int.class, etc. | |
| 815 ciType* java_mirror_type() const; | |
| 816 | |
| 817 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 818 | |
| 819 virtual const Type *cast_to_exactness(bool klass_is_exact) const; | |
| 820 | |
| 223 | 821 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
| 0 | 822 |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
823 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 824 |
| 825 virtual const Type *xmeet( const Type *t ) const; | |
| 826 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const; | |
| 827 virtual const Type *xdual() const; // Compute dual right now. | |
| 828 | |
| 829 // Convenience common pre-built types. | |
| 830 static const TypeInstPtr *NOTNULL; | |
| 831 static const TypeInstPtr *BOTTOM; | |
| 832 static const TypeInstPtr *MIRROR; | |
| 833 static const TypeInstPtr *MARK; | |
| 834 static const TypeInstPtr *KLASS; | |
| 835 #ifndef PRODUCT | |
| 836 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping | |
| 837 #endif | |
| 838 }; | |
| 839 | |
| 840 //------------------------------TypeAryPtr------------------------------------- | |
| 841 // Class of Java array pointers | |
| 842 class TypeAryPtr : public TypeOopPtr { | |
| 1761 | 843 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) { |
| 844 #ifdef ASSERT | |
| 845 if (k != NULL) { | |
| 846 // Verify that specified klass and TypeAryPtr::klass() follow the same rules. | |
| 847 ciKlass* ck = compute_klass(true); | |
| 1792 | 848 if (k != ck) { |
| 1761 | 849 this->dump(); tty->cr(); |
| 850 tty->print(" k: "); | |
| 851 k->print(); tty->cr(); | |
| 852 tty->print("ck: "); | |
| 853 if (ck != NULL) ck->print(); | |
| 854 else tty->print("<NULL>"); | |
| 855 tty->cr(); | |
| 856 assert(false, "unexpected TypeAryPtr::_klass"); | |
| 857 } | |
| 858 } | |
| 859 #endif | |
| 860 } | |
| 0 | 861 virtual bool eq( const Type *t ) const; |
| 862 virtual int hash() const; // Type specific hashing | |
| 863 const TypeAry *_ary; // Array we point into | |
| 864 | |
| 1761 | 865 ciKlass* compute_klass(DEBUG_ONLY(bool verify = false)) const; |
| 866 | |
| 0 | 867 public: |
| 868 // Accessors | |
| 869 ciKlass* klass() const; | |
| 870 const TypeAry* ary() const { return _ary; } | |
| 871 const Type* elem() const { return _ary->_elem; } | |
| 872 const TypeInt* size() const { return _ary->_size; } | |
| 873 | |
| 223 | 874 static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot); |
| 0 | 875 // Constant pointer to array |
| 223 | 876 static const TypeAryPtr *make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot); |
| 0 | 877 |
| 878 // Return a 'ptr' version of this type | |
| 879 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 880 | |
| 881 virtual const Type *cast_to_exactness(bool klass_is_exact) const; | |
| 882 | |
| 223 | 883 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
| 0 | 884 |
| 885 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
|
886 virtual const TypeInt* narrow_size_type(const TypeInt* size) const; |
| 0 | 887 |
| 888 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
|
889 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 890 |
| 891 virtual const Type *xmeet( const Type *t ) const; | |
| 892 virtual const Type *xdual() const; // Compute dual right now. | |
| 893 | |
| 894 // Convenience common pre-built types. | |
| 895 static const TypeAryPtr *RANGE; | |
| 896 static const TypeAryPtr *OOPS; | |
| 163 | 897 static const TypeAryPtr *NARROWOOPS; |
| 0 | 898 static const TypeAryPtr *BYTES; |
| 899 static const TypeAryPtr *SHORTS; | |
| 900 static const TypeAryPtr *CHARS; | |
| 901 static const TypeAryPtr *INTS; | |
| 902 static const TypeAryPtr *LONGS; | |
| 903 static const TypeAryPtr *FLOATS; | |
| 904 static const TypeAryPtr *DOUBLES; | |
| 905 // selects one of the above: | |
| 906 static const TypeAryPtr *get_array_body_type(BasicType elem) { | |
| 907 assert((uint)elem <= T_CONFLICT && _array_body_type[elem] != NULL, "bad elem type"); | |
| 908 return _array_body_type[elem]; | |
| 909 } | |
| 910 static const TypeAryPtr *_array_body_type[T_CONFLICT+1]; | |
| 911 // 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
|
912 #ifdef ASSERT |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
913 // One type is interface, the other is oop |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
914 virtual bool interface_vs_oop(const Type *t) const; |
|
915cc9c5ebc6
6837094: False positive for "meet not symmetric" failure
kvn
parents:
628
diff
changeset
|
915 #endif |
| 0 | 916 #ifndef PRODUCT |
| 917 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping | |
| 918 #endif | |
| 919 }; | |
| 920 | |
| 921 //------------------------------TypeKlassPtr----------------------------------- | |
| 922 // Class of Java Klass pointers | |
| 923 class TypeKlassPtr : public TypeOopPtr { | |
| 924 TypeKlassPtr( PTR ptr, ciKlass* klass, int offset ); | |
| 925 | |
| 926 virtual bool eq( const Type *t ) const; | |
| 927 virtual int hash() const; // Type specific hashing | |
| 928 | |
| 929 public: | |
| 930 ciSymbol* name() const { return _klass->name(); } | |
| 931 | |
| 555 | 932 bool is_loaded() const { return _klass->is_loaded(); } |
| 933 | |
| 0 | 934 // ptr to klass 'k' |
| 935 static const TypeKlassPtr *make( ciKlass* k ) { return make( TypePtr::Constant, k, 0); } | |
| 936 // ptr to klass 'k' with offset | |
| 937 static const TypeKlassPtr *make( ciKlass* k, int offset ) { return make( TypePtr::Constant, k, offset); } | |
| 938 // ptr to klass 'k' or sub-klass | |
| 939 static const TypeKlassPtr *make( PTR ptr, ciKlass* k, int offset); | |
| 940 | |
| 941 virtual const Type *cast_to_ptr_type(PTR ptr) const; | |
| 942 | |
| 943 virtual const Type *cast_to_exactness(bool klass_is_exact) const; | |
| 944 | |
| 945 // corresponding pointer to instance, for a given class | |
| 946 const TypeOopPtr* as_instance_type() const; | |
| 947 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
235
diff
changeset
|
948 virtual const TypePtr *add_offset( intptr_t offset ) const; |
| 0 | 949 virtual const Type *xmeet( const Type *t ) const; |
| 950 virtual const Type *xdual() const; // Compute dual right now. | |
| 951 | |
| 952 // Convenience common pre-built types. | |
| 953 static const TypeKlassPtr* OBJECT; // Not-null object klass or below | |
| 954 static const TypeKlassPtr* OBJECT_OR_NULL; // Maybe-null version of same | |
| 955 #ifndef PRODUCT | |
| 956 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping | |
| 957 #endif | |
| 958 }; | |
| 959 | |
| 163 | 960 //------------------------------TypeNarrowOop---------------------------------- |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
961 // A compressed reference to some kind of Oop. This type wraps around |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
962 // a preexisting TypeOopPtr and forwards most of it's operations to |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
963 // the underlying type. It's only real purpose is to track the |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
964 // oopness of the compressed oop value when we expose the conversion |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
965 // between the normal and the compressed form. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
966 class TypeNarrowOop : public Type { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
967 protected: |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
968 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
|
969 |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
970 TypeNarrowOop( const TypePtr* ptrtype): Type(NarrowOop), |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
971 _ptrtype(ptrtype) { |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
972 assert(ptrtype->offset() == 0 || |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
973 ptrtype->offset() == OffsetBot || |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
974 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
|
975 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
976 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
977 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
|
978 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
|
979 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
|
980 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
981 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
|
982 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
|
983 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
984 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
|
985 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
986 // 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
|
987 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
|
988 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
989 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
|
990 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
991 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
|
992 |
|
2379
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
1972
diff
changeset
|
993 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
|
994 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
|
995 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
996 |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
997 // returns the equivalent ptr type for this compressed pointer |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
998 const TypePtr *get_ptrtype() const { |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
999 return _ptrtype; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1000 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1001 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1002 static const TypeNarrowOop *BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1003 static const TypeNarrowOop *NULL_PTR; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1004 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1005 #ifndef PRODUCT |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1006 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
|
1007 #endif |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1008 }; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1009 |
| 0 | 1010 //------------------------------TypeFunc--------------------------------------- |
| 1011 // Class of Array Types | |
| 1012 class TypeFunc : public Type { | |
| 1013 TypeFunc( const TypeTuple *domain, const TypeTuple *range ) : Type(Function), _domain(domain), _range(range) {} | |
| 1014 virtual bool eq( const Type *t ) const; | |
| 1015 virtual int hash() const; // Type specific hashing | |
| 1016 virtual bool singleton(void) const; // TRUE if type is a singleton | |
| 1017 virtual bool empty(void) const; // TRUE if type is vacuous | |
| 1018 public: | |
| 1019 // Constants are shared among ADLC and VM | |
| 1020 enum { Control = AdlcVMDeps::Control, | |
| 1021 I_O = AdlcVMDeps::I_O, | |
| 1022 Memory = AdlcVMDeps::Memory, | |
| 1023 FramePtr = AdlcVMDeps::FramePtr, | |
| 1024 ReturnAdr = AdlcVMDeps::ReturnAdr, | |
| 1025 Parms = AdlcVMDeps::Parms | |
| 1026 }; | |
| 1027 | |
| 1028 const TypeTuple* const _domain; // Domain of inputs | |
| 1029 const TypeTuple* const _range; // Range of results | |
| 1030 | |
| 1031 // Accessors: | |
| 1032 const TypeTuple* domain() const { return _domain; } | |
| 1033 const TypeTuple* range() const { return _range; } | |
| 1034 | |
| 1035 static const TypeFunc *make(ciMethod* method); | |
| 1036 static const TypeFunc *make(ciSignature signature, const Type* extra); | |
| 1037 static const TypeFunc *make(const TypeTuple* domain, const TypeTuple* range); | |
| 1038 | |
| 1039 virtual const Type *xmeet( const Type *t ) const; | |
| 1040 virtual const Type *xdual() const; // Compute dual right now. | |
| 1041 | |
| 1042 BasicType return_type() const; | |
| 1043 | |
| 1044 #ifndef PRODUCT | |
| 1045 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping | |
| 1046 void print_flattened() const; // Print a 'flattened' signature | |
| 1047 #endif | |
| 1048 // Convenience common pre-built types. | |
| 1049 }; | |
| 1050 | |
| 1051 //------------------------------accessors-------------------------------------- | |
| 163 | 1052 inline bool Type::is_ptr_to_narrowoop() const { |
| 1053 #ifdef _LP64 | |
| 1054 return (isa_oopptr() != NULL && is_oopptr()->is_ptr_to_narrowoop_nv()); | |
| 1055 #else | |
| 1056 return false; | |
| 1057 #endif | |
| 1058 } | |
| 1059 | |
| 0 | 1060 inline float Type::getf() const { |
| 1061 assert( _base == FloatCon, "Not a FloatCon" ); | |
| 1062 return ((TypeF*)this)->_f; | |
| 1063 } | |
| 1064 | |
| 1065 inline double Type::getd() const { | |
| 1066 assert( _base == DoubleCon, "Not a DoubleCon" ); | |
| 1067 return ((TypeD*)this)->_d; | |
| 1068 } | |
| 1069 | |
| 1070 inline const TypeF *Type::is_float_constant() const { | |
| 1071 assert( _base == FloatCon, "Not a Float" ); | |
| 1072 return (TypeF*)this; | |
| 1073 } | |
| 1074 | |
| 1075 inline const TypeF *Type::isa_float_constant() const { | |
| 1076 return ( _base == FloatCon ? (TypeF*)this : NULL); | |
| 1077 } | |
| 1078 | |
| 1079 inline const TypeD *Type::is_double_constant() const { | |
| 1080 assert( _base == DoubleCon, "Not a Double" ); | |
| 1081 return (TypeD*)this; | |
| 1082 } | |
| 1083 | |
| 1084 inline const TypeD *Type::isa_double_constant() const { | |
| 1085 return ( _base == DoubleCon ? (TypeD*)this : NULL); | |
| 1086 } | |
| 1087 | |
| 1088 inline const TypeInt *Type::is_int() const { | |
| 1089 assert( _base == Int, "Not an Int" ); | |
| 1090 return (TypeInt*)this; | |
| 1091 } | |
| 1092 | |
| 1093 inline const TypeInt *Type::isa_int() const { | |
| 1094 return ( _base == Int ? (TypeInt*)this : NULL); | |
| 1095 } | |
| 1096 | |
| 1097 inline const TypeLong *Type::is_long() const { | |
| 1098 assert( _base == Long, "Not a Long" ); | |
| 1099 return (TypeLong*)this; | |
| 1100 } | |
| 1101 | |
| 1102 inline const TypeLong *Type::isa_long() const { | |
| 1103 return ( _base == Long ? (TypeLong*)this : NULL); | |
| 1104 } | |
| 1105 | |
| 1106 inline const TypeTuple *Type::is_tuple() const { | |
| 1107 assert( _base == Tuple, "Not a Tuple" ); | |
| 1108 return (TypeTuple*)this; | |
| 1109 } | |
| 1110 | |
| 1111 inline const TypeAry *Type::is_ary() const { | |
| 1112 assert( _base == Array , "Not an Array" ); | |
| 1113 return (TypeAry*)this; | |
| 1114 } | |
| 1115 | |
| 1116 inline const TypePtr *Type::is_ptr() const { | |
| 1117 // AnyPtr is the first Ptr and KlassPtr the last, with no non-ptrs between. | |
| 1118 assert(_base >= AnyPtr && _base <= KlassPtr, "Not a pointer"); | |
| 1119 return (TypePtr*)this; | |
| 1120 } | |
| 1121 | |
| 1122 inline const TypePtr *Type::isa_ptr() const { | |
| 1123 // AnyPtr is the first Ptr and KlassPtr the last, with no non-ptrs between. | |
| 1124 return (_base >= AnyPtr && _base <= KlassPtr) ? (TypePtr*)this : NULL; | |
| 1125 } | |
| 1126 | |
| 1127 inline const TypeOopPtr *Type::is_oopptr() const { | |
| 1128 // OopPtr is the first and KlassPtr the last, with no non-oops between. | |
| 1129 assert(_base >= OopPtr && _base <= KlassPtr, "Not a Java pointer" ) ; | |
| 1130 return (TypeOopPtr*)this; | |
| 1131 } | |
| 1132 | |
| 1133 inline const TypeOopPtr *Type::isa_oopptr() const { | |
| 1134 // OopPtr is the first and KlassPtr the last, with no non-oops between. | |
| 1135 return (_base >= OopPtr && _base <= KlassPtr) ? (TypeOopPtr*)this : NULL; | |
| 1136 } | |
| 1137 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1138 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
|
1139 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
|
1140 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1141 |
| 0 | 1142 inline const TypeRawPtr *Type::is_rawptr() const { |
| 1143 assert( _base == RawPtr, "Not a raw pointer" ); | |
| 1144 return (TypeRawPtr*)this; | |
| 1145 } | |
| 1146 | |
| 1147 inline const TypeInstPtr *Type::isa_instptr() const { | |
| 1148 return (_base == InstPtr) ? (TypeInstPtr*)this : NULL; | |
| 1149 } | |
| 1150 | |
| 1151 inline const TypeInstPtr *Type::is_instptr() const { | |
| 1152 assert( _base == InstPtr, "Not an object pointer" ); | |
| 1153 return (TypeInstPtr*)this; | |
| 1154 } | |
| 1155 | |
| 1156 inline const TypeAryPtr *Type::isa_aryptr() const { | |
| 1157 return (_base == AryPtr) ? (TypeAryPtr*)this : NULL; | |
| 1158 } | |
| 1159 | |
| 1160 inline const TypeAryPtr *Type::is_aryptr() const { | |
| 1161 assert( _base == AryPtr, "Not an array pointer" ); | |
| 1162 return (TypeAryPtr*)this; | |
| 1163 } | |
| 1164 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1165 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
|
1166 // 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
|
1167 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
|
1168 return (TypeNarrowOop*)this; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1169 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1170 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1171 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
|
1172 // 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
|
1173 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
|
1174 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1175 |
| 0 | 1176 inline const TypeKlassPtr *Type::isa_klassptr() const { |
| 1177 return (_base == KlassPtr) ? (TypeKlassPtr*)this : NULL; | |
| 1178 } | |
| 1179 | |
| 1180 inline const TypeKlassPtr *Type::is_klassptr() const { | |
| 1181 assert( _base == KlassPtr, "Not a klass pointer" ); | |
| 1182 return (TypeKlassPtr*)this; | |
| 1183 } | |
| 1184 | |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1185 inline const TypePtr* Type::make_ptr() const { |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1186 return (_base == NarrowOop) ? is_narrowoop()->get_ptrtype() : |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1187 (isa_ptr() ? is_ptr() : NULL); |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1188 } |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1189 |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1190 inline const TypeOopPtr* Type::make_oopptr() const { |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1191 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
|
1192 } |
|
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
820
diff
changeset
|
1193 |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1194 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
|
1195 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
|
1196 (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
|
1197 } |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
163
diff
changeset
|
1198 |
| 0 | 1199 inline bool Type::is_floatingpoint() const { |
| 1200 if( (_base == FloatCon) || (_base == FloatBot) || | |
| 1201 (_base == DoubleCon) || (_base == DoubleBot) ) | |
| 1202 return true; | |
| 1203 return false; | |
| 1204 } | |
| 1205 | |
| 1206 | |
| 1207 // =============================================================== | |
| 1208 // Things that need to be 64-bits in the 64-bit build but | |
| 1209 // 32-bits in the 32-bit build. Done this way to get full | |
| 1210 // optimization AND strong typing. | |
| 1211 #ifdef _LP64 | |
| 1212 | |
| 1213 // For type queries and asserts | |
| 1214 #define is_intptr_t is_long | |
| 1215 #define isa_intptr_t isa_long | |
| 1216 #define find_intptr_t_type find_long_type | |
| 1217 #define find_intptr_t_con find_long_con | |
| 1218 #define TypeX TypeLong | |
| 1219 #define Type_X Type::Long | |
| 1220 #define TypeX_X TypeLong::LONG | |
| 1221 #define TypeX_ZERO TypeLong::ZERO | |
| 1222 // For 'ideal_reg' machine registers | |
| 1223 #define Op_RegX Op_RegL | |
| 1224 // For phase->intcon variants | |
| 1225 #define MakeConX longcon | |
| 1226 #define ConXNode ConLNode | |
| 1227 // For array index arithmetic | |
| 1228 #define MulXNode MulLNode | |
| 1229 #define AndXNode AndLNode | |
| 1230 #define OrXNode OrLNode | |
| 1231 #define CmpXNode CmpLNode | |
| 1232 #define SubXNode SubLNode | |
| 1233 #define LShiftXNode LShiftLNode | |
| 1234 // For object size computation: | |
| 1235 #define AddXNode AddLNode | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1236 #define RShiftXNode RShiftLNode |
| 0 | 1237 // For card marks and hashcodes |
| 1238 #define URShiftXNode URShiftLNode | |
|
420
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1239 // UseOptoBiasInlining |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1240 #define XorXNode XorLNode |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1241 #define StoreXConditionalNode StoreLConditionalNode |
| 0 | 1242 // Opcodes |
| 1243 #define Op_LShiftX Op_LShiftL | |
| 1244 #define Op_AndX Op_AndL | |
| 1245 #define Op_AddX Op_AddL | |
| 1246 #define Op_SubX Op_SubL | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
827
diff
changeset
|
1247 #define Op_XorX Op_XorL |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
827
diff
changeset
|
1248 #define Op_URShiftX Op_URShiftL |
| 0 | 1249 // conversions |
| 1250 #define ConvI2X(x) ConvI2L(x) | |
| 1251 #define ConvL2X(x) (x) | |
| 1252 #define ConvX2I(x) ConvL2I(x) | |
| 1253 #define ConvX2L(x) (x) | |
| 1254 | |
| 1255 #else | |
| 1256 | |
| 1257 // For type queries and asserts | |
| 1258 #define is_intptr_t is_int | |
| 1259 #define isa_intptr_t isa_int | |
| 1260 #define find_intptr_t_type find_int_type | |
| 1261 #define find_intptr_t_con find_int_con | |
| 1262 #define TypeX TypeInt | |
| 1263 #define Type_X Type::Int | |
| 1264 #define TypeX_X TypeInt::INT | |
| 1265 #define TypeX_ZERO TypeInt::ZERO | |
| 1266 // For 'ideal_reg' machine registers | |
| 1267 #define Op_RegX Op_RegI | |
| 1268 // For phase->intcon variants | |
| 1269 #define MakeConX intcon | |
| 1270 #define ConXNode ConINode | |
| 1271 // For array index arithmetic | |
| 1272 #define MulXNode MulINode | |
| 1273 #define AndXNode AndINode | |
| 1274 #define OrXNode OrINode | |
| 1275 #define CmpXNode CmpINode | |
| 1276 #define SubXNode SubINode | |
| 1277 #define LShiftXNode LShiftINode | |
| 1278 // For object size computation: | |
| 1279 #define AddXNode AddINode | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1280 #define RShiftXNode RShiftINode |
| 0 | 1281 // For card marks and hashcodes |
| 1282 #define URShiftXNode URShiftINode | |
|
420
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1283 // UseOptoBiasInlining |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1284 #define XorXNode XorINode |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
366
diff
changeset
|
1285 #define StoreXConditionalNode StoreIConditionalNode |
| 0 | 1286 // Opcodes |
| 1287 #define Op_LShiftX Op_LShiftI | |
| 1288 #define Op_AndX Op_AndI | |
| 1289 #define Op_AddX Op_AddI | |
| 1290 #define Op_SubX Op_SubI | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
827
diff
changeset
|
1291 #define Op_XorX Op_XorI |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
827
diff
changeset
|
1292 #define Op_URShiftX Op_URShiftI |
| 0 | 1293 // conversions |
| 1294 #define ConvI2X(x) (x) | |
| 1295 #define ConvL2X(x) ConvL2I(x) | |
| 1296 #define ConvX2I(x) (x) | |
| 1297 #define ConvX2L(x) ConvI2L(x) | |
| 1298 | |
| 1299 #endif | |
| 1972 | 1300 |
| 1301 #endif // SHARE_VM_OPTO_TYPE_HPP |