react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactAndroid/src/main/jni/react/jni/Android.mk

@@ -27,7 +27,7 @@ LOCAL_CFLAGS += -fexceptions -frtti -Wno-unused-lambda-capture
 LOCAL_LDLIBS += -landroid
 
 # The dynamic libraries (.so files) that this module depends on.
-LOCAL_SHARED_LIBRARIES := libfolly_json libfb libfbjni libglog_init libyoga
+LOCAL_SHARED_LIBRARIES := libfolly_json libfb libfbjni libglog_init libyoga libreact_render_runtimescheduler
 
 # The static libraries (.a files) that this module depends on.
 LOCAL_STATIC_LIBRARIES := libreactnative libcallinvokerholder libruntimeexecutor
@@ -39,7 +39,7 @@ LOCAL_STATIC_LIBRARIES := libreactnative libcallinvokerholder libruntimeexecutor
 LOCAL_MODULE := reactnativeutilsjni
 
 # Compile all local c++ files.
-LOCAL_SRC_FILES := $(wildcard Cxx*.cpp) $(wildcard J*.cpp) $(wildcard M*.cpp) $(wildcard N*.cpp) $(wildcard P*.cpp) $(wildcard R*.cpp) $(wildcard W*.cpp)
+LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
 
 ifeq ($(APP_OPTIM),debug)
   # Keep symbols by overriding the strip command invoked by ndk-build.
@@ -77,7 +77,7 @@ LOCAL_CFLAGS += -fexceptions -frtti -Wno-unused-lambda-capture
 LOCAL_LDLIBS += -landroid
 
 # The dynamic libraries (.so files) that this module depends on.
-LOCAL_SHARED_LIBRARIES := libreactnativeutilsjni libfolly_json libfb libfbjni libglog_init libyoga
+LOCAL_SHARED_LIBRARIES := libreactnativeutilsjni libfolly_json libfb libfbjni libglog_init libyoga logger libreact_render_runtimescheduler
 
 # The static libraries (.a files) that this module depends on.
 LOCAL_STATIC_LIBRARIES := libreactnative libruntimeexecutor libcallinvokerholder
@@ -124,10 +124,12 @@ $(call import-module,yogajni)
 $(call import-module,cxxreact)
 $(call import-module,jsi)
 $(call import-module,jsiexecutor)
+$(call import-module,logger)
 $(call import-module,callinvoker)
 $(call import-module,reactperflogger)
 $(call import-module,hermes)
 $(call import-module,runtimeexecutor)
+$(call import-module,react/renderer/runtimescheduler)
 $(call import-module,react/nativemodule/core)
 
 include $(REACT_SRC_DIR)/reactperflogger/jni/Android.mk
@@ -135,6 +137,7 @@ include $(REACT_SRC_DIR)/reactperflogger/jni/Android.mk
 # Note: Update this only when ready to minimize breaking changes.
 include $(REACT_SRC_DIR)/turbomodule/core/jni/Android.mk
 include $(REACT_SRC_DIR)/fabric/jni/Android.mk
+include $(REACT_SRC_DIR)/common/mapbuffer/jni/Android.mk
 
 # TODO(ramanpreet):
 #   Why doesn't this import-module call generate a jscexecutor.so file?

package/ReactAndroid/src/main/jni/react/jni/BUCK

@@ -20,6 +20,7 @@ EXPORTED_HEADERS = [
     "ReadableNativeArray.h",
     "ReadableNativeMap.h",
     "JRuntimeExecutor.h",
+    "JRuntimeScheduler.h",
     "WritableNativeArray.h",
     "WritableNativeMap.h",
 ]
