< prev index next >

src/hotspot/share/oops/compressedOops.inline.hpp

Print this page

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
< prev index next >