[flang] Apply lower bounds correctly before runtime call to ubound

[clementval]

Summary

Apply lower bounds before call to the ubound runtime function.
This is similary done in genLBound.

[jeanPerier]

LGTM, thanks

flang/lib/Lower/IntrinsicCall.cpp

static mlir::Value computeLBOUND(fir::FirOpBuilder &builder, mlir::Location loc,
   mlir::Value extent = fir::factory::readExtent(builder, loc, array, dim);
   zero = builder.createConvert(loc, extent.getType(), zero);
   auto dimIsEmpty = builder.create<mlir::arith::CmpIOp>(
       loc, mlir::arith::CmpIPredicate::eq, extent, zero);
   one = builder.createConvert(loc, lb.getType(), one);
   return builder.create<mlir::arith::SelectOp>(loc, dimIsEmpty, one, lb);
 }
 
-/// Create a fir.box to be passed to the LBOUND runtime.
+/// Create a fir.box to be passed to the LBOUND/UBOUND runtime.
 /// This ensure that local lower bounds of assumed shape are propagated and that
 /// a fir.box with equivalent LBOUNDs but an explicit shape is created for
 /// assumed size arrays to avoid undefined behaviors in codegen or the runtime.
-static mlir::Value createBoxForLBOUND(mlir::Location loc,
-                                      fir::FirOpBuilder &builder,
-                                      const fir::ExtendedValue &array) {
+static mlir::Value
+createBoxForRuntimeBoundInquiry(mlir::Location loc, fir::FirOpBuilder &builder,
   if (!array.isAssumedSize())
     return array.match(
         [&](const fir::BoxValue &boxValue) -> mlir::Value {
           // This entity is mapped to a fir.box that may not contain the local
           // lower bound information if it is a dummy. Rebox it with the local
           // shape information.
           mlir::Value localShape = builder.createShape(loc, array);
           mlir::Value oldBox = boxValue.getAddr();
IntrinsicLibrary::genLbound(mlir::Type resultType,
   if (llvm::Optional<std::int64_t> cstDim =
           fir::factory::getIntIfConstant(dim)) {
     mlir::Value one = builder.createIntegerConstant(loc, resultType, 1);
     mlir::Value zero = builder.createIntegerConstant(loc, indexType, 0);
     mlir::Value lb = computeLBOUND(builder, loc, array, *cstDim - 1, zero, one);
     return builder.createConvert(loc, resultType, lb);
   }
 
-  fir::ExtendedValue box = createBoxForLBOUND(loc, builder, array);
+  fir::ExtendedValue box = createBoxForRuntimeBoundInquiry(loc, builder, array);
   return builder.createConvert(
       loc, resultType,
       fir::runtime::genLboundDim(builder, loc, fir::getBase(box), dim));
 }
 
 // UBOUND
 fir::ExtendedValue
 IntrinsicLibrary::genUbound(mlir::Type resultType,
if (args.size() == 3) {
 
     // Create mutable fir.box to be passed to the runtime for the result.
     mlir::Type type = builder.getVarLenSeqTy(resultType, /*rank=*/1);
     fir::MutableBoxValue resultMutableBox =
         fir::factory::createTempMutableBox(builder, loc, type);
     mlir::Value resultIrBox =
         fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
 
-    fir::runtime::genUbound(builder, loc, resultIrBox, fir::getBase(args[0]),
-                            kind);
+    fir::ExtendedValue box =
+        createBoxForRuntimeBoundInquiry(loc, builder, args[0]);
+    fir::runtime::genUbound(builder, loc, resultIrBox, fir::getBase(box), kind);
 
     return readAndAddCleanUp(resultMutableBox, resultType, "UBOUND");
   }
   return mlir::Value();
 }
 
 // SPACING
 mlir::Value IntrinsicLibrary::genSpacing(mlir::Type resultType,

flang/test/Lower/Intrinsics/ubound01.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! Check that assumed shape lower bounds are applied before passing the
+! descriptor to the runtime call.
+
+  real, target :: a(10:20,99:100)
+  call s2(a,17,-100)
+contains
+  subroutine show(bounds)
+    integer(8) :: bounds(:)
+    print *, bounds
+  end subroutine
+  subroutine s2(a,n,n2)
+    Real a(n:,n2:)
+    call show(ubound(a, kind=8))
+  End Subroutine
+end
+
+! CHECK-LABEL: func.func @_QFPs2
+! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?x?xf32>>
+! CHECK: %[[BOX:.*]] = fir.rebox %[[ARG0]](%{{.*}}) : (!fir.box<!fir.array<?x?xf32>>, !fir.shift<2>) -> !fir.box<!fir.array<?x?xf32>>
+! CHECK: %[[BOX_NONE:.*]] = fir.convert %[[BOX]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<none>
+! CHECK: %{{.*}} = fir.call @_FortranAUbound(%{{.*}}, %[[BOX_NONE]], %{{.*}}, %{{.*}}, %{{.*}}) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> none