Loom: PPC64, S390, ARM32, Zero stubs

Reviewed-by: rpressler

Author: shipilev

src/hotspot/cpu/aarch64/continuation_aarch64.inline.hpp

@@ -35,7 +35,7 @@ const int ContinuationHelper::align_wiggle = 1;
 #ifdef ASSERT
 bool Frame::assert_frame_laid_out(frame f) {
   intptr_t* sp = f.sp();
-  address pc = *(address*)(sp - SENDER_SP_RET_ADDRESS_OFFSET);
+  address pc = *(address*)(sp - frame::sender_sp_ret_address_offset());
   intptr_t* fp = *(intptr_t**)(sp - frame::sender_sp_offset);
   assert (f.raw_pc() == pc, "f.ra_pc: " INTPTR_FORMAT " actual: " INTPTR_FORMAT, p2i(f.raw_pc()), p2i(pc));
   assert (f.fp() == fp, "f.fp: " INTPTR_FORMAT " actual: " INTPTR_FORMAT, p2i(f.fp()), p2i(fp));
@@ -418,7 +418,7 @@ intptr_t* Thaw<ConfigT>::push_interpreter_return_frame(intptr_t* sp) {
   assert((intptr_t)sp % 16 == 0, "");
 
   sp -= ContinuationHelper::frame_metadata;
-  *(address*)(sp - SENDER_SP_RET_ADDRESS_OFFSET) = pc;
+  *(address*)(sp - frame::sender_sp_ret_address_offset()) = pc;
   *(intptr_t**)(sp - frame::sender_sp_offset) = fp;
   return sp;
 }

src/hotspot/cpu/aarch64/frame_aarch64.inline.hpp

@@ -399,6 +399,10 @@ inline bool frame::is_interpreted_frame() const {
   return Interpreter::contains(pc());
 }
 
+inline int frame::sender_sp_ret_address_offset() {
+  return frame::sender_sp_offset - frame::return_addr_offset;
+}
+
 inline const ImmutableOopMap* frame::get_oop_map() const {
   if (_cb == NULL) return NULL;
   if (_cb->oop_maps() != NULL) {

src/hotspot/cpu/arm/c1_LIRGenerator_arm.cpp

@@ -1327,3 +1327,7 @@ void LIRGenerator::volatile_field_load(LIR_Address* address, LIR_Opr result,
   }
   __ load(address, result, info, lir_patch_none);
 }
+
+void LIRGenerator::do_continuation_doYield(Intrinsic* x) {
+  fatal("Continuation.doYield intrinsic is not implemented on this platform");
+}

src/hotspot/cpu/arm/continuation_arm.inline.hpp

@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2019, 2021 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_ARM_CONTINUATION_ARM_INLINE_HPP
+#define CPU_ARM_CONTINUATION_ARM_INLINE_HPP
+
+#include "oops/instanceStackChunkKlass.inline.hpp"
+#include "runtime/frame.hpp"
+#include "runtime/frame.inline.hpp"
+
+// TODO: Implement
+const int ContinuationHelper::frame_metadata = 0;
+const int ContinuationHelper::align_wiggle = 0;
+
+#ifdef ASSERT
+bool Frame::assert_frame_laid_out(frame f) {
+  Unimplemented();
+  return false;
+}
+#endif
+
+inline intptr_t** Frame::callee_link_address(const frame& f) {
+  Unimplemented();
+  return NULL;
+}
+
+template<typename FKind>
+static inline intptr_t* real_fp(const frame& f) {
+  Unimplemented();
+  return NULL;
+}
+
+template<typename FKind> // TODO: maybe do the same CRTP trick with Interpreted and Compiled as with hframe
+static inline intptr_t** link_address(const frame& f) {
+  Unimplemented();
+  return NULL;
+}
+
+inline address* Interpreted::return_pc_address(const frame& f) {
+  Unimplemented();
+  return NULL;
+}
+
+template <bool relative>
+void Interpreted::patch_sender_sp(frame& f, intptr_t* sp) {
+  Unimplemented();
+}
+
+inline address* Frame::return_pc_address(const frame& f) {
+  Unimplemented();
+  return NULL;
+}
+
+inline address Frame::real_pc(const frame& f) {
+  Unimplemented();
+  return NULL;
+}
+
+inline void Frame::patch_pc(const frame& f, address pc) {
+  Unimplemented();
+}
+
+inline intptr_t* Interpreted::frame_top(const frame& f, InterpreterOopMap* mask) { // inclusive; this will be copied with the frame
+  Unimplemented();
+  return NULL;
+}
+
+template <bool relative>
+inline intptr_t* Interpreted::frame_bottom(const frame& f) { // exclusive; this will not be copied with the frame
+  Unimplemented();
+  return NULL;
+}
+
+inline intptr_t* Interpreted::frame_top(const frame& f, int callee_argsize, bool callee_interpreted) {
+  Unimplemented();
+  return NULL;
+}
+
+template<typename FKind, typename RegisterMapT>
+inline void ContinuationHelper::update_register_map(RegisterMapT* map, const frame& f) {
+  Unimplemented();
+}
+
+template<typename RegisterMapT>
+inline void ContinuationHelper::update_register_map_with_callee(RegisterMapT* map, const frame& f) {
+  Unimplemented();
+}
+
+inline void ContinuationHelper::push_pd(const frame& f) {
+  Unimplemented();
+}
+
+// creates the yield stub frame faster than JavaThread::last_frame
+inline frame ContinuationHelper::last_frame(JavaThread* thread) {
+  Unimplemented();
+  return frame();
+}
+
+frame ContinuationEntry::to_frame() {
+  Unimplemented();
+  return frame();
+}
+
+void ContinuationEntry::update_register_map(RegisterMap* map) {
+  Unimplemented();
+}
+
+void ContinuationHelper::set_anchor_to_entry_pd(JavaFrameAnchor* anchor, ContinuationEntry* cont) {
+  Unimplemented();
+}
+
+void ContinuationHelper::set_anchor_pd(JavaFrameAnchor* anchor, intptr_t* sp) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+inline void Freeze<ConfigT>::set_top_frame_metadata_pd(const frame& hf) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+inline intptr_t* Freeze<ConfigT>::align_bottom(intptr_t* bottom, int argsize) {
+  Unimplemented();
+  return NULL;
+}
+
+template <typename ConfigT>
+template<typename FKind>
+inline frame Freeze<ConfigT>::sender(const frame& f) {
+  Unimplemented();
+  return frame();
+}
+
+template <typename ConfigT>
+template<typename FKind> frame Freeze<ConfigT>::new_hframe(frame& f, frame& caller) {
+  Unimplemented();
+  return frame();
+}
+
+template <typename ConfigT>
+inline void Freeze<ConfigT>::relativize_interpreted_frame_metadata(const frame& f, const frame& hf) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+template <typename FKind, bool bottom>
+inline void Freeze<ConfigT>::patch_pd(frame& hf, const frame& caller) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+inline void Freeze<ConfigT>::patch_chunk_pd(intptr_t* vsp, intptr_t* hsp) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+inline frame Thaw<ConfigT>::new_entry_frame() {
+  Unimplemented();
+  return frame();
+}
+
+template <typename ConfigT>
+template<typename FKind> frame Thaw<ConfigT>::new_frame(const frame& hf, frame& caller, bool bottom) {
+  Unimplemented();
+  return frame();
+}
+
+template <typename ConfigT>
+inline void Thaw<ConfigT>::set_interpreter_frame_bottom(const frame& f, intptr_t* bottom) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+inline void Thaw<ConfigT>::derelativize_interpreted_frame_metadata(const frame& hf, const frame& f) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+inline intptr_t* Thaw<ConfigT>::align(const frame& hf, intptr_t* vsp, frame& caller, bool bottom) {
+  Unimplemented();
+  return NULL;
+}
+
+template <typename ConfigT>
+template<typename FKind, bool bottom>
+inline void Thaw<ConfigT>::patch_pd(frame& f, const frame& caller) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+intptr_t* Thaw<ConfigT>::push_interpreter_return_frame(intptr_t* sp) {
+  Unimplemented();
+  return NULL;
+}
+
+template <typename ConfigT>
+void Thaw<ConfigT>::patch_chunk_pd(intptr_t* sp) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+inline void Thaw<ConfigT>::prefetch_chunk_pd(void* start, int size) {
+  Unimplemented();
+}
+
+template <typename ConfigT>
+inline intptr_t* Thaw<ConfigT>::align_chunk(intptr_t* vsp) {
+  Unimplemented();
+  return NULL;
+}
+
+#endif // CPU_ARM_CONTINUATION_ARM_INLINE_HPP

src/hotspot/cpu/arm/frame_arm.cpp

@@ -248,11 +248,6 @@ bool frame::is_interpreted_frame() const  {
   return Interpreter::contains(pc());
 }
 
-int frame::frame_size(RegisterMap* map) const {
-  frame sender = this->sender(map);
-  return sender.sp() - sp();
-}
-
 intptr_t* frame::entry_frame_argument_at(int offset) const {
   assert(is_entry_frame(), "entry frame expected");
   // convert offset to index to deal with tsi
@@ -279,7 +274,12 @@ BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
   return (BasicObjectLock*) addr_at(interpreter_frame_monitor_block_bottom_offset);
 }
 
-BasicObjectLock* frame::interpreter_frame_monitor_end() const {
+// Pointer beyond the "oldest/deepest" BasicObjectLock on stack.
+template BasicObjectLock* frame::interpreter_frame_monitor_end<true>() const;
+template BasicObjectLock* frame::interpreter_frame_monitor_end<false>() const;
+
+template <bool relative>
+inline BasicObjectLock* frame::interpreter_frame_monitor_end() const {
   BasicObjectLock* result = (BasicObjectLock*) *addr_at(interpreter_frame_monitor_block_top_offset);
   // make sure the pointer points inside the frame
   assert((intptr_t) fp() >  (intptr_t) result, "result must <  than frame pointer");
@@ -399,6 +399,7 @@ frame frame::sender_for_interpreter_frame(RegisterMap* map) const {
   return frame(sender_sp, unextended_sp, link(), sender_pc());
 }
 
+template <bool stub>
 frame frame::sender_for_compiled_frame(RegisterMap* map) const {
   assert(map != NULL, "map must be set");
 
@@ -442,7 +443,7 @@ frame frame::sender(RegisterMap* map) const {
   assert(_cb == CodeCache::find_blob(pc()),"Must be the same");
 
   if (_cb != NULL) {
-    return sender_for_compiled_frame(map);
+    return sender_for_compiled_frame<false>(map);
   }
 
   assert(false, "should not be called for a C frame");
@@ -547,8 +548,11 @@ BasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result)
   return type;
 }
 
+template intptr_t* frame::interpreter_frame_tos_at<false>(jint offset) const;
+template intptr_t* frame::interpreter_frame_tos_at<true >(jint offset) const;
 
-intptr_t* frame::interpreter_frame_tos_at(jint offset) const {
+template <bool relative>
+inline intptr_t* frame::interpreter_frame_tos_at(jint offset) const {
   int index = (Interpreter::expr_offset_in_bytes(offset)/wordSize);
   return &interpreter_frame_tos_address()[index];
 }
@@ -576,6 +580,9 @@ frame::frame(void* sp, void* fp, void* pc) {
   init((intptr_t*)sp, (intptr_t*)fp, (address)pc);
 }
 
+void frame::describe_top_pd(FrameValues& values) {
+  Unimplemented();
+}
 #endif
 
 intptr_t *frame::initial_deoptimization_info() {

src/hotspot/cpu/arm/frame_arm.hpp

@@ -90,6 +90,8 @@
   }
 #endif
 
+  const ImmutableOopMap* get_oop_map() const;
+
  public:
   // Constructors
 
@@ -110,6 +112,9 @@
   // expression stack tos if we are nested in a java call
   intptr_t* interpreter_frame_last_sp() const;
 
+  template <typename RegisterMapT>
+  static void update_map_with_saved_link(RegisterMapT* map, intptr_t** link_addr);
+
   // deoptimization support
   void interpreter_frame_set_last_sp(intptr_t* sp);
 
@@ -118,4 +123,7 @@
 
   static jint interpreter_frame_expression_stack_direction() { return -1; }
 
+  template <bool relative = false>
+  inline intptr_t* interpreter_frame_last_sp() const;
+
 #endif // CPU_ARM_FRAME_ARM_HPP