101 return v;
102 }
103
104 inline uint32_t CompressedOops::narrow_oop_value(oop o) {
105 return narrow_oop_value(encode(o));
106 }
107
108 inline uint32_t CompressedOops::narrow_oop_value(narrowOop o) {
109 return static_cast<uint32_t>(o);
110 }
111
112 template<typename T>
113 inline narrowOop CompressedOops::narrow_oop_cast(T i) {
114 static_assert(std::is_integral<T>::value, "precondition");
115 uint32_t narrow_value = static_cast<uint32_t>(i);
116 // Ensure no bits lost in conversion to uint32_t.
117 assert(i == static_cast<T>(narrow_value), "narrowOop overflow");
118 return static_cast<narrowOop>(narrow_value);
119 }
120
121 static inline bool check_alignment(Klass* v) {
122 return (intptr_t)v % KlassAlignmentInBytes == 0;
123 }
124
125 inline Klass* CompressedKlassPointers::decode_raw(narrowKlass v) {
126 return decode_raw(v, base());
127 }
128
129 inline Klass* CompressedKlassPointers::decode_raw(narrowKlass v, address narrow_base) {
130 return (Klass*)((uintptr_t)narrow_base +((uintptr_t)v << shift()));
131 }
132
133 inline Klass* CompressedKlassPointers::decode_not_null(narrowKlass v) {
134 return decode_not_null(v, base());
135 }
136
137 inline Klass* CompressedKlassPointers::decode_not_null(narrowKlass v, address narrow_base) {
138 assert(!is_null(v), "narrow klass value can never be zero");
139 Klass* result = decode_raw(v, narrow_base);
140 assert(check_alignment(result), "address not aligned: " PTR_FORMAT, p2i(result));
141 return result;
142 }
143
144 inline Klass* CompressedKlassPointers::decode(narrowKlass v) {
145 return is_null(v) ? nullptr : decode_not_null(v);
146 }
147
148 inline narrowKlass CompressedKlassPointers::encode_not_null(Klass* v) {
149 return encode_not_null(v, base());
150 }
151
152 inline narrowKlass CompressedKlassPointers::encode_not_null(Klass* v, address narrow_base) {
153 assert(!is_null(v), "klass value can never be zero");
154 assert(check_alignment(v), "Address not aligned");
155 uint64_t pd = (uint64_t)(pointer_delta(v, narrow_base, 1));
156 assert(KlassEncodingMetaspaceMax > pd, "change encoding max if new encoding");
157 uint64_t result = pd >> shift();
158 assert((result & CONST64(0xffffffff00000000)) == 0, "narrow klass pointer overflow");
159 assert(decode_not_null(result, narrow_base) == v, "reversibility");
160 return (narrowKlass)result;
161 }
162
163 inline narrowKlass CompressedKlassPointers::encode(Klass* v) {
164 return is_null(v) ? (narrowKlass)0 : encode_not_null(v);
165 }
166
167 #endif // SHARE_OOPS_COMPRESSEDOOPS_INLINE_HPP
|
101 return v;
102 }
103
104 inline uint32_t CompressedOops::narrow_oop_value(oop o) {
105 return narrow_oop_value(encode(o));
106 }
107
108 inline uint32_t CompressedOops::narrow_oop_value(narrowOop o) {
109 return static_cast<uint32_t>(o);
110 }
111
112 template<typename T>
113 inline narrowOop CompressedOops::narrow_oop_cast(T i) {
114 static_assert(std::is_integral<T>::value, "precondition");
115 uint32_t narrow_value = static_cast<uint32_t>(i);
116 // Ensure no bits lost in conversion to uint32_t.
117 assert(i == static_cast<T>(narrow_value), "narrowOop overflow");
118 return static_cast<narrowOop>(narrow_value);
119 }
120
121 #endif // SHARE_OOPS_COMPRESSEDOOPS_INLINE_HPP
|