< prev index next >

src/hotspot/share/utilities/globalDefinitions.hpp

Print this page




 477 #ifdef CPU_NOT_MULTIPLE_COPY_ATOMIC
 478 const bool support_IRIW_for_not_multiple_copy_atomic_cpu = true;
 479 #else
 480 const bool support_IRIW_for_not_multiple_copy_atomic_cpu = false;
 481 #endif
 482 
 483 // The expected size in bytes of a cache line, used to pad data structures.
 484 #ifndef DEFAULT_CACHE_LINE_SIZE
 485   #define DEFAULT_CACHE_LINE_SIZE 64
 486 #endif
 487 
 488 
 489 //----------------------------------------------------------------------------------------------------
 490 // Utility macros for compilers
 491 // used to silence compiler warnings
 492 
 493 #define Unused_Variable(var) var
 494 
 495 
 496 //----------------------------------------------------------------------------------------------------









 497 // Miscellaneous
 498 
 499 // 6302670 Eliminate Hotspot __fabsf dependency
 500 // All fabs() callers should call this function instead, which will implicitly
 501 // convert the operand to double, avoiding a dependency on __fabsf which
 502 // doesn't exist in early versions of Solaris 8.
 503 inline double fabsd(double value) {
 504   return fabs(value);
 505 }
 506 
 507 // Returns numerator/denominator as percentage value from 0 to 100. If denominator
 508 // is zero, return 0.0.
 509 template<typename T>
 510 inline double percent_of(T numerator, T denominator) {
 511   return denominator != 0 ? (double)numerator / denominator * 100.0 : 0.0;
 512 }
 513 
 514 //----------------------------------------------------------------------------------------------------
 515 // Special casts
 516 // Cast floats into same-size integers and vice-versa w/o changing bit-pattern


 553 union jlong_accessor {
 554   jint  words[2];
 555   jlong long_value;
 556 };
 557 
 558 void basic_types_init(); // cannot define here; uses assert
 559 
 560 
 561 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java
 562 enum BasicType {
 563   T_BOOLEAN     =  4,
 564   T_CHAR        =  5,
 565   T_FLOAT       =  6,
 566   T_DOUBLE      =  7,
 567   T_BYTE        =  8,
 568   T_SHORT       =  9,
 569   T_INT         = 10,
 570   T_LONG        = 11,
 571   T_OBJECT      = 12,
 572   T_ARRAY       = 13,
 573   T_VOID        = 14,
 574   T_ADDRESS     = 15,
 575   T_NARROWOOP   = 16,
 576   T_METADATA    = 17,
 577   T_NARROWKLASS = 18,
 578   T_CONFLICT    = 19, // for stack value type with conflicting contents

 579   T_ILLEGAL     = 99
 580 };
 581 
 582 inline bool is_java_primitive(BasicType t) {
 583   return T_BOOLEAN <= t && t <= T_LONG;
 584 }
 585 
 586 inline bool is_subword_type(BasicType t) {
 587   // these guys are processed exactly like T_INT in calling sequences:
 588   return (t == T_BOOLEAN || t == T_CHAR || t == T_BYTE || t == T_SHORT);
 589 }
 590 
 591 inline bool is_signed_subword_type(BasicType t) {
 592   return (t == T_BYTE || t == T_SHORT);
 593 }
 594 
 595 inline bool is_reference_type(BasicType t) {
 596   return (t == T_OBJECT || t == T_ARRAY);
 597 }
 598 
 599 // Convert a char from a classfile signature to a BasicType
 600 inline BasicType char2type(char c) {
 601   switch( c ) {
 602   case 'B': return T_BYTE;
 603   case 'C': return T_CHAR;
 604   case 'D': return T_DOUBLE;
 605   case 'F': return T_FLOAT;
 606   case 'I': return T_INT;
 607   case 'J': return T_LONG;
 608   case 'S': return T_SHORT;
 609   case 'Z': return T_BOOLEAN;
 610   case 'V': return T_VOID;
 611   case 'L': return T_OBJECT;
 612   case '[': return T_ARRAY;

 613   }
 614   return T_ILLEGAL;
 615 }
 616 
 617 extern char type2char_tab[T_CONFLICT+1];     // Map a BasicType to a jchar
 618 inline char type2char(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2char_tab[t] : 0; }
 619 extern int type2size[T_CONFLICT+1];         // Map BasicType to result stack elements
 620 extern const char* type2name_tab[T_CONFLICT+1];     // Map a BasicType to a jchar
 621 inline const char* type2name(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2name_tab[t] : NULL; }
 622 extern BasicType name2type(const char* name);
 623 
 624 // Auxiliary math routines
 625 // least common multiple
 626 extern size_t lcm(size_t a, size_t b);
 627 
 628 
 629 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java
 630 enum BasicTypeSize {
 631   T_BOOLEAN_size     = 1,
 632   T_CHAR_size        = 1,
 633   T_FLOAT_size       = 1,
 634   T_DOUBLE_size      = 2,
 635   T_BYTE_size        = 1,
 636   T_SHORT_size       = 1,
 637   T_INT_size         = 1,
 638   T_LONG_size        = 2,
 639   T_OBJECT_size      = 1,
 640   T_ARRAY_size       = 1,
 641   T_NARROWOOP_size   = 1,
 642   T_NARROWKLASS_size = 1,
 643   T_VOID_size        = 0

 644 };
 645 
 646 
 647 // maps a BasicType to its instance field storage type:
 648 // all sub-word integral types are widened to T_INT
 649 extern BasicType type2field[T_CONFLICT+1];
 650 extern BasicType type2wfield[T_CONFLICT+1];
 651 
 652 
 653 // size in bytes
 654 enum ArrayElementSize {
 655   T_BOOLEAN_aelem_bytes     = 1,
 656   T_CHAR_aelem_bytes        = 2,
 657   T_FLOAT_aelem_bytes       = 4,
 658   T_DOUBLE_aelem_bytes      = 8,
 659   T_BYTE_aelem_bytes        = 1,
 660   T_SHORT_aelem_bytes       = 2,
 661   T_INT_aelem_bytes         = 4,
 662   T_LONG_aelem_bytes        = 8,
 663 #ifdef _LP64
 664   T_OBJECT_aelem_bytes      = 8,
 665   T_ARRAY_aelem_bytes       = 8,

 666 #else
 667   T_OBJECT_aelem_bytes      = 4,
 668   T_ARRAY_aelem_bytes       = 4,

 669 #endif
 670   T_NARROWOOP_aelem_bytes   = 4,
 671   T_NARROWKLASS_aelem_bytes = 4,
 672   T_VOID_aelem_bytes        = 0
 673 };
 674 
 675 extern int _type2aelembytes[T_CONFLICT+1]; // maps a BasicType to nof bytes used by its array element
 676 #ifdef ASSERT
 677 extern int type2aelembytes(BasicType t, bool allow_address = false); // asserts
 678 #else
 679 inline int type2aelembytes(BasicType t, bool allow_address = false) { return _type2aelembytes[t]; }
 680 #endif
 681 
 682 
 683 // JavaValue serves as a container for arbitrary Java values.
 684 
 685 class JavaValue {
 686 
 687  public:
 688   typedef union JavaCallValue {


 744 
 745 // TosState describes the top-of-stack state before and after the execution of
 746 // a bytecode or method. The top-of-stack value may be cached in one or more CPU
 747 // registers. The TosState corresponds to the 'machine representation' of this cached
 748 // value. There's 4 states corresponding to the JAVA types int, long, float & double
 749 // as well as a 5th state in case the top-of-stack value is actually on the top
 750 // of stack (in memory) and thus not cached. The atos state corresponds to the itos
 751 // state when it comes to machine representation but is used separately for (oop)
 752 // type specific operations (e.g. verification code).
 753 
 754 enum TosState {         // describes the tos cache contents
 755   btos = 0,             // byte, bool tos cached
 756   ztos = 1,             // byte, bool tos cached
 757   ctos = 2,             // char tos cached
 758   stos = 3,             // short tos cached
 759   itos = 4,             // int tos cached
 760   ltos = 5,             // long tos cached
 761   ftos = 6,             // float tos cached
 762   dtos = 7,             // double tos cached
 763   atos = 8,             // object cached
 764   vtos = 9,             // tos not cached
 765   number_of_states,
 766   ilgl                  // illegal state: should not occur
 767 };
 768 
 769 
 770 inline TosState as_TosState(BasicType type) {
 771   switch (type) {
 772     case T_BYTE   : return btos;
 773     case T_BOOLEAN: return ztos;
 774     case T_CHAR   : return ctos;
 775     case T_SHORT  : return stos;
 776     case T_INT    : return itos;
 777     case T_LONG   : return ltos;
 778     case T_FLOAT  : return ftos;
 779     case T_DOUBLE : return dtos;
 780     case T_VOID   : return vtos;
 781     case T_ARRAY  : // fall through

 782     case T_OBJECT : return atos;
 783     default       : return ilgl;
 784   }
 785 }
 786 
 787 inline BasicType as_BasicType(TosState state) {
 788   switch (state) {
 789     case btos : return T_BYTE;
 790     case ztos : return T_BOOLEAN;
 791     case ctos : return T_CHAR;
 792     case stos : return T_SHORT;
 793     case itos : return T_INT;
 794     case ltos : return T_LONG;
 795     case ftos : return T_FLOAT;
 796     case dtos : return T_DOUBLE;
 797     case atos : return T_OBJECT;
 798     case vtos : return T_VOID;
 799     default   : return T_ILLEGAL;
 800   }
 801 }


 976   return log2_intptr((uintptr_t)x);
 977 }
 978 
 979 inline int log2_uint(uint x) {
 980   STATIC_ASSERT(sizeof(uint) <= sizeof(uintptr_t));
 981   return log2_intptr((uintptr_t)x);
 982 }
 983 
 984 //  A negative value of 'x' will return '63'
 985 inline int log2_jlong(jlong x) {
 986   STATIC_ASSERT(sizeof(jlong) <= sizeof(julong));
 987   return log2_long((julong)x);
 988 }
 989 
 990 //* the argument must be exactly a power of 2
 991 inline int exact_log2(intptr_t x) {
 992   assert(is_power_of_2(x), "x must be a power of 2: " INTPTR_FORMAT, x);
 993   return log2_intptr(x);
 994 }
 995 










 996 //* the argument must be exactly a power of 2
 997 inline int exact_log2_long(jlong x) {
 998   assert(is_power_of_2_long(x), "x must be a power of 2: " JLONG_FORMAT, x);
 999   return log2_long(x);
1000 }
1001 
1002 inline bool is_odd (intx x) { return x & 1;      }
1003 inline bool is_even(intx x) { return !is_odd(x); }
1004 
1005 // abs methods which cannot overflow and so are well-defined across
1006 // the entire domain of integer types.
1007 static inline unsigned int uabs(unsigned int n) {
1008   union {
1009     unsigned int result;
1010     int value;
1011   };
1012   result = n;
1013   if (value < 0) result = 0-result;
1014   return result;
1015 }


1117 
1118 //----------------------------------------------------------------------------------------------------
1119 // String type aliases used by command line flag declarations and
1120 // processing utilities.
1121 
1122 typedef const char* ccstr;
1123 typedef const char* ccstrlist;   // represents string arguments which accumulate
1124 
1125 //----------------------------------------------------------------------------------------------------
1126 // Default hash/equals functions used by ResourceHashtable and KVHashtable
1127 
1128 template<typename K> unsigned primitive_hash(const K& k) {
1129   unsigned hash = (unsigned)((uintptr_t)k);
1130   return hash ^ (hash >> 3); // just in case we're dealing with aligned ptrs
1131 }
1132 
1133 template<typename K> bool primitive_equals(const K& k0, const K& k1) {
1134   return k0 == k1;
1135 }
1136 






1137 
1138 #endif // SHARE_UTILITIES_GLOBALDEFINITIONS_HPP


 477 #ifdef CPU_NOT_MULTIPLE_COPY_ATOMIC
 478 const bool support_IRIW_for_not_multiple_copy_atomic_cpu = true;
 479 #else
 480 const bool support_IRIW_for_not_multiple_copy_atomic_cpu = false;
 481 #endif
 482 
 483 // The expected size in bytes of a cache line, used to pad data structures.
 484 #ifndef DEFAULT_CACHE_LINE_SIZE
 485   #define DEFAULT_CACHE_LINE_SIZE 64
 486 #endif
 487 
 488 
 489 //----------------------------------------------------------------------------------------------------
 490 // Utility macros for compilers
 491 // used to silence compiler warnings
 492 
 493 #define Unused_Variable(var) var
 494 
 495 
 496 //----------------------------------------------------------------------------------------------------
 497 // Prototyping
 498 // "Code Missing Here" macro, un-define when integrating back from prototyping stage and break
 499 // compilation on purpose (i.e. "forget me not")
 500 #define PROTOTYPE
 501 #ifdef PROTOTYPE
 502 #define CMH(m)
 503 #endif
 504 
 505 //----------------------------------------------------------------------------------------------------
 506 // Miscellaneous
 507 
 508 // 6302670 Eliminate Hotspot __fabsf dependency
 509 // All fabs() callers should call this function instead, which will implicitly
 510 // convert the operand to double, avoiding a dependency on __fabsf which
 511 // doesn't exist in early versions of Solaris 8.
 512 inline double fabsd(double value) {
 513   return fabs(value);
 514 }
 515 
 516 // Returns numerator/denominator as percentage value from 0 to 100. If denominator
 517 // is zero, return 0.0.
 518 template<typename T>
 519 inline double percent_of(T numerator, T denominator) {
 520   return denominator != 0 ? (double)numerator / denominator * 100.0 : 0.0;
 521 }
 522 
 523 //----------------------------------------------------------------------------------------------------
 524 // Special casts
 525 // Cast floats into same-size integers and vice-versa w/o changing bit-pattern


 562 union jlong_accessor {
 563   jint  words[2];
 564   jlong long_value;
 565 };
 566 
 567 void basic_types_init(); // cannot define here; uses assert
 568 
 569 
 570 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java
 571 enum BasicType {
 572   T_BOOLEAN     =  4,
 573   T_CHAR        =  5,
 574   T_FLOAT       =  6,
 575   T_DOUBLE      =  7,
 576   T_BYTE        =  8,
 577   T_SHORT       =  9,
 578   T_INT         = 10,
 579   T_LONG        = 11,
 580   T_OBJECT      = 12,
 581   T_ARRAY       = 13,
 582   T_VALUETYPE   = 14,
 583   T_VOID        = 15,
 584   T_ADDRESS     = 16,
 585   T_NARROWOOP   = 17,
 586   T_METADATA    = 18,
 587   T_NARROWKLASS = 19,
 588   T_CONFLICT    = 20, // for stack value type with conflicting contents
 589   T_ILLEGAL     = 99
 590 };
 591 
 592 inline bool is_java_primitive(BasicType t) {
 593   return T_BOOLEAN <= t && t <= T_LONG;
 594 }
 595 
 596 inline bool is_subword_type(BasicType t) {
 597   // these guys are processed exactly like T_INT in calling sequences:
 598   return (t == T_BOOLEAN || t == T_CHAR || t == T_BYTE || t == T_SHORT);
 599 }
 600 
 601 inline bool is_signed_subword_type(BasicType t) {
 602   return (t == T_BYTE || t == T_SHORT);
 603 }
 604 
 605 inline bool is_reference_type(BasicType t) {
 606   return (t == T_OBJECT || t == T_ARRAY || t == T_VALUETYPE);
 607 }
 608 
 609 // Convert a char from a classfile signature to a BasicType
 610 inline BasicType char2type(char c) {
 611   switch( c ) {
 612   case 'B': return T_BYTE;
 613   case 'C': return T_CHAR;
 614   case 'D': return T_DOUBLE;
 615   case 'F': return T_FLOAT;
 616   case 'I': return T_INT;
 617   case 'J': return T_LONG;
 618   case 'S': return T_SHORT;
 619   case 'Z': return T_BOOLEAN;
 620   case 'V': return T_VOID;
 621   case 'L': return T_OBJECT;
 622   case '[': return T_ARRAY;
 623   case 'Q': return T_VALUETYPE;
 624   }
 625   return T_ILLEGAL;
 626 }
 627 
 628 extern char type2char_tab[T_CONFLICT+1];     // Map a BasicType to a jchar
 629 inline char type2char(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2char_tab[t] : 0; }
 630 extern int type2size[T_CONFLICT+1];         // Map BasicType to result stack elements
 631 extern const char* type2name_tab[T_CONFLICT+1];     // Map a BasicType to a jchar
 632 inline const char* type2name(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2name_tab[t] : NULL; }
 633 extern BasicType name2type(const char* name);
 634 
 635 // Auxiliary math routines
 636 // least common multiple
 637 extern size_t lcm(size_t a, size_t b);
 638 
 639 
 640 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java
 641 enum BasicTypeSize {
 642   T_BOOLEAN_size     = 1,
 643   T_CHAR_size        = 1,
 644   T_FLOAT_size       = 1,
 645   T_DOUBLE_size      = 2,
 646   T_BYTE_size        = 1,
 647   T_SHORT_size       = 1,
 648   T_INT_size         = 1,
 649   T_LONG_size        = 2,
 650   T_OBJECT_size      = 1,
 651   T_ARRAY_size       = 1,
 652   T_NARROWOOP_size   = 1,
 653   T_NARROWKLASS_size = 1,
 654   T_VOID_size        = 0,
 655   T_VALUETYPE_size   = 1
 656 };
 657 
 658 
 659 // maps a BasicType to its instance field storage type:
 660 // all sub-word integral types are widened to T_INT
 661 extern BasicType type2field[T_CONFLICT+1];
 662 extern BasicType type2wfield[T_CONFLICT+1];
 663 
 664 
 665 // size in bytes
 666 enum ArrayElementSize {
 667   T_BOOLEAN_aelem_bytes     = 1,
 668   T_CHAR_aelem_bytes        = 2,
 669   T_FLOAT_aelem_bytes       = 4,
 670   T_DOUBLE_aelem_bytes      = 8,
 671   T_BYTE_aelem_bytes        = 1,
 672   T_SHORT_aelem_bytes       = 2,
 673   T_INT_aelem_bytes         = 4,
 674   T_LONG_aelem_bytes        = 8,
 675 #ifdef _LP64
 676   T_OBJECT_aelem_bytes      = 8,
 677   T_ARRAY_aelem_bytes       = 8,
 678   T_VALUETYPE_aelem_bytes   = 8,
 679 #else
 680   T_OBJECT_aelem_bytes      = 4,
 681   T_ARRAY_aelem_bytes       = 4,
 682   T_VALUETYPE_aelem_bytes   = 4,
 683 #endif
 684   T_NARROWOOP_aelem_bytes   = 4,
 685   T_NARROWKLASS_aelem_bytes = 4,
 686   T_VOID_aelem_bytes        = 0
 687 };
 688 
 689 extern int _type2aelembytes[T_CONFLICT+1]; // maps a BasicType to nof bytes used by its array element
 690 #ifdef ASSERT
 691 extern int type2aelembytes(BasicType t, bool allow_address = false); // asserts
 692 #else
 693 inline int type2aelembytes(BasicType t, bool allow_address = false) { return _type2aelembytes[t]; }
 694 #endif
 695 
 696 
 697 // JavaValue serves as a container for arbitrary Java values.
 698 
 699 class JavaValue {
 700 
 701  public:
 702   typedef union JavaCallValue {


 758 
 759 // TosState describes the top-of-stack state before and after the execution of
 760 // a bytecode or method. The top-of-stack value may be cached in one or more CPU
 761 // registers. The TosState corresponds to the 'machine representation' of this cached
 762 // value. There's 4 states corresponding to the JAVA types int, long, float & double
 763 // as well as a 5th state in case the top-of-stack value is actually on the top
 764 // of stack (in memory) and thus not cached. The atos state corresponds to the itos
 765 // state when it comes to machine representation but is used separately for (oop)
 766 // type specific operations (e.g. verification code).
 767 
 768 enum TosState {         // describes the tos cache contents
 769   btos = 0,             // byte, bool tos cached
 770   ztos = 1,             // byte, bool tos cached
 771   ctos = 2,             // char tos cached
 772   stos = 3,             // short tos cached
 773   itos = 4,             // int tos cached
 774   ltos = 5,             // long tos cached
 775   ftos = 6,             // float tos cached
 776   dtos = 7,             // double tos cached
 777   atos = 8,             // object cached
 778   vtos = 9,             // tos not cached,
 779   number_of_states,
 780   ilgl                  // illegal state: should not occur
 781 };
 782 
 783 
 784 inline TosState as_TosState(BasicType type) {
 785   switch (type) {
 786     case T_BYTE   : return btos;
 787     case T_BOOLEAN: return ztos;
 788     case T_CHAR   : return ctos;
 789     case T_SHORT  : return stos;
 790     case T_INT    : return itos;
 791     case T_LONG   : return ltos;
 792     case T_FLOAT  : return ftos;
 793     case T_DOUBLE : return dtos;
 794     case T_VOID   : return vtos;
 795     case T_VALUETYPE: // fall through
 796     case T_ARRAY  :   // fall through
 797     case T_OBJECT : return atos;
 798     default       : return ilgl;
 799   }
 800 }
 801 
 802 inline BasicType as_BasicType(TosState state) {
 803   switch (state) {
 804     case btos : return T_BYTE;
 805     case ztos : return T_BOOLEAN;
 806     case ctos : return T_CHAR;
 807     case stos : return T_SHORT;
 808     case itos : return T_INT;
 809     case ltos : return T_LONG;
 810     case ftos : return T_FLOAT;
 811     case dtos : return T_DOUBLE;
 812     case atos : return T_OBJECT;
 813     case vtos : return T_VOID;
 814     default   : return T_ILLEGAL;
 815   }
 816 }


 991   return log2_intptr((uintptr_t)x);
 992 }
 993 
 994 inline int log2_uint(uint x) {
 995   STATIC_ASSERT(sizeof(uint) <= sizeof(uintptr_t));
 996   return log2_intptr((uintptr_t)x);
 997 }
 998 
 999 //  A negative value of 'x' will return '63'
1000 inline int log2_jlong(jlong x) {
1001   STATIC_ASSERT(sizeof(jlong) <= sizeof(julong));
1002   return log2_long((julong)x);
1003 }
1004 
1005 //* the argument must be exactly a power of 2
1006 inline int exact_log2(intptr_t x) {
1007   assert(is_power_of_2(x), "x must be a power of 2: " INTPTR_FORMAT, x);
1008   return log2_intptr(x);
1009 }
1010 
1011 // the argument doesn't need to be a power of two
1012 inline int upper_log2(intptr_t x) {
1013   int shift = log2_intptr(x);
1014   intptr_t y = 1ULL << shift;
1015   if (y < x) {
1016     shift++;
1017   }
1018   return shift;
1019 }
1020 
1021 //* the argument must be exactly a power of 2
1022 inline int exact_log2_long(jlong x) {
1023   assert(is_power_of_2_long(x), "x must be a power of 2: " JLONG_FORMAT, x);
1024   return log2_long(x);
1025 }
1026 
1027 inline bool is_odd (intx x) { return x & 1;      }
1028 inline bool is_even(intx x) { return !is_odd(x); }
1029 
1030 // abs methods which cannot overflow and so are well-defined across
1031 // the entire domain of integer types.
1032 static inline unsigned int uabs(unsigned int n) {
1033   union {
1034     unsigned int result;
1035     int value;
1036   };
1037   result = n;
1038   if (value < 0) result = 0-result;
1039   return result;
1040 }


1142 
1143 //----------------------------------------------------------------------------------------------------
1144 // String type aliases used by command line flag declarations and
1145 // processing utilities.
1146 
1147 typedef const char* ccstr;
1148 typedef const char* ccstrlist;   // represents string arguments which accumulate
1149 
1150 //----------------------------------------------------------------------------------------------------
1151 // Default hash/equals functions used by ResourceHashtable and KVHashtable
1152 
1153 template<typename K> unsigned primitive_hash(const K& k) {
1154   unsigned hash = (unsigned)((uintptr_t)k);
1155   return hash ^ (hash >> 3); // just in case we're dealing with aligned ptrs
1156 }
1157 
1158 template<typename K> bool primitive_equals(const K& k0, const K& k1) {
1159   return k0 == k1;
1160 }
1161 
1162 // TEMP!!!!
1163 // This should be removed after LW2 arrays are implemented (JDK-8220790).
1164 // It's an alias to (EnableValhalla && (ValueArrayElemMaxFlatSize != 0)),
1165 // which is actually not 100% correct, but works for the current set of C1/C2
1166 // implementation and test cases.
1167 #define ValueArrayFlatten (EnableValhalla && (ValueArrayElemMaxFlatSize != 0))
1168 
1169 #endif // SHARE_UTILITIES_GLOBALDEFINITIONS_HPP
< prev index next >