Basic RISC-V fast path structure

Author: caizixian

openjdk/cpu/riscv/mmtkBarrierSetAssembler_riscv.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018, 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.
+ *
+ */
+#include "precompiled.hpp"
+#include "asm/macroAssembler.inline.hpp"
+#include "interpreter/interp_masm.hpp"
+#include "mmtkBarrierSet.hpp"
+#include "mmtkBarrierSetAssembler_riscv.hpp"
+#include "mmtkBarrierSetC1.hpp"
+#include "mmtkMutator.hpp"
+#include "runtime/sharedRuntime.hpp"
+#include "utilities/macros.hpp"
+#include "c1/c1_LIRAssembler.hpp"
+#include "c1/c1_MacroAssembler.hpp"
+
+#define __ masm->
+
+void MMTkBarrierSetAssembler::eden_allocate(MacroAssembler* masm, Register thread, Register obj, Register var_size_in_bytes, int con_size_in_bytes, Register t1, Label& slow_case) {
+  // assert(false, "Not implemented");
+  __ j(slow_case); // just jal with x0/zr
+}
+
+#undef __
+
+#define __ sasm->
+
+void MMTkBarrierSetAssembler::generate_c1_write_barrier_runtime_stub(StubAssembler* sasm) const {
+  // assert(false, "Not implemented");
+}
+
+#undef __
+
+#define __ ce->masm()->
+
+void MMTkBarrierSetAssembler::generate_c1_write_barrier_stub_call(LIR_Assembler* ce, MMTkC1BarrierStub* stub) {
+//  assert(false, "Not implemented");
+}
+
+#undef __

openjdk/cpu/riscv/mmtkBarrierSetAssembler_riscv.hpp

@@ -0,0 +1,43 @@
+#ifndef MMTK_OPENJDK_MMTK_BARRIER_SET_ASSEMBLER_RISCV_HPP
+#define MMTK_OPENJDK_MMTK_BARRIER_SET_ASSEMBLER_RISCV_HPP
+
+#include "asm/macroAssembler.hpp"
+#include "gc/shared/barrierSetAssembler.hpp"
+
+class MMTkBarrierSetC1;
+class MMTkC1BarrierStub;
+class LIR_Assembler;
+class StubAssembler;
+
+class MMTkBarrierSetAssembler: public BarrierSetAssembler {
+  friend class MMTkBarrierSetC1;
+
+protected:
+  /// Full pre-barrier
+  virtual void object_reference_write_pre(MacroAssembler* masm, DecoratorSet decorators, Address dst, Register val, Register tmp1, Register tmp2) const {}
+  /// Full post-barrier
+  virtual void object_reference_write_post(MacroAssembler* masm, DecoratorSet decorators, Address dst, Register val, Register tmp1, Register tmp2) const {}
+
+  /// Barrier elision test
+  virtual bool can_remove_barrier(DecoratorSet decorators, Register val, bool skip_const_null) const {
+    bool in_heap = (decorators & IN_HEAP) != 0;
+    bool as_normal = (decorators & AS_NORMAL) != 0;
+    assert((decorators & IS_DEST_UNINITIALIZED) == 0, "unsupported");
+    return !in_heap || (skip_const_null && val == noreg);
+  }
+
+  /// Generate C1 write barrier slow-call assembly code
+  virtual void generate_c1_write_barrier_runtime_stub(StubAssembler* sasm) const;
+
+public:
+  virtual void eden_allocate(MacroAssembler* masm, Register thread, Register obj, Register var_size_in_bytes, int con_size_in_bytes, Register t1, Label& slow_case);
+  virtual void store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Address dst, Register val, Register tmp1, Register tmp2, Register tmp3) {
+    if (type == T_OBJECT || type == T_ARRAY) object_reference_write_pre(masm, decorators, dst, val, tmp1, tmp2);
+    BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2, tmp3);
+    if (type == T_OBJECT || type == T_ARRAY) object_reference_write_post(masm, decorators, dst, val, tmp1, tmp2);
+  }
+
+  /// Generate C1 write barrier slow-call stub
+  static void generate_c1_write_barrier_stub_call(LIR_Assembler* ce, MMTkC1BarrierStub* stub);
+};
+#endif // MMTK_OPENJDK_MMTK_BARRIER_SET_ASSEMBLER_RISCV_HPP

