Merge pull request #1148 from schweitzpgi/ch-bug1

Fix mask evaluation bug.

Author: schweitzpgi

flang/lib/Lower/ConvertExpr.cpp

@@ -4077,11 +4077,16 @@ class ArrayExprLowering {
     return header;
   }
 
+  /// Lower mask expressions with implied iteration spaces from the variants of
+  /// WHERE syntax. Since it is legal for mask expressions to have side-effects
+  /// and modify values that will be used for the lhs, rhs, or both of
+  /// subsequent assignments, the mask must be evaluated before the assignment
+  /// is processed.
   /// Mask expressions are array expressions too.
   void genMasks() {
-    auto loc = getLoc();
     // Lower the mask expressions, if any.
     if (implicitSpaceHasMasks()) {
+      auto loc = getLoc();
       // Mask expressions are array expressions too.
       for (const auto *e : implicitSpace->getExprs())
         if (e && !implicitSpace->isLowered(e)) {
@@ -4140,7 +4145,6 @@ class ArrayExprLowering {
             auto ldExt = builder.create<fir::LoadOp>(loc, coor);
             extents.push_back(builder.createConvert(loc, idxTy, ldExt));
           }
-          destShape = extents;
           // Construct shape of buffer.
           auto shapeOp = builder.genShape(loc, extents);
 
@@ -4221,11 +4225,6 @@ class ArrayExprLowering {
   std::pair<IterationSpace, mlir::OpBuilder::InsertPoint>
   genIterSpace(mlir::Type resultType) {
     auto loc = getLoc();
-
-    // Generate any mask expressions, as necessary. This is the compute step
-    // that creates the effective masks. See 10.2.3.2 in particular.
-    genMasks();
-
     auto shape = genIterationShape();
     if (!destination) {
       // Allocate storage for the result if it is not already provided.
@@ -4675,16 +4674,9 @@ class ArrayExprLowering {
   static ExtValue convertAdjustedType(fir::FirOpBuilder &builder,
                                       mlir::Location loc, mlir::Type toType,
                                       const ExtValue &exv) {
-    auto lenFromBufferType = [&](mlir::Type ty) {
-      return builder.create<mlir::ConstantIndexOp>(
-          loc, fir::dyn_cast_ptrEleTy(ty).cast<fir::CharacterType>().getLen());
-    };
     return exv.match(
         [&](const fir::CharBoxValue &cb) -> ExtValue {
-          auto typeParams = fir::getTypeParams(exv);
-          auto len = typeParams.size() > 0
-                         ? typeParams[0]
-                         : lenFromBufferType(cb.getBuffer().getType());
+          auto len = cb.getLen();
           auto mem =
               builder.create<fir::AllocaOp>(loc, toType, mlir::ValueRange{len});
           fir::CharBoxValue result(mem, len);
@@ -4706,7 +4698,9 @@ class ArrayExprLowering {
     return [=](IterSpace iters) -> ExtValue {
       auto exv = lambda(iters);
       auto val = fir::getBase(exv);
-      if (elementTypeWasAdjusted(val.getType()))
+      auto valTy = val.getType();
+      if (elementTypeWasAdjusted(valTy) &&
+          !(fir::isa_ref_type(valTy) && fir::isa_integer(ty)))
         return convertAdjustedType(builder, loc, ty, exv);
       return builder.createConvert(loc, ty, val);
     };
@@ -6401,7 +6395,11 @@ class ArrayExprLowering {
       : converter{converter}, builder{converter.getFirOpBuilder()},
         stmtCtx{stmtCtx}, symMap{symMap},
         explicitSpace(expSpace->isActive() ? expSpace : nullptr),
-        implicitSpace(impSpace->empty() ? nullptr : impSpace), semant{sem} {}
+        implicitSpace(impSpace->empty() ? nullptr : impSpace), semant{sem} {
+    // Generate any mask expressions, as necessary. This is the compute step
+    // that creates the effective masks. See 10.2.3.2 in particular.
+    genMasks();
+  }
 
   mlir::Location getLoc() { return converter.getCurrentLocation(); }
 

flang/test/Lower/array-expression.f90

@@ -816,13 +816,12 @@ subroutine test19g(a,b,i)
   ! CHECK: %[[VAL_25:.*]] = subi %[[VAL_14]], %[[VAL_23]] : index
   ! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] unordered iter_args(%[[VAL_28:.*]] = %[[VAL_12]]) -> (!fir.array<70x!fir.char<4,?>>) {
   ! CHECK: %[[VAL_29:.*]] = fir.array_access %[[VAL_20]], %[[VAL_27]] : (!fir.array<140x!fir.char<2,13>>, index) -> !fir.ref<!fir.char<2,13>>
-  ! CHECK: %[[VAL_30:.*]] = constant 13 : index
-  ! CHECK: %[[VAL_31:.*]] = fir.alloca !fir.char<4,?>(%[[VAL_30]] : index)
-  ! CHECK: %[[VAL_32:.*]] = cmpi slt, %[[VAL_30]], %[[VAL_4]] : index
-  ! CHECK: %[[VAL_33:.*]] = select %[[VAL_32]], %[[VAL_30]], %[[VAL_4]] : index
+  ! CHECK: %[[VAL_31:.*]] = fir.alloca !fir.char<4,?>(%[[VAL_4]] : index)
+  ! CHECK: %[[VAL_32:.*]] = cmpi slt, %[[VAL_4]], %[[VAL_4]] : index
+  ! CHECK: %[[VAL_33:.*]] = select %[[VAL_32]], %[[VAL_4]], %[[VAL_4]] : index
   ! CHECK: fir.char_convert %[[VAL_29]] for %[[VAL_33]] to %[[VAL_31]] : !fir.ref<!fir.char<2,13>>, index, !fir.ref<!fir.char<4,?>>
   ! CHECK: %[[VAL_34:.*]] = constant 1 : index
-  ! CHECK: %[[VAL_35:.*]] = subi %[[VAL_30]], %[[VAL_34]] : index
+  ! CHECK: %[[VAL_35:.*]] = subi %[[VAL_4]], %[[VAL_34]] : index
   ! CHECK: %[[VAL_36:.*]] = constant 32 : i32
   ! CHECK: %[[VAL_37:.*]] = fir.undefined !fir.char<4>
   ! CHECK: %[[VAL_38:.*]] = fir.insert_value %[[VAL_37]], %[[VAL_36]], [0 : index] : (!fir.char<4>, i32) -> !fir.char<4>