[flang] prevent undefined behavior in character MAXLOC folding

[jeanPerier]

Summary

When folding MAXLOC/MINLOC, the current element being compared was moved twice
in row in case it became the new extremum. With intrinsic types, it
made no difference (std::move is a no-op for them), but for characters
where the string storage is actually moved, it caused the new extremum to
be set to the empty string, leading to wrong results.

Note: I could have left the first std::move relating to logical Findloc, but it
brings nothing and makes the code less auditable, so I also removed it.

[klausler]

CHARACTER is an intrinsic type.

[jeanPerier]

In D122590#3411747, @klausler wrote:

CHARACTER is an intrinsic type.

Thanks, I updated the commit message to state "numeric and logical types" instead.

flang/lib/Evaluate/fold-integer.cpp

bool IsHit(typename Constant<T>::Element element,
       std::optional<Constant<T>> &value,
       [[maybe_unused]] RelationalOperator relation) const {
     std::optional<Expr<LogicalResult>> cmp;
     bool result{true};
     if (value) {
       if constexpr (T::category == TypeCategory::Logical) {
         // array(at) .EQV. value?
         static_assert(WHICH == WhichLocation::Findloc);
-        cmp.emplace(
-            ConvertToType<LogicalResult>(Expr<T>{LogicalOperation<T::kind>{
-                LogicalOperator::Eqv, Expr<T>{Constant<T>{std::move(element)}},
-                Expr<T>{Constant<T>{*value}}}}));
+        cmp.emplace(ConvertToType<LogicalResult>(
+            Expr<T>{LogicalOperation<T::kind>{LogicalOperator::Eqv,
+                Expr<T>{Constant<T>{element}}, Expr<T>{Constant<T>{*value}}}}));
       } else { // compare array(at) to value
-        cmp.emplace(
-            PackageRelation(relation, Expr<T>{Constant<T>{std::move(element)}},
-                Expr<T>{Constant<T>{*value}}));
+        cmp.emplace(PackageRelation(relation, Expr<T>{Constant<T>{element}},
       }
       Expr<LogicalResult> folded{Fold(context_, std::move(*cmp))};
       result = GetScalarConstantValue<LogicalResult>(folded).value().IsTrue();
     } else {
       // first unmasked element for MAXLOC/MINLOC - always take it
     }
     if constexpr (WHICH == WhichLocation::Maxloc ||
         WHICH == WhichLocation::Minloc) {

flang/test/Evaluate/fold-findloc.f90

module m1
   logical, parameter :: test_ni2e = all(minloc(ia2, dim=1) == [1, 1, 2])
   logical, parameter :: test_ni2f = all(minloc(ia2, dim=1, back=.true.) == [1, 2, 2])
   logical, parameter :: test_ni2g = all(minloc(ia2, dim=2) == [1, 3])
 
   logical, parameter :: test_xi3a = all(maxloc(ia3) == [0,0,0])
   logical, parameter :: test_xi3b = all(maxloc(ia3, back=.true.) == [0,0,0])
   logical, parameter :: test_xi3c = all(maxloc(ia3, dim=2) == reshape([0,0,0,0],shape=[2,2]))
   logical, parameter :: test_xi3d = all(maxloc(ia3, dim=2, back=.true.) == reshape([0,0,0,0],shape=[2,2]))
+
+  character(1), parameter :: a(4) = ['a', 'b', 'a', 'b']
+  logical, parameter :: test_char1 = all(maxloc(a).eq.[2])
+  logical, parameter :: test_char2 = all(minloc(a).eq.[1])
+  logical, parameter :: test_char3 = all(maxloc(a, back=.true.).eq.[4])
+  logical, parameter :: test_char4 = all(minloc(a, back=.true.).eq.[3])
 end module