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