diff --git a/runtime/lib/ffi_dynamic_library.cc b/runtime/lib/ffi_dynamic_library.cc
index af4a52e..4bd67e2 100644
--- a/runtime/lib/ffi_dynamic_library.cc
+++ b/runtime/lib/ffi_dynamic_library.cc
@@ -2,7 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-#if !defined(TARGET_OS_LINUX) && !defined(TARGET_OS_MACOS)
+#if !defined(TARGET_OS_LINUX) && !defined(TARGET_OS_MACOS) &&                  \
+    !defined(TARGET_OS_ANDROID)
 // TODO(dacoharkes): Implement dynamic libraries for other targets & merge the
 // implementation with:
 // - runtime/bin/extensions.h
@@ -20,7 +21,8 @@
 namespace dart {
 
 static void* LoadExtensionLibrary(const char* library_file) {
-#if defined(TARGET_OS_LINUX) || defined(TARGET_OS_MACOS)
+#if defined(TARGET_OS_LINUX) || defined(TARGET_OS_MACOS) ||                    \
+    defined(TARGET_OS_ANDROID)
   void* handle = dlopen(library_file, RTLD_LAZY);
   if (handle == nullptr) {
     char* error = dlerror();
@@ -68,7 +70,8 @@
 }
 
 static void* ResolveSymbol(void* handle, const char* symbol) {
-#if defined(TARGET_OS_LINUX) || defined(TARGET_OS_MACOS)
+#if defined(TARGET_OS_LINUX) || defined(TARGET_OS_MACOS) ||                    \
+    defined(TARGET_OS_ANDROID)
   dlerror();  // Clear any errors.
   void* pointer = dlsym(handle, symbol);
   if (pointer == nullptr) {
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index 5f1a3d6..d89e51c 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -5193,7 +5193,8 @@
   set_native_c_function(native_function);
 }
 
-#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_IA32)
+#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64) ||                  \
+    defined(TARGET_ARCH_IA32)
 
 #define Z zone_
 
@@ -5212,7 +5213,7 @@
   ASSERT(((1 << CallingConventions::kFirstCalleeSavedCpuReg) &
           CallingConventions::kArgumentRegisters) == 0);
 
-#if defined(TARGET_ARCH_IA32)
+#if defined(TARGET_ARCH_ARM64) || defined(TARGET_ARCH_IA32)
   constexpr intptr_t kNumTemps = 2;
 #else
   constexpr intptr_t kNumTemps = 1;
@@ -5227,7 +5228,7 @@
                       CallingConventions::kFirstNonArgumentRegister));
   summary->set_temp(0, Location::RegisterLocation(
                            CallingConventions::kSecondNonArgumentRegister));
-#if defined(TARGET_ARCH_IA32)
+#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM64)
   summary->set_temp(1, Location::RegisterLocation(
                            CallingConventions::kFirstCalleeSavedCpuReg));
 #endif
diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc
index 6a4649d..a7807d9 100644
--- a/runtime/vm/compiler/backend/il_arm64.cc
+++ b/runtime/vm/compiler/backend/il_arm64.cc
@@ -873,7 +873,102 @@
 }
 
 void FfiCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNREACHABLE();
