Fix warning when building kernel libraries

larryliu0820 · larryliu0820 · commit 9bc4b6007976 · 2025-10-27T16:24:01.000-07:00
Getting warnings like the following:

```
  /home/larryliu/executorch/kernels/portable/cpu/op_maximum.cpp: In lambda function:
  /home/larryliu/executorch/kernels/portable/cpu/op_maximum.cpp:52:9: note: the ABI for passing parameters with 32-byte alignment has changed in GCC 4.6
     52 |         [](const auto val_a, const auto val_b) {
        |         ^
  /home/larryliu/executorch/../executorch/runtime/core/exec_aten/util/scalar_type_util.h:919:7: note: in definition of macro 'ET_INTERNAL_SWITCH'
    919 |       __VA_ARGS__                                              \
        |       ^~~~~~~~~~~
  /home/larryliu/executorch/../executorch/runtime/core/exec_aten/util/scalar_type_util.h:931:3: note: in expansion of macro 'ET_INTERNAL_SWITCH_CASE'
    931 |   ET_INTERNAL_SWITCH_CASE(                                             \
        |   ^~~~~~~~~~~~~~~~~~~~~~~
  /home/larryliu/executorch/../executorch/runtime/core/exec_aten/util/scalar_type_util.h:957:3: note: in expansion of macro 'ET_INTERNAL_SWITCH_CASE_INT_TYPES'
    957 |   ET_INTERNAL_SWITCH_CASE_INT_TYPES(CTYPE_ALIAS, __VA_ARGS__) \
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  /home/larryliu/executorch/../executorch/runtime/core/exec_aten/util/scalar_type_util.h:1008:3: note: in expansion of macro 'ET_INTERNAL_SWITCH_CASE_REAL_TYPES'
   1008 |   ET_INTERNAL_SWITCH_CASE_REAL_TYPES(CTYPE_ALIAS, __VA_ARGS__)               \
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  /home/larryliu/executorch/../executorch/runtime/core/exec_aten/util/scalar_type_util.h:1136:7: note: in expansion of macro 'ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND'
   1136 |       ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND(          \
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  /home/larryliu/executorch/../executorch/runtime/core/exec_aten/util/scalar_type_util.h:1172:3: note: in expansion of macro 'ET_SWITCH_REAL_TYPES_AND'
   1172 |   ET_SWITCH_REAL_TYPES_AND(Bool, TYPE, CONTEXT, NAME, CTYPE_ALIAS, __VA_ARGS__)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~
  /home/larryliu/executorch/kernels/portable/cpu/op_maximum.cpp:47:3: note: in expansion of macro 'ET_SWITCH_REALB_TYPES'
     47 |   ET_SWITCH_REALB_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&amp;]() {
        |   ^~~~~~~~~~~~~~~~~~~~~
```

