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

comparison src/share/vm/graal/graalEnv.cpp @ 6948:e522a00b91aa

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 12 Nov 2012 23:14:12 +0100
parents	957c266d8bc5
children	2afd99933ae6

comparison

equal deleted inserted replaced

-:ae13cc658b80
+:e522a00b91aa
 #include "compiler/compilerOracle.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/universe.inline.hpp"
-#include "oops/methodDataOop.hpp"
+#include "oops/methodData.hpp"
 #include "oops/objArrayKlass.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "runtime/init.hpp"
 #include "runtime/reflection.hpp"
 #include "runtime/sharedRuntime.hpp"
 //
 // 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();
+accessing_klass = ObjArrayKlass::cast(accessing_klass())->bottom_klass();
 }
 if (!accessing_klass->oop_is_instance()) {
 return true;
 }
 if (resolved_klass->oop_is_objArray()) {
 // Find the element klass, if this is an array.
-resolved_klass = objArrayKlass::cast(resolved_klass())->bottom_klass();
+resolved_klass = ObjArrayKlass::cast(resolved_klass())->bottom_klass();
 }
 if (resolved_klass->oop_is_instance()) {
 return Reflection::verify_class_access(accessing_klass(), resolved_klass(), true);
 }
 return true;
 KlassHandle found_klass;
 {
 ttyUnlocker ttyul;  // release tty lock to avoid ordering problems
 MutexLocker ml(Compile_lock);
-klassOop kls;
+Klass*  kls;
 if (!require_local) {
 kls = SystemDictionary::find_constrained_instance_or_array_klass(sym, loader, CHECK_(KlassHandle()));
 } else {
 kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain, CHECK_(KlassHandle()));
 }
 if (found_klass.is_null() && !cpool.is_null() && cpool->has_preresolution()) {
 // Look inside the constant pool for pre-resolved class entries.
 for (int i = cpool->length() - 1; i >= 1; i--) {
 if (cpool->tag_at(i).is_klass()) {
-klassOop kls = cpool->resolved_klass_at(i);
+Klass*  kls = cpool->resolved_klass_at(i);
 if (Klass::cast(kls)->name() == sym) {
 return kls;
 }
 }
 }
 KlassHandle GraalEnv::get_klass_by_index_impl(constantPoolHandle& cpool,
 int index,
 bool& is_accessible,
 KlassHandle& accessor) {
 EXCEPTION_CONTEXT;
-KlassHandle klass (THREAD, constantPoolOopDesc::klass_at_if_loaded(cpool, index));
+KlassHandle klass (THREAD, ConstantPool::klass_at_if_loaded(cpool, index));
 Symbol* klass_name = NULL;
 if (klass.is_null()) {
 // The klass has not been inserted into the constant pool.
 // Try to look it up by name.
 {
 // We have to lock the cpool to keep the oop from being resolved
 // while we are accessing it.
-ObjectLocker ol(cpool, THREAD);
+MutexLockerEx ml(cpool->lock(), THREAD);
 constantTag tag = cpool->tag_at(index);
 if (tag.is_klass()) {
 // The klass has been inserted into the constant pool
 // very recently.
 return;
 }
 // Perform the field lookup.
-klassOop canonical_holder =
+Klass*  canonical_holder =
-instanceKlass::cast(declared_holder())->find_field(name, signature, &field_desc);
+InstanceKlass::cast(declared_holder())->find_field(name, signature, &field_desc);
 if (canonical_holder == NULL) {
 return;
 }
 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,
+void GraalEnv::get_field_by_index(instanceKlassHandle& accessor, fieldDescriptor& fd, int index) {
-int index) {
 ResourceMark rm;
 return get_field_by_index_impl(accessor, fd, index);
 }
 // ------------------------------------------------------------------
 if (holder_is_accessible) { // Our declared holder is loaded.
 instanceKlassHandle lookup = get_instance_klass_for_declared_method_holder(holder);
 methodHandle m = lookup_method(accessor, lookup, name_sym, sig_sym, bc);
 if (!m.is_null() &&
 (bc == Bytecodes::_invokestatic
-?  instanceKlass::cast(m->method_holder())->is_not_initialized()
+?  InstanceKlass::cast(m->method_holder())->is_not_initialized()
-: !instanceKlass::cast(m->method_holder())->is_loaded())) {
+: !InstanceKlass::cast(m->method_holder())->is_loaded())) {
 m = NULL;
 }
 if (!m.is_null()) {
 // We found the method.
 return m;
 //bool test_deps = counter_changed;
 //DEBUG_ONLY(test_deps = true);
 //if (!test_deps)  return;
 for (Dependencies::DepStream deps(dependencies); deps.next(); ) {
-klassOop witness = deps.check_dependency();
+Klass*  witness = deps.check_dependency();
 if (witness != NULL) {
 return false;
 }
 }
 Dependencies* dependencies,
 CompileTask* task,
 int compile_id,
 bool has_debug_info,
 bool has_unsafe_access,
-bool install_code) {
+bool bind_to_method) {
 EXCEPTION_CONTEXT;
 NMethodSweeper::possibly_sweep();
 nmethod* nm = NULL;
 int comp_level = CompLevel_simple;
 {
 dependencies->encode_content_bytes();
 // Check for {class loads, evolution, breakpoints} during compilation
 if (!check_for_system_dictionary_modification(dependencies)) {
 // While not a true deoptimization, it is a preemptive decompile.
-methodDataOop mdo = method()->method_data();
+MethodData* mdp = method()->method_data();
-if (mdo != NULL) {
+if (mdp != NULL) {
-mdo->inc_decompile_count();
+mdp->inc_decompile_count();
 }
 // All buffers in the CodeBuffer are allocated in the CodeCache.
 // If the code buffer is created on each compile attempt
 // as in C2, then it must be freed.
 // Record successful registration.
 // (Put nm into the task handle *before* publishing to the Java heap.)
 if (task != NULL)  task->set_code(nm);
-if (install_code) {
+if (bind_to_method) {
 if (entry_bci == InvocationEntryBci) {
 if (TieredCompilation) {
 // If there is an old version we're done with it
 nmethod* old = method->code();
 if (TraceMethodReplacement && old != NULL) {
 tty->print_cr("Installing osr method (%d) %s @ %d",
 comp_level,
 method_name,
 entry_bci);
 }
-instanceKlass::cast(method->method_holder())->add_osr_nmethod(nm);
+InstanceKlass::cast(method->method_holder())->add_osr_nmethod(nm);
 }
 }
 }
 }

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/graal/graalEnv.cpp @ 6948:e522a00b91aa