@@ -54,7 +55,7 @@ rn_xplat_cxx_library(
     visibility = [
         "PUBLIC",
     ],
-    deps = ([
+    deps = [
         "//xplat/third-party/linker_lib:android",
         "//xplat/third-party/linker_lib:atomic",
         "//third-party/glog:glog",
@@ -67,7 +68,9 @@ rn_xplat_cxx_library(
         react_native_xplat_target("cxxreact:module"),
         react_native_xplat_target("jsinspector:jsinspector"),
         react_native_xplat_target("runtimeexecutor:runtimeexecutor"),
+        react_native_xplat_target("react/renderer/runtimescheduler:runtimescheduler"),
+        react_native_xplat_target("logger:logger"),
         react_native_xplat_dep("jsi:jsi"),
         FBJNI_TARGET,
-    ]) if not IS_OSS_BUILD else [],
+    ] if not IS_OSS_BUILD else [],
 )

package/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp

@@ -26,9 +26,16 @@
 #include <fb/log.h>
 #include <fbjni/ByteBuffer.h>
 #include <folly/dynamic.h>
+#include <glog/logging.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+#include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
+
+#include <logger/react_native_log.h>
 
 #include "CxxModuleWrapper.h"
 #include "JNativeRunnable.h"
+#include "JReactCxxErrorHandler.h"
+#include "JReactSoftExceptionLogger.h"
 #include "JavaScriptExecutorHolder.h"
 #include "JniJSModulesUnbundle.h"
 #include "NativeArray.h"
@@ -92,6 +99,10 @@ CatalystInstanceImpl::initHybrid(jni::alias_ref<jclass>) {
 CatalystInstanceImpl::CatalystInstanceImpl()
     : instance_(std::make_unique<Instance>()) {}
 
+void CatalystInstanceImpl::warnOnLegacyNativeModuleSystemUse() {
+  CxxNativeModule::setShouldWarnOnUse(true);
+}
+
 void CatalystInstanceImpl::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybrid", CatalystInstanceImpl::initHybrid),
@@ -127,11 +138,39 @@ void CatalystInstanceImpl::registerNatives() {
           CatalystInstanceImpl::handleMemoryPressure),
       makeNativeMethod(
           "getRuntimeExecutor", CatalystInstanceImpl::getRuntimeExecutor),
+      makeNativeMethod(
+          "getRuntimeScheduler", CatalystInstanceImpl::getRuntimeScheduler),
+      makeNativeMethod(
+          "installRuntimeScheduler",
+          CatalystInstanceImpl::installRuntimeScheduler),
+      makeNativeMethod(
+          "warnOnLegacyNativeModuleSystemUse",
+          CatalystInstanceImpl::warnOnLegacyNativeModuleSystemUse),
   });
 
   JNativeRunnable::registerNatives();
 }
 
+void log(ReactNativeLogLevel level, const char *message) {
+  switch (level) {
+    case ReactNativeLogLevelInfo:
+      LOG(INFO) << message;
+      break;
+    case ReactNativeLogLevelWarning:
+      LOG(WARNING) << message;
+      JReactSoftExceptionLogger::logNoThrowSoftExceptionWithMessage(
+          "react_native_log#warning", message);
+      break;
+    case ReactNativeLogLevelError:
+      LOG(ERROR) << message;
+      JReactCxxErrorHandler::handleError(message);
+      break;
+    case ReactNativeLogLevelFatal:
+      LOG(FATAL) << message;
+      break;
+  }
+}
+
 void CatalystInstanceImpl::initializeBridge(
     jni::alias_ref<ReactCallback::javaobject> callback,
     // This executor is actually a factory holder.
@@ -142,6 +181,8 @@ void CatalystInstanceImpl::initializeBridge(
         javaModules,
     jni::alias_ref<jni::JCollection<ModuleHolder::javaobject>::javaobject>
         cxxModules) {
+  set_react_native_logfunc(&log);
+
   // TODO mhorowitz: how to assert here?
   // Assertions.assertCondition(mBridge == null, "initializeBridge should be
   // called once");
@@ -354,5 +395,25 @@ CatalystInstanceImpl::getRuntimeExecutor() {
   return runtimeExecutor_;
 }
 
+jni::alias_ref<JRuntimeScheduler::javaobject>
+CatalystInstanceImpl::getRuntimeScheduler() {
+  return runtimeScheduler_;
+}
+
+void CatalystInstanceImpl::installRuntimeScheduler() {
+  if (!runtimeScheduler_) {
+    auto runtimeExecutor = instance_->getRuntimeExecutor();
+    auto runtimeScheduler = std::make_shared<RuntimeScheduler>(runtimeExecutor);
+
+    runtimeScheduler_ =
+        jni::make_global(JRuntimeScheduler::newObjectCxxArgs(runtimeScheduler));
+
+    runtimeExecutor([runtimeScheduler](jsi::Runtime &runtime) {
+      RuntimeSchedulerBinding::createAndInstallIfNeeded(
+          runtime, runtimeScheduler);
+    });
+  }
+}
+
 } // namespace react
 } // namespace facebook

