Address various warnings as errors (#8581)

Summary:
Pull Request resolved: #8581

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

extension/threadpool/cpuinfo_utils.cpp

@@ -6,6 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <c10/util/irange.h>
 #include <executorch/extension/threadpool/cpuinfo_utils.h>
 
 #include <fstream>
@@ -84,7 +85,7 @@ bool populate_available_cpu_mids() {
   cpu_midrs->resize(num_possible_cores);
   const std::string kMidrFilePathPrefix = "/sys/devices/system/cpu/cpu";
   const std::string kMidrFilePathSuffix = "/regs/identification/midr_el1";
-  for (int32_t i = 0; i < num_possible_cores; ++i) {
+  for (const auto i : c10::irange(num_possible_cores)) {
     std::string midr_file_path =
         kMidrFilePathPrefix + std::to_string(i) + kMidrFilePathSuffix;
     ET_LOG(Info, "Reading file %s", midr_file_path.c_str());
@@ -115,7 +116,7 @@ uint32_t _get_num_performant_cores() {
     ET_LOG(Info, "CPU info and manual query on # of cpus dont match.");
     return 0;
   }
-  for (int32_t i = 0; i < cpu_midrs->size(); ++i) {
+  for (const auto i : c10::irange(cpu_midrs->size())) {
     uint32_t masked_midr = (*cpu_midrs)[i] & RIVISION_MASK;
     switch (masked_midr) {
       case CPUINFO_ARM_MIDR_CORTEX_A520:
@@ -148,7 +149,7 @@ uint32_t get_num_performant_cores() {
   uint32_t num_possible_cores = cpuinfo_get_processors_count();
   uint32_t num_non_performant_core = 0;
   if (uarch_count > 1) {
-    for (int32_t i = 0; i < uarch_count; ++i) {
+    for (const auto i : c10::irange(uarch_count)) {
       const struct cpuinfo_uarch_info* uarch_info = cpuinfo_get_uarch(i);
       if (is_non_performant_core(uarch_info)) {
         num_non_performant_core += uarch_info->processor_count;

extension/threadpool/targets.bzl

@@ -23,6 +23,7 @@ def define_common_targets():
         srcs = _THREADPOOL_SRCS,
         deps = [
             "//executorch/runtime/core:core",
+            "//executorch/runtime/core/portable_type/c10/c10:c10",
         ],
         exported_headers = _THREADPOOL_HEADERS,
         exported_deps = [

kernels/portable/cpu/op__to_dim_order_copy.cpp

@@ -6,6 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <c10/util/irange.h>
+
 #include <executorch/kernels/portable/cpu/scalar_utils.h>
 #include <executorch/kernels/portable/cpu/util/copy_ops_util.h>
 #include <executorch/runtime/core/exec_aten/util/dim_order_util.h>
@@ -41,7 +43,7 @@ int64_t coordinateToIndexWithDimOrder(
 
   dim_order_to_stride_nocheck(
       sizes.data(), dim_order.data(), sizes.size(), strides);
-  for (size_t i = 0; i < self.dim(); ++i) {
+  for (const auto i : c10::irange(self.dim())) {
     index += cur_indices[i] * strides[i];
   }
   return index;
@@ -59,7 +61,7 @@ void _to_dim_order_copy_impl(const Tensor& self, Tensor& out) {
   for (ssize_t i = 0; i < self.numel(); i++) {
     // Update the current indices.
     for (ssize_t j = self.dim() - 1; j >= 0; j--) {
-      if (coordinate[j] + 1 < self.size(j)) {
+      if (coordinate[j] + 1 < static_cast<size_t>(self.size(j))) {
         coordinate[j]++;
         break;
       } else {

kernels/portable/cpu/op_amax.cpp

@@ -6,6 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <c10/util/irange.h>
 #include <cmath>
 
 #include <executorch/kernels/portable/cpu/util/reduce_util.h>
@@ -44,7 +45,7 @@ Tensor& amax_out(
 
   ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, "amax.out", CTYPE, [&]() {
     CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
-    for (size_t out_ix = 0; out_ix < out.numel(); ++out_ix) {
+    for (const auto out_ix : c10::irange(out.numel())) {
       out_data[out_ix] = reduce_over_dim_list<CTYPE>(
           [](CTYPE v, CTYPE max_v) {
             return std::isnan(v) || v > max_v ? v : max_v;

kernels/portable/cpu/op_expand_copy.cpp

@@ -96,7 +96,8 @@ 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,8 @@ 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/functional_util.h

@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include <c10/util/irange.h>
+
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
 #include <executorch/runtime/core/exec_aten/util/tensor_util.h>
 
@@ -30,7 +32,7 @@ inline CTYPE apply_unary_reduce_fn(
     const int64_t size,
     const int64_t stride = 1) {
   CTYPE acc_val = data_in[0];
-  for (size_t i = 1; i < size; i++) {
+  for (const auto i : c10::irange(size)) {
     acc_val = reduce_fun(data_in[i * stride], acc_val);
   }
   return acc_val;
@@ -51,7 +53,7 @@ inline void apply_unary_map_fn(
     CTYPE_OUT* const data_out,
     const int64_t size,
     const int64_t stride = 1) {
-  for (size_t i = 0; i < size; i++) {
+  for (const auto i : c10::irange(size)) {
     data_out[i * stride] = map_fun(data_in[i * stride]);
   }
 }
@@ -77,7 +79,7 @@ inline CTYPE_OUT apply_unary_map_reduce_fn(
     const int64_t size,
     const int64_t stride = 1) {
   CTYPE_OUT acc_val = map_fun(data_in[0]);
-  for (size_t i = 1; i < size; ++i) {
+  for (const auto i : c10::irange(size)) {
     acc_val = reduce_fun(map_fun(data_in[i * stride]), acc_val);
   }
   return acc_val;

kernels/portable/cpu/util/reduce_util.cpp

@@ -48,8 +48,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);
+      ET_LOG_AND_RETURN_IF_FALSE(non_neg_d < kTensorDimensionLimit);
 
       ET_CHECK_OR_RETURN_FALSE(
           dim_exist[non_neg_d] == false,
@@ -86,7 +85,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 +107,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 +135,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 +154,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 +233,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 +249,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 +265,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/reduce_util.h

@@ -50,15 +50,15 @@ void apply_on_flat_ix_with_dim_mask_and_base(
     const size_t start,
     const size_t end) {
   // Compute innermost dim from dim list
-  size_t inner_dim = in.dim() - 1;
+  int64_t inner_dim = in.dim() - 1;
   while (!dim_mask[inner_dim]) {
     inner_dim--;
   }
 
   // Initialize array of indices per dimension. This array is used to maintain
   // the per-dimension index of the element in `in` that is being reduced over
   // Only the dims that are in the dim list are relevant.
-  size_t dim_index[kTensorDimensionLimit];
+  int64_t dim_index[kTensorDimensionLimit];
   for (int64_t d = 0; d < in.dim(); d++) {
     dim_index[d] = 0;
   }

kernels/portable/cpu/util/repeat_util.cpp

@@ -8,6 +8,7 @@
 
 #include <cstring>
 
+#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>
 #include <executorch/runtime/core/exec_aten/util/tensor_util.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",

kernels/prim_ops/et_view.cpp

@@ -32,7 +32,8 @@ bool get_view_target_size(
     executorch::aten::ArrayRef<int64_t> size,
     int64_t dim,
     executorch::aten::SizesType* out_size) {
-  ET_LOG_AND_RETURN_IF_FALSE(size.size() == dim);
+  ET_LOG_AND_RETURN_IF_FALSE(
+      dim >= 0 && size.size() == static_cast<size_t>(dim));
   int minus1_dim = -1;
   int n_zero = 0;
   int64_t numel_without_minus_1 = 1;

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;