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

annotate src/share/vm/ci/ciEnv.cpp @ 3762:5c0a3c1858b1

7048782: CMS: assert(last_chunk_index_to_check<= last_chunk_index) failed: parCardTableModRefBS.cpp:359 Summary: The LNC array is sized before the start of a scavenge, while the heap may expand during a scavenge. With CMS, the last block of an arbitrary suffice of the LNC array may expand due to coalition with the expansion delta. We now take care not to attempt access past the end of the LNC array. LNC array code will be cleaned up and suitably encapsulated as part of the forthcoming performance RFE 7043675. Reviewed-by: brutisso

author	ysr
date	Thu, 02 Jun 2011 10:23:36 -0700
parents	08ccee2c4dbf
children	81d815b05abb

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2426 1d1603768966 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass trims parents: 2263 diff changeset	2 * Copyright (c) 1999, 2011, 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/ciInstanceKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	32 #include "ci/ciMethod.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33 #include "ci/ciNullObject.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	34 #include "ci/ciObjArrayKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	35 #include "ci/ciTypeArrayKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	36 #include "ci/ciUtilities.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	37 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	38 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	39 #include "code/scopeDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	40 #include "compiler/compileBroker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	41 #include "compiler/compileLog.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	42 #include "compiler/compilerOracle.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	43 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	44 #include "interpreter/linkResolver.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	45 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	46 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	47 #include "memory/universe.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	48 #include "oops/methodDataOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	49 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	50 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	51 #include "oops/oop.inline2.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	52 #include "prims/jvmtiExport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	53 #include "runtime/init.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	54 #include "runtime/reflection.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	55 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	56 #include "utilities/dtrace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	57 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	58 #include "c1/c1_Runtime1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	59 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	60 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	61 #include "opto/runtime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	62 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	63
a61af66fc99e Initial load duke parents: diff changeset	64 // ciEnv
a61af66fc99e Initial load duke parents: diff changeset	65 //
a61af66fc99e Initial load duke parents: diff changeset	66 // This class is the top level broker for requests from the compiler
a61af66fc99e Initial load duke parents: diff changeset	67 // to the VM.
a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 ciObject* ciEnv::_null_object_instance;
a61af66fc99e Initial load duke parents: diff changeset	70 ciMethodKlass* ciEnv::_method_klass_instance;
a61af66fc99e Initial load duke parents: diff changeset	71 ciKlassKlass* ciEnv::_klass_klass_instance;
a61af66fc99e Initial load duke parents: diff changeset	72 ciInstanceKlassKlass* ciEnv::_instance_klass_klass_instance;
a61af66fc99e Initial load duke parents: diff changeset	73 ciTypeArrayKlassKlass* ciEnv::_type_array_klass_klass_instance;
a61af66fc99e Initial load duke parents: diff changeset	74 ciObjArrayKlassKlass* ciEnv::_obj_array_klass_klass_instance;
a61af66fc99e Initial load duke parents: diff changeset	75
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	76 #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	77 WK_KLASSES_DO(WK_KLASS_DEFN)
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	78 #undef WK_KLASS_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 ciSymbol* ciEnv::_unloaded_cisymbol = NULL;
a61af66fc99e Initial load duke parents: diff changeset	81 ciInstanceKlass* ciEnv::_unloaded_ciinstance_klass = NULL;
a61af66fc99e Initial load duke parents: diff changeset	82 ciObjArrayKlass* ciEnv::_unloaded_ciobjarrayklass = NULL;
a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84 jobject ciEnv::_ArrayIndexOutOfBoundsException_handle = NULL;
a61af66fc99e Initial load duke parents: diff changeset	85 jobject ciEnv::_ArrayStoreException_handle = NULL;
a61af66fc99e Initial load duke parents: diff changeset	86 jobject ciEnv::_ClassCastException_handle = NULL;
a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	89 static bool firstEnv = true;
a61af66fc99e Initial load duke parents: diff changeset	90 #endif /* PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	91
a61af66fc99e Initial load duke parents: diff changeset	92 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	93 // ciEnv::ciEnv
a61af66fc99e Initial load duke parents: diff changeset	94 ciEnv::ciEnv(CompileTask* task, int system_dictionary_modification_counter) {
a61af66fc99e Initial load duke parents: diff changeset	95 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
a61af66fc99e Initial load duke parents: diff changeset	98 thread->set_env(this);
a61af66fc99e Initial load duke parents: diff changeset	99 assert(ciEnv::current() == this, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 _oop_recorder = NULL;
a61af66fc99e Initial load duke parents: diff changeset	102 _debug_info = NULL;
a61af66fc99e Initial load duke parents: diff changeset	103 _dependencies = NULL;
a61af66fc99e Initial load duke parents: diff changeset	104 _failure_reason = NULL;
a61af66fc99e Initial load duke parents: diff changeset	105 _compilable = MethodCompilable;
a61af66fc99e Initial load duke parents: diff changeset	106 _break_at_compile = false;
a61af66fc99e Initial load duke parents: diff changeset	107 _compiler_data = NULL;
a61af66fc99e Initial load duke parents: diff changeset	108 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	109 assert(!firstEnv, "not initialized properly");
a61af66fc99e Initial load duke parents: diff changeset	110 #endif /* !PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	111
a61af66fc99e Initial load duke parents: diff changeset	112 _system_dictionary_modification_counter = system_dictionary_modification_counter;
a61af66fc99e Initial load duke parents: diff changeset	113 _num_inlined_bytecodes = 0;
a61af66fc99e Initial load duke parents: diff changeset	114 assert(task == NULL \|\| thread->task() == task, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	115 _task = task;
a61af66fc99e Initial load duke parents: diff changeset	116 _log = NULL;
a61af66fc99e Initial load duke parents: diff changeset	117
a61af66fc99e Initial load duke parents: diff changeset	118 // Temporary buffer for creating symbols and such.
a61af66fc99e Initial load duke parents: diff changeset	119 _name_buffer = NULL;
a61af66fc99e Initial load duke parents: diff changeset	120 _name_buffer_len = 0;
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 _arena = &_ciEnv_arena;
a61af66fc99e Initial load duke parents: diff changeset	123 _factory = new (_arena) ciObjectFactory(_arena, 128);
a61af66fc99e Initial load duke parents: diff changeset	124
a61af66fc99e Initial load duke parents: diff changeset	125 // Preload commonly referenced system ciObjects.
a61af66fc99e Initial load duke parents: diff changeset	126
a61af66fc99e Initial load duke parents: diff changeset	127 // During VM initialization, these instances have not yet been created.
a61af66fc99e Initial load duke parents: diff changeset	128 // Assertions ensure that these instances are not accessed before
a61af66fc99e Initial load duke parents: diff changeset	129 // their initialization.
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 assert(Universe::is_fully_initialized(), "should be complete");
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 oop o = Universe::null_ptr_exception_instance();
a61af66fc99e Initial load duke parents: diff changeset	134 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load duke parents: diff changeset	135 _NullPointerException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load duke parents: diff changeset	136 o = Universe::arithmetic_exception_instance();
a61af66fc99e Initial load duke parents: diff changeset	137 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load duke parents: diff changeset	138 _ArithmeticException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load duke parents: diff changeset	139
a61af66fc99e Initial load duke parents: diff changeset	140 _ArrayIndexOutOfBoundsException_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	141 _ArrayStoreException_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	142 _ClassCastException_instance = NULL;
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	143 _the_null_string = NULL;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	144 _the_min_jint_string = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	145 }
a61af66fc99e Initial load duke parents: diff changeset	146
a61af66fc99e Initial load duke parents: diff changeset	147 ciEnv::ciEnv(Arena* arena) {
a61af66fc99e Initial load duke parents: diff changeset	148 ASSERT_IN_VM;
a61af66fc99e Initial load duke parents: diff changeset	149
a61af66fc99e Initial load duke parents: diff changeset	150 // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
a61af66fc99e Initial load duke parents: diff changeset	151 CompilerThread* current_thread = CompilerThread::current();
a61af66fc99e Initial load duke parents: diff changeset	152 assert(current_thread->env() == NULL, "must be");
a61af66fc99e Initial load duke parents: diff changeset	153 current_thread->set_env(this);
a61af66fc99e Initial load duke parents: diff changeset	154 assert(ciEnv::current() == this, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 _oop_recorder = NULL;
a61af66fc99e Initial load duke parents: diff changeset	157 _debug_info = NULL;
a61af66fc99e Initial load duke parents: diff changeset	158 _dependencies = NULL;
a61af66fc99e Initial load duke parents: diff changeset	159 _failure_reason = NULL;
a61af66fc99e Initial load duke parents: diff changeset	160 _compilable = MethodCompilable_never;
a61af66fc99e Initial load duke parents: diff changeset	161 _break_at_compile = false;
a61af66fc99e Initial load duke parents: diff changeset	162 _compiler_data = NULL;
a61af66fc99e Initial load duke parents: diff changeset	163 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	164 assert(firstEnv, "must be first");
a61af66fc99e Initial load duke parents: diff changeset	165 firstEnv = false;
a61af66fc99e Initial load duke parents: diff changeset	166 #endif /* !PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 _system_dictionary_modification_counter = 0;
a61af66fc99e Initial load duke parents: diff changeset	169 _num_inlined_bytecodes = 0;
a61af66fc99e Initial load duke parents: diff changeset	170 _task = NULL;
a61af66fc99e Initial load duke parents: diff changeset	171 _log = NULL;
a61af66fc99e Initial load duke parents: diff changeset	172
a61af66fc99e Initial load duke parents: diff changeset	173 // Temporary buffer for creating symbols and such.
a61af66fc99e Initial load duke parents: diff changeset	174 _name_buffer = NULL;
a61af66fc99e Initial load duke parents: diff changeset	175 _name_buffer_len = 0;
a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177 _arena = arena;
a61af66fc99e Initial load duke parents: diff changeset	178 _factory = new (_arena) ciObjectFactory(_arena, 128);
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 // Preload commonly referenced system ciObjects.
a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182 // During VM initialization, these instances have not yet been created.
a61af66fc99e Initial load duke parents: diff changeset	183 // Assertions ensure that these instances are not accessed before
a61af66fc99e Initial load duke parents: diff changeset	184 // their initialization.
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 assert(Universe::is_fully_initialized(), "must be");
a61af66fc99e Initial load duke parents: diff changeset	187
a61af66fc99e Initial load duke parents: diff changeset	188 oop o = Universe::null_ptr_exception_instance();
a61af66fc99e Initial load duke parents: diff changeset	189 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load duke parents: diff changeset	190 _NullPointerException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load duke parents: diff changeset	191 o = Universe::arithmetic_exception_instance();
a61af66fc99e Initial load duke parents: diff changeset	192 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load duke parents: diff changeset	193 _ArithmeticException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195 _ArrayIndexOutOfBoundsException_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	196 _ArrayStoreException_instance = NULL;
a61af66fc99e Initial load duke parents: diff changeset	197 _ClassCastException_instance = NULL;
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	198 _the_null_string = NULL;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	199 _the_min_jint_string = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	200 }
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 ciEnv::~ciEnv() {
a61af66fc99e Initial load duke parents: diff changeset	203 CompilerThread* current_thread = CompilerThread::current();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	204 _factory->remove_symbols();
0 a61af66fc99e Initial load duke parents: diff changeset	205 current_thread->set_env(NULL);
a61af66fc99e Initial load duke parents: diff changeset	206 }
a61af66fc99e Initial load duke parents: diff changeset	207
a61af66fc99e Initial load duke parents: diff changeset	208 // ------------------------------------------------------------------
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	209 // 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	210 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	211 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	212 // 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	213 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	214 _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	215 _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	216 _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	217 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	218
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	219 // ------------------------------------------------------------------
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	220 // 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	221 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	222 // Need lock?
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	223 _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	224 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	225 _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	226 _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	227 _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	228 } else {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	229 _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	230 _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	231 _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	232 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	233 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	234
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	235 // ------------------------------------------------------------------
0 a61af66fc99e Initial load duke parents: diff changeset	236 // helper for lazy exception creation
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	237 ciInstance* ciEnv::get_or_create_exception(jobject& handle, Symbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	238 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	239 if (handle == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	240 // Cf. universe.cpp, creation of Universe::_null_ptr_exception_instance.
a61af66fc99e Initial load duke parents: diff changeset	241 klassOop k = SystemDictionary::find(name, Handle(), Handle(), THREAD);
a61af66fc99e Initial load duke parents: diff changeset	242 jobject objh = NULL;
a61af66fc99e Initial load duke parents: diff changeset	243 if (!HAS_PENDING_EXCEPTION && k != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	244 oop obj = instanceKlass::cast(k)->allocate_permanent_instance(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	245 if (!HAS_PENDING_EXCEPTION)
a61af66fc99e Initial load duke parents: diff changeset	246 objh = JNIHandles::make_global(obj);
a61af66fc99e Initial load duke parents: diff changeset	247 }
a61af66fc99e Initial load duke parents: diff changeset	248 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	249 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	250 } else {
a61af66fc99e Initial load duke parents: diff changeset	251 handle = objh;
a61af66fc99e Initial load duke parents: diff changeset	252 }
a61af66fc99e Initial load duke parents: diff changeset	253 }
a61af66fc99e Initial load duke parents: diff changeset	254 oop obj = JNIHandles::resolve(handle);
a61af66fc99e Initial load duke parents: diff changeset	255 return obj == NULL? NULL: get_object(obj)->as_instance();
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257
a61af66fc99e Initial load duke parents: diff changeset	258 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	259 // ciEnv::ArrayIndexOutOfBoundsException_instance, etc.
a61af66fc99e Initial load duke parents: diff changeset	260 ciInstance* ciEnv::ArrayIndexOutOfBoundsException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	261 if (_ArrayIndexOutOfBoundsException_instance == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	262 _ArrayIndexOutOfBoundsException_instance
a61af66fc99e Initial load duke parents: diff changeset	263 = get_or_create_exception(_ArrayIndexOutOfBoundsException_handle,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	264 vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
0 a61af66fc99e Initial load duke parents: diff changeset	265 }
a61af66fc99e Initial load duke parents: diff changeset	266 return _ArrayIndexOutOfBoundsException_instance;
a61af66fc99e Initial load duke parents: diff changeset	267 }
a61af66fc99e Initial load duke parents: diff changeset	268 ciInstance* ciEnv::ArrayStoreException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	269 if (_ArrayStoreException_instance == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	270 _ArrayStoreException_instance
a61af66fc99e Initial load duke parents: diff changeset	271 = get_or_create_exception(_ArrayStoreException_handle,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	272 vmSymbols::java_lang_ArrayStoreException());
0 a61af66fc99e Initial load duke parents: diff changeset	273 }
a61af66fc99e Initial load duke parents: diff changeset	274 return _ArrayStoreException_instance;
a61af66fc99e Initial load duke parents: diff changeset	275 }
a61af66fc99e Initial load duke parents: diff changeset	276 ciInstance* ciEnv::ClassCastException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	277 if (_ClassCastException_instance == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	278 _ClassCastException_instance
a61af66fc99e Initial load duke parents: diff changeset	279 = get_or_create_exception(_ClassCastException_handle,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	280 vmSymbols::java_lang_ClassCastException());
0 a61af66fc99e Initial load duke parents: diff changeset	281 }
a61af66fc99e Initial load duke parents: diff changeset	282 return _ClassCastException_instance;
a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	285 ciInstance* ciEnv::the_null_string() {
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	286 if (_the_null_string == NULL) {
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	287 VM_ENTRY_MARK;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	288 _the_null_string = get_object(Universe::the_null_string())->as_instance();
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	289 }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	290 return _the_null_string;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	291 }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	292
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	293 ciInstance* ciEnv::the_min_jint_string() {
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	294 if (_the_min_jint_string == NULL) {
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	295 VM_ENTRY_MARK;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	296 _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	297 }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	298 return _the_min_jint_string;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	299 }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1059 diff changeset	300
0 a61af66fc99e Initial load duke parents: diff changeset	301 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	302 // ciEnv::get_method_from_handle
a61af66fc99e Initial load duke parents: diff changeset	303 ciMethod* ciEnv::get_method_from_handle(jobject method) {
a61af66fc99e Initial load duke parents: diff changeset	304 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	305 return get_object(JNIHandles::resolve(method))->as_method();
a61af66fc99e Initial load duke parents: diff changeset	306 }
a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	309 // ciEnv::make_array
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 844 diff changeset	310 ciArray* ciEnv::make_system_array(GrowableArray<ciObject> objects) {
0 a61af66fc99e Initial load duke parents: diff changeset	311 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	312 int length = objects->length();
a61af66fc99e Initial load duke parents: diff changeset	313 objArrayOop a = oopFactory::new_system_objArray(length, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	314 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	315 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	316 record_out_of_memory_failure();
a61af66fc99e Initial load duke parents: diff changeset	317 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	318 }
a61af66fc99e Initial load duke parents: diff changeset	319 for (int i = 0; i < length; i++) {
a61af66fc99e Initial load duke parents: diff changeset	320 a->obj_at_put(i, objects->at(i)->get_oop());
a61af66fc99e Initial load duke parents: diff changeset	321 }
a61af66fc99e Initial load duke parents: diff changeset	322 assert(a->is_perm(), "");
a61af66fc99e Initial load duke parents: diff changeset	323 return get_object(a)->as_array();
a61af66fc99e Initial load duke parents: diff changeset	324 }
a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	328 // ciEnv::array_element_offset_in_bytes
a61af66fc99e Initial load duke parents: diff changeset	329 int ciEnv::array_element_offset_in_bytes(ciArray* a_h, ciObject* o_h) {
a61af66fc99e Initial load duke parents: diff changeset	330 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	331 objArrayOop a = (objArrayOop)a_h->get_oop();
a61af66fc99e Initial load duke parents: diff changeset	332 assert(a->is_objArray(), "");
a61af66fc99e Initial load duke parents: diff changeset	333 int length = a->length();
a61af66fc99e Initial load duke parents: diff changeset	334 oop o = o_h->get_oop();
a61af66fc99e Initial load duke parents: diff changeset	335 for (int i = 0; i < length; i++) {
a61af66fc99e Initial load duke parents: diff changeset	336 if (a->obj_at(i) == o) return i;
a61af66fc99e Initial load duke parents: diff changeset	337 }
a61af66fc99e Initial load duke parents: diff changeset	338 return -1;
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 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	343 // ciEnv::check_klass_accessiblity
a61af66fc99e Initial load duke parents: diff changeset	344 //
a61af66fc99e Initial load duke parents: diff changeset	345 // Note: the logic of this method should mirror the logic of
a61af66fc99e Initial load duke parents: diff changeset	346 // constantPoolOopDesc::verify_constant_pool_resolve.
a61af66fc99e Initial load duke parents: diff changeset	347 bool ciEnv::check_klass_accessibility(ciKlass* accessing_klass,
a61af66fc99e Initial load duke parents: diff changeset	348 klassOop resolved_klass) {
a61af66fc99e Initial load duke parents: diff changeset	349 if (accessing_klass == NULL \|\| !accessing_klass->is_loaded()) {
a61af66fc99e Initial load duke parents: diff changeset	350 return true;
a61af66fc99e Initial load duke parents: diff changeset	351 }
a61af66fc99e Initial load duke parents: diff changeset	352 if (accessing_klass->is_obj_array()) {
a61af66fc99e Initial load duke parents: diff changeset	353 accessing_klass = accessing_klass->as_obj_array_klass()->base_element_klass();
a61af66fc99e Initial load duke parents: diff changeset	354 }
a61af66fc99e Initial load duke parents: diff changeset	355 if (!accessing_klass->is_instance_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	356 return true;
a61af66fc99e Initial load duke parents: diff changeset	357 }
a61af66fc99e Initial load duke parents: diff changeset	358
a61af66fc99e Initial load duke parents: diff changeset	359 if (resolved_klass->klass_part()->oop_is_objArray()) {
a61af66fc99e Initial load duke parents: diff changeset	360 // Find the element klass, if this is an array.
a61af66fc99e Initial load duke parents: diff changeset	361 resolved_klass = objArrayKlass::cast(resolved_klass)->bottom_klass();
a61af66fc99e Initial load duke parents: diff changeset	362 }
a61af66fc99e Initial load duke parents: diff changeset	363 if (resolved_klass->klass_part()->oop_is_instance()) {
a61af66fc99e Initial load duke parents: diff changeset	364 return Reflection::verify_class_access(accessing_klass->get_klassOop(),
a61af66fc99e Initial load duke parents: diff changeset	365 resolved_klass,
a61af66fc99e Initial load duke parents: diff changeset	366 true);
a61af66fc99e Initial load duke parents: diff changeset	367 }
a61af66fc99e Initial load duke parents: diff changeset	368 return true;
a61af66fc99e Initial load duke parents: diff changeset	369 }
a61af66fc99e Initial load duke parents: diff changeset	370
a61af66fc99e Initial load duke parents: diff changeset	371 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	372 // ciEnv::get_klass_by_name_impl
a61af66fc99e Initial load duke parents: diff changeset	373 ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,
a61af66fc99e Initial load duke parents: diff changeset	374 ciSymbol* name,
a61af66fc99e Initial load duke parents: diff changeset	375 bool require_local) {
a61af66fc99e Initial load duke parents: diff changeset	376 ASSERT_IN_VM;
a61af66fc99e Initial load duke parents: diff changeset	377 EXCEPTION_CONTEXT;
a61af66fc99e Initial load duke parents: diff changeset	378
a61af66fc99e Initial load duke parents: diff changeset	379 // Now we need to check the SystemDictionary
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	380 Symbol* sym = name->get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	381 if (sym->byte_at(0) == 'L' &&
a61af66fc99e Initial load duke parents: diff changeset	382 sym->byte_at(sym->utf8_length()-1) == ';') {
a61af66fc99e Initial load duke parents: diff changeset	383 // 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	384 // Call recursive to keep scope of strippedsym.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	385 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	386 sym->utf8_length()-2,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	387 KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	388 ciSymbol* strippedname = get_symbol(strippedsym);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	389 return get_klass_by_name_impl(accessing_klass, strippedname, require_local);
0 a61af66fc99e Initial load duke parents: diff changeset	390 }
a61af66fc99e Initial load duke parents: diff changeset	391
a61af66fc99e Initial load duke parents: diff changeset	392 // Check for prior unloaded klass. The SystemDictionary's answers
a61af66fc99e Initial load duke parents: diff changeset	393 // can vary over time but the compiler needs consistency.
a61af66fc99e Initial load duke parents: diff changeset	394 ciKlass* unloaded_klass = check_get_unloaded_klass(accessing_klass, name);
a61af66fc99e Initial load duke parents: diff changeset	395 if (unloaded_klass != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	396 if (require_local) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	397 return unloaded_klass;
a61af66fc99e Initial load duke parents: diff changeset	398 }
a61af66fc99e Initial load duke parents: diff changeset	399
a61af66fc99e Initial load duke parents: diff changeset	400 Handle loader(THREAD, (oop)NULL);
a61af66fc99e Initial load duke parents: diff changeset	401 Handle domain(THREAD, (oop)NULL);
a61af66fc99e Initial load duke parents: diff changeset	402 if (accessing_klass != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	403 loader = Handle(THREAD, accessing_klass->loader());
a61af66fc99e Initial load duke parents: diff changeset	404 domain = Handle(THREAD, accessing_klass->protection_domain());
a61af66fc99e Initial load duke parents: diff changeset	405 }
a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 // setup up the proper type to return on OOM
a61af66fc99e Initial load duke parents: diff changeset	408 ciKlass* fail_type;
a61af66fc99e Initial load duke parents: diff changeset	409 if (sym->byte_at(0) == '[') {
a61af66fc99e Initial load duke parents: diff changeset	410 fail_type = _unloaded_ciobjarrayklass;
a61af66fc99e Initial load duke parents: diff changeset	411 } else {
a61af66fc99e Initial load duke parents: diff changeset	412 fail_type = _unloaded_ciinstance_klass;
a61af66fc99e Initial load duke parents: diff changeset	413 }
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 1972 diff changeset	414 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	415 {
2263 5841dc1964f0 7021531: lock ordering problems after fix for 6354181 never parents: 2244 diff changeset	416 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	417 MutexLocker ml(Compile_lock);
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	418 klassOop kls;
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	419 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	420 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	421 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	422 } else {
4f26f535a225 6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111" never parents: 2177 diff changeset	423 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	424 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	425 }
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 1972 diff changeset	426 found_klass = KlassHandle(THREAD, kls);
0 a61af66fc99e Initial load duke parents: diff changeset	427 }
a61af66fc99e Initial load duke parents: diff changeset	428
a61af66fc99e Initial load duke parents: diff changeset	429 // If we fail to find an array klass, look again for its element type.
a61af66fc99e Initial load duke parents: diff changeset	430 // The element type may be available either locally or via constraints.
a61af66fc99e Initial load duke parents: diff changeset	431 // In either case, if we can find the element type in the system dictionary,
a61af66fc99e Initial load duke parents: diff changeset	432 // we must build an array type around it. The CI requires array klasses
a61af66fc99e Initial load duke parents: diff changeset	433 // to be loaded if their element klasses are loaded, except when memory
a61af66fc99e Initial load duke parents: diff changeset	434 // is exhausted.
a61af66fc99e Initial load duke parents: diff changeset	435 if (sym->byte_at(0) == '[' &&
a61af66fc99e Initial load duke parents: diff changeset	436 (sym->byte_at(1) == '[' \|\| sym->byte_at(1) == 'L')) {
a61af66fc99e Initial load duke parents: diff changeset	437 // We have an unloaded array.
a61af66fc99e Initial load duke parents: diff changeset	438 // 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	439 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	440 sym->utf8_length()-1,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	441 KILL_COMPILE_ON_FATAL_(fail_type));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	442
0 a61af66fc99e Initial load duke parents: diff changeset	443 // Get element ciKlass recursively.
a61af66fc99e Initial load duke parents: diff changeset	444 ciKlass* elem_klass =
a61af66fc99e Initial load duke parents: diff changeset	445 get_klass_by_name_impl(accessing_klass,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	446 get_symbol(elem_sym),
0 a61af66fc99e Initial load duke parents: diff changeset	447 require_local);
a61af66fc99e Initial load duke parents: diff changeset	448 if (elem_klass != NULL && elem_klass->is_loaded()) {
a61af66fc99e Initial load duke parents: diff changeset	449 // Now make an array for it
a61af66fc99e Initial load duke parents: diff changeset	450 return ciObjArrayKlass::make_impl(elem_klass);
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452 }
a61af66fc99e Initial load duke parents: diff changeset	453
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 1972 diff changeset	454 if (found_klass() != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	455 // Found it. Build a CI handle.
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 1972 diff changeset	456 return get_object(found_klass())->as_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	457 }
a61af66fc99e Initial load duke parents: diff changeset	458
a61af66fc99e Initial load duke parents: diff changeset	459 if (require_local) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	460 // Not yet loaded into the VM, or not governed by loader constraints.
a61af66fc99e Initial load duke parents: diff changeset	461 // Make a CI representative for it.
a61af66fc99e Initial load duke parents: diff changeset	462 return get_unloaded_klass(accessing_klass, name);
a61af66fc99e Initial load duke parents: diff changeset	463 }
a61af66fc99e Initial load duke parents: diff changeset	464
a61af66fc99e Initial load duke parents: diff changeset	465 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	466 // ciEnv::get_klass_by_name
a61af66fc99e Initial load duke parents: diff changeset	467 ciKlass* ciEnv::get_klass_by_name(ciKlass* accessing_klass,
a61af66fc99e Initial load duke parents: diff changeset	468 ciSymbol* klass_name,
a61af66fc99e Initial load duke parents: diff changeset	469 bool require_local) {
a61af66fc99e Initial load duke parents: diff changeset	470 GUARDED_VM_ENTRY(return get_klass_by_name_impl(accessing_klass,
a61af66fc99e Initial load duke parents: diff changeset	471 klass_name,
a61af66fc99e Initial load duke parents: diff changeset	472 require_local);)
a61af66fc99e Initial load duke parents: diff changeset	473 }
a61af66fc99e Initial load duke parents: diff changeset	474
a61af66fc99e Initial load duke parents: diff changeset	475 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	476 // ciEnv::get_klass_by_index_impl
a61af66fc99e Initial load duke parents: diff changeset	477 //
a61af66fc99e Initial load duke parents: diff changeset	478 // Implementation of get_klass_by_index.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	479 ciKlass* ciEnv::get_klass_by_index_impl(constantPoolHandle cpool,
0 a61af66fc99e Initial load duke parents: diff changeset	480 int index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	481 bool& is_accessible,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	482 ciInstanceKlass* accessor) {
0 a61af66fc99e Initial load duke parents: diff changeset	483 EXCEPTION_CONTEXT;
a61af66fc99e Initial load duke parents: diff changeset	484 KlassHandle klass (THREAD, constantPoolOopDesc::klass_at_if_loaded(cpool, index));
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	485 Symbol* klass_name = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	486 if (klass.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	487 // The klass has not been inserted into the constant pool.
a61af66fc99e Initial load duke parents: diff changeset	488 // Try to look it up by name.
a61af66fc99e Initial load duke parents: diff changeset	489 {
a61af66fc99e Initial load duke parents: diff changeset	490 // We have to lock the cpool to keep the oop from being resolved
a61af66fc99e Initial load duke parents: diff changeset	491 // while we are accessing it.
a61af66fc99e Initial load duke parents: diff changeset	492 ObjectLocker ol(cpool, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	493
a61af66fc99e Initial load duke parents: diff changeset	494 constantTag tag = cpool->tag_at(index);
a61af66fc99e Initial load duke parents: diff changeset	495 if (tag.is_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	496 // The klass has been inserted into the constant pool
a61af66fc99e Initial load duke parents: diff changeset	497 // very recently.
a61af66fc99e Initial load duke parents: diff changeset	498 klass = KlassHandle(THREAD, cpool->resolved_klass_at(index));
a61af66fc99e Initial load duke parents: diff changeset	499 } else if (tag.is_symbol()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	500 klass_name = cpool->symbol_at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	501 } else {
a61af66fc99e Initial load duke parents: diff changeset	502 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	503 klass_name = cpool->unresolved_klass_at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	504 }
a61af66fc99e Initial load duke parents: diff changeset	505 }
a61af66fc99e Initial load duke parents: diff changeset	506 }
a61af66fc99e Initial load duke parents: diff changeset	507
a61af66fc99e Initial load duke parents: diff changeset	508 if (klass.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	509 // Not found in constant pool. Use the name to do the lookup.
a61af66fc99e Initial load duke parents: diff changeset	510 ciKlass* k = get_klass_by_name_impl(accessor,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	511 get_symbol(klass_name),
0 a61af66fc99e Initial load duke parents: diff changeset	512 false);
a61af66fc99e Initial load duke parents: diff changeset	513 // Calculate accessibility the hard way.
a61af66fc99e Initial load duke parents: diff changeset	514 if (!k->is_loaded()) {
a61af66fc99e Initial load duke parents: diff changeset	515 is_accessible = false;
a61af66fc99e Initial load duke parents: diff changeset	516 } else if (k->loader() != accessor->loader() &&
a61af66fc99e Initial load duke parents: diff changeset	517 get_klass_by_name_impl(accessor, k->name(), true) == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	518 // Loaded only remotely. Not linked yet.
a61af66fc99e Initial load duke parents: diff changeset	519 is_accessible = false;
a61af66fc99e Initial load duke parents: diff changeset	520 } else {
a61af66fc99e Initial load duke parents: diff changeset	521 // Linked locally, and we must also check public/private, etc.
a61af66fc99e Initial load duke parents: diff changeset	522 is_accessible = check_klass_accessibility(accessor, k->get_klassOop());
a61af66fc99e Initial load duke parents: diff changeset	523 }
a61af66fc99e Initial load duke parents: diff changeset	524 return k;
a61af66fc99e Initial load duke parents: diff changeset	525 }
a61af66fc99e Initial load duke parents: diff changeset	526
a61af66fc99e Initial load duke parents: diff changeset	527 // Check for prior unloaded klass. The SystemDictionary's answers
a61af66fc99e Initial load duke parents: diff changeset	528 // can vary over time but the compiler needs consistency.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	529 ciSymbol* name = get_symbol(klass()->klass_part()->name());
0 a61af66fc99e Initial load duke parents: diff changeset	530 ciKlass* unloaded_klass = check_get_unloaded_klass(accessor, name);
a61af66fc99e Initial load duke parents: diff changeset	531 if (unloaded_klass != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	532 is_accessible = false;
a61af66fc99e Initial load duke parents: diff changeset	533 return unloaded_klass;
a61af66fc99e Initial load duke parents: diff changeset	534 }
a61af66fc99e Initial load duke parents: diff changeset	535
a61af66fc99e Initial load duke parents: diff changeset	536 // It is known to be accessible, since it was found in the constant pool.
a61af66fc99e Initial load duke parents: diff changeset	537 is_accessible = true;
a61af66fc99e Initial load duke parents: diff changeset	538 return get_object(klass())->as_klass();
a61af66fc99e Initial load duke parents: diff changeset	539 }
a61af66fc99e Initial load duke parents: diff changeset	540
a61af66fc99e Initial load duke parents: diff changeset	541 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	542 // ciEnv::get_klass_by_index
a61af66fc99e Initial load duke parents: diff changeset	543 //
a61af66fc99e Initial load duke parents: diff changeset	544 // Get a klass from the constant pool.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	545 ciKlass* ciEnv::get_klass_by_index(constantPoolHandle cpool,
0 a61af66fc99e Initial load duke parents: diff changeset	546 int index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	547 bool& is_accessible,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	548 ciInstanceKlass* accessor) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	549 GUARDED_VM_ENTRY(return get_klass_by_index_impl(cpool, index, is_accessible, accessor);)
0 a61af66fc99e Initial load duke parents: diff changeset	550 }
a61af66fc99e Initial load duke parents: diff changeset	551
a61af66fc99e Initial load duke parents: diff changeset	552 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	553 // ciEnv::get_constant_by_index_impl
a61af66fc99e Initial load duke parents: diff changeset	554 //
a61af66fc99e Initial load duke parents: diff changeset	555 // Implementation of get_constant_by_index().
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	556 ciConstant ciEnv::get_constant_by_index_impl(constantPoolHandle cpool,
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	557 int pool_index, int cache_index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	558 ciInstanceKlass* accessor) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	559 bool ignore_will_link;
0 a61af66fc99e Initial load duke parents: diff changeset	560 EXCEPTION_CONTEXT;
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	561 int index = pool_index;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	562 if (cache_index >= 0) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	563 assert(index < 0, "only one kind of index at a time");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	564 ConstantPoolCacheEntry* cpc_entry = cpool->cache()->entry_at(cache_index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	565 index = cpc_entry->constant_pool_index();
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	566 oop obj = cpc_entry->f1();
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	567 if (obj != NULL) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	568 assert(obj->is_instance(), "must be an instance");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	569 ciObject* ciobj = get_object(obj);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	570 return ciConstant(T_OBJECT, ciobj);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	571 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	572 }
0 a61af66fc99e Initial load duke parents: diff changeset	573 constantTag tag = cpool->tag_at(index);
a61af66fc99e Initial load duke parents: diff changeset	574 if (tag.is_int()) {
a61af66fc99e Initial load duke parents: diff changeset	575 return ciConstant(T_INT, (jint)cpool->int_at(index));
a61af66fc99e Initial load duke parents: diff changeset	576 } else if (tag.is_long()) {
a61af66fc99e Initial load duke parents: diff changeset	577 return ciConstant((jlong)cpool->long_at(index));
a61af66fc99e Initial load duke parents: diff changeset	578 } else if (tag.is_float()) {
a61af66fc99e Initial load duke parents: diff changeset	579 return ciConstant((jfloat)cpool->float_at(index));
a61af66fc99e Initial load duke parents: diff changeset	580 } else if (tag.is_double()) {
a61af66fc99e Initial load duke parents: diff changeset	581 return ciConstant((jdouble)cpool->double_at(index));
a61af66fc99e Initial load duke parents: diff changeset	582 } else if (tag.is_string() \|\| tag.is_unresolved_string()) {
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	583 oop string = NULL;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	584 if (cpool->is_pseudo_string_at(index)) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	585 string = cpool->pseudo_string_at(index);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	586 } else {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	587 string = cpool->string_at(index, THREAD);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	588 if (HAS_PENDING_EXCEPTION) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	589 CLEAR_PENDING_EXCEPTION;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	590 record_out_of_memory_failure();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	591 return ciConstant();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 0 diff changeset	592 }
0 a61af66fc99e Initial load duke parents: diff changeset	593 }
a61af66fc99e Initial load duke parents: diff changeset	594 ciObject* constant = get_object(string);
a61af66fc99e Initial load duke parents: diff changeset	595 assert (constant->is_instance(), "must be an instance, or not? ");
a61af66fc99e Initial load duke parents: diff changeset	596 return ciConstant(T_OBJECT, constant);
a61af66fc99e Initial load duke parents: diff changeset	597 } else if (tag.is_klass() \|\| tag.is_unresolved_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	598 // 4881222: allow ldc to take a class type
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	599 ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore_will_link, accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	600 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	601 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	602 record_out_of_memory_failure();
a61af66fc99e Initial load duke parents: diff changeset	603 return ciConstant();
a61af66fc99e Initial load duke parents: diff changeset	604 }
a61af66fc99e Initial load duke parents: diff changeset	605 assert (klass->is_instance_klass() \|\| klass->is_array_klass(),
a61af66fc99e Initial load duke parents: diff changeset	606 "must be an instance or array klass ");
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	607 return ciConstant(T_OBJECT, klass->java_mirror());
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	608 } else if (tag.is_object()) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	609 oop obj = cpool->object_at(index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	610 assert(obj->is_instance(), "must be an instance");
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	611 ciObject* ciobj = get_object(obj);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	612 return ciConstant(T_OBJECT, ciobj);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	613 } else if (tag.is_method_type()) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	614 // 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	615 ciSymbol* signature = get_symbol(cpool->method_type_signature_at(index));
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	616 ciObject* ciobj = get_unloaded_method_type_constant(signature);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	617 return ciConstant(T_OBJECT, ciobj);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	618 } else if (tag.is_method_handle()) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	619 // 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	620 int ref_kind = cpool->method_handle_ref_kind_at(index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	621 int callee_index = cpool->method_handle_klass_index_at(index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	622 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	623 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	624 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	625 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	626 return ciConstant(T_OBJECT, ciobj);
0 a61af66fc99e Initial load duke parents: diff changeset	627 } else {
a61af66fc99e Initial load duke parents: diff changeset	628 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	629 return ciConstant();
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 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	634 // ciEnv::get_constant_by_index
a61af66fc99e Initial load duke parents: diff changeset	635 //
a61af66fc99e Initial load duke parents: diff changeset	636 // Pull a constant out of the constant pool. How appropriate.
a61af66fc99e Initial load duke parents: diff changeset	637 //
a61af66fc99e Initial load duke parents: diff changeset	638 // 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	639 ciConstant ciEnv::get_constant_by_index(constantPoolHandle cpool,
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	640 int pool_index, int cache_index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	641 ciInstanceKlass* accessor) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	642 GUARDED_VM_ENTRY(return get_constant_by_index_impl(cpool, pool_index, cache_index, accessor);)
0 a61af66fc99e Initial load duke parents: diff changeset	643 }
a61af66fc99e Initial load duke parents: diff changeset	644
a61af66fc99e Initial load duke parents: diff changeset	645 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	646 // ciEnv::get_field_by_index_impl
a61af66fc99e Initial load duke parents: diff changeset	647 //
a61af66fc99e Initial load duke parents: diff changeset	648 // Implementation of get_field_by_index.
a61af66fc99e Initial load duke parents: diff changeset	649 //
a61af66fc99e Initial load duke parents: diff changeset	650 // Implementation note: the results of field lookups are cached
a61af66fc99e Initial load duke parents: diff changeset	651 // in the accessor klass.
a61af66fc99e Initial load duke parents: diff changeset	652 ciField* ciEnv::get_field_by_index_impl(ciInstanceKlass* accessor,
a61af66fc99e Initial load duke parents: diff changeset	653 int index) {
a61af66fc99e Initial load duke parents: diff changeset	654 ciConstantPoolCache* cache = accessor->field_cache();
a61af66fc99e Initial load duke parents: diff changeset	655 if (cache == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	656 ciField* field = new (arena()) ciField(accessor, index);
a61af66fc99e Initial load duke parents: diff changeset	657 return field;
a61af66fc99e Initial load duke parents: diff changeset	658 } else {
a61af66fc99e Initial load duke parents: diff changeset	659 ciField* field = (ciField*)cache->get(index);
a61af66fc99e Initial load duke parents: diff changeset	660 if (field == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	661 field = new (arena()) ciField(accessor, index);
a61af66fc99e Initial load duke parents: diff changeset	662 cache->insert(index, field);
a61af66fc99e Initial load duke parents: diff changeset	663 }
a61af66fc99e Initial load duke parents: diff changeset	664 return field;
a61af66fc99e Initial load duke parents: diff changeset	665 }
a61af66fc99e Initial load duke parents: diff changeset	666 }
a61af66fc99e Initial load duke parents: diff changeset	667
a61af66fc99e Initial load duke parents: diff changeset	668 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	669 // ciEnv::get_field_by_index
a61af66fc99e Initial load duke parents: diff changeset	670 //
a61af66fc99e Initial load duke parents: diff changeset	671 // Get a field by index from a klass's constant pool.
a61af66fc99e Initial load duke parents: diff changeset	672 ciField* ciEnv::get_field_by_index(ciInstanceKlass* accessor,
a61af66fc99e Initial load duke parents: diff changeset	673 int index) {
a61af66fc99e Initial load duke parents: diff changeset	674 GUARDED_VM_ENTRY(return get_field_by_index_impl(accessor, index);)
a61af66fc99e Initial load duke parents: diff changeset	675 }
a61af66fc99e Initial load duke parents: diff changeset	676
a61af66fc99e Initial load duke parents: diff changeset	677 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	678 // ciEnv::lookup_method
a61af66fc99e Initial load duke parents: diff changeset	679 //
a61af66fc99e Initial load duke parents: diff changeset	680 // Perform an appropriate method lookup based on accessor, holder,
a61af66fc99e Initial load duke parents: diff changeset	681 // name, signature, and bytecode.
a61af66fc99e Initial load duke parents: diff changeset	682 methodOop ciEnv::lookup_method(instanceKlass* accessor,
a61af66fc99e Initial load duke parents: diff changeset	683 instanceKlass* holder,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	684 Symbol* name,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	685 Symbol* sig,
0 a61af66fc99e Initial load duke parents: diff changeset	686 Bytecodes::Code bc) {
a61af66fc99e Initial load duke parents: diff changeset	687 EXCEPTION_CONTEXT;
a61af66fc99e Initial load duke parents: diff changeset	688 KlassHandle h_accessor(THREAD, accessor);
a61af66fc99e Initial load duke parents: diff changeset	689 KlassHandle h_holder(THREAD, holder);
a61af66fc99e Initial load duke parents: diff changeset	690 LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL));
a61af66fc99e Initial load duke parents: diff changeset	691 methodHandle dest_method;
a61af66fc99e Initial load duke parents: diff changeset	692 switch (bc) {
a61af66fc99e Initial load duke parents: diff changeset	693 case Bytecodes::_invokestatic:
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::resolve_static_call_or_null(h_holder, name, sig, h_accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	696 break;
a61af66fc99e Initial load duke parents: diff changeset	697 case Bytecodes::_invokespecial:
a61af66fc99e Initial load duke parents: diff changeset	698 dest_method =
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	699 LinkResolver::resolve_special_call_or_null(h_holder, name, sig, h_accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	700 break;
a61af66fc99e Initial load duke parents: diff changeset	701 case Bytecodes::_invokeinterface:
a61af66fc99e Initial load duke parents: diff changeset	702 dest_method =
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	703 LinkResolver::linktime_resolve_interface_method_or_null(h_holder, name, sig,
0 a61af66fc99e Initial load duke parents: diff changeset	704 h_accessor, true);
a61af66fc99e Initial load duke parents: diff changeset	705 break;
a61af66fc99e Initial load duke parents: diff changeset	706 case Bytecodes::_invokevirtual:
a61af66fc99e Initial load duke parents: diff changeset	707 dest_method =
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	708 LinkResolver::linktime_resolve_virtual_method_or_null(h_holder, name, sig,
0 a61af66fc99e Initial load duke parents: diff changeset	709 h_accessor, true);
a61af66fc99e Initial load duke parents: diff changeset	710 break;
a61af66fc99e Initial load duke parents: diff changeset	711 default: ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	712 }
a61af66fc99e Initial load duke parents: diff changeset	713
a61af66fc99e Initial load duke parents: diff changeset	714 return dest_method();
a61af66fc99e Initial load duke parents: diff changeset	715 }
a61af66fc99e Initial load duke parents: diff changeset	716
a61af66fc99e Initial load duke parents: diff changeset	717
a61af66fc99e Initial load duke parents: diff changeset	718 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	719 // ciEnv::get_method_by_index_impl
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	720 ciMethod* ciEnv::get_method_by_index_impl(constantPoolHandle cpool,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	721 int index, Bytecodes::Code bc,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	722 ciInstanceKlass* accessor) {
0 a61af66fc99e Initial load duke parents: diff changeset	723 int holder_index = cpool->klass_ref_index_at(index);
a61af66fc99e Initial load duke parents: diff changeset	724 bool holder_is_accessible;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	725 ciKlass* holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	726 ciInstanceKlass* declared_holder = get_instance_klass_for_declared_method_holder(holder);
a61af66fc99e Initial load duke parents: diff changeset	727
a61af66fc99e Initial load duke parents: diff changeset	728 // Get the method's name and signature.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	729 Symbol* name_sym = cpool->name_ref_at(index);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	730 Symbol* sig_sym = cpool->signature_ref_at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	731
a61af66fc99e Initial load duke parents: diff changeset	732 if (holder_is_accessible) { // Our declared holder is loaded.
a61af66fc99e Initial load duke parents: diff changeset	733 instanceKlass* lookup = declared_holder->get_instanceKlass();
a61af66fc99e Initial load duke parents: diff changeset	734 methodOop m = lookup_method(accessor->get_instanceKlass(), lookup, name_sym, sig_sym, bc);
a61af66fc99e Initial load duke parents: diff changeset	735 if (m != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	736 // We found the method.
a61af66fc99e Initial load duke parents: diff changeset	737 return get_object(m)->as_method();
a61af66fc99e Initial load duke parents: diff changeset	738 }
a61af66fc99e Initial load duke parents: diff changeset	739 }
a61af66fc99e Initial load duke parents: diff changeset	740
a61af66fc99e Initial load duke parents: diff changeset	741 // Either the declared holder was not loaded, or the method could
a61af66fc99e Initial load duke parents: diff changeset	742 // not be found. Create a dummy ciMethod to represent the failed
a61af66fc99e Initial load duke parents: diff changeset	743 // lookup.
a61af66fc99e Initial load duke parents: diff changeset	744
a61af66fc99e Initial load duke parents: diff changeset	745 return get_unloaded_method(declared_holder,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	746 get_symbol(name_sym),
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	747 get_symbol(sig_sym));
0 a61af66fc99e Initial load duke parents: diff changeset	748 }
a61af66fc99e Initial load duke parents: diff changeset	749
a61af66fc99e Initial load duke parents: diff changeset	750
a61af66fc99e Initial load duke parents: diff changeset	751 // ------------------------------------------------------------------
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	752 // ciEnv::get_fake_invokedynamic_method_impl
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	753 ciMethod* ciEnv::get_fake_invokedynamic_method_impl(constantPoolHandle cpool,
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	754 int index, Bytecodes::Code bc) {
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	755 // Compare the following logic with InterpreterRuntime::resolve_invokedynamic.
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	756 assert(bc == Bytecodes::_invokedynamic, "must be invokedynamic");
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	757
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	758 bool is_resolved = cpool->cache()->main_entry_at(index)->is_resolved(bc);
3279 08ccee2c4dbf 6993078: JSR 292 too many pushes: Lesp points into register window twisti parents: 2426 diff changeset	759 if (is_resolved && cpool->cache()->secondary_entry_at(index)->is_f1_null())
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	760 // FIXME: code generation could allow for null (unlinked) call site
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	761 is_resolved = false;
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	762
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	763 // Call site might not be resolved yet. We could create a real invoker method from the
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	764 // compiler, but it is simpler to stop the code path here with an unlinked method.
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	765 if (!is_resolved) {
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	766 ciInstanceKlass* mh_klass = get_object(SystemDictionary::MethodHandle_klass())->as_instance_klass();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	767 ciSymbol* sig_sym = get_symbol(cpool->signature_ref_at(index));
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	768 return get_unloaded_method(mh_klass, ciSymbol::invokeExact_name(), sig_sym);
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	769 }
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	770
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	771 // Get the invoker methodOop from the constant pool.
1662 e0ba4e04c839 6969574: invokedynamic call sites deoptimize instead of executing jrose parents: 1602 diff changeset	772 oop f1_value = cpool->cache()->main_entry_at(index)->f1();
3279 08ccee2c4dbf 6993078: JSR 292 too many pushes: Lesp points into register window twisti parents: 2426 diff changeset	773 methodOop signature_invoker = (methodOop) f1_value;
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	774 assert(signature_invoker != NULL && signature_invoker->is_method() && signature_invoker->is_method_handle_invoke(),
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	775 "correct result from LinkResolver::resolve_invokedynamic");
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	776
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1397 diff changeset	777 return get_object(signature_invoker)->as_method();
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	778 }
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	779
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	780
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	781 // ------------------------------------------------------------------
0 a61af66fc99e Initial load duke parents: diff changeset	782 // ciEnv::get_instance_klass_for_declared_method_holder
a61af66fc99e Initial load duke parents: diff changeset	783 ciInstanceKlass* ciEnv::get_instance_klass_for_declared_method_holder(ciKlass* method_holder) {
a61af66fc99e Initial load duke parents: diff changeset	784 // For the case of <array>.clone(), the method holder can be a ciArrayKlass
a61af66fc99e Initial load duke parents: diff changeset	785 // instead of a ciInstanceKlass. For that case simply pretend that the
a61af66fc99e Initial load duke parents: diff changeset	786 // declared holder is Object.clone since that's where the call will bottom out.
a61af66fc99e Initial load duke parents: diff changeset	787 // A more correct fix would trickle out through many interfaces in CI,
a61af66fc99e Initial load duke parents: diff changeset	788 // requiring ciInstanceKlass* to become ciKlass* and many more places would
a61af66fc99e Initial load duke parents: diff changeset	789 // require checks to make sure the expected type was found. Given that this
a61af66fc99e Initial load duke parents: diff changeset	790 // only occurs for clone() the more extensive fix seems like overkill so
a61af66fc99e Initial load duke parents: diff changeset	791 // instead we simply smear the array type into Object.
a61af66fc99e Initial load duke parents: diff changeset	792 if (method_holder->is_instance_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	793 return method_holder->as_instance_klass();
a61af66fc99e Initial load duke parents: diff changeset	794 } else if (method_holder->is_array_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	795 return current()->Object_klass();
a61af66fc99e Initial load duke parents: diff changeset	796 } else {
a61af66fc99e Initial load duke parents: diff changeset	797 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	798 }
a61af66fc99e Initial load duke parents: diff changeset	799 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	800 }
a61af66fc99e Initial load duke parents: diff changeset	801
a61af66fc99e Initial load duke parents: diff changeset	802
a61af66fc99e Initial load duke parents: diff changeset	803 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	804 // ciEnv::get_method_by_index
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	805 ciMethod* ciEnv::get_method_by_index(constantPoolHandle cpool,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	806 int index, Bytecodes::Code bc,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	807 ciInstanceKlass* accessor) {
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	808 if (bc == Bytecodes::_invokedynamic) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	809 GUARDED_VM_ENTRY(return get_fake_invokedynamic_method_impl(cpool, index, bc);)
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	810 } else {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	811 GUARDED_VM_ENTRY(return get_method_by_index_impl(cpool, index, bc, accessor);)
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	812 }
0 a61af66fc99e Initial load duke parents: diff changeset	813 }
a61af66fc99e Initial load duke parents: diff changeset	814
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 1080 diff changeset	815
0 a61af66fc99e Initial load duke parents: diff changeset	816 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	817 // ciEnv::name_buffer
a61af66fc99e Initial load duke parents: diff changeset	818 char *ciEnv::name_buffer(int req_len) {
a61af66fc99e Initial load duke parents: diff changeset	819 if (_name_buffer_len < req_len) {
a61af66fc99e Initial load duke parents: diff changeset	820 if (_name_buffer == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	821 _name_buffer = (char)arena()->Amalloc(sizeof(char)req_len);
a61af66fc99e Initial load duke parents: diff changeset	822 _name_buffer_len = req_len;
a61af66fc99e Initial load duke parents: diff changeset	823 } else {
a61af66fc99e Initial load duke parents: diff changeset	824 _name_buffer =
a61af66fc99e Initial load duke parents: diff changeset	825 (char*)arena()->Arealloc(_name_buffer, _name_buffer_len, req_len);
a61af66fc99e Initial load duke parents: diff changeset	826 _name_buffer_len = req_len;
a61af66fc99e Initial load duke parents: diff changeset	827 }
a61af66fc99e Initial load duke parents: diff changeset	828 }
a61af66fc99e Initial load duke parents: diff changeset	829 return _name_buffer;
a61af66fc99e Initial load duke parents: diff changeset	830 }
a61af66fc99e Initial load duke parents: diff changeset	831
a61af66fc99e Initial load duke parents: diff changeset	832 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	833 // ciEnv::is_in_vm
a61af66fc99e Initial load duke parents: diff changeset	834 bool ciEnv::is_in_vm() {
a61af66fc99e Initial load duke parents: diff changeset	835 return JavaThread::current()->thread_state() == _thread_in_vm;
a61af66fc99e Initial load duke parents: diff changeset	836 }
a61af66fc99e Initial load duke parents: diff changeset	837
a61af66fc99e Initial load duke parents: diff changeset	838 bool ciEnv::system_dictionary_modification_counter_changed() {
a61af66fc99e Initial load duke parents: diff changeset	839 return _system_dictionary_modification_counter != SystemDictionary::number_of_modifications();
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::check_for_system_dictionary_modification
a61af66fc99e Initial load duke parents: diff changeset	844 // Check for changes to the system dictionary during compilation
a61af66fc99e Initial load duke parents: diff changeset	845 // class loads, evolution, breakpoints
a61af66fc99e Initial load duke parents: diff changeset	846 void ciEnv::check_for_system_dictionary_modification(ciMethod* target) {
a61af66fc99e Initial load duke parents: diff changeset	847 if (failing()) return; // no need for further checks
a61af66fc99e Initial load duke parents: diff changeset	848
a61af66fc99e Initial load duke parents: diff changeset	849 // Dependencies must be checked when the system dictionary changes.
a61af66fc99e Initial load duke parents: diff changeset	850 // If logging is enabled all violated dependences will be recorded in
a61af66fc99e Initial load duke parents: diff changeset	851 // the log. In debug mode check dependencies even if the system
a61af66fc99e Initial load duke parents: diff changeset	852 // dictionary hasn't changed to verify that no invalid dependencies
a61af66fc99e Initial load duke parents: diff changeset	853 // were inserted. Any violated dependences in this case are dumped to
a61af66fc99e Initial load duke parents: diff changeset	854 // the tty.
a61af66fc99e Initial load duke parents: diff changeset	855
a61af66fc99e Initial load duke parents: diff changeset	856 bool counter_changed = system_dictionary_modification_counter_changed();
a61af66fc99e Initial load duke parents: diff changeset	857 bool test_deps = counter_changed;
a61af66fc99e Initial load duke parents: diff changeset	858 DEBUG_ONLY(test_deps = true);
a61af66fc99e Initial load duke parents: diff changeset	859 if (!test_deps) return;
a61af66fc99e Initial load duke parents: diff changeset	860
a61af66fc99e Initial load duke parents: diff changeset	861 bool print_failures = false;
a61af66fc99e Initial load duke parents: diff changeset	862 DEBUG_ONLY(print_failures = !counter_changed);
a61af66fc99e Initial load duke parents: diff changeset	863
a61af66fc99e Initial load duke parents: diff changeset	864 bool keep_going = (print_failures \|\| xtty != NULL);
a61af66fc99e Initial load duke parents: diff changeset	865
a61af66fc99e Initial load duke parents: diff changeset	866 int violated = 0;
a61af66fc99e Initial load duke parents: diff changeset	867
a61af66fc99e Initial load duke parents: diff changeset	868 for (Dependencies::DepStream deps(dependencies()); deps.next(); ) {
a61af66fc99e Initial load duke parents: diff changeset	869 klassOop witness = deps.check_dependency();
a61af66fc99e Initial load duke parents: diff changeset	870 if (witness != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	871 ++violated;
a61af66fc99e Initial load duke parents: diff changeset	872 if (print_failures) deps.print_dependency(witness, /verbose=/ true);
a61af66fc99e Initial load duke parents: diff changeset	873 // If there's no log and we're not sanity-checking, we're done.
a61af66fc99e Initial load duke parents: diff changeset	874 if (!keep_going) break;
a61af66fc99e Initial load duke parents: diff changeset	875 }
a61af66fc99e Initial load duke parents: diff changeset	876 }
a61af66fc99e Initial load duke parents: diff changeset	877
a61af66fc99e Initial load duke parents: diff changeset	878 if (violated != 0) {
a61af66fc99e Initial load duke parents: diff changeset	879 assert(counter_changed, "failed dependencies, but counter didn't change");
a61af66fc99e Initial load duke parents: diff changeset	880 record_failure("concurrent class loading");
a61af66fc99e Initial load duke parents: diff changeset	881 }
a61af66fc99e Initial load duke parents: diff changeset	882 }
a61af66fc99e Initial load duke parents: diff changeset	883
a61af66fc99e Initial load duke parents: diff changeset	884 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	885 // ciEnv::register_method
a61af66fc99e Initial load duke parents: diff changeset	886 void ciEnv::register_method(ciMethod* target,
a61af66fc99e Initial load duke parents: diff changeset	887 int entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	888 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	889 int orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	890 CodeBuffer* code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	891 int frame_words,
a61af66fc99e Initial load duke parents: diff changeset	892 OopMapSet* oop_map_set,
a61af66fc99e Initial load duke parents: diff changeset	893 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load duke parents: diff changeset	894 ImplicitExceptionTable* inc_table,
a61af66fc99e Initial load duke parents: diff changeset	895 AbstractCompiler* compiler,
a61af66fc99e Initial load duke parents: diff changeset	896 int comp_level,
a61af66fc99e Initial load duke parents: diff changeset	897 bool has_debug_info,
a61af66fc99e Initial load duke parents: diff changeset	898 bool has_unsafe_access) {
a61af66fc99e Initial load duke parents: diff changeset	899 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	900 nmethod* nm = NULL;
a61af66fc99e Initial load duke parents: diff changeset	901 {
a61af66fc99e Initial load duke parents: diff changeset	902 // To prevent compile queue updates.
a61af66fc99e Initial load duke parents: diff changeset	903 MutexLocker locker(MethodCompileQueue_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	904
a61af66fc99e Initial load duke parents: diff changeset	905 // Prevent SystemDictionary::add_to_hierarchy from running
a61af66fc99e Initial load duke parents: diff changeset	906 // and invalidating our dependencies until we install this method.
a61af66fc99e Initial load duke parents: diff changeset	907 MutexLocker ml(Compile_lock);
a61af66fc99e Initial load duke parents: diff changeset	908
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	909 // 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	910 if (!failing() &&
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	911 ( (!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	912 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	913 (!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	914 JvmtiExport::can_access_local_variables()) \|\|
1213 6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty dcubed parents: 1142 diff changeset	915 (!jvmti_can_post_on_exceptions() &&
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty dcubed parents: 1142 diff changeset	916 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	917 record_failure("Jvmti state change invalidated dependencies");
0 a61af66fc99e Initial load duke parents: diff changeset	918 }
a61af66fc99e Initial load duke parents: diff changeset	919
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	920 // 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	921 if (!failing() &&
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	922 ( (!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	923 (!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	924 (!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	925 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	926 }
0 a61af66fc99e Initial load duke parents: diff changeset	927
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	928 if (!failing()) {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	929 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	930 // 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	931 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	932 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	933
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	934 // 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	935 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	936
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	937 // Check for {class loads, evolution, breakpoints} during compilation
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	938 check_for_system_dictionary_modification(target);
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 470 diff changeset	939 }
0 a61af66fc99e Initial load duke parents: diff changeset	940
a61af66fc99e Initial load duke parents: diff changeset	941 methodHandle method(THREAD, target->get_methodOop());
a61af66fc99e Initial load duke parents: diff changeset	942
a61af66fc99e Initial load duke parents: diff changeset	943 if (failing()) {
a61af66fc99e Initial load duke parents: diff changeset	944 // While not a true deoptimization, it is a preemptive decompile.
a61af66fc99e Initial load duke parents: diff changeset	945 methodDataOop mdo = method()->method_data();
a61af66fc99e Initial load duke parents: diff changeset	946 if (mdo != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	947 mdo->inc_decompile_count();
a61af66fc99e Initial load duke parents: diff changeset	948 }
a61af66fc99e Initial load duke parents: diff changeset	949
a61af66fc99e Initial load duke parents: diff changeset	950 // All buffers in the CodeBuffer are allocated in the CodeCache.
a61af66fc99e Initial load duke parents: diff changeset	951 // If the code buffer is created on each compile attempt
a61af66fc99e Initial load duke parents: diff changeset	952 // as in C2, then it must be freed.
a61af66fc99e Initial load duke parents: diff changeset	953 code_buffer->free_blob();
a61af66fc99e Initial load duke parents: diff changeset	954 return;
a61af66fc99e Initial load duke parents: diff changeset	955 }
a61af66fc99e Initial load duke parents: diff changeset	956
a61af66fc99e Initial load duke parents: diff changeset	957 assert(offsets->value(CodeOffsets::Deopt) != -1, "must have deopt entry");
a61af66fc99e Initial load duke parents: diff changeset	958 assert(offsets->value(CodeOffsets::Exceptions) != -1, "must have exception entry");
a61af66fc99e Initial load duke parents: diff changeset	959
a61af66fc99e Initial load duke parents: diff changeset	960 nm = nmethod::new_nmethod(method,
a61af66fc99e Initial load duke parents: diff changeset	961 compile_id(),
a61af66fc99e Initial load duke parents: diff changeset	962 entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	963 offsets,
a61af66fc99e Initial load duke parents: diff changeset	964 orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	965 debug_info(), dependencies(), code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	966 frame_words, oop_map_set,
a61af66fc99e Initial load duke parents: diff changeset	967 handler_table, inc_table,
a61af66fc99e Initial load duke parents: diff changeset	968 compiler, comp_level);
a61af66fc99e Initial load duke parents: diff changeset	969
a61af66fc99e Initial load duke parents: diff changeset	970 // Free codeBlobs
a61af66fc99e Initial load duke parents: diff changeset	971 code_buffer->free_blob();
a61af66fc99e Initial load duke parents: diff changeset	972
a61af66fc99e Initial load duke parents: diff changeset	973 // stress test 6243940 by immediately making the method
a61af66fc99e Initial load duke parents: diff changeset	974 // non-entrant behind the system's back. This has serious
a61af66fc99e Initial load duke parents: diff changeset	975 // side effects on the code cache and is not meant for
a61af66fc99e Initial load duke parents: diff changeset	976 // general stress testing
a61af66fc99e Initial load duke parents: diff changeset	977 if (nm != NULL && StressNonEntrant) {
a61af66fc99e Initial load duke parents: diff changeset	978 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	979 NativeJump::patch_verified_entry(nm->entry_point(), nm->verified_entry_point(),
a61af66fc99e Initial load duke parents: diff changeset	980 SharedRuntime::get_handle_wrong_method_stub());
a61af66fc99e Initial load duke parents: diff changeset	981 }
a61af66fc99e Initial load duke parents: diff changeset	982
a61af66fc99e Initial load duke parents: diff changeset	983 if (nm == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	984 // The CodeCache is full. Print out warning and disable compilation.
a61af66fc99e Initial load duke parents: diff changeset	985 record_failure("code cache is full");
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1142 diff changeset	986 {
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1142 diff changeset	987 MutexUnlocker ml(Compile_lock);
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1142 diff changeset	988 MutexUnlocker locker(MethodCompileQueue_lock);
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1142 diff changeset	989 CompileBroker::handle_full_code_cache();
0 a61af66fc99e Initial load duke parents: diff changeset	990 }
a61af66fc99e Initial load duke parents: diff changeset	991 } else {
a61af66fc99e Initial load duke parents: diff changeset	992 NOT_PRODUCT(nm->set_has_debug_info(has_debug_info); )
a61af66fc99e Initial load duke parents: diff changeset	993 nm->set_has_unsafe_access(has_unsafe_access);
a61af66fc99e Initial load duke parents: diff changeset	994
a61af66fc99e Initial load duke parents: diff changeset	995 // Record successful registration.
a61af66fc99e Initial load duke parents: diff changeset	996 // (Put nm into the task handle before publishing to the Java heap.)
a61af66fc99e Initial load duke parents: diff changeset	997 if (task() != NULL) task()->set_code(nm);
a61af66fc99e Initial load duke parents: diff changeset	998
a61af66fc99e Initial load duke parents: diff changeset	999 if (entry_bci == InvocationEntryBci) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1000 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1001 // If there is an old version we're done with it
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1002 nmethod* old = method->code();
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1003 if (TraceMethodReplacement && old != NULL) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1004 ResourceMark rm;
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1005 char *method_name = method->name_and_sig_as_C_string();
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1006 tty->print_cr("Replacing method %s", method_name);
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1007 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1008 if (old != NULL ) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1009 old->make_not_entrant();
d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1010 }
0 a61af66fc99e Initial load duke parents: diff changeset	1011 }
a61af66fc99e Initial load duke parents: diff changeset	1012 if (TraceNMethodInstalls ) {
a61af66fc99e Initial load duke parents: diff changeset	1013 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1014 char *method_name = method->name_and_sig_as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	1015 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	1016 tty->print_cr("Installing method (%d) %s ",
a61af66fc99e Initial load duke parents: diff changeset	1017 comp_level,
a61af66fc99e Initial load duke parents: diff changeset	1018 method_name);
a61af66fc99e Initial load duke parents: diff changeset	1019 }
a61af66fc99e Initial load duke parents: diff changeset	1020 // Allow the code to be executed
a61af66fc99e Initial load duke parents: diff changeset	1021 method->set_code(method, nm);
a61af66fc99e Initial load duke parents: diff changeset	1022 } else {
a61af66fc99e Initial load duke parents: diff changeset	1023 if (TraceNMethodInstalls ) {
a61af66fc99e Initial load duke parents: diff changeset	1024 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1025 char *method_name = method->name_and_sig_as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	1026 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	1027 tty->print_cr("Installing osr method (%d) %s @ %d",
a61af66fc99e Initial load duke parents: diff changeset	1028 comp_level,
a61af66fc99e Initial load duke parents: diff changeset	1029 method_name,
a61af66fc99e Initial load duke parents: diff changeset	1030 entry_bci);
a61af66fc99e Initial load duke parents: diff changeset	1031 }
a61af66fc99e Initial load duke parents: diff changeset	1032 instanceKlass::cast(method->method_holder())->add_osr_nmethod(nm);
a61af66fc99e Initial load duke parents: diff changeset	1033
a61af66fc99e Initial load duke parents: diff changeset	1034 }
a61af66fc99e Initial load duke parents: diff changeset	1035 }
a61af66fc99e Initial load duke parents: diff changeset	1036 }
a61af66fc99e Initial load duke parents: diff changeset	1037 // JVMTI -- compiled method notification (must be done outside lock)
a61af66fc99e Initial load duke parents: diff changeset	1038 if (nm != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1039 nm->post_compiled_method_load_event();
a61af66fc99e Initial load duke parents: diff changeset	1040 }
a61af66fc99e Initial load duke parents: diff changeset	1041
a61af66fc99e Initial load duke parents: diff changeset	1042 }
a61af66fc99e Initial load duke parents: diff changeset	1043
a61af66fc99e Initial load duke parents: diff changeset	1044
a61af66fc99e Initial load duke parents: diff changeset	1045 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1046 // ciEnv::find_system_klass
a61af66fc99e Initial load duke parents: diff changeset	1047 ciKlass* ciEnv::find_system_klass(ciSymbol* klass_name) {
a61af66fc99e Initial load duke parents: diff changeset	1048 VM_ENTRY_MARK;
a61af66fc99e Initial load duke parents: diff changeset	1049 return get_klass_by_name_impl(NULL, klass_name, false);
a61af66fc99e Initial load duke parents: diff changeset	1050 }
a61af66fc99e Initial load duke parents: diff changeset	1051
a61af66fc99e Initial load duke parents: diff changeset	1052 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1053 // ciEnv::comp_level
a61af66fc99e Initial load duke parents: diff changeset	1054 int ciEnv::comp_level() {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1662 diff changeset	1055 if (task() == NULL) return CompLevel_highest_tier;
0 a61af66fc99e Initial load duke parents: diff changeset	1056 return task()->comp_level();
a61af66fc99e Initial load duke parents: diff changeset	1057 }
a61af66fc99e Initial load duke parents: diff changeset	1058
a61af66fc99e Initial load duke parents: diff changeset	1059 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1060 // ciEnv::compile_id
a61af66fc99e Initial load duke parents: diff changeset	1061 uint ciEnv::compile_id() {
a61af66fc99e Initial load duke parents: diff changeset	1062 if (task() == NULL) return 0;
a61af66fc99e Initial load duke parents: diff changeset	1063 return task()->compile_id();
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 // ciEnv::notice_inlined_method()
a61af66fc99e Initial load duke parents: diff changeset	1068 void ciEnv::notice_inlined_method(ciMethod* method) {
a61af66fc99e Initial load duke parents: diff changeset	1069 _num_inlined_bytecodes += method->code_size();
a61af66fc99e Initial load duke parents: diff changeset	1070 }
a61af66fc99e Initial load duke parents: diff changeset	1071
a61af66fc99e Initial load duke parents: diff changeset	1072 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1073 // ciEnv::num_inlined_bytecodes()
a61af66fc99e Initial load duke parents: diff changeset	1074 int ciEnv::num_inlined_bytecodes() const {
a61af66fc99e Initial load duke parents: diff changeset	1075 return _num_inlined_bytecodes;
a61af66fc99e Initial load duke parents: diff changeset	1076 }
a61af66fc99e Initial load duke parents: diff changeset	1077
a61af66fc99e Initial load duke parents: diff changeset	1078 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1079 // ciEnv::record_failure()
a61af66fc99e Initial load duke parents: diff changeset	1080 void ciEnv::record_failure(const char* reason) {
a61af66fc99e Initial load duke parents: diff changeset	1081 if (log() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1082 log()->elem("failure reason='%s'", reason);
a61af66fc99e Initial load duke parents: diff changeset	1083 }
a61af66fc99e Initial load duke parents: diff changeset	1084 if (_failure_reason == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1085 // Record the first failure reason.
a61af66fc99e Initial load duke parents: diff changeset	1086 _failure_reason = reason;
a61af66fc99e Initial load duke parents: diff changeset	1087 }
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::record_method_not_compilable()
a61af66fc99e Initial load duke parents: diff changeset	1092 void ciEnv::record_method_not_compilable(const char* reason, bool all_tiers) {
a61af66fc99e Initial load duke parents: diff changeset	1093 int new_compilable =
a61af66fc99e Initial load duke parents: diff changeset	1094 all_tiers ? MethodCompilable_never : MethodCompilable_not_at_tier ;
a61af66fc99e Initial load duke parents: diff changeset	1095
a61af66fc99e Initial load duke parents: diff changeset	1096 // Only note transitions to a worse state
a61af66fc99e Initial load duke parents: diff changeset	1097 if (new_compilable > _compilable) {
a61af66fc99e Initial load duke parents: diff changeset	1098 if (log() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1099 if (all_tiers) {
a61af66fc99e Initial load duke parents: diff changeset	1100 log()->elem("method_not_compilable");
a61af66fc99e Initial load duke parents: diff changeset	1101 } else {
a61af66fc99e Initial load duke parents: diff changeset	1102 log()->elem("method_not_compilable_at_tier");
a61af66fc99e Initial load duke parents: diff changeset	1103 }
a61af66fc99e Initial load duke parents: diff changeset	1104 }
a61af66fc99e Initial load duke parents: diff changeset	1105 _compilable = new_compilable;
a61af66fc99e Initial load duke parents: diff changeset	1106
a61af66fc99e Initial load duke parents: diff changeset	1107 // Reset failure reason; this one is more important.
a61af66fc99e Initial load duke parents: diff changeset	1108 _failure_reason = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1109 record_failure(reason);
a61af66fc99e Initial load duke parents: diff changeset	1110 }
a61af66fc99e Initial load duke parents: diff changeset	1111 }
a61af66fc99e Initial load duke parents: diff changeset	1112
a61af66fc99e Initial load duke parents: diff changeset	1113 // ------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1114 // ciEnv::record_out_of_memory_failure()
a61af66fc99e Initial load duke parents: diff changeset	1115 void ciEnv::record_out_of_memory_failure() {
a61af66fc99e Initial load duke parents: diff changeset	1116 // If memory is low, we stop compiling methods.
a61af66fc99e Initial load duke parents: diff changeset	1117 record_method_not_compilable("out of memory");
a61af66fc99e Initial load duke parents: diff changeset	1118 }

Mercurial > hg > truffle

annotate src/share/vm/ci/ciEnv.cpp @ 3762:5c0a3c1858b1