1 /*
  2  * Copyright (c) 2022, 2024, 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_ARM_CONTINUATIONHELPER_ARM_INLINE_HPP
 26 #define CPU_ARM_CONTINUATIONHELPER_ARM_INLINE_HPP
 27 
 28 #include "runtime/continuationHelper.hpp"
 29 
 30 // TODO: Implement
 31 
 32 template<typename FKind>
 33 static inline intptr_t** link_address(const frame& f) {
 34   Unimplemented();
 35   return nullptr;
 36 }
 37 
 38 static inline void patch_return_pc_with_preempt_stub(frame& f) {
 39   Unimplemented();
 40 }
 41 
 42 inline int ContinuationHelper::frame_align_words(int size) {
 43   Unimplemented();
 44   return 0;
 45 }
 46 
 47 inline intptr_t* ContinuationHelper::frame_align_pointer(intptr_t* sp) {
 48   Unimplemented();
 49   return nullptr;
 50 }
 51 
 52 template<typename FKind>
 53 inline void ContinuationHelper::update_register_map(const frame& f, RegisterMap* map) {
 54   Unimplemented();
 55 }
 56 
 57 inline void ContinuationHelper::update_register_map_with_callee(const frame& f, RegisterMap* map) {
 58   Unimplemented();
 59 }
 60 
 61 inline void ContinuationHelper::push_pd(const frame& f) {
 62   Unimplemented();
 63 }
 64 
 65 inline void ContinuationHelper::set_anchor_to_entry_pd(JavaFrameAnchor* anchor, ContinuationEntry* cont) {
 66   Unimplemented();
 67 }
 68 
 69 inline void ContinuationHelper::set_anchor_pd(JavaFrameAnchor* anchor, intptr_t* sp) {
 70   Unimplemented();
 71 }
 72 
 73 #ifdef ASSERT
 74 inline bool ContinuationHelper::Frame::assert_frame_laid_out(frame f) {
 75   Unimplemented();
 76   return false;
 77 }
 78 #endif
 79 
 80 inline intptr_t** ContinuationHelper::Frame::callee_link_address(const frame& f) {
 81   Unimplemented();
 82   return nullptr;
 83 }
 84 
 85 template<typename FKind>
 86 static inline intptr_t* real_fp(const frame& f) {
 87   Unimplemented();
 88   return nullptr;
 89 }
 90 
 91 inline address* ContinuationHelper::InterpretedFrame::return_pc_address(const frame& f) {
 92   Unimplemented();
 93   return nullptr;
 94 }
 95 
 96 inline void ContinuationHelper::InterpretedFrame::patch_sender_sp(frame& f, const frame& caller) {
 97   Unimplemented();
 98 }
 99 
100 inline address* ContinuationHelper::Frame::return_pc_address(const frame& f) {
101   Unimplemented();
102   return nullptr;
103 }
104 
105 inline address ContinuationHelper::Frame::real_pc(const frame& f) {
106   Unimplemented();
107   return nullptr;
108 }
109 
110 inline void ContinuationHelper::Frame::patch_pc(const frame& f, address pc) {
111   Unimplemented();
112 }
113 
114 inline intptr_t* ContinuationHelper::InterpretedFrame::frame_top(const frame& f, InterpreterOopMap* mask) { // inclusive; this will be copied with the frame
115   Unimplemented();
116   return nullptr;
117 }
118 
119 inline intptr_t* ContinuationHelper::InterpretedFrame::frame_bottom(const frame& f) { // exclusive; this will not be copied with the frame
120   Unimplemented();
121   return nullptr;
122 }
123 
124 inline intptr_t* ContinuationHelper::InterpretedFrame::frame_top(const frame& f, int callee_argsize, bool callee_interpreted) {
125   Unimplemented();
126   return nullptr;
127 }
128 
129 inline intptr_t* ContinuationHelper::InterpretedFrame::callers_sp(const frame& f) {
130   Unimplemented();
131   return nullptr;
132 }
133 
134 #endif // CPU_ARM_CONTINUATIONHELPER_ARM_INLINE_HPP