67 inline markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) { |
67 inline markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) { |
68 return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark); |
68 return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark); |
69 } |
69 } |
70 |
70 |
71 inline Klass* oopDesc::klass() const { |
71 inline Klass* oopDesc::klass() const { |
72 if (UseCompressedKlassPointers) { |
72 if (UseCompressedClassPointers) { |
73 return Klass::decode_klass_not_null(_metadata._compressed_klass); |
73 return Klass::decode_klass_not_null(_metadata._compressed_klass); |
74 } else { |
74 } else { |
75 return _metadata._klass; |
75 return _metadata._klass; |
76 } |
76 } |
77 } |
77 } |
78 |
78 |
79 inline Klass* oopDesc::klass_or_null() const volatile { |
79 inline Klass* oopDesc::klass_or_null() const volatile { |
80 // can be NULL in CMS |
80 // can be NULL in CMS |
81 if (UseCompressedKlassPointers) { |
81 if (UseCompressedClassPointers) { |
82 return Klass::decode_klass(_metadata._compressed_klass); |
82 return Klass::decode_klass(_metadata._compressed_klass); |
83 } else { |
83 } else { |
84 return _metadata._klass; |
84 return _metadata._klass; |
85 } |
85 } |
86 } |
86 } |
87 |
87 |
88 inline int oopDesc::klass_gap_offset_in_bytes() { |
88 inline int oopDesc::klass_gap_offset_in_bytes() { |
89 assert(UseCompressedKlassPointers, "only applicable to compressed klass pointers"); |
89 assert(UseCompressedClassPointers, "only applicable to compressed klass pointers"); |
90 return oopDesc::klass_offset_in_bytes() + sizeof(narrowKlass); |
90 return oopDesc::klass_offset_in_bytes() + sizeof(narrowKlass); |
91 } |
91 } |
92 |
92 |
93 inline Klass** oopDesc::klass_addr() { |
93 inline Klass** oopDesc::klass_addr() { |
94 // Only used internally and with CMS and will not work with |
94 // Only used internally and with CMS and will not work with |
95 // UseCompressedOops |
95 // UseCompressedOops |
96 assert(!UseCompressedKlassPointers, "only supported with uncompressed klass pointers"); |
96 assert(!UseCompressedClassPointers, "only supported with uncompressed klass pointers"); |
97 return (Klass**) &_metadata._klass; |
97 return (Klass**) &_metadata._klass; |
98 } |
98 } |
99 |
99 |
100 inline narrowKlass* oopDesc::compressed_klass_addr() { |
100 inline narrowKlass* oopDesc::compressed_klass_addr() { |
101 assert(UseCompressedKlassPointers, "only called by compressed klass pointers"); |
101 assert(UseCompressedClassPointers, "only called by compressed klass pointers"); |
102 return &_metadata._compressed_klass; |
102 return &_metadata._compressed_klass; |
103 } |
103 } |
104 |
104 |
105 inline void oopDesc::set_klass(Klass* k) { |
105 inline void oopDesc::set_klass(Klass* k) { |
106 // since klasses are promoted no store check is needed |
106 // since klasses are promoted no store check is needed |
107 assert(Universe::is_bootstrapping() || k != NULL, "must be a real Klass*"); |
107 assert(Universe::is_bootstrapping() || k != NULL, "must be a real Klass*"); |
108 assert(Universe::is_bootstrapping() || k->is_klass(), "not a Klass*"); |
108 assert(Universe::is_bootstrapping() || k->is_klass(), "not a Klass*"); |
109 if (UseCompressedKlassPointers) { |
109 if (UseCompressedClassPointers) { |
110 *compressed_klass_addr() = Klass::encode_klass_not_null(k); |
110 *compressed_klass_addr() = Klass::encode_klass_not_null(k); |
111 } else { |
111 } else { |
112 *klass_addr() = k; |
112 *klass_addr() = k; |
113 } |
113 } |
114 } |
114 } |
116 inline int oopDesc::klass_gap() const { |
116 inline int oopDesc::klass_gap() const { |
117 return *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()); |
117 return *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()); |
118 } |
118 } |
119 |
119 |
120 inline void oopDesc::set_klass_gap(int v) { |
120 inline void oopDesc::set_klass_gap(int v) { |
121 if (UseCompressedKlassPointers) { |
121 if (UseCompressedClassPointers) { |
122 *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()) = v; |
122 *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()) = v; |
123 } |
123 } |
124 } |
124 } |
125 |
125 |
126 inline void oopDesc::set_klass_to_list_ptr(oop k) { |
126 inline void oopDesc::set_klass_to_list_ptr(oop k) { |
127 // This is only to be used during GC, for from-space objects, so no |
127 // This is only to be used during GC, for from-space objects, so no |
128 // barrier is needed. |
128 // barrier is needed. |
129 if (UseCompressedKlassPointers) { |
129 if (UseCompressedClassPointers) { |
130 _metadata._compressed_klass = (narrowKlass)encode_heap_oop(k); // may be null (parnew overflow handling) |
130 _metadata._compressed_klass = (narrowKlass)encode_heap_oop(k); // may be null (parnew overflow handling) |
131 } else { |
131 } else { |
132 _metadata._klass = (Klass*)(address)k; |
132 _metadata._klass = (Klass*)(address)k; |
133 } |
133 } |
134 } |
134 } |
135 |
135 |
136 inline oop oopDesc::list_ptr_from_klass() { |
136 inline oop oopDesc::list_ptr_from_klass() { |
137 // This is only to be used during GC, for from-space objects. |
137 // This is only to be used during GC, for from-space objects. |
138 if (UseCompressedKlassPointers) { |
138 if (UseCompressedClassPointers) { |
139 return decode_heap_oop((narrowOop)_metadata._compressed_klass); |
139 return decode_heap_oop((narrowOop)_metadata._compressed_klass); |
140 } else { |
140 } else { |
141 // Special case for GC |
141 // Special case for GC |
142 return (oop)(address)_metadata._klass; |
142 return (oop)(address)_metadata._klass; |
143 } |
143 } |