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