Fix -Werror diagnostics in vendored runtime and kernel sources

On toolchains where int32_t and uint32_t are long (the Xtensa and RISC-V
ESP-IDF toolchains, and arm-none-eabi-gcc), log and check messages that pass
them to %d or %u trip -Wformat. ESP-IDF builds with -Werror, so its component
currently compiles the vendored ExecuTorch sources with a blanket -Wno-error;
these fixes let the next change narrow that.

The runtime, flat_tensor and portable kernel sources now use PRId32/PRIu32, or
cast to int where the rest of a message already does. ET_PRI_SIZES_AND_STRIDES,
the format for elements of sizes() and strides(), was "d" in lean mode, which is
wrong for int32_t on these toolchains, so its users such as extension/tensor's
tensor_ptr.cpp failed -Werror=format there. It is now PRId32, which is "d"
wherever int32_t is int. The size and stride messages in op_fft_r2c and in the
ET_CHECK_CONTIGUOUS and ET_CHECK_SAME_STRIDES macros of tensor_util.h use it,
so the STRIDES macros no longer truncate ATen-mode strides to int32_t, and those
macros loop over and print dimensions as size_t, which kernels outside this
tree also get.

Other diagnostics that ESP-IDF turns into errors are fixed in the same sources:
an always-true `index >= 0` on a uint32_t in flat_tensor, a cast to a
const-qualified type in native_dropout, prod's `*=` on bool outputs
(-Wint-in-bool-context), missing parentheses in ET_CHECK_SAME_SHAPE3, and
always_inline on non-inline templates in the Cadence generic im2row operators,
which now use ET_INLINE. prod's bool product, in both prod_out and prod_int_out,
is now `&&` through a template helper, because `if constexpr` only discards a
branch inside a template; results are unchanged for every dtype.

Verified by compiling every vendored runtime and kernel source (281) as the
generated component builds them for esp32s3 and esp32c6, under ESP-IDF 6.1's
-Wall -Werror, at both -Os and -Og; by compiling extension/tensor/tensor_ptr.cpp
and the tensor_util.h check macros with both ESP-IDF toolchains under
-Werror=format and on host in ATen mode; and by running the component's
emulator tests. On host, portable_kernels_test and the exec_aten util tests
pass.

Authored with Claude Code.

Author: rascani

backends/cadence/generic/operators/op_im2row.cpp

