Mercurial > hg > truffle
view src/share/vm/ci/ciInstanceKlass.hpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
author | Bernhard Urban <bernhard.urban@jku.at> |
---|---|
date | Mon, 15 Apr 2013 19:54:58 +0200 |
parents | 2cb439954abf |
children | 836a62f43af9 |
line wrap: on
line source
/* * 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 * 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_CIINSTANCEKLASS_HPP #define SHARE_VM_CI_CIINSTANCEKLASS_HPP #include "ci/ciConstantPoolCache.hpp" #include "ci/ciFlags.hpp" #include "ci/ciKlass.hpp" #include "ci/ciSymbol.hpp" // ciInstanceKlass // // This class represents a Klass* in the HotSpot virtual machine // whose Klass part is an InstanceKlass. It may or may not // be loaded. class ciInstanceKlass : public ciKlass { CI_PACKAGE_ACCESS friend class ciBytecodeStream; friend class ciEnv; friend class ciExceptionHandler; friend class ciMethod; friend class ciField; private: jobject _loader; jobject _protection_domain; InstanceKlass::ClassState _init_state; // state of class bool _is_shared; bool _has_finalizer; bool _has_subklass; bool _has_nonstatic_fields; ciFlags _flags; jint _nonstatic_field_size; jint _nonstatic_oop_map_size; // Lazy fields get filled in only upon request. ciInstanceKlass* _super; ciInstance* _java_mirror; ciConstantPoolCache* _field_cache; // cached map index->field GrowableArray<ciField*>* _nonstatic_fields; // The possible values of the _implementor fall into following three cases: // NULL: no implementor. // A ciInstanceKlass that's not itself: one implementor. // Itsef: more than one implementors. ciInstanceKlass* _implementor; GrowableArray<ciField*>* _non_static_fields; protected: ciInstanceKlass(KlassHandle h_k); ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain); InstanceKlass* get_instanceKlass() const { return (InstanceKlass*)get_Klass(); } oop loader(); jobject loader_handle(); oop protection_domain(); jobject protection_domain_handle(); const char* type_string() { return "ciInstanceKlass"; } bool is_in_package_impl(const char* packagename, int len); void print_impl(outputStream* st); ciConstantPoolCache* field_cache(); bool is_shared() { return _is_shared; } void compute_shared_init_state(); bool compute_shared_has_subklass(); int compute_nonstatic_fields(); GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields); // Update the init_state for shared klasses void update_if_shared(InstanceKlass::ClassState expected) { if (_is_shared && _init_state != expected) { if (is_loaded()) compute_shared_init_state(); } } public: // Has this klass been initialized? bool is_initialized() { update_if_shared(InstanceKlass::fully_initialized); return _init_state == InstanceKlass::fully_initialized; } // Is this klass being initialized? bool is_being_initialized() { update_if_shared(InstanceKlass::being_initialized); return _init_state == InstanceKlass::being_initialized; } // Has this klass been linked? bool is_linked() { update_if_shared(InstanceKlass::linked); return _init_state >= InstanceKlass::linked; } // General klass information. ciFlags flags() { assert(is_loaded(), "must be loaded"); return _flags; } bool has_finalizer() { assert(is_loaded(), "must be loaded"); return _has_finalizer; } bool has_subklass() { assert(is_loaded(), "must be loaded"); if (_is_shared && !_has_subklass) { if (flags().is_final()) { return false; } else { return compute_shared_has_subklass(); } } return _has_subklass; } jint size_helper() { return (Klass::layout_helper_size_in_bytes(layout_helper()) >> LogHeapWordSize); } jint nonstatic_field_size() { assert(is_loaded(), "must be loaded"); return _nonstatic_field_size; } jint has_nonstatic_fields() { assert(is_loaded(), "must be loaded"); return _has_nonstatic_fields; } jint nonstatic_oop_map_size() { assert(is_loaded(), "must be loaded"); return _nonstatic_oop_map_size; } ciInstanceKlass* super(); jint nof_implementors() { ciInstanceKlass* impl; assert(is_loaded(), "must be loaded"); impl = implementor(); if (impl == NULL) { return 0; } else if (impl != this) { return 1; } else { return 2; } } ciInstanceKlass* get_canonical_holder(int offset); ciField* get_field_by_offset(int field_offset, bool is_static); ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static); GrowableArray<ciField*>* non_static_fields(); // total number of nonstatic fields (including inherited): int nof_nonstatic_fields() { if (_nonstatic_fields == NULL) return compute_nonstatic_fields(); else return _nonstatic_fields->length(); } // nth nonstatic field (presented by ascending address) ciField* nonstatic_field_at(int i) { assert(_nonstatic_fields != NULL, ""); return _nonstatic_fields->at(i); } ciInstanceKlass* unique_concrete_subklass(); bool has_finalizable_subclass(); bool contains_field_offset(int offset) { return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size()); } // Get the instance of java.lang.Class corresponding to // this klass. This instance is used for locking of // synchronized static methods of this klass. ciInstance* java_mirror(); // Java access flags bool is_public () { return flags().is_public(); } bool is_final () { return flags().is_final(); } bool is_super () { return flags().is_super(); } bool is_interface () { return flags().is_interface(); } bool is_abstract () { return flags().is_abstract(); } ciMethod* find_method(ciSymbol* name, ciSymbol* signature); // Note: To find a method from name and type strings, use ciSymbol::make, // but consider adding to vmSymbols.hpp instead. bool is_leaf_type(); ciInstanceKlass* implementor(); // Is the defining class loader of this class the default loader? bool uses_default_loader(); bool is_java_lang_Object() const; // Is this klass in the given package? bool is_in_package(const char* packagename) { return is_in_package(packagename, (int) strlen(packagename)); } bool is_in_package(const char* packagename, int len); // What kind of ciObject is this? bool is_instance_klass() const { return true; } bool is_java_klass() const { return true; } // Dump the current state of this klass for compilation replay. virtual void dump_replay_data(outputStream* out); }; #endif // SHARE_VM_CI_CIINSTANCEKLASS_HPP