Remove obsolete functions from JNI macro assemblers.

Remove obsolete methods and related T32 tests. Change some
functions to private functions of implementing classes,
unavailable through the JNI macro assembler interface.

Add some T32 tests for `MoveArguments()`. Add a TODO for
using LDRD which should improve some @CriticalNative stubs.

Remove unnecessary `#include`s of `jni_macro_assembler.h`.

Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Bug: 271573990
Change-Id: I65c14ba1cf8a50db80243aaaa96e85eb6a28477f

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;