@@ -9,12 +9,7 @@
 #include <executorch/backends/cadence/generic/operators/op_im2row.h>
 
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-
-#ifndef DISABLE_ALWAYS_INLINE
-#define ALWAYS_INLINE __attribute__((always_inline))
-#else
-#define ALWAYS_INLINE inline
-#endif
+#include <executorch/runtime/platform/compiler.h>
 
 namespace impl {
 namespace generic {
@@ -26,7 +21,7 @@ using ::executorch::aten::Tensor;
 using ::executorch::runtime::KernelRuntimeContext;
 
 template <typename T>
-ALWAYS_INLINE void im2row_(
+ET_INLINE void im2row_(
     const T* __restrict__ data_im,
     const int32_t in_zero_point,
     /* input parameters*/

backends/cadence/generic/operators/op_transposed_im2row.cpp

@@ -12,12 +12,7 @@
 
 #include <executorch/backends/cadence/generic/kernels/kernels.h>
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-
-#ifndef DISABLE_ALWAYS_INLINE
-#define ALWAYS_INLINE __attribute__((always_inline))
-#else
-#define ALWAYS_INLINE inline
-#endif
+#include <executorch/runtime/platform/compiler.h>
 
 namespace impl {
 namespace generic {
@@ -29,7 +24,7 @@ using ::executorch::aten::Tensor;
 using ::executorch::runtime::KernelRuntimeContext;
 
 template <typename T>
-ALWAYS_INLINE void transposed_im2row_(
+ET_INLINE void transposed_im2row_(
     const T* __restrict__ data_im,
     const int32_t in_zero_point,
     /* input parameters*/

extension/flat_tensor/flat_tensor_data_map.cpp

@@ -74,7 +74,8 @@ Result<const flat_tensor_flatbuffer::NamedData*> get_named_data(
       ET_CHECK_OR_RETURN_ERROR(
           segment_index < segments->size(),
           InvalidExternalData,
-          "Segment index %zu for key %.*s is out of bounds for segment size %d. Malformed PTD file.",
+          "Segment index %zu for key %.*s is out of bounds for segment size %" PRIu32
+          ". Malformed PTD file.",
           static_cast<size_t>(segment_index),
           static_cast<int>(key.size()),
           key.data(),
@@ -255,9 +256,9 @@ ET_NODISCARD Result<const char*> FlatTensorDataMap::get_key(
     uint32_t index) const {
   uint32_t num_keys = get_num_keys().get();
   ET_CHECK_OR_RETURN_ERROR(
-      index >= 0 && index < num_keys,
+      index < num_keys,
       InvalidArgument,
-      "Index %u out of range of size %u",
+      "Index %" PRIu32 " out of range of size %" PRIu32,
       index,
       num_keys);
   return flat_tensor_->named_data()->Get(index)->key()->c_str();
@@ -280,7 +281,8 @@ ET_NODISCARD Result<const char*> FlatTensorDataMap::get_key(
   ET_CHECK_OR_RETURN_ERROR(
       fh.ok(),
       InvalidExternalData,
-      "Failed to parse FlatTensor header with error code %u. File may be corrupt.",
+      "Failed to parse FlatTensor header with error code %" PRIu32
+      ". File may be corrupt.",
       static_cast<uint32_t>(fh.error()));
 
   Result<uint64_t> expected_size = get_segment_end_offset(fh.get());
@@ -366,7 +368,7 @@ ET_NODISCARD Result<const char*> FlatTensorDataMap::get_key(
           root_offset <=
               flat_tensor_data->size() - sizeof(flatbuffers::soffset_t),
       InvalidExternalData,
-      "FlatTensor root table offset %u is invalid for data size %zu",
+      "FlatTensor root table offset %" PRIu32 " is invalid for data size %zu",
       root_offset,
       flat_tensor_data->size());
 
@@ -383,9 +385,9 @@ ET_NODISCARD Result<const char*> FlatTensorDataMap::get_key(
   ET_CHECK_OR_RETURN_ERROR(
       flat_tensor->version() <= kMaxSupportedSchemaVersion,
       InvalidExternalData,
-      "FlatTensor schema version %u is newer than the highest this runtime "
-      "supports (%u). Export the data with an older ExecuTorch, or update the "
-      "runtime.",
+      "FlatTensor schema version %" PRIu32
+      " is newer than the highest this runtime supports (%" PRIu32
+      "). Export the data with an older ExecuTorch, or update the runtime.",
       flat_tensor->version(),
       kMaxSupportedSchemaVersion);
 

kernels/portable/cpu/op_fft_r2c.cpp

@@ -252,7 +252,8 @@ Tensor& _fft_r2c_out(
               out_sizes.data(), out_sizes.size())) == Error::Ok,
       InvalidArgument,
       out,
-      "Failed to resize output tensor (last dim %d).",
+      "Failed to resize output tensor (last dim %" ET_PRI_SIZES_AND_STRIDES
+      ").",
       out_sizes[dim.back()]);
 
   // NOTE: as of this writing, upstream PyTorch only supports float/double, so

kernels/portable/cpu/op_native_dropout.cpp

@@ -63,7 +63,7 @@ std::tuple<Tensor&, Tensor&> native_dropout_out(
               utils::SupportedTensorDtypes::SAME_AS_COMMON>(
               [](const CTYPE_COMPUTE val, const CTYPE_COMPUTE mask_val) {
                 if (!mask_val) {
-                  return static_cast<decltype(val)>(0);
+                  return static_cast<CTYPE_COMPUTE>(0);
                 }
                 return val;
               },

kernels/portable/cpu/op_prod.cpp

@@ -10,13 +10,29 @@
 #include <executorch/kernels/portable/cpu/util/reduce_util.h>
 #include <executorch/runtime/kernel/kernel_includes.h>
 
+#include <type_traits>
+
 namespace torch {
 namespace executor {
 namespace native {
 
 using Tensor = executorch::aten::Tensor;
 using ScalarType = executorch::aten::ScalarType;
 
+namespace {
+
+// `*` on bool trips -Wint-in-bool-context; for bool the product is `&&`.
+template <typename T>
+T multiply(T a, T b) {
+  if constexpr (std::is_same_v<T, bool>) {
+    return a && b;
+  } else {
+    return a * b;
+  }
+}
+
+} // namespace
+
 Tensor& prod_out(
     KernelRuntimeContext& ctx,
     const Tensor& in,
@@ -40,7 +56,7 @@ Tensor& prod_out(
       auto data_out = out.mutable_data_ptr<CTYPE_OUT>();
       data_out[0] = static_cast<CTYPE_OUT>(1);
       for (const auto i : c10::irange(in.numel())) {
-        data_out[0] *= static_cast<CTYPE_OUT>(data_in[i]);
+        data_out[0] = multiply(data_out[0], static_cast<CTYPE_OUT>(data_in[i]));
       }
     });
   });
@@ -86,7 +102,8 @@ Tensor& prod_int_out(
                     map_reduce_over_dim<CTYPE_IN, CTYPE_OUT>(
                         [](CTYPE_IN v) { return static_cast<CTYPE_OUT>(v); },
                         [](CTYPE_OUT outv, long, CTYPE_OUT acc, long) {
-                          return std::tuple<CTYPE_OUT, long>{acc * outv, 0};
+                          return std::tuple<CTYPE_OUT, long>{
+                              multiply(acc, outv), 0};
                         },
                         in,
                         dim,

kernels/portable/cpu/op_repeat_interleave.cpp

@@ -50,7 +50,7 @@ bool check_repeat_interleave_args(
     for (const auto i : c10::irange(repeats.numel())) {
       ET_CHECK_OR_RETURN_FALSE(
           repeats_data[i] >= 0,
-          "repeats cannot be negative; repeats_data[%" PRId64 "] = %d",
+          "repeats cannot be negative; repeats_data[%" PRId64 "] = %" PRId32,
           static_cast<int64_t>(i),
           repeats_data[i]);
     }

runtime/core/exec_aten/util/tensor_util.h

@@ -103,7 +103,7 @@
     ET_CHECK_MSG(                                                      \
         a_numel__ == b_numel__ && b_numel__ == c_numel__ &&            \
             ((a_numel__ == 1 && b_numel__ == 1 && c_numel__ == 1) ||   \
-             a_dim__ == b_dim__ && b_dim__ == c_dim__),                \
+             (a_dim__ == b_dim__ && b_dim__ == c_dim__)),              \
         ET_TENSOR_CHECK_PREFIX__                                       \
         ": numel={%zu, %zu, %zu}, dim={%zu, %zu, %zu}",                \
         a_numel__,                                                     \
@@ -248,13 +248,14 @@
     ET_CHECK_MSG(                                                             \
         strides[strides.size() - 1] == 1,                                     \
         "The stride of the last dimension shall be 1 for contiguous tensor, " \
-        "not %d",                                                             \
+        "not %" ET_PRI_SIZES_AND_STRIDES,                                     \
         strides[strides.size() - 1]);                                         \
     for (size_t i = strides.size() - 1; i > 0; i--) {                         \
       ET_CHECK_MSG(                                                           \
           strides[i - 1] == strides[i] * sizes[i],                            \
           "The stride of the %zu-th dimension shall equal to "                \
-          "strides[%zu] * sizes[%zu], now is %d and %d",                      \
+          "strides[%zu] * sizes[%zu], now is %" ET_PRI_SIZES_AND_STRIDES      \
+          " and %" ET_PRI_SIZES_AND_STRIDES,                                  \
           i - 1,                                                              \
           i,                                                                  \
           i,                                                                  \
@@ -270,24 +271,27 @@
  */
 #define ET_CHECK_SAME_STRIDES2(a__, b__)                                       \
   do {                                                                         \
+    const size_t a_dim__ = a__.dim();                                          \
+    const size_t b_dim__ = b__.dim();                                          \
     ET_CHECK_MSG(                                                              \
-        a__.dim() == b__.dim(),                                                \
+        a_dim__ == b_dim__,                                                    \
         "Two tensors shall have same number of strides, but not %zu and %zu.", \
-        a__.dim(),                                                             \
-        b__.dim());                                                            \
+        a_dim__,                                                               \
+        b_dim__);                                                              \
     const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
         a_strides = a__.strides();                                             \
     const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
         b_strides = b__.strides();                                             \
-    for (const auto i : c10::irange(a__.dim())) {                              \
+    for (size_t i = 0; i < a_dim__; i++) {                                     \
       ET_CHECK_MSG(                                                            \
           a_strides[i] == b_strides[i],                                        \
           "a.strides()[%zu] shall equal to b.strides()[%zu], "                 \
-          "but now is %d and %d.",                                             \
+          "but now is %" ET_PRI_SIZES_AND_STRIDES                              \
+          " and %" ET_PRI_SIZES_AND_STRIDES ".",                               \
           i,                                                                   \
           i,                                                                   \
-          (int32_t)a_strides[i],                                               \
-          (int32_t)b_strides[i]);                                              \
+          a_strides[i],                                                        \
+          b_strides[i]);                                                       \
     }                                                                          \
   } while (0)
 
@@ -298,30 +302,35 @@
  */
 #define ET_CHECK_SAME_STRIDES3(a__, b__, c__)                           \
   do {                                                                  \
+    const size_t a_dim__ = a__.dim();                                   \
+    const size_t b_dim__ = b__.dim();                                   \
+    const size_t c_dim__ = c__.dim();                                   \
     ET_CHECK_MSG(                                                       \
-        a__.dim() == b__.dim() && b__.dim() == c__.dim(),               \
+        a_dim__ == b_dim__ && b_dim__ == c_dim__,                       \
         "Three tensors shall have same number of strides, "             \
         "but not %zu, %zu and %zu.",                                    \
-        a__.dim(),                                                      \
-        b__.dim(),                                                      \
-        c__.dim());                                                     \
+        a_dim__,                                                        \
+        b_dim__,                                                        \
+        c_dim__);                                                       \
     const ::executorch::aten::ArrayRef<executorch::aten::StridesType>   \
         a_strides = a__.strides();                                      \
     const ::executorch::aten::ArrayRef<executorch::aten::StridesType>   \
         b_strides = b__.strides();                                      \
     const ::executorch::aten::ArrayRef<executorch::aten::StridesType>   \
         c_strides = c__.strides();                                      \
-    for (const auto i : c10::irange(a__.dim())) {                       \
+    for (size_t i = 0; i < a_dim__; i++) {                              \
       ET_CHECK_MSG(                                                     \
           a_strides[i] == b_strides[i] && b_strides[i] == c_strides[i], \
           "a_strides[%zu], b_strides[%zu] and c_strides[%zu] "          \
-          "shall share same value, but now is %d, %d and %d",           \
+          "shall share same value, but now is "                         \
+          "%" ET_PRI_SIZES_AND_STRIDES ", %" ET_PRI_SIZES_AND_STRIDES   \
+          " and %" ET_PRI_SIZES_AND_STRIDES,                            \
           i,                                                            \
           i,                                                            \
           i,                                                            \
-          (int32_t)a_strides[i],                                        \
-          (int32_t)b_strides[i],                                        \
-          (int32_t)c_strides[i]);                                       \
+          a_strides[i],                                                 \
+          b_strides[i],                                                 \
+          c_strides[i]);                                                \
     }                                                                   \
   } while (0)
 

runtime/core/portable_type/tensor_impl.h

@@ -16,6 +16,8 @@
 #include <executorch/runtime/core/tensor_shape_dynamism.h>
 #include <executorch/runtime/platform/compiler.h>
 
+#include <cinttypes>
+
 // Forward declaration of a helper that provides access to internal resizing
 // methods of TensorImpl. Real definition is in
 // executorch/runtime/core/exec_aten/tensor_util.h.
@@ -334,7 +336,7 @@ ::executorch::runtime::Result<ssize_t> safe_numel(
 // Appropriate format specifier for elements of sizes() and
 // strides(). Must be used instead of using d directly to support ATen
 // mode.
-#define ET_PRI_SIZES_AND_STRIDES "d"
+#define ET_PRI_SIZES_AND_STRIDES PRId32
 
 } // namespace etensor
 } // namespace runtime

runtime/executor/program.cpp

@@ -218,7 +218,7 @@ Result<executorch_flatbuffer::ExecutionPlan*> get_execution_plan(
             root_offset <=
                 program_data->size() - sizeof(flatbuffers::soffset_t),
         InvalidProgram,
-        "Root table offset %u is invalid for program size %zu",
+        "Root table offset %" PRIu32 " is invalid for program size %zu",
         root_offset,
         program_data->size());
   }
@@ -235,8 +235,9 @@ Result<executorch_flatbuffer::ExecutionPlan*> get_execution_plan(
   ET_CHECK_OR_RETURN_ERROR(
       flatbuffer_program->version() <= kMaxSupportedSchemaVersion,
       InvalidProgram,
-      "Program schema version %u is newer than the highest this runtime "
-      "supports (%u). Export the model with an older ExecuTorch, or update "
+      "Program schema version %" PRIu32
+      " is newer than the highest this runtime supports (%" PRIu32
+      "). Export the model with an older ExecuTorch, or update "
       "the runtime.",
       flatbuffer_program->version(),
       kMaxSupportedSchemaVersion);