< prev index next >

src/share/vm/oops/oop.inline.hpp

Print this page
rev 12906 : [mq]: gc_interface


   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_OOPS_OOP_INLINE_HPP
  26 #define SHARE_VM_OOPS_OOP_INLINE_HPP
  27 
  28 #include "gc/shared/ageTable.hpp"
  29 #include "gc/shared/barrierSet.inline.hpp"
  30 #include "gc/shared/cardTableModRefBS.hpp"
  31 #include "gc/shared/collectedHeap.inline.hpp"
  32 #include "gc/shared/genCollectedHeap.hpp"
  33 #include "gc/shared/generation.hpp"
  34 #include "oops/arrayKlass.hpp"
  35 #include "oops/arrayOop.hpp"
  36 #include "oops/klass.inline.hpp"
  37 #include "oops/markOop.inline.hpp"
  38 #include "oops/oop.hpp"

  39 #include "runtime/atomic.hpp"
  40 #include "runtime/orderAccess.inline.hpp"
  41 #include "runtime/os.hpp"
  42 #include "utilities/macros.hpp"
  43 
  44 inline void update_barrier_set(void* p, oop v, bool release = false) {
  45   assert(oopDesc::bs() != NULL, "Uninitialized bs in oop!");
  46   oopDesc::bs()->write_ref_field(p, v, release);
  47 }
  48 
  49 template <class T> inline void update_barrier_set_pre(T* p, oop v) {
  50   oopDesc::bs()->write_ref_field_pre(p, v);
  51 }
  52 
  53 template <class T> void oop_store(T* p, oop v) {
  54   if (always_do_update_barrier) {
  55     oop_store((volatile T*)p, v);
  56   } else {
  57     update_barrier_set_pre(p, v);
  58     oopDesc::encode_store_heap_oop(p, v);
  59     // always_do_update_barrier == false =>
  60     // Either we are at a safepoint (in GC) or CMS is not used. In both
  61     // cases it's unnecessary to mark the card as dirty with release sematics.
  62     update_barrier_set((void*)p, v, false /* release */);  // cast away type
  63   }
  64 }
  65 
  66 template <class T> void oop_store(volatile T* p, oop v) {
  67   update_barrier_set_pre((T*)p, v);   // cast away volatile
  68   // Used by release_obj_field_put, so use release_store_ptr.
  69   oopDesc::release_encode_store_heap_oop(p, v);
  70   // When using CMS we must mark the card corresponding to p as dirty
  71   // with release sematics to prevent that CMS sees the dirty card but
  72   // not the new value v at p due to reordering of the two
  73   // stores. Note that CMS has a concurrent precleaning phase, where
  74   // it reads the card table while the Java threads are running.
  75   update_barrier_set((void*)p, v, true /* release */);    // cast away type
  76 }
  77 
  78 // Should replace *addr = oop assignments where addr type depends on UseCompressedOops
  79 // (without having to remember the function name this calls).
  80 inline void oop_store_raw(HeapWord* addr, oop value) {
  81   if (UseCompressedOops) {
  82     oopDesc::encode_store_heap_oop((narrowOop*)addr, value);
  83   } else {
  84     oopDesc::encode_store_heap_oop((oop*)addr, value);
  85   }
  86 }
  87 
  88 // Implementation of all inlined member functions defined in oop.hpp
  89 // We need a separate file to avoid circular references
  90 
  91 void oopDesc::release_set_mark(markOop m) {
  92   OrderAccess::release_store_ptr(&_mark, m);
  93 }
  94 
  95 markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) {
  96   return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark);
  97 }
  98 
  99 void oopDesc::init_mark() {
 100   set_mark(markOopDesc::prototype_for_object(this));
 101 }
 102 
 103 Klass* oopDesc::klass() const {
 104   if (UseCompressedClassPointers) {
 105     return Klass::decode_klass_not_null(_metadata._compressed_klass);
 106   } else {
 107     return _metadata._klass;


 338 }
 339 
 340 narrowOop oopDesc::encode_heap_oop_not_null(oop v) {
 341   assert(!is_null(v), "oop value can never be zero");
 342   assert(check_obj_alignment(v), "Address not aligned");
 343   assert(Universe::heap()->is_in_reserved(v), "Address not in heap");
 344   address base = Universe::narrow_oop_base();
 345   int    shift = Universe::narrow_oop_shift();
 346   uint64_t  pd = (uint64_t)(pointer_delta((void*)v, (void*)base, 1));
 347   assert(OopEncodingHeapMax > pd, "change encoding max if new encoding");
 348   uint64_t result = pd >> shift;
 349   assert((result & CONST64(0xffffffff00000000)) == 0, "narrow oop overflow");
 350   assert(decode_heap_oop(result) == v, "reversibility");
 351   return (narrowOop)result;
 352 }
 353 
 354 narrowOop oopDesc::encode_heap_oop(oop v) {
 355   return (is_null(v)) ? (narrowOop)0 : encode_heap_oop_not_null(v);
 356 }
 357 






 358 // Load and decode an oop out of the Java heap into a wide oop.
 359 oop oopDesc::load_decode_heap_oop_not_null(narrowOop* p) {
 360   return decode_heap_oop_not_null(*p);
 361 }
 362 
 363 // Load and decode an oop out of the heap accepting null
 364 oop oopDesc::load_decode_heap_oop(narrowOop* p) {
 365   return decode_heap_oop(*p);
 366 }
 367 






 368 // Encode and store a heap oop.
 369 void oopDesc::encode_store_heap_oop_not_null(narrowOop* p, oop v) {
 370   *p = encode_heap_oop_not_null(v);
 371 }
 372 
 373 // Encode and store a heap oop allowing for null.
 374 void oopDesc::encode_store_heap_oop(narrowOop* p, oop v) {
 375   *p = encode_heap_oop(v);
 376 }
 377 
 378 // Store heap oop as is for volatile fields.
 379 void oopDesc::release_store_heap_oop(volatile oop* p, oop v) {
 380   OrderAccess::release_store_ptr(p, v);
 381 }
 382 void oopDesc::release_store_heap_oop(volatile narrowOop* p, narrowOop v) {
 383   OrderAccess::release_store(p, v);
 384 }
 385 
 386 void oopDesc::release_encode_store_heap_oop_not_null(volatile narrowOop* p, oop v) {
 387   // heap oop is not pointer sized.
 388   OrderAccess::release_store(p, encode_heap_oop_not_null(v));
 389 }
 390 void oopDesc::release_encode_store_heap_oop_not_null(volatile oop* p, oop v) {
 391   OrderAccess::release_store_ptr(p, v);
 392 }
 393 
 394 void oopDesc::release_encode_store_heap_oop(volatile oop* p, oop v) {
 395   OrderAccess::release_store_ptr(p, v);
 396 }
 397 void oopDesc::release_encode_store_heap_oop(volatile narrowOop* p, oop v) {
 398   OrderAccess::release_store(p, encode_heap_oop(v));
 399 }
 400 
 401 // These functions are only used to exchange oop fields in instances,
 402 // not headers.
 403 oop oopDesc::atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest) {
 404   if (UseCompressedOops) {
 405     // encode exchange value from oop to T
 406     narrowOop val = encode_heap_oop(exchange_value);
 407     narrowOop old = (narrowOop)Atomic::xchg(val, (narrowOop*)dest);
 408     // decode old from T to oop
 409     return decode_heap_oop(old);
 410   } else {
 411     return (oop)Atomic::xchg_ptr(exchange_value, (oop*)dest);
 412   }
 413 }
 414 
 415 oop oopDesc::atomic_compare_exchange_oop(oop exchange_value,
 416                                          volatile HeapWord *dest,
 417                                          oop compare_value,
 418                                          bool prebarrier) {
 419   if (UseCompressedOops) {
 420     if (prebarrier) {
 421       update_barrier_set_pre((narrowOop*)dest, exchange_value);
 422     }
 423     // encode exchange and compare value from oop to T
 424     narrowOop val = encode_heap_oop(exchange_value);
 425     narrowOop cmp = encode_heap_oop(compare_value);
 426 
 427     narrowOop old = (narrowOop) Atomic::cmpxchg(val, (narrowOop*)dest, cmp);
 428     // decode old from T to oop
 429     return decode_heap_oop(old);
 430   } else {
 431     if (prebarrier) {
 432       update_barrier_set_pre((oop*)dest, exchange_value);
 433     }
 434     return (oop)Atomic::cmpxchg_ptr(exchange_value, (oop*)dest, compare_value);
 435   }
 436 }
 437 
 438 // In order to put or get a field out of an instance, must first check
 439 // if the field has been compressed and uncompress it.
 440 oop oopDesc::obj_field(int offset) const {
 441   return UseCompressedOops ?
 442     load_decode_heap_oop(obj_field_addr<narrowOop>(offset)) :
 443     load_decode_heap_oop(obj_field_addr<oop>(offset));
 444 }
 445 
 446 void oopDesc::obj_field_put(int offset, oop value) {
 447   UseCompressedOops ? oop_store(obj_field_addr<narrowOop>(offset), value) :
 448                       oop_store(obj_field_addr<oop>(offset),       value);
 449 }
 450 
 451 void oopDesc::obj_field_put_raw(int offset, oop value) {
 452   UseCompressedOops ?
 453     encode_store_heap_oop(obj_field_addr<narrowOop>(offset), value) :
 454     encode_store_heap_oop(obj_field_addr<oop>(offset),       value);
 455 }
 456 void oopDesc::obj_field_put_volatile(int offset, oop value) {
 457   OrderAccess::release();
 458   obj_field_put(offset, value);
 459   OrderAccess::fence();
 460 }
 461 
 462 Metadata* oopDesc::metadata_field(int offset) const           { return *metadata_field_addr(offset);   }
 463 void oopDesc::metadata_field_put(int offset, Metadata* value) { *metadata_field_addr(offset) = value;  }
 464 
 465 jbyte oopDesc::byte_field(int offset) const                   { return (jbyte) *byte_field_addr(offset);    }
 466 void oopDesc::byte_field_put(int offset, jbyte contents)      { *byte_field_addr(offset) = (jint) contents; }
 467 
 468 jchar oopDesc::char_field(int offset) const                   { return (jchar) *char_field_addr(offset);    }
 469 void oopDesc::char_field_put(int offset, jchar contents)      { *char_field_addr(offset) = (jint) contents; }
 470 
 471 jboolean oopDesc::bool_field(int offset) const                { return (jboolean) *bool_field_addr(offset); }
 472 void oopDesc::bool_field_put(int offset, jboolean contents)   { *bool_field_addr(offset) = (((jint) contents) & 1); }
 473 
 474 jint oopDesc::int_field(int offset) const                     { return *int_field_addr(offset);        }
 475 void oopDesc::int_field_put(int offset, jint contents)        { *int_field_addr(offset) = contents;    }
 476 
 477 jshort oopDesc::short_field(int offset) const                 { return (jshort) *short_field_addr(offset);  }
 478 void oopDesc::short_field_put(int offset, jshort contents)    { *short_field_addr(offset) = (jint) contents;}
 479 
 480 jlong oopDesc::long_field(int offset) const                   { return *long_field_addr(offset);       }
 481 void oopDesc::long_field_put(int offset, jlong contents)      { *long_field_addr(offset) = contents;   }
 482 
 483 jfloat oopDesc::float_field(int offset) const                 { return *float_field_addr(offset);      }
 484 void oopDesc::float_field_put(int offset, jfloat contents)    { *float_field_addr(offset) = contents;  }
 485 
 486 jdouble oopDesc::double_field(int offset) const               { return *double_field_addr(offset);     }
 487 void oopDesc::double_field_put(int offset, jdouble contents)  { *double_field_addr(offset) = contents; }
 488 
 489 address oopDesc::address_field(int offset) const              { return *address_field_addr(offset);     }
 490 void oopDesc::address_field_put(int offset, address contents) { *address_field_addr(offset) = contents; }
 491 
 492 oop oopDesc::obj_field_acquire(int offset) const {
 493   return UseCompressedOops ?
 494              decode_heap_oop((narrowOop)
 495                OrderAccess::load_acquire(obj_field_addr<narrowOop>(offset)))
 496            : decode_heap_oop((oop)
 497                OrderAccess::load_ptr_acquire(obj_field_addr<oop>(offset)));
 498 }
 499 void oopDesc::release_obj_field_put(int offset, oop value) {
 500   UseCompressedOops ?
 501     oop_store((volatile narrowOop*)obj_field_addr<narrowOop>(offset), value) :
 502     oop_store((volatile oop*)      obj_field_addr<oop>(offset),       value);
 503 }
 504 
 505 jbyte oopDesc::byte_field_acquire(int offset) const                   { return OrderAccess::load_acquire(byte_field_addr(offset));     }
 506 void oopDesc::release_byte_field_put(int offset, jbyte contents)      { OrderAccess::release_store(byte_field_addr(offset), contents); }
 507 
 508 jchar oopDesc::char_field_acquire(int offset) const                   { return OrderAccess::load_acquire(char_field_addr(offset));     }
 509 void oopDesc::release_char_field_put(int offset, jchar contents)      { OrderAccess::release_store(char_field_addr(offset), contents); }
 510 
 511 jboolean oopDesc::bool_field_acquire(int offset) const                { return OrderAccess::load_acquire(bool_field_addr(offset));     }
 512 void oopDesc::release_bool_field_put(int offset, jboolean contents)   { OrderAccess::release_store(bool_field_addr(offset), (contents & 1)); }
 513 
 514 jint oopDesc::int_field_acquire(int offset) const                     { return OrderAccess::load_acquire(int_field_addr(offset));      }
 515 void oopDesc::release_int_field_put(int offset, jint contents)        { OrderAccess::release_store(int_field_addr(offset), contents);  }
 516 
 517 jshort oopDesc::short_field_acquire(int offset) const                 { return (jshort)OrderAccess::load_acquire(short_field_addr(offset)); }
 518 void oopDesc::release_short_field_put(int offset, jshort contents)    { OrderAccess::release_store(short_field_addr(offset), contents);     }
 519 
 520 jlong oopDesc::long_field_acquire(int offset) const                   { return OrderAccess::load_acquire(long_field_addr(offset));       }
 521 void oopDesc::release_long_field_put(int offset, jlong contents)      { OrderAccess::release_store(long_field_addr(offset), contents);   }
 522 
 523 jfloat oopDesc::float_field_acquire(int offset) const                 { return OrderAccess::load_acquire(float_field_addr(offset));      }
 524 void oopDesc::release_float_field_put(int offset, jfloat contents)    { OrderAccess::release_store(float_field_addr(offset), contents);  }
 525 
 526 jdouble oopDesc::double_field_acquire(int offset) const               { return OrderAccess::load_acquire(double_field_addr(offset));     }
 527 void oopDesc::release_double_field_put(int offset, jdouble contents)  { OrderAccess::release_store(double_field_addr(offset), contents); }
 528 
 529 address oopDesc::address_field_acquire(int offset) const              { return (address) OrderAccess::load_ptr_acquire(address_field_addr(offset)); }
 530 void oopDesc::release_address_field_put(int offset, address contents) { OrderAccess::release_store_ptr(address_field_addr(offset), contents); }
 531 
 532 bool oopDesc::is_locked() const {
 533   return mark()->is_locked();
 534 }
 535 
 536 bool oopDesc::is_unlocked() const {
 537   return mark()->is_unlocked();
 538 }
 539 
 540 bool oopDesc::has_bias_pattern() const {
 541   return mark()->has_bias_pattern();
 542 }
 543 
 544 // used only for asserts
 545 bool oopDesc::is_oop(bool ignore_mark_word) const {
 546   oop obj = (oop) this;
 547   if (!check_obj_alignment(obj)) return false;
 548   if (!Universe::heap()->is_in_reserved(obj)) return false;
 549   // obj is aligned and accessible in heap
 550   if (Universe::heap()->is_in_reserved(obj->klass_or_null())) return false;




   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_OOPS_OOP_INLINE_HPP
  26 #define SHARE_VM_OOPS_OOP_INLINE_HPP
  27 
  28 #include "gc/shared/ageTable.hpp"


  29 #include "gc/shared/collectedHeap.inline.hpp"
  30 #include "gc/shared/genCollectedHeap.hpp"
  31 #include "gc/shared/generation.hpp"
  32 #include "oops/arrayKlass.hpp"
  33 #include "oops/arrayOop.hpp"
  34 #include "oops/klass.inline.hpp"
  35 #include "oops/markOop.inline.hpp"
  36 #include "oops/oop.hpp"
  37 #include "runtime/access.hpp"
  38 #include "runtime/atomic.hpp"
  39 #include "runtime/orderAccess.inline.hpp"
  40 #include "runtime/os.hpp"
  41 #include "utilities/macros.hpp"
  42 












































  43 // Implementation of all inlined member functions defined in oop.hpp
  44 // We need a separate file to avoid circular references
  45 
  46 void oopDesc::release_set_mark(markOop m) {
  47   OrderAccess::release_store_ptr(&_mark, m);
  48 }
  49 
  50 markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) {
  51   return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark);
  52 }
  53 
  54 void oopDesc::init_mark() {
  55   set_mark(markOopDesc::prototype_for_object(this));
  56 }
  57 
  58 Klass* oopDesc::klass() const {
  59   if (UseCompressedClassPointers) {
  60     return Klass::decode_klass_not_null(_metadata._compressed_klass);
  61   } else {
  62     return _metadata._klass;


 293 }
 294 
 295 narrowOop oopDesc::encode_heap_oop_not_null(oop v) {
 296   assert(!is_null(v), "oop value can never be zero");
 297   assert(check_obj_alignment(v), "Address not aligned");
 298   assert(Universe::heap()->is_in_reserved(v), "Address not in heap");
 299   address base = Universe::narrow_oop_base();
 300   int    shift = Universe::narrow_oop_shift();
 301   uint64_t  pd = (uint64_t)(pointer_delta((void*)v, (void*)base, 1));
 302   assert(OopEncodingHeapMax > pd, "change encoding max if new encoding");
 303   uint64_t result = pd >> shift;
 304   assert((result & CONST64(0xffffffff00000000)) == 0, "narrow oop overflow");
 305   assert(decode_heap_oop(result) == v, "reversibility");
 306   return (narrowOop)result;
 307 }
 308 
 309 narrowOop oopDesc::encode_heap_oop(oop v) {
 310   return (is_null(v)) ? (narrowOop)0 : encode_heap_oop_not_null(v);
 311 }
 312 
 313 narrowOop oopDesc::load_heap_oop(narrowOop* p) { return *p; }
 314 oop       oopDesc::load_heap_oop(oop* p)       { return *p; }
 315 
 316 void oopDesc::store_heap_oop(narrowOop* p, narrowOop v) { *p = v; }
 317 void oopDesc::store_heap_oop(oop* p, oop v)             { *p = v; }
 318 
 319 // Load and decode an oop out of the Java heap into a wide oop.
 320 oop oopDesc::load_decode_heap_oop_not_null(narrowOop* p) {
 321   return decode_heap_oop_not_null(load_heap_oop(p));
 322 }
 323 
 324 // Load and decode an oop out of the heap accepting null
 325 oop oopDesc::load_decode_heap_oop(narrowOop* p) {
 326   return decode_heap_oop(load_heap_oop(p));
 327 }
 328 
 329 oop oopDesc::load_decode_heap_oop_not_null(oop* p) { return *p; }
 330 oop oopDesc::load_decode_heap_oop(oop* p)          { return *p; }
 331 
 332 void oopDesc::encode_store_heap_oop_not_null(oop* p, oop v) { *p = v; }
 333 void oopDesc::encode_store_heap_oop(oop* p, oop v)          { *p = v; }
 334 
 335 // Encode and store a heap oop.
 336 void oopDesc::encode_store_heap_oop_not_null(narrowOop* p, oop v) {
 337   *p = encode_heap_oop_not_null(v);
 338 }
 339 
 340 // Encode and store a heap oop allowing for null.
 341 void oopDesc::encode_store_heap_oop(narrowOop* p, oop v) {
 342   *p = encode_heap_oop(v);
 343 }
 344 
 345 inline oop oopDesc::obj_field(int offset) const                  { return HeapAccess<>::oop_load_at(oop_base(), offset); }
 346 inline void oopDesc::obj_field_put(int offset, oop value)        { HeapAccess<>::oop_store_at(oop_base(), offset, value); }































































































































 347 
 348 inline jbyte oopDesc::byte_field(int offset) const               { return HeapAccess<>::load_at(oop_base(), offset); }
 349 inline void oopDesc::byte_field_put(int offset, jbyte value)     { HeapAccess<>::store_at(oop_base(), offset, value); }
 350 
 351 inline jchar oopDesc::char_field(int offset) const               { return HeapAccess<>::load_at(oop_base(), offset); }
 352 inline void oopDesc::char_field_put(int offset, jchar value)     { HeapAccess<>::store_at(oop_base(), offset, value); }
 353 
 354 inline jboolean oopDesc::bool_field(int offset) const            { return HeapAccess<>::load_at(oop_base(), offset); }
 355 inline void oopDesc::bool_field_put(int offset, jboolean value)  { HeapAccess<>::store_at(oop_base(), offset, jboolean(value & 1)); }
 356 
 357 inline jint oopDesc::int_field(int offset) const                 { return HeapAccess<>::load_at(oop_base(), offset); }
 358 inline void oopDesc::int_field_put(int offset, jint value)       { HeapAccess<>::store_at(oop_base(), offset, value); }
 359 
 360 inline jshort oopDesc::short_field(int offset) const             { return HeapAccess<>::load_at(oop_base(), offset); }
 361 inline void oopDesc::short_field_put(int offset, jshort value)   { HeapAccess<>::store_at(oop_base(), offset, value); }
 362 
 363 inline jlong oopDesc::long_field(int offset) const               { return HeapAccess<>::load_at(oop_base(), offset); }
 364 inline void oopDesc::long_field_put(int offset, jlong value)     { HeapAccess<>::store_at(oop_base(), offset, value); }
 365 
 366 inline jfloat oopDesc::float_field(int offset) const             { return HeapAccess<>::load_at(oop_base(), offset); }
 367 inline void oopDesc::float_field_put(int offset, jfloat value)   { HeapAccess<>::store_at(oop_base(), offset, value); }
 368 
 369 inline jdouble oopDesc::double_field(int offset) const           { return HeapAccess<>::load_at(oop_base(), offset); }
 370 inline void oopDesc::double_field_put(int offset, jdouble value) { HeapAccess<>::store_at(oop_base(), offset, value); }
 371 
 372 bool oopDesc::is_locked() const {
 373   return mark()->is_locked();
 374 }
 375 
 376 bool oopDesc::is_unlocked() const {
 377   return mark()->is_unlocked();
 378 }
 379 
 380 bool oopDesc::has_bias_pattern() const {
 381   return mark()->has_bias_pattern();
 382 }
 383 
 384 // used only for asserts
 385 bool oopDesc::is_oop(bool ignore_mark_word) const {
 386   oop obj = (oop) this;
 387   if (!check_obj_alignment(obj)) return false;
 388   if (!Universe::heap()->is_in_reserved(obj)) return false;
 389   // obj is aligned and accessible in heap
 390   if (Universe::heap()->is_in_reserved(obj->klass_or_null())) return false;


< prev index next >