1 /*
  2  * Copyright (c) 2019, 2021, 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 CPU_S390_CONTINUATION_S390_INLINE_HPP
 26 #define CPU_S390_CONTINUATION_S390_INLINE_HPP
 27 
 28 #include "oops/instanceStackChunkKlass.inline.hpp"
 29 #include "runtime/frame.hpp"
 30 #include "runtime/frame.inline.hpp"
 31 
 32 // TODO: Implement
 33 const int ContinuationHelper::frame_metadata = 0;
 34 const int ContinuationHelper::align_wiggle = 0;
 35 
 36 #ifdef ASSERT
 37 bool Frame::assert_frame_laid_out(frame f) {
 38   Unimplemented();
 39   return false;
 40 }
 41 #endif
 42 
 43 inline intptr_t** Frame::callee_link_address(const frame& f) {
 44   Unimplemented();
 45   return NULL;
 46 }
 47 
 48 template<typename FKind>
 49 static inline intptr_t* real_fp(const frame& f) {
 50   Unimplemented();
 51   return NULL;
 52 }
 53 
 54 template<typename FKind> // TODO: maybe do the same CRTP trick with Interpreted and Compiled as with hframe
 55 static inline intptr_t** link_address(const frame& f) {
 56   Unimplemented();
 57   return NULL;
 58 }
 59 
 60 inline address* Interpreted::return_pc_address(const frame& f) {
 61   Unimplemented();
 62   return NULL;
 63 }
 64 
 65 template <bool relative>
 66 void Interpreted::patch_sender_sp(frame& f, intptr_t* sp) {
 67   Unimplemented();
 68 }
 69 
 70 inline address* Frame::return_pc_address(const frame& f) {
 71   Unimplemented();
 72   return NULL;
 73 }
 74 
 75 inline address Frame::real_pc(const frame& f) {
 76   Unimplemented();
 77   return NULL;
 78 }
 79 
 80 inline void Frame::patch_pc(const frame& f, address pc) {
 81   Unimplemented();
 82 }
 83 
 84 inline intptr_t* Interpreted::frame_top(const frame& f, InterpreterOopMap* mask) { // inclusive; this will be copied with the frame
 85   Unimplemented();
 86   return NULL;
 87 }
 88 
 89 template <bool relative>
 90 inline intptr_t* Interpreted::frame_bottom(const frame& f) { // exclusive; this will not be copied with the frame
 91   Unimplemented();
 92   return NULL;
 93 }
 94 
 95 inline intptr_t* Interpreted::frame_top(const frame& f, int callee_argsize, bool callee_interpreted) {
 96   Unimplemented();
 97   return NULL;
 98 }
 99 
100 template<typename FKind, typename RegisterMapT>
101 inline void ContinuationHelper::update_register_map(RegisterMapT* map, const frame& f) {
102   Unimplemented();
103 }
104 
105 template<typename RegisterMapT>
106 inline void ContinuationHelper::update_register_map_with_callee(RegisterMapT* map, const frame& f) {
107   Unimplemented();
108 }
109 
110 inline void ContinuationHelper::push_pd(const frame& f) {
111   Unimplemented();
112 }
113 
114 // creates the yield stub frame faster than JavaThread::last_frame
115 inline frame ContinuationHelper::last_frame(JavaThread* thread) {
116   Unimplemented();
117   return frame();
118 }
119 
120 frame ContinuationEntry::to_frame() {
121   Unimplemented();
122   return frame();
123 }
124 
125 void ContinuationEntry::update_register_map(RegisterMap* map) {
126   Unimplemented();
127 }
128 
129 void ContinuationHelper::set_anchor_to_entry_pd(JavaFrameAnchor* anchor, ContinuationEntry* cont) {
130   Unimplemented();
131 }
132 
133 void ContinuationHelper::set_anchor_pd(JavaFrameAnchor* anchor, intptr_t* sp) {
134   Unimplemented();
135 }
136 
137 template <typename ConfigT>
138 inline void Freeze<ConfigT>::set_top_frame_metadata_pd(const frame& hf) {
139   Unimplemented();
140 }
141 
142 template <typename ConfigT>
143 inline intptr_t* Freeze<ConfigT>::align_bottom(intptr_t* bottom, int argsize) {
144   Unimplemented();
145   return NULL;
146 }
147 
148 template <typename ConfigT>
149 template<typename FKind>
150 inline frame Freeze<ConfigT>::sender(const frame& f) {
151   Unimplemented();
152   return frame();
153 }
154 
155 template <typename ConfigT>
156 template<typename FKind> frame Freeze<ConfigT>::new_hframe(frame& f, frame& caller) {
157   Unimplemented();
158   return frame();
159 }
160 
161 template <typename ConfigT>
162 inline void Freeze<ConfigT>::relativize_interpreted_frame_metadata(const frame& f, const frame& hf) {
163   Unimplemented();
164 }
165 
166 template <typename ConfigT>
167 template <typename FKind, bool bottom>
168 inline void Freeze<ConfigT>::patch_pd(frame& hf, const frame& caller) {
169   Unimplemented();
170 }
171 
172 template <typename ConfigT>
173 inline void Freeze<ConfigT>::patch_chunk_pd(intptr_t* vsp, intptr_t* hsp) {
174   Unimplemented();
175 }
176 
177 template <typename ConfigT>
178 inline frame Thaw<ConfigT>::new_entry_frame() {
179   Unimplemented();
180   return frame();
181 }
182 
183 template <typename ConfigT>
184 template<typename FKind> frame Thaw<ConfigT>::new_frame(const frame& hf, frame& caller, bool bottom) {
185   Unimplemented();
186   return frame();
187 }
188 
189 template <typename ConfigT>
190 inline void Thaw<ConfigT>::set_interpreter_frame_bottom(const frame& f, intptr_t* bottom) {
191   Unimplemented();
192 }
193 
194 template <typename ConfigT>
195 inline void Thaw<ConfigT>::derelativize_interpreted_frame_metadata(const frame& hf, const frame& f) {
196   Unimplemented();
197 }
198 
199 template <typename ConfigT>
200 inline intptr_t* Thaw<ConfigT>::align(const frame& hf, intptr_t* vsp, frame& caller, bool bottom) {
201   Unimplemented();
202   return NULL;
203 }
204 
205 template <typename ConfigT>
206 template<typename FKind, bool bottom>
207 inline void Thaw<ConfigT>::patch_pd(frame& f, const frame& caller) {
208   Unimplemented();
209 }
210 
211 template <typename ConfigT>
212 intptr_t* Thaw<ConfigT>::push_interpreter_return_frame(intptr_t* sp) {
213   Unimplemented();
214   return NULL;
215 }
216 
217 template <typename ConfigT>
218 void Thaw<ConfigT>::patch_chunk_pd(intptr_t* sp) {
219   Unimplemented();
220 }
221 
222 template <typename ConfigT>
223 inline void Thaw<ConfigT>::prefetch_chunk_pd(void* start, int size) {
224   Unimplemented();
225 }
226 
227 template <typename ConfigT>
228 inline intptr_t* Thaw<ConfigT>::align_chunk(intptr_t* vsp) {
229   Unimplemented();
230   return NULL;
231 }
232 
233 #endif // CPU_S390_CONTINUATION_S390_INLINE_HPP