+  Register saved_fp = locs()->temp(0).reg();
+  Register temp = locs()->temp(1).reg();
+  Register branch = locs()->in(TargetAddressIndex()).reg();
+
+  // Save frame pointer because we're going to update it when we enter the exit
+  // frame.
+  __ mov(saved_fp, FPREG);
+
+  // We need to create a dummy "exit frame". It will share the same pool pointer
+  // but have a null code object.
+  __ LoadObject(CODE_REG, Object::null_object());
+  __ set_constant_pool_allowed(false);
+  __ EnterDartFrame(0, PP);
+
+  // Save exit frame information to enable stack walking as we are about
+  // to transition to Dart VM C++ code.
+  __ StoreToOffset(FPREG, THR,
+                   compiler::target::Thread::top_exit_frame_info_offset());
+
+  // Make space for arguments and align the frame.
+  __ ReserveAlignedFrameSpace(compiler::ffi::NumStackSlots(arg_locations_) *
+                              kWordSize);
+
+  for (intptr_t i = 0, n = NativeArgCount(); i < n; ++i) {
+    Location origin = locs()->in(i);
+    Location target = arg_locations_[i];
+
+    if (target.IsStackSlot()) {
+      if (origin.IsRegister()) {
+        __ StoreToOffset(origin.reg(), SPREG, target.ToStackSlotOffset());
+      } else if (origin.IsFpuRegister()) {
+        __ StoreDToOffset(origin.fpu_reg(), SPREG, target.ToStackSlotOffset());
+      } else if (origin.IsStackSlot() || origin.IsDoubleStackSlot()) {
+        // The base register cannot be SPREG because we've moved it.
+        ASSERT(origin.base_reg() == FPREG);
+        __ LoadFromOffset(TMP, saved_fp, origin.ToStackSlotOffset());
+        __ StoreToOffset(TMP, SPREG, target.ToStackSlotOffset());
+      }
+    } else {
+      ASSERT(origin.Equals(target));
+    }
+  }
+
+  // Mark that the thread is executing VM code.
+  __ StoreToOffset(branch, THR, compiler::target::Thread::vm_tag_offset());
+
+  // We need to copy the return address up into the dummy stack frame so the
+  // stack walker will know which safepoint to use.
+  const intptr_t call_sequence_start = __ CodeSize();
+
+  // 5 instructions, 4 bytes each.
+  constexpr intptr_t kCallSequenceLength = 5 * 4;
+
+  __ adr(temp, Immediate(kCallSequenceLength));
+  __ StoreToOffset(temp, FPREG, kSavedCallerPcSlotFromFp * kWordSize);
+
+  // We are entering runtime code, so the C stack pointer must be restored from
+  // the stack limit to the top of the stack. We cache the stack limit address
+  // in a callee-saved register.
+  __ mov(temp, CSP);
+  __ mov(CSP, SP);
+
+  __ blr(branch);
+
+  ASSERT(__ CodeSize() - call_sequence_start == kCallSequenceLength);
+
+  // Restore the Dart stack pointer and the saved C stack pointer.
+  __ mov(SP, CSP);
+  __ mov(CSP, temp);
+
+  compiler->EmitCallsiteMetadata(token_pos(), DeoptId::kNone,
+                                 RawPcDescriptors::Kind::kOther, locs());
+
+  // Mark that the thread is executing Dart code.
+  __ LoadImmediate(temp, VMTag::kDartCompiledTagId);
+  __ StoreToOffset(temp, THR, compiler::target::Thread::vm_tag_offset());
+
+  // Reset exit frame information in Isolate structure.
+  __ StoreToOffset(ZR, THR,
+                   compiler::target::Thread::top_exit_frame_info_offset());
+
+  // Refresh write barrier mask.
+  __ ldr(BARRIER_MASK,
+         Address(THR, compiler::target::Thread::write_barrier_mask_offset()));
+
+  // Although PP is a callee-saved register, it may have been moved by the GC.
+  __ LeaveDartFrame(compiler::kRestoreCallerPP);
+
+  // Restore the global object pool after returning from runtime (old space is
+  // moving, so the GOP could have been relocated).
+  if (FLAG_precompiled_mode && FLAG_use_bare_instructions) {
+    __ ldr(PP, Address(THR, Thread::global_object_pool_offset()));
+    __ sub(PP, PP, Operand(kHeapObjectTag));  // Pool in PP is untagged!
+  }
+
+  __ set_constant_pool_allowed(true);
 }
 
 LocationSummary* OneByteStringFromCharCodeInstr::MakeLocationSummary(
diff --git a/runtime/vm/compiler/ffi.cc b/runtime/vm/compiler/ffi.cc
index a92d033..0c75e40 100644
--- a/runtime/vm/compiler/ffi.cc
+++ b/runtime/vm/compiler/ffi.cc
@@ -11,7 +11,8 @@
 
 namespace ffi {
 
-#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_IA32)
+#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64) ||                  \
+    defined(TARGET_ARCH_IA32)
 
 static const size_t kSizeUnknown = 0;
 
@@ -127,7 +128,7 @@
           Location result = Location::RegisterLocation(
               CallingConventions::ArgumentRegisters[cpu_regs_used]);
           cpu_regs_used++;
-          if (CallingConventions::kArgumentIntRegXorXmmReg) {
+          if (CallingConventions::kArgumentIntRegXorFpuReg) {
             fpu_regs_used++;
           }
           return result;
@@ -135,11 +136,11 @@
         break;
       case kUnboxedFloat:
       case kUnboxedDouble:
-        if (fpu_regs_used < CallingConventions::kNumXmmArgRegs) {
+        if (fpu_regs_used < CallingConventions::kNumFpuArgRegs) {
           Location result = Location::FpuRegisterLocation(
-              CallingConventions::XmmArgumentRegisters[fpu_regs_used]);
+              CallingConventions::FpuArgumentRegisters[fpu_regs_used]);
           fpu_regs_used++;
-          if (CallingConventions::kArgumentIntRegXorXmmReg) {
+          if (CallingConventions::kArgumentIntRegXorFpuReg) {
             cpu_regs_used++;
           }
           return result;
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 169355a..59e1498 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -2485,7 +2485,8 @@
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfFfiTrampoline(
     const Function& function) {
-#if !defined(TARGET_ARCH_X64) && !defined(TARGET_ARCH_IA32)
+#if !defined(TARGET_ARCH_X64) && !defined(TARGET_ARCH_ARM64) &&                \
+    !defined(TARGET_ARCH_IA32)
   UNREACHABLE();
 #else
   graph_entry_ =
diff --git a/runtime/vm/constants_arm64.cc b/runtime/vm/constants_arm64.cc
new file mode 100644
index 0000000..0714ae3
--- /dev/null
+++ b/runtime/vm/constants_arm64.cc
@@ -0,0 +1,21 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#if defined(TARGET_ARCH_ARM64)
+
+#include "vm/constants_arm64.h"
+
+namespace dart {
+
+const Register CallingConventions::ArgumentRegisters[] = {
+    R0, R1, R2, R3, R4, R5, R6, R7,
+};
+
+const FpuRegister CallingConventions::FpuArgumentRegisters[] = {
+    V0, V1, V2, V3, V4, V5, V6, V7,
+};
+
+}  // namespace dart
+
+#endif
diff --git a/runtime/vm/constants_arm64.h b/runtime/vm/constants_arm64.h
index 0e2d6ea..fa592e1 100644
--- a/runtime/vm/constants_arm64.h
+++ b/runtime/vm/constants_arm64.h
@@ -137,6 +137,9 @@
 typedef uint32_t RegList;
 const RegList kAllCpuRegistersList = 0xFFFFFFFF;
 
+// See "Procedure Call Standard for the ARM 64-bit Architecture", document
+// number "ARM IHI 0055B", May 22 2013.
+
 // C++ ABI call registers.
 const RegList kAbiArgumentCpuRegs = (1 << R0) | (1 << R1) | (1 << R2) |
                                     (1 << R3) | (1 << R4) | (1 << R5) |
@@ -173,6 +176,32 @@
 
 constexpr int kStoreBufferWrapperSize = 32;
 
+#define R(REG) (1 << REG)
+
+class CallingConventions {
+ public:
+  static const intptr_t kArgumentRegisters = kAbiArgumentCpuRegs;
+  static const Register ArgumentRegisters[];
+  static const intptr_t kNumArgRegs = 8;
+
+  static const FpuRegister FpuArgumentRegisters[];
+  static const intptr_t kFpuArgumentRegisters =
+      R(V0) | R(V1) | R(V2) | R(V3) | R(V4) | R(V5) | R(V6) | R(V7);
+  static const intptr_t kNumFpuArgRegs = 8;
+
+  static const bool kArgumentIntRegXorFpuReg = false;
+
+  static constexpr Register kReturnReg = R0;
+  static constexpr Register kSecondReturnReg = kNoRegister;
+  static constexpr FpuRegister kReturnFpuReg = V0;
+
+  static constexpr Register kFirstCalleeSavedCpuReg = kAbiFirstPreservedCpuReg;
+  static constexpr Register kFirstNonArgumentRegister = R8;
+  static constexpr Register kSecondNonArgumentRegister = R9;
+};
+
+#undef R
+
 static inline Register ConcreteRegister(Register r) {
   return ((r == ZR) || (r == CSP)) ? R31 : r;
 }
diff --git a/runtime/vm/constants_ia32.cc b/runtime/vm/constants_ia32.cc
index 16ae341..62c3f6a 100644
--- a/runtime/vm/constants_ia32.cc
+++ b/runtime/vm/constants_ia32.cc
@@ -8,13 +8,13 @@
 
 namespace dart {
 
-// Although 'kArgumentRegisters' and 'kXmmArgumentRegisters' are both 0, we have
+// Although 'kArgumentRegisters' and 'kFpuArgumentRegisters' are both 0, we have
 // to give these arrays at least one element to appease MSVC.
 
 const Register CallingConventions::ArgumentRegisters[] = {
     static_cast<Register>(0)};
-const XmmRegister CallingConventions::XmmArgumentRegisters[] = {
-    static_cast<XmmRegister>(0)};
+const FpuRegister CallingConventions::FpuArgumentRegisters[] = {
+    static_cast<FpuRegister>(0)};
 
 }  // namespace dart
 
diff --git a/runtime/vm/constants_ia32.h b/runtime/vm/constants_ia32.h
index 43d3064..24e3783 100644
--- a/runtime/vm/constants_ia32.h
+++ b/runtime/vm/constants_ia32.h
@@ -125,17 +125,17 @@
   static const intptr_t kArgumentRegisters = 0;
   static const intptr_t kNumArgRegs = 0;
 
-  static const XmmRegister XmmArgumentRegisters[];
+  static const XmmRegister FpuArgumentRegisters[];
   static const intptr_t kXmmArgumentRegisters = 0;
-  static const intptr_t kNumXmmArgRegs = 0;
+  static const intptr_t kNumFpuArgRegs = 0;
 
-  static const bool kArgumentIntRegXorXmmReg = false;
+  static const bool kArgumentIntRegXorFpuReg = false;
 
   static constexpr Register kReturnReg = EAX;
   static constexpr Register kSecondReturnReg = EDX;
 
   // Floating point values are returned on the "FPU stack" (in "ST" registers).
-  static constexpr XmmRegister kReturnXmmReg = kNoXmmRegister;
+  static constexpr XmmRegister kReturnFpuReg = kNoXmmRegister;
 
   static constexpr Register kFirstCalleeSavedCpuReg = EBX;
   static constexpr Register kFirstNonArgumentRegister = EAX;
diff --git a/runtime/vm/constants_x64.cc b/runtime/vm/constants_x64.cc
index 397977e..3f38d9d 100644
--- a/runtime/vm/constants_x64.cc
+++ b/runtime/vm/constants_x64.cc
@@ -13,7 +13,7 @@
     CallingConventions::kArg1Reg, CallingConventions::kArg2Reg,
     CallingConventions::kArg3Reg, CallingConventions::kArg4Reg};
 
-const XmmRegister CallingConventions::XmmArgumentRegisters[] = {
+const XmmRegister CallingConventions::FpuArgumentRegisters[] = {
     XmmRegister::XMM0, XmmRegister::XMM1, XmmRegister::XMM2, XmmRegister::XMM3};
 #else
 const Register CallingConventions::ArgumentRegisters[] = {
@@ -21,7 +21,7 @@
     CallingConventions::kArg3Reg, CallingConventions::kArg4Reg,
     CallingConventions::kArg5Reg, CallingConventions::kArg6Reg};
 
-const XmmRegister CallingConventions::XmmArgumentRegisters[] = {
+const XmmRegister CallingConventions::FpuArgumentRegisters[] = {
     XmmRegister::XMM0, XmmRegister::XMM1, XmmRegister::XMM2, XmmRegister::XMM3,
     XmmRegister::XMM4, XmmRegister::XMM5, XmmRegister::XMM6, XmmRegister::XMM7};
 #endif
diff --git a/runtime/vm/constants_x64.h b/runtime/vm/constants_x64.h
index cbaedaa..3e8d0070 100644
--- a/runtime/vm/constants_x64.h
+++ b/runtime/vm/constants_x64.h
@@ -157,14 +157,14 @@
       R(kArg1Reg) | R(kArg2Reg) | R(kArg3Reg) | R(kArg4Reg);
   static const intptr_t kNumArgRegs = 4;
 
-  static const XmmRegister XmmArgumentRegisters[];
-  static const intptr_t kXmmArgumentRegisters =
+  static const XmmRegister FpuArgumentRegisters[];
+  static const intptr_t kFpuArgumentRegisters =
       R(XMM0) | R(XMM1) | R(XMM2) | R(XMM3);
-  static const intptr_t kNumXmmArgRegs = 4;
+  static const intptr_t kNumFpuArgRegs = 4;
 
   // can ArgumentRegisters[i] and XmmArgumentRegisters[i] both be used at the
   // same time? (Windows no, rest yes)
-  static const bool kArgumentIntRegXorXmmReg = true;
+  static const bool kArgumentIntRegXorFpuReg = true;
 
   static const intptr_t kShadowSpaceBytes = 4 * kWordSize;
 
@@ -203,15 +203,15 @@
                                              R(kArg5Reg) | R(kArg6Reg);
   static const intptr_t kNumArgRegs = 6;
 
-  static const XmmRegister XmmArgumentRegisters[];
+  static const XmmRegister FpuArgumentRegisters[];
   static const intptr_t kXmmArgumentRegisters = R(XMM0) | R(XMM1) | R(XMM2) |
                                                 R(XMM3) | R(XMM4) | R(XMM5) |
                                                 R(XMM6) | R(XMM7);
-  static const intptr_t kNumXmmArgRegs = 8;
+  static const intptr_t kNumFpuArgRegs = 8;
 
   // can ArgumentRegisters[i] and XmmArgumentRegisters[i] both be used at the
   // same time? (Windows no, rest yes)
-  static const bool kArgumentIntRegXorXmmReg = false;
+  static const bool kArgumentIntRegXorFpuReg = false;
 
   static const intptr_t kShadowSpaceBytes = 0;
 
diff --git a/runtime/vm/dart_api_impl.h b/runtime/vm/dart_api_impl.h
index 0fa7622..202143e 100644
--- a/runtime/vm/dart_api_impl.h
+++ b/runtime/vm/dart_api_impl.h
@@ -297,12 +297,13 @@
 
   static bool IsFfiEnabled() {
     // dart:ffi is not implemented for the following configurations
-#if !defined(TARGET_ARCH_X64) && !defined(TARGET_ARCH_IA32)
+#if !defined(TARGET_ARCH_X64) && !defined(TARGET_ARCH_ARM64) &&                \
+    !defined(TARGET_ARCH_IA32)
     // https://github.com/dart-lang/sdk/issues/35760 Arm32 && Android
     // https://github.com/dart-lang/sdk/issues/35772 Arm64
     return false;
 #elif !defined(TARGET_OS_LINUX) && !defined(TARGET_OS_MACOS) &&                \
-    !defined(TARGET_OS_WINDOWS)
+    !defined(TARGET_OS_ANDROID) && !defined(TARGET_OS_WINDOWS)
     // https://github.com/dart-lang/sdk/issues/35760 Arm32 && Android
     // https://github.com/dart-lang/sdk/issues/35772 Arm64
     // https://github.com/dart-lang/sdk/issues/35773 DBC
diff --git a/runtime/vm/vm_sources.gni b/runtime/vm/vm_sources.gni
index 7fb6f1f..eadae4d 100644
--- a/runtime/vm/vm_sources.gni
+++ b/runtime/vm/vm_sources.gni
@@ -43,6 +43,7 @@
   "compilation_trace.cc",
   "compilation_trace.h",
   "constants_arm.h",
+  "constants_arm64.cc",
   "constants_arm64.h",
   "constants_dbc.h",
   "constants_ia32.h",
diff --git a/tests/standalone_2/ffi/dylib_utils.dart b/tests/standalone_2/ffi/dylib_utils.dart
index 1c924d4..fb8153a 100644
--- a/tests/standalone_2/ffi/dylib_utils.dart
+++ b/tests/standalone_2/ffi/dylib_utils.dart
@@ -7,7 +7,8 @@
 
 String _platformPath(String name, {String path}) {
   if (path == null) path = "";
-  if (Platform.isLinux) return path + "lib" + name + ".so";
+  if (Platform.isLinux || Platform.isAndroid)
+    return path + "lib" + name + ".so";
   if (Platform.isMacOS) return path + "lib" + name + ".dylib";
   if (Platform.isWindows) return path + name + ".dll";
   throw Exception("Platform not implemented");
diff --git a/tests/standalone_2/ffi/gc_helper.dart b/tests/standalone_2/ffi/gc_helper.dart
index 5e9431d..182e1df 100644
--- a/tests/standalone_2/ffi/gc_helper.dart
+++ b/tests/standalone_2/ffi/gc_helper.dart
@@ -12,8 +12,9 @@
 abstract class GCWatcher {
   factory GCWatcher() => _GCWatcherImpl();
   factory GCWatcher.dummy() => _MockGCWatcher();
-  factory GCWatcher.ifAvailable() =>
-      Platform.isWindows ? GCWatcher.dummy() : GCWatcher();
+  factory GCWatcher.ifAvailable() => (Platform.isWindows || Platform.isAndroid)
+      ? GCWatcher.dummy()
+      : GCWatcher();
 
   Future<int> size();
   void dispose();
diff --git a/tests/standalone_2/standalone_2_kernel.status b/tests/standalone_2/standalone_2_kernel.status
index 75ee38a..fdbc2ab 100644
--- a/tests/standalone_2/standalone_2_kernel.status
+++ b/tests/standalone_2/standalone_2_kernel.status
@@ -244,11 +244,11 @@
 io/web_socket_compression_test: Skip # Timeout
 io/web_socket_test: Skip # Timeout
 
-[ $compiler != dartk || $mode == product || $arch != ia32 && $arch != x64 || $system != linux && $system != macos && $system != windows ]
+[ $compiler != dartk || $mode == product || $arch != arm64 && $arch != ia32 && $arch != x64 || $system != android && $system != linux && $system != macos && $system != windows ]
 ffi/function_stress_test: SkipByDesign # FFI must be supported. Also requires --verbose-gc, which isn't included in product.
 ffi/subtype_test: SkipByDesign # FFI must be supported. Also requires --verbose-gc, which isn't included in product.
 
-[ $arch != ia32 && $arch != x64 || $system != linux && $system != macos && $system != windows ]
+[ $arch != arm64 && $arch != ia32 && $arch != x64 || $system != android && $system != linux && $system != macos && $system != windows ]
 ffi: Skip # ffi not yet supported on other systems than linux/macos/windows x64/ia32
 
 [ $compiler != dartk && $compiler != dartkb && $compiler != dartkp || $compiler == dartkp && $system == windows ]