Address various warnings as errors

Summary:
Some projects uses more restrictive build options than currently used in ET CI.

This means we encountered a number of errors when enabling for a microcontroller.

Reviewed By: digantdesai, swolchok

Differential Revision: D69139962

Author: JakeStevens

kernels/portable/cpu/op_expand_copy.cpp

@@ -96,7 +96,7 @@ Tensor& expand_copy_out(
 
   ET_KERNEL_CHECK(
       ctx,
-      repeat_tensor(self, {repeats, repeats_size}, out) == Error::Ok,
+      repeat_tensor(self, makeArrayRef(repeats, repeats_size), out) == Error::Ok,
       InvalidArgument,
       out);
 

kernels/portable/cpu/util/broadcast_util.cpp

@@ -6,6 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <executorch/kernels/portable/cpu/util/broadcast_util.h>
 #include <executorch/kernels/portable/cpu/util/repeat_util.h>
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
@@ -274,7 +275,7 @@ void delinearize_index(
     size_t* out_indexes,
     const size_t out_indexes_len) {
   ET_CHECK(shape.size() <= out_indexes_len);
-  for (auto i = 0; i < shape.size(); ++i) {
+  for (size_t i = 0; i < shape.size(); ++i) {
     auto dim = shape.size() - 1 - i;
     auto dim_size = shape[dim];
     out_indexes[dim] = linear_index % dim_size;
@@ -304,7 +305,7 @@ size_t linearize_access_indexes(
   size_t linear_index = 0;
   for (size_t i = 0; i < indexes_broadcast_from.size(); ++i) {
     // If this dimension is broadcasted, add zero to the linear address.
-    if (indexes_broadcast_from[i] >= broadcast_from_shape[i]) {
+    if (indexes_broadcast_from[i] >= static_cast<size_t>(broadcast_from_shape[i])) {
       ET_CHECK_MSG(
           broadcast_from_shape[i] == 1,
           "Expected dim size == 1 if broadcasted, but actual dim size is %zu",

kernels/portable/cpu/util/broadcast_util.h

@@ -289,7 +289,7 @@ inline void apply_binary_elementwise_fn(
   const CTYPE_B* const data_b = b.const_data_ptr<CTYPE_B>();
   CTYPE_OUT* const data_out = out.mutable_data_ptr<CTYPE_OUT>();
 
-  for (size_t i = 0; i < out.numel(); ++i) {
+  for (size_t i = 0; i < static_cast<size_t>(out.numel()); ++i) {
     size_t a_linear_index = i;
     size_t b_linear_index = i;
 

kernels/portable/cpu/util/reduce_util.cpp

@@ -49,7 +49,7 @@ ET_NODISCARD bool check_dim_list_is_valid(
 
       const size_t non_neg_d = _normalize_non_neg_d(d, in.dim());
       ET_LOG_AND_RETURN_IF_FALSE(
-          non_neg_d < kTensorDimensionLimit && non_neg_d >= 0);
+          non_neg_d < kTensorDimensionLimit);
 
       ET_CHECK_OR_RETURN_FALSE(
           dim_exist[non_neg_d] == false,
@@ -86,7 +86,7 @@ size_t get_reduced_dim_product(
   }
   size_t dim_product = 1;
   if (!dim.has_value()) {
-    for (size_t i = 0; i < in.dim(); ++i) {
+    for (size_t i = 0; i < static_cast<size_t>(in.dim()); ++i) {
       dim_product *= in.size(i);
     }
     return dim_product;
@@ -108,7 +108,7 @@ size_t get_reduced_dim_product(
   size_t dim_product = 1;
   const size_t in_dim = in.dim();
   if (!dim_list.has_value() || dim_list.value().size() == 0) {
-    for (size_t i = 0; i < in.dim(); ++i) {
+    for (size_t i = 0; i < static_cast<size_t>(in.dim()); ++i) {
       dim_product *= in.size(i);
     }
     return dim_product;
@@ -136,7 +136,7 @@ size_t get_out_numel(
       ET_CHECK_VALID_DIM(dim_val, in.dim());
     }
     const size_t non_neg_dim = _normalize_non_neg_d(dim_val, in.dim());
-    for (size_t d = 0; d < in.dim(); ++d) {
+    for (size_t d = 0; d < static_cast<size_t>(in.dim()); ++d) {
       if (d != non_neg_dim) {
         out_numel *= in.size(d);
       }
@@ -155,7 +155,7 @@ size_t get_out_numel(
         dim_list) {
   size_t out_numel = 1;
   if (dim_list.has_value() && dim_list.value().size() != 0) {
-    for (size_t d = 0; d < in.dim(); ++d) {
+    for (size_t d = 0; d < static_cast<size_t>(in.dim()); ++d) {
       if (!check_dim_in_dim_list(d, in.dim(), dim_list.value())) {
         out_numel *= in.size(d);
       }
@@ -234,7 +234,7 @@ size_t compute_reduced_out_size(
   if (dim.has_value()) {
     const auto dim_val = dim.value();
     const size_t non_neg_dim = _normalize_non_neg_d(dim_val, in_dim);
-    for (ssize_t i = 0; i < non_neg_dim; ++i) {
+    for (size_t i = 0; i < non_neg_dim; ++i) {
       sizes_arr[i] = in.size(i);
     }
     if (keepdim) {
@@ -250,7 +250,7 @@ size_t compute_reduced_out_size(
     }
   } else {
     if (keepdim) {
-      for (size_t i = 0; i < in_dim; ++i) {
+      for (size_t i = 0; i < static_cast<size_t>(in_dim); ++i) {
         sizes_arr[i] = 1;
       }
     } else {
@@ -266,7 +266,9 @@ size_t compute_reduced_out_size(
         dim_list,
     bool keepdim,
     executorch::aten::SizesType* sizes_arr) {
-  const auto in_dim = in.dim();
+  // check_dim_in_dim_list and later comparisons
+  // expect in_dim to be size_t, so cast it here
+  const size_t in_dim = static_cast<size_t>(in.dim());
   size_t out_dim = in_dim;
 
   if (dim_list.has_value() && dim_list.value().size() != 0) {

kernels/portable/cpu/util/repeat_util.cpp

@@ -9,6 +9,7 @@
 #include <cstring>
 
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/kernels/portable/cpu/util/repeat_util.h>
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
 #include <executorch/runtime/core/exec_aten/util/tensor_util.h>
 #include <executorch/runtime/platform/assert.h>
@@ -26,7 +27,7 @@ bool check_repeat_args(
     Tensor& out) {
   // Ensure the self tensors list is non-empty.
   ET_CHECK_OR_RETURN_FALSE(
-      repeats.size() >= self.dim(),
+      static_cast<ssize_t>(repeats.size()) >= self.dim(),
       "Number of dimensions of repeat dims can not be smaller than number of dimensions of tensor");
 
   // Repeat arrayref shall not contain negative element.
@@ -39,7 +40,7 @@ bool check_repeat_args(
 
   /// Check if out.size() is legal.
   ET_CHECK_OR_RETURN_FALSE(
-      out.dim() == repeats.size(),
+      static_cast<size_t>(out.dim()) == repeats.size(),
       "The dimension of out shall equal size of repeats, but now is %zd and %zd",
       out.dim(),
       repeats.size());
@@ -48,7 +49,7 @@ bool check_repeat_args(
   // kTensorDimensionLimit. Only check out tensor because the number of
   // dimension of out tensor shall have more than or equal to self tensor
   ET_CHECK_OR_RETURN_FALSE(
-      out.dim() <= kTensorDimensionLimit,
+      static_cast<size_t>(out.dim()) <= kTensorDimensionLimit,
       "The dimension of input and output should not be larger than %zd",
       kTensorDimensionLimit);
 
@@ -58,7 +59,7 @@ bool check_repeat_args(
   // repeats, and called it reformat_self_size. We then make point-to-point mul
   // of reformat_self_size and repeats. The result should equal out.size().
   size_t reformat_self_size[kTensorDimensionLimit];
-  for (size_t i = 0; i < out.dim() - self.dim(); i++) {
+  for (ssize_t i = 0; i < out.dim() - self.dim(); i++) {
     reformat_self_size[i] = 1;
   }
 
@@ -130,7 +131,7 @@ void repeat_internal(
   // The increment along index of slot array to reach the next possible valid
   // value.
   int64_t incr[kTensorDimensionLimit];
-  for (size_t i = 0; i < self_dim; i++) {
+  for (size_t i = 0; i < static_cast<size_t>(self_dim); i++) {
     incr[i] = self_size[i];
   }
 
@@ -140,7 +141,7 @@ void repeat_internal(
   // than self).
   size_t index = self_dim - 1;
   size_t start = out.dim() - self_dim;
-  while (slots[0] != out.size(start)) {
+  while (slots[0] != static_cast<size_t>(out.size(start))) {
     // Compute the offset (from origin) in the out tensor where this self
     // data will be copied to.
     size_t offset = compute_access_offset(slots, strides, self_dim);
@@ -150,7 +151,7 @@ void repeat_internal(
     slots[index] += incr[index];
     // If we have reached the limit in the innermost dimension, successively
     // increment the slot index of outer dimensions.
-    while (slots[index] == out.size(start + index)) {
+    while (slots[index] == static_cast<size_t>(out.size(start + index))) {
       if (index == 0) {
         break;
       }
@@ -226,7 +227,7 @@ Error repeat_tensor(
   // so we reset the upper bound of innermost dim to 1. 'in_incr' indicates
   // the size (in bytes) of the self data.
   int64_t limits[kTensorDimensionLimit];
-  for (size_t i = 0; i < self_dim; i++) {
+  for (ssize_t i = 0; i < self_dim; i++) {
     limits[i] = self_size[i];
   }
 

kernels/portable/cpu/util/targets.bzl

@@ -61,7 +61,6 @@ def define_common_targets():
             "//executorch/runtime/core/exec_aten/util:scalar_type_util",
             "//executorch/runtime/core/exec_aten/util:tensor_util",
         ],
-        compiler_flags = ["-Wno-missing-prototypes"],
         visibility = ["//executorch/kernels/portable/cpu/..."],
     )
 
@@ -71,7 +70,6 @@ def define_common_targets():
         exported_headers = [
             "broadcast_util.h",
         ],
-        compiler_flags = ["-Wno-missing-prototypes"],
         deps = [
             ":repeat_util",
             "//executorch/runtime/kernel:kernel_includes",

runtime/core/data_loader.h

@@ -69,12 +69,12 @@ class DataLoader {
     SegmentInfo() = default;
 
     explicit SegmentInfo(
-        Type segment_type,
-        size_t segment_index = 0,
-        const char* descriptor = nullptr)
-        : segment_type(segment_type),
-          segment_index(segment_index),
-          descriptor(descriptor) {}
+        Type segment_type_,
+        size_t segment_index_ = 0,
+        const char* descriptor_ = nullptr)
+        : segment_type(segment_type_),
+          segment_index(segment_index_),
+          descriptor(descriptor_) {}
   };
 
   virtual ~DataLoader() = default;

runtime/core/exec_aten/util/dim_order_util.h

@@ -22,7 +22,7 @@ namespace runtime {
 namespace {
 template <typename DimOrderType>
 bool validate_dim_order(const DimOrderType* dim_order, const size_t dims) {
-  for (int32_t i = 0; i < dims; ++i) {
+  for (size_t i = 0; i < dims; ++i) {
     if (dim_order[i] >= dims) {
       return false;
     }
@@ -42,7 +42,7 @@ template <typename DimOrderType>
 inline bool is_contiguous_dim_order(
     const DimOrderType* dim_order,
     const size_t dims) {
-  for (int i = 0; i < dims; ++i) {
+  for (size_t i = 0; i < dims; ++i) {
     if (dim_order[i] != i) {
       return false;
     }
@@ -74,7 +74,7 @@ bool is_channels_last_dim_order(
   if (dim_order[0] != 0) {
     return false;
   }
-  int d = 1;
+  size_t d = 1;
   while (d < dims - 1) {
     if (dim_order[d] != d + 1) {
       return false;
@@ -162,8 +162,8 @@ struct StrideDimOrder {
   StridesType stride;
   DimOrderType dim_order;
 
-  StrideDimOrder(StridesType stride, DimOrderType dim_order)
-      : stride(stride), dim_order(dim_order) {}
+  StrideDimOrder(StridesType stride_, DimOrderType dim_order_)
+      : stride(stride_), dim_order(dim_order_) {}
   StrideDimOrder() = default;
   bool operator>(const StrideDimOrder& other) const {
     // descending order

runtime/core/exec_aten/util/tensor_util.h

@@ -582,7 +582,7 @@ inline bool tensors_have_same_dtype(
 
 inline bool tensor_is_rank(executorch::aten::Tensor t, size_t rank) {
   ET_CHECK_OR_RETURN_FALSE(
-      t.dim() == rank,
+      static_cast<size_t>(t.dim()) == rank,
       "Expected tensor.dim() to be %zu, but got %zu",
       static_cast<size_t>(rank),
       static_cast<size_t>(t.dim()));
@@ -594,7 +594,7 @@ inline bool tensor_has_rank_greater_or_equal_to(
     executorch::aten::Tensor t,
     size_t rank) {
   ET_CHECK_OR_RETURN_FALSE(
-      t.dim() >= rank,
+      static_cast<size_t>(t.dim()) >= rank,
       "Expected tensor.dim() to be >= %zu, but got %zu",
       static_cast<size_t>(rank),
       static_cast<size_t>(t.dim()));
@@ -606,7 +606,7 @@ inline bool tensor_has_rank_smaller_or_equal_to(
     executorch::aten::Tensor t,
     size_t rank) {
   ET_CHECK_OR_RETURN_FALSE(
-      t.dim() <= rank,
+      static_cast<size_t>(t.dim()) <= rank,
       "Expected tensor.dim() to be <= %zu, but got %zu",
       static_cast<size_t>(rank),
       static_cast<size_t>(t.dim()));
@@ -663,12 +663,12 @@ inline bool tensors_have_same_size_at_dims(
     executorch::aten::Tensor b,
     size_t dim_b) {
   ET_CHECK_OR_RETURN_FALSE(
-      dim_a < a.dim(),
+      dim_a < static_cast<size_t>(a.dim()),
       "Cannot retrieve dim %zu from tensor with dim %zu",
       static_cast<size_t>(dim_a),
       static_cast<size_t>(a.dim()));
   ET_CHECK_OR_RETURN_FALSE(
-      dim_b < b.dim(),
+      dim_b < static_cast<size_t>(b.dim()),
       "Cannot retrieve dim %zu from tensor with dim %zu",
       static_cast<size_t>(dim_b),
       static_cast<size_t>(b.dim()));
@@ -700,7 +700,7 @@ inline bool tensors_have_same_shape(
         static_cast<size_t>(b.numel()),
         static_cast<size_t>(a.dim()),
         static_cast<size_t>(b.dim()));
-    for (size_t d = 0; d < ET_MIN2(a.dim(), b.dim()); ++d) {
+    for (size_t d = 0; d < static_cast<size_t>(ET_MIN2(a.dim(), b.dim())); ++d) {
       ET_LOG(
           Error,
           "    size(%zu): (%zu, %zu)",
@@ -737,7 +737,7 @@ inline bool tensors_have_same_shape(
         static_cast<size_t>(a.dim()),
         static_cast<size_t>(b.dim()),
         static_cast<size_t>(c.dim()));
-    for (size_t d = 0; d < ET_MIN3(a.dim(), b.dim(), c.dim()); ++d) {
+    for (size_t d = 0; d < static_cast<size_t>(ET_MIN3(a.dim(), b.dim(), c.dim())); ++d) {
       ET_LOG(
           Error,
           "    size(%zu): (%zu, %zu, %zu)",
@@ -800,7 +800,7 @@ inline bool tensors_have_same_strides(
         ET_TENSOR_CHECK_PREFIX__ ": dim=(%zu, %zu)",
         static_cast<size_t>(a.dim()),
         static_cast<size_t>(b.dim()));
-    for (size_t d = 0; d < ET_MIN2(a.dim(), b.dim()); ++d) {
+    for (size_t d = 0; d < static_cast<size_t>(ET_MIN2(a.dim(), b.dim())); ++d) {
       ET_LOG(
           Error,
           "    stride(%zu): (%zu, %zu)",
@@ -825,7 +825,7 @@ inline bool tensors_have_same_strides(
         static_cast<size_t>(a.dim()),
         static_cast<size_t>(b.dim()),
         static_cast<size_t>(c.dim()));
-    for (size_t d = 0; d < ET_MIN3(a.dim(), b.dim(), c.dim()); ++d) {
+    for (size_t d = 0; d < static_cast<size_t>(ET_MIN3(a.dim(), b.dim(), c.dim())); ++d) {
       ET_LOG(
           Error,
           "    stride(%zu): (%zu, %zu, %zu)",
@@ -909,7 +909,7 @@ inline size_t getTrailingDims(
       dim,
       ssize_t(tensor.dim()));
   size_t dims = 1;
-  for (size_t i = dim + 1; i < tensor.dim(); ++i) {
+  for (size_t i = dim + 1; i < static_cast<size_t>(tensor.dim()); ++i) {
     dims *= static_cast<size_t>(tensor.size(i));
   }
   return dims;
@@ -982,7 +982,7 @@ inline void indexToCoordinate(
     const executorch::aten::Tensor& tensor,
     size_t index,
     size_t* coordinate) {
-  ET_CHECK(index < tensor.numel());
+  ET_CHECK(index < static_cast<size_t>(tensor.numel()));
   for (auto i = 0; i < tensor.dim(); ++i) {
     auto dim = tensor.dim() - 1 - i;
     size_t dim_size = tensor.size(dim);