react-native-executorch 0.5.15 → 0.6.0

package/third-party/include/executorch/runtime/core/error.h

@@ -63,6 +63,12 @@ enum class Error : error_code_t {
   /// Operator(s) missing in the operator registry.
   OperatorMissing = 0x14,
 
+  /// Registration error: Exceeding the maximum number of kernels.
+  RegistrationExceedingMaxKernels = 0x15,
+
+  /// Registration error: The kernel is already registered.
+  RegistrationAlreadyRegistered = 0x16,
+
   /*
    * Resource errors.
    */
@@ -95,9 +101,54 @@ enum class Error : error_code_t {
   DelegateMemoryAllocationFailed = 0x31,
   /// Execute stage: The handle is invalid.
   DelegateInvalidHandle = 0x32,
-
 };
 
+// Stringify the Error enum.
+constexpr const char *to_string(const Error error) {
+  switch (error) {
+  case Error::Ok:
+    return "Error::Ok";
+  case Error::Internal:
+    return "Error::Internal";
+  case Error::InvalidState:
+    return "Error::InvalidState";
+  case Error::EndOfMethod:
+    return "Error::EndOfMethod";
+  case Error::NotSupported:
+    return "Error::NotSupported";
+  case Error::NotImplemented:
+    return "Error::NotImplemented";
+  case Error::InvalidArgument:
+    return "Error::InvalidArgument";
+  case Error::InvalidType:
+    return "Error::InvalidType";
+  case Error::OperatorMissing:
+    return "Error::OperatorMissing";
+  case Error::NotFound:
+    return "Error::NotFound";
+  case Error::MemoryAllocationFailed:
+    return "Error::MemoryAllocationFailed";
+  case Error::AccessFailed:
+    return "Error::AccessFailed";
+  case Error::InvalidProgram:
+    return "Error::InvalidProgram";
+  case Error::InvalidExternalData:
+    return "Error::InvalidExternalData";
+  case Error::OutOfResources:
+    return "Error::OutOfResources";
+  case Error::DelegateInvalidCompatibility:
+    return "Error::DelegateInvalidCompatibility";
+  case Error::DelegateMemoryAllocationFailed:
+    return "Error::DelegateMemoryAllocationFailed";
+  case Error::DelegateInvalidHandle:
+    return "Error::DelegateInvalidHandle";
+  case Error::RegistrationExceedingMaxKernels:
+    return "Error::RegistrationExceedingMaxKernels";
+  case Error::RegistrationAlreadyRegistered:
+    return "Error::RegistrationAlreadyRegistered";
+  }
+}
+
 } // namespace runtime
 } // namespace executorch
 
@@ -154,42 +205,36 @@ using ::executorch::runtime::error_code_t;
  * @param[in] ... Optional format string for the log error message and its
  * arguments.
  */
-#define ET_CHECK_OK_OR_RETURN_ERROR(error__, ...)                              \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR(error__, ##__VA_ARGS__)
-
-// Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR(...)                              \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_SELECT(__VA_ARGS__, 10, 9, 8, 7, 6, 5,  \
-                                              4, 3, 2, 1)                      \
-  (__VA_ARGS__)
+#define ET_CHECK_OK_OR_RETURN_ERROR(...)                                       \
+  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR(__VA_ARGS__)
 
 /**
  * Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
  * This macro selects the correct version of
  * ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR based on the number of arguments passed.
- * It uses a trick with the preprocessor to count the number of arguments and
- * then selects the appropriate macro.
- *
- * The macro expansion uses __VA_ARGS__ to accept any number of arguments and
- * then appends them to ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_, followed by the
- * count of arguments. The count is determined by the macro
- * ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_SELECT which takes the arguments and
- * passes them along with a sequence of numbers (2, 1). The preprocessor then
- * matches this sequence to the correct number of arguments provided.
- *
- * If two arguments are passed, ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2 is
- * selected, suitable for cases where an error code and a custom message are
- * provided. If only one argument is passed,
- * ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_1 is selected, which is used for cases
- * with just an error code.
- *
- * Usage:
- * ET_CHECK_OK_OR_RETURN_ERROR(error_code); // Calls v1
- * ET_CHECK_OK_OR_RETURN_ERROR(error_code, "Error message", ...); // Calls v2
+ * It uses a helper that reliably picks the 1-arg or 2+-arg form on
+ * MSVC/Clang/GCC.
  */
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_SELECT(_1, _2, _3, _4, _5, _6,    \
-                                                    _7, _8, _9, _10, N, ...)   \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_##N
+#define ET_INTERNAL_EXPAND(x) x
+#define ET_INTERNAL_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, NAME,   \
+                              ...)                                             \
+  NAME
+
+// Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
+// Picks _2 for 2..10 args, _1 for exactly 1 arg.
+#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR(...)                              \
+  ET_INTERNAL_EXPAND(ET_INTERNAL_GET_MACRO(                                    \
+      __VA_ARGS__, ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2, /* 10 */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 9  */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 8  */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 7  */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 6  */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 5  */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 4  */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 3  */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 2  */            \
+      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_1               /* 1  */            \
+      )(__VA_ARGS__))
 
 // Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
 #define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_1(error__)                        \
