diff --git a/flang/include/flang/Optimizer/Builder/FIRBuilder.h b/flang/include/flang/Optimizer/Builder/FIRBuilder.h index 9382d77a8d67..6e617d50f0be 100644 --- a/flang/include/flang/Optimizer/Builder/FIRBuilder.h +++ b/flang/include/flang/Optimizer/Builder/FIRBuilder.h @@ -271,14 +271,14 @@ public: /// Sample genDeclare callback for createArrayTemp() below. /// It creates fir.declare operation using the given operands. /// \p memref is the base of the allocated temporary, - /// which may be !fir.ref> or !fir.ref>. + /// which may be !fir.ref> or !fir.box/class<>. static mlir::Value genTempDeclareOp(fir::FirOpBuilder &builder, mlir::Location loc, mlir::Value memref, llvm::StringRef name, mlir::Value shape, llvm::ArrayRef typeParams, fir::FortranVariableFlagsAttr attrs); - /// Create a temporary array with the given \p arrayType, + /// Create a temporary with the given \p baseType, /// \p shape, \p extents and \p typeParams. An optional /// \p polymorphicMold specifies the entity which dynamic type /// has to be used for the allocation. @@ -291,16 +291,26 @@ public: /// If \p useStack is true, the function will try to do the allocation /// in stack memory (which is not always possible currently). /// The first return value is the base of the temporary object, - /// which may be !fir.ref> or !fir.ref>. + /// which may be !fir.ref> or !fir.box/class<>. /// The second return value is true, if the actual allocation /// was done in heap memory. + std::pair createAndDeclareTemp( + mlir::Location loc, mlir::Type baseType, mlir::Value shape, + llvm::ArrayRef extents, + llvm::ArrayRef typeParams, + const std::function &genDeclare, + mlir::Value polymorphicMold, bool useStack, llvm::StringRef tmpName); + /// Create and declare an array temporary. std::pair createArrayTemp(mlir::Location loc, fir::SequenceType arrayType, mlir::Value shape, llvm::ArrayRef extents, llvm::ArrayRef typeParams, const std::function &genDeclare, mlir::Value polymorphicMold, bool useStack = false, - llvm::StringRef tmpName = ".tmp.array"); + llvm::StringRef tmpName = ".tmp.array") { + return createAndDeclareTemp(loc, arrayType, shape, extents, typeParams, + genDeclare, polymorphicMold, useStack, tmpName); + } /// Create an LLVM stack save intrinsic op. Returns the saved stack pointer. /// The stack address space is fetched from the data layout of the current diff --git a/flang/include/flang/Optimizer/Builder/MutableBox.h b/flang/include/flang/Optimizer/Builder/MutableBox.h index 39657ddaf6e0..e1cb0f9852ba 100644 --- a/flang/include/flang/Optimizer/Builder/MutableBox.h +++ b/flang/include/flang/Optimizer/Builder/MutableBox.h @@ -181,6 +181,18 @@ mlir::Value genIsNotAllocatedOrAssociatedTest(fir::FirOpBuilder &builder, mlir::Value genNullBoxStorage(fir::FirOpBuilder &builder, mlir::Location loc, mlir::Type boxTy); +/// Generate an unallocated box of the given \p boxTy with the +/// bounds, type parameters, and dynamic type set according to the +/// parameters. +/// \p shape may be null for scalars, and \p polymorphicMold may be null for +/// statically typed entities. This box can then be directly passed to the +/// runtime for allocation. +mlir::Value getAndEstablishBoxStorage(fir::FirOpBuilder &builder, + mlir::Location loc, + fir::BaseBoxType boxTy, mlir::Value shape, + llvm::ArrayRef typeParams, + mlir::Value polymorphicMold); + } // namespace fir::factory #endif // FORTRAN_OPTIMIZER_BUILDER_MUTABLEBOX_H diff --git a/flang/include/flang/Optimizer/Dialect/FIRType.h b/flang/include/flang/Optimizer/Dialect/FIRType.h index 52b14f15f89b..ab6254da19e0 100644 --- a/flang/include/flang/Optimizer/Dialect/FIRType.h +++ b/flang/include/flang/Optimizer/Dialect/FIRType.h @@ -47,6 +47,9 @@ public: /// Returns the element type of this box type. mlir::Type getEleTy() const; + /// Get the raw address type of the memory described by the box. + mlir::Type getBaseAddressType() const; + /// Unwrap element type from fir.heap, fir.ptr and fir.array. mlir::Type unwrapInnerType() const; @@ -56,6 +59,9 @@ public: /// Is this a box for a pointer? bool isPointer() const; + /// Is this a box describing volatile memory? + bool isVolatile() const; + /// Return the same type, except for the shape, that is taken the shape /// of shapeMold. BaseBoxType getBoxTypeWithNewShape(mlir::Type shapeMold) const; diff --git a/flang/lib/Optimizer/Builder/FIRBuilder.cpp b/flang/lib/Optimizer/Builder/FIRBuilder.cpp index 68a1cc7a3aee..584f3c8ee310 100644 --- a/flang/lib/Optimizer/Builder/FIRBuilder.cpp +++ b/flang/lib/Optimizer/Builder/FIRBuilder.cpp @@ -366,55 +366,29 @@ mlir::Value fir::FirOpBuilder::createHeapTemporary( name, dynamicLength, dynamicShape, attrs); } -std::pair fir::FirOpBuilder::createArrayTemp( - mlir::Location loc, fir::SequenceType arrayType, mlir::Value shape, +std::pair fir::FirOpBuilder::createAndDeclareTemp( + mlir::Location loc, mlir::Type baseType, mlir::Value shape, llvm::ArrayRef extents, llvm::ArrayRef typeParams, const std::function &genDeclare, mlir::Value polymorphicMold, bool useStack, llvm::StringRef tmpName) { if (polymorphicMold) { // Create *allocated* polymorphic temporary using the dynamic type - // of the mold and the provided shape/extents. The created temporary - // array will be written element per element, that is why it has to be - // allocated. - mlir::Type boxHeapType = fir::HeapType::get(arrayType); - mlir::Value alloc = fir::factory::genNullBoxStorage( - *this, loc, fir::ClassType::get(boxHeapType)); - fir::FortranVariableFlagsAttr declAttrs = - fir::FortranVariableFlagsAttr::get( - getContext(), fir::FortranVariableFlagsEnum::allocatable); - - mlir::Value base = genDeclare(*this, loc, alloc, tmpName, - /*shape=*/nullptr, typeParams, declAttrs); - - int rank = extents.size(); - fir::runtime::genAllocatableApplyMold(*this, loc, alloc, polymorphicMold, - rank); - if (!extents.empty()) { - mlir::Type idxTy = getIndexType(); - mlir::Value one = createIntegerConstant(loc, idxTy, 1); - unsigned dim = 0; - for (mlir::Value extent : extents) { - mlir::Value dimIndex = createIntegerConstant(loc, idxTy, dim++); - fir::runtime::genAllocatableSetBounds(*this, loc, alloc, dimIndex, one, - extent); - } - } - if (!typeParams.empty()) { - // We should call AllocatableSetDerivedLength() here. - // TODO: does the mold provide the length parameters or - // the operation itself or should they be in sync? - TODO(loc, "polymorphic type with length parameters"); - } - fir::runtime::genAllocatableAllocate(*this, loc, alloc); - + // of the mold and the provided shape/extents. + auto boxType = fir::ClassType::get(fir::HeapType::get(baseType)); + mlir::Value boxAddress = fir::factory::getAndEstablishBoxStorage( + *this, loc, boxType, shape, typeParams, polymorphicMold); + fir::runtime::genAllocatableAllocate(*this, loc, boxAddress); + mlir::Value box = create(loc, boxAddress); + mlir::Value base = + genDeclare(*this, loc, box, tmpName, /*shape=*/mlir::Value{}, + typeParams, fir::FortranVariableFlagsAttr{}); return {base, /*isHeapAllocation=*/true}; } mlir::Value allocmem; if (useStack) - allocmem = createTemporary(loc, arrayType, tmpName, extents, typeParams); + allocmem = createTemporary(loc, baseType, tmpName, extents, typeParams); else - allocmem = - createHeapTemporary(loc, arrayType, tmpName, extents, typeParams); + allocmem = createHeapTemporary(loc, baseType, tmpName, extents, typeParams); mlir::Value base = genDeclare(*this, loc, allocmem, tmpName, shape, typeParams, fir::FortranVariableFlagsAttr{}); return {base, !useStack}; diff --git a/flang/lib/Optimizer/Builder/HLFIRTools.cpp b/flang/lib/Optimizer/Builder/HLFIRTools.cpp index f24dc2caeedf..ce82cad15389 100644 --- a/flang/lib/Optimizer/Builder/HLFIRTools.cpp +++ b/flang/lib/Optimizer/Builder/HLFIRTools.cpp @@ -1331,63 +1331,36 @@ bool hlfir::elementalOpMustProduceTemp(hlfir::ElementalOp elemental) { std::pair hlfir::createTempFromMold(mlir::Location loc, fir::FirOpBuilder &builder, hlfir::Entity mold) { + assert(!mold.isAssumedRank() && + "cannot create temporary from assumed-rank mold"); llvm::SmallVector lenParams; hlfir::genLengthParameters(loc, builder, mold, lenParams); llvm::StringRef tmpName{".tmp"}; - mlir::Value alloc; - mlir::Value isHeapAlloc; + mlir::Value shape{}; - fir::FortranVariableFlagsAttr declAttrs; - - if (mold.isPolymorphic()) { - // Create unallocated polymorphic temporary using the dynamic type - // of the mold. The static type of the temporary matches - // the static type of the mold, but then the dynamic type - // of the mold is applied to the temporary's descriptor. - - if (mold.isArray()) - hlfir::genShape(loc, builder, mold); - - // Create polymorphic allocatable box on the stack. - mlir::Type boxHeapType = fir::HeapType::get(fir::unwrapRefType( - mlir::cast(mold.getType()).getEleTy())); - // The box must be initialized, because AllocatableApplyMold - // may read its contents (e.g. for checking whether it is allocated). - alloc = fir::factory::genNullBoxStorage(builder, loc, - fir::ClassType::get(boxHeapType)); - // The temporary is unallocated even after AllocatableApplyMold below. - // If the temporary is used as assignment LHS it will be automatically - // allocated on the heap, as long as we use Assign family - // runtime functions. So set MustFree to true. - isHeapAlloc = builder.createBool(loc, true); - declAttrs = fir::FortranVariableFlagsAttr::get( - builder.getContext(), fir::FortranVariableFlagsEnum::allocatable); - } else if (mold.isArray()) { - mlir::Type sequenceType = - hlfir::getFortranElementOrSequenceType(mold.getType()); + llvm::SmallVector extents; + if (mold.isArray()) { shape = hlfir::genShape(loc, builder, mold); - auto extents = hlfir::getIndexExtents(loc, builder, shape); - alloc = builder.createHeapTemporary(loc, sequenceType, tmpName, extents, - lenParams); - isHeapAlloc = builder.createBool(loc, true); - } else { - alloc = builder.createTemporary(loc, mold.getFortranElementType(), tmpName, - /*shape=*/std::nullopt, lenParams); - isHeapAlloc = builder.createBool(loc, false); - } - auto declareOp = - builder.create(loc, alloc, tmpName, shape, lenParams, - /*dummy_scope=*/nullptr, declAttrs); - if (mold.isPolymorphic()) { - int rank = mold.getRank(); - // TODO: should probably read rank from the mold. - if (rank < 0) - TODO(loc, "create temporary for assumed rank polymorphic"); - fir::runtime::genAllocatableApplyMold(builder, loc, alloc, - mold.getFirBase(), rank); + extents = hlfir::getExplicitExtentsFromShape(shape, builder); } - return {hlfir::Entity{declareOp.getBase()}, isHeapAlloc}; + bool useStack = !mold.isArray() && !mold.isPolymorphic(); + auto genTempDeclareOp = + [](fir::FirOpBuilder &builder, mlir::Location loc, mlir::Value memref, + llvm::StringRef name, mlir::Value shape, + llvm::ArrayRef typeParams, + fir::FortranVariableFlagsAttr attrs) -> mlir::Value { + auto declareOp = + builder.create(loc, memref, name, shape, typeParams, + /*dummy_scope=*/nullptr, attrs); + return declareOp.getBase(); + }; + + auto [base, isHeapAlloc] = builder.createAndDeclareTemp( + loc, mold.getElementOrSequenceType(), shape, extents, lenParams, + genTempDeclareOp, mold.isPolymorphic() ? mold.getBase() : nullptr, + useStack, tmpName); + return {hlfir::Entity{base}, builder.createBool(loc, isHeapAlloc)}; } hlfir::Entity hlfir::createStackTempFromMold(mlir::Location loc, diff --git a/flang/lib/Optimizer/Builder/MutableBox.cpp b/flang/lib/Optimizer/Builder/MutableBox.cpp index e6d630412ec3..f20b5e37dffd 100644 --- a/flang/lib/Optimizer/Builder/MutableBox.cpp +++ b/flang/lib/Optimizer/Builder/MutableBox.cpp @@ -349,10 +349,7 @@ mlir::Value fir::factory::createUnallocatedBox( const bool isAssumedRank = baseBoxType.isAssumedRank(); if (isAssumedRank) baseBoxType = baseBoxType.getBoxTypeWithNewShape(/*rank=*/0); - auto baseAddrType = baseBoxType.getEleTy(); - if (!fir::isa_ref_type(baseAddrType)) - baseAddrType = - builder.getRefType(baseAddrType, fir::isa_volatile_type(baseBoxType)); + auto baseAddrType = baseBoxType.getBaseAddressType(); auto type = fir::unwrapRefType(baseAddrType); auto eleTy = fir::unwrapSequenceType(type); if (auto recTy = mlir::dyn_cast(eleTy)) @@ -982,3 +979,20 @@ mlir::Value fir::factory::genNullBoxStorage(fir::FirOpBuilder &builder, builder.create(loc, nullBox, boxStorage); return boxStorage; } + +mlir::Value fir::factory::getAndEstablishBoxStorage( + fir::FirOpBuilder &builder, mlir::Location loc, fir::BaseBoxType boxTy, + mlir::Value shape, llvm::ArrayRef typeParams, + mlir::Value polymorphicMold) { + mlir::Value boxStorage = builder.createTemporary(loc, boxTy); + mlir::Value nullAddr = + builder.createNullConstant(loc, boxTy.getBaseAddressType()); + mlir::Value box = + builder.create(loc, boxTy, nullAddr, shape, + /*emptySlice=*/mlir::Value{}, + fir::factory::elideLengthsAlreadyInType( + boxTy.unwrapInnerType(), typeParams), + polymorphicMold); + builder.create(loc, box, boxStorage); + return boxStorage; +} diff --git a/flang/lib/Optimizer/CodeGen/LowerRepackArrays.cpp b/flang/lib/Optimizer/CodeGen/LowerRepackArrays.cpp index 7fb713ff1a6c..de97a0bbc184 100644 --- a/flang/lib/Optimizer/CodeGen/LowerRepackArrays.cpp +++ b/flang/lib/Optimizer/CodeGen/LowerRepackArrays.cpp @@ -190,12 +190,10 @@ mlir::Value PackArrayConversion::allocateTempBuffer( if (useStack && canAllocateTempOnStack(origBox)) assert(!isHeapAllocation && "temp must have been allocated on the stack"); - if (isHeapAllocation) - if (auto baseType = mlir::dyn_cast(base.getType())) - if (mlir::isa(baseType.getEleTy())) - return builder.create(loc, base); - mlir::Type ptrType = base.getType(); + if (llvm::isa(ptrType)) + return base; + mlir::Type tempBoxType = fir::BoxType::get(mlir::isa(ptrType) ? ptrType : fir::unwrapRefType(ptrType)); diff --git a/flang/lib/Optimizer/Dialect/FIRType.cpp b/flang/lib/Optimizer/Dialect/FIRType.cpp index 1e6e95393c2f..e65faf3a7396 100644 --- a/flang/lib/Optimizer/Dialect/FIRType.cpp +++ b/flang/lib/Optimizer/Dialect/FIRType.cpp @@ -1407,6 +1407,13 @@ mlir::Type BaseBoxType::getEleTy() const { [](auto type) { return type.getEleTy(); }); } +mlir::Type BaseBoxType::getBaseAddressType() const { + mlir::Type eleTy = getEleTy(); + if (fir::isa_ref_type(eleTy)) + return eleTy; + return fir::ReferenceType::get(eleTy, isVolatile()); +} + mlir::Type BaseBoxType::unwrapInnerType() const { return fir::unwrapInnerType(getEleTy()); } @@ -1492,6 +1499,7 @@ bool fir::BaseBoxType::isPointer() const { return llvm::isa(getEleTy()); } +bool BaseBoxType::isVolatile() const { return fir::isa_volatile_type(*this); } //===----------------------------------------------------------------------===// // FIROpsDialect //===----------------------------------------------------------------------===// diff --git a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp index 8cfca59ecdad..baa2e2180eaf 100644 --- a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp +++ b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp @@ -1586,7 +1586,7 @@ void hlfir::AssociateOp::build(mlir::OpBuilder &builder, mlir::Type firVarType; auto sourceExprType = mlir::dyn_cast(source.getType()); if (sourceExprType && sourceExprType.isPolymorphic()) - firVarType = fir::ClassType::get(fir::HeapType::get(dataType)); + firVarType = fir::ClassType::get(dataType); else firVarType = fir::ReferenceType::get(dataType); diff --git a/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp b/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp index 8a36214def16..58f2b5771297 100644 --- a/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp +++ b/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp @@ -125,7 +125,9 @@ createArrayTemp(mlir::Location loc, fir::FirOpBuilder &builder, auto [base, isHeapAlloc] = builder.createArrayTemp( loc, sequenceType, shape, extents, lenParams, genTempDeclareOp, polymorphicMold ? polymorphicMold->getFirBase() : nullptr); - return {hlfir::Entity{base}, builder.createBool(loc, isHeapAlloc)}; + hlfir::Entity temp = hlfir::Entity{base}; + assert(!temp.isAllocatable() && "temp must have been allocated"); + return {temp, builder.createBool(loc, isHeapAlloc)}; } /// Copy \p source into a new temporary and package the temporary into a @@ -134,13 +136,10 @@ static mlir::Value copyInTempAndPackage(mlir::Location loc, fir::FirOpBuilder &builder, hlfir::Entity source) { auto [temp, cleanup] = hlfir::createTempFromMold(loc, builder, source); - builder.create(loc, source, temp, temp.isAllocatable(), + assert(!temp.isAllocatable() && "expect temp to already be allocated"); + builder.create(loc, source, temp, /*realloc=*/false, /*keep_lhs_length_if_realloc=*/false, /*temporary_lhs=*/true); - // Dereference allocatable temporary directly to simplify processing - // of its uses. - if (temp.isAllocatable()) - temp = hlfir::derefPointersAndAllocatables(loc, builder, temp); return packageBufferizedExpr(loc, builder, temp, cleanup); } @@ -442,18 +441,10 @@ struct AssociateOpConversion // !fir.box>> value must be // propagated as the box address !fir.ref>. auto adjustVar = [&](mlir::Value sourceVar, mlir::Type assocType) { - if (mlir::isa(sourceVar.getType()) && - mlir::isa( - fir::unwrapRefType(sourceVar.getType()))) { - // Association of a polymorphic value. - sourceVar = builder.create(loc, sourceVar); - assert(mlir::isa(sourceVar.getType()) && - fir::isAllocatableType(sourceVar.getType())); - assert(sourceVar.getType() == assocType); - } else if ((mlir::isa(sourceVar.getType()) && - !mlir::isa(assocType)) || - ((mlir::isa(sourceVar.getType()) && - !mlir::isa(assocType)))) { + if ((mlir::isa(sourceVar.getType()) && + !mlir::isa(assocType)) || + ((mlir::isa(sourceVar.getType()) && + !mlir::isa(assocType)))) { sourceVar = builder.create(loc, assocType, sourceVar); } else { sourceVar = builder.createConvert(loc, assocType, sourceVar); @@ -549,23 +540,7 @@ static void genBufferDestruction(mlir::Location loc, fir::FirOpBuilder &builder, // fir::FreeMemOp operand type must be a fir::HeapType. mlir::Type heapType = fir::HeapType::get( hlfir::getFortranElementOrSequenceType(var.getType())); - if (mlir::isa(var.getType()) && - mlir::isa(fir::unwrapRefType(var.getType()))) { - // A temporary for a polymorphic expression is represented - // via an allocatable. Variable type in this case - // is !fir.ref>>>. - // We need to free the allocatable data, not the box - // that is allocated on the stack. - var = builder.create(loc, var); - assert(mlir::isa(var.getType()) && - fir::isAllocatableType(var.getType())); - addr = builder.create(loc, heapType, var); - // Lowering currently does not produce DestroyOp with 'finalize' - // for polymorphic temporaries. It will have to do so, for example, - // for MERGE with polymorphic results. - if (mustFinalize) - TODO(loc, "finalizing polymorphic temporary in HLFIR"); - } else if (mlir::isa(var.getType())) { + if (mlir::isa(var.getType())) { if (mustFinalize && !mlir::isa(var.getType())) fir::emitFatalError(loc, "non-finalizable variable"); @@ -757,9 +732,6 @@ struct ElementalOpConversion adaptor.getTypeparams().end()); auto [temp, cleanup] = createArrayTemp(loc, builder, elemental.getType(), shape, extents, typeParams, mold); - // If the box load is needed, we'd better place it outside - // of the loop nest. - temp = derefPointersAndAllocatables(loc, builder, temp); if (optimizeEmptyElementals) extents = fir::factory::updateRuntimeExtentsForEmptyArrays(builder, loc, diff --git a/flang/test/HLFIR/as_expr-codegen-polymorphic.fir b/flang/test/HLFIR/as_expr-codegen-polymorphic.fir index 30a8da72c3e4..f22ef2fa5aed 100644 --- a/flang/test/HLFIR/as_expr-codegen-polymorphic.fir +++ b/flang/test/HLFIR/as_expr-codegen-polymorphic.fir @@ -9,14 +9,13 @@ func.func @as_expr_class(%arg0 : !fir.class, %arg1: !fir.ref) { return } // CHECK-LABEL: func.func @as_expr_class( +// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = ".tmp"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) // CHECK: %[[VAL_5:.*]] = arith.constant true -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %{{.*}} {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp"} : (!fir.ref>>>) -> (!fir.ref>>>, !fir.ref>>>) // ... copy ... -// CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_6]]#0 : !fir.ref>>> // CHECK: %[[VAL_12:.*]] = fir.undefined tuple>>, i1> // CHECK: %[[VAL_13:.*]] = fir.insert_value %[[VAL_12]], %[[VAL_5]], [1 : index] : (tuple>>, i1>, i1) -> tuple>>, i1> -// CHECK: %[[VAL_14:.*]] = fir.insert_value %[[VAL_13]], %[[VAL_11]], [0 : index] : (tuple>>, i1>, !fir.class>>) -> tuple>>, i1> -// CHECK: hlfir.assign %[[VAL_11]] to %{{.*}} : !fir.class>>, !fir.ref> +// CHECK: %[[VAL_14:.*]] = fir.insert_value %[[VAL_13]], %[[VAL_6]]#0, [0 : index] : (tuple>>, i1>, !fir.class>>) -> tuple>>, i1> +// CHECK: hlfir.assign %[[VAL_6]]#0 to %{{.*}} : !fir.class>>, !fir.ref> func.func @as_expr_class_2(%arg0 : !fir.class>) { @@ -26,13 +25,11 @@ func.func @as_expr_class_2(%arg0 : !fir.class>) { return } // CHECK-LABEL: func.func @as_expr_class_2( +// CHECK: %[[VAL_10:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = ".tmp"} : (!fir.class>>>) -> (!fir.class>>>, !fir.class>>>) // CHECK: %[[VAL_9:.*]] = arith.constant true -// CHECK: %[[VAL_10:.*]]:2 = hlfir.declare %{{.*}} {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp"} : (!fir.ref>>>>) -> (!fir.ref>>>>, !fir.ref>>>>) -// CHECK: %[[VAL_11:.*]] = arith.constant 1 : i32 // ... copy ... -// CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_10]]#0 : !fir.ref>>>> // CHECK: %[[VAL_16:.*]] = fir.undefined tuple>>>, i1> // CHECK: %[[VAL_17:.*]] = fir.insert_value %[[VAL_16]], %[[VAL_9]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> -// CHECK: %[[VAL_18:.*]] = fir.insert_value %[[VAL_17]], %[[VAL_15]], [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> +// CHECK: %[[VAL_18:.*]] = fir.insert_value %[[VAL_17]], %[[VAL_10]]#0, [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> // CHECK: %[[VAL_19:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_20:.*]] = hlfir.designate %[[VAL_15]] (%[[VAL_19]]) : (!fir.class>>>, index) -> !fir.class> +// CHECK: %[[VAL_20:.*]] = hlfir.designate %[[VAL_10]]#0 (%[[VAL_19]]) : (!fir.class>>>, index) -> !fir.class> diff --git a/flang/test/HLFIR/as_expr-codegen.fir b/flang/test/HLFIR/as_expr-codegen.fir index 7123e499e9f7..e4dd2a9a3fc3 100644 --- a/flang/test/HLFIR/as_expr-codegen.fir +++ b/flang/test/HLFIR/as_expr-codegen.fir @@ -12,8 +12,8 @@ func.func @char_expr(%addr: !fir.ref>, %len: index) { // CHECK-SAME: %[[VAL_1:.*]]: index) { // CHECK: %[[VAL_2:.*]]:2 = hlfir.declare %[[VAL_0]] typeparams %[[VAL_1]] {uniq_name = "c"} : (!fir.ref>, index) -> (!fir.boxchar<1>, !fir.ref>) // CHECK: %[[VAL_3:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_1]] : index) {bindc_name = ".tmp"} -// CHECK: %[[VAL_5:.*]] = arith.constant false // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] typeparams %[[VAL_1]] {uniq_name = ".tmp"} : (!fir.ref>, index) -> (!fir.boxchar<1>, !fir.ref>) +// CHECK: %[[VAL_5:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_2]]#0 to %[[VAL_4]]#0 temporary_lhs : !fir.boxchar<1>, !fir.boxchar<1> // CHECK: %[[VAL_6:.*]] = fir.undefined tuple, i1> // CHECK: %[[VAL_7:.*]] = fir.insert_value %[[VAL_6]], %[[VAL_5]], [1 : index] : (tuple, i1>, i1) -> tuple, i1> @@ -29,8 +29,8 @@ func.func @char_expr_2(%addr: !fir.ref>, %len: index) { // CHECK-SAME: %[[VAL_1:.*]]: index) { // CHECK: %[[VAL_2:.*]] = fir.alloca !fir.char<1,10> {bindc_name = ".tmp"} // CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_0]] typeparams %[[VAL_1]] {uniq_name = "c"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) -// CHECK: %[[VAL_5:.*]] = arith.constant false // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_2]] typeparams %[[VAL_1]] {uniq_name = ".tmp"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) +// CHECK: %[[VAL_5:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_3]]#0 to %[[VAL_4]]#0 temporary_lhs : !fir.ref>, !fir.ref> // CHECK: %[[VAL_6:.*]] = fir.undefined tuple>, i1> // CHECK: %[[VAL_7:.*]] = fir.insert_value %[[VAL_6]], %[[VAL_5]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> @@ -46,8 +46,8 @@ func.func @shape_from_type(%arg0 : !fir.ref>) { // CHECK: %[[VAL_2:.*]] = arith.constant 20 : index // CHECK: %[[VAL_3:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_4:.*]] = fir.allocmem !fir.array<10x20xi32> {bindc_name = ".tmp", uniq_name = ""} -// CHECK: %[[VAL_5:.*]] = arith.constant true // CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_4]](%[[VAL_3]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<2>) -> (!fir.heap>, !fir.heap>) +// CHECK: %[[VAL_5:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_6]]#0 temporary_lhs : !fir.ref>, !fir.heap> // CHECK: %[[VAL_7:.*]] = fir.undefined tuple>, i1> // CHECK: %[[VAL_8:.*]] = fir.insert_value %[[VAL_7]], %[[VAL_5]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> @@ -65,8 +65,8 @@ func.func @shape_from_box(%arg0 : !fir.box>) { // CHECK: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_2]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_1]], %[[VAL_3]]#1 : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_5:.*]] = fir.allocmem !fir.array<10x?xi32>, %[[VAL_3]]#1 {bindc_name = ".tmp", uniq_name = ""} -// CHECK: %[[VAL_6:.*]] = arith.constant true // CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_4]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<2>) -> (!fir.box>, !fir.heap>) +// CHECK: %[[VAL_6:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_7]]#0 temporary_lhs : !fir.box>, !fir.box> // CHECK: %[[VAL_8:.*]] = fir.undefined tuple>, i1> // CHECK: %[[VAL_9:.*]] = fir.insert_value %[[VAL_8]], %[[VAL_6]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> diff --git a/flang/test/HLFIR/associate-codegen.fir b/flang/test/HLFIR/associate-codegen.fir index f7ee4fa83c9f..fef752601120 100644 --- a/flang/test/HLFIR/associate-codegen.fir +++ b/flang/test/HLFIR/associate-codegen.fir @@ -258,8 +258,8 @@ func.func @test_multiple_associations(%arg0: !hlfir.expr<1x2xi32>) { // CHECK: %[[VAL_5:.*]] = arith.constant 1 : index // CHECK: %[[VAL_6:.*]] = arith.constant 2 : index // CHECK: %[[VAL_7:.*]] = fir.allocmem !fir.array<1x2xi32> {bindc_name = ".tmp", uniq_name = ""} -// CHECK: %[[VAL_8:.*]] = arith.constant true // CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_7]](%[[VAL_4]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<2>) -> (!fir.heap>, !fir.heap>) +// CHECK: %[[VAL_8:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_9]]#0 temporary_lhs : !hlfir.expr<1x2xi32>, !fir.heap> // CHECK: %[[VAL_10:.*]] = fir.undefined tuple>, i1> // CHECK: %[[VAL_11:.*]] = fir.insert_value %[[VAL_10]], %[[VAL_8]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> @@ -271,8 +271,8 @@ func.func @test_multiple_associations(%arg0: !hlfir.expr<1x2xi32>) { // CHECK: %[[VAL_16:.*]] = arith.constant 1 : index // CHECK: %[[VAL_17:.*]] = arith.constant 2 : index // CHECK: %[[VAL_18:.*]] = fir.allocmem !fir.array<1x2xi32> {bindc_name = ".tmp", uniq_name = ""} -// CHECK: %[[VAL_19:.*]] = arith.constant true // CHECK: %[[VAL_20:.*]]:2 = hlfir.declare %[[VAL_18]](%[[VAL_15]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<2>) -> (!fir.heap>, !fir.heap>) +// CHECK: %[[VAL_19:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_20]]#0 temporary_lhs : !hlfir.expr<1x2xi32>, !fir.heap> // CHECK: %[[VAL_21:.*]] = fir.undefined tuple>, i1> // CHECK: %[[VAL_22:.*]] = fir.insert_value %[[VAL_21]], %[[VAL_19]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> @@ -302,8 +302,8 @@ func.func @test_get_length(%arg0: !fir.ref>) { // CHECK-SAME: %[[VAL_0:.*]]: !fir.ref>) { // CHECK: %[[VAL_1:.*]] = fir.alloca !fir.char<1,2> {bindc_name = ".tmp"} // CHECK: %[[VAL_2:.*]] = arith.constant 2 : index -// CHECK: %[[VAL_3:.*]] = arith.constant false // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_1]] typeparams %[[VAL_2]] {uniq_name = ".tmp"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) +// CHECK: %[[VAL_3:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_0]] to %[[VAL_4]]#0 temporary_lhs : !fir.ref>, !fir.ref> // CHECK: %[[VAL_5:.*]] = fir.undefined tuple>, i1> // CHECK: %[[VAL_6:.*]] = fir.insert_value %[[VAL_5]], %[[VAL_3]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> @@ -354,8 +354,8 @@ func.func @_QPtest_multiple_expr_uses_inside_elemental() { // CHECK: %[[VAL_14:.*]] = arith.constant 1 : index // CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_9]] step %[[VAL_14]] unordered { // CHECK: %[[VAL_16:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_4]] : index) {bindc_name = ".tmp"} -// CHECK: %[[VAL_17:.*]] = arith.constant false // CHECK: %[[VAL_18:.*]]:2 = hlfir.declare %[[VAL_16]] typeparams %[[VAL_4]] {uniq_name = ".tmp"} : (!fir.ref>, index) -> (!fir.boxchar<1>, !fir.ref>) +// CHECK: %[[VAL_17:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_5]]#0 to %[[VAL_18]]#0 temporary_lhs : !fir.boxchar<1>, !fir.boxchar<1> // CHECK: %[[VAL_19:.*]] = fir.undefined tuple, i1> // CHECK: %[[VAL_20:.*]] = fir.insert_value %[[VAL_19]], %[[VAL_17]], [1 : index] : (tuple, i1>, i1) -> tuple, i1> @@ -406,8 +406,8 @@ func.func @_QPtest_multitple_associates_for_same_expr() { // CHECK: %[[VAL_11:.*]] = fir.insert_value %[[VAL_10]], %[[VAL_5]], [1 : index] : (tuple>>, i1>, i1) -> tuple>>, i1> // CHECK: %[[VAL_12:.*]] = fir.insert_value %[[VAL_11]], %[[VAL_4]]#0, [0 : index] : (tuple>>, i1>, !fir.heap>>) -> tuple>>, i1> // CHECK: %[[VAL_13:.*]] = fir.allocmem !fir.array<10x!fir.char<1>> {bindc_name = ".tmp", uniq_name = ""} -// CHECK: %[[VAL_14:.*]] = arith.constant true // CHECK: %[[VAL_15:.*]]:2 = hlfir.declare %[[VAL_13]](%[[VAL_2]]) typeparams %[[VAL_0]] {uniq_name = ".tmp"} : (!fir.heap>>, !fir.shape<1>, index) -> (!fir.heap>>, !fir.heap>>) +// CHECK: %[[VAL_14:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_4]]#0 to %[[VAL_15]]#0 temporary_lhs : !fir.heap>>, !fir.heap>> // CHECK: %[[VAL_16:.*]] = fir.undefined tuple>>, i1> // CHECK: %[[VAL_17:.*]] = fir.insert_value %[[VAL_16]], %[[VAL_14]], [1 : index] : (tuple>>, i1>, i1) -> tuple>>, i1> @@ -417,8 +417,8 @@ func.func @_QPtest_multitple_associates_for_same_expr() { // CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (!fir.ref>>) -> !fir.heap>> // CHECK: fir.freemem %[[VAL_21]] : !fir.heap>> // CHECK: %[[VAL_22:.*]] = fir.allocmem !fir.array<10x!fir.char<1>> {bindc_name = ".tmp", uniq_name = ""} -// CHECK: %[[VAL_23:.*]] = arith.constant true // CHECK: %[[VAL_24:.*]]:2 = hlfir.declare %[[VAL_22]](%[[VAL_2]]) typeparams %[[VAL_0]] {uniq_name = ".tmp"} : (!fir.heap>>, !fir.shape<1>, index) -> (!fir.heap>>, !fir.heap>>) +// CHECK: %[[VAL_23:.*]] = arith.constant true // CHECK: hlfir.assign %[[VAL_4]]#0 to %[[VAL_24]]#0 temporary_lhs : !fir.heap>>, !fir.heap>> // CHECK: %[[VAL_25:.*]] = fir.undefined tuple>>, i1> // CHECK: %[[VAL_26:.*]] = fir.insert_value %[[VAL_25]], %[[VAL_23]], [1 : index] : (tuple>>, i1>, i1) -> tuple>>, i1> diff --git a/flang/test/HLFIR/bufferize-poly-expr.fir b/flang/test/HLFIR/bufferize-poly-expr.fir index 49c2347b2b26..1c63805e5242 100644 --- a/flang/test/HLFIR/bufferize-poly-expr.fir +++ b/flang/test/HLFIR/bufferize-poly-expr.fir @@ -17,22 +17,26 @@ func.func @test_poly_expr_without_associate() { // CHECK: %[[VAL_3:.*]] = fir.undefined !fir.class>> // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = ".tmp.intrinsic_result"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) // CHECK: %[[VAL_5:.*]] = fir.zero_bits !fir.heap> -// CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_5]] : (!fir.heap>) -> !fir.class>> +// CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_5]] source_box %[[VAL_4]]#0 : (!fir.heap>, !fir.class>>) -> !fir.class>> // CHECK: fir.store %[[VAL_6]] to %[[VAL_0]] : !fir.ref>>> -// CHECK: %[[VAL_7:.*]] = arith.constant true -// CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp"} : (!fir.ref>>>) -> (!fir.ref>>>, !fir.ref>>>) -// CHECK: %[[VAL_9:.*]] = arith.constant 0 : i32 -// CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_0]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_4]]#1 : (!fir.class>>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_10]], %[[VAL_11]], %[[VAL_9]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: hlfir.assign %[[VAL_4]]#0 to %[[VAL_8]]#0 realloc temporary_lhs : !fir.class>>, !fir.ref>>> -// CHECK: %[[VAL_8B:.*]] = fir.load %[[VAL_8]]#0 -// CHECK: %[[VAL_13:.*]] = fir.undefined tuple>>, i1> -// CHECK: %[[VAL_14:.*]] = fir.insert_value %[[VAL_13]], %[[VAL_7]], [1 : index] : (tuple>>, i1>, i1) -> tuple>>, i1> -// CHECK: %[[VAL_15:.*]] = fir.insert_value %[[VAL_14]], %[[VAL_8B]], [0 : index] : (tuple>>, i1>, !fir.class>>) -> tuple>>, i1> -// CHECK: hlfir.assign %[[VAL_8B]] to %[[VAL_2]]#0 realloc : !fir.class>>, !fir.ref>>> -// CHECK: %[[VAL_17:.*]] = fir.box_addr %[[VAL_8B]] : (!fir.class>>) -> !fir.heap> -// CHECK: fir.freemem %[[VAL_17]] : !fir.heap> +// CHECK: %[[VAL_7:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_11:.*]] = arith.constant false +// CHECK: %[[VAL_12:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_0]] : (!fir.ref>>>) -> !fir.ref> +// CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_7]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_16:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_13]], %[[VAL_14]], %[[VAL_11]], %[[VAL_12:.*]], {{.*}} +// CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_0]] : !fir.ref>>> +// CHECK: %[[VAL_18:.*]]:2 = hlfir.declare %[[VAL_17]] {uniq_name = ".tmp"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) +// CHECK: %[[VAL_19:.*]] = arith.constant true +// CHECK: hlfir.assign %[[VAL_4]]#0 to %[[VAL_18]]#0 temporary_lhs : !fir.class>>, !fir.class>> +// CHECK: %[[VAL_20:.*]] = fir.undefined tuple>>, i1> +// CHECK: %[[VAL_21:.*]] = fir.insert_value %[[VAL_20]], %[[VAL_19]], [1 : index] : (tuple>>, i1>, i1) -> tuple>>, i1> +// CHECK: %[[VAL_22:.*]] = fir.insert_value %[[VAL_21]], %[[VAL_18]]#0, [0 : index] : (tuple>>, i1>, !fir.class>>) -> tuple>>, i1> +// CHECK: hlfir.assign %[[VAL_18]]#0 to %[[VAL_2]]#0 realloc : !fir.class>>, !fir.ref>>> +// CHECK: %[[VAL_23:.*]] = fir.box_addr %[[VAL_18]]#0 : (!fir.class>>) -> !fir.heap> +// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_18]]#0 : (!fir.class>>) -> !fir.box +// CHECK: fir.call @_FortranADestroyWithoutFinalization(%[[VAL_24]]) : (!fir.box) -> () +// CHECK: fir.freemem %[[VAL_23]] : !fir.heap> // CHECK: return // CHECK: } @@ -60,45 +64,47 @@ func.func @test_poly_expr_with_associate(%arg1: !fir.class>> {fir.bindc_name = "v2"}) { -// CHECK: %[[VAL_1:.*]] = fir.alloca !fir.class>>> -// CHECK: %[[VAL_2:.*]] = fir.alloca !fir.class>>> {bindc_name = ".result"} -// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "_QFtestEv2"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) -// CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_2]] {uniq_name = ".tmp.func_result"} : (!fir.ref>>>>) -> (!fir.ref>>>>, !fir.ref>>>>) -// CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref>>>> -// CHECK: %[[VAL_6:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_5]], %[[VAL_6]] : (!fir.class>>>, index) -> (index, index, index) -// CHECK: %[[VAL_8:.*]] = fir.shape %[[VAL_7]]#1 : (index) -> !fir.shape<1> -// CHECK: %[[VAL_9:.*]] = fir.zero_bits !fir.heap>> -// CHECK: %[[VAL_10:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1> -// CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_9]](%[[VAL_11]]) : (!fir.heap>>, !fir.shape<1>) -> !fir.class>>> -// CHECK: fir.store %[[VAL_12]] to %[[VAL_1]] : !fir.ref>>>> -// CHECK: %[[VAL_13:.*]] = arith.constant true -// CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp"} : (!fir.ref>>>>) -> (!fir.ref>>>>, !fir.ref>>>>) -// CHECK: %[[VAL_15:.*]] = arith.constant 1 : i32 -// CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_1]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_5]] : (!fir.class>>>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_16]], %[[VAL_17]], %[[VAL_15]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: hlfir.assign %[[VAL_5]] to %[[VAL_14]]#0 realloc temporary_lhs : !fir.class>>>, !fir.ref>>>> -// CHECK: %[[VAL_14B:.*]] = fir.load %[[VAL_14]]#0 -// CHECK: %[[VAL_19:.*]] = fir.undefined tuple>>>, i1> -// CHECK: %[[VAL_20:.*]] = fir.insert_value %[[VAL_19]], %[[VAL_13]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> -// CHECK: %[[VAL_21:.*]] = fir.insert_value %[[VAL_20]], %[[VAL_14B]], [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> -// CHECK: %[[VAL_22:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_23:.*]]:3 = fir.box_dims %[[VAL_5]], %[[VAL_22]] : (!fir.class>>>, index) -> (index, index, index) -// CHECK: %[[VAL_24:.*]] = fir.shape %[[VAL_23]]#1 : (index) -> !fir.shape<1> -// CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_2]] : (!fir.ref>>>>) -> !fir.box -// CHECK: fir.call @_FortranADestroy(%[[VAL_27]]) fastmath : (!fir.box) -> () -// CHECK: %[[VAL_29:.*]] = arith.constant 3 : index -// CHECK: %[[VAL_30:.*]] = fir.shape %[[VAL_29]] : (index) -> !fir.shape<1> -// CHECK: %[[VAL_31:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_32:.*]] = %[[VAL_31]] to %[[VAL_29]] step %[[VAL_31]] { -// CHECK: %[[VAL_33:.*]] = hlfir.designate %[[VAL_3]]#0 (%[[VAL_32]]) : (!fir.class>>, index) -> !fir.class> -// CHECK: %[[VAL_34:.*]] = hlfir.designate %[[VAL_14B]] (%[[VAL_32]]) : (!fir.class>>>, index) -> !fir.class> -// CHECK: fir.dispatch "assign"(%[[VAL_33]] : !fir.class>) (%[[VAL_33]], %[[VAL_34]] : !fir.class>, !fir.class>) {pass_arg_pos = 0 : i32} +// CHECK-SAME: %[[ARG0:.*]]: !fir.class>> {fir.bindc_name = "v2"}) { +// CHECK: %[[VAL_0:.*]] = fir.alloca !fir.class>>> +// CHECK: %[[VAL_1:.*]] = fir.alloca !fir.class>>> {bindc_name = ".result"} +// CHECK: %[[VAL_2:.*]]:2 = hlfir.declare %[[ARG0]] {uniq_name = "_QFtestEv2"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) +// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_1]] {uniq_name = ".tmp.func_result"} : (!fir.ref>>>>) -> (!fir.ref>>>>, !fir.ref>>>>) +// CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref>>>> +// CHECK: %[[VAL_5:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_4]], %[[VAL_5]] : (!fir.class>>>, index) -> (index, index, index) +// CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_6]]#1 : (index) -> !fir.shape<1> +// CHECK: %[[VAL_8:.*]] = fir.zero_bits !fir.heap>> +// CHECK: %[[VAL_9:.*]] = fir.embox %[[VAL_8]](%[[VAL_7]]) source_box %[[VAL_4]] : (!fir.heap>>, !fir.shape<1>, !fir.class>>>) -> !fir.class>>> +// CHECK: fir.store %[[VAL_9]] to %[[VAL_0]] : !fir.ref>>>> +// CHECK: %[[VAL_10:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_14:.*]] = arith.constant false +// CHECK: %[[VAL_15:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_0]] : (!fir.ref>>>>) -> !fir.ref> +// CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_10]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_19:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_16]], %[[VAL_17]], %[[VAL_14]], %[[VAL_15]], {{.*}} +// CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_0]] : !fir.ref>>>> +// CHECK: %[[VAL_21:.*]]:2 = hlfir.declare %[[VAL_20]] {uniq_name = ".tmp"} : (!fir.class>>>) -> (!fir.class>>>, !fir.class>>>) +// CHECK: %[[VAL_22:.*]] = arith.constant true +// CHECK: hlfir.assign %[[VAL_4]] to %[[VAL_21]]#0 temporary_lhs : !fir.class>>>, !fir.class>>> +// CHECK: %[[VAL_23:.*]] = fir.undefined tuple>>>, i1> +// CHECK: %[[VAL_24:.*]] = fir.insert_value %[[VAL_23]], %[[VAL_22]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> +// CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[VAL_21]]#0, [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> +// CHECK: %[[VAL_26:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_27:.*]]:3 = fir.box_dims %[[VAL_4]], %[[VAL_26]] : (!fir.class>>>, index) -> (index, index, index) +// CHECK: %[[VAL_28:.*]] = fir.shape %[[VAL_27]]#1 : (index) -> !fir.shape<1> +// CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_1]] : (!fir.ref>>>>) -> !fir.box +// CHECK: fir.call @_FortranADestroy(%[[VAL_29]]) fastmath : (!fir.box) -> () +// CHECK: %[[VAL_30:.*]] = arith.constant 3 : index +// CHECK: %[[VAL_31:.*]] = fir.shape %[[VAL_30]] : (index) -> !fir.shape<1> +// CHECK: %[[VAL_32:.*]] = arith.constant 1 : index +// CHECK: fir.do_loop %[[VAL_33:.*]] = %[[VAL_32]] to %[[VAL_30]] step %[[VAL_32]] { +// CHECK: %[[VAL_34:.*]] = hlfir.designate %[[VAL_2]]#0 (%[[VAL_33]]) : (!fir.class>>, index) -> !fir.class> +// CHECK: %[[VAL_35:.*]] = hlfir.designate %[[VAL_21]]#0 (%[[VAL_33]]) : (!fir.class>>>, index) -> !fir.class> +// CHECK: fir.dispatch "assign"(%[[VAL_34]] : !fir.class>) (%[[VAL_34]], %[[VAL_35]] : !fir.class>, !fir.class>) {pass_arg_pos = 0 : i32} // CHECK: } -// CHECK: %[[VAL_35:.*]] = fir.box_addr %[[VAL_14B]] : (!fir.class>>>) -> !fir.heap>> -// CHECK: fir.freemem %[[VAL_35]] : !fir.heap>> +// CHECK: %[[VAL_36:.*]] = fir.box_addr %[[VAL_21]]#1 : (!fir.class>>>) -> !fir.heap>> +// CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_21]]#1 : (!fir.class>>>) -> !fir.box +// CHECK: fir.call @_FortranADestroyWithoutFinalization(%[[VAL_37]]) : (!fir.box) -> () +// CHECK: fir.freemem %[[VAL_36]] : !fir.heap>> // CHECK: return // CHECK: } diff --git a/flang/test/HLFIR/element-codegen-issue-118922.fir b/flang/test/HLFIR/element-codegen-issue-118922.fir index 8fc0aa92a6b3..da998cc7430e 100644 --- a/flang/test/HLFIR/element-codegen-issue-118922.fir +++ b/flang/test/HLFIR/element-codegen-issue-118922.fir @@ -36,8 +36,8 @@ func.func @_QMmPbug(%val: !fir.char<1>, %var: !fir.ref> // CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (!fir.heap>) -> !fir.ref> // CHECK: %[[VAL_13:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_14:.*]] = arith.constant false // CHECK: %[[VAL_15:.*]]:2 = hlfir.declare %[[VAL_2]] typeparams %[[VAL_13]] {uniq_name = ".tmp"} : (!fir.ref>, index) -> (!fir.ref>, !fir.ref>) +// CHECK: %[[VAL_14:.*]] = arith.constant false // CHECK: hlfir.assign %[[VAL_12]] to %[[VAL_15]]#0 temporary_lhs : !fir.ref>, !fir.ref> // CHECK: %[[VAL_16:.*]] = fir.undefined tuple>, i1> // CHECK: %[[VAL_17:.*]] = fir.insert_value %[[VAL_16]], %[[VAL_14]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> diff --git a/flang/test/HLFIR/elemental-codegen.fir b/flang/test/HLFIR/elemental-codegen.fir index 67af4261470f..9aec993de3fc 100644 --- a/flang/test/HLFIR/elemental-codegen.fir +++ b/flang/test/HLFIR/elemental-codegen.fir @@ -153,70 +153,41 @@ func.func @test_polymorphic(%arg0: !fir.class> {fir.bindc_ return } // CHECK-LABEL: func.func @test_polymorphic( -// CHECK-SAME: %[[VAL_0:.*]]: !fir.class> {fir.bindc_name = "x"}, -// CHECK-SAME: %[[VAL_1:.*]]: !fir.class>> {fir.bindc_name = "y"}, -// CHECK-SAME: %[[EX0:.*]]: index, -// CHECK-SAME: %[[EX1:.*]]: index) { -// CHECK: %[[VAL_4:.*]] = fir.alloca !fir.class>>> -// CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEx"} : (!fir.class>) -> (!fir.class>, !fir.class>) -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEy"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) -// CHECK: %[[VAL_7:.*]] = fir.shape %[[EX0]], %[[EX1]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_8:.*]] = fir.zero_bits !fir.heap>> -// CHECK: %[[VAL_9:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_9]], %[[VAL_9]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_11:.*]] = fir.embox %[[VAL_8]](%[[VAL_10]]) : (!fir.heap>>, !fir.shape<2>) -> !fir.class>>> -// CHECK: fir.store %[[VAL_11]] to %[[VAL_4]] : !fir.ref>>>> -// CHECK: %[[VAL_13:.*]]:2 = hlfir.declare %[[VAL_4]] {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp.array"} : (!fir.ref>>>>) -> (!fir.ref>>>>, !fir.ref>>>>) -// CHECK: %[[RANK:.*]] = arith.constant 2 : i32 -// CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_4]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_5]]#1 : (!fir.class>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_15]], %[[VAL_16]], %[[RANK]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: %[[VAL_18:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_19:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_4]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_19]] : (index) -> i32 -// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_18]] : (index) -> i64 -// CHECK: %[[VAL_23:.*]] = fir.convert %[[EX0]] : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_20]], %[[VAL_21]], %[[VAL_22]], %[[VAL_23]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_25:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_4]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_25]] : (index) -> i32 -// CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_18]] : (index) -> i64 -// CHECK: %[[VAL_29:.*]] = fir.convert %[[EX1]] : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_26]], %[[VAL_27]], %[[VAL_28]], %[[VAL_29]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_31:.*]] = fir.address_of(@_QQclX -// CHECK: %[[VAL_32:.*]] = arith.constant {{.*}} : index -// CHECK: %[[VAL_33:.*]] = arith.constant {{.*}} : i32 -// CHECK: %[[VAL_34:.*]] = arith.constant false -// CHECK: %[[VAL_35:.*]] = fir.absent !fir.box -// CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_4]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_31]] : (!fir.ref>) -> !fir.ref -// CHECK: %[[VAL_38:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_36]], %{{.*}}, %[[VAL_34]], %[[VAL_35]], %[[VAL_37]], %[[VAL_33]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 -// CHECK: %[[VAL_12:.*]] = arith.constant true -// CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_13]]#0 : !fir.ref>>>> -// CHECK: %[[VAL_40:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_41:.*]] = %[[VAL_40]] to %[[EX1]] step %[[VAL_40]] unordered { -// CHECK: fir.do_loop %[[VAL_42:.*]] = %[[VAL_40]] to %[[EX0]] step %[[VAL_40]] unordered { -// CHECK: %[[VAL_43:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_42]], %[[VAL_41]]) : (!fir.class>>, index, index) -> !fir.class> -// CHECK: %[[VAL_44:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_45:.*]]:3 = fir.box_dims %[[VAL_39]], %[[VAL_44]] : (!fir.class>>>, index) -> (index, index, index) -// CHECK: %[[VAL_46:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_47:.*]]:3 = fir.box_dims %[[VAL_39]], %[[VAL_46]] : (!fir.class>>>, index) -> (index, index, index) -// CHECK: %[[VAL_48:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_49:.*]] = arith.subi %[[VAL_45]]#0, %[[VAL_48]] : index -// CHECK: %[[VAL_50:.*]] = arith.addi %[[VAL_42]], %[[VAL_49]] : index -// CHECK: %[[VAL_51:.*]] = arith.subi %[[VAL_47]]#0, %[[VAL_48]] : index -// CHECK: %[[VAL_52:.*]] = arith.addi %[[VAL_41]], %[[VAL_51]] : index -// CHECK: %[[VAL_53:.*]] = hlfir.designate %[[VAL_39]] (%[[VAL_50]], %[[VAL_52]]) : (!fir.class>>>, index, index) -> !fir.class> -// CHECK: hlfir.assign %[[VAL_43]] to %[[VAL_53]] temporary_lhs : !fir.class>, !fir.class> +// CHECK-SAME: %[[ARG0:.*]]: !fir.class> {fir.bindc_name = "x"}, +// CHECK-SAME: %[[ARG1:.*]]: !fir.class>> {fir.bindc_name = "y"}, +// CHECK-SAME: %[[ARG2:.*]]: index, +// CHECK-SAME: %[[ARG3:.*]]: index) { +// CHECK: %[[VAL_0:.*]] = fir.alloca !fir.class>>> +// CHECK: %[[VAL_1:.*]]:2 = hlfir.declare %[[ARG0]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEx"} : (!fir.class>) -> (!fir.class>, !fir.class>) +// CHECK: %[[VAL_2:.*]]:2 = hlfir.declare %[[ARG1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEy"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) +// CHECK: %[[VAL_3:.*]] = fir.shape %[[ARG2]], %[[ARG3]] : (index, index) -> !fir.shape<2> +// CHECK: %[[VAL_4:.*]] = fir.zero_bits !fir.heap>> +// CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_4]](%[[VAL_3]]) source_box %[[VAL_1]]#1 : (!fir.heap>>, !fir.shape<2>, !fir.class>) -> !fir.class>>> +// CHECK: fir.store %[[VAL_5]] to %[[VAL_0]] : !fir.ref>>>> +// CHECK: %[[VAL_6:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_10:.*]] = arith.constant false +// CHECK: %[[VAL_11:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_0]] : (!fir.ref>>>>) -> !fir.ref> +// CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_6]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_15:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_12]], %[[VAL_13]], %[[VAL_10]], %[[VAL_11]], +// CHECK: %[[VAL_16:.*]] = fir.load %[[VAL_0]] : !fir.ref>>>> +// CHECK: %[[VAL_17:.*]]:2 = hlfir.declare %[[VAL_16]] {uniq_name = ".tmp.array"} : (!fir.class>>>) -> (!fir.class>>>, !fir.class>>>) +// CHECK: %[[VAL_18:.*]] = arith.constant true +// CHECK: %[[VAL_19:.*]] = arith.constant 1 : index +// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_19]] to %[[ARG3]] step %[[VAL_19]] unordered { +// CHECK: fir.do_loop %[[VAL_21:.*]] = %[[VAL_19]] to %[[ARG2]] step %[[VAL_19]] unordered { +// CHECK: %[[VAL_22:.*]] = hlfir.designate %[[VAL_2]]#0 (%[[VAL_21]], %[[VAL_20]]) : (!fir.class>>, index, index) -> !fir.class> +// CHECK: %[[VAL_23:.*]] = hlfir.designate %[[VAL_17]]#0 (%[[VAL_21]], %[[VAL_20]]) : (!fir.class>>>, index, index) -> !fir.class> +// CHECK: hlfir.assign %[[VAL_22]] to %[[VAL_23]] temporary_lhs : !fir.class>, !fir.class> // CHECK: } // CHECK: } -// CHECK: %[[VAL_54:.*]] = fir.undefined tuple>>>, i1> -// CHECK: %[[VAL_55:.*]] = fir.insert_value %[[VAL_54]], %[[VAL_12]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> -// CHECK: %[[VAL_56:.*]] = fir.insert_value %[[VAL_55]], %[[VAL_39]], [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> +// CHECK: %[[VAL_24:.*]] = fir.undefined tuple>>>, i1> +// CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[VAL_18]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> +// CHECK: %[[VAL_26:.*]] = fir.insert_value %[[VAL_25]], %[[VAL_17]]#0, [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> // CHECK: return // CHECK: } + // Test that hlfir.expr mold is properly applied for the second hlfir.elemental. func.func @test_polymorphic_expr(%arg0: !fir.class> {fir.bindc_name = "x"}, %arg1: !fir.class>> {fir.bindc_name = "y"}, %ex0 : index, %ex1 : index) { %1:2 = hlfir.declare %arg0 {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEx"} : (!fir.class>) -> (!fir.class>, !fir.class>) @@ -236,124 +207,67 @@ func.func @test_polymorphic_expr(%arg0: !fir.class> {fir.b return } // CHECK-LABEL: func.func @test_polymorphic_expr( -// CHECK-SAME: %[[VAL_0:.*]]: !fir.class> {fir.bindc_name = "x"}, -// CHECK-SAME: %[[VAL_1:.*]]: !fir.class>> {fir.bindc_name = "y"}, -// CHECK-SAME: %[[VAL_2:.*]]: index, -// CHECK-SAME: %[[VAL_3:.*]]: index) { -// CHECK: %[[VAL_4:.*]] = fir.alloca !fir.class>>> -// CHECK: %[[VAL_5:.*]] = fir.alloca !fir.class>>> -// CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEx"} : (!fir.class>) -> (!fir.class>, !fir.class>) -// CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEy"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) -// CHECK: %[[VAL_8:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_9:.*]] = fir.zero_bits !fir.heap>> -// CHECK: %[[VAL_10:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_10]], %[[VAL_10]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_9]](%[[VAL_11]]) : (!fir.heap>>, !fir.shape<2>) -> !fir.class>>> -// CHECK: fir.store %[[VAL_12]] to %[[VAL_5]] : !fir.ref>>>> -// CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_5]] {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp.array"} : (!fir.ref>>>>) -> (!fir.ref>>>>, !fir.ref>>>>) -// CHECK: %[[VAL_15:.*]] = arith.constant 2 : i32 -// CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_5]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_6]]#1 : (!fir.class>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_16]], %[[VAL_17]], %[[VAL_15]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: %[[VAL_19:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_20:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_5]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_20]] : (index) -> i32 -// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_19]] : (index) -> i64 -// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_2]] : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_21]], %[[VAL_22]], %[[VAL_23]], %[[VAL_24]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_26:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_5]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_26]] : (index) -> i32 -// CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_19]] : (index) -> i64 -// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_3]] : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_27]], %[[VAL_28]], %[[VAL_29]], %[[VAL_30]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_32:.*]] = fir.address_of(@_QQcl -// CHECK: %[[VAL_33:.*]] = arith.constant {{.*}} : index -// CHECK: %[[VAL_34:.*]] = arith.constant {{.*}} : i32 -// CHECK: %[[VAL_35:.*]] = arith.constant false -// CHECK: %[[VAL_36:.*]] = fir.absent !fir.box -// CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_5]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_32]] : (!fir.ref>) -> !fir.ref -// CHECK: %[[VAL_39:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_37]], %{{.*}}, %[[VAL_35]], %[[VAL_36]], %[[VAL_38]], %[[VAL_34]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 -// CHECK: %[[VAL_13:.*]] = arith.constant true -// CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_14]]#0 : !fir.ref>>>> -// CHECK: %[[VAL_41:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_42:.*]] = %[[VAL_41]] to %[[VAL_3]] step %[[VAL_41]] unordered { -// CHECK: fir.do_loop %[[VAL_43:.*]] = %[[VAL_41]] to %[[VAL_2]] step %[[VAL_41]] unordered { -// CHECK: %[[VAL_44:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_43]], %[[VAL_42]]) : (!fir.class>>, index, index) -> !fir.class> -// CHECK: %[[VAL_45:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_46:.*]]:3 = fir.box_dims %[[VAL_40]], %[[VAL_45]] : (!fir.class>>>, index) -> (index, index, index) -// CHECK: %[[VAL_47:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_48:.*]]:3 = fir.box_dims %[[VAL_40]], %[[VAL_47]] : (!fir.class>>>, index) -> (index, index, index) -// CHECK: %[[VAL_49:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_50:.*]] = arith.subi %[[VAL_46]]#0, %[[VAL_49]] : index -// CHECK: %[[VAL_51:.*]] = arith.addi %[[VAL_43]], %[[VAL_50]] : index -// CHECK: %[[VAL_52:.*]] = arith.subi %[[VAL_48]]#0, %[[VAL_49]] : index -// CHECK: %[[VAL_53:.*]] = arith.addi %[[VAL_42]], %[[VAL_52]] : index -// CHECK: %[[VAL_54:.*]] = hlfir.designate %[[VAL_40]] (%[[VAL_51]], %[[VAL_53]]) : (!fir.class>>>, index, index) -> !fir.class> -// CHECK: hlfir.assign %[[VAL_44]] to %[[VAL_54]] temporary_lhs : !fir.class>, !fir.class> +// CHECK-SAME: %[[ARG0:.*]]: !fir.class> {fir.bindc_name = "x"}, +// CHECK-SAME: %[[ARG1:.*]]: !fir.class>> {fir.bindc_name = "y"}, +// CHECK-SAME: %[[ARG2:.*]]: index, +// CHECK-SAME: %[[ARG3:.*]]: index) { +// CHECK: %[[VAL_0:.*]] = fir.alloca !fir.class>>> +// CHECK: %[[VAL_1:.*]] = fir.alloca !fir.class>>> +// CHECK: %[[VAL_2:.*]]:2 = hlfir.declare %[[ARG0]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEx"} : (!fir.class>) -> (!fir.class>, !fir.class>) +// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[ARG1]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtestEy"} : (!fir.class>>) -> (!fir.class>>, !fir.class>>) +// CHECK: %[[VAL_4:.*]] = fir.shape %[[ARG2]], %[[ARG3]] : (index, index) -> !fir.shape<2> +// CHECK: %[[VAL_5:.*]] = fir.zero_bits !fir.heap>> +// CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_5]](%[[VAL_4]]) source_box %[[VAL_2]]#1 : (!fir.heap>>, !fir.shape<2>, !fir.class>) -> !fir.class>>> +// CHECK: fir.store %[[VAL_6]] to %[[VAL_1]] : !fir.ref>>>> +// CHECK: %[[VAL_7:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_11:.*]] = arith.constant false +// CHECK: %[[VAL_12:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_1]] : (!fir.ref>>>>) -> !fir.ref> +// CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_7]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_16:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_13]], %[[VAL_14]], %[[VAL_11]], %[[VAL_12]], +// CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_1]] : !fir.ref>>>> +// CHECK: %[[VAL_18:.*]]:2 = hlfir.declare %[[VAL_17]] {uniq_name = ".tmp.array"} : (!fir.class>>>) -> (!fir.class>>>, !fir.class>>>) +// CHECK: %[[VAL_19:.*]] = arith.constant true +// CHECK: %[[VAL_20:.*]] = arith.constant 1 : index +// CHECK: fir.do_loop %[[VAL_21:.*]] = %[[VAL_20]] to %[[ARG3]] step %[[VAL_20]] unordered { +// CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_20]] to %[[ARG2]] step %[[VAL_20]] unordered { +// CHECK: %[[VAL_23:.*]] = hlfir.designate %[[VAL_3]]#0 (%[[VAL_22]], %[[VAL_21]]) : (!fir.class>>, index, index) -> !fir.class> +// CHECK: %[[VAL_24:.*]] = hlfir.designate %[[VAL_18]]#0 (%[[VAL_22]], %[[VAL_21]]) : (!fir.class>>>, index, index) -> !fir.class> +// CHECK: hlfir.assign %[[VAL_23]] to %[[VAL_24]] temporary_lhs : !fir.class>, !fir.class> // CHECK: } // CHECK: } -// CHECK: %[[VAL_55:.*]] = fir.undefined tuple>>>, i1> -// CHECK: %[[VAL_56:.*]] = fir.insert_value %[[VAL_55]], %[[VAL_13]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> -// CHECK: %[[VAL_57:.*]] = fir.insert_value %[[VAL_56]], %[[VAL_40]], [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> -// CHECK: %[[VAL_58:.*]] = fir.zero_bits !fir.heap>> -// CHECK: %[[VAL_59:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_60:.*]] = fir.shape %[[VAL_59]], %[[VAL_59]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_61:.*]] = fir.embox %[[VAL_58]](%[[VAL_60]]) : (!fir.heap>>, !fir.shape<2>) -> !fir.class>>> -// CHECK: fir.store %[[VAL_61]] to %[[VAL_4]] : !fir.ref>>>> -// CHECK: %[[VAL_63:.*]]:2 = hlfir.declare %[[VAL_4]] {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp.array"} : (!fir.ref>>>>) -> (!fir.ref>>>>, !fir.ref>>>>) -// CHECK: %[[VAL_64:.*]] = arith.constant 2 : i32 -// CHECK: %[[VAL_65:.*]] = fir.convert %[[VAL_4]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_66:.*]] = fir.convert %[[VAL_40]] : (!fir.class>>>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_65]], %[[VAL_66]], %[[VAL_64]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: %[[VAL_68:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_69:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_70:.*]] = fir.convert %[[VAL_4]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_71:.*]] = fir.convert %[[VAL_69]] : (index) -> i32 -// CHECK: %[[VAL_72:.*]] = fir.convert %[[VAL_68]] : (index) -> i64 -// CHECK: %[[VAL_73:.*]] = fir.convert %[[VAL_2]] : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_70]], %[[VAL_71]], %[[VAL_72]], %[[VAL_73]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_75:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_76:.*]] = fir.convert %[[VAL_4]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_77:.*]] = fir.convert %[[VAL_75]] : (index) -> i32 -// CHECK: %[[VAL_78:.*]] = fir.convert %[[VAL_68]] : (index) -> i64 -// CHECK: %[[VAL_79:.*]] = fir.convert %[[VAL_3]] : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_76]], %[[VAL_77]], %[[VAL_78]], %[[VAL_79]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_81:.*]] = fir.address_of(@_QQcl -// CHECK: %[[VAL_82:.*]] = arith.constant {{.*}} : index -// CHECK: %[[VAL_83:.*]] = arith.constant {{.*}} : i32 -// CHECK: %[[VAL_84:.*]] = arith.constant false -// CHECK: %[[VAL_85:.*]] = fir.absent !fir.box -// CHECK: %[[VAL_86:.*]] = fir.convert %[[VAL_4]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_87:.*]] = fir.convert %[[VAL_81]] : (!fir.ref>) -> !fir.ref -// CHECK: %[[VAL_88:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_86]], %{{.*}}, %[[VAL_84]], %[[VAL_85]], %[[VAL_87]], %[[VAL_83]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 -// CHECK: %[[VAL_62:.*]] = arith.constant true -// CHECK: %[[VAL_89:.*]] = fir.load %[[VAL_63]]#0 : !fir.ref>>>> -// CHECK: %[[VAL_90:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_91:.*]] = %[[VAL_90]] to %[[VAL_3]] step %[[VAL_90]] unordered { -// CHECK: fir.do_loop %[[VAL_92:.*]] = %[[VAL_90]] to %[[VAL_2]] step %[[VAL_90]] unordered { -// CHECK: %[[VAL_93:.*]] = hlfir.designate %[[VAL_40]] (%[[VAL_92]], %[[VAL_91]]) : (!fir.class>>>, index, index) -> !fir.class> -// CHECK: %[[VAL_94:.*]] = arith.constant false -// CHECK: %[[VAL_95:.*]] = fir.undefined tuple>, i1> -// CHECK: %[[VAL_96:.*]] = fir.insert_value %[[VAL_95]], %[[VAL_94]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> -// CHECK: %[[VAL_97:.*]] = fir.insert_value %[[VAL_96]], %[[VAL_93]], [0 : index] : (tuple>, i1>, !fir.class>) -> tuple>, i1> -// CHECK: %[[VAL_98:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_99:.*]]:3 = fir.box_dims %[[VAL_89]], %[[VAL_98]] : (!fir.class>>>, index) -> (index, index, index) -// CHECK: %[[VAL_100:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_101:.*]]:3 = fir.box_dims %[[VAL_89]], %[[VAL_100]] : (!fir.class>>>, index) -> (index, index, index) -// CHECK: %[[VAL_102:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_103:.*]] = arith.subi %[[VAL_99]]#0, %[[VAL_102]] : index -// CHECK: %[[VAL_104:.*]] = arith.addi %[[VAL_92]], %[[VAL_103]] : index -// CHECK: %[[VAL_105:.*]] = arith.subi %[[VAL_101]]#0, %[[VAL_102]] : index -// CHECK: %[[VAL_106:.*]] = arith.addi %[[VAL_91]], %[[VAL_105]] : index -// CHECK: %[[VAL_107:.*]] = hlfir.designate %[[VAL_89]] (%[[VAL_104]], %[[VAL_106]]) : (!fir.class>>>, index, index) -> !fir.class> -// CHECK: hlfir.assign %[[VAL_93]] to %[[VAL_107]] temporary_lhs : !fir.class>, !fir.class> +// CHECK: %[[VAL_25:.*]] = fir.undefined tuple>>>, i1> +// CHECK: %[[VAL_26:.*]] = fir.insert_value %[[VAL_25]], %[[VAL_19]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> +// CHECK: %[[VAL_27:.*]] = fir.insert_value %[[VAL_26]], %[[VAL_18]]#0, [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> +// CHECK: %[[VAL_28:.*]] = fir.zero_bits !fir.heap>> +// CHECK: %[[VAL_29:.*]] = fir.embox %[[VAL_28]](%[[VAL_4]]) source_box %[[VAL_18]]#1 : (!fir.heap>>, !fir.shape<2>, !fir.class>>>) -> !fir.class>>> +// CHECK: fir.store %[[VAL_29]] to %[[VAL_0]] : !fir.ref>>>> +// CHECK: %[[VAL_30:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_34:.*]] = arith.constant false +// CHECK: %[[VAL_35:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_0]] : (!fir.ref>>>>) -> !fir.ref> +// CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_30]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_39:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_36]], %[[VAL_37]], %[[VAL_34]], %[[VAL_35]], +// CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_0]] : !fir.ref>>>> +// CHECK: %[[VAL_41:.*]]:2 = hlfir.declare %[[VAL_40]] {uniq_name = ".tmp.array"} : (!fir.class>>>) -> (!fir.class>>>, !fir.class>>>) +// CHECK: %[[VAL_42:.*]] = arith.constant true +// CHECK: %[[VAL_43:.*]] = arith.constant 1 : index +// CHECK: fir.do_loop %[[VAL_44:.*]] = %[[VAL_43]] to %[[ARG3]] step %[[VAL_43]] unordered { +// CHECK: fir.do_loop %[[VAL_45:.*]] = %[[VAL_43]] to %[[ARG2]] step %[[VAL_43]] unordered { +// CHECK: %[[VAL_46:.*]] = hlfir.designate %[[VAL_18]]#0 (%[[VAL_45]], %[[VAL_44]]) : (!fir.class>>>, index, index) -> !fir.class> +// CHECK: %[[VAL_47:.*]] = arith.constant false +// CHECK: %[[VAL_48:.*]] = fir.undefined tuple>, i1> +// CHECK: %[[VAL_49:.*]] = fir.insert_value %[[VAL_48]], %[[VAL_47]], [1 : index] : (tuple>, i1>, i1) -> tuple>, i1> +// CHECK: %[[VAL_50:.*]] = fir.insert_value %[[VAL_49]], %[[VAL_46]], [0 : index] : (tuple>, i1>, !fir.class>) -> tuple>, i1> +// CHECK: %[[VAL_51:.*]] = hlfir.designate %[[VAL_41]]#0 (%[[VAL_45]], %[[VAL_44]]) : (!fir.class>>>, index, index) -> !fir.class> +// CHECK: hlfir.assign %[[VAL_46]] to %[[VAL_51]] temporary_lhs : !fir.class>, !fir.class> +// CHECK: %[[VAL_52:.*]] = fir.box_addr %[[VAL_46]] : (!fir.class>) -> !fir.heap> +// CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_46]] : (!fir.class>) -> !fir.box +// CHECK: fir.call @_FortranADestroyWithoutFinalization(%[[VAL_53]]) : (!fir.box) -> () // CHECK: } // CHECK: } -// CHECK: %[[VAL_108:.*]] = fir.undefined tuple>>>, i1> -// CHECK: %[[VAL_109:.*]] = fir.insert_value %[[VAL_108]], %[[VAL_62]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> -// CHECK: %[[VAL_110:.*]] = fir.insert_value %[[VAL_109]], %[[VAL_89]], [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> +// CHECK: %[[VAL_54:.*]] = fir.undefined tuple>>>, i1> +// CHECK: %[[VAL_55:.*]] = fir.insert_value %[[VAL_54]], %[[VAL_42]], [1 : index] : (tuple>>>, i1>, i1) -> tuple>>>, i1> +// CHECK: %[[VAL_56:.*]] = fir.insert_value %[[VAL_55]], %[[VAL_41]]#0, [0 : index] : (tuple>>>, i1>, !fir.class>>>) -> tuple>>>, i1> // CHECK: return // CHECK: } diff --git a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-multiple-variables.f90 b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-multiple-variables.f90 index 12e15a2aafc2..217ac5638a3e 100644 --- a/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-multiple-variables.f90 +++ b/flang/test/Lower/OpenMP/DelayedPrivatization/target-private-multiple-variables.f90 @@ -65,8 +65,8 @@ end subroutine target_allocatable ! CHECK-NEXT: %[[BOX_DIMS:.*]]:3 = fir.box_dims %[[MOLD]], %[[C0]] ! CHECK-NEXT: %[[SHAPE:.*]] = fir.shape %[[BOX_DIMS]]#1 ! CHECK-NEXT: %[[DATA_ALLOC:.*]] = fir.allocmem !fir.array, %[[BOX_DIMS]]#1 -! CHECK-NEXT: %[[TRUE:.*]] = arith.constant true ! CHECK-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[DATA_ALLOC:.*]](%[[SHAPE]]) +! CHECK-NEXT: %[[TRUE:.*]] = arith.constant true ! CHECK-NEXT: %[[C0_2:.*]] = arith.constant 0 : index ! CHECK-NEXT: %[[BOX_DIMS_2:.*]]:3 = fir.box_dims %[[MOLD]], %[[C0_2]] ! CHECK-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[BOX_DIMS_2]]#0, %[[BOX_DIMS_2]]#1 diff --git a/flang/test/Lower/OpenMP/delayed-privatization-allocatable-array.f90 b/flang/test/Lower/OpenMP/delayed-privatization-allocatable-array.f90 index d1c7167546b4..8446e99126f2 100644 --- a/flang/test/Lower/OpenMP/delayed-privatization-allocatable-array.f90 +++ b/flang/test/Lower/OpenMP/delayed-privatization-allocatable-array.f90 @@ -36,8 +36,8 @@ end subroutine ! CHECK-NEXT: %[[DIMS:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C0]] ! CHECK-NEXT: %[[SHAPE:.*]] = fir.shape %[[DIMS]]#1 ! CHECK-NEXT: %[[MEM:.*]] = fir.allocmem !fir.array, %[[DIMS]]#1 -! CHECK-NEXT: %[[TRUE:.*]] = arith.constant true ! CHECK-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[MEM]](%[[SHAPE]]) +! CHECK-NEXT: %[[TRUE:.*]] = arith.constant true ! CHECK-NEXT: %[[C0_2:.*]] = arith.constant 0 : index ! CHECK-NEXT: %[[DIMS_2:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C0_2]] ! CHECK-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[DIMS_2]]#0, %[[DIMS_2]]#1 diff --git a/flang/test/Lower/OpenMP/delayed-privatization-array.f90 b/flang/test/Lower/OpenMP/delayed-privatization-array.f90 index 9aaf75f66dbb..0cda25492498 100644 --- a/flang/test/Lower/OpenMP/delayed-privatization-array.f90 +++ b/flang/test/Lower/OpenMP/delayed-privatization-array.f90 @@ -38,8 +38,8 @@ end subroutine ! ONE_DIM-NEXT: %[[DIMS:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C0]] ! ONE_DIM-NEXT: %[[SHAPE:.*]] = fir.shape %[[DIMS]]#1 ! ONE_DIM-NEXT: %[[ARRAY_ALLOC:.*]] = fir.allocmem !fir.array, %[[DIMS]]#1 -! ONE_DIM-NEXT: %[[TRUE:.*]] = arith.constant true ! ONE_DIM-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[ARRAY_ALLOC]](%[[SHAPE]]) +! ONE_DIM-NEXT: %[[TRUE:.*]] = arith.constant true ! ONE_DIM-NEXT: %[[C0_0:.*]] = arith.constant 0 ! ONE_DIM-NEXT: %[[DIMS2:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C0_0]] ! ONE_DIM-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[DIMS2]]#0, %[[DIMS2]]#1 @@ -76,8 +76,8 @@ end subroutine ! TWO_DIM-NEXT: %[[DIMS_1:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C1]] ! TWO_DIM-NEXT: %[[SHAPE:.*]] = fir.shape %[[DIMS_0]]#1, %[[DIMS_1]]#1 ! TWO_DIM-NEXT: %[[ARRAY_ALLOC:.*]] = fir.allocmem !fir.array, %[[DIMS_0]]#1, %[[DIMS_1]]#1 -! TWO_DIM-NEXT: %[[TRUE:.*]] = arith.constant true ! TWO_DIM-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[ARRAY_ALLOC]](%[[SHAPE]]) +! TWO_DIM-NEXT: %[[TRUE:.*]] = arith.constant true ! TWO_DIM-NEXT: %[[C0_0:.*]] = arith.constant 0 ! TWO_DIM-NEXT: %[[DIMS2_0:.*]]:3 = fir.box_dims %[[PRIV_ARG_VAL]], %[[C0_0]] ! TWO_DIM-NEXT: %[[C1_0:.*]] = arith.constant 1 @@ -111,8 +111,8 @@ end program ! ONE_DIM_DEFAULT_LB-NEXT: %[[C10:.*]] = arith.constant 10 : index ! ONE_DIM_DEFAULT_LB-NEXT: %[[SHAPE:.*]] = fir.shape %[[C10]] ! ONE_DIM_DEFAULT_LB-NEXT: %[[ARRAY_ALLOC:.*]] = fir.allocmem !fir.array<10xi32> -! ONE_DIM_DEFAULT_LB-NEXT: %[[TRUE:.*]] = arith.constant true ! ONE_DIM_DEFAULT_LB-NEXT: %[[DECL:.*]]:2 = hlfir.declare %[[ARRAY_ALLOC]](%[[SHAPE]]) +! ONE_DIM_DEFAULT_LB-NEXT: %[[TRUE:.*]] = arith.constant true ! ONE_DIM_DEFAULT_LB-NEXT: %[[ONE:.*]] = arith.constant 1 : index ! ONE_DIM_DEFAULT_LB-NEXT: %[[TEN:.*]] = arith.constant 10 : index ! ONE_DIM_DEFAULT_LB-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[ONE]], %[[TEN]] diff --git a/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 b/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 index 96e719faf912..4bfd5d8d1926 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 @@ -39,8 +39,8 @@ end program ! CHECK: %[[VAL_4:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_3]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array, %[[VAL_4]]#1 {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[VAL_7:.*]] = arith.constant true ! CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) +! CHECK: %[[VAL_7:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_2]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 index 86dac33409c7..a5710fcf5352 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 @@ -23,8 +23,8 @@ end program ! CHECK: %[[VAL_4:.*]] = arith.constant 2 : index ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_3]], %[[VAL_4]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array<3x2xi32> {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[VAL_7:.*]] = arith.constant true ! CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<2>) -> (!fir.heap>, !fir.heap>) +! CHECK: %[[VAL_7:.*]] = arith.constant true ! CHECK: %[[VAL_9:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_10:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_9]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_11:.*]] = arith.constant 1 : index diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array.f90 index 575dbdae9b61..8e3de498f59c 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array.f90 @@ -23,8 +23,8 @@ end program ! CHECK: %[[VAL_4:.*]] = arith.constant 3 : index ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_1:.*]] = fir.allocmem !fir.array<3xi32> {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap>, +! CHECK: %[[TRUE:.*]] = arith.constant true !fir.shape<1>) -> (!fir.heap>, !fir.heap>) ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_3]], %[[C0]] : (!fir.box>, index) -> (index, index, index) diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 index 733b7aa67fca..488ecc353af8 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 @@ -23,8 +23,8 @@ end program ! CHECK: %[[VAL_4:.*]] = arith.constant 3 : index ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_1:.*]] = fir.allocmem !fir.array<3xi32> -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.heap>, !fir.heap>) +! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_3]], %[[C0]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/parallel-reduction-pointer-array.f90 b/flang/test/Lower/OpenMP/parallel-reduction-pointer-array.f90 index 72360bdc43a6..f638688bc2cc 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-pointer-array.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-pointer-array.f90 @@ -40,8 +40,8 @@ end program ! CHECK: %[[VAL_10:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_9]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_10]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array, %[[VAL_10]]#1 {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_12]](%[[VAL_11]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) +! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_15]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_17:.*]] = fir.shape_shift %[[VAL_16]]#0, %[[VAL_16]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/parallel-reduction3.f90 b/flang/test/Lower/OpenMP/parallel-reduction3.f90 index bc1a8b232890..69d669a4093f 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction3.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction3.f90 @@ -12,8 +12,8 @@ ! CHECK: %[[VAL_4:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_3]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array, %[[VAL_4]]#1 {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) +! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_2]], %[[C0]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/reduction-array-intrinsic.f90 b/flang/test/Lower/OpenMP/reduction-array-intrinsic.f90 index ae5952eb662e..8b4f37278185 100644 --- a/flang/test/Lower/OpenMP/reduction-array-intrinsic.f90 +++ b/flang/test/Lower/OpenMP/reduction-array-intrinsic.f90 @@ -20,8 +20,8 @@ end subroutine ! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_4]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_6:.*]] = fir.shape %[[VAL_5]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_7:.*]] = fir.allocmem !fir.array, %[[VAL_5]]#1 {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[VAL_8:.*]] = arith.constant true ! CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_7]](%[[VAL_6]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) +! CHECK: %[[VAL_8:.*]] = arith.constant true ! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_10]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_12:.*]] = fir.shape_shift %[[VAL_11]]#0, %[[VAL_11]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-allocatable-array-minmax.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-allocatable-array-minmax.f90 index eaa388a6f2f5..5b4c5e65ffcc 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-allocatable-array-minmax.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-allocatable-array-minmax.f90 @@ -53,8 +53,8 @@ end program ! CHECK: %[[VAL_10:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_9]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_10]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array, %[[VAL_10]]#1 {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_12]](%[[VAL_11]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) +! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_15]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_17:.*]] = fir.shape_shift %[[VAL_16]]#0, %[[VAL_16]]#1 : (index, index) -> !fir.shapeshift<1> @@ -115,8 +115,8 @@ end program ! CHECK: %[[VAL_10:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_9]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_10]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_12:.*]] = fir.allocmem !fir.array, %[[VAL_10]]#1 {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_12]](%[[VAL_11]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) +! CHECK: %[[VAL_13:.*]] = arith.constant true ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_15]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_17:.*]] = fir.shape_shift %[[VAL_16]]#0, %[[VAL_16]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 index 0cd3cd0cec29..290f9e198136 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 @@ -33,8 +33,8 @@ end program ! CHECK: %[[VAL_4:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_3]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]]#1 : (index) -> !fir.shape<1> ! CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array, %[[VAL_4]]#1 {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) +! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_2]], %[[C0]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 index 9cf018fd605e..21261da49710 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 @@ -24,8 +24,8 @@ end program ! CHECK: %[[VAL_4:.*]] = arith.constant 2 : index ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_1:.*]] = fir.allocmem !fir.array<2xi32> {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.heap>, !fir.heap>) +! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_3]], %[[C0]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 index 224a8b5f32ef..ab8dcf1f076c 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 @@ -24,8 +24,8 @@ end program ! CHECK: %[[VAL_4:.*]] = arith.constant 2 : index ! CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_1:.*]] = fir.allocmem !fir.array<2xi32> {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_5]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<1>) -> (!fir.heap>, !fir.heap>) +! CHECK: %[[TRUE:.*]] = arith.constant true ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[VAL_3]], %[[C0]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[SHIFT:.*]] = fir.shape_shift %[[DIMS]]#0, %[[DIMS]]#1 : (index, index) -> !fir.shapeshift<1> diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 index e94cf8f73c55..e0a3b469f40c 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 @@ -35,8 +35,8 @@ endprogram ! CHECK: %[[VAL_5:.*]] = arith.constant 3 : index ! CHECK: %[[VAL_6:.*]] = fir.shape %[[VAL_4]], %[[VAL_5]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_7:.*]] = fir.allocmem !fir.array<3x3xf64> {bindc_name = ".tmp", uniq_name = ""} -! CHECK: %[[VAL_8:.*]] = arith.constant true ! CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_7]](%[[VAL_6]]) {uniq_name = ".tmp"} : (!fir.heap>, !fir.shape<2>) -> (!fir.heap>, !fir.heap>) +! CHECK: %[[VAL_8:.*]] = arith.constant true ! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_10]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index diff --git a/flang/test/Lower/do_concurrent_local_assoc_entity.f90 b/flang/test/Lower/do_concurrent_local_assoc_entity.f90 index ee931ffdfdcc..a3d0c34ed856 100644 --- a/flang/test/Lower/do_concurrent_local_assoc_entity.f90 +++ b/flang/test/Lower/do_concurrent_local_assoc_entity.f90 @@ -18,7 +18,7 @@ end subroutine local_assoc ! CHECK-NEXT: %[[SHAPE:.*]] = fir.shape %[[C8]] ! CHECK-NEXT: %[[TMP_ALLOC:.*]] = fir.allocmem !{{.*}} {bindc_name = ".tmp", {{.*}}} ! CHECK: %[[TMP_DECL:.*]]:2 = hlfir.declare %[[TMP_ALLOC]](%[[SHAPE]]) -! CHECK-NEXT: %[[C1:.*]] = arith.constant 1 : index +! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK-NEXT: %[[C8:.*]] = arith.constant 8 : index ! CHECK-NEXT: %[[SHAPE_SHIFT:.*]] = fir.shape_shift %[[C1]], %[[C8]] ! CHECK-NEXT: %[[TMP_BOX:.*]] = fir.embox %[[TMP_DECL]]#0(%[[SHAPE_SHIFT]]) diff --git a/flang/test/Transforms/lower-repack-arrays.fir b/flang/test/Transforms/lower-repack-arrays.fir index 0b323b1bb069..012e957173ac 100644 --- a/flang/test/Transforms/lower-repack-arrays.fir +++ b/flang/test/Transforms/lower-repack-arrays.fir @@ -799,79 +799,67 @@ func.func @_QPtest6(%arg0: !fir.class>> {fir.bi return } // CHECK-LABEL: func.func @_QPtest6( -// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.class>> {fir.bindc_name = "x"}) { +// CHECK-SAME: %[[ARG0:.*]]: !fir.class>> {fir.bindc_name = "x"}) { +// CHECK: %[[VAL_0:.*]] = arith.constant // CHECK: %[[VAL_1:.*]] = arith.constant -// CHECK: %[[VAL_2:.*]] = arith.constant -// CHECK: %[[VAL_3:.*]] = arith.constant 2 : i32 -// CHECK: %[[VAL_4:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_5:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_6:.*]] = arith.constant false -// CHECK: %[[VAL_7:.*]] = fir.alloca !fir.class>>> -// CHECK: %[[VAL_8:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.class>>) -> i1 -// CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.class>>) { -// CHECK: %[[VAL_11:.*]] = fir.is_contiguous_box %[[VAL_0]] innermost : (!fir.class>>) -> i1 -// CHECK: %[[VAL_12:.*]] = arith.cmpi eq, %[[VAL_11]], %[[VAL_6]] : i1 -// CHECK: %[[VAL_13:.*]] = fir.box_addr %[[VAL_0]] : (!fir.class>>) -> !fir.ref>>> -// CHECK: %[[VAL_14:.*]] = fir.is_present %[[VAL_13]] : (!fir.ref>>>) -> i1 -// CHECK: %[[VAL_15:.*]] = arith.andi %[[VAL_12]], %[[VAL_14]] : i1 -// CHECK: %[[VAL_16:.*]] = fir.if %[[VAL_15]] -> (!fir.class>>) { -// CHECK: %[[VAL_17:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_5]] : (!fir.class>>, index) -> (index, index, index) -// CHECK: %[[VAL_18:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_4]] : (!fir.class>>, index) -> (index, index, index) -// CHECK: %[[VAL_19:.*]] = fir.zero_bits !fir.heap>> -// CHECK: %[[VAL_20:.*]] = fir.shape %[[VAL_5]], %[[VAL_5]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_21:.*]] = fir.embox %[[VAL_19]](%[[VAL_20]]) : (!fir.heap>>, !fir.shape<2>) -> !fir.class>>> -// CHECK: fir.store %[[VAL_21]] to %[[VAL_7]] : !fir.ref>>>> -// CHECK: %[[VAL_22:.*]] = fir.declare %[[VAL_7]] {fortran_attrs = #fir.var_attrs, uniq_name = ".repacked"} : (!fir.ref>>>>) -> !fir.ref>>>> -// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_0]] : (!fir.class>>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_23]], %[[VAL_24]], %[[VAL_3]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_5]] : (index) -> i32 -// CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_4]] : (index) -> i64 -// CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_17]]#1 : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_25]], %[[VAL_26]], %[[VAL_27]], %[[VAL_28]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_4]] : (index) -> i32 -// CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_4]] : (index) -> i64 -// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_18]]#1 : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_29]], %[[VAL_30]], %[[VAL_31]], %[[VAL_32]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_33:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_34:.*]] = fir.absent !fir.box -// CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_33]] : (!fir.ref>) -> !fir.ref -// CHECK: %[[VAL_37:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_35]], %{{.*}}, %[[VAL_6]], %[[VAL_34]], %[[VAL_36]], %[[VAL_2]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 -// CHECK: %[[VAL_38:.*]] = fir.load %[[VAL_22]] : !fir.ref>>>> -// CHECK: %[[VAL_39:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_38]] : (!fir.class>>>) -> !fir.box -// CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_0]] : (!fir.class>>) -> !fir.box -// CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_39]] : (!fir.ref>) -> !fir.ref -// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_40]], %[[VAL_41]], %[[VAL_42]], %[[VAL_2]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () -// CHECK: %[[VAL_43:.*]] = fir.shift %[[VAL_17]]#0, %[[VAL_18]]#0 : (index, index) -> !fir.shift<2> -// CHECK: %[[VAL_44:.*]] = fir.rebox %[[VAL_38]](%[[VAL_43]]) : (!fir.class>>>, !fir.shift<2>) -> !fir.class>> -// CHECK: fir.result %[[VAL_44]] : !fir.class>> +// CHECK: %[[VAL_2:.*]] = arith.constant 1 : index +// CHECK: %[[VAL_3:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_4:.*]] = arith.constant false +// CHECK: %[[VAL_5:.*]] = fir.alloca !fir.class>>> +// CHECK: %[[VAL_6:.*]] = fir.dummy_scope : !fir.dscope +// CHECK: %[[VAL_7:.*]] = fir.is_present %[[ARG0]] : (!fir.class>>) -> i1 +// CHECK: %[[VAL_8:.*]] = fir.if %[[VAL_7]] -> (!fir.class>>) { +// CHECK: %[[VAL_9:.*]] = fir.is_contiguous_box %[[ARG0]] innermost : (!fir.class>>) -> i1 +// CHECK: %[[VAL_10:.*]] = arith.cmpi eq, %[[VAL_9]], %[[VAL_4]] : i1 +// CHECK: %[[VAL_11:.*]] = fir.box_addr %[[ARG0]] : (!fir.class>>) -> !fir.ref>>> +// CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_11]] : (!fir.ref>>>) -> i1 +// CHECK: %[[VAL_13:.*]] = arith.andi %[[VAL_10]], %[[VAL_12]] : i1 +// CHECK: %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (!fir.class>>) { +// CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[ARG0]], %[[VAL_3]] : (!fir.class>>, index) -> (index, index, index) +// CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[ARG0]], %[[VAL_2]] : (!fir.class>>, index) -> (index, index, index) +// CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_15]]#1, %[[VAL_16]]#1 : (index, index) -> !fir.shape<2> +// CHECK: %[[VAL_18:.*]] = fir.zero_bits !fir.heap>> +// CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_18]](%[[VAL_17]]) source_box %[[ARG0]] : (!fir.heap>>, !fir.shape<2>, !fir.class>>) -> !fir.class>>> +// CHECK: fir.store %[[VAL_19]] to %[[VAL_5]] : !fir.ref>>>> +// CHECK: %[[VAL_20:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_21:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_22:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_5]] : (!fir.ref>>>>) -> !fir.ref> +// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_20]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_21]] : (!fir.ref>) -> !fir.ref +// CHECK: %[[VAL_26:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_23]], %[[VAL_24]], %[[VAL_4]], %[[VAL_22]], %[[VAL_25]], %[[VAL_1]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 +// CHECK: %[[VAL_27:.*]] = fir.load %[[VAL_5]] : !fir.ref>>>> +// CHECK: %[[VAL_28:.*]] = fir.declare %[[VAL_27]] {uniq_name = ".repacked"} : (!fir.class>>>) -> !fir.class>>> +// CHECK: %[[VAL_29:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_28]] : (!fir.class>>>) -> !fir.box +// CHECK: %[[VAL_31:.*]] = fir.convert %[[ARG0]] : (!fir.class>>) -> !fir.box +// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_29]] : (!fir.ref>) -> !fir.ref +// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_30]], %[[VAL_31]], %[[VAL_32]], %[[VAL_1]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () +// CHECK: %[[VAL_33:.*]] = fir.shift %[[VAL_15]]#0, %[[VAL_16]]#0 : (index, index) -> !fir.shift<2> +// CHECK: %[[VAL_34:.*]] = fir.rebox %[[VAL_28]](%[[VAL_33]]) : (!fir.class>>>, !fir.shift<2>) -> !fir.class>> +// CHECK: fir.result %[[VAL_34]] : !fir.class>> // CHECK: } else { -// CHECK: fir.result %[[VAL_0]] : !fir.class>> +// CHECK: fir.result %[[ARG0]] : !fir.class>> // CHECK: } -// CHECK: fir.result %[[VAL_16]] : !fir.class>> +// CHECK: fir.result %[[VAL_14]] : !fir.class>> // CHECK: } else { -// CHECK: fir.result %[[VAL_0]] : !fir.class>> +// CHECK: fir.result %[[ARG0]] : !fir.class>> // CHECK: } -// CHECK: %[[VAL_45:.*]] = fir.declare %[[VAL_10]] dummy_scope %[[VAL_8]] {uniq_name = "_QFtest6Ex"} : (!fir.class>>, !fir.dscope) -> !fir.class>> -// CHECK: %[[VAL_46:.*]] = fir.is_present %[[VAL_0]] : (!fir.class>>) -> i1 -// CHECK: fir.if %[[VAL_46]] { -// CHECK: %[[VAL_47:.*]] = fir.box_addr %[[VAL_10]] : (!fir.class>>) -> !fir.heap>> -// CHECK: %[[VAL_49:.*]] = fir.box_addr %[[VAL_0]] : (!fir.class>>) -> !fir.heap>> -// CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_47]] : (!fir.heap>>) -> index -// CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (!fir.heap>>) -> index -// CHECK: %[[VAL_51:.*]] = arith.cmpi ne, %[[VAL_48]], %[[VAL_50]] : index -// CHECK: fir.if %[[VAL_51]] { -// CHECK: %[[VAL_52:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_0]] : (!fir.class>>) -> !fir.box -// CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_10]] : (!fir.class>>) -> !fir.box -// CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_52]] : (!fir.ref>) -> !fir.ref -// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_53]], %[[VAL_54]], %[[VAL_55]], %[[VAL_1]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () -// CHECK: fir.freemem %[[VAL_47]] : !fir.heap>> +// CHECK: %[[VAL_35:.*]] = fir.declare %[[VAL_8]] dummy_scope %[[VAL_6]] {uniq_name = "_QFtest6Ex"} : (!fir.class>>, !fir.dscope) -> !fir.class>> +// CHECK: %[[VAL_36:.*]] = fir.is_present %[[ARG0]] : (!fir.class>>) -> i1 +// CHECK: fir.if %[[VAL_36]] { +// CHECK: %[[VAL_37:.*]] = fir.box_addr %[[VAL_8]] : (!fir.class>>) -> !fir.heap>> +// CHECK: %[[VAL_38:.*]] = fir.box_addr %[[ARG0]] : (!fir.class>>) -> !fir.heap>> +// CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (!fir.heap>>) -> index +// CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_38]] : (!fir.heap>>) -> index +// CHECK: %[[VAL_41:.*]] = arith.cmpi ne, %[[VAL_39]], %[[VAL_40]] : index +// CHECK: fir.if %[[VAL_41]] { +// CHECK: %[[VAL_42:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_43:.*]] = fir.convert %[[ARG0]] : (!fir.class>>) -> !fir.box +// CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_8]] : (!fir.class>>) -> !fir.box +// CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_42]] : (!fir.ref>) -> !fir.ref +// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_43]], %[[VAL_44]], %[[VAL_45]], %[[VAL_0]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () +// CHECK: fir.freemem %[[VAL_37]] : !fir.heap>> // CHECK: } // CHECK: } // CHECK: return @@ -887,79 +875,67 @@ func.func @_QPtest6_stack(%arg0: !fir.class>> { return } // CHECK-LABEL: func.func @_QPtest6_stack( -// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.class>> {fir.bindc_name = "x"}) { +// CHECK-SAME: %[[ARG0:.*]]: !fir.class>> {fir.bindc_name = "x"}) { +// CHECK: %[[VAL_0:.*]] = arith.constant // CHECK: %[[VAL_1:.*]] = arith.constant -// CHECK: %[[VAL_2:.*]] = arith.constant -// CHECK: %[[VAL_3:.*]] = arith.constant 2 : i32 -// CHECK: %[[VAL_4:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_5:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_6:.*]] = arith.constant false -// CHECK: %[[VAL_7:.*]] = fir.alloca !fir.class>>> -// CHECK: %[[VAL_8:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.class>>) -> i1 -// CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.class>>) { -// CHECK: %[[VAL_11:.*]] = fir.is_contiguous_box %[[VAL_0]] innermost : (!fir.class>>) -> i1 -// CHECK: %[[VAL_12:.*]] = arith.cmpi eq, %[[VAL_11]], %[[VAL_6]] : i1 -// CHECK: %[[VAL_13:.*]] = fir.box_addr %[[VAL_0]] : (!fir.class>>) -> !fir.ref>>> -// CHECK: %[[VAL_14:.*]] = fir.is_present %[[VAL_13]] : (!fir.ref>>>) -> i1 -// CHECK: %[[VAL_15:.*]] = arith.andi %[[VAL_12]], %[[VAL_14]] : i1 -// CHECK: %[[VAL_16:.*]] = fir.if %[[VAL_15]] -> (!fir.class>>) { -// CHECK: %[[VAL_17:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_5]] : (!fir.class>>, index) -> (index, index, index) -// CHECK: %[[VAL_18:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_4]] : (!fir.class>>, index) -> (index, index, index) -// CHECK: %[[VAL_19:.*]] = fir.zero_bits !fir.heap>> -// CHECK: %[[VAL_20:.*]] = fir.shape %[[VAL_5]], %[[VAL_5]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_21:.*]] = fir.embox %[[VAL_19]](%[[VAL_20]]) : (!fir.heap>>, !fir.shape<2>) -> !fir.class>>> -// CHECK: fir.store %[[VAL_21]] to %[[VAL_7]] : !fir.ref>>>> -// CHECK: %[[VAL_22:.*]] = fir.declare %[[VAL_7]] {fortran_attrs = #fir.var_attrs, uniq_name = ".repacked"} : (!fir.ref>>>>) -> !fir.ref>>>> -// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_0]] : (!fir.class>>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_23]], %[[VAL_24]], %[[VAL_3]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_5]] : (index) -> i32 -// CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_4]] : (index) -> i64 -// CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_17]]#1 : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_25]], %[[VAL_26]], %[[VAL_27]], %[[VAL_28]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_4]] : (index) -> i32 -// CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_4]] : (index) -> i64 -// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_18]]#1 : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_29]], %[[VAL_30]], %[[VAL_31]], %[[VAL_32]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_33:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_34:.*]] = fir.absent !fir.box -// CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>>) -> !fir.ref> -// CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_33]] : (!fir.ref>) -> !fir.ref -// CHECK: %[[VAL_37:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_35]], %{{.*}}, %[[VAL_6]], %[[VAL_34]], %[[VAL_36]], %[[VAL_2]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 -// CHECK: %[[VAL_38:.*]] = fir.load %[[VAL_22]] : !fir.ref>>>> -// CHECK: %[[VAL_39:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_38]] : (!fir.class>>>) -> !fir.box -// CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_0]] : (!fir.class>>) -> !fir.box -// CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_39]] : (!fir.ref>) -> !fir.ref -// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_40]], %[[VAL_41]], %[[VAL_42]], %[[VAL_2]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () -// CHECK: %[[VAL_43:.*]] = fir.shift %[[VAL_17]]#0, %[[VAL_18]]#0 : (index, index) -> !fir.shift<2> -// CHECK: %[[VAL_44:.*]] = fir.rebox %[[VAL_38]](%[[VAL_43]]) : (!fir.class>>>, !fir.shift<2>) -> !fir.class>> -// CHECK: fir.result %[[VAL_44]] : !fir.class>> +// CHECK: %[[VAL_2:.*]] = arith.constant 1 : index +// CHECK: %[[VAL_3:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_4:.*]] = arith.constant false +// CHECK: %[[VAL_5:.*]] = fir.alloca !fir.class>>> +// CHECK: %[[VAL_6:.*]] = fir.dummy_scope : !fir.dscope +// CHECK: %[[VAL_7:.*]] = fir.is_present %[[ARG0]] : (!fir.class>>) -> i1 +// CHECK: %[[VAL_8:.*]] = fir.if %[[VAL_7]] -> (!fir.class>>) { +// CHECK: %[[VAL_9:.*]] = fir.is_contiguous_box %[[ARG0]] innermost : (!fir.class>>) -> i1 +// CHECK: %[[VAL_10:.*]] = arith.cmpi eq, %[[VAL_9]], %[[VAL_4]] : i1 +// CHECK: %[[VAL_11:.*]] = fir.box_addr %[[ARG0]] : (!fir.class>>) -> !fir.ref>>> +// CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_11]] : (!fir.ref>>>) -> i1 +// CHECK: %[[VAL_13:.*]] = arith.andi %[[VAL_10]], %[[VAL_12]] : i1 +// CHECK: %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (!fir.class>>) { +// CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[ARG0]], %[[VAL_3]] : (!fir.class>>, index) -> (index, index, index) +// CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[ARG0]], %[[VAL_2]] : (!fir.class>>, index) -> (index, index, index) +// CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_15]]#1, %[[VAL_16]]#1 : (index, index) -> !fir.shape<2> +// CHECK: %[[VAL_18:.*]] = fir.zero_bits !fir.heap>> +// CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_18]](%[[VAL_17]]) source_box %[[ARG0]] : (!fir.heap>>, !fir.shape<2>, !fir.class>>) -> !fir.class>>> +// CHECK: fir.store %[[VAL_19]] to %[[VAL_5]] : !fir.ref>>>> +// CHECK: %[[VAL_20:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_21:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_22:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_5]] : (!fir.ref>>>>) -> !fir.ref> +// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_20]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_21]] : (!fir.ref>) -> !fir.ref +// CHECK: %[[VAL_26:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_23]], %[[VAL_24]], %[[VAL_4]], %[[VAL_22]], %[[VAL_25]], %[[VAL_1]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 +// CHECK: %[[VAL_27:.*]] = fir.load %[[VAL_5]] : !fir.ref>>>> +// CHECK: %[[VAL_28:.*]] = fir.declare %[[VAL_27]] {uniq_name = ".repacked"} : (!fir.class>>>) -> !fir.class>>> +// CHECK: %[[VAL_29:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_28]] : (!fir.class>>>) -> !fir.box +// CHECK: %[[VAL_31:.*]] = fir.convert %[[ARG0]] : (!fir.class>>) -> !fir.box +// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_29]] : (!fir.ref>) -> !fir.ref +// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_30]], %[[VAL_31]], %[[VAL_32]], %[[VAL_1]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () +// CHECK: %[[VAL_33:.*]] = fir.shift %[[VAL_15]]#0, %[[VAL_16]]#0 : (index, index) -> !fir.shift<2> +// CHECK: %[[VAL_34:.*]] = fir.rebox %[[VAL_28]](%[[VAL_33]]) : (!fir.class>>>, !fir.shift<2>) -> !fir.class>> +// CHECK: fir.result %[[VAL_34]] : !fir.class>> // CHECK: } else { -// CHECK: fir.result %[[VAL_0]] : !fir.class>> +// CHECK: fir.result %[[ARG0]] : !fir.class>> // CHECK: } -// CHECK: fir.result %[[VAL_16]] : !fir.class>> +// CHECK: fir.result %[[VAL_14]] : !fir.class>> // CHECK: } else { -// CHECK: fir.result %[[VAL_0]] : !fir.class>> +// CHECK: fir.result %[[ARG0]] : !fir.class>> // CHECK: } -// CHECK: %[[VAL_45:.*]] = fir.declare %[[VAL_10]] dummy_scope %[[VAL_8]] {uniq_name = "_QFtest6_stackEx"} : (!fir.class>>, !fir.dscope) -> !fir.class>> -// CHECK: %[[VAL_46:.*]] = fir.is_present %[[VAL_0]] : (!fir.class>>) -> i1 -// CHECK: fir.if %[[VAL_46]] { -// CHECK: %[[VAL_47:.*]] = fir.box_addr %[[VAL_10]] : (!fir.class>>) -> !fir.heap>> -// CHECK: %[[VAL_49:.*]] = fir.box_addr %[[VAL_0]] : (!fir.class>>) -> !fir.heap>> -// CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_47]] : (!fir.heap>>) -> index -// CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (!fir.heap>>) -> index -// CHECK: %[[VAL_51:.*]] = arith.cmpi ne, %[[VAL_48]], %[[VAL_50]] : index -// CHECK: fir.if %[[VAL_51]] { -// CHECK: %[[VAL_52:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_0]] : (!fir.class>>) -> !fir.box -// CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_10]] : (!fir.class>>) -> !fir.box -// CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_52]] : (!fir.ref>) -> !fir.ref -// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_53]], %[[VAL_54]], %[[VAL_55]], %[[VAL_1]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () -// CHECK: fir.freemem %[[VAL_47]] : !fir.heap>> +// CHECK: %[[VAL_35:.*]] = fir.declare %[[VAL_8]] dummy_scope %[[VAL_6]] {uniq_name = "_QFtest6_stackEx"} : (!fir.class>>, !fir.dscope) -> !fir.class>> +// CHECK: %[[VAL_36:.*]] = fir.is_present %[[ARG0]] : (!fir.class>>) -> i1 +// CHECK: fir.if %[[VAL_36]] { +// CHECK: %[[VAL_37:.*]] = fir.box_addr %[[VAL_8]] : (!fir.class>>) -> !fir.heap>> +// CHECK: %[[VAL_38:.*]] = fir.box_addr %[[ARG0]] : (!fir.class>>) -> !fir.heap>> +// CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (!fir.heap>>) -> index +// CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_38]] : (!fir.heap>>) -> index +// CHECK: %[[VAL_41:.*]] = arith.cmpi ne, %[[VAL_39]], %[[VAL_40]] : index +// CHECK: fir.if %[[VAL_41]] { +// CHECK: %[[VAL_42:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_43:.*]] = fir.convert %[[ARG0]] : (!fir.class>>) -> !fir.box +// CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_8]] : (!fir.class>>) -> !fir.box +// CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_42]] : (!fir.ref>) -> !fir.ref +// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_43]], %[[VAL_44]], %[[VAL_45]], %[[VAL_0]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () +// CHECK: fir.freemem %[[VAL_37]] : !fir.heap>> // CHECK: } // CHECK: } // CHECK: return @@ -974,79 +950,67 @@ func.func @_QPtest7(%arg0: !fir.class> {fir.bindc_name = "x return } // CHECK-LABEL: func.func @_QPtest7( -// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.class> {fir.bindc_name = "x"}) { +// CHECK-SAME: %[[ARG0:.*]]: !fir.class> {fir.bindc_name = "x"}) { +// CHECK: %[[VAL_0:.*]] = arith.constant // CHECK: %[[VAL_1:.*]] = arith.constant -// CHECK: %[[VAL_2:.*]] = arith.constant -// CHECK: %[[VAL_3:.*]] = arith.constant 2 : i32 -// CHECK: %[[VAL_4:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_5:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_6:.*]] = arith.constant false -// CHECK: %[[VAL_7:.*]] = fir.alloca !fir.class>> -// CHECK: %[[VAL_8:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.class>) -> i1 -// CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.class>) { -// CHECK: %[[VAL_11:.*]] = fir.is_contiguous_box %[[VAL_0]] innermost : (!fir.class>) -> i1 -// CHECK: %[[VAL_12:.*]] = arith.cmpi eq, %[[VAL_11]], %[[VAL_6]] : i1 -// CHECK: %[[VAL_13:.*]] = fir.box_addr %[[VAL_0]] : (!fir.class>) -> !fir.ref>> -// CHECK: %[[VAL_14:.*]] = fir.is_present %[[VAL_13]] : (!fir.ref>>) -> i1 -// CHECK: %[[VAL_15:.*]] = arith.andi %[[VAL_12]], %[[VAL_14]] : i1 -// CHECK: %[[VAL_16:.*]] = fir.if %[[VAL_15]] -> (!fir.class>) { -// CHECK: %[[VAL_17:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_5]] : (!fir.class>, index) -> (index, index, index) -// CHECK: %[[VAL_18:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_4]] : (!fir.class>, index) -> (index, index, index) -// CHECK: %[[VAL_19:.*]] = fir.zero_bits !fir.heap> -// CHECK: %[[VAL_20:.*]] = fir.shape %[[VAL_5]], %[[VAL_5]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_21:.*]] = fir.embox %[[VAL_19]](%[[VAL_20]]) : (!fir.heap>, !fir.shape<2>) -> !fir.class>> -// CHECK: fir.store %[[VAL_21]] to %[[VAL_7]] : !fir.ref>>> -// CHECK: %[[VAL_22:.*]] = fir.declare %[[VAL_7]] {fortran_attrs = #fir.var_attrs, uniq_name = ".repacked"} : (!fir.ref>>>) -> !fir.ref>>> -// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_0]] : (!fir.class>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_23]], %[[VAL_24]], %[[VAL_3]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_5]] : (index) -> i32 -// CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_4]] : (index) -> i64 -// CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_17]]#1 : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_25]], %[[VAL_26]], %[[VAL_27]], %[[VAL_28]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_4]] : (index) -> i32 -// CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_4]] : (index) -> i64 -// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_18]]#1 : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_29]], %[[VAL_30]], %[[VAL_31]], %[[VAL_32]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_33:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_34:.*]] = fir.absent !fir.box -// CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_33]] : (!fir.ref>) -> !fir.ref -// CHECK: %[[VAL_37:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_35]], %{{.*}}, %[[VAL_6]], %[[VAL_34]], %[[VAL_36]], %[[VAL_2]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 -// CHECK: %[[VAL_38:.*]] = fir.load %[[VAL_22]] : !fir.ref>>> -// CHECK: %[[VAL_39:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_38]] : (!fir.class>>) -> !fir.box -// CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_0]] : (!fir.class>) -> !fir.box -// CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_39]] : (!fir.ref>) -> !fir.ref -// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_40]], %[[VAL_41]], %[[VAL_42]], %[[VAL_2]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () -// CHECK: %[[VAL_43:.*]] = fir.shift %[[VAL_17]]#0, %[[VAL_18]]#0 : (index, index) -> !fir.shift<2> -// CHECK: %[[VAL_44:.*]] = fir.rebox %[[VAL_38]](%[[VAL_43]]) : (!fir.class>>, !fir.shift<2>) -> !fir.class> -// CHECK: fir.result %[[VAL_44]] : !fir.class> +// CHECK: %[[VAL_2:.*]] = arith.constant 1 : index +// CHECK: %[[VAL_3:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_4:.*]] = arith.constant false +// CHECK: %[[VAL_5:.*]] = fir.alloca !fir.class>> +// CHECK: %[[VAL_6:.*]] = fir.dummy_scope : !fir.dscope +// CHECK: %[[VAL_7:.*]] = fir.is_present %[[ARG0]] : (!fir.class>) -> i1 +// CHECK: %[[VAL_8:.*]] = fir.if %[[VAL_7]] -> (!fir.class>) { +// CHECK: %[[VAL_9:.*]] = fir.is_contiguous_box %[[ARG0]] innermost : (!fir.class>) -> i1 +// CHECK: %[[VAL_10:.*]] = arith.cmpi eq, %[[VAL_9]], %[[VAL_4]] : i1 +// CHECK: %[[VAL_11:.*]] = fir.box_addr %[[ARG0]] : (!fir.class>) -> !fir.ref>> +// CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_11]] : (!fir.ref>>) -> i1 +// CHECK: %[[VAL_13:.*]] = arith.andi %[[VAL_10]], %[[VAL_12]] : i1 +// CHECK: %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (!fir.class>) { +// CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[ARG0]], %[[VAL_3]] : (!fir.class>, index) -> (index, index, index) +// CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[ARG0]], %[[VAL_2]] : (!fir.class>, index) -> (index, index, index) +// CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_15]]#1, %[[VAL_16]]#1 : (index, index) -> !fir.shape<2> +// CHECK: %[[VAL_18:.*]] = fir.zero_bits !fir.heap> +// CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_18]](%[[VAL_17]]) source_box %[[ARG0]] : (!fir.heap>, !fir.shape<2>, !fir.class>) -> !fir.class>> +// CHECK: fir.store %[[VAL_19]] to %[[VAL_5]] : !fir.ref>>> +// CHECK: %[[VAL_20:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_21:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_22:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_5]] : (!fir.ref>>>) -> !fir.ref> +// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_20]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_21]] : (!fir.ref>) -> !fir.ref +// CHECK: %[[VAL_26:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_23]], %[[VAL_24]], %[[VAL_4]], %[[VAL_22]], %[[VAL_25]], %[[VAL_1]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 +// CHECK: %[[VAL_27:.*]] = fir.load %[[VAL_5]] : !fir.ref>>> +// CHECK: %[[VAL_28:.*]] = fir.declare %[[VAL_27]] {uniq_name = ".repacked"} : (!fir.class>>) -> !fir.class>> +// CHECK: %[[VAL_29:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_28]] : (!fir.class>>) -> !fir.box +// CHECK: %[[VAL_31:.*]] = fir.convert %[[ARG0]] : (!fir.class>) -> !fir.box +// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_29]] : (!fir.ref>) -> !fir.ref +// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_30]], %[[VAL_31]], %[[VAL_32]], %[[VAL_1]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () +// CHECK: %[[VAL_33:.*]] = fir.shift %[[VAL_15]]#0, %[[VAL_16]]#0 : (index, index) -> !fir.shift<2> +// CHECK: %[[VAL_34:.*]] = fir.rebox %[[VAL_28]](%[[VAL_33]]) : (!fir.class>>, !fir.shift<2>) -> !fir.class> +// CHECK: fir.result %[[VAL_34]] : !fir.class> // CHECK: } else { -// CHECK: fir.result %[[VAL_0]] : !fir.class> +// CHECK: fir.result %[[ARG0]] : !fir.class> // CHECK: } -// CHECK: fir.result %[[VAL_16]] : !fir.class> +// CHECK: fir.result %[[VAL_14]] : !fir.class> // CHECK: } else { -// CHECK: fir.result %[[VAL_0]] : !fir.class> +// CHECK: fir.result %[[ARG0]] : !fir.class> // CHECK: } -// CHECK: %[[VAL_45:.*]] = fir.declare %[[VAL_10]] dummy_scope %[[VAL_8]] {uniq_name = "_QFtest7Ex"} : (!fir.class>, !fir.dscope) -> !fir.class> -// CHECK: %[[VAL_46:.*]] = fir.is_present %[[VAL_0]] : (!fir.class>) -> i1 -// CHECK: fir.if %[[VAL_46]] { -// CHECK: %[[VAL_47:.*]] = fir.box_addr %[[VAL_10]] : (!fir.class>) -> !fir.heap> -// CHECK: %[[VAL_49:.*]] = fir.box_addr %[[VAL_0]] : (!fir.class>) -> !fir.heap> -// CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_47]] : (!fir.heap>) -> index -// CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (!fir.heap>) -> index -// CHECK: %[[VAL_51:.*]] = arith.cmpi ne, %[[VAL_48]], %[[VAL_50]] : index -// CHECK: fir.if %[[VAL_51]] { -// CHECK: %[[VAL_52:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_0]] : (!fir.class>) -> !fir.box -// CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_10]] : (!fir.class>) -> !fir.box -// CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_52]] : (!fir.ref>) -> !fir.ref -// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_53]], %[[VAL_54]], %[[VAL_55]], %[[VAL_1]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () -// CHECK: fir.freemem %[[VAL_47]] : !fir.heap> +// CHECK: %[[VAL_35:.*]] = fir.declare %[[VAL_8]] dummy_scope %[[VAL_6]] {uniq_name = "_QFtest7Ex"} : (!fir.class>, !fir.dscope) -> !fir.class> +// CHECK: %[[VAL_36:.*]] = fir.is_present %[[ARG0]] : (!fir.class>) -> i1 +// CHECK: fir.if %[[VAL_36]] { +// CHECK: %[[VAL_37:.*]] = fir.box_addr %[[VAL_8]] : (!fir.class>) -> !fir.heap> +// CHECK: %[[VAL_38:.*]] = fir.box_addr %[[ARG0]] : (!fir.class>) -> !fir.heap> +// CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (!fir.heap>) -> index +// CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_38]] : (!fir.heap>) -> index +// CHECK: %[[VAL_41:.*]] = arith.cmpi ne, %[[VAL_39]], %[[VAL_40]] : index +// CHECK: fir.if %[[VAL_41]] { +// CHECK: %[[VAL_42:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_43:.*]] = fir.convert %[[ARG0]] : (!fir.class>) -> !fir.box +// CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_8]] : (!fir.class>) -> !fir.box +// CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_42]] : (!fir.ref>) -> !fir.ref +// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_43]], %[[VAL_44]], %[[VAL_45]], %[[VAL_0]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () +// CHECK: fir.freemem %[[VAL_37]] : !fir.heap> // CHECK: } // CHECK: } // CHECK: return @@ -1062,79 +1026,67 @@ func.func @_QPtest7_stack(%arg0: !fir.class> {fir.bindc_nam return } // CHECK-LABEL: func.func @_QPtest7_stack( -// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.class> {fir.bindc_name = "x"}) { +// CHECK-SAME: %[[ARG0:.*]]: !fir.class> {fir.bindc_name = "x"}) { +// CHECK: %[[VAL_0:.*]] = arith.constant // CHECK: %[[VAL_1:.*]] = arith.constant -// CHECK: %[[VAL_2:.*]] = arith.constant -// CHECK: %[[VAL_3:.*]] = arith.constant 2 : i32 -// CHECK: %[[VAL_4:.*]] = arith.constant 1 : index -// CHECK: %[[VAL_5:.*]] = arith.constant 0 : index -// CHECK: %[[VAL_6:.*]] = arith.constant false -// CHECK: %[[VAL_7:.*]] = fir.alloca !fir.class>> -// CHECK: %[[VAL_8:.*]] = fir.dummy_scope : !fir.dscope -// CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.class>) -> i1 -// CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.class>) { -// CHECK: %[[VAL_11:.*]] = fir.is_contiguous_box %[[VAL_0]] innermost : (!fir.class>) -> i1 -// CHECK: %[[VAL_12:.*]] = arith.cmpi eq, %[[VAL_11]], %[[VAL_6]] : i1 -// CHECK: %[[VAL_13:.*]] = fir.box_addr %[[VAL_0]] : (!fir.class>) -> !fir.ref>> -// CHECK: %[[VAL_14:.*]] = fir.is_present %[[VAL_13]] : (!fir.ref>>) -> i1 -// CHECK: %[[VAL_15:.*]] = arith.andi %[[VAL_12]], %[[VAL_14]] : i1 -// CHECK: %[[VAL_16:.*]] = fir.if %[[VAL_15]] -> (!fir.class>) { -// CHECK: %[[VAL_17:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_5]] : (!fir.class>, index) -> (index, index, index) -// CHECK: %[[VAL_18:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_4]] : (!fir.class>, index) -> (index, index, index) -// CHECK: %[[VAL_19:.*]] = fir.zero_bits !fir.heap> -// CHECK: %[[VAL_20:.*]] = fir.shape %[[VAL_5]], %[[VAL_5]] : (index, index) -> !fir.shape<2> -// CHECK: %[[VAL_21:.*]] = fir.embox %[[VAL_19]](%[[VAL_20]]) : (!fir.heap>, !fir.shape<2>) -> !fir.class>> -// CHECK: fir.store %[[VAL_21]] to %[[VAL_7]] : !fir.ref>>> -// CHECK: %[[VAL_22:.*]] = fir.declare %[[VAL_7]] {fortran_attrs = #fir.var_attrs, uniq_name = ".repacked"} : (!fir.ref>>>) -> !fir.ref>>> -// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_0]] : (!fir.class>) -> !fir.box -// CHECK: fir.call @_FortranAAllocatableApplyMold(%[[VAL_23]], %[[VAL_24]], %[[VAL_3]]) : (!fir.ref>, !fir.box, i32) -> () -// CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_5]] : (index) -> i32 -// CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_4]] : (index) -> i64 -// CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_17]]#1 : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_25]], %[[VAL_26]], %[[VAL_27]], %[[VAL_28]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_4]] : (index) -> i32 -// CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_4]] : (index) -> i64 -// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_18]]#1 : (index) -> i64 -// CHECK: fir.call @_FortranAAllocatableSetBounds(%[[VAL_29]], %[[VAL_30]], %[[VAL_31]], %[[VAL_32]]) : (!fir.ref>, i32, i64, i64) -> () -// CHECK: %[[VAL_33:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_34:.*]] = fir.absent !fir.box -// CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_7]] : (!fir.ref>>>) -> !fir.ref> -// CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_33]] : (!fir.ref>) -> !fir.ref -// CHECK: %[[VAL_37:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_35]], %{{.*}}, %[[VAL_6]], %[[VAL_34]], %[[VAL_36]], %[[VAL_2]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 -// CHECK: %[[VAL_38:.*]] = fir.load %[[VAL_22]] : !fir.ref>>> -// CHECK: %[[VAL_39:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_38]] : (!fir.class>>) -> !fir.box -// CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_0]] : (!fir.class>) -> !fir.box -// CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_39]] : (!fir.ref>) -> !fir.ref -// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_40]], %[[VAL_41]], %[[VAL_42]], %[[VAL_2]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () -// CHECK: %[[VAL_43:.*]] = fir.shift %[[VAL_17]]#0, %[[VAL_18]]#0 : (index, index) -> !fir.shift<2> -// CHECK: %[[VAL_44:.*]] = fir.rebox %[[VAL_38]](%[[VAL_43]]) : (!fir.class>>, !fir.shift<2>) -> !fir.class> -// CHECK: fir.result %[[VAL_44]] : !fir.class> +// CHECK: %[[VAL_2:.*]] = arith.constant 1 : index +// CHECK: %[[VAL_3:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_4:.*]] = arith.constant false +// CHECK: %[[VAL_5:.*]] = fir.alloca !fir.class>> +// CHECK: %[[VAL_6:.*]] = fir.dummy_scope : !fir.dscope +// CHECK: %[[VAL_7:.*]] = fir.is_present %[[ARG0]] : (!fir.class>) -> i1 +// CHECK: %[[VAL_8:.*]] = fir.if %[[VAL_7]] -> (!fir.class>) { +// CHECK: %[[VAL_9:.*]] = fir.is_contiguous_box %[[ARG0]] innermost : (!fir.class>) -> i1 +// CHECK: %[[VAL_10:.*]] = arith.cmpi eq, %[[VAL_9]], %[[VAL_4]] : i1 +// CHECK: %[[VAL_11:.*]] = fir.box_addr %[[ARG0]] : (!fir.class>) -> !fir.ref>> +// CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_11]] : (!fir.ref>>) -> i1 +// CHECK: %[[VAL_13:.*]] = arith.andi %[[VAL_10]], %[[VAL_12]] : i1 +// CHECK: %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (!fir.class>) { +// CHECK: %[[VAL_15:.*]]:3 = fir.box_dims %[[ARG0]], %[[VAL_3]] : (!fir.class>, index) -> (index, index, index) +// CHECK: %[[VAL_16:.*]]:3 = fir.box_dims %[[ARG0]], %[[VAL_2]] : (!fir.class>, index) -> (index, index, index) +// CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_15]]#1, %[[VAL_16]]#1 : (index, index) -> !fir.shape<2> +// CHECK: %[[VAL_18:.*]] = fir.zero_bits !fir.heap> +// CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_18]](%[[VAL_17]]) source_box %[[ARG0]] : (!fir.heap>, !fir.shape<2>, !fir.class>) -> !fir.class>> +// CHECK: fir.store %[[VAL_19]] to %[[VAL_5]] : !fir.ref>>> +// CHECK: %[[VAL_20:.*]] = fir.zero_bits !fir.ref +// CHECK: %[[VAL_21:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_22:.*]] = fir.absent !fir.box +// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_5]] : (!fir.ref>>>) -> !fir.ref> +// CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_20]] : (!fir.ref) -> !fir.ref +// CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_21]] : (!fir.ref>) -> !fir.ref +// CHECK: %[[VAL_26:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_23]], %[[VAL_24]], %[[VAL_4]], %[[VAL_22]], %[[VAL_25]], %[[VAL_1]]) : (!fir.ref>, !fir.ref, i1, !fir.box, !fir.ref, i32) -> i32 +// CHECK: %[[VAL_27:.*]] = fir.load %[[VAL_5]] : !fir.ref>>> +// CHECK: %[[VAL_28:.*]] = fir.declare %[[VAL_27]] {uniq_name = ".repacked"} : (!fir.class>>) -> !fir.class>> +// CHECK: %[[VAL_29:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_28]] : (!fir.class>>) -> !fir.box +// CHECK: %[[VAL_31:.*]] = fir.convert %[[ARG0]] : (!fir.class>) -> !fir.box +// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_29]] : (!fir.ref>) -> !fir.ref +// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_30]], %[[VAL_31]], %[[VAL_32]], %[[VAL_1]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () +// CHECK: %[[VAL_33:.*]] = fir.shift %[[VAL_15]]#0, %[[VAL_16]]#0 : (index, index) -> !fir.shift<2> +// CHECK: %[[VAL_34:.*]] = fir.rebox %[[VAL_28]](%[[VAL_33]]) : (!fir.class>>, !fir.shift<2>) -> !fir.class> +// CHECK: fir.result %[[VAL_34]] : !fir.class> // CHECK: } else { -// CHECK: fir.result %[[VAL_0]] : !fir.class> +// CHECK: fir.result %[[ARG0]] : !fir.class> // CHECK: } -// CHECK: fir.result %[[VAL_16]] : !fir.class> +// CHECK: fir.result %[[VAL_14]] : !fir.class> // CHECK: } else { -// CHECK: fir.result %[[VAL_0]] : !fir.class> +// CHECK: fir.result %[[ARG0]] : !fir.class> // CHECK: } -// CHECK: %[[VAL_45:.*]] = fir.declare %[[VAL_10]] dummy_scope %[[VAL_8]] {uniq_name = "_QFtest7Ex"} : (!fir.class>, !fir.dscope) -> !fir.class> -// CHECK: %[[VAL_46:.*]] = fir.is_present %[[VAL_0]] : (!fir.class>) -> i1 -// CHECK: fir.if %[[VAL_46]] { -// CHECK: %[[VAL_47:.*]] = fir.box_addr %[[VAL_10]] : (!fir.class>) -> !fir.heap> -// CHECK: %[[VAL_49:.*]] = fir.box_addr %[[VAL_0]] : (!fir.class>) -> !fir.heap> -// CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_47]] : (!fir.heap>) -> index -// CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (!fir.heap>) -> index -// CHECK: %[[VAL_51:.*]] = arith.cmpi ne, %[[VAL_48]], %[[VAL_50]] : index -// CHECK: fir.if %[[VAL_51]] { -// CHECK: %[[VAL_52:.*]] = fir.address_of(@{{_QQcl.*}} -// CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_0]] : (!fir.class>) -> !fir.box -// CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_10]] : (!fir.class>) -> !fir.box -// CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_52]] : (!fir.ref>) -> !fir.ref -// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_53]], %[[VAL_54]], %[[VAL_55]], %[[VAL_1]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () -// CHECK: fir.freemem %[[VAL_47]] : !fir.heap> +// CHECK: %[[VAL_35:.*]] = fir.declare %[[VAL_8]] dummy_scope %[[VAL_6]] {uniq_name = "_QFtest7Ex"} : (!fir.class>, !fir.dscope) -> !fir.class> +// CHECK: %[[VAL_36:.*]] = fir.is_present %[[ARG0]] : (!fir.class>) -> i1 +// CHECK: fir.if %[[VAL_36]] { +// CHECK: %[[VAL_37:.*]] = fir.box_addr %[[VAL_8]] : (!fir.class>) -> !fir.heap> +// CHECK: %[[VAL_38:.*]] = fir.box_addr %[[ARG0]] : (!fir.class>) -> !fir.heap> +// CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (!fir.heap>) -> index +// CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_38]] : (!fir.heap>) -> index +// CHECK: %[[VAL_41:.*]] = arith.cmpi ne, %[[VAL_39]], %[[VAL_40]] : index +// CHECK: fir.if %[[VAL_41]] { +// CHECK: %[[VAL_42:.*]] = fir.address_of(@{{_QQcl.*}}) : !fir.ref> +// CHECK: %[[VAL_43:.*]] = fir.convert %[[ARG0]] : (!fir.class>) -> !fir.box +// CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_8]] : (!fir.class>) -> !fir.box +// CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_42]] : (!fir.ref>) -> !fir.ref +// CHECK: fir.call @_FortranAShallowCopyDirect(%[[VAL_43]], %[[VAL_44]], %[[VAL_45]], %[[VAL_0]]) : (!fir.box, !fir.box, !fir.ref, i32) -> () +// CHECK: fir.freemem %[[VAL_37]] : !fir.heap> // CHECK: } // CHECK: } // CHECK: return