src/share/vm/oops/constantPool.hpp

@@ -60,10 +60,26 @@
   Symbol* get_symbol() {
     return (Symbol*)(_ptr & ~_pseudo_bit);
   }
 };
 
+class CPKlassSlot VALUE_OBJ_CLASS_SPEC {
+  int _name_index;
+  int _resolved_klass_index;
+public:
+  CPKlassSlot(int n, int rk) {
+    _name_index = n;
+    _resolved_klass_index = rk;
+  }
+  int name_index() const {
+    return _name_index;
+  }
+  int resolved_klass_index() const {
+    return _resolved_klass_index;
+  }
+};
+
 class KlassSizeStats;
 
 class ConstantPool : public Metadata {
   friend class VMStructs;
   friend class JVMCIVMStructs;

@@ -79,11 +95,11 @@
   Array<Klass*>*       _resolved_klasses;
 
   enum {
     _has_preresolution = 1,           // Flags
     _on_stack          = 2,
-    _is_shared_quick   = 4
+    _is_shared         = 4
   };
   enum {
     _invalid_resolved_klass_index = 0xffff
   };
 

@@ -160,11 +176,11 @@
   Array<u1>* tags() const                   { return _tags; }
   Array<u2>* operands() const               { return _operands; }
 
   bool has_preresolution() const            { return (_flags & _has_preresolution) != 0; }
   void set_has_preresolution() {
-    assert(!is_shared_quick(), "should never be called on shared ConstantPools");
+    assert(!is_shared(), "should never be called on shared ConstantPools");
     _flags |= _has_preresolution;
   }
 
   // Redefine classes support.  If a method refering to this constant pool
   // is on the executing stack, or as a handle in vm code, this constant pool

@@ -172,12 +188,11 @@
   // class.
   bool on_stack() const                      { return (_flags &_on_stack) != 0; }
   void set_on_stack(const bool value);
 
   // Faster than MetaspaceObj::is_shared() - used by set_on_stack()
-  bool is_shared_quick() const               { return (_flags & _is_shared_quick) != 0; }
-  void set_is_shared_quick()                 { _flags |= _is_shared_quick; }
+  bool is_shared() const                     { return (_flags & _is_shared) != 0; }
 
   // Klass holding pool
   InstanceKlass* pool_holder() const      { return _pool_holder; }
   void set_pool_holder(InstanceKlass* k)  { _pool_holder = k; }
   InstanceKlass** pool_holder_addr()      { return &_pool_holder; }

@@ -352,23 +367,32 @@
   Klass* klass_at_ignore_error(int which, TRAPS) {
     constantPoolHandle h_this(THREAD, this);
     return klass_at_impl(h_this, which, false, THREAD);
   }
 
+  CPKlassSlot klass_slot_at(int which) const {
+    assert(tag_at(which).is_unresolved_klass() || tag_at(which).is_klass(),
+           "Corrupted constant pool");
+    int value = *int_at_addr(which);
+    int name_index = extract_high_short_from_int(value);
+    int resolved_klass_index = extract_low_short_from_int(value);
+    return CPKlassSlot(name_index, resolved_klass_index);
+  }
+
   Symbol* klass_name_at(int which) const;  // Returns the name, w/o resolving.
-  int klass_name_index_at(int which) const;
+  int klass_name_index_at(int which) const {
+    return klass_slot_at(which).name_index();
+  }
 
   Klass* resolved_klass_at(int which) const {  // Used by Compiler
     guarantee(tag_at(which).is_klass(), "Corrupted constant pool");
     // Must do an acquire here in case another thread resolved the klass
     // behind our back, lest we later load stale values thru the oop.
-    int value = *int_at_addr(which);
-    int resolved_klass_index = extract_low_short_from_int(value);
-    int name_index = extract_high_short_from_int(value);
-    assert(tag_at(name_index).is_symbol(), "sanity");
+    CPKlassSlot kslot = klass_slot_at(which);
+    assert(tag_at(kslot.name_index()).is_symbol(), "sanity");
 
-    Klass** adr = resolved_klasses()->adr_at(resolved_klass_index);
+    Klass** adr = resolved_klasses()->adr_at(kslot.resolved_klass_index());
     return (Klass*)OrderAccess::load_ptr_acquire(adr);
   }
 
   // RedefineClasses() API support:
   Symbol* klass_at_noresolve(int which) { return klass_name_at(which); }