openjdk/cpu/x86/mmtkBarrierSetAssembler_x86.hpp

@@ -30,7 +30,7 @@ class MMTkBarrierSetAssembler: public BarrierSetAssembler {
   virtual void generate_c1_write_barrier_runtime_stub(StubAssembler* sasm) const;
 
 public:
-  virtual void eden_allocate(MacroAssembler* masm, Register thread, Register obj, Register var_size_in_bytes, int con_size_in_bytes, Register t1, Label& slow_case);
+  virtual void eden_allocate(MacroAssembler* masm, Register thread, Register obj, Register var_size_in_bytes, int con_size_in_bytes, Register t1, Label& slow_case) override;
   virtual void store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Address dst, Register val, Register tmp1, Register tmp2, Register tmp3) {
     if (type == T_OBJECT || type == T_ARRAY) object_reference_write_pre(masm, decorators, dst, val, tmp1, tmp2);
     BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2, tmp3);

openjdk/share/barriers/mmtkObjectBarrier.cpp

@@ -21,7 +21,8 @@ void MMTkObjectBarrierSetRuntime::object_reference_write_post(oop src, oop* slot
 #define __ masm->
 
 void MMTkObjectBarrierSetAssembler::object_reference_write_post(MacroAssembler* masm, DecoratorSet decorators, Address dst, Register val, Register tmp1, Register tmp2) const {
-  if (can_remove_barrier(decorators, val, /* skip_const_null */ true)) return;
+  //if (can_remove_barrier(decorators, val, /* skip_const_null */ true)) return;
+  /*
 #if MMTK_ENABLE_BARRIER_FASTPATH
   Label done;
 
@@ -66,18 +67,21 @@ void MMTkObjectBarrierSetAssembler::object_reference_write_post(MacroAssembler*
   __ movptr(c_rarg2, val == noreg ?  (int32_t) NULL_WORD : val);
   __ call_VM_leaf_base(FN_ADDR(MMTkBarrierSetRuntime::object_reference_write_post_call), 3);
 #endif
+*/
+  assert(false, "Not implemented");
 }
 
 void MMTkObjectBarrierSetAssembler::arraycopy_epilogue(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Register src, Register dst, Register count) {
-  const bool dest_uninitialized = (decorators & IS_DEST_UNINITIALIZED) != 0;
-  if ((type == T_OBJECT || type == T_ARRAY) && !dest_uninitialized) {
-    __ pusha();
-    __ movptr(c_rarg0, src);
-    __ movptr(c_rarg1, dst);
-    __ movptr(c_rarg2, count);
-    __ call_VM_leaf_base(FN_ADDR(MMTkBarrierSetRuntime::object_reference_array_copy_post_call), 3);
-    __ popa();
-  }
+  // const bool dest_uninitialized = (decorators & IS_DEST_UNINITIALIZED) != 0;
+  // if ((type == T_OBJECT || type == T_ARRAY) && !dest_uninitialized) {
+  //   __ pusha();
+  //   __ movptr(c_rarg0, src);
+  //   __ movptr(c_rarg1, dst);
+  //   __ movptr(c_rarg2, count);
+  //   __ call_VM_leaf_base(FN_ADDR(MMTkBarrierSetRuntime::object_reference_array_copy_post_call), 3);
+  //   __ popa();
+  // }
+  assert(false, "Not implemented");
 }
 
 #undef __

openjdk/share/barriers/mmtkObjectBarrier.hpp

@@ -41,7 +41,7 @@ class MMTkObjectBarrierSetAssembler: public MMTkBarrierSetAssembler {
 protected:
   virtual void object_reference_write_post(MacroAssembler* masm, DecoratorSet decorators, Address dst, Register val, Register tmp1, Register tmp2) const override;
 public:
-  virtual void arraycopy_epilogue(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Register src, Register dst, Register count) override;
+  virtual void arraycopy_epilogue(MacroAssembler* masm, DecoratorSet decorators, BasicType type, Register src, Register dst, Register count);
 };
 #endif