annotate src/share/vm/opto/runtime.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 3582bf76420e
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: 1368
diff changeset
2 * Copyright (c) 1998, 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: 1368
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1368
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: 1368
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: 1844
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
27 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
28 #include "code/compiledIC.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
29 #include "code/icBuffer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
30 #include "code/nmethod.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
31 #include "code/pcDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
32 #include "code/scopeDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
33 #include "code/vtableStubs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
34 #include "compiler/compileBroker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
35 #include "compiler/compilerOracle.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
36 #include "compiler/oopMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
37 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
38 #include "gc_implementation/g1/heapRegion.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
39 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
40 #include "interpreter/bytecode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
41 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
42 #include "interpreter/linkResolver.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
43 #include "memory/barrierSet.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
44 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
45 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
46 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
47 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
48 #include "opto/addnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
49 #include "opto/callnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
50 #include "opto/cfgnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
51 #include "opto/connode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
52 #include "opto/graphKit.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
53 #include "opto/machnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
54 #include "opto/matcher.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
55 #include "opto/memnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
56 #include "opto/mulnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
57 #include "opto/runtime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
58 #include "opto/subnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
59 #include "runtime/fprofiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
60 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
61 #include "runtime/interfaceSupport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
62 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
63 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
64 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
65 #include "runtime/threadCritical.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
66 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
67 #include "runtime/vframeArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
68 #include "runtime/vframe_hp.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
69 #include "utilities/copy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
70 #include "utilities/preserveException.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
71 #ifdef TARGET_ARCH_MODEL_x86_32
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
72 # include "adfiles/ad_x86_32.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
73 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
74 #ifdef TARGET_ARCH_MODEL_x86_64
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
75 # include "adfiles/ad_x86_64.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
76 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
77 #ifdef TARGET_ARCH_MODEL_sparc
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
78 # include "adfiles/ad_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
79 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
80 #ifdef TARGET_ARCH_MODEL_zero
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
81 # include "adfiles/ad_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
82 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
83
a61af66fc99e Initial load
duke
parents:
diff changeset
84
a61af66fc99e Initial load
duke
parents:
diff changeset
85 // For debugging purposes:
a61af66fc99e Initial load
duke
parents:
diff changeset
86 // To force FullGCALot inside a runtime function, add the following two lines
a61af66fc99e Initial load
duke
parents:
diff changeset
87 //
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // Universe::release_fullgc_alot_dummy();
a61af66fc99e Initial load
duke
parents:
diff changeset
89 // MarkSweep::invoke(0, "Debugging");
a61af66fc99e Initial load
duke
parents:
diff changeset
90 //
a61af66fc99e Initial load
duke
parents:
diff changeset
91 // At command line specify the parameters: -XX:+FullGCALot -XX:FullGCALotStart=100000000
a61af66fc99e Initial load
duke
parents:
diff changeset
92
a61af66fc99e Initial load
duke
parents:
diff changeset
93
a61af66fc99e Initial load
duke
parents:
diff changeset
94
a61af66fc99e Initial load
duke
parents:
diff changeset
95
a61af66fc99e Initial load
duke
parents:
diff changeset
96 // Compiled code entry points
a61af66fc99e Initial load
duke
parents:
diff changeset
97 address OptoRuntime::_new_instance_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
98 address OptoRuntime::_new_array_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
99 address OptoRuntime::_multianewarray2_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
100 address OptoRuntime::_multianewarray3_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
101 address OptoRuntime::_multianewarray4_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
102 address OptoRuntime::_multianewarray5_Java = NULL;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
103 address OptoRuntime::_g1_wb_pre_Java = NULL;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
104 address OptoRuntime::_g1_wb_post_Java = NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
105 address OptoRuntime::_vtable_must_compile_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
106 address OptoRuntime::_complete_monitor_locking_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
107 address OptoRuntime::_rethrow_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
108
a61af66fc99e Initial load
duke
parents:
diff changeset
109 address OptoRuntime::_slow_arraycopy_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
110 address OptoRuntime::_register_finalizer_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
111
a61af66fc99e Initial load
duke
parents:
diff changeset
112 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load
duke
parents:
diff changeset
113 address OptoRuntime::_zap_dead_Java_locals_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
114 address OptoRuntime::_zap_dead_native_locals_Java = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
115 # endif
a61af66fc99e Initial load
duke
parents:
diff changeset
116
a61af66fc99e Initial load
duke
parents:
diff changeset
117
a61af66fc99e Initial load
duke
parents:
diff changeset
118 // This should be called in an assertion at the start of OptoRuntime routines
a61af66fc99e Initial load
duke
parents:
diff changeset
119 // which are entered from compiled code (all of them)
a61af66fc99e Initial load
duke
parents:
diff changeset
120 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
121 static bool check_compiled_frame(JavaThread* thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
122 assert(thread->last_frame().is_runtime_frame(), "cannot call runtime directly from compiled code");
a61af66fc99e Initial load
duke
parents:
diff changeset
123 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
124 RegisterMap map(thread, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
125 frame caller = thread->last_frame().sender(&map);
a61af66fc99e Initial load
duke
parents:
diff changeset
126 assert(caller.is_compiled_frame(), "not being called from compiled like code");
a61af66fc99e Initial load
duke
parents:
diff changeset
127 #endif /* ASSERT */
a61af66fc99e Initial load
duke
parents:
diff changeset
128 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
129 }
a61af66fc99e Initial load
duke
parents:
diff changeset
130 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
131
a61af66fc99e Initial load
duke
parents:
diff changeset
132
a61af66fc99e Initial load
duke
parents:
diff changeset
133 #define gen(env, var, type_func_gen, c_func, fancy_jump, pass_tls, save_arg_regs, return_pc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
134 var = generate_stub(env, type_func_gen, CAST_FROM_FN_PTR(address, c_func), #var, fancy_jump, pass_tls, save_arg_regs, return_pc)
a61af66fc99e Initial load
duke
parents:
diff changeset
135
a61af66fc99e Initial load
duke
parents:
diff changeset
136 void OptoRuntime::generate(ciEnv* env) {
a61af66fc99e Initial load
duke
parents:
diff changeset
137
a61af66fc99e Initial load
duke
parents:
diff changeset
138 generate_exception_blob();
a61af66fc99e Initial load
duke
parents:
diff changeset
139
a61af66fc99e Initial load
duke
parents:
diff changeset
140 // Note: tls: Means fetching the return oop out of the thread-local storage
a61af66fc99e Initial load
duke
parents:
diff changeset
141 //
a61af66fc99e Initial load
duke
parents:
diff changeset
142 // variable/name type-function-gen , runtime method ,fncy_jp, tls,save_args,retpc
a61af66fc99e Initial load
duke
parents:
diff changeset
143 // -------------------------------------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
144 gen(env, _new_instance_Java , new_instance_Type , new_instance_C , 0 , true , false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
145 gen(env, _new_array_Java , new_array_Type , new_array_C , 0 , true , false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
146 gen(env, _multianewarray2_Java , multianewarray2_Type , multianewarray2_C , 0 , true , false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
147 gen(env, _multianewarray3_Java , multianewarray3_Type , multianewarray3_C , 0 , true , false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
148 gen(env, _multianewarray4_Java , multianewarray4_Type , multianewarray4_C , 0 , true , false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
149 gen(env, _multianewarray5_Java , multianewarray5_Type , multianewarray5_C , 0 , true , false, false);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
150 gen(env, _g1_wb_pre_Java , g1_wb_pre_Type , SharedRuntime::g1_wb_pre , 0 , false, false, false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
151 gen(env, _g1_wb_post_Java , g1_wb_post_Type , SharedRuntime::g1_wb_post , 0 , false, false, false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
152 gen(env, _complete_monitor_locking_Java , complete_monitor_enter_Type , SharedRuntime::complete_monitor_locking_C , 0 , false, false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
153 gen(env, _rethrow_Java , rethrow_Type , rethrow_C , 2 , true , false, true );
a61af66fc99e Initial load
duke
parents:
diff changeset
154
a61af66fc99e Initial load
duke
parents:
diff changeset
155 gen(env, _slow_arraycopy_Java , slow_arraycopy_Type , SharedRuntime::slow_arraycopy_C , 0 , false, false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
156 gen(env, _register_finalizer_Java , register_finalizer_Type , register_finalizer , 0 , false, false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
157
a61af66fc99e Initial load
duke
parents:
diff changeset
158 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load
duke
parents:
diff changeset
159 gen(env, _zap_dead_Java_locals_Java , zap_dead_locals_Type , zap_dead_Java_locals_C , 0 , false, true , false );
a61af66fc99e Initial load
duke
parents:
diff changeset
160 gen(env, _zap_dead_native_locals_Java , zap_dead_locals_Type , zap_dead_native_locals_C , 0 , false, true , false );
a61af66fc99e Initial load
duke
parents:
diff changeset
161 # endif
a61af66fc99e Initial load
duke
parents:
diff changeset
162
a61af66fc99e Initial load
duke
parents:
diff changeset
163 }
a61af66fc99e Initial load
duke
parents:
diff changeset
164
a61af66fc99e Initial load
duke
parents:
diff changeset
165 #undef gen
a61af66fc99e Initial load
duke
parents:
diff changeset
166
a61af66fc99e Initial load
duke
parents:
diff changeset
167
a61af66fc99e Initial load
duke
parents:
diff changeset
168 // Helper method to do generation of RunTimeStub's
a61af66fc99e Initial load
duke
parents:
diff changeset
169 address OptoRuntime::generate_stub( ciEnv* env,
a61af66fc99e Initial load
duke
parents:
diff changeset
170 TypeFunc_generator gen, address C_function,
a61af66fc99e Initial load
duke
parents:
diff changeset
171 const char *name, int is_fancy_jump,
a61af66fc99e Initial load
duke
parents:
diff changeset
172 bool pass_tls,
a61af66fc99e Initial load
duke
parents:
diff changeset
173 bool save_argument_registers,
a61af66fc99e Initial load
duke
parents:
diff changeset
174 bool return_pc ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
175 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
176 Compile C( env, gen, C_function, name, is_fancy_jump, pass_tls, save_argument_registers, return_pc );
a61af66fc99e Initial load
duke
parents:
diff changeset
177 return C.stub_entry_point();
a61af66fc99e Initial load
duke
parents:
diff changeset
178 }
a61af66fc99e Initial load
duke
parents:
diff changeset
179
a61af66fc99e Initial load
duke
parents:
diff changeset
180 const char* OptoRuntime::stub_name(address entry) {
a61af66fc99e Initial load
duke
parents:
diff changeset
181 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
182 CodeBlob* cb = CodeCache::find_blob(entry);
a61af66fc99e Initial load
duke
parents:
diff changeset
183 RuntimeStub* rs =(RuntimeStub *)cb;
a61af66fc99e Initial load
duke
parents:
diff changeset
184 assert(rs != NULL && rs->is_runtime_stub(), "not a runtime stub");
a61af66fc99e Initial load
duke
parents:
diff changeset
185 return rs->name();
a61af66fc99e Initial load
duke
parents:
diff changeset
186 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
187 // Fast implementation for product mode (maybe it should be inlined too)
a61af66fc99e Initial load
duke
parents:
diff changeset
188 return "runtime stub";
a61af66fc99e Initial load
duke
parents:
diff changeset
189 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
190 }
a61af66fc99e Initial load
duke
parents:
diff changeset
191
a61af66fc99e Initial load
duke
parents:
diff changeset
192
a61af66fc99e Initial load
duke
parents:
diff changeset
193 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
194 // Opto compiler runtime routines
a61af66fc99e Initial load
duke
parents:
diff changeset
195 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
196
a61af66fc99e Initial load
duke
parents:
diff changeset
197
a61af66fc99e Initial load
duke
parents:
diff changeset
198 //=============================allocation======================================
a61af66fc99e Initial load
duke
parents:
diff changeset
199 // We failed the fast-path allocation. Now we need to do a scavenge or GC
a61af66fc99e Initial load
duke
parents:
diff changeset
200 // and try allocation again.
a61af66fc99e Initial load
duke
parents:
diff changeset
201
1166
7b0e9cba0307 6896647: card marks can be deferred too long
ysr
parents: 1142
diff changeset
202 void OptoRuntime::new_store_pre_barrier(JavaThread* thread) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
203 // After any safepoint, just before going back to compiled code,
1027
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 605
diff changeset
204 // we inform the GC that we will be doing initializing writes to
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 605
diff changeset
205 // this object in the future without emitting card-marks, so
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 605
diff changeset
206 // GC may take any compensating steps.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 605
diff changeset
207 // NOTE: Keep this code consistent with GraphKit::store_barrier.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
208
a61af66fc99e Initial load
duke
parents:
diff changeset
209 oop new_obj = thread->vm_result();
a61af66fc99e Initial load
duke
parents:
diff changeset
210 if (new_obj == NULL) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
211
a61af66fc99e Initial load
duke
parents:
diff changeset
212 assert(Universe::heap()->can_elide_tlab_store_barriers(),
a61af66fc99e Initial load
duke
parents:
diff changeset
213 "compiler must check this first");
1027
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 605
diff changeset
214 // GC may decide to give back a safer copy of new_obj.
1166
7b0e9cba0307 6896647: card marks can be deferred too long
ysr
parents: 1142
diff changeset
215 new_obj = Universe::heap()->new_store_pre_barrier(thread, new_obj);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
216 thread->set_vm_result(new_obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
217 }
a61af66fc99e Initial load
duke
parents:
diff changeset
218
a61af66fc99e Initial load
duke
parents:
diff changeset
219 // object allocation
a61af66fc99e Initial load
duke
parents:
diff changeset
220 JRT_BLOCK_ENTRY(void, OptoRuntime::new_instance_C(klassOopDesc* klass, JavaThread* thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
221 JRT_BLOCK;
a61af66fc99e Initial load
duke
parents:
diff changeset
222 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
223 SharedRuntime::_new_instance_ctr++; // new instance requires GC
a61af66fc99e Initial load
duke
parents:
diff changeset
224 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
225 assert(check_compiled_frame(thread), "incorrect caller");
a61af66fc99e Initial load
duke
parents:
diff changeset
226
a61af66fc99e Initial load
duke
parents:
diff changeset
227 // These checks are cheap to make and support reflective allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
228 int lh = Klass::cast(klass)->layout_helper();
a61af66fc99e Initial load
duke
parents:
diff changeset
229 if (Klass::layout_helper_needs_slow_path(lh)
a61af66fc99e Initial load
duke
parents:
diff changeset
230 || !instanceKlass::cast(klass)->is_initialized()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
231 KlassHandle kh(THREAD, klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
232 kh->check_valid_for_instantiation(false, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
233 if (!HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load
duke
parents:
diff changeset
234 instanceKlass::cast(kh())->initialize(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
235 }
a61af66fc99e Initial load
duke
parents:
diff changeset
236 if (!HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load
duke
parents:
diff changeset
237 klass = kh();
a61af66fc99e Initial load
duke
parents:
diff changeset
238 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
239 klass = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
240 }
a61af66fc99e Initial load
duke
parents:
diff changeset
241 }
a61af66fc99e Initial load
duke
parents:
diff changeset
242
a61af66fc99e Initial load
duke
parents:
diff changeset
243 if (klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
244 // Scavenge and allocate an instance.
a61af66fc99e Initial load
duke
parents:
diff changeset
245 oop result = instanceKlass::cast(klass)->allocate_instance(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
246 thread->set_vm_result(result);
a61af66fc99e Initial load
duke
parents:
diff changeset
247
a61af66fc99e Initial load
duke
parents:
diff changeset
248 // Pass oops back through thread local storage. Our apparent type to Java
a61af66fc99e Initial load
duke
parents:
diff changeset
249 // is that we return an oop, but we can block on exit from this routine and
a61af66fc99e Initial load
duke
parents:
diff changeset
250 // a GC can trash the oop in C's return register. The generated stub will
a61af66fc99e Initial load
duke
parents:
diff changeset
251 // fetch the oop from TLS after any possible GC.
a61af66fc99e Initial load
duke
parents:
diff changeset
252 }
a61af66fc99e Initial load
duke
parents:
diff changeset
253
a61af66fc99e Initial load
duke
parents:
diff changeset
254 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
a61af66fc99e Initial load
duke
parents:
diff changeset
255 JRT_BLOCK_END;
a61af66fc99e Initial load
duke
parents:
diff changeset
256
a61af66fc99e Initial load
duke
parents:
diff changeset
257 if (GraphKit::use_ReduceInitialCardMarks()) {
1027
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 605
diff changeset
258 // inform GC that we won't do card marks for initializing writes.
1166
7b0e9cba0307 6896647: card marks can be deferred too long
ysr
parents: 1142
diff changeset
259 new_store_pre_barrier(thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
260 }
a61af66fc99e Initial load
duke
parents:
diff changeset
261 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
262
a61af66fc99e Initial load
duke
parents:
diff changeset
263
a61af66fc99e Initial load
duke
parents:
diff changeset
264 // array allocation
a61af66fc99e Initial load
duke
parents:
diff changeset
265 JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_C(klassOopDesc* array_type, int len, JavaThread *thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
266 JRT_BLOCK;
a61af66fc99e Initial load
duke
parents:
diff changeset
267 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
268 SharedRuntime::_new_array_ctr++; // new array requires GC
a61af66fc99e Initial load
duke
parents:
diff changeset
269 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
270 assert(check_compiled_frame(thread), "incorrect caller");
a61af66fc99e Initial load
duke
parents:
diff changeset
271
a61af66fc99e Initial load
duke
parents:
diff changeset
272 // Scavenge and allocate an instance.
a61af66fc99e Initial load
duke
parents:
diff changeset
273 oop result;
a61af66fc99e Initial load
duke
parents:
diff changeset
274
a61af66fc99e Initial load
duke
parents:
diff changeset
275 if (Klass::cast(array_type)->oop_is_typeArray()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
276 // The oopFactory likes to work with the element type.
a61af66fc99e Initial load
duke
parents:
diff changeset
277 // (We could bypass the oopFactory, since it doesn't add much value.)
a61af66fc99e Initial load
duke
parents:
diff changeset
278 BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
279 result = oopFactory::new_typeArray(elem_type, len, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
280 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
281 // Although the oopFactory likes to work with the elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
282 // the compiler prefers the array_type, since it must already have
a61af66fc99e Initial load
duke
parents:
diff changeset
283 // that latter value in hand for the fast path.
a61af66fc99e Initial load
duke
parents:
diff changeset
284 klassOopDesc* elem_type = objArrayKlass::cast(array_type)->element_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
285 result = oopFactory::new_objArray(elem_type, len, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
286 }
a61af66fc99e Initial load
duke
parents:
diff changeset
287
a61af66fc99e Initial load
duke
parents:
diff changeset
288 // Pass oops back through thread local storage. Our apparent type to Java
a61af66fc99e Initial load
duke
parents:
diff changeset
289 // is that we return an oop, but we can block on exit from this routine and
a61af66fc99e Initial load
duke
parents:
diff changeset
290 // a GC can trash the oop in C's return register. The generated stub will
a61af66fc99e Initial load
duke
parents:
diff changeset
291 // fetch the oop from TLS after any possible GC.
a61af66fc99e Initial load
duke
parents:
diff changeset
292 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
a61af66fc99e Initial load
duke
parents:
diff changeset
293 thread->set_vm_result(result);
a61af66fc99e Initial load
duke
parents:
diff changeset
294 JRT_BLOCK_END;
a61af66fc99e Initial load
duke
parents:
diff changeset
295
a61af66fc99e Initial load
duke
parents:
diff changeset
296 if (GraphKit::use_ReduceInitialCardMarks()) {
1027
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 605
diff changeset
297 // inform GC that we won't do card marks for initializing writes.
1166
7b0e9cba0307 6896647: card marks can be deferred too long
ysr
parents: 1142
diff changeset
298 new_store_pre_barrier(thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
299 }
a61af66fc99e Initial load
duke
parents:
diff changeset
300 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
301
a61af66fc99e Initial load
duke
parents:
diff changeset
302 // Note: multianewarray for one dimension is handled inline by GraphKit::new_array.
a61af66fc99e Initial load
duke
parents:
diff changeset
303
a61af66fc99e Initial load
duke
parents:
diff changeset
304 // multianewarray for 2 dimensions
a61af66fc99e Initial load
duke
parents:
diff changeset
305 JRT_ENTRY(void, OptoRuntime::multianewarray2_C(klassOopDesc* elem_type, int len1, int len2, JavaThread *thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
306 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
307 SharedRuntime::_multi2_ctr++; // multianewarray for 1 dimension
a61af66fc99e Initial load
duke
parents:
diff changeset
308 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
309 assert(check_compiled_frame(thread), "incorrect caller");
a61af66fc99e Initial load
duke
parents:
diff changeset
310 assert(oop(elem_type)->is_klass(), "not a class");
a61af66fc99e Initial load
duke
parents:
diff changeset
311 jint dims[2];
a61af66fc99e Initial load
duke
parents:
diff changeset
312 dims[0] = len1;
a61af66fc99e Initial load
duke
parents:
diff changeset
313 dims[1] = len2;
a61af66fc99e Initial load
duke
parents:
diff changeset
314 oop obj = arrayKlass::cast(elem_type)->multi_allocate(2, dims, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
315 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
a61af66fc99e Initial load
duke
parents:
diff changeset
316 thread->set_vm_result(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
317 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
318
a61af66fc99e Initial load
duke
parents:
diff changeset
319 // multianewarray for 3 dimensions
a61af66fc99e Initial load
duke
parents:
diff changeset
320 JRT_ENTRY(void, OptoRuntime::multianewarray3_C(klassOopDesc* elem_type, int len1, int len2, int len3, JavaThread *thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
321 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
322 SharedRuntime::_multi3_ctr++; // multianewarray for 1 dimension
a61af66fc99e Initial load
duke
parents:
diff changeset
323 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
324 assert(check_compiled_frame(thread), "incorrect caller");
a61af66fc99e Initial load
duke
parents:
diff changeset
325 assert(oop(elem_type)->is_klass(), "not a class");
a61af66fc99e Initial load
duke
parents:
diff changeset
326 jint dims[3];
a61af66fc99e Initial load
duke
parents:
diff changeset
327 dims[0] = len1;
a61af66fc99e Initial load
duke
parents:
diff changeset
328 dims[1] = len2;
a61af66fc99e Initial load
duke
parents:
diff changeset
329 dims[2] = len3;
a61af66fc99e Initial load
duke
parents:
diff changeset
330 oop obj = arrayKlass::cast(elem_type)->multi_allocate(3, dims, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
331 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
a61af66fc99e Initial load
duke
parents:
diff changeset
332 thread->set_vm_result(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
333 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
334
a61af66fc99e Initial load
duke
parents:
diff changeset
335 // multianewarray for 4 dimensions
a61af66fc99e Initial load
duke
parents:
diff changeset
336 JRT_ENTRY(void, OptoRuntime::multianewarray4_C(klassOopDesc* elem_type, int len1, int len2, int len3, int len4, JavaThread *thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
337 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
338 SharedRuntime::_multi4_ctr++; // multianewarray for 1 dimension
a61af66fc99e Initial load
duke
parents:
diff changeset
339 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
340 assert(check_compiled_frame(thread), "incorrect caller");
a61af66fc99e Initial load
duke
parents:
diff changeset
341 assert(oop(elem_type)->is_klass(), "not a class");
a61af66fc99e Initial load
duke
parents:
diff changeset
342 jint dims[4];
a61af66fc99e Initial load
duke
parents:
diff changeset
343 dims[0] = len1;
a61af66fc99e Initial load
duke
parents:
diff changeset
344 dims[1] = len2;
a61af66fc99e Initial load
duke
parents:
diff changeset
345 dims[2] = len3;
a61af66fc99e Initial load
duke
parents:
diff changeset
346 dims[3] = len4;
a61af66fc99e Initial load
duke
parents:
diff changeset
347 oop obj = arrayKlass::cast(elem_type)->multi_allocate(4, dims, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
348 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
a61af66fc99e Initial load
duke
parents:
diff changeset
349 thread->set_vm_result(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
350 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
351
a61af66fc99e Initial load
duke
parents:
diff changeset
352 // multianewarray for 5 dimensions
a61af66fc99e Initial load
duke
parents:
diff changeset
353 JRT_ENTRY(void, OptoRuntime::multianewarray5_C(klassOopDesc* elem_type, int len1, int len2, int len3, int len4, int len5, JavaThread *thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
354 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
355 SharedRuntime::_multi5_ctr++; // multianewarray for 1 dimension
a61af66fc99e Initial load
duke
parents:
diff changeset
356 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
357 assert(check_compiled_frame(thread), "incorrect caller");
a61af66fc99e Initial load
duke
parents:
diff changeset
358 assert(oop(elem_type)->is_klass(), "not a class");
a61af66fc99e Initial load
duke
parents:
diff changeset
359 jint dims[5];
a61af66fc99e Initial load
duke
parents:
diff changeset
360 dims[0] = len1;
a61af66fc99e Initial load
duke
parents:
diff changeset
361 dims[1] = len2;
a61af66fc99e Initial load
duke
parents:
diff changeset
362 dims[2] = len3;
a61af66fc99e Initial load
duke
parents:
diff changeset
363 dims[3] = len4;
a61af66fc99e Initial load
duke
parents:
diff changeset
364 dims[4] = len5;
a61af66fc99e Initial load
duke
parents:
diff changeset
365 oop obj = arrayKlass::cast(elem_type)->multi_allocate(5, dims, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
366 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
a61af66fc99e Initial load
duke
parents:
diff changeset
367 thread->set_vm_result(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
368 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
369
a61af66fc99e Initial load
duke
parents:
diff changeset
370 const TypeFunc *OptoRuntime::new_instance_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
371 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
372 const Type **fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
373 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
a61af66fc99e Initial load
duke
parents:
diff changeset
374 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
375
a61af66fc99e Initial load
duke
parents:
diff changeset
376 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
377 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
378 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
a61af66fc99e Initial load
duke
parents:
diff changeset
379
a61af66fc99e Initial load
duke
parents:
diff changeset
380 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
381
a61af66fc99e Initial load
duke
parents:
diff changeset
382 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
383 }
a61af66fc99e Initial load
duke
parents:
diff changeset
384
a61af66fc99e Initial load
duke
parents:
diff changeset
385
a61af66fc99e Initial load
duke
parents:
diff changeset
386 const TypeFunc *OptoRuntime::athrow_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
387 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
388 const Type **fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
389 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
a61af66fc99e Initial load
duke
parents:
diff changeset
390 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
391
a61af66fc99e Initial load
duke
parents:
diff changeset
392 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
393 fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
394
a61af66fc99e Initial load
duke
parents:
diff changeset
395 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
396
a61af66fc99e Initial load
duke
parents:
diff changeset
397 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
398 }
a61af66fc99e Initial load
duke
parents:
diff changeset
399
a61af66fc99e Initial load
duke
parents:
diff changeset
400
a61af66fc99e Initial load
duke
parents:
diff changeset
401 const TypeFunc *OptoRuntime::new_array_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
402 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
403 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
404 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
a61af66fc99e Initial load
duke
parents:
diff changeset
405 fields[TypeFunc::Parms+1] = TypeInt::INT; // array size
a61af66fc99e Initial load
duke
parents:
diff changeset
406 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
407
a61af66fc99e Initial load
duke
parents:
diff changeset
408 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
409 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
410 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
a61af66fc99e Initial load
duke
parents:
diff changeset
411
a61af66fc99e Initial load
duke
parents:
diff changeset
412 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
413
a61af66fc99e Initial load
duke
parents:
diff changeset
414 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
415 }
a61af66fc99e Initial load
duke
parents:
diff changeset
416
a61af66fc99e Initial load
duke
parents:
diff changeset
417 const TypeFunc *OptoRuntime::multianewarray_Type(int ndim) {
a61af66fc99e Initial load
duke
parents:
diff changeset
418 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
419 const int nargs = ndim + 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
420 const Type **fields = TypeTuple::fields(nargs);
a61af66fc99e Initial load
duke
parents:
diff changeset
421 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
a61af66fc99e Initial load
duke
parents:
diff changeset
422 for( int i = 1; i < nargs; i++ )
a61af66fc99e Initial load
duke
parents:
diff changeset
423 fields[TypeFunc::Parms + i] = TypeInt::INT; // array size
a61af66fc99e Initial load
duke
parents:
diff changeset
424 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+nargs, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
425
a61af66fc99e Initial load
duke
parents:
diff changeset
426 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
427 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
428 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
a61af66fc99e Initial load
duke
parents:
diff changeset
429 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
430
a61af66fc99e Initial load
duke
parents:
diff changeset
431 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
432 }
a61af66fc99e Initial load
duke
parents:
diff changeset
433
a61af66fc99e Initial load
duke
parents:
diff changeset
434 const TypeFunc *OptoRuntime::multianewarray2_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
435 return multianewarray_Type(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
436 }
a61af66fc99e Initial load
duke
parents:
diff changeset
437
a61af66fc99e Initial load
duke
parents:
diff changeset
438 const TypeFunc *OptoRuntime::multianewarray3_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
439 return multianewarray_Type(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
440 }
a61af66fc99e Initial load
duke
parents:
diff changeset
441
a61af66fc99e Initial load
duke
parents:
diff changeset
442 const TypeFunc *OptoRuntime::multianewarray4_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
443 return multianewarray_Type(4);
a61af66fc99e Initial load
duke
parents:
diff changeset
444 }
a61af66fc99e Initial load
duke
parents:
diff changeset
445
a61af66fc99e Initial load
duke
parents:
diff changeset
446 const TypeFunc *OptoRuntime::multianewarray5_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
447 return multianewarray_Type(5);
a61af66fc99e Initial load
duke
parents:
diff changeset
448 }
a61af66fc99e Initial load
duke
parents:
diff changeset
449
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
450 const TypeFunc *OptoRuntime::g1_wb_pre_Type() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
451 const Type **fields = TypeTuple::fields(2);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
452 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // original field value
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
453 fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
454 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
455
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
456 // create result type (range)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
457 fields = TypeTuple::fields(0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
458 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
459
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
460 return TypeFunc::make(domain, range);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
461 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
462
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
463 const TypeFunc *OptoRuntime::g1_wb_post_Type() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
464
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
465 const Type **fields = TypeTuple::fields(2);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
466 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Card addr
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
467 fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
468 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
469
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
470 // create result type (range)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
471 fields = TypeTuple::fields(0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
472 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
473
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
474 return TypeFunc::make(domain, range);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
475 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
476
0
a61af66fc99e Initial load
duke
parents:
diff changeset
477 const TypeFunc *OptoRuntime::uncommon_trap_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
478 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
479 const Type **fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
480 // symbolOop name of class to be loaded
a61af66fc99e Initial load
duke
parents:
diff changeset
481 fields[TypeFunc::Parms+0] = TypeInt::INT;
a61af66fc99e Initial load
duke
parents:
diff changeset
482 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
483
a61af66fc99e Initial load
duke
parents:
diff changeset
484 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
485 fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
486 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
487
a61af66fc99e Initial load
duke
parents:
diff changeset
488 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
489 }
a61af66fc99e Initial load
duke
parents:
diff changeset
490
a61af66fc99e Initial load
duke
parents:
diff changeset
491 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load
duke
parents:
diff changeset
492 // Type used for stub generation for zap_dead_locals.
a61af66fc99e Initial load
duke
parents:
diff changeset
493 // No inputs or outputs
a61af66fc99e Initial load
duke
parents:
diff changeset
494 const TypeFunc *OptoRuntime::zap_dead_locals_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
495 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
496 const Type **fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
497 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
498
a61af66fc99e Initial load
duke
parents:
diff changeset
499 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
500 fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
501 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
502
a61af66fc99e Initial load
duke
parents:
diff changeset
503 return TypeFunc::make(domain,range);
a61af66fc99e Initial load
duke
parents:
diff changeset
504 }
a61af66fc99e Initial load
duke
parents:
diff changeset
505 # endif
a61af66fc99e Initial load
duke
parents:
diff changeset
506
a61af66fc99e Initial load
duke
parents:
diff changeset
507
a61af66fc99e Initial load
duke
parents:
diff changeset
508 //-----------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
509 // Monitor Handling
a61af66fc99e Initial load
duke
parents:
diff changeset
510 const TypeFunc *OptoRuntime::complete_monitor_enter_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
511 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
512 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
513 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
a61af66fc99e Initial load
duke
parents:
diff changeset
514 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock
a61af66fc99e Initial load
duke
parents:
diff changeset
515 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
516
a61af66fc99e Initial load
duke
parents:
diff changeset
517 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
518 fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
519
a61af66fc99e Initial load
duke
parents:
diff changeset
520 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
521
a61af66fc99e Initial load
duke
parents:
diff changeset
522 return TypeFunc::make(domain,range);
a61af66fc99e Initial load
duke
parents:
diff changeset
523 }
a61af66fc99e Initial load
duke
parents:
diff changeset
524
a61af66fc99e Initial load
duke
parents:
diff changeset
525
a61af66fc99e Initial load
duke
parents:
diff changeset
526 //-----------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
527 const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
528 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
529 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
530 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
a61af66fc99e Initial load
duke
parents:
diff changeset
531 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock
a61af66fc99e Initial load
duke
parents:
diff changeset
532 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
533
a61af66fc99e Initial load
duke
parents:
diff changeset
534 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
535 fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
536
a61af66fc99e Initial load
duke
parents:
diff changeset
537 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
538
a61af66fc99e Initial load
duke
parents:
diff changeset
539 return TypeFunc::make(domain,range);
a61af66fc99e Initial load
duke
parents:
diff changeset
540 }
a61af66fc99e Initial load
duke
parents:
diff changeset
541
a61af66fc99e Initial load
duke
parents:
diff changeset
542 const TypeFunc* OptoRuntime::flush_windows_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
543 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
544 const Type** fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
545 fields[TypeFunc::Parms+0] = NULL; // void
a61af66fc99e Initial load
duke
parents:
diff changeset
546 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
547
a61af66fc99e Initial load
duke
parents:
diff changeset
548 // create result type
a61af66fc99e Initial load
duke
parents:
diff changeset
549 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
550 fields[TypeFunc::Parms+0] = NULL; // void
a61af66fc99e Initial load
duke
parents:
diff changeset
551 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
552
a61af66fc99e Initial load
duke
parents:
diff changeset
553 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
554 }
a61af66fc99e Initial load
duke
parents:
diff changeset
555
a61af66fc99e Initial load
duke
parents:
diff changeset
556 const TypeFunc* OptoRuntime::l2f_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
557 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
558 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
559 fields[TypeFunc::Parms+0] = TypeLong::LONG;
a61af66fc99e Initial load
duke
parents:
diff changeset
560 fields[TypeFunc::Parms+1] = Type::HALF;
a61af66fc99e Initial load
duke
parents:
diff changeset
561 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
562
a61af66fc99e Initial load
duke
parents:
diff changeset
563 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
564 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
565 fields[TypeFunc::Parms+0] = Type::FLOAT;
a61af66fc99e Initial load
duke
parents:
diff changeset
566 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
567
a61af66fc99e Initial load
duke
parents:
diff changeset
568 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
569 }
a61af66fc99e Initial load
duke
parents:
diff changeset
570
a61af66fc99e Initial load
duke
parents:
diff changeset
571 const TypeFunc* OptoRuntime::modf_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
572 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
573 fields[TypeFunc::Parms+0] = Type::FLOAT;
a61af66fc99e Initial load
duke
parents:
diff changeset
574 fields[TypeFunc::Parms+1] = Type::FLOAT;
a61af66fc99e Initial load
duke
parents:
diff changeset
575 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
576
a61af66fc99e Initial load
duke
parents:
diff changeset
577 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
578 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
579 fields[TypeFunc::Parms+0] = Type::FLOAT;
a61af66fc99e Initial load
duke
parents:
diff changeset
580
a61af66fc99e Initial load
duke
parents:
diff changeset
581 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
582
a61af66fc99e Initial load
duke
parents:
diff changeset
583 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
584 }
a61af66fc99e Initial load
duke
parents:
diff changeset
585
a61af66fc99e Initial load
duke
parents:
diff changeset
586 const TypeFunc *OptoRuntime::Math_D_D_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
587 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
588 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
589 // symbolOop name of class to be loaded
a61af66fc99e Initial load
duke
parents:
diff changeset
590 fields[TypeFunc::Parms+0] = Type::DOUBLE;
a61af66fc99e Initial load
duke
parents:
diff changeset
591 fields[TypeFunc::Parms+1] = Type::HALF;
a61af66fc99e Initial load
duke
parents:
diff changeset
592 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
593
a61af66fc99e Initial load
duke
parents:
diff changeset
594 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
595 fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
596 fields[TypeFunc::Parms+0] = Type::DOUBLE;
a61af66fc99e Initial load
duke
parents:
diff changeset
597 fields[TypeFunc::Parms+1] = Type::HALF;
a61af66fc99e Initial load
duke
parents:
diff changeset
598 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
599
a61af66fc99e Initial load
duke
parents:
diff changeset
600 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
601 }
a61af66fc99e Initial load
duke
parents:
diff changeset
602
a61af66fc99e Initial load
duke
parents:
diff changeset
603 const TypeFunc* OptoRuntime::Math_DD_D_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
604 const Type **fields = TypeTuple::fields(4);
a61af66fc99e Initial load
duke
parents:
diff changeset
605 fields[TypeFunc::Parms+0] = Type::DOUBLE;
a61af66fc99e Initial load
duke
parents:
diff changeset
606 fields[TypeFunc::Parms+1] = Type::HALF;
a61af66fc99e Initial load
duke
parents:
diff changeset
607 fields[TypeFunc::Parms+2] = Type::DOUBLE;
a61af66fc99e Initial load
duke
parents:
diff changeset
608 fields[TypeFunc::Parms+3] = Type::HALF;
a61af66fc99e Initial load
duke
parents:
diff changeset
609 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+4, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
610
a61af66fc99e Initial load
duke
parents:
diff changeset
611 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
612 fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
613 fields[TypeFunc::Parms+0] = Type::DOUBLE;
a61af66fc99e Initial load
duke
parents:
diff changeset
614 fields[TypeFunc::Parms+1] = Type::HALF;
a61af66fc99e Initial load
duke
parents:
diff changeset
615 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
616
a61af66fc99e Initial load
duke
parents:
diff changeset
617 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
618 }
a61af66fc99e Initial load
duke
parents:
diff changeset
619
a61af66fc99e Initial load
duke
parents:
diff changeset
620 //-------------- currentTimeMillis
a61af66fc99e Initial load
duke
parents:
diff changeset
621
a61af66fc99e Initial load
duke
parents:
diff changeset
622 const TypeFunc* OptoRuntime::current_time_millis_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
623 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
624 const Type **fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
625 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+0, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
626
a61af66fc99e Initial load
duke
parents:
diff changeset
627 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
628 fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
629 fields[TypeFunc::Parms+0] = TypeLong::LONG;
a61af66fc99e Initial load
duke
parents:
diff changeset
630 fields[TypeFunc::Parms+1] = Type::HALF;
a61af66fc99e Initial load
duke
parents:
diff changeset
631 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
632
a61af66fc99e Initial load
duke
parents:
diff changeset
633 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
634 }
a61af66fc99e Initial load
duke
parents:
diff changeset
635
a61af66fc99e Initial load
duke
parents:
diff changeset
636 // arraycopy stub variations:
a61af66fc99e Initial load
duke
parents:
diff changeset
637 enum ArrayCopyType {
a61af66fc99e Initial load
duke
parents:
diff changeset
638 ac_fast, // void(ptr, ptr, size_t)
a61af66fc99e Initial load
duke
parents:
diff changeset
639 ac_checkcast, // int(ptr, ptr, size_t, size_t, ptr)
a61af66fc99e Initial load
duke
parents:
diff changeset
640 ac_slow, // void(ptr, int, ptr, int, int)
a61af66fc99e Initial load
duke
parents:
diff changeset
641 ac_generic // int(ptr, int, ptr, int, int)
a61af66fc99e Initial load
duke
parents:
diff changeset
642 };
a61af66fc99e Initial load
duke
parents:
diff changeset
643
a61af66fc99e Initial load
duke
parents:
diff changeset
644 static const TypeFunc* make_arraycopy_Type(ArrayCopyType act) {
a61af66fc99e Initial load
duke
parents:
diff changeset
645 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
646 int num_args = (act == ac_fast ? 3 : 5);
a61af66fc99e Initial load
duke
parents:
diff changeset
647 int num_size_args = (act == ac_fast ? 1 : act == ac_checkcast ? 2 : 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
648 int argcnt = num_args;
a61af66fc99e Initial load
duke
parents:
diff changeset
649 LP64_ONLY(argcnt += num_size_args); // halfwords for lengths
a61af66fc99e Initial load
duke
parents:
diff changeset
650 const Type** fields = TypeTuple::fields(argcnt);
a61af66fc99e Initial load
duke
parents:
diff changeset
651 int argp = TypeFunc::Parms;
a61af66fc99e Initial load
duke
parents:
diff changeset
652 fields[argp++] = TypePtr::NOTNULL; // src
a61af66fc99e Initial load
duke
parents:
diff changeset
653 if (num_size_args == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
654 fields[argp++] = TypeInt::INT; // src_pos
a61af66fc99e Initial load
duke
parents:
diff changeset
655 }
a61af66fc99e Initial load
duke
parents:
diff changeset
656 fields[argp++] = TypePtr::NOTNULL; // dest
a61af66fc99e Initial load
duke
parents:
diff changeset
657 if (num_size_args == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
658 fields[argp++] = TypeInt::INT; // dest_pos
a61af66fc99e Initial load
duke
parents:
diff changeset
659 fields[argp++] = TypeInt::INT; // length
a61af66fc99e Initial load
duke
parents:
diff changeset
660 }
a61af66fc99e Initial load
duke
parents:
diff changeset
661 while (num_size_args-- > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
662 fields[argp++] = TypeX_X; // size in whatevers (size_t)
a61af66fc99e Initial load
duke
parents:
diff changeset
663 LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length
a61af66fc99e Initial load
duke
parents:
diff changeset
664 }
a61af66fc99e Initial load
duke
parents:
diff changeset
665 if (act == ac_checkcast) {
a61af66fc99e Initial load
duke
parents:
diff changeset
666 fields[argp++] = TypePtr::NOTNULL; // super_klass
a61af66fc99e Initial load
duke
parents:
diff changeset
667 }
a61af66fc99e Initial load
duke
parents:
diff changeset
668 assert(argp == TypeFunc::Parms+argcnt, "correct decoding of act");
a61af66fc99e Initial load
duke
parents:
diff changeset
669 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
670
a61af66fc99e Initial load
duke
parents:
diff changeset
671 // create result type if needed
a61af66fc99e Initial load
duke
parents:
diff changeset
672 int retcnt = (act == ac_checkcast || act == ac_generic ? 1 : 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
673 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
674 if (retcnt == 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
675 fields[TypeFunc::Parms+0] = NULL; // void
a61af66fc99e Initial load
duke
parents:
diff changeset
676 else
a61af66fc99e Initial load
duke
parents:
diff changeset
677 fields[TypeFunc::Parms+0] = TypeInt::INT; // status result, if needed
a61af66fc99e Initial load
duke
parents:
diff changeset
678 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+retcnt, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
679 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
680 }
a61af66fc99e Initial load
duke
parents:
diff changeset
681
a61af66fc99e Initial load
duke
parents:
diff changeset
682 const TypeFunc* OptoRuntime::fast_arraycopy_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
683 // This signature is simple: Two base pointers and a size_t.
a61af66fc99e Initial load
duke
parents:
diff changeset
684 return make_arraycopy_Type(ac_fast);
a61af66fc99e Initial load
duke
parents:
diff changeset
685 }
a61af66fc99e Initial load
duke
parents:
diff changeset
686
a61af66fc99e Initial load
duke
parents:
diff changeset
687 const TypeFunc* OptoRuntime::checkcast_arraycopy_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
688 // An extension of fast_arraycopy_Type which adds type checking.
a61af66fc99e Initial load
duke
parents:
diff changeset
689 return make_arraycopy_Type(ac_checkcast);
a61af66fc99e Initial load
duke
parents:
diff changeset
690 }
a61af66fc99e Initial load
duke
parents:
diff changeset
691
a61af66fc99e Initial load
duke
parents:
diff changeset
692 const TypeFunc* OptoRuntime::slow_arraycopy_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
693 // This signature is exactly the same as System.arraycopy.
a61af66fc99e Initial load
duke
parents:
diff changeset
694 // There are no intptr_t (int/long) arguments.
a61af66fc99e Initial load
duke
parents:
diff changeset
695 return make_arraycopy_Type(ac_slow);
a61af66fc99e Initial load
duke
parents:
diff changeset
696 }
a61af66fc99e Initial load
duke
parents:
diff changeset
697
a61af66fc99e Initial load
duke
parents:
diff changeset
698 const TypeFunc* OptoRuntime::generic_arraycopy_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
699 // This signature is like System.arraycopy, except that it returns status.
a61af66fc99e Initial load
duke
parents:
diff changeset
700 return make_arraycopy_Type(ac_generic);
a61af66fc99e Initial load
duke
parents:
diff changeset
701 }
a61af66fc99e Initial load
duke
parents:
diff changeset
702
a61af66fc99e Initial load
duke
parents:
diff changeset
703
1763
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
704 const TypeFunc* OptoRuntime::array_fill_Type() {
1844
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1763
diff changeset
705 // create input type (domain): pointer, int, size_t
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1763
diff changeset
706 const Type** fields = TypeTuple::fields(3 LP64_ONLY( + 1));
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1763
diff changeset
707 int argp = TypeFunc::Parms;
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1763
diff changeset
708 fields[argp++] = TypePtr::NOTNULL;
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1763
diff changeset
709 fields[argp++] = TypeInt::INT;
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1763
diff changeset
710 fields[argp++] = TypeX_X; // size in whatevers (size_t)
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1763
diff changeset
711 LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1763
diff changeset
712 const TypeTuple *domain = TypeTuple::make(argp, fields);
1763
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
713
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
714 // create result type
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
715 fields = TypeTuple::fields(1);
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
716 fields[TypeFunc::Parms+0] = NULL; // void
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
717 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
718
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
719 return TypeFunc::make(domain, range);
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
720 }
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
721
0
a61af66fc99e Initial load
duke
parents:
diff changeset
722 //------------- Interpreter state access for on stack replacement
a61af66fc99e Initial load
duke
parents:
diff changeset
723 const TypeFunc* OptoRuntime::osr_end_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
724 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
725 const Type **fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
726 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // OSR temp buf
a61af66fc99e Initial load
duke
parents:
diff changeset
727 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
728
a61af66fc99e Initial load
duke
parents:
diff changeset
729 // create result type
a61af66fc99e Initial load
duke
parents:
diff changeset
730 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
731 // fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // locked oop
a61af66fc99e Initial load
duke
parents:
diff changeset
732 fields[TypeFunc::Parms+0] = NULL; // void
a61af66fc99e Initial load
duke
parents:
diff changeset
733 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
734 return TypeFunc::make(domain, range);
a61af66fc99e Initial load
duke
parents:
diff changeset
735 }
a61af66fc99e Initial load
duke
parents:
diff changeset
736
a61af66fc99e Initial load
duke
parents:
diff changeset
737 //-------------- methodData update helpers
a61af66fc99e Initial load
duke
parents:
diff changeset
738
a61af66fc99e Initial load
duke
parents:
diff changeset
739 const TypeFunc* OptoRuntime::profile_receiver_type_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
740 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
741 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
742 fields[TypeFunc::Parms+0] = TypeAryPtr::NOTNULL; // methodData pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
743 fields[TypeFunc::Parms+1] = TypeInstPtr::BOTTOM; // receiver oop
a61af66fc99e Initial load
duke
parents:
diff changeset
744 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
745
a61af66fc99e Initial load
duke
parents:
diff changeset
746 // create result type
a61af66fc99e Initial load
duke
parents:
diff changeset
747 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
748 fields[TypeFunc::Parms+0] = NULL; // void
a61af66fc99e Initial load
duke
parents:
diff changeset
749 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
750 return TypeFunc::make(domain,range);
a61af66fc99e Initial load
duke
parents:
diff changeset
751 }
a61af66fc99e Initial load
duke
parents:
diff changeset
752
a61af66fc99e Initial load
duke
parents:
diff changeset
753 JRT_LEAF(void, OptoRuntime::profile_receiver_type_C(DataLayout* data, oopDesc* receiver))
a61af66fc99e Initial load
duke
parents:
diff changeset
754 if (receiver == NULL) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
755 klassOop receiver_klass = receiver->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
756
a61af66fc99e Initial load
duke
parents:
diff changeset
757 intptr_t* mdp = ((intptr_t*)(data)) + DataLayout::header_size_in_cells();
a61af66fc99e Initial load
duke
parents:
diff changeset
758 int empty_row = -1; // free row, if any is encountered
a61af66fc99e Initial load
duke
parents:
diff changeset
759
a61af66fc99e Initial load
duke
parents:
diff changeset
760 // ReceiverTypeData* vc = new ReceiverTypeData(mdp);
a61af66fc99e Initial load
duke
parents:
diff changeset
761 for (uint row = 0; row < ReceiverTypeData::row_limit(); row++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
762 // if (vc->receiver(row) == receiver_klass)
a61af66fc99e Initial load
duke
parents:
diff changeset
763 int receiver_off = ReceiverTypeData::receiver_cell_index(row);
a61af66fc99e Initial load
duke
parents:
diff changeset
764 intptr_t row_recv = *(mdp + receiver_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
765 if (row_recv == (intptr_t) receiver_klass) {
a61af66fc99e Initial load
duke
parents:
diff changeset
766 // vc->set_receiver_count(row, vc->receiver_count(row) + DataLayout::counter_increment);
a61af66fc99e Initial load
duke
parents:
diff changeset
767 int count_off = ReceiverTypeData::receiver_count_cell_index(row);
a61af66fc99e Initial load
duke
parents:
diff changeset
768 *(mdp + count_off) += DataLayout::counter_increment;
a61af66fc99e Initial load
duke
parents:
diff changeset
769 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
770 } else if (row_recv == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
771 // else if (vc->receiver(row) == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
772 empty_row = (int) row;
a61af66fc99e Initial load
duke
parents:
diff changeset
773 }
a61af66fc99e Initial load
duke
parents:
diff changeset
774 }
a61af66fc99e Initial load
duke
parents:
diff changeset
775
a61af66fc99e Initial load
duke
parents:
diff changeset
776 if (empty_row != -1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
777 int receiver_off = ReceiverTypeData::receiver_cell_index(empty_row);
a61af66fc99e Initial load
duke
parents:
diff changeset
778 // vc->set_receiver(empty_row, receiver_klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
779 *(mdp + receiver_off) = (intptr_t) receiver_klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
780 // vc->set_receiver_count(empty_row, DataLayout::counter_increment);
a61af66fc99e Initial load
duke
parents:
diff changeset
781 int count_off = ReceiverTypeData::receiver_count_cell_index(empty_row);
a61af66fc99e Initial load
duke
parents:
diff changeset
782 *(mdp + count_off) = DataLayout::counter_increment;
1206
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 1166
diff changeset
783 } else {
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 1166
diff changeset
784 // Receiver did not match any saved receiver and there is no empty row for it.
1251
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic")
kvn
parents: 1206
diff changeset
785 // Increment total counter to indicate polymorphic case.
1206
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 1166
diff changeset
786 intptr_t* count_p = (intptr_t*)(((byte*)(data)) + in_bytes(CounterData::count_offset()));
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 1166
diff changeset
787 *count_p += DataLayout::counter_increment;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
788 }
a61af66fc99e Initial load
duke
parents:
diff changeset
789 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
790
a61af66fc99e Initial load
duke
parents:
diff changeset
791 //-----------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
792 // implicit exception support.
a61af66fc99e Initial load
duke
parents:
diff changeset
793
a61af66fc99e Initial load
duke
parents:
diff changeset
794 static void report_null_exception_in_code_cache(address exception_pc) {
a61af66fc99e Initial load
duke
parents:
diff changeset
795 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
796 CodeBlob* n = CodeCache::find_blob(exception_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
797 if (n != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
798 tty->print_cr("#");
a61af66fc99e Initial load
duke
parents:
diff changeset
799 tty->print_cr("# HotSpot Runtime Error, null exception in generated code");
a61af66fc99e Initial load
duke
parents:
diff changeset
800 tty->print_cr("#");
a61af66fc99e Initial load
duke
parents:
diff changeset
801 tty->print_cr("# pc where exception happened = " INTPTR_FORMAT, exception_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
802
a61af66fc99e Initial load
duke
parents:
diff changeset
803 if (n->is_nmethod()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
804 methodOop method = ((nmethod*)n)->method();
a61af66fc99e Initial load
duke
parents:
diff changeset
805 tty->print_cr("# Method where it happened %s.%s ", Klass::cast(method->method_holder())->name()->as_C_string(), method->name()->as_C_string());
a61af66fc99e Initial load
duke
parents:
diff changeset
806 tty->print_cr("#");
a61af66fc99e Initial load
duke
parents:
diff changeset
807 if (ShowMessageBoxOnError && UpdateHotSpotCompilerFileOnError) {
a61af66fc99e Initial load
duke
parents:
diff changeset
808 const char* title = "HotSpot Runtime Error";
a61af66fc99e Initial load
duke
parents:
diff changeset
809 const char* question = "Do you want to exclude compilation of this method in future runs?";
a61af66fc99e Initial load
duke
parents:
diff changeset
810 if (os::message_box(title, question)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
811 CompilerOracle::append_comment_to_file("");
a61af66fc99e Initial load
duke
parents:
diff changeset
812 CompilerOracle::append_comment_to_file("Null exception in compiled code resulted in the following exclude");
a61af66fc99e Initial load
duke
parents:
diff changeset
813 CompilerOracle::append_comment_to_file("");
a61af66fc99e Initial load
duke
parents:
diff changeset
814 CompilerOracle::append_exclude_to_file(method);
a61af66fc99e Initial load
duke
parents:
diff changeset
815 tty->print_cr("#");
a61af66fc99e Initial load
duke
parents:
diff changeset
816 tty->print_cr("# %s has been updated to exclude the specified method", CompileCommandFile);
a61af66fc99e Initial load
duke
parents:
diff changeset
817 tty->print_cr("#");
a61af66fc99e Initial load
duke
parents:
diff changeset
818 }
a61af66fc99e Initial load
duke
parents:
diff changeset
819 }
a61af66fc99e Initial load
duke
parents:
diff changeset
820 fatal("Implicit null exception happened in compiled method");
a61af66fc99e Initial load
duke
parents:
diff changeset
821 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
822 n->print();
a61af66fc99e Initial load
duke
parents:
diff changeset
823 fatal("Implicit null exception happened in generated stub");
a61af66fc99e Initial load
duke
parents:
diff changeset
824 }
a61af66fc99e Initial load
duke
parents:
diff changeset
825 }
a61af66fc99e Initial load
duke
parents:
diff changeset
826 fatal("Implicit null exception at wrong place");
a61af66fc99e Initial load
duke
parents:
diff changeset
827 }
a61af66fc99e Initial load
duke
parents:
diff changeset
828
a61af66fc99e Initial load
duke
parents:
diff changeset
829
a61af66fc99e Initial load
duke
parents:
diff changeset
830 //-------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
831 // register policy
a61af66fc99e Initial load
duke
parents:
diff changeset
832
a61af66fc99e Initial load
duke
parents:
diff changeset
833 bool OptoRuntime::is_callee_saved_register(MachRegisterNumbers reg) {
a61af66fc99e Initial load
duke
parents:
diff changeset
834 assert(reg >= 0 && reg < _last_Mach_Reg, "must be a machine register");
a61af66fc99e Initial load
duke
parents:
diff changeset
835 switch (register_save_policy[reg]) {
a61af66fc99e Initial load
duke
parents:
diff changeset
836 case 'C': return false; //SOC
a61af66fc99e Initial load
duke
parents:
diff changeset
837 case 'E': return true ; //SOE
a61af66fc99e Initial load
duke
parents:
diff changeset
838 case 'N': return false; //NS
a61af66fc99e Initial load
duke
parents:
diff changeset
839 case 'A': return false; //AS
a61af66fc99e Initial load
duke
parents:
diff changeset
840 }
a61af66fc99e Initial load
duke
parents:
diff changeset
841 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
842 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
843 }
a61af66fc99e Initial load
duke
parents:
diff changeset
844
a61af66fc99e Initial load
duke
parents:
diff changeset
845 //-----------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
846 // Exceptions
a61af66fc99e Initial load
duke
parents:
diff changeset
847 //
a61af66fc99e Initial load
duke
parents:
diff changeset
848
a61af66fc99e Initial load
duke
parents:
diff changeset
849 static void trace_exception(oop exception_oop, address exception_pc, const char* msg) PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
850
a61af66fc99e Initial load
duke
parents:
diff changeset
851 // The method is an entry that is always called by a C++ method not
a61af66fc99e Initial load
duke
parents:
diff changeset
852 // directly from compiled code. Compiled code will call the C++ method following.
a61af66fc99e Initial load
duke
parents:
diff changeset
853 // We can't allow async exception to be installed during exception processing.
a61af66fc99e Initial load
duke
parents:
diff changeset
854 JRT_ENTRY_NO_ASYNC(address, OptoRuntime::handle_exception_C_helper(JavaThread* thread, nmethod* &nm))
a61af66fc99e Initial load
duke
parents:
diff changeset
855
a61af66fc99e Initial load
duke
parents:
diff changeset
856 // Do not confuse exception_oop with pending_exception. The exception_oop
a61af66fc99e Initial load
duke
parents:
diff changeset
857 // is only used to pass arguments into the method. Not for general
a61af66fc99e Initial load
duke
parents:
diff changeset
858 // exception handling. DO NOT CHANGE IT to use pending_exception, since
a61af66fc99e Initial load
duke
parents:
diff changeset
859 // the runtime stubs checks this on exit.
a61af66fc99e Initial load
duke
parents:
diff changeset
860 assert(thread->exception_oop() != NULL, "exception oop is found");
a61af66fc99e Initial load
duke
parents:
diff changeset
861 address handler_address = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
862
a61af66fc99e Initial load
duke
parents:
diff changeset
863 Handle exception(thread, thread->exception_oop());
a61af66fc99e Initial load
duke
parents:
diff changeset
864
a61af66fc99e Initial load
duke
parents:
diff changeset
865 if (TraceExceptions) {
a61af66fc99e Initial load
duke
parents:
diff changeset
866 trace_exception(exception(), thread->exception_pc(), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
867 }
a61af66fc99e Initial load
duke
parents:
diff changeset
868 // for AbortVMOnException flag
a61af66fc99e Initial load
duke
parents:
diff changeset
869 NOT_PRODUCT(Exceptions::debug_check_abort(exception));
a61af66fc99e Initial load
duke
parents:
diff changeset
870
a61af66fc99e Initial load
duke
parents:
diff changeset
871 #ifdef ASSERT
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1135
diff changeset
872 if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
873 // should throw an exception here
a61af66fc99e Initial load
duke
parents:
diff changeset
874 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
875 }
a61af66fc99e Initial load
duke
parents:
diff changeset
876 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
877
a61af66fc99e Initial load
duke
parents:
diff changeset
878
a61af66fc99e Initial load
duke
parents:
diff changeset
879 // new exception handling: this method is entered only from adapters
a61af66fc99e Initial load
duke
parents:
diff changeset
880 // exceptions from compiled java methods are handled in compiled code
a61af66fc99e Initial load
duke
parents:
diff changeset
881 // using rethrow node
a61af66fc99e Initial load
duke
parents:
diff changeset
882
a61af66fc99e Initial load
duke
parents:
diff changeset
883 address pc = thread->exception_pc();
a61af66fc99e Initial load
duke
parents:
diff changeset
884 nm = CodeCache::find_nmethod(pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
885 assert(nm != NULL, "No NMethod found");
a61af66fc99e Initial load
duke
parents:
diff changeset
886 if (nm->is_native_method()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
887 fatal("Native mathod should not have path to exception handling");
a61af66fc99e Initial load
duke
parents:
diff changeset
888 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
889 // we are switching to old paradigm: search for exception handler in caller_frame
a61af66fc99e Initial load
duke
parents:
diff changeset
890 // instead in exception handler of caller_frame.sender()
a61af66fc99e Initial load
duke
parents:
diff changeset
891
1213
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 1166
diff changeset
892 if (JvmtiExport::can_post_on_exceptions()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
893 // "Full-speed catching" is not necessary here,
a61af66fc99e Initial load
duke
parents:
diff changeset
894 // since we're notifying the VM on every catch.
a61af66fc99e Initial load
duke
parents:
diff changeset
895 // Force deoptimization and the rest of the lookup
a61af66fc99e Initial load
duke
parents:
diff changeset
896 // will be fine.
a61af66fc99e Initial load
duke
parents:
diff changeset
897 deoptimize_caller_frame(thread, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
898 }
a61af66fc99e Initial load
duke
parents:
diff changeset
899
a61af66fc99e Initial load
duke
parents:
diff changeset
900 // Check the stack guard pages. If enabled, look for handler in this frame;
a61af66fc99e Initial load
duke
parents:
diff changeset
901 // otherwise, forcibly unwind the frame.
a61af66fc99e Initial load
duke
parents:
diff changeset
902 //
a61af66fc99e Initial load
duke
parents:
diff changeset
903 // 4826555: use default current sp for reguard_stack instead of &nm: it's more accurate.
a61af66fc99e Initial load
duke
parents:
diff changeset
904 bool force_unwind = !thread->reguard_stack();
a61af66fc99e Initial load
duke
parents:
diff changeset
905 bool deopting = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
906 if (nm->is_deopt_pc(pc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
907 deopting = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
908 RegisterMap map(thread, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
909 frame deoptee = thread->last_frame().sender(&map);
a61af66fc99e Initial load
duke
parents:
diff changeset
910 assert(deoptee.is_deoptimized_frame(), "must be deopted");
a61af66fc99e Initial load
duke
parents:
diff changeset
911 // Adjust the pc back to the original throwing pc
a61af66fc99e Initial load
duke
parents:
diff changeset
912 pc = deoptee.pc();
a61af66fc99e Initial load
duke
parents:
diff changeset
913 }
a61af66fc99e Initial load
duke
parents:
diff changeset
914
a61af66fc99e Initial load
duke
parents:
diff changeset
915 // If we are forcing an unwind because of stack overflow then deopt is
a61af66fc99e Initial load
duke
parents:
diff changeset
916 // irrelevant sice we are throwing the frame away anyway.
a61af66fc99e Initial load
duke
parents:
diff changeset
917
a61af66fc99e Initial load
duke
parents:
diff changeset
918 if (deopting && !force_unwind) {
a61af66fc99e Initial load
duke
parents:
diff changeset
919 handler_address = SharedRuntime::deopt_blob()->unpack_with_exception();
a61af66fc99e Initial load
duke
parents:
diff changeset
920 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
921
a61af66fc99e Initial load
duke
parents:
diff changeset
922 handler_address =
a61af66fc99e Initial load
duke
parents:
diff changeset
923 force_unwind ? NULL : nm->handler_for_exception_and_pc(exception, pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
924
a61af66fc99e Initial load
duke
parents:
diff changeset
925 if (handler_address == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
926 handler_address = SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, force_unwind, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
927 assert (handler_address != NULL, "must have compiled handler");
a61af66fc99e Initial load
duke
parents:
diff changeset
928 // Update the exception cache only when the unwind was not forced.
a61af66fc99e Initial load
duke
parents:
diff changeset
929 if (!force_unwind) {
a61af66fc99e Initial load
duke
parents:
diff changeset
930 nm->add_handler_for_exception_and_pc(exception,pc,handler_address);
a61af66fc99e Initial load
duke
parents:
diff changeset
931 }
a61af66fc99e Initial load
duke
parents:
diff changeset
932 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
933 assert(handler_address == SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, force_unwind, true), "Must be the same");
a61af66fc99e Initial load
duke
parents:
diff changeset
934 }
a61af66fc99e Initial load
duke
parents:
diff changeset
935 }
a61af66fc99e Initial load
duke
parents:
diff changeset
936
a61af66fc99e Initial load
duke
parents:
diff changeset
937 thread->set_exception_pc(pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
938 thread->set_exception_handler_pc(handler_address);
a61af66fc99e Initial load
duke
parents:
diff changeset
939 thread->set_exception_stack_size(0);
1135
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 1027
diff changeset
940
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1257
diff changeset
941 // Check if the exception PC is a MethodHandle call site.
1368
93767e6a2dfd 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 1295
diff changeset
942 thread->set_is_method_handle_return(nm->is_method_handle_return(pc));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
943 }
a61af66fc99e Initial load
duke
parents:
diff changeset
944
a61af66fc99e Initial load
duke
parents:
diff changeset
945 // Restore correct return pc. Was saved above.
a61af66fc99e Initial load
duke
parents:
diff changeset
946 thread->set_exception_oop(exception());
a61af66fc99e Initial load
duke
parents:
diff changeset
947 return handler_address;
a61af66fc99e Initial load
duke
parents:
diff changeset
948
a61af66fc99e Initial load
duke
parents:
diff changeset
949 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
950
a61af66fc99e Initial load
duke
parents:
diff changeset
951 // We are entering here from exception_blob
a61af66fc99e Initial load
duke
parents:
diff changeset
952 // If there is a compiled exception handler in this method, we will continue there;
a61af66fc99e Initial load
duke
parents:
diff changeset
953 // otherwise we will unwind the stack and continue at the caller of top frame method
a61af66fc99e Initial load
duke
parents:
diff changeset
954 // Note we enter without the usual JRT wrapper. We will call a helper routine that
a61af66fc99e Initial load
duke
parents:
diff changeset
955 // will do the normal VM entry. We do it this way so that we can see if the nmethod
a61af66fc99e Initial load
duke
parents:
diff changeset
956 // we looked up the handler for has been deoptimized in the meantime. If it has been
a61af66fc99e Initial load
duke
parents:
diff changeset
957 // we must not use the handler and instread return the deopt blob.
a61af66fc99e Initial load
duke
parents:
diff changeset
958 address OptoRuntime::handle_exception_C(JavaThread* thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
959 //
a61af66fc99e Initial load
duke
parents:
diff changeset
960 // We are in Java not VM and in debug mode we have a NoHandleMark
a61af66fc99e Initial load
duke
parents:
diff changeset
961 //
a61af66fc99e Initial load
duke
parents:
diff changeset
962 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
963 SharedRuntime::_find_handler_ctr++; // find exception handler
a61af66fc99e Initial load
duke
parents:
diff changeset
964 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
965 debug_only(NoHandleMark __hm;)
a61af66fc99e Initial load
duke
parents:
diff changeset
966 nmethod* nm = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
967 address handler_address = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
968 {
a61af66fc99e Initial load
duke
parents:
diff changeset
969 // Enter the VM
a61af66fc99e Initial load
duke
parents:
diff changeset
970
a61af66fc99e Initial load
duke
parents:
diff changeset
971 ResetNoHandleMark rnhm;
a61af66fc99e Initial load
duke
parents:
diff changeset
972 handler_address = handle_exception_C_helper(thread, nm);
a61af66fc99e Initial load
duke
parents:
diff changeset
973 }
a61af66fc99e Initial load
duke
parents:
diff changeset
974
a61af66fc99e Initial load
duke
parents:
diff changeset
975 // Back in java: Use no oops, DON'T safepoint
a61af66fc99e Initial load
duke
parents:
diff changeset
976
a61af66fc99e Initial load
duke
parents:
diff changeset
977 // Now check to see if the handler we are returning is in a now
a61af66fc99e Initial load
duke
parents:
diff changeset
978 // deoptimized frame
a61af66fc99e Initial load
duke
parents:
diff changeset
979
a61af66fc99e Initial load
duke
parents:
diff changeset
980 if (nm != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
981 RegisterMap map(thread, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
982 frame caller = thread->last_frame().sender(&map);
a61af66fc99e Initial load
duke
parents:
diff changeset
983 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
984 assert(caller.is_compiled_frame(), "must be");
a61af66fc99e Initial load
duke
parents:
diff changeset
985 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
986 if (caller.is_deoptimized_frame()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
987 handler_address = SharedRuntime::deopt_blob()->unpack_with_exception();
a61af66fc99e Initial load
duke
parents:
diff changeset
988 }
a61af66fc99e Initial load
duke
parents:
diff changeset
989 }
a61af66fc99e Initial load
duke
parents:
diff changeset
990 return handler_address;
a61af66fc99e Initial load
duke
parents:
diff changeset
991 }
a61af66fc99e Initial load
duke
parents:
diff changeset
992
a61af66fc99e Initial load
duke
parents:
diff changeset
993 //------------------------------rethrow----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
994 // We get here after compiled code has executed a 'RethrowNode'. The callee
a61af66fc99e Initial load
duke
parents:
diff changeset
995 // is either throwing or rethrowing an exception. The callee-save registers
a61af66fc99e Initial load
duke
parents:
diff changeset
996 // have been restored, synchronized objects have been unlocked and the callee
a61af66fc99e Initial load
duke
parents:
diff changeset
997 // stack frame has been removed. The return address was passed in.
a61af66fc99e Initial load
duke
parents:
diff changeset
998 // Exception oop is passed as the 1st argument. This routine is then called
a61af66fc99e Initial load
duke
parents:
diff changeset
999 // from the stub. On exit, we know where to jump in the caller's code.
a61af66fc99e Initial load
duke
parents:
diff changeset
1000 // After this C code exits, the stub will pop his frame and end in a jump
a61af66fc99e Initial load
duke
parents:
diff changeset
1001 // (instead of a return). We enter the caller's default handler.
a61af66fc99e Initial load
duke
parents:
diff changeset
1002 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1003 // This must be JRT_LEAF:
a61af66fc99e Initial load
duke
parents:
diff changeset
1004 // - caller will not change its state as we cannot block on exit,
a61af66fc99e Initial load
duke
parents:
diff changeset
1005 // therefore raw_exception_handler_for_return_address is all it takes
a61af66fc99e Initial load
duke
parents:
diff changeset
1006 // to handle deoptimized blobs
a61af66fc99e Initial load
duke
parents:
diff changeset
1007 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1008 // However, there needs to be a safepoint check in the middle! So compiled
a61af66fc99e Initial load
duke
parents:
diff changeset
1009 // safepoints are completely watertight.
a61af66fc99e Initial load
duke
parents:
diff changeset
1010 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1011 // Thus, it cannot be a leaf since it contains the No_GC_Verifier.
a61af66fc99e Initial load
duke
parents:
diff changeset
1012 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1013 // *THIS IS NOT RECOMMENDED PROGRAMMING STYLE*
a61af66fc99e Initial load
duke
parents:
diff changeset
1014 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1015 address OptoRuntime::rethrow_C(oopDesc* exception, JavaThread* thread, address ret_pc) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1016 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1017 SharedRuntime::_rethrow_ctr++; // count rethrows
a61af66fc99e Initial load
duke
parents:
diff changeset
1018 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1019 assert (exception != NULL, "should have thrown a NULLPointerException");
a61af66fc99e Initial load
duke
parents:
diff changeset
1020 #ifdef ASSERT
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1135
diff changeset
1021 if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1022 // should throw an exception here
a61af66fc99e Initial load
duke
parents:
diff changeset
1023 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
1024 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1025 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1026
a61af66fc99e Initial load
duke
parents:
diff changeset
1027 thread->set_vm_result(exception);
a61af66fc99e Initial load
duke
parents:
diff changeset
1028 // Frame not compiled (handles deoptimization blob)
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1257
diff changeset
1029 return SharedRuntime::raw_exception_handler_for_return_address(thread, ret_pc);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1030 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1031
a61af66fc99e Initial load
duke
parents:
diff changeset
1032
a61af66fc99e Initial load
duke
parents:
diff changeset
1033 const TypeFunc *OptoRuntime::rethrow_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1034 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
1035 const Type **fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1036 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
a61af66fc99e Initial load
duke
parents:
diff changeset
1037 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
1038
a61af66fc99e Initial load
duke
parents:
diff changeset
1039 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
1040 fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1041 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
a61af66fc99e Initial load
duke
parents:
diff changeset
1042 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
1043
a61af66fc99e Initial load
duke
parents:
diff changeset
1044 return TypeFunc::make(domain, range);
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 void OptoRuntime::deoptimize_caller_frame(JavaThread *thread, bool doit) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1049 // Deoptimize frame
a61af66fc99e Initial load
duke
parents:
diff changeset
1050 if (doit) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1051 // Called from within the owner thread, so no need for safepoint
a61af66fc99e Initial load
duke
parents:
diff changeset
1052 RegisterMap reg_map(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
1053 frame stub_frame = thread->last_frame();
a61af66fc99e Initial load
duke
parents:
diff changeset
1054 assert(stub_frame.is_runtime_frame() || exception_blob()->contains(stub_frame.pc()), "sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
1055 frame caller_frame = stub_frame.sender(&reg_map);
a61af66fc99e Initial load
duke
parents:
diff changeset
1056
1213
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 1166
diff changeset
1057 // bypass VM_DeoptimizeFrame and deoptimize the frame directly
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 1166
diff changeset
1058 Deoptimization::deoptimize_frame(thread, caller_frame.id());
0
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
a61af66fc99e Initial load
duke
parents:
diff changeset
1063 const TypeFunc *OptoRuntime::register_finalizer_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1064 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
1065 const Type **fields = TypeTuple::fields(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1066 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // oop; Receiver
a61af66fc99e Initial load
duke
parents:
diff changeset
1067 // // The JavaThread* is passed to each routine as the last argument
a61af66fc99e Initial load
duke
parents:
diff changeset
1068 // fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // JavaThread *; Executing thread
a61af66fc99e Initial load
duke
parents:
diff changeset
1069 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
1070
a61af66fc99e Initial load
duke
parents:
diff changeset
1071 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
1072 fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1073
a61af66fc99e Initial load
duke
parents:
diff changeset
1074 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
1075
a61af66fc99e Initial load
duke
parents:
diff changeset
1076 return TypeFunc::make(domain,range);
a61af66fc99e Initial load
duke
parents:
diff changeset
1077 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1078
a61af66fc99e Initial load
duke
parents:
diff changeset
1079
a61af66fc99e Initial load
duke
parents:
diff changeset
1080 //-----------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1081 // Dtrace support. entry and exit probes have the same signature
a61af66fc99e Initial load
duke
parents:
diff changeset
1082 const TypeFunc *OptoRuntime::dtrace_method_entry_exit_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1083 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
1084 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1085 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
a61af66fc99e Initial load
duke
parents:
diff changeset
1086 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // methodOop; Method we are entering
a61af66fc99e Initial load
duke
parents:
diff changeset
1087 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
1088
a61af66fc99e Initial load
duke
parents:
diff changeset
1089 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
1090 fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1091
a61af66fc99e Initial load
duke
parents:
diff changeset
1092 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
1093
a61af66fc99e Initial load
duke
parents:
diff changeset
1094 return TypeFunc::make(domain,range);
a61af66fc99e Initial load
duke
parents:
diff changeset
1095 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1096
a61af66fc99e Initial load
duke
parents:
diff changeset
1097 const TypeFunc *OptoRuntime::dtrace_object_alloc_Type() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1098 // create input type (domain)
a61af66fc99e Initial load
duke
parents:
diff changeset
1099 const Type **fields = TypeTuple::fields(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1100 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
a61af66fc99e Initial load
duke
parents:
diff changeset
1101 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // oop; newly allocated object
a61af66fc99e Initial load
duke
parents:
diff changeset
1102
a61af66fc99e Initial load
duke
parents:
diff changeset
1103 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
1104
a61af66fc99e Initial load
duke
parents:
diff changeset
1105 // create result type (range)
a61af66fc99e Initial load
duke
parents:
diff changeset
1106 fields = TypeTuple::fields(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1107
a61af66fc99e Initial load
duke
parents:
diff changeset
1108 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
a61af66fc99e Initial load
duke
parents:
diff changeset
1109
a61af66fc99e Initial load
duke
parents:
diff changeset
1110 return TypeFunc::make(domain,range);
a61af66fc99e Initial load
duke
parents:
diff changeset
1111 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1112
a61af66fc99e Initial load
duke
parents:
diff changeset
1113
a61af66fc99e Initial load
duke
parents:
diff changeset
1114 JRT_ENTRY_NO_ASYNC(void, OptoRuntime::register_finalizer(oopDesc* obj, JavaThread* thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
1115 assert(obj->is_oop(), "must be a valid oop");
a61af66fc99e Initial load
duke
parents:
diff changeset
1116 assert(obj->klass()->klass_part()->has_finalizer(), "shouldn't be here otherwise");
a61af66fc99e Initial load
duke
parents:
diff changeset
1117 instanceKlass::register_finalizer(instanceOop(obj), CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1118 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1119
a61af66fc99e Initial load
duke
parents:
diff changeset
1120 //-----------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1121
a61af66fc99e Initial load
duke
parents:
diff changeset
1122 NamedCounter * volatile OptoRuntime::_named_counters = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1123
a61af66fc99e Initial load
duke
parents:
diff changeset
1124 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1125 // dump the collected NamedCounters.
a61af66fc99e Initial load
duke
parents:
diff changeset
1126 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1127 void OptoRuntime::print_named_counters() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1128 int total_lock_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1129 int eliminated_lock_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1130
a61af66fc99e Initial load
duke
parents:
diff changeset
1131 NamedCounter* c = _named_counters;
a61af66fc99e Initial load
duke
parents:
diff changeset
1132 while (c) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1133 if (c->tag() == NamedCounter::LockCounter || c->tag() == NamedCounter::EliminatedLockCounter) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1134 int count = c->count();
a61af66fc99e Initial load
duke
parents:
diff changeset
1135 if (count > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1136 bool eliminated = c->tag() == NamedCounter::EliminatedLockCounter;
a61af66fc99e Initial load
duke
parents:
diff changeset
1137 if (Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1138 tty->print_cr("%d %s%s", count, c->name(), eliminated ? " (eliminated)" : "");
a61af66fc99e Initial load
duke
parents:
diff changeset
1139 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1140 total_lock_count += count;
a61af66fc99e Initial load
duke
parents:
diff changeset
1141 if (eliminated) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1142 eliminated_lock_count += count;
a61af66fc99e Initial load
duke
parents:
diff changeset
1143 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1144 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1145 } else if (c->tag() == NamedCounter::BiasedLockingCounter) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1146 BiasedLockingCounters* blc = ((BiasedLockingNamedCounter*)c)->counters();
a61af66fc99e Initial load
duke
parents:
diff changeset
1147 if (blc->nonzero()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1148 tty->print_cr("%s", c->name());
a61af66fc99e Initial load
duke
parents:
diff changeset
1149 blc->print_on(tty);
a61af66fc99e Initial load
duke
parents:
diff changeset
1150 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1151 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1152 c = c->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
1153 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1154 if (total_lock_count > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1155 tty->print_cr("dynamic locks: %d", total_lock_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1156 if (eliminated_lock_count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1157 tty->print_cr("eliminated locks: %d (%d%%)", eliminated_lock_count,
a61af66fc99e Initial load
duke
parents:
diff changeset
1158 (int)(eliminated_lock_count * 100.0 / total_lock_count));
a61af66fc99e Initial load
duke
parents:
diff changeset
1159 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1160 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1161 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1162
a61af66fc99e Initial load
duke
parents:
diff changeset
1163 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1164 // Allocate a new NamedCounter. The JVMState is used to generate the
a61af66fc99e Initial load
duke
parents:
diff changeset
1165 // name which consists of method@line for the inlining tree.
a61af66fc99e Initial load
duke
parents:
diff changeset
1166 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1167
a61af66fc99e Initial load
duke
parents:
diff changeset
1168 NamedCounter* OptoRuntime::new_named_counter(JVMState* youngest_jvms, NamedCounter::CounterTag tag) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1169 int max_depth = youngest_jvms->depth();
a61af66fc99e Initial load
duke
parents:
diff changeset
1170
a61af66fc99e Initial load
duke
parents:
diff changeset
1171 // Visit scopes from youngest to oldest.
a61af66fc99e Initial load
duke
parents:
diff changeset
1172 bool first = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1173 stringStream st;
a61af66fc99e Initial load
duke
parents:
diff changeset
1174 for (int depth = max_depth; depth >= 1; depth--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1175 JVMState* jvms = youngest_jvms->of_depth(depth);
a61af66fc99e Initial load
duke
parents:
diff changeset
1176 ciMethod* m = jvms->has_method() ? jvms->method() : NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1177 if (!first) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1178 st.print(" ");
a61af66fc99e Initial load
duke
parents:
diff changeset
1179 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1180 first = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1181 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1182 int bci = jvms->bci();
a61af66fc99e Initial load
duke
parents:
diff changeset
1183 if (bci < 0) bci = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1184 st.print("%s.%s@%d", m->holder()->name()->as_utf8(), m->name()->as_utf8(), bci);
a61af66fc99e Initial load
duke
parents:
diff changeset
1185 // To print linenumbers instead of bci use: m->line_number_from_bci(bci)
a61af66fc99e Initial load
duke
parents:
diff changeset
1186 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1187 NamedCounter* c;
a61af66fc99e Initial load
duke
parents:
diff changeset
1188 if (tag == NamedCounter::BiasedLockingCounter) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1189 c = new BiasedLockingNamedCounter(strdup(st.as_string()));
a61af66fc99e Initial load
duke
parents:
diff changeset
1190 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1191 c = new NamedCounter(strdup(st.as_string()), tag);
a61af66fc99e Initial load
duke
parents:
diff changeset
1192 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1193
a61af66fc99e Initial load
duke
parents:
diff changeset
1194 // atomically add the new counter to the head of the list. We only
a61af66fc99e Initial load
duke
parents:
diff changeset
1195 // add counters so this is safe.
a61af66fc99e Initial load
duke
parents:
diff changeset
1196 NamedCounter* head;
a61af66fc99e Initial load
duke
parents:
diff changeset
1197 do {
a61af66fc99e Initial load
duke
parents:
diff changeset
1198 head = _named_counters;
a61af66fc99e Initial load
duke
parents:
diff changeset
1199 c->set_next(head);
a61af66fc99e Initial load
duke
parents:
diff changeset
1200 } while (Atomic::cmpxchg_ptr(c, &_named_counters, head) != head);
a61af66fc99e Initial load
duke
parents:
diff changeset
1201 return c;
a61af66fc99e Initial load
duke
parents:
diff changeset
1202 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1203
a61af66fc99e Initial load
duke
parents:
diff changeset
1204 //-----------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1205 // Non-product code
a61af66fc99e Initial load
duke
parents:
diff changeset
1206 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1207
a61af66fc99e Initial load
duke
parents:
diff changeset
1208 int trace_exception_counter = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1209 static void trace_exception(oop exception_oop, address exception_pc, const char* msg) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1210 ttyLocker ttyl;
a61af66fc99e Initial load
duke
parents:
diff changeset
1211 trace_exception_counter++;
a61af66fc99e Initial load
duke
parents:
diff changeset
1212 tty->print("%d [Exception (%s): ", trace_exception_counter, msg);
a61af66fc99e Initial load
duke
parents:
diff changeset
1213 exception_oop->print_value();
a61af66fc99e Initial load
duke
parents:
diff changeset
1214 tty->print(" in ");
a61af66fc99e Initial load
duke
parents:
diff changeset
1215 CodeBlob* blob = CodeCache::find_blob(exception_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
1216 if (blob->is_nmethod()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1217 ((nmethod*)blob)->method()->print_value();
a61af66fc99e Initial load
duke
parents:
diff changeset
1218 } else if (blob->is_runtime_stub()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1219 tty->print("<runtime-stub>");
a61af66fc99e Initial load
duke
parents:
diff changeset
1220 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1221 tty->print("<unknown>");
a61af66fc99e Initial load
duke
parents:
diff changeset
1222 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1223 tty->print(" at " INTPTR_FORMAT, exception_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
1224 tty->print_cr("]");
a61af66fc99e Initial load
duke
parents:
diff changeset
1225 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1226
a61af66fc99e Initial load
duke
parents:
diff changeset
1227 #endif // PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1228
a61af66fc99e Initial load
duke
parents:
diff changeset
1229
a61af66fc99e Initial load
duke
parents:
diff changeset
1230 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load
duke
parents:
diff changeset
1231 // Called from call sites in compiled code with oop maps (actually safepoints)
a61af66fc99e Initial load
duke
parents:
diff changeset
1232 // Zaps dead locals in first java frame.
a61af66fc99e Initial load
duke
parents:
diff changeset
1233 // Is entry because may need to lock to generate oop maps
a61af66fc99e Initial load
duke
parents:
diff changeset
1234 // Currently, only used for compiler frames, but someday may be used
a61af66fc99e Initial load
duke
parents:
diff changeset
1235 // for interpreter frames, too.
a61af66fc99e Initial load
duke
parents:
diff changeset
1236
a61af66fc99e Initial load
duke
parents:
diff changeset
1237 int OptoRuntime::ZapDeadCompiledLocals_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1238
a61af66fc99e Initial load
duke
parents:
diff changeset
1239 // avoid pointers to member funcs with these helpers
a61af66fc99e Initial load
duke
parents:
diff changeset
1240 static bool is_java_frame( frame* f) { return f->is_java_frame(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
1241 static bool is_native_frame(frame* f) { return f->is_native_frame(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
1242
a61af66fc99e Initial load
duke
parents:
diff changeset
1243
a61af66fc99e Initial load
duke
parents:
diff changeset
1244 void OptoRuntime::zap_dead_java_or_native_locals(JavaThread* thread,
a61af66fc99e Initial load
duke
parents:
diff changeset
1245 bool (*is_this_the_right_frame_to_zap)(frame*)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1246 assert(JavaThread::current() == thread, "is this needed?");
a61af66fc99e Initial load
duke
parents:
diff changeset
1247
a61af66fc99e Initial load
duke
parents:
diff changeset
1248 if ( !ZapDeadCompiledLocals ) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
1249
a61af66fc99e Initial load
duke
parents:
diff changeset
1250 bool skip = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1251
a61af66fc99e Initial load
duke
parents:
diff changeset
1252 if ( ZapDeadCompiledLocalsFirst == 0 ) ; // nothing special
a61af66fc99e Initial load
duke
parents:
diff changeset
1253 else if ( ZapDeadCompiledLocalsFirst > ZapDeadCompiledLocals_count ) skip = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1254 else if ( ZapDeadCompiledLocalsFirst == ZapDeadCompiledLocals_count )
a61af66fc99e Initial load
duke
parents:
diff changeset
1255 warning("starting zapping after skipping");
a61af66fc99e Initial load
duke
parents:
diff changeset
1256
a61af66fc99e Initial load
duke
parents:
diff changeset
1257 if ( ZapDeadCompiledLocalsLast == -1 ) ; // nothing special
a61af66fc99e Initial load
duke
parents:
diff changeset
1258 else if ( ZapDeadCompiledLocalsLast < ZapDeadCompiledLocals_count ) skip = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1259 else if ( ZapDeadCompiledLocalsLast == ZapDeadCompiledLocals_count )
a61af66fc99e Initial load
duke
parents:
diff changeset
1260 warning("about to zap last zap");
a61af66fc99e Initial load
duke
parents:
diff changeset
1261
a61af66fc99e Initial load
duke
parents:
diff changeset
1262 ++ZapDeadCompiledLocals_count; // counts skipped zaps, too
a61af66fc99e Initial load
duke
parents:
diff changeset
1263
a61af66fc99e Initial load
duke
parents:
diff changeset
1264 if ( skip ) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
1265
a61af66fc99e Initial load
duke
parents:
diff changeset
1266 // find java frame and zap it
a61af66fc99e Initial load
duke
parents:
diff changeset
1267
a61af66fc99e Initial load
duke
parents:
diff changeset
1268 for (StackFrameStream sfs(thread); !sfs.is_done(); sfs.next()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1269 if (is_this_the_right_frame_to_zap(sfs.current()) ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1270 sfs.current()->zap_dead_locals(thread, sfs.register_map());
a61af66fc99e Initial load
duke
parents:
diff changeset
1271 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
1272 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1273 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1274 warning("no frame found to zap in zap_dead_Java_locals_C");
a61af66fc99e Initial load
duke
parents:
diff changeset
1275 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1276
a61af66fc99e Initial load
duke
parents:
diff changeset
1277 JRT_LEAF(void, OptoRuntime::zap_dead_Java_locals_C(JavaThread* thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
1278 zap_dead_java_or_native_locals(thread, is_java_frame);
a61af66fc99e Initial load
duke
parents:
diff changeset
1279 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1280
a61af66fc99e Initial load
duke
parents:
diff changeset
1281 // The following does not work because for one thing, the
a61af66fc99e Initial load
duke
parents:
diff changeset
1282 // thread state is wrong; it expects java, but it is native.
605
98cb887364d3 6810672: Comment typos
twisti
parents: 342
diff changeset
1283 // Also, the invariants in a native stub are different and
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1284 // I'm not sure it is safe to have a MachCalRuntimeDirectNode
a61af66fc99e Initial load
duke
parents:
diff changeset
1285 // in there.
a61af66fc99e Initial load
duke
parents:
diff changeset
1286 // So for now, we do not zap in native stubs.
a61af66fc99e Initial load
duke
parents:
diff changeset
1287
a61af66fc99e Initial load
duke
parents:
diff changeset
1288 JRT_LEAF(void, OptoRuntime::zap_dead_native_locals_C(JavaThread* thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
1289 zap_dead_java_or_native_locals(thread, is_native_frame);
a61af66fc99e Initial load
duke
parents:
diff changeset
1290 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1291
a61af66fc99e Initial load
duke
parents:
diff changeset
1292 # endif