xmos-ai-tools 1.1.2.dev216__py3-none-macosx_11_0_arm64.whl → 1.1.2.dev236__py3-none-macosx_11_0_arm64.whl

xmos_ai_tools/runtime/include/signal/src/overlap_add.h

@@ -0,0 +1,46 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef SIGNAL_SRC_OVERLAP_ADD_H_
+#define SIGNAL_SRC_OVERLAP_ADD_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace tflm_signal {
+// Adds (with saturation) the contents of `input` to the contents of `buffer`,
+// both of size `input_size`, then copies the first `output_size` elements of
+// `buffer` to `output`, shifts the last `input_size`-`output_size` elements of
+// `buffer` to the beginning of `buffer` and fills the trailing `output_size`
+// samples in `buffer` with zeros.
+// input: {input[0] ... input[input_size-1]}
+// buffer: {buffer[0] ... buffer[input_size-1]}
+// After invocation:
+// output: {saturate(input[0] + buffer[0]),
+//          ... ,
+//          saturate(input[output_size-1] + buffer[output_size-1])}
+// buffer: {saturate(input[output_size] + buffer[output_size]),
+//          ...
+//          saturate(  input[input_size-output_size-1]
+//                   + buffer[input_size-output_size-1]),
+//          zeros(output_size)}
+void OverlapAdd(const int16_t* input, int16_t* buffer, int input_size,
+                int16_t* output, int output_size);
+
+// The same as the int16_t variant above, but without saturation
+void OverlapAdd(const float* input, float* buffer, int input_size,
+                float* output, int output_size);
+
+}  //  namespace tflm_signal
+#endif  // SIGNAL_SRC_OVERLAP_ADD_H_

xmos_ai_tools/runtime/include/signal/src/pcan_argc_fixed.h

@@ -0,0 +1,41 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_MICRO_KERNELS__SRC_PCAN_AGC_FIXED_H
+#define SIGNAL_MICRO_KERNELS__SRC_PCAN_AGC_FIXED_H
+#include <cstdint>
+
+#include "msb.h"
+#include "tensorflow/lite/kernels/internal/compatibility.h"
+
+namespace tflite {
+namespace tflm_signal {
+
+#define kPcanSnrBits 12
+#define kPcanOutputBits 6
+
+int16_t WideDynamicFunction(const uint32_t x, const int16_t* lut);
+
+uint32_t PcanShrink(const uint32_t x);
+
+void ApplyPcanAutoGainControlFixed(const int16_t* gain_lut, int32_t snr_shift,
+                                   const uint32_t* noise_estimate,
+                                   uint32_t* filterbank_output,
+                                   int num_channels);
+
+}  // namespace tflm_signal
+}  // namespace tflite
+
+#endif  // SIGNAL_MICRO_KERNELS__PCAN_AGC_FIXED_H

xmos_ai_tools/runtime/include/signal/src/rfft.h

@@ -0,0 +1,85 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_RFFT_H_
+#define SIGNAL_SRC_RFFT_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "signal/src/complex.h"
+
+// TODO(b/286250473): remove namespace once de-duped libraries
+namespace tflm_signal {
+
+// RFFT (Real Fast Fourier Transform)
+// FFT for real valued time domain inputs.
+
+// 16-bit Integer input/output
+
+// Returns the size of the memory that an RFFT of `fft_length` needs
+size_t RfftInt16GetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an RFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  RfftGetNeededMemory(fft_length).
+// Return the value of `state` on success or nullptr on failure
+void* RfftInt16Init(int32_t fft_length, void* state, size_t state_size);
+
+// Applies RFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see RfftInit)
+// * `output` must be of size (`fft_length` * 2) + 1 elements
+void RfftInt16Apply(void* state, const int16_t* input,
+                    Complex<int16_t>* output);
+
+// 32-bit Integer input/output
+
+// Returns the size of the memory that an RFFT of `fft_length` needs
+size_t RfftInt32GetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an RFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  RfftGetNeededMemory(fft_length).
+// Return the value of `state` on success or nullptr on failure
+void* RfftInt32Init(int32_t fft_length, void* state, size_t state_size);
+
+// Applies RFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see RfftInit)
+// * `output` must be of size (`fft_length` * 2) + 1 elements
+void RfftInt32Apply(void* state, const int32_t* input,
+                    Complex<int32_t>* output);
+
+// Floating point input/output
+
+// Returns the size of the memory that an RFFT of `fft_length` needs
+size_t RfftFloatGetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an RFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  RfftGetNeededMemory(fft_length).
+// Return the value of `state` on success or nullptr on failure
+void* RfftFloatInit(int32_t fft_length, void* state, size_t state_size);
+
+// Applies RFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see RfftInit)
+// * `output` must be of size (`fft_length` * 2) + 1 elements
+void RfftFloatApply(void* state, const float* input, Complex<float>* output);
+
+}  // namespace tflm_signal
+
+#endif  // SIGNAL_SRC_RFFT_H_

