graal-jvmci-8: src/share/vm/graal/graalEnv.cpp comparison

comparison src/share/vm/graal/graalEnv.cpp @ 7094:eec7173947a1

removed remaining use of the C++ "compiler interface" (i.e. ci) by Graal for installing dependencies

author	Doug Simon <doug.simon@oracle.com>
date	Thu, 29 Nov 2012 17:13:13 +0100
parents	af30115c9d0e
children	38076efb9062

comparison

equal deleted inserted replaced

-:dff79b1f82f1
+:eec7173947a1
 #include "runtime/sharedRuntime.hpp"
 #include "utilities/dtrace.hpp"
 #include "c1/c1_Runtime1.hpp"
 // ------------------------------------------------------------------
-// ciEnv::check_klass_accessiblity
-//
 // Note: the logic of this method should mirror the logic of
 // constantPoolOopDesc::verify_constant_pool_resolve.
 bool GraalEnv::check_klass_accessibility(KlassHandle accessing_klass, KlassHandle resolved_klass) {
 if (accessing_klass->oop_is_objArray()) {
 accessing_klass = ObjArrayKlass::cast(accessing_klass())->bottom_klass();
 }
 return true;
 }
 // ------------------------------------------------------------------
-// ciEnv::get_klass_by_name_impl
 KlassHandle GraalEnv::get_klass_by_name_impl(KlassHandle& accessing_klass,
 constantPoolHandle& cpool,
 Symbol* sym,
 bool require_local) {
 EXCEPTION_CONTEXT;
 // Build it on the fly if the element class exists.
 TempNewSymbol elem_sym = SymbolTable::new_symbol(sym->as_utf8()+1,
 sym->utf8_length()-1,
 CHECK_(KlassHandle()));
-// Get element ciKlass recursively.
+// Get element Klass recursively.
 KlassHandle elem_klass =
 get_klass_by_name_impl(accessing_klass,
 cpool,
 elem_sym,
 require_local);
 return found_klass();
 }
 // ------------------------------------------------------------------
-// ciEnv::get_klass_by_name
 KlassHandle GraalEnv::get_klass_by_name(KlassHandle& accessing_klass,
 Symbol* klass_name,
 bool require_local) {
 ResourceMark rm;
 constantPoolHandle cpool;
 klass_name,
 require_local);
 }
 // ------------------------------------------------------------------
-// ciEnv::get_klass_by_index_impl
-//
 // Implementation of get_klass_by_index.
 KlassHandle GraalEnv::get_klass_by_index_impl(constantPoolHandle& cpool,
 int index,
 bool& is_accessible,
 KlassHandle& accessor) {
 is_accessible = true;
 return klass;
 }
 // ------------------------------------------------------------------
-// ciEnv::get_klass_by_index
-//
 // Get a klass from the constant pool.
 KlassHandle GraalEnv::get_klass_by_index(constantPoolHandle& cpool,
 int index,
 bool& is_accessible,
 KlassHandle& accessor) {
 KlassHandle result = get_klass_by_index_impl(cpool, index, is_accessible, accessor);
 return result;
 }
 // ------------------------------------------------------------------
-// ciEnv::get_field_by_index_impl
-//
 // Implementation of get_field_by_index.
 //
 // Implementation note: the results of field lookups are cached
 // in the accessor klass.
 void GraalEnv::get_field_by_index_impl(instanceKlassHandle& klass, fieldDescriptor& field_desc,
 int nt_index = cpool->name_and_type_ref_index_at(index);
 int sig_index = cpool->signature_ref_index_at(nt_index);
 Symbol* signature = cpool->symbol_at(sig_index);
 // Get the field's declared holder.
-//
-// Note: we actually create a ciInstanceKlass for this klass,
-// even though we may not need to.
 int holder_index = cpool->klass_ref_index_at(index);
 bool holder_is_accessible;
 KlassHandle declared_holder = get_klass_by_index(cpool, holder_index,
 holder_is_accessible,
 klass);
 assert(canonical_holder == field_desc.field_holder(), "just checking");
 }
 // ------------------------------------------------------------------
-// ciEnv::get_field_by_index
-//
 // Get a field by index from a klass's constant pool.
 void GraalEnv::get_field_by_index(instanceKlassHandle& accessor, fieldDescriptor& fd, int index) {
 ResourceMark rm;
 return get_field_by_index_impl(accessor, fd, index);
 }
 // ------------------------------------------------------------------
-// ciEnv::lookup_method
-//
 // Perform an appropriate method lookup based on accessor, holder,
 // name, signature, and bytecode.
 methodHandle GraalEnv::lookup_method(instanceKlassHandle& h_accessor,
 instanceKlassHandle& h_holder,
 Symbol*       name,
 return dest_method;
 }
 // ------------------------------------------------------------------
-// ciEnv::get_method_by_index_impl
 methodHandle GraalEnv::get_method_by_index_impl(constantPoolHandle& cpool,
 int index, Bytecodes::Code bc,
 instanceKlassHandle& accessor) {
 int holder_index = cpool->klass_ref_index_at(index);
 bool holder_is_accessible;
 return m;
 }
 }
 // Either the declared holder was not loaded, or the method could
-// not be found.  Create a dummy ciMethod to represent the failed
+// not be found.
-// lookup.
 return NULL;
 }
 // ------------------------------------------------------------------
-// ciEnv::get_instance_klass_for_declared_method_holder
 instanceKlassHandle GraalEnv::get_instance_klass_for_declared_method_holder(KlassHandle& method_holder) {
-// For the case of <array>.clone(), the method holder can be a ciArrayKlass
+// For the case of <array>.clone(), the method holder can be an ArrayKlass*
-// instead of a ciInstanceKlass.  For that case simply pretend that the
+// instead of an InstanceKlass*.  For that case simply pretend that the
 // declared holder is Object.clone since that's where the call will bottom out.
-// A more correct fix would trickle out through many interfaces in CI,
-// requiring ciInstanceKlass* to become ciKlass* and many more places would
-// require checks to make sure the expected type was found.  Given that this
-// only occurs for clone() the more extensive fix seems like overkill so
-// instead we simply smear the array type into Object.
 if (method_holder->oop_is_instance()) {
 return instanceKlassHandle(method_holder());
 } else if (method_holder->oop_is_array()) {
 return instanceKlassHandle(SystemDictionary::Object_klass());
 } else {
 return NULL;
 }
 // ------------------------------------------------------------------
-// ciEnv::get_method_by_index
 methodHandle GraalEnv::get_method_by_index(constantPoolHandle& cpool,
 int index, Bytecodes::Code bc,
 instanceKlassHandle& accessor) {
 ResourceMark rm;
 assert(bc != Bytecodes::_invokedynamic, "invokedynamic not yet supported");
 return get_method_by_index_impl(cpool, index, bc, accessor);
 }
 // ------------------------------------------------------------------
-// ciEnv::check_for_system_dictionary_modification
 // Check for changes to the system dictionary during compilation
 // class loads, evolution, breakpoints
 bool GraalEnv::check_for_system_dictionary_modification(Dependencies* dependencies) {
 // Dependencies must be checked when the system dictionary changes.
 // If logging is enabled all violated dependences will be recorded in
 return true;
 }
 // ------------------------------------------------------------------
-// ciEnv::register_method
 GraalEnv::CodeInstallResult GraalEnv::register_method(
 methodHandle& method,
 nmethod*& nm,
 int entry_bci,
 CodeOffsets* offsets,

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/graal/graalEnv.cpp @ 7094:eec7173947a1