author | roland |
Fri, 17 Aug 2018 17:13:12 +0200 | |
changeset 51521 | 76a51e26d0ac |
parent 51333 | f6641fcf7b7e |
child 53244 | 9807daeb47c4 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
48961
120b61d50f85
8195103: Refactor out card table from CardTableModRefBS to flatten the BarrierSet hierarchy
eosterlund
parents:
47216
diff
changeset
|
2 |
* Copyright (c) 1998, 2018, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4637
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4637
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4637
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_OPTO_RUNTIME_HPP |
26 |
#define SHARE_VM_OPTO_RUNTIME_HPP |
|
27 |
||
28 |
#include "code/codeBlob.hpp" |
|
29 |
#include "opto/machnode.hpp" |
|
25715
d5a8dbdc5150
8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories.
goetz
parents:
24953
diff
changeset
|
30 |
#include "opto/optoreg.hpp" |
7397 | 31 |
#include "opto/type.hpp" |
32 |
#include "runtime/biasedLocking.hpp" |
|
23491 | 33 |
#include "runtime/rtmLocking.hpp" |
7397 | 34 |
#include "runtime/deoptimization.hpp" |
35 |
#include "runtime/vframe.hpp" |
|
36 |
||
1 | 37 |
//------------------------------OptoRuntime------------------------------------ |
38 |
// Opto compiler runtime routines |
|
39 |
// |
|
40 |
// These are all generated from Ideal graphs. They are called with the |
|
41 |
// Java calling convention. Internally they call C++. They are made once at |
|
42 |
// startup time and Opto compiles calls to them later. |
|
43 |
// Things are broken up into quads: the signature they will be called with, |
|
44 |
// the address of the generated code, the corresponding C++ code and an |
|
45 |
// nmethod. |
|
46 |
||
47 |
// The signature (returned by "xxx_Type()") is used at startup time by the |
|
48 |
// Generator to make the generated code "xxx_Java". Opto compiles calls |
|
49 |
// to the generated code "xxx_Java". When the compiled code gets executed, |
|
50 |
// it calls the C++ code "xxx_C". The generated nmethod is saved in the |
|
51 |
// CodeCache. Exception handlers use the nmethod to get the callee-save |
|
52 |
// register OopMaps. |
|
53 |
class CallInfo; |
|
54 |
||
55 |
// |
|
56 |
// NamedCounters are tagged counters which can be used for profiling |
|
57 |
// code in various ways. Currently they are used by the lock coarsening code |
|
58 |
// |
|
59 |
||
13195 | 60 |
class NamedCounter : public CHeapObj<mtCompiler> { |
1 | 61 |
public: |
62 |
enum CounterTag { |
|
63 |
NoTag, |
|
64 |
LockCounter, |
|
65 |
EliminatedLockCounter, |
|
23491 | 66 |
BiasedLockingCounter, |
67 |
RTMLockingCounter |
|
1 | 68 |
}; |
69 |
||
70 |
private: |
|
71 |
const char * _name; |
|
72 |
int _count; |
|
73 |
CounterTag _tag; |
|
74 |
NamedCounter* _next; |
|
75 |
||
76 |
public: |
|
77 |
NamedCounter(const char *n, CounterTag tag = NoTag): |
|
25949 | 78 |
_name(n == NULL ? NULL : os::strdup(n)), |
1 | 79 |
_count(0), |
51333
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
50860
diff
changeset
|
80 |
_tag(tag), |
f6641fcf7b7e
8208670: Compiler changes to allow enabling -Wreorder
tschatzl
parents:
50860
diff
changeset
|
81 |
_next(NULL) {} |
1 | 82 |
|
25949 | 83 |
~NamedCounter() { |
84 |
if (_name != NULL) { |
|
85 |
os::free((void*)_name); |
|
86 |
} |
|
87 |
} |
|
88 |
||
1 | 89 |
const char * name() const { return _name; } |
90 |
int count() const { return _count; } |
|
91 |
address addr() { return (address)&_count; } |
|
92 |
CounterTag tag() const { return _tag; } |
|
93 |
void set_tag(CounterTag tag) { _tag = tag; } |
|
94 |
||
95 |
NamedCounter* next() const { return _next; } |
|
96 |
void set_next(NamedCounter* next) { |
|
23491 | 97 |
assert(_next == NULL || next == NULL, "already set"); |
1 | 98 |
_next = next; |
99 |
} |
|
100 |
||
101 |
}; |
|
102 |
||
103 |
class BiasedLockingNamedCounter : public NamedCounter { |
|
104 |
private: |
|
105 |
BiasedLockingCounters _counters; |
|
106 |
||
107 |
public: |
|
108 |
BiasedLockingNamedCounter(const char *n) : |
|
109 |
NamedCounter(n, BiasedLockingCounter), _counters() {} |
|
110 |
||
111 |
BiasedLockingCounters* counters() { return &_counters; } |
|
112 |
}; |
|
113 |
||
23491 | 114 |
|
115 |
class RTMLockingNamedCounter : public NamedCounter { |
|
116 |
private: |
|
117 |
RTMLockingCounters _counters; |
|
118 |
||
119 |
public: |
|
120 |
RTMLockingNamedCounter(const char *n) : |
|
121 |
NamedCounter(n, RTMLockingCounter), _counters() {} |
|
122 |
||
123 |
RTMLockingCounters* counters() { return &_counters; } |
|
124 |
}; |
|
125 |
||
1 | 126 |
typedef const TypeFunc*(*TypeFunc_generator)(); |
127 |
||
128 |
class OptoRuntime : public AllStatic { |
|
129 |
friend class Matcher; // allow access to stub names |
|
130 |
||
131 |
private: |
|
132 |
// define stubs |
|
133 |
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); |
|
134 |
||
135 |
// References to generated stubs |
|
136 |
static address _new_instance_Java; |
|
137 |
static address _new_array_Java; |
|
10566
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10028
diff
changeset
|
138 |
static address _new_array_nozero_Java; |
1 | 139 |
static address _multianewarray2_Java; |
140 |
static address _multianewarray3_Java; |
|
141 |
static address _multianewarray4_Java; |
|
142 |
static address _multianewarray5_Java; |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
7397
diff
changeset
|
143 |
static address _multianewarrayN_Java; |
1 | 144 |
static address _vtable_must_compile_Java; |
145 |
static address _complete_monitor_locking_Java; |
|
146 |
static address _rethrow_Java; |
|
31856 | 147 |
static address _monitor_notify_Java; |
148 |
static address _monitor_notifyAll_Java; |
|
1 | 149 |
|
150 |
static address _slow_arraycopy_Java; |
|
151 |
static address _register_finalizer_Java; |
|
152 |
||
153 |
// |
|
154 |
// Implementation of runtime methods |
|
155 |
// ================================= |
|
156 |
||
157 |
// Allocate storage for a Java instance. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
158 |
static void new_instance_C(Klass* instance_klass, JavaThread *thread); |
1 | 159 |
|
160 |
// Allocate storage for a objArray or typeArray |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
161 |
static void new_array_C(Klass* array_klass, int len, JavaThread *thread); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
162 |
static void new_array_nozero_C(Klass* array_klass, int len, JavaThread *thread); |
1 | 163 |
|
164 |
// Allocate storage for a multi-dimensional arrays |
|
165 |
// Note: needs to be fixed for arbitrary number of dimensions |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
166 |
static void multianewarray2_C(Klass* klass, int len1, int len2, JavaThread *thread); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
167 |
static void multianewarray3_C(Klass* klass, int len1, int len2, int len3, JavaThread *thread); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
168 |
static void multianewarray4_C(Klass* klass, int len1, int len2, int len3, int len4, JavaThread *thread); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
169 |
static void multianewarray5_C(Klass* klass, int len1, int len2, int len3, int len4, int len5, JavaThread *thread); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
170 |
static void multianewarrayN_C(Klass* klass, arrayOopDesc* dims, JavaThread *thread); |
1 | 171 |
|
172 |
public: |
|
173 |
// Slow-path Locking and Unlocking |
|
174 |
static void complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, JavaThread* thread); |
|
30244 | 175 |
static void complete_monitor_unlocking_C(oopDesc* obj, BasicLock* lock, JavaThread* thread); |
1 | 176 |
|
31856 | 177 |
static void monitor_notify_C(oopDesc* obj, JavaThread* thread); |
178 |
static void monitor_notifyAll_C(oopDesc* obj, JavaThread* thread); |
|
179 |
||
1 | 180 |
private: |
181 |
||
182 |
// Implicit exception support |
|
183 |
static void throw_null_exception_C(JavaThread* thread); |
|
184 |
||
185 |
// Exception handling |
|
186 |
static address handle_exception_C (JavaThread* thread); |
|
187 |
static address handle_exception_C_helper(JavaThread* thread, nmethod*& nm); |
|
188 |
static address rethrow_C (oopDesc* exception, JavaThread *thread, address return_pc ); |
|
14835
70896cb93c35
8004741: Missing compiled exception handle table entry for multidimensional array allocation
kvn
parents:
14132
diff
changeset
|
189 |
static void deoptimize_caller_frame (JavaThread *thread); |
1 | 190 |
static void deoptimize_caller_frame (JavaThread *thread, bool doit); |
10987
696ed3367418
7109887: java/util/Arrays/CopyMethods.java fails with -XX:+DeoptimizeALot
kvn
parents:
10566
diff
changeset
|
191 |
static bool is_deoptimized_caller_frame (JavaThread *thread); |
1 | 192 |
|
193 |
// CodeBlob support |
|
194 |
// =================================================================== |
|
195 |
||
196 |
static ExceptionBlob* _exception_blob; |
|
197 |
static void generate_exception_blob(); |
|
198 |
||
199 |
static void register_finalizer(oopDesc* obj, JavaThread* thread); |
|
200 |
||
201 |
public: |
|
202 |
||
203 |
static bool is_callee_saved_register(MachRegisterNumbers reg); |
|
204 |
||
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
18507
diff
changeset
|
205 |
// One time only generate runtime code stubs. Returns true |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
18507
diff
changeset
|
206 |
// when runtime stubs have been generated successfully and |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
18507
diff
changeset
|
207 |
// false otherwise. |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
18507
diff
changeset
|
208 |
static bool generate(ciEnv* env); |
1 | 209 |
|
210 |
// Returns the name of a stub |
|
211 |
static const char* stub_name(address entry); |
|
212 |
||
213 |
// access to runtime stubs entry points for java code |
|
214 |
static address new_instance_Java() { return _new_instance_Java; } |
|
215 |
static address new_array_Java() { return _new_array_Java; } |
|
10566
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10028
diff
changeset
|
216 |
static address new_array_nozero_Java() { return _new_array_nozero_Java; } |
1 | 217 |
static address multianewarray2_Java() { return _multianewarray2_Java; } |
218 |
static address multianewarray3_Java() { return _multianewarray3_Java; } |
|
219 |
static address multianewarray4_Java() { return _multianewarray4_Java; } |
|
220 |
static address multianewarray5_Java() { return _multianewarray5_Java; } |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
7397
diff
changeset
|
221 |
static address multianewarrayN_Java() { return _multianewarrayN_Java; } |
1 | 222 |
static address vtable_must_compile_stub() { return _vtable_must_compile_Java; } |
31856 | 223 |
static address complete_monitor_locking_Java() { return _complete_monitor_locking_Java; } |
224 |
static address monitor_notify_Java() { return _monitor_notify_Java; } |
|
225 |
static address monitor_notifyAll_Java() { return _monitor_notifyAll_Java; } |
|
1 | 226 |
|
227 |
static address slow_arraycopy_Java() { return _slow_arraycopy_Java; } |
|
228 |
static address register_finalizer_Java() { return _register_finalizer_Java; } |
|
229 |
||
230 |
static ExceptionBlob* exception_blob() { return _exception_blob; } |
|
231 |
||
232 |
// Leaf routines helping with method data update |
|
233 |
static void profile_receiver_type_C(DataLayout* data, oopDesc* receiver); |
|
234 |
||
235 |
// Implicit exception support |
|
236 |
static void throw_div0_exception_C (JavaThread* thread); |
|
237 |
static void throw_stack_overflow_error_C(JavaThread* thread); |
|
238 |
||
239 |
// Exception handling |
|
240 |
static address rethrow_stub() { return _rethrow_Java; } |
|
241 |
||
242 |
||
243 |
// Type functions |
|
244 |
// ====================================================== |
|
245 |
||
246 |
static const TypeFunc* new_instance_Type(); // object allocation (slow case) |
|
247 |
static const TypeFunc* new_array_Type (); // [a]newarray (slow case) |
|
248 |
static const TypeFunc* multianewarray_Type(int ndim); // multianewarray |
|
249 |
static const TypeFunc* multianewarray2_Type(); // multianewarray |
|
250 |
static const TypeFunc* multianewarray3_Type(); // multianewarray |
|
251 |
static const TypeFunc* multianewarray4_Type(); // multianewarray |
|
252 |
static const TypeFunc* multianewarray5_Type(); // multianewarray |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
7397
diff
changeset
|
253 |
static const TypeFunc* multianewarrayN_Type(); // multianewarray |
1 | 254 |
static const TypeFunc* complete_monitor_enter_Type(); |
255 |
static const TypeFunc* complete_monitor_exit_Type(); |
|
31856 | 256 |
static const TypeFunc* monitor_notify_Type(); |
1 | 257 |
static const TypeFunc* uncommon_trap_Type(); |
258 |
static const TypeFunc* athrow_Type(); |
|
259 |
static const TypeFunc* rethrow_Type(); |
|
260 |
static const TypeFunc* Math_D_D_Type(); // sin,cos & friends |
|
261 |
static const TypeFunc* Math_DD_D_Type(); // mod,pow & friends |
|
262 |
static const TypeFunc* modf_Type(); |
|
263 |
static const TypeFunc* l2f_Type(); |
|
12377
ae6def2813e0
7160570: Intrinsification support for tracing framework
rbackman
parents:
10987
diff
changeset
|
264 |
static const TypeFunc* void_long_Type(); |
1 | 265 |
|
266 |
static const TypeFunc* flush_windows_Type(); |
|
267 |
||
268 |
// arraycopy routine types |
|
269 |
static const TypeFunc* fast_arraycopy_Type(); // bit-blasters |
|
270 |
static const TypeFunc* checkcast_arraycopy_Type(); |
|
271 |
static const TypeFunc* generic_arraycopy_Type(); |
|
272 |
static const TypeFunc* slow_arraycopy_Type(); // the full routine |
|
273 |
||
6433 | 274 |
static const TypeFunc* array_fill_Type(); |
275 |
||
14132 | 276 |
static const TypeFunc* aescrypt_block_Type(); |
277 |
static const TypeFunc* cipherBlockChaining_aescrypt_Type(); |
|
35154 | 278 |
static const TypeFunc* counterMode_aescrypt_Type(); |
14132 | 279 |
|
24953
9680119572be
8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents:
23491
diff
changeset
|
280 |
static const TypeFunc* sha_implCompress_Type(); |
9680119572be
8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents:
23491
diff
changeset
|
281 |
static const TypeFunc* digestBase_implCompressMB_Type(); |
9680119572be
8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents:
23491
diff
changeset
|
282 |
|
26434
09ad55e5f486
8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents:
25949
diff
changeset
|
283 |
static const TypeFunc* multiplyToLen_Type(); |
31583
eb5bea7b4835
8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents:
31129
diff
changeset
|
284 |
static const TypeFunc* montgomeryMultiply_Type(); |
eb5bea7b4835
8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents:
31129
diff
changeset
|
285 |
static const TypeFunc* montgomerySquare_Type(); |
26434
09ad55e5f486
8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents:
25949
diff
changeset
|
286 |
|
31129
02ee7609f0e1
8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents:
30244
diff
changeset
|
287 |
static const TypeFunc* squareToLen_Type(); |
02ee7609f0e1
8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents:
30244
diff
changeset
|
288 |
|
02ee7609f0e1
8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents:
30244
diff
changeset
|
289 |
static const TypeFunc* mulAdd_Type(); |
02ee7609f0e1
8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents:
30244
diff
changeset
|
290 |
|
35110
f19bcdf40799
8143355: Update for addition of vectorizedMismatch intrinsic for x86
kvn
parents:
33063
diff
changeset
|
291 |
static const TypeFunc* vectorizedMismatch_Type(); |
f19bcdf40799
8143355: Update for addition of vectorizedMismatch intrinsic for x86
kvn
parents:
33063
diff
changeset
|
292 |
|
31404
63e8fcd70bfc
8073108: Use x86 and SPARC CPU instructions for GHASH acceleration
ascarpino
parents:
31129
diff
changeset
|
293 |
static const TypeFunc* ghash_processBlocks_Type(); |
50860
480a96a43b62
8205528: Base64 encoding algorithm using AVX512 instructions
kvn
parents:
50180
diff
changeset
|
294 |
static const TypeFunc* base64_encodeBlock_Type(); |
31404
63e8fcd70bfc
8073108: Use x86 and SPARC CPU instructions for GHASH acceleration
ascarpino
parents:
31129
diff
changeset
|
295 |
|
18507
61bfc8995bb3
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
14835
diff
changeset
|
296 |
static const TypeFunc* updateBytesCRC32_Type(); |
31515 | 297 |
static const TypeFunc* updateBytesCRC32C_Type(); |
18507
61bfc8995bb3
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
14835
diff
changeset
|
298 |
|
32581 | 299 |
static const TypeFunc* updateBytesAdler32_Type(); |
300 |
||
1 | 301 |
// leaf on stack replacement interpreter accessor types |
302 |
static const TypeFunc* osr_end_Type(); |
|
303 |
||
304 |
// leaf methodData routine types |
|
305 |
static const TypeFunc* profile_receiver_type_Type(); |
|
306 |
||
307 |
// leaf on stack replacement interpreter accessor types |
|
308 |
static const TypeFunc* fetch_int_Type(); |
|
309 |
static const TypeFunc* fetch_long_Type(); |
|
310 |
static const TypeFunc* fetch_float_Type(); |
|
311 |
static const TypeFunc* fetch_double_Type(); |
|
312 |
static const TypeFunc* fetch_oop_Type(); |
|
313 |
static const TypeFunc* fetch_monitor_Type(); |
|
314 |
||
315 |
static const TypeFunc* register_finalizer_Type(); |
|
316 |
||
317 |
// Dtrace support |
|
318 |
static const TypeFunc* dtrace_method_entry_exit_Type(); |
|
319 |
static const TypeFunc* dtrace_object_alloc_Type(); |
|
320 |
||
321 |
private: |
|
322 |
static NamedCounter * volatile _named_counters; |
|
323 |
||
324 |
public: |
|
325 |
// helper function which creates a named counter labeled with the |
|
326 |
// if they are available |
|
327 |
static NamedCounter* new_named_counter(JVMState* jvms, NamedCounter::CounterTag tag); |
|
328 |
||
329 |
// dumps all the named counters |
|
330 |
static void print_named_counters(); |
|
331 |
||
332 |
}; |
|
7397 | 333 |
|
334 |
#endif // SHARE_VM_OPTO_RUNTIME_HPP |