1 /* 2 * Copyright (c) 2022, 2023, 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 #ifndef SHARE_VM_RUNTIME_CONTINUATIONHELPER_HPP 26 #define SHARE_VM_RUNTIME_CONTINUATIONHELPER_HPP 27 28 #include "code/scopeDesc.hpp" 29 #include "compiler/oopMap.hpp" 30 #include "memory/allStatic.hpp" 31 #include "runtime/frame.hpp" 32 #include "runtime/stackValue.hpp" 33 34 // Helper, all-static 35 class ContinuationEntry; 36 37 class ContinuationHelper { 38 public: 39 static inline void set_anchor_pd(JavaFrameAnchor* anchor, intptr_t* sp); 40 static inline void set_anchor_to_entry_pd(JavaFrameAnchor* anchor, ContinuationEntry* entry); 41 42 template<typename FKind> static void update_register_map(const frame& f, RegisterMap* map); 43 static inline void update_register_map_with_callee(const frame& f, RegisterMap* map); 44 45 static inline void push_pd(const frame& f); 46 47 static inline address return_address_at(intptr_t* sp); 48 static inline void patch_return_address_at(intptr_t* sp, address pc); 49 50 static inline int frame_align_words(int size); 51 static inline intptr_t* frame_align_pointer(intptr_t* sp); 52 53 // Abstract helpers for describing frames in general 54 class Frame; 55 class NonInterpretedFrame; 56 57 // Concrete helpers for describing concrete types of frames 58 class InterpretedFrame; 59 class NonInterpretedUnknownFrame; 60 class CompiledFrame; 61 class NativeFrame; 62 class StubFrame; 63 }; 64 65 class ContinuationHelper::Frame : public AllStatic { 66 public: 67 static const bool interpreted = false; 68 static const bool stub = false; 69 static const bool native = false; 70 71 static inline intptr_t** callee_link_address(const frame& f); 72 static Method* frame_method(const frame& f); 73 static inline address real_pc(const frame& f); 74 static inline void patch_pc(const frame& f, address pc); 75 static address* return_pc_address(const frame& f); 76 static address return_pc(const frame& f); 77 static bool is_stub(CodeBlob* cb); 78 79 #ifdef ASSERT 80 static inline intptr_t* frame_top(const frame &f); 81 static inline bool is_deopt_return(address pc, const frame& sender); 82 static bool assert_frame_laid_out(frame f); 83 #endif 84 }; 85 86 class ContinuationHelper::InterpretedFrame : public ContinuationHelper::Frame { 87 public: 88 static const bool interpreted = true; 89 90 static inline intptr_t* frame_top(const frame& f, InterpreterOopMap* mask); 91 static inline intptr_t* frame_top(const frame& f); 92 static inline intptr_t* frame_top(const frame& f, int callee_argsize, bool callee_interpreted); 93 static inline intptr_t* frame_bottom(const frame& f); 94 static inline intptr_t* callers_sp(const frame& f); 95 static inline int stack_argsize(const frame& f); 96 97 static inline address* return_pc_address(const frame& f); 98 static address return_pc(const frame& f); 99 static void patch_sender_sp(frame& f, const frame& caller); 100 101 static int size(const frame& f); 102 static inline int expression_stack_size(const frame &f, InterpreterOopMap* mask); 103 104 static int monitors_to_fix(JavaThread* thread, const frame& f, ResourceHashtable<oopDesc*, bool> &table, stackChunkOop chunk) NOT_DEBUG_RETURN0; 105 106 static bool is_instance(const frame& f); 107 108 typedef InterpreterOopMap* ExtraT; 109 }; 110 111 class ContinuationHelper::NonInterpretedFrame : public ContinuationHelper::Frame { 112 public: 113 static inline intptr_t* frame_top(const frame& f, int callee_argsize, bool callee_interpreted); 114 static inline intptr_t* frame_top(const frame& f); 115 static inline intptr_t* frame_bottom(const frame& f); 116 117 static inline int size(const frame& f); 118 static inline int stack_argsize(const frame& f); 119 }; 120 121 class ContinuationHelper::NonInterpretedUnknownFrame : public ContinuationHelper::NonInterpretedFrame { 122 public: 123 static bool is_instance(const frame& f); 124 }; 125 126 class ContinuationHelper::CompiledFrame : public ContinuationHelper::NonInterpretedFrame { 127 public: 128 static bool is_instance(const frame& f); 129 130 template <typename RegisterMapT> 131 static int monitors_to_fix(JavaThread* thread, RegisterMapT* map, const frame& f, ResourceHashtable<oopDesc*, bool> &table) NOT_DEBUG_RETURN0; 132 }; 133 134 class ContinuationHelper::NativeFrame : public ContinuationHelper::NonInterpretedFrame { 135 public: 136 static const bool native = true; 137 138 static bool is_instance(const frame& f); 139 140 static int monitors_to_fix(JavaThread* thread, const frame& f, ResourceHashtable<oopDesc*, bool> &table) NOT_DEBUG_RETURN0; 141 static int stack_argsize(const frame& f) { return 0; } 142 }; 143 144 class ContinuationHelper::StubFrame : public ContinuationHelper::NonInterpretedFrame { 145 public: 146 static const bool stub = true; 147 148 static bool is_instance(const frame& f); 149 static int stack_argsize(const frame& f) { return 0; } 150 }; 151 152 #endif // SHARE_VM_RUNTIME_CONTINUATIONHELPER_HPP