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