truffle: src/share/vm/ci/ciEnv.cpp annotate

annotate src/share/vm/ci/ciEnv.cpp @ 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	b9a918201d47
children	836a62f43af9

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8104 f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 8004 diff changeset	2 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	26 #include "ci/ciConstant.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	27 #include "ci/ciEnv.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	28 #include "ci/ciField.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	29 #include "ci/ciInstance.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	30 #include "ci/ciInstanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	31 #include "ci/ciMethod.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	32 #include "ci/ciNullObject.hpp"
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	33 #include "ci/ciReplay.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	34 #include "ci/ciUtilities.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	35 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	36 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	37 #include "code/scopeDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	38 #include "compiler/compileBroker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	39 #include "compiler/compileLog.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	40 #include "compiler/compilerOracle.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	41 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	42 #include "interpreter/linkResolver.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	43 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	44 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	45 #include "memory/universe.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	46 #include "oops/methodData.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	47 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	48 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	49 #include "oops/oop.inline2.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	50 #include "prims/jvmtiExport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	51 #include "runtime/init.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	52 #include "runtime/reflection.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	53 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	54 #include "utilities/dtrace.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6985 diff changeset	55 #include "utilities/macros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	56 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	57 #include "c1/c1_Runtime1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	58 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	59 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	60 #include "opto/runtime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	61 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	62
a61af66fc99e Initial load duke parents: diff changeset	63 // ciEnv
a61af66fc99e Initial load duke parents: diff changeset	64 //
a61af66fc99e Initial load duke parents: diff changeset	65 // This class is the top level broker for requests from the compiler
a61af66fc99e Initial load duke parents: diff changeset	66 // to the VM.
a61af66fc99e Initial load duke parents: diff changeset	67
a61af66fc99e Initial load duke parents: diff changeset	68 ciObject* ciEnv::_null_object_instance;
a61af66fc99e Initial load duke parents: diff changeset	69
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	70 #define WK_KLASS_DEFN(name, ignore_s, ignore_o) ciInstanceKlass* ciEnv::_##name = NULL;
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	71 WK_KLASSES_DO(WK_KLASS_DEFN)
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	72 #undef WK_KLASS_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	73
a61af66fc99e Initial load duke parents: diff changeset	74 ciSymbol* ciEnv::_unloaded_cisymbol = NULL;
a61af66fc99e Initial load duke parents: diff changeset	75 ciInstanceKlass* ciEnv::_unloaded_ciinstance_klass = NULL;
a61af66fc99e Initial load duke parents: diff changeset	76 ciObjArrayKlass* ciEnv::_unloaded_ciobjarrayklass = NULL;
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78 jobject ciEnv::_ArrayIndexOutOfBoundsException_handle = NULL;
a61af66fc99e Initial load duke parents: diff changeset	79 jobject ciEnv::_ArrayStoreException_handle = NULL;
a61af66fc99e Initial load duke parents: diff changeset	80 jobject ciEnv::_ClassCastException_handle = NULL;
a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	82 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	83 static bool firstEnv = true;
a61af66fc99e Initial load duke parents: diff changeset	84 #endif /* PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	85
a61af66fc99e Initial load duke parents: diff changeset	86 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	87 // ciEnv::ciEnv
a61af66fc99e Initial load duke parents: diff changeset	88 ciEnv::ciEnv(CompileTask* task, int system_dictionary_modification_counter) {
a61af66fc99e Initial load duke parents: diff changeset	89 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	90
a61af66fc99e Initial load duke parents: diff changeset	91 // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
a61af66fc99e Initial load duke parents: diff changeset	92 thread->set_env(this);
a61af66fc99e Initial load duke parents: diff changeset	93 assert(ciEnv::current() == this, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	94
a61af66fc99e Initial load duke parents: diff changeset	95 _oop_recorder = NULL;
a61af66fc99e Initial load duke parents: diff changeset	96 _debug_info = NULL;
a61af66fc99e Initial load duke parents: diff changeset	97 _dependencies = NULL;
a61af66fc99e Initial load duke parents: diff changeset	98 _failure_reason = NULL;
a61af66fc99e Initial load duke parents: diff changeset	99 _compilable = MethodCompilable;
a61af66fc99e Initial load duke parents: diff changeset	100 _break_at_compile = false;
a61af66fc99e Initial load duke parents: diff changeset	101 _compiler_data = NULL;
a61af66fc99e Initial load duke parents: diff changeset	102 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	103 assert(!firstEnv, "not initialized properly");
a61af66fc99e Initial load duke parents: diff changeset	104 #endif /* !PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	105
a61af66fc99e Initial load duke parents: diff changeset	106 _system_dictionary_modification_counter = system_dictionary_modification_counter;
a61af66fc99e Initial load duke parents: diff changeset	107 _num_inlined_bytecodes = 0;
a61af66fc99e Initial load duke parents: diff changeset	108 assert(task == NULL \|\| thread->task() == task, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	109 _task = task;
a61af66fc99e Initial load duke parents: diff changeset	110 _log = NULL;
a61af66fc99e Initial load duke parents: diff changeset	111
a61af66fc99e Initial load duke parents: diff changeset	112 // Temporary buffer for creating symbols and such.
a61af66fc99e Initial load duke parents: diff changeset	113 _name_buffer = NULL;
a61af66fc99e Initial load duke parents: diff changeset	114 _name_buffer_len = 0;
a61af66fc99e Initial load duke parents: diff changeset	115
a61af66fc99e Initial load duke parents: diff changeset	116 _arena = &_ciEnv_arena;
a61af66fc99e Initial load duke parents: diff changeset	117 _factory = new (_arena) ciObjectFactory(_arena, 128);
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119 // Preload commonly referenced system ciObjects.
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 // During VM initialization, these instances have not yet been created.
a61af66fc99e Initial load duke parents: diff changeset	122 // Assertions ensure that these instances are not accessed before
a61af66fc99e Initial load duke parents: diff changeset	123 // their initialization.
a61af66fc99e Initial load duke parents: diff changeset	124
a61af66fc99e Initial load duke parents: diff changeset	125 assert(Universe::is_fully_initialized(), "should be complete");
a61af66fc99e Initial load duke parents: diff changeset	126
a61af66fc99e Initial load duke parents: diff changeset	127 oop o = Universe::null_ptr_exception_instance();
a61af66fc99e Initial load duke parents: diff changeset	128 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load duke parents: diff changeset	129 _NullPointerException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load duke parents: diff changeset	130 o = Universe::arithmetic_exception_instance();
a61af66fc99e Initial load duke parents: diff changeset	131 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load duke parents: diff changeset	132 _ArithmeticException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134 _ArrayIndexOutOfBoundsException_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	135 _ArrayStoreException_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	136 _ClassCastException_instance = NULL;
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	137 _the_null_string = NULL;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	138 _the_min_jint_string = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	139 }
a61af66fc99e Initial load duke parents: diff changeset	140
a61af66fc99e Initial load duke parents: diff changeset	141 ciEnv::ciEnv(Arena* arena) {
a61af66fc99e Initial load duke parents: diff changeset	142 ASSERT_IN_VM;
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
a61af66fc99e Initial load duke parents: diff changeset	145 CompilerThread* current_thread = CompilerThread::current();
a61af66fc99e Initial load duke parents: diff changeset	146 assert(current_thread->env() == NULL, "must be");
a61af66fc99e Initial load duke parents: diff changeset	147 current_thread->set_env(this);
a61af66fc99e Initial load duke parents: diff changeset	148 assert(ciEnv::current() == this, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	149
a61af66fc99e Initial load duke parents: diff changeset	150 _oop_recorder = NULL;
a61af66fc99e Initial load duke parents: diff changeset	151 _debug_info = NULL;
a61af66fc99e Initial load duke parents: diff changeset	152 _dependencies = NULL;
a61af66fc99e Initial load duke parents: diff changeset	153 _failure_reason = NULL;
a61af66fc99e Initial load duke parents: diff changeset	154 _compilable = MethodCompilable_never;
a61af66fc99e Initial load duke parents: diff changeset	155 _break_at_compile = false;
a61af66fc99e Initial load duke parents: diff changeset	156 _compiler_data = NULL;
a61af66fc99e Initial load duke parents: diff changeset	157 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	158 assert(firstEnv, "must be first");
a61af66fc99e Initial load duke parents: diff changeset	159 firstEnv = false;
a61af66fc99e Initial load duke parents: diff changeset	160 #endif /* !PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 _system_dictionary_modification_counter = 0;
a61af66fc99e Initial load duke parents: diff changeset	163 _num_inlined_bytecodes = 0;
a61af66fc99e Initial load duke parents: diff changeset	164 _task = NULL;
a61af66fc99e Initial load duke parents: diff changeset	165 _log = NULL;
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 // Temporary buffer for creating symbols and such.
a61af66fc99e Initial load duke parents: diff changeset	168 _name_buffer = NULL;
a61af66fc99e Initial load duke parents: diff changeset	169 _name_buffer_len = 0;
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 _arena = arena;
a61af66fc99e Initial load duke parents: diff changeset	172 _factory = new (_arena) ciObjectFactory(_arena, 128);
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174 // Preload commonly referenced system ciObjects.
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // During VM initialization, these instances have not yet been created.
a61af66fc99e Initial load duke parents: diff changeset	177 // Assertions ensure that these instances are not accessed before
a61af66fc99e Initial load duke parents: diff changeset	178 // their initialization.
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 assert(Universe::is_fully_initialized(), "must be");
a61af66fc99e Initial load duke parents: diff changeset	181
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	182 _NullPointerException_instance = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	183 _ArithmeticException_instance = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	184 _ArrayIndexOutOfBoundsException_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	185 _ArrayStoreException_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	186 _ClassCastException_instance = NULL;
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	187 _the_null_string = NULL;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	188 _the_min_jint_string = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	189 }
a61af66fc99e Initial load duke parents: diff changeset	190
a61af66fc99e Initial load duke parents: diff changeset	191 ciEnv::~ciEnv() {
a61af66fc99e Initial load duke parents: diff changeset	192 CompilerThread* current_thread = CompilerThread::current();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	193 _factory->remove_symbols();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	194 // Need safepoint to clear the env on the thread. RedefineClasses might
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	195 // be reading it.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	196 GUARDED_VM_ENTRY(current_thread->set_env(NULL);)
0 a61af66fc99e Initial load duke parents: diff changeset	197 }
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 // ------------------------------------------------------------------
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	200 // Cache Jvmti state
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	201 void ciEnv::cache_jvmti_state() {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	202 VM_ENTRY_MARK;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	203 // Get Jvmti capabilities under lock to get consistant values.
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	204 MutexLocker mu(JvmtiThreadState_lock);
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	205 _jvmti_can_hotswap_or_post_breakpoint = JvmtiExport::can_hotswap_or_post_breakpoint();
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	206 _jvmti_can_access_local_variables = JvmtiExport::can_access_local_variables();
1213 6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty dcubed parents: 1142 diff changeset	207 _jvmti_can_post_on_exceptions = JvmtiExport::can_post_on_exceptions();
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	208 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	209
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	210 // ------------------------------------------------------------------
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	211 // Cache DTrace flags
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	212 void ciEnv::cache_dtrace_flags() {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	213 // Need lock?
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	214 _dtrace_extended_probes = ExtendedDTraceProbes;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	215 if (_dtrace_extended_probes) {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	216 _dtrace_monitor_probes = true;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	217 _dtrace_method_probes = true;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	218 _dtrace_alloc_probes = true;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	219 } else {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	220 _dtrace_monitor_probes = DTraceMonitorProbes;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	221 _dtrace_method_probes = DTraceMethodProbes;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	222 _dtrace_alloc_probes = DTraceAllocProbes;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	223 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	224 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	225
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	226 // ------------------------------------------------------------------
0 a61af66fc99e Initial load duke parents: diff changeset	227 // helper for lazy exception creation
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	228 ciInstance* ciEnv::get_or_create_exception(jobject& handle, Symbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	229 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	230 if (handle == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	231 // Cf. universe.cpp, creation of Universe::_null_ptr_exception_instance.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	232 Klass* k = SystemDictionary::find(name, Handle(), Handle(), THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	233 jobject objh = NULL;
a61af66fc99e Initial load duke parents: diff changeset	234 if (!HAS_PENDING_EXCEPTION && k != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	235 oop obj = InstanceKlass::cast(k)->allocate_instance(THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	236 if (!HAS_PENDING_EXCEPTION)
a61af66fc99e Initial load duke parents: diff changeset	237 objh = JNIHandles::make_global(obj);
a61af66fc99e Initial load duke parents: diff changeset	238 }
a61af66fc99e Initial load duke parents: diff changeset	239 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	240 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	241 } else {
a61af66fc99e Initial load duke parents: diff changeset	242 handle = objh;
a61af66fc99e Initial load duke parents: diff changeset	243 }
a61af66fc99e Initial load duke parents: diff changeset	244 }
a61af66fc99e Initial load duke parents: diff changeset	245 oop obj = JNIHandles::resolve(handle);
a61af66fc99e Initial load duke parents: diff changeset	246 return obj == NULL? NULL: get_object(obj)->as_instance();
a61af66fc99e Initial load duke parents: diff changeset	247 }
a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 ciInstance* ciEnv::ArrayIndexOutOfBoundsException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	250 if (_ArrayIndexOutOfBoundsException_instance == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	251 _ArrayIndexOutOfBoundsException_instance
a61af66fc99e Initial load duke parents: diff changeset	252 = get_or_create_exception(_ArrayIndexOutOfBoundsException_handle,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	253 vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
0 a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255 return _ArrayIndexOutOfBoundsException_instance;
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257 ciInstance* ciEnv::ArrayStoreException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	258 if (_ArrayStoreException_instance == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	259 _ArrayStoreException_instance
a61af66fc99e Initial load duke parents: diff changeset	260 = get_or_create_exception(_ArrayStoreException_handle,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	261 vmSymbols::java_lang_ArrayStoreException());
0 a61af66fc99e Initial load duke parents: diff changeset	262 }
a61af66fc99e Initial load duke parents: diff changeset	263 return _ArrayStoreException_instance;
a61af66fc99e Initial load duke parents: diff changeset	264 }
a61af66fc99e Initial load duke parents: diff changeset	265 ciInstance* ciEnv::ClassCastException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	266 if (_ClassCastException_instance == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	267 _ClassCastException_instance
a61af66fc99e Initial load duke parents: diff changeset	268 = get_or_create_exception(_ClassCastException_handle,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	269 vmSymbols::java_lang_ClassCastException());
0 a61af66fc99e Initial load duke parents: diff changeset	270 }
a61af66fc99e Initial load duke parents: diff changeset	271 return _ClassCastException_instance;
a61af66fc99e Initial load duke parents: diff changeset	272 }
a61af66fc99e Initial load duke parents: diff changeset	273
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	274 ciInstance* ciEnv::the_null_string() {
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	275 if (_the_null_string == NULL) {
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	276 VM_ENTRY_MARK;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	277 _the_null_string = get_object(Universe::the_null_string())->as_instance();
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	278 }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	279 return _the_null_string;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	280 }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	281
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	282 ciInstance* ciEnv::the_min_jint_string() {
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	283 if (_the_min_jint_string == NULL) {
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	284 VM_ENTRY_MARK;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	285 _the_min_jint_string = get_object(Universe::the_min_jint_string())->as_instance();
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	286 }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	287 return _the_min_jint_string;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	288 }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	289
0 a61af66fc99e Initial load duke parents: diff changeset	290 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	291 // ciEnv::get_method_from_handle
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	292 ciMethod* ciEnv::get_method_from_handle(Method* method) {
0 a61af66fc99e Initial load duke parents: diff changeset	293 VM_ENTRY_MARK;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	294 return get_metadata(method)->as_method();
0 a61af66fc99e Initial load duke parents: diff changeset	295 }
a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	298 // ciEnv::array_element_offset_in_bytes
a61af66fc99e Initial load duke parents: diff changeset	299 int ciEnv::array_element_offset_in_bytes(ciArray* a_h, ciObject* o_h) {
a61af66fc99e Initial load duke parents: diff changeset	300 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	301 objArrayOop a = (objArrayOop)a_h->get_oop();
a61af66fc99e Initial load duke parents: diff changeset	302 assert(a->is_objArray(), "");
a61af66fc99e Initial load duke parents: diff changeset	303 int length = a->length();
a61af66fc99e Initial load duke parents: diff changeset	304 oop o = o_h->get_oop();
a61af66fc99e Initial load duke parents: diff changeset	305 for (int i = 0; i < length; i++) {
a61af66fc99e Initial load duke parents: diff changeset	306 if (a->obj_at(i) == o) return i;
a61af66fc99e Initial load duke parents: diff changeset	307 }
a61af66fc99e Initial load duke parents: diff changeset	308 return -1;
a61af66fc99e Initial load duke parents: diff changeset	309 }
a61af66fc99e Initial load duke parents: diff changeset	310
a61af66fc99e Initial load duke parents: diff changeset	311
a61af66fc99e Initial load duke parents: diff changeset	312 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	313 // ciEnv::check_klass_accessiblity
a61af66fc99e Initial load duke parents: diff changeset	314 //
a61af66fc99e Initial load duke parents: diff changeset	315 // Note: the logic of this method should mirror the logic of
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	316 // ConstantPool::verify_constant_pool_resolve.
0 a61af66fc99e Initial load duke parents: diff changeset	317 bool ciEnv::check_klass_accessibility(ciKlass* accessing_klass,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	318 Klass* resolved_klass) {
0 a61af66fc99e Initial load duke parents: diff changeset	319 if (accessing_klass == NULL \|\| !accessing_klass->is_loaded()) {
a61af66fc99e Initial load duke parents: diff changeset	320 return true;
a61af66fc99e Initial load duke parents: diff changeset	321 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	322 if (accessing_klass->is_obj_array_klass()) {
0 a61af66fc99e Initial load duke parents: diff changeset	323 accessing_klass = accessing_klass->as_obj_array_klass()->base_element_klass();
a61af66fc99e Initial load duke parents: diff changeset	324 }
a61af66fc99e Initial load duke parents: diff changeset	325 if (!accessing_klass->is_instance_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	326 return true;
a61af66fc99e Initial load duke parents: diff changeset	327 }
a61af66fc99e Initial load duke parents: diff changeset	328
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	329 if (resolved_klass->oop_is_objArray()) {
0 a61af66fc99e Initial load duke parents: diff changeset	330 // Find the element klass, if this is an array.
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6792 diff changeset	331 resolved_klass = ObjArrayKlass::cast(resolved_klass)->bottom_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	332 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	333 if (resolved_klass->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	334 return Reflection::verify_class_access(accessing_klass->get_Klass(),
0 a61af66fc99e Initial load duke parents: diff changeset	335 resolved_klass,
a61af66fc99e Initial load duke parents: diff changeset	336 true);
a61af66fc99e Initial load duke parents: diff changeset	337 }
a61af66fc99e Initial load duke parents: diff changeset	338 return true;
a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340
a61af66fc99e Initial load duke parents: diff changeset	341 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	342 // ciEnv::get_klass_by_name_impl
a61af66fc99e Initial load duke parents: diff changeset	343 ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	344 constantPoolHandle cpool,
0 a61af66fc99e Initial load duke parents: diff changeset	345 ciSymbol* name,
a61af66fc99e Initial load duke parents: diff changeset	346 bool require_local) {
a61af66fc99e Initial load duke parents: diff changeset	347 ASSERT_IN_VM;
a61af66fc99e Initial load duke parents: diff changeset	348 EXCEPTION_CONTEXT;
a61af66fc99e Initial load duke parents: diff changeset	349
a61af66fc99e Initial load duke parents: diff changeset	350 // Now we need to check the SystemDictionary
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	351 Symbol* sym = name->get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	352 if (sym->byte_at(0) == 'L' &&
a61af66fc99e Initial load duke parents: diff changeset	353 sym->byte_at(sym->utf8_length()-1) == ';') {
a61af66fc99e Initial load duke parents: diff changeset	354 // This is a name from a signature. Strip off the trimmings.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	355 // Call recursive to keep scope of strippedsym.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	356 TempNewSymbol strippedsym = SymbolTable::new_symbol(sym->as_utf8()+1,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	357 sym->utf8_length()-2,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	358 KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	359 ciSymbol* strippedname = get_symbol(strippedsym);
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	360 return get_klass_by_name_impl(accessing_klass, cpool, strippedname, require_local);
0 a61af66fc99e Initial load duke parents: diff changeset	361 }
a61af66fc99e Initial load duke parents: diff changeset	362
a61af66fc99e Initial load duke parents: diff changeset	363 // Check for prior unloaded klass. The SystemDictionary's answers
a61af66fc99e Initial load duke parents: diff changeset	364 // can vary over time but the compiler needs consistency.
a61af66fc99e Initial load duke parents: diff changeset	365 ciKlass* unloaded_klass = check_get_unloaded_klass(accessing_klass, name);
a61af66fc99e Initial load duke parents: diff changeset	366 if (unloaded_klass != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	367 if (require_local) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	368 return unloaded_klass;
a61af66fc99e Initial load duke parents: diff changeset	369 }
a61af66fc99e Initial load duke parents: diff changeset	370
a61af66fc99e Initial load duke parents: diff changeset	371 Handle loader(THREAD, (oop)NULL);
a61af66fc99e Initial load duke parents: diff changeset	372 Handle domain(THREAD, (oop)NULL);
a61af66fc99e Initial load duke parents: diff changeset	373 if (accessing_klass != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	374 loader = Handle(THREAD, accessing_klass->loader());
a61af66fc99e Initial load duke parents: diff changeset	375 domain = Handle(THREAD, accessing_klass->protection_domain());
a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377
a61af66fc99e Initial load duke parents: diff changeset	378 // setup up the proper type to return on OOM
a61af66fc99e Initial load duke parents: diff changeset	379 ciKlass* fail_type;
a61af66fc99e Initial load duke parents: diff changeset	380 if (sym->byte_at(0) == '[') {
a61af66fc99e Initial load duke parents: diff changeset	381 fail_type = _unloaded_ciobjarrayklass;
a61af66fc99e Initial load duke parents: diff changeset	382 } else {
a61af66fc99e Initial load duke parents: diff changeset	383 fail_type = _unloaded_ciinstance_klass;
a61af66fc99e Initial load duke parents: diff changeset	384 }
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 1972 diff changeset	385 KlassHandle found_klass;
2244 4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	386 {
2263 5841dc1964f0 7021531: lock ordering problems after fix for 6354181 never parents: 2244 diff changeset	387 ttyUnlocker ttyul; // release tty lock to avoid ordering problems
2244 4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	388 MutexLocker ml(Compile_lock);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	389 Klass* kls;
2244 4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	390 if (!require_local) {
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	391 kls = SystemDictionary::find_constrained_instance_or_array_klass(sym, loader,
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	392 KILL_COMPILE_ON_FATAL_(fail_type));
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	393 } else {
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	394 kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain,
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	395 KILL_COMPILE_ON_FATAL_(fail_type));
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	396 }
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 1972 diff changeset	397 found_klass = KlassHandle(THREAD, kls);
0 a61af66fc99e Initial load duke parents: diff changeset	398 }
a61af66fc99e Initial load duke parents: diff changeset	399
a61af66fc99e Initial load duke parents: diff changeset	400 // If we fail to find an array klass, look again for its element type.
a61af66fc99e Initial load duke parents: diff changeset	401 // The element type may be available either locally or via constraints.
a61af66fc99e Initial load duke parents: diff changeset	402 // In either case, if we can find the element type in the system dictionary,
a61af66fc99e Initial load duke parents: diff changeset	403 // we must build an array type around it. The CI requires array klasses
a61af66fc99e Initial load duke parents: diff changeset	404 // to be loaded if their element klasses are loaded, except when memory
a61af66fc99e Initial load duke parents: diff changeset	405 // is exhausted.
a61af66fc99e Initial load duke parents: diff changeset	406 if (sym->byte_at(0) == '[' &&
a61af66fc99e Initial load duke parents: diff changeset	407 (sym->byte_at(1) == '[' \|\| sym->byte_at(1) == 'L')) {
a61af66fc99e Initial load duke parents: diff changeset	408 // We have an unloaded array.
a61af66fc99e Initial load duke parents: diff changeset	409 // Build it on the fly if the element class exists.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	410 TempNewSymbol elem_sym = SymbolTable::new_symbol(sym->as_utf8()+1,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	411 sym->utf8_length()-1,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	412 KILL_COMPILE_ON_FATAL_(fail_type));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	413
0 a61af66fc99e Initial load duke parents: diff changeset	414 // Get element ciKlass recursively.
a61af66fc99e Initial load duke parents: diff changeset	415 ciKlass* elem_klass =
a61af66fc99e Initial load duke parents: diff changeset	416 get_klass_by_name_impl(accessing_klass,
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	417 cpool,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	418 get_symbol(elem_sym),
0 a61af66fc99e Initial load duke parents: diff changeset	419 require_local);
a61af66fc99e Initial load duke parents: diff changeset	420 if (elem_klass != NULL && elem_klass->is_loaded()) {
a61af66fc99e Initial load duke parents: diff changeset	421 // Now make an array for it
a61af66fc99e Initial load duke parents: diff changeset	422 return ciObjArrayKlass::make_impl(elem_klass);
a61af66fc99e Initial load duke parents: diff changeset	423 }
a61af66fc99e Initial load duke parents: diff changeset	424 }
a61af66fc99e Initial load duke parents: diff changeset	425
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	426 if (found_klass() == NULL && !cpool.is_null() && cpool->has_preresolution()) {
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	427 // Look inside the constant pool for pre-resolved class entries.
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	428 for (int i = cpool->length() - 1; i >= 1; i--) {
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	429 if (cpool->tag_at(i).is_klass()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	430 Klass* kls = cpool->resolved_klass_at(i);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6940 diff changeset	431 if (kls->name() == sym) {
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	432 found_klass = KlassHandle(THREAD, kls);
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	433 break;
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	434 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	435 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	436 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	437 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	438
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 1972 diff changeset	439 if (found_klass() != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	440 // Found it. Build a CI handle.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	441 return get_klass(found_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	442 }
a61af66fc99e Initial load duke parents: diff changeset	443
a61af66fc99e Initial load duke parents: diff changeset	444 if (require_local) return NULL;
4001 5eb9169b1a14 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP twisti parents: 3959 diff changeset	445
0 a61af66fc99e Initial load duke parents: diff changeset	446 // Not yet loaded into the VM, or not governed by loader constraints.
a61af66fc99e Initial load duke parents: diff changeset	447 // Make a CI representative for it.
a61af66fc99e Initial load duke parents: diff changeset	448 return get_unloaded_klass(accessing_klass, name);
a61af66fc99e Initial load duke parents: diff changeset	449 }
a61af66fc99e Initial load duke parents: diff changeset	450
a61af66fc99e Initial load duke parents: diff changeset	451 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	452 // ciEnv::get_klass_by_name
a61af66fc99e Initial load duke parents: diff changeset	453 ciKlass* ciEnv::get_klass_by_name(ciKlass* accessing_klass,
a61af66fc99e Initial load duke parents: diff changeset	454 ciSymbol* klass_name,
a61af66fc99e Initial load duke parents: diff changeset	455 bool require_local) {
a61af66fc99e Initial load duke parents: diff changeset	456 GUARDED_VM_ENTRY(return get_klass_by_name_impl(accessing_klass,
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	457 constantPoolHandle(),
0 a61af66fc99e Initial load duke parents: diff changeset	458 klass_name,
a61af66fc99e Initial load duke parents: diff changeset	459 require_local);)
a61af66fc99e Initial load duke parents: diff changeset	460 }
a61af66fc99e Initial load duke parents: diff changeset	461
a61af66fc99e Initial load duke parents: diff changeset	462 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	463 // ciEnv::get_klass_by_index_impl
a61af66fc99e Initial load duke parents: diff changeset	464 //
a61af66fc99e Initial load duke parents: diff changeset	465 // Implementation of get_klass_by_index.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	466 ciKlass* ciEnv::get_klass_by_index_impl(constantPoolHandle cpool,
0 a61af66fc99e Initial load duke parents: diff changeset	467 int index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	468 bool& is_accessible,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	469 ciInstanceKlass* accessor) {
0 a61af66fc99e Initial load duke parents: diff changeset	470 EXCEPTION_CONTEXT;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	471 KlassHandle klass; // = NULL;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	472 Symbol* klass_name = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	473
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	474 if (cpool->tag_at(index).is_symbol()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	475 klass_name = cpool->symbol_at(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	476 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	477 // Check if it's resolved if it's not a symbol constant pool entry.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	478 klass = KlassHandle(THREAD, ConstantPool::klass_at_if_loaded(cpool, index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	479
0 a61af66fc99e Initial load duke parents: diff changeset	480 if (klass.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	481 // The klass has not been inserted into the constant pool.
a61af66fc99e Initial load duke parents: diff changeset	482 // Try to look it up by name.
a61af66fc99e Initial load duke parents: diff changeset	483 {
a61af66fc99e Initial load duke parents: diff changeset	484 // We have to lock the cpool to keep the oop from being resolved
a61af66fc99e Initial load duke parents: diff changeset	485 // while we are accessing it.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	486 MonitorLockerEx ml(cpool->lock());
0 a61af66fc99e Initial load duke parents: diff changeset	487 constantTag tag = cpool->tag_at(index);
a61af66fc99e Initial load duke parents: diff changeset	488 if (tag.is_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	489 // The klass has been inserted into the constant pool
a61af66fc99e Initial load duke parents: diff changeset	490 // very recently.
a61af66fc99e Initial load duke parents: diff changeset	491 klass = KlassHandle(THREAD, cpool->resolved_klass_at(index));
a61af66fc99e Initial load duke parents: diff changeset	492 } else {
a61af66fc99e Initial load duke parents: diff changeset	493 assert(cpool->tag_at(index).is_unresolved_klass(), "wrong tag");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	494 klass_name = cpool->unresolved_klass_at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	495 }
a61af66fc99e Initial load duke parents: diff changeset	496 }
a61af66fc99e Initial load duke parents: diff changeset	497 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	498 }
0 a61af66fc99e Initial load duke parents: diff changeset	499
a61af66fc99e Initial load duke parents: diff changeset	500 if (klass.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	501 // Not found in constant pool. Use the name to do the lookup.
a61af66fc99e Initial load duke parents: diff changeset	502 ciKlass* k = get_klass_by_name_impl(accessor,
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	503 cpool,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	504 get_symbol(klass_name),
0 a61af66fc99e Initial load duke parents: diff changeset	505 false);
a61af66fc99e Initial load duke parents: diff changeset	506 // Calculate accessibility the hard way.
a61af66fc99e Initial load duke parents: diff changeset	507 if (!k->is_loaded()) {
a61af66fc99e Initial load duke parents: diff changeset	508 is_accessible = false;
a61af66fc99e Initial load duke parents: diff changeset	509 } else if (k->loader() != accessor->loader() &&
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	510 get_klass_by_name_impl(accessor, cpool, k->name(), true) == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	511 // Loaded only remotely. Not linked yet.
a61af66fc99e Initial load duke parents: diff changeset	512 is_accessible = false;
a61af66fc99e Initial load duke parents: diff changeset	513 } else {
a61af66fc99e Initial load duke parents: diff changeset	514 // Linked locally, and we must also check public/private, etc.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	515 is_accessible = check_klass_accessibility(accessor, k->get_Klass());
0 a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517 return k;
a61af66fc99e Initial load duke parents: diff changeset	518 }
a61af66fc99e Initial load duke parents: diff changeset	519
a61af66fc99e Initial load duke parents: diff changeset	520 // Check for prior unloaded klass. The SystemDictionary's answers
a61af66fc99e Initial load duke parents: diff changeset	521 // can vary over time but the compiler needs consistency.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	522 ciSymbol* name = get_symbol(klass()->name());
0 a61af66fc99e Initial load duke parents: diff changeset	523 ciKlass* unloaded_klass = check_get_unloaded_klass(accessor, name);
a61af66fc99e Initial load duke parents: diff changeset	524 if (unloaded_klass != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	525 is_accessible = false;
a61af66fc99e Initial load duke parents: diff changeset	526 return unloaded_klass;
a61af66fc99e Initial load duke parents: diff changeset	527 }
a61af66fc99e Initial load duke parents: diff changeset	528
a61af66fc99e Initial load duke parents: diff changeset	529 // It is known to be accessible, since it was found in the constant pool.
a61af66fc99e Initial load duke parents: diff changeset	530 is_accessible = true;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	531 return get_klass(klass());
0 a61af66fc99e Initial load duke parents: diff changeset	532 }
a61af66fc99e Initial load duke parents: diff changeset	533
a61af66fc99e Initial load duke parents: diff changeset	534 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	535 // ciEnv::get_klass_by_index
a61af66fc99e Initial load duke parents: diff changeset	536 //
a61af66fc99e Initial load duke parents: diff changeset	537 // Get a klass from the constant pool.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	538 ciKlass* ciEnv::get_klass_by_index(constantPoolHandle cpool,
0 a61af66fc99e Initial load duke parents: diff changeset	539 int index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	540 bool& is_accessible,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	541 ciInstanceKlass* accessor) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	542 GUARDED_VM_ENTRY(return get_klass_by_index_impl(cpool, index, is_accessible, accessor);)
0 a61af66fc99e Initial load duke parents: diff changeset	543 }
a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	546 // ciEnv::get_constant_by_index_impl
a61af66fc99e Initial load duke parents: diff changeset	547 //
a61af66fc99e Initial load duke parents: diff changeset	548 // Implementation of get_constant_by_index().
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	549 ciConstant ciEnv::get_constant_by_index_impl(constantPoolHandle cpool,
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	550 int pool_index, int cache_index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	551 ciInstanceKlass* accessor) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	552 bool ignore_will_link;
0 a61af66fc99e Initial load duke parents: diff changeset	553 EXCEPTION_CONTEXT;
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	554 int index = pool_index;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	555 if (cache_index >= 0) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	556 assert(index < 0, "only one kind of index at a time");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	557 oop obj = cpool->resolved_references()->obj_at(cache_index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	558 if (obj != NULL) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	559 ciObject* ciobj = get_object(obj);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	560 return ciConstant(T_OBJECT, ciobj);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	561 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	562 index = cpool->object_to_cp_index(cache_index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	563 }
0 a61af66fc99e Initial load duke parents: diff changeset	564 constantTag tag = cpool->tag_at(index);
a61af66fc99e Initial load duke parents: diff changeset	565 if (tag.is_int()) {
a61af66fc99e Initial load duke parents: diff changeset	566 return ciConstant(T_INT, (jint)cpool->int_at(index));
a61af66fc99e Initial load duke parents: diff changeset	567 } else if (tag.is_long()) {
a61af66fc99e Initial load duke parents: diff changeset	568 return ciConstant((jlong)cpool->long_at(index));
a61af66fc99e Initial load duke parents: diff changeset	569 } else if (tag.is_float()) {
a61af66fc99e Initial load duke parents: diff changeset	570 return ciConstant((jfloat)cpool->float_at(index));
a61af66fc99e Initial load duke parents: diff changeset	571 } else if (tag.is_double()) {
a61af66fc99e Initial load duke parents: diff changeset	572 return ciConstant((jdouble)cpool->double_at(index));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	573 } else if (tag.is_string()) {
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	574 oop string = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	575 assert(cache_index >= 0, "should have a cache index");
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	576 if (cpool->is_pseudo_string_at(index)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	577 string = cpool->pseudo_string_at(index, cache_index);
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	578 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	579 string = cpool->string_at(index, cache_index, THREAD);
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	580 if (HAS_PENDING_EXCEPTION) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	581 CLEAR_PENDING_EXCEPTION;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	582 record_out_of_memory_failure();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	583 return ciConstant();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	584 }
0 a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586 ciObject* constant = get_object(string);
a61af66fc99e Initial load duke parents: diff changeset	587 assert (constant->is_instance(), "must be an instance, or not? ");
a61af66fc99e Initial load duke parents: diff changeset	588 return ciConstant(T_OBJECT, constant);
a61af66fc99e Initial load duke parents: diff changeset	589 } else if (tag.is_klass() \|\| tag.is_unresolved_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	590 // 4881222: allow ldc to take a class type
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	591 ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore_will_link, accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	592 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	593 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	594 record_out_of_memory_failure();
a61af66fc99e Initial load duke parents: diff changeset	595 return ciConstant();
a61af66fc99e Initial load duke parents: diff changeset	596 }
a61af66fc99e Initial load duke parents: diff changeset	597 assert (klass->is_instance_klass() \|\| klass->is_array_klass(),
a61af66fc99e Initial load duke parents: diff changeset	598 "must be an instance or array klass ");
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	599 return ciConstant(T_OBJECT, klass->java_mirror());
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	600 } else if (tag.is_method_type()) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	601 // must execute Java code to link this CP entry into cache[i].f1
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	602 ciSymbol* signature = get_symbol(cpool->method_type_signature_at(index));
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	603 ciObject* ciobj = get_unloaded_method_type_constant(signature);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	604 return ciConstant(T_OBJECT, ciobj);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	605 } else if (tag.is_method_handle()) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	606 // must execute Java code to link this CP entry into cache[i].f1
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	607 int ref_kind = cpool->method_handle_ref_kind_at(index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	608 int callee_index = cpool->method_handle_klass_index_at(index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	609 ciKlass* callee = get_klass_by_index_impl(cpool, callee_index, ignore_will_link, accessor);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	610 ciSymbol* name = get_symbol(cpool->method_handle_name_ref_at(index));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	611 ciSymbol* signature = get_symbol(cpool->method_handle_signature_ref_at(index));
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	612 ciObject* ciobj = get_unloaded_method_handle_constant(callee, name, signature, ref_kind);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	613 return ciConstant(T_OBJECT, ciobj);
0 a61af66fc99e Initial load duke parents: diff changeset	614 } else {
a61af66fc99e Initial load duke parents: diff changeset	615 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	616 return ciConstant();
a61af66fc99e Initial load duke parents: diff changeset	617 }
a61af66fc99e Initial load duke parents: diff changeset	618 }
a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	621 // ciEnv::get_constant_by_index
a61af66fc99e Initial load duke parents: diff changeset	622 //
a61af66fc99e Initial load duke parents: diff changeset	623 // Pull a constant out of the constant pool. How appropriate.
a61af66fc99e Initial load duke parents: diff changeset	624 //
a61af66fc99e Initial load duke parents: diff changeset	625 // Implementation note: this query is currently in no way cached.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	626 ciConstant ciEnv::get_constant_by_index(constantPoolHandle cpool,
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	627 int pool_index, int cache_index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	628 ciInstanceKlass* accessor) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	629 GUARDED_VM_ENTRY(return get_constant_by_index_impl(cpool, pool_index, cache_index, accessor);)
0 a61af66fc99e Initial load duke parents: diff changeset	630 }
a61af66fc99e Initial load duke parents: diff changeset	631
a61af66fc99e Initial load duke parents: diff changeset	632 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	633 // ciEnv::get_field_by_index_impl
a61af66fc99e Initial load duke parents: diff changeset	634 //
a61af66fc99e Initial load duke parents: diff changeset	635 // Implementation of get_field_by_index.
a61af66fc99e Initial load duke parents: diff changeset	636 //
a61af66fc99e Initial load duke parents: diff changeset	637 // Implementation note: the results of field lookups are cached
a61af66fc99e Initial load duke parents: diff changeset	638 // in the accessor klass.
a61af66fc99e Initial load duke parents: diff changeset	639 ciField* ciEnv::get_field_by_index_impl(ciInstanceKlass* accessor,
a61af66fc99e Initial load duke parents: diff changeset	640 int index) {
a61af66fc99e Initial load duke parents: diff changeset	641 ciConstantPoolCache* cache = accessor->field_cache();
a61af66fc99e Initial load duke parents: diff changeset	642 if (cache == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	643 ciField* field = new (arena()) ciField(accessor, index);
a61af66fc99e Initial load duke parents: diff changeset	644 return field;
a61af66fc99e Initial load duke parents: diff changeset	645 } else {
a61af66fc99e Initial load duke parents: diff changeset	646 ciField* field = (ciField*)cache->get(index);
a61af66fc99e Initial load duke parents: diff changeset	647 if (field == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	648 field = new (arena()) ciField(accessor, index);
a61af66fc99e Initial load duke parents: diff changeset	649 cache->insert(index, field);
a61af66fc99e Initial load duke parents: diff changeset	650 }
a61af66fc99e Initial load duke parents: diff changeset	651 return field;
a61af66fc99e Initial load duke parents: diff changeset	652 }
a61af66fc99e Initial load duke parents: diff changeset	653 }
a61af66fc99e Initial load duke parents: diff changeset	654
a61af66fc99e Initial load duke parents: diff changeset	655 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	656 // ciEnv::get_field_by_index
a61af66fc99e Initial load duke parents: diff changeset	657 //
a61af66fc99e Initial load duke parents: diff changeset	658 // Get a field by index from a klass's constant pool.
a61af66fc99e Initial load duke parents: diff changeset	659 ciField* ciEnv::get_field_by_index(ciInstanceKlass* accessor,
a61af66fc99e Initial load duke parents: diff changeset	660 int index) {
a61af66fc99e Initial load duke parents: diff changeset	661 GUARDED_VM_ENTRY(return get_field_by_index_impl(accessor, index);)
a61af66fc99e Initial load duke parents: diff changeset	662 }
a61af66fc99e Initial load duke parents: diff changeset	663
a61af66fc99e Initial load duke parents: diff changeset	664 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	665 // ciEnv::lookup_method
a61af66fc99e Initial load duke parents: diff changeset	666 //
a61af66fc99e Initial load duke parents: diff changeset	667 // Perform an appropriate method lookup based on accessor, holder,
a61af66fc99e Initial load duke parents: diff changeset	668 // name, signature, and bytecode.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	669 Method* ciEnv::lookup_method(InstanceKlass* accessor,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	670 InstanceKlass* holder,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	671 Symbol* name,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	672 Symbol* sig,
0 a61af66fc99e Initial load duke parents: diff changeset	673 Bytecodes::Code bc) {
a61af66fc99e Initial load duke parents: diff changeset	674 EXCEPTION_CONTEXT;
a61af66fc99e Initial load duke parents: diff changeset	675 KlassHandle h_accessor(THREAD, accessor);
a61af66fc99e Initial load duke parents: diff changeset	676 KlassHandle h_holder(THREAD, holder);
a61af66fc99e Initial load duke parents: diff changeset	677 LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL));
a61af66fc99e Initial load duke parents: diff changeset	678 methodHandle dest_method;
a61af66fc99e Initial load duke parents: diff changeset	679 switch (bc) {
a61af66fc99e Initial load duke parents: diff changeset	680 case Bytecodes::_invokestatic:
a61af66fc99e Initial load duke parents: diff changeset	681 dest_method =
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	682 LinkResolver::resolve_static_call_or_null(h_holder, name, sig, h_accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	683 break;
a61af66fc99e Initial load duke parents: diff changeset	684 case Bytecodes::_invokespecial:
a61af66fc99e Initial load duke parents: diff changeset	685 dest_method =
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	686 LinkResolver::resolve_special_call_or_null(h_holder, name, sig, h_accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	687 break;
a61af66fc99e Initial load duke parents: diff changeset	688 case Bytecodes::_invokeinterface:
a61af66fc99e Initial load duke parents: diff changeset	689 dest_method =
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	690 LinkResolver::linktime_resolve_interface_method_or_null(h_holder, name, sig,
0 a61af66fc99e Initial load duke parents: diff changeset	691 h_accessor, true);
a61af66fc99e Initial load duke parents: diff changeset	692 break;
a61af66fc99e Initial load duke parents: diff changeset	693 case Bytecodes::_invokevirtual:
a61af66fc99e Initial load duke parents: diff changeset	694 dest_method =
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	695 LinkResolver::linktime_resolve_virtual_method_or_null(h_holder, name, sig,
0 a61af66fc99e Initial load duke parents: diff changeset	696 h_accessor, true);
a61af66fc99e Initial load duke parents: diff changeset	697 break;
a61af66fc99e Initial load duke parents: diff changeset	698 default: ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	699 }
a61af66fc99e Initial load duke parents: diff changeset	700
a61af66fc99e Initial load duke parents: diff changeset	701 return dest_method();
a61af66fc99e Initial load duke parents: diff changeset	702 }
a61af66fc99e Initial load duke parents: diff changeset	703
a61af66fc99e Initial load duke parents: diff changeset	704
a61af66fc99e Initial load duke parents: diff changeset	705 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	706 // ciEnv::get_method_by_index_impl
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	707 ciMethod* ciEnv::get_method_by_index_impl(constantPoolHandle cpool,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	708 int index, Bytecodes::Code bc,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	709 ciInstanceKlass* accessor) {
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	710 if (bc == Bytecodes::_invokedynamic) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	711 ConstantPoolCacheEntry* cpce = cpool->invokedynamic_cp_cache_entry_at(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	712 bool is_resolved = !cpce->is_f1_null();
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	713 // FIXME: code generation could allow for null (unlinked) call site
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	714 // The call site could be made patchable as follows:
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	715 // Load the appendix argument from the constant pool.
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	716 // Test the appendix argument and jump to a known deopt routine if it is null.
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	717 // Jump through a patchable call site, which is initially a deopt routine.
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	718 // Patch the call site to the nmethod entry point of the static compiled lambda form.
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	719 // As with other two-component call sites, both values must be independently verified.
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	720
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	721 if (is_resolved) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	722 // Get the invoker Method* from the constant pool.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	723 // (The appendix argument, if any, will be noted in the method's signature.)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	724 Method* adapter = cpce->f1_as_method();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	725 return get_method(adapter);
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	726 }
0 a61af66fc99e Initial load duke parents: diff changeset	727
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	728 // Fake a method that is equivalent to a declared method.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	729 ciInstanceKlass* holder = get_instance_klass(SystemDictionary::MethodHandle_klass());
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4001 diff changeset	730 ciSymbol* name = ciSymbol::invokeBasic_name();
4001 5eb9169b1a14 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP twisti parents: 3959 diff changeset	731 ciSymbol* signature = get_symbol(cpool->signature_ref_at(index));
5eb9169b1a14 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP twisti parents: 3959 diff changeset	732 return get_unloaded_method(holder, name, signature, accessor);
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	733 } else {
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	734 const int holder_index = cpool->klass_ref_index_at(index);
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	735 bool holder_is_accessible;
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	736 ciKlass* holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor);
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	737 ciInstanceKlass* declared_holder = get_instance_klass_for_declared_method_holder(holder);
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	738
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	739 // Get the method's name and signature.
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	740 Symbol* name_sym = cpool->name_ref_at(index);
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	741 Symbol* sig_sym = cpool->signature_ref_at(index);
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	742
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	743 if (cpool->has_preresolution()
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	744 \|\| (holder == ciEnv::MethodHandle_klass() &&
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	745 MethodHandles::is_signature_polymorphic_name(holder->get_Klass(), name_sym))) {
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	746 // Short-circuit lookups for JSR 292-related call sites.
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	747 // That is, do not rely only on name-based lookups, because they may fail
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	748 // if the names are not resolvable in the boot class loader (7056328).
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	749 switch (bc) {
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	750 case Bytecodes::_invokevirtual:
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	751 case Bytecodes::_invokeinterface:
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	752 case Bytecodes::_invokespecial:
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	753 case Bytecodes::_invokestatic:
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	754 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	755 Method* m = ConstantPool::method_at_if_loaded(cpool, index);
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	756 if (m != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	757 return get_method(m);
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	758 }
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	759 }
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	760 break;
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	761 }
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	762 }
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	763
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	764 if (holder_is_accessible) { // Our declared holder is loaded.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	765 InstanceKlass* lookup = declared_holder->get_instanceKlass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	766 Method* m = lookup_method(accessor->get_instanceKlass(), lookup, name_sym, sig_sym, bc);
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	767 if (m != NULL &&
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	768 (bc == Bytecodes::_invokestatic
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6853 diff changeset	769 ? m->method_holder()->is_not_initialized()
18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6853 diff changeset	770 : !m->method_holder()->is_loaded())) {
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	771 m = NULL;
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	772 }
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	773 #ifdef ASSERT
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	774 if (m != NULL && ReplayCompiles && !ciReplay::is_loaded(m)) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	775 m = NULL;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	776 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	777 #endif
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	778 if (m != NULL) {
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	779 // We found the method.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	780 return get_method(m);
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	781 }
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	782 }
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	783
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	784 // Either the declared holder was not loaded, or the method could
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	785 // not be found. Create a dummy ciMethod to represent the failed
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	786 // lookup.
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	787 ciSymbol* name = get_symbol(name_sym);
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	788 ciSymbol* signature = get_symbol(sig_sym);
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	789 return get_unloaded_method(declared_holder, name, signature, accessor);
7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	790 }
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	791 }
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	792
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	793
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	794 // ------------------------------------------------------------------
0 a61af66fc99e Initial load duke parents: diff changeset	795 // ciEnv::get_instance_klass_for_declared_method_holder
a61af66fc99e Initial load duke parents: diff changeset	796 ciInstanceKlass* ciEnv::get_instance_klass_for_declared_method_holder(ciKlass* method_holder) {
a61af66fc99e Initial load duke parents: diff changeset	797 // For the case of <array>.clone(), the method holder can be a ciArrayKlass
a61af66fc99e Initial load duke parents: diff changeset	798 // instead of a ciInstanceKlass. For that case simply pretend that the
a61af66fc99e Initial load duke parents: diff changeset	799 // declared holder is Object.clone since that's where the call will bottom out.
a61af66fc99e Initial load duke parents: diff changeset	800 // A more correct fix would trickle out through many interfaces in CI,
a61af66fc99e Initial load duke parents: diff changeset	801 // requiring ciInstanceKlass* to become ciKlass* and many more places would
a61af66fc99e Initial load duke parents: diff changeset	802 // require checks to make sure the expected type was found. Given that this
a61af66fc99e Initial load duke parents: diff changeset	803 // only occurs for clone() the more extensive fix seems like overkill so
a61af66fc99e Initial load duke parents: diff changeset	804 // instead we simply smear the array type into Object.
8777 2dec1d9bfbe1 8009565: [partfait] Null pointer deference in hotspot/src/share/vm/ci/ciEnv.cpp morris parents: 8104 diff changeset	805 guarantee(method_holder != NULL, "no method holder");
0 a61af66fc99e Initial load duke parents: diff changeset	806 if (method_holder->is_instance_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	807 return method_holder->as_instance_klass();
a61af66fc99e Initial load duke parents: diff changeset	808 } else if (method_holder->is_array_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	809 return current()->Object_klass();
a61af66fc99e Initial load duke parents: diff changeset	810 } else {
a61af66fc99e Initial load duke parents: diff changeset	811 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	812 }
a61af66fc99e Initial load duke parents: diff changeset	813 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	814 }
a61af66fc99e Initial load duke parents: diff changeset	815
a61af66fc99e Initial load duke parents: diff changeset	816
a61af66fc99e Initial load duke parents: diff changeset	817 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	818 // ciEnv::get_method_by_index
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	819 ciMethod* ciEnv::get_method_by_index(constantPoolHandle cpool,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	820 int index, Bytecodes::Code bc,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	821 ciInstanceKlass* accessor) {
6634 7f813940ac35 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites twisti parents: 6266 diff changeset	822 GUARDED_VM_ENTRY(return get_method_by_index_impl(cpool, index, bc, accessor);)
0 a61af66fc99e Initial load duke parents: diff changeset	823 }
a61af66fc99e Initial load duke parents: diff changeset	824
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	825
0 a61af66fc99e Initial load duke parents: diff changeset	826 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	827 // ciEnv::name_buffer
a61af66fc99e Initial load duke parents: diff changeset	828 char *ciEnv::name_buffer(int req_len) {
a61af66fc99e Initial load duke parents: diff changeset	829 if (_name_buffer_len < req_len) {
a61af66fc99e Initial load duke parents: diff changeset	830 if (_name_buffer == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	831 _name_buffer = (char)arena()->Amalloc(sizeof(char)req_len);
a61af66fc99e Initial load duke parents: diff changeset	832 _name_buffer_len = req_len;
a61af66fc99e Initial load duke parents: diff changeset	833 } else {
a61af66fc99e Initial load duke parents: diff changeset	834 _name_buffer =
a61af66fc99e Initial load duke parents: diff changeset	835 (char*)arena()->Arealloc(_name_buffer, _name_buffer_len, req_len);
a61af66fc99e Initial load duke parents: diff changeset	836 _name_buffer_len = req_len;
a61af66fc99e Initial load duke parents: diff changeset	837 }
a61af66fc99e Initial load duke parents: diff changeset	838 }
a61af66fc99e Initial load duke parents: diff changeset	839 return _name_buffer;
a61af66fc99e Initial load duke parents: diff changeset	840 }
a61af66fc99e Initial load duke parents: diff changeset	841
a61af66fc99e Initial load duke parents: diff changeset	842 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	843 // ciEnv::is_in_vm
a61af66fc99e Initial load duke parents: diff changeset	844 bool ciEnv::is_in_vm() {
a61af66fc99e Initial load duke parents: diff changeset	845 return JavaThread::current()->thread_state() == _thread_in_vm;
a61af66fc99e Initial load duke parents: diff changeset	846 }
a61af66fc99e Initial load duke parents: diff changeset	847
a61af66fc99e Initial load duke parents: diff changeset	848 bool ciEnv::system_dictionary_modification_counter_changed() {
a61af66fc99e Initial load duke parents: diff changeset	849 return _system_dictionary_modification_counter != SystemDictionary::number_of_modifications();
a61af66fc99e Initial load duke parents: diff changeset	850 }
a61af66fc99e Initial load duke parents: diff changeset	851
a61af66fc99e Initial load duke parents: diff changeset	852 // ------------------------------------------------------------------
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	853 // ciEnv::validate_compile_task_dependencies
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	854 //
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	855 // Check for changes during compilation (e.g. class loads, evolution,
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	856 // breakpoints, call site invalidation).
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	857 void ciEnv::validate_compile_task_dependencies(ciMethod* target) {
0 a61af66fc99e Initial load duke parents: diff changeset	858 if (failing()) return; // no need for further checks
a61af66fc99e Initial load duke parents: diff changeset	859
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	860 // First, check non-klass dependencies as we might return early and
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	861 // not check klass dependencies if the system dictionary
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	862 // modification counter hasn't changed (see below).
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	863 for (Dependencies::DepStream deps(dependencies()); deps.next(); ) {
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	864 if (deps.is_klass_type()) continue; // skip klass dependencies
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	865 Klass* witness = deps.check_dependency();
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	866 if (witness != NULL) {
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	867 record_failure("invalid non-klass dependency");
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	868 return;
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	869 }
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	870 }
0 a61af66fc99e Initial load duke parents: diff changeset	871
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	872 // Klass dependencies must be checked when the system dictionary
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	873 // changes. If logging is enabled all violated dependences will be
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	874 // recorded in the log. In debug mode check dependencies even if
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	875 // the system dictionary hasn't changed to verify that no invalid
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	876 // dependencies were inserted. Any violated dependences in this
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	877 // case are dumped to the tty.
0 a61af66fc99e Initial load duke parents: diff changeset	878 bool counter_changed = system_dictionary_modification_counter_changed();
a61af66fc99e Initial load duke parents: diff changeset	879
3959 eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	880 bool verify_deps = trueInDebug;
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	881 if (!counter_changed && !verify_deps) return;
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	882
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	883 int klass_violations = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	884 for (Dependencies::DepStream deps(dependencies()); deps.next(); ) {
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	885 if (!deps.is_klass_type()) continue; // skip non-klass dependencies
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	886 Klass* witness = deps.check_dependency();
0 a61af66fc99e Initial load duke parents: diff changeset	887 if (witness != NULL) {
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	888 klass_violations++;
3959 eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	889 if (!counter_changed) {
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	890 // Dependence failed but counter didn't change. Log a message
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	891 // describing what failed and allow the assert at the end to
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	892 // trigger.
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	893 deps.print_dependency(witness);
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	894 } else if (xtty == NULL) {
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	895 // If we're not logging then a single violation is sufficient,
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	896 // otherwise we want to log all the dependences which were
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	897 // violated.
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	898 break;
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	899 }
0 a61af66fc99e Initial load duke parents: diff changeset	900 }
a61af66fc99e Initial load duke parents: diff changeset	901 }
a61af66fc99e Initial load duke parents: diff changeset	902
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	903 if (klass_violations != 0) {
3959 eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	904 #ifdef ASSERT
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	905 if (!counter_changed && !PrintCompilation) {
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	906 // Print out the compile task that failed
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	907 _task->print_line();
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	908 }
eda6988c0d81 7092236: java/util/EnumSet/EnumSetBash.java fails never parents: 3899 diff changeset	909 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	910 assert(counter_changed, "failed dependencies, but counter didn't change");
a61af66fc99e Initial load duke parents: diff changeset	911 record_failure("concurrent class loading");
a61af66fc99e Initial load duke parents: diff changeset	912 }
a61af66fc99e Initial load duke parents: diff changeset	913 }
a61af66fc99e Initial load duke parents: diff changeset	914
a61af66fc99e Initial load duke parents: diff changeset	915 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	916 // ciEnv::register_method
a61af66fc99e Initial load duke parents: diff changeset	917 void ciEnv::register_method(ciMethod* target,
a61af66fc99e Initial load duke parents: diff changeset	918 int entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	919 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	920 int orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	921 CodeBuffer* code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	922 int frame_words,
a61af66fc99e Initial load duke parents: diff changeset	923 OopMapSet* oop_map_set,
a61af66fc99e Initial load duke parents: diff changeset	924 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load duke parents: diff changeset	925 ImplicitExceptionTable* inc_table,
a61af66fc99e Initial load duke parents: diff changeset	926 AbstractCompiler* compiler,
a61af66fc99e Initial load duke parents: diff changeset	927 int comp_level,
6792 137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	928 bool has_unsafe_access,
137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	929 bool has_wide_vectors) {
0 a61af66fc99e Initial load duke parents: diff changeset	930 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	931 nmethod* nm = NULL;
a61af66fc99e Initial load duke parents: diff changeset	932 {
a61af66fc99e Initial load duke parents: diff changeset	933 // To prevent compile queue updates.
a61af66fc99e Initial load duke parents: diff changeset	934 MutexLocker locker(MethodCompileQueue_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	935
a61af66fc99e Initial load duke parents: diff changeset	936 // Prevent SystemDictionary::add_to_hierarchy from running
a61af66fc99e Initial load duke parents: diff changeset	937 // and invalidating our dependencies until we install this method.
a61af66fc99e Initial load duke parents: diff changeset	938 MutexLocker ml(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	939
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	940 // Change in Jvmti state may invalidate compilation.
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	941 if (!failing() &&
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	942 ( (!jvmti_can_hotswap_or_post_breakpoint() &&
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	943 JvmtiExport::can_hotswap_or_post_breakpoint()) \|\|
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	944 (!jvmti_can_access_local_variables() &&
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	945 JvmtiExport::can_access_local_variables()) \|\|
1213 6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty dcubed parents: 1142 diff changeset	946 (!jvmti_can_post_on_exceptions() &&
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty dcubed parents: 1142 diff changeset	947 JvmtiExport::can_post_on_exceptions()) )) {
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	948 record_failure("Jvmti state change invalidated dependencies");
0 a61af66fc99e Initial load duke parents: diff changeset	949 }
a61af66fc99e Initial load duke parents: diff changeset	950
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	951 // Change in DTrace flags may invalidate compilation.
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	952 if (!failing() &&
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	953 ( (!dtrace_extended_probes() && ExtendedDTraceProbes) \|\|
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	954 (!dtrace_method_probes() && DTraceMethodProbes) \|\|
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	955 (!dtrace_alloc_probes() && DTraceAllocProbes) )) {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	956 record_failure("DTrace flags change invalidated dependencies");
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	957 }
0 a61af66fc99e Initial load duke parents: diff changeset	958
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	959 if (!failing()) {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	960 if (log() != NULL) {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	961 // Log the dependencies which this compilation declares.
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	962 dependencies()->log_all_dependencies();
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	963 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	964
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	965 // Encode the dependencies now, so we can check them right away.
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	966 dependencies()->encode_content_bytes();
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	967
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	968 // Check for {class loads, evolution, breakpoints, ...} during compilation
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3461 diff changeset	969 validate_compile_task_dependencies(target);
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	970 }
0 a61af66fc99e Initial load duke parents: diff changeset	971
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	972 methodHandle method(THREAD, target->get_Method());
0 a61af66fc99e Initial load duke parents: diff changeset	973
a61af66fc99e Initial load duke parents: diff changeset	974 if (failing()) {
a61af66fc99e Initial load duke parents: diff changeset	975 // While not a true deoptimization, it is a preemptive decompile.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	976 MethodData* mdo = method()->method_data();
0 a61af66fc99e Initial load duke parents: diff changeset	977 if (mdo != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	978 mdo->inc_decompile_count();
a61af66fc99e Initial load duke parents: diff changeset	979 }
a61af66fc99e Initial load duke parents: diff changeset	980
a61af66fc99e Initial load duke parents: diff changeset	981 // All buffers in the CodeBuffer are allocated in the CodeCache.
a61af66fc99e Initial load duke parents: diff changeset	982 // If the code buffer is created on each compile attempt
a61af66fc99e Initial load duke parents: diff changeset	983 // as in C2, then it must be freed.
a61af66fc99e Initial load duke parents: diff changeset	984 code_buffer->free_blob();
a61af66fc99e Initial load duke parents: diff changeset	985 return;
a61af66fc99e Initial load duke parents: diff changeset	986 }
a61af66fc99e Initial load duke parents: diff changeset	987
a61af66fc99e Initial load duke parents: diff changeset	988 assert(offsets->value(CodeOffsets::Deopt) != -1, "must have deopt entry");
a61af66fc99e Initial load duke parents: diff changeset	989 assert(offsets->value(CodeOffsets::Exceptions) != -1, "must have exception entry");
a61af66fc99e Initial load duke parents: diff changeset	990
a61af66fc99e Initial load duke parents: diff changeset	991 nm = nmethod::new_nmethod(method,
a61af66fc99e Initial load duke parents: diff changeset	992 compile_id(),
a61af66fc99e Initial load duke parents: diff changeset	993 entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	994 offsets,
a61af66fc99e Initial load duke parents: diff changeset	995 orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	996 debug_info(), dependencies(), code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	997 frame_words, oop_map_set,
a61af66fc99e Initial load duke parents: diff changeset	998 handler_table, inc_table,
a61af66fc99e Initial load duke parents: diff changeset	999 compiler, comp_level);
a61af66fc99e Initial load duke parents: diff changeset	1000
a61af66fc99e Initial load duke parents: diff changeset	1001 // Free codeBlobs
a61af66fc99e Initial load duke parents: diff changeset	1002 code_buffer->free_blob();
a61af66fc99e Initial load duke parents: diff changeset	1003
a61af66fc99e Initial load duke parents: diff changeset	1004 // stress test 6243940 by immediately making the method
a61af66fc99e Initial load duke parents: diff changeset	1005 // non-entrant behind the system's back. This has serious
a61af66fc99e Initial load duke parents: diff changeset	1006 // side effects on the code cache and is not meant for
a61af66fc99e Initial load duke parents: diff changeset	1007 // general stress testing
a61af66fc99e Initial load duke parents: diff changeset	1008 if (nm != NULL && StressNonEntrant) {
a61af66fc99e Initial load duke parents: diff changeset	1009 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	1010 NativeJump::patch_verified_entry(nm->entry_point(), nm->verified_entry_point(),
a61af66fc99e Initial load duke parents: diff changeset	1011 SharedRuntime::get_handle_wrong_method_stub());
a61af66fc99e Initial load duke parents: diff changeset	1012 }
a61af66fc99e Initial load duke parents: diff changeset	1013
a61af66fc99e Initial load duke parents: diff changeset	1014 if (nm == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1015 // The CodeCache is full. Print out warning and disable compilation.
a61af66fc99e Initial load duke parents: diff changeset	1016 record_failure("code cache is full");
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1142 diff changeset	1017 {
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1142 diff changeset	1018 MutexUnlocker ml(Compile_lock);
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1142 diff changeset	1019 MutexUnlocker locker(MethodCompileQueue_lock);
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1142 diff changeset	1020 CompileBroker::handle_full_code_cache();
0 a61af66fc99e Initial load duke parents: diff changeset	1021 }
a61af66fc99e Initial load duke parents: diff changeset	1022 } else {
a61af66fc99e Initial load duke parents: diff changeset	1023 nm->set_has_unsafe_access(has_unsafe_access);
6792 137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	1024 nm->set_has_wide_vectors(has_wide_vectors);
0 a61af66fc99e Initial load duke parents: diff changeset	1025
a61af66fc99e Initial load duke parents: diff changeset	1026 // Record successful registration.
a61af66fc99e Initial load duke parents: diff changeset	1027 // (Put nm into the task handle before publishing to the Java heap.)
a61af66fc99e Initial load duke parents: diff changeset	1028 if (task() != NULL) task()->set_code(nm);
a61af66fc99e Initial load duke parents: diff changeset	1029
a61af66fc99e Initial load duke parents: diff changeset	1030 if (entry_bci == InvocationEntryBci) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1031 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1032 // If there is an old version we're done with it
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1033 nmethod* old = method->code();
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1034 if (TraceMethodReplacement && old != NULL) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1035 ResourceMark rm;
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1036 char *method_name = method->name_and_sig_as_C_string();
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1037 tty->print_cr("Replacing method %s", method_name);
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1038 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1039 if (old != NULL ) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1040 old->make_not_entrant();
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1041 }
0 a61af66fc99e Initial load duke parents: diff changeset	1042 }
a61af66fc99e Initial load duke parents: diff changeset	1043 if (TraceNMethodInstalls ) {
a61af66fc99e Initial load duke parents: diff changeset	1044 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1045 char *method_name = method->name_and_sig_as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	1046 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	1047 tty->print_cr("Installing method (%d) %s ",
a61af66fc99e Initial load duke parents: diff changeset	1048 comp_level,
a61af66fc99e Initial load duke parents: diff changeset	1049 method_name);
a61af66fc99e Initial load duke parents: diff changeset	1050 }
a61af66fc99e Initial load duke parents: diff changeset	1051 // Allow the code to be executed
a61af66fc99e Initial load duke parents: diff changeset	1052 method->set_code(method, nm);
a61af66fc99e Initial load duke parents: diff changeset	1053 } else {
a61af66fc99e Initial load duke parents: diff changeset	1054 if (TraceNMethodInstalls ) {
a61af66fc99e Initial load duke parents: diff changeset	1055 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1056 char *method_name = method->name_and_sig_as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	1057 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	1058 tty->print_cr("Installing osr method (%d) %s @ %d",
a61af66fc99e Initial load duke parents: diff changeset	1059 comp_level,
a61af66fc99e Initial load duke parents: diff changeset	1060 method_name,
a61af66fc99e Initial load duke parents: diff changeset	1061 entry_bci);
a61af66fc99e Initial load duke parents: diff changeset	1062 }
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6853 diff changeset	1063 method->method_holder()->add_osr_nmethod(nm);
0 a61af66fc99e Initial load duke parents: diff changeset	1064
a61af66fc99e Initial load duke parents: diff changeset	1065 }
a61af66fc99e Initial load duke parents: diff changeset	1066 }
a61af66fc99e Initial load duke parents: diff changeset	1067 }
a61af66fc99e Initial load duke parents: diff changeset	1068 // JVMTI -- compiled method notification (must be done outside lock)
a61af66fc99e Initial load duke parents: diff changeset	1069 if (nm != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1070 nm->post_compiled_method_load_event();
a61af66fc99e Initial load duke parents: diff changeset	1071 }
a61af66fc99e Initial load duke parents: diff changeset	1072
a61af66fc99e Initial load duke parents: diff changeset	1073 }
a61af66fc99e Initial load duke parents: diff changeset	1074
a61af66fc99e Initial load duke parents: diff changeset	1075
a61af66fc99e Initial load duke parents: diff changeset	1076 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1077 // ciEnv::find_system_klass
a61af66fc99e Initial load duke parents: diff changeset	1078 ciKlass* ciEnv::find_system_klass(ciSymbol* klass_name) {
a61af66fc99e Initial load duke parents: diff changeset	1079 VM_ENTRY_MARK;
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3279 diff changeset	1080 return get_klass_by_name_impl(NULL, constantPoolHandle(), klass_name, false);
0 a61af66fc99e Initial load duke parents: diff changeset	1081 }
a61af66fc99e Initial load duke parents: diff changeset	1082
a61af66fc99e Initial load duke parents: diff changeset	1083 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1084 // ciEnv::comp_level
a61af66fc99e Initial load duke parents: diff changeset	1085 int ciEnv::comp_level() {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1086 if (task() == NULL) return CompLevel_highest_tier;
0 a61af66fc99e Initial load duke parents: diff changeset	1087 return task()->comp_level();
a61af66fc99e Initial load duke parents: diff changeset	1088 }
a61af66fc99e Initial load duke parents: diff changeset	1089
a61af66fc99e Initial load duke parents: diff changeset	1090 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1091 // ciEnv::compile_id
a61af66fc99e Initial load duke parents: diff changeset	1092 uint ciEnv::compile_id() {
a61af66fc99e Initial load duke parents: diff changeset	1093 if (task() == NULL) return 0;
a61af66fc99e Initial load duke parents: diff changeset	1094 return task()->compile_id();
a61af66fc99e Initial load duke parents: diff changeset	1095 }
a61af66fc99e Initial load duke parents: diff changeset	1096
a61af66fc99e Initial load duke parents: diff changeset	1097 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1098 // ciEnv::notice_inlined_method()
a61af66fc99e Initial load duke parents: diff changeset	1099 void ciEnv::notice_inlined_method(ciMethod* method) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4001 diff changeset	1100 _num_inlined_bytecodes += method->code_size_for_inlining();
0 a61af66fc99e Initial load duke parents: diff changeset	1101 }
a61af66fc99e Initial load duke parents: diff changeset	1102
a61af66fc99e Initial load duke parents: diff changeset	1103 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1104 // ciEnv::num_inlined_bytecodes()
a61af66fc99e Initial load duke parents: diff changeset	1105 int ciEnv::num_inlined_bytecodes() const {
a61af66fc99e Initial load duke parents: diff changeset	1106 return _num_inlined_bytecodes;
a61af66fc99e Initial load duke parents: diff changeset	1107 }
a61af66fc99e Initial load duke parents: diff changeset	1108
a61af66fc99e Initial load duke parents: diff changeset	1109 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1110 // ciEnv::record_failure()
a61af66fc99e Initial load duke parents: diff changeset	1111 void ciEnv::record_failure(const char* reason) {
a61af66fc99e Initial load duke parents: diff changeset	1112 if (log() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1113 log()->elem("failure reason='%s'", reason);
a61af66fc99e Initial load duke parents: diff changeset	1114 }
a61af66fc99e Initial load duke parents: diff changeset	1115 if (_failure_reason == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1116 // Record the first failure reason.
a61af66fc99e Initial load duke parents: diff changeset	1117 _failure_reason = reason;
a61af66fc99e Initial load duke parents: diff changeset	1118 }
a61af66fc99e Initial load duke parents: diff changeset	1119 }
a61af66fc99e Initial load duke parents: diff changeset	1120
a61af66fc99e Initial load duke parents: diff changeset	1121 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1122 // ciEnv::record_method_not_compilable()
a61af66fc99e Initial load duke parents: diff changeset	1123 void ciEnv::record_method_not_compilable(const char* reason, bool all_tiers) {
a61af66fc99e Initial load duke parents: diff changeset	1124 int new_compilable =
a61af66fc99e Initial load duke parents: diff changeset	1125 all_tiers ? MethodCompilable_never : MethodCompilable_not_at_tier ;
a61af66fc99e Initial load duke parents: diff changeset	1126
a61af66fc99e Initial load duke parents: diff changeset	1127 // Only note transitions to a worse state
a61af66fc99e Initial load duke parents: diff changeset	1128 if (new_compilable > _compilable) {
a61af66fc99e Initial load duke parents: diff changeset	1129 if (log() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1130 if (all_tiers) {
a61af66fc99e Initial load duke parents: diff changeset	1131 log()->elem("method_not_compilable");
a61af66fc99e Initial load duke parents: diff changeset	1132 } else {
6843 c3e799c37717 7177003: C1: LogCompilation support vlivanov parents: 6792 diff changeset	1133 log()->elem("method_not_compilable_at_tier level='%d'",
c3e799c37717 7177003: C1: LogCompilation support vlivanov parents: 6792 diff changeset	1134 current()->task()->comp_level());
0 a61af66fc99e Initial load duke parents: diff changeset	1135 }
a61af66fc99e Initial load duke parents: diff changeset	1136 }
a61af66fc99e Initial load duke parents: diff changeset	1137 _compilable = new_compilable;
a61af66fc99e Initial load duke parents: diff changeset	1138
a61af66fc99e Initial load duke parents: diff changeset	1139 // Reset failure reason; this one is more important.
a61af66fc99e Initial load duke parents: diff changeset	1140 _failure_reason = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1141 record_failure(reason);
a61af66fc99e Initial load duke parents: diff changeset	1142 }
a61af66fc99e Initial load duke parents: diff changeset	1143 }
a61af66fc99e Initial load duke parents: diff changeset	1144
a61af66fc99e Initial load duke parents: diff changeset	1145 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1146 // ciEnv::record_out_of_memory_failure()
a61af66fc99e Initial load duke parents: diff changeset	1147 void ciEnv::record_out_of_memory_failure() {
a61af66fc99e Initial load duke parents: diff changeset	1148 // If memory is low, we stop compiling methods.
a61af66fc99e Initial load duke parents: diff changeset	1149 record_method_not_compilable("out of memory");
a61af66fc99e Initial load duke parents: diff changeset	1150 }
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1151
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1152 fileStream* ciEnv::_replay_data_stream = NULL;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1153
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1154 void ciEnv::dump_replay_data() {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1155 VM_ENTRY_MARK;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1156 MutexLocker ml(Compile_lock);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1157 if (_replay_data_stream == NULL) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1158 _replay_data_stream = new (ResourceObj::C_HEAP, mtCompiler) fileStream(ReplayDataFile);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1159 if (_replay_data_stream == NULL) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1160 fatal(err_msg("Can't open %s for replay data", ReplayDataFile));
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1161 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1162 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1163 dump_replay_data(_replay_data_stream);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1164 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1165
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1166
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1167 void ciEnv::dump_replay_data(outputStream* out) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1168 ASSERT_IN_VM;
7990 fcc9e7681d63 8006410: allocating without ResourceMark when CompileCommand was specified vlivanov parents: 6985 diff changeset	1169 ResourceMark rm;
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1170 #if INCLUDE_JVMTI
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1171 out->print_cr("JvmtiExport can_access_local_variables %d", _jvmti_can_access_local_variables);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1172 out->print_cr("JvmtiExport can_hotswap_or_post_breakpoint %d", _jvmti_can_hotswap_or_post_breakpoint);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1173 out->print_cr("JvmtiExport can_post_on_exceptions %d", _jvmti_can_post_on_exceptions);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1174 #endif // INCLUDE_JVMTI
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1175
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1176 GrowableArray<ciMetadata> objects = _factory->get_ci_metadata();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1177 out->print_cr("# %d ciObject found", objects->length());
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1178 for (int i = 0; i < objects->length(); i++) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1179 objects->at(i)->dump_replay_data(out);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1180 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1181 Method* method = task()->method();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1182 int entry_bci = task()->osr_bci();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1183 // Klass holder = method->method_holder();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1184 out->print_cr("compile %s %s %s %d",
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1185 method->klass_name()->as_quoted_ascii(),
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1186 method->name()->as_quoted_ascii(),
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1187 method->signature()->as_quoted_ascii(),
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1188 entry_bci);
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1189 out->flush();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6940 diff changeset	1190 }

Mercurial > hg > truffle

annotate src/share/vm/ci/ciEnv.cpp @ 9126:bc26f978b0ce