@@ -209,21 +254,3 @@ using ::executorch::runtime::error_code_t;
       return et_error__;                                                       \
     }                                                                          \
   } while (0)
-
-// Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_3                                 \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_4                                 \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_5                                 \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_6                                 \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_7                                 \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_8                                 \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_9                                 \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_10                                \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2

package/third-party/include/executorch/runtime/core/exec_aten/util/scalar_type_util.h

@@ -867,14 +867,14 @@ public:
 #define ET_INTERNAL_SWITCH_CASE(enum_type, CTYPE_ALIAS, ...)                   \
   case enum_type: {                                                            \
     ET_INTERNAL_CHECK_SELECTIVE_BUILD(enum_type);                              \
-    using CTYPE_ALIAS =                                                        \
+    using CTYPE_ALIAS [[maybe_unused]] =                                       \
         ::executorch::runtime::ScalarTypeToCppType<enum_type>::type;           \
     return __VA_ARGS__();                                                      \
   }
 #else
 #define ET_INTERNAL_SWITCH_CASE(enum_type, CTYPE_ALIAS, ...)                   \
   case enum_type: {                                                            \
-    using CTYPE_ALIAS =                                                        \
+    using CTYPE_ALIAS [[maybe_unused]] =                                       \
         ::executorch::runtime::ScalarTypeToCppType<enum_type>::type;           \
     return __VA_ARGS__();                                                      \
   }
@@ -888,8 +888,9 @@ public:
     switch (_st) {                                                             \
       __VA_ARGS__                                                              \
     default:                                                                   \
-      ET_CHECK_MSG(false, "Unhandled dtype %s for %s",                         \
-                   ::executorch::runtime::toString(_st), et_switch_name);      \
+      CONTEXT.fail(torch::executor::Error::InvalidArgument);                   \
+      ET_LOG(Error, "Unhandled dtype %s for %s",                               \
+             ::executorch::runtime::toString(_st), et_switch_name);            \
     }                                                                          \
   }()
 
@@ -1236,6 +1237,19 @@ public:
               ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T3,      \
                                       CTYPE_ALIAS, __VA_ARGS__))
 
+#define ET_SWITCH_FOUR_TYPES(T1, T2, T3, T4, TYPE, CONTEXT, NAME, CTYPE_ALIAS, \
+                             ...)                                              \
+  ET_INTERNAL_SWITCH(                                                          \
+      TYPE, CONTEXT, NAME,                                                     \
+      ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T1, CTYPE_ALIAS, \
+                              __VA_ARGS__)                                     \
+          ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T2,          \
+                                  CTYPE_ALIAS, __VA_ARGS__)                    \
+              ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T3,      \
+                                      CTYPE_ALIAS, __VA_ARGS__)                \
+                  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T4,  \
+                                          CTYPE_ALIAS, __VA_ARGS__))
+
 } // namespace runtime
 } // namespace executorch
 

package/third-party/include/executorch/runtime/core/memory_allocator.h

@@ -12,6 +12,8 @@
 #include <cstdint>
 #include <stdio.h>
 
+#include <c10/util/safe_numerics.h>
+
 #include <executorch/runtime/core/error.h>
 #include <executorch/runtime/platform/assert.h>
 #include <executorch/runtime/platform/compiler.h>
@@ -82,7 +84,7 @@ public:
 
     // If the end of this allocation exceeds the end of this allocator, print
     // error messages and return nullptr