package/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.h

@@ -15,6 +15,7 @@
 #include "CxxModuleWrapper.h"
 #include "JMessageQueueThread.h"
 #include "JRuntimeExecutor.h"
+#include "JRuntimeScheduler.h"
 #include "JSLoader.h"
 #include "JavaModuleWrapper.h"
 #include "ModuleRegistryBuilder.h"
@@ -61,6 +62,10 @@ class CatalystInstanceImpl : public jni::HybridClass<CatalystInstanceImpl> {
       jni::alias_ref<jni::JCollection<ModuleHolder::javaobject>::javaobject>
           cxxModules);
 
+  // When called from CatalystInstanceImpl.java, warnings will be logged when
+  // CxxNativeModules are used. Java NativeModule usages log error in Java.
+  void warnOnLegacyNativeModuleSystemUse();
+
   void extendNativeModules(
       jni::alias_ref<jni::JCollection<
           JavaModuleWrapper::javaobject>::javaobject> javaModules,
@@ -94,6 +99,8 @@ class CatalystInstanceImpl : public jni::HybridClass<CatalystInstanceImpl> {
   jni::alias_ref<CallInvokerHolder::javaobject> getJSCallInvokerHolder();
   jni::alias_ref<CallInvokerHolder::javaobject> getNativeCallInvokerHolder();
   jni::alias_ref<JRuntimeExecutor::javaobject> getRuntimeExecutor();
+  jni::alias_ref<JRuntimeScheduler::javaobject> getRuntimeScheduler();
+  void installRuntimeScheduler();
   void setGlobalVariable(std::string propName, std::string &&jsonValue);
   jlong getJavaScriptContext();
   void handleMemoryPressure(int pressureLevel);
@@ -106,6 +113,7 @@ class CatalystInstanceImpl : public jni::HybridClass<CatalystInstanceImpl> {
   jni::global_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder_;
   jni::global_ref<CallInvokerHolder::javaobject> nativeCallInvokerHolder_;
   jni::global_ref<JRuntimeExecutor::javaobject> runtimeExecutor_;
+  jni::global_ref<JRuntimeScheduler::javaobject> runtimeScheduler_;
 };
 
 } // namespace react

package/ReactAndroid/src/main/jni/react/jni/JReactCxxErrorHandler.cpp

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "JReactCxxErrorHandler.h"
+
+using namespace facebook::react;
+
+void JReactCxxErrorHandler::handleError(std::string message) {
+  static const auto handleError =
+      javaClassStatic()->getStaticMethod<void(std::string message)>(
+          "handleError");
+
+  return handleError(javaClassStatic(), message);
+}

package/{ReactCommon/react/renderer/components/picker/iospicker/primitives.h → ReactAndroid/src/main/jni/react/jni/JReactCxxErrorHandler.h}

@@ -7,22 +7,18 @@
 
 #pragma once
 
-#include <react/renderer/graphics/Color.h>
-
+#include <fbjni/fbjni.h>
 #include <string>
 
 namespace facebook {
 namespace react {
 
-struct PickerItemsStruct {
-  std::string label;
-  std::string value;
-  SharedColor textColor;
+class JReactCxxErrorHandler : public jni::JavaClass<JReactCxxErrorHandler> {
+ public:
+  static constexpr const char *kJavaDescriptor =
+      "Lcom/facebook/react/bridge/ReactCxxErrorHandler;";
 
-  bool operator==(const PickerItemsStruct &rhs) const {
-    return (
-        label == rhs.label && value == rhs.value && textColor == rhs.textColor);
-  }
+  static void handleError(std::string message);
 };
 
 } // namespace react

package/ReactAndroid/src/main/jni/react/jni/JReactSoftExceptionLogger.cpp

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "JReactSoftExceptionLogger.h"
+
+using namespace facebook::react;
+
+void JReactSoftExceptionLogger::logNoThrowSoftExceptionWithMessage(
+    std::string tag,
+    std::string message) {
+  static const auto logNoThrowSoftExceptionWithMessage =
+      javaClassStatic()
+          ->getStaticMethod<void(std::string tag, std::string message)>(
+              "logNoThrowSoftExceptionWithMessage");
+
+  return logNoThrowSoftExceptionWithMessage(javaClassStatic(), tag, message);
+}

package/ReactAndroid/src/main/jni/react/jni/JReactSoftExceptionLogger.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <string>
+
+namespace facebook {
+namespace react {
+
+class JReactSoftExceptionLogger
+    : public jni::JavaClass<JReactSoftExceptionLogger> {
+ public:
+  static constexpr const char *kJavaDescriptor =
+      "Lcom/facebook/react/bridge/ReactSoftExceptionLogger;";
+
+  static void logNoThrowSoftExceptionWithMessage(
+      std::string tag,
+      std::string message);
+};
+
+} // namespace react
+} // namespace facebook

package/{ReactCommon/react/renderer/components/picker/androidpicker/react/renderer/components/androidpicker/AndroidDialogPickerComponentDescriptor.h → ReactAndroid/src/main/jni/react/jni/JRuntimeScheduler.cpp}

@@ -5,17 +5,18 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#pragma once
-
-#include "AndroidDialogPickerShadowNode.h"
-
-#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "JRuntimeScheduler.h"
 
 namespace facebook {
 namespace react {
 
-using AndroidDialogPickerComponentDescriptor =
-    ConcreteComponentDescriptor<AndroidDialogPickerShadowNode>;
+JRuntimeScheduler::JRuntimeScheduler(
+    std::weak_ptr<RuntimeScheduler> runtimeScheduler)
+    : runtimeScheduler_(runtimeScheduler) {}
+
+std::weak_ptr<RuntimeScheduler> JRuntimeScheduler::get() {
+  return runtimeScheduler_;
+}
 
 } // namespace react
 } // namespace facebook

package/ReactAndroid/src/main/jni/react/jni/JRuntimeScheduler.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+namespace facebook {
+namespace react {
+
+class JRuntimeScheduler : public jni::HybridClass<JRuntimeScheduler> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/facebook/react/bridge/RuntimeScheduler;";
+
+  std::weak_ptr<RuntimeScheduler> get();
+
+ private:
+  friend HybridBase;
+  JRuntimeScheduler(std::weak_ptr<RuntimeScheduler> runtimeScheduler);
+  std::weak_ptr<RuntimeScheduler> runtimeScheduler_;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactAndroid/src/main/jni/react/jni/JSLoader.cpp

@@ -66,7 +66,7 @@ loadScriptFromAssets(AAssetManager *manager, const std::string &assetName) {
 
   throw std::runtime_error(folly::to<std::string>(
       "Unable to load script. Make sure you're "
-      "either running Metro (run 'react-native start') or that your bundle '",
+      "either running Metro (run 'npx react-native start') or that your bundle '",
       assetName,
       "' is packaged correctly for release."));
 }

package/ReactAndroid/src/main/jni/react/jni/JavaModuleWrapper.cpp

@@ -152,100 +152,6 @@ MethodCallResult JavaNativeModule::callSerializableNativeHook(
   return method->invoke(instance_, wrapper_->getModule(), params);
 }
 
-NewJavaNativeModule::NewJavaNativeModule(
-    std::weak_ptr<Instance> instance,
-    jni::alias_ref<JavaModuleWrapper::javaobject> wrapper,
-    std::shared_ptr<MessageQueueThread> messageQueueThread)
-    : instance_(std::move(instance)),
-      wrapper_(make_global(wrapper)),
-      module_(make_global(wrapper->getModule())),
-      messageQueueThread_(std::move(messageQueueThread)) {
-  auto descs = wrapper_->getMethodDescriptors();
-  std::string moduleName = getName();
-  methods_.reserve(descs->size());
-
-  for (const auto &desc : *descs) {
-    auto type = desc->getType();
-    auto name = desc->getName();
-    methods_.emplace_back(
-        desc->getMethod(),
-        desc->getName(),
-        desc->getSignature(),
-        moduleName + "." + name,
-        type == "syncHook");
-
-    methodDescriptors_.emplace_back(name, type);
-  }
-}
-
-std::string NewJavaNativeModule::getName() {
-  static auto getNameMethod =
-      wrapper_->getClass()->getMethod<jstring()>("getName");
-  return getNameMethod(wrapper_)->toStdString();
-}
-
-std::vector<MethodDescriptor> NewJavaNativeModule::getMethods() {
-  return methodDescriptors_;
-}
-
-folly::dynamic NewJavaNativeModule::getConstants() {
-  static auto constantsMethod =
-      wrapper_->getClass()->getMethod<NativeMap::javaobject()>("getConstants");
-  auto constants = constantsMethod(wrapper_);
-  if (!constants) {
-    return nullptr;
-  } else {
-    return cthis(constants)->consume();
-  }
-}
-
-void NewJavaNativeModule::invoke(
-    unsigned int reactMethodId,
-    folly::dynamic &&params,
-    int callId) {
-  if (reactMethodId >= methods_.size()) {
-    throw std::invalid_argument(folly::to<std::string>(
-        "methodId ",
-        reactMethodId,
-        " out of range [0..",
-        methods_.size(),
-        "]"));
-  }
-  CHECK(!methods_[reactMethodId].isSyncHook())
-      << "Trying to invoke a synchronous hook asynchronously";
-  messageQueueThread_->runOnQueue(
-      [this, reactMethodId, params = std::move(params), callId]() mutable {
-#ifdef WITH_FBSYSTRACE
-        if (callId != -1) {
-          fbsystrace_end_async_flow(TRACE_TAG_REACT_APPS, "native", callId);
-        }
-#endif
-        invokeInner(reactMethodId, std::move(params));
-      });
-}
-
-MethodCallResult NewJavaNativeModule::callSerializableNativeHook(
-    unsigned int reactMethodId,
-    folly::dynamic &&params) {
-  if (reactMethodId >= methods_.size()) {
-    throw std::invalid_argument(folly::to<std::string>(
-        "methodId ",
-        reactMethodId,
-        " out of range [0..",
-        methods_.size(),
-        "]"));
-  }
-  CHECK(methods_[reactMethodId].isSyncHook())
-      << "Trying to invoke a asynchronous method as synchronous hook";
-  return invokeInner(reactMethodId, std::move(params));
-}
-
-MethodCallResult NewJavaNativeModule::invokeInner(
-    unsigned int reactMethodId,
-    folly::dynamic &&params) {
-  return methods_[reactMethodId].invoke(instance_, module_.get(), params);
-}
-
 jni::local_ref<JReflectMethod::javaobject> JMethodDescriptor::getMethod()
     const {
   static auto method =

package/ReactAndroid/src/main/jni/react/jni/JavaModuleWrapper.h

@@ -85,35 +85,5 @@ class JavaNativeModule : public NativeModule {
   std::vector<folly::Optional<MethodInvoker>> syncMethods_;
 };
 
-// Experimental new implementation that uses direct method invocation
-class NewJavaNativeModule : public NativeModule {
- public:
-  NewJavaNativeModule(
-      std::weak_ptr<Instance> instance,
-      jni::alias_ref<JavaModuleWrapper::javaobject> wrapper,
-      std::shared_ptr<MessageQueueThread> messageQueueThread);
-
-  std::string getName() override;
-  std::vector<MethodDescriptor> getMethods() override;
-  folly::dynamic getConstants() override;
-  void invoke(unsigned int reactMethodId, folly::dynamic &&params, int callId)
-      override;
-  MethodCallResult callSerializableNativeHook(
-      unsigned int reactMethodId,
-      folly::dynamic &&params) override;
-
- private:
-  std::weak_ptr<Instance> instance_;
-  jni::global_ref<JavaModuleWrapper::javaobject> wrapper_;
-  jni::global_ref<JBaseJavaModule::javaobject> module_;
-  std::shared_ptr<MessageQueueThread> messageQueueThread_;
-  std::vector<MethodInvoker> methods_;
-  std::vector<MethodDescriptor> methodDescriptors_;
-
-  MethodCallResult invokeInner(
-      unsigned int reactMethodId,
-      folly::dynamic &&params);
-};
-
 } // namespace react
 } // namespace facebook

package/ReactAndroid/src/main/jni/react/jni/ProxyExecutor.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <cxxreact/JSExecutor.h>
+#include <cxxreact/RAMBundleRegistry.h>
 #include <fbjni/fbjni.h>
 #include <jni.h>
 #include "OnLoad.h"

package/ReactAndroid/src/main/jni/third-party/boost/Android.mk

@@ -1,9 +1,14 @@
-LOCAL_PATH:= $(call my-dir)
+LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 
+# These ASM files are picked from the boost release separately,
+# because the react native version does not include anything outside of headers.
+# They are required for Folly futures to compile successfully.
+LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/asm/$(TARGET_ARCH)/*.S)
+
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/boost_1_63_0
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/boost_1_63_0
 
-LOCAL_MODULE    := boost
+LOCAL_MODULE := boost
 
 include $(BUILD_STATIC_LIBRARY)

package/ReactAndroid/src/main/jni/third-party/boost/asm/arm/jump_arm_aapcs_elf_gas.S

@@ -0,0 +1,86 @@
+/*
+            Copyright Oliver Kowalke 2009.
+   Distributed under the Boost Software License, Version 1.0.
+      (See accompanying file LICENSE_1_0.txt or copy at
+          http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/*******************************************************
+ *                                                     *
+ *  -------------------------------------------------  *
+ *  |  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  *
+ *  -------------------------------------------------  *
+ *  | 0x0 | 0x4 | 0x8 | 0xc | 0x10| 0x14| 0x18| 0x1c|  *
+ *  -------------------------------------------------  *
+ *  | s16 | s17 | s18 | s19 | s20 | s21 | s22 | s23 |  *
+ *  -------------------------------------------------  *
+ *  -------------------------------------------------  *
+ *  |  8  |  9  |  10 |  11 |  12 |  13 |  14 |  15 |  *
+ *  -------------------------------------------------  *
+ *  | 0x20| 0x24| 0x28| 0x2c| 0x30| 0x34| 0x38| 0x3c|  *
+ *  -------------------------------------------------  *
+ *  | s24 | s25 | s26 | s27 | s28 | s29 | s30 | s31 |  *
+ *  -------------------------------------------------  *
+ *  -------------------------------------------------  *
+ *  |  16 |  17 |  18 |  19 |  20 |  21 |  22 |  23 |  *
+ *  -------------------------------------------------  *
+ *  | 0x40| 0x44| 0x48| 0x4c| 0x50| 0x54| 0x58| 0x5c|  *
+ *  -------------------------------------------------  *
+ *  |hiddn|  v1 |  v2 |  v3 |  v4 |  v5 |  v6 |  v7 |  *
+ *  -------------------------------------------------  *
+ *  -------------------------------------------------  *
+ *  |  24 |  25 |  26 |  27 |  28 |  29 |  30 |  31 |  *
+ *  -------------------------------------------------  *
+ *  | 0x60| 0x64| 0x68| 0x6c| 0x70| 0x74| 0x78| 0x7c|  *
+ *  -------------------------------------------------  *
+ *  |  v8 |  lr |  pc | FCTX| DATA|                 |  *
+ *  -------------------------------------------------  *
+ *                                                     *
+ *******************************************************/
+
+.text
+.globl jump_fcontext
+.align 2
+.type jump_fcontext,%function
+jump_fcontext:
+    @ save LR as PC
+    push {lr}
+    @ save hidden,V1-V8,LR
+    push {a1,v1-v8,lr}
+
+    @ prepare stack for FPU
+    sub  sp, sp, #64
+#if (defined(__VFP_FP__) && !defined(__SOFTFP__))
+    @ save S16-S31
+    vstmia sp, {d8-d15}
+#endif
+
+    @ store RSP (pointing to context-data) in A1
+    mov  a1, sp
+
+    @ restore RSP (pointing to context-data) from A2
+    mov  sp, a2
+
+#if (defined(__VFP_FP__) && !defined(__SOFTFP__))
+    @ restore S16-S31
+    vldmia  sp, {d8-d15}
+#endif
+    @ prepare stack for FPU
+    add  sp, sp, #64
+
+    @ restore hidden,V1-V8,LR
+    pop {a4,v1-v8,lr}
+
+    @ return transfer_t from jump
+    str  a1, [a4, #0]
+    str  a3, [a4, #4]
+    @ pass transfer_t as first arg in context function
+    @ A1 == FCTX, A2 == DATA
+    mov  a2, a3
+
+    @ restore PC
+    pop {pc}
+.size jump_fcontext,.-jump_fcontext
+
+@ Mark that we don't need executable stack.
+.section .note.GNU-stack,"",%progbits