annotate src/share/vm/ci/ciEnv.cpp @ 1994:6cd6d394f280

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed()) 7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages. Reviewed-by: johnc, tonyp
author ysr
date Tue, 07 Dec 2010 21:55:53 -0800
parents f95d63e2154a
children 06f017f7daa7 9afee0b9fc1d
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1507
diff changeset
2 * Copyright (c) 1999, 2010, 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 ciSymbolKlass* ciEnv::_symbol_klass_instance;
a61af66fc99e Initial load
duke
parents:
diff changeset
72 ciKlassKlass* ciEnv::_klass_klass_instance;
a61af66fc99e Initial load
duke
parents:
diff changeset
73 ciInstanceKlassKlass* ciEnv::_instance_klass_klass_instance;
a61af66fc99e Initial load
duke
parents:
diff changeset
74 ciTypeArrayKlassKlass* ciEnv::_type_array_klass_klass_instance;
a61af66fc99e Initial load
duke
parents:
diff changeset
75 ciObjArrayKlassKlass* ciEnv::_obj_array_klass_klass_instance;
a61af66fc99e Initial load
duke
parents:
diff changeset
76
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1138
diff changeset
77 #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
78 WK_KLASSES_DO(WK_KLASS_DEFN)
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1138
diff changeset
79 #undef WK_KLASS_DEFN
0
a61af66fc99e Initial load
duke
parents:
diff changeset
80
a61af66fc99e Initial load
duke
parents:
diff changeset
81 ciSymbol* ciEnv::_unloaded_cisymbol = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
82 ciInstanceKlass* ciEnv::_unloaded_ciinstance_klass = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
83 ciObjArrayKlass* ciEnv::_unloaded_ciobjarrayklass = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
84
a61af66fc99e Initial load
duke
parents:
diff changeset
85 jobject ciEnv::_ArrayIndexOutOfBoundsException_handle = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
86 jobject ciEnv::_ArrayStoreException_handle = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
87 jobject ciEnv::_ClassCastException_handle = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
88
a61af66fc99e Initial load
duke
parents:
diff changeset
89 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
90 static bool firstEnv = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
91 #endif /* PRODUCT */
a61af66fc99e Initial load
duke
parents:
diff changeset
92
a61af66fc99e Initial load
duke
parents:
diff changeset
93 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
94 // ciEnv::ciEnv
a61af66fc99e Initial load
duke
parents:
diff changeset
95 ciEnv::ciEnv(CompileTask* task, int system_dictionary_modification_counter) {
a61af66fc99e Initial load
duke
parents:
diff changeset
96 VM_ENTRY_MARK;
a61af66fc99e Initial load
duke
parents:
diff changeset
97
a61af66fc99e Initial load
duke
parents:
diff changeset
98 // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
99 thread->set_env(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
100 assert(ciEnv::current() == this, "sanity");
a61af66fc99e Initial load
duke
parents:
diff changeset
101
a61af66fc99e Initial load
duke
parents:
diff changeset
102 _oop_recorder = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
103 _debug_info = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
104 _dependencies = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
105 _failure_reason = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
106 _compilable = MethodCompilable;
a61af66fc99e Initial load
duke
parents:
diff changeset
107 _break_at_compile = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
108 _compiler_data = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
109 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
110 assert(!firstEnv, "not initialized properly");
a61af66fc99e Initial load
duke
parents:
diff changeset
111 #endif /* !PRODUCT */
a61af66fc99e Initial load
duke
parents:
diff changeset
112
a61af66fc99e Initial load
duke
parents:
diff changeset
113 _system_dictionary_modification_counter = system_dictionary_modification_counter;
a61af66fc99e Initial load
duke
parents:
diff changeset
114 _num_inlined_bytecodes = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
115 assert(task == NULL || thread->task() == task, "sanity");
a61af66fc99e Initial load
duke
parents:
diff changeset
116 _task = task;
a61af66fc99e Initial load
duke
parents:
diff changeset
117 _log = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
118
a61af66fc99e Initial load
duke
parents:
diff changeset
119 // Temporary buffer for creating symbols and such.
a61af66fc99e Initial load
duke
parents:
diff changeset
120 _name_buffer = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
121 _name_buffer_len = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
122
a61af66fc99e Initial load
duke
parents:
diff changeset
123 _arena = &_ciEnv_arena;
a61af66fc99e Initial load
duke
parents:
diff changeset
124 _factory = new (_arena) ciObjectFactory(_arena, 128);
a61af66fc99e Initial load
duke
parents:
diff changeset
125
a61af66fc99e Initial load
duke
parents:
diff changeset
126 // Preload commonly referenced system ciObjects.
a61af66fc99e Initial load
duke
parents:
diff changeset
127
a61af66fc99e Initial load
duke
parents:
diff changeset
128 // During VM initialization, these instances have not yet been created.
a61af66fc99e Initial load
duke
parents:
diff changeset
129 // Assertions ensure that these instances are not accessed before
a61af66fc99e Initial load
duke
parents:
diff changeset
130 // their initialization.
a61af66fc99e Initial load
duke
parents:
diff changeset
131
a61af66fc99e Initial load
duke
parents:
diff changeset
132 assert(Universe::is_fully_initialized(), "should be complete");
a61af66fc99e Initial load
duke
parents:
diff changeset
133
a61af66fc99e Initial load
duke
parents:
diff changeset
134 oop o = Universe::null_ptr_exception_instance();
a61af66fc99e Initial load
duke
parents:
diff changeset
135 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load
duke
parents:
diff changeset
136 _NullPointerException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load
duke
parents:
diff changeset
137 o = Universe::arithmetic_exception_instance();
a61af66fc99e Initial load
duke
parents:
diff changeset
138 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load
duke
parents:
diff changeset
139 _ArithmeticException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load
duke
parents:
diff changeset
140
a61af66fc99e Initial load
duke
parents:
diff changeset
141 _ArrayIndexOutOfBoundsException_instance = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
142 _ArrayStoreException_instance = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
143 _ClassCastException_instance = NULL;
1080
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 1059
diff changeset
144 _the_null_string = NULL;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 1059
diff changeset
145 _the_min_jint_string = NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
146 }
a61af66fc99e Initial load
duke
parents:
diff changeset
147
a61af66fc99e Initial load
duke
parents:
diff changeset
148 ciEnv::ciEnv(Arena* arena) {
a61af66fc99e Initial load
duke
parents:
diff changeset
149 ASSERT_IN_VM;
a61af66fc99e Initial load
duke
parents:
diff changeset
150
a61af66fc99e Initial load
duke
parents:
diff changeset
151 // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
152 CompilerThread* current_thread = CompilerThread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
153 assert(current_thread->env() == NULL, "must be");
a61af66fc99e Initial load
duke
parents:
diff changeset
154 current_thread->set_env(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
155 assert(ciEnv::current() == this, "sanity");
a61af66fc99e Initial load
duke
parents:
diff changeset
156
a61af66fc99e Initial load
duke
parents:
diff changeset
157 _oop_recorder = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
158 _debug_info = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
159 _dependencies = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
160 _failure_reason = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
161 _compilable = MethodCompilable_never;
a61af66fc99e Initial load
duke
parents:
diff changeset
162 _break_at_compile = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
163 _compiler_data = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
164 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
165 assert(firstEnv, "must be first");
a61af66fc99e Initial load
duke
parents:
diff changeset
166 firstEnv = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
167 #endif /* !PRODUCT */
a61af66fc99e Initial load
duke
parents:
diff changeset
168
a61af66fc99e Initial load
duke
parents:
diff changeset
169 _system_dictionary_modification_counter = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
170 _num_inlined_bytecodes = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
171 _task = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
172 _log = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
173
a61af66fc99e Initial load
duke
parents:
diff changeset
174 // Temporary buffer for creating symbols and such.
a61af66fc99e Initial load
duke
parents:
diff changeset
175 _name_buffer = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
176 _name_buffer_len = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
177
a61af66fc99e Initial load
duke
parents:
diff changeset
178 _arena = arena;
a61af66fc99e Initial load
duke
parents:
diff changeset
179 _factory = new (_arena) ciObjectFactory(_arena, 128);
a61af66fc99e Initial load
duke
parents:
diff changeset
180
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // Preload commonly referenced system ciObjects.
a61af66fc99e Initial load
duke
parents:
diff changeset
182
a61af66fc99e Initial load
duke
parents:
diff changeset
183 // During VM initialization, these instances have not yet been created.
a61af66fc99e Initial load
duke
parents:
diff changeset
184 // Assertions ensure that these instances are not accessed before
a61af66fc99e Initial load
duke
parents:
diff changeset
185 // their initialization.
a61af66fc99e Initial load
duke
parents:
diff changeset
186
a61af66fc99e Initial load
duke
parents:
diff changeset
187 assert(Universe::is_fully_initialized(), "must be");
a61af66fc99e Initial load
duke
parents:
diff changeset
188
a61af66fc99e Initial load
duke
parents:
diff changeset
189 oop o = Universe::null_ptr_exception_instance();
a61af66fc99e Initial load
duke
parents:
diff changeset
190 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load
duke
parents:
diff changeset
191 _NullPointerException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load
duke
parents:
diff changeset
192 o = Universe::arithmetic_exception_instance();
a61af66fc99e Initial load
duke
parents:
diff changeset
193 assert(o != NULL, "should have been initialized");
a61af66fc99e Initial load
duke
parents:
diff changeset
194 _ArithmeticException_instance = get_object(o)->as_instance();
a61af66fc99e Initial load
duke
parents:
diff changeset
195
a61af66fc99e Initial load
duke
parents:
diff changeset
196 _ArrayIndexOutOfBoundsException_instance = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
197 _ArrayStoreException_instance = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
198 _ClassCastException_instance = NULL;
1080
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 1059
diff changeset
199 _the_null_string = NULL;
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 1059
diff changeset
200 _the_min_jint_string = NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
201 }
a61af66fc99e Initial load
duke
parents:
diff changeset
202
a61af66fc99e Initial load
duke
parents:
diff changeset
203 ciEnv::~ciEnv() {
a61af66fc99e Initial load
duke
parents:
diff changeset
204 CompilerThread* current_thread = CompilerThread::current();
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
a61af66fc99e Initial load
duke
parents:
diff changeset
237 ciInstance* ciEnv::get_or_create_exception(jobject& handle, symbolHandle name) {
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,
a61af66fc99e Initial load
duke
parents:
diff changeset
264 vmSymbolHandles::java_lang_ArrayIndexOutOfBoundsException());
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,
a61af66fc99e Initial load
duke
parents:
diff changeset
272 vmSymbolHandles::java_lang_ArrayStoreException());
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,
a61af66fc99e Initial load
duke
parents:
diff changeset
280 vmSymbolHandles::java_lang_ClassCastException());
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
a61af66fc99e Initial load
duke
parents:
diff changeset
380 symbolHandle sym(THREAD, name->get_symbolOop());
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.
a61af66fc99e Initial load
duke
parents:
diff changeset
384 sym = oopFactory::new_symbol_handle(sym->as_utf8()+1,
a61af66fc99e Initial load
duke
parents:
diff changeset
385 sym->utf8_length()-2,
a61af66fc99e Initial load
duke
parents:
diff changeset
386 KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass));
a61af66fc99e Initial load
duke
parents:
diff changeset
387 name = get_object(sym())->as_symbol();
a61af66fc99e Initial load
duke
parents:
diff changeset
388 }
a61af66fc99e Initial load
duke
parents:
diff changeset
389
a61af66fc99e Initial load
duke
parents:
diff changeset
390 // Check for prior unloaded klass. The SystemDictionary's answers
a61af66fc99e Initial load
duke
parents:
diff changeset
391 // can vary over time but the compiler needs consistency.
a61af66fc99e Initial load
duke
parents:
diff changeset
392 ciKlass* unloaded_klass = check_get_unloaded_klass(accessing_klass, name);
a61af66fc99e Initial load
duke
parents:
diff changeset
393 if (unloaded_klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
394 if (require_local) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
395 return unloaded_klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
396 }
a61af66fc99e Initial load
duke
parents:
diff changeset
397
a61af66fc99e Initial load
duke
parents:
diff changeset
398 Handle loader(THREAD, (oop)NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
399 Handle domain(THREAD, (oop)NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
400 if (accessing_klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
401 loader = Handle(THREAD, accessing_klass->loader());
a61af66fc99e Initial load
duke
parents:
diff changeset
402 domain = Handle(THREAD, accessing_klass->protection_domain());
a61af66fc99e Initial load
duke
parents:
diff changeset
403 }
a61af66fc99e Initial load
duke
parents:
diff changeset
404
a61af66fc99e Initial load
duke
parents:
diff changeset
405 // setup up the proper type to return on OOM
a61af66fc99e Initial load
duke
parents:
diff changeset
406 ciKlass* fail_type;
a61af66fc99e Initial load
duke
parents:
diff changeset
407 if (sym->byte_at(0) == '[') {
a61af66fc99e Initial load
duke
parents:
diff changeset
408 fail_type = _unloaded_ciobjarrayklass;
a61af66fc99e Initial load
duke
parents:
diff changeset
409 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
410 fail_type = _unloaded_ciinstance_klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
411 }
a61af66fc99e Initial load
duke
parents:
diff changeset
412 klassOop found_klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
413 if (!require_local) {
a61af66fc99e Initial load
duke
parents:
diff changeset
414 found_klass =
a61af66fc99e Initial load
duke
parents:
diff changeset
415 SystemDictionary::find_constrained_instance_or_array_klass(sym, loader,
a61af66fc99e Initial load
duke
parents:
diff changeset
416 KILL_COMPILE_ON_FATAL_(fail_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
417 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
418 found_klass =
a61af66fc99e Initial load
duke
parents:
diff changeset
419 SystemDictionary::find_instance_or_array_klass(sym, loader, domain,
a61af66fc99e Initial load
duke
parents:
diff changeset
420 KILL_COMPILE_ON_FATAL_(fail_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
421 }
a61af66fc99e Initial load
duke
parents:
diff changeset
422
a61af66fc99e Initial load
duke
parents:
diff changeset
423 // If we fail to find an array klass, look again for its element type.
a61af66fc99e Initial load
duke
parents:
diff changeset
424 // The element type may be available either locally or via constraints.
a61af66fc99e Initial load
duke
parents:
diff changeset
425 // In either case, if we can find the element type in the system dictionary,
a61af66fc99e Initial load
duke
parents:
diff changeset
426 // we must build an array type around it. The CI requires array klasses
a61af66fc99e Initial load
duke
parents:
diff changeset
427 // to be loaded if their element klasses are loaded, except when memory
a61af66fc99e Initial load
duke
parents:
diff changeset
428 // is exhausted.
a61af66fc99e Initial load
duke
parents:
diff changeset
429 if (sym->byte_at(0) == '[' &&
a61af66fc99e Initial load
duke
parents:
diff changeset
430 (sym->byte_at(1) == '[' || sym->byte_at(1) == 'L')) {
a61af66fc99e Initial load
duke
parents:
diff changeset
431 // We have an unloaded array.
a61af66fc99e Initial load
duke
parents:
diff changeset
432 // Build it on the fly if the element class exists.
a61af66fc99e Initial load
duke
parents:
diff changeset
433 symbolOop elem_sym = oopFactory::new_symbol(sym->as_utf8()+1,
a61af66fc99e Initial load
duke
parents:
diff changeset
434 sym->utf8_length()-1,
a61af66fc99e Initial load
duke
parents:
diff changeset
435 KILL_COMPILE_ON_FATAL_(fail_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
436 // Get element ciKlass recursively.
a61af66fc99e Initial load
duke
parents:
diff changeset
437 ciKlass* elem_klass =
a61af66fc99e Initial load
duke
parents:
diff changeset
438 get_klass_by_name_impl(accessing_klass,
a61af66fc99e Initial load
duke
parents:
diff changeset
439 get_object(elem_sym)->as_symbol(),
a61af66fc99e Initial load
duke
parents:
diff changeset
440 require_local);
a61af66fc99e Initial load
duke
parents:
diff changeset
441 if (elem_klass != NULL && elem_klass->is_loaded()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
442 // Now make an array for it
a61af66fc99e Initial load
duke
parents:
diff changeset
443 return ciObjArrayKlass::make_impl(elem_klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
444 }
a61af66fc99e Initial load
duke
parents:
diff changeset
445 }
a61af66fc99e Initial load
duke
parents:
diff changeset
446
a61af66fc99e Initial load
duke
parents:
diff changeset
447 if (found_klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
448 // Found it. Build a CI handle.
a61af66fc99e Initial load
duke
parents:
diff changeset
449 return get_object(found_klass)->as_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
450 }
a61af66fc99e Initial load
duke
parents:
diff changeset
451
a61af66fc99e Initial load
duke
parents:
diff changeset
452 if (require_local) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
453 // Not yet loaded into the VM, or not governed by loader constraints.
a61af66fc99e Initial load
duke
parents:
diff changeset
454 // Make a CI representative for it.
a61af66fc99e Initial load
duke
parents:
diff changeset
455 return get_unloaded_klass(accessing_klass, name);
a61af66fc99e Initial load
duke
parents:
diff changeset
456 }
a61af66fc99e Initial load
duke
parents:
diff changeset
457
a61af66fc99e Initial load
duke
parents:
diff changeset
458 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
459 // ciEnv::get_klass_by_name
a61af66fc99e Initial load
duke
parents:
diff changeset
460 ciKlass* ciEnv::get_klass_by_name(ciKlass* accessing_klass,
a61af66fc99e Initial load
duke
parents:
diff changeset
461 ciSymbol* klass_name,
a61af66fc99e Initial load
duke
parents:
diff changeset
462 bool require_local) {
a61af66fc99e Initial load
duke
parents:
diff changeset
463 GUARDED_VM_ENTRY(return get_klass_by_name_impl(accessing_klass,
a61af66fc99e Initial load
duke
parents:
diff changeset
464 klass_name,
a61af66fc99e Initial load
duke
parents:
diff changeset
465 require_local);)
a61af66fc99e Initial load
duke
parents:
diff changeset
466 }
a61af66fc99e Initial load
duke
parents:
diff changeset
467
a61af66fc99e Initial load
duke
parents:
diff changeset
468 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
469 // ciEnv::get_klass_by_index_impl
a61af66fc99e Initial load
duke
parents:
diff changeset
470 //
a61af66fc99e Initial load
duke
parents:
diff changeset
471 // Implementation of get_klass_by_index.
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
472 ciKlass* ciEnv::get_klass_by_index_impl(constantPoolHandle cpool,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
473 int index,
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
474 bool& is_accessible,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
475 ciInstanceKlass* accessor) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
476 EXCEPTION_CONTEXT;
a61af66fc99e Initial load
duke
parents:
diff changeset
477 KlassHandle klass (THREAD, constantPoolOopDesc::klass_at_if_loaded(cpool, index));
a61af66fc99e Initial load
duke
parents:
diff changeset
478 symbolHandle klass_name;
a61af66fc99e Initial load
duke
parents:
diff changeset
479 if (klass.is_null()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
480 // The klass has not been inserted into the constant pool.
a61af66fc99e Initial load
duke
parents:
diff changeset
481 // Try to look it up by name.
a61af66fc99e Initial load
duke
parents:
diff changeset
482 {
a61af66fc99e Initial load
duke
parents:
diff changeset
483 // We have to lock the cpool to keep the oop from being resolved
a61af66fc99e Initial load
duke
parents:
diff changeset
484 // while we are accessing it.
a61af66fc99e Initial load
duke
parents:
diff changeset
485 ObjectLocker ol(cpool, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
486
a61af66fc99e Initial load
duke
parents:
diff changeset
487 constantTag tag = cpool->tag_at(index);
a61af66fc99e Initial load
duke
parents:
diff changeset
488 if (tag.is_klass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
489 // The klass has been inserted into the constant pool
a61af66fc99e Initial load
duke
parents:
diff changeset
490 // very recently.
a61af66fc99e Initial load
duke
parents:
diff changeset
491 klass = KlassHandle(THREAD, cpool->resolved_klass_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
492 } else if (tag.is_symbol()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
493 klass_name = symbolHandle(THREAD, cpool->symbol_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
494 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
495 assert(cpool->tag_at(index).is_unresolved_klass(), "wrong tag");
a61af66fc99e Initial load
duke
parents:
diff changeset
496 klass_name = symbolHandle(THREAD, cpool->unresolved_klass_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
497 }
a61af66fc99e Initial load
duke
parents:
diff changeset
498 }
a61af66fc99e Initial load
duke
parents:
diff changeset
499 }
a61af66fc99e Initial load
duke
parents:
diff changeset
500
a61af66fc99e Initial load
duke
parents:
diff changeset
501 if (klass.is_null()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
502 // Not found in constant pool. Use the name to do the lookup.
a61af66fc99e Initial load
duke
parents:
diff changeset
503 ciKlass* k = get_klass_by_name_impl(accessor,
a61af66fc99e Initial load
duke
parents:
diff changeset
504 get_object(klass_name())->as_symbol(),
a61af66fc99e Initial load
duke
parents:
diff changeset
505 false);
a61af66fc99e Initial load
duke
parents:
diff changeset
506 // Calculate accessibility the hard way.
a61af66fc99e Initial load
duke
parents:
diff changeset
507 if (!k->is_loaded()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
508 is_accessible = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
509 } else if (k->loader() != accessor->loader() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
510 get_klass_by_name_impl(accessor, k->name(), true) == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
511 // Loaded only remotely. Not linked yet.
a61af66fc99e Initial load
duke
parents:
diff changeset
512 is_accessible = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
513 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
514 // Linked locally, and we must also check public/private, etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
515 is_accessible = check_klass_accessibility(accessor, k->get_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
516 }
a61af66fc99e Initial load
duke
parents:
diff changeset
517 return k;
a61af66fc99e Initial load
duke
parents:
diff changeset
518 }
a61af66fc99e Initial load
duke
parents:
diff changeset
519
a61af66fc99e Initial load
duke
parents:
diff changeset
520 // Check for prior unloaded klass. The SystemDictionary's answers
a61af66fc99e Initial load
duke
parents:
diff changeset
521 // can vary over time but the compiler needs consistency.
a61af66fc99e Initial load
duke
parents:
diff changeset
522 ciSymbol* name = get_object(klass()->klass_part()->name())->as_symbol();
a61af66fc99e Initial load
duke
parents:
diff changeset
523 ciKlass* unloaded_klass = check_get_unloaded_klass(accessor, name);
a61af66fc99e Initial load
duke
parents:
diff changeset
524 if (unloaded_klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
525 is_accessible = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
526 return unloaded_klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
527 }
a61af66fc99e Initial load
duke
parents:
diff changeset
528
a61af66fc99e Initial load
duke
parents:
diff changeset
529 // It is known to be accessible, since it was found in the constant pool.
a61af66fc99e Initial load
duke
parents:
diff changeset
530 is_accessible = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
531 return get_object(klass())->as_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
532 }
a61af66fc99e Initial load
duke
parents:
diff changeset
533
a61af66fc99e Initial load
duke
parents:
diff changeset
534 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
535 // ciEnv::get_klass_by_index
a61af66fc99e Initial load
duke
parents:
diff changeset
536 //
a61af66fc99e Initial load
duke
parents:
diff changeset
537 // Get a klass from the constant pool.
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
538 ciKlass* ciEnv::get_klass_by_index(constantPoolHandle cpool,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
539 int index,
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
540 bool& is_accessible,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
541 ciInstanceKlass* accessor) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
542 GUARDED_VM_ENTRY(return get_klass_by_index_impl(cpool, index, is_accessible, accessor);)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
543 }
a61af66fc99e Initial load
duke
parents:
diff changeset
544
a61af66fc99e Initial load
duke
parents:
diff changeset
545 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
546 // ciEnv::get_constant_by_index_impl
a61af66fc99e Initial load
duke
parents:
diff changeset
547 //
a61af66fc99e Initial load
duke
parents:
diff changeset
548 // Implementation of get_constant_by_index().
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
549 ciConstant ciEnv::get_constant_by_index_impl(constantPoolHandle cpool,
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
550 int pool_index, int cache_index,
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
551 ciInstanceKlass* accessor) {
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
552 bool ignore_will_link;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
553 EXCEPTION_CONTEXT;
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
554 int index = pool_index;
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
555 if (cache_index >= 0) {
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
556 assert(index < 0, "only one kind of index at a time");
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
557 ConstantPoolCacheEntry* cpc_entry = cpool->cache()->entry_at(cache_index);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
558 index = cpc_entry->constant_pool_index();
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
559 oop obj = cpc_entry->f1();
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
560 if (obj != NULL) {
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
561 assert(obj->is_instance(), "must be an instance");
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
562 ciObject* ciobj = get_object(obj);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
563 return ciConstant(T_OBJECT, ciobj);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
564 }
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
565 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
566 constantTag tag = cpool->tag_at(index);
a61af66fc99e Initial load
duke
parents:
diff changeset
567 if (tag.is_int()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
568 return ciConstant(T_INT, (jint)cpool->int_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
569 } else if (tag.is_long()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
570 return ciConstant((jlong)cpool->long_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
571 } else if (tag.is_float()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
572 return ciConstant((jfloat)cpool->float_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
573 } else if (tag.is_double()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
574 return ciConstant((jdouble)cpool->double_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
575 } 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
576 oop string = NULL;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
577 if (cpool->is_pseudo_string_at(index)) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
578 string = cpool->pseudo_string_at(index);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
579 } else {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
580 string = cpool->string_at(index, THREAD);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
581 if (HAS_PENDING_EXCEPTION) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
582 CLEAR_PENDING_EXCEPTION;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
583 record_out_of_memory_failure();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
584 return ciConstant();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 0
diff changeset
585 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
586 }
a61af66fc99e Initial load
duke
parents:
diff changeset
587 ciObject* constant = get_object(string);
a61af66fc99e Initial load
duke
parents:
diff changeset
588 assert (constant->is_instance(), "must be an instance, or not? ");
a61af66fc99e Initial load
duke
parents:
diff changeset
589 return ciConstant(T_OBJECT, constant);
a61af66fc99e Initial load
duke
parents:
diff changeset
590 } else if (tag.is_klass() || tag.is_unresolved_klass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
591 // 4881222: allow ldc to take a class type
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
592 ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore_will_link, accessor);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
593 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load
duke
parents:
diff changeset
594 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load
duke
parents:
diff changeset
595 record_out_of_memory_failure();
a61af66fc99e Initial load
duke
parents:
diff changeset
596 return ciConstant();
a61af66fc99e Initial load
duke
parents:
diff changeset
597 }
a61af66fc99e Initial load
duke
parents:
diff changeset
598 assert (klass->is_instance_klass() || klass->is_array_klass(),
a61af66fc99e Initial load
duke
parents:
diff changeset
599 "must be an instance or array klass ");
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
600 return ciConstant(T_OBJECT, klass->java_mirror());
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
601 } else if (tag.is_object()) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
602 oop obj = cpool->object_at(index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
603 assert(obj->is_instance(), "must be an instance");
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
604 ciObject* ciobj = get_object(obj);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
605 return ciConstant(T_OBJECT, ciobj);
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
606 } else if (tag.is_method_type()) {
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
607 // 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
608 ciSymbol* signature = get_object(cpool->method_type_signature_at(index))->as_symbol();
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
609 ciObject* ciobj = get_unloaded_method_type_constant(signature);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
610 return ciConstant(T_OBJECT, ciobj);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
611 } else if (tag.is_method_handle()) {
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
612 // 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
613 int ref_kind = cpool->method_handle_ref_kind_at(index);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
614 int callee_index = cpool->method_handle_klass_index_at(index);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
615 ciKlass* callee = get_klass_by_index_impl(cpool, callee_index, ignore_will_link, accessor);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
616 ciSymbol* name = get_object(cpool->method_handle_name_ref_at(index))->as_symbol();
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
617 ciSymbol* signature = get_object(cpool->method_handle_signature_ref_at(index))->as_symbol();
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
618 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
619 return ciConstant(T_OBJECT, ciobj);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
620 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
621 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
622 return ciConstant();
a61af66fc99e Initial load
duke
parents:
diff changeset
623 }
a61af66fc99e Initial load
duke
parents:
diff changeset
624 }
a61af66fc99e Initial load
duke
parents:
diff changeset
625
a61af66fc99e Initial load
duke
parents:
diff changeset
626 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
627 // ciEnv::get_constant_by_index
a61af66fc99e Initial load
duke
parents:
diff changeset
628 //
a61af66fc99e Initial load
duke
parents:
diff changeset
629 // Pull a constant out of the constant pool. How appropriate.
a61af66fc99e Initial load
duke
parents:
diff changeset
630 //
a61af66fc99e Initial load
duke
parents:
diff changeset
631 // 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
632 ciConstant ciEnv::get_constant_by_index(constantPoolHandle cpool,
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
633 int pool_index, int cache_index,
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
634 ciInstanceKlass* accessor) {
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1552
diff changeset
635 GUARDED_VM_ENTRY(return get_constant_by_index_impl(cpool, pool_index, cache_index, accessor);)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
636 }
a61af66fc99e Initial load
duke
parents:
diff changeset
637
a61af66fc99e Initial load
duke
parents:
diff changeset
638 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
639 // ciEnv::get_field_by_index_impl
a61af66fc99e Initial load
duke
parents:
diff changeset
640 //
a61af66fc99e Initial load
duke
parents:
diff changeset
641 // Implementation of get_field_by_index.
a61af66fc99e Initial load
duke
parents:
diff changeset
642 //
a61af66fc99e Initial load
duke
parents:
diff changeset
643 // Implementation note: the results of field lookups are cached
a61af66fc99e Initial load
duke
parents:
diff changeset
644 // in the accessor klass.
a61af66fc99e Initial load
duke
parents:
diff changeset
645 ciField* ciEnv::get_field_by_index_impl(ciInstanceKlass* accessor,
a61af66fc99e Initial load
duke
parents:
diff changeset
646 int index) {
a61af66fc99e Initial load
duke
parents:
diff changeset
647 ciConstantPoolCache* cache = accessor->field_cache();
a61af66fc99e Initial load
duke
parents:
diff changeset
648 if (cache == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
649 ciField* field = new (arena()) ciField(accessor, index);
a61af66fc99e Initial load
duke
parents:
diff changeset
650 return field;
a61af66fc99e Initial load
duke
parents:
diff changeset
651 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
652 ciField* field = (ciField*)cache->get(index);
a61af66fc99e Initial load
duke
parents:
diff changeset
653 if (field == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
654 field = new (arena()) ciField(accessor, index);
a61af66fc99e Initial load
duke
parents:
diff changeset
655 cache->insert(index, field);
a61af66fc99e Initial load
duke
parents:
diff changeset
656 }
a61af66fc99e Initial load
duke
parents:
diff changeset
657 return field;
a61af66fc99e Initial load
duke
parents:
diff changeset
658 }
a61af66fc99e Initial load
duke
parents:
diff changeset
659 }
a61af66fc99e Initial load
duke
parents:
diff changeset
660
a61af66fc99e Initial load
duke
parents:
diff changeset
661 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
662 // ciEnv::get_field_by_index
a61af66fc99e Initial load
duke
parents:
diff changeset
663 //
a61af66fc99e Initial load
duke
parents:
diff changeset
664 // Get a field by index from a klass's constant pool.
a61af66fc99e Initial load
duke
parents:
diff changeset
665 ciField* ciEnv::get_field_by_index(ciInstanceKlass* accessor,
a61af66fc99e Initial load
duke
parents:
diff changeset
666 int index) {
a61af66fc99e Initial load
duke
parents:
diff changeset
667 GUARDED_VM_ENTRY(return get_field_by_index_impl(accessor, index);)
a61af66fc99e Initial load
duke
parents:
diff changeset
668 }
a61af66fc99e Initial load
duke
parents:
diff changeset
669
a61af66fc99e Initial load
duke
parents:
diff changeset
670 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
671 // ciEnv::lookup_method
a61af66fc99e Initial load
duke
parents:
diff changeset
672 //
a61af66fc99e Initial load
duke
parents:
diff changeset
673 // Perform an appropriate method lookup based on accessor, holder,
a61af66fc99e Initial load
duke
parents:
diff changeset
674 // name, signature, and bytecode.
a61af66fc99e Initial load
duke
parents:
diff changeset
675 methodOop ciEnv::lookup_method(instanceKlass* accessor,
a61af66fc99e Initial load
duke
parents:
diff changeset
676 instanceKlass* holder,
a61af66fc99e Initial load
duke
parents:
diff changeset
677 symbolOop name,
a61af66fc99e Initial load
duke
parents:
diff changeset
678 symbolOop sig,
a61af66fc99e Initial load
duke
parents:
diff changeset
679 Bytecodes::Code bc) {
a61af66fc99e Initial load
duke
parents:
diff changeset
680 EXCEPTION_CONTEXT;
a61af66fc99e Initial load
duke
parents:
diff changeset
681 KlassHandle h_accessor(THREAD, accessor);
a61af66fc99e Initial load
duke
parents:
diff changeset
682 KlassHandle h_holder(THREAD, holder);
a61af66fc99e Initial load
duke
parents:
diff changeset
683 symbolHandle h_name(THREAD, name);
a61af66fc99e Initial load
duke
parents:
diff changeset
684 symbolHandle h_sig(THREAD, sig);
a61af66fc99e Initial load
duke
parents:
diff changeset
685 LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL));
a61af66fc99e Initial load
duke
parents:
diff changeset
686 methodHandle dest_method;
a61af66fc99e Initial load
duke
parents:
diff changeset
687 switch (bc) {
a61af66fc99e Initial load
duke
parents:
diff changeset
688 case Bytecodes::_invokestatic:
a61af66fc99e Initial load
duke
parents:
diff changeset
689 dest_method =
a61af66fc99e Initial load
duke
parents:
diff changeset
690 LinkResolver::resolve_static_call_or_null(h_holder, h_name, h_sig, h_accessor);
a61af66fc99e Initial load
duke
parents:
diff changeset
691 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
692 case Bytecodes::_invokespecial:
a61af66fc99e Initial load
duke
parents:
diff changeset
693 dest_method =
a61af66fc99e Initial load
duke
parents:
diff changeset
694 LinkResolver::resolve_special_call_or_null(h_holder, h_name, h_sig, h_accessor);
a61af66fc99e Initial load
duke
parents:
diff changeset
695 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
696 case Bytecodes::_invokeinterface:
a61af66fc99e Initial load
duke
parents:
diff changeset
697 dest_method =
a61af66fc99e Initial load
duke
parents:
diff changeset
698 LinkResolver::linktime_resolve_interface_method_or_null(h_holder, h_name, h_sig,
a61af66fc99e Initial load
duke
parents:
diff changeset
699 h_accessor, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
700 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
701 case Bytecodes::_invokevirtual:
a61af66fc99e Initial load
duke
parents:
diff changeset
702 dest_method =
a61af66fc99e Initial load
duke
parents:
diff changeset
703 LinkResolver::linktime_resolve_virtual_method_or_null(h_holder, h_name, h_sig,
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 default: ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
707 }
a61af66fc99e Initial load
duke
parents:
diff changeset
708
a61af66fc99e Initial load
duke
parents:
diff changeset
709 return dest_method();
a61af66fc99e Initial load
duke
parents:
diff changeset
710 }
a61af66fc99e Initial load
duke
parents:
diff changeset
711
a61af66fc99e Initial load
duke
parents:
diff changeset
712
a61af66fc99e Initial load
duke
parents:
diff changeset
713 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
714 // ciEnv::get_method_by_index_impl
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
715 ciMethod* ciEnv::get_method_by_index_impl(constantPoolHandle cpool,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
716 int index, Bytecodes::Code bc,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
717 ciInstanceKlass* accessor) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
718 int holder_index = cpool->klass_ref_index_at(index);
a61af66fc99e Initial load
duke
parents:
diff changeset
719 bool holder_is_accessible;
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
720 ciKlass* holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
721 ciInstanceKlass* declared_holder = get_instance_klass_for_declared_method_holder(holder);
a61af66fc99e Initial load
duke
parents:
diff changeset
722
a61af66fc99e Initial load
duke
parents:
diff changeset
723 // Get the method's name and signature.
a61af66fc99e Initial load
duke
parents:
diff changeset
724 symbolOop name_sym = cpool->name_ref_at(index);
1059
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 989
diff changeset
725 symbolOop sig_sym = cpool->signature_ref_at(index);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
726
a61af66fc99e Initial load
duke
parents:
diff changeset
727 if (holder_is_accessible) { // Our declared holder is loaded.
a61af66fc99e Initial load
duke
parents:
diff changeset
728 instanceKlass* lookup = declared_holder->get_instanceKlass();
a61af66fc99e Initial load
duke
parents:
diff changeset
729 methodOop m = lookup_method(accessor->get_instanceKlass(), lookup, name_sym, sig_sym, bc);
a61af66fc99e Initial load
duke
parents:
diff changeset
730 if (m != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
731 // We found the method.
a61af66fc99e Initial load
duke
parents:
diff changeset
732 return get_object(m)->as_method();
a61af66fc99e Initial load
duke
parents:
diff changeset
733 }
a61af66fc99e Initial load
duke
parents:
diff changeset
734 }
a61af66fc99e Initial load
duke
parents:
diff changeset
735
a61af66fc99e Initial load
duke
parents:
diff changeset
736 // Either the declared holder was not loaded, or the method could
a61af66fc99e Initial load
duke
parents:
diff changeset
737 // not be found. Create a dummy ciMethod to represent the failed
a61af66fc99e Initial load
duke
parents:
diff changeset
738 // lookup.
a61af66fc99e Initial load
duke
parents:
diff changeset
739
a61af66fc99e Initial load
duke
parents:
diff changeset
740 return get_unloaded_method(declared_holder,
a61af66fc99e Initial load
duke
parents:
diff changeset
741 get_object(name_sym)->as_symbol(),
a61af66fc99e Initial load
duke
parents:
diff changeset
742 get_object(sig_sym)->as_symbol());
a61af66fc99e Initial load
duke
parents:
diff changeset
743 }
a61af66fc99e Initial load
duke
parents:
diff changeset
744
a61af66fc99e Initial load
duke
parents:
diff changeset
745
a61af66fc99e Initial load
duke
parents:
diff changeset
746 // ------------------------------------------------------------------
1137
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
747 // ciEnv::get_fake_invokedynamic_method_impl
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
748 ciMethod* ciEnv::get_fake_invokedynamic_method_impl(constantPoolHandle cpool,
1137
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
749 int index, Bytecodes::Code bc) {
1507
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
750 // Compare the following logic with InterpreterRuntime::resolve_invokedynamic.
1137
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
751 assert(bc == Bytecodes::_invokedynamic, "must be invokedynamic");
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
752
1507
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
753 bool is_resolved = cpool->cache()->main_entry_at(index)->is_resolved(bc);
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
754 if (is_resolved && (oop) cpool->cache()->secondary_entry_at(index)->f1() == NULL)
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
755 // FIXME: code generation could allow for null (unlinked) call site
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
756 is_resolved = false;
1137
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 // 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
759 // 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
760 if (!is_resolved) {
1137
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
761 ciInstanceKlass* mh_klass = get_object(SystemDictionary::MethodHandle_klass())->as_instance_klass();
1507
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
762 ciSymbol* sig_sym = get_object(cpool->signature_ref_at(index))->as_symbol();
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
763 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
764 }
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
765
1507
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
766 // Get the invoker methodOop from the constant pool.
1662
e0ba4e04c839 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 1602
diff changeset
767 oop f1_value = cpool->cache()->main_entry_at(index)->f1();
e0ba4e04c839 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 1602
diff changeset
768 methodOop signature_invoker = methodOop(f1_value);
1507
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
769 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
770 "correct result from LinkResolver::resolve_invokedynamic");
1137
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
771
1507
cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 1397
diff changeset
772 return get_object(signature_invoker)->as_method();
1137
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
773 }
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
774
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
775
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
776 // ------------------------------------------------------------------
0
a61af66fc99e Initial load
duke
parents:
diff changeset
777 // ciEnv::get_instance_klass_for_declared_method_holder
a61af66fc99e Initial load
duke
parents:
diff changeset
778 ciInstanceKlass* ciEnv::get_instance_klass_for_declared_method_holder(ciKlass* method_holder) {
a61af66fc99e Initial load
duke
parents:
diff changeset
779 // For the case of <array>.clone(), the method holder can be a ciArrayKlass
a61af66fc99e Initial load
duke
parents:
diff changeset
780 // instead of a ciInstanceKlass. For that case simply pretend that the
a61af66fc99e Initial load
duke
parents:
diff changeset
781 // declared holder is Object.clone since that's where the call will bottom out.
a61af66fc99e Initial load
duke
parents:
diff changeset
782 // A more correct fix would trickle out through many interfaces in CI,
a61af66fc99e Initial load
duke
parents:
diff changeset
783 // requiring ciInstanceKlass* to become ciKlass* and many more places would
a61af66fc99e Initial load
duke
parents:
diff changeset
784 // require checks to make sure the expected type was found. Given that this
a61af66fc99e Initial load
duke
parents:
diff changeset
785 // only occurs for clone() the more extensive fix seems like overkill so
a61af66fc99e Initial load
duke
parents:
diff changeset
786 // instead we simply smear the array type into Object.
a61af66fc99e Initial load
duke
parents:
diff changeset
787 if (method_holder->is_instance_klass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
788 return method_holder->as_instance_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
789 } else if (method_holder->is_array_klass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
790 return current()->Object_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
791 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
792 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
793 }
a61af66fc99e Initial load
duke
parents:
diff changeset
794 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
795 }
a61af66fc99e Initial load
duke
parents:
diff changeset
796
a61af66fc99e Initial load
duke
parents:
diff changeset
797
a61af66fc99e Initial load
duke
parents:
diff changeset
798 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
799 // ciEnv::get_method_by_index
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
800 ciMethod* ciEnv::get_method_by_index(constantPoolHandle cpool,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
801 int index, Bytecodes::Code bc,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
802 ciInstanceKlass* accessor) {
1137
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
803 if (bc == Bytecodes::_invokedynamic) {
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
804 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
805 } else {
1138
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2
twisti
parents: 1137
diff changeset
806 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
807 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
808 }
a61af66fc99e Initial load
duke
parents:
diff changeset
809
1137
97125851f396 6829187: compiler optimizations required for JSR 292
twisti
parents: 1080
diff changeset
810
0
a61af66fc99e Initial load
duke
parents:
diff changeset
811 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
812 // ciEnv::name_buffer
a61af66fc99e Initial load
duke
parents:
diff changeset
813 char *ciEnv::name_buffer(int req_len) {
a61af66fc99e Initial load
duke
parents:
diff changeset
814 if (_name_buffer_len < req_len) {
a61af66fc99e Initial load
duke
parents:
diff changeset
815 if (_name_buffer == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
816 _name_buffer = (char*)arena()->Amalloc(sizeof(char)*req_len);
a61af66fc99e Initial load
duke
parents:
diff changeset
817 _name_buffer_len = req_len;
a61af66fc99e Initial load
duke
parents:
diff changeset
818 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
819 _name_buffer =
a61af66fc99e Initial load
duke
parents:
diff changeset
820 (char*)arena()->Arealloc(_name_buffer, _name_buffer_len, req_len);
a61af66fc99e Initial load
duke
parents:
diff changeset
821 _name_buffer_len = req_len;
a61af66fc99e Initial load
duke
parents:
diff changeset
822 }
a61af66fc99e Initial load
duke
parents:
diff changeset
823 }
a61af66fc99e Initial load
duke
parents:
diff changeset
824 return _name_buffer;
a61af66fc99e Initial load
duke
parents:
diff changeset
825 }
a61af66fc99e Initial load
duke
parents:
diff changeset
826
a61af66fc99e Initial load
duke
parents:
diff changeset
827 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
828 // ciEnv::is_in_vm
a61af66fc99e Initial load
duke
parents:
diff changeset
829 bool ciEnv::is_in_vm() {
a61af66fc99e Initial load
duke
parents:
diff changeset
830 return JavaThread::current()->thread_state() == _thread_in_vm;
a61af66fc99e Initial load
duke
parents:
diff changeset
831 }
a61af66fc99e Initial load
duke
parents:
diff changeset
832
a61af66fc99e Initial load
duke
parents:
diff changeset
833 bool ciEnv::system_dictionary_modification_counter_changed() {
a61af66fc99e Initial load
duke
parents:
diff changeset
834 return _system_dictionary_modification_counter != SystemDictionary::number_of_modifications();
a61af66fc99e Initial load
duke
parents:
diff changeset
835 }
a61af66fc99e Initial load
duke
parents:
diff changeset
836
a61af66fc99e Initial load
duke
parents:
diff changeset
837 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
838 // ciEnv::check_for_system_dictionary_modification
a61af66fc99e Initial load
duke
parents:
diff changeset
839 // Check for changes to the system dictionary during compilation
a61af66fc99e Initial load
duke
parents:
diff changeset
840 // class loads, evolution, breakpoints
a61af66fc99e Initial load
duke
parents:
diff changeset
841 void ciEnv::check_for_system_dictionary_modification(ciMethod* target) {
a61af66fc99e Initial load
duke
parents:
diff changeset
842 if (failing()) return; // no need for further checks
a61af66fc99e Initial load
duke
parents:
diff changeset
843
a61af66fc99e Initial load
duke
parents:
diff changeset
844 // Dependencies must be checked when the system dictionary changes.
a61af66fc99e Initial load
duke
parents:
diff changeset
845 // If logging is enabled all violated dependences will be recorded in
a61af66fc99e Initial load
duke
parents:
diff changeset
846 // the log. In debug mode check dependencies even if the system
a61af66fc99e Initial load
duke
parents:
diff changeset
847 // dictionary hasn't changed to verify that no invalid dependencies
a61af66fc99e Initial load
duke
parents:
diff changeset
848 // were inserted. Any violated dependences in this case are dumped to
a61af66fc99e Initial load
duke
parents:
diff changeset
849 // the tty.
a61af66fc99e Initial load
duke
parents:
diff changeset
850
a61af66fc99e Initial load
duke
parents:
diff changeset
851 bool counter_changed = system_dictionary_modification_counter_changed();
a61af66fc99e Initial load
duke
parents:
diff changeset
852 bool test_deps = counter_changed;
a61af66fc99e Initial load
duke
parents:
diff changeset
853 DEBUG_ONLY(test_deps = true);
a61af66fc99e Initial load
duke
parents:
diff changeset
854 if (!test_deps) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
855
a61af66fc99e Initial load
duke
parents:
diff changeset
856 bool print_failures = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
857 DEBUG_ONLY(print_failures = !counter_changed);
a61af66fc99e Initial load
duke
parents:
diff changeset
858
a61af66fc99e Initial load
duke
parents:
diff changeset
859 bool keep_going = (print_failures || xtty != NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
860
a61af66fc99e Initial load
duke
parents:
diff changeset
861 int violated = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
862
a61af66fc99e Initial load
duke
parents:
diff changeset
863 for (Dependencies::DepStream deps(dependencies()); deps.next(); ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
864 klassOop witness = deps.check_dependency();
a61af66fc99e Initial load
duke
parents:
diff changeset
865 if (witness != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
866 ++violated;
a61af66fc99e Initial load
duke
parents:
diff changeset
867 if (print_failures) deps.print_dependency(witness, /*verbose=*/ true);
a61af66fc99e Initial load
duke
parents:
diff changeset
868 // If there's no log and we're not sanity-checking, we're done.
a61af66fc99e Initial load
duke
parents:
diff changeset
869 if (!keep_going) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
870 }
a61af66fc99e Initial load
duke
parents:
diff changeset
871 }
a61af66fc99e Initial load
duke
parents:
diff changeset
872
a61af66fc99e Initial load
duke
parents:
diff changeset
873 if (violated != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
874 assert(counter_changed, "failed dependencies, but counter didn't change");
a61af66fc99e Initial load
duke
parents:
diff changeset
875 record_failure("concurrent class loading");
a61af66fc99e Initial load
duke
parents:
diff changeset
876 }
a61af66fc99e Initial load
duke
parents:
diff changeset
877 }
a61af66fc99e Initial load
duke
parents:
diff changeset
878
a61af66fc99e Initial load
duke
parents:
diff changeset
879 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
880 // ciEnv::register_method
a61af66fc99e Initial load
duke
parents:
diff changeset
881 void ciEnv::register_method(ciMethod* target,
a61af66fc99e Initial load
duke
parents:
diff changeset
882 int entry_bci,
a61af66fc99e Initial load
duke
parents:
diff changeset
883 CodeOffsets* offsets,
a61af66fc99e Initial load
duke
parents:
diff changeset
884 int orig_pc_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
885 CodeBuffer* code_buffer,
a61af66fc99e Initial load
duke
parents:
diff changeset
886 int frame_words,
a61af66fc99e Initial load
duke
parents:
diff changeset
887 OopMapSet* oop_map_set,
a61af66fc99e Initial load
duke
parents:
diff changeset
888 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load
duke
parents:
diff changeset
889 ImplicitExceptionTable* inc_table,
a61af66fc99e Initial load
duke
parents:
diff changeset
890 AbstractCompiler* compiler,
a61af66fc99e Initial load
duke
parents:
diff changeset
891 int comp_level,
a61af66fc99e Initial load
duke
parents:
diff changeset
892 bool has_debug_info,
a61af66fc99e Initial load
duke
parents:
diff changeset
893 bool has_unsafe_access) {
a61af66fc99e Initial load
duke
parents:
diff changeset
894 VM_ENTRY_MARK;
a61af66fc99e Initial load
duke
parents:
diff changeset
895 nmethod* nm = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
896 {
a61af66fc99e Initial load
duke
parents:
diff changeset
897 // To prevent compile queue updates.
a61af66fc99e Initial load
duke
parents:
diff changeset
898 MutexLocker locker(MethodCompileQueue_lock, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
899
a61af66fc99e Initial load
duke
parents:
diff changeset
900 // Prevent SystemDictionary::add_to_hierarchy from running
a61af66fc99e Initial load
duke
parents:
diff changeset
901 // and invalidating our dependencies until we install this method.
a61af66fc99e Initial load
duke
parents:
diff changeset
902 MutexLocker ml(Compile_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
903
780
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
904 // 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
905 if (!failing() &&
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
906 ( (!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
907 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
908 (!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
909 JvmtiExport::can_access_local_variables()) ||
1213
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 1142
diff changeset
910 (!jvmti_can_post_on_exceptions() &&
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 1142
diff changeset
911 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
912 record_failure("Jvmti state change invalidated dependencies");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
913 }
a61af66fc99e Initial load
duke
parents:
diff changeset
914
780
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
915 // 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
916 if (!failing() &&
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
917 ( (!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
918 (!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
919 (!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
920 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
921 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
922
780
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
923 if (!failing()) {
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
924 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
925 // 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
926 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
927 }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
928
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
929 // 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
930 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
931
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 470
diff changeset
932 // 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
933 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
934 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
935
a61af66fc99e Initial load
duke
parents:
diff changeset
936 methodHandle method(THREAD, target->get_methodOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
937
a61af66fc99e Initial load
duke
parents:
diff changeset
938 if (failing()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
939 // While not a true deoptimization, it is a preemptive decompile.
a61af66fc99e Initial load
duke
parents:
diff changeset
940 methodDataOop mdo = method()->method_data();
a61af66fc99e Initial load
duke
parents:
diff changeset
941 if (mdo != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
942 mdo->inc_decompile_count();
a61af66fc99e Initial load
duke
parents:
diff changeset
943 }
a61af66fc99e Initial load
duke
parents:
diff changeset
944
a61af66fc99e Initial load
duke
parents:
diff changeset
945 // All buffers in the CodeBuffer are allocated in the CodeCache.
a61af66fc99e Initial load
duke
parents:
diff changeset
946 // If the code buffer is created on each compile attempt
a61af66fc99e Initial load
duke
parents:
diff changeset
947 // as in C2, then it must be freed.
a61af66fc99e Initial load
duke
parents:
diff changeset
948 code_buffer->free_blob();
a61af66fc99e Initial load
duke
parents:
diff changeset
949 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
950 }
a61af66fc99e Initial load
duke
parents:
diff changeset
951
a61af66fc99e Initial load
duke
parents:
diff changeset
952 assert(offsets->value(CodeOffsets::Deopt) != -1, "must have deopt entry");
a61af66fc99e Initial load
duke
parents:
diff changeset
953 assert(offsets->value(CodeOffsets::Exceptions) != -1, "must have exception entry");
a61af66fc99e Initial load
duke
parents:
diff changeset
954
a61af66fc99e Initial load
duke
parents:
diff changeset
955 nm = nmethod::new_nmethod(method,
a61af66fc99e Initial load
duke
parents:
diff changeset
956 compile_id(),
a61af66fc99e Initial load
duke
parents:
diff changeset
957 entry_bci,
a61af66fc99e Initial load
duke
parents:
diff changeset
958 offsets,
a61af66fc99e Initial load
duke
parents:
diff changeset
959 orig_pc_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
960 debug_info(), dependencies(), code_buffer,
a61af66fc99e Initial load
duke
parents:
diff changeset
961 frame_words, oop_map_set,
a61af66fc99e Initial load
duke
parents:
diff changeset
962 handler_table, inc_table,
a61af66fc99e Initial load
duke
parents:
diff changeset
963 compiler, comp_level);
a61af66fc99e Initial load
duke
parents:
diff changeset
964
a61af66fc99e Initial load
duke
parents:
diff changeset
965 // Free codeBlobs
a61af66fc99e Initial load
duke
parents:
diff changeset
966 code_buffer->free_blob();
a61af66fc99e Initial load
duke
parents:
diff changeset
967
a61af66fc99e Initial load
duke
parents:
diff changeset
968 // stress test 6243940 by immediately making the method
a61af66fc99e Initial load
duke
parents:
diff changeset
969 // non-entrant behind the system's back. This has serious
a61af66fc99e Initial load
duke
parents:
diff changeset
970 // side effects on the code cache and is not meant for
a61af66fc99e Initial load
duke
parents:
diff changeset
971 // general stress testing
a61af66fc99e Initial load
duke
parents:
diff changeset
972 if (nm != NULL && StressNonEntrant) {
a61af66fc99e Initial load
duke
parents:
diff changeset
973 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
974 NativeJump::patch_verified_entry(nm->entry_point(), nm->verified_entry_point(),
a61af66fc99e Initial load
duke
parents:
diff changeset
975 SharedRuntime::get_handle_wrong_method_stub());
a61af66fc99e Initial load
duke
parents:
diff changeset
976 }
a61af66fc99e Initial load
duke
parents:
diff changeset
977
a61af66fc99e Initial load
duke
parents:
diff changeset
978 if (nm == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
979 // The CodeCache is full. Print out warning and disable compilation.
a61af66fc99e Initial load
duke
parents:
diff changeset
980 record_failure("code cache is full");
1202
5f24d0319e54 4360113: Evict nmethods when code cache gets full
kvn
parents: 1142
diff changeset
981 {
5f24d0319e54 4360113: Evict nmethods when code cache gets full
kvn
parents: 1142
diff changeset
982 MutexUnlocker ml(Compile_lock);
5f24d0319e54 4360113: Evict nmethods when code cache gets full
kvn
parents: 1142
diff changeset
983 MutexUnlocker locker(MethodCompileQueue_lock);
5f24d0319e54 4360113: Evict nmethods when code cache gets full
kvn
parents: 1142
diff changeset
984 CompileBroker::handle_full_code_cache();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
985 }
a61af66fc99e Initial load
duke
parents:
diff changeset
986 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
987 NOT_PRODUCT(nm->set_has_debug_info(has_debug_info); )
a61af66fc99e Initial load
duke
parents:
diff changeset
988 nm->set_has_unsafe_access(has_unsafe_access);
a61af66fc99e Initial load
duke
parents:
diff changeset
989
a61af66fc99e Initial load
duke
parents:
diff changeset
990 // Record successful registration.
a61af66fc99e Initial load
duke
parents:
diff changeset
991 // (Put nm into the task handle *before* publishing to the Java heap.)
a61af66fc99e Initial load
duke
parents:
diff changeset
992 if (task() != NULL) task()->set_code(nm);
a61af66fc99e Initial load
duke
parents:
diff changeset
993
a61af66fc99e Initial load
duke
parents:
diff changeset
994 if (entry_bci == InvocationEntryBci) {
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
995 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
996 // If there is an old version we're done with it
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
997 nmethod* old = method->code();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
998 if (TraceMethodReplacement && old != NULL) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
999 ResourceMark rm;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
1000 char *method_name = method->name_and_sig_as_C_string();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
1001 tty->print_cr("Replacing method %s", method_name);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
1002 }
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
1003 if (old != NULL ) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
1004 old->make_not_entrant();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
1005 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1006 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1007 if (TraceNMethodInstalls ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1008 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
1009 char *method_name = method->name_and_sig_as_C_string();
a61af66fc99e Initial load
duke
parents:
diff changeset
1010 ttyLocker ttyl;
a61af66fc99e Initial load
duke
parents:
diff changeset
1011 tty->print_cr("Installing method (%d) %s ",
a61af66fc99e Initial load
duke
parents:
diff changeset
1012 comp_level,
a61af66fc99e Initial load
duke
parents:
diff changeset
1013 method_name);
a61af66fc99e Initial load
duke
parents:
diff changeset
1014 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1015 // Allow the code to be executed
a61af66fc99e Initial load
duke
parents:
diff changeset
1016 method->set_code(method, nm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1017 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1018 if (TraceNMethodInstalls ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1019 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
1020 char *method_name = method->name_and_sig_as_C_string();
a61af66fc99e Initial load
duke
parents:
diff changeset
1021 ttyLocker ttyl;
a61af66fc99e Initial load
duke
parents:
diff changeset
1022 tty->print_cr("Installing osr method (%d) %s @ %d",
a61af66fc99e Initial load
duke
parents:
diff changeset
1023 comp_level,
a61af66fc99e Initial load
duke
parents:
diff changeset
1024 method_name,
a61af66fc99e Initial load
duke
parents:
diff changeset
1025 entry_bci);
a61af66fc99e Initial load
duke
parents:
diff changeset
1026 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1027 instanceKlass::cast(method->method_holder())->add_osr_nmethod(nm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1028
a61af66fc99e Initial load
duke
parents:
diff changeset
1029 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1030 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1031 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1032 // JVMTI -- compiled method notification (must be done outside lock)
a61af66fc99e Initial load
duke
parents:
diff changeset
1033 if (nm != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1034 nm->post_compiled_method_load_event();
a61af66fc99e Initial load
duke
parents:
diff changeset
1035 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1036
a61af66fc99e Initial load
duke
parents:
diff changeset
1037 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1038
a61af66fc99e Initial load
duke
parents:
diff changeset
1039
a61af66fc99e Initial load
duke
parents:
diff changeset
1040 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1041 // ciEnv::find_system_klass
a61af66fc99e Initial load
duke
parents:
diff changeset
1042 ciKlass* ciEnv::find_system_klass(ciSymbol* klass_name) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1043 VM_ENTRY_MARK;
a61af66fc99e Initial load
duke
parents:
diff changeset
1044 return get_klass_by_name_impl(NULL, klass_name, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
1045 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1046
a61af66fc99e Initial load
duke
parents:
diff changeset
1047 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1048 // ciEnv::comp_level
a61af66fc99e Initial load
duke
parents:
diff changeset
1049 int ciEnv::comp_level() {
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1662
diff changeset
1050 if (task() == NULL) return CompLevel_highest_tier;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1051 return task()->comp_level();
a61af66fc99e Initial load
duke
parents:
diff changeset
1052 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1053
a61af66fc99e Initial load
duke
parents:
diff changeset
1054 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1055 // ciEnv::compile_id
a61af66fc99e Initial load
duke
parents:
diff changeset
1056 uint ciEnv::compile_id() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1057 if (task() == NULL) return 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1058 return task()->compile_id();
a61af66fc99e Initial load
duke
parents:
diff changeset
1059 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1060
a61af66fc99e Initial load
duke
parents:
diff changeset
1061 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1062 // ciEnv::notice_inlined_method()
a61af66fc99e Initial load
duke
parents:
diff changeset
1063 void ciEnv::notice_inlined_method(ciMethod* method) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1064 _num_inlined_bytecodes += method->code_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
1065 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1066
a61af66fc99e Initial load
duke
parents:
diff changeset
1067 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1068 // ciEnv::num_inlined_bytecodes()
a61af66fc99e Initial load
duke
parents:
diff changeset
1069 int ciEnv::num_inlined_bytecodes() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
1070 return _num_inlined_bytecodes;
a61af66fc99e Initial load
duke
parents:
diff changeset
1071 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1072
a61af66fc99e Initial load
duke
parents:
diff changeset
1073 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1074 // ciEnv::record_failure()
a61af66fc99e Initial load
duke
parents:
diff changeset
1075 void ciEnv::record_failure(const char* reason) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1076 if (log() != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1077 log()->elem("failure reason='%s'", reason);
a61af66fc99e Initial load
duke
parents:
diff changeset
1078 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1079 if (_failure_reason == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1080 // Record the first failure reason.
a61af66fc99e Initial load
duke
parents:
diff changeset
1081 _failure_reason = reason;
a61af66fc99e Initial load
duke
parents:
diff changeset
1082 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1083 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1084
a61af66fc99e Initial load
duke
parents:
diff changeset
1085 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1086 // ciEnv::record_method_not_compilable()
a61af66fc99e Initial load
duke
parents:
diff changeset
1087 void ciEnv::record_method_not_compilable(const char* reason, bool all_tiers) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1088 int new_compilable =
a61af66fc99e Initial load
duke
parents:
diff changeset
1089 all_tiers ? MethodCompilable_never : MethodCompilable_not_at_tier ;
a61af66fc99e Initial load
duke
parents:
diff changeset
1090
a61af66fc99e Initial load
duke
parents:
diff changeset
1091 // Only note transitions to a worse state
a61af66fc99e Initial load
duke
parents:
diff changeset
1092 if (new_compilable > _compilable) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1093 if (log() != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1094 if (all_tiers) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1095 log()->elem("method_not_compilable");
a61af66fc99e Initial load
duke
parents:
diff changeset
1096 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1097 log()->elem("method_not_compilable_at_tier");
a61af66fc99e Initial load
duke
parents:
diff changeset
1098 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1099 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1100 _compilable = new_compilable;
a61af66fc99e Initial load
duke
parents:
diff changeset
1101
a61af66fc99e Initial load
duke
parents:
diff changeset
1102 // Reset failure reason; this one is more important.
a61af66fc99e Initial load
duke
parents:
diff changeset
1103 _failure_reason = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1104 record_failure(reason);
a61af66fc99e Initial load
duke
parents:
diff changeset
1105 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1106 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1107
a61af66fc99e Initial load
duke
parents:
diff changeset
1108 // ------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1109 // ciEnv::record_out_of_memory_failure()
a61af66fc99e Initial load
duke
parents:
diff changeset
1110 void ciEnv::record_out_of_memory_failure() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1111 // If memory is low, we stop compiling methods.
a61af66fc99e Initial load
duke
parents:
diff changeset
1112 record_method_not_compilable("out of memory");
a61af66fc99e Initial load
duke
parents:
diff changeset
1113 }