Enable volatile for declarations of volatile boxes

Author: ashermancinelli

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

@@ -207,6 +207,35 @@ static bool hasExplicitLowerBounds(mlir::Value shape) {
          mlir::isa<fir::ShapeShiftType, fir::ShiftType>(shape.getType());
 }
 
+static std::pair<mlir::Type, mlir::Value>
+updateTypeWithVolatility(mlir::Type inputType, mlir::Value memref,
+                         mlir::OpBuilder &builder,
+                         fir::FortranVariableFlagsAttr fortran_attrs) {
+  if (mlir::isa<fir::BoxType, fir::ReferenceType>(inputType) && fortran_attrs &&
+      bitEnumContainsAny(fortran_attrs.getFlags(),
+                         fir::FortranVariableFlagsEnum::fortran_volatile)) {
+    const bool isPointer = bitEnumContainsAny(
+        fortran_attrs.getFlags(), fir::FortranVariableFlagsEnum::pointer);
+    auto updateType = [&](auto t) {
+      using FIRT = decltype(t);
+      // If an entity is a pointer, the entity it points to is volatile, as far
+      // as consumers of the pointer are concerned.
+      auto elementType = t.getEleTy();
+      const bool elementTypeIsVolatile =
+          isPointer || fir::isa_volatile_type(elementType);
+      auto newEleTy =
+          fir::updateTypeWithVolatility(elementType, elementTypeIsVolatile);
+      inputType = FIRT::get(newEleTy, true);
+    };
+    llvm::TypeSwitch<mlir::Type>(inputType)
+        .Case<fir::ReferenceType, fir::BoxType>(updateType)
+        .Default([](mlir::Type t) { return t; });
+    memref =
+        builder.create<fir::VolatileCastOp>(memref.getLoc(), inputType, memref);
+  }
+  return std::make_pair(inputType, memref);
+}
+
 void hlfir::DeclareOp::build(mlir::OpBuilder &builder,
                              mlir::OperationState &result, mlir::Value memref,
                              llvm::StringRef uniq_name, mlir::Value shape,
@@ -217,22 +246,8 @@ void hlfir::DeclareOp::build(mlir::OpBuilder &builder,
   auto nameAttr = builder.getStringAttr(uniq_name);
   mlir::Type inputType = memref.getType();
   bool hasExplicitLbs = hasExplicitLowerBounds(shape);
-  if (auto refType = mlir::dyn_cast<fir::ReferenceType>(inputType);
-      fortran_attrs && refType &&
-      bitEnumContainsAny(fortran_attrs.getFlags(),
-                         fir::FortranVariableFlagsEnum::fortran_volatile)) {
-    auto eleType = refType.getEleTy();
-    const bool isPointer = bitEnumContainsAny(
-        fortran_attrs.getFlags(), fir::FortranVariableFlagsEnum::pointer);
-    if (isPointer) {
-      // If an entity is a pointer, the entity it points to is volatile, as far
-      // as consumers of the pointer are concerned.
-      eleType = fir::updateTypeWithVolatility(eleType, true);
-    }
-    inputType = fir::ReferenceType::get(eleType, /*isVolatile=*/true);
-    memref =
-        builder.create<fir::VolatileCastOp>(memref.getLoc(), inputType, memref);
-  }
+  std::tie(inputType, memref) =
+      updateTypeWithVolatility(inputType, memref, builder, fortran_attrs);
   mlir::Type hlfirVariableType =
       getHLFIRVariableType(inputType, hasExplicitLbs);
   build(builder, result, {hlfirVariableType, inputType}, memref, shape,

flang/test/Lower/volatile3.f90

@@ -44,6 +44,7 @@ subroutine sub_volatile_array_pointer(arr)
    end subroutine
 end program
 
+
 ! CHECK-LABEL:   func.func @_QQmain() attributes {fir.bindc_name = "p"} {
 ! CHECK:           %[[VAL_0:.*]] = arith.constant 10 : index
 ! CHECK:           %[[VAL_1:.*]] = fir.address_of(@_QFEnonvolatile_array) : !fir.ref<!fir.array<10xi32>>
@@ -117,9 +118,10 @@ subroutine sub_volatile_array_pointer(arr)
 ! CHECK:           %[[VAL_1:.*]] = arith.constant 1 : index
 ! CHECK:           %[[VAL_2:.*]] = arith.constant 5 : i32
 ! CHECK:           %[[VAL_3:.*]] = fir.dummy_scope : !fir.dscope
-! CHECK:           %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %[[VAL_3]] {fortran_attrs = #fir.var_attrs<volatile>, uniq_name = "_QFFsub_volatile_array_assumed_shapeEarr"} : (!fir.box<!fir.array<?xi32>>, !fir.dscope) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
-! CHECK:           %[[VAL_5:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_1]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
-! CHECK:           hlfir.assign %[[VAL_2]] to %[[VAL_5]] : i32, !fir.ref<i32>
+! CHECK:           %[[VAL_4:.*]] = fir.volatile_cast %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>, volatile>
+! CHECK:           %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_4]] dummy_scope %[[VAL_3]] {fortran_attrs = #fir.var_attrs<volatile>, uniq_name = "_QFFsub_volatile_array_assumed_shapeEarr"} : (!fir.box<!fir.array<?xi32>, volatile>, !fir.dscope) -> (!fir.box<!fir.array<?xi32>, volatile>, !fir.box<!fir.array<?xi32>, volatile>)
+! CHECK:           %[[VAL_6:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_1]])  : (!fir.box<!fir.array<?xi32>, volatile>, index) -> !fir.ref<i32, volatile>
+! CHECK:           hlfir.assign %[[VAL_2]] to %[[VAL_6]] : i32, !fir.ref<i32, volatile>
 ! CHECK:           return
 ! CHECK:         }