Fixing them in this PR
diff --git a/kernels/optimized/cpu/op_add.cpp b/kernels/optimized/cpu/op_add.cpp
@@ -68,7 +68,7 @@ Tensor& opt_add_out(
 
         using Vec = at::vec::Vectorized<CTYPE>;
         at::vec::map<CTYPE>(
-            [alpha_val, b_val](Vec x) { return x + Vec(alpha_val * b_val); },
+            [alpha_val, b_val](Vec& x) { return x + Vec(alpha_val * b_val); },
             out.mutable_data_ptr<CTYPE>(),
             a.const_data_ptr<CTYPE>(),
             out.numel());
diff --git a/kernels/optimized/cpu/op_div.cpp b/kernels/optimized/cpu/op_div.cpp
@@ -87,14 +87,14 @@ Tensor& opt_div_out(
           using Vec = at::vec::Vectorized<CTYPE>;
           if (a.numel() == 1) {
             at::vec::map<CTYPE>(
-                [scalar_casted](Vec x) { return Vec(scalar_casted) / x; },
+                [scalar_casted](Vec& x) { return Vec(scalar_casted) / x; },
                 out.mutable_data_ptr<CTYPE>(),
                 tensor->const_data_ptr<CTYPE>(),
                 out.numel());
           } else {
             Vec inv_scalar_casted_vec(CTYPE(1) / scalar_casted);
             at::vec::map<CTYPE>(
-                [inv_scalar_casted_vec](Vec x) {
+                [inv_scalar_casted_vec](Vec& x) {
                   return x * inv_scalar_casted_vec;
                 },
                 out.mutable_data_ptr<CTYPE>(),
diff --git a/kernels/optimized/cpu/op_exp.cpp b/kernels/optimized/cpu/op_exp.cpp
@@ -36,7 +36,7 @@ void exp_data(
     CTYPE_OUT* out_data) {
   using Vec = at::vec::Vectorized<CTYPE_IN>;
   at::vec::map<CTYPE_IN>(
-      [](Vec x) { return x.exp(); }, out_data, in_data, numel);
+      [](Vec& x) { return x.exp(); }, out_data, in_data, numel);
 }
 
 /**
diff --git a/kernels/optimized/cpu/op_le.cpp b/kernels/optimized/cpu/op_le.cpp
@@ -48,7 +48,7 @@ Tensor& opt_le_tensor_out(
     ET_SWITCH_REALB_TYPES(a_type, ctx, op_name, CTYPE, [&]() {
       using Vec = at::vec::Vectorized<CTYPE>;
       at::vec::map2<CTYPE>(
-          [](Vec x, Vec y) { return x.le(y); },
+          [](Vec& x, Vec& y) { return x.le(y); },
           out.mutable_data_ptr<CTYPE>(),
           a.const_data_ptr<CTYPE>(),
           b.const_data_ptr<CTYPE>(),
diff --git a/kernels/optimized/cpu/op_log_softmax.cpp b/kernels/optimized/cpu/op_log_softmax.cpp
@@ -55,7 +55,7 @@ void log_softmax_kernel(const Tensor& input, int64_t dim, Tensor& out) {
         0,
         outer_size,
         ::executorch::extension::internal::GRAIN_SIZE,
-        [&](const auto begin, const auto end) {
+        [&](const auto& begin, const auto& end) {
           at::native::serial_vec_log_softmax_lastdim_range(
               input_data_base,
               output_data_base,
diff --git a/kernels/optimized/cpu/op_mul.cpp b/kernels/optimized/cpu/op_mul.cpp
@@ -56,7 +56,7 @@ Tensor& opt_mul_out(
 
           using Vec = at::vec::Vectorized<CTYPE>;
           at::vec::map<CTYPE>(
-              [b_casted](Vec x) { return x * Vec(b_casted); },
+              [b_casted](Vec& x) { return x * Vec(b_casted); },
               out.mutable_data_ptr<CTYPE>(),
               a.const_data_ptr<CTYPE>(),
               out.numel());
diff --git a/kernels/optimized/cpu/op_native_layer_norm.cpp b/kernels/optimized/cpu/op_native_layer_norm.cpp
@@ -92,7 +92,7 @@ void layer_norm(
       }
     } else {
       at::vec::map3<CTYPE>(
-          [scale, offset](auto x, auto gamma, auto beta) {
+          [scale, offset](auto& x, auto& gamma, auto& beta) {
             using Vec = decltype(x);
             return (x * Vec(scale) + Vec(offset)) * gamma + beta;
           },
diff --git a/kernels/optimized/cpu/op_sub.cpp b/kernels/optimized/cpu/op_sub.cpp
@@ -86,15 +86,15 @@ Tensor& opt_sub_out(
           using Vec = at::vec::Vectorized<CTYPE>;
           if (a.numel() == 1) {
             at::vec::map<CTYPE>(
-                [alpha_val, scalar_casted](Vec x) {
+                [alpha_val, scalar_casted](Vec& x) {
                   return Vec(scalar_casted) - Vec(alpha_val) * x;
                 },
                 out.mutable_data_ptr<CTYPE>(),
                 tensor->const_data_ptr<CTYPE>(),
                 out.numel());
           } else {
             at::vec::map<CTYPE>(
-                [alpha_val, scalar_casted](Vec x) {
+                [alpha_val, scalar_casted](Vec& x) {
                   return x - Vec(alpha_val * scalar_casted);
                 },
                 out.mutable_data_ptr<CTYPE>(),
diff --git a/kernels/portable/cpu/op_add.cpp b/kernels/portable/cpu/op_add.cpp
@@ -80,7 +80,7 @@ Tensor& add_out(
           CTYPE_COMPUTE,
           op_name,
           utils::SupportedTensorDtypes::REALHBBF16>(
-          [val_alpha](const auto val_a, const auto val_b) {
+          [val_alpha](const auto& val_a, const auto& val_b) {
             return val_a + val_alpha * val_b;
           },
           ctx,
@@ -136,7 +136,7 @@ Tensor& add_scalar_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::SAME_AS_COMMON>(
-        [val_alpha_times_b](const auto val_a) {
+        [val_alpha_times_b](const auto& val_a) {
           // Cast here supports vectorization; either it does nothing
           // or it casts from CTYPE_COMPUTE to
           // Vectorized<CTYPE_COMPUTE>.
diff --git a/kernels/portable/cpu/op_addmm.cpp b/kernels/portable/cpu/op_addmm.cpp
@@ -92,7 +92,7 @@ Tensor& addmm_out(
           CTYPE,
           op_name,
           utils::SupportedTensorDtypes::REALHBF16>(
-          [alpha_val, beta_val](const auto val_a, const auto val_b) {
+          [alpha_val, beta_val](const auto& val_a, const auto& val_b) {
             return val_a * alpha_val + val_b * beta_val;
           },
           ctx,
diff --git a/kernels/portable/cpu/op_atan2.cpp b/kernels/portable/cpu/op_atan2.cpp
@@ -59,7 +59,7 @@ Tensor& atan2_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::FLOATHBF16>(
-        [](const auto val_a, const auto val_b) {
+        [](const auto& val_a, const auto& val_b) {
           return executorch::math::atan2(val_a, val_b);
         },
         ctx,
diff --git a/kernels/portable/cpu/op_clamp.cpp b/kernels/portable/cpu/op_clamp.cpp
@@ -139,7 +139,7 @@ Tensor& clamp_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::SAME_AS_COMMON>(
-        [has_min, min_opt, has_max, max_opt](const auto val_in) {
+        [has_min, min_opt, has_max, max_opt](const auto& val_in) {
           auto val_out = val_in;
           if (has_min) {
             val_out = utils::max_override(
diff --git a/kernels/portable/cpu/op_div.cpp b/kernels/portable/cpu/op_div.cpp
@@ -62,7 +62,7 @@ Tensor& div_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::FLOATHBF16>(
-        [](const auto val_a, const auto val_b) { return val_a / val_b; },
+        [](const auto& val_a, const auto& val_b) { return val_a / val_b; },
         ctx,
         a,
         utils::SupportedTensorDtypes::REALHBBF16,
@@ -195,7 +195,7 @@ Tensor& div_scalar_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::SAME_AS_COMMON>(
-        [val_b](const auto val_a) { return val_a / val_b; },
+        [val_b](const auto& val_a) { return val_a / val_b; },
         ctx,
         a,
         utils::SupportedTensorDtypes::REALHBBF16,
diff --git a/kernels/portable/cpu/op_fmod.cpp b/kernels/portable/cpu/op_fmod.cpp
@@ -138,7 +138,7 @@ Tensor& fmod_Scalar_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::REALHBF16>(
-        [val_b](const auto val_a) {
+        [val_b](const auto& val_a) {
           return executorch::math::fmod(val_a, (decltype(val_a))val_b);
         },
         ctx,
diff --git a/kernels/portable/cpu/op_isinf.cpp b/kernels/portable/cpu/op_isinf.cpp
@@ -14,7 +14,18 @@ namespace torch {
 namespace executor {
 namespace native {
 
-DEFINE_UNARY_UFUNC_REALHBBF16_TO_BOOL(isinf_out, std::isinf)
+bool isinf_float(float x) {
+  return std::isinf(x);
+}
+
+bool isinf_double(double x) {
+  return std::isinf(x);
+}
+
+Tensor& isinf_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
+  return internal::unary_ufunc_realhbbf16_to_bool(
+      isinf_float, isinf_double, ctx, in, out);
+}
 
 } // namespace native
 } // namespace executor
diff --git a/kernels/portable/cpu/op_isnan.cpp b/kernels/portable/cpu/op_isnan.cpp
@@ -13,8 +13,18 @@
 namespace torch {
 namespace executor {
 namespace native {
+bool isnan_float(float x) {
+  return std::isnan(x);
+}
 
-DEFINE_UNARY_UFUNC_REALHBBF16_TO_BOOL(isnan_out, std::isnan)
+bool isnan_double(double x) {
+  return std::isnan(x);
+}
+
+Tensor& isnan_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
+  return internal::unary_ufunc_realhbbf16_to_bool(
+      isnan_float, isnan_double, ctx, in, out);
+}
 
 } // namespace native
 } // namespace executor
diff --git a/kernels/portable/cpu/op_maximum.cpp b/kernels/portable/cpu/op_maximum.cpp
@@ -49,7 +49,7 @@ Tensor& maximum_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::REALHBBF16>(
-        [](const auto val_a, const auto val_b) {
+        [](const auto& val_a, const auto& val_b) {
           return utils::max_override(val_a, val_b);
         },
         ctx,
diff --git a/kernels/portable/cpu/op_mul.cpp b/kernels/portable/cpu/op_mul.cpp
@@ -72,7 +72,7 @@ Tensor& mul_out(
           CTYPE_COMPUTE,
           op_name,
           utils::SupportedTensorDtypes::REALHBBF16>(
-          [](const auto val_a, const auto val_b) { return val_a * val_b; },
+          [](const auto& val_a, const auto& val_b) { return val_a * val_b; },
           ctx,
           a,
           utils::SupportedTensorDtypes::REALHBBF16,
@@ -116,7 +116,7 @@ Tensor& mul_scalar_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::SAME_AS_COMMON>(
-        [val_b](const auto val_a) { return val_a * val_b; },
+        [val_b](const auto& val_a) { return val_a * val_b; },
         ctx,
         a,
         utils::SupportedTensorDtypes::REALHBBF16,
diff --git a/kernels/portable/cpu/op_neg.cpp b/kernels/portable/cpu/op_neg.cpp
@@ -39,7 +39,7 @@ Tensor& neg_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
         CTYPE,
         op_name,
         utils::SupportedTensorDtypes::SAME_AS_COMMON>(
-        [](const auto val_in) { return -val_in; },
+        [](const auto& val_in) { return -val_in; },
         ctx,
         in,
         utils::SupportedTensorDtypes::REALHBF16,
diff --git a/kernels/portable/cpu/op_pow.cpp b/kernels/portable/cpu/op_pow.cpp
@@ -57,7 +57,7 @@ Tensor& pow_Tensor_Tensor_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::REALHBF16>(
-        [](const auto val_a, const auto val_b) {
+        [](const auto& val_a, const auto& val_b) {
           return executorch::math::pow(val_a, val_b);
         },
         ctx,
diff --git a/kernels/portable/cpu/op_rsub.cpp b/kernels/portable/cpu/op_rsub.cpp
@@ -56,7 +56,7 @@ Tensor& rsub_scalar_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::SAME_AS_COMMON>(
-        [val_b, val_alpha](const auto val_a) {
+        [val_b, val_alpha](const auto& val_a) {
           return val_b - val_alpha * val_a;
         },
         ctx,
diff --git a/kernels/portable/cpu/op_sigmoid.cpp b/kernels/portable/cpu/op_sigmoid.cpp
@@ -47,7 +47,7 @@ Tensor& sigmoid_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::FLOATHBF16>(
-        [](const auto val_in) {
+        [](const auto& val_in) {
           const auto one = static_cast<decltype(val_in)>(1.0);
           auto out_val = one / (one + executorch::math::exp(-val_in));
           return out_val;
diff --git a/kernels/portable/cpu/op_sub.cpp b/kernels/portable/cpu/op_sub.cpp
@@ -60,7 +60,7 @@ Tensor& sub_out(
         CTYPE_COMPUTE,
         op_name,
         utils::SupportedTensorDtypes::REALHBF16>(
-        [val_alpha](const auto val_a, const auto val_b) {
+        [val_alpha](const auto& val_a, const auto& val_b) {
           return val_a - (decltype(val_b))(val_alpha)*val_b;
         },
         ctx,

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ void exp_data(`
`36`	`36`	`CTYPE_OUT* out_data) {`
`37`	`37`	`using Vec = at::vec::Vectorized<CTYPE_IN>;`
`38`	`38`	`at::vec::map<CTYPE_IN>(`
`39`		`- [](Vec x) { return x.exp(); }, out_data, in_data, numel);`
	`39`	`+ [](Vec& x) { return x.exp(); }, out_data, in_data, numel);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ void layer_norm(`
`92`	`92`	`}`
`93`	`93`	`} else {`
`94`	`94`	`at::vec::map3<CTYPE>(`
`95`		`- [scale, offset](auto x, auto gamma, auto beta) {`
	`95`	`+ [scale, offset](auto& x, auto& gamma, auto& beta) {`
`96`	`96`	`using Vec = decltype(x);`
`97`	`97`	`return (x * Vec(scale) + Vec(offset)) * gamma + beta;`
`98`	`98`	`},`