--- a/src/share/vm/ci/ciObject.hpp	Fri Aug 31 16:39:35 2012 -0700
+++ b/src/share/vm/ci/ciObject.hpp	Sat Sep 01 13:25:18 2012 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,7 @@
 #ifndef SHARE_VM_CI_CIOBJECT_HPP
 #define SHARE_VM_CI_CIOBJECT_HPP
 
+#include "ci/ciBaseObject.hpp"
 #include "ci/ciClassList.hpp"
 #include "memory/allocation.hpp"
 #include "runtime/handles.hpp"
@@ -45,10 +46,10 @@
 //
 // Within the VM, the oop and klass hierarchies are separate.
 // The compiler interface does not preserve this separation --
-// the distinction between `klassOop' and `Klass' are not
+// the distinction between `Klass*' and `Klass' are not
 // reflected in the interface and instead the Klass hierarchy
 // is directly modeled as the subclasses of ciKlass.
-class ciObject : public ResourceObj {
+class ciObject : public ciBaseObject {
   CI_PACKAGE_ACCESS
   friend class ciEnv;
 
@@ -57,13 +58,7 @@
   // handle may, in a small set of cases, correctly be NULL.
   jobject  _handle;
   ciKlass* _klass;
-  uint     _ident;
 
-  enum { FLAG_BITS   = 2 };
-  enum {
-         PERM_FLAG        = 1,
-         SCAVENGABLE_FLAG = 2
-       };
 protected:
   ciObject();
   ciObject(oop o);
@@ -77,30 +72,17 @@
     return JNIHandles::resolve_non_null(_handle);
   }
 
-  void init_flags_from(oop x) {
-    int flags = 0;
-    if (x != NULL) {
-      if (x->is_perm())
-        flags |= PERM_FLAG;
-      if (x->is_scavengable())
-        flags |= SCAVENGABLE_FLAG;
-    }
-    _ident |= flags;
-  }
+  void init_flags_from(oop x);
 
   // Virtual behavior of the print() method.
   virtual void print_impl(outputStream* st) {}
 
   virtual const char* type_string() { return "ciObject"; }
 
-  void set_ident(uint id);
 public:
   // The klass of this ciObject.
   ciKlass* klass();
 
-  // A number unique to this object.
-  uint ident();
-
   // Are two ciObjects equal?
   bool equals(ciObject* obj);
 
@@ -119,11 +101,6 @@
   // True if is_perm is true or ScavengeRootsInCode > 1.
   bool should_be_constant();
 
-  // Is this object guaranteed to be in the permanent part of the heap?
-  // If so, CollectedHeap::can_elide_permanent_oop_store_barriers is relevant.
-  // If the answer is false, no guarantees are made.
-  bool is_perm() { return (_ident & PERM_FLAG) != 0; }
-
   // Might this object possibly move during a scavenge operation?
   // If the answer is true and ScavengeRootsInCode==0, the oop cannot be embedded in code.
   bool is_scavengable() { return (_ident & SCAVENGABLE_FLAG) != 0; }
@@ -137,57 +114,29 @@
   // be registered with the oopRecorder.
   jobject constant_encoding();
 
+  virtual bool is_object() const            { return true; }
+
   // What kind of ciObject is this?
   virtual bool is_null_object()       const { return false; }
   virtual bool is_call_site()         const { return false; }
   virtual bool is_cpcache()           const { return false; }
   virtual bool is_instance()                { return false; }
   virtual bool is_member_name()       const { return false; }
-  virtual bool is_method()                  { return false; }
-  virtual bool is_method_data()             { return false; }
   virtual bool is_method_handle()     const { return false; }
   virtual bool is_array()                   { return false; }
   virtual bool is_obj_array()               { return false; }
   virtual bool is_type_array()              { return false; }
-  virtual bool is_symbol()                  { return false; }
-  virtual bool is_type()                    { return false; }
-  virtual bool is_return_address()          { return false; }
-  virtual bool is_klass()                   { return false; }
-  virtual bool is_instance_klass()          { return false; }
-  virtual bool is_method_klass()            { return false; }
-  virtual bool is_array_klass()             { return false; }
-  virtual bool is_obj_array_klass()         { return false; }
-  virtual bool is_type_array_klass()        { return false; }
-  virtual bool is_symbol_klass()            { return false; }
-  virtual bool is_klass_klass()             { return false; }
-  virtual bool is_instance_klass_klass()    { return false; }
-  virtual bool is_array_klass_klass()       { return false; }
-  virtual bool is_obj_array_klass_klass()   { return false; }
-  virtual bool is_type_array_klass_klass()  { return false; }
 
   // Is this a type or value which has no associated class?
   // It is true of primitive types and null objects.
   virtual bool is_classless() const         { return false; }
 
-  // Is this ciObject a Java Language Object?  That is,
-  // is the ciObject an instance or an array
-  virtual bool is_java_object()             { return false; }
-
-  // Does this ciObject represent a Java Language class?
-  // That is, is the ciObject an instanceKlass or arrayKlass?
-  virtual bool is_java_klass()              { return false; }
-
-  // Is this ciObject the ciInstanceKlass representing
-  // java.lang.Object()?
-  virtual bool is_java_lang_Object()        { return false; }
-
-  // Does this ciObject refer to a real oop in the VM?
-  //
-  // Note: some ciObjects refer to oops which have yet to be
-  // created.  We refer to these as "unloaded".  Specifically,
-  // there are unloaded ciMethods, ciObjArrayKlasses, and
-  // ciInstanceKlasses.  By convention the ciNullObject is
-  // considered loaded, and primitive types are considered loaded.
+  // Note: some ciObjects refer to oops which have yet to be created.
+  // We refer to these as "unloaded".  Specifically, there are
+  // unloaded instances of java.lang.Class,
+  // java.lang.invoke.MethodHandle, and java.lang.invoke.MethodType.
+  // By convention the ciNullObject is considered loaded, and
+  // primitive types are considered loaded.
   bool is_loaded() const {
     return handle() != NULL || is_classless();
   }
@@ -201,10 +150,6 @@
     assert(is_call_site(), "bad cast");
     return (ciCallSite*) this;
   }
