124     case ObjLayout::Compressed: {
125       narrowKlass narrow_klass = Atomic::load_acquire(&_metadata._compressed_klass);
126       return CompressedKlassPointers::decode(narrow_klass);
127     }
128     default:
129       return Atomic::load_acquire(&_metadata._klass);
130   }
131 }
132 
133 Klass* oopDesc::klass_without_asserts() const {
134   switch (ObjLayout::klass_mode()) {
135     case ObjLayout::Compact:
136       return mark().klass_without_asserts();
137     case ObjLayout::Compressed:
138       return CompressedKlassPointers::decode_without_asserts(_metadata._compressed_klass);
139     default:
140       return _metadata._klass;
141   }
142 }
143 











144 void oopDesc::set_klass(Klass* k) {
145   assert(Universe::is_bootstrapping() || (k != nullptr && k->is_klass()), "incorrect Klass");
146   assert(!UseCompactObjectHeaders, "don't set Klass* with compact headers");
147   if (UseCompressedClassPointers) {
148     _metadata._compressed_klass = CompressedKlassPointers::encode_not_null(k);
149   } else {
150     _metadata._klass = k;
151   }
152 }
153 
154 void oopDesc::release_set_klass(HeapWord* mem, Klass* k) {
155   assert(Universe::is_bootstrapping() || (k != nullptr && k->is_klass()), "incorrect Klass");
156   assert(!UseCompactObjectHeaders, "don't set Klass* with compact headers");
157   char* raw_mem = ((char*)mem + klass_offset_in_bytes());
158   if (UseCompressedClassPointers) {
159     Atomic::release_store((narrowKlass*)raw_mem,
160                           CompressedKlassPointers::encode_not_null(k));
161   } else {
162     Atomic::release_store((Klass**)raw_mem, k);
163   }

124     case ObjLayout::Compressed: {
125       narrowKlass narrow_klass = Atomic::load_acquire(&_metadata._compressed_klass);
126       return CompressedKlassPointers::decode(narrow_klass);
127     }
128     default:
129       return Atomic::load_acquire(&_metadata._klass);
130   }
131 }
132 
133 Klass* oopDesc::klass_without_asserts() const {
134   switch (ObjLayout::klass_mode()) {
135     case ObjLayout::Compact:
136       return mark().klass_without_asserts();
137     case ObjLayout::Compressed:
138       return CompressedKlassPointers::decode_without_asserts(_metadata._compressed_klass);
139     default:
140       return _metadata._klass;
141   }
142 }
143 
144 narrowKlass oopDesc::narrow_klass() const {
145   switch (ObjLayout::klass_mode()) {
146     case ObjLayout::Compact:
147       return mark().narrow_klass();
148     case ObjLayout::Compressed:
149       return _metadata._compressed_klass;
150     default:
151       ShouldNotReachHere();
152   }
153 }
154 
155 void oopDesc::set_klass(Klass* k) {
156   assert(Universe::is_bootstrapping() || (k != nullptr && k->is_klass()), "incorrect Klass");
157   assert(!UseCompactObjectHeaders, "don't set Klass* with compact headers");
158   if (UseCompressedClassPointers) {
159     _metadata._compressed_klass = CompressedKlassPointers::encode_not_null(k);
160   } else {
161     _metadata._klass = k;
162   }
163 }
164 
165 void oopDesc::release_set_klass(HeapWord* mem, Klass* k) {
166   assert(Universe::is_bootstrapping() || (k != nullptr && k->is_klass()), "incorrect Klass");
167   assert(!UseCompactObjectHeaders, "don't set Klass* with compact headers");
168   char* raw_mem = ((char*)mem + klass_offset_in_bytes());
169   if (UseCompressedClassPointers) {
170     Atomic::release_store((narrowKlass*)raw_mem,
171                           CompressedKlassPointers::encode_not_null(k));
172   } else {
173     Atomic::release_store((Klass**)raw_mem, k);
174   }