-    if (end > end_) {
+    if (end > end_ || end < start) {
       ET_LOG(Error,
              "Memory allocation failed: %zuB requested (adjusted for "
              "alignment), %zuB available",
@@ -133,7 +135,15 @@ public:
     // Some users of this method allocate lists of pointers, causing the next
     // line to expand to `sizeof(type *)`, which triggers a clang-tidy warning.
     // NOLINTNEXTLINE(bugprone-sizeof-expression)
-    return static_cast<T *>(this->allocate(size * sizeof(T), alignment));
+    size_t bytes_size = 0;
+    bool overflow = c10::mul_overflows(size, sizeof(T), &bytes_size);
+    if (overflow) {
+      ET_LOG(Error,
+             "Failed to allocate list of type %zu: size * sizeof(T) overflowed",
+             size);
+      return nullptr;
+    }
+    return static_cast<T *>(this->allocate(bytes_size, alignment));
   }
 
   // Returns the allocator memory's base address.

package/third-party/include/executorch/runtime/core/named_data_map.h

@@ -8,12 +8,6 @@
 
 #pragma once
 
-#ifdef __GNUC__
-// Disable -Wdeprecated-declarations, as some builds use 'Werror'.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
 #include <executorch/runtime/core/freeable_buffer.h>
 #include <executorch/runtime/core/result.h>
@@ -27,7 +21,7 @@ namespace ET_RUNTIME_NAMESPACE {
  * Interface to access and retrieve data via name.
  * See executorch/extension/flat_tensor/ for an example.
  */
-class ET_EXPERIMENTAL NamedDataMap {
+class NamedDataMap {
 public:
   virtual ~NamedDataMap() = default;
   /**
@@ -80,7 +74,3 @@ public:
 
 } // namespace ET_RUNTIME_NAMESPACE
 } // namespace executorch
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif

package/third-party/include/executorch/runtime/core/portable_type/c10/c10/macros/Export.h

@@ -1,79 +1 @@
-#define C10_USING_CUSTOM_GENERATED_MACROS
-#ifndef C10_MACROS_EXPORT_H_
-#define C10_MACROS_EXPORT_H_
-
-#ifndef C10_USING_CUSTOM_GENERATED_MACROS
-#include <c10/macros/cmake_macros.h>
-#endif // C10_USING_CUSTOM_GENERATED_MACROS
-
 #include <torch/headeronly/macros/Export.h>
-
-// This one is being used by libtorch.so
-#ifdef CAFFE2_BUILD_MAIN_LIB
-#define TORCH_API C10_EXPORT
-#else
-#define TORCH_API C10_IMPORT
-#endif
-
-// You may be wondering: Whose brilliant idea was it to split torch_cuda into
-// two pieces with confusing names?
-// Once upon a time, there _was_ only TORCH_CUDA_API. All was happy until we
-// tried to compile PyTorch for CUDA 11.1, which ran into relocation marker
-// issues when linking big binaries.
-// (https://github.com/pytorch/pytorch/issues/39968) We had two choices:
-//    (1) Stop supporting so many GPU architectures
-//    (2) Do something else
-// We chose #2 and decided to split the behemoth that was torch_cuda into two
-// smaller libraries, one with most of the core kernel functions (torch_cuda_cu)
-// and the other that had..well..everything else (torch_cuda_cpp). The idea was
-// this: instead of linking our static libraries (like the hefty
-// libcudnn_static.a) with another huge library, torch_cuda, and run into pesky
-// relocation marker issues, we could link our static libraries to a smaller
-// part of torch_cuda (torch_cuda_cpp) and avoid the issues.
-
-// libtorch_cuda_cu.so
-#ifdef TORCH_CUDA_CU_BUILD_MAIN_LIB
-#define TORCH_CUDA_CU_API C10_EXPORT
-#elif defined(BUILD_SPLIT_CUDA)
-#define TORCH_CUDA_CU_API C10_IMPORT
-#endif
-
-// libtorch_cuda_cpp.so
-#ifdef TORCH_CUDA_CPP_BUILD_MAIN_LIB
-#define TORCH_CUDA_CPP_API C10_EXPORT
-#elif defined(BUILD_SPLIT_CUDA)
-#define TORCH_CUDA_CPP_API C10_IMPORT
-#endif
-
-// libtorch_cuda.so (where torch_cuda_cu and torch_cuda_cpp are a part of the
-// same api)
-#ifdef TORCH_CUDA_BUILD_MAIN_LIB
-#define TORCH_CUDA_CPP_API C10_EXPORT
-#define TORCH_CUDA_CU_API C10_EXPORT
-#elif !defined(BUILD_SPLIT_CUDA)
-#define TORCH_CUDA_CPP_API C10_IMPORT
-#define TORCH_CUDA_CU_API C10_IMPORT
-#endif
-
-#if defined(TORCH_HIP_BUILD_MAIN_LIB)
-#define TORCH_HIP_CPP_API C10_EXPORT
-#define TORCH_HIP_API C10_EXPORT
-#else
-#define TORCH_HIP_CPP_API C10_IMPORT
-#define TORCH_HIP_API C10_IMPORT
-#endif
-
-#if defined(TORCH_XPU_BUILD_MAIN_LIB)
-#define TORCH_XPU_API C10_EXPORT
-#else
-#define TORCH_XPU_API C10_IMPORT
-#endif
-
-// Enums only need to be exported on windows for non-CUDA files
-#if defined(_WIN32) && defined(__CUDACC__)
-#define C10_API_ENUM C10_API
-#else
-#define C10_API_ENUM
-#endif
-
-#endif // C10_MACROS_EXPORT_H_