xmos_ai_tools/runtime/include/signal/src/square_root.h

@@ -0,0 +1,32 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_SQUARE_ROOT_H_
+#define SIGNAL_SRC_SQUARE_ROOT_H_
+
+#include <stdint.h>
+
+namespace tflite {
+namespace tflm_signal {
+// TODO(b/286250473): remove namespace once de-duped libraries above
+
+// Square root
+uint16_t Sqrt32(uint32_t num);
+uint32_t Sqrt64(uint64_t num);
+
+}  // namespace tflm_signal
+}  // namespace tflite
+
+#endif  // SIGNAL_SRC_SQUARE_ROOT_H_

xmos_ai_tools/runtime/include/{tensorflow/lite/micro/python/interpreter/src/numpy_utils.h → signal/src/window.h}

@@ -12,22 +12,20 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 ==============================================================================*/
-#ifndef TENSORFLOW_LITE_MICRO_TOOLS_PYTHON_INTERPRETER_NUMPY_UTILS_H_
-#define TENSORFLOW_LITE_MICRO_TOOLS_PYTHON_INTERPRETER_NUMPY_UTILS_H_
 
-// Disallow Numpy 1.7 deprecated symbols.
-#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
-#include <numpy/ndarraytypes.h>
+#ifndef SIGNAL_SRC_WINDOW_H_
+#define SIGNAL_SRC_WINDOW_H_
 
-#include "tensorflow/lite/c/c_api_types.h"
+#include <stdint.h>
 
-namespace tflite {
+namespace tflm_signal {
 
-void* ImportNumpy();
-int TfLiteTypeToPyArrayType(TfLiteType tf_lite_type);
-TfLiteType TfLiteTypeFromPyType(int py_type);
-TfLiteType TfLiteTypeFromPyArray(const PyArrayObject* array);
-
-}  // namespace tflite
-
-#endif
+// Applies a window function to an input signal
+//
+// * `input` and `window` must be both of size `size` elements and are
+//    multiplied element-by element.
+// * `shift` is a right shift to apply before writing the result to `output`.
+void ApplyWindow(const int16_t* input, const int16_t* window, int size,
+                 int shift, int16_t* output);
+}  // namespace tflm_signal
+#endif  // SIGNAL_SRC_WINDOW_H_

xmos_ai_tools/runtime/include/signal/testdata/fft_test_data.h

@@ -0,0 +1,48 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef SIGNAL_TESTDATA_FFT_TEST_DATA_H_
+#define SIGNAL_TESTDATA_FFT_TEST_DATA_H_
+
+#include <cstdint>
+
+namespace tflite {
+
+/* These arrays are generated using random data. They serve to detect changes
+ * in the kernels. They do not test correctness.
+ */
+extern const int16_t kRfftInt16Length512Input[];
+extern const int16_t kRfftInt16Length512Golden[];
+
+extern const int32_t kRfftInt32Length512Input[];
+extern const int32_t kRfftInt32Length512Golden[];
+
+extern const float kRfftFloatLength512Input[];
+extern const float kRfftFloatLength512Golden[];
+
+extern const int16_t kIrfftInt16Length512Input[];
+extern const int16_t kIrfftInt16Length512Golden[];
+
+extern const int32_t kIrfftInt32Length512Input[];
+extern const int32_t kIrfftInt32Length512Golden[];
+
+extern const float kIrfftFloatLength512Input[];
+extern const float kIrfftFloatLength512Golden[];
+
+extern const int16_t kFftAutoScaleLength512Input[];
+extern const int16_t kFftAutoScaleLength512Golden[];
+
+}  // namespace tflite
+
+#endif  // SIGNAL_TESTDATA_FFT_TEST_DATA_H_

xmos_ai_tools/runtime/include/tensorflow/lite/array.h

