annotate src/share/vm/c1/c1_Runtime1.cpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
author johnc
date Sat, 06 Oct 2012 01:17:44 -0700
parents da91efe96a93
children d8ce2825b193
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
4872
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes
never
parents: 4825
diff changeset
2 * Copyright (c) 1999, 2012, 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: 1247
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1247
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: 1247
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: 1905
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
26 #include "asm/codeBuffer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
27 #include "c1/c1_CodeStubs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
28 #include "c1/c1_Defs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
29 #include "c1/c1_FrameMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
30 #include "c1/c1_LIRAssembler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
31 #include "c1/c1_MacroAssembler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
32 #include "c1/c1_Runtime1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
33 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
34 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
35 #include "code/codeBlob.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
36 #include "code/compiledIC.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
37 #include "code/pcDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
38 #include "code/scopeDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
39 #include "code/vtableStubs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
40 #include "compiler/disassembler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
41 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
42 #include "interpreter/bytecode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
43 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
44 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
45 #include "memory/barrierSet.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
46 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
47 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
48 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
49 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
50 #include "runtime/biasedLocking.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
51 #include "runtime/compilationPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
52 #include "runtime/interfaceSupport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
53 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
54 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
55 #include "runtime/threadCritical.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
56 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
57 #include "runtime/vframeArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
58 #include "utilities/copy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1905
diff changeset
59 #include "utilities/events.hpp"
0
a61af66fc99e Initial load
duke
parents:
diff changeset
60
a61af66fc99e Initial load
duke
parents:
diff changeset
61
a61af66fc99e Initial load
duke
parents:
diff changeset
62 // Implementation of StubAssembler
a61af66fc99e Initial load
duke
parents:
diff changeset
63
a61af66fc99e Initial load
duke
parents:
diff changeset
64 StubAssembler::StubAssembler(CodeBuffer* code, const char * name, int stub_id) : C1_MacroAssembler(code) {
a61af66fc99e Initial load
duke
parents:
diff changeset
65 _name = name;
a61af66fc99e Initial load
duke
parents:
diff changeset
66 _must_gc_arguments = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
67 _frame_size = no_frame_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
68 _num_rt_args = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
69 _stub_id = stub_id;
a61af66fc99e Initial load
duke
parents:
diff changeset
70 }
a61af66fc99e Initial load
duke
parents:
diff changeset
71
a61af66fc99e Initial load
duke
parents:
diff changeset
72
a61af66fc99e Initial load
duke
parents:
diff changeset
73 void StubAssembler::set_info(const char* name, bool must_gc_arguments) {
a61af66fc99e Initial load
duke
parents:
diff changeset
74 _name = name;
a61af66fc99e Initial load
duke
parents:
diff changeset
75 _must_gc_arguments = must_gc_arguments;
a61af66fc99e Initial load
duke
parents:
diff changeset
76 }
a61af66fc99e Initial load
duke
parents:
diff changeset
77
a61af66fc99e Initial load
duke
parents:
diff changeset
78
a61af66fc99e Initial load
duke
parents:
diff changeset
79 void StubAssembler::set_frame_size(int size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
80 if (_frame_size == no_frame_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
81 _frame_size = size;
a61af66fc99e Initial load
duke
parents:
diff changeset
82 }
a61af66fc99e Initial load
duke
parents:
diff changeset
83 assert(_frame_size == size, "can't change the frame size");
a61af66fc99e Initial load
duke
parents:
diff changeset
84 }
a61af66fc99e Initial load
duke
parents:
diff changeset
85
a61af66fc99e Initial load
duke
parents:
diff changeset
86
a61af66fc99e Initial load
duke
parents:
diff changeset
87 void StubAssembler::set_num_rt_args(int args) {
a61af66fc99e Initial load
duke
parents:
diff changeset
88 if (_num_rt_args == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
89 _num_rt_args = args;
a61af66fc99e Initial load
duke
parents:
diff changeset
90 }
a61af66fc99e Initial load
duke
parents:
diff changeset
91 assert(_num_rt_args == args, "can't change the number of args");
a61af66fc99e Initial load
duke
parents:
diff changeset
92 }
a61af66fc99e Initial load
duke
parents:
diff changeset
93
a61af66fc99e Initial load
duke
parents:
diff changeset
94 // Implementation of Runtime1
a61af66fc99e Initial load
duke
parents:
diff changeset
95
a61af66fc99e Initial load
duke
parents:
diff changeset
96 CodeBlob* Runtime1::_blobs[Runtime1::number_of_ids];
a61af66fc99e Initial load
duke
parents:
diff changeset
97 const char *Runtime1::_blob_names[] = {
a61af66fc99e Initial load
duke
parents:
diff changeset
98 RUNTIME1_STUBS(STUB_NAME, LAST_STUB_NAME)
a61af66fc99e Initial load
duke
parents:
diff changeset
99 };
a61af66fc99e Initial load
duke
parents:
diff changeset
100
a61af66fc99e Initial load
duke
parents:
diff changeset
101 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
102 // statistics
a61af66fc99e Initial load
duke
parents:
diff changeset
103 int Runtime1::_generic_arraycopy_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
104 int Runtime1::_primitive_arraycopy_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
105 int Runtime1::_oop_arraycopy_cnt = 0;
2446
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
106 int Runtime1::_generic_arraycopystub_cnt = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
107 int Runtime1::_arraycopy_slowcase_cnt = 0;
2446
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
108 int Runtime1::_arraycopy_checkcast_cnt = 0;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
109 int Runtime1::_arraycopy_checkcast_attempt_cnt = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
110 int Runtime1::_new_type_array_slowcase_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
111 int Runtime1::_new_object_array_slowcase_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
112 int Runtime1::_new_instance_slowcase_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
113 int Runtime1::_new_multi_array_slowcase_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
114 int Runtime1::_monitorenter_slowcase_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
115 int Runtime1::_monitorexit_slowcase_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
116 int Runtime1::_patch_code_slowcase_cnt = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
117 int Runtime1::_throw_range_check_exception_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
118 int Runtime1::_throw_index_exception_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
119 int Runtime1::_throw_div0_exception_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
120 int Runtime1::_throw_null_pointer_exception_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
121 int Runtime1::_throw_class_cast_exception_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
122 int Runtime1::_throw_incompatible_class_change_error_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
123 int Runtime1::_throw_array_store_exception_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
124 int Runtime1::_throw_count = 0;
2446
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
125
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
126 static int _byte_arraycopy_cnt = 0;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
127 static int _short_arraycopy_cnt = 0;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
128 static int _int_arraycopy_cnt = 0;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
129 static int _long_arraycopy_cnt = 0;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
130 static int _oop_arraycopy_cnt = 0;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
131
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
132 address Runtime1::arraycopy_count_address(BasicType type) {
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
133 switch (type) {
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
134 case T_BOOLEAN:
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
135 case T_BYTE: return (address)&_byte_arraycopy_cnt;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
136 case T_CHAR:
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
137 case T_SHORT: return (address)&_short_arraycopy_cnt;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
138 case T_FLOAT:
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
139 case T_INT: return (address)&_int_arraycopy_cnt;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
140 case T_DOUBLE:
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
141 case T_LONG: return (address)&_long_arraycopy_cnt;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
142 case T_ARRAY:
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
143 case T_OBJECT: return (address)&_oop_arraycopy_cnt;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
144 default:
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
145 ShouldNotReachHere();
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
146 return NULL;
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
147 }
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
148 }
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
149
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
150
0
a61af66fc99e Initial load
duke
parents:
diff changeset
151 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
152
a61af66fc99e Initial load
duke
parents:
diff changeset
153 // Simple helper to see if the caller of a runtime stub which
a61af66fc99e Initial load
duke
parents:
diff changeset
154 // entered the VM has been deoptimized
a61af66fc99e Initial load
duke
parents:
diff changeset
155
a61af66fc99e Initial load
duke
parents:
diff changeset
156 static bool caller_is_deopted() {
a61af66fc99e Initial load
duke
parents:
diff changeset
157 JavaThread* thread = JavaThread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
158 RegisterMap reg_map(thread, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
159 frame runtime_frame = thread->last_frame();
a61af66fc99e Initial load
duke
parents:
diff changeset
160 frame caller_frame = runtime_frame.sender(&reg_map);
a61af66fc99e Initial load
duke
parents:
diff changeset
161 assert(caller_frame.is_compiled_frame(), "must be compiled");
a61af66fc99e Initial load
duke
parents:
diff changeset
162 return caller_frame.is_deoptimized_frame();
a61af66fc99e Initial load
duke
parents:
diff changeset
163 }
a61af66fc99e Initial load
duke
parents:
diff changeset
164
a61af66fc99e Initial load
duke
parents:
diff changeset
165 // Stress deoptimization
a61af66fc99e Initial load
duke
parents:
diff changeset
166 static void deopt_caller() {
a61af66fc99e Initial load
duke
parents:
diff changeset
167 if ( !caller_is_deopted()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
168 JavaThread* thread = JavaThread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
169 RegisterMap reg_map(thread, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
170 frame runtime_frame = thread->last_frame();
a61af66fc99e Initial load
duke
parents:
diff changeset
171 frame caller_frame = runtime_frame.sender(&reg_map);
1213
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 1142
diff changeset
172 Deoptimization::deoptimize_frame(thread, caller_frame.id());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
173 assert(caller_is_deopted(), "Must be deoptimized");
a61af66fc99e Initial load
duke
parents:
diff changeset
174 }
a61af66fc99e Initial load
duke
parents:
diff changeset
175 }
a61af66fc99e Initial load
duke
parents:
diff changeset
176
a61af66fc99e Initial load
duke
parents:
diff changeset
177
1584
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
178 void Runtime1::generate_blob_for(BufferBlob* buffer_blob, StubID id) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
179 assert(0 <= id && id < number_of_ids, "illegal stub id");
a61af66fc99e Initial load
duke
parents:
diff changeset
180 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // create code buffer for code storage
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1681
diff changeset
182 CodeBuffer code(buffer_blob);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
183
1584
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
184 Compilation::setup_code_buffer(&code, 0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
185
a61af66fc99e Initial load
duke
parents:
diff changeset
186 // create assembler for code generation
a61af66fc99e Initial load
duke
parents:
diff changeset
187 StubAssembler* sasm = new StubAssembler(&code, name_for(id), id);
a61af66fc99e Initial load
duke
parents:
diff changeset
188 // generate code for runtime stub
a61af66fc99e Initial load
duke
parents:
diff changeset
189 OopMapSet* oop_maps;
a61af66fc99e Initial load
duke
parents:
diff changeset
190 oop_maps = generate_code_for(id, sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
191 assert(oop_maps == NULL || sasm->frame_size() != no_frame_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
192 "if stub has an oop map it must have a valid frame size");
a61af66fc99e Initial load
duke
parents:
diff changeset
193
a61af66fc99e Initial load
duke
parents:
diff changeset
194 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
195 // Make sure that stubs that need oopmaps have them
a61af66fc99e Initial load
duke
parents:
diff changeset
196 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
197 // These stubs don't need to have an oopmap
a61af66fc99e Initial load
duke
parents:
diff changeset
198 case dtrace_object_alloc_id:
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
199 case g1_pre_barrier_slow_id:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
200 case g1_post_barrier_slow_id:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
201 case slow_subtype_check_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
202 case fpu2long_stub_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
203 case unwind_exception_id:
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
204 case counter_overflow_id:
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
205 #if defined(SPARC) || defined(PPC)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
206 case handle_exception_nofpu_id: // Unused on sparc
a61af66fc99e Initial load
duke
parents:
diff changeset
207 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
208 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
209
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // All other stubs should have oopmaps
a61af66fc99e Initial load
duke
parents:
diff changeset
211 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
212 assert(oop_maps != NULL, "must have an oopmap");
a61af66fc99e Initial load
duke
parents:
diff changeset
213 }
a61af66fc99e Initial load
duke
parents:
diff changeset
214 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
215
a61af66fc99e Initial load
duke
parents:
diff changeset
216 // align so printing shows nop's instead of random code at the end (SimpleStubs are aligned)
a61af66fc99e Initial load
duke
parents:
diff changeset
217 sasm->align(BytesPerWord);
a61af66fc99e Initial load
duke
parents:
diff changeset
218 // make sure all code is in code buffer
a61af66fc99e Initial load
duke
parents:
diff changeset
219 sasm->flush();
a61af66fc99e Initial load
duke
parents:
diff changeset
220 // create blob - distinguish a few special cases
a61af66fc99e Initial load
duke
parents:
diff changeset
221 CodeBlob* blob = RuntimeStub::new_runtime_stub(name_for(id),
a61af66fc99e Initial load
duke
parents:
diff changeset
222 &code,
a61af66fc99e Initial load
duke
parents:
diff changeset
223 CodeOffsets::frame_never_safe,
a61af66fc99e Initial load
duke
parents:
diff changeset
224 sasm->frame_size(),
a61af66fc99e Initial load
duke
parents:
diff changeset
225 oop_maps,
a61af66fc99e Initial load
duke
parents:
diff changeset
226 sasm->must_gc_arguments());
a61af66fc99e Initial load
duke
parents:
diff changeset
227 // install blob
a61af66fc99e Initial load
duke
parents:
diff changeset
228 assert(blob != NULL, "blob must exist");
a61af66fc99e Initial load
duke
parents:
diff changeset
229 _blobs[id] = blob;
a61af66fc99e Initial load
duke
parents:
diff changeset
230 }
a61af66fc99e Initial load
duke
parents:
diff changeset
231
a61af66fc99e Initial load
duke
parents:
diff changeset
232
1584
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
233 void Runtime1::initialize(BufferBlob* blob) {
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
234 // platform-dependent initialization
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
235 initialize_pd();
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
236 // generate stubs
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
237 for (int id = 0; id < number_of_ids; id++) generate_blob_for(blob, (StubID)id);
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
238 // printing
0
a61af66fc99e Initial load
duke
parents:
diff changeset
239 #ifndef PRODUCT
1584
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
240 if (PrintSimpleStubs) {
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
241 ResourceMark rm;
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
242 for (int id = 0; id < number_of_ids; id++) {
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
243 _blobs[id]->print();
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
244 if (_blobs[id]->oop_maps() != NULL) {
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
245 _blobs[id]->oop_maps()->print();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
246 }
a61af66fc99e Initial load
duke
parents:
diff changeset
247 }
1584
b812ff5abc73 6958292: C1: Enable parallel compilation
iveresov
parents: 1552
diff changeset
248 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
249 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
250 }
a61af66fc99e Initial load
duke
parents:
diff changeset
251
a61af66fc99e Initial load
duke
parents:
diff changeset
252
a61af66fc99e Initial load
duke
parents:
diff changeset
253 CodeBlob* Runtime1::blob_for(StubID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
254 assert(0 <= id && id < number_of_ids, "illegal stub id");
a61af66fc99e Initial load
duke
parents:
diff changeset
255 return _blobs[id];
a61af66fc99e Initial load
duke
parents:
diff changeset
256 }
a61af66fc99e Initial load
duke
parents:
diff changeset
257
a61af66fc99e Initial load
duke
parents:
diff changeset
258
a61af66fc99e Initial load
duke
parents:
diff changeset
259 const char* Runtime1::name_for(StubID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
260 assert(0 <= id && id < number_of_ids, "illegal stub id");
a61af66fc99e Initial load
duke
parents:
diff changeset
261 return _blob_names[id];
a61af66fc99e Initial load
duke
parents:
diff changeset
262 }
a61af66fc99e Initial load
duke
parents:
diff changeset
263
a61af66fc99e Initial load
duke
parents:
diff changeset
264 const char* Runtime1::name_for_address(address entry) {
a61af66fc99e Initial load
duke
parents:
diff changeset
265 for (int id = 0; id < number_of_ids; id++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
266 if (entry == entry_for((StubID)id)) return name_for((StubID)id);
a61af66fc99e Initial load
duke
parents:
diff changeset
267 }
a61af66fc99e Initial load
duke
parents:
diff changeset
268
a61af66fc99e Initial load
duke
parents:
diff changeset
269 #define FUNCTION_CASE(a, f) \
a61af66fc99e Initial load
duke
parents:
diff changeset
270 if ((intptr_t)a == CAST_FROM_FN_PTR(intptr_t, f)) return #f
a61af66fc99e Initial load
duke
parents:
diff changeset
271
a61af66fc99e Initial load
duke
parents:
diff changeset
272 FUNCTION_CASE(entry, os::javaTimeMillis);
a61af66fc99e Initial load
duke
parents:
diff changeset
273 FUNCTION_CASE(entry, os::javaTimeNanos);
a61af66fc99e Initial load
duke
parents:
diff changeset
274 FUNCTION_CASE(entry, SharedRuntime::OSR_migration_end);
a61af66fc99e Initial load
duke
parents:
diff changeset
275 FUNCTION_CASE(entry, SharedRuntime::d2f);
a61af66fc99e Initial load
duke
parents:
diff changeset
276 FUNCTION_CASE(entry, SharedRuntime::d2i);
a61af66fc99e Initial load
duke
parents:
diff changeset
277 FUNCTION_CASE(entry, SharedRuntime::d2l);
a61af66fc99e Initial load
duke
parents:
diff changeset
278 FUNCTION_CASE(entry, SharedRuntime::dcos);
a61af66fc99e Initial load
duke
parents:
diff changeset
279 FUNCTION_CASE(entry, SharedRuntime::dexp);
a61af66fc99e Initial load
duke
parents:
diff changeset
280 FUNCTION_CASE(entry, SharedRuntime::dlog);
a61af66fc99e Initial load
duke
parents:
diff changeset
281 FUNCTION_CASE(entry, SharedRuntime::dlog10);
a61af66fc99e Initial load
duke
parents:
diff changeset
282 FUNCTION_CASE(entry, SharedRuntime::dpow);
a61af66fc99e Initial load
duke
parents:
diff changeset
283 FUNCTION_CASE(entry, SharedRuntime::drem);
a61af66fc99e Initial load
duke
parents:
diff changeset
284 FUNCTION_CASE(entry, SharedRuntime::dsin);
a61af66fc99e Initial load
duke
parents:
diff changeset
285 FUNCTION_CASE(entry, SharedRuntime::dtan);
a61af66fc99e Initial load
duke
parents:
diff changeset
286 FUNCTION_CASE(entry, SharedRuntime::f2i);
a61af66fc99e Initial load
duke
parents:
diff changeset
287 FUNCTION_CASE(entry, SharedRuntime::f2l);
a61af66fc99e Initial load
duke
parents:
diff changeset
288 FUNCTION_CASE(entry, SharedRuntime::frem);
a61af66fc99e Initial load
duke
parents:
diff changeset
289 FUNCTION_CASE(entry, SharedRuntime::l2d);
a61af66fc99e Initial load
duke
parents:
diff changeset
290 FUNCTION_CASE(entry, SharedRuntime::l2f);
a61af66fc99e Initial load
duke
parents:
diff changeset
291 FUNCTION_CASE(entry, SharedRuntime::ldiv);
a61af66fc99e Initial load
duke
parents:
diff changeset
292 FUNCTION_CASE(entry, SharedRuntime::lmul);
a61af66fc99e Initial load
duke
parents:
diff changeset
293 FUNCTION_CASE(entry, SharedRuntime::lrem);
a61af66fc99e Initial load
duke
parents:
diff changeset
294 FUNCTION_CASE(entry, SharedRuntime::lrem);
a61af66fc99e Initial load
duke
parents:
diff changeset
295 FUNCTION_CASE(entry, SharedRuntime::dtrace_method_entry);
a61af66fc99e Initial load
duke
parents:
diff changeset
296 FUNCTION_CASE(entry, SharedRuntime::dtrace_method_exit);
6135
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
297 FUNCTION_CASE(entry, is_instance_of);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
298 FUNCTION_CASE(entry, trace_block_entry);
6006
0105f367a14c 7160570: Intrinsification support for tracing framework
rbackman
parents: 4872
diff changeset
299 #ifdef TRACE_HAVE_INTRINSICS
0105f367a14c 7160570: Intrinsification support for tracing framework
rbackman
parents: 4872
diff changeset
300 FUNCTION_CASE(entry, TRACE_TIME_METHOD);
0105f367a14c 7160570: Intrinsification support for tracing framework
rbackman
parents: 4872
diff changeset
301 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
302
a61af66fc99e Initial load
duke
parents:
diff changeset
303 #undef FUNCTION_CASE
a61af66fc99e Initial load
duke
parents:
diff changeset
304
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
305 // Soft float adds more runtime names.
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
306 return pd_name_for_address(entry);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
307 }
a61af66fc99e Initial load
duke
parents:
diff changeset
308
a61af66fc99e Initial load
duke
parents:
diff changeset
309
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
310 JRT_ENTRY(void, Runtime1::new_instance(JavaThread* thread, Klass* klass))
0
a61af66fc99e Initial load
duke
parents:
diff changeset
311 NOT_PRODUCT(_new_instance_slowcase_cnt++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
312
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
313 assert(klass->is_klass(), "not a class");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
314 instanceKlassHandle h(thread, klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
315 h->check_valid_for_instantiation(true, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
316 // make sure klass is initialized
a61af66fc99e Initial load
duke
parents:
diff changeset
317 h->initialize(CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
318 // allocate instance and return via TLS
a61af66fc99e Initial load
duke
parents:
diff changeset
319 oop obj = h->allocate_instance(CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
320 thread->set_vm_result(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
321 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
322
a61af66fc99e Initial load
duke
parents:
diff changeset
323
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
324 JRT_ENTRY(void, Runtime1::new_type_array(JavaThread* thread, Klass* klass, jint length))
0
a61af66fc99e Initial load
duke
parents:
diff changeset
325 NOT_PRODUCT(_new_type_array_slowcase_cnt++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
326 // Note: no handle for klass needed since they are not used
a61af66fc99e Initial load
duke
parents:
diff changeset
327 // anymore after new_typeArray() and no GC can happen before.
a61af66fc99e Initial load
duke
parents:
diff changeset
328 // (This may have to change if this code changes!)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
329 assert(klass->is_klass(), "not a class");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
330 BasicType elt_type = typeArrayKlass::cast(klass)->element_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
331 oop obj = oopFactory::new_typeArray(elt_type, length, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
332 thread->set_vm_result(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
333 // This is pretty rare but this runtime patch is stressful to deoptimization
a61af66fc99e Initial load
duke
parents:
diff changeset
334 // if we deoptimize here so force a deopt to stress the path.
a61af66fc99e Initial load
duke
parents:
diff changeset
335 if (DeoptimizeALot) {
a61af66fc99e Initial load
duke
parents:
diff changeset
336 deopt_caller();
a61af66fc99e Initial load
duke
parents:
diff changeset
337 }
a61af66fc99e Initial load
duke
parents:
diff changeset
338
a61af66fc99e Initial load
duke
parents:
diff changeset
339 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
340
a61af66fc99e Initial load
duke
parents:
diff changeset
341
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
342 JRT_ENTRY(void, Runtime1::new_object_array(JavaThread* thread, Klass* array_klass, jint length))
0
a61af66fc99e Initial load
duke
parents:
diff changeset
343 NOT_PRODUCT(_new_object_array_slowcase_cnt++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
344
a61af66fc99e Initial load
duke
parents:
diff changeset
345 // Note: no handle for klass needed since they are not used
a61af66fc99e Initial load
duke
parents:
diff changeset
346 // anymore after new_objArray() and no GC can happen before.
a61af66fc99e Initial load
duke
parents:
diff changeset
347 // (This may have to change if this code changes!)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
348 assert(array_klass->is_klass(), "not a class");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
349 Klass* elem_klass = objArrayKlass::cast(array_klass)->element_klass();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
350 objArrayOop obj = oopFactory::new_objArray(elem_klass, length, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
351 thread->set_vm_result(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
352 // This is pretty rare but this runtime patch is stressful to deoptimization
a61af66fc99e Initial load
duke
parents:
diff changeset
353 // if we deoptimize here so force a deopt to stress the path.
a61af66fc99e Initial load
duke
parents:
diff changeset
354 if (DeoptimizeALot) {
a61af66fc99e Initial load
duke
parents:
diff changeset
355 deopt_caller();
a61af66fc99e Initial load
duke
parents:
diff changeset
356 }
a61af66fc99e Initial load
duke
parents:
diff changeset
357 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
358
a61af66fc99e Initial load
duke
parents:
diff changeset
359
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
360 JRT_ENTRY(void, Runtime1::new_multi_array(JavaThread* thread, Klass* klass, int rank, jint* dims))
0
a61af66fc99e Initial load
duke
parents:
diff changeset
361 NOT_PRODUCT(_new_multi_array_slowcase_cnt++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
362
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
363 assert(klass->is_klass(), "not a class");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
364 assert(rank >= 1, "rank must be nonzero");
a61af66fc99e Initial load
duke
parents:
diff changeset
365 oop obj = arrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
366 thread->set_vm_result(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
367 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
368
a61af66fc99e Initial load
duke
parents:
diff changeset
369
a61af66fc99e Initial load
duke
parents:
diff changeset
370 JRT_ENTRY(void, Runtime1::unimplemented_entry(JavaThread* thread, StubID id))
a61af66fc99e Initial load
duke
parents:
diff changeset
371 tty->print_cr("Runtime1::entry_for(%d) returned unimplemented entry point", id);
a61af66fc99e Initial load
duke
parents:
diff changeset
372 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
373
a61af66fc99e Initial load
duke
parents:
diff changeset
374
2168
e4fee0bdaa85 7008809: should report the class in ArrayStoreExceptions from compiled code
never
parents: 2142
diff changeset
375 JRT_ENTRY(void, Runtime1::throw_array_store_exception(JavaThread* thread, oopDesc* obj))
e4fee0bdaa85 7008809: should report the class in ArrayStoreExceptions from compiled code
never
parents: 2142
diff changeset
376 ResourceMark rm(thread);
e4fee0bdaa85 7008809: should report the class in ArrayStoreExceptions from compiled code
never
parents: 2142
diff changeset
377 const char* klass_name = Klass::cast(obj->klass())->external_name();
e4fee0bdaa85 7008809: should report the class in ArrayStoreExceptions from compiled code
never
parents: 2142
diff changeset
378 SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArrayStoreException(), klass_name);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
379 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
380
a61af66fc99e Initial load
duke
parents:
diff changeset
381
3791
2c359f27615c 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 3269
diff changeset
382 // counter_overflow() is called from within C1-compiled methods. The enclosing method is the method
2c359f27615c 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 3269
diff changeset
383 // associated with the top activation record. The inlinee (that is possibly included in the enclosing
2c359f27615c 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 3269
diff changeset
384 // method) method oop is passed as an argument. In order to do that it is embedded in the code as
2c359f27615c 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 3269
diff changeset
385 // a constant.
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
386 static nmethod* counter_overflow_helper(JavaThread* THREAD, int branch_bci, Method* m) {
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
387 nmethod* osr_nm = NULL;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
388 methodHandle method(THREAD, m);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
389
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
390 RegisterMap map(THREAD, false);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
391 frame fr = THREAD->last_frame().sender(&map);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
392 nmethod* nm = (nmethod*) fr.cb();
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
393 assert(nm!= NULL && nm->is_nmethod(), "Sanity check");
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
394 methodHandle enclosing_method(THREAD, nm->method());
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
395
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
396 CompLevel level = (CompLevel)nm->comp_level();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
397 int bci = InvocationEntryBci;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
398 if (branch_bci != InvocationEntryBci) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
399 // Compute desination bci
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
400 address pc = method()->code_base() + branch_bci;
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
401 Bytecodes::Code branch = Bytecodes::code_at(method(), pc);
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
402 int offset = 0;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
403 switch (branch) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
404 case Bytecodes::_if_icmplt: case Bytecodes::_iflt:
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
405 case Bytecodes::_if_icmpgt: case Bytecodes::_ifgt:
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
406 case Bytecodes::_if_icmple: case Bytecodes::_ifle:
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
407 case Bytecodes::_if_icmpge: case Bytecodes::_ifge:
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
408 case Bytecodes::_if_icmpeq: case Bytecodes::_if_acmpeq: case Bytecodes::_ifeq:
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
409 case Bytecodes::_if_icmpne: case Bytecodes::_if_acmpne: case Bytecodes::_ifne:
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
410 case Bytecodes::_ifnull: case Bytecodes::_ifnonnull: case Bytecodes::_goto:
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
411 offset = (int16_t)Bytes::get_Java_u2(pc + 1);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
412 break;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
413 case Bytecodes::_goto_w:
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
414 offset = Bytes::get_Java_u4(pc + 1);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
415 break;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
416 default: ;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
417 }
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
418 bci = branch_bci + offset;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
419 }
4825
20334ed5ed3c 7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents: 4048
diff changeset
420 assert(!HAS_PENDING_EXCEPTION, "Should not have any exceptions pending");
3791
2c359f27615c 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 3269
diff changeset
421 osr_nm = CompilationPolicy::policy()->event(enclosing_method, method, branch_bci, bci, level, nm, THREAD);
4825
20334ed5ed3c 7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents: 4048
diff changeset
422 assert(!HAS_PENDING_EXCEPTION, "Event handler should not throw any exceptions");
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
423 return osr_nm;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
424 }
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
425
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
426 JRT_BLOCK_ENTRY(address, Runtime1::counter_overflow(JavaThread* thread, int bci, Method* method))
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
427 nmethod* osr_nm;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
428 JRT_BLOCK
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
429 osr_nm = counter_overflow_helper(thread, bci, method);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
430 if (osr_nm != NULL) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
431 RegisterMap map(thread, false);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
432 frame fr = thread->last_frame().sender(&map);
1905
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents: 1783
diff changeset
433 Deoptimization::deoptimize_frame(thread, fr.id());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
434 }
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
435 JRT_BLOCK_END
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
436 return NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
437 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
438
a61af66fc99e Initial load
duke
parents:
diff changeset
439 extern void vm_exit(int code);
a61af66fc99e Initial load
duke
parents:
diff changeset
440
a61af66fc99e Initial load
duke
parents:
diff changeset
441 // Enter this method from compiled code handler below. This is where we transition
a61af66fc99e Initial load
duke
parents:
diff changeset
442 // to VM mode. This is done as a helper routine so that the method called directly
a61af66fc99e Initial load
duke
parents:
diff changeset
443 // from compiled code does not have to transition to VM. This allows the entry
a61af66fc99e Initial load
duke
parents:
diff changeset
444 // method to see if the nmethod that we have just looked up a handler for has
a61af66fc99e Initial load
duke
parents:
diff changeset
445 // been deoptimized while we were in the vm. This simplifies the assembly code
a61af66fc99e Initial load
duke
parents:
diff changeset
446 // cpu directories.
a61af66fc99e Initial load
duke
parents:
diff changeset
447 //
a61af66fc99e Initial load
duke
parents:
diff changeset
448 // We are entering here from exception stub (via the entry method below)
a61af66fc99e Initial load
duke
parents:
diff changeset
449 // If there is a compiled exception handler in this method, we will continue there;
a61af66fc99e Initial load
duke
parents:
diff changeset
450 // otherwise we will unwind the stack and continue at the caller of top frame method
a61af66fc99e Initial load
duke
parents:
diff changeset
451 // Note: we enter in Java using a special JRT wrapper. This wrapper allows us to
a61af66fc99e Initial load
duke
parents:
diff changeset
452 // control the area where we can allow a safepoint. After we exit the safepoint area we can
a61af66fc99e Initial load
duke
parents:
diff changeset
453 // check to see if the handler we are going to return is now in a nmethod that has
a61af66fc99e Initial load
duke
parents:
diff changeset
454 // been deoptimized. If that is the case we return the deopt blob
a61af66fc99e Initial load
duke
parents:
diff changeset
455 // unpack_with_exception entry instead. This makes life for the exception blob easier
a61af66fc99e Initial load
duke
parents:
diff changeset
456 // because making that same check and diverting is painful from assembly language.
a61af66fc99e Initial load
duke
parents:
diff changeset
457 JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* thread, oopDesc* ex, address pc, nmethod*& nm))
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
458 // Reset method handle flag.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
459 thread->set_is_method_handle_return(false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
460
a61af66fc99e Initial load
duke
parents:
diff changeset
461 Handle exception(thread, ex);
a61af66fc99e Initial load
duke
parents:
diff changeset
462 nm = CodeCache::find_nmethod(pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
463 assert(nm != NULL, "this is not an nmethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
464 // Adjust the pc as needed/
a61af66fc99e Initial load
duke
parents:
diff changeset
465 if (nm->is_deopt_pc(pc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
466 RegisterMap map(thread, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
467 frame exception_frame = thread->last_frame().sender(&map);
a61af66fc99e Initial load
duke
parents:
diff changeset
468 // if the frame isn't deopted then pc must not correspond to the caller of last_frame
a61af66fc99e Initial load
duke
parents:
diff changeset
469 assert(exception_frame.is_deoptimized_frame(), "must be deopted");
a61af66fc99e Initial load
duke
parents:
diff changeset
470 pc = exception_frame.pc();
a61af66fc99e Initial load
duke
parents:
diff changeset
471 }
a61af66fc99e Initial load
duke
parents:
diff changeset
472 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
473 assert(exception.not_null(), "NULL exceptions should be handled by throw_exception");
a61af66fc99e Initial load
duke
parents:
diff changeset
474 assert(exception->is_oop(), "just checking");
a61af66fc99e Initial load
duke
parents:
diff changeset
475 // Check that exception is a subclass of Throwable, otherwise we have a VerifyError
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 579
diff changeset
476 if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
477 if (ExitVMOnVerifyError) vm_exit(-1);
a61af66fc99e Initial load
duke
parents:
diff changeset
478 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
479 }
a61af66fc99e Initial load
duke
parents:
diff changeset
480 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
481
a61af66fc99e Initial load
duke
parents:
diff changeset
482 // Check the stack guard pages and reenable them if necessary and there is
a61af66fc99e Initial load
duke
parents:
diff changeset
483 // enough space on the stack to do so. Use fast exceptions only if the guard
a61af66fc99e Initial load
duke
parents:
diff changeset
484 // pages are enabled.
a61af66fc99e Initial load
duke
parents:
diff changeset
485 bool guard_pages_enabled = thread->stack_yellow_zone_enabled();
a61af66fc99e Initial load
duke
parents:
diff changeset
486 if (!guard_pages_enabled) guard_pages_enabled = thread->reguard_stack();
a61af66fc99e Initial load
duke
parents:
diff changeset
487
1213
6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 1142
diff changeset
488 if (JvmtiExport::can_post_on_exceptions()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
489 // To ensure correct notification of exception catches and throws
a61af66fc99e Initial load
duke
parents:
diff changeset
490 // we have to deoptimize here. If we attempted to notify the
a61af66fc99e Initial load
duke
parents:
diff changeset
491 // catches and throws during this exception lookup it's possible
a61af66fc99e Initial load
duke
parents:
diff changeset
492 // we could deoptimize on the way out of the VM and end back in
a61af66fc99e Initial load
duke
parents:
diff changeset
493 // the interpreter at the throw site. This would result in double
a61af66fc99e Initial load
duke
parents:
diff changeset
494 // notifications since the interpreter would also notify about
a61af66fc99e Initial load
duke
parents:
diff changeset
495 // these same catches and throws as it unwound the frame.
a61af66fc99e Initial load
duke
parents:
diff changeset
496
a61af66fc99e Initial load
duke
parents:
diff changeset
497 RegisterMap reg_map(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
498 frame stub_frame = thread->last_frame();
a61af66fc99e Initial load
duke
parents:
diff changeset
499 frame caller_frame = stub_frame.sender(&reg_map);
a61af66fc99e Initial load
duke
parents:
diff changeset
500
a61af66fc99e Initial load
duke
parents:
diff changeset
501 // We don't really want to deoptimize the nmethod itself since we
a61af66fc99e Initial load
duke
parents:
diff changeset
502 // can actually continue in the exception handler ourselves but I
a61af66fc99e Initial load
duke
parents:
diff changeset
503 // don't see an easy way to have the desired effect.
1905
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents: 1783
diff changeset
504 Deoptimization::deoptimize_frame(thread, caller_frame.id());
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents: 1783
diff changeset
505 assert(caller_is_deopted(), "Must be deoptimized");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
506
a61af66fc99e Initial load
duke
parents:
diff changeset
507 return SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
a61af66fc99e Initial load
duke
parents:
diff changeset
508 }
a61af66fc99e Initial load
duke
parents:
diff changeset
509
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
510 // ExceptionCache is used only for exceptions at call sites and not for implicit exceptions
0
a61af66fc99e Initial load
duke
parents:
diff changeset
511 if (guard_pages_enabled) {
a61af66fc99e Initial load
duke
parents:
diff changeset
512 address fast_continuation = nm->handler_for_exception_and_pc(exception, pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
513 if (fast_continuation != NULL) {
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
514 // Set flag if return address is a method handle call site.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
515 thread->set_is_method_handle_return(nm->is_method_handle_return(pc));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
516 return fast_continuation;
a61af66fc99e Initial load
duke
parents:
diff changeset
517 }
a61af66fc99e Initial load
duke
parents:
diff changeset
518 }
a61af66fc99e Initial load
duke
parents:
diff changeset
519
a61af66fc99e Initial load
duke
parents:
diff changeset
520 // If the stack guard pages are enabled, check whether there is a handler in
a61af66fc99e Initial load
duke
parents:
diff changeset
521 // the current method. Otherwise (guard pages disabled), force an unwind and
a61af66fc99e Initial load
duke
parents:
diff changeset
522 // skip the exception cache update (i.e., just leave continuation==NULL).
a61af66fc99e Initial load
duke
parents:
diff changeset
523 address continuation = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
524 if (guard_pages_enabled) {
a61af66fc99e Initial load
duke
parents:
diff changeset
525
a61af66fc99e Initial load
duke
parents:
diff changeset
526 // New exception handling mechanism can support inlined methods
a61af66fc99e Initial load
duke
parents:
diff changeset
527 // with exception handlers since the mappings are from PC to PC
a61af66fc99e Initial load
duke
parents:
diff changeset
528
a61af66fc99e Initial load
duke
parents:
diff changeset
529 // debugging support
a61af66fc99e Initial load
duke
parents:
diff changeset
530 // tracing
a61af66fc99e Initial load
duke
parents:
diff changeset
531 if (TraceExceptions) {
a61af66fc99e Initial load
duke
parents:
diff changeset
532 ttyLocker ttyl;
a61af66fc99e Initial load
duke
parents:
diff changeset
533 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
534 tty->print_cr("Exception <%s> (0x%x) thrown in compiled method <%s> at PC " PTR_FORMAT " for thread 0x%x",
a61af66fc99e Initial load
duke
parents:
diff changeset
535 exception->print_value_string(), (address)exception(), nm->method()->print_value_string(), pc, thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
536 }
a61af66fc99e Initial load
duke
parents:
diff changeset
537 // for AbortVMOnException flag
a61af66fc99e Initial load
duke
parents:
diff changeset
538 NOT_PRODUCT(Exceptions::debug_check_abort(exception));
a61af66fc99e Initial load
duke
parents:
diff changeset
539
a61af66fc99e Initial load
duke
parents:
diff changeset
540 // Clear out the exception oop and pc since looking up an
a61af66fc99e Initial load
duke
parents:
diff changeset
541 // exception handler can cause class loading, which might throw an
a61af66fc99e Initial load
duke
parents:
diff changeset
542 // exception and those fields are expected to be clear during
a61af66fc99e Initial load
duke
parents:
diff changeset
543 // normal bytecode execution.
a61af66fc99e Initial load
duke
parents:
diff changeset
544 thread->set_exception_oop(NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
545 thread->set_exception_pc(NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
546
a61af66fc99e Initial load
duke
parents:
diff changeset
547 continuation = SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
548 // If an exception was thrown during exception dispatch, the exception oop may have changed
a61af66fc99e Initial load
duke
parents:
diff changeset
549 thread->set_exception_oop(exception());
a61af66fc99e Initial load
duke
parents:
diff changeset
550 thread->set_exception_pc(pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
551
a61af66fc99e Initial load
duke
parents:
diff changeset
552 // the exception cache is used only by non-implicit exceptions
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
553 if (continuation != NULL) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
554 nm->add_handler_for_exception_and_pc(exception, pc, continuation);
a61af66fc99e Initial load
duke
parents:
diff changeset
555 }
a61af66fc99e Initial load
duke
parents:
diff changeset
556 }
a61af66fc99e Initial load
duke
parents:
diff changeset
557
a61af66fc99e Initial load
duke
parents:
diff changeset
558 thread->set_vm_result(exception());
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
559 // Set flag if return address is a method handle call site.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
560 thread->set_is_method_handle_return(nm->is_method_handle_return(pc));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
561
a61af66fc99e Initial load
duke
parents:
diff changeset
562 if (TraceExceptions) {
a61af66fc99e Initial load
duke
parents:
diff changeset
563 ttyLocker ttyl;
a61af66fc99e Initial load
duke
parents:
diff changeset
564 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
565 tty->print_cr("Thread " PTR_FORMAT " continuing at PC " PTR_FORMAT " for exception thrown at PC " PTR_FORMAT,
a61af66fc99e Initial load
duke
parents:
diff changeset
566 thread, continuation, pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
567 }
a61af66fc99e Initial load
duke
parents:
diff changeset
568
a61af66fc99e Initial load
duke
parents:
diff changeset
569 return continuation;
a61af66fc99e Initial load
duke
parents:
diff changeset
570 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
571
a61af66fc99e Initial load
duke
parents:
diff changeset
572 // Enter this method from compiled code only if there is a Java exception handler
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
573 // in the method handling the exception.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
574 // We are entering here from exception stub. We don't do a normal VM transition here.
a61af66fc99e Initial load
duke
parents:
diff changeset
575 // We do it in a helper. This is so we can check to see if the nmethod we have just
a61af66fc99e Initial load
duke
parents:
diff changeset
576 // searched for an exception handler has been deoptimized in the meantime.
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
577 address Runtime1::exception_handler_for_pc(JavaThread* thread) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
578 oop exception = thread->exception_oop();
a61af66fc99e Initial load
duke
parents:
diff changeset
579 address pc = thread->exception_pc();
a61af66fc99e Initial load
duke
parents:
diff changeset
580 // Still in Java mode
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
581 DEBUG_ONLY(ResetNoHandleMark rnhm);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
582 nmethod* nm = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
583 address continuation = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
584 {
a61af66fc99e Initial load
duke
parents:
diff changeset
585 // Enter VM mode by calling the helper
a61af66fc99e Initial load
duke
parents:
diff changeset
586 ResetNoHandleMark rnhm;
a61af66fc99e Initial load
duke
parents:
diff changeset
587 continuation = exception_handler_for_pc_helper(thread, exception, pc, nm);
a61af66fc99e Initial load
duke
parents:
diff changeset
588 }
a61af66fc99e Initial load
duke
parents:
diff changeset
589 // Back in JAVA, use no oops DON'T safepoint
a61af66fc99e Initial load
duke
parents:
diff changeset
590
a61af66fc99e Initial load
duke
parents:
diff changeset
591 // Now check to see if the nmethod we were called from is now deoptimized.
a61af66fc99e Initial load
duke
parents:
diff changeset
592 // If so we must return to the deopt blob and deoptimize the nmethod
a61af66fc99e Initial load
duke
parents:
diff changeset
593 if (nm != NULL && caller_is_deopted()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
594 continuation = SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
a61af66fc99e Initial load
duke
parents:
diff changeset
595 }
a61af66fc99e Initial load
duke
parents:
diff changeset
596
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
597 assert(continuation != NULL, "no handler found");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
598 return continuation;
a61af66fc99e Initial load
duke
parents:
diff changeset
599 }
a61af66fc99e Initial load
duke
parents:
diff changeset
600
a61af66fc99e Initial load
duke
parents:
diff changeset
601
a61af66fc99e Initial load
duke
parents:
diff changeset
602 JRT_ENTRY(void, Runtime1::throw_range_check_exception(JavaThread* thread, int index))
a61af66fc99e Initial load
duke
parents:
diff changeset
603 NOT_PRODUCT(_throw_range_check_exception_count++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
604 char message[jintAsStringSize];
a61af66fc99e Initial load
duke
parents:
diff changeset
605 sprintf(message, "%d", index);
a61af66fc99e Initial load
duke
parents:
diff changeset
606 SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), message);
a61af66fc99e Initial load
duke
parents:
diff changeset
607 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
608
a61af66fc99e Initial load
duke
parents:
diff changeset
609
a61af66fc99e Initial load
duke
parents:
diff changeset
610 JRT_ENTRY(void, Runtime1::throw_index_exception(JavaThread* thread, int index))
a61af66fc99e Initial load
duke
parents:
diff changeset
611 NOT_PRODUCT(_throw_index_exception_count++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
612 char message[16];
a61af66fc99e Initial load
duke
parents:
diff changeset
613 sprintf(message, "%d", index);
a61af66fc99e Initial load
duke
parents:
diff changeset
614 SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_IndexOutOfBoundsException(), message);
a61af66fc99e Initial load
duke
parents:
diff changeset
615 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
616
a61af66fc99e Initial load
duke
parents:
diff changeset
617
a61af66fc99e Initial load
duke
parents:
diff changeset
618 JRT_ENTRY(void, Runtime1::throw_div0_exception(JavaThread* thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
619 NOT_PRODUCT(_throw_div0_exception_count++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
620 SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArithmeticException(), "/ by zero");
a61af66fc99e Initial load
duke
parents:
diff changeset
621 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
622
a61af66fc99e Initial load
duke
parents:
diff changeset
623
a61af66fc99e Initial load
duke
parents:
diff changeset
624 JRT_ENTRY(void, Runtime1::throw_null_pointer_exception(JavaThread* thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
625 NOT_PRODUCT(_throw_null_pointer_exception_count++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
626 SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException());
a61af66fc99e Initial load
duke
parents:
diff changeset
627 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
628
a61af66fc99e Initial load
duke
parents:
diff changeset
629
a61af66fc99e Initial load
duke
parents:
diff changeset
630 JRT_ENTRY(void, Runtime1::throw_class_cast_exception(JavaThread* thread, oopDesc* object))
a61af66fc99e Initial load
duke
parents:
diff changeset
631 NOT_PRODUCT(_throw_class_cast_exception_count++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
632 ResourceMark rm(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
633 char* message = SharedRuntime::generate_class_cast_message(
a61af66fc99e Initial load
duke
parents:
diff changeset
634 thread, Klass::cast(object->klass())->external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
635 SharedRuntime::throw_and_post_jvmti_exception(
a61af66fc99e Initial load
duke
parents:
diff changeset
636 thread, vmSymbols::java_lang_ClassCastException(), message);
a61af66fc99e Initial load
duke
parents:
diff changeset
637 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
638
a61af66fc99e Initial load
duke
parents:
diff changeset
639
a61af66fc99e Initial load
duke
parents:
diff changeset
640 JRT_ENTRY(void, Runtime1::throw_incompatible_class_change_error(JavaThread* thread))
a61af66fc99e Initial load
duke
parents:
diff changeset
641 NOT_PRODUCT(_throw_incompatible_class_change_error_count++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
642 ResourceMark rm(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
643 SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_IncompatibleClassChangeError());
a61af66fc99e Initial load
duke
parents:
diff changeset
644 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
645
a61af66fc99e Initial load
duke
parents:
diff changeset
646
a61af66fc99e Initial load
duke
parents:
diff changeset
647 JRT_ENTRY_NO_ASYNC(void, Runtime1::monitorenter(JavaThread* thread, oopDesc* obj, BasicObjectLock* lock))
a61af66fc99e Initial load
duke
parents:
diff changeset
648 NOT_PRODUCT(_monitorenter_slowcase_cnt++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
649 if (PrintBiasedLockingStatistics) {
a61af66fc99e Initial load
duke
parents:
diff changeset
650 Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
a61af66fc99e Initial load
duke
parents:
diff changeset
651 }
a61af66fc99e Initial load
duke
parents:
diff changeset
652 Handle h_obj(thread, obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
653 assert(h_obj()->is_oop(), "must be NULL or an object");
a61af66fc99e Initial load
duke
parents:
diff changeset
654 if (UseBiasedLocking) {
a61af66fc99e Initial load
duke
parents:
diff changeset
655 // Retry fast entry if bias is revoked to avoid unnecessary inflation
a61af66fc99e Initial load
duke
parents:
diff changeset
656 ObjectSynchronizer::fast_enter(h_obj, lock->lock(), true, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
657 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
658 if (UseFastLocking) {
a61af66fc99e Initial load
duke
parents:
diff changeset
659 // When using fast locking, the compiled code has already tried the fast case
a61af66fc99e Initial load
duke
parents:
diff changeset
660 assert(obj == lock->obj(), "must match");
a61af66fc99e Initial load
duke
parents:
diff changeset
661 ObjectSynchronizer::slow_enter(h_obj, lock->lock(), THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
662 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
663 lock->set_obj(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
664 ObjectSynchronizer::fast_enter(h_obj, lock->lock(), false, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
665 }
a61af66fc99e Initial load
duke
parents:
diff changeset
666 }
a61af66fc99e Initial load
duke
parents:
diff changeset
667 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
668
a61af66fc99e Initial load
duke
parents:
diff changeset
669
a61af66fc99e Initial load
duke
parents:
diff changeset
670 JRT_LEAF(void, Runtime1::monitorexit(JavaThread* thread, BasicObjectLock* lock))
a61af66fc99e Initial load
duke
parents:
diff changeset
671 NOT_PRODUCT(_monitorexit_slowcase_cnt++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
672 assert(thread == JavaThread::current(), "threads must correspond");
a61af66fc99e Initial load
duke
parents:
diff changeset
673 assert(thread->last_Java_sp(), "last_Java_sp must be set");
a61af66fc99e Initial load
duke
parents:
diff changeset
674 // monitorexit is non-blocking (leaf routine) => no exceptions can be thrown
a61af66fc99e Initial load
duke
parents:
diff changeset
675 EXCEPTION_MARK;
a61af66fc99e Initial load
duke
parents:
diff changeset
676
a61af66fc99e Initial load
duke
parents:
diff changeset
677 oop obj = lock->obj();
a61af66fc99e Initial load
duke
parents:
diff changeset
678 assert(obj->is_oop(), "must be NULL or an object");
a61af66fc99e Initial load
duke
parents:
diff changeset
679 if (UseFastLocking) {
a61af66fc99e Initial load
duke
parents:
diff changeset
680 // When using fast locking, the compiled code has already tried the fast case
a61af66fc99e Initial load
duke
parents:
diff changeset
681 ObjectSynchronizer::slow_exit(obj, lock->lock(), THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
682 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
683 ObjectSynchronizer::fast_exit(obj, lock->lock(), THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
684 }
a61af66fc99e Initial load
duke
parents:
diff changeset
685 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
686
4048
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
687 // Cf. OptoRuntime::deoptimize_caller_frame
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
688 JRT_ENTRY(void, Runtime1::deoptimize(JavaThread* thread))
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
689 // Called from within the owner thread, so no need for safepoint
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
690 RegisterMap reg_map(thread, false);
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
691 frame stub_frame = thread->last_frame();
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
692 assert(stub_frame.is_runtime_frame(), "sanity check");
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
693 frame caller_frame = stub_frame.sender(&reg_map);
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
694
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
695 // We are coming from a compiled method; check this is true.
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
696 assert(CodeCache::find_nmethod(caller_frame.pc()) != NULL, "sanity");
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
697
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
698 // Deoptimize the caller frame.
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
699 Deoptimization::deoptimize_frame(thread, caller_frame.id());
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
700
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
701 // Return to the now deoptimized frame.
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
702 JRT_END
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
703
0
a61af66fc99e Initial load
duke
parents:
diff changeset
704
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
705 static Klass* resolve_field_return_klass(methodHandle caller, int bci, TRAPS) {
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
706 Bytecode_field field_access(caller, bci);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
707 // This can be static or non-static field access
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
708 Bytecodes::Code code = field_access.code();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
709
a61af66fc99e Initial load
duke
parents:
diff changeset
710 // We must load class, initialize class and resolvethe field
a61af66fc99e Initial load
duke
parents:
diff changeset
711 FieldAccessInfo result; // initialize class if needed
a61af66fc99e Initial load
duke
parents:
diff changeset
712 constantPoolHandle constants(THREAD, caller->constants());
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
713 LinkResolver::resolve_field(result, constants, field_access.index(), Bytecodes::java_code(code), false, CHECK_NULL);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
714 return result.klass()();
a61af66fc99e Initial load
duke
parents:
diff changeset
715 }
a61af66fc99e Initial load
duke
parents:
diff changeset
716
a61af66fc99e Initial load
duke
parents:
diff changeset
717
a61af66fc99e Initial load
duke
parents:
diff changeset
718 //
a61af66fc99e Initial load
duke
parents:
diff changeset
719 // This routine patches sites where a class wasn't loaded or
a61af66fc99e Initial load
duke
parents:
diff changeset
720 // initialized at the time the code was generated. It handles
a61af66fc99e Initial load
duke
parents:
diff changeset
721 // references to classes, fields and forcing of initialization. Most
a61af66fc99e Initial load
duke
parents:
diff changeset
722 // of the cases are straightforward and involving simply forcing
a61af66fc99e Initial load
duke
parents:
diff changeset
723 // resolution of a class, rewriting the instruction stream with the
a61af66fc99e Initial load
duke
parents:
diff changeset
724 // needed constant and replacing the call in this function with the
a61af66fc99e Initial load
duke
parents:
diff changeset
725 // patched code. The case for static field is more complicated since
a61af66fc99e Initial load
duke
parents:
diff changeset
726 // the thread which is in the process of initializing a class can
a61af66fc99e Initial load
duke
parents:
diff changeset
727 // access it's static fields but other threads can't so the code
a61af66fc99e Initial load
duke
parents:
diff changeset
728 // either has to deoptimize when this case is detected or execute a
a61af66fc99e Initial load
duke
parents:
diff changeset
729 // check that the current thread is the initializing thread. The
a61af66fc99e Initial load
duke
parents:
diff changeset
730 // current
a61af66fc99e Initial load
duke
parents:
diff changeset
731 //
a61af66fc99e Initial load
duke
parents:
diff changeset
732 // Patches basically look like this:
a61af66fc99e Initial load
duke
parents:
diff changeset
733 //
a61af66fc99e Initial load
duke
parents:
diff changeset
734 //
a61af66fc99e Initial load
duke
parents:
diff changeset
735 // patch_site: jmp patch stub ;; will be patched
a61af66fc99e Initial load
duke
parents:
diff changeset
736 // continue: ...
a61af66fc99e Initial load
duke
parents:
diff changeset
737 // ...
a61af66fc99e Initial load
duke
parents:
diff changeset
738 // ...
a61af66fc99e Initial load
duke
parents:
diff changeset
739 // ...
a61af66fc99e Initial load
duke
parents:
diff changeset
740 //
a61af66fc99e Initial load
duke
parents:
diff changeset
741 // They have a stub which looks like this:
a61af66fc99e Initial load
duke
parents:
diff changeset
742 //
a61af66fc99e Initial load
duke
parents:
diff changeset
743 // ;; patch body
a61af66fc99e Initial load
duke
parents:
diff changeset
744 // movl <const>, reg (for class constants)
a61af66fc99e Initial load
duke
parents:
diff changeset
745 // <or> movl [reg1 + <const>], reg (for field offsets)
a61af66fc99e Initial load
duke
parents:
diff changeset
746 // <or> movl reg, [reg1 + <const>] (for field offsets)
a61af66fc99e Initial load
duke
parents:
diff changeset
747 // <being_init offset> <bytes to copy> <bytes to skip>
a61af66fc99e Initial load
duke
parents:
diff changeset
748 // patch_stub: call Runtime1::patch_code (through a runtime stub)
a61af66fc99e Initial load
duke
parents:
diff changeset
749 // jmp patch_site
a61af66fc99e Initial load
duke
parents:
diff changeset
750 //
a61af66fc99e Initial load
duke
parents:
diff changeset
751 //
a61af66fc99e Initial load
duke
parents:
diff changeset
752 // A normal patch is done by rewriting the patch body, usually a move,
a61af66fc99e Initial load
duke
parents:
diff changeset
753 // and then copying it into place over top of the jmp instruction
a61af66fc99e Initial load
duke
parents:
diff changeset
754 // being careful to flush caches and doing it in an MP-safe way. The
a61af66fc99e Initial load
duke
parents:
diff changeset
755 // constants following the patch body are used to find various pieces
a61af66fc99e Initial load
duke
parents:
diff changeset
756 // of the patch relative to the call site for Runtime1::patch_code.
a61af66fc99e Initial load
duke
parents:
diff changeset
757 // The case for getstatic and putstatic is more complicated because
a61af66fc99e Initial load
duke
parents:
diff changeset
758 // getstatic and putstatic have special semantics when executing while
a61af66fc99e Initial load
duke
parents:
diff changeset
759 // the class is being initialized. getstatic/putstatic on a class
a61af66fc99e Initial load
duke
parents:
diff changeset
760 // which is being_initialized may be executed by the initializing
a61af66fc99e Initial load
duke
parents:
diff changeset
761 // thread but other threads have to block when they execute it. This
a61af66fc99e Initial load
duke
parents:
diff changeset
762 // is accomplished in compiled code by executing a test of the current
a61af66fc99e Initial load
duke
parents:
diff changeset
763 // thread against the initializing thread of the class. It's emitted
a61af66fc99e Initial load
duke
parents:
diff changeset
764 // as boilerplate in their stub which allows the patched code to be
a61af66fc99e Initial load
duke
parents:
diff changeset
765 // executed before it's copied back into the main body of the nmethod.
a61af66fc99e Initial load
duke
parents:
diff changeset
766 //
a61af66fc99e Initial load
duke
parents:
diff changeset
767 // being_init: get_thread(<tmp reg>
a61af66fc99e Initial load
duke
parents:
diff changeset
768 // cmpl [reg1 + <init_thread_offset>], <tmp reg>
a61af66fc99e Initial load
duke
parents:
diff changeset
769 // jne patch_stub
a61af66fc99e Initial load
duke
parents:
diff changeset
770 // movl [reg1 + <const>], reg (for field offsets) <or>
a61af66fc99e Initial load
duke
parents:
diff changeset
771 // movl reg, [reg1 + <const>] (for field offsets)
a61af66fc99e Initial load
duke
parents:
diff changeset
772 // jmp continue
a61af66fc99e Initial load
duke
parents:
diff changeset
773 // <being_init offset> <bytes to copy> <bytes to skip>
a61af66fc99e Initial load
duke
parents:
diff changeset
774 // patch_stub: jmp Runtim1::patch_code (through a runtime stub)
a61af66fc99e Initial load
duke
parents:
diff changeset
775 // jmp patch_site
a61af66fc99e Initial load
duke
parents:
diff changeset
776 //
a61af66fc99e Initial load
duke
parents:
diff changeset
777 // If the class is being initialized the patch body is rewritten and
a61af66fc99e Initial load
duke
parents:
diff changeset
778 // the patch site is rewritten to jump to being_init, instead of
a61af66fc99e Initial load
duke
parents:
diff changeset
779 // patch_stub. Whenever this code is executed it checks the current
a61af66fc99e Initial load
duke
parents:
diff changeset
780 // thread against the intializing thread so other threads will enter
a61af66fc99e Initial load
duke
parents:
diff changeset
781 // the runtime and end up blocked waiting the class to finish
a61af66fc99e Initial load
duke
parents:
diff changeset
782 // initializing inside the calls to resolve_field below. The
a61af66fc99e Initial load
duke
parents:
diff changeset
783 // initializing class will continue on it's way. Once the class is
a61af66fc99e Initial load
duke
parents:
diff changeset
784 // fully_initialized, the intializing_thread of the class becomes
a61af66fc99e Initial load
duke
parents:
diff changeset
785 // NULL, so the next thread to execute this code will fail the test,
a61af66fc99e Initial load
duke
parents:
diff changeset
786 // call into patch_code and complete the patching process by copying
a61af66fc99e Initial load
duke
parents:
diff changeset
787 // the patch body back into the main part of the nmethod and resume
a61af66fc99e Initial load
duke
parents:
diff changeset
788 // executing.
a61af66fc99e Initial load
duke
parents:
diff changeset
789 //
a61af66fc99e Initial load
duke
parents:
diff changeset
790 //
a61af66fc99e Initial load
duke
parents:
diff changeset
791
a61af66fc99e Initial load
duke
parents:
diff changeset
792 JRT_ENTRY(void, Runtime1::patch_code(JavaThread* thread, Runtime1::StubID stub_id ))
a61af66fc99e Initial load
duke
parents:
diff changeset
793 NOT_PRODUCT(_patch_code_slowcase_cnt++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
794
a61af66fc99e Initial load
duke
parents:
diff changeset
795 ResourceMark rm(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
796 RegisterMap reg_map(thread, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
797 frame runtime_frame = thread->last_frame();
a61af66fc99e Initial load
duke
parents:
diff changeset
798 frame caller_frame = runtime_frame.sender(&reg_map);
a61af66fc99e Initial load
duke
parents:
diff changeset
799
a61af66fc99e Initial load
duke
parents:
diff changeset
800 // last java frame on stack
a61af66fc99e Initial load
duke
parents:
diff changeset
801 vframeStream vfst(thread, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
802 assert(!vfst.at_end(), "Java frame must exist");
a61af66fc99e Initial load
duke
parents:
diff changeset
803
a61af66fc99e Initial load
duke
parents:
diff changeset
804 methodHandle caller_method(THREAD, vfst.method());
a61af66fc99e Initial load
duke
parents:
diff changeset
805 // Note that caller_method->code() may not be same as caller_code because of OSR's
a61af66fc99e Initial load
duke
parents:
diff changeset
806 // Note also that in the presence of inlining it is not guaranteed
a61af66fc99e Initial load
duke
parents:
diff changeset
807 // that caller_method() == caller_code->method()
a61af66fc99e Initial load
duke
parents:
diff changeset
808
a61af66fc99e Initial load
duke
parents:
diff changeset
809 int bci = vfst.bci();
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
810 Bytecodes::Code code = caller_method()->java_code_at(bci);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
811
a61af66fc99e Initial load
duke
parents:
diff changeset
812 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
813 // this is used by assertions in the access_field_patching_id
a61af66fc99e Initial load
duke
parents:
diff changeset
814 BasicType patch_field_type = T_ILLEGAL;
a61af66fc99e Initial load
duke
parents:
diff changeset
815 #endif // PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
816 bool deoptimize_for_volatile = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
817 int patch_field_offset = -1;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
818 KlassHandle init_klass(THREAD, NULL); // klass needed by load_klass_patching code
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
819 KlassHandle load_klass(THREAD, NULL); // klass needed by load_klass_patching code
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
820 Handle mirror(THREAD, NULL); // oop needed by load_mirror_patching code
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
821 bool load_klass_or_mirror_patch_id =
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
822 (stub_id == Runtime1::load_klass_patching_id || stub_id == Runtime1::load_mirror_patching_id);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
823
0
a61af66fc99e Initial load
duke
parents:
diff changeset
824 if (stub_id == Runtime1::access_field_patching_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
825
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
826 Bytecode_field field_access(caller_method, bci);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
827 FieldAccessInfo result; // initialize class if needed
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
828 Bytecodes::Code code = field_access.code();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
829 constantPoolHandle constants(THREAD, caller_method->constants());
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
830 LinkResolver::resolve_field(result, constants, field_access.index(), Bytecodes::java_code(code), false, CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
831 patch_field_offset = result.field_offset();
a61af66fc99e Initial load
duke
parents:
diff changeset
832
a61af66fc99e Initial load
duke
parents:
diff changeset
833 // If we're patching a field which is volatile then at compile it
a61af66fc99e Initial load
duke
parents:
diff changeset
834 // must not have been know to be volatile, so the generated code
a61af66fc99e Initial load
duke
parents:
diff changeset
835 // isn't correct for a volatile reference. The nmethod has to be
a61af66fc99e Initial load
duke
parents:
diff changeset
836 // deoptimized so that the code can be regenerated correctly.
a61af66fc99e Initial load
duke
parents:
diff changeset
837 // This check is only needed for access_field_patching since this
a61af66fc99e Initial load
duke
parents:
diff changeset
838 // is the path for patching field offsets. load_klass is only
a61af66fc99e Initial load
duke
parents:
diff changeset
839 // used for patching references to oops which don't need special
a61af66fc99e Initial load
duke
parents:
diff changeset
840 // handling in the volatile case.
a61af66fc99e Initial load
duke
parents:
diff changeset
841 deoptimize_for_volatile = result.access_flags().is_volatile();
a61af66fc99e Initial load
duke
parents:
diff changeset
842
a61af66fc99e Initial load
duke
parents:
diff changeset
843 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
844 patch_field_type = result.field_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
845 #endif
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
846 } else if (load_klass_or_mirror_patch_id) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
847 Klass* k = NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
848 switch (code) {
a61af66fc99e Initial load
duke
parents:
diff changeset
849 case Bytecodes::_putstatic:
a61af66fc99e Initial load
duke
parents:
diff changeset
850 case Bytecodes::_getstatic:
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
851 { Klass* klass = resolve_field_return_klass(caller_method, bci, CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
852 init_klass = KlassHandle(THREAD, klass);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
853 mirror = Handle(THREAD, klass->java_mirror());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
854 }
a61af66fc99e Initial load
duke
parents:
diff changeset
855 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
856 case Bytecodes::_new:
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
857 { Bytecode_new bnew(caller_method(), caller_method->bcp_from(bci));
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
858 k = caller_method->constants()->klass_at(bnew.index(), CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
859 }
a61af66fc99e Initial load
duke
parents:
diff changeset
860 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
861 case Bytecodes::_multianewarray:
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
862 { Bytecode_multianewarray mna(caller_method(), caller_method->bcp_from(bci));
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
863 k = caller_method->constants()->klass_at(mna.index(), CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
864 }
a61af66fc99e Initial load
duke
parents:
diff changeset
865 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
866 case Bytecodes::_instanceof:
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
867 { Bytecode_instanceof io(caller_method(), caller_method->bcp_from(bci));
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
868 k = caller_method->constants()->klass_at(io.index(), CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
869 }
a61af66fc99e Initial load
duke
parents:
diff changeset
870 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
871 case Bytecodes::_checkcast:
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
872 { Bytecode_checkcast cc(caller_method(), caller_method->bcp_from(bci));
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
873 k = caller_method->constants()->klass_at(cc.index(), CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
874 }
a61af66fc99e Initial load
duke
parents:
diff changeset
875 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
876 case Bytecodes::_anewarray:
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
877 { Bytecode_anewarray anew(caller_method(), caller_method->bcp_from(bci));
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
878 Klass* ek = caller_method->constants()->klass_at(anew.index(), CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
879 k = Klass::cast(ek)->array_klass(CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
880 }
a61af66fc99e Initial load
duke
parents:
diff changeset
881 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
882 case Bytecodes::_ldc:
a61af66fc99e Initial load
duke
parents:
diff changeset
883 case Bytecodes::_ldc_w:
a61af66fc99e Initial load
duke
parents:
diff changeset
884 {
2142
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 2002
diff changeset
885 Bytecode_loadconstant cc(caller_method, bci);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
886 oop m = cc.resolve_constant(CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
887 mirror = Handle(THREAD, m);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
888 }
a61af66fc99e Initial load
duke
parents:
diff changeset
889 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
890 default: Unimplemented();
a61af66fc99e Initial load
duke
parents:
diff changeset
891 }
a61af66fc99e Initial load
duke
parents:
diff changeset
892 // convert to handle
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
893 load_klass = KlassHandle(THREAD, k);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
894 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
895 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
896 }
a61af66fc99e Initial load
duke
parents:
diff changeset
897
a61af66fc99e Initial load
duke
parents:
diff changeset
898 if (deoptimize_for_volatile) {
a61af66fc99e Initial load
duke
parents:
diff changeset
899 // At compile time we assumed the field wasn't volatile but after
a61af66fc99e Initial load
duke
parents:
diff changeset
900 // loading it turns out it was volatile so we have to throw the
a61af66fc99e Initial load
duke
parents:
diff changeset
901 // compiled code out and let it be regenerated.
a61af66fc99e Initial load
duke
parents:
diff changeset
902 if (TracePatching) {
a61af66fc99e Initial load
duke
parents:
diff changeset
903 tty->print_cr("Deoptimizing for patching volatile field reference");
a61af66fc99e Initial load
duke
parents:
diff changeset
904 }
485
ac8fe14c93e4 6767587: missing call to make_not_entrant after deoptimizing for patching volatiles
never
parents: 362
diff changeset
905 // It's possible the nmethod was invalidated in the last
ac8fe14c93e4 6767587: missing call to make_not_entrant after deoptimizing for patching volatiles
never
parents: 362
diff changeset
906 // safepoint, but if it's still alive then make it not_entrant.
ac8fe14c93e4 6767587: missing call to make_not_entrant after deoptimizing for patching volatiles
never
parents: 362
diff changeset
907 nmethod* nm = CodeCache::find_nmethod(caller_frame.pc());
ac8fe14c93e4 6767587: missing call to make_not_entrant after deoptimizing for patching volatiles
never
parents: 362
diff changeset
908 if (nm != NULL) {
ac8fe14c93e4 6767587: missing call to make_not_entrant after deoptimizing for patching volatiles
never
parents: 362
diff changeset
909 nm->make_not_entrant();
ac8fe14c93e4 6767587: missing call to make_not_entrant after deoptimizing for patching volatiles
never
parents: 362
diff changeset
910 }
ac8fe14c93e4 6767587: missing call to make_not_entrant after deoptimizing for patching volatiles
never
parents: 362
diff changeset
911
1905
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents: 1783
diff changeset
912 Deoptimization::deoptimize_frame(thread, caller_frame.id());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
913
a61af66fc99e Initial load
duke
parents:
diff changeset
914 // Return to the now deoptimized frame.
a61af66fc99e Initial load
duke
parents:
diff changeset
915 }
a61af66fc99e Initial load
duke
parents:
diff changeset
916
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1584
diff changeset
917 // If we are patching in a non-perm oop, make sure the nmethod
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1584
diff changeset
918 // is on the right list.
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
919 if (ScavengeRootsInCode && mirror.not_null() && mirror()->is_scavengable()) {
1602
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1584
diff changeset
920 MutexLockerEx ml_code (CodeCache_lock, Mutex::_no_safepoint_check_flag);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1584
diff changeset
921 nmethod* nm = CodeCache::find_nmethod(caller_frame.pc());
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1584
diff changeset
922 guarantee(nm != NULL, "only nmethods can contain non-perm oops");
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1584
diff changeset
923 if (!nm->on_scavenge_root_list())
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1584
diff changeset
924 CodeCache::add_scavenge_root_nmethod(nm);
136b78722a08 6939203: JSR 292 needs method handle constants
jrose
parents: 1584
diff changeset
925 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
926
a61af66fc99e Initial load
duke
parents:
diff changeset
927 // Now copy code back
a61af66fc99e Initial load
duke
parents:
diff changeset
928
a61af66fc99e Initial load
duke
parents:
diff changeset
929 {
a61af66fc99e Initial load
duke
parents:
diff changeset
930 MutexLockerEx ml_patch (Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
931 //
a61af66fc99e Initial load
duke
parents:
diff changeset
932 // Deoptimization may have happened while we waited for the lock.
a61af66fc99e Initial load
duke
parents:
diff changeset
933 // In that case we don't bother to do any patching we just return
a61af66fc99e Initial load
duke
parents:
diff changeset
934 // and let the deopt happen
a61af66fc99e Initial load
duke
parents:
diff changeset
935 if (!caller_is_deopted()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
936 NativeGeneralJump* jump = nativeGeneralJump_at(caller_frame.pc());
a61af66fc99e Initial load
duke
parents:
diff changeset
937 address instr_pc = jump->jump_destination();
a61af66fc99e Initial load
duke
parents:
diff changeset
938 NativeInstruction* ni = nativeInstruction_at(instr_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
939 if (ni->is_jump() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
940 // the jump has not been patched yet
a61af66fc99e Initial load
duke
parents:
diff changeset
941 // The jump destination is slow case and therefore not part of the stubs
a61af66fc99e Initial load
duke
parents:
diff changeset
942 // (stubs are only for StaticCalls)
a61af66fc99e Initial load
duke
parents:
diff changeset
943
a61af66fc99e Initial load
duke
parents:
diff changeset
944 // format of buffer
a61af66fc99e Initial load
duke
parents:
diff changeset
945 // ....
a61af66fc99e Initial load
duke
parents:
diff changeset
946 // instr byte 0 <-- copy_buff
a61af66fc99e Initial load
duke
parents:
diff changeset
947 // instr byte 1
a61af66fc99e Initial load
duke
parents:
diff changeset
948 // ..
a61af66fc99e Initial load
duke
parents:
diff changeset
949 // instr byte n-1
a61af66fc99e Initial load
duke
parents:
diff changeset
950 // n
a61af66fc99e Initial load
duke
parents:
diff changeset
951 // .... <-- call destination
a61af66fc99e Initial load
duke
parents:
diff changeset
952
a61af66fc99e Initial load
duke
parents:
diff changeset
953 address stub_location = caller_frame.pc() + PatchingStub::patch_info_offset();
a61af66fc99e Initial load
duke
parents:
diff changeset
954 unsigned char* byte_count = (unsigned char*) (stub_location - 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
955 unsigned char* byte_skip = (unsigned char*) (stub_location - 2);
a61af66fc99e Initial load
duke
parents:
diff changeset
956 unsigned char* being_initialized_entry_offset = (unsigned char*) (stub_location - 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
957 address copy_buff = stub_location - *byte_skip - *byte_count;
a61af66fc99e Initial load
duke
parents:
diff changeset
958 address being_initialized_entry = stub_location - *being_initialized_entry_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
959 if (TracePatching) {
a61af66fc99e Initial load
duke
parents:
diff changeset
960 tty->print_cr(" Patching %s at bci %d at address 0x%x (%s)", Bytecodes::name(code), bci,
a61af66fc99e Initial load
duke
parents:
diff changeset
961 instr_pc, (stub_id == Runtime1::access_field_patching_id) ? "field" : "klass");
a61af66fc99e Initial load
duke
parents:
diff changeset
962 nmethod* caller_code = CodeCache::find_nmethod(caller_frame.pc());
a61af66fc99e Initial load
duke
parents:
diff changeset
963 assert(caller_code != NULL, "nmethod not found");
a61af66fc99e Initial load
duke
parents:
diff changeset
964
a61af66fc99e Initial load
duke
parents:
diff changeset
965 // NOTE we use pc() not original_pc() because we already know they are
a61af66fc99e Initial load
duke
parents:
diff changeset
966 // identical otherwise we'd have never entered this block of code
a61af66fc99e Initial load
duke
parents:
diff changeset
967
a61af66fc99e Initial load
duke
parents:
diff changeset
968 OopMap* map = caller_code->oop_map_for_return_address(caller_frame.pc());
a61af66fc99e Initial load
duke
parents:
diff changeset
969 assert(map != NULL, "null check");
a61af66fc99e Initial load
duke
parents:
diff changeset
970 map->print();
a61af66fc99e Initial load
duke
parents:
diff changeset
971 tty->cr();
a61af66fc99e Initial load
duke
parents:
diff changeset
972
a61af66fc99e Initial load
duke
parents:
diff changeset
973 Disassembler::decode(copy_buff, copy_buff + *byte_count, tty);
a61af66fc99e Initial load
duke
parents:
diff changeset
974 }
a61af66fc99e Initial load
duke
parents:
diff changeset
975 // depending on the code below, do_patch says whether to copy the patch body back into the nmethod
a61af66fc99e Initial load
duke
parents:
diff changeset
976 bool do_patch = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
977 if (stub_id == Runtime1::access_field_patching_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
978 // The offset may not be correct if the class was not loaded at code generation time.
a61af66fc99e Initial load
duke
parents:
diff changeset
979 // Set it now.
a61af66fc99e Initial load
duke
parents:
diff changeset
980 NativeMovRegMem* n_move = nativeMovRegMem_at(copy_buff);
a61af66fc99e Initial load
duke
parents:
diff changeset
981 assert(n_move->offset() == 0 || (n_move->offset() == 4 && (patch_field_type == T_DOUBLE || patch_field_type == T_LONG)), "illegal offset for type");
a61af66fc99e Initial load
duke
parents:
diff changeset
982 assert(patch_field_offset >= 0, "illegal offset");
a61af66fc99e Initial load
duke
parents:
diff changeset
983 n_move->add_offset_in_bytes(patch_field_offset);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
984 } else if (load_klass_or_mirror_patch_id) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
985 // If a getstatic or putstatic is referencing a klass which
a61af66fc99e Initial load
duke
parents:
diff changeset
986 // isn't fully initialized, the patch body isn't copied into
a61af66fc99e Initial load
duke
parents:
diff changeset
987 // place until initialization is complete. In this case the
a61af66fc99e Initial load
duke
parents:
diff changeset
988 // patch site is setup so that any threads besides the
a61af66fc99e Initial load
duke
parents:
diff changeset
989 // initializing thread are forced to come into the VM and
a61af66fc99e Initial load
duke
parents:
diff changeset
990 // block.
a61af66fc99e Initial load
duke
parents:
diff changeset
991 do_patch = (code != Bytecodes::_getstatic && code != Bytecodes::_putstatic) ||
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
992 InstanceKlass::cast(init_klass())->is_initialized();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
993 NativeGeneralJump* jump = nativeGeneralJump_at(instr_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
994 if (jump->jump_destination() == being_initialized_entry) {
a61af66fc99e Initial load
duke
parents:
diff changeset
995 assert(do_patch == true, "initialization must be complete at this point");
a61af66fc99e Initial load
duke
parents:
diff changeset
996 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
997 // patch the instruction <move reg, klass>
a61af66fc99e Initial load
duke
parents:
diff changeset
998 NativeMovConstReg* n_copy = nativeMovConstReg_at(copy_buff);
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
999
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1000 assert(n_copy->data() == 0 ||
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1748
diff changeset
1001 n_copy->data() == (intptr_t)Universe::non_oop_word(),
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1002 "illegal init value");
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1003 if (stub_id == Runtime1::load_klass_patching_id) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1004 assert(load_klass() != NULL, "klass not set");
a61af66fc99e Initial load
duke
parents:
diff changeset
1005 n_copy->set_data((intx) (load_klass()));
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1006 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1007 assert(mirror() != NULL, "klass not set");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1008 n_copy->set_data((intx) (mirror()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1009 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1010
a61af66fc99e Initial load
duke
parents:
diff changeset
1011 if (TracePatching) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1012 Disassembler::decode(copy_buff, copy_buff + *byte_count, tty);
a61af66fc99e Initial load
duke
parents:
diff changeset
1013 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1014
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1015 #if defined(SPARC) || defined(PPC)
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1016 // Update the location in the nmethod with the proper
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1017 // metadata. When the code was generated, a NULL was stuffed
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1018 // in the metadata table and that table needs to be update to
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1019 // have the right value. On intel the value is kept
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1020 // directly in the instruction instead of in the metadata
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1021 // table, so set_data above effectively updated the value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1022 nmethod* nm = CodeCache::find_nmethod(instr_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
1023 assert(nm != NULL, "invalid nmethod_pc");
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1024 RelocIterator mds(nm, copy_buff, copy_buff + 1);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1025 bool found = false;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1026 while (mds.next() && !found) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1027 if (mds.type() == relocInfo::oop_type) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1028 assert(stub_id == Runtime1::load_mirror_patching_id, "wrong stub id");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1029 oop_Relocation* r = mds.oop_reloc();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1030 oop* oop_adr = r->oop_addr();
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1031 *oop_adr = mirror();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1032 r->fix_oop_relocation();
a61af66fc99e Initial load
duke
parents:
diff changeset
1033 found = true;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1034 } else if (mds.type() == relocInfo::metadata_type) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1035 assert(stub_id == Runtime1::load_klass_patching_id, "wrong stub id");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1036 metadata_Relocation* r = mds.metadata_reloc();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1037 Metadata** metadata_adr = r->metadata_addr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1038 *metadata_adr = load_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1039 r->fix_metadata_relocation();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1040 found = true;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1041 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1042 }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1043 assert(found, "the metadata must exist!");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1044 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1045
a61af66fc99e Initial load
duke
parents:
diff changeset
1046 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1047 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1048 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
1049 }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1050
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1051 if (do_patch) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1052 // replace instructions
a61af66fc99e Initial load
duke
parents:
diff changeset
1053 // first replace the tail, then the call
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1054 #ifdef ARM
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1055 if(load_klass_or_mirror_patch_id && !VM_Version::supports_movw()) {
3269
7ec4bb02d5f0 7035861: linux-armsflt: assert(ni->data() == (int)(x + o)) failed: instructions must match
vladidan
parents: 2446
diff changeset
1056 nmethod* nm = CodeCache::find_nmethod(instr_pc);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1057 address addr = NULL;
3269
7ec4bb02d5f0 7035861: linux-armsflt: assert(ni->data() == (int)(x + o)) failed: instructions must match
vladidan
parents: 2446
diff changeset
1058 assert(nm != NULL, "invalid nmethod_pc");
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1059 RelocIterator mds(nm, copy_buff, copy_buff + 1);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1060 while (mds.next()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1061 if (mds.type() == relocInfo::oop_type) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1062 assert(stub_id == Runtime1::load_mirror_patching_id, "wrong stub id");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1063 oop_Relocation* r = mds.oop_reloc();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1064 addr = (address)r->oop_addr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1065 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1066 } else if (mds.type() == relocInfo::metadata_type) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1067 assert(stub_id == Runtime1::load_klass_patching_id, "wrong stub id");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1068 metadata_Relocation* r = mds.metadata_reloc();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1069 addr = (address)r->metadata_addr();
3269
7ec4bb02d5f0 7035861: linux-armsflt: assert(ni->data() == (int)(x + o)) failed: instructions must match
vladidan
parents: 2446
diff changeset
1070 break;
7ec4bb02d5f0 7035861: linux-armsflt: assert(ni->data() == (int)(x + o)) failed: instructions must match
vladidan
parents: 2446
diff changeset
1071 }
7ec4bb02d5f0 7035861: linux-armsflt: assert(ni->data() == (int)(x + o)) failed: instructions must match
vladidan
parents: 2446
diff changeset
1072 }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1073 assert(addr != NULL, "metadata relocation must exist");
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1074 copy_buff -= *byte_count;
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1075 NativeMovConstReg* n_copy2 = nativeMovConstReg_at(copy_buff);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1076 n_copy2->set_pc_relative_offset(addr, instr_pc);
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1077 }
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1078 #endif
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1079
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1080 for (int i = NativeCall::instruction_size; i < *byte_count; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1081 address ptr = copy_buff + i;
a61af66fc99e Initial load
duke
parents:
diff changeset
1082 int a_byte = (*ptr) & 0xFF;
a61af66fc99e Initial load
duke
parents:
diff changeset
1083 address dst = instr_pc + i;
a61af66fc99e Initial load
duke
parents:
diff changeset
1084 *(unsigned char*)dst = (unsigned char) a_byte;
a61af66fc99e Initial load
duke
parents:
diff changeset
1085 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1086 ICache::invalidate_range(instr_pc, *byte_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1087 NativeGeneralJump::replace_mt_safe(instr_pc, copy_buff);
a61af66fc99e Initial load
duke
parents:
diff changeset
1088
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1089 if (load_klass_or_mirror_patch_id) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1090 relocInfo::relocType rtype =
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1091 (stub_id == Runtime1::load_klass_patching_id) ?
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1092 relocInfo::metadata_type :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1093 relocInfo::oop_type;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1094 // update relocInfo to metadata
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1095 nmethod* nm = CodeCache::find_nmethod(instr_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
1096 assert(nm != NULL, "invalid nmethod_pc");
a61af66fc99e Initial load
duke
parents:
diff changeset
1097
a61af66fc99e Initial load
duke
parents:
diff changeset
1098 // The old patch site is now a move instruction so update
a61af66fc99e Initial load
duke
parents:
diff changeset
1099 // the reloc info so that it will get updated during
a61af66fc99e Initial load
duke
parents:
diff changeset
1100 // future GCs.
a61af66fc99e Initial load
duke
parents:
diff changeset
1101 RelocIterator iter(nm, (address)instr_pc, (address)(instr_pc + 1));
a61af66fc99e Initial load
duke
parents:
diff changeset
1102 relocInfo::change_reloc_info_for_address(&iter, (address) instr_pc,
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1103 relocInfo::none, rtype);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1104 #ifdef SPARC
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1105 // Sparc takes two relocations for an metadata so update the second one.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1106 address instr_pc2 = instr_pc + NativeMovConstReg::add_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
1107 RelocIterator iter2(nm, instr_pc2, instr_pc2 + 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1108 relocInfo::change_reloc_info_for_address(&iter2, (address) instr_pc2,
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1109 relocInfo::none, rtype);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1110 #endif
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1111 #ifdef PPC
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1112 { address instr_pc2 = instr_pc + NativeMovConstReg::lo_offset;
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1113 RelocIterator iter2(nm, instr_pc2, instr_pc2 + 1);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1114 relocInfo::change_reloc_info_for_address(&iter2, (address) instr_pc2,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1115 relocInfo::none, rtype);
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1116 }
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1603
diff changeset
1117 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1118 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1119
a61af66fc99e Initial load
duke
parents:
diff changeset
1120 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1121 ICache::invalidate_range(copy_buff, *byte_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1122 NativeGeneralJump::insert_unconditional(instr_pc, being_initialized_entry);
a61af66fc99e Initial load
duke
parents:
diff changeset
1123 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1124 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1125 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1126 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1127 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1128
a61af66fc99e Initial load
duke
parents:
diff changeset
1129 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1130 // Entry point for compiled code. We want to patch a nmethod.
a61af66fc99e Initial load
duke
parents:
diff changeset
1131 // We don't do a normal VM transition here because we want to
a61af66fc99e Initial load
duke
parents:
diff changeset
1132 // know after the patching is complete and any safepoint(s) are taken
a61af66fc99e Initial load
duke
parents:
diff changeset
1133 // if the calling nmethod was deoptimized. We do this by calling a
a61af66fc99e Initial load
duke
parents:
diff changeset
1134 // helper method which does the normal VM transition and when it
a61af66fc99e Initial load
duke
parents:
diff changeset
1135 // completes we can check for deoptimization. This simplifies the
a61af66fc99e Initial load
duke
parents:
diff changeset
1136 // assembly code in the cpu directories.
a61af66fc99e Initial load
duke
parents:
diff changeset
1137 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1138 int Runtime1::move_klass_patching(JavaThread* thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1139 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1140 // NOTE: we are still in Java
a61af66fc99e Initial load
duke
parents:
diff changeset
1141 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1142 Thread* THREAD = thread;
a61af66fc99e Initial load
duke
parents:
diff changeset
1143 debug_only(NoHandleMark nhm;)
a61af66fc99e Initial load
duke
parents:
diff changeset
1144 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1145 // Enter VM mode
a61af66fc99e Initial load
duke
parents:
diff changeset
1146
a61af66fc99e Initial load
duke
parents:
diff changeset
1147 ResetNoHandleMark rnhm;
a61af66fc99e Initial load
duke
parents:
diff changeset
1148 patch_code(thread, load_klass_patching_id);
a61af66fc99e Initial load
duke
parents:
diff changeset
1149 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1150 // Back in JAVA, use no oops DON'T safepoint
a61af66fc99e Initial load
duke
parents:
diff changeset
1151
a61af66fc99e Initial load
duke
parents:
diff changeset
1152 // Return true if calling code is deoptimized
a61af66fc99e Initial load
duke
parents:
diff changeset
1153
a61af66fc99e Initial load
duke
parents:
diff changeset
1154 return caller_is_deopted();
a61af66fc99e Initial load
duke
parents:
diff changeset
1155 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1156
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1157 int Runtime1::move_mirror_patching(JavaThread* thread) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1158 //
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1159 // NOTE: we are still in Java
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1160 //
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1161 Thread* THREAD = thread;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1162 debug_only(NoHandleMark nhm;)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1163 {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1164 // Enter VM mode
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1165
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1166 ResetNoHandleMark rnhm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1167 patch_code(thread, load_mirror_patching_id);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1168 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1169 // Back in JAVA, use no oops DON'T safepoint
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1170
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1171 // Return true if calling code is deoptimized
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1172
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1173 return caller_is_deopted();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1174 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1175
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1176 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1177 // Entry point for compiled code. We want to patch a nmethod.
a61af66fc99e Initial load
duke
parents:
diff changeset
1178 // We don't do a normal VM transition here because we want to
a61af66fc99e Initial load
duke
parents:
diff changeset
1179 // know after the patching is complete and any safepoint(s) are taken
a61af66fc99e Initial load
duke
parents:
diff changeset
1180 // if the calling nmethod was deoptimized. We do this by calling a
a61af66fc99e Initial load
duke
parents:
diff changeset
1181 // helper method which does the normal VM transition and when it
a61af66fc99e Initial load
duke
parents:
diff changeset
1182 // completes we can check for deoptimization. This simplifies the
a61af66fc99e Initial load
duke
parents:
diff changeset
1183 // assembly code in the cpu directories.
a61af66fc99e Initial load
duke
parents:
diff changeset
1184 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1185
a61af66fc99e Initial load
duke
parents:
diff changeset
1186 int Runtime1::access_field_patching(JavaThread* thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1187 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1188 // NOTE: we are still in Java
a61af66fc99e Initial load
duke
parents:
diff changeset
1189 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1190 Thread* THREAD = thread;
a61af66fc99e Initial load
duke
parents:
diff changeset
1191 debug_only(NoHandleMark nhm;)
a61af66fc99e Initial load
duke
parents:
diff changeset
1192 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1193 // Enter VM mode
a61af66fc99e Initial load
duke
parents:
diff changeset
1194
a61af66fc99e Initial load
duke
parents:
diff changeset
1195 ResetNoHandleMark rnhm;
a61af66fc99e Initial load
duke
parents:
diff changeset
1196 patch_code(thread, access_field_patching_id);
a61af66fc99e Initial load
duke
parents:
diff changeset
1197 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1198 // Back in JAVA, use no oops DON'T safepoint
a61af66fc99e Initial load
duke
parents:
diff changeset
1199
a61af66fc99e Initial load
duke
parents:
diff changeset
1200 // Return true if calling code is deoptimized
a61af66fc99e Initial load
duke
parents:
diff changeset
1201
a61af66fc99e Initial load
duke
parents:
diff changeset
1202 return caller_is_deopted();
a61af66fc99e Initial load
duke
parents:
diff changeset
1203 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1204
a61af66fc99e Initial load
duke
parents:
diff changeset
1205
a61af66fc99e Initial load
duke
parents:
diff changeset
1206 JRT_LEAF(void, Runtime1::trace_block_entry(jint block_id))
a61af66fc99e Initial load
duke
parents:
diff changeset
1207 // for now we just print out the block id
a61af66fc99e Initial load
duke
parents:
diff changeset
1208 tty->print("%d ", block_id);
a61af66fc99e Initial load
duke
parents:
diff changeset
1209 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1210
a61af66fc99e Initial load
duke
parents:
diff changeset
1211
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1212 // Array copy return codes.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1213 enum {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1214 ac_failed = -1, // arraycopy failed
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1215 ac_ok = 0 // arraycopy succeeded
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1216 };
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1217
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1218
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1219 // Below length is the # elements copied.
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1220 template <class T> int obj_arraycopy_work(oopDesc* src, T* src_addr,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1221 oopDesc* dst, T* dst_addr,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1222 int length) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1223
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1224 // For performance reasons, we assume we are using a card marking write
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1225 // barrier. The assert will fail if this is not the case.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1226 // Note that we use the non-virtual inlineable variant of write_ref_array.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1227 BarrierSet* bs = Universe::heap()->barrier_set();
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1228 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt");
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1229 assert(bs->has_write_ref_array_pre_opt(), "For pre-barrier as well.");
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1230 if (src == dst) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1231 // same object, no check
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1232 bs->write_ref_array_pre(dst_addr, length);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1233 Copy::conjoint_oops_atomic(src_addr, dst_addr, length);
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1234 bs->write_ref_array((HeapWord*)dst_addr, length);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1235 return ac_ok;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1236 } else {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1237 Klass* bound = objArrayKlass::cast(dst->klass())->element_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1238 Klass* stype = objArrayKlass::cast(src->klass())->element_klass();
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1239 if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1240 // Elements are guaranteed to be subtypes, so no check necessary
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1241 bs->write_ref_array_pre(dst_addr, length);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1242 Copy::conjoint_oops_atomic(src_addr, dst_addr, length);
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1243 bs->write_ref_array((HeapWord*)dst_addr, length);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1244 return ac_ok;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1245 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1246 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1247 return ac_failed;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1248 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1249
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1250 // fast and direct copy of arrays; returning -1, means that an exception may be thrown
a61af66fc99e Initial load
duke
parents:
diff changeset
1251 // and we did not copy anything
a61af66fc99e Initial load
duke
parents:
diff changeset
1252 JRT_LEAF(int, Runtime1::arraycopy(oopDesc* src, int src_pos, oopDesc* dst, int dst_pos, int length))
a61af66fc99e Initial load
duke
parents:
diff changeset
1253 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1254 _generic_arraycopy_cnt++; // Slow-path oop array copy
a61af66fc99e Initial load
duke
parents:
diff changeset
1255 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1256
a61af66fc99e Initial load
duke
parents:
diff changeset
1257 if (src == NULL || dst == NULL || src_pos < 0 || dst_pos < 0 || length < 0) return ac_failed;
a61af66fc99e Initial load
duke
parents:
diff changeset
1258 if (!dst->is_array() || !src->is_array()) return ac_failed;
a61af66fc99e Initial load
duke
parents:
diff changeset
1259 if ((unsigned int) arrayOop(src)->length() < (unsigned int)src_pos + (unsigned int)length) return ac_failed;
a61af66fc99e Initial load
duke
parents:
diff changeset
1260 if ((unsigned int) arrayOop(dst)->length() < (unsigned int)dst_pos + (unsigned int)length) return ac_failed;
a61af66fc99e Initial load
duke
parents:
diff changeset
1261
a61af66fc99e Initial load
duke
parents:
diff changeset
1262 if (length == 0) return ac_ok;
a61af66fc99e Initial load
duke
parents:
diff changeset
1263 if (src->is_typeArray()) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1264 Klass* const klass_oop = src->klass();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1265 if (klass_oop != dst->klass()) return ac_failed;
a61af66fc99e Initial load
duke
parents:
diff changeset
1266 typeArrayKlass* klass = typeArrayKlass::cast(klass_oop);
a61af66fc99e Initial load
duke
parents:
diff changeset
1267 const int l2es = klass->log2_element_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
1268 const int ihs = klass->array_header_in_bytes() / wordSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
1269 char* src_addr = (char*) ((oopDesc**)src + ihs) + (src_pos << l2es);
a61af66fc99e Initial load
duke
parents:
diff changeset
1270 char* dst_addr = (char*) ((oopDesc**)dst + ihs) + (dst_pos << l2es);
a61af66fc99e Initial load
duke
parents:
diff changeset
1271 // Potential problem: memmove is not guaranteed to be word atomic
a61af66fc99e Initial load
duke
parents:
diff changeset
1272 // Revisit in Merlin
a61af66fc99e Initial load
duke
parents:
diff changeset
1273 memmove(dst_addr, src_addr, length << l2es);
a61af66fc99e Initial load
duke
parents:
diff changeset
1274 return ac_ok;
a61af66fc99e Initial load
duke
parents:
diff changeset
1275 } else if (src->is_objArray() && dst->is_objArray()) {
2002
ac637b7220d1 6985015: C1 needs to support compressed oops
iveresov
parents: 1972
diff changeset
1276 if (UseCompressedOops) {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1277 narrowOop *src_addr = objArrayOop(src)->obj_at_addr<narrowOop>(src_pos);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1278 narrowOop *dst_addr = objArrayOop(dst)->obj_at_addr<narrowOop>(dst_pos);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1279 return obj_arraycopy_work(src, src_addr, dst, dst_addr, length);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1280 } else {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1281 oop *src_addr = objArrayOop(src)->obj_at_addr<oop>(src_pos);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1282 oop *dst_addr = objArrayOop(dst)->obj_at_addr<oop>(dst_pos);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1283 return obj_arraycopy_work(src, src_addr, dst, dst_addr, length);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1284 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1285 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1286 return ac_failed;
a61af66fc99e Initial load
duke
parents:
diff changeset
1287 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1288
a61af66fc99e Initial load
duke
parents:
diff changeset
1289
a61af66fc99e Initial load
duke
parents:
diff changeset
1290 JRT_LEAF(void, Runtime1::primitive_arraycopy(HeapWord* src, HeapWord* dst, int length))
a61af66fc99e Initial load
duke
parents:
diff changeset
1291 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1292 _primitive_arraycopy_cnt++;
a61af66fc99e Initial load
duke
parents:
diff changeset
1293 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1294
a61af66fc99e Initial load
duke
parents:
diff changeset
1295 if (length == 0) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
1296 // Not guaranteed to be word atomic, but that doesn't matter
a61af66fc99e Initial load
duke
parents:
diff changeset
1297 // for anything but an oop array, which is covered by oop_arraycopy.
1603
d93949c5bdcc 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 1602
diff changeset
1298 Copy::conjoint_jbytes(src, dst, length);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1299 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1300
a61af66fc99e Initial load
duke
parents:
diff changeset
1301 JRT_LEAF(void, Runtime1::oop_arraycopy(HeapWord* src, HeapWord* dst, int num))
a61af66fc99e Initial load
duke
parents:
diff changeset
1302 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1303 _oop_arraycopy_cnt++;
a61af66fc99e Initial load
duke
parents:
diff changeset
1304 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1305
a61af66fc99e Initial load
duke
parents:
diff changeset
1306 if (num == 0) return;
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1307 BarrierSet* bs = Universe::heap()->barrier_set();
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1308 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt");
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1309 assert(bs->has_write_ref_array_pre_opt(), "For pre-barrier as well.");
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1310 if (UseCompressedOops) {
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1311 bs->write_ref_array_pre((narrowOop*)dst, num);
2002
ac637b7220d1 6985015: C1 needs to support compressed oops
iveresov
parents: 1972
diff changeset
1312 Copy::conjoint_oops_atomic((narrowOop*) src, (narrowOop*) dst, num);
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1313 } else {
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1314 bs->write_ref_array_pre((oop*)dst, num);
2002
ac637b7220d1 6985015: C1 needs to support compressed oops
iveresov
parents: 1972
diff changeset
1315 Copy::conjoint_oops_atomic((oop*) src, (oop*) dst, num);
1245
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1316 }
6484c4ee11cb 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 1142
diff changeset
1317 bs->write_ref_array(dst, num);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1318 JRT_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1319
a61af66fc99e Initial load
duke
parents:
diff changeset
1320
6135
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1321 JRT_LEAF(int, Runtime1::is_instance_of(oopDesc* mirror, oopDesc* obj))
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1322 // had to return int instead of bool, otherwise there may be a mismatch
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1323 // between the C calling convention and the Java one.
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1324 // e.g., on x86, GCC may clear only %al when returning a bool false, but
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1325 // JVM takes the whole %eax as the return value, which may misinterpret
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1326 // the return value as a boolean true.
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1327
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1328 assert(mirror != NULL, "should null-check on mirror before calling");
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6135
diff changeset
1329 Klass* k = java_lang_Class::as_Klass(mirror);
6135
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1330 return (k != NULL && obj != NULL && obj->is_a(k)) ? 1 : 0;
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1331 JRT_END
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1332
8f37087fc13f 7171890: C1: add Class.isInstance intrinsic
roland
parents: 6006
diff changeset
1333
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1334 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1335 void Runtime1::print_statistics() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1336 tty->print_cr("C1 Runtime statistics:");
a61af66fc99e Initial load
duke
parents:
diff changeset
1337 tty->print_cr(" _resolve_invoke_virtual_cnt: %d", SharedRuntime::_resolve_virtual_ctr);
a61af66fc99e Initial load
duke
parents:
diff changeset
1338 tty->print_cr(" _resolve_invoke_opt_virtual_cnt: %d", SharedRuntime::_resolve_opt_virtual_ctr);
a61af66fc99e Initial load
duke
parents:
diff changeset
1339 tty->print_cr(" _resolve_invoke_static_cnt: %d", SharedRuntime::_resolve_static_ctr);
a61af66fc99e Initial load
duke
parents:
diff changeset
1340 tty->print_cr(" _handle_wrong_method_cnt: %d", SharedRuntime::_wrong_method_ctr);
a61af66fc99e Initial load
duke
parents:
diff changeset
1341 tty->print_cr(" _ic_miss_cnt: %d", SharedRuntime::_ic_miss_ctr);
a61af66fc99e Initial load
duke
parents:
diff changeset
1342 tty->print_cr(" _generic_arraycopy_cnt: %d", _generic_arraycopy_cnt);
2446
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1343 tty->print_cr(" _generic_arraycopystub_cnt: %d", _generic_arraycopystub_cnt);
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1344 tty->print_cr(" _byte_arraycopy_cnt: %d", _byte_arraycopy_cnt);
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1345 tty->print_cr(" _short_arraycopy_cnt: %d", _short_arraycopy_cnt);
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1346 tty->print_cr(" _int_arraycopy_cnt: %d", _int_arraycopy_cnt);
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1347 tty->print_cr(" _long_arraycopy_cnt: %d", _long_arraycopy_cnt);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1348 tty->print_cr(" _primitive_arraycopy_cnt: %d", _primitive_arraycopy_cnt);
2446
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1349 tty->print_cr(" _oop_arraycopy_cnt (C): %d", Runtime1::_oop_arraycopy_cnt);
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1350 tty->print_cr(" _oop_arraycopy_cnt (stub): %d", _oop_arraycopy_cnt);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1351 tty->print_cr(" _arraycopy_slowcase_cnt: %d", _arraycopy_slowcase_cnt);
2446
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1352 tty->print_cr(" _arraycopy_checkcast_cnt: %d", _arraycopy_checkcast_cnt);
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2376
diff changeset
1353 tty->print_cr(" _arraycopy_checkcast_attempt_cnt:%d", _arraycopy_checkcast_attempt_cnt);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1354
a61af66fc99e Initial load
duke
parents:
diff changeset
1355 tty->print_cr(" _new_type_array_slowcase_cnt: %d", _new_type_array_slowcase_cnt);
a61af66fc99e Initial load
duke
parents:
diff changeset
1356 tty->print_cr(" _new_object_array_slowcase_cnt: %d", _new_object_array_slowcase_cnt);
a61af66fc99e Initial load
duke
parents:
diff changeset
1357 tty->print_cr(" _new_instance_slowcase_cnt: %d", _new_instance_slowcase_cnt);
a61af66fc99e Initial load
duke
parents:
diff changeset
1358 tty->print_cr(" _new_multi_array_slowcase_cnt: %d", _new_multi_array_slowcase_cnt);
a61af66fc99e Initial load
duke
parents:
diff changeset
1359 tty->print_cr(" _monitorenter_slowcase_cnt: %d", _monitorenter_slowcase_cnt);
a61af66fc99e Initial load
duke
parents:
diff changeset
1360 tty->print_cr(" _monitorexit_slowcase_cnt: %d", _monitorexit_slowcase_cnt);
a61af66fc99e Initial load
duke
parents:
diff changeset
1361 tty->print_cr(" _patch_code_slowcase_cnt: %d", _patch_code_slowcase_cnt);
a61af66fc99e Initial load
duke
parents:
diff changeset
1362
a61af66fc99e Initial load
duke
parents:
diff changeset
1363 tty->print_cr(" _throw_range_check_exception_count: %d:", _throw_range_check_exception_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1364 tty->print_cr(" _throw_index_exception_count: %d:", _throw_index_exception_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1365 tty->print_cr(" _throw_div0_exception_count: %d:", _throw_div0_exception_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1366 tty->print_cr(" _throw_null_pointer_exception_count: %d:", _throw_null_pointer_exception_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1367 tty->print_cr(" _throw_class_cast_exception_count: %d:", _throw_class_cast_exception_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1368 tty->print_cr(" _throw_incompatible_class_change_error_count: %d:", _throw_incompatible_class_change_error_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1369 tty->print_cr(" _throw_array_store_exception_count: %d:", _throw_array_store_exception_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1370 tty->print_cr(" _throw_count: %d:", _throw_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
1371
a61af66fc99e Initial load
duke
parents:
diff changeset
1372 SharedRuntime::print_ic_miss_histogram();
a61af66fc99e Initial load
duke
parents:
diff changeset
1373 tty->cr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1374 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1375 #endif // PRODUCT