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 or int64_t where the rest of a message already does
(Tensor::SizesType and StridesType differ between lean and ATen mode). The
ET_CHECK_CONTIGUOUS and ET_CHECK_SAME_STRIDES macros in tensor_util.h get the
same fix, since kernels outside this tree expand them. The size_t values in the
messages touched here print with ET_PRIsize_t instead of %zu, which the Cadence
Xtensa toolchain's C library does not support.

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.
The bool product 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 (275) with the
ESP-IDF 6.1 flags for esp32s3 and esp32c6 at -Og and -Os, under -Werror with
format and type-limits errors enabled: all clean. On host, portable_kernels_test
(1891 tests) and the exec_aten util tests pass.

Authored with Claude Code.

Author: rascani

backends/cadence/generic/operators/op_im2row.cpp

@@ -11,7 +11,7 @@
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
 
 #ifndef DISABLE_ALWAYS_INLINE
-#define ALWAYS_INLINE __attribute__((always_inline))
+#define ALWAYS_INLINE inline __attribute__((always_inline))
 #else
 #define ALWAYS_INLINE inline
 #endif

backends/cadence/generic/operators/op_transposed_im2row.cpp

@@ -14,7 +14,7 @@
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
 
 #ifndef DISABLE_ALWAYS_INLINE
-#define ALWAYS_INLINE __attribute__((always_inline))
+#define ALWAYS_INLINE inline __attribute__((always_inline))
 #else
 #define ALWAYS_INLINE inline
 #endif

extension/flat_tensor/flat_tensor_data_map.cpp

@@ -74,7 +74,9 @@ 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 %" ET_PRIsize_t
+          " 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 +257,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 +282,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 +369,8 @@ 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 %" ET_PRIsize_t,
       root_offset,
       flat_tensor_data->size());
 
@@ -383,9 +387,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,8 +252,8 @@ Tensor& _fft_r2c_out(
               out_sizes.data(), out_sizes.size())) == Error::Ok,
       InvalidArgument,
       out,
-      "Failed to resize output tensor (last dim %d).",
-      out_sizes[dim.back()]);
+      "Failed to resize output tensor (last dim %" PRId64 ").",
+      static_cast<int64_t>(out_sizes[dim.back()]));
 
   // NOTE: as of this writing, upstream PyTorch only supports float/double, so
   // we follow suit.

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]));
       }
     });
   });

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,18 +248,19 @@
     ET_CHECK_MSG(                                                             \
         strides[strides.size() - 1] == 1,                                     \
         "The stride of the last dimension shall be 1 for contiguous tensor, " \
-        "not %d",                                                             \
-        strides[strides.size() - 1]);                                         \
+        "not %" PRId64,                                                       \
+        static_cast<int64_t>(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",                      \
+          "The stride of the %" ET_PRIsize_t                                  \
+          "-th dimension shall equal to strides[%" ET_PRIsize_t               \
+          "] * sizes[%" ET_PRIsize_t "], now is %" PRId64 " and %" PRId64,    \
           i - 1,                                                              \
           i,                                                                  \
           i,                                                                  \
-          strides[i - 1],                                                     \
-          strides[i] * sizes[i]);                                             \
+          static_cast<int64_t>(strides[i - 1]),                               \
+          static_cast<int64_t>(strides[i] * sizes[i]));                       \
     }                                                                         \
   } while (0)
 
@@ -282,8 +283,9 @@
     for (const auto i : c10::irange(a__.dim())) {                              \
       ET_CHECK_MSG(                                                            \
           a_strides[i] == b_strides[i],                                        \
-          "a.strides()[%zu] shall equal to b.strides()[%zu], "                 \
-          "but now is %d and %d.",                                             \
+          "a.strides()[%" ET_PRIsize_t                                         \
+          "] shall equal to b.strides()[%" ET_PRIsize_t                        \
+          "], but now is %" PRId32 " and %" PRId32 ".",                        \
           i,                                                                   \
           i,                                                                   \
           (int32_t)a_strides[i],                                               \
@@ -314,8 +316,10 @@
     for (const auto i : c10::irange(a__.dim())) {                       \
       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",           \
+          "a_strides[%" ET_PRIsize_t "], b_strides[%" ET_PRIsize_t      \
+          "] and c_strides[%" ET_PRIsize_t                              \
+          "] shall share same value, "                                  \
+          "but now is %" PRId32 ", %" PRId32 " and %" PRId32,           \
           i,                                                            \
           i,                                                            \
           i,                                                            \

runtime/executor/program.cpp

@@ -218,7 +218,8 @@ 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 %" ET_PRIsize_t,
         root_offset,
         program_data->size());
   }
@@ -235,8 +236,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);

runtime/executor/program_validation.cpp

@@ -41,7 +41,7 @@ validate_tensor(const executorch_flatbuffer::Tensor* tensor) {
       ET_LOG(
           Error,
           "Size must be non-negative, got %d at dimension %u",
-          size,
+          static_cast<int>(size),
           static_cast<unsigned>(i));
       return Error::InvalidProgram;
     }
@@ -199,7 +199,7 @@ validate_program(const executorch_flatbuffer::Program* program) {
                 "TensorList item %u has out-of-bounds index %d (values size "
                 "%u) in execution plan %u",
                 static_cast<unsigned>(item_idx),
-                evalue_index,
+                static_cast<int>(evalue_index),
                 static_cast<unsigned>(values->size()),
                 static_cast<unsigned>(plan_idx));
             return Error::InvalidProgram;
@@ -213,7 +213,7 @@ validate_program(const executorch_flatbuffer::Program* program) {
                 "TensorList item %u references null evalue at index %d in "
                 "execution plan %u",
                 static_cast<unsigned>(item_idx),
-                evalue_index,
+                static_cast<int>(evalue_index),
                 static_cast<unsigned>(plan_idx));
             return Error::InvalidProgram;
           }
@@ -226,7 +226,7 @@ validate_program(const executorch_flatbuffer::Program* program) {
                 "index %d in execution plan %u",
                 static_cast<unsigned>(item_idx),
                 static_cast<int>(referenced_value->val_type()),
-                evalue_index,
+                static_cast<int>(evalue_index),
                 static_cast<unsigned>(plan_idx));
             return Error::InvalidProgram;
           }