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
|