[Flang] Fix code for ALLOCATE statement with MOLD argument for scalars

[PeteSteinfeld]

Summary

When we allocate a variable using a MOLD argument, the function that
applies the type of the MOLD argument first checks to see if the
variable is already allocated by looking at its descriptor. But in the
case of allocating a scalar, the descriptor has not yet been created and
the associated memory was uninitialized. This update fixes that.

Note that there's already a test for allocations, but it uses the argument
"use-alloc-runtime", which causes different code to be generated. So I
added a new test.

[jeanPerier]

I think removing this check is not correct from a semantic point of view because we are required to gracefully catch double allocation errors when STAT/ERRMSG is provided.

I think the bug may be caused by the fact that the descriptor is obtained using box.getAddr() at [1] before emitting the runtime call, and this is not correct with the current lowering: fir::factory::getMutableIRBox(builder, loc, box); should be used instead to ensure the descriptor of local allocatables is synced with the local variables tracking the allocatable in a "descriptor-less" fashion.

[1]: https://github.com/llvm/llvm-project/blob/4143d3ebd2d8fbefc8d7ba2cded304a6049aed7f/flang/lib/Lower/Allocatable.cpp#L223

[clementval]

In D144761#4153469, @jeanPerier wrote:

I think removing this check is not correct from a semantic point of view because we are required to gracefully catch double allocation errors when STAT/ERRMSG is provided.

I think the bug may be caused by the fact that the descriptor is obtained using box.getAddr() at [1] before emitting the runtime call, and this is not correct with the current lowering: fir::factory::getMutableIRBox(builder, loc, box); should be used instead to ensure the descriptor of local allocatables is synced with the local variables tracking the allocatable in a "descriptor-less" fashion.

[1]: https://github.com/llvm/llvm-project/blob/4143d3ebd2d8fbefc8d7ba2cded304a6049aed7f/flang/lib/Lower/Allocatable.cpp#L223

I agree with Jean here. We likely have the same problem with source allocation as well.

[PeteSteinfeld]

Responding to Valentin's and Jean's comments to actually fix the code. Also,
I added a test.

[jeanPerier]

Thanks Pete, LGTM.

[clementval]

LGTM

flang/lib/Lower/Allocatable.cpp

static void genRuntimeAllocateApplyMold(fir::FirOpBuilder &builder,
                                         fir::ExtendedValue mold, int rank) {
   mlir::func::FuncOp callee =
       box.isPointer()
           ? fir::runtime::getRuntimeFunc<mkRTKey(PointerApplyMold)>(loc,
                                                                     builder)
           : fir::runtime::getRuntimeFunc<mkRTKey(AllocatableApplyMold)>(
                 loc, builder);
   llvm::SmallVector<mlir::Value> args{
-      box.getAddr(), fir::getBase(mold),
+      fir::factory::getMutableIRBox(builder, loc, box), fir::getBase(mold),
       builder.createIntegerConstant(
           loc, callee.getFunctionType().getInputs()[2], rank)};
   llvm::SmallVector<mlir::Value> operands;
   for (auto [fst, snd] : llvm::zip(args, callee.getFunctionType().getInputs()))
     operands.emplace_back(builder.createConvert(loc, snd, fst));
   builder.create<fir::CallOp>(loc, callee, operands);
 }
 

flang/test/Lower/allocate-mold.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! Test lowering of ALLOCATE statement with a MOLD argument for scalars
+
+subroutine scalar_mold_allocation()
+  integer, allocatable :: a
+  allocate(a, mold=9)
+end subroutine
+
+! CHECK-LABEL: func.func @_QPscalar_mold_allocation() {
+! CHECK: %[[A:.*]] = fir.alloca !fir.box<!fir.heap<i32>> {bindc_name = "a", uniq_name = "_QFscalar_mold_allocationEa"}
+! CHECK: %[[HEAP_A:.*]] = fir.alloca !fir.heap<i32> {uniq_name = "_QFscalar_mold_allocationEa.addr"}
+! CHECK: %[[ADDR_A:.*]] = fir.load %[[HEAP_A]] : !fir.ref<!fir.heap<i32>>
+! CHECK: %[[BOX_ADDR_A:.*]] = fir.embox %[[ADDR_A]] : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>>
+! CHECK: fir.store %[[BOX_ADDR_A]] to %[[A]] : !fir.ref<!fir.box<!fir.heap<i32>>>
+! CHECK: %[[A_REF_BOX_NONE1:.*]] = fir.convert %[[A]] : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>>
+! CHECK: %{{.*}} = fir.call @_FortranAAllocatableApplyMold(%[[A_REF_BOX_NONE1]], %{{.*}}, %{{.*}}) {{.*}} : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32) -> none
+! CHECK: %[[A_REF_BOX_NONE2:.*]] = fir.convert %[[A]] : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>>
+! CHECK: %{{.*}} = fir.call @_FortranAAllocatableAllocate(%[[A_REF_BOX_NONE2]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) {{.*}} : (!fir.ref<!fir.box<none>>, i1, !fir.box<none>, !fir.ref<i8>, i32) -> i32