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

rev 9846 : 8146401: Clean up oop.hpp: add inline directives and fix header files
Reviewed-by: coleenp
rev 9847 : 8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
Summary: Fix remaining issues after 8146401

@@ -98,11 +98,11 @@
 
 void oopDesc::init_mark() {
   set_mark(markOopDesc::prototype_for_object(this));
 }
 
-inline Klass* oopDesc::klass() const {
+Klass* oopDesc::klass() const {
   if (UseCompressedClassPointers) {
     return Klass::decode_klass_not_null(_metadata._compressed_klass);
   } else {
     return _metadata._klass;
   }

@@ -127,11 +127,11 @@
 narrowKlass* oopDesc::compressed_klass_addr() {
   assert(UseCompressedClassPointers, "only called by compressed klass pointers");
   return &_metadata._compressed_klass;
 }
 
-inline void oopDesc::set_klass(Klass* k) {
+void oopDesc::set_klass(Klass* k) {
   // since klasses are promoted no store check is needed
   assert(Universe::is_bootstrapping() || k != NULL, "must be a real Klass*");
   assert(Universe::is_bootstrapping() || k->is_klass(), "not a Klass*");
   if (UseCompressedClassPointers) {
     *compressed_klass_addr() = Klass::encode_klass_not_null(k);

@@ -142,11 +142,11 @@
 
 int oopDesc::klass_gap() const {
   return *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes());
 }
 
-inline void oopDesc::set_klass_gap(int v) {
+void oopDesc::set_klass_gap(int v) {
   if (UseCompressedClassPointers) {
     *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()) = v;
   }
 }
 

@@ -172,11 +172,11 @@
 
 bool oopDesc::is_a(Klass* k) const {
   return klass()->is_subtype_of(k);
 }
 
-inline int oopDesc::size()  {
+int oopDesc::size()  {
   return size_given_klass(klass());
 }
 
 int oopDesc::size_given_klass(Klass* klass)  {
   int lh = klass->layout_helper();

@@ -262,11 +262,11 @@
   assert(s > 0, "Bad size calculated");
   return s;
 }
 
 bool oopDesc::is_instance()  const { return klass()->is_instance_klass();  }
-inline bool oopDesc::is_array()     const { return klass()->is_array_klass();     }
+bool oopDesc::is_array()     const { return klass()->is_array_klass();     }
 bool oopDesc::is_objArray()  const { return klass()->is_objArray_klass();  }
 bool oopDesc::is_typeArray() const { return klass()->is_typeArray_klass(); }
 
 void*      oopDesc::field_base(int offset)          const { return (void*)&((char*)this)[offset]; }
 

@@ -296,20 +296,20 @@
 
 inline bool check_obj_alignment(oop obj) {
   return cast_from_oop<intptr_t>(obj) % MinObjAlignmentInBytes == 0;
 }
 
-inline oop oopDesc::decode_heap_oop_not_null(narrowOop v) {
+oop oopDesc::decode_heap_oop_not_null(narrowOop v) {
   assert(!is_null(v), "narrow oop value can never be zero");
   address base = Universe::narrow_oop_base();
   int    shift = Universe::narrow_oop_shift();
   oop result = (oop)(void*)((uintptr_t)base + ((uintptr_t)v << shift));
   assert(check_obj_alignment(result), "address not aligned: " INTPTR_FORMAT, p2i((void*) result));
   return result;
 }
 
-inline oop oopDesc::decode_heap_oop(narrowOop v) {
+oop oopDesc::decode_heap_oop(narrowOop v) {
   return is_null(v) ? (oop)NULL : decode_heap_oop_not_null(v);
 }
 
 narrowOop oopDesc::encode_heap_oop_not_null(oop v) {
   assert(!is_null(v), "oop value can never be zero");

@@ -323,11 +323,11 @@
   assert((result & CONST64(0xffffffff00000000)) == 0, "narrow oop overflow");
   assert(decode_heap_oop(result) == v, "reversibility");
   return (narrowOop)result;
 }
 
-inline narrowOop oopDesc::encode_heap_oop(oop v) {
+narrowOop oopDesc::encode_heap_oop(oop v) {
   return (is_null(v)) ? (narrowOop)0 : encode_heap_oop_not_null(v);
 }
 
 // Load and decode an oop out of the Java heap into a wide oop.
 oop oopDesc::load_decode_heap_oop_not_null(narrowOop* p) {

@@ -514,11 +514,11 @@
 bool oopDesc::has_bias_pattern() const {
   return mark()->has_bias_pattern();
 }
 
 // used only for asserts
-inline bool oopDesc::is_oop(bool ignore_mark_word) const {
+bool oopDesc::is_oop(bool ignore_mark_word) const {
   oop obj = (oop) this;
   if (!check_obj_alignment(obj)) return false;
   if (!Universe::heap()->is_in_reserved(obj)) return false;
   // obj is aligned and accessible in heap
   if (Universe::heap()->is_in_reserved(obj->klass_or_null())) return false;

@@ -536,11 +536,11 @@
   return !SafepointSynchronize::is_at_safepoint();
 }
 
 
 // used only for asserts
-inline bool oopDesc::is_oop_or_null(bool ignore_mark_word) const {
+bool oopDesc::is_oop_or_null(bool ignore_mark_word) const {
   return this == NULL ? true : is_oop(ignore_mark_word);
 }
 
 #ifndef PRODUCT
 // used only for asserts

@@ -618,11 +618,11 @@
 oop oopDesc::forwardee() const {
   return (oop) mark()->decode_pointer();
 }
 
 // The following method needs to be MT safe.
-inline uint oopDesc::age() const {
+uint oopDesc::age() const {
   assert(!is_forwarded(), "Attempt to read age from forwarded mark");
   if (has_displaced_mark()) {
     return displaced_mark()->age();
   } else {
     return mark()->age();