1 files changed, 0 insertions, 86 deletions
diff --git a/compiler/utils/jni_macro_assembler.h b/compiler/utils/jni_macro_assembler.h
index 79dd987081..15a4c3fe67 100644
--- a/compiler/utils/jni_macro_assembler.h
+++ b/compiler/utils/jni_macro_assembler.h
@@ -118,41 +118,18 @@ class JNIMacroAssembler : public DeletableArenaObject<kArenaAllocAssembler> {
   // Store routines
   virtual void Store(FrameOffset offs, ManagedRegister src, size_t size) = 0;
   virtual void Store(ManagedRegister base, MemberOffset offs, ManagedRegister src, size_t size) = 0;
-  virtual void StoreRef(FrameOffset dest, ManagedRegister src) = 0;
   virtual void StoreRawPtr(FrameOffset dest, ManagedRegister src) = 0;
 
-  virtual void StoreImmediateToFrame(FrameOffset dest, uint32_t imm) = 0;
-
-  virtual void StoreStackOffsetToThread(ThreadOffset<kPointerSize> thr_offs,
-                                        FrameOffset fr_offs) = 0;
-
   // Stores stack pointer by tagging it if required so we can walk the stack. In debuggable runtimes
   // we use tag to tell if we are using JITed code or AOT code. In non-debuggable runtimes we never
   // use JITed code when AOT code is present. So checking for AOT code is sufficient to detect which
   // code is being executed. We avoid tagging in non-debuggable runtimes to reduce instructions.
   virtual void StoreStackPointerToThread(ThreadOffset<kPointerSize> thr_offs, bool tag_sp) = 0;
 
-  virtual void StoreSpanning(FrameOffset dest,
-                             ManagedRegister src,
-                             FrameOffset in_off) = 0;
-
   // Load routines
   virtual void Load(ManagedRegister dest, FrameOffset src, size_t size) = 0;
   virtual void Load(ManagedRegister dest, ManagedRegister base, MemberOffset offs, size_t size) = 0;
 
-  virtual void LoadFromThread(ManagedRegister dest,
-                              ThreadOffset<kPointerSize> src,
-                              size_t size) = 0;
-
-  virtual void LoadRef(ManagedRegister dest, FrameOffset src) = 0;
-  // If unpoison_reference is true and kPoisonReference is true, then we negate the read reference.
-  virtual void LoadRef(ManagedRegister dest,
-                       ManagedRegister base,
-                       MemberOffset offs,
-                       bool unpoison_reference) = 0;
-
-  virtual void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) = 0;
-
   virtual void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset<kPointerSize> offs) = 0;
 
   // Copying routines
@@ -169,56 +146,8 @@ class JNIMacroAssembler : public DeletableArenaObject<kArenaAllocAssembler> {
 
   virtual void Move(ManagedRegister dest, ManagedRegister src, size_t size) = 0;
 
-  virtual void CopyRawPtrFromThread(FrameOffset fr_offs, ThreadOffset<kPointerSize> thr_offs) = 0;
-
-  virtual void CopyRawPtrToThread(ThreadOffset<kPointerSize> thr_offs,
-                                  FrameOffset fr_offs,
-                                  ManagedRegister scratch) = 0;
-
-  virtual void CopyRef(FrameOffset dest, FrameOffset src) = 0;
-  virtual void CopyRef(FrameOffset dest,
-                       ManagedRegister base,
-                       MemberOffset offs,
-                       bool unpoison_reference) = 0;
-
-  virtual void Copy(FrameOffset dest, FrameOffset src, size_t size) = 0;
-
-  virtual void Copy(FrameOffset dest,
-                    ManagedRegister src_base,
-                    Offset src_offset,
-                    ManagedRegister scratch,
-                    size_t size) = 0;
-
-  virtual void Copy(ManagedRegister dest_base,
-                    Offset dest_offset,
-                    FrameOffset src,
-                    ManagedRegister scratch,
-                    size_t size) = 0;
-
-  virtual void Copy(FrameOffset dest,
-                    FrameOffset src_base,
-                    Offset src_offset,
-                    ManagedRegister scratch,
-                    size_t size) = 0;
-
-  virtual void Copy(ManagedRegister dest,
-                    Offset dest_offset,
-                    ManagedRegister src,
-                    Offset src_offset,
-                    ManagedRegister scratch,
-                    size_t size) = 0;
-
-  virtual void Copy(FrameOffset dest,
-                    Offset dest_offset,
-                    FrameOffset src,
-                    Offset src_offset,
-                    ManagedRegister scratch,
-                    size_t size) = 0;
-
   virtual void Move(ManagedRegister dst, size_t value) = 0;
 
-  virtual void MemoryBarrier(ManagedRegister scratch) = 0;
-
   // Sign extension
   virtual void SignExtend(ManagedRegister mreg, size_t size) = 0;
 
@@ -229,21 +158,6 @@ class JNIMacroAssembler : public DeletableArenaObject<kArenaAllocAssembler> {
   virtual void GetCurrentThread(ManagedRegister dest) = 0;
   virtual void GetCurrentThread(FrameOffset dest_offset) = 0;
 
-  // Set up `out_reg` to hold a `jobject` (`StackReference<Object>*` to a spilled value),
-  // or to be null if the value is null and `null_allowed`. `in_reg` holds a possibly
-  // stale reference that can be used to avoid loading the spilled value to
-  // see if the value is null.
-  virtual void CreateJObject(ManagedRegister out_reg,
-                             FrameOffset spilled_reference_offset,
-                             ManagedRegister in_reg,
-                             bool null_allowed) = 0;
-
-  // Set up `out_off` to hold a `jobject` (`StackReference<Object>*` to a spilled value),
-  // or to be null if the value is null and `null_allowed`.
-  virtual void CreateJObject(FrameOffset out_off,
-                             FrameOffset spilled_reference_offset,
-                             bool null_allowed) = 0;
-
   // Heap::VerifyObject on src. In some cases (such as a reference to this) we
   // know that src may not be null.
   virtual void VerifyObject(ManagedRegister src, bool could_be_null) = 0;