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