-  ciCPCache*               as_cpcache() {
-    assert(is_cpcache(), "bad cast");
-    return (ciCPCache*) this;
-  }
   ciInstance*              as_instance() {
     assert(is_instance(), "bad cast");
     return (ciInstance*)this;
@@ -213,14 +158,6 @@
     assert(is_member_name(), "bad cast");
     return (ciMemberName*)this;
   }
-  ciMethod*                as_method() {
-    assert(is_method(), "bad cast");
-    return (ciMethod*)this;
-  }
-  ciMethodData*            as_method_data() {
-    assert(is_method_data(), "bad cast");
-    return (ciMethodData*)this;
-  }
   ciMethodHandle*          as_method_handle() {
     assert(is_method_handle(), "bad cast");
     return (ciMethodHandle*) this;
@@ -237,62 +174,6 @@
     assert(is_type_array(), "bad cast");
     return (ciTypeArray*)this;
   }
-  ciSymbol*                as_symbol() {
-    assert(is_symbol(), "bad cast");
-    return (ciSymbol*)this;
-  }
-  ciType*                  as_type() {
-    assert(is_type(), "bad cast");
-    return (ciType*)this;
-  }
-  ciReturnAddress*         as_return_address() {
-    assert(is_return_address(), "bad cast");
-    return (ciReturnAddress*)this;
-  }
-  ciKlass*                 as_klass() {
-    assert(is_klass(), "bad cast");
-    return (ciKlass*)this;
-  }
-  ciInstanceKlass*         as_instance_klass() {
-    assert(is_instance_klass(), "bad cast");
-    return (ciInstanceKlass*)this;
-  }
-  ciMethodKlass*           as_method_klass() {
-    assert(is_method_klass(), "bad cast");
-    return (ciMethodKlass*)this;
-  }
-  ciArrayKlass*            as_array_klass() {
-    assert(is_array_klass(), "bad cast");
-    return (ciArrayKlass*)this;
-  }
-  ciObjArrayKlass*         as_obj_array_klass() {
-    assert(is_obj_array_klass(), "bad cast");
-    return (ciObjArrayKlass*)this;
-  }
-  ciTypeArrayKlass*        as_type_array_klass() {
-    assert(is_type_array_klass(), "bad cast");
-    return (ciTypeArrayKlass*)this;
-  }
-  ciKlassKlass*            as_klass_klass() {
-    assert(is_klass_klass(), "bad cast");
-    return (ciKlassKlass*)this;
-  }
-  ciInstanceKlassKlass*    as_instance_klass_klass() {
-    assert(is_instance_klass_klass(), "bad cast");
-    return (ciInstanceKlassKlass*)this;
-  }
-  ciArrayKlassKlass*       as_array_klass_klass() {
-    assert(is_array_klass_klass(), "bad cast");
-    return (ciArrayKlassKlass*)this;
-  }
-  ciObjArrayKlassKlass*    as_obj_array_klass_klass() {
-    assert(is_obj_array_klass_klass(), "bad cast");
-    return (ciObjArrayKlassKlass*)this;
-  }
-  ciTypeArrayKlassKlass*   as_type_array_klass_klass() {
-    assert(is_type_array_klass_klass(), "bad cast");
-    return (ciTypeArrayKlassKlass*)this;
-  }
 
   // Print debugging output about this ciObject.
   void print(outputStream* st);