/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#ifndef SHARE_VM_CI_CIOBJECT_HPP
#define SHARE_VM_CI_CIOBJECT_HPP
#include "ci/ciClassList.hpp"
#include "memory/allocation.hpp"
#include "runtime/handles.hpp"
#include "runtime/jniHandles.hpp"
// ciObject
//
// This class represents an oop in the HotSpot virtual machine.
// Its subclasses are structured in a hierarchy which mirrors
// an aggregate of the VM's oop and klass hierarchies (see
// oopHierarchy.hpp). Each instance of ciObject holds a handle
// to a corresponding oop on the VM side and provides routines
// for accessing the information in its oop. By using the ciObject
// hierarchy for accessing oops in the VM, the compiler ensures
// that it is safe with respect to garbage collection; that is,
// GC and compilation can proceed independently without
// interference.
//
// 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
// reflected in the interface and instead the Klass hierarchy
// is directly modeled as the subclasses of ciKlass.
friend class ciEnv;
private:
// A JNI handle referring to an oop in the VM. This
// handle may, in a small set of cases, correctly be NULL.
enum {
};
protected:
ciObject();
// Get the VM oop that this object holds.
}
int flags = 0;
if (x != NULL) {
if (x->is_perm())
if (x->is_scavengable())
}
}
// Virtual behavior of the print() method.
public:
// The klass of this ciObject.
// A number unique to this object.
uint ident();
// Are two ciObjects equal?
// A hash value for the convenience of compilers.
int hash();
// Tells if this oop has an encoding as a constant.
// True if is_perm is true.
// Also true if ScavengeRootsInCode is non-zero.
// If it does not have an encoding, the compiler is responsible for
// making other arrangements for dealing with the oop.
// See ciEnv::make_array
bool can_be_constant();
// Tells if this oop should be made a constant.
// 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.
// Might this object possibly move during a scavenge operation?
// If the answer is true and ScavengeRootsInCode==0, the oop cannot be embedded in code.
// The address which the compiler should embed into the
// generated code to represent this oop. This address
// is not the true address of the oop -- it will get patched
// during nmethod creation.
//
// Usage note: no address arithmetic allowed. Oop must
// be registered with the oopRecorder.
// 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_method_type() 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.
bool is_loaded() const {
}
// Subclass casting with assertions.
return (ciNullObject*)this;
}
return (ciCallSite*)this;
}
return (ciCPCache*)this;
}
return (ciInstance*)this;
}
return (ciMemberName*)this;
}
return (ciMethod*)this;
}
return (ciMethodData*)this;
}
return (ciMethodHandle*)this;
}
return (ciMethodType*)this;
}
return (ciArray*)this;
}
return (ciObjArray*)this;
}
return (ciTypeArray*)this;
}
return (ciSymbol*)this;
}
return (ciType*)this;
}
return (ciReturnAddress*)this;
}
return (ciKlass*)this;
}
return (ciInstanceKlass*)this;
}
return (ciMethodKlass*)this;
}
return (ciArrayKlass*)this;
}
return (ciObjArrayKlass*)this;
}
return (ciTypeArrayKlass*)this;
}
return (ciKlassKlass*)this;
}
return (ciInstanceKlassKlass*)this;
}
return (ciArrayKlassKlass*)this;
}
return (ciObjArrayKlassKlass*)this;
}
return (ciTypeArrayKlassKlass*)this;
}
// Print debugging output about this ciObject.
// Print debugging output about the oop this ciObject represents.
};
#endif // SHARE_VM_CI_CIOBJECT_HPP