1 /* 2 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 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_CI_CIOBJECT_HPP 26 #define SHARE_VM_CI_CIOBJECT_HPP 27 28 #include "ci/ciBaseObject.hpp" 29 #include "ci/ciClassList.hpp" 30 #include "memory/allocation.hpp" 31 #include "runtime/handles.hpp" 32 #include "runtime/jniHandles.hpp" 33 34 // ciObject 35 // 36 // This class represents an oop in the HotSpot virtual machine. 37 // Its subclasses are structured in a hierarchy which mirrors 38 // an aggregate of the VM's oop and klass hierarchies (see 39 // oopHierarchy.hpp). Each instance of ciObject holds a handle 40 // to a corresponding oop on the VM side and provides routines 41 // for accessing the information in its oop. By using the ciObject 42 // hierarchy for accessing oops in the VM, the compiler ensures 43 // that it is safe with respect to garbage collection; that is, 44 // GC and compilation can proceed independently without 45 // interference. 46 // 47 // Within the VM, the oop and klass hierarchies are separate. 48 // The compiler interface does not preserve this separation -- 49 // the distinction between `Klass*' and `Klass' are not 50 // reflected in the interface and instead the Klass hierarchy 51 // is directly modeled as the subclasses of ciKlass. 52 class ciObject : public ciBaseObject { 53 CI_PACKAGE_ACCESS 54 friend class ciEnv; 55 56 private: 57 // A JNI handle referring to an oop in the VM. This 58 // handle may, in a small set of cases, correctly be NULL. 59 jobject _handle; 60 ciKlass* _klass; 61 62 protected: 63 ciObject(); 64 ciObject(oop o); 65 ciObject(Handle h); 66 ciObject(ciKlass* klass); 67 68 jobject handle() const { return _handle; } 69 // Get the VM oop that this object holds. 70 oop get_oop() const { 71 assert(_handle != NULL, "null oop"); 72 return JNIHandles::resolve_non_null(_handle); 73 } 74 75 void init_flags_from(oop x); 76 77 // Virtual behavior of the print() method. 78 virtual void print_impl(outputStream* st) {} 79 80 virtual const char* type_string() { return "ciObject"; } 81 82 public: 83 // The klass of this ciObject. 84 ciKlass* klass(); 85 86 // Are two ciObjects equal? 87 bool equals(ciObject* obj); 88 89 // A hash value for the convenience of compilers. 90 int hash(); 91 92 // Tells if this oop has an encoding as a constant. 93 // True if is_perm is true. 94 // Also true if ScavengeRootsInCode is non-zero. 95 // If it does not have an encoding, the compiler is responsible for 96 // making other arrangements for dealing with the oop. 97 // See ciEnv::make_array 98 bool can_be_constant(); 99 100 // Tells if this oop should be made a constant. 101 // True if is_perm is true or ScavengeRootsInCode > 1. 102 bool should_be_constant(); 103 104 // Might this object possibly move during a scavenge operation? 105 // If the answer is true and ScavengeRootsInCode==0, the oop cannot be embedded in code. 106 bool is_scavengable() { return (_ident & SCAVENGABLE_FLAG) != 0; } 107 108 // The address which the compiler should embed into the 109 // generated code to represent this oop. This address 110 // is not the true address of the oop -- it will get patched 111 // during nmethod creation. 112 // 113 // Usage note: no address arithmetic allowed. Oop must 114 // be registered with the oopRecorder. 115 jobject constant_encoding(); 116 117 virtual bool is_object() const { return true; } 118 119 // What kind of ciObject is this? 120 virtual bool is_null_object() const { return false; } 121 virtual bool is_call_site() const { return false; } 122 virtual bool is_cpcache() const { return false; } 123 virtual bool is_instance() { return false; } 124 virtual bool is_member_name() const { return false; } 125 virtual bool is_method_handle() const { return false; } 126 virtual bool is_method_type() const { return false; } 127 virtual bool is_array() { return false; } 128 virtual bool is_obj_array() { return false; } 129 virtual bool is_type_array() { return false; } 130 131 // Is this a type or value which has no associated class? 132 // It is true of primitive types and null objects. 133 virtual bool is_classless() const { return false; } 134 virtual void dump_replay_data(outputStream* st) { /* do nothing */ } 135 136 // Note: some ciObjects refer to oops which have yet to be created. 137 // We refer to these as "unloaded". Specifically, there are 138 // unloaded instances of java.lang.Class, 139 // java.lang.invoke.MethodHandle, and java.lang.invoke.MethodType. 140 // By convention the ciNullObject is considered loaded, and 141 // primitive types are considered loaded. 142 bool is_loaded() const { 143 return handle() != NULL || is_classless(); 144 } 145 146 // Subclass casting with assertions. 147 ciNullObject* as_null_object() { 148 assert(is_null_object(), "bad cast"); 149 return (ciNullObject*)this; 150 } 151 ciCallSite* as_call_site() { 152 assert(is_call_site(), "bad cast"); 153 return (ciCallSite*)this; 154 } 155 ciInstance* as_instance() { 156 assert(is_instance(), "bad cast"); 157 return (ciInstance*)this; 158 } 159 ciMemberName* as_member_name() { 160 assert(is_member_name(), "bad cast"); 161 return (ciMemberName*)this; 162 } 163 ciMethodHandle* as_method_handle() { 164 assert(is_method_handle(), "bad cast"); 165 return (ciMethodHandle*)this; 166 } 167 ciMethodType* as_method_type() { 168 assert(is_method_type(), "bad cast"); 169 return (ciMethodType*)this; 170 } 171 ciArray* as_array() { 172 assert(is_array(), "bad cast"); 173 return (ciArray*)this; 174 } 175 ciObjArray* as_obj_array() { 176 assert(is_obj_array(), "bad cast"); 177 return (ciObjArray*)this; 178 } 179 ciTypeArray* as_type_array() { 180 assert(is_type_array(), "bad cast"); 181 return (ciTypeArray*)this; 182 } 183 184 // Print debugging output about this ciObject. 185 void print(outputStream* st); 186 void print() { print(tty); } // GDB cannot handle default arguments 187 188 // Print debugging output about the oop this ciObject represents. 189 void print_oop(outputStream* st = tty); 190 }; 191 192 #endif // SHARE_VM_CI_CIOBJECT_HPP