| /* | |
| * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| * | |
| */ | |
| #ifndef CPU_PPC_STACKCHUNKFRAMESTREAM_PPC_INLINE_HPP | |
| #define CPU_PPC_STACKCHUNKFRAMESTREAM_PPC_INLINE_HPP | |
| #include "interpreter/oopMapCache.hpp" | |
| #include "runtime/frame.inline.hpp" | |
| #include "runtime/registerMap.hpp" | |
| #ifdef ASSERT | |
| template <ChunkFrames frame_kind> | |
| inline bool StackChunkFrameStream<frame_kind>::is_in_frame(void* p0) const { | |
| assert(!is_done(), ""); | |
| assert(is_compiled(), ""); | |
| intptr_t* p = (intptr_t*)p0; | |
| int argsize = (_cb->as_nmethod()->num_stack_arg_slots() * VMRegImpl::stack_slot_size) >> LogBytesPerWord; | |
| int frame_size = _cb->frame_size() + (argsize > 0 ? argsize + frame::metadata_words_at_top : 0); | |
| return (p - unextended_sp()) >= 0 && (p - unextended_sp()) < frame_size; | |
| } | |
| #endif | |
| template <ChunkFrames frame_kind> | |
| inline frame StackChunkFrameStream<frame_kind>::to_frame() const { | |
| if (is_done()) { | |
| return frame(_sp, _sp, nullptr, nullptr, nullptr, nullptr, true); | |
| } else { | |
| // Compiled frames on heap don't have back links. See FreezeBase::patch_pd() and frame::setup(). | |
| return frame(sp(), unextended_sp(), Interpreter::contains(pc()) ? fp() : nullptr, pc(), cb(), _oopmap, true); | |
| } | |
| } | |
| template <ChunkFrames frame_kind> | |
| inline address StackChunkFrameStream<frame_kind>::get_pc() const { | |
| assert(!is_done(), ""); | |
| return (address)((frame::common_abi*) _sp)->lr; | |
| } | |
| template <ChunkFrames frame_kind> | |
| inline intptr_t* StackChunkFrameStream<frame_kind>::fp() const { | |
| // See FreezeBase::patch_pd() and frame::setup() | |
| assert((frame_kind == ChunkFrames::Mixed && is_interpreted()), ""); | |
| intptr_t* fp_addr = (intptr_t*)&((frame::common_abi*)_sp)->callers_sp; | |
| assert(*(intptr_t**)fp_addr != nullptr, ""); | |
| // derelativize | |
| return fp_addr + *fp_addr; | |
| } | |
| template <ChunkFrames frame_kind> | |
| inline intptr_t* StackChunkFrameStream<frame_kind>::derelativize(int offset) const { | |
| intptr_t* fp = this->fp(); | |
| assert(fp != nullptr, ""); | |
| return fp + fp[offset]; | |
| } | |
| template <ChunkFrames frame_kind> | |
| inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interpreter_frame() const { | |
| assert_is_interpreted_and_frame_type_mixed(); | |
| return derelativize(ijava_idx(esp)) + 1 - frame::metadata_words; // On PPC esp points to the next free slot | |
| } | |
| template <ChunkFrames frame_kind> | |
| inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() { | |
| assert_is_interpreted_and_frame_type_mixed(); | |
| if (derelativize(ijava_idx(locals)) + 1 >= _end) { | |
| _unextended_sp = _end; | |
| _sp = _end; | |
| } else { | |
| _unextended_sp = derelativize(ijava_idx(sender_sp)); | |
| _sp = this->fp(); | |
| } | |
| } | |
| // Details for the comment on StackChunkFrameStream<frame_kind>::frame_size() | |
| // | |
| // Interpreted caller frames get extended even if the callee is also | |
| // interpreted. This is done to accomodate non-parameter locals. | |
| // | |
| // The size of a single frame is from the unextended sp to the bottom of the | |
| // locals array. The combined size of caller/callee is the single size with the | |
| // overlap deducted. The overlap is the size of the call parameters plus the | |
| // size of the metadata at the sp (frame::metadata_words_at_top). | |
| // | |
| // | |
| // Case 1: no metadata between a frame Case 2: metadata is located between | |
| // and its locals a frame and its locals as on ppc64 | |
| // | |
| // | | L0 aka P0 | | | L0 aka P0 | | |
| // | | : : | | | : : | | |
| // | | : Pn | | | : Pn | | |
| // | | : | | | : | | |
| // | | Lm | | | Lm | | |
| // | ======================== | |----------------------| | |
| // S0 | | Frame F0 | | | Metadata@top | | |
| // | | | S0 | | | | |
| // | | | | | | | |
| // | |----------------------| | | | | |
| // || | L0 aka P0 | | ======================== | |
| // over- || | : : | | | Frame F0 | | |
| // lap || | : Pn |<- unext. SP | | | | |
| // | | : | | | |<- bottom_of_locals | |
| // | | Lm |<- SP | |----------------------| | |
| // | ======================== || | L0 aka P0 | | |
| // | | Frame F1 | || | : : | | |
| // S1 | | | over- || | : Pn |<- unext. SP | |
| // | | | lap || | : | + metadata_words_at_top | |
| // | |----------------------| || | Lm | | |
| // | | L0 aka P0 | || |----------------------| | |
| // | | : : | || | Metadata@top | | |
| // | | : Pn |<- unext. SP || | |<- unextended SP | |
| // | : | | | | | |
| // | Lm |<- SP | | |<- SP | |
| // ======================== | ======================== | |
| // | | Frame F1 | | |
| // | | | | |
| // | | | | |
| // | |----------------------| | |
| // overlap = size of stackargs S1 | | L0 aka P0 | | |
| // | | : : | | |
| // | | : Pn |<- unext. SP | |
| // | | : | + metadata_words_at_top | |
| // | | Lm | | |
| // | |----------------------| | |
| // | | Metadata@top | | |
| // | | |<- unextended SP | |
| // | | | |
| // | |<- SP | |
| // ======================== | |
| // | |
| // sizeof(Metadata@top) = frame::metadata_words_at_top | |
| // bottom_of_locals = unext. sp + sizeof(Metadata@top) + stackargs | |
| // overlap = bottom_of_locals - unext. sp | |
| // = stackargs + sizeof(Metadata@top) | |
| template <ChunkFrames frame_kind> | |
| inline int StackChunkFrameStream<frame_kind>::interpreter_frame_size() const { | |
| assert_is_interpreted_and_frame_type_mixed(); | |
| intptr_t* top = unextended_sp(); // later subtract argsize if callee is interpreted | |
| intptr_t* bottom = derelativize(ijava_idx(locals)) + 1; | |
| return (int)(bottom - top); | |
| } | |
| // Size of stack args in words (P0..Pn above). Only valid if the caller is also | |
| // interpreted. The function is also called if the caller is compiled but the | |
| // result is not used in that case (same on x86). | |
| // See also setting of sender_sp in ContinuationHelper::InterpretedFrame::patch_sender_sp() | |
| template <ChunkFrames frame_kind> | |
| inline int StackChunkFrameStream<frame_kind>::interpreter_frame_stack_argsize() const { | |
| assert_is_interpreted_and_frame_type_mixed(); | |
| frame::ijava_state* state = (frame::ijava_state*)((uintptr_t)fp() - frame::ijava_state_size); | |
| int diff = (int)(state->locals - (state->sender_sp + frame::metadata_words_at_top) + 1); | |
| assert(diff == -frame::metadata_words_at_top || ((Method*)state->method)->size_of_parameters() == diff, | |
| "size_of_parameters(): %d diff: %d sp: " PTR_FORMAT " fp:" PTR_FORMAT, | |
| ((Method*)state->method)->size_of_parameters(), diff, p2i(sp()), p2i(fp())); | |
| return diff; | |
| } | |
| template <ChunkFrames frame_kind> | |
| inline int StackChunkFrameStream<frame_kind>::interpreter_frame_num_oops() const { | |
| assert_is_interpreted_and_frame_type_mixed(); | |
| ResourceMark rm; | |
| InterpreterOopMap mask; | |
| frame f = to_frame(); | |
| f.interpreted_frame_oop_map(&mask); | |
| return mask.num_oops() | |
| + 1 // for the mirror oop | |
| + (f.interpreter_frame_method()->is_native() ? 1 : 0) // temp oop slot | |
| + pointer_delta_as_int((intptr_t*)f.interpreter_frame_monitor_begin(), | |
| (intptr_t*)f.interpreter_frame_monitor_end())/BasicObjectLock::size(); | |
| } | |
| template<> | |
| template<> | |
| inline void StackChunkFrameStream<ChunkFrames::Mixed>::update_reg_map_pd(RegisterMap* map) { | |
| // Nothing to do (no non-volatile registers in java calling convention) | |
| } | |
| template<> | |
| template<> | |
| inline void StackChunkFrameStream<ChunkFrames::CompiledOnly>::update_reg_map_pd(RegisterMap* map) { | |
| // Nothing to do (no non-volatile registers in java calling convention) | |
| } | |
| template <ChunkFrames frame_kind> | |
| template <typename RegisterMapT> | |
| inline void StackChunkFrameStream<frame_kind>::update_reg_map_pd(RegisterMapT* map) {} | |
| #endif // CPU_PPC_STACKCHUNKFRAMESTREAM_PPC_INLINE_HPP |