annotate src/share/vm/opto/runtime.hpp @ 4710:41406797186b

7113012: G1: rename not-fully-young GCs as "mixed" Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets). Reviewed-by: johnc, brutisso
author tonyp
date Fri, 16 Dec 2011 02:14:27 -0500
parents 7e0e43cf86d6
children 0105f367a14c
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
2 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1166
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1166
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: 1166
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: 1763
diff changeset
25 #ifndef SHARE_VM_OPTO_RUNTIME_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
26 #define SHARE_VM_OPTO_RUNTIME_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
28 #include "code/codeBlob.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
29 #include "opto/machnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
30 #include "opto/type.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
31 #include "runtime/biasedLocking.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
32 #include "runtime/deoptimization.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
33 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
34
0
a61af66fc99e Initial load
duke
parents:
diff changeset
35 //------------------------------OptoRuntime------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
36 // Opto compiler runtime routines
a61af66fc99e Initial load
duke
parents:
diff changeset
37 //
a61af66fc99e Initial load
duke
parents:
diff changeset
38 // These are all generated from Ideal graphs. They are called with the
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // Java calling convention. Internally they call C++. They are made once at
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // startup time and Opto compiles calls to them later.
a61af66fc99e Initial load
duke
parents:
diff changeset
41 // Things are broken up into quads: the signature they will be called with,
a61af66fc99e Initial load
duke
parents:
diff changeset
42 // the address of the generated code, the corresponding C++ code and an
a61af66fc99e Initial load
duke
parents:
diff changeset
43 // nmethod.
a61af66fc99e Initial load
duke
parents:
diff changeset
44
a61af66fc99e Initial load
duke
parents:
diff changeset
45 // The signature (returned by "xxx_Type()") is used at startup time by the
a61af66fc99e Initial load
duke
parents:
diff changeset
46 // Generator to make the generated code "xxx_Java". Opto compiles calls
a61af66fc99e Initial load
duke
parents:
diff changeset
47 // to the generated code "xxx_Java". When the compiled code gets executed,
a61af66fc99e Initial load
duke
parents:
diff changeset
48 // it calls the C++ code "xxx_C". The generated nmethod is saved in the
a61af66fc99e Initial load
duke
parents:
diff changeset
49 // CodeCache. Exception handlers use the nmethod to get the callee-save
a61af66fc99e Initial load
duke
parents:
diff changeset
50 // register OopMaps.
a61af66fc99e Initial load
duke
parents:
diff changeset
51 class CallInfo;
a61af66fc99e Initial load
duke
parents:
diff changeset
52
a61af66fc99e Initial load
duke
parents:
diff changeset
53 //
a61af66fc99e Initial load
duke
parents:
diff changeset
54 // NamedCounters are tagged counters which can be used for profiling
a61af66fc99e Initial load
duke
parents:
diff changeset
55 // code in various ways. Currently they are used by the lock coarsening code
a61af66fc99e Initial load
duke
parents:
diff changeset
56 //
a61af66fc99e Initial load
duke
parents:
diff changeset
57
a61af66fc99e Initial load
duke
parents:
diff changeset
58 class NamedCounter : public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
59 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
60 enum CounterTag {
a61af66fc99e Initial load
duke
parents:
diff changeset
61 NoTag,
a61af66fc99e Initial load
duke
parents:
diff changeset
62 LockCounter,
a61af66fc99e Initial load
duke
parents:
diff changeset
63 EliminatedLockCounter,
a61af66fc99e Initial load
duke
parents:
diff changeset
64 BiasedLockingCounter
a61af66fc99e Initial load
duke
parents:
diff changeset
65 };
a61af66fc99e Initial load
duke
parents:
diff changeset
66
a61af66fc99e Initial load
duke
parents:
diff changeset
67 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
68 const char * _name;
a61af66fc99e Initial load
duke
parents:
diff changeset
69 int _count;
a61af66fc99e Initial load
duke
parents:
diff changeset
70 CounterTag _tag;
a61af66fc99e Initial load
duke
parents:
diff changeset
71 NamedCounter* _next;
a61af66fc99e Initial load
duke
parents:
diff changeset
72
a61af66fc99e Initial load
duke
parents:
diff changeset
73 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
74 NamedCounter(const char *n, CounterTag tag = NoTag):
a61af66fc99e Initial load
duke
parents:
diff changeset
75 _name(n),
a61af66fc99e Initial load
duke
parents:
diff changeset
76 _count(0),
a61af66fc99e Initial load
duke
parents:
diff changeset
77 _next(NULL),
a61af66fc99e Initial load
duke
parents:
diff changeset
78 _tag(tag) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
79
a61af66fc99e Initial load
duke
parents:
diff changeset
80 const char * name() const { return _name; }
a61af66fc99e Initial load
duke
parents:
diff changeset
81 int count() const { return _count; }
a61af66fc99e Initial load
duke
parents:
diff changeset
82 address addr() { return (address)&_count; }
a61af66fc99e Initial load
duke
parents:
diff changeset
83 CounterTag tag() const { return _tag; }
a61af66fc99e Initial load
duke
parents:
diff changeset
84 void set_tag(CounterTag tag) { _tag = tag; }
a61af66fc99e Initial load
duke
parents:
diff changeset
85
a61af66fc99e Initial load
duke
parents:
diff changeset
86 NamedCounter* next() const { return _next; }
a61af66fc99e Initial load
duke
parents:
diff changeset
87 void set_next(NamedCounter* next) {
a61af66fc99e Initial load
duke
parents:
diff changeset
88 assert(_next == NULL, "already set");
a61af66fc99e Initial load
duke
parents:
diff changeset
89 _next = next;
a61af66fc99e Initial load
duke
parents:
diff changeset
90 }
a61af66fc99e Initial load
duke
parents:
diff changeset
91
a61af66fc99e Initial load
duke
parents:
diff changeset
92 };
a61af66fc99e Initial load
duke
parents:
diff changeset
93
a61af66fc99e Initial load
duke
parents:
diff changeset
94 class BiasedLockingNamedCounter : public NamedCounter {
a61af66fc99e Initial load
duke
parents:
diff changeset
95 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
96 BiasedLockingCounters _counters;
a61af66fc99e Initial load
duke
parents:
diff changeset
97
a61af66fc99e Initial load
duke
parents:
diff changeset
98 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
99 BiasedLockingNamedCounter(const char *n) :
a61af66fc99e Initial load
duke
parents:
diff changeset
100 NamedCounter(n, BiasedLockingCounter), _counters() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
101
a61af66fc99e Initial load
duke
parents:
diff changeset
102 BiasedLockingCounters* counters() { return &_counters; }
a61af66fc99e Initial load
duke
parents:
diff changeset
103 };
a61af66fc99e Initial load
duke
parents:
diff changeset
104
a61af66fc99e Initial load
duke
parents:
diff changeset
105 typedef const TypeFunc*(*TypeFunc_generator)();
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107 class OptoRuntime : public AllStatic {
a61af66fc99e Initial load
duke
parents:
diff changeset
108 friend class Matcher; // allow access to stub names
a61af66fc99e Initial load
duke
parents:
diff changeset
109
a61af66fc99e Initial load
duke
parents:
diff changeset
110 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
111 // define stubs
a61af66fc99e Initial load
duke
parents:
diff changeset
112 static address generate_stub(ciEnv* ci_env, TypeFunc_generator gen, address C_function, const char *name, int is_fancy_jump, bool pass_tls, bool save_arguments, bool return_pc);
a61af66fc99e Initial load
duke
parents:
diff changeset
113
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // References to generated stubs
a61af66fc99e Initial load
duke
parents:
diff changeset
115 static address _new_instance_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
116 static address _new_array_Java;
3961
a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array
kvn
parents: 3805
diff changeset
117 static address _new_array_nozero_Java;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
118 static address _multianewarray2_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
119 static address _multianewarray3_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
120 static address _multianewarray4_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
121 static address _multianewarray5_Java;
3805
263247c478c5 7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents: 1972
diff changeset
122 static address _multianewarrayN_Java;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
123 static address _g1_wb_pre_Java;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
124 static address _g1_wb_post_Java;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
125 static address _vtable_must_compile_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
126 static address _complete_monitor_locking_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
127 static address _rethrow_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
128
a61af66fc99e Initial load
duke
parents:
diff changeset
129 static address _slow_arraycopy_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
130 static address _register_finalizer_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
131
a61af66fc99e Initial load
duke
parents:
diff changeset
132 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load
duke
parents:
diff changeset
133 static address _zap_dead_Java_locals_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
134 static address _zap_dead_native_locals_Java;
a61af66fc99e Initial load
duke
parents:
diff changeset
135 # endif
a61af66fc99e Initial load
duke
parents:
diff changeset
136
a61af66fc99e Initial load
duke
parents:
diff changeset
137
a61af66fc99e Initial load
duke
parents:
diff changeset
138 //
a61af66fc99e Initial load
duke
parents:
diff changeset
139 // Implementation of runtime methods
a61af66fc99e Initial load
duke
parents:
diff changeset
140 // =================================
a61af66fc99e Initial load
duke
parents:
diff changeset
141
a61af66fc99e Initial load
duke
parents:
diff changeset
142 // Allocate storage for a Java instance.
a61af66fc99e Initial load
duke
parents:
diff changeset
143 static void new_instance_C(klassOopDesc* instance_klass, JavaThread *thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
144
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // Allocate storage for a objArray or typeArray
a61af66fc99e Initial load
duke
parents:
diff changeset
146 static void new_array_C(klassOopDesc* array_klass, int len, JavaThread *thread);
3961
a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array
kvn
parents: 3805
diff changeset
147 static void new_array_nozero_C(klassOopDesc* array_klass, int len, JavaThread *thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
148
1166
7b0e9cba0307 6896647: card marks can be deferred too long
ysr
parents: 1027
diff changeset
149 // Post-slow-path-allocation, pre-initializing-stores step for
7b0e9cba0307 6896647: card marks can be deferred too long
ysr
parents: 1027
diff changeset
150 // implementing ReduceInitialCardMarks
7b0e9cba0307 6896647: card marks can be deferred too long
ysr
parents: 1027
diff changeset
151 static void new_store_pre_barrier(JavaThread* thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
152
a61af66fc99e Initial load
duke
parents:
diff changeset
153 // Allocate storage for a multi-dimensional arrays
a61af66fc99e Initial load
duke
parents:
diff changeset
154 // Note: needs to be fixed for arbitrary number of dimensions
a61af66fc99e Initial load
duke
parents:
diff changeset
155 static void multianewarray2_C(klassOopDesc* klass, int len1, int len2, JavaThread *thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
156 static void multianewarray3_C(klassOopDesc* klass, int len1, int len2, int len3, JavaThread *thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
157 static void multianewarray4_C(klassOopDesc* klass, int len1, int len2, int len3, int len4, JavaThread *thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
158 static void multianewarray5_C(klassOopDesc* klass, int len1, int len2, int len3, int len4, int len5, JavaThread *thread);
3805
263247c478c5 7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents: 1972
diff changeset
159 static void multianewarrayN_C(klassOopDesc* klass, arrayOopDesc* dims, JavaThread *thread);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
160 static void g1_wb_pre_C(oopDesc* orig, JavaThread* thread);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
161 static void g1_wb_post_C(void* card_addr, JavaThread* thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
162
a61af66fc99e Initial load
duke
parents:
diff changeset
163 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // Slow-path Locking and Unlocking
a61af66fc99e Initial load
duke
parents:
diff changeset
165 static void complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
166 static void complete_monitor_unlocking_C(oopDesc* obj, BasicLock* lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
167
a61af66fc99e Initial load
duke
parents:
diff changeset
168 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
169
a61af66fc99e Initial load
duke
parents:
diff changeset
170 // Implicit exception support
a61af66fc99e Initial load
duke
parents:
diff changeset
171 static void throw_null_exception_C(JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
172
a61af66fc99e Initial load
duke
parents:
diff changeset
173 // Exception handling
a61af66fc99e Initial load
duke
parents:
diff changeset
174 static address handle_exception_C (JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
175 static address handle_exception_C_helper(JavaThread* thread, nmethod*& nm);
a61af66fc99e Initial load
duke
parents:
diff changeset
176 static address rethrow_C (oopDesc* exception, JavaThread *thread, address return_pc );
a61af66fc99e Initial load
duke
parents:
diff changeset
177 static void deoptimize_caller_frame (JavaThread *thread, bool doit);
4063
7e0e43cf86d6 7109887: java/util/Arrays/CopyMethods.java fails with -XX:+DeoptimizeALot
kvn
parents: 3961
diff changeset
178 static bool is_deoptimized_caller_frame (JavaThread *thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
179
a61af66fc99e Initial load
duke
parents:
diff changeset
180 // CodeBlob support
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // ===================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
182
a61af66fc99e Initial load
duke
parents:
diff changeset
183 static ExceptionBlob* _exception_blob;
a61af66fc99e Initial load
duke
parents:
diff changeset
184 static void generate_exception_blob();
a61af66fc99e Initial load
duke
parents:
diff changeset
185
a61af66fc99e Initial load
duke
parents:
diff changeset
186 static void register_finalizer(oopDesc* obj, JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
187
a61af66fc99e Initial load
duke
parents:
diff changeset
188 // zaping dead locals, either from Java frames or from native frames
a61af66fc99e Initial load
duke
parents:
diff changeset
189 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load
duke
parents:
diff changeset
190 static void zap_dead_Java_locals_C( JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
191 static void zap_dead_native_locals_C( JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
192
a61af66fc99e Initial load
duke
parents:
diff changeset
193 static void zap_dead_java_or_native_locals( JavaThread*, bool (*)(frame*));
a61af66fc99e Initial load
duke
parents:
diff changeset
194
a61af66fc99e Initial load
duke
parents:
diff changeset
195 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
196 static int ZapDeadCompiledLocals_count;
a61af66fc99e Initial load
duke
parents:
diff changeset
197
a61af66fc99e Initial load
duke
parents:
diff changeset
198 # endif
a61af66fc99e Initial load
duke
parents:
diff changeset
199
a61af66fc99e Initial load
duke
parents:
diff changeset
200
a61af66fc99e Initial load
duke
parents:
diff changeset
201 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
202
a61af66fc99e Initial load
duke
parents:
diff changeset
203 static bool is_callee_saved_register(MachRegisterNumbers reg);
a61af66fc99e Initial load
duke
parents:
diff changeset
204
a61af66fc99e Initial load
duke
parents:
diff changeset
205 // One time only generate runtime code stubs
a61af66fc99e Initial load
duke
parents:
diff changeset
206 static void generate(ciEnv* env);
a61af66fc99e Initial load
duke
parents:
diff changeset
207
a61af66fc99e Initial load
duke
parents:
diff changeset
208 // Returns the name of a stub
a61af66fc99e Initial load
duke
parents:
diff changeset
209 static const char* stub_name(address entry);
a61af66fc99e Initial load
duke
parents:
diff changeset
210
a61af66fc99e Initial load
duke
parents:
diff changeset
211 // access to runtime stubs entry points for java code
a61af66fc99e Initial load
duke
parents:
diff changeset
212 static address new_instance_Java() { return _new_instance_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
213 static address new_array_Java() { return _new_array_Java; }
3961
a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array
kvn
parents: 3805
diff changeset
214 static address new_array_nozero_Java() { return _new_array_nozero_Java; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
215 static address multianewarray2_Java() { return _multianewarray2_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
216 static address multianewarray3_Java() { return _multianewarray3_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
217 static address multianewarray4_Java() { return _multianewarray4_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
218 static address multianewarray5_Java() { return _multianewarray5_Java; }
3805
263247c478c5 7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents: 1972
diff changeset
219 static address multianewarrayN_Java() { return _multianewarrayN_Java; }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
220 static address g1_wb_pre_Java() { return _g1_wb_pre_Java; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
221 static address g1_wb_post_Java() { return _g1_wb_post_Java; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
222 static address vtable_must_compile_stub() { return _vtable_must_compile_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
223 static address complete_monitor_locking_Java() { return _complete_monitor_locking_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
224
a61af66fc99e Initial load
duke
parents:
diff changeset
225 static address slow_arraycopy_Java() { return _slow_arraycopy_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
226 static address register_finalizer_Java() { return _register_finalizer_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
227
a61af66fc99e Initial load
duke
parents:
diff changeset
228
a61af66fc99e Initial load
duke
parents:
diff changeset
229 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load
duke
parents:
diff changeset
230 static address zap_dead_locals_stub(bool is_native) { return is_native
a61af66fc99e Initial load
duke
parents:
diff changeset
231 ? _zap_dead_native_locals_Java
a61af66fc99e Initial load
duke
parents:
diff changeset
232 : _zap_dead_Java_locals_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
233 static MachNode* node_to_call_zap_dead_locals(Node* n, int block_num, bool is_native);
a61af66fc99e Initial load
duke
parents:
diff changeset
234 # endif
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
236 static ExceptionBlob* exception_blob() { return _exception_blob; }
a61af66fc99e Initial load
duke
parents:
diff changeset
237
a61af66fc99e Initial load
duke
parents:
diff changeset
238 // Leaf routines helping with method data update
a61af66fc99e Initial load
duke
parents:
diff changeset
239 static void profile_receiver_type_C(DataLayout* data, oopDesc* receiver);
a61af66fc99e Initial load
duke
parents:
diff changeset
240
a61af66fc99e Initial load
duke
parents:
diff changeset
241 // Implicit exception support
a61af66fc99e Initial load
duke
parents:
diff changeset
242 static void throw_div0_exception_C (JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
243 static void throw_stack_overflow_error_C(JavaThread* thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
244
a61af66fc99e Initial load
duke
parents:
diff changeset
245 // Exception handling
a61af66fc99e Initial load
duke
parents:
diff changeset
246 static address rethrow_stub() { return _rethrow_Java; }
a61af66fc99e Initial load
duke
parents:
diff changeset
247
a61af66fc99e Initial load
duke
parents:
diff changeset
248
a61af66fc99e Initial load
duke
parents:
diff changeset
249 // Type functions
a61af66fc99e Initial load
duke
parents:
diff changeset
250 // ======================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
251
a61af66fc99e Initial load
duke
parents:
diff changeset
252 static const TypeFunc* new_instance_Type(); // object allocation (slow case)
a61af66fc99e Initial load
duke
parents:
diff changeset
253 static const TypeFunc* new_array_Type (); // [a]newarray (slow case)
a61af66fc99e Initial load
duke
parents:
diff changeset
254 static const TypeFunc* multianewarray_Type(int ndim); // multianewarray
a61af66fc99e Initial load
duke
parents:
diff changeset
255 static const TypeFunc* multianewarray2_Type(); // multianewarray
a61af66fc99e Initial load
duke
parents:
diff changeset
256 static const TypeFunc* multianewarray3_Type(); // multianewarray
a61af66fc99e Initial load
duke
parents:
diff changeset
257 static const TypeFunc* multianewarray4_Type(); // multianewarray
a61af66fc99e Initial load
duke
parents:
diff changeset
258 static const TypeFunc* multianewarray5_Type(); // multianewarray
3805
263247c478c5 7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents: 1972
diff changeset
259 static const TypeFunc* multianewarrayN_Type(); // multianewarray
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
260 static const TypeFunc* g1_wb_pre_Type();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
261 static const TypeFunc* g1_wb_post_Type();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
262 static const TypeFunc* complete_monitor_enter_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
263 static const TypeFunc* complete_monitor_exit_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
264 static const TypeFunc* uncommon_trap_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
265 static const TypeFunc* athrow_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
266 static const TypeFunc* rethrow_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
267 static const TypeFunc* Math_D_D_Type(); // sin,cos & friends
a61af66fc99e Initial load
duke
parents:
diff changeset
268 static const TypeFunc* Math_DD_D_Type(); // mod,pow & friends
a61af66fc99e Initial load
duke
parents:
diff changeset
269 static const TypeFunc* modf_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
270 static const TypeFunc* l2f_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
271 static const TypeFunc* current_time_millis_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
272
a61af66fc99e Initial load
duke
parents:
diff changeset
273 static const TypeFunc* flush_windows_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
274
a61af66fc99e Initial load
duke
parents:
diff changeset
275 // arraycopy routine types
a61af66fc99e Initial load
duke
parents:
diff changeset
276 static const TypeFunc* fast_arraycopy_Type(); // bit-blasters
a61af66fc99e Initial load
duke
parents:
diff changeset
277 static const TypeFunc* checkcast_arraycopy_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
278 static const TypeFunc* generic_arraycopy_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
279 static const TypeFunc* slow_arraycopy_Type(); // the full routine
a61af66fc99e Initial load
duke
parents:
diff changeset
280
1763
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
281 static const TypeFunc* array_fill_Type();
d6f45b55c972 4809552: Optimize Arrays.fill(...)
never
parents: 1552
diff changeset
282
0
a61af66fc99e Initial load
duke
parents:
diff changeset
283 // leaf on stack replacement interpreter accessor types
a61af66fc99e Initial load
duke
parents:
diff changeset
284 static const TypeFunc* osr_end_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
285
a61af66fc99e Initial load
duke
parents:
diff changeset
286 // leaf methodData routine types
a61af66fc99e Initial load
duke
parents:
diff changeset
287 static const TypeFunc* profile_receiver_type_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
288
a61af66fc99e Initial load
duke
parents:
diff changeset
289 // leaf on stack replacement interpreter accessor types
a61af66fc99e Initial load
duke
parents:
diff changeset
290 static const TypeFunc* fetch_int_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
291 static const TypeFunc* fetch_long_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
292 static const TypeFunc* fetch_float_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
293 static const TypeFunc* fetch_double_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
294 static const TypeFunc* fetch_oop_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
295 static const TypeFunc* fetch_monitor_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
296
a61af66fc99e Initial load
duke
parents:
diff changeset
297 static const TypeFunc* register_finalizer_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
298
a61af66fc99e Initial load
duke
parents:
diff changeset
299 // Dtrace support
a61af66fc99e Initial load
duke
parents:
diff changeset
300 static const TypeFunc* dtrace_method_entry_exit_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
301 static const TypeFunc* dtrace_object_alloc_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
302
a61af66fc99e Initial load
duke
parents:
diff changeset
303 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load
duke
parents:
diff changeset
304 static const TypeFunc* zap_dead_locals_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
305 # endif
a61af66fc99e Initial load
duke
parents:
diff changeset
306
a61af66fc99e Initial load
duke
parents:
diff changeset
307 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
308 static NamedCounter * volatile _named_counters;
a61af66fc99e Initial load
duke
parents:
diff changeset
309
a61af66fc99e Initial load
duke
parents:
diff changeset
310 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
311 // helper function which creates a named counter labeled with the
a61af66fc99e Initial load
duke
parents:
diff changeset
312 // if they are available
a61af66fc99e Initial load
duke
parents:
diff changeset
313 static NamedCounter* new_named_counter(JVMState* jvms, NamedCounter::CounterTag tag);
a61af66fc99e Initial load
duke
parents:
diff changeset
314
a61af66fc99e Initial load
duke
parents:
diff changeset
315 // dumps all the named counters
a61af66fc99e Initial load
duke
parents:
diff changeset
316 static void print_named_counters();
a61af66fc99e Initial load
duke
parents:
diff changeset
317
a61af66fc99e Initial load
duke
parents:
diff changeset
318 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
319
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
320 #endif // SHARE_VM_OPTO_RUNTIME_HPP