1 /* 2 * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved. 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 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifdef COMPILER2 26 #include "asm/macroAssembler.hpp" 27 #include "asm/macroAssembler.inline.hpp" 28 #include "code/aotCodeCache.hpp" 29 #include "code/vmreg.hpp" 30 #include "interpreter/interpreter.hpp" 31 #include "opto/runtime.hpp" 32 #include "runtime/sharedRuntime.hpp" 33 #include "runtime/stubRoutines.hpp" 34 #include "runtime/vframeArray.hpp" 35 #include "utilities/globalDefinitions.hpp" 36 #include "vmreg_x86.inline.hpp" 37 38 class SimpleRuntimeFrame { 39 40 public: 41 42 // Most of the runtime stubs have this simple frame layout. 43 // This class exists to make the layout shared in one place. 44 // Offsets are for compiler stack slots, which are jints. 45 enum layout { 46 // The frame sender code expects that rbp will be in the "natural" place and 47 // will override any oopMap setting for it. We must therefore force the layout 48 // so that it agrees with the frame sender code. 49 rbp_off = frame::arg_reg_save_area_bytes/BytesPerInt, 50 rbp_off2, 51 return_off, return_off2, 52 framesize 53 }; 54 }; 55 56 #define __ masm-> 57 58 //------------------------------generate_uncommon_trap_blob-------------------- 59 UncommonTrapBlob* OptoRuntime::generate_uncommon_trap_blob() { 60 // Allocate space for the code 61 ResourceMark rm; 62 // Setup code generation tools 63 const char* name = OptoRuntime::stub_name(OptoStubId::uncommon_trap_id); 64 CodeBuffer buffer(name, 2048, 1024); 65 if (buffer.blob() == nullptr) { 66 return nullptr; 67 } 68 MacroAssembler* masm = new MacroAssembler(&buffer); 69 70 assert(SimpleRuntimeFrame::framesize % 4 == 0, "sp not 16-byte aligned"); 71 72 address start = __ pc(); 73 74 // Push self-frame. We get here with a return address on the 75 // stack, so rsp is 8-byte aligned until we allocate our frame. 76 __ subptr(rsp, SimpleRuntimeFrame::return_off << LogBytesPerInt); // Epilog! 77 78 // No callee saved registers. rbp is assumed implicitly saved 79 __ movptr(Address(rsp, SimpleRuntimeFrame::rbp_off << LogBytesPerInt), rbp); 80 81 // compiler left unloaded_class_index in j_rarg0 move to where the 82 // runtime expects it. 83 __ movl(c_rarg1, j_rarg0); 84 85 __ set_last_Java_frame(noreg, noreg, nullptr, rscratch1); 86 87 // Call C code. Need thread but NOT official VM entry 88 // crud. We cannot block on this call, no GC can happen. Call should 89 // capture callee-saved registers as well as return values. 90 // Thread is in rdi already. 91 // 92 // UnrollBlock* uncommon_trap(JavaThread* thread, jint unloaded_class_index); 93 94 __ mov(c_rarg0, r15_thread); 95 __ movl(c_rarg2, Deoptimization::Unpack_uncommon_trap); 96 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::uncommon_trap))); 97 98 // Set an oopmap for the call site 99 OopMapSet* oop_maps = new OopMapSet(); 100 OopMap* map = new OopMap(SimpleRuntimeFrame::framesize, 0); 101 102 // location of rbp is known implicitly by the frame sender code 103 104 oop_maps->add_gc_map(__ pc() - start, map); 105 106 __ reset_last_Java_frame(false); 107 108 // Load UnrollBlock* into rdi 109 __ mov(rdi, rax); 110 111 #ifdef ASSERT 112 { Label L; 113 __ cmpptr(Address(rdi, Deoptimization::UnrollBlock::unpack_kind_offset()), 114 Deoptimization::Unpack_uncommon_trap); 115 __ jcc(Assembler::equal, L); 116 __ stop("OptoRuntime::generate_uncommon_trap_blob: expected Unpack_uncommon_trap"); 117 __ bind(L); 118 } 119 #endif 120 121 // Pop all the frames we must move/replace. 122 // 123 // Frame picture (youngest to oldest) 124 // 1: self-frame (no frame link) 125 // 2: deopting frame (no frame link) 126 // 3: caller of deopting frame (could be compiled/interpreted). 127 128 // Pop self-frame. We have no frame, and must rely only on rax and rsp. 129 __ addptr(rsp, (SimpleRuntimeFrame::framesize - 2) << LogBytesPerInt); // Epilog! 130 131 // Pop deoptimized frame (int) 132 __ movl(rcx, Address(rdi, 133 Deoptimization::UnrollBlock:: 134 size_of_deoptimized_frame_offset())); 135 __ addptr(rsp, rcx); 136 137 // rsp should be pointing at the return address to the caller (3) 138 139 // Pick up the initial fp we should save 140 // restore rbp before stack bang because if stack overflow is thrown it needs to be pushed (and preserved) 141 __ movptr(rbp, Address(rdi, Deoptimization::UnrollBlock::initial_info_offset())); 142 143 #ifdef ASSERT 144 // Compilers generate code that bang the stack by as much as the 145 // interpreter would need. So this stack banging should never 146 // trigger a fault. Verify that it does not on non product builds. 147 __ movl(rbx, Address(rdi ,Deoptimization::UnrollBlock::total_frame_sizes_offset())); 148 __ bang_stack_size(rbx, rcx); 149 #endif 150 151 // Load address of array of frame pcs into rcx (address*) 152 __ movptr(rcx, Address(rdi, Deoptimization::UnrollBlock::frame_pcs_offset())); 153 154 // Trash the return pc 155 __ addptr(rsp, wordSize); 156 157 // Load address of array of frame sizes into rsi (intptr_t*) 158 __ movptr(rsi, Address(rdi, Deoptimization::UnrollBlock:: frame_sizes_offset())); 159 160 // Counter 161 __ movl(rdx, Address(rdi, Deoptimization::UnrollBlock:: number_of_frames_offset())); // (int) 162 163 // Now adjust the caller's stack to make up for the extra locals but 164 // record the original sp so that we can save it in the skeletal 165 // interpreter frame and the stack walking of interpreter_sender 166 // will get the unextended sp value and not the "real" sp value. 167 168 const Register sender_sp = r8; 169 170 __ mov(sender_sp, rsp); 171 __ movl(rbx, Address(rdi, Deoptimization::UnrollBlock:: caller_adjustment_offset())); // (int) 172 __ subptr(rsp, rbx); 173 174 // Push interpreter frames in a loop 175 Label loop; 176 __ bind(loop); 177 __ movptr(rbx, Address(rsi, 0)); // Load frame size 178 __ subptr(rbx, 2 * wordSize); // We'll push pc and rbp by hand 179 __ pushptr(Address(rcx, 0)); // Save return address 180 __ enter(); // Save old & set new rbp 181 __ subptr(rsp, rbx); // Prolog 182 __ movptr(Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize), 183 sender_sp); // Make it walkable 184 // This value is corrected by layout_activation_impl 185 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD); 186 __ mov(sender_sp, rsp); // Pass sender_sp to next frame 187 __ addptr(rsi, wordSize); // Bump array pointer (sizes) 188 __ addptr(rcx, wordSize); // Bump array pointer (pcs) 189 __ decrementl(rdx); // Decrement counter 190 __ jcc(Assembler::notZero, loop); 191 __ pushptr(Address(rcx, 0)); // Save final return address 192 193 // Re-push self-frame 194 __ enter(); // Save old & set new rbp 195 __ subptr(rsp, (SimpleRuntimeFrame::framesize - 4) << LogBytesPerInt); 196 // Prolog 197 198 // Use rbp because the frames look interpreted now 199 // Save "the_pc" since it cannot easily be retrieved using the last_java_SP after we aligned SP. 200 // Don't need the precise return PC here, just precise enough to point into this code blob. 201 address the_pc = __ pc(); 202 __ set_last_Java_frame(noreg, rbp, the_pc, rscratch1); 203 204 // Call C code. Need thread but NOT official VM entry 205 // crud. We cannot block on this call, no GC can happen. Call should 206 // restore return values to their stack-slots with the new SP. 207 // Thread is in rdi already. 208 // 209 // BasicType unpack_frames(JavaThread* thread, int exec_mode); 210 211 __ andptr(rsp, -(StackAlignmentInBytes)); // Align SP as required by ABI 212 __ mov(c_rarg0, r15_thread); 213 __ movl(c_rarg1, Deoptimization::Unpack_uncommon_trap); 214 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::unpack_frames))); 215 216 // Set an oopmap for the call site 217 // Use the same PC we used for the last java frame 218 oop_maps->add_gc_map(the_pc - start, new OopMap(SimpleRuntimeFrame::framesize, 0)); 219 220 // Clear fp AND pc 221 __ reset_last_Java_frame(true); 222 223 // Pop self-frame. 224 __ leave(); // Epilog 225 226 // Jump to interpreter 227 __ ret(0); 228 229 // Make sure all code is generated 230 masm->flush(); 231 232 return UncommonTrapBlob::create(&buffer, oop_maps, 233 SimpleRuntimeFrame::framesize >> 1); 234 } 235 236 //------------------------------generate_exception_blob--------------------------- 237 // creates exception blob at the end 238 // Using exception blob, this code is jumped from a compiled method. 239 // (see emit_exception_handler in x86_64.ad file) 240 // 241 // Given an exception pc at a call we call into the runtime for the 242 // handler in this method. This handler might merely restore state 243 // (i.e. callee save registers) unwind the frame and jump to the 244 // exception handler for the nmethod if there is no Java level handler 245 // for the nmethod. 246 // 247 // This code is entered with a jmp. 248 // 249 // Arguments: 250 // rax: exception oop 251 // rdx: exception pc 252 // 253 // Results: 254 // rax: exception oop 255 // rdx: exception pc in caller or ??? 256 // destination: exception handler of caller 257 // 258 // Note: the exception pc MUST be at a call (precise debug information) 259 // Registers rax, rdx, rcx, rsi, rdi, r8-r11 are not callee saved. 260 // 261 262 ExceptionBlob* OptoRuntime::generate_exception_blob() { 263 assert(!OptoRuntime::is_callee_saved_register(RDX_num), ""); 264 assert(!OptoRuntime::is_callee_saved_register(RAX_num), ""); 265 assert(!OptoRuntime::is_callee_saved_register(RCX_num), ""); 266 267 assert(SimpleRuntimeFrame::framesize % 4 == 0, "sp not 16-byte aligned"); 268 269 // Allocate space for the code 270 ResourceMark rm; 271 // Setup code generation tools 272 const char* name = OptoRuntime::stub_name(OptoStubId::exception_id); 273 CodeBuffer buffer(name, 2048, 1024); 274 if (buffer.blob() == nullptr) { 275 return nullptr; 276 } 277 278 int pc_offset = 0; 279 if (AOTCodeCache::load_exception_blob(&buffer, &pc_offset)) { 280 OopMapSet* oop_maps = new OopMapSet(); 281 oop_maps->add_gc_map(pc_offset, new OopMap(SimpleRuntimeFrame::framesize, 0)); 282 283 // Set exception blob 284 _exception_blob = ExceptionBlob::create(&buffer, oop_maps, SimpleRuntimeFrame::framesize >> 1); 285 return _exception_blob; 286 } 287 288 MacroAssembler* masm = new MacroAssembler(&buffer); 289 address start = __ pc(); 290 291 // Exception pc is 'return address' for stack walker 292 __ push(rdx); 293 __ subptr(rsp, SimpleRuntimeFrame::return_off << LogBytesPerInt); // Prolog 294 295 // Save callee-saved registers. See x86_64.ad. 296 297 // rbp is an implicitly saved callee saved register (i.e., the calling 298 // convention will save/restore it in the prolog/epilog). Other than that 299 // there are no callee save registers now that adapter frames are gone. 300 301 __ movptr(Address(rsp, SimpleRuntimeFrame::rbp_off << LogBytesPerInt), rbp); 302 303 // Store exception in Thread object. We cannot pass any arguments to the 304 // handle_exception call, since we do not want to make any assumption 305 // about the size of the frame where the exception happened in. 306 // c_rarg0 is either rdi (Linux) or rcx (Windows). 307 __ movptr(Address(r15_thread, JavaThread::exception_oop_offset()),rax); 308 __ movptr(Address(r15_thread, JavaThread::exception_pc_offset()), rdx); 309 310 // This call does all the hard work. It checks if an exception handler 311 // exists in the method. 312 // If so, it returns the handler address. 313 // If not, it prepares for stack-unwinding, restoring the callee-save 314 // registers of the frame being removed. 315 // 316 // address OptoRuntime::handle_exception_C(JavaThread* thread) 317 318 // At a method handle call, the stack may not be properly aligned 319 // when returning with an exception. 320 address the_pc = __ pc(); 321 __ set_last_Java_frame(noreg, noreg, the_pc, rscratch1); 322 __ mov(c_rarg0, r15_thread); 323 __ andptr(rsp, -(StackAlignmentInBytes)); // Align stack 324 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, OptoRuntime::handle_exception_C))); 325 326 // Set an oopmap for the call site. This oopmap will only be used if we 327 // are unwinding the stack. Hence, all locations will be dead. 328 // Callee-saved registers will be the same as the frame above (i.e., 329 // handle_exception_stub), since they were restored when we got the 330 // exception. 331 332 OopMapSet* oop_maps = new OopMapSet(); 333 334 pc_offset = the_pc - start; 335 oop_maps->add_gc_map(pc_offset, new OopMap(SimpleRuntimeFrame::framesize, 0)); 336 337 __ reset_last_Java_frame(false); 338 339 // Restore callee-saved registers 340 341 // rbp is an implicitly saved callee-saved register (i.e., the calling 342 // convention will save restore it in prolog/epilog) Other than that 343 // there are no callee save registers now that adapter frames are gone. 344 345 __ movptr(rbp, Address(rsp, SimpleRuntimeFrame::rbp_off << LogBytesPerInt)); 346 347 __ addptr(rsp, SimpleRuntimeFrame::return_off << LogBytesPerInt); // Epilog 348 __ pop(rdx); // No need for exception pc anymore 349 350 // rax: exception handler 351 352 // We have a handler in rax (could be deopt blob). 353 __ mov(r8, rax); 354 355 // Get the exception oop 356 __ movptr(rax, Address(r15_thread, JavaThread::exception_oop_offset())); 357 // Get the exception pc in case we are deoptimized 358 __ movptr(rdx, Address(r15_thread, JavaThread::exception_pc_offset())); 359 #ifdef ASSERT 360 __ movptr(Address(r15_thread, JavaThread::exception_handler_pc_offset()), NULL_WORD); 361 __ movptr(Address(r15_thread, JavaThread::exception_pc_offset()), NULL_WORD); 362 #endif 363 // Clear the exception oop so GC no longer processes it as a root. 364 __ movptr(Address(r15_thread, JavaThread::exception_oop_offset()), NULL_WORD); 365 366 // rax: exception oop 367 // r8: exception handler 368 // rdx: exception pc 369 // Jump to handler 370 371 __ jmp(r8); 372 373 // Make sure all code is generated 374 masm->flush(); 375 376 AOTCodeCache::store_exception_blob(&buffer, pc_offset); 377 // Set exception blob 378 return ExceptionBlob::create(&buffer, oop_maps, SimpleRuntimeFrame::framesize >> 1); 379 } 380 #endif // COMPILER2