@@ -0,0 +1,156 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_LITE_ARRAY_H_
+#define TENSORFLOW_LITE_ARRAY_H_
+
+#include <cstring>
+#include <initializer_list>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include "tensorflow/lite/core/c/common.h"
+
+namespace tflite {
+
+/// TfLite*Array helpers
+
+namespace array_internal {
+
+// Function object used as a deleter for unique_ptr holding TFLite*Array
+// objects.
+struct TfLiteArrayDeleter {
+  void operator()(TfLiteIntArray* a);
+  void operator()(TfLiteFloatArray* a);
+};
+
+// Maps T to the corresponding TfLiteArray type.
+template <class T>
+struct TfLiteArrayInfo;
+
+template <>
+struct TfLiteArrayInfo<int> {
+  using Type = TfLiteIntArray;
+};
+
+template <>
+struct TfLiteArrayInfo<float> {
+  using Type = TfLiteFloatArray;
+};
+
+}  // namespace array_internal
+
+template <class T>
+using TfLiteArrayUniquePtr =
+    std::unique_ptr<typename array_internal::TfLiteArrayInfo<T>::Type,
+                    array_internal::TfLiteArrayDeleter>;
+
+// `unique_ptr` wrapper for `TfLiteIntArray`s.
+using IntArrayUniquePtr = TfLiteArrayUniquePtr<int>;
+
+// `unique_ptr` wrapper for `TfLiteFloatArray`s.
+using FloatArrayUniquePtr = TfLiteArrayUniquePtr<float>;
+
+// Allocates a TfLiteArray of given size using malloc.
+//
+// This builds an int array by default as this is the overwhelming part of the
+// use cases.
+template <class T = int>
+TfLiteArrayUniquePtr<T> BuildTfLiteArray(int size);
+
+// Allocates a TfLiteIntArray of given size using malloc.
+template <>
+inline IntArrayUniquePtr BuildTfLiteArray<int>(const int size) {
+  return IntArrayUniquePtr(TfLiteIntArrayCreate(size));
+}
+
+// Allocates a TfLiteFloatArray of given size using malloc.
+template <>
+inline FloatArrayUniquePtr BuildTfLiteArray<float>(const int size) {
+  return FloatArrayUniquePtr(TfLiteFloatArrayCreate(size));
+}
+
+// Allocates a TFLiteArray of given size and initializes it with the given
+// values.
+//
+// `values` is expected to holds `size` elements.
+//
+// If T is explicitely specified and the type of values is not the same as T,
+// then a static_cast is performed.
+template <class T = void, class U,
+          class Type = std::conditional_t<std::is_same<T, void>::value, U, T>>
+TfLiteArrayUniquePtr<Type> BuildTfLiteArray(const int size,
+                                            const U* const values) {
+  TfLiteArrayUniquePtr<Type> array = BuildTfLiteArray<Type>(size);
+  // If size is 0, the array pointer may be null.
+  if (array && values) {
+    if (std::is_same<Type, U>::value) {
+      memcpy(array->data, values, size * sizeof(Type));
+    } else {
+      for (int i = 0; i < size; ++i) {
+        array->data[i] = static_cast<Type>(values[i]);
+      }
+    }
+  }
+  return array;
+}
+
+// Allocates a TFLiteArray and initializes it with the given array.
+//
+// `values` is expected to holds `size` elements.
+template <class T, size_t N>
+TfLiteArrayUniquePtr<T> BuildTfLiteArray(const T (&values)[N]) {
+  return BuildTfLiteArray<T>(static_cast<int>(N), values);
+}
+
+// Allocates a TFLiteArray and initializes it with the given values.
+//
+// This uses SFINAE to only be picked up by for types that implement `data()`
+// and `size()` member functions. We cannot reuse detection facilities provided
+// by Abseil in this code.
+//
+// To conform with the other overloads, we allow specifying the type of the
+// array as well as deducing it from the container.
+template <
+    class T = void, class Container,
+    class ElementType =
+        std::decay_t<decltype(*std::declval<Container>().data())>,
+    class SizeType = std::decay_t<decltype(std::declval<Container>().size())>,
+    class Type =
+        std::conditional_t<std::is_same<T, void>::value, ElementType, T>>
+TfLiteArrayUniquePtr<Type> BuildTfLiteArray(const Container& values) {
+  return BuildTfLiteArray<Type>(static_cast<int>(values.size()), values.data());
+}
+
+// Allocates a TFLiteArray and initializes it with the given values.
+template <class T>
+TfLiteArrayUniquePtr<T> BuildTfLiteArray(
+    const std::initializer_list<T>& values) {
+  return BuildTfLiteArray(static_cast<int>(values.size()), values.begin());
+}
+
+// Allocates a TFLiteArray and initializes it with the given array.
+inline IntArrayUniquePtr BuildTfLiteArray(const TfLiteIntArray& other) {
+  return BuildTfLiteArray(other.size, other.data);
+}
+
+// Allocates a TFLiteArray and initializes it with the given array.
+inline FloatArrayUniquePtr BuildTfLiteArray(const TfLiteFloatArray& other) {
+  return BuildTfLiteArray(other.size, other.data);
+}
+
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_ARRAY_H_

xmos_ai_tools/runtime/include/tensorflow/lite/builtin_ops.h

@@ -189,6 +189,50 @@ typedef enum {
   kTfLiteBuiltinBitcast = 159,
   kTfLiteBuiltinBitwiseXor = 160,
   kTfLiteBuiltinRightShift = 161,
+  kTfLiteBuiltinStablehloLogistic = 162,
+  kTfLiteBuiltinStablehloAdd = 163,
+  kTfLiteBuiltinStablehloDivide = 164,
+  kTfLiteBuiltinStablehloMultiply = 165,
+  kTfLiteBuiltinStablehloMaximum = 166,
+  kTfLiteBuiltinStablehloReshape = 167,
+  kTfLiteBuiltinStablehloClamp = 168,
+  kTfLiteBuiltinStablehloConcatenate = 169,
+  kTfLiteBuiltinStablehloBroadcastInDim = 170,
+  kTfLiteBuiltinStablehloConvolution = 171,
+  kTfLiteBuiltinStablehloSlice = 172,
+  kTfLiteBuiltinStablehloCustomCall = 173,
+  kTfLiteBuiltinStablehloReduce = 174,
+  kTfLiteBuiltinStablehloAbs = 175,
+  kTfLiteBuiltinStablehloAnd = 176,
+  kTfLiteBuiltinStablehloCosine = 177,
+  kTfLiteBuiltinStablehloExponential = 178,
+  kTfLiteBuiltinStablehloFloor = 179,
+  kTfLiteBuiltinStablehloLog = 180,
+  kTfLiteBuiltinStablehloMinimum = 181,
+  kTfLiteBuiltinStablehloNegate = 182,
+  kTfLiteBuiltinStablehloOr = 183,
+  kTfLiteBuiltinStablehloPower = 184,
+  kTfLiteBuiltinStablehloRemainder = 185,
+  kTfLiteBuiltinStablehloRsqrt = 186,
+  kTfLiteBuiltinStablehloSelect = 187,
+  kTfLiteBuiltinStablehloSubtract = 188,
+  kTfLiteBuiltinStablehloTanh = 189,
+  kTfLiteBuiltinStablehloScatter = 190,
+  kTfLiteBuiltinStablehloCompare = 191,
+  kTfLiteBuiltinStablehloConvert = 192,
+  kTfLiteBuiltinStablehloDynamicSlice = 193,
+  kTfLiteBuiltinStablehloDynamicUpdateSlice = 194,
+  kTfLiteBuiltinStablehloPad = 195,
+  kTfLiteBuiltinStablehloIota = 196,
+  kTfLiteBuiltinStablehloDotGeneral = 197,
+  kTfLiteBuiltinStablehloReduceWindow = 198,
+  kTfLiteBuiltinStablehloSort = 199,
+  kTfLiteBuiltinStablehloWhile = 200,
+  kTfLiteBuiltinStablehloGather = 201,
+  kTfLiteBuiltinStablehloTranspose = 202,
+  kTfLiteBuiltinDilate = 203,
+  kTfLiteBuiltinStablehloRngBitGenerator = 204,
+  kTfLiteBuiltinReduceWindow = 205,
 } TfLiteBuiltinOperator;
 
 #ifdef __cplusplus

xmos_ai_tools/runtime/include/tensorflow/lite/c/c_api_types.h

@@ -15,6 +15,12 @@ limitations under the License.
 #ifndef TENSORFLOW_LITE_C_C_API_TYPES_H_
 #define TENSORFLOW_LITE_C_C_API_TYPES_H_
 
+/// \file
+///
+/// C API types for TensorFlow Lite.
+///
+/// For documentation, see tensorflow/lite/core/c/c_api_types.h
+
 #include "tensorflow/lite/core/c/c_api_types.h"
 
 #endif  // TENSORFLOW_LITE_C_C_API_TYPES_H_

xmos_ai_tools/runtime/include/tensorflow/lite/c/common.h

@@ -13,35 +13,18 @@ See the License for the specific language governing permissions and
 limitations under the License.
 ==============================================================================*/
 
-// This file defines common C types and APIs for implementing operations,
-// delegates and other constructs in TensorFlow Lite. The actual operations and
-// delegates can be defined using C++, but the interface between the interpreter
-// and the operations are C.
-//
-// Summary of abstractions
-// TF_LITE_ENSURE - Self-sufficient error checking
-// TfLiteStatus - Status reporting
-// TfLiteIntArray - stores tensor shapes (dims),
-// TfLiteContext - allows an op to access the tensors
-// TfLiteTensor - tensor (a multidimensional array)
-// TfLiteNode - a single node or operation
-// TfLiteRegistration - the implementation of a conceptual operation.
-// TfLiteDelegate - allows delegation of nodes to alternative backends.
-//
-// Some abstractions in this file are created and managed by Interpreter.
-//
-// NOTE: The order of values in these structs are "semi-ABI stable". New values
-// should be added only to the end of structs and never reordered.
+/// \file
+///
+/// This file defines common C types and APIs for implementing operations,
+/// delegates and other constructs in TensorFlow Lite. The actual operations and
+/// delegates can be defined using C++, but the interface between the
+/// interpreter and the operations are C.
+///
+/// For documentation, see tensorflow/lite/core/c/common.h.
 
 #ifndef TENSORFLOW_LITE_C_COMMON_H_
 #define TENSORFLOW_LITE_C_COMMON_H_
 
 #include "tensorflow/lite/core/c/common.h"
 
-// TfLiteOpaqueDelegate: allows delegation of nodes to alternative backends.
-// TfLiteOpaqueDelegate is an abstract type that is intended to have the same
-// role as TfLiteDelegate, but without necessarily exposing the implementation
-// details of how delegates are implemented.
-typedef TfLiteDelegate TfLiteOpaqueDelegate;
-
 #endif  // TENSORFLOW_LITE_C_COMMON_H_

xmos_ai_tools/runtime/include/tensorflow/lite/core/api/error_reporter.h

@@ -61,9 +61,9 @@ class ErrorReporter {
 // reduce binary size, define TF_LITE_STRIP_ERROR_STRINGS when compiling and
 // every call will be stubbed out, taking no memory.
 #ifndef TF_LITE_STRIP_ERROR_STRINGS
-#define TF_LITE_REPORT_ERROR(reporter, ...)                             \
-  do {                                                                  \
-    static_cast<tflite::ErrorReporter*>(reporter)->Report(__VA_ARGS__); \
+#define TF_LITE_REPORT_ERROR(reporter, ...)                               \
+  do {                                                                    \
+    static_cast<::tflite::ErrorReporter*>(reporter)->Report(__VA_ARGS__); \
   } while (false)
 #else  // TF_LITE_STRIP_ERROR_STRINGS
 #define TF_LITE_REPORT_ERROR(reporter, ...)

xmos_ai_tools/runtime/include/tensorflow/lite/core/api/flatbuffer_conversions.h

@@ -420,6 +420,21 @@ TfLiteStatus ParseRightShift(const Operator* op, ErrorReporter* error_reporter,
                              BuiltinDataAllocator* allocator,
                              void** builtin_data);
 
+TfLiteStatus ParseStablehloScatter(const Operator* op,
+                                   ErrorReporter* error_reporter,
+                                   BuiltinDataAllocator* allocator,
+                                   void** builtin_data);
+
+TfLiteStatus ParseStablehloRngBitGenerator(const Operator* op,
+                                           ErrorReporter* error_reporter,
+                                           BuiltinDataAllocator* allocator,
+                                           void** builtin_data);
+
+TfLiteStatus ParseStablehloGather(const Operator* op,
+                                  ErrorReporter* error_reporter,
+                                  BuiltinDataAllocator* allocator,
+                                  void** builtin_data);
+
 }  // namespace tflite
 
 #endif  // TENSORFLOW_LITE_CORE_API_FLATBUFFER_CONVERSIONS_H_