diff --git a/flang/examples/FeatureList/FeatureList.cpp b/flang/examples/FeatureList/FeatureList.cpp index 3ca92da4f6467..28689b5d3c4b0 100644 --- a/flang/examples/FeatureList/FeatureList.cpp +++ b/flang/examples/FeatureList/FeatureList.cpp @@ -410,10 +410,12 @@ struct NodeVisitor { READ_FEATURE(LetterSpec) READ_FEATURE(LiteralConstant) READ_FEATURE(IntLiteralConstant) + READ_FEATURE(ReduceOperation) READ_FEATURE(LocalitySpec) READ_FEATURE(LocalitySpec::DefaultNone) READ_FEATURE(LocalitySpec::Local) READ_FEATURE(LocalitySpec::LocalInit) + READ_FEATURE(LocalitySpec::Reduce) READ_FEATURE(LocalitySpec::Shared) READ_FEATURE(LockStmt) READ_FEATURE(LockStmt::LockStat) diff --git a/flang/include/flang/Optimizer/Dialect/FIRAttr.td b/flang/include/flang/Optimizer/Dialect/FIRAttr.td index f8b3fb861cc62..5404d189a4863 100644 --- a/flang/include/flang/Optimizer/Dialect/FIRAttr.td +++ b/flang/include/flang/Optimizer/Dialect/FIRAttr.td @@ -67,6 +67,36 @@ def fir_BoxFieldAttr : I32EnumAttr< let cppNamespace = "fir"; } +def fir_ReduceOperationEnum : I32BitEnumAttr<"ReduceOperationEnum", + "intrinsic operations and functions supported by DO CONCURRENT REDUCE", + [ + I32BitEnumAttrCaseBit<"Add", 0, "add">, + I32BitEnumAttrCaseBit<"Multiply", 1, "multiply">, + I32BitEnumAttrCaseBit<"AND", 2, "and">, + I32BitEnumAttrCaseBit<"OR", 3, "or">, + I32BitEnumAttrCaseBit<"EQV", 4, "eqv">, + I32BitEnumAttrCaseBit<"NEQV", 5, "neqv">, + I32BitEnumAttrCaseBit<"MAX", 6, "max">, + I32BitEnumAttrCaseBit<"MIN", 7, "min">, + I32BitEnumAttrCaseBit<"IAND", 8, "iand">, + I32BitEnumAttrCaseBit<"IOR", 9, "ior">, + I32BitEnumAttrCaseBit<"EIOR", 10, "eior"> + ]> { + let separator = ", "; + let cppNamespace = "::fir"; + let printBitEnumPrimaryGroups = 1; +} + +def fir_ReduceAttr : fir_Attr<"Reduce"> { + let mnemonic = "reduce_attr"; + + let parameters = (ins + "ReduceOperationEnum":$reduce_operation + ); + + let assemblyFormat = "`<` $reduce_operation `>`"; +} + // mlir::SideEffects::Resource for modelling operations which add debugging information def DebuggingResource : Resource<"::fir::DebuggingResource">; diff --git a/flang/include/flang/Optimizer/Dialect/FIROps.td b/flang/include/flang/Optimizer/Dialect/FIROps.td index 64c5e360b28f7..b9fd4fed6f13d 100644 --- a/flang/include/flang/Optimizer/Dialect/FIROps.td +++ b/flang/include/flang/Optimizer/Dialect/FIROps.td @@ -2062,8 +2062,37 @@ class region_Op traits = []> : let hasVerifier = 1; } -def fir_DoLoopOp : region_Op<"do_loop", - [DeclareOpInterfaceMethods { + let summary = "Represent reduction semantics for the reduce clause"; + + let description = [{ + Given the address of a variable, creates reduction information for the + reduce clause. + + ``` + %17 = fir.reduce %8 {name = "sum"} : (!fir.ref) -> !fir.ref + fir.do_loop ... unordered reduce(#fir.reduce_attr -> %17 : !fir.ref) ... + ``` + + This operation is typically used for DO CONCURRENT REDUCE clause. The memref + operand may have a unique name while the `name` attribute preserves the + original name of a reduction variable. + }]; + + let arguments = (ins + AnyRefOrBoxLike:$memref, + Builtin_StringAttr:$name + ); + + let results = (outs AnyRefOrBox); + + let assemblyFormat = [{ + operands attr-dict `:` functional-type(operands, results) + }]; +} + +def fir_DoLoopOp : region_Op<"do_loop", [AttrSizedOperandSegments, + DeclareOpInterfaceMethods]> { let summary = "generalized loop operation"; let description = [{ @@ -2095,7 +2124,9 @@ def fir_DoLoopOp : region_Op<"do_loop", Index:$step, Variadic:$initArgs, OptionalAttr:$unordered, - OptionalAttr:$finalValue + OptionalAttr:$finalValue, + Variadic:$reduceOperands, + OptionalAttr:$reduceAttrs ); let results = (outs Variadic:$results); let regions = (region SizedRegion<1>:$region); @@ -2106,6 +2137,8 @@ def fir_DoLoopOp : region_Op<"do_loop", "mlir::Value":$step, CArg<"bool", "false">:$unordered, CArg<"bool", "false">:$finalCountValue, CArg<"mlir::ValueRange", "std::nullopt">:$iterArgs, + CArg<"mlir::ValueRange", "std::nullopt">:$reduceOperands, + CArg<"llvm::ArrayRef", "{}">:$reduceAttrs, CArg<"llvm::ArrayRef", "{}">:$attributes)> ]; @@ -2118,11 +2151,13 @@ def fir_DoLoopOp : region_Op<"do_loop", return getBody()->getArguments().drop_front(); } mlir::Operation::operand_range getIterOperands() { - return getOperands().drop_front(getNumControlOperands()); + return getOperands().drop_front(getNumControlOperands()) + .take_front(getNumIterOperands()); } llvm::MutableArrayRef getInitsMutable() { return - getOperation()->getOpOperands().drop_front(getNumControlOperands()); + getOperation()->getOpOperands().drop_front(getNumControlOperands()) + .take_front(getNumIterOperands()); } void setLowerBound(mlir::Value bound) { (*this)->setOperand(0, bound); } @@ -2131,17 +2166,31 @@ def fir_DoLoopOp : region_Op<"do_loop", /// Number of region arguments for loop-carried values unsigned getNumRegionIterArgs() { - return getBody()->getNumArguments() - 1; + return getBody()->getNumArguments() - (1 + getNumReduceOperands()); } /// Number of operands controlling the loop: lb, ub, step unsigned getNumControlOperands() { return 3; } /// Does the operation hold operands for loop-carried values bool hasIterOperands() { - return (*this)->getNumOperands() > getNumControlOperands(); + return getNumIterOperands() > 0; + } + /// Does the operation hold operands for reduction variables + bool hasReduceOperands() { + return getNumReduceOperands() > 0; + } + /// Get Number of variadic operands + unsigned getNumOperands(unsigned idx) { + auto segments = (*this)->getAttrOfType( + getOperandSegmentSizeAttr()); + return static_cast(segments[idx]); } /// Get Number of loop-carried values unsigned getNumIterOperands() { - return (*this)->getNumOperands() - getNumControlOperands(); + return getNumOperands(3); + } + // Get Number of reduction operands + unsigned getNumReduceOperands() { + return getNumOperands(4); } /// Get the body of the loop diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h index 68ae50c312cde..15948bb073664 100644 --- a/flang/include/flang/Parser/dump-parse-tree.h +++ b/flang/include/flang/Parser/dump-parse-tree.h @@ -436,10 +436,12 @@ class ParseTreeDumper { NODE(parser, LetterSpec) NODE(parser, LiteralConstant) NODE(parser, IntLiteralConstant) + NODE(parser, ReduceOperation) NODE(parser, LocalitySpec) NODE(LocalitySpec, DefaultNone) NODE(LocalitySpec, Local) NODE(LocalitySpec, LocalInit) + NODE(LocalitySpec, Reduce) NODE(LocalitySpec, Shared) NODE(parser, LockStmt) NODE(LockStmt, LockStat) diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h index 0a40aa8b8f616..68a4319a85047 100644 --- a/flang/include/flang/Parser/parse-tree.h +++ b/flang/include/flang/Parser/parse-tree.h @@ -1870,6 +1870,13 @@ struct ProcComponentRef { WRAPPER_CLASS_BOILERPLATE(ProcComponentRef, Scalar); }; +// R1522 procedure-designator -> +// procedure-name | proc-component-ref | data-ref % binding-name +struct ProcedureDesignator { + UNION_CLASS_BOILERPLATE(ProcedureDesignator); + std::variant u; +}; + // R914 coindexed-named-object -> data-ref struct CoindexedNamedObject { BOILERPLATE(CoindexedNamedObject); @@ -2236,16 +2243,29 @@ struct ConcurrentHeader { t; }; +// F'2023 R1131 reduce-operation -> +// + | * | .AND. | .OR. | .EQV. | .NEQV. | +// MAX | MIN | IAND | IOR | IEOR +struct ReduceOperation { + UNION_CLASS_BOILERPLATE(ReduceOperation); + std::variant u; +}; + // R1130 locality-spec -> // LOCAL ( variable-name-list ) | LOCAL_INIT ( variable-name-list ) | +// REDUCE ( reduce-operation : variable-name-list ) | // SHARED ( variable-name-list ) | DEFAULT ( NONE ) struct LocalitySpec { UNION_CLASS_BOILERPLATE(LocalitySpec); WRAPPER_CLASS(Local, std::list); WRAPPER_CLASS(LocalInit, std::list); + struct Reduce { + TUPLE_CLASS_BOILERPLATE(Reduce); + std::tuple> t; + }; WRAPPER_CLASS(Shared, std::list); EMPTY_CLASS(DefaultNone); - std::variant u; + std::variant u; }; // R1123 loop-control -> @@ -3180,13 +3200,6 @@ WRAPPER_CLASS(ExternalStmt, std::list); // R1519 intrinsic-stmt -> INTRINSIC [::] intrinsic-procedure-name-list WRAPPER_CLASS(IntrinsicStmt, std::list); -// R1522 procedure-designator -> -// procedure-name | proc-component-ref | data-ref % binding-name -struct ProcedureDesignator { - UNION_CLASS_BOILERPLATE(ProcedureDesignator); - std::variant u; -}; - // R1525 alt-return-spec -> * label WRAPPER_CLASS(AltReturnSpec, Label); diff --git a/flang/include/flang/Semantics/symbol.h b/flang/include/flang/Semantics/symbol.h index 50f7b68d80cb1..8ccf93c803845 100644 --- a/flang/include/flang/Semantics/symbol.h +++ b/flang/include/flang/Semantics/symbol.h @@ -714,6 +714,7 @@ class Symbol { CrayPointer, CrayPointee, LocalityLocal, // named in LOCAL locality-spec LocalityLocalInit, // named in LOCAL_INIT locality-spec + LocalityReduce, // named in REDUCE locality-spec LocalityShared, // named in SHARED locality-spec InDataStmt, // initialized in a DATA statement, =>object, or /init/ InNamelist, // in a Namelist group diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp index afbc1122de868..b9d4bcc0338fb 100644 --- a/flang/lib/Lower/Bridge.cpp +++ b/flang/lib/Lower/Bridge.cpp @@ -101,7 +101,7 @@ struct IncrementLoopInfo { bool hasLocalitySpecs() const { return !localSymList.empty() || !localInitSymList.empty() || - !sharedSymList.empty(); + !reduceSymList.empty() || !sharedSymList.empty(); } // Data members common to both structured and unstructured loops. @@ -113,6 +113,8 @@ struct IncrementLoopInfo { bool isUnordered; // do concurrent, forall llvm::SmallVector localSymList; llvm::SmallVector localInitSymList; + llvm::SmallVector> reduceSymList; llvm::SmallVector sharedSymList; mlir::Value loopVariable = nullptr; @@ -1696,6 +1698,62 @@ class FirConverter : public Fortran::lower::AbstractConverter { builder->create(loc); } + fir::ReduceOperationEnum getReduceOperationEnum( + const Fortran::parser::ReduceOperation &rOpr) const { + fir::ReduceOperationEnum reduce_operation = fir::ReduceOperationEnum::Add; + using IntrinsicOperator = + Fortran::parser::DefinedOperator::IntrinsicOperator; + std::visit( + Fortran::common::visitors{ + [&](const Fortran::parser::DefinedOperator &dOpr) { + const auto &intrinsicOp{std::get(dOpr.u)}; + switch (intrinsicOp) { + case IntrinsicOperator::Add: + reduce_operation = fir::ReduceOperationEnum::Add; + return; + case IntrinsicOperator::Multiply: + reduce_operation = fir::ReduceOperationEnum::Multiply; + return; + case IntrinsicOperator::AND: + reduce_operation = fir::ReduceOperationEnum::AND; + return; + case IntrinsicOperator::OR: + reduce_operation = fir::ReduceOperationEnum::OR; + return; + case IntrinsicOperator::EQV: + reduce_operation = fir::ReduceOperationEnum::EQV; + return; + case IntrinsicOperator::NEQV: + reduce_operation = fir::ReduceOperationEnum::NEQV; + return; + default: + return; + } + }, + [&](const Fortran::parser::ProcedureDesignator &procD) { + const Fortran::parser::Name *name{ + std::get_if(&procD.u) + }; + if (name && name->symbol) { + const Fortran::parser::CharBlock + &realName{name->symbol->GetUltimate().name()}; + if (realName == "max") + reduce_operation = fir::ReduceOperationEnum::MAX; + else if (realName == "min") + reduce_operation = fir::ReduceOperationEnum::MIN; + else if (realName == "iand") + reduce_operation = fir::ReduceOperationEnum::IAND; + else if (realName == "ior") + reduce_operation = fir::ReduceOperationEnum::IOR; + else if (realName == "ieor") + reduce_operation = fir::ReduceOperationEnum::EIOR; + } + } + }, + rOpr.u); + return fir::ReduceOperationEnum(reduce_operation); + } + /// Collect DO CONCURRENT or FORALL loop control information. IncrementLoopNestInfo getConcurrentControl( const Fortran::parser::ConcurrentHeader &header, @@ -1718,6 +1776,15 @@ class FirConverter : public Fortran::lower::AbstractConverter { std::get_if(&x.u)) for (const Fortran::parser::Name &x : localInitList->v) info.localInitSymList.push_back(x.symbol); + if (const auto *reduceList = + std::get_if(&x.u)) { + fir::ReduceOperationEnum reduce_operation = getReduceOperationEnum( + std::get(reduceList->t)); + for (const Fortran::parser::Name &x : + std::get>(reduceList->t)) { + info.reduceSymList.push_back(std::make_pair(reduce_operation, x.symbol)); + } + } if (const auto *sharedList = std::get_if(&x.u)) for (const Fortran::parser::Name &x : sharedList->v) @@ -1910,9 +1977,26 @@ class FirConverter : public Fortran::lower::AbstractConverter { mlir::Type loopVarType = info.getLoopVariableType(); mlir::Value loopValue; if (info.isUnordered) { + llvm::SmallVector reduceOperands; + llvm::SmallVector reduceAttrs; + // Create DO CONCURRENT reduce operations and attributes + for (const auto reduceSym : info.reduceSymList) { + const fir::ReduceOperationEnum reduce_operation = reduceSym.first; + const Fortran::semantics::Symbol *sym = reduceSym.second; + fir::ExtendedValue exv = getSymbolExtendedValue(*sym, nullptr); + auto reduce_op = builder->create( + loc, fir::ReferenceType::get(genType(*sym)), fir::getBase(exv), + builder->getStringAttr(sym->name().ToString())); + reduceOperands.push_back(reduce_op); + auto reduce_attr = fir::ReduceAttr::get( + builder->getContext(), reduce_operation); + reduceAttrs.push_back(reduce_attr); + } // The loop variable value is explicitly updated. info.doLoop = builder->create( - loc, lowerValue, upperValue, stepValue, /*unordered=*/true); + loc, lowerValue, upperValue, stepValue, /*unordered=*/true, + /*finalCountValue=*/false, /*iterArgs=*/std::nullopt, + llvm::ArrayRef(reduceOperands), reduceAttrs); builder->setInsertionPointToStart(info.doLoop.getBody()); loopValue = builder->createConvert(loc, loopVarType, info.doLoop.getInductionVar()); diff --git a/flang/lib/Optimizer/Dialect/FIRAttr.cpp b/flang/lib/Optimizer/Dialect/FIRAttr.cpp index 9ea3a0568f691..2a688c144c069 100644 --- a/flang/lib/Optimizer/Dialect/FIRAttr.cpp +++ b/flang/lib/Optimizer/Dialect/FIRAttr.cpp @@ -297,8 +297,8 @@ void fir::printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr, void FIROpsDialect::registerAttributes() { addAttributes(); + LowerBoundAttr, PointIntervalAttr, RealAttr, ReduceAttr, + SubclassAttr, UpperBoundAttr, CUDADataAttributeAttr, + CUDAProcAttributeAttr, CUDALaunchBoundsAttr, + CUDAClusterDimsAttr, CUDADataTransferKindAttr>(); } diff --git a/flang/lib/Optimizer/Dialect/FIROps.cpp b/flang/lib/Optimizer/Dialect/FIROps.cpp index edf7f7f4b1a96..a8c923804d140 100644 --- a/flang/lib/Optimizer/Dialect/FIROps.cpp +++ b/flang/lib/Optimizer/Dialect/FIROps.cpp @@ -2065,9 +2065,15 @@ void fir::DoLoopOp::build(mlir::OpBuilder &builder, mlir::OperationState &result, mlir::Value lb, mlir::Value ub, mlir::Value step, bool unordered, bool finalCountValue, mlir::ValueRange iterArgs, + mlir::ValueRange reduceOperands, + llvm::ArrayRef reduceAttrs, llvm::ArrayRef attributes) { result.addOperands({lb, ub, step}); result.addOperands(iterArgs); + result.addOperands(reduceOperands); + result.addAttribute(getOperandSegmentSizeAttr(), builder.getDenseI32ArrayAttr( + {1, 1, 1, static_cast(iterArgs.size()), + static_cast(reduceOperands.size())})); if (finalCountValue) { result.addTypes(builder.getIndexType()); result.addAttribute(getFinalValueAttrName(result.name), @@ -2086,6 +2092,9 @@ void fir::DoLoopOp::build(mlir::OpBuilder &builder, if (unordered) result.addAttribute(getUnorderedAttrName(result.name), builder.getUnitAttr()); + if (!reduceAttrs.empty()) + result.addAttribute(getReduceAttrsAttrName(result.name), + builder.getArrayAttr(reduceAttrs)); result.addAttributes(attributes); } @@ -2113,26 +2122,55 @@ mlir::ParseResult fir::DoLoopOp::parse(mlir::OpAsmParser &parser, // Parse the optional initial iteration arguments. llvm::SmallVector regionArgs; - llvm::SmallVector operands; + llvm::SmallVector iterOperands; llvm::SmallVector argTypes; bool prependCount = false; regionArgs.push_back(inductionVariable); if (succeeded(parser.parseOptionalKeyword("iter_args"))) { // Parse assignment list and results type list. - if (parser.parseAssignmentList(regionArgs, operands) || + if (parser.parseAssignmentList(regionArgs, iterOperands) || parser.parseArrowTypeList(result.types)) return mlir::failure(); - if (result.types.size() == operands.size() + 1) + if (result.types.size() == iterOperands.size() + 1) prependCount = true; // Resolve input operands. llvm::ArrayRef resTypes = result.types; for (auto operand_type : - llvm::zip(operands, prependCount ? resTypes.drop_front() : resTypes)) + llvm::zip(iterOperands, prependCount ? resTypes.drop_front() : resTypes)) if (parser.resolveOperand(std::get<0>(operand_type), std::get<1>(operand_type), result.operands)) return mlir::failure(); - } else if (succeeded(parser.parseOptionalArrow())) { + } + + // Parse the reduction arguments. + llvm::SmallVector reduceOperands; + llvm::SmallVector reduceArgTypes; + if (succeeded(parser.parseOptionalKeyword("reduce"))) { + // Parse reduction attributes and variables. + llvm::SmallVector attributes; + if (failed(parser.parseCommaSeparatedList(mlir::AsmParser::Delimiter::Paren, + [&]() { + if (parser.parseAttribute(attributes.emplace_back()) || + parser.parseArrow() || + parser.parseOperand(reduceOperands.emplace_back()) || + parser.parseColonType(reduceArgTypes.emplace_back())) + return mlir::failure(); + return mlir::success(); + }))) + return mlir::failure(); + // Resolve input operands. + for (auto operand_type : llvm::zip(reduceOperands, reduceArgTypes)) + if (parser.resolveOperand(std::get<0>(operand_type), + std::get<1>(operand_type), result.operands)) + return mlir::failure(); + llvm::SmallVector arrayAttr(attributes.begin(), + attributes.end()); + result.addAttribute(getReduceAttrsAttrName(result.name), + builder.getArrayAttr(arrayAttr)); + } + + if (!iterOperands.size() && succeeded(parser.parseOptionalArrow())) { if (parser.parseKeyword("index")) return mlir::failure(); result.types.push_back(indexType); @@ -2215,6 +2253,11 @@ mlir::LogicalResult fir::DoLoopOp::verify() { i++; } + auto reduceAttrs = getReduceAttrsAttr(); + if (getNumReduceOperands() != (reduceAttrs ? reduceAttrs.size() : 0)) + return emitOpError( + "mismatch in number of reduction variables and reduction attributes"); + return mlir::success(); } @@ -2233,12 +2276,24 @@ void fir::DoLoopOp::print(mlir::OpAsmPrinter &p) { }); p << ") -> (" << getResultTypes() << ')'; printBlockTerminators = true; - } else if (getFinalValue()) { + } + if (hasReduceOperands()) { + p << " reduce("; + auto attrs = getReduceAttrsAttr(); + auto operands = getReduceOperands(); + llvm::interleaveComma(llvm::zip(attrs, operands), p, [&](auto it) { + p << std::get<0>(it) << " -> " << std::get<1>(it) << " : " + << std::get<1>(it).getType(); + }); + p << ')'; + printBlockTerminators = true; + } + if (!hasIterOperands() && getFinalValue()) { p << " -> " << getResultTypes(); printBlockTerminators = true; } - p.printOptionalAttrDictWithKeyword((*this)->getAttrs(), - {"unordered", "finalValue"}); + p.printOptionalAttrDictWithKeyword( + (*this)->getAttrs(), {"unordered", "reduceAttrs", "finalValue"}); p << ' '; p.printRegion(getRegion(), /*printEntryBlockArgs=*/false, printBlockTerminators); diff --git a/flang/lib/Parser/executable-parsers.cpp b/flang/lib/Parser/executable-parsers.cpp index 382a593416872..6bacdb34f8c70 100644 --- a/flang/lib/Parser/executable-parsers.cpp +++ b/flang/lib/Parser/executable-parsers.cpp @@ -252,13 +252,23 @@ TYPE_PARSER(parenthesized(construct( TYPE_PARSER(construct(name / "=", scalarIntExpr / ":", scalarIntExpr, maybe(":" >> scalarIntExpr))) +// F'2023 R1131 reduce-operation -> +// + | * | .AND. | .OR. | .EQV. | .NEQV. | +// MAX | MIN | IAND | IOR | IEOR +TYPE_PARSER(construct(Parser{}) || + construct(Parser{})) + // R1130 locality-spec -> // LOCAL ( variable-name-list ) | LOCAL_INIT ( variable-name-list ) | +// REDUCE ( reduce-operation : variable-name-list ) | // SHARED ( variable-name-list ) | DEFAULT ( NONE ) TYPE_PARSER(construct(construct( "LOCAL" >> parenthesized(listOfNames))) || construct(construct( "LOCAL_INIT"_sptok >> parenthesized(listOfNames))) || + construct(construct( + "REDUCE"_sptok >> "("_tok >> Parser{} / ":", + listOfNames / ")")) || construct(construct( "SHARED" >> parenthesized(listOfNames))) || construct( diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp index 1639e900903fe..969b9c3a3802b 100644 --- a/flang/lib/Parser/unparse.cpp +++ b/flang/lib/Parser/unparse.cpp @@ -1038,6 +1038,10 @@ class UnparseVisitor { void Unparse(const LocalitySpec::LocalInit &x) { Word("LOCAL_INIT("), Walk(x.v, ", "), Put(')'); } + void Unparse(const LocalitySpec::Reduce &x) { + Word("REDUCE("), Walk(std::get(x.t)), Put(':'); + Walk(std::get>(x.t), ", "), Put(')'); + } void Unparse(const LocalitySpec::Shared &x) { Word("SHARED("), Walk(x.v, ", "), Put(')'); } diff --git a/flang/lib/Semantics/check-do-forall.cpp b/flang/lib/Semantics/check-do-forall.cpp index c1eab090a4bb1..0a7149e5d3686 100644 --- a/flang/lib/Semantics/check-do-forall.cpp +++ b/flang/lib/Semantics/check-do-forall.cpp @@ -683,6 +683,89 @@ class DoContext { } } + void CheckReduce( + const parser::LocalitySpec::Reduce &reduce) const { + const parser::ReduceOperation &reduceOperation = + std::get(reduce.t); + // F'2023 C1132, reduction variables should have suitable intrinsic type + bool supported_identifier = true; + common::visit( + common::visitors{ + [&](const parser::DefinedOperator &dOpr) { + const auto &intrinsicOp{ + std::get(dOpr.u) + }; + for (const Fortran::parser::Name &x : + std::get>(reduce.t)) { + const auto *type{x.symbol->GetType()}; + bool suitable_type = false; + switch (intrinsicOp) { + case parser::DefinedOperator::IntrinsicOperator::Add: + case parser::DefinedOperator::IntrinsicOperator::Multiply: + if (type->IsNumeric(TypeCategory::Integer) || + type->IsNumeric(TypeCategory::Real) || + type->IsNumeric(TypeCategory::Complex)) { + // TODO: check composite type. + suitable_type = true; + } + break; + case parser::DefinedOperator::IntrinsicOperator::AND: + case parser::DefinedOperator::IntrinsicOperator::OR: + case parser::DefinedOperator::IntrinsicOperator::EQV: + case parser::DefinedOperator::IntrinsicOperator::NEQV: + if (type->category() == DeclTypeSpec::Category::Logical) { + suitable_type = true; + } + break; + default: + supported_identifier = false; + return; + } + if (!suitable_type) { + context_.Say(currentStatementSourcePosition_, + "Reduction variable '%s' does not have a " + "suitable type."_err_en_US, x.symbol->name()); + } + } + }, + [&](const parser::ProcedureDesignator &procD) { + const parser::Name *name{std::get_if(&procD.u)}; + if (!(name && name->symbol)) { + supported_identifier = false; + return; + } + const SourceName &realName{name->symbol->GetUltimate().name()}; + for (const Fortran::parser::Name &x : std::get>(reduce.t)) { + const auto *type{x.symbol->GetType()}; + bool suitable_type = false; + if (realName == "max" || realName == "min") { + if (type->IsNumeric(TypeCategory::Integer) || + type->IsNumeric(TypeCategory::Real)) + suitable_type = true; + } else if (realName == "iand" || realName == "ior" || + realName == "ieor") { + if (type->IsNumeric(TypeCategory::Integer)) + suitable_type = true; + } else { + supported_identifier = false; + return; + } + if (!suitable_type) { + context_.Say(currentStatementSourcePosition_, + "Reduction variable '%s' does not have a " + "suitable type."_err_en_US, x.symbol->name()); + } + } + } + }, + reduceOperation.u); + if (!supported_identifier) { + context_.Say(currentStatementSourcePosition_, + "Invalid reduction identifier in REDUCE clause."_err_en_US); + } + } + // C1123, concurrent limit or step expressions can't reference index-names void CheckConcurrentHeader(const parser::ConcurrentHeader &header) const { if (const auto &mask{ @@ -737,6 +820,12 @@ class DoContext { std::get>(header.t)}) { CheckMaskDoesNotReferenceLocal(*mask, localVars); } + for (auto &ls : localitySpecs) { + if (const auto *reduce{ + std::get_if(&ls.u)}) { + CheckReduce(*reduce); + } + } CheckDefaultNoneImpliesExplicitLocality(localitySpecs, block); } } diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp index 40eee89de131a..61f0811982feb 100644 --- a/flang/lib/Semantics/resolve-names.cpp +++ b/flang/lib/Semantics/resolve-names.cpp @@ -537,7 +537,9 @@ class ScopeHandler : public ImplicitRulesVisitor { void SayAlreadyDeclared(const SourceName &, const SourceName &); void SayWithReason( const parser::Name &, Symbol &, MessageFixedText &&, Message &&); - void SayWithDecl(const parser::Name &, Symbol &, MessageFixedText &&); + template + void SayWithDecl(const parser::Name &, Symbol &, MessageFixedText &&, + A &&...args); void SayLocalMustBeVariable(const parser::Name &, Symbol &); void SayDerivedType(const SourceName &, MessageFixedText &&, const Scope &); void Say2(const SourceName &, MessageFixedText &&, const SourceName &, @@ -1041,10 +1043,10 @@ class DeclarationVisitor : public ArraySpecVisitor, Symbol &DeclareObjectEntity(const parser::Name &, Attrs = Attrs{}); // Make sure that there's an entity in an enclosing scope called Name Symbol &FindOrDeclareEnclosingEntity(const parser::Name &); - // Declare a LOCAL/LOCAL_INIT entity. If there isn't a type specified + // Declare a LOCAL/LOCAL_INIT/REDUCE entity. If there isn't a type specified // it comes from the entity in the containing scope, or implicit rules. // Return pointer to the new symbol, or nullptr on error. - Symbol *DeclareLocalEntity(const parser::Name &); + Symbol *DeclareLocalEntity(const parser::Name &, Symbol::Flag); // Declare a statement entity (i.e., an implied DO loop index for // a DATA statement or an array constructor). If there isn't an explict // type specified, implicit rules apply. Return pointer to the new symbol, @@ -1145,7 +1147,8 @@ class DeclarationVisitor : public ArraySpecVisitor, const parser::Name *FindComponent(const parser::Name *, const parser::Name &); void Initialization(const parser::Name &, const parser::Initialization &, bool inComponentDecl); - bool PassesLocalityChecks(const parser::Name &name, Symbol &symbol); + bool PassesLocalityChecks(const parser::Name &name, Symbol &symbol, + Symbol::Flag flag); bool CheckForHostAssociatedImplicit(const parser::Name &); // Declare an object or procedure entity. @@ -1214,6 +1217,7 @@ class ConstructVisitor : public virtual DeclarationVisitor { bool Pre(const parser::ConcurrentHeader &); bool Pre(const parser::LocalitySpec::Local &); bool Pre(const parser::LocalitySpec::LocalInit &); + bool Pre(const parser::LocalitySpec::Reduce &); bool Pre(const parser::LocalitySpec::Shared &); bool Pre(const parser::AcSpec &); bool Pre(const parser::AcImpliedDo &); @@ -1573,6 +1577,7 @@ class ResolveNamesVisitor : public virtual ScopeHandler, ResolveName(*parser::Unwrap(x.name)); } void Post(const parser::ProcComponentRef &); + bool Pre(const parser::ReduceOperation &); bool Pre(const parser::FunctionReference &); bool Pre(const parser::CallStmt &); bool Pre(const parser::ImportStmt &); @@ -2254,9 +2259,11 @@ void ScopeHandler::SayWithReason(const parser::Name &name, Symbol &symbol, context().SetError(symbol, isFatal); } -void ScopeHandler::SayWithDecl( - const parser::Name &name, Symbol &symbol, MessageFixedText &&msg) { - auto &message{Say(name, std::move(msg), symbol.name()) +template void ScopeHandler::SayWithDecl( + const parser::Name &name, Symbol &symbol, MessageFixedText &&msg, + A &&...args) { + auto &message{Say(name.source, std::move(msg), symbol.name(), + std::forward(args)...) .Attach(Message{symbol.name(), symbol.test(Symbol::Flag::Implicit) ? "Implicit declaration of '%s'"_en_US @@ -6458,44 +6465,60 @@ bool DeclarationVisitor::PassesSharedLocalityChecks( return true; } -// Checks for locality-specs LOCAL and LOCAL_INIT +// Checks for locality-specs LOCAL, LOCAL_INIT, and REDUCE bool DeclarationVisitor::PassesLocalityChecks( - const parser::Name &name, Symbol &symbol) { - if (IsAllocatable(symbol)) { // C1128 - SayWithDecl(name, symbol, - "ALLOCATABLE variable '%s' not allowed in a locality-spec"_err_en_US); + const parser::Name &name, Symbol &symbol, Symbol::Flag flag) { + bool isReduce = flag == Symbol::Flag::LocalityReduce; + if (IsAllocatable(symbol) && !isReduce) { // C1128, F'2023 C1130 + SayWithDecl(name, symbol, "ALLOCATABLE variable '%s' not allowed in a " + "LOCAL%s locality-spec"_err_en_US, + (flag == Symbol::Flag::LocalityLocalInit) ? "_INIT" : ""); return false; } - if (IsOptional(symbol)) { // C1128 + if (IsOptional(symbol)) { // C1128, F'2023 C1130-C1131 SayWithDecl(name, symbol, "OPTIONAL argument '%s' not allowed in a locality-spec"_err_en_US); return false; } - if (IsIntentIn(symbol)) { // C1128 + if (IsIntentIn(symbol)) { // C1128, F'2023 C1130-C1131 SayWithDecl(name, symbol, "INTENT IN argument '%s' not allowed in a locality-spec"_err_en_US); return false; } - if (IsFinalizable(symbol)) { // C1128 - SayWithDecl(name, symbol, - "Finalizable variable '%s' not allowed in a locality-spec"_err_en_US); + if (IsFinalizable(symbol) && !isReduce) { // C1128, F'2023 C1130 + SayWithDecl(name, symbol, "Finalizable variable '%s' not allowed in a " + "LOCAL%s locality-spec"_err_en_US, + (flag == Symbol::Flag::LocalityLocalInit) ? "_INIT" : ""); return false; } - if (evaluate::IsCoarray(symbol)) { // C1128 - SayWithDecl( - name, symbol, "Coarray '%s' not allowed in a locality-spec"_err_en_US); + if (evaluate::IsCoarray(symbol) && !isReduce) { // C1128, F'2023 C1130 + SayWithDecl(name, symbol, "Coarray '%s' not allowed in a " + "LOCAL%s locality-spec"_err_en_US, + (flag == Symbol::Flag::LocalityLocalInit) ? "_INIT" : ""); return false; } if (const DeclTypeSpec * type{symbol.GetType()}) { if (type->IsPolymorphic() && IsDummy(symbol) && - !IsPointer(symbol)) { // C1128 - SayWithDecl(name, symbol, - "Nonpointer polymorphic argument '%s' not allowed in a " - "locality-spec"_err_en_US); + !IsPointer(symbol) && !isReduce) { // C1128, F'2023 C1130 + SayWithDecl(name, symbol, "Nonpointer polymorphic argument '%s' not " + "allowed in a LOCAL%s locality-spec"_err_en_US, + (flag == Symbol::Flag::LocalityLocalInit) ? "_INIT" : ""); return false; } } - if (IsAssumedSizeArray(symbol)) { // C1128 + if (symbol.attrs().test(Attr::ASYNCHRONOUS) && isReduce) { // F'2023 C1131 + SayWithDecl(name, symbol, + "ASYNCHRONOUS variable '%s' not allowed in a " + "REDUCE locality-spec"_err_en_US); + return false; + } + if (symbol.attrs().test(Attr::VOLATILE) && isReduce) { // F'2023 C1131 + SayWithDecl(name, symbol, + "VOLATILE variable '%s' not allowed in a " + "REDUCE locality-spec"_err_en_US); + return false; + } + if (IsAssumedSizeArray(symbol)) { // C1128, F'2023 C1130-C1131 SayWithDecl(name, symbol, "Assumed size array '%s' not allowed in a locality-spec"_err_en_US); return false; @@ -6524,9 +6547,10 @@ Symbol &DeclarationVisitor::FindOrDeclareEnclosingEntity( return *prev; } -Symbol *DeclarationVisitor::DeclareLocalEntity(const parser::Name &name) { +Symbol *DeclarationVisitor::DeclareLocalEntity( + const parser::Name &name, Symbol::Flag flag) { Symbol &prev{FindOrDeclareEnclosingEntity(name)}; - if (!PassesLocalityChecks(name, prev)) { + if (!PassesLocalityChecks(name, prev, flag)) { return nullptr; } return &MakeHostAssocSymbol(name, prev); @@ -6866,7 +6890,7 @@ bool ConstructVisitor::Pre(const parser::ConcurrentHeader &header) { bool ConstructVisitor::Pre(const parser::LocalitySpec::Local &x) { for (auto &name : x.v) { - if (auto *symbol{DeclareLocalEntity(name)}) { + if (auto *symbol{DeclareLocalEntity(name, Symbol::Flag::LocalityLocal)}) { symbol->set(Symbol::Flag::LocalityLocal); } } @@ -6875,13 +6899,25 @@ bool ConstructVisitor::Pre(const parser::LocalitySpec::Local &x) { bool ConstructVisitor::Pre(const parser::LocalitySpec::LocalInit &x) { for (auto &name : x.v) { - if (auto *symbol{DeclareLocalEntity(name)}) { + if (auto *symbol{ + DeclareLocalEntity(name, Symbol::Flag::LocalityLocalInit)}) { symbol->set(Symbol::Flag::LocalityLocalInit); } } return false; } +bool ConstructVisitor::Pre(const parser::LocalitySpec::Reduce &x) { + Walk(std::get(x.t)); + for (auto &name : std::get>(x.t)) { + if (auto *symbol{ + DeclareLocalEntity(name, Symbol::Flag::LocalityReduce)}) { + symbol->set(Symbol::Flag::LocalityReduce); + } + } + return false; +} + bool ConstructVisitor::Pre(const parser::LocalitySpec::Shared &x) { for (const auto &name : x.v) { if (!FindSymbol(name)) { @@ -8216,6 +8252,15 @@ void ResolveNamesVisitor::HandleProcedureName( } } +bool ResolveNamesVisitor::Pre(const parser::ReduceOperation &x) { + if (const auto *procD{parser::Unwrap(x.u)}) { + if (const auto *name{parser::Unwrap(procD->u)}) { + HandleProcedureName(Symbol::Flag::Function, *name); + } + } + return false; +} + bool ResolveNamesVisitor::CheckImplicitNoneExternal( const SourceName &name, const Symbol &symbol) { if (symbol.has() && isImplicitNoneExternal() && diff --git a/flang/test/Analysis/AliasAnalysis/alias-analysis-5.fir b/flang/test/Analysis/AliasAnalysis/alias-analysis-5.fir index 0624138586912..ccbc142131f53 100644 --- a/flang/test/Analysis/AliasAnalysis/alias-analysis-5.fir +++ b/flang/test/Analysis/AliasAnalysis/alias-analysis-5.fir @@ -21,7 +21,7 @@ func.func @_QPtest1(%arg0: !fir.box> {fir.bindc_name = "arraya %1 = fir.load %arg3 : !fir.ref %2 = fir.convert %1 : (i32) -> index %3 = fir.convert %c1 : (index) -> i32 - %4:2 = fir.do_loop %arg4 = %c1 to %2 step %c1 iter_args(%arg5 = %3) -> (index, i32) { + %4:2 = fir.do_loop %arg4 = %c1 to %2 step %c1 iter_args(%arg5 = %3) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg5 to %0 : !fir.ref %5 = fir.load %0 : !fir.ref %6 = fir.convert %5 : (i32) -> i64 @@ -64,7 +64,7 @@ func.func @_QPtest3(%arg0: !fir.box> {fir.bindc_name = "arraya %1 = fir.load %arg3 : !fir.ref %2 = fir.convert %1 : (i32) -> index %3 = fir.convert %c1 : (index) -> i32 - %4:2 = fir.do_loop %arg4 = %c1 to %2 step %c1 iter_args(%arg5 = %3) -> (index, i32) { + %4:2 = fir.do_loop %arg4 = %c1 to %2 step %c1 iter_args(%arg5 = %3) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg5 to %0 : !fir.ref %5 = fir.load %0 : !fir.ref %6 = fir.convert %5 : (i32) -> i64 @@ -123,7 +123,7 @@ func.func @_QMtest4Ptest() { %5 = fir.load %3 : !fir.ref %6 = fir.convert %5 : (i32) -> index %7 = fir.convert %c1 : (index) -> i32 - %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) { + %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %4 : !fir.ref %9 = fir.load %1 : !fir.ref>>> %10:3 = fir.box_dims %9, %c0 : (!fir.box>>, index) -> (index, index, index) @@ -192,7 +192,7 @@ func.func @_QMtest5Ptest() { %5 = fir.load %3 : !fir.ref %6 = fir.convert %5 : (i32) -> index %7 = fir.convert %c1 : (index) -> i32 - %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) { + %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %4 : !fir.ref %9 = fir.load %1 : !fir.ref>>> %10:3 = fir.box_dims %9, %c0 : (!fir.box>>, index) -> (index, index, index) @@ -260,7 +260,7 @@ func.func @_QMtest6Ptest() { %5 = fir.load %3 : !fir.ref %6 = fir.convert %5 : (i32) -> index %7 = fir.convert %c1 : (index) -> i32 - %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) { + %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %4 : !fir.ref %9 = fir.load %1 : !fir.ref>>> %10:3 = fir.box_dims %9, %c0 : (!fir.box>>, index) -> (index, index, index) @@ -329,7 +329,7 @@ func.func @_QMtest7Ptest() { %5 = fir.load %3 : !fir.ref %6 = fir.convert %5 : (i32) -> index %7 = fir.convert %c1 : (index) -> i32 - %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) { + %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %4 : !fir.ref %9 = fir.load %1 : !fir.ref>>> %10:3 = fir.box_dims %9, %c0 : (!fir.box>>, index) -> (index, index, index) @@ -394,7 +394,7 @@ func.func @_QMtest8Ptest() { %5 = fir.load %3 : !fir.ref %6 = fir.convert %5 : (i32) -> index %7 = fir.convert %c1 : (index) -> i32 - %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) { + %8:2 = fir.do_loop %arg0 = %c1 to %6 step %c1 iter_args(%arg1 = %7) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %4 : !fir.ref %9 = fir.load %1 : !fir.ref>>> %10:3 = fir.box_dims %9, %c0 : (!fir.box>>, index) -> (index, index, index) @@ -457,7 +457,7 @@ func.func @_QMtest9Ptest(%arg0: !fir.box> {fir.bindc_name = "a %4 = fir.load %2 : !fir.ref %5 = fir.convert %4 : (i32) -> index %6 = fir.convert %c1 : (index) -> i32 - %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) { + %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %3 : !fir.ref %8 = fir.load %0 : !fir.ref>>> %9:3 = fir.box_dims %8, %c0 : (!fir.box>>, index) -> (index, index, index) @@ -520,7 +520,7 @@ func.func @_QMtest10Ptest(%arg0: !fir.box> {fir.bindc_name = " %4 = fir.load %2 : !fir.ref %5 = fir.convert %4 : (i32) -> index %6 = fir.convert %c1 : (index) -> i32 - %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) { + %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %3 : !fir.ref %8 = fir.load %0 : !fir.ref>>> %9:3 = fir.box_dims %8, %c0 : (!fir.box>>, index) -> (index, index, index) @@ -583,7 +583,7 @@ func.func @_QMtest11Ptest(%arg0: !fir.box> {fir.bindc_name = " %4 = fir.load %2 : !fir.ref %5 = fir.convert %4 : (i32) -> index %6 = fir.convert %c1 : (index) -> i32 - %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) { + %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %3 : !fir.ref %8 = fir.load %0 : !fir.ref>>> %9:3 = fir.box_dims %8, %c0 : (!fir.box>>, index) -> (index, index, index) @@ -643,7 +643,7 @@ func.func @_QMtest12Ptest(%arg0: !fir.box> {fir.bindc_name = " %4 = fir.load %2 : !fir.ref %5 = fir.convert %4 : (i32) -> index %6 = fir.convert %c1 : (index) -> i32 - %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) { + %7:2 = fir.do_loop %arg1 = %c1 to %5 step %c1 iter_args(%arg2 = %6) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %3 : !fir.ref %8 = fir.load %0 : !fir.ref>>> %9:3 = fir.box_dims %8, %c0 : (!fir.box>>, index) -> (index, index, index) diff --git a/flang/test/Analysis/AliasAnalysis/alias-analysis-7.fir b/flang/test/Analysis/AliasAnalysis/alias-analysis-7.fir index fdf2fc4353bbb..d6b6fcd627fc3 100644 --- a/flang/test/Analysis/AliasAnalysis/alias-analysis-7.fir +++ b/flang/test/Analysis/AliasAnalysis/alias-analysis-7.fir @@ -49,12 +49,12 @@ func.func @_QPupdate() { %21 = arith.subi %20, %c1_i32 : i32 %22 = fir.convert %21 : (i32) -> index %23 = fir.convert %c1 : (index) -> i32 - %24:2 = fir.do_loop %arg0 = %c1 to %22 step %c1 iter_args(%arg1 = %23) -> (index, i32) { + %24:2 = fir.do_loop %arg0 = %c1 to %22 step %c1 iter_args(%arg1 = %23) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %11#1 : !fir.ref %25 = fir.load %9#0 : !fir.ref %26 = arith.subi %25, %c1_i32 : i32 %27 = fir.convert %26 : (i32) -> index - %28:2 = fir.do_loop %arg2 = %c1 to %27 step %c1 iter_args(%arg3 = %23) -> (index, i32) { + %28:2 = fir.do_loop %arg2 = %c1 to %27 step %c1 iter_args(%arg3 = %23) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg3 to %7#1 : !fir.ref %32 = fir.load %17#0 : !fir.ref>>> %33 = fir.load %3#0 : !fir.ref diff --git a/flang/test/Fir/affine-promotion.fir b/flang/test/Fir/affine-promotion.fir index aae35c6ef5659..ae2e05ae58dbe 100644 --- a/flang/test/Fir/affine-promotion.fir +++ b/flang/test/Fir/affine-promotion.fir @@ -13,7 +13,7 @@ func.func @loop_with_load_and_store(%a1: !arr_d1, %a2: !arr_d1, %a3: !arr_d1) { %siz = affine.apply #arr_len()[%c1,%len] %t1 = fir.alloca !fir.array, %siz - fir.do_loop %i = %c1 to %len step %c1 { + fir.do_loop %i = %c1 to %len step %c1 attributes {operandSegmentSizes = array} { %a1_idx = fir.array_coor %a1(%dims) %i : (!arr_d1, !fir.shape<1>, index) -> !fir.ref %a1_v = fir.load %a1_idx : !fir.ref @@ -28,7 +28,7 @@ func.func @loop_with_load_and_store(%a1: !arr_d1, %a2: !arr_d1, %a3: !arr_d1) { fir.store %v to %t1_idx : !fir.ref } - fir.do_loop %i = %c1 to %len step %c1 { + fir.do_loop %i = %c1 to %len step %c1 attributes {operandSegmentSizes = array} { %t1_idx = fir.array_coor %t1(%dims) %i : (!arr_d1, !fir.shape<1>, index) -> !fir.ref %t1_v = fir.load %t1_idx : !fir.ref @@ -85,9 +85,9 @@ func.func @loop_with_if(%a: !arr_d1, %v: f32) { %len = arith.constant 100 : index %dims = fir.shape %len : (index) -> !fir.shape<1> - fir.do_loop %i = %c1 to %len step %c1 { - fir.do_loop %j = %c1 to %len step %c1 { - fir.do_loop %k = %c1 to %len step %c1 { + fir.do_loop %i = %c1 to %len step %c1 attributes {operandSegmentSizes = array} { + fir.do_loop %j = %c1 to %len step %c1 attributes {operandSegmentSizes = array} { + fir.do_loop %k = %c1 to %len step %c1 attributes {operandSegmentSizes = array} { %im2 = arith.subi %i, %c2 : index %cond = arith.cmpi "sgt", %im2, %c0 : index fir.if %cond { diff --git a/flang/test/Fir/array-copies-pointers.fir b/flang/test/Fir/array-copies-pointers.fir index 490c1c1055e18..fb46cb00a3e02 100644 --- a/flang/test/Fir/array-copies-pointers.fir +++ b/flang/test/Fir/array-copies-pointers.fir @@ -20,7 +20,7 @@ func.func @maybe_overlap(%arg0: !fir.ptr>, %arg1 : !fir.ref< %1 = fir.shape %c100 : (index) -> !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %arg1(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %3, %arg2 : (!fir.array<100xf32>, index) -> f32 %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> fir.result %6 : !fir.array<100xf32> @@ -48,7 +48,7 @@ func.func @no_overlap1(%arg0: !fir.ptr>, %arg1 : !fir.ref !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %arg1(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %3, %arg2 : (!fir.array<100xf32>, index) -> f32 %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> fir.result %6 : !fir.array<100xf32> @@ -74,7 +74,7 @@ func.func @no_overlap(%arg0: !fir.ptr>, %arg1: !fir.ref !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> - %3 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) { + %3 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %4 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32 %5 = fir.array_update %arg3, %4, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> fir.result %5 : !fir.array<100xf32> @@ -101,7 +101,7 @@ func.func @maybe_overlap_2(%arg0: !fir.ptr>, %arg1: !fir.ref %1 = fir.shape %c100 : (index) -> !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %arg1(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32 %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> fir.result %6 : !fir.array<100xf32> @@ -129,7 +129,7 @@ func.func @no_overlap_2(%arg0: !fir.ptr>, %arg1: !fir.ref !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %arg1(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32 %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> fir.result %6 : !fir.array<100xf32> @@ -156,7 +156,7 @@ func.func @maybe_overlap_3(%arg0: !fir.ptr>, %arg1: !fir.ptr %1 = fir.shape %c100 : (index) -> !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %arg1(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32 %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> fir.result %6 : !fir.array<100xf32> @@ -185,7 +185,7 @@ func.func @derived_whose_component_may_be_aliased(%arg0: !fir.box !fir.shift<1> %6 = fir.array_load %3(%5) : (!fir.box>>, !fir.shift<1>) -> !fir.array %7 = arith.subi %c4, %c1 : index - %8 = fir.do_loop %arg2 = %c0 to %7 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<4xi32>) { + %8 = fir.do_loop %arg2 = %c0 to %7 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<4xi32>) attributes {operandSegmentSizes = array} { %9 = fir.array_fetch %6, %arg2 : (!fir.array, index) -> i32 %10 = fir.array_update %arg3, %9, %arg2 : (!fir.array<4xi32>, i32, index) -> !fir.array<4xi32> fir.result %10 : !fir.array<4xi32> @@ -215,7 +215,7 @@ func.func @complex_real_aliasing(%arg0: !fir.ref !fir.slice<1> %6 = fir.array_load %arg1(%4) [%5] : (!fir.ref>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<4xf32> %7 = arith.subi %c4, %c1 : index - %8 = fir.do_loop %arg2 = %c0 to %7 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array) { + %8 = fir.do_loop %arg2 = %c0 to %7 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array) attributes {operandSegmentSizes = array} { %9 = fir.array_fetch %6, %arg2 : (!fir.array<4xf32>, index) -> f32 %10 = fir.array_update %arg3, %9, %arg2 : (!fir.array, f32, index) -> !fir.array fir.result %10 : !fir.array @@ -247,7 +247,7 @@ func.func @maybe_overlap_3(%arg0: !fir.ptr>, %arg1: !fir.ref %1 = fir.shape %c100 : (index) -> !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %0(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32 %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> fir.result %6 : !fir.array<100xf32> @@ -280,7 +280,7 @@ func.func @no_overlap_3(%arg0: !fir.ptr>, %arg1: !fir.ref !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ptr>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %0(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32 %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> fir.result %6 : !fir.array<100xf32> diff --git a/flang/test/Fir/array-modify.fir b/flang/test/Fir/array-modify.fir index 09c9516ec57d3..63d2a3c4d0950 100644 --- a/flang/test/Fir/array-modify.fir +++ b/flang/test/Fir/array-modify.fir @@ -12,7 +12,7 @@ func.func @no_overlap(%arg0: !fir.ref>, %arg1: !fir.ref !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %arg1(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %3, %arg2 : (!fir.array<100xf32>, index) -> f32 %6:2 = fir.array_modify %arg3, %arg2 : (!fir.array<100xf32>, index) -> (!fir.ref, !fir.array<100xf32>) fir.store %5 to %0 : !fir.ref @@ -33,7 +33,7 @@ func.func @no_overlap(%arg0: !fir.ref>, %arg1: !fir.ref !fir.shape<1> // CHECK: %[[VAL_8:.*]] = fir.undefined !fir.array<100xf32> // CHECK: %[[VAL_9:.*]] = fir.undefined !fir.array<100xf32> -// CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_4]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array<100xf32>) { +// CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_4]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_13:.*]] = arith.constant 1 : index // CHECK: %[[VAL_14:.*]] = arith.addi %[[VAL_11]], %[[VAL_13]] : index // CHECK: %[[VAL_15:.*]] = fir.array_coor %[[VAL_1]](%[[VAL_7]]) %[[VAL_14]] : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref @@ -61,7 +61,7 @@ func.func @overlap(%arg0: !fir.ref>) { %2 = fir.array_load %arg0(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.slice %c100, %c1, %c-1 : (index, index, index) -> !fir.slice<1> %4 = fir.array_load %arg0(%1) [%3] : (!fir.ref>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<100xf32> - %5 = fir.do_loop %arg1 = %c0 to %c99 step %c1 unordered iter_args(%arg2 = %2) -> (!fir.array<100xf32>) { + %5 = fir.do_loop %arg1 = %c0 to %c99 step %c1 unordered iter_args(%arg2 = %2) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %6 = fir.array_fetch %4, %arg1 : (!fir.array<100xf32>, index) -> f32 %7:2 = fir.array_modify %arg2, %arg1 : (!fir.array<100xf32>, index) -> (!fir.ref, !fir.array<100xf32>) fir.store %6 to %0 : !fir.ref @@ -85,7 +85,7 @@ func.func @overlap(%arg0: !fir.ref>) { // CHECK: %[[VAL_10:.*]] = arith.constant 0 : index // CHECK: %[[VAL_11:.*]] = arith.constant 1 : index // CHECK: %[[VAL_12:.*]] = arith.subi %[[VAL_9]], %[[VAL_11]] : index -// CHECK: fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_11]] { +// CHECK: fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_11]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_14:.*]] = arith.constant 1 : index // CHECK: %[[VAL_15:.*]] = arith.addi %[[VAL_13]], %[[VAL_14]] : index // CHECK: %[[VAL_16:.*]] = fir.array_coor %[[VAL_0]](%[[VAL_7]]) %[[VAL_15]] : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref @@ -98,7 +98,7 @@ func.func @overlap(%arg0: !fir.ref>) { // CHECK: %[[VAL_21:.*]] = fir.undefined !fir.array<100xf32> // CHECK: %[[VAL_22:.*]] = fir.slice %[[VAL_1]], %[[VAL_3]], %[[VAL_4]] : (index, index, index) -> !fir.slice<1> // CHECK: %[[VAL_23:.*]] = fir.undefined !fir.array<100xf32> -// CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_5]] to %[[VAL_2]] step %[[VAL_3]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_21]]) -> (!fir.array<100xf32>) { +// CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_5]] to %[[VAL_2]] step %[[VAL_3]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_21]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_27:.*]] = arith.constant 1 : index // CHECK: %[[VAL_28:.*]] = arith.addi %[[VAL_25]], %[[VAL_27]] : index // CHECK: %[[VAL_29:.*]] = fir.array_coor %[[VAL_0]](%[[VAL_7]]) {{\[}}%[[VAL_22]]] %[[VAL_28]] : (!fir.ref>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref @@ -114,7 +114,7 @@ func.func @overlap(%arg0: !fir.ref>) { // CHECK: %[[VAL_35:.*]] = arith.constant 0 : index // CHECK: %[[VAL_36:.*]] = arith.constant 1 : index // CHECK: %[[VAL_37:.*]] = arith.subi %[[VAL_34]], %[[VAL_36]] : index -// CHECK: fir.do_loop %[[VAL_38:.*]] = %[[VAL_35]] to %[[VAL_37]] step %[[VAL_36]] { +// CHECK: fir.do_loop %[[VAL_38:.*]] = %[[VAL_35]] to %[[VAL_37]] step %[[VAL_36]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_39:.*]] = arith.constant 1 : index // CHECK: %[[VAL_40:.*]] = arith.addi %[[VAL_38]], %[[VAL_39]] : index // CHECK: %[[VAL_41:.*]] = fir.array_coor %[[VAL_8]](%[[VAL_7]]) %[[VAL_40]] : (!fir.heap>, !fir.shape<1>, index) -> !fir.ref diff --git a/flang/test/Fir/array-value-copy-2.fir b/flang/test/Fir/array-value-copy-2.fir index 21b340af10c6b..03370cc8a92c5 100644 --- a/flang/test/Fir/array-value-copy-2.fir +++ b/flang/test/Fir/array-value-copy-2.fir @@ -31,7 +31,7 @@ func.func @_QPslice1(%arg0: !fir.box>, %arg1: !fir.ref, % %18 = fir.array_load %arg0 [%17] : (!fir.box>, !fir.slice<1>) -> !fir.array %c1 = arith.constant 1 : index %19 = arith.subi %8, %c1 : index - %20 = fir.do_loop %arg3 = %c0 to %19 step %c1 unordered iter_args(%arg4 = %10) -> (!fir.array) { + %20 = fir.do_loop %arg3 = %c0 to %19 step %c1 unordered iter_args(%arg4 = %10) -> (!fir.array) attributes {operandSegmentSizes = array} { %21 = fir.array_fetch %18, %arg3 : (!fir.array, index) -> f32 %22 = fir.array_update %arg4, %21, %arg3 : (!fir.array, f32, index) -> !fir.array fir.result %22 : !fir.array @@ -77,7 +77,7 @@ func.func @_QPslice2(%arg0: !fir.box>, %arg1: !fir.ref, % %c1 = arith.constant 1 : index %c0_2 = arith.constant 0 : index %22 = arith.subi %9, %c1 : index - %23 = fir.do_loop %arg3 = %c0_2 to %22 step %c1 unordered iter_args(%arg4 = %11) -> (!fir.array) { + %23 = fir.do_loop %arg3 = %c0_2 to %22 step %c1 unordered iter_args(%arg4 = %11) -> (!fir.array) attributes {operandSegmentSizes = array} { %24 = fir.array_fetch %21, %arg3 : (!fir.array, index) -> f32 %25 = fir.array_update %arg4, %24, %arg3 : (!fir.array, f32, index) -> !fir.array fir.result %25 : !fir.array diff --git a/flang/test/Fir/array-value-copy-3.fir b/flang/test/Fir/array-value-copy-3.fir index 2840c3c68d701..22363ab907f49 100644 --- a/flang/test/Fir/array-value-copy-3.fir +++ b/flang/test/Fir/array-value-copy-3.fir @@ -20,7 +20,7 @@ func.func @test_overlap_with_alloc_components(%arg0: !fir.ref !fir.slice<1> %2 = fir.array_load %arg0(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<10x!t_with_alloc_comp> %7 = fir.array_load %arg0(%1) [%6] : (!fir.ref>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<10x!t_with_alloc_comp> - %9 = fir.do_loop %arg1 = %c0 to %c9 step %c1 unordered iter_args(%arg2 = %2) -> (!fir.array<10x!t_with_alloc_comp>) { + %9 = fir.do_loop %arg1 = %c0 to %c9 step %c1 unordered iter_args(%arg2 = %2) -> (!fir.array<10x!t_with_alloc_comp>) attributes {operandSegmentSizes = array} { %10 = fir.array_access %7, %arg1 : (!fir.array<10x!t_with_alloc_comp>, index) -> !fir.ref %11 = fir.array_access %arg2, %arg1 : (!fir.array<10x!t_with_alloc_comp>, index) -> !fir.ref fir.call @custom_assign(%11, %10) : (!fir.ref, !fir.ref) -> none diff --git a/flang/test/Fir/array-value-copy-4.fir b/flang/test/Fir/array-value-copy-4.fir index f120f054f6abd..431f56f3e7b3c 100644 --- a/flang/test/Fir/array-value-copy-4.fir +++ b/flang/test/Fir/array-value-copy-4.fir @@ -32,7 +32,7 @@ func.func @_QMmodPsub1(%arg0: !fir.box (!fir.array>>}>>) { + %17 = fir.do_loop %arg1 = %c0_2 to %16 step %c1 unordered iter_args(%arg2 = %10) -> (!fir.array>>}>>) attributes {operandSegmentSizes = array} { %18 = fir.array_access %15, %arg1 : (!fir.array>>}>>, index) -> !fir.ref>>}>> %19 = fir.array_access %arg2, %arg1 : (!fir.array>>}>>, index) -> !fir.ref>>}>> %20 = fir.embox %19 : (!fir.ref>>}>>) -> !fir.box>>}>> diff --git a/flang/test/Fir/array-value-copy-cam4.fir b/flang/test/Fir/array-value-copy-cam4.fir index 3bb465cfaa59f..ea92dd2a70e8a 100644 --- a/flang/test/Fir/array-value-copy-cam4.fir +++ b/flang/test/Fir/array-value-copy-cam4.fir @@ -86,8 +86,8 @@ module { %45 = fir.array_load %0(%43) [%44] : (!fir.ref>, !fir.shape<2>, !fir.slice<2>) -> !fir.array<4x27xf64> %46 = arith.subi %23, %c1 : index %47 = arith.subi %29, %c1 : index - %48 = fir.do_loop %arg5 = %c0 to %47 step %c1 unordered iter_args(%arg6 = %40) -> (!fir.array) { - %49 = fir.do_loop %arg7 = %c0 to %46 step %c1 unordered iter_args(%arg8 = %arg6) -> (!fir.array) { + %48 = fir.do_loop %arg5 = %c0 to %47 step %c1 unordered iter_args(%arg6 = %40) -> (!fir.array) attributes {operandSegmentSizes = array} { + %49 = fir.do_loop %arg7 = %c0 to %46 step %c1 unordered iter_args(%arg8 = %arg6) -> (!fir.array) attributes {operandSegmentSizes = array} { %50 = fir.array_fetch %45, %arg7, %arg5 : (!fir.array<4x27xf64>, index, index) -> f64 %51 = fir.array_update %arg8, %50, %15, %arg7, %arg5, %33, %37 : (!fir.array, f64, index, index, index, index, index) -> !fir.array fir.result %51 : !fir.array diff --git a/flang/test/Fir/array-value-copy.fir b/flang/test/Fir/array-value-copy.fir index 58db8b3ae4cd2..b73e6fc1e87cd 100644 --- a/flang/test/Fir/array-value-copy.fir +++ b/flang/test/Fir/array-value-copy.fir @@ -92,7 +92,7 @@ func.func @conversion_with_temporary(%arr0 : !fir.ref>) { %c1 = arith.constant 1 : index %c0 = arith.constant 0 : index %7 = arith.subi %3, %c1 : index - %8 = fir.do_loop %arg0 = %c0 to %7 step %c1 unordered iter_args(%arg1 = %2) -> (!fir.array<10xi32>) { + %8 = fir.do_loop %arg0 = %c0 to %7 step %c1 unordered iter_args(%arg1 = %2) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { %9 = fir.array_fetch %6, %arg0 : (!fir.array<10xi32>, index) -> i32 %10 = fir.array_update %arg1, %9, %arg0 : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32> fir.result %10 : !fir.array<10xi32> @@ -106,14 +106,14 @@ func.func @conversion_with_temporary(%arr0 : !fir.ref>) { // Allocation of temporary array. // CHECK: %[[TEMP:.*]] = fir.allocmem !fir.array<10xi32> // Copy of original array to temp. -// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} { +// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref // CHECK: %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap>, !fir.shape<1>, index) -> !fir.ref // CHECK: %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref // CHECK: fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref // CHECK: } // Perform the assignment i = i(10:1:-1) using the temporary array. -// CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10xi32>) { +// CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { // CHECK-NOT: %{{.*}} = fir.array_fetch // CHECK-NOT: %{{.*}} = fir.array_update // CHECK: %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) [%{{.*}}] %{{.*}} : (!fir.ref>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref @@ -123,7 +123,7 @@ func.func @conversion_with_temporary(%arr0 : !fir.ref>) { // CHECK: fir.result %{{.*}} : !fir.array<10xi32> // CHECK: } // Copy the result back to the original array. -// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} { +// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[COOR0:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap>, !fir.shape<1>, index) -> !fir.ref // CHECK: %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref // CHECK: %[[LOAD0:.*]] = fir.load %[[COOR0:.*]] : !fir.ref @@ -160,8 +160,8 @@ func.func @conversion_with_temporary_multidim(%0: !fir.ref> %c0 = arith.constant 0 : index %10 = arith.subi %3, %c1_2 : index %11 = arith.subi %4, %c1_2 : index - %12 = fir.do_loop %arg0 = %c0 to %11 step %c1_2 unordered iter_args(%arg1 = %2) -> (!fir.array<10x5xi32>) { - %13 = fir.do_loop %arg2 = %c0 to %10 step %c1_2 unordered iter_args(%arg3 = %arg1) -> (!fir.array<10x5xi32>) { + %12 = fir.do_loop %arg0 = %c0 to %11 step %c1_2 unordered iter_args(%arg1 = %2) -> (!fir.array<10x5xi32>) attributes {operandSegmentSizes = array} { + %13 = fir.do_loop %arg2 = %c0 to %10 step %c1_2 unordered iter_args(%arg3 = %arg1) -> (!fir.array<10x5xi32>) attributes {operandSegmentSizes = array} { %14 = fir.array_fetch %9, %arg2, %arg0 : (!fir.array<10x5xi32>, index, index) -> i32 %15 = fir.array_update %arg3, %14, %arg2, %arg0 : (!fir.array<10x5xi32>, i32, index, index) -> !fir.array<10x5xi32> fir.result %15 : !fir.array<10x5xi32> @@ -179,18 +179,18 @@ func.func @conversion_with_temporary_multidim(%0: !fir.ref> // CHECK: %[[TEMP:.*]] = fir.allocmem !fir.array<10x5xi32> // CHECK: %[[IDX5:.*]] = fir.convert %[[CST5]] : (index) -> index // CHECK: %[[UB5:.*]] = arith.subi %[[IDX5]], %{{.*}} : index -// CHECK: fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %[[UB5]] step %{{.*}} { +// CHECK: fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %[[UB5]] step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[IDX10:.*]] = fir.convert %[[CST10]] : (index) -> index // CHECK: %[[UB10:.*]] = arith.subi %[[IDX10]], %{{.*}} : index -// CHECK: fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %[[UB10]] step %{{.*}} { +// CHECK: fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %[[UB10]] step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[IDX1:.*]] = arith.addi %[[INDUC1]], %{{.*}} : index // CHECK: %[[IDX2:.*]] = arith.addi %[[INDUC0]], %{{.*}} : index // CHECK: %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %[[IDX1:.*]], %[[IDX2:.*]] : (!fir.ref>, !fir.shape<2>, index, index) -> !fir.ref // CHECK: %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}}, %{{.*}} : (!fir.heap>, !fir.shape<2>, index, index) -> !fir.ref // CHECK: %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref // CHECK: fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref -// CHECK: %{{.*}} = fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10x5xi32>) { -// CHECK: %{{.*}} = fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10x5xi32>) { +// CHECK: %{{.*}} = fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10x5xi32>) attributes {operandSegmentSizes = array} { +// CHECK: %{{.*}} = fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10x5xi32>) attributes {operandSegmentSizes = array} { // CHECK: %[[IDX1:.*]] = arith.addi %[[INDUC1]], %{{.*}} : index // CHECK: %[[IDX2:.*]] = arith.addi %[[INDUC0]], %{{.*}} : index // CHECK-NOT: %{{.*}} = fir.array_fetch @@ -201,10 +201,10 @@ func.func @conversion_with_temporary_multidim(%0: !fir.ref> // CHECK: fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref // CHECK: %[[IDX5:.*]] = fir.convert %[[CST5]] : (index) -> index // CHECK: %[[UB5:.*]] = arith.subi %[[IDX5]], %{{.*}} : index -// CHECK: fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %[[UB5]] step %{{.*}} { +// CHECK: fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %[[UB5]] step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[IDX10:.*]] = fir.convert %[[CST10]] : (index) -> index // CHECK: %[[UB10:.*]] = arith.subi %[[IDX10]], %{{.*}} : index -// CHECK: fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %[[UB10]] step %{{.*}} { +// CHECK: fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %[[UB10]] step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[IDX1:.*]] = arith.addi %[[INDUC1]], %{{.*}} : index // CHECK: %[[IDX2:.*]] = arith.addi %[[INDUC0]], %{{.*}} : index // CHECK: %[[COOR0:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %[[IDX1]], %[[IDX2]] : (!fir.heap>, !fir.shape<2>, index, index) -> !fir.ref @@ -225,7 +225,7 @@ func.func @array_modify_no_overlap(%arg0: !fir.ref>, %arg1: %1 = fir.shape %c100 : (index) -> !fir.shape<1> %2 = fir.array_load %arg0(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.array_load %arg1(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> - %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) { + %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %5 = fir.array_fetch %3, %arg2 : (!fir.array<100xf32>, index) -> f32 %6:2 = fir.array_modify %arg3, %arg2 : (!fir.array<100xf32>, index) -> (!fir.ref, !fir.array<100xf32>) fir.store %5 to %0 : !fir.ref @@ -242,7 +242,7 @@ func.func private @user_defined_assignment(!fir.ref, !fir.ref) // CHECK-SAME: %[[ARR0:.*]]: !fir.ref>, // CHECK-SAME: %[[ARR1:.*]]: !fir.ref>) { // CHECK: %[[VAR0:.*]] = fir.alloca f32 -// CHECK-COUNT-1: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<100xf32>) { +// CHECK-COUNT-1: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { // CHECK-NOT: %{{.*}} = fir.array_fetch // CHECK-NOT: %{{.*}} = fir.array_modify // CHECK: %[[COOR0:.*]] = fir.array_coor %arg1(%1) %5 : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref @@ -266,7 +266,7 @@ func.func @array_modify_overlap(%arg0: !fir.ref>) { %2 = fir.array_load %arg0(%1) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> %3 = fir.slice %c100, %c1, %c-1 : (index, index, index) -> !fir.slice<1> %4 = fir.array_load %arg0(%1) [%3] : (!fir.ref>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<100xf32> - %5 = fir.do_loop %arg1 = %c0 to %c99 step %c1 unordered iter_args(%arg2 = %2) -> (!fir.array<100xf32>) { + %5 = fir.do_loop %arg1 = %c0 to %c99 step %c1 unordered iter_args(%arg2 = %2) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { %6 = fir.array_fetch %4, %arg1 : (!fir.array<100xf32>, index) -> f32 %7:2 = fir.array_modify %arg2, %arg1 : (!fir.array<100xf32>, index) -> (!fir.ref, !fir.array<100xf32>) fir.store %6 to %0 : !fir.ref @@ -285,7 +285,7 @@ func.func private @user_defined_assignment(!fir.ref, !fir.ref) // Allocate the temporary array. // CHECK: %[[TEMP:.*]] = fir.allocmem !fir.array<100xf32> // Copy original array to temp. -// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} { +// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref // CHECK: %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap>, !fir.shape<1>, index) -> !fir.ref // CHECK: %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref @@ -302,7 +302,7 @@ func.func private @user_defined_assignment(!fir.ref, !fir.ref) // CHECK: fir.call @user_defined_assignment(%[[COOR1]], %[[VAR0]]) : (!fir.ref, !fir.ref) -> () // CHECK: } // Copy back result to original array from temp. -// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} { +// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[COOR0:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap>, !fir.shape<1>, index) -> !fir.ref // CHECK: %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref // CHECK: %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref @@ -324,7 +324,7 @@ func.func @array_of_types() { %c10_i32 = arith.constant 10 : i32 %3 = fir.convert %c10_i32 : (i32) -> index %c1 = arith.constant 1 : index - %4 = fir.do_loop %arg0 = %2 to %3 step %c1 -> index { + %4 = fir.do_loop %arg0 = %2 to %3 step %c1 -> index attributes {operandSegmentSizes = array} { %6 = fir.convert %arg0 : (index) -> i32 fir.store %6 to %0 : !fir.ref %c1_0 = arith.constant 1 : index @@ -348,7 +348,7 @@ func.func @array_of_types() { %c1_2 = arith.constant 1 : index %c0 = arith.constant 0 : index %19 = arith.subi %18, %c1_2 : index - %20 = fir.do_loop %arg1 = %c0 to %19 step %c1_2 unordered iter_args(%arg2 = %17) -> (!fir.array<10xi32>) { + %20 = fir.do_loop %arg1 = %c0 to %19 step %c1_2 unordered iter_args(%arg2 = %17) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { %22 = fir.array_update %arg2, %c0_i32, %arg1 : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32> fir.result %22 : !fir.array<10xi32> } @@ -362,8 +362,8 @@ func.func @array_of_types() { } // CHECK-LABEL: func @array_of_types() { -// CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} -> index { -// CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%arg2 = %17) -> (!fir.array<10xi32>) { +// CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} -> index attributes {operandSegmentSizes = array} { +// CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%arg2 = %17) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { // CHECK-NOT: %{{.*}} = fir.array_update // CHECK: %[[COOR0:.*]] = fir.array_coor %{{.*}}(%{{.*}}) [%{{.*}}] %{{.*}} : (!fir.ref>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref // CHECK: fir.store %{{.*}} to %[[COOR0]] : !fir.ref @@ -387,7 +387,7 @@ func.func @conversion_with_temporary_boxed_array(%arr0 : !fir.box (!fir.array<10xi32>) { + %8 = fir.do_loop %arg0 = %c0 to %7 step %c1 unordered iter_args(%arg1 = %2) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { %9 = fir.array_fetch %6, %arg0 : (!fir.array<10xi32>, index) -> i32 %10 = fir.array_update %arg1, %9, %arg0 : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32> fir.result %10 : !fir.array<10xi32> @@ -401,14 +401,14 @@ func.func @conversion_with_temporary_boxed_array(%arr0 : !fir.box // Copy of original array to temp. -// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} { +// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref // CHECK: %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap>, !fir.shapeshift<1>, index) -> !fir.ref // CHECK: %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref // CHECK: fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref // CHECK: } // Perform the assignment i = i(10:1:-1) using the temporary array. -// CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10xi32>) { +// CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { // CHECK-NOT: %{{.*}} = fir.array_fetch // CHECK-NOT: %{{.*}} = fir.update // CHECK: %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) [%{{.*}}] %{{.*}} : (!fir.box>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref @@ -418,7 +418,7 @@ func.func @conversion_with_temporary_boxed_array(%arr0 : !fir.box // CHECK: } // Copy the result back to the original array. -// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} { +// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[COOR0:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap>, !fir.shapeshift<1>, index) -> !fir.ref // CHECK: %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref // CHECK: %[[LOAD0:.*]] = fir.load %[[COOR0:.*]] : !fir.ref @@ -459,7 +459,7 @@ func.func @array_fetch_derived_type(%0 : !fir.ref !fir.shape<1> %arr0 = fir.array_load %0(%shape) : (!fir.ref}>>>, !fir.shape<1>) -> !fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>> - %4 = fir.do_loop %arg0 = %2 to %3 step %c1 -> index { + %4 = fir.do_loop %arg0 = %2 to %3 step %c1 -> index attributes {operandSegmentSizes = array} { %6 = fir.convert %arg0 : (index) -> i32 fir.store %6 to %1 : !fir.ref %c1_i32_0 = arith.constant 1 : i32 diff --git a/flang/test/Fir/arrayset.fir b/flang/test/Fir/arrayset.fir index a9630c815fc42..3a8edf65c65fd 100644 --- a/flang/test/Fir/arrayset.fir +++ b/flang/test/Fir/arrayset.fir @@ -8,7 +8,7 @@ func.func @x(%arr : !fir.ref>) { %stepvar = arith.constant 1 : index // CHECK: alloca [10 x float], i64 1 %a = fir.alloca !fir.array<10xf32> - fir.do_loop %iv = %1 to %2 step %stepvar unordered { + fir.do_loop %iv = %1 to %2 step %stepvar unordered attributes {operandSegmentSizes = array} { %3 = fir.coordinate_of %arr, %iv : (!fir.ref>, index) -> !fir.ref // CHECK: %[[reg10:.*]] = load float, ptr %4 = fir.load %3 : !fir.ref diff --git a/flang/test/Fir/arrexp.fir b/flang/test/Fir/arrexp.fir index 5d265a5e3a08d..be27a6d754b76 100644 --- a/flang/test/Fir/arrexp.fir +++ b/flang/test/Fir/arrexp.fir @@ -7,9 +7,9 @@ func.func @f1(%a : !fir.ref>, %n : index, %m : index, %o : i %s = fir.shape_shift %o, %n, %p, %m : (index, index, index, index) -> !fir.shapeshift<2> %vIn = fir.array_load %a(%s) : (!fir.ref>, !fir.shapeshift<2>) -> !fir.array // CHECK: = icmp sgt - %r = fir.do_loop %j = %p to %m step %c1 iter_args(%v1 = %vIn) -> !fir.array { + %r = fir.do_loop %j = %p to %m step %c1 iter_args(%v1 = %vIn) -> !fir.array attributes {operandSegmentSizes = array} { // CHECK: = icmp sgt - %r = fir.do_loop %i = %o to %n step %c1 iter_args(%v = %v1) -> !fir.array { + %r = fir.do_loop %i = %o to %n step %c1 iter_args(%v = %v1) -> !fir.array attributes {operandSegmentSizes = array} { // CHECK: %[[AOFF:.*]] = getelementptr float, ptr %[[A]], i64 // CHECK: store float %[[F]], ptr %[[AOFF]] %r = fir.array_update %v, %f, %i, %j : (!fir.array, f32, index, index) -> !fir.array @@ -30,9 +30,9 @@ func.func @f2(%a : !fir.ref>, %b : !fir.ref>, !fir.shapeshift<2>) -> !fir.array %wIn = fir.array_load %b(%s) : (!fir.ref>, !fir.shapeshift<2>) -> !fir.array // CHECK: = icmp sgt - %r = fir.do_loop %j = %p to %m step %c1 iter_args(%v1 = %vIn) -> !fir.array { + %r = fir.do_loop %j = %p to %m step %c1 iter_args(%v1 = %vIn) -> !fir.array attributes {operandSegmentSizes = array} { // CHECK: = icmp sgt - %r = fir.do_loop %i = %o to %n step %c1 iter_args(%v = %v1) -> !fir.array { + %r = fir.do_loop %i = %o to %n step %c1 iter_args(%v = %v1) -> !fir.array attributes {operandSegmentSizes = array} { %x = fir.array_fetch %wIn, %i, %j : (!fir.array, index, index) -> f32 %y = arith.addf %x, %f : f32 // CHECK: %[[AOFF:.*]] = getelementptr float, ptr %[[A]], i64 @@ -54,9 +54,9 @@ func.func @f3(%a : !fir.ref>, %b : !fir.ref>, !fir.shapeshift<2>) -> !fir.array %wIn = fir.array_load %b(%s) : (!fir.ref>, !fir.shapeshift<2>) -> !fir.array // CHECK: = icmp sgt - %r = fir.do_loop %j = %p to %m step %c1 iter_args(%v1 = %vIn) -> !fir.array { + %r = fir.do_loop %j = %p to %m step %c1 iter_args(%v1 = %vIn) -> !fir.array attributes {operandSegmentSizes = array} { // CHECK: = icmp sgt - %r = fir.do_loop %i = %o to %n step %c1 iter_args(%v = %v1) -> !fir.array { + %r = fir.do_loop %i = %o to %n step %c1 iter_args(%v = %v1) -> !fir.array attributes {operandSegmentSizes = array} { %x = fir.array_fetch %wIn, %i, %j : (!fir.array, index, index) -> f32 %y = arith.addf %x, %f : f32 // CHECK: %[[AOFF:.*]] = getelementptr float, ptr %[[A]], i64 @@ -79,9 +79,9 @@ func.func @f4(%a : !fir.ref>, %b : !fir.ref>, !fir.shapeshift<2>) -> !fir.array %wIn = fir.array_load %b(%s) : (!fir.ref>, !fir.shapeshift<2>) -> !fir.array // CHECK: = icmp sgt - %r = fir.do_loop %j = %p to %m step %c1 iter_args(%v1 = %vIn) -> !fir.array { + %r = fir.do_loop %j = %p to %m step %c1 iter_args(%v1 = %vIn) -> !fir.array attributes {operandSegmentSizes = array} { // CHECK: = icmp sgt - %r = fir.do_loop %i = %o to %n step %c1 iter_args(%v = %v1) -> !fir.array { + %r = fir.do_loop %i = %o to %n step %c1 iter_args(%v = %v1) -> !fir.array attributes {operandSegmentSizes = array} { %x2 = fir.array_fetch %vIn, %i, %j : (!fir.array, index, index) -> f32 %x = fir.array_fetch %wIn, %i, %j : (!fir.array, index, index) -> f32 %y = arith.addf %x, %f : f32 @@ -111,7 +111,7 @@ func.func @f5(%arg0: !fir.box>, %arg1: !fir.box>) -> !fir.array %3 = fir.array_load %arg1 : (!fir.box>) -> !fir.array // CHECK: icmp sgt - %4 = fir.do_loop %arg3 = %c0 to %1 step %c1 iter_args(%arg4 = %2) -> (!fir.array) { + %4 = fir.do_loop %arg3 = %c0 to %1 step %c1 iter_args(%arg4 = %2) -> (!fir.array) attributes {operandSegmentSizes = array} { // CHECK: %[[B_STRIDE_GEP:.*]] = getelementptr {{.*}}, ptr %[[B]], i32 0, i32 7, i32 0, i32 2 // CHECK: %[[B_STRIDE:.*]] = load i64, ptr %[[B_STRIDE_GEP]] // CHECK: %[[B_DIM_OFFSET:.*]] = mul nsw i64 %{{.*}}, %[[B_STRIDE]] @@ -151,7 +151,7 @@ func.func @f6(%arg0: !fir.box>, %arg1: f32) { %2 = fir.array_load %arg0 [%1] : (!fir.box>, !fir.slice<1>) -> !fir.array %3 = fir.slice %c1, %c9, %c1 : (index, index, index) -> !fir.slice<1> %4 = fir.array_load %arg0 [%3] : (!fir.box>, !fir.slice<1>) -> !fir.array - %5 = fir.do_loop %arg2 = %c0 to %c9 step %c1 iter_args(%arg3 = %2) -> (!fir.array) { + %5 = fir.do_loop %arg2 = %c0 to %c9 step %c1 iter_args(%arg3 = %2) -> (!fir.array) attributes {operandSegmentSizes = array} { %6 = fir.array_fetch %4, %arg2 : (!fir.array, index) -> f32 %7 = arith.addf %6, %arg1 : f32 %8 = fir.array_update %arg3, %7, %arg2 : (!fir.array, f32, index) -> !fir.array diff --git a/flang/test/Fir/char-conversion.fir b/flang/test/Fir/char-conversion.fir index 0eaad4ca73a04..4da2c2162d081 100644 --- a/flang/test/Fir/char-conversion.fir +++ b/flang/test/Fir/char-conversion.fir @@ -16,7 +16,7 @@ func.func @char_convert() { // CHECK: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_0]] : (i32) -> index // CHECK: %[[VAL_6:.*]] = arith.subi %[[VAL_5]], %[[VAL_4]] : index -// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_3]] to %[[VAL_6]] step %[[VAL_4]] { +// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_3]] to %[[VAL_6]] step %[[VAL_4]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_1]] : (!fir.ref>) -> !fir.ref> // CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_2]] : (!fir.ref>>) -> !fir.ref> // CHECK: %[[VAL_10:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_7]] : (!fir.ref>, index) -> !fir.ref diff --git a/flang/test/Fir/convert-to-llvm-openmp-and-fir.fir b/flang/test/Fir/convert-to-llvm-openmp-and-fir.fir index 72cd0a763e71a..57ef425e0e917 100644 --- a/flang/test/Fir/convert-to-llvm-openmp-and-fir.fir +++ b/flang/test/Fir/convert-to-llvm-openmp-and-fir.fir @@ -351,7 +351,7 @@ func.func @_QPopenmp_target_data_region() { %3 = fir.convert %c1024_i32 : (i32) -> index %c1 = arith.constant 1 : index %4 = fir.convert %2 : (index) -> i32 - %5:2 = fir.do_loop %arg0 = %2 to %3 step %c1 iter_args(%arg1 = %4) -> (index, i32) { + %5:2 = fir.do_loop %arg0 = %2 to %3 step %c1 iter_args(%arg1 = %4) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %1 : !fir.ref %6 = fir.load %1 : !fir.ref %7 = fir.load %1 : !fir.ref @@ -499,7 +499,7 @@ func.func @_QPsimd_with_nested_loop() { %c10_i32_2 = arith.constant 10 : i32 %5 = fir.convert %c10_i32_2 : (i32) -> index %c1 = arith.constant 1 : index - %6 = fir.do_loop %arg1 = %4 to %5 step %c1 -> index { + %6 = fir.do_loop %arg1 = %4 to %5 step %c1 -> index attributes {operandSegmentSizes = array} { %8 = fir.convert %arg1 : (index) -> i32 fir.store %8 to %3 : !fir.ref %9 = fir.load %0 : !fir.ref @@ -655,7 +655,7 @@ func.func @_QPsb() { omp.sections { omp.section { %2 = fir.convert %c1 : (index) -> i32 - %3:2 = fir.do_loop %arg0 = %c1 to %c10 step %c1 iter_args(%arg1 = %2) -> (index, i32) { + %3:2 = fir.do_loop %arg0 = %c1 to %c10 step %c1 iter_args(%arg1 = %2) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %0 : !fir.ref %4 = fir.load %1 : !fir.ref %5 = arith.addi %4, %c1_i32 : i32 diff --git a/flang/test/Fir/embox-write.fir b/flang/test/Fir/embox-write.fir index 6068c090d4822..612619cd11b2a 100644 --- a/flang/test/Fir/embox-write.fir +++ b/flang/test/Fir/embox-write.fir @@ -10,7 +10,7 @@ func.func @set_all_n(%n : index, %x : i32) { // CHECK-DAG: %[[IV:.*]] = phi i64 // CHECK-DAG: %[[LCV:.*]] = phi i64 // CHECK: icmp sgt i64 %[[LCV]], 0 - fir.do_loop %i = %c1 to %n step %c1 unordered { + fir.do_loop %i = %c1 to %n step %c1 unordered attributes {operandSegmentSizes = array} { %1 = fir.coordinate_of %a, %i : (!fir.box>, index) -> !fir.ref // CHECK: store i32 %{{.*}}, ptr %{{.*}} fir.store %x to %1 : !fir.ref diff --git a/flang/test/Fir/fir-ops.fir b/flang/test/Fir/fir-ops.fir index 962621c4e2e1a..3b0828ed30f74 100644 --- a/flang/test/Fir/fir-ops.fir +++ b/flang/test/Fir/fir-ops.fir @@ -206,7 +206,7 @@ func.func @loop() { %c10 = arith.constant 10 : index %ct = arith.constant true -// CHECK: fir.do_loop [[VAL_65:%.*]] = [[VAL_62]] to [[VAL_63]] step [[VAL_62]] { +// CHECK: fir.do_loop [[VAL_65:%.*]] = [[VAL_62]] to [[VAL_63]] step [[VAL_62]] attributes {operandSegmentSizes = array} { // CHECK: fir.if [[VAL_64]] { // CHECK: fir.call @nop() : () -> () // CHECK: } else { @@ -215,7 +215,7 @@ func.func @loop() { // CHECK: } // CHECK: fir.unreachable // CHECK: } - fir.do_loop %i = %c1 to %c10 step %c1 { + fir.do_loop %i = %c1 to %c10 step %c1 attributes {operandSegmentSizes = array} { fir.if %ct { fir.call @nop() : () -> () } else { @@ -597,9 +597,9 @@ func.func @array_access(%arr : !fir.ref>) { %c0 = arith.constant 0 : index %c99 = arith.constant 99 : index %c1 = arith.constant 1 : index - fir.do_loop %i = %c0 to %c99 step %c1 { + fir.do_loop %i = %c0 to %c99 step %c1 attributes {operandSegmentSizes = array} { %c49 = arith.constant 49 : index - fir.do_loop %j = %c0 to %c49 step %c1 { + fir.do_loop %j = %c0 to %c49 step %c1 attributes {operandSegmentSizes = array} { // CHECK: fir.array_coor %{{.*}}(%[[sh]]) [%[[sl]]] %{{.*}}, %{{.*}} : %p = fir.array_coor %arr(%shape)[%slice] %i, %j : (!fir.ref>, !fir.shape<2>, !fir.slice<2>, index, index) -> !fir.ref %x = arith.constant 42.0 : f32 @@ -834,7 +834,7 @@ func.func @embox_tdesc(%arg0: !fir.class index %c1 = arith.constant 1 : index %3 = fir.convert %1 : (index) -> i32 - %4:2 = fir.do_loop %arg2 = %1 to %2 step %c1 iter_args(%arg3 = %3) -> (index, i32) { + %4:2 = fir.do_loop %arg2 = %1 to %2 step %c1 iter_args(%arg3 = %3) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg3 to %0 : !fir.ref %9 = fir.load %0 : !fir.ref %10 = fir.convert %9 : (i32) -> i64 diff --git a/flang/test/Fir/invalid.fir b/flang/test/Fir/invalid.fir index 049e108ba992d..25e0d179645e2 100644 --- a/flang/test/Fir/invalid.fir +++ b/flang/test/Fir/invalid.fir @@ -353,7 +353,7 @@ func.func @embox_tdesc(%arg0: !fir.class index %c1 = arith.constant 1 : index %3 = fir.convert %1 : (index) -> i32 - %4:2 = fir.do_loop %arg2 = %1 to %2 step %c1 iter_args(%arg3 = %3) -> (index, i32) { + %4:2 = fir.do_loop %arg2 = %1 to %2 step %c1 iter_args(%arg3 = %3) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg3 to %0 : !fir.ref %9 = fir.load %0 : !fir.ref %10 = fir.convert %9 : (i32) -> i64 @@ -405,14 +405,14 @@ func.func @embox_tdesc(%arg0: !fir.class index { +fir.do_loop %i = %c1 to %c10 step %c1 unordered -> index attributes {operandSegmentSizes = array} { } // ----- %c1 = arith.constant 1 : index %c10 = arith.constant 10 : index -fir.do_loop %i = %c1 to %c10 step %c1 -> index { +fir.do_loop %i = %c1 to %c10 step %c1 -> index attributes {operandSegmentSizes = array} { %f1 = arith.constant 1.0 : f32 // expected-error@+1 {{'fir.result' op types mismatch between result op and its parent}} fir.result %f1 : f32 @@ -423,7 +423,7 @@ fir.do_loop %i = %c1 to %c10 step %c1 -> index { %c1 = arith.constant 1 : index %c10 = arith.constant 10 : index // expected-error@+1 {{'fir.result' op parent of result must have same arity}} -fir.do_loop %i = %c1 to %c10 step %c1 -> index { +fir.do_loop %i = %c1 to %c10 step %c1 -> index attributes {operandSegmentSizes = array} { } // ----- @@ -770,9 +770,9 @@ func.func @foo(%arg0: !fir.ref}>> %c30 = arith.constant 30 : index %0 = fir.shape %c30 : (index) -> !fir.shape<1> %1 = fir.array_load %arg0(%0) : (!fir.ref}>>>, !fir.shape<1>) -> !fir.array<30x!fir.type}>> - %2 = fir.do_loop %arg1 = %c1 to %c9 step %c1 unordered iter_args(%arg2 = %1) -> (!fir.array<30x!fir.type}>>) { + %2 = fir.do_loop %arg1 = %c1 to %c9 step %c1 unordered iter_args(%arg2 = %1) -> (!fir.array<30x!fir.type}>>) attributes {operandSegmentSizes = array} { %3 = fir.field_index c, !fir.type}> - %4 = fir.do_loop %arg3 = %c0 to %c19 step %c1 unordered iter_args(%arg4 = %arg2) -> (!fir.array<30x!fir.type}>>) { + %4 = fir.do_loop %arg3 = %c0 to %c19 step %c1 unordered iter_args(%arg4 = %arg2) -> (!fir.array<30x!fir.type}>>) attributes {operandSegmentSizes = array} { // expected-error@+1 {{'fir.array_access' op return type and/or indices do not type check}} %5 = fir.array_access %1, %arg1, %3, %arg3 : (!fir.array<30x!fir.type}>>, index, !fir.field, index) -> !fir.ref %6 = fir.call @ifoo(%5) : (!fir.ref) -> i32 diff --git a/flang/test/Fir/loop01.fir b/flang/test/Fir/loop01.fir index c1cbb522c378c..b568a1c89be43 100644 --- a/flang/test/Fir/loop01.fir +++ b/flang/test/Fir/loop01.fir @@ -2,7 +2,7 @@ // RUN: fir-opt --split-input-file --cfg-conversion="set-nsw=true" %s | FileCheck %s --check-prefix=NSW func.func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref) { - fir.do_loop %iv = %lb to %ub step %step unordered { + fir.do_loop %iv = %lb to %ub step %step unordered attributes {operandSegmentSizes = array} { // expect following conditional blocks to get fused fir.if %b { fir.store %iv to %addr : !fir.ref @@ -137,7 +137,7 @@ func.func private @f3(i16) func.func @x3(%lo : index, %up : index) -> i1 { %c1 = arith.constant 1 : index %ok1 = arith.constant true - %ok2 = fir.do_loop %i = %lo to %up step %c1 iter_args(%j = %ok1) -> i1 { + %ok2 = fir.do_loop %i = %lo to %up step %c1 iter_args(%j = %ok1) -> i1 attributes {operandSegmentSizes = array} { %ok = fir.call @f2() : () -> i1 fir.result %ok : i1 } @@ -197,7 +197,7 @@ func.func @y3(%lo : index, %up : index) -> i1 { %c1 = arith.constant 1 : index %ok1 = arith.constant true %ok4 = fir.call @f2() : () -> i1 - %ok2:2 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok3 = %ok1) iter_args(%j = %ok4) -> i1 { + %ok2:2 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok3 = %ok1) iter_args(%j = %ok4) -> i1 attributes {operandSegmentSizes = array} { %ok = fir.call @f2() : () -> i1 fir.result %ok3, %ok : i1, i1 } @@ -268,7 +268,7 @@ func.func private @f4(i32) -> i1 // do_loop that returns the final value of the induction func.func @x4(%lo : index, %up : index) -> index { %c1 = arith.constant 1 : index - %v = fir.do_loop %i = %lo to %up step %c1 -> index { + %v = fir.do_loop %i = %lo to %up step %c1 -> index attributes {operandSegmentSizes = array} { %i1 = fir.convert %i : (index) -> i32 %ok = fir.call @f4(%i1) : (i32) -> i1 fir.result %i : index @@ -395,7 +395,7 @@ func.func @y4(%lo : index, %up : index) -> index { func.func @x5(%lo : index, %up : index) -> index { %c1 = arith.constant 1 : index %s1 = arith.constant 42 : i16 - %v:2 = fir.do_loop %i = %lo to %up step %c1 iter_args(%s = %s1) -> (index, i16) { + %v:2 = fir.do_loop %i = %lo to %up step %c1 iter_args(%s = %s1) -> (index, i16) attributes {operandSegmentSizes = array} { %ok = fir.call @f2() : () -> i1 %s2 = fir.convert %ok : (i1) -> i16 fir.result %i, %s2 : index, i16 @@ -462,7 +462,7 @@ func.func @y5(%lo : index, %up : index) -> index { %c1 = arith.constant 1 : index %s1 = arith.constant 42 : i16 %ok1 = arith.constant true - %v:3 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok2 = %ok1) iter_args(%s = %s1) -> (index, i1, i16) { + %v:3 = fir.iterate_while (%i = %lo to %up step %c1) and (%ok2 = %ok1) iter_args(%s = %s1) -> (index, i1, i16) attributes {operandSegmentSizes = array} { %ok = fir.call @f2() : () -> i1 %s2 = fir.convert %ok : (i1) -> i16 fir.result %i, %ok, %s2 : index, i1, i16 diff --git a/flang/test/Fir/loop02.fir b/flang/test/Fir/loop02.fir index 50948e0e7aa6b..c6ee3d342df46 100644 --- a/flang/test/Fir/loop02.fir +++ b/flang/test/Fir/loop02.fir @@ -4,7 +4,7 @@ func.func @x(%addr : !fir.ref) { %bound = arith.constant 452 : index %step = arith.constant 1 : index - fir.do_loop %iv = %bound to %bound step %step { + fir.do_loop %iv = %bound to %bound step %step attributes {operandSegmentSizes = array} { fir.call @y(%addr) : (!fir.ref) -> () } return diff --git a/flang/test/Fir/loop10.fir b/flang/test/Fir/loop10.fir index c0eb723826b1a..db8d9ab708f52 100644 --- a/flang/test/Fir/loop10.fir +++ b/flang/test/Fir/loop10.fir @@ -8,11 +8,11 @@ func.func @x(%addr : !fir.ref>) -> index { // CHECK-DAG: %[[R:.*]] = phi i64 {{.*}} [ 0, // CHECK-DAG: %[[ROW:.*]] = phi i64 {{.*}} [ 11, // CHECK: icmp sgt i64 %[[ROW]], 0 - fir.do_loop %iv = %c0 to %c10 step %c1 { + fir.do_loop %iv = %c0 to %c10 step %c1 attributes {operandSegmentSizes = array} { // CHECK-DAG: %[[C:.*]] = phi i64 {{.*}} [ 0, // CHECK-DAG: %[[COL:.*]] = phi i64 {{.*}} [ 11, // CHECK: icmp sgt i64 %[[COL]], 0 - fir.do_loop %jv = %c0 to %c10 step %c1 { + fir.do_loop %jv = %c0 to %c10 step %c1 attributes {operandSegmentSizes = array} { // CHECK: getelementptr {{.*}} %[[ADDR]], i32 0, i64 %[[R]], i64 %[[C]] %ptr = fir.coordinate_of %addr, %jv, %iv : (!fir.ref>, index, index) -> !fir.ref %c22 = arith.constant 22 : i32 diff --git a/flang/test/Fir/target-rewrite-boxchar.fir b/flang/test/Fir/target-rewrite-boxchar.fir index b87cb35b46eb6..d383c95c3e052 100644 --- a/flang/test/Fir/target-rewrite-boxchar.fir +++ b/flang/test/Fir/target-rewrite-boxchar.fir @@ -48,7 +48,7 @@ func.func @boxcharsret(%arg0 : !fir.boxchar<1> {llvm.sret = !fir.char<1,?>}, %ar %c1 = arith.constant 1 : index %3 = fir.convert %1#1 : (i64) -> index %last = arith.subi %3, %c1 : index - fir.do_loop %i = %c0 to %last step %c1 { + fir.do_loop %i = %c0 to %last step %c1 attributes {operandSegmentSizes = array} { %in_pos = fir.coordinate_of %2#0, %i : (!fir.ref>>, index) -> !fir.ref> %out_pos = fir.coordinate_of %1#0, %i : (!fir.ref>>, index) -> !fir.ref> %ch = fir.load %in_pos : !fir.ref> diff --git a/flang/test/Fir/target.fir b/flang/test/Fir/target.fir index 653b100bccbd4..5d6672b5fb0f0 100644 --- a/flang/test/Fir/target.fir +++ b/flang/test/Fir/target.fir @@ -130,7 +130,7 @@ func.func @char1copy(%arg0 : !fir.boxchar<1> {llvm.sret = !fir.char<1, ?>}, %arg %c1 = arith.constant 1 : index %3 = fir.convert %1#1 : (i64) -> index %last = arith.subi %3, %c1 : index - fir.do_loop %i = %c0 to %last step %c1 { + fir.do_loop %i = %c0 to %last step %c1 attributes {operandSegmentSizes = array} { %in_pos = fir.coordinate_of %2#0, %i : (!fir.ref>>, index) -> !fir.ref> %out_pos = fir.coordinate_of %1#0, %i : (!fir.ref>>, index) -> !fir.ref> %ch = fir.load %in_pos : !fir.ref> diff --git a/flang/test/Fir/tbaa-codegen2.fir b/flang/test/Fir/tbaa-codegen2.fir index e649c06731c6b..825b12e059a55 100644 --- a/flang/test/Fir/tbaa-codegen2.fir +++ b/flang/test/Fir/tbaa-codegen2.fir @@ -29,7 +29,7 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.targ %5 = fir.allocmem !fir.array, %3#1 {bindc_name = ".tmp.array", uniq_name = ""} %6 = fir.declare %5(%4) {uniq_name = ".tmp.array"} : (!fir.heap>, !fir.shape<1>) -> !fir.heap> %7 = fir.embox %6(%4) : (!fir.heap>, !fir.shape<1>) -> !fir.box> - fir.do_loop %arg1 = %c1 to %3#1 step %c1 unordered { + fir.do_loop %arg1 = %c1 to %3#1 step %c1 unordered attributes {operandSegmentSizes = array} { %16 = fir.array_coor %2 %arg1 : (!fir.box>, index) -> !fir.ref // load with tbaa %17 = fir.load %16 {tbaa = [#tbaa_tag]} : !fir.ref diff --git a/flang/test/HLFIR/all-elemental.fir b/flang/test/HLFIR/all-elemental.fir index 1ba8bb1b7a5fb..f4f6089d8e067 100644 --- a/flang/test/HLFIR/all-elemental.fir +++ b/flang/test/HLFIR/all-elemental.fir @@ -45,7 +45,7 @@ func.func @_QFPtest(%arg0: !fir.ref> {fir.bindc_name = "b"}, // CHECK-NEXT: %[[V8:.*]] = fir.shape %c7 : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V9:.*]] = hlfir.designate %[[V1]]#0 (%[[V7]], %c1:%c7:%c1) shape %[[V8]] : (!fir.ref>, i64, index, index, index, !fir.shape<1>) -> !fir.box> // CHECK-NEXT: %[[V10:.*]] = fir.load %[[V5]]#0 : !fir.ref -// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %true) -> (i1) { +// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %true) -> (i1) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V14:.*]] = hlfir.designate %[[V9]] (%arg3) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V15:.*]] = fir.load %[[V14]] : !fir.ref // CHECK-NEXT: %[[V16:.*]] = arith.cmpi sge, %[[V15]], %[[V10]] : i32 diff --git a/flang/test/HLFIR/any-elemental.fir b/flang/test/HLFIR/any-elemental.fir index 6e233068d2e9b..75daa9290d4f7 100644 --- a/flang/test/HLFIR/any-elemental.fir +++ b/flang/test/HLFIR/any-elemental.fir @@ -45,7 +45,7 @@ func.func @_QFPtest(%arg0: !fir.ref> {fir.bindc_name = "b"}, // CHECK-NEXT: %[[V8:.*]] = fir.shape %c7 : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V9:.*]] = hlfir.designate %[[V1]]#0 (%[[V7]], %c1:%c7:%c1) shape %[[V8]] : (!fir.ref>, i64, index, index, index, !fir.shape<1>) -> !fir.box> // CHECK-NEXT: %[[V10:.*]] = fir.load %[[V5]]#0 : !fir.ref -// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %false) -> (i1) { +// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %false) -> (i1) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V14:.*]] = hlfir.designate %[[V9]] (%arg3) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V15:.*]] = fir.load %[[V14]] : !fir.ref // CHECK-NEXT: %[[V16:.*]] = arith.cmpi sge, %[[V15]], %[[V10]] : i32 @@ -116,7 +116,7 @@ func.func @_Qtest_recursive() attributes {fir.bindc_name = "test"} { hlfir.assign %c1_i32 to %5#0 : i32, !fir.ref %13 = fir.load %1#0 : !fir.ref>>> %14:3 = fir.box_dims %13, %c0 : (!fir.box>>, index) -> (index, index, index) - fir.do_loop %arg0 = %c1 to %14#1 step %c1 unordered { + fir.do_loop %arg0 = %c1 to %14#1 step %c1 unordered attributes {operandSegmentSizes = array} { %27:3 = fir.box_dims %13, %c0 : (!fir.box>>, index) -> (index, index, index) %28 = arith.subi %27#0, %c1 : index %29 = arith.addi %arg0, %28 : index @@ -167,7 +167,7 @@ func.func @_Qtest_recursive() attributes {fir.bindc_name = "test"} { return } // CHECK-LABEL: func.func @_Qtest_recursive() -// CHECK: %[[V20:.*]] = fir.do_loop %arg0 = %c1 to %{{.*}} step %c1 iter_args(%arg1 = %false) -> (i1) { +// CHECK: %[[V20:.*]] = fir.do_loop %arg0 = %c1 to %{{.*}} step %c1 iter_args(%arg1 = %false) -> (i1) attributes {operandSegmentSizes = array} { // CHECK: %[[V26:.*]] = fir.load %[[V1]]#0 : !fir.ref>>> // CHECK: %[[V27:.*]]:3 = fir.box_dims %[[V26]], %c0 : (!fir.box>>, index) -> (index, index, index) // CHECK: %[[V28:.*]] = arith.addi %[[V27]]#0, %[[V27]]#1 : index @@ -178,7 +178,7 @@ func.func @_Qtest_recursive() attributes {fir.bindc_name = "test"} { // CHECK: %[[V33:.*]] = arith.select %[[V32]], %[[V31]], %c0 : index // CHECK: %[[V34:.*]] = fir.shape %[[V33]] : (index) -> !fir.shape<1> // CHECK: %[[V35:.*]] = hlfir.designate %[[V26]] (%[[V27]]#0:%[[V29]]:%c1) shape %[[V34]] : (!fir.box>>, index, index, index, !fir.shape<1>) -> !fir.box> -// CHECK: %[[V36:.*]] = fir.do_loop %arg2 = %c1 to %[[V33]] step %c1 iter_args(%arg3 = %false) -> (i1) { +// CHECK: %[[V36:.*]] = fir.do_loop %arg2 = %c1 to %[[V33]] step %c1 iter_args(%arg3 = %false) -> (i1) attributes {operandSegmentSizes = array} { // CHECK: %[[V38:.*]] = hlfir.designate %[[V35]] (%arg2) : (!fir.box>, index) -> !fir.ref // CHECK: %[[V39:.*]] = fir.load %[[V38]] : !fir.ref // CHECK: %[[V40:.*]] = arith.cmpi eq, %[[V39]], %c1_i32 : i32 diff --git a/flang/test/HLFIR/assign-codegen.fir b/flang/test/HLFIR/assign-codegen.fir index 9a21c02808c63..05eda7a8ed682 100644 --- a/flang/test/HLFIR/assign-codegen.fir +++ b/flang/test/HLFIR/assign-codegen.fir @@ -114,7 +114,7 @@ func.func @scalar_character(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>) { // CHECK: %[[VAL_19:.*]] = fir.undefined !fir.char<1> // CHECK: %[[VAL_20:.*]] = fir.insert_value %[[VAL_19]], %[[VAL_18]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> // CHECK: %[[VAL_21:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_9]] to %[[VAL_17]] step %[[VAL_21]] { +// CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_9]] to %[[VAL_17]] step %[[VAL_21]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_3]] : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_24:.*]] = fir.coordinate_of %[[VAL_23]], %[[VAL_22]] : (!fir.ref>>, index) -> !fir.ref> // CHECK: fir.store %[[VAL_20]] to %[[VAL_24]] : !fir.ref> @@ -380,7 +380,7 @@ func.func @test_upoly_expr_assignment(%arg0: !fir.class> {fir %8:2 = hlfir.declare %0 {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp.array"} : (!fir.ref>>>) -> (!fir.ref>>>, !fir.ref>>>) %22 = fir.load %8#0 : !fir.ref>>> %c1_2 = arith.constant 1 : index - fir.do_loop %arg2 = %c1_2 to %3#1 step %c1_2 unordered { + fir.do_loop %arg2 = %c1_2 to %3#1 step %c1_2 unordered attributes {operandSegmentSizes = array} { %27 = hlfir.designate %2#0 (%arg2) : (!fir.class>, index) -> !fir.class %c0_3 = arith.constant 0 : index %28:3 = fir.box_dims %22, %c0_3 : (!fir.class>>, index) -> (index, index, index) @@ -403,7 +403,7 @@ func.func @test_upoly_expr_assignment(%arg0: !fir.class> {fir // CHECK: %[[VAL_7:.*]] = fir.declare %[[VAL_2]] {fortran_attrs = #fir.var_attrs, uniq_name = ".tmp.array"} : (!fir.ref>>>) -> !fir.ref>>> // CHECK: %[[VAL_8:.*]] = fir.load %[[VAL_7]] : !fir.ref>>> // CHECK: %[[VAL_9:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_9]] to %[[VAL_6]]#1 step %[[VAL_9]] unordered { +// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_9]] to %[[VAL_6]]#1 step %[[VAL_9]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_11:.*]] = fir.array_coor %[[VAL_5]] %[[VAL_10]] : (!fir.class>, index) -> !fir.ref // CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_11]] source_box %[[VAL_5]] : (!fir.ref, !fir.class>) -> !fir.class // CHECK: %[[VAL_13:.*]] = arith.constant 0 : index diff --git a/flang/test/HLFIR/associate-codegen.fir b/flang/test/HLFIR/associate-codegen.fir index f5e015c4169f6..1b9a46d45bc69 100644 --- a/flang/test/HLFIR/associate-codegen.fir +++ b/flang/test/HLFIR/associate-codegen.fir @@ -86,7 +86,7 @@ func.func @associate_char(%arg0: !fir.boxchar<1> ) { // CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_13]], %[[VAL_14]], %[[VAL_11]], %[[VAL_12]]) : (!fir.ref, !fir.ref, i64, i1) -> () // CHECK: %[[VAL_15:.*]] = arith.constant 1 : index // CHECK: %[[VAL_16:.*]] = arith.subi %[[VAL_7]], %[[VAL_15]] : index -// CHECK: fir.do_loop %[[VAL_17:.*]] = %[[VAL_2]]#1 to %[[VAL_16]] step %[[VAL_15]] { +// CHECK: fir.do_loop %[[VAL_17:.*]] = %[[VAL_2]]#1 to %[[VAL_16]] step %[[VAL_15]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_18:.*]] = arith.subi %[[VAL_17]], %[[VAL_2]]#1 : index // CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_6]]#1 : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_20:.*]] = fir.coordinate_of %[[VAL_19]], %[[VAL_18]] : (!fir.ref>>, index) -> !fir.ref> @@ -221,8 +221,8 @@ func.func @test_shape_of(%arg0: !fir.ref>) { // CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_4]](%[[VAL_3]]) {uniq_name = ".tmp.array"} : (!fir.heap>, !fir.shape<2>) -> (!fir.heap>, !fir.heap>) // CHECK: %[[VAL_6:.*]] = arith.constant true // CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_1]] step %[[VAL_7]] unordered { -// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_2]] step %[[VAL_7]] unordered { +// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_1]] step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_2]] step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_10:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_8]], %[[VAL_9]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_10]] : !fir.ref // CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_9]], %[[VAL_8]]) : (!fir.heap>, index, index) -> !fir.ref @@ -353,7 +353,7 @@ func.func @_QPtest_multiple_expr_uses_inside_elemental() { // CHECK: %[[VAL_12:.*]]:2 = hlfir.declare %[[VAL_11]](%[[VAL_10]]) {uniq_name = ".tmp.array"} : (!fir.heap>>, !fir.shape<1>) -> (!fir.box>>, !fir.heap>>) // CHECK: %[[VAL_13:.*]] = arith.constant true // CHECK: %[[VAL_14:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_9]] step %[[VAL_14]] unordered { +// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_9]] step %[[VAL_14]] unordered attributes {operandSegmentSizes = array} { // 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>) @@ -398,7 +398,7 @@ func.func @_QPtest_multitple_associates_for_same_expr() { // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]](%[[VAL_2]]) typeparams %[[VAL_0]] {uniq_name = ".tmp.array"} : (!fir.heap>>, !fir.shape<1>, index) -> (!fir.heap>>, !fir.heap>>) // CHECK: %[[VAL_5:.*]] = arith.constant true // CHECK: %[[VAL_6:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_6]] to %[[VAL_1]] step %[[VAL_6]] unordered { +// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_6]] to %[[VAL_1]] step %[[VAL_6]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_8:.*]] = fir.undefined !fir.ref> // CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_7]]) typeparams %[[VAL_0]] : (!fir.heap>>, index, index) -> !fir.ref> // CHECK: hlfir.assign %[[VAL_8]] to %[[VAL_9]] temporary_lhs : !fir.ref>, !fir.ref> diff --git a/flang/test/HLFIR/bufferize-poly-expr.fir b/flang/test/HLFIR/bufferize-poly-expr.fir index dfa62a9ac5ab7..af5573fbc97e3 100644 --- a/flang/test/HLFIR/bufferize-poly-expr.fir +++ b/flang/test/HLFIR/bufferize-poly-expr.fir @@ -51,7 +51,7 @@ func.func @test_poly_expr_with_associate(%arg1: !fir.class !fir.shape<1> %c1 = arith.constant 1 : index - fir.do_loop %arg2 = %c1 to %c3 step %c1 { + fir.do_loop %arg2 = %c1 to %c3 step %c1 attributes {operandSegmentSizes = array} { %13 = hlfir.designate %2#0 (%arg2) : (!fir.class>>, index) -> !fir.class> %14 = hlfir.designate %9#0 (%arg2) : (!fir.class>>>, index) -> !fir.class> fir.dispatch "assign"(%13 : !fir.class>) (%13, %14 : !fir.class>, !fir.class>) {pass_arg_pos = 0 : i32} @@ -93,7 +93,7 @@ func.func @test_poly_expr_with_associate(%arg1: !fir.class !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: fir.do_loop %[[VAL_32:.*]] = %[[VAL_31]] to %[[VAL_29]] step %[[VAL_31]] attributes {operandSegmentSizes = array} { // 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} diff --git a/flang/test/HLFIR/bufferize01.fir b/flang/test/HLFIR/bufferize01.fir index 89af0c2766f94..0c23af79eedb8 100644 --- a/flang/test/HLFIR/bufferize01.fir +++ b/flang/test/HLFIR/bufferize01.fir @@ -54,7 +54,7 @@ // CHECK: %[[VAL_42:.*]]:2 = hlfir.declare %[[VAL_41]](%[[VAL_40]]) typeparams %[[VAL_39]] {uniq_name = ".tmp.array"} : (!fir.heap>>, !fir.shape<1>, index) -> (!fir.box>>, !fir.heap>>) // CHECK: %[[VAL_43:.*]] = arith.constant true // CHECK: %[[VAL_44:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_45:.*]] = %[[VAL_44]] to %[[VAL_3]] step %[[VAL_44]] { +// CHECK: fir.do_loop %[[VAL_45:.*]] = %[[VAL_44]] to %[[VAL_3]] step %[[VAL_44]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_46:.*]] = fir.box_elesize %[[VAL_35]] : (!fir.box>>>) -> index // CHECK: %[[VAL_47:.*]] = hlfir.designate %[[VAL_35]] (%[[VAL_45]]) typeparams %[[VAL_46]] : (!fir.box>>>, index, index) -> !fir.boxchar<1> // CHECK: %[[VAL_48:.*]] = arith.constant false diff --git a/flang/test/HLFIR/char_extremum-bufferization.fir b/flang/test/HLFIR/char_extremum-bufferization.fir index 4ce1471ae3271..c0928a70d4abe 100644 --- a/flang/test/HLFIR/char_extremum-bufferization.fir +++ b/flang/test/HLFIR/char_extremum-bufferization.fir @@ -49,7 +49,7 @@ func.func @_QPmax1(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.b // CHECK: %[[VAL_24:.*]] = fir.undefined !fir.char<1> // CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> // CHECK: %[[C1_0:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_18:.*]] to %[[VAL_23]] step %[[C1_0]] { +// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_18:.*]] to %[[VAL_23]] step %[[C1_0]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_16]] : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_31:.*]] = fir.coordinate_of %[[VAL_30]], %[[ARG3]] : (!fir.ref>>, index) -> !fir.ref> // CHECK: fir.store %[[VAL_25:.*]] to %[[VAL_31]] : !fir.ref> @@ -110,7 +110,7 @@ func.func @_QPmin1(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.b // CHECK: %[[VAL_24:.*]] = fir.undefined !fir.char<1> // CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> // CHECK: %[[C1_0:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_18:.*]] to %[[VAL_23]] step %[[C1_0]] { +// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_18:.*]] to %[[VAL_23]] step %[[C1_0]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_16]] : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_31:.*]] = fir.coordinate_of %[[VAL_30]], %[[ARG3]] : (!fir.ref>>, index) -> !fir.ref> // CHECK: fir.store %[[VAL_25:.*]] to %[[VAL_31]] : !fir.ref> @@ -205,7 +205,7 @@ func.func @_QPmax2(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.b // CHECK: %[[VAL_34:.*]] = fir.undefined !fir.char<1> // CHECK: %[[VAL_35:.*]] = fir.insert_value %[[VAL_34]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> // CHECK: %[[C1_4:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_28:.*]] to %[[VAL_33]] step %[[C1_4]] { +// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_28:.*]] to %[[VAL_33]] step %[[C1_4]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_26]] : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_43:.*]] = fir.coordinate_of %[[VAL_42]], %[[ARG3]] : (!fir.ref>>, index) -> !fir.ref> // CHECK: fir.store %[[VAL_35:.*]] to %[[VAL_43]] : !fir.ref> @@ -303,7 +303,7 @@ func.func @_QPmin2(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.b // CHECK: %[[VAL_34:.*]] = fir.undefined !fir.char<1> // CHECK: %[[VAL_35:.*]] = fir.insert_value %[[VAL_34]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> // CHECK: %[[C1_4:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_28:.*]] to %[[VAL_33]] step %[[C1_4]] { +// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_28:.*]] to %[[VAL_33]] step %[[C1_4]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_26]] : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_43:.*]] = fir.coordinate_of %[[VAL_42]], %[[ARG3]] : (!fir.ref>>, index) -> !fir.ref> // CHECK: fir.store %[[VAL_35:.*]] to %[[VAL_43]] : !fir.ref> @@ -382,7 +382,7 @@ func.func @_QPmax3(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.b // CHECK: %[[VAL_36:.*]] = fir.undefined !fir.char<1> // CHECK: %[[VAL_37:.*]] = fir.insert_value %[[VAL_36]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> // CHECK: %[[C1_1:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[ARG4:.*]] = %[[VAL_30:.*]] to %[[VAL_35]] step %[[C1_1]] { +// CHECK: fir.do_loop %[[ARG4:.*]] = %[[VAL_30:.*]] to %[[VAL_35]] step %[[C1_1]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_28]] : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_43:.*]] = fir.coordinate_of %[[VAL_42]], %[[ARG4]] : (!fir.ref>>, index) -> !fir.ref> // CHECK: fir.store %[[VAL_37:.*]] to %[[VAL_43]] : !fir.ref> @@ -458,7 +458,7 @@ func.func @_QPmin3(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.b // CHECK: %[[VAL_36:.*]] = fir.undefined !fir.char<1> // CHECK: %[[VAL_37:.*]] = fir.insert_value %[[VAL_36]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> // CHECK: %[[C1_1:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[ARG4:.*]] = %[[VAL_30:.*]] to %[[VAL_35]] step %[[C1_1]] { +// CHECK: fir.do_loop %[[ARG4:.*]] = %[[VAL_30:.*]] to %[[VAL_35]] step %[[C1_1]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_28]] : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_43:.*]] = fir.coordinate_of %[[VAL_42]], %[[ARG4]] : (!fir.ref>>, index) -> !fir.ref> // CHECK: fir.store %[[VAL_37:.*]] to %[[VAL_43]] : !fir.ref> diff --git a/flang/test/HLFIR/concat-bufferization.fir b/flang/test/HLFIR/concat-bufferization.fir index a68cc3c1ed2ca..52660a3c2af2b 100644 --- a/flang/test/HLFIR/concat-bufferization.fir +++ b/flang/test/HLFIR/concat-bufferization.fir @@ -37,7 +37,7 @@ func.func @concat(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>, %arg2: !fir.bo // CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_16]], %[[VAL_17]], %[[VAL_14]], %[[VAL_15]]) : (!fir.ref, !fir.ref, i64, i1) -> () // CHECK: %[[VAL_18:.*]] = arith.constant 1 : index // CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_10]], %[[VAL_18]] : index -// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_5]]#1 to %[[VAL_19]] step %[[VAL_18]] { +// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_5]]#1 to %[[VAL_19]] step %[[VAL_18]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_21:.*]] = arith.subi %[[VAL_20]], %[[VAL_5]]#1 : index // CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_8]]#1 : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_23:.*]] = fir.coordinate_of %[[VAL_22]], %[[VAL_21]] : (!fir.ref>>, index) -> !fir.ref> @@ -91,7 +91,7 @@ func.func @concat_chained(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>, %arg2: // CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_19]], %[[VAL_20]], %[[VAL_17]], %[[VAL_18]]) : (!fir.ref, !fir.ref, i64, i1) -> () // CHECK: %[[VAL_21:.*]] = arith.constant 1 : index // CHECK: %[[VAL_22:.*]] = arith.subi %[[VAL_13]], %[[VAL_21]] : index -// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_6]]#1 to %[[VAL_22]] step %[[VAL_21]] { +// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_6]]#1 to %[[VAL_22]] step %[[VAL_21]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_24:.*]] = arith.subi %[[VAL_23]], %[[VAL_6]]#1 : index // CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_9]]#1 : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_26:.*]] = fir.coordinate_of %[[VAL_25]], %[[VAL_24]] : (!fir.ref>>, index) -> !fir.ref> @@ -113,7 +113,7 @@ func.func @concat_chained(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>, %arg2: // CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_38]], %[[VAL_39]], %[[VAL_36]], %[[VAL_37]]) : (!fir.ref, !fir.ref, i64, i1) -> () // CHECK: %[[VAL_40:.*]] = arith.constant 1 : index // CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_32]], %[[VAL_40]] : index -// CHECK: fir.do_loop %[[VAL_42:.*]] = %[[VAL_13]] to %[[VAL_41]] step %[[VAL_40]] { +// CHECK: fir.do_loop %[[VAL_42:.*]] = %[[VAL_13]] to %[[VAL_41]] step %[[VAL_40]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_42]], %[[VAL_13]] : index // CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_11]]#1 : (!fir.ref>) -> !fir.ref>> // CHECK: %[[VAL_45:.*]] = fir.coordinate_of %[[VAL_44]], %[[VAL_43]] : (!fir.ref>>, index) -> !fir.ref> diff --git a/flang/test/HLFIR/convert-assign-inside-openacc-recipe.fir b/flang/test/HLFIR/convert-assign-inside-openacc-recipe.fir index 5a272bb95cc27..d7c44ce49a513 100644 --- a/flang/test/HLFIR/convert-assign-inside-openacc-recipe.fir +++ b/flang/test/HLFIR/convert-assign-inside-openacc-recipe.fir @@ -28,7 +28,7 @@ acc.reduction.recipe @reduction_add_box_heap_Uxi32 : !fir.box>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) %true = arith.constant true %c1_0 = arith.constant 1 : index - fir.do_loop %arg5 = %c1_0 to %4 step %c1_0 unordered { + fir.do_loop %arg5 = %c1_0 to %4 step %c1_0 unordered attributes {operandSegmentSizes = array} { %13 = hlfir.designate %6 (%arg5) : (!fir.box>>, index) -> !fir.ref %14 = hlfir.designate %7 (%arg5) : (!fir.box>>, index) -> !fir.ref %15 = fir.load %13 : !fir.ref diff --git a/flang/test/HLFIR/count-elemental.fir b/flang/test/HLFIR/count-elemental.fir index 0df5cc3c031ea..3f5b65db76356 100644 --- a/flang/test/HLFIR/count-elemental.fir +++ b/flang/test/HLFIR/count-elemental.fir @@ -46,7 +46,7 @@ func.func @_QFPtest(%arg0: !fir.ref> {fir.bindc_name = "b"}, // CHECK-NEXT: %[[V8:.*]] = fir.shape %c7 : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V9:.*]] = hlfir.designate %[[V1]]#0 (%[[V7]], %c1:%c7:%c1) shape %[[V8]] : (!fir.ref>, i64, index, index, index, !fir.shape<1>) -> !fir.box> // CHECK-NEXT: %[[V10:.*]] = fir.load %[[V5]]#0 : !fir.ref -// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %c0_i32) -> (i32) { +// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %c0_i32) -> (i32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V13:.*]] = hlfir.designate %[[V9]] (%arg3) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V13]] : !fir.ref // CHECK-NEXT: %[[V15:.*]] = arith.cmpi sge, %[[V14]], %[[V10]] : i32 @@ -104,7 +104,7 @@ func.func @_QFPtest_kind2(%arg0: !fir.ref> {fir.bindc_name = // CHECK-NEXT: %[[V8:.*]] = fir.shape %c7 : (index) -> !fir.shape<1> // CHECK-NEXT: %[[V9:.*]] = hlfir.designate %[[V1]]#0 (%[[V7]], %c1:%c7:%c1) shape %[[V8]] : (!fir.ref>, i64, index, index, index, !fir.shape<1>) -> !fir.box> // CHECK-NEXT: %[[V10:.*]] = fir.load %[[V5]]#0 : !fir.ref -// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %c0_i16) -> (i16) { +// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %c0_i16) -> (i16) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V13:.*]] = hlfir.designate %[[V9]] (%arg3) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V13]] : !fir.ref // CHECK-NEXT: %[[V15:.*]] = arith.cmpi sge, %[[V14]], %[[V10]] : i32 @@ -191,9 +191,9 @@ func.func @_QFPtest_multi(%arg0: !fir.ref> {fir.bindc_name // CHECK-NEXT: %[[V5:.*]]:2 = hlfir.declare %arg2 {uniq_name = "_QFFtestEval"} : (!fir.ref) -> (!fir.ref, !fir.ref) // CHECK-NEXT: %[[V6:.*]] = hlfir.designate %[[V1]]#0 (%c1:%c4:%c1, %c1:%c7:%c1, %c1:%c2:%c1) shape %[[V0]] : (!fir.ref>, index, index, index, index, index, index, index, index, index, !fir.shape<3>) -> !fir.ref> // CHECK-NEXT: %[[V7:.*]] = fir.load %[[V5]]#0 : !fir.ref -// CHECK-NEXT: %[[V8:.*]] = fir.do_loop %arg3 = %c1 to %c2 step %c1 iter_args(%arg4 = %c0_i32) -> (i32) { -// CHECK-NEXT: %[[V10:.*]] = fir.do_loop %arg5 = %c1 to %c7 step %c1 iter_args(%arg6 = %arg4) -> (i32) { -// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg7 = %c1 to %c4 step %c1 iter_args(%arg8 = %arg6) -> (i32) { +// CHECK-NEXT: %[[V8:.*]] = fir.do_loop %arg3 = %c1 to %c2 step %c1 iter_args(%arg4 = %c0_i32) -> (i32) attributes {operandSegmentSizes = array} { +// CHECK-NEXT: %[[V10:.*]] = fir.do_loop %arg5 = %c1 to %c7 step %c1 iter_args(%arg6 = %arg4) -> (i32) attributes {operandSegmentSizes = array} { +// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg7 = %c1 to %c4 step %c1 iter_args(%arg8 = %arg6) -> (i32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V12:.*]] = hlfir.designate %[[V6]] (%arg7, %arg5, %arg3) : (!fir.ref>, index, index, index) -> !fir.ref // CHECK-NEXT: %[[V13:.*]] = fir.load %[[V12]] : !fir.ref // CHECK-NEXT: %[[V14:.*]] = arith.cmpi sge, %[[V13]], %[[V7]] : i32 @@ -249,7 +249,7 @@ func.func @_QFPtest_rec_sum(%arg0: !fir.ref> {fir.bindc_name return %14 : i32 } // CHECK-LABEL: func.func @_QFPtest_rec_sum(%arg0: !fir.ref> {fir.bindc_name = "b"}, %arg1: !fir.ref {fir.bindc_name = "row"}, %arg2: !fir.ref {fir.bindc_name = "val"}) -> i32 { -// CHECK: %[[V12:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %c0_i32) -> (i32) { +// CHECK: %[[V12:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %c0_i32) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[V14:.*]] = hlfir.sum %[[V11]] : (!hlfir.expr<7xi32>) -> i32 // CHECK: %[[V15:.*]] = arith.cmpi sge, %[[V14]], %[[V10]] : i32 // CHECK: %[[V16:.*]] = arith.addi %arg4, %c1_i32 : i32 @@ -298,8 +298,8 @@ func.func @_QFPtest_rec_count(%arg0: !fir.ref> {fir.bindc_na return %14 : i32 } // CHECK-LABEL: func.func @_QFPtest_rec_count(%arg0: !fir.ref> {fir.bindc_name = "b"}, %arg1: !fir.ref {fir.bindc_name = "row"}, %arg2: !fir.ref {fir.bindc_name = "val"}) -> i32 { -// CHECK: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %c0_i32) -> (i32) { -// CHECK: %[[V13:.*]] = fir.do_loop %arg5 = %c1 to %c7 step %c1 iter_args(%arg6 = %c0_i32) -> (i32) { +// CHECK: %[[V11:.*]] = fir.do_loop %arg3 = %c1 to %c7 step %c1 iter_args(%arg4 = %c0_i32) -> (i32) attributes {operandSegmentSizes = array} { +// CHECK: %[[V13:.*]] = fir.do_loop %arg5 = %c1 to %c7 step %c1 iter_args(%arg6 = %c0_i32) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[V17:.*]] = hlfir.designate %[[V9]] (%arg5) : (!fir.box>, index) -> !fir.ref // CHECK: %[[V18:.*]] = fir.load %[[V17]] : !fir.ref // CHECK: %[[V19:.*]] = arith.cmpi sge, %[[V18]], %[[V10]] : i32 diff --git a/flang/test/HLFIR/elemental-codegen-nested.fir b/flang/test/HLFIR/elemental-codegen-nested.fir index 3ef296249c7d6..7780f232393d8 100644 --- a/flang/test/HLFIR/elemental-codegen-nested.fir +++ b/flang/test/HLFIR/elemental-codegen-nested.fir @@ -19,13 +19,13 @@ // CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_13]](%[[VAL_12]]) {uniq_name = ".tmp.array"} : (!fir.heap>, !fir.shape<1>) -> (!fir.heap>, !fir.heap>) // CHECK: %[[VAL_15:.*]] = arith.constant true // CHECK: %[[VAL_16:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_17:.*]] = %[[VAL_16]] to %[[VAL_2]] step %[[VAL_16]] { +// CHECK: fir.do_loop %[[VAL_17:.*]] = %[[VAL_16]] to %[[VAL_2]] step %[[VAL_16]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_18:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_19:.*]] = fir.allocmem !fir.array<2xf32> {bindc_name = ".tmp.array", uniq_name = ""} // CHECK: %[[VAL_20:.*]]:2 = hlfir.declare %[[VAL_19]](%[[VAL_18]]) {uniq_name = ".tmp.array"} : (!fir.heap>, !fir.shape<1>) -> (!fir.heap>, !fir.heap>) // CHECK: %[[VAL_21:.*]] = arith.constant true // CHECK: %[[VAL_22:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_22]] to %[[VAL_2]] step %[[VAL_22]] { +// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_22]] to %[[VAL_2]] step %[[VAL_22]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_24:.*]] = fir.load %[[VAL_11]]#0 : !fir.ref // CHECK: %[[VAL_25:.*]] = hlfir.designate %[[VAL_20]]#0 (%[[VAL_23]]) : (!fir.heap>, index) -> !fir.ref // CHECK: hlfir.assign %[[VAL_24]] to %[[VAL_25]] temporary_lhs : f32, !fir.ref diff --git a/flang/test/HLFIR/elemental-codegen.fir b/flang/test/HLFIR/elemental-codegen.fir index 0d5f343cb1771..8472454a1a8df 100644 --- a/flang/test/HLFIR/elemental-codegen.fir +++ b/flang/test/HLFIR/elemental-codegen.fir @@ -26,8 +26,8 @@ func.func @numeric_type(%arg0: !fir.ref>, %arg1: !fir.ref< // CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_4]]) {uniq_name = ".tmp.array"} : (!fir.heap>, !fir.shape<2>) -> (!fir.heap>, !fir.heap>) // CHECK: %[[VAL_7:.*]] = arith.constant true // CHECK: %[[VAL_8:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_8]] to %[[VAL_3]] step %[[VAL_8]] { -// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_8]] to %[[VAL_2]] step %[[VAL_8]] { +// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_8]] to %[[VAL_3]] step %[[VAL_8]] attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_8]] to %[[VAL_2]] step %[[VAL_8]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_11:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_10]], %[[VAL_9]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_1]] (%[[VAL_10]], %[[VAL_9]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_13:.*]] = fir.load %[[VAL_11]] : !fir.ref @@ -62,7 +62,7 @@ func.func @char_type(%arg0: !fir.box>>, %arg1: index // CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_4]]) typeparams %[[VAL_2]] {uniq_name = ".tmp.array"} : (!fir.heap>>, !fir.shape<1>, index) -> (!fir.box>>, !fir.heap>>) // CHECK: %[[VAL_7:.*]] = arith.constant true // CHECK: %[[VAL_8:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_8]] to %[[VAL_1]] step %[[VAL_8]] { +// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_8]] to %[[VAL_1]] step %[[VAL_8]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_10:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_9]]) typeparams %[[VAL_3]] : (!fir.box>>, index, index) -> !fir.boxchar<1> // concatenation // CHECK: %[[VAL_30:.*]]:2 = hlfir.declare %[[VAL_14:.*]] typeparams %[[VAL_13:.*]] {uniq_name = "tmp"} : (!fir.ref>, index) -> (!fir.boxchar<1>, !fir.ref>) @@ -97,8 +97,8 @@ func.func @derived_transpose(%arg0: !fir.box>>, !fir.shape<2>) -> (!fir.box>>, !fir.heap>>) // CHECK: %[[VAL_6:.*]] = arith.constant true // CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_1]] step %[[VAL_7]] { -// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_2]] step %[[VAL_7]] { +// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_1]] step %[[VAL_7]] attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_2]] step %[[VAL_7]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_10:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_9]], %[[VAL_8]]) : (!fir.box>>, index, index) -> !fir.box> // CHECK: %[[VAL_11:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_9]], %[[VAL_8]]) : (!fir.box>>, index, index) -> !fir.ref> // CHECK: hlfir.assign %[[VAL_10]] to %[[VAL_11]] temporary_lhs : !fir.box>, !fir.ref> @@ -127,8 +127,8 @@ func.func @unordered() { // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]](%[[VAL_2]]) {uniq_name = ".tmp.array"} : (!fir.heap>, !fir.shape<2>) -> (!fir.heap>, !fir.heap>) // CHECK: %[[VAL_5:.*]] = arith.constant true // CHECK: %[[VAL_6:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_6]] to %[[VAL_1]] step %[[VAL_6]] unordered { -// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_6]] to %[[VAL_0]] step %[[VAL_6]] unordered { +// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_6]] to %[[VAL_1]] step %[[VAL_6]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_6]] to %[[VAL_0]] step %[[VAL_6]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_9:.*]] = arith.constant 0 : i32 // CHECK: %[[VAL_10:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_8]], %[[VAL_7]]) : (!fir.heap>, index, index) -> !fir.ref // CHECK: hlfir.assign %[[VAL_9]] to %[[VAL_10]] temporary_lhs : i32, !fir.ref @@ -195,8 +195,8 @@ func.func @test_polymorphic(%arg0: !fir.class> {fir.bindc_ // CHECK: %[[VAL_38:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_36]], %[[VAL_34]], %[[VAL_35]], %[[VAL_37]], %[[VAL_33]]) : (!fir.ref>, i1, !fir.box, !fir.ref, i32) -> i32 // 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: fir.do_loop %[[VAL_41:.*]] = %[[VAL_40]] to %[[EX1]] step %[[VAL_40]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_42:.*]] = %[[VAL_40]] to %[[EX0]] step %[[VAL_40]] unordered attributes {operandSegmentSizes = array} { // 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) @@ -279,8 +279,8 @@ func.func @test_polymorphic_expr(%arg0: !fir.class> {fir.b // CHECK: %[[VAL_39:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_37]], %[[VAL_35]], %[[VAL_36]], %[[VAL_38]], %[[VAL_34]]) : (!fir.ref>, i1, !fir.box, !fir.ref, i32) -> i32 // 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: fir.do_loop %[[VAL_42:.*]] = %[[VAL_41]] to %[[VAL_3]] step %[[VAL_41]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_43:.*]] = %[[VAL_41]] to %[[VAL_2]] step %[[VAL_41]] unordered attributes {operandSegmentSizes = array} { // 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) @@ -332,8 +332,8 @@ func.func @test_polymorphic_expr(%arg0: !fir.class> {fir.b // CHECK: %[[VAL_88:.*]] = fir.call @_FortranAAllocatableAllocate(%[[VAL_86]], %[[VAL_84]], %[[VAL_85]], %[[VAL_87]], %[[VAL_83]]) : (!fir.ref>, i1, !fir.box, !fir.ref, i32) -> i32 // 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: fir.do_loop %[[VAL_91:.*]] = %[[VAL_90]] to %[[VAL_3]] step %[[VAL_90]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_92:.*]] = %[[VAL_90]] to %[[VAL_2]] step %[[VAL_90]] unordered attributes {operandSegmentSizes = array} { // 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> diff --git a/flang/test/HLFIR/elemental-shallow-copy.fir b/flang/test/HLFIR/elemental-shallow-copy.fir index c57a2766e318d..9f9b3219a87a5 100644 --- a/flang/test/HLFIR/elemental-shallow-copy.fir +++ b/flang/test/HLFIR/elemental-shallow-copy.fir @@ -23,7 +23,7 @@ func.func @_QMtypesPtest() { // CHECK: %[[VAL_2:.*]] = fir.alloca !fir.type<_QMtypesTt{x:!fir.box>}> {bindc_name = ".result"} // CHECK: %[[VAL_6:.*]] = fir.allocmem !fir.array<1x!fir.type<_QMtypesTt{x:!fir.box>}>> {bindc_name = ".tmp.array", uniq_name = ""} // CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]](%{{.*}}) {uniq_name = ".tmp.array"} : (!fir.heap>}>>>, !fir.shape<1>) -> (!fir.heap>}>>>, !fir.heap>}>>>) -// CHECK: fir.do_loop %[[VAL_10:.*]] = %{{.*}} to %{{.*}} step %{{.*}} { +// CHECK: fir.do_loop %[[VAL_10:.*]] = %{{.*}} to %{{.*}} step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_11:.*]]:2 = hlfir.declare %[[VAL_2]] {uniq_name = ".tmp.func_result"} : (!fir.ref>}>>) -> (!fir.ref>}>>, !fir.ref>}>>) // CHECK: %[[VAL_15:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_10]]) : (!fir.heap>}>>>, index) -> !fir.ref>}>> // CHECK: %[[VAL_16:.*]] = fir.load %[[VAL_11]]#0 : !fir.ref>}>> diff --git a/flang/test/HLFIR/extents-of-shape-of.f90 b/flang/test/HLFIR/extents-of-shape-of.f90 index 1168004597d19..0482c46b08f96 100644 --- a/flang/test/HLFIR/extents-of-shape-of.f90 +++ b/flang/test/HLFIR/extents-of-shape-of.f90 @@ -20,8 +20,8 @@ elemental subroutine elem_sub(x) ! CHECK-HLFIR-NEXT: %[[EXT0:.*]] = arith.constant 2 : index ! CHECK-HLFIR-NEXT: %[[EXT1:.*]] = hlfir.get_extent %[[SHAPE]] {dim = 1 : index} : (!fir.shape<2>) -> index ! CHECK-HLFIR-NEXT: %[[C1:.*]] = arith.constant 1 : index -! CHECK-HLFIR-NEXT: fir.do_loop %[[ARG2:.*]] = %[[C1]] to %[[EXT1]] step %[[C1]] unordered { -! CHECK-HLFIR-NEXT: fir.do_loop %[[ARG3:.*]] = %[[C1]] to %[[EXT0]] step %[[C1]] unordered { +! CHECK-HLFIR-NEXT: fir.do_loop %[[ARG2:.*]] = %[[C1]] to %[[EXT1]] step %[[C1]] unordered attributes {operandSegmentSizes = array} { +! CHECK-HLFIR-NEXT: fir.do_loop %[[ARG3:.*]] = %[[C1]] to %[[EXT0]] step %[[C1]] unordered attributes {operandSegmentSizes = array} { ! CHECK-HLFIR-NEXT: %[[ELE:.*]] = hlfir.apply %[[MUL]], %[[ARG3]], %[[ARG2]] : (!hlfir.expr<2x?xf32>, index, index) -> f32 ! CHECK-HLFIR-NEXT: %[[ASSOC:.*]]:3 = hlfir.associate %[[ELE]] {adapt.valuebyref} : (f32) -> (!fir.ref, !fir.ref, i1) ! CHECK-HLFIR-NEXT: fir.call @@ -40,8 +40,8 @@ elemental subroutine elem_sub(x) ! CHECK-FIR-NEXT: %[[DIMS1:.*]]:3 = fir.box_dims %[[MUL]], %[[C1]] ! ... ! CHECK-FIR: %[[SHAPE:.*]] = fir.shape %[[DIMS0]]#1, %[[DIMS1]]#1 -! CHECK-FIR-NEXT: fir.do_loop %[[ARG2:.*]] = %[[C1]] to %[[DIMS1]]#1 step %[[C1]] unordered { -! CHECK-FIR-NEXT: fir.do_loop %[[ARG3:.*]] = %[[C1]] to %[[C2]] step %[[C1]] unordered { +! CHECK-FIR-NEXT: fir.do_loop %[[ARG2:.*]] = %[[C1]] to %[[DIMS1]]#1 step %[[C1]] unordered attributes {operandSegmentSizes = array} { +! CHECK-FIR-NEXT: fir.do_loop %[[ARG3:.*]] = %[[C1]] to %[[C2]] step %[[C1]] unordered attributes {operandSegmentSizes = array} { ! ... ! CHECK-ALL: return diff --git a/flang/test/HLFIR/inline-elemental.fir b/flang/test/HLFIR/inline-elemental.fir index 2d3beace4c759..7328d3f25ccd6 100644 --- a/flang/test/HLFIR/inline-elemental.fir +++ b/flang/test/HLFIR/inline-elemental.fir @@ -84,7 +84,7 @@ func.func @inline_to_loop(%arg0: !fir.box> {fir.bindc_name = " %array = fir.array_load %0#0 : (!fir.box>) -> !fir.array %c1 = arith.constant 1 : index %max = arith.subi %4#1, %c1 : index - %7 = fir.do_loop %arg4 = %c0 to %max step %c1 unordered iter_args(%arg5 = %array) -> (!fir.array) { + %7 = fir.do_loop %arg4 = %c0 to %max step %c1 unordered iter_args(%arg5 = %array) -> (!fir.array) attributes {operandSegmentSizes = array} { %8 = hlfir.apply %6, %arg4 : (!hlfir.expr, index) -> i32 %9 = hlfir.designate %3#0 (%arg4) : (!fir.box>, index) -> !fir.ref %10 = fir.load %9 : !fir.ref diff --git a/flang/test/HLFIR/maxloc-elemental.fir b/flang/test/HLFIR/maxloc-elemental.fir index c97117dd10de1..dfd0dc71fc981 100644 --- a/flang/test/HLFIR/maxloc-elemental.fir +++ b/flang/test/HLFIR/maxloc-elemental.fir @@ -40,7 +40,7 @@ func.func @_QPtest(%arg0: !fir.box> {fir.bindc_name = "array"} // CHECK-NEXT: fir.store %c0_i32 to %[[V0]] : !fir.ref // CHECK-NEXT: %[[V9:.*]]:3 = fir.box_dims %[[V1]]#0, %c0 : (!fir.box>, index) -> (index, index, index) // CHECK-NEXT: %[[V10:.*]] = arith.subi %[[V9]]#1, %c1 : index -// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10]] step %c1 iter_args(%arg4 = %c-2147483648_i32) -> (i32) { +// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10]] step %c1 iter_args(%arg4 = %c-2147483648_i32) -> (i32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V14:.*]] = arith.addi %arg3, %c1 : index // CHECK-NEXT: %[[V15:.*]] = hlfir.designate %[[V1]]#0 (%[[V14]]) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V16:.*]] = fir.load %[[V15]] : !fir.ref @@ -72,7 +72,7 @@ func.func @_QPtest(%arg0: !fir.box> {fir.bindc_name = "array"} // CHECK-NEXT: fir.result %[[V18]] : i32 // CHECK-NEXT: } // CHECK-NEXT: %[[BD:.*]]:3 = fir.box_dims %[[V2]]#0, %c0 : (!fir.box>, index) -> (index, index, index) -// CHECK-NEXT: fir.do_loop %arg3 = %c1 to %[[BD]]#1 step %c1 unordered { +// CHECK-NEXT: fir.do_loop %arg3 = %c1 to %[[BD]]#1 step %c1 unordered attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V13:.*]] = hlfir.designate %[[RES]] (%arg3) : (!fir.ref>, index) -> !fir.ref // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V13]] : !fir.ref // CHECK-NEXT: %[[V15:.*]] = hlfir.designate %[[V2]]#0 (%arg3) : (!fir.box>, index) -> !fir.ref @@ -107,7 +107,7 @@ func.func @_QPtest_float(%arg0: !fir.box> {fir.bindc_name = "a } // CHECK-LABEL: _QPtest_float // CHECK: %cst = arith.constant 0xFF800000 : f32 -// CHECK: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10:.*]] step %c1 iter_args(%arg4 = %cst) -> (f32) { +// CHECK: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10:.*]] step %c1 iter_args(%arg4 = %cst) -> (f32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V14:.*]] = arith.addi %arg3, %c1 : index // CHECK-NEXT: %[[V15:.*]] = hlfir.designate %[[V1:.*]]#0 (%[[V14]]) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V16:.*]] = fir.load %[[V15]] : !fir.ref diff --git a/flang/test/HLFIR/minloc-elemental.fir b/flang/test/HLFIR/minloc-elemental.fir index 58cfe3ea01279..f3c3e9f383db1 100644 --- a/flang/test/HLFIR/minloc-elemental.fir +++ b/flang/test/HLFIR/minloc-elemental.fir @@ -40,7 +40,7 @@ func.func @_QPtest(%arg0: !fir.box> {fir.bindc_name = "array"} // CHECK-NEXT: fir.store %c0_i32 to %[[V0]] : !fir.ref // CHECK-NEXT: %[[V9:.*]]:3 = fir.box_dims %[[V1]]#0, %c0 : (!fir.box>, index) -> (index, index, index) // CHECK-NEXT: %[[V10:.*]] = arith.subi %[[V9]]#1, %c1 : index -// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) { +// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V14:.*]] = arith.addi %arg3, %c1 : index // CHECK-NEXT: %[[V15:.*]] = hlfir.designate %[[V1]]#0 (%[[V14]]) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V16:.*]] = fir.load %[[V15]] : !fir.ref @@ -72,7 +72,7 @@ func.func @_QPtest(%arg0: !fir.box> {fir.bindc_name = "array"} // CHECK-NEXT: fir.result %[[V18]] : i32 // CHECK-NEXT: } // CHECK-NEXT: %[[BD:.*]]:3 = fir.box_dims %[[V2]]#0, %c0 : (!fir.box>, index) -> (index, index, index) -// CHECK-NEXT: fir.do_loop %arg3 = %c1 to %[[BD]]#1 step %c1 unordered { +// CHECK-NEXT: fir.do_loop %arg3 = %c1 to %[[BD]]#1 step %c1 unordered attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V13:.*]] = hlfir.designate %[[RES]] (%arg3) : (!fir.ref>, index) -> !fir.ref // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V13]] : !fir.ref // CHECK-NEXT: %[[V15:.*]] = hlfir.designate %[[V2]]#0 (%arg3) : (!fir.box>, index) -> !fir.ref @@ -122,7 +122,7 @@ func.func @_QPtest_kind2(%arg0: !fir.box> {fir.bindc_name = "a // CHECK-NEXT: fir.store %c0_i16 to %[[V0]] : !fir.ref // CHECK-NEXT: %[[V9:.*]]:3 = fir.box_dims %[[V1]]#0, %c0 : (!fir.box>, index) -> (index, index, index) // CHECK-NEXT: %[[V10:.*]] = arith.subi %[[V9]]#1, %c1 : index -// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) { +// CHECK-NEXT: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V14:.*]] = arith.addi %arg3, %c1 : index // CHECK-NEXT: %[[V15:.*]] = hlfir.designate %[[V1]]#0 (%[[V14]]) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V16:.*]] = fir.load %[[V15]] : !fir.ref @@ -154,7 +154,7 @@ func.func @_QPtest_kind2(%arg0: !fir.box> {fir.bindc_name = "a // CHECK-NEXT: fir.result %[[V18]] : i32 // CHECK-NEXT: } // CHECK-NEXT: %[[BD:.*]]:3 = fir.box_dims %[[V2]]#0, %c0 : (!fir.box>, index) -> (index, index, index) -// CHECK-NEXT: fir.do_loop %arg3 = %c1 to %[[BD]]#1 step %c1 unordered { +// CHECK-NEXT: fir.do_loop %arg3 = %c1 to %[[BD]]#1 step %c1 unordered attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V13:.*]] = hlfir.designate %[[RES]] (%arg3) : (!fir.ref>, index) -> !fir.ref // CHECK-NEXT: %[[V14:.*]] = fir.load %[[V13]] : !fir.ref // CHECK-NEXT: %[[V15:.*]] = hlfir.designate %[[V2]]#0 (%arg3) : (!fir.box>, index) -> !fir.ref @@ -215,7 +215,7 @@ func.func @_QPtest_kind2_convert(%arg0: !fir.box> {fir.bindc_n // CHECK-NEXT: fir.store %c0_i16 to %[[V0]] : !fir.ref // CHECK-NEXT: %[[V7:.*]]:3 = fir.box_dims %[[V2]]#0, %c0 : (!fir.box>, index) -> (index, index, index) // CHECK-NEXT: %[[V8:.*]] = arith.subi %[[V7]]#1, %c1 : index -// CHECK-NEXT: %[[V9:.*]] = fir.do_loop %arg3 = %c0 to %[[V8]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) { +// CHECK-NEXT: %[[V9:.*]] = fir.do_loop %arg3 = %c0 to %[[V8]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V15:.*]] = arith.addi %arg3, %c1 : index // CHECK-NEXT: %[[V16:.*]] = hlfir.designate %[[V2]]#0 (%[[V15]]) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V17:.*]] = fir.load %[[V16]] : !fir.ref @@ -284,7 +284,7 @@ func.func @_QPtest_float(%arg0: !fir.box> {fir.bindc_name = "a } // CHECK-LABEL: _QPtest_float // CHECK: %cst = arith.constant 0x7F800000 : f32 -// CHECK: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10:.*]] step %c1 iter_args(%arg4 = %cst) -> (f32) { +// CHECK: %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10:.*]] step %c1 iter_args(%arg4 = %cst) -> (f32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %[[V14:.*]] = arith.addi %arg3, %c1 : index // CHECK-NEXT: %[[V15:.*]] = hlfir.designate %[[V1:.*]]#0 (%[[V14]]) : (!fir.box>, index) -> !fir.ref // CHECK-NEXT: %[[V16:.*]] = fir.load %[[V15]] : !fir.ref @@ -419,5 +419,5 @@ func.func @_QPtest_parts(%arg0: !fir.box> {fir.bindc_name = "x } // Characters are not supported at the moment // CHECK-LABEL: _QPtest_parts -// CHECK: fir.do_loop %{{.*}} = %c0 to %{{.*}} step %c1 iter_args(%{{.*}} = %c2147483647_i32) -> (i32) { +// CHECK: fir.do_loop %{{.*}} = %c0 to %{{.*}} step %c1 iter_args(%{{.*}} = %c2147483647_i32) -> (i32) attributes {operandSegmentSizes = array} { diff --git a/flang/test/HLFIR/opt-array-slice-assign.fir b/flang/test/HLFIR/opt-array-slice-assign.fir index 11bd97c115834..764266be2fc60 100644 --- a/flang/test/HLFIR/opt-array-slice-assign.fir +++ b/flang/test/HLFIR/opt-array-slice-assign.fir @@ -40,8 +40,8 @@ func.func @_QPtest1(%arg0: !fir.ref> {fir.bindc_name return } // CHECK-LABEL: func.func @_QPtest1( -// CHECK: fir.do_loop %[[VAL_21:.*]] = -// CHECK: fir.do_loop %[[VAL_22:.*]] = +// CHECK: fir.do_loop %[[VAL_21:.*]] = {{.*}} attributes {{.*}} +// CHECK: fir.do_loop %[[VAL_22:.*]] = {{.*}} attributes {{.*}} // CHECK: %[[VAL_23:.*]] = hlfir.designate %[[VAL_17:.*]] (%[[VAL_22]], %[[VAL_21]]) : (!fir.box>, index, index) -> !fir.ref // CHECK: %[[VAL_24:.*]] = fir.load %[[VAL_23]] : !fir.ref // CHECK: %[[VAL_25:.*]] = hlfir.no_reassoc %[[VAL_24]] : f32 @@ -73,8 +73,8 @@ func.func @_QPtest2(%arg0: !fir.ref>>> return } // CHECK-LABEL: func.func @_QPtest2( -// CHECK: fir.do_loop %[[VAL_11:.*]] = -// CHECK: fir.do_loop %[[VAL_12:.*]] = +// CHECK: fir.do_loop %[[VAL_11:.*]] = {{.*}} attributes {{.*}} +// CHECK: fir.do_loop %[[VAL_12:.*]] = {{.*}} attributes {{.*}} // CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_9:.*]] (%[[VAL_12]], %[[VAL_11]]) : (!fir.box>, index, index) -> !fir.ref // CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_13]] : !fir.ref // CHECK: %[[VAL_15:.*]] = hlfir.no_reassoc %[[VAL_14]] : f32 @@ -119,8 +119,8 @@ func.func @_QPtest3(%arg0: !fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_27:.*]] = fir.load %[[VAL_26]] : !fir.ref // CHECK: %[[VAL_28:.*]] = hlfir.no_reassoc %[[VAL_27]] : f32 @@ -160,7 +160,7 @@ func.func @_QPtest4(%arg0: !fir.ref> {fir.bindc_name = "x"}, % %17 = fir.load %6#0 : !fir.ref %18 = fir.convert %17 : (i32) -> index %19 = fir.convert %14 : (index) -> i32 - %20:2 = fir.do_loop %arg4 = %14 to %16 step %18 iter_args(%arg5 = %19) -> (index, i32) { + %20:2 = fir.do_loop %arg4 = %14 to %16 step %18 iter_args(%arg5 = %19) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg5 to %3#1 : !fir.ref %21 = fir.load %3#0 : !fir.ref %22 = fir.load %6#0 : !fir.ref @@ -236,7 +236,7 @@ func.func @_QPtest5(%arg0: !fir.ref> {fir.bindc_name = "x"}, % %17 = fir.load %6#0 : !fir.ref %18 = fir.convert %17 : (i32) -> index %19 = fir.convert %14 : (index) -> i32 - %20:2 = fir.do_loop %arg4 = %14 to %16 step %18 iter_args(%arg5 = %19) -> (index, i32) { + %20:2 = fir.do_loop %arg4 = %14 to %16 step %18 iter_args(%arg5 = %19) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg5 to %3#1 : !fir.ref %21 = fir.load %3#0 : !fir.ref %22 = fir.load %6#0 : !fir.ref @@ -322,7 +322,7 @@ func.func @_QPtest6(%arg0: !fir.ref> {fir.bindc_name = "x"}, %25 = fir.load %14#0 : !fir.ref %26 = fir.convert %25 : (i32) -> index %27 = fir.convert %22 : (index) -> i32 - %28:2 = fir.do_loop %arg4 = %22 to %24 step %26 iter_args(%arg5 = %27) -> (index, i32) { + %28:2 = fir.do_loop %arg4 = %22 to %24 step %26 iter_args(%arg5 = %27) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg5 to %3#1 : !fir.ref %29 = fir.load %3#0 : !fir.ref %30 = fir.load %14#0 : !fir.ref diff --git a/flang/test/HLFIR/opt-bufferization-leslie3d.fir b/flang/test/HLFIR/opt-bufferization-leslie3d.fir index 351b3754cf4db..1453abb532e97 100644 --- a/flang/test/HLFIR/opt-bufferization-leslie3d.fir +++ b/flang/test/HLFIR/opt-bufferization-leslie3d.fir @@ -48,12 +48,12 @@ func.func @_QPupdate() { %21 = arith.subi %20, %c1_i32 : i32 %22 = fir.convert %21 : (i32) -> index %23 = fir.convert %c1 : (index) -> i32 - %24:2 = fir.do_loop %arg0 = %c1 to %22 step %c1 iter_args(%arg1 = %23) -> (index, i32) { + %24:2 = fir.do_loop %arg0 = %c1 to %22 step %c1 iter_args(%arg1 = %23) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg1 to %11#1 : !fir.ref %25 = fir.load %9#0 : !fir.ref %26 = arith.subi %25, %c1_i32 : i32 %27 = fir.convert %26 : (i32) -> index - %28:2 = fir.do_loop %arg2 = %c1 to %27 step %c1 iter_args(%arg3 = %23) -> (index, i32) { + %28:2 = fir.do_loop %arg2 = %c1 to %27 step %c1 iter_args(%arg3 = %23) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg3 to %7#1 : !fir.ref %32 = fir.load %17#0 : !fir.ref>>> %33 = fir.load %3#0 : !fir.ref diff --git a/flang/test/HLFIR/opt-bufferization.fir b/flang/test/HLFIR/opt-bufferization.fir index faa8f4bcdb778..4896ffa210431 100644 --- a/flang/test/HLFIR/opt-bufferization.fir +++ b/flang/test/HLFIR/opt-bufferization.fir @@ -24,7 +24,7 @@ func.func @simple(%arg: !fir.ref>) { // CHECK: %[[VAL_3:.*]] = arith.constant 1 : i32 // CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_0]](%[[VAL_4]]) {uniq_name = "array"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) -// CHECK: fir.do_loop %[[VAL_6:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered { +// CHECK: fir.do_loop %[[VAL_6:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_7:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_6]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_8:.*]] = fir.load %[[VAL_7]] : !fir.ref // CHECK: %[[VAL_9:.*]] = arith.subi %[[VAL_8]], %[[VAL_3]] : i32 @@ -61,7 +61,7 @@ func.func @read_no_alias(%arg: !fir.ref>, %arg1: !fir.ref !fir.shape<1> // CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_0]](%[[VAL_4]]) {uniq_name = "array"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_4]]) {uniq_name = "other"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) -// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered { +// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_8:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_7]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_7]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_8]] : !fir.ref @@ -135,8 +135,8 @@ func.func @two_dimensional(%arg: !fir.ref>) { // CHECK: %[[VAL_3:.*]] = arith.constant 1 : i32 // CHECK: %[[VAL_4:.*]] = fir.shape %[[VAL_2]], %[[VAL_2]] : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_0]](%[[VAL_4]]) {uniq_name = "array"} : (!fir.ref>, !fir.shape<2>) -> (!fir.ref>, !fir.ref>) -// CHECK: fir.do_loop %[[VAL_6:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered { -// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered { +// CHECK: fir.do_loop %[[VAL_6:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_8:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_7]], %[[VAL_6]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_8]] : !fir.ref // CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_9]], %[[VAL_3]] : i32 @@ -423,7 +423,7 @@ func.func @_QMmPrepro(%arg0: !fir.ref {fir.bindc_name = "imin"}, %arg1: !fi %12 = fir.load %7#0 : !fir.ref %13 = fir.convert %12 : (i32) -> index %14 = fir.convert %11 : (index) -> i32 - %15:2 = fir.do_loop %arg3 = %11 to %13 step %c1 iter_args(%arg4 = %14) -> (index, i32) { + %15:2 = fir.do_loop %arg3 = %11 to %13 step %c1 iter_args(%arg4 = %14) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg4 to %6#1 : !fir.ref %16 = fir.load %9#0 : !fir.ref %17 = fir.convert %16 : (i32) -> i64 @@ -473,7 +473,7 @@ func.func @_QMmPrepro(%arg0: !fir.ref {fir.bindc_name = "imin"}, %arg1: !fi // CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_15]]#0 : !fir.ref // CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> index // CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_19]] : (index) -> i32 -// CHECK: %[[VAL_23:.*]]:2 = fir.do_loop %[[VAL_24:.*]] = %[[VAL_19]] to %[[VAL_21]] step %[[VAL_6]] iter_args(%[[VAL_25:.*]] = %[[VAL_22]]) -> (index, i32) { +// CHECK: %[[VAL_23:.*]]:2 = fir.do_loop %[[VAL_24:.*]] = %[[VAL_19]] to %[[VAL_21]] step %[[VAL_6]] iter_args(%[[VAL_25:.*]] = %[[VAL_22]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_25]] to %[[VAL_14]]#1 : !fir.ref // CHECK: %[[VAL_26:.*]] = fir.load %[[VAL_17]]#0 : !fir.ref // CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i32) -> i64 @@ -481,7 +481,7 @@ func.func @_QMmPrepro(%arg0: !fir.ref {fir.bindc_name = "imin"}, %arg1: !fi // CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (i32) -> i64 // CHECK: %[[VAL_30:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_31:.*]] = hlfir.designate %[[VAL_10]]#0 (%[[VAL_27]], %[[VAL_5]]:%[[VAL_7]]:%[[VAL_6]], %[[VAL_29]]) shape %[[VAL_30]] : (!fir.ref>, i64, index, index, index, i64, !fir.shape<1>) -> !fir.box> -// CHECK: fir.do_loop %[[VAL_32:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_6]] unordered { +// CHECK: fir.do_loop %[[VAL_32:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_6]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_33:.*]] = hlfir.designate %[[VAL_31]] (%[[VAL_32]]) : (!fir.box>, index) -> !fir.ref // CHECK: %[[VAL_34:.*]] = fir.load %[[VAL_33]] : !fir.ref // CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_34]], %[[VAL_3]] : i32 @@ -533,7 +533,7 @@ func.func @other_reads(%z_arg: !fir.box> {fir.bindc_name = "z" // CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_0]](%[[VAL_6]]) {uniq_name = "z"} : (!fir.box>, !fir.shape<1>) -> (!fir.box>, !fir.box>) // CHECK: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_6]]) {uniq_name = "x"} : (!fir.box>, !fir.shape<1>) -> (!fir.box>, !fir.box>) // CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_2]](%[[VAL_6]]) {uniq_name = "y"} : (!fir.box>, !fir.shape<1>) -> (!fir.box>, !fir.box>) -// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_3]] to %[[VAL_5]]#1 step %[[VAL_3]] unordered { +// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_3]] to %[[VAL_5]]#1 step %[[VAL_3]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_11:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_10]]) : (!fir.box>, index) -> !fir.ref // CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_11]] : !fir.ref // CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_9]]#0 (%[[VAL_10]]) : (!fir.box>, index) -> !fir.ref @@ -580,7 +580,7 @@ func.func @other_reads_late_decl(%z_arg: !fir.box> {fir.bindc_ // CHECK-DAG: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_0]](%[[VAL_6]]) {uniq_name = "z"} : (!fir.box>, !fir.shape<1>) -> (!fir.box>, !fir.box>) // CHECK-DAG: %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_6]]) {uniq_name = "x"} : (!fir.box>, !fir.shape<1>) -> (!fir.box>, !fir.box>) // CHECK-DAG: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_2]](%[[VAL_6]]) {uniq_name = "y"} : (!fir.box>, !fir.shape<1>) -> (!fir.box>, !fir.box>) -// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_3]] to %[[VAL_5]]#1 step %[[VAL_3]] unordered { +// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_3]] to %[[VAL_5]]#1 step %[[VAL_3]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_11:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_10]]) : (!fir.box>, index) -> !fir.ref // CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_11]] : !fir.ref // CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_9]]#0 (%[[VAL_10]]) : (!fir.box>, index) -> !fir.ref @@ -644,7 +644,7 @@ func.func @other_reads_odd_shape(%z_arg: !fir.box> {fir.bindc_ // CHECK: %[[VAL_13:.*]] = arith.addi %[[VAL_6]]#1, %[[VAL_4]] : index // CHECK: %[[VAL_14:.*]] = fir.shape %[[VAL_13]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_15:.*]] = hlfir.designate %[[VAL_12]]#0 (%[[VAL_4]]:%[[VAL_13]]:%[[VAL_3]]) shape %[[VAL_14]] : (!fir.box>, index, index, index, !fir.shape<1>) -> !fir.box> -// CHECK: fir.do_loop %[[VAL_16:.*]] = %[[VAL_3]] to %[[VAL_6]]#1 step %[[VAL_3]] unordered { +// CHECK: fir.do_loop %[[VAL_16:.*]] = %[[VAL_3]] to %[[VAL_6]]#1 step %[[VAL_3]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_17:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_16]]) : (!fir.box>, index) -> !fir.ref // CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_17]] : !fir.ref // CHECK: %[[VAL_19:.*]] = hlfir.designate %[[VAL_9]]#0 (%[[VAL_16]]) : (!fir.box>, index) -> !fir.ref @@ -782,8 +782,8 @@ func.func @_QPddx(%arg0: !fir.box> {fir.bindc_name = "array" // CHECK: %[[VAL_50:.*]] = arith.select %[[VAL_49]], %[[VAL_48]], %[[VAL_8]] : index // CHECK: %[[VAL_51:.*]] = fir.shape %[[VAL_50]], %[[VAL_37]] : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_52:.*]] = hlfir.designate %[[VAL_26]]#0 (%[[VAL_4]]:%[[VAL_47]]:%[[VAL_7]], %[[VAL_7]]:%[[VAL_35]]:%[[VAL_7]]) shape %[[VAL_51]] : (!fir.box>, index, index, index, index, index, index, !fir.shape<2>) -> !fir.box> -// CHECK: fir.do_loop %[[VAL_53:.*]] = %[[VAL_7]] to %[[VAL_37]] step %[[VAL_7]] unordered { -// CHECK: fir.do_loop %[[VAL_54:.*]] = %[[VAL_7]] to %[[VAL_33]] step %[[VAL_7]] unordered { +// CHECK: fir.do_loop %[[VAL_53:.*]] = %[[VAL_7]] to %[[VAL_37]] step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_54:.*]] = %[[VAL_7]] to %[[VAL_33]] step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_55:.*]] = hlfir.designate %[[VAL_39]] (%[[VAL_54]], %[[VAL_53]]) : (!fir.box>, index, index) -> !fir.ref // CHECK: %[[VAL_56:.*]] = hlfir.designate %[[VAL_45]] (%[[VAL_54]], %[[VAL_53]]) : (!fir.box>, index, index) -> !fir.ref // CHECK: %[[VAL_57:.*]] = fir.load %[[VAL_55]] : !fir.ref diff --git a/flang/test/HLFIR/opt-scalar-assign.fir b/flang/test/HLFIR/opt-scalar-assign.fir index 2b1631a8202ab..bc017375c6b96 100644 --- a/flang/test/HLFIR/opt-scalar-assign.fir +++ b/flang/test/HLFIR/opt-scalar-assign.fir @@ -19,8 +19,8 @@ func.func @_QPtest1() { // CHECK: %[[VAL_4:.*]] = fir.alloca !fir.array<11x13xf32> {bindc_name = "x", uniq_name = "_QFtest1Ex"} // CHECK: %[[VAL_5:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_4]](%[[VAL_5]]) {uniq_name = "_QFtest1Ex"} : (!fir.ref>, !fir.shape<2>) -> (!fir.ref>, !fir.ref>) -// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_0]] to %[[VAL_3]] step %[[VAL_0]] unordered { -// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_0]] to %[[VAL_2]] step %[[VAL_0]] unordered { +// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_0]] to %[[VAL_3]] step %[[VAL_0]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_0]] to %[[VAL_2]] step %[[VAL_0]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_8]], %[[VAL_7]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: hlfir.assign %[[VAL_1]] to %[[VAL_9]] : f32, !fir.ref // CHECK: } @@ -42,8 +42,8 @@ func.func @_QPtest2(%arg0: !fir.box> {fir.bindc_name = "x"}) // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "_QFtest2Ex"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_4]]#0, %[[VAL_2]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_4]]#0, %[[VAL_1]] : (!fir.box>, index) -> (index, index, index) -// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_6]]#1 step %[[VAL_1]] unordered { -// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_1]] to %[[VAL_5]]#1 step %[[VAL_1]] unordered { +// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_6]]#1 step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_1]] to %[[VAL_5]]#1 step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_8]], %[[VAL_7]]) : (!fir.box>, index, index) -> !fir.ref // CHECK: hlfir.assign %[[VAL_3]] to %[[VAL_9]] : i32, !fir.ref // CHECK: } @@ -68,7 +68,7 @@ func.func @_QPtest4(%arg0: !fir.ref !fir.logical<4> // CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref>>>> // CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_2]] : (!fir.box>>>, index) -> (index, index, index) -// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_1]] to %[[VAL_7]]#1 step %[[VAL_1]] unordered { +// CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_1]] to %[[VAL_7]]#1 step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_6]], %[[VAL_2]] : (!fir.box>>>, index) -> (index, index, index) // CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_9]]#0, %[[VAL_1]] : index // CHECK: %[[VAL_11:.*]] = arith.addi %[[VAL_8]], %[[VAL_10]] : index @@ -92,7 +92,7 @@ func.func @_QPtest3(%arg0: !fir.ref>>> {fir // CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtest3Ex"} : (!fir.ref>>>) -> (!fir.ref>>>, !fir.ref>>>) // CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref>>> // CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_5]], %[[VAL_2]] : (!fir.box>>, index) -> (index, index, index) -// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_6]]#1 step %[[VAL_1]] unordered { +// CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_6]]#1 step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_8:.*]]:3 = fir.box_dims %[[VAL_5]], %[[VAL_2]] : (!fir.box>>, index) -> (index, index, index) // CHECK: %[[VAL_9:.*]] = arith.subi %[[VAL_8]]#0, %[[VAL_1]] : index // CHECK: %[[VAL_10:.*]] = arith.addi %[[VAL_7]], %[[VAL_9]] : index @@ -123,7 +123,7 @@ func.func @_QPtest5(%arg0: !fir.ref>> {fir.bindc_n // CHECK: %[[VAL_6:.*]] = fir.undefined !fir.complex<4> // CHECK: %[[VAL_7:.*]] = fir.insert_value %[[VAL_6]], %[[VAL_2]], [0 : index] : (!fir.complex<4>, f32) -> !fir.complex<4> // CHECK: %[[VAL_8:.*]] = fir.insert_value %[[VAL_7]], %[[VAL_2]], [1 : index] : (!fir.complex<4>, f32) -> !fir.complex<4> -// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_1]] to %[[VAL_3]] step %[[VAL_1]] unordered { +// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_1]] to %[[VAL_3]] step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_10:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_9]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: hlfir.assign %[[VAL_8]] to %[[VAL_10]] : !fir.complex<4>, !fir.ref> // CHECK: } diff --git a/flang/test/HLFIR/opt-variable-assign.fir b/flang/test/HLFIR/opt-variable-assign.fir index 17124fa86af65..69d8838ce928a 100644 --- a/flang/test/HLFIR/opt-variable-assign.fir +++ b/flang/test/HLFIR/opt-variable-assign.fir @@ -28,16 +28,16 @@ func.func @_QPtest1(%arg0: !fir.ref> {fir.bindc_name = "x"}) // CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_3]]) {uniq_name = "_QFtest1Ey"} : (!fir.ref>, !fir.shape<2>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_7:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_1]]:%[[VAL_2]]:%[[VAL_1]], %[[VAL_1]]:%[[VAL_2]]:%[[VAL_1]]) shape %[[VAL_3]] : (!fir.ref>, index, index, index, index, index, index, !fir.shape<2>) -> !fir.ref> // CHECK: %[[VAL_8:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_1]]:%[[VAL_2]]:%[[VAL_1]], %[[VAL_1]]:%[[VAL_2]]:%[[VAL_1]]) shape %[[VAL_3]] : (!fir.ref>, index, index, index, index, index, index, !fir.shape<2>) -> !fir.ref> -// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered { -// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered { +// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_11:.*]] = hlfir.designate %[[VAL_7]] (%[[VAL_10]], %[[VAL_9]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_11]] : !fir.ref // CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_8]] (%[[VAL_10]], %[[VAL_9]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: hlfir.assign %[[VAL_12]] to %[[VAL_13]] : f32, !fir.ref // CHECK: } // CHECK: } -// CHECK: fir.do_loop %[[VAL_14:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered { -// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered { +// CHECK: fir.do_loop %[[VAL_14:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_16:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_15]], %[[VAL_14]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_16]] : !fir.ref // CHECK: %[[VAL_18:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_15]], %[[VAL_14]]) : (!fir.ref>, index, index) -> !fir.ref @@ -87,16 +87,16 @@ func.func @_QPtest2(%arg0: !fir.box> {fir.bindc_name = "x"}) // CHECK: %[[VAL_14:.*]] = fir.shape %[[VAL_11]], %[[VAL_13]] : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_15:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_2]]:%[[VAL_8]]#1:%[[VAL_2]], %[[VAL_2]]:%[[VAL_9]]#1:%[[VAL_2]]) shape %[[VAL_14]] : (!fir.box>, index, index, index, index, index, index, !fir.shape<2>) -> !fir.box> // CHECK: %[[VAL_16:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_2]]:%[[VAL_3]]:%[[VAL_2]], %[[VAL_2]]:%[[VAL_3]]:%[[VAL_2]]) shape %[[VAL_6]] : (!fir.ref>, index, index, index, index, index, index, !fir.shape<2>) -> !fir.ref> -// CHECK: fir.do_loop %[[VAL_17:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered { -// CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered { +// CHECK: fir.do_loop %[[VAL_17:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_19:.*]] = hlfir.designate %[[VAL_15]] (%[[VAL_18]], %[[VAL_17]]) : (!fir.box>, index, index) -> !fir.ref // CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_19]] : !fir.ref // CHECK: %[[VAL_21:.*]] = hlfir.designate %[[VAL_16]] (%[[VAL_18]], %[[VAL_17]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: hlfir.assign %[[VAL_20]] to %[[VAL_21]] : f32, !fir.ref // CHECK: } // CHECK: } -// CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered { -// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered { +// CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_24:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_23]], %[[VAL_22]]) : (!fir.box>, index, index) -> !fir.ref // CHECK: %[[VAL_25:.*]] = fir.load %[[VAL_24]] : !fir.ref // CHECK: %[[VAL_26:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_23]], %[[VAL_22]]) : (!fir.ref>, index, index) -> !fir.ref @@ -146,8 +146,8 @@ func.func @_QPtest3(%arg0: !fir.box> {fir.bindc_name = "x"}) // CHECK: %[[VAL_14:.*]] = arith.select %[[VAL_13]], %[[VAL_10]]#1, %[[VAL_1]] : index // CHECK: %[[VAL_15:.*]] = fir.shape %[[VAL_12]], %[[VAL_14]] : (index, index) -> !fir.shape<2> // CHECK: %[[VAL_16:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_2]]:%[[VAL_9]]#1:%[[VAL_2]], %[[VAL_2]]:%[[VAL_10]]#1:%[[VAL_2]]) shape %[[VAL_15]] : (!fir.box>, index, index, index, index, index, index, !fir.shape<2>) -> !fir.box> -// CHECK: fir.do_loop %[[VAL_17:.*]] = %[[VAL_2]] to %[[VAL_14]] step %[[VAL_2]] unordered { -// CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_2]] to %[[VAL_12]] step %[[VAL_2]] unordered { +// CHECK: fir.do_loop %[[VAL_17:.*]] = %[[VAL_2]] to %[[VAL_14]] step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_2]] to %[[VAL_12]] step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_19:.*]] = hlfir.designate %[[VAL_8]] (%[[VAL_18]], %[[VAL_17]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_19]] : !fir.ref // CHECK: %[[VAL_21:.*]] = hlfir.designate %[[VAL_16]] (%[[VAL_18]], %[[VAL_17]]) : (!fir.box>, index, index) -> !fir.ref @@ -156,8 +156,8 @@ func.func @_QPtest3(%arg0: !fir.box> {fir.bindc_name = "x"}) // CHECK: } // CHECK: %[[VAL_22:.*]]:3 = fir.box_dims %[[VAL_4]]#0, %[[VAL_1]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[VAL_23:.*]]:3 = fir.box_dims %[[VAL_4]]#0, %[[VAL_2]] : (!fir.box>, index) -> (index, index, index) -// CHECK: fir.do_loop %[[VAL_24:.*]] = %[[VAL_2]] to %[[VAL_23]]#1 step %[[VAL_2]] unordered { -// CHECK: fir.do_loop %[[VAL_25:.*]] = %[[VAL_2]] to %[[VAL_22]]#1 step %[[VAL_2]] unordered { +// CHECK: fir.do_loop %[[VAL_24:.*]] = %[[VAL_2]] to %[[VAL_23]]#1 step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { +// CHECK: fir.do_loop %[[VAL_25:.*]] = %[[VAL_2]] to %[[VAL_22]]#1 step %[[VAL_2]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_26:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_25]], %[[VAL_24]]) : (!fir.ref>, index, index) -> !fir.ref // CHECK: %[[VAL_27:.*]] = fir.load %[[VAL_26]] : !fir.ref // CHECK: %[[VAL_28:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_25]], %[[VAL_24]]) : (!fir.box>, index, index) -> !fir.ref diff --git a/flang/test/HLFIR/order_assignments/forall-codegen-fuse-assignments.fir b/flang/test/HLFIR/order_assignments/forall-codegen-fuse-assignments.fir index d5ee7a66c772a..a921035e0ca3a 100644 --- a/flang/test/HLFIR/order_assignments/forall-codegen-fuse-assignments.fir +++ b/flang/test/HLFIR/order_assignments/forall-codegen-fuse-assignments.fir @@ -34,7 +34,7 @@ func.func @test_assignment_fusing(%x: !fir.ref>, %y : !fir.bo // FUSE: %[[VAL_3:.*]] = arith.constant 1 : index // FUSE: %[[VAL_4:.*]] = arith.constant 10 : index // FUSE: %[[VAL_5:.*]] = arith.constant 1 : index -// FUSE: fir.do_loop %[[VAL_6:.*]] = %[[VAL_3]] to %[[VAL_4]] step %[[VAL_5]] { +// FUSE: fir.do_loop %[[VAL_6:.*]] = %[[VAL_3]] to %[[VAL_4]] step %[[VAL_5]] attributes {operandSegmentSizes = array} { // FUSE-NEXT: %[[VAL_7:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_6]]) : (!fir.ref>, index) -> !fir.ref // FUSE-NEXT: hlfir.assign %[[VAL_2]] to %[[VAL_7]] : i32, !fir.ref // FUSE-NEXT: %[[VAL_8:.*]] = hlfir.designate %[[VAL_1]] (%[[VAL_6]]) : (!fir.box>, index) -> !fir.ref diff --git a/flang/test/HLFIR/order_assignments/forall-codegen-no-conflict.fir b/flang/test/HLFIR/order_assignments/forall-codegen-no-conflict.fir index 784367f4b05df..b474c6134b765 100644 --- a/flang/test/HLFIR/order_assignments/forall-codegen-no-conflict.fir +++ b/flang/test/HLFIR/order_assignments/forall-codegen-no-conflict.fir @@ -25,7 +25,7 @@ func.func @test_simple(%x: !fir.ref>) { // CHECK: %[[VAL_2:.*]] = arith.constant 10 : index // CHECK: %[[VAL_3:.*]] = arith.constant 1 : index // CHECK: %[[VAL_4:.*]] = arith.constant 42 : i32 -// CHECK: fir.do_loop %[[VAL_5:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_3]] { +// CHECK: fir.do_loop %[[VAL_5:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_3]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_6:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_5]]) : (!fir.ref>, index) -> !fir.ref // CHECK: hlfir.assign %[[VAL_4]] to %[[VAL_6]] : i32, !fir.ref // CHECK: } @@ -55,7 +55,7 @@ func.func @test_index(%x: !fir.ref>) { // CHECK: %[[VAL_2:.*]] = arith.constant 1 : index // CHECK: %[[VAL_3:.*]] = arith.constant 10 : index // CHECK: %[[VAL_4:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_5:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_4]] { +// CHECK: fir.do_loop %[[VAL_5:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_4]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (index) -> i32 // CHECK: fir.store %[[VAL_6]] to %[[VAL_1]] : !fir.ref // CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_1]] : !fir.ref @@ -112,7 +112,7 @@ func.func @split_schedule(%arg0: !fir.box>, %arg1: !fir.box index // CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_4]] : (i64) -> index // CHECK: %[[VAL_11:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_11]] { +// CHECK: fir.do_loop %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_11]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (index) -> i64 // CHECK: %[[VAL_14:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_13]]) : (!fir.box>, i64) -> !fir.ref // CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_14]] : !fir.ref @@ -125,9 +125,9 @@ func.func @split_schedule(%arg0: !fir.box>, %arg1: !fir.box index // CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_4]] : (i64) -> index // CHECK: %[[VAL_24:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_17]] to %[[VAL_18]] step %[[VAL_19]] { +// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_17]] to %[[VAL_18]] step %[[VAL_19]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (index) -> i64 -// CHECK: fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_24]] { +// CHECK: fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_24]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (index) -> i64 // CHECK: %[[VAL_27:.*]] = arith.subi %[[VAL_3]], %[[VAL_21]] : i64 // CHECK: %[[VAL_28:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_27]]) : (!fir.box>, i64) -> !fir.ref @@ -183,14 +183,14 @@ func.func @test_mask(%arg0: !fir.box>, %arg1: !fir.box index // CHECK: %[[VAL_18:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_10]] { +// CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_10]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (index) -> i64 // CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_12]]) : (!fir.box>>, i64) -> !fir.ref> // CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_13]] : !fir.ref> // CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (!fir.logical<4>) -> i1 // CHECK: fir.if %[[VAL_15]] { // CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_12]] : (i64) -> index -// CHECK: fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_18]] { +// CHECK: fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_18]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (index) -> i64 // CHECK: %[[VAL_21:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_12]], %[[VAL_20]]) : (!fir.box>, i64, i64) -> !fir.ref // CHECK: %[[VAL_22:.*]] = fir.load %[[VAL_21]] : !fir.ref diff --git a/flang/test/HLFIR/order_assignments/inlined-stack-temp.fir b/flang/test/HLFIR/order_assignments/inlined-stack-temp.fir index 0724d019537c0..fcdbb46c5a3b0 100644 --- a/flang/test/HLFIR/order_assignments/inlined-stack-temp.fir +++ b/flang/test/HLFIR/order_assignments/inlined-stack-temp.fir @@ -46,7 +46,7 @@ func.func @test_scalar_save(%arg0: !fir.box>) { // CHECK: %[[VAL_16:.*]] = fir.allocmem !fir.array, %[[VAL_13]] {bindc_name = ".tmp.forall", uniq_name = ""} // CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_13]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_18:.*]]:2 = hlfir.declare %[[VAL_16]](%[[VAL_17]]) {uniq_name = ".tmp.forall"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) -// CHECK: fir.do_loop %[[VAL_19:.*]] = %[[VAL_5]] to %[[VAL_6]] step %[[VAL_7]] { +// CHECK: fir.do_loop %[[VAL_19:.*]] = %[[VAL_5]] to %[[VAL_6]] step %[[VAL_7]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (index) -> i32 // CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> i64 // CHECK: %[[VAL_22:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_21]]) : (!fir.box>, i64) -> !fir.ref @@ -61,7 +61,7 @@ func.func @test_scalar_save(%arg0: !fir.box>) { // CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_2]] : (i32) -> index // CHECK: %[[VAL_29:.*]] = arith.constant 1 : index // CHECK: fir.store %[[VAL_14]] to %[[VAL_1]] : !fir.ref -// CHECK: fir.do_loop %[[VAL_30:.*]] = %[[VAL_27]] to %[[VAL_28]] step %[[VAL_29]] { +// CHECK: fir.do_loop %[[VAL_30:.*]] = %[[VAL_27]] to %[[VAL_28]] step %[[VAL_29]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (index) -> i32 // CHECK: %[[VAL_32:.*]] = fir.load %[[VAL_1]] : !fir.ref // CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_32]], %[[VAL_15]] : index @@ -144,7 +144,7 @@ func.func @mask_and_rhs_conflict(%arg0: !fir.box>) { // CHECK: %[[VAL_29:.*]] = fir.allocmem !fir.array, %[[VAL_26]] {bindc_name = ".tmp.forall", uniq_name = ""} // CHECK: %[[VAL_30:.*]] = fir.shape %[[VAL_26]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_31:.*]]:2 = hlfir.declare %[[VAL_29]](%[[VAL_30]]) {uniq_name = ".tmp.forall"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) -// CHECK: fir.do_loop %[[VAL_32:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_9]] { +// CHECK: fir.do_loop %[[VAL_32:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_9]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_32]] : (index) -> i32 // CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i32) -> i64 // CHECK: %[[VAL_35:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_34]]) : (!fir.box>, i64) -> !fir.ref @@ -171,7 +171,7 @@ func.func @mask_and_rhs_conflict(%arg0: !fir.box>) { // CHECK: %[[VAL_49:.*]] = arith.constant 1 : index // CHECK: fir.store %[[VAL_16]] to %[[VAL_2]] : !fir.ref // CHECK: fir.store %[[VAL_27]] to %[[VAL_1]] : !fir.ref -// CHECK: fir.do_loop %[[VAL_50:.*]] = %[[VAL_47]] to %[[VAL_48]] step %[[VAL_49]] { +// CHECK: fir.do_loop %[[VAL_50:.*]] = %[[VAL_47]] to %[[VAL_48]] step %[[VAL_49]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_51:.*]] = fir.convert %[[VAL_50]] : (index) -> i32 // CHECK: %[[VAL_52:.*]] = fir.load %[[VAL_2]] : !fir.ref // CHECK: %[[VAL_53:.*]] = arith.addi %[[VAL_52]], %[[VAL_17]] : index @@ -240,7 +240,7 @@ func.func @test_where_mask_save(%arg0: !fir.box>) { // CHECK: %[[VAL_12:.*]]:3 = hlfir.associate %[[VAL_13:.*]](%[[VAL_5]]) {uniq_name = ".tmp.where"} : (!hlfir.expr>, !fir.shape<1>) -> (!fir.box>>, !fir.ref>>, i1) // CHECK: hlfir.destroy %[[VAL_13]] : !hlfir.expr> // CHECK: %[[VAL_14:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_4]]#1 step %[[VAL_14]] { +// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_4]]#1 step %[[VAL_14]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_16:.*]] = hlfir.designate %[[VAL_12]]#0 (%[[VAL_15]]) : (!fir.box>>, index) -> !fir.ref> // CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_16]] : !fir.ref> // CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_17]] : (!fir.logical<4>) -> i1 @@ -294,7 +294,7 @@ func.func @test_where_rhs_save(%x: !fir.ref>, %mask: !fir.ref // CHECK: %[[VAL_19:.*]] = fir.allocmem !fir.array, %[[VAL_16]] {bindc_name = ".tmp.where", uniq_name = ""} // CHECK: %[[VAL_20:.*]] = fir.shape %[[VAL_16]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_21:.*]]:2 = hlfir.declare %[[VAL_19]](%[[VAL_20]]) {uniq_name = ".tmp.where"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) -// CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_9]] to %[[VAL_7]] step %[[VAL_9]] { +// CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_9]] to %[[VAL_7]] step %[[VAL_9]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_23:.*]] = hlfir.designate %[[VAL_1]] (%[[VAL_22]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_24:.*]] = fir.load %[[VAL_23]] : !fir.ref> // CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (!fir.logical<4>) -> i1 @@ -313,7 +313,7 @@ func.func @test_where_rhs_save(%x: !fir.ref>, %mask: !fir.ref // CHECK: %[[VAL_32:.*]] = fir.shape %[[VAL_31]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_33:.*]] = arith.constant 1 : index // CHECK: fir.store %[[VAL_17]] to %[[VAL_2]] : !fir.ref -// CHECK: fir.do_loop %[[VAL_34:.*]] = %[[VAL_33]] to %[[VAL_31]] step %[[VAL_33]] { +// CHECK: fir.do_loop %[[VAL_34:.*]] = %[[VAL_33]] to %[[VAL_31]] step %[[VAL_33]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_35:.*]] = hlfir.designate %[[VAL_1]] (%[[VAL_34]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_36:.*]] = fir.load %[[VAL_35]] : !fir.ref> // CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (!fir.logical<4>) -> i1 diff --git a/flang/test/HLFIR/order_assignments/lhs-conflicts-codegen.fir b/flang/test/HLFIR/order_assignments/lhs-conflicts-codegen.fir index 45ceb516a6863..d72fcabeee704 100644 --- a/flang/test/HLFIR/order_assignments/lhs-conflicts-codegen.fir +++ b/flang/test/HLFIR/order_assignments/lhs-conflicts-codegen.fir @@ -39,7 +39,7 @@ func.func @save_box_in_ssa_register(%arg0: !fir.box>, %arg1: ! // CHECK-SAME: %[[VAL_1:.*]]: !fir.box>>) { // CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "x"} : (!fir.box>) -> (!fir.box>, !fir.box>) // CHECK: %[[VAL_18:.*]] = hlfir.designate %[[VAL_5]]#0 (%{{.*}}:%{{.*}}:%{{.*}}) shape %{{.*}} : (!fir.box>, i64, i64, index, !fir.shape<1>) -> !fir.box> -// CHECK: fir.do_loop %[[VAL_20:.*]] = {{.*}} { +// CHECK: fir.do_loop %[[VAL_20:.*]] = {{.*}} attributes {{.*}} { // CHECK: %[[VAL_21:.*]] = hlfir.designate %[[VAL_18]] (%[[VAL_20]]) : (!fir.box>, index) -> !fir.ref // CHECK: fir.call @logical_to_real(%[[VAL_21]], %{{.*}}) : (!fir.ref, !fir.logical<4>) -> () // CHECK: } @@ -195,7 +195,7 @@ func.func @test_vector_subscript_overlap(%arg0: !fir.ref>) { // CHECK: %[[VAL_76:.*]] = arith.constant 0 : index // CHECK: %[[VAL_77:.*]]:3 = fir.box_dims %[[VAL_75]], %[[VAL_76]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[VAL_79:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_80:.*]] = %[[VAL_79]] to %[[VAL_77]]#1 step %[[VAL_79]] { +// CHECK: fir.do_loop %[[VAL_80:.*]] = %[[VAL_79]] to %[[VAL_77]]#1 step %[[VAL_79]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_81:.*]] = fir.load %[[VAL_4]] : !fir.ref // CHECK: %[[VAL_82:.*]] = arith.addi %[[VAL_81]], %{{.*}} : i64 // CHECK: fir.store %[[VAL_82]] to %[[VAL_4]] : !fir.ref diff --git a/flang/test/HLFIR/order_assignments/runtime-stack-temp.fir b/flang/test/HLFIR/order_assignments/runtime-stack-temp.fir index aa334c5ac56cf..31297be5a5e86 100644 --- a/flang/test/HLFIR/order_assignments/runtime-stack-temp.fir +++ b/flang/test/HLFIR/order_assignments/runtime-stack-temp.fir @@ -73,7 +73,7 @@ func.func @test_runtime_stack(%arg0: !fir.box>, %n: !fir.ref // CHECK: %[[VAL_22:.*]] = fir.call @_FortranACreateValueStack(%{{.*}}, %{{.*}}) : (!fir.ref, i32) -> !fir.llvm_ptr -// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_15]] { +// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_15]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_23]] : (index) -> i32 // CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_8]], %[[VAL_24]] : i32 // CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_7]], %[[VAL_24]] : i32 @@ -95,7 +95,7 @@ func.func @test_runtime_stack(%arg0: !fir.box>, %n: !fir.ref index // CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_12]] : (i32) -> index // CHECK: fir.store %[[VAL_16]] to %[[VAL_3]] : !fir.ref -// CHECK: fir.do_loop %[[VAL_43:.*]] = %[[VAL_40]] to %[[VAL_41]] step %[[VAL_42]] { +// CHECK: fir.do_loop %[[VAL_43:.*]] = %[[VAL_40]] to %[[VAL_41]] step %[[VAL_42]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_43]] : (index) -> i32 // CHECK: %[[VAL_45:.*]] = fir.load %[[VAL_3]] : !fir.ref // CHECK: %[[VAL_46:.*]] = arith.addi %[[VAL_45]], %[[VAL_17]] : i64 diff --git a/flang/test/HLFIR/order_assignments/user-defined-assignment-finalization.fir b/flang/test/HLFIR/order_assignments/user-defined-assignment-finalization.fir index ae5329a2d2433..dd062f8e64754 100644 --- a/flang/test/HLFIR/order_assignments/user-defined-assignment-finalization.fir +++ b/flang/test/HLFIR/order_assignments/user-defined-assignment-finalization.fir @@ -142,7 +142,7 @@ func.func @_QPtest2() { // CHECK: %[[VAL_8:.*]] = hlfir.as_expr %[[VAL_7]]#0 : (!fir.ref>}>>>) -> !hlfir.expr<2x!fir.type<_QMtypesTud_assign{x:!fir.box>}>> // CHECK: %[[VAL_9:.*]]:3 = hlfir.associate %[[VAL_8]](%[[VAL_3]]) {uniq_name = ".tmp.assign"} : (!hlfir.expr<2x!fir.type<_QMtypesTud_assign{x:!fir.box>}>>, !fir.shape<1>) -> (!fir.ref>}>>>, !fir.ref>}>>>, i1) // CHECK: %[[VAL_10:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_10]] to %[[VAL_0]] step %[[VAL_10]] { +// CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_10]] to %[[VAL_0]] step %[[VAL_10]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_11]]) : (!fir.ref>}>>>, index) -> !fir.ref>}>> // CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_9]]#0 (%[[VAL_11]]) : (!fir.ref>}>>>, index) -> !fir.ref>}>> // CHECK: %[[VAL_14:.*]] = fir.embox %[[VAL_12]] : (!fir.ref>}>>) -> !fir.box>}>> @@ -245,7 +245,7 @@ func.func @_QPtest3(%arg0: !fir.ref> {fir.bindc_name = "y"}) { // CHECK: fir.save_result %[[VAL_19]] to %[[VAL_5]](%[[VAL_7]]) : !fir.array<2x!fir.type<_QMtypesTud_assign{x:!fir.box>}>>, !fir.ref>}>>>, !fir.shape<1> // CHECK: %[[VAL_20:.*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_7]]) {uniq_name = ".tmp.func_result"} : (!fir.ref>}>>>, !fir.shape<1>) -> (!fir.ref>}>>>, !fir.ref>}>>>) // CHECK: %[[VAL_27:.*]] = fir.call @_FortranACreateValueStack(%{{.*}}, %{{.*}}) : (!fir.ref, i32) -> !fir.llvm_ptr -// CHECK: fir.do_loop %[[VAL_28:.*]] = %{{.*}} to %[[VAL_4]] step %{{.*}} { +// CHECK: fir.do_loop %[[VAL_28:.*]] = %{{.*}} to %[[VAL_4]] step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_29:.*]] = hlfir.designate %[[VAL_16]]#0 (%[[VAL_28]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_30:.*]] = fir.load %[[VAL_29]] : !fir.ref> // CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (!fir.logical<4>) -> i1 @@ -257,7 +257,7 @@ func.func @_QPtest3(%arg0: !fir.ref> {fir.bindc_name = "y"}) { // CHECK: %[[VAL_35:.*]] = fir.call @_FortranAPushValue(%[[VAL_27]], %[[VAL_34]]) : (!fir.llvm_ptr, !fir.box) -> none // CHECK: } // CHECK: } -// CHECK: fir.do_loop %[[VAL_37:.*]] = %{{.*}} to %[[VAL_4]] step %{{.*}} { +// CHECK: fir.do_loop %[[VAL_37:.*]] = %{{.*}} to %[[VAL_4]] step %{{.*}} attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_38:.*]] = hlfir.designate %[[VAL_16]]#0 (%[[VAL_37]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_38]] : !fir.ref> // CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_39]] : (!fir.logical<4>) -> i1 diff --git a/flang/test/HLFIR/order_assignments/user-defined-assignment.fir b/flang/test/HLFIR/order_assignments/user-defined-assignment.fir index 61836b8bcc57e..199b581e30864 100644 --- a/flang/test/HLFIR/order_assignments/user-defined-assignment.fir +++ b/flang/test/HLFIR/order_assignments/user-defined-assignment.fir @@ -58,7 +58,7 @@ func.func @test_elemental_overlap(%i: !fir.ref>) { // CHECK: %[[VAL_12:.*]] = arith.constant 10 : index // CHECK: %[[VAL_13:.*]] = fir.shape %[[VAL_12]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_14:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_12]] step %[[VAL_14]] { +// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_12]] step %[[VAL_14]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_16:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_15]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_17:.*]] = hlfir.designate %[[VAL_10]]#0 (%[[VAL_15]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_17]] : !fir.ref> @@ -156,7 +156,7 @@ func.func @test_scalar_forall_overlap(%i: !fir.ref>) { // CHECK: %[[VAL_15:.*]] = fir.allocmem !fir.array, %[[VAL_12]] {bindc_name = ".tmp.forall", uniq_name = ""} // CHECK: %[[VAL_16:.*]] = fir.shape %[[VAL_12]] : (index) -> !fir.shape<1> // CHECK: %[[VAL_17:.*]]:2 = hlfir.declare %[[VAL_15]](%[[VAL_16]]) {uniq_name = ".tmp.forall"} : (!fir.heap>, !fir.shape<1>) -> (!fir.box>, !fir.heap>) -// CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_3]] to %[[VAL_4]] step %[[VAL_6]] { +// CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_3]] to %[[VAL_4]] step %[[VAL_6]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_5]], %[[VAL_18]] : index // CHECK: %[[VAL_20:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_19]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_21:.*]] = fir.load %[[VAL_20]] : !fir.ref @@ -169,7 +169,7 @@ func.func @test_scalar_forall_overlap(%i: !fir.ref>) { // CHECK: } // CHECK: %[[VAL_26:.*]] = arith.constant 1 : index // CHECK: fir.store %[[VAL_13]] to %[[VAL_1]] : !fir.ref -// CHECK: fir.do_loop %[[VAL_27:.*]] = %[[VAL_3]] to %[[VAL_4]] step %[[VAL_26]] { +// CHECK: fir.do_loop %[[VAL_27:.*]] = %[[VAL_3]] to %[[VAL_4]] step %[[VAL_26]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_28:.*]] = fir.load %[[VAL_1]] : !fir.ref // CHECK: %[[VAL_29:.*]] = arith.addi %[[VAL_28]], %[[VAL_14]] : index // CHECK: fir.store %[[VAL_29]] to %[[VAL_1]] : !fir.ref diff --git a/flang/test/HLFIR/order_assignments/vector-subscripts-codegen.fir b/flang/test/HLFIR/order_assignments/vector-subscripts-codegen.fir index c75daf4f69cff..d186a604b8059 100644 --- a/flang/test/HLFIR/order_assignments/vector-subscripts-codegen.fir +++ b/flang/test/HLFIR/order_assignments/vector-subscripts-codegen.fir @@ -36,7 +36,7 @@ func.func @simple(%arg0: !fir.ref> , %arg1: !fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_2]](%[[VAL_7]]) {uniq_name = "z"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_10:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_10]] to %[[VAL_3]] step %[[VAL_10]] { +// CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_10]] to %[[VAL_3]] step %[[VAL_10]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_11]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_13:.*]] = fir.load %[[VAL_12]] : !fir.ref // CHECK: %[[VAL_14:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_13]]) : (!fir.ref>, i64) -> !fir.ref @@ -98,7 +98,7 @@ func.func @forall_vector_lhs(%arg0: !fir.ref> , %arg1: !f // CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_3]] : (i32) -> index // CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_2]] : (i32) -> index // CHECK: %[[VAL_13:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_14:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_13]] { +// CHECK: fir.do_loop %[[VAL_14:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_13]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (index) -> i32 // CHECK: %[[VAL_16:.*]] = hlfir.elemental %[[VAL_9]] : (!fir.shape<1>) -> !hlfir.expr<10xf32> { // CHECK: ^bb0(%[[VAL_17:.*]]: index): @@ -109,7 +109,7 @@ func.func @forall_vector_lhs(%arg0: !fir.ref> , %arg1: !f // CHECK: } // CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_15]] : (i32) -> i64 // CHECK: %[[VAL_22:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_22]] to %[[VAL_4]] step %[[VAL_22]] { +// CHECK: fir.do_loop %[[VAL_23:.*]] = %[[VAL_22]] to %[[VAL_4]] step %[[VAL_22]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_24:.*]] = hlfir.designate %[[VAL_10]]#0 (%[[VAL_23]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_25:.*]] = fir.load %[[VAL_24]] : !fir.ref // CHECK: %[[VAL_26:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_25]], %[[VAL_21]]) : (!fir.ref>, i64, i64) -> !fir.ref @@ -158,7 +158,7 @@ func.func @where_vector_subscripts(%arg0: !fir.ref // CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_8]]) {uniq_name = "x"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_10:.*]]:2 = hlfir.declare %[[VAL_2]](%[[VAL_6]]) {uniq_name = "y"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_11:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_12:.*]] = %[[VAL_11]] to %[[VAL_5]] step %[[VAL_11]] { +// CHECK: fir.do_loop %[[VAL_12:.*]] = %[[VAL_11]] to %[[VAL_5]] step %[[VAL_11]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_12]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_13]] : !fir.ref> // CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (!fir.logical<4>) -> i1 @@ -203,7 +203,7 @@ func.func @unordered(%arg0: !fir.ref> , %arg1: !fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_2]](%[[VAL_7]]) {uniq_name = "z"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_10:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_10]] to %[[VAL_3]] step %[[VAL_10]] unordered { +// CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_10]] to %[[VAL_3]] step %[[VAL_10]] unordered attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_11]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_13:.*]] = fir.load %[[VAL_12]] : !fir.ref // CHECK: %[[VAL_14:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_13]]) : (!fir.ref>, i64) -> !fir.ref diff --git a/flang/test/HLFIR/order_assignments/where-codegen-no-conflict.fir b/flang/test/HLFIR/order_assignments/where-codegen-no-conflict.fir index a1a357b45a64e..75eca5ad657b0 100644 --- a/flang/test/HLFIR/order_assignments/where-codegen-no-conflict.fir +++ b/flang/test/HLFIR/order_assignments/where-codegen-no-conflict.fir @@ -27,7 +27,7 @@ func.func @test_simple(%arg0: !fir.box>, %arg1: !fir.box>>, index) -> (index, index, index) // CHECK: %[[VAL_7:.*]] = fir.shape %[[VAL_6]]#1 : (index) -> !fir.shape<1> // CHECK: %[[VAL_8:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_8]] to %[[VAL_6]]#1 step %[[VAL_8]] { +// CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_8]] to %[[VAL_6]]#1 step %[[VAL_8]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_10:.*]] = hlfir.designate %[[VAL_3]]#0 (%[[VAL_9]]) : (!fir.box>>, index) -> !fir.ref> // CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_10]] : !fir.ref> // CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (!fir.logical<4>) -> i1 @@ -89,7 +89,7 @@ func.func @test_elsewhere(%arg0: !fir.ref>, %arg1: !fir.ref< // CHECK: %[[VAL_10:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_6]]) {uniq_name = "y"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_11:.*]]:2 = hlfir.declare %[[VAL_2]](%[[VAL_6]]) {uniq_name = "z"} : (!fir.ref>, !fir.shape<1>) -> (!fir.ref>, !fir.ref>) // CHECK: %[[VAL_12:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_13:.*]] = %[[VAL_12]] to %[[VAL_5]] step %[[VAL_12]] { +// CHECK: fir.do_loop %[[VAL_13:.*]] = %[[VAL_12]] to %[[VAL_5]] step %[[VAL_12]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_14:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_13]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_14]] : !fir.ref> // CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (!fir.logical<4>) -> i1 @@ -100,7 +100,7 @@ func.func @test_elsewhere(%arg0: !fir.ref>, %arg1: !fir.ref< // CHECK: } // CHECK: } // CHECK: %[[VAL_19:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_19]] to %[[VAL_5]] step %[[VAL_19]] { +// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_19]] to %[[VAL_5]] step %[[VAL_19]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_21:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_20]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_22:.*]] = fir.load %[[VAL_21]] : !fir.ref> // CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (!fir.logical<4>) -> i1 @@ -117,7 +117,7 @@ func.func @test_elsewhere(%arg0: !fir.ref>, %arg1: !fir.ref< // CHECK: } // CHECK: } // CHECK: %[[VAL_29:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_30:.*]] = %[[VAL_29]] to %[[VAL_5]] step %[[VAL_29]] { +// CHECK: fir.do_loop %[[VAL_30:.*]] = %[[VAL_29]] to %[[VAL_5]] step %[[VAL_29]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_31:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_30]]) : (!fir.ref>>, index) -> !fir.ref> // CHECK: %[[VAL_32:.*]] = fir.load %[[VAL_31]] : !fir.ref> // CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_32]] : (!fir.logical<4>) -> i1 @@ -208,7 +208,7 @@ func.func @expr_tree(%arg0: !fir.box>, %arg1: !fir.box !fir.shape<1> // CHECK: %[[VAL_11:.*]] = hlfir.designate %[[VAL_9]]#0 (%[[VAL_6]]:%[[VAL_5]]:%[[VAL_4]]) shape %[[VAL_10]] : (!fir.box>, index, index, index, !fir.shape<1>) -> !fir.box> // CHECK: %[[VAL_12:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_13:.*]] = %[[VAL_12]] to %[[VAL_6]] step %[[VAL_12]] { +// CHECK: fir.do_loop %[[VAL_13:.*]] = %[[VAL_12]] to %[[VAL_6]] step %[[VAL_12]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_14:.*]] = hlfir.designate %[[VAL_11]] (%[[VAL_13]]) : (!fir.box>, index) -> !fir.ref // CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_14]] : !fir.ref // CHECK: %[[VAL_16:.*]] = math.absf %[[VAL_15]] fastmath : f32 @@ -287,10 +287,10 @@ func.func @inside_forall(%arg0: !fir.ref>, %arg1: !fir.ref // CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_5]] : (i32) -> index // CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_4]] : (i32) -> index // CHECK: %[[VAL_14:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_14]] { +// CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_14]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (index) -> i32 // CHECK: %[[VAL_17:.*]] = arith.constant 1 : index -// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_17]] to %[[VAL_7]] step %[[VAL_17]] { +// CHECK: fir.do_loop %[[VAL_20:.*]] = %[[VAL_17]] to %[[VAL_7]] step %[[VAL_17]] attributes {operandSegmentSizes = array} { // CHECK: %[[VAL_21:.*]] = hlfir.designate %[[VAL_11]]#0 (%[[VAL_20]]) : (!fir.ref>, index) -> !fir.ref // CHECK: %[[VAL_22:.*]] = fir.load %[[VAL_21]] : !fir.ref // CHECK: %[[VAL_23:.*]] = arith.cmpf ogt, %[[VAL_22]], %[[VAL_3]] : f32 diff --git a/flang/test/Lower/HLFIR/array-ctor-as-inlined-temp.f90 b/flang/test/Lower/HLFIR/array-ctor-as-inlined-temp.f90 index a7c2faa410fb8..e5020008ee535 100644 --- a/flang/test/Lower/HLFIR/array-ctor-as-inlined-temp.f90 +++ b/flang/test/Lower/HLFIR/array-ctor-as-inlined-temp.f90 @@ -144,7 +144,7 @@ subroutine test_implied_do(n) ! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (i64) -> index ! CHECK: %[[VAL_26:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i64) -> index -! CHECK: fir.do_loop %[[VAL_28:.*]] = %[[VAL_23]] to %[[VAL_25]] step %[[VAL_27]] { +! CHECK: fir.do_loop %[[VAL_28:.*]] = %[[VAL_23]] to %[[VAL_25]] step %[[VAL_27]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_29:.*]] = arith.constant 42 : i32 ! CHECK: %[[VAL_30:.*]] = fir.load %[[VAL_1]] : !fir.ref ! CHECK: %[[VAL_31:.*]] = arith.addi %[[VAL_30]], %[[VAL_18B]] : index @@ -208,7 +208,7 @@ subroutine test_strided_implied_do(lb, ub, stride) ! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (i64) -> index ! CHECK: %[[VAL_30:.*]] = fir.load %[[VAL_5]]#0 : !fir.ref ! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (i64) -> index -! CHECK: fir.do_loop %[[VAL_32:.*]] = %[[VAL_27]] to %[[VAL_29]] step %[[VAL_31]] { +! CHECK: fir.do_loop %[[VAL_32:.*]] = %[[VAL_27]] to %[[VAL_29]] step %[[VAL_31]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_33:.*]] = arith.constant 42 : i32 ! CHECK: %[[VAL_34:.*]] = fir.load %[[VAL_3]] : !fir.ref ! CHECK: %[[VAL_35:.*]] = arith.addi %[[VAL_34]], %[[VAL_22B]] : index @@ -281,14 +281,14 @@ subroutine test_nested_implied_do(n, m) ! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_37]] : (i64) -> index ! CHECK: %[[VAL_39:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_39]] : (i64) -> index -! CHECK: fir.do_loop %[[VAL_41:.*]] = %[[VAL_36]] to %[[VAL_38]] step %[[VAL_40]] { +! CHECK: fir.do_loop %[[VAL_41:.*]] = %[[VAL_36]] to %[[VAL_38]] step %[[VAL_40]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_42:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_42]] : (i64) -> index ! CHECK: %[[VAL_44:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref ! CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_44]] : (i64) -> index ! CHECK: %[[VAL_46:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_47:.*]] = fir.convert %[[VAL_46]] : (i64) -> index -! CHECK: fir.do_loop %[[VAL_48:.*]] = %[[VAL_43]] to %[[VAL_45]] step %[[VAL_47]] { +! CHECK: fir.do_loop %[[VAL_48:.*]] = %[[VAL_43]] to %[[VAL_45]] step %[[VAL_47]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_49:.*]] = fir.convert %[[VAL_48]] : (index) -> i64 ! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i64) -> i32 ! CHECK: %[[VAL_51:.*]] = fir.convert %[[VAL_41]] : (index) -> i64 diff --git a/flang/test/Lower/HLFIR/array-ctor-as-runtime-temp.f90 b/flang/test/Lower/HLFIR/array-ctor-as-runtime-temp.f90 index e1e65fc48baba..b84f9cfa5294e 100644 --- a/flang/test/Lower/HLFIR/array-ctor-as-runtime-temp.f90 +++ b/flang/test/Lower/HLFIR/array-ctor-as-runtime-temp.f90 @@ -30,7 +30,7 @@ subroutine test_loops() ! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (i64) -> index ! CHECK: %[[VAL_20:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i64) -> index -! CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_16]] to %[[VAL_19]] step %[[VAL_21]] { +! CHECK: fir.do_loop %[[VAL_22:.*]] = %[[VAL_16]] to %[[VAL_19]] step %[[VAL_21]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_23:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_23]] : (i64) -> index ! CHECK: %[[VAL_25:.*]] = fir.call @_QMarrayctorPifoo() fastmath : () -> i32 @@ -38,7 +38,7 @@ subroutine test_loops() ! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i64) -> index ! CHECK: %[[VAL_28:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (i64) -> index -! CHECK: fir.do_loop %[[VAL_30:.*]] = %[[VAL_24]] to %[[VAL_27]] step %[[VAL_29]] { +! CHECK: fir.do_loop %[[VAL_30:.*]] = %[[VAL_24]] to %[[VAL_27]] step %[[VAL_29]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (index) -> i64 ! CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_31]] : (i64) -> i32 ! CHECK: fir.store %[[VAL_32]] to %[[VAL_0]] : !fir.ref diff --git a/flang/test/Lower/HLFIR/calls-optional.f90 b/flang/test/Lower/HLFIR/calls-optional.f90 index 1ada5b198aed2..6f62589ce65a1 100644 --- a/flang/test/Lower/HLFIR/calls-optional.f90 +++ b/flang/test/Lower/HLFIR/calls-optional.f90 @@ -77,7 +77,7 @@ elemental subroutine elem_takes_two_optional(x, y) ! CHECK: %[[VAL_10:.*]]:3 = fir.box_dims %[[VAL_2]]#0, %[[VAL_9]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref>>> ! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_13:.*]] = %[[VAL_12]] to %[[VAL_10]]#1 step %[[VAL_12]] unordered { +! CHECK: fir.do_loop %[[VAL_13:.*]] = %[[VAL_12]] to %[[VAL_10]]#1 step %[[VAL_12]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_14:.*]] = hlfir.designate %[[VAL_2]]#0 (%[[VAL_13]]) : (!fir.box>, index) -> !fir.ref ! CHECK: %[[VAL_15:.*]] = fir.if %[[VAL_8]] -> (!fir.ref) { ! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index @@ -109,7 +109,7 @@ elemental subroutine elem_takes_one_optional(x) ! CHECK: %[[VAL_2:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_1]]#0, %[[VAL_2]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_4:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_5:.*]] = %[[VAL_4]] to %[[VAL_3]]#1 step %[[VAL_4]] unordered { +! CHECK: fir.do_loop %[[VAL_5:.*]] = %[[VAL_4]] to %[[VAL_3]]#1 step %[[VAL_4]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_6:.*]] = hlfir.designate %[[VAL_1]]#0 (%[[VAL_5]]) : (!fir.box>, index) -> !fir.ref ! CHECK: fir.call @_QPelem_takes_one_optional(%[[VAL_6]]) {{.*}} : (!fir.ref) -> () ! CHECK: } @@ -131,7 +131,7 @@ elemental subroutine elem_optional_poly(x, y) ! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_6:.*]]:3 = fir.box_dims %[[VAL_2]]#0, %[[VAL_5]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_6]]#1 step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_6]]#1 step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = hlfir.designate %[[VAL_2]]#0 (%[[VAL_8]]) : (!fir.box>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.embox %[[VAL_9]] : (!fir.ref) -> !fir.box ! CHECK: %[[VAL_11:.*]] = fir.rebox %[[VAL_10]] : (!fir.box) -> !fir.class diff --git a/flang/test/Lower/HLFIR/elemental-call-vector-subscripts.f90 b/flang/test/Lower/HLFIR/elemental-call-vector-subscripts.f90 index fb88c7d60076c..4e8b5180a9cb1 100644 --- a/flang/test/Lower/HLFIR/elemental-call-vector-subscripts.f90 +++ b/flang/test/Lower/HLFIR/elemental-call-vector-subscripts.f90 @@ -24,7 +24,7 @@ elemental subroutine foo(x, y) ! CHECK: %[[VAL_8:.*]] = arith.constant 3 : index ! CHECK: %[[VAL_9:.*]] = arith.constant 0.000000e+00 : f32 ! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_10]] to %[[VAL_8]] step %[[VAL_10]] unordered { +! CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_10]] to %[[VAL_8]] step %[[VAL_10]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_11]]) : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[VAL_13:.*]] = fir.load %[[VAL_12]] : !fir.ref ! CHECK: %[[VAL_14:.*]] = hlfir.designate %[[VAL_3]]#0 (%[[VAL_13]]) : (!fir.ref>, i64) -> !fir.ref @@ -65,7 +65,7 @@ elemental subroutine foo_value(x, y) ! CHECK: } ! CHECK: %[[VAL_16:.*]] = arith.constant 0.000000e+00 : f32 ! CHECK: %[[VAL_17:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_17]] to %[[VAL_8]] step %[[VAL_17]] unordered { +! CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_17]] to %[[VAL_8]] step %[[VAL_17]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = hlfir.apply %[[VAL_10]], %[[VAL_18]] : (!hlfir.expr<3xf32>, index) -> f32 ! CHECK: fir.call @_QPfoo_value(%[[VAL_19]], %[[VAL_16]]) {{.*}}: (f32, f32) -> () ! CHECK: } @@ -85,7 +85,7 @@ elemental subroutine foo2(j) ! CHECK: hlfir.elemental ! CHECK: %[[VAL_16:.*]] = hlfir.elemental ! CHECK: %[[VAL_20:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_21:.*]] = {{.*}} +! CHECK: fir.do_loop %[[VAL_21:.*]] = {{.*}} attributes {{.*}} ! CHECK: %[[VAL_22:.*]] = hlfir.apply %[[VAL_16]], %[[VAL_21]] : (!hlfir.expr, index) -> i64 ! CHECK: %[[VAL_23:.*]]:3 = hlfir.associate %[[VAL_22]] {adapt.valuebyref} : (i64) -> (!fir.ref, !fir.ref, i1) ! CHECK: fir.call @_QPfoo2(%[[VAL_23]]#1){{.*}}: (!fir.ref) -> () diff --git a/flang/test/Lower/HLFIR/elemental-user-procedure-ref.f90 b/flang/test/Lower/HLFIR/elemental-user-procedure-ref.f90 index aea23d8d94672..3cbc22b47747a 100644 --- a/flang/test/Lower/HLFIR/elemental-user-procedure-ref.f90 +++ b/flang/test/Lower/HLFIR/elemental-user-procedure-ref.f90 @@ -90,8 +90,8 @@ elemental subroutine elem_sub(a, b) ! CHECK: %[[VAL_4:.*]] = arith.constant 20 : index ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1:.*]](%[[VAL_5:[^)]*]]) {{.*}}y ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_7]] unordered { -! CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_3]] step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { +! CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_7]] to %[[VAL_3]] step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_10:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_9]], %[[VAL_8]]) : (!fir.ref>, index, index) -> !fir.ref ! CHECK: fir.call @_QPelem_sub(%[[VAL_2]]#1, %[[VAL_10]]) fastmath : (!fir.ref, !fir.ref) -> () ! CHECK: } @@ -113,8 +113,8 @@ impure elemental subroutine impure_elem(a) ! CHECK: %[[VAL_3:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_0]](%[[VAL_3]]) dummy_scope %{{[0-9]+}} {uniq_name = "_QFimpure_elementalEx"} : (!fir.ref>, !fir.shape<2>, !fir.dscope) -> (!fir.ref>, !fir.ref>) ! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_6:.*]] = %[[VAL_5]] to %[[VAL_2]] step %[[VAL_5]] { -! CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_5]] to %[[VAL_1]] step %[[VAL_5]] { +! CHECK: fir.do_loop %[[VAL_6:.*]] = %[[VAL_5]] to %[[VAL_2]] step %[[VAL_5]] attributes {operandSegmentSizes = array} { +! CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_5]] to %[[VAL_1]] step %[[VAL_5]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_8:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_7]], %[[VAL_6]]) : (!fir.ref>, index, index) -> !fir.ref ! CHECK: fir.call @_QPimpure_elem(%[[VAL_8]]) fastmath : (!fir.ref) -> () ! CHECK: } @@ -138,8 +138,8 @@ elemental subroutine ordered_elem(a) ! CHECK: %[[VAL_3:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_0]](%[[VAL_3]]) dummy_scope %{{[0-9]+}} {uniq_name = "_QFordered_elementalEx"} : (!fir.ref>, !fir.shape<2>, !fir.dscope) -> (!fir.ref>, !fir.ref>) ! CHECK: %[[VAL_5:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_6:.*]] = %[[VAL_5]] to %[[VAL_2]] step %[[VAL_5]] { -! CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_5]] to %[[VAL_1]] step %[[VAL_5]] { +! CHECK: fir.do_loop %[[VAL_6:.*]] = %[[VAL_5]] to %[[VAL_2]] step %[[VAL_5]] attributes {operandSegmentSizes = array} { +! CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_5]] to %[[VAL_1]] step %[[VAL_5]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_8:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_7]], %[[VAL_6]]) : (!fir.ref>, index, index) -> !fir.ref ! CHECK: fir.call @_QPordered_elem(%[[VAL_8]]) fastmath : (!fir.ref) -> () ! CHECK: } @@ -171,8 +171,8 @@ impure elemental subroutine impure_elem(a) ! CHECK: } ! CHECK: %[[VAL_11:.*]]:3 = hlfir.associate %[[VAL_5]](%[[VAL_3]]) {uniq_name = "adapt.impure_arg_eval"} : (!hlfir.expr<10x20xf32>, !fir.shape<2>) -> (!fir.ref>, !fir.ref>, i1) ! CHECK: %[[VAL_13:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_14:.*]] = %[[VAL_13]] to %[[VAL_2]] step %[[VAL_13]] { -! CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_1]] step %[[VAL_13]] { +! CHECK: fir.do_loop %[[VAL_14:.*]] = %[[VAL_13]] to %[[VAL_2]] step %[[VAL_13]] attributes {operandSegmentSizes = array} { +! CHECK: fir.do_loop %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_1]] step %[[VAL_13]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_16:.*]] = hlfir.designate %[[VAL_11]]#0 (%[[VAL_15]], %[[VAL_14]]) : (!fir.ref>, index, index) -> !fir.ref ! CHECK: fir.call @_QPimpure_elem(%[[VAL_16]]) fastmath : (!fir.ref) -> () ! CHECK: } diff --git a/flang/test/Lower/HLFIR/intrinsic-subroutines.f90 b/flang/test/Lower/HLFIR/intrinsic-subroutines.f90 index 216e044ec9cab..f3cc0c3b3af71 100644 --- a/flang/test/Lower/HLFIR/intrinsic-subroutines.f90 +++ b/flang/test/Lower/HLFIR/intrinsic-subroutines.f90 @@ -43,7 +43,7 @@ program main ! CHECK: %[[VAL_13:.*]] = arith.constant 2 : i32 ! CHECK: %[[VAL_14:.*]] = arith.constant 0 : i32 ! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_16:.*]] = %[[VAL_15]] to %[[VAL_0]] step %[[VAL_15]] { +! CHECK: fir.do_loop %[[VAL_16:.*]] = %[[VAL_15]] to %[[VAL_0]] step %[[VAL_15]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_17:.*]] = hlfir.designate %[[VAL_3]]#0 (%[[VAL_16]]) : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_17]] : !fir.ref ! CHECK: %[[VAL_19:.*]] = hlfir.designate %[[VAL_9]]#0 (%[[VAL_16]]) : (!fir.ref>, index) -> !fir.ref diff --git a/flang/test/Lower/Intrinsics/cmplx.f90 b/flang/test/Lower/Intrinsics/cmplx.f90 index fe08920ece512..8c65686615011 100644 --- a/flang/test/Lower/Intrinsics/cmplx.f90 +++ b/flang/test/Lower/Intrinsics/cmplx.f90 @@ -138,7 +138,7 @@ subroutine cmplx_array(x, y) ! CHECK: %[[VAL_20:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_21:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_22:.*]] = arith.subi %[[VAL_8]]#1, %[[VAL_20]] : index -! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_21]] to %[[VAL_22]] step %[[VAL_20]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_19]]) -> (!fir.array>) { +! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_21]] to %[[VAL_22]] step %[[VAL_20]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_19]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_26:.*]] = fir.array_fetch %[[VAL_9]], %[[VAL_24]] : (!fir.array, index) -> f32 ! CHECK: %[[VAL_27:.*]] = fir.if %[[VAL_10]] -> (f32) { ! CHECK: %[[VAL_28:.*]] = fir.array_fetch %[[VAL_16]], %[[VAL_24]] : (!fir.array, index) -> f32 diff --git a/flang/test/Lower/Intrinsics/ieee_festatus.f90 b/flang/test/Lower/Intrinsics/ieee_festatus.f90 index 0fbaf2f4d00c7..6bb5e253776a8 100644 --- a/flang/test/Lower/Intrinsics/ieee_festatus.f90 +++ b/flang/test/Lower/Intrinsics/ieee_festatus.f90 @@ -22,7 +22,7 @@ program s ! CHECK: %[[V_60:[0-9]+]] = fir.address_of(@_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.0) : !fir.ref>> ! CHECK: %[[V_61:[0-9]+]] = fir.declare %[[V_60]](%[[V_1]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.0"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_95:[0-9]+]] = fir.array_coor %[[V_61]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_96:[0-9]+]] = fir.field_index _QM__fortran_ieee_exceptionsTieee_flag_type.flag, !fir.type<_QM__fortran_ieee_exceptionsTieee_flag_type{_QM__fortran_ieee_exceptionsTieee_flag_type.flag:i8}> ! CHECK: %[[V_97:[0-9]+]] = fir.coordinate_of %[[V_95]], %[[V_96]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -38,7 +38,7 @@ program s call ieee_set_halting_mode(ieee_all, .true.) ! CHECK: %[[V_62:[0-9]+]] = fir.declare %[[V_60]](%[[V_1]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.0"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_95:[0-9]+]] = fir.array_coor %[[V_62]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_96:[0-9]+]] = fir.array_coor %[[V_59]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_97:[0-9]+]] = fir.field_index _QM__fortran_ieee_exceptionsTieee_flag_type.flag, !fir.type<_QM__fortran_ieee_exceptionsTieee_flag_type{_QM__fortran_ieee_exceptionsTieee_flag_type.flag:i8}> @@ -62,7 +62,7 @@ program s ! CHECK: %[[V_77:[0-9]+]] = fir.address_of(@_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.1) : !fir.ref>> ! CHECK: %[[V_78:[0-9]+]] = fir.declare %[[V_77]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.1"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_95:[0-9]+]] = fir.array_coor %[[V_78]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_96:[0-9]+]] = fir.field_index _QM__fortran_ieee_exceptionsTieee_flag_type.flag, !fir.type<_QM__fortran_ieee_exceptionsTieee_flag_type{_QM__fortran_ieee_exceptionsTieee_flag_type.flag:i8}> ! CHECK: %[[V_97:[0-9]+]] = fir.coordinate_of %[[V_95]], %[[V_96]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -78,7 +78,7 @@ program s call ieee_set_halting_mode(ieee_usual, .false.) ! CHECK: %[[V_79:[0-9]+]] = fir.declare %[[V_60]](%[[V_1]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.0"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_95:[0-9]+]] = fir.array_coor %[[V_79]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_96:[0-9]+]] = fir.array_coor %[[V_59]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_97:[0-9]+]] = fir.field_index _QM__fortran_ieee_exceptionsTieee_flag_type.flag, !fir.type<_QM__fortran_ieee_exceptionsTieee_flag_type{_QM__fortran_ieee_exceptionsTieee_flag_type.flag:i8}> @@ -100,7 +100,7 @@ program s ! CHECK: %[[V_88:[0-9]+]] = fir.declare %[[V_60]](%[[V_1]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.0"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> call ieee_set_status(status) - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_95:[0-9]+]] = fir.array_coor %[[V_88]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_96:[0-9]+]] = fir.array_coor %[[V_59]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_97:[0-9]+]] = fir.field_index _QM__fortran_ieee_exceptionsTieee_flag_type.flag, !fir.type<_QM__fortran_ieee_exceptionsTieee_flag_type{_QM__fortran_ieee_exceptionsTieee_flag_type.flag:i8}> diff --git a/flang/test/Lower/Intrinsics/ieee_flag.f90 b/flang/test/Lower/Intrinsics/ieee_flag.f90 index 7cd24c07ce9bd..1107f8b507401 100644 --- a/flang/test/Lower/Intrinsics/ieee_flag.f90 +++ b/flang/test/Lower/Intrinsics/ieee_flag.f90 @@ -96,7 +96,7 @@ ! CHECK: %[[V_140:[0-9]+]] = fir.address_of(@_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.1) : !fir.ref>> ! CHECK: %[[V_141:[0-9]+]] = fir.declare %[[V_140]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.1"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_141]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref @@ -112,7 +112,7 @@ ! CHECK: %[[V_142:[0-9]+]] = fir.address_of(@_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.2) : !fir.ref>> ! CHECK: %[[V_143:[0-9]+]] = fir.declare %[[V_142]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.2"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_143]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_60]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -132,7 +132,7 @@ ! CHECK: %[[V_154:[0-9]+]] = fir.declare %[[V_140]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.1"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> ! CHECK: %[[V_155:[0-9]+]] = fir.address_of(@_QQro.2xl4.3) : !fir.ref>> ! CHECK: %[[V_156:[0-9]+]] = fir.declare %[[V_155]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2xl4.3"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_154]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_156]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref> @@ -150,7 +150,7 @@ call ieee_set_flag([ieee_invalid, ieee_overflow], [.false., .true.]) ! CHECK: %[[V_157:[0-9]+]] = fir.declare %[[V_142]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.2"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_157]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_60]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -169,7 +169,7 @@ ! CHECK: %[[V_165:[0-9]+]] = fir.address_of(@_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4) : !fir.ref>> ! CHECK: %[[V_166:[0-9]+]] = fir.declare %[[V_165]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_166]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref @@ -184,7 +184,7 @@ call ieee_set_flag(ieee_usual, .true.) ! CHECK: %[[V_167:[0-9]+]] = fir.declare %[[V_165]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_167]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_64]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -204,7 +204,7 @@ ! CHECK: %[[V_178:[0-9]+]] = fir.declare %[[V_165]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> ! CHECK: %[[V_179:[0-9]+]] = fir.address_of(@_QQro.3xl4.5) : !fir.ref>> ! CHECK: %[[V_180:[0-9]+]] = fir.declare %[[V_179]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3xl4.5"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_178]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_180]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref> @@ -222,7 +222,7 @@ call ieee_set_flag(ieee_usual, [.true., .false., .true.]) ! CHECK: %[[V_181:[0-9]+]] = fir.declare %[[V_165]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_181]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_64]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -241,7 +241,7 @@ ! CHECK: %[[V_189:[0-9]+]] = fir.address_of(@_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.6) : !fir.ref>> ! CHECK: %[[V_190:[0-9]+]] = fir.declare %[[V_189]](%[[V_1]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.6"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_190]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref @@ -256,7 +256,7 @@ call ieee_set_flag(ieee_all, .false.) ! CHECK: %[[V_191:[0-9]+]] = fir.declare %[[V_189]](%[[V_1]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.6"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_191]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_62]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -343,7 +343,7 @@ print*, 'invalid[T]: ', v ! CHECK: %[[V_266:[0-9]+]] = fir.declare %[[V_140]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.1"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_266]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref @@ -358,7 +358,7 @@ call ieee_set_halting_mode([ieee_invalid, ieee_overflow], .false.) ! CHECK: %[[V_267:[0-9]+]] = fir.declare %[[V_142]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.2"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_267]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_60]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -378,7 +378,7 @@ ! CHECK: %[[V_274:[0-9]+]] = fir.declare %[[V_140]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.1"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> ! CHECK: %[[V_275:[0-9]+]] = fir.declare %[[V_155]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2xl4.3"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_274]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_275]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref> @@ -396,7 +396,7 @@ call ieee_set_halting_mode([ieee_invalid, ieee_overflow], [.false., .true.]) ! CHECK: %[[V_276:[0-9]+]] = fir.declare %[[V_142]](%[[V_59]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.2x_QM__fortran_ieee_exceptionsTieee_flag_type.2"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c2{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_276]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_60]](%[[V_59]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -415,7 +415,7 @@ print*, '[overflow[T], invalid[F]]: ', v2 ! CHECK: %[[V_283:[0-9]+]] = fir.declare %[[V_165]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_283]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref @@ -430,7 +430,7 @@ call ieee_set_halting_mode(ieee_usual, .true.) ! CHECK: %[[V_284:[0-9]+]] = fir.declare %[[V_165]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_284]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_64]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -450,7 +450,7 @@ ! CHECK: %[[V_291:[0-9]+]] = fir.declare %[[V_165]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> ! CHECK: %[[V_292:[0-9]+]] = fir.declare %[[V_179]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3xl4.5"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_291]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_292]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref> @@ -468,7 +468,7 @@ call ieee_set_halting_mode(ieee_usual, [.true., .false., .true.]) ! CHECK: %[[V_293:[0-9]+]] = fir.declare %[[V_165]](%[[V_54]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.3x_QM__fortran_ieee_exceptionsTieee_flag_type.4"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c3{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_293]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_64]](%[[V_54]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref @@ -487,7 +487,7 @@ print*, '[overflow[T], divide_by_zero[F], invalid[T]]: ', v_usual ! CHECK: %[[V_300:[0-9]+]] = fir.declare %[[V_189]](%[[V_1]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.6"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_300]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref ! CHECK: %[[V_312:[0-9]+]] = fir.load %[[V_311]] : !fir.ref @@ -502,7 +502,7 @@ call ieee_set_halting_mode(ieee_all, .true.) ! CHECK: %[[V_301:[0-9]+]] = fir.declare %[[V_189]](%[[V_1]]) {fortran_attrs = #fir.var_attrs, uniq_name = "_QQro.5x_QM__fortran_ieee_exceptionsTieee_flag_type.6"} : (!fir.ref>>, !fir.shape<1>) -> !fir.ref>> - ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} { + ! CHECK: fir.do_loop %arg0 = %c1{{.*}} to %c5{{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_310:[0-9]+]] = fir.array_coor %[[V_301]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_311:[0-9]+]] = fir.array_coor %[[V_62]](%[[V_1]]) %arg0 : (!fir.ref>>, !fir.shape<1>, index) -> !fir.ref> ! CHECK: %[[V_312:[0-9]+]] = fir.coordinate_of %[[V_310]], %[[V_82]] : (!fir.ref>, !fir.field) -> !fir.ref diff --git a/flang/test/Lower/Intrinsics/index.f90 b/flang/test/Lower/Intrinsics/index.f90 index f1204458f7a40..ae1a43ba4f1f8 100644 --- a/flang/test/Lower/Intrinsics/index.f90 +++ b/flang/test/Lower/Intrinsics/index.f90 @@ -65,7 +65,7 @@ subroutine test_optional(string, substring, back) ! CHECK: %[[VAL_15:.*]] = fir.embox %[[VAL_12]](%[[VAL_14]]) : (!fir.ref>>, !fir.shape<1>) -> !fir.box>> ! CHECK: %[[VAL_16:.*]] = arith.select %[[VAL_11]], %[[VAL_2]], %[[VAL_15]] : !fir.box>> ! CHECK: %[[VAL_17:.*]] = fir.array_load %[[VAL_16]] {fir.optional} : (!fir.box>>) -> !fir.array> -! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_26:.*]] = %{{.*}}) -> (!fir.array) { +! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_26:.*]] = %{{.*}}) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_31:.*]] = fir.if %[[VAL_11]] -> (!fir.logical<4>) { ! CHECK: %[[VAL_32:.*]] = fir.array_fetch %[[VAL_17]], %[[VAL_25]] : (!fir.array>, index) -> !fir.logical<4> ! CHECK: fir.result %[[VAL_32]] : !fir.logical<4> diff --git a/flang/test/Lower/Intrinsics/max.f90 b/flang/test/Lower/Intrinsics/max.f90 index 1909a4eca3f67..0de59c9770380 100644 --- a/flang/test/Lower/Intrinsics/max.f90 +++ b/flang/test/Lower/Intrinsics/max.f90 @@ -14,7 +14,7 @@ subroutine dynamic_optional(a, b, c) ! CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_2]] : (!fir.box>) -> i1 ! CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_12]], %[[VAL_2]], %{{.*}} : !fir.box> ! CHECK: %[[VAL_18:.*]] = fir.array_load %[[VAL_17]] {fir.optional} : (!fir.box>) -> !fir.array - ! CHECK: fir.do_loop %[[VAL_26:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_27:.*]] = %{{.*}}) -> (!fir.array) { + ! CHECK: fir.do_loop %[[VAL_26:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_27:.*]] = %{{.*}}) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_28:.*]] = fir.array_fetch %[[VAL_10]], %[[VAL_26]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_29:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_26]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_30:.*]] = arith.cmpi sgt, %[[VAL_28]], %[[VAL_29]] : i32 @@ -44,7 +44,7 @@ subroutine dynamic_optional_array_expr_scalar_optional(a, b, c) ! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>) -> !fir.array ! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>) -> !fir.array ! CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_2]] : (!fir.ref) -> i1 - ! CHECK: fir.do_loop %[[VAL_20:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_21:.*]] = %{{.*}}) -> (!fir.array) { + ! CHECK: fir.do_loop %[[VAL_20:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_21:.*]] = %{{.*}}) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_22:.*]] = fir.array_fetch %[[VAL_10]], %[[VAL_20]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_23:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_20]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_24:.*]] = arith.cmpi sgt, %[[VAL_22]], %[[VAL_23]] : i32 diff --git a/flang/test/Lower/Intrinsics/mvbits.f90 b/flang/test/Lower/Intrinsics/mvbits.f90 index 747418fd35f28..e610409319828 100644 --- a/flang/test/Lower/Intrinsics/mvbits.f90 +++ b/flang/test/Lower/Intrinsics/mvbits.f90 @@ -44,7 +44,7 @@ function mvbits_test(from, frompos, len, to, topos) ! CHECK: %[[VAL_11:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_12:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_13:.*]] = arith.subi %[[VAL_6]]#1, %[[VAL_11]] : index -! CHECK: fir.do_loop %[[VAL_14:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_11]] { +! CHECK: fir.do_loop %[[VAL_14:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_11]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_15:.*]] = fir.array_fetch %[[VAL_7]], %[[VAL_14]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_17:.*]] = arith.addi %[[VAL_14]], %[[VAL_16]] : index diff --git a/flang/test/Lower/Intrinsics/scan.f90 b/flang/test/Lower/Intrinsics/scan.f90 index 2dd6933bc46fa..7977e58db5ff6 100644 --- a/flang/test/Lower/Intrinsics/scan.f90 +++ b/flang/test/Lower/Intrinsics/scan.f90 @@ -51,7 +51,7 @@ subroutine test_optional(string, set, back) ! CHECK: %[[VAL_15:.*]] = fir.embox %[[VAL_12]](%[[VAL_14]]) : (!fir.ref>>, !fir.shape<1>) -> !fir.box>> ! CHECK: %[[VAL_16:.*]] = arith.select %[[VAL_11]], %[[VAL_2]], %[[VAL_15]] : !fir.box>> ! CHECK: %[[VAL_17:.*]] = fir.array_load %[[VAL_16]] {fir.optional} : (!fir.box>>) -> !fir.array> -! CHECK: fir.do_loop %[[VAL_25:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array) { +! CHECK: fir.do_loop %[[VAL_25:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_31:.*]] = fir.if %[[VAL_11]] -> (!fir.logical<4>) { ! CHECK: %[[VAL_32:.*]] = fir.array_fetch %[[VAL_17]], %[[VAL_25]] : (!fir.array>, index) -> !fir.logical<4> ! CHECK: fir.result %[[VAL_32]] : !fir.logical<4> @@ -83,7 +83,7 @@ subroutine test_optional_scalar(string, set, back) ! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i1) -> !fir.logical<4> ! CHECK: fir.result %[[VAL_15]] : !fir.logical<4> ! CHECK: } -! CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array) { +! CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_12]] : (!fir.logical<4>) -> i1 ! CHECK: fir.call @_FortranAScan1(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_39]]) {{.*}}: (!fir.ref, i64, !fir.ref, i64, i1) -> i64 ! CHECK: } diff --git a/flang/test/Lower/Intrinsics/transfer.f90 b/flang/test/Lower/Intrinsics/transfer.f90 index 812946f106476..323cd3feffb21 100644 --- a/flang/test/Lower/Intrinsics/transfer.f90 +++ b/flang/test/Lower/Intrinsics/transfer.f90 @@ -60,7 +60,7 @@ subroutine trans_test(store, word) ! CHECK: %[[VAL_28:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_29:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_30:.*]] = arith.subi %[[VAL_3]], %[[VAL_28]] : index - ! CHECK: %[[VAL_31:.*]] = fir.do_loop %[[VAL_32:.*]] = %[[VAL_29]] to %[[VAL_30]] step %[[VAL_28]] unordered iter_args(%[[VAL_33:.*]] = %[[VAL_5]]) -> (!fir.array<3xi32>) { + ! CHECK: %[[VAL_31:.*]] = fir.do_loop %[[VAL_32:.*]] = %[[VAL_29]] to %[[VAL_30]] step %[[VAL_28]] unordered iter_args(%[[VAL_33:.*]] = %[[VAL_5]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_34:.*]] = fir.array_fetch %[[VAL_27]], %[[VAL_32]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_35:.*]] = fir.array_update %[[VAL_33]], %[[VAL_34]], %[[VAL_32]] : (!fir.array<3xi32>, i32, index) -> !fir.array<3xi32> ! CHECK: fir.result %[[VAL_35]] : !fir.array<3xi32> diff --git a/flang/test/Lower/Intrinsics/transpose_opt.f90 b/flang/test/Lower/Intrinsics/transpose_opt.f90 index 65102d1f8912f..0141af66c8d9a 100644 --- a/flang/test/Lower/Intrinsics/transpose_opt.f90 +++ b/flang/test/Lower/Intrinsics/transpose_opt.f90 @@ -12,8 +12,8 @@ subroutine transpose_test(mat) ! CHECK: %[[VAL_6:.*]] = fir.array_load %[[VAL_0]](%{{.*}}) : (!fir.ref>, !fir.shape<2>) -> !fir.array<2x3xf32> ! CHECK: %[[VAL_7:.*]] = fir.allocmem !fir.array<3x2xf32> ! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_7]](%{{.*}}) : (!fir.heap>, !fir.shape<2>) -> !fir.array<3x2xf32> -! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_16:.*]] = %[[VAL_9]]) -> (!fir.array<3x2xf32>) { -! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_19:.*]] = %[[VAL_16]]) -> (!fir.array<3x2xf32>) { +! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_16:.*]] = %[[VAL_9]]) -> (!fir.array<3x2xf32>) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_19:.*]] = %[[VAL_16]]) -> (!fir.array<3x2xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_20:.*]] = fir.array_fetch %[[VAL_6]], %[[VAL_15]], %[[VAL_18]] : (!fir.array<2x3xf32>, index, index) -> f32 ! CHECK: %[[VAL_21:.*]] = fir.array_update %[[VAL_19]], %[[VAL_20]], %[[VAL_18]], %[[VAL_15]] : (!fir.array<3x2xf32>, f32, index, index) -> !fir.array<3x2xf32> ! CHECK: fir.result %[[VAL_21]] : !fir.array<3x2xf32> @@ -50,8 +50,8 @@ subroutine transpose_allocatable_test(mat) ! CHECK: %[[VAL_25:.*]] = fir.allocmem !fir.array ! CHECK: %[[VAL_27:.*]] = fir.array_load %[[VAL_25]](%{{.*}}) : (!fir.heap>, !fir.shape<2>) -> !fir.array -! CHECK: %[[VAL_32:.*]] = fir.do_loop %[[VAL_33:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_34:.*]] = %[[VAL_27]]) -> (!fir.array) { -! CHECK: %[[VAL_35:.*]] = fir.do_loop %[[VAL_36:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_37:.*]] = %[[VAL_34]]) -> (!fir.array) { +! CHECK: %[[VAL_32:.*]] = fir.do_loop %[[VAL_33:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_34:.*]] = %[[VAL_27]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_35:.*]] = fir.do_loop %[[VAL_36:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_37:.*]] = %[[VAL_34]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_38:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_33]], %[[VAL_36]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_39:.*]] = fir.array_update %[[VAL_37]], %[[VAL_38]], %[[VAL_36]], %[[VAL_33]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_39]] : !fir.array @@ -64,8 +64,8 @@ subroutine transpose_allocatable_test(mat) ! CHECK: %[[VAL_43:.*]] = fir.array_load %[[VAL_10]](%{{.*}}) : (!fir.heap>, !fir.shape<2>) -> !fir.array -! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_50:.*]] = %[[VAL_43]]) -> (!fir.array) { -! CHECK: %[[VAL_51:.*]] = fir.do_loop %[[VAL_52:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_53:.*]] = %[[VAL_50]]) -> (!fir.array) { +! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_50:.*]] = %[[VAL_43]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_51:.*]] = fir.do_loop %[[VAL_52:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_53:.*]] = %[[VAL_50]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_54:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_49]], %[[VAL_52]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_55:.*]] = fir.array_update %[[VAL_53]], %[[VAL_54]], %[[VAL_52]], %[[VAL_49]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_55]] : !fir.array @@ -82,8 +82,8 @@ subroutine transpose_allocatable_test(mat) ! CHECK: %[[VAL_60:.*]] = fir.allocmem !fir.array ! CHECK: %[[VAL_62:.*]] = fir.array_load %[[VAL_60]](%{{.*}}) : (!fir.heap>, !fir.shape<2>) -> !fir.array -! CHECK: %[[VAL_67:.*]] = fir.do_loop %[[VAL_68:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_69:.*]] = %[[VAL_62]]) -> (!fir.array) { -! CHECK: %[[VAL_70:.*]] = fir.do_loop %[[VAL_71:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_72:.*]] = %[[VAL_69]]) -> (!fir.array) { +! CHECK: %[[VAL_67:.*]] = fir.do_loop %[[VAL_68:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_69:.*]] = %[[VAL_62]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_70:.*]] = fir.do_loop %[[VAL_71:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_72:.*]] = %[[VAL_69]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_73:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_68]], %[[VAL_71]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_74:.*]] = fir.array_update %[[VAL_72]], %[[VAL_73]], %[[VAL_71]], %[[VAL_68]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_74]] : !fir.array diff --git a/flang/test/Lower/Intrinsics/verify.f90 b/flang/test/Lower/Intrinsics/verify.f90 index eb1454c001f70..de79e5cd45d2e 100644 --- a/flang/test/Lower/Intrinsics/verify.f90 +++ b/flang/test/Lower/Intrinsics/verify.f90 @@ -68,7 +68,7 @@ subroutine test_optional(string, set, back) ! CHECK: %[[VAL_15:.*]] = fir.embox %[[VAL_12]](%[[VAL_14]]) : (!fir.ref>>, !fir.shape<1>) -> !fir.box>> ! CHECK: %[[VAL_16:.*]] = arith.select %[[VAL_11]], %[[VAL_2]], %[[VAL_15]] : !fir.box>> ! CHECK: %[[VAL_17:.*]] = fir.array_load %[[VAL_16]] {fir.optional} : (!fir.box>>) -> !fir.array> -! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_26:.*]] = %{{.*}}) -> (!fir.array) { +! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_26:.*]] = %{{.*}}) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_31:.*]] = fir.if %[[VAL_11]] -> (!fir.logical<4>) { ! CHECK: %[[VAL_32:.*]] = fir.array_fetch %[[VAL_17]], %[[VAL_25]] : (!fir.array>, index) -> !fir.logical<4> ! CHECK: fir.result %[[VAL_32]] : !fir.logical<4> diff --git a/flang/test/Lower/OpenACC/acc-declare.f90 b/flang/test/Lower/OpenACC/acc-declare.f90 index ff1e756c20e12..8652c2910e43e 100644 --- a/flang/test/Lower/OpenACC/acc-declare.f90 +++ b/flang/test/Lower/OpenACC/acc-declare.f90 @@ -22,7 +22,7 @@ subroutine acc_declare_copy() ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%{{.*}} : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) ! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[DECL]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: %[[TOKEN:.*]] = acc.declare_enter dataOperands(%[[COPYIN]] : !fir.ref>) -! CHECK: %{{.*}}:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %{{.*}}) -> (index, i32) { +! CHECK: %{{.*}}:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { ! CHECK: } ! CHECK: acc.declare_exit token(%[[TOKEN]]) dataOperands(%[[COPYIN]] : !fir.ref>) ! CHECK: acc.copyout accPtr(%[[COPYIN]] : !fir.ref>) bounds(%[[BOUND]]) to varPtr(%[[DECL]]#0 : !fir.ref>) {dataClause = #acc, name = "a"} @@ -44,7 +44,7 @@ subroutine acc_declare_create() ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%{{.*}} : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) ! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECL]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a"} ! CHECK: %[[TOKEN:.*]] = acc.declare_enter dataOperands(%[[CREATE]] : !fir.ref>) -! CHECK: %{{.*}}:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %{{.*}}) -> (index, i32) { +! CHECK: %{{.*}}:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { ! CHECK: } ! CHECK: acc.declare_exit token(%[[TOKEN]]) dataOperands(%[[CREATE]] : !fir.ref>) ! CHECK: acc.delete accPtr(%[[CREATE]] : !fir.ref>) bounds(%[[BOUND]]) {dataClause = #acc, name = "a"} @@ -299,7 +299,7 @@ subroutine acc_declare_multiple_directive(a, b) ! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[DECL_A]]#0 : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECL_B]]#0 : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {dataClause = #acc, name = "b"} ! CHECK: acc.declare_enter dataOperands(%[[COPYIN]], %[[CREATE]] : !fir.ref>, !fir.ref>) -! CHECK: %{{.*}}:{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %{{.*}}) -> (index, i32) { +! CHECK: %{{.*}}:{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { ! CHECK: acc.copyout accPtr(%[[CREATE]] : !fir.ref>) bounds(%{{.*}}) to varPtr(%[[DECL_B]]#0 : !fir.ref>) {name = "b"} diff --git a/flang/test/Lower/OpenACC/acc-reduction.f90 b/flang/test/Lower/OpenACC/acc-reduction.f90 index 545c4f217577b..b59734d059632 100644 --- a/flang/test/Lower/OpenACC/acc-reduction.f90 +++ b/flang/test/Lower/OpenACC/acc-reduction.f90 @@ -325,7 +325,7 @@ ! CHECK: %[[LB:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.constant 99 : index ! CHECK: %[[STEP:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] { +! CHECK: fir.do_loop %[[IV:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[DECLARE]]#0, %[[IV]] : (!fir.ref>, index) -> !fir.ref ! CHECK: fir.store %[[INIT]] to %[[COORD]] : !fir.ref ! CHECK: } @@ -335,7 +335,7 @@ ! CHECK: %[[LB0:.*]] = arith.constant 0 : index ! CHECK: %[[UB0:.*]] = arith.constant 99 : index ! CHECK: %[[STEP0:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] { +! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0]], %[[IV0]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1]], %[[IV0]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[LOAD1:.*]] = fir.load %[[COORD1]] : !fir.ref @@ -376,11 +376,11 @@ ! CHECK: %[[LB0:.*]] = arith.constant 0 : index ! CHECK: %[[UB0:.*]] = arith.constant 9 : index ! CHECK: %[[STEP0:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] { +! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] attributes {operandSegmentSizes = array} { ! CHECK: %[[LB1:.*]] = arith.constant 0 : index ! CHECK: %[[UB1:.*]] = arith.constant 99 : index ! CHECK: %[[STEP1:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] { +! CHECK: fir.do_loop %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0:.*]], %[[IV0]], %[[IV1]] : (!fir.ref>, index, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1:.*]], %[[IV0]], %[[IV1]] : (!fir.ref>, index, index) -> !fir.ref ! CHECK: %[[LOAD1:.*]] = fir.load %[[COORD1]] : !fir.ref @@ -422,11 +422,11 @@ ! CHECK: %[[LB0:.*]] = arith.constant 0 : index ! CHECK: %[[UB0:.*]] = arith.constant 9 : index ! CHECK: %[[STEP0:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] { +! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] attributes {operandSegmentSizes = array} { ! CHECK: %[[LB1:.*]] = arith.constant 0 : index ! CHECK: %[[UB1:.*]] = arith.constant 99 : index ! CHECK: %[[STEP1:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] { +! CHECK: fir.do_loop %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0]], %[[IV0]], %[[IV1]] : (!fir.ref>, index, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1]], %[[IV0]], %[[IV1]] : (!fir.ref>, index, index) -> !fir.ref ! CHECK: %[[LOAD1:.*]] = fir.load %[[COORD1]] : !fir.ref @@ -468,7 +468,7 @@ ! CHECK: %[[LB0:.*]] = arith.constant 0 : index ! CHECK: %[[UB0:.*]] = arith.constant 99 : index ! CHECK: %[[STEP0:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] { +! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0]], %[[IV0]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1]], %[[IV0]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[LOAD1:.*]] = fir.load %[[COORD1]] : !fir.ref @@ -525,7 +525,7 @@ ! CHECK: %[[LB:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.constant 99 : index ! CHECK: %[[STEP:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] { +! CHECK: fir.do_loop %[[IV:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0]], %[[IV]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1]], %[[IV]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[LOAD1:.*]] = fir.load %[[COORD1]] : !fir.ref @@ -564,7 +564,7 @@ ! CHECK: %[[LB:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.constant 99 : index ! CHECK: %[[STEP:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] { +! CHECK: fir.do_loop %[[IV:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0]], %[[IV]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1]], %[[IV]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[LOAD1:.*]] = fir.load %[[COORD1]] : !fir.ref @@ -603,15 +603,15 @@ ! CHECK: %[[LB0:.*]] = arith.constant 0 : index ! CHECK: %[[UB0:.*]] = arith.constant 1 : index ! CHECK: %[[STEP0:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] { +! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] attributes {operandSegmentSizes = array} { ! CHECK: %[[LB1:.*]] = arith.constant 0 : index ! CHECK: %[[UB1:.*]] = arith.constant 9 : index ! CHECK: %[[STEP1:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] { +! CHECK: fir.do_loop %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[LB2:.*]] = arith.constant 0 : index ! CHECK: %[[UB2:.*]] = arith.constant 99 : index ! CHECK: %[[STEP2:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV2:.*]] = %[[LB2]] to %[[UB2]] step %[[STEP2]] { +! CHECK: fir.do_loop %[[IV2:.*]] = %[[LB2]] to %[[UB2]] step %[[STEP2]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0]], %[[IV0]], %[[IV1]], %[[IV2]] : (!fir.ref>, index, index, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1]], %[[IV0]], %[[IV1]], %[[IV2]] : (!fir.ref>, index, index, index) -> !fir.ref ! CHECK: %[[LOAD1:.*]] = fir.load %[[COORD1]] : !fir.ref @@ -636,11 +636,11 @@ ! CHECK: %[[LB0:.*]] = arith.constant 0 : index ! CHECK: %[[UB0:.*]] = arith.constant 9 : index ! CHECK: %[[STEP0:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] { +! CHECK: fir.do_loop %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] attributes {operandSegmentSizes = array} { ! CHECK: %[[LB1:.*]] = arith.constant 0 : index ! CHECK: %[[UB1:.*]] = arith.constant 99 : index ! CHECK: %[[STEP1:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] { +! CHECK: fir.do_loop %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0]], %[[IV0]], %[[IV1]] : (!fir.ref>, index, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1]], %[[IV0]], %[[IV1]] : (!fir.ref>, index, index) -> !fir.ref ! CHECK: %[[LOAD1]] = fir.load %[[COORD1]] : !fir.ref @@ -664,7 +664,7 @@ ! CHECK: %[[LB:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.constant 99 : index ! CHECK: %[[STEP:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[IV:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] { +! CHECK: fir.do_loop %[[IV:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD1:.*]] = fir.coordinate_of %[[ARG0]], %[[IV]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[COORD2:.*]] = fir.coordinate_of %[[ARG1]], %[[IV]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[LOAD1:.*]] = fir.load %[[COORD1]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/hlfir-seqloop-parallel.f90 b/flang/test/Lower/OpenMP/hlfir-seqloop-parallel.f90 index 68d20213a14b5..f00f4ec6fad38 100644 --- a/flang/test/Lower/OpenMP/hlfir-seqloop-parallel.f90 +++ b/flang/test/Lower/OpenMP/hlfir-seqloop-parallel.f90 @@ -20,7 +20,7 @@ subroutine sb1 !CHECK: omp.parallel { !CHECK: %[[I_PVT_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", pinned} !CHECK: %[[I_PVT_DECL:.*]]:2 = hlfir.declare %[[I_PVT_ADDR]] {uniq_name = "_QFsb1Ei"} : (!fir.ref) -> (!fir.ref, !fir.ref) -!CHECK: %[[I_FINAL_VAL:.*]]:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[I_VAL:.*]] = %{{.*}}) -> (index, i32) { +!CHECK: %[[I_FINAL_VAL:.*]]:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[I_VAL:.*]] = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { !CHECK: fir.store %[[I_VAL]] to %[[I_PVT_DECL]]#1 : !fir.ref !CHECK: } !CHECK: fir.store %[[I_FINAL_VAL]]#1 to %[[I_PVT_DECL]]#1 : !fir.ref @@ -55,15 +55,15 @@ subroutine sb2 !CHECK: %[[I_PVT_DECL:.*]]:2 = hlfir.declare %[[I_PVT_ADDR]] {uniq_name = "_QFsb2Ei"} : (!fir.ref) -> (!fir.ref, !fir.ref) !CHECK: %[[J_PVT_ADDR:.*]] = fir.alloca i32 {bindc_name = "j", pinned} !CHECK: %[[J_PVT_DECL:.*]]:2 = hlfir.declare %[[J_PVT_ADDR]] {uniq_name = "_QFsb2Ej"} : (!fir.ref) -> (!fir.ref, !fir.ref) -!CHECK: %[[FINAL_J_VAL:.*]]:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[J_VAL:.*]] = %{{.*}}) -> (index, i32) { +!CHECK: %[[FINAL_J_VAL:.*]]:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[J_VAL:.*]] = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { !CHECK: fir.store %arg1 to %9#1 : !fir.ref !CHECK: fir.if %{{.*}} { -!CHECK: %[[FINAL_I_VAL:.*]]:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[I_VAL:.*]] = %{{.*}}) -> (index, i32) { +!CHECK: %[[FINAL_I_VAL:.*]]:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[I_VAL:.*]] = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { !CHECK: fir.store %[[I_VAL]] to %[[I_PVT_DECL]]#1 : !fir.ref !CHECK: } !CHECK: fir.store %[[FINAL_I_VAL]]#1 to %[[I_PVT_DECL]]#1 : !fir.ref !CHECK: } -!CHECK: %[[FINAL_I_VAL:.*]]:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[I_VAL:.*]] = %{{.*}}) -> (index, i32) { +!CHECK: %[[FINAL_I_VAL:.*]]:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[I_VAL:.*]] = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { !CHECK: fir.store %[[I_VAL]] to %[[I_PVT_DECL]]#1 : !fir.ref !CHECK: } !CHECK: fir.store %[[FINAL_I_VAL]]#1 to %[[I_PVT_DECL]]#1 : !fir.ref diff --git a/flang/test/Lower/OpenMP/parallel-private-clause-fixes.f90 b/flang/test/Lower/OpenMP/parallel-private-clause-fixes.f90 index d3843c8e241af..5fc2ca49c60a8 100644 --- a/flang/test/Lower/OpenMP/parallel-private-clause-fixes.f90 +++ b/flang/test/Lower/OpenMP/parallel-private-clause-fixes.f90 @@ -32,7 +32,7 @@ ! CHECK: %[[LB:.*]] = fir.convert %[[VAL_8]] : (index) -> i32 ! CHECK: %[[VAL_12:.*]]:2 = fir.do_loop %[[VAL_13:[^ ]*]] = ! CHECK-SAME: %[[VAL_8]] to %[[VAL_10]] step %[[VAL_11]] -! CHECK-SAME: iter_args(%[[IV:.*]] = %[[LB]]) -> (index, i32) { +! CHECK-SAME: iter_args(%[[IV:.*]] = %[[LB]]) -> (index, i32) attributes {operandSegmentSizes = array} { ! CHECK: fir.store %[[IV]] to %[[PRIV_J_DECL]]#1 : !fir.ref ! CHECK: %[[LOAD:.*]] = fir.load %[[PRIV_I_DECL]]#0 : !fir.ref ! CHECK: %[[VAL_15:.*]] = fir.load %[[PRIV_J_DECL]]#0 : !fir.ref diff --git a/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 b/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 index f6d3b0b73f738..da906ccef5b16 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-allocatable-array.f90 @@ -53,7 +53,7 @@ program reduce ! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_4]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_6:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_9]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 index b44fe4c1f4cc2..0fe079c7b9223 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array-lb.f90 @@ -42,8 +42,8 @@ program reduce ! CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_6]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_8:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1, %[[VAL_7]]#0, %[[VAL_7]]#1 : (index, index, index, index) -> !fir.shapeshift<2> ! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_9]] to %[[VAL_7]]#1 step %[[VAL_9]] unordered { -! CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_5]]#1 step %[[VAL_9]] unordered { +! CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_9]] to %[[VAL_7]]#1 step %[[VAL_9]] unordered attributes {operandSegmentSizes = array} { +! CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_5]]#1 step %[[VAL_9]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_12:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_8]]) %[[VAL_11]], %[[VAL_10]] : (!fir.box>, !fir.shapeshift<2>, index, index) -> !fir.ref ! CHECK: %[[VAL_13:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_8]]) %[[VAL_11]], %[[VAL_10]] : (!fir.box>, !fir.shapeshift<2>, index, index) -> !fir.ref ! CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_12]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array.f90 index 60b21c9b1ebbe..fd7f3248f3c25 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array.f90 @@ -39,7 +39,7 @@ program reduce ! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_4]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_6:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_9]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 b/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 index 5d4c86d1d76e8..9ed77ac57dea1 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction-array2.f90 @@ -38,7 +38,7 @@ program reduce ! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_4]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_6:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_9]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/parallel-reduction3.f90 b/flang/test/Lower/OpenMP/parallel-reduction3.f90 index 47b743a558b49..819a3bf12c1f3 100644 --- a/flang/test/Lower/OpenMP/parallel-reduction3.f90 +++ b/flang/test/Lower/OpenMP/parallel-reduction3.f90 @@ -27,7 +27,7 @@ ! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_4]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_6:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_9]] : !fir.ref 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 be1e3ec0cb9d9..0f1f962b769d2 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array-assumed-shape.f90 @@ -48,7 +48,7 @@ subroutine reduce(r) ! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_4]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_6:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_9]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 index add422f5d9564..856b39194e11b 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array.f90 @@ -40,7 +40,7 @@ program reduce ! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_4]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_6:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_9]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 index e988567fc3371..f252a25836640 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-array2.f90 @@ -40,7 +40,7 @@ program reduce ! CHECK: %[[VAL_5:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_4]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_6:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered { +! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_7]] to %[[VAL_5]]#1 step %[[VAL_7]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_6]]) %[[VAL_8]] : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_9]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 b/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 index ed462b58bbf88..3f0a4ec9fadae 100644 --- a/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 +++ b/flang/test/Lower/OpenMP/wsloop-reduction-multiple-clauses.f90 @@ -55,8 +55,8 @@ program main ! CHECK: %[[VAL_7:.*]]:3 = fir.box_dims %[[VAL_2]], %[[VAL_6]] : (!fir.box>, index) -> (index, index, index) ! CHECK: %[[VAL_8:.*]] = fir.shape_shift %[[VAL_5]]#0, %[[VAL_5]]#1, %[[VAL_7]]#0, %[[VAL_7]]#1 : (index, index, index, index) -> !fir.shapeshift<2> ! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_9]] to %[[VAL_7]]#1 step %[[VAL_9]] unordered { -! CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_5]]#1 step %[[VAL_9]] unordered { +! CHECK: fir.do_loop %[[VAL_10:.*]] = %[[VAL_9]] to %[[VAL_7]]#1 step %[[VAL_9]] unordered {{.*}} { +! CHECK: fir.do_loop %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_5]]#1 step %[[VAL_9]] unordered {{.*}} { ! CHECK: %[[VAL_12:.*]] = fir.array_coor %[[VAL_2]](%[[VAL_8]]) %[[VAL_11]], %[[VAL_10]] : (!fir.box>, !fir.shapeshift<2>, index, index) -> !fir.ref ! CHECK: %[[VAL_13:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_8]]) %[[VAL_11]], %[[VAL_10]] : (!fir.box>, !fir.shapeshift<2>, index, index) -> !fir.ref ! CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_12]] : !fir.ref diff --git a/flang/test/Lower/OpenMP/wsloop-variable.f90 b/flang/test/Lower/OpenMP/wsloop-variable.f90 index 4d83b33288036..ba53fabd93a9a 100644 --- a/flang/test/Lower/OpenMP/wsloop-variable.f90 +++ b/flang/test/Lower/OpenMP/wsloop-variable.f90 @@ -138,7 +138,7 @@ subroutine wsloop_variable_sub !CHECK: %[[VAL_33:.*]] = fir.load %[[VAL_15]]#0 : !fir.ref !CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i32) -> index !CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_30]] : (index) -> i64 -!CHECK: %[[VAL_36:.*]]:2 = fir.do_loop %[[VAL_37:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_34]] iter_args(%[[VAL_38:.*]] = %[[VAL_35]]) -> (index, i64) { +!CHECK: %[[VAL_36:.*]]:2 = fir.do_loop %[[VAL_37:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_34]] iter_args(%[[VAL_38:.*]] = %[[VAL_35]]) -> (index, i64) attributes {operandSegmentSizes = array} { !CHECK: fir.store %[[VAL_38]] to %[[VAL_17]]#1 : !fir.ref !CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref !CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_39]] : (i16) -> i64 diff --git a/flang/test/Lower/allocatable-assignment.f90 b/flang/test/Lower/allocatable-assignment.f90 index 5c9887c507b67..b2f6080b7f1ec 100644 --- a/flang/test/Lower/allocatable-assignment.f90 +++ b/flang/test/Lower/allocatable-assignment.f90 @@ -301,8 +301,8 @@ subroutine test_from_cst_shape_array(x, y) ! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_4]], %[[VAL_27]] : index ! CHECK: %[[VAL_30:.*]] = arith.subi %[[VAL_5]], %[[VAL_27]] : index -! CHECK: %[[VAL_31:.*]] = fir.do_loop %[[VAL_32:.*]] = %[[VAL_28]] to %[[VAL_30]] step %[[VAL_27]] unordered iter_args(%[[VAL_33:.*]] = %[[VAL_26]]) -> (!fir.array) { -! CHECK: %[[VAL_34:.*]] = fir.do_loop %[[VAL_35:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_36:.*]] = %[[VAL_33]]) -> (!fir.array) { +! CHECK: %[[VAL_31:.*]] = fir.do_loop %[[VAL_32:.*]] = %[[VAL_28]] to %[[VAL_30]] step %[[VAL_27]] unordered iter_args(%[[VAL_33:.*]] = %[[VAL_26]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_34:.*]] = fir.do_loop %[[VAL_35:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_36:.*]] = %[[VAL_33]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_37:.*]] = fir.array_fetch %[[VAL_7]], %[[VAL_35]], %[[VAL_32]] : (!fir.array<2x3xf32>, index, index) -> f32 ! CHECK: %[[VAL_38:.*]] = fir.array_update %[[VAL_36]], %[[VAL_37]], %[[VAL_35]], %[[VAL_32]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_38]] : !fir.array @@ -318,8 +318,8 @@ subroutine test_from_cst_shape_array(x, y) ! CHECK: %[[VAL_44:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_45:.*]] = arith.subi %[[VAL_4]], %[[VAL_43]] : index ! CHECK: %[[VAL_46:.*]] = arith.subi %[[VAL_5]], %[[VAL_43]] : index -! CHECK: %[[VAL_47:.*]] = fir.do_loop %[[VAL_48:.*]] = %[[VAL_44]] to %[[VAL_46]] step %[[VAL_43]] unordered iter_args(%[[VAL_49:.*]] = %[[VAL_42]]) -> (!fir.array) { -! CHECK: %[[VAL_50:.*]] = fir.do_loop %[[VAL_51:.*]] = %[[VAL_44]] to %[[VAL_45]] step %[[VAL_43]] unordered iter_args(%[[VAL_52:.*]] = %[[VAL_49]]) -> (!fir.array) { +! CHECK: %[[VAL_47:.*]] = fir.do_loop %[[VAL_48:.*]] = %[[VAL_44]] to %[[VAL_46]] step %[[VAL_43]] unordered iter_args(%[[VAL_49:.*]] = %[[VAL_42]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_50:.*]] = fir.do_loop %[[VAL_51:.*]] = %[[VAL_44]] to %[[VAL_45]] step %[[VAL_43]] unordered iter_args(%[[VAL_52:.*]] = %[[VAL_49]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_53:.*]] = fir.array_fetch %[[VAL_7]], %[[VAL_51]], %[[VAL_48]] : (!fir.array<2x3xf32>, index, index) -> f32 ! CHECK: %[[VAL_54:.*]] = fir.array_update %[[VAL_52]], %[[VAL_53]], %[[VAL_51]], %[[VAL_48]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_54]] : !fir.array @@ -339,8 +339,8 @@ subroutine test_from_cst_shape_array(x, y) ! CHECK: %[[VAL_63:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_64:.*]] = arith.subi %[[VAL_4]], %[[VAL_62]] : index ! CHECK: %[[VAL_65:.*]] = arith.subi %[[VAL_5]], %[[VAL_62]] : index -! CHECK: %[[VAL_66:.*]] = fir.do_loop %[[VAL_67:.*]] = %[[VAL_63]] to %[[VAL_65]] step %[[VAL_62]] unordered iter_args(%[[VAL_68:.*]] = %[[VAL_61]]) -> (!fir.array) { -! CHECK: %[[VAL_69:.*]] = fir.do_loop %[[VAL_70:.*]] = %[[VAL_63]] to %[[VAL_64]] step %[[VAL_62]] unordered iter_args(%[[VAL_71:.*]] = %[[VAL_68]]) -> (!fir.array) { +! CHECK: %[[VAL_66:.*]] = fir.do_loop %[[VAL_67:.*]] = %[[VAL_63]] to %[[VAL_65]] step %[[VAL_62]] unordered iter_args(%[[VAL_68:.*]] = %[[VAL_61]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_69:.*]] = fir.do_loop %[[VAL_70:.*]] = %[[VAL_63]] to %[[VAL_64]] step %[[VAL_62]] unordered iter_args(%[[VAL_71:.*]] = %[[VAL_68]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_72:.*]] = fir.array_fetch %[[VAL_7]], %[[VAL_70]], %[[VAL_67]] : (!fir.array<2x3xf32>, index, index) -> f32 ! CHECK: %[[VAL_73:.*]] = fir.array_update %[[VAL_71]], %[[VAL_72]], %[[VAL_70]], %[[VAL_67]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_73]] : !fir.array @@ -398,8 +398,8 @@ subroutine test_from_dyn_shape_array(x, y) ! CHECK: %[[VAL_27:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_28:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_26]] : index ! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_5]]#1, %[[VAL_26]] : index -! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_27]] to %[[VAL_29]] step %[[VAL_26]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_25]]) -> (!fir.array) { -! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_27]] to %[[VAL_28]] step %[[VAL_26]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_32]]) -> (!fir.array) { +! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_27]] to %[[VAL_29]] step %[[VAL_26]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_25]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_27]] to %[[VAL_28]] step %[[VAL_26]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_32]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_36:.*]] = fir.array_fetch %[[VAL_6]], %[[VAL_34]], %[[VAL_31]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_37:.*]] = fir.array_update %[[VAL_35]], %[[VAL_36]], %[[VAL_34]], %[[VAL_31]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_37]] : !fir.array @@ -415,8 +415,8 @@ subroutine test_from_dyn_shape_array(x, y) ! CHECK: %[[VAL_43:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_44:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_42]] : index ! CHECK: %[[VAL_45:.*]] = arith.subi %[[VAL_5]]#1, %[[VAL_42]] : index -! CHECK: %[[VAL_46:.*]] = fir.do_loop %[[VAL_47:.*]] = %[[VAL_43]] to %[[VAL_45]] step %[[VAL_42]] unordered iter_args(%[[VAL_48:.*]] = %[[VAL_41]]) -> (!fir.array) { -! CHECK: %[[VAL_49:.*]] = fir.do_loop %[[VAL_50:.*]] = %[[VAL_43]] to %[[VAL_44]] step %[[VAL_42]] unordered iter_args(%[[VAL_51:.*]] = %[[VAL_48]]) -> (!fir.array) { +! CHECK: %[[VAL_46:.*]] = fir.do_loop %[[VAL_47:.*]] = %[[VAL_43]] to %[[VAL_45]] step %[[VAL_42]] unordered iter_args(%[[VAL_48:.*]] = %[[VAL_41]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_49:.*]] = fir.do_loop %[[VAL_50:.*]] = %[[VAL_43]] to %[[VAL_44]] step %[[VAL_42]] unordered iter_args(%[[VAL_51:.*]] = %[[VAL_48]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_52:.*]] = fir.array_fetch %[[VAL_6]], %[[VAL_50]], %[[VAL_47]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_53:.*]] = fir.array_update %[[VAL_51]], %[[VAL_52]], %[[VAL_50]], %[[VAL_47]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_53]] : !fir.array @@ -436,8 +436,8 @@ subroutine test_from_dyn_shape_array(x, y) ! CHECK: %[[VAL_62:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_63:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_61]] : index ! CHECK: %[[VAL_64:.*]] = arith.subi %[[VAL_5]]#1, %[[VAL_61]] : index -! CHECK: %[[VAL_65:.*]] = fir.do_loop %[[VAL_66:.*]] = %[[VAL_62]] to %[[VAL_64]] step %[[VAL_61]] unordered iter_args(%[[VAL_67:.*]] = %[[VAL_60]]) -> (!fir.array) { -! CHECK: %[[VAL_68:.*]] = fir.do_loop %[[VAL_69:.*]] = %[[VAL_62]] to %[[VAL_63]] step %[[VAL_61]] unordered iter_args(%[[VAL_70:.*]] = %[[VAL_67]]) -> (!fir.array) { +! CHECK: %[[VAL_65:.*]] = fir.do_loop %[[VAL_66:.*]] = %[[VAL_62]] to %[[VAL_64]] step %[[VAL_61]] unordered iter_args(%[[VAL_67:.*]] = %[[VAL_60]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_68:.*]] = fir.do_loop %[[VAL_69:.*]] = %[[VAL_62]] to %[[VAL_63]] step %[[VAL_61]] unordered iter_args(%[[VAL_70:.*]] = %[[VAL_67]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_71:.*]] = fir.array_fetch %[[VAL_6]], %[[VAL_69]], %[[VAL_66]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_72:.*]] = fir.array_update %[[VAL_70]], %[[VAL_71]], %[[VAL_69]], %[[VAL_66]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_72]] : !fir.array @@ -498,8 +498,8 @@ subroutine test_with_lbounds(x, y) ! CHECK: %[[VAL_32:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_33:.*]] = arith.subi %[[VAL_8]]#1, %[[VAL_31]] : index ! CHECK: %[[VAL_34:.*]] = arith.subi %[[VAL_10]]#1, %[[VAL_31]] : index -! CHECK: %[[VAL_35:.*]] = fir.do_loop %[[VAL_36:.*]] = %[[VAL_32]] to %[[VAL_34]] step %[[VAL_31]] unordered iter_args(%[[VAL_37:.*]] = %[[VAL_30]]) -> (!fir.array) { -! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_32]] to %[[VAL_33]] step %[[VAL_31]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_37]]) -> (!fir.array) { +! CHECK: %[[VAL_35:.*]] = fir.do_loop %[[VAL_36:.*]] = %[[VAL_32]] to %[[VAL_34]] step %[[VAL_31]] unordered iter_args(%[[VAL_37:.*]] = %[[VAL_30]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_32]] to %[[VAL_33]] step %[[VAL_31]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_37]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_41:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_39]], %[[VAL_36]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_42:.*]] = fir.array_update %[[VAL_40]], %[[VAL_41]], %[[VAL_39]], %[[VAL_36]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_42]] : !fir.array @@ -515,8 +515,8 @@ subroutine test_with_lbounds(x, y) ! CHECK: %[[VAL_48:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_49:.*]] = arith.subi %[[VAL_8]]#1, %[[VAL_47]] : index ! CHECK: %[[VAL_50:.*]] = arith.subi %[[VAL_10]]#1, %[[VAL_47]] : index -! CHECK: %[[VAL_51:.*]] = fir.do_loop %[[VAL_52:.*]] = %[[VAL_48]] to %[[VAL_50]] step %[[VAL_47]] unordered iter_args(%[[VAL_53:.*]] = %[[VAL_46]]) -> (!fir.array) { -! CHECK: %[[VAL_54:.*]] = fir.do_loop %[[VAL_55:.*]] = %[[VAL_48]] to %[[VAL_49]] step %[[VAL_47]] unordered iter_args(%[[VAL_56:.*]] = %[[VAL_53]]) -> (!fir.array) { +! CHECK: %[[VAL_51:.*]] = fir.do_loop %[[VAL_52:.*]] = %[[VAL_48]] to %[[VAL_50]] step %[[VAL_47]] unordered iter_args(%[[VAL_53:.*]] = %[[VAL_46]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_54:.*]] = fir.do_loop %[[VAL_55:.*]] = %[[VAL_48]] to %[[VAL_49]] step %[[VAL_47]] unordered iter_args(%[[VAL_56:.*]] = %[[VAL_53]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_57:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_55]], %[[VAL_52]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_58:.*]] = fir.array_update %[[VAL_56]], %[[VAL_57]], %[[VAL_55]], %[[VAL_52]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_58]] : !fir.array @@ -536,8 +536,8 @@ subroutine test_with_lbounds(x, y) ! CHECK: %[[VAL_67:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_68:.*]] = arith.subi %[[VAL_8]]#1, %[[VAL_66]] : index ! CHECK: %[[VAL_69:.*]] = arith.subi %[[VAL_10]]#1, %[[VAL_66]] : index -! CHECK: %[[VAL_70:.*]] = fir.do_loop %[[VAL_71:.*]] = %[[VAL_67]] to %[[VAL_69]] step %[[VAL_66]] unordered iter_args(%[[VAL_72:.*]] = %[[VAL_65]]) -> (!fir.array) { -! CHECK: %[[VAL_73:.*]] = fir.do_loop %[[VAL_74:.*]] = %[[VAL_67]] to %[[VAL_68]] step %[[VAL_66]] unordered iter_args(%[[VAL_75:.*]] = %[[VAL_72]]) -> (!fir.array) { +! CHECK: %[[VAL_70:.*]] = fir.do_loop %[[VAL_71:.*]] = %[[VAL_67]] to %[[VAL_69]] step %[[VAL_66]] unordered iter_args(%[[VAL_72:.*]] = %[[VAL_65]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_73:.*]] = fir.do_loop %[[VAL_74:.*]] = %[[VAL_67]] to %[[VAL_68]] step %[[VAL_66]] unordered iter_args(%[[VAL_75:.*]] = %[[VAL_72]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_76:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_74]], %[[VAL_71]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_77:.*]] = fir.array_update %[[VAL_75]], %[[VAL_76]], %[[VAL_74]], %[[VAL_71]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_77]] : !fir.array @@ -606,8 +606,8 @@ function return_pointer() ! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_10]]#1, %[[VAL_33]] : index ! CHECK: %[[VAL_36:.*]] = arith.subi %[[VAL_12]]#1, %[[VAL_33]] : index -! CHECK: %[[VAL_37:.*]] = fir.do_loop %[[VAL_38:.*]] = %[[VAL_34]] to %[[VAL_36]] step %[[VAL_33]] unordered iter_args(%[[VAL_39:.*]] = %[[VAL_32]]) -> (!fir.array) { -! CHECK: %[[VAL_40:.*]] = fir.do_loop %[[VAL_41:.*]] = %[[VAL_34]] to %[[VAL_35]] step %[[VAL_33]] unordered iter_args(%[[VAL_42:.*]] = %[[VAL_39]]) -> (!fir.array) { +! CHECK: %[[VAL_37:.*]] = fir.do_loop %[[VAL_38:.*]] = %[[VAL_34]] to %[[VAL_36]] step %[[VAL_33]] unordered iter_args(%[[VAL_39:.*]] = %[[VAL_32]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_40:.*]] = fir.do_loop %[[VAL_41:.*]] = %[[VAL_34]] to %[[VAL_35]] step %[[VAL_33]] unordered iter_args(%[[VAL_42:.*]] = %[[VAL_39]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_43:.*]] = fir.array_fetch %[[VAL_13]], %[[VAL_41]], %[[VAL_38]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_44:.*]] = fir.array_update %[[VAL_42]], %[[VAL_43]], %[[VAL_41]], %[[VAL_38]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_44]] : !fir.array @@ -623,8 +623,8 @@ function return_pointer() ! CHECK: %[[VAL_50:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_51:.*]] = arith.subi %[[VAL_10]]#1, %[[VAL_49]] : index ! CHECK: %[[VAL_52:.*]] = arith.subi %[[VAL_12]]#1, %[[VAL_49]] : index -! CHECK: %[[VAL_53:.*]] = fir.do_loop %[[VAL_54:.*]] = %[[VAL_50]] to %[[VAL_52]] step %[[VAL_49]] unordered iter_args(%[[VAL_55:.*]] = %[[VAL_48]]) -> (!fir.array) { -! CHECK: %[[VAL_56:.*]] = fir.do_loop %[[VAL_57:.*]] = %[[VAL_50]] to %[[VAL_51]] step %[[VAL_49]] unordered iter_args(%[[VAL_58:.*]] = %[[VAL_55]]) -> (!fir.array) { +! CHECK: %[[VAL_53:.*]] = fir.do_loop %[[VAL_54:.*]] = %[[VAL_50]] to %[[VAL_52]] step %[[VAL_49]] unordered iter_args(%[[VAL_55:.*]] = %[[VAL_48]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_56:.*]] = fir.do_loop %[[VAL_57:.*]] = %[[VAL_50]] to %[[VAL_51]] step %[[VAL_49]] unordered iter_args(%[[VAL_58:.*]] = %[[VAL_55]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_59:.*]] = fir.array_fetch %[[VAL_13]], %[[VAL_57]], %[[VAL_54]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_60:.*]] = fir.array_update %[[VAL_58]], %[[VAL_59]], %[[VAL_57]], %[[VAL_54]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_60]] : !fir.array @@ -644,8 +644,8 @@ function return_pointer() ! CHECK: %[[VAL_69:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_70:.*]] = arith.subi %[[VAL_10]]#1, %[[VAL_68]] : index ! CHECK: %[[VAL_71:.*]] = arith.subi %[[VAL_12]]#1, %[[VAL_68]] : index -! CHECK: %[[VAL_72:.*]] = fir.do_loop %[[VAL_73:.*]] = %[[VAL_69]] to %[[VAL_71]] step %[[VAL_68]] unordered iter_args(%[[VAL_74:.*]] = %[[VAL_67]]) -> (!fir.array) { -! CHECK: %[[VAL_75:.*]] = fir.do_loop %[[VAL_76:.*]] = %[[VAL_69]] to %[[VAL_70]] step %[[VAL_68]] unordered iter_args(%[[VAL_77:.*]] = %[[VAL_74]]) -> (!fir.array) { +! CHECK: %[[VAL_72:.*]] = fir.do_loop %[[VAL_73:.*]] = %[[VAL_69]] to %[[VAL_71]] step %[[VAL_68]] unordered iter_args(%[[VAL_74:.*]] = %[[VAL_67]]) -> (!fir.array) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_75:.*]] = fir.do_loop %[[VAL_76:.*]] = %[[VAL_69]] to %[[VAL_70]] step %[[VAL_68]] unordered iter_args(%[[VAL_77:.*]] = %[[VAL_74]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_78:.*]] = fir.array_fetch %[[VAL_13]], %[[VAL_76]], %[[VAL_73]] : (!fir.array, index, index) -> f32 ! CHECK: %[[VAL_79:.*]] = fir.array_update %[[VAL_77]], %[[VAL_78]], %[[VAL_76]], %[[VAL_73]] : (!fir.array, f32, index, index) -> !fir.array ! CHECK: fir.result %[[VAL_79]] : !fir.array @@ -760,7 +760,7 @@ subroutine test_cst_char(x, c) ! CHECK: %[[VAL_24:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_25:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_6]], %[[VAL_24]] : index -! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_28:.*]] = %[[VAL_25]] to %[[VAL_26]] step %[[VAL_24]] unordered iter_args(%[[VAL_29:.*]] = %[[VAL_23]]) -> (!fir.array>) { +! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_28:.*]] = %[[VAL_25]] to %[[VAL_26]] step %[[VAL_24]] unordered iter_args(%[[VAL_29:.*]] = %[[VAL_23]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_30:.*]] = fir.array_access %[[VAL_8]], %[[VAL_28]] : (!fir.array<20x!fir.char<1,12>>, index) -> !fir.ref> ! CHECK: %[[VAL_31:.*]] = fir.array_access %[[VAL_29]], %[[VAL_28]] : (!fir.array>, index) -> !fir.ref> ! CHECK: %[[VAL_32:.*]] = arith.constant 10 : index @@ -779,7 +779,7 @@ subroutine test_cst_char(x, c) ! CHECK: %[[VAL_44:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_45:.*]] = fir.insert_value %[[VAL_44]], %[[VAL_43]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_46:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_47:.*]] = %[[VAL_34]] to %[[VAL_42]] step %[[VAL_46]] { +! CHECK: fir.do_loop %[[VAL_47:.*]] = %[[VAL_34]] to %[[VAL_42]] step %[[VAL_46]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_31]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_49:.*]] = fir.coordinate_of %[[VAL_48]], %[[VAL_47]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_45]] to %[[VAL_49]] : !fir.ref> @@ -795,7 +795,7 @@ subroutine test_cst_char(x, c) ! CHECK: %[[VAL_54:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_55:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_56:.*]] = arith.subi %[[VAL_6]], %[[VAL_54]] : index -! CHECK: %[[VAL_57:.*]] = fir.do_loop %[[VAL_58:.*]] = %[[VAL_55]] to %[[VAL_56]] step %[[VAL_54]] unordered iter_args(%[[VAL_59:.*]] = %[[VAL_53]]) -> (!fir.array>) { +! CHECK: %[[VAL_57:.*]] = fir.do_loop %[[VAL_58:.*]] = %[[VAL_55]] to %[[VAL_56]] step %[[VAL_54]] unordered iter_args(%[[VAL_59:.*]] = %[[VAL_53]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_60:.*]] = fir.array_access %[[VAL_8]], %[[VAL_58]] : (!fir.array<20x!fir.char<1,12>>, index) -> !fir.ref> ! CHECK: %[[VAL_61:.*]] = fir.array_access %[[VAL_59]], %[[VAL_58]] : (!fir.array>, index) -> !fir.ref> ! CHECK: %[[VAL_62:.*]] = arith.constant 10 : index @@ -814,7 +814,7 @@ subroutine test_cst_char(x, c) ! CHECK: %[[VAL_74:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_75:.*]] = fir.insert_value %[[VAL_74]], %[[VAL_73]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_76:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_77:.*]] = %[[VAL_64]] to %[[VAL_72]] step %[[VAL_76]] { +! CHECK: fir.do_loop %[[VAL_77:.*]] = %[[VAL_64]] to %[[VAL_72]] step %[[VAL_76]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_78:.*]] = fir.convert %[[VAL_61]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_79:.*]] = fir.coordinate_of %[[VAL_78]], %[[VAL_77]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_75]] to %[[VAL_79]] : !fir.ref> @@ -834,7 +834,7 @@ subroutine test_cst_char(x, c) ! CHECK: %[[VAL_87:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_88:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_89:.*]] = arith.subi %[[VAL_6]], %[[VAL_87]] : index -! CHECK: %[[VAL_90:.*]] = fir.do_loop %[[VAL_91:.*]] = %[[VAL_88]] to %[[VAL_89]] step %[[VAL_87]] unordered iter_args(%[[VAL_92:.*]] = %[[VAL_86]]) -> (!fir.array>) { +! CHECK: %[[VAL_90:.*]] = fir.do_loop %[[VAL_91:.*]] = %[[VAL_88]] to %[[VAL_89]] step %[[VAL_87]] unordered iter_args(%[[VAL_92:.*]] = %[[VAL_86]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_93:.*]] = fir.array_access %[[VAL_8]], %[[VAL_91]] : (!fir.array<20x!fir.char<1,12>>, index) -> !fir.ref> ! CHECK: %[[VAL_94:.*]] = fir.array_access %[[VAL_92]], %[[VAL_91]] : (!fir.array>, index) -> !fir.ref> ! CHECK: %[[VAL_95:.*]] = arith.constant 10 : index @@ -853,7 +853,7 @@ subroutine test_cst_char(x, c) ! CHECK: %[[VAL_107:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_108:.*]] = fir.insert_value %[[VAL_107]], %[[VAL_106]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_109:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_110:.*]] = %[[VAL_97]] to %[[VAL_105]] step %[[VAL_109]] { +! CHECK: fir.do_loop %[[VAL_110:.*]] = %[[VAL_97]] to %[[VAL_105]] step %[[VAL_109]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_111:.*]] = fir.convert %[[VAL_94]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_112:.*]] = fir.coordinate_of %[[VAL_111]], %[[VAL_110]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_108]] to %[[VAL_112]] : !fir.ref> @@ -912,7 +912,7 @@ subroutine test_dyn_char(x, n, c) ! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_30:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_31:.*]] = arith.subi %[[VAL_10]], %[[VAL_29]] : index -! CHECK: %[[VAL_32:.*]] = fir.do_loop %[[VAL_33:.*]] = %[[VAL_30]] to %[[VAL_31]] step %[[VAL_29]] unordered iter_args(%[[VAL_34:.*]] = %[[VAL_28]]) -> (!fir.array>) { +! CHECK: %[[VAL_32:.*]] = fir.do_loop %[[VAL_33:.*]] = %[[VAL_30]] to %[[VAL_31]] step %[[VAL_29]] unordered iter_args(%[[VAL_34:.*]] = %[[VAL_28]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_35:.*]] = fir.array_access %[[VAL_12]], %[[VAL_33]] typeparams %[[VAL_3]]#1 : (!fir.array<20x!fir.char<1,?>>, index, index) -> !fir.ref> ! CHECK: %[[VAL_36:.*]] = fir.array_access %[[VAL_34]], %[[VAL_33]] typeparams %[[VAL_9]] : (!fir.array>, index, i32) -> !fir.ref> ! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_9]] : (i32) -> index @@ -932,7 +932,7 @@ subroutine test_dyn_char(x, n, c) ! CHECK: %[[VAL_50:.*]] = fir.insert_value %[[VAL_49]], %[[VAL_48]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_51:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_47]] : (i32) -> index -! CHECK: fir.do_loop %[[VAL_53:.*]] = %[[VAL_39]] to %[[VAL_52]] step %[[VAL_51]] { +! CHECK: fir.do_loop %[[VAL_53:.*]] = %[[VAL_39]] to %[[VAL_52]] step %[[VAL_51]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_36]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_55:.*]] = fir.coordinate_of %[[VAL_54]], %[[VAL_53]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_50]] to %[[VAL_55]] : !fir.ref> @@ -948,7 +948,7 @@ subroutine test_dyn_char(x, n, c) ! CHECK: %[[VAL_60:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_61:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_62:.*]] = arith.subi %[[VAL_10]], %[[VAL_60]] : index -! CHECK: %[[VAL_63:.*]] = fir.do_loop %[[VAL_64:.*]] = %[[VAL_61]] to %[[VAL_62]] step %[[VAL_60]] unordered iter_args(%[[VAL_65:.*]] = %[[VAL_59]]) -> (!fir.array>) { +! CHECK: %[[VAL_63:.*]] = fir.do_loop %[[VAL_64:.*]] = %[[VAL_61]] to %[[VAL_62]] step %[[VAL_60]] unordered iter_args(%[[VAL_65:.*]] = %[[VAL_59]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_66:.*]] = fir.array_access %[[VAL_12]], %[[VAL_64]] typeparams %[[VAL_3]]#1 : (!fir.array<20x!fir.char<1,?>>, index, index) -> !fir.ref> ! CHECK: %[[VAL_67:.*]] = fir.array_access %[[VAL_65]], %[[VAL_64]] typeparams %[[VAL_9]] : (!fir.array>, index, i32) -> !fir.ref> ! CHECK: %[[VAL_68:.*]] = fir.convert %[[VAL_9]] : (i32) -> index @@ -968,7 +968,7 @@ subroutine test_dyn_char(x, n, c) ! CHECK: %[[VAL_81:.*]] = fir.insert_value %[[VAL_80]], %[[VAL_79]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_82:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_83:.*]] = fir.convert %[[VAL_78]] : (i32) -> index -! CHECK: fir.do_loop %[[VAL_84:.*]] = %[[VAL_70]] to %[[VAL_83]] step %[[VAL_82]] { +! CHECK: fir.do_loop %[[VAL_84:.*]] = %[[VAL_70]] to %[[VAL_83]] step %[[VAL_82]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_85:.*]] = fir.convert %[[VAL_67]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_86:.*]] = fir.coordinate_of %[[VAL_85]], %[[VAL_84]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_81]] to %[[VAL_86]] : !fir.ref> @@ -989,7 +989,7 @@ subroutine test_dyn_char(x, n, c) ! CHECK: %[[VAL_95:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_96:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_97:.*]] = arith.subi %[[VAL_10]], %[[VAL_95]] : index -! CHECK: %[[VAL_98:.*]] = fir.do_loop %[[VAL_99:.*]] = %[[VAL_96]] to %[[VAL_97]] step %[[VAL_95]] unordered iter_args(%[[VAL_100:.*]] = %[[VAL_94]]) -> (!fir.array>) { +! CHECK: %[[VAL_98:.*]] = fir.do_loop %[[VAL_99:.*]] = %[[VAL_96]] to %[[VAL_97]] step %[[VAL_95]] unordered iter_args(%[[VAL_100:.*]] = %[[VAL_94]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_101:.*]] = fir.array_access %[[VAL_12]], %[[VAL_99]] typeparams %[[VAL_3]]#1 : (!fir.array<20x!fir.char<1,?>>, index, index) -> !fir.ref> ! CHECK: %[[VAL_102:.*]] = fir.array_access %[[VAL_100]], %[[VAL_99]] typeparams %[[VAL_9]] : (!fir.array>, index, i32) -> !fir.ref> ! CHECK: %[[VAL_103:.*]] = fir.convert %[[VAL_9]] : (i32) -> index @@ -1009,7 +1009,7 @@ subroutine test_dyn_char(x, n, c) ! CHECK: %[[VAL_116:.*]] = fir.insert_value %[[VAL_115]], %[[VAL_114]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_117:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_118:.*]] = fir.convert %[[VAL_113]] : (i32) -> index -! CHECK: fir.do_loop %[[VAL_119:.*]] = %[[VAL_105]] to %[[VAL_118]] step %[[VAL_117]] { +! CHECK: fir.do_loop %[[VAL_119:.*]] = %[[VAL_105]] to %[[VAL_118]] step %[[VAL_117]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_120:.*]] = fir.convert %[[VAL_102]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_121:.*]] = fir.coordinate_of %[[VAL_120]], %[[VAL_119]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_116]] to %[[VAL_121]] : !fir.ref> @@ -1094,7 +1094,7 @@ subroutine test_vector_subscript(x, y, v) ! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_10]], %[[VAL_27]] : index -! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_26]]) -> (!fir.array) { +! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_26]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_33:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_31]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i32) -> index ! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_34]], %[[VAL_3]] : index @@ -1110,7 +1110,7 @@ subroutine test_vector_subscript(x, y, v) ! CHECK: %[[VAL_41:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_42:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_10]], %[[VAL_41]] : index -! CHECK: %[[VAL_44:.*]] = fir.do_loop %[[VAL_45:.*]] = %[[VAL_42]] to %[[VAL_43]] step %[[VAL_41]] unordered iter_args(%[[VAL_46:.*]] = %[[VAL_40]]) -> (!fir.array) { +! CHECK: %[[VAL_44:.*]] = fir.do_loop %[[VAL_45:.*]] = %[[VAL_42]] to %[[VAL_43]] step %[[VAL_41]] unordered iter_args(%[[VAL_46:.*]] = %[[VAL_40]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_47:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_45]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_47]] : (i32) -> index ! CHECK: %[[VAL_49:.*]] = arith.subi %[[VAL_48]], %[[VAL_3]] : index @@ -1130,7 +1130,7 @@ subroutine test_vector_subscript(x, y, v) ! CHECK: %[[VAL_58:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_59:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_60:.*]] = arith.subi %[[VAL_10]], %[[VAL_58]] : index -! CHECK: %[[VAL_61:.*]] = fir.do_loop %[[VAL_62:.*]] = %[[VAL_59]] to %[[VAL_60]] step %[[VAL_58]] unordered iter_args(%[[VAL_63:.*]] = %[[VAL_57]]) -> (!fir.array) { +! CHECK: %[[VAL_61:.*]] = fir.do_loop %[[VAL_62:.*]] = %[[VAL_59]] to %[[VAL_60]] step %[[VAL_58]] unordered iter_args(%[[VAL_63:.*]] = %[[VAL_57]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_64:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_62]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_65:.*]] = fir.convert %[[VAL_64]] : (i32) -> index ! CHECK: %[[VAL_66:.*]] = arith.subi %[[VAL_65]], %[[VAL_3]] : index @@ -1186,7 +1186,7 @@ end function elt ! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_22:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_21]] : index -! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_20]]) -> (!fir.array) { +! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_20]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_27:.*]] = arith.addi %[[VAL_25]], %[[VAL_3]]#0 : index ! CHECK: %[[VAL_28:.*]] = fir.array_coor %[[VAL_4]](%[[VAL_5]]) %[[VAL_27]] : (!fir.heap>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_29:.*]] = fir.call @_QPelt(%[[VAL_28]]) {{.*}}: (!fir.ref) -> f32 @@ -1201,7 +1201,7 @@ end function elt ! CHECK: %[[VAL_34:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_35:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_36:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_34]] : index -! CHECK: %[[VAL_37:.*]] = fir.do_loop %[[VAL_38:.*]] = %[[VAL_35]] to %[[VAL_36]] step %[[VAL_34]] unordered iter_args(%[[VAL_39:.*]] = %[[VAL_33]]) -> (!fir.array) { +! CHECK: %[[VAL_37:.*]] = fir.do_loop %[[VAL_38:.*]] = %[[VAL_35]] to %[[VAL_36]] step %[[VAL_34]] unordered iter_args(%[[VAL_39:.*]] = %[[VAL_33]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_40:.*]] = arith.addi %[[VAL_38]], %[[VAL_3]]#0 : index ! CHECK: %[[VAL_41:.*]] = fir.array_coor %[[VAL_4]](%[[VAL_5]]) %[[VAL_40]] : (!fir.heap>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_42:.*]] = fir.call @_QPelt(%[[VAL_41]]) {{.*}}: (!fir.ref) -> f32 @@ -1220,7 +1220,7 @@ end function elt ! CHECK: %[[VAL_50:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_51:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_52:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_50]] : index -! CHECK: %[[VAL_53:.*]] = fir.do_loop %[[VAL_54:.*]] = %[[VAL_51]] to %[[VAL_52]] step %[[VAL_50]] unordered iter_args(%[[VAL_55:.*]] = %[[VAL_49]]) -> (!fir.array) { +! CHECK: %[[VAL_53:.*]] = fir.do_loop %[[VAL_54:.*]] = %[[VAL_51]] to %[[VAL_52]] step %[[VAL_50]] unordered iter_args(%[[VAL_55:.*]] = %[[VAL_49]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_56:.*]] = arith.addi %[[VAL_54]], %[[VAL_3]]#0 : index ! CHECK: %[[VAL_57:.*]] = fir.array_coor %[[VAL_4]](%[[VAL_5]]) %[[VAL_56]] : (!fir.heap>, !fir.shapeshift<1>, index) -> !fir.ref ! CHECK: %[[VAL_58:.*]] = fir.call @_QPelt(%[[VAL_57]]) {{.*}}: (!fir.ref) -> f32 diff --git a/flang/test/Lower/allocate-source-allocatables.f90 b/flang/test/Lower/allocate-source-allocatables.f90 index f09612c3197da..c70e5f7e0dcaa 100644 --- a/flang/test/Lower/allocate-source-allocatables.f90 +++ b/flang/test/Lower/allocate-source-allocatables.f90 @@ -195,7 +195,7 @@ subroutine test_allocatable_with_shapespec(n, a, m) ! CHECK: %[[VAL_19:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_20:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_21:.*]] = arith.subi %[[VAL_11]], %[[VAL_19]] : index -! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_23:.*]] = %[[VAL_20]] to %[[VAL_21]] step %[[VAL_19]] unordered iter_args(%[[VAL_24:.*]] = %[[VAL_18]]) -> (!fir.array<5xi32>) { +! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_23:.*]] = %[[VAL_20]] to %[[VAL_21]] step %[[VAL_19]] unordered iter_args(%[[VAL_24:.*]] = %[[VAL_18]]) -> (!fir.array<5xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_25:.*]] = fir.array_fetch %[[VAL_15]], %[[VAL_23]] : (!fir.array<5xi32>, index) -> i32 ! CHECK: %[[VAL_26:.*]] = fir.array_update %[[VAL_24]], %[[VAL_25]], %[[VAL_23]] : (!fir.array<5xi32>, i32, index) -> !fir.array<5xi32> ! CHECK: fir.result %[[VAL_26]] : !fir.array<5xi32> diff --git a/flang/test/Lower/allocate-source-pointers.f90 b/flang/test/Lower/allocate-source-pointers.f90 index 1beb420c53191..7988168f5abd2 100644 --- a/flang/test/Lower/allocate-source-pointers.f90 +++ b/flang/test/Lower/allocate-source-pointers.f90 @@ -181,7 +181,7 @@ subroutine test_pointer_with_shapespec(n, a, m) ! CHECK: %[[VAL_19:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_20:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_21:.*]] = arith.subi %[[VAL_11]], %[[VAL_19]] : index -! CHECK: %[[VAL_22:.*]] = fir.do_loop %[[VAL_23:.*]] = %[[VAL_20]] to %[[VAL_21]] step %[[VAL_19]] unordered iter_args(%[[VAL_24:.*]] = %[[VAL_18]]) -> (!fir.array<5xi32>) { +! CHECK: %[[VAL_22:.*]] = fir.do_loop %[[VAL_23:.*]] = %[[VAL_20]] to %[[VAL_21]] step %[[VAL_19]] unordered iter_args(%[[VAL_24:.*]] = %[[VAL_18]]) -> (!fir.array<5xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_25:.*]] = fir.array_fetch %[[VAL_15]], %[[VAL_23]] : (!fir.array<5xi32>, index) -> i32 ! CHECK: %[[VAL_26:.*]] = fir.array_update %[[VAL_24]], %[[VAL_25]], %[[VAL_23]] : (!fir.array<5xi32>, i32, index) -> !fir.array<5xi32> ! CHECK: fir.result %[[VAL_26]] : !fir.array<5xi32> diff --git a/flang/test/Lower/array-constructor-index.f90 b/flang/test/Lower/array-constructor-index.f90 index a8d330aea63dc..295140838a8a2 100644 --- a/flang/test/Lower/array-constructor-index.f90 +++ b/flang/test/Lower/array-constructor-index.f90 @@ -25,7 +25,7 @@ end function test1 ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i64) -> index ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i64) -> index -! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_15]] iter_args(%[[VAL_18:.*]] = %[[VAL_8]]) -> (!fir.heap>) { +! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_15]] iter_args(%[[VAL_18:.*]] = %[[VAL_8]]) -> (!fir.heap>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_17]] : (index) -> i64 ! CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_0]] : !fir.ref ! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i8) -> i64 @@ -63,7 +63,7 @@ end function test1 ! CHECK: %[[VAL_46:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_47:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_48:.*]] = arith.subi %[[VAL_3]], %[[VAL_46]] : index -! CHECK: %[[VAL_49:.*]] = fir.do_loop %[[VAL_50:.*]] = %[[VAL_47]] to %[[VAL_48]] step %[[VAL_46]] unordered iter_args(%[[VAL_51:.*]] = %[[VAL_6]]) -> (!fir.array<4xi8>) { +! CHECK: %[[VAL_49:.*]] = fir.do_loop %[[VAL_50:.*]] = %[[VAL_47]] to %[[VAL_48]] step %[[VAL_46]] unordered iter_args(%[[VAL_51:.*]] = %[[VAL_6]]) -> (!fir.array<4xi8>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_52:.*]] = fir.array_fetch %[[VAL_44]], %[[VAL_50]] : (!fir.array<4xi64>, index) -> i64 ! CHECK: %[[VAL_53:.*]] = fir.no_reassoc %[[VAL_52]] : i64 ! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_53]] : (i64) -> i8 @@ -100,7 +100,7 @@ end function test2 ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i64) -> index ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i64) -> index -! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_15]] iter_args(%[[VAL_18:.*]] = %[[VAL_8]]) -> (!fir.heap>) { +! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_15]] iter_args(%[[VAL_18:.*]] = %[[VAL_8]]) -> (!fir.heap>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_17]] : (index) -> i64 ! CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_0]] : !fir.ref ! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i16) -> i64 @@ -138,7 +138,7 @@ end function test2 ! CHECK: %[[VAL_46:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_47:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_48:.*]] = arith.subi %[[VAL_3]], %[[VAL_46]] : index -! CHECK: %[[VAL_49:.*]] = fir.do_loop %[[VAL_50:.*]] = %[[VAL_47]] to %[[VAL_48]] step %[[VAL_46]] unordered iter_args(%[[VAL_51:.*]] = %[[VAL_6]]) -> (!fir.array<4xi16>) { +! CHECK: %[[VAL_49:.*]] = fir.do_loop %[[VAL_50:.*]] = %[[VAL_47]] to %[[VAL_48]] step %[[VAL_46]] unordered iter_args(%[[VAL_51:.*]] = %[[VAL_6]]) -> (!fir.array<4xi16>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_52:.*]] = fir.array_fetch %[[VAL_44]], %[[VAL_50]] : (!fir.array<4xi64>, index) -> i64 ! CHECK: %[[VAL_53:.*]] = fir.no_reassoc %[[VAL_52]] : i64 ! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_53]] : (i64) -> i16 @@ -175,7 +175,7 @@ end function test3 ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i64) -> index ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i64) -> index -! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_15]] iter_args(%[[VAL_18:.*]] = %[[VAL_8]]) -> (!fir.heap>) { +! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_15]] iter_args(%[[VAL_18:.*]] = %[[VAL_8]]) -> (!fir.heap>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_17]] : (index) -> i64 ! CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_0]] : !fir.ref ! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> i64 @@ -213,7 +213,7 @@ end function test3 ! CHECK: %[[VAL_46:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_47:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_48:.*]] = arith.subi %[[VAL_3]], %[[VAL_46]] : index -! CHECK: %[[VAL_49:.*]] = fir.do_loop %[[VAL_50:.*]] = %[[VAL_47]] to %[[VAL_48]] step %[[VAL_46]] unordered iter_args(%[[VAL_51:.*]] = %[[VAL_6]]) -> (!fir.array<4xi32>) { +! CHECK: %[[VAL_49:.*]] = fir.do_loop %[[VAL_50:.*]] = %[[VAL_47]] to %[[VAL_48]] step %[[VAL_46]] unordered iter_args(%[[VAL_51:.*]] = %[[VAL_6]]) -> (!fir.array<4xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_52:.*]] = fir.array_fetch %[[VAL_44]], %[[VAL_50]] : (!fir.array<4xi64>, index) -> i64 ! CHECK: %[[VAL_53:.*]] = fir.no_reassoc %[[VAL_52]] : i64 ! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_53]] : (i64) -> i32 @@ -250,7 +250,7 @@ end function test4 ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i64) -> index ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : i64 ! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i64) -> index -! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_15]] iter_args(%[[VAL_18:.*]] = %[[VAL_8]]) -> (!fir.heap>) { +! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_15]] iter_args(%[[VAL_18:.*]] = %[[VAL_8]]) -> (!fir.heap>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_17]] : (index) -> i64 ! CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_0]] : !fir.ref ! CHECK: %[[VAL_21:.*]] = arith.muli %[[VAL_19]], %[[VAL_20]] : i64 @@ -287,7 +287,7 @@ end function test4 ! CHECK: %[[VAL_45:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_46:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_47:.*]] = arith.subi %[[VAL_3]], %[[VAL_45]] : index -! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %[[VAL_46]] to %[[VAL_47]] step %[[VAL_45]] unordered iter_args(%[[VAL_50:.*]] = %[[VAL_6]]) -> (!fir.array<4xi64>) { +! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %[[VAL_46]] to %[[VAL_47]] step %[[VAL_45]] unordered iter_args(%[[VAL_50:.*]] = %[[VAL_6]]) -> (!fir.array<4xi64>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_51:.*]] = fir.array_fetch %[[VAL_43]], %[[VAL_49]] : (!fir.array<4xi64>, index) -> i64 ! CHECK: %[[VAL_52:.*]] = fir.no_reassoc %[[VAL_51]] : i64 ! CHECK: %[[VAL_53:.*]] = fir.array_update %[[VAL_50]], %[[VAL_52]], %[[VAL_49]] : (!fir.array<4xi64>, i64, index) -> !fir.array<4xi64> diff --git a/flang/test/Lower/array-elemental-calls.f90 b/flang/test/Lower/array-elemental-calls.f90 index 853807bcb3e6c..d3241f8c29393 100644 --- a/flang/test/Lower/array-elemental-calls.f90 +++ b/flang/test/Lower/array-elemental-calls.f90 @@ -71,7 +71,7 @@ elemental impure integer function impure_func(j) ! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_7:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_8:.*]] = arith.subi %[[VAL_3]]#1, %[[VAL_6]] : index -! CHECK: %[[VAL_9:.*]] = fir.do_loop %[[VAL_10:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_6]] unordered iter_args(%[[VAL_11:.*]] = %[[VAL_4]]) -> (!fir.array) { +! CHECK: %[[VAL_9:.*]] = fir.do_loop %[[VAL_10:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_6]] unordered iter_args(%[[VAL_11:.*]] = %[[VAL_4]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_13:.*]] = arith.addi %[[VAL_10]], %[[VAL_12]] : index ! CHECK: %[[VAL_14:.*]] = fir.array_coor %[[VAL_1]] %[[VAL_13]] : (!fir.box>, index) -> !fir.ref @@ -88,7 +88,7 @@ elemental impure integer function impure_func(j) ! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_24:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_20]]#1, %[[VAL_23]] : index -! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] iter_args(%[[VAL_28:.*]] = %[[VAL_21]]) -> (!fir.array) { +! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] iter_args(%[[VAL_28:.*]] = %[[VAL_21]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_27]], %[[VAL_29]] : index ! CHECK: %[[VAL_31:.*]] = fir.array_coor %[[VAL_1]] %[[VAL_30]] : (!fir.box>, index) -> !fir.ref diff --git a/flang/test/Lower/array-elemental-subroutines.f90 b/flang/test/Lower/array-elemental-subroutines.f90 index 84be5cb792f01..58fa9ed24f58d 100644 --- a/flang/test/Lower/array-elemental-subroutines.f90 +++ b/flang/test/Lower/array-elemental-subroutines.f90 @@ -16,7 +16,7 @@ ! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_17:.*]] = arith.subi %[[VAL_6]]#1, %[[VAL_15]] : index -! CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] { +! CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_18]], %[[VAL_19]] : index ! CHECK: %[[VAL_21:.*]] = fir.array_coor %[[VAL_0]] %[[VAL_20]] : (!fir.box>, index) -> !fir.ref diff --git a/flang/test/Lower/array-expression-assumed-size.f90 b/flang/test/Lower/array-expression-assumed-size.f90 index ae35da951538b..c3442e8dda0cb 100644 --- a/flang/test/Lower/array-expression-assumed-size.f90 +++ b/flang/test/Lower/array-expression-assumed-size.f90 @@ -64,8 +64,8 @@ end subroutine assumed_size_forall_test ! CHECK: %[[VAL_44:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_45:.*]] = arith.subi %[[VAL_13]], %[[VAL_43]] : index ! CHECK: %[[VAL_46:.*]] = arith.subi %[[VAL_25]], %[[VAL_43]] : index -! CHECK: %[[VAL_47:.*]] = fir.do_loop %[[VAL_48:.*]] = %[[VAL_44]] to %[[VAL_46]] step %[[VAL_43]] unordered iter_args(%[[VAL_49:.*]] = %[[VAL_28]]) -> (!fir.array<10x?xi32>) { -! CHECK: %[[VAL_50:.*]] = fir.do_loop %[[VAL_51:.*]] = %[[VAL_44]] to %[[VAL_45]] step %[[VAL_43]] unordered iter_args(%[[VAL_52:.*]] = %[[VAL_49]]) -> (!fir.array<10x?xi32>) { +! CHECK: %[[VAL_47:.*]] = fir.do_loop %[[VAL_48:.*]] = %[[VAL_44]] to %[[VAL_46]] step %[[VAL_43]] unordered iter_args(%[[VAL_49:.*]] = %[[VAL_28]]) -> (!fir.array<10x?xi32>) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_50:.*]] = fir.do_loop %[[VAL_51:.*]] = %[[VAL_44]] to %[[VAL_45]] step %[[VAL_43]] unordered iter_args(%[[VAL_52:.*]] = %[[VAL_49]]) -> (!fir.array<10x?xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_53:.*]] = fir.array_fetch %[[VAL_42]], %[[VAL_51]], %[[VAL_48]] : (!fir.array<10x?xi32>, index, index) -> i32 ! CHECK: %[[VAL_54:.*]] = fir.array_update %[[VAL_52]], %[[VAL_53]], %[[VAL_51]], %[[VAL_48]] : (!fir.array<10x?xi32>, i32, index, index) -> !fir.array<10x?xi32> ! CHECK: fir.result %[[VAL_54]] : !fir.array<10x?xi32> @@ -92,7 +92,7 @@ end subroutine assumed_size_forall_test ! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_0]](%[[VAL_9]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<10x?xi32> ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_2]], %[[VAL_3]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]](%[[VAL_11]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<10x?xi32> -! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_10]]) -> (!fir.array<10x?xi32>) { +! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_10]]) -> (!fir.array<10x?xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32 ! CHECK: fir.store %[[VAL_16]] to %[[VAL_1]] : !fir.ref ! CHECK: %[[VAL_17:.*]] = arith.constant 1 : index @@ -124,7 +124,7 @@ end subroutine assumed_size_forall_test ! CHECK: %[[VAL_43:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_44:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_45:.*]] = arith.subi %[[VAL_33]], %[[VAL_43]] : index -! CHECK: %[[VAL_46:.*]] = fir.do_loop %[[VAL_47:.*]] = %[[VAL_44]] to %[[VAL_45]] step %[[VAL_43]] unordered iter_args(%[[VAL_48:.*]] = %[[VAL_15]]) -> (!fir.array<10x?xi32>) { +! CHECK: %[[VAL_46:.*]] = fir.do_loop %[[VAL_47:.*]] = %[[VAL_44]] to %[[VAL_45]] step %[[VAL_43]] unordered iter_args(%[[VAL_48:.*]] = %[[VAL_15]]) -> (!fir.array<10x?xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_49:.*]] = arith.subi %[[VAL_40]], %[[VAL_34]] : index ! CHECK: %[[VAL_50:.*]] = arith.muli %[[VAL_47]], %[[VAL_42]] : index ! CHECK: %[[VAL_51:.*]] = arith.addi %[[VAL_49]], %[[VAL_50]] : index diff --git a/flang/test/Lower/array-expression-subscript.f90 b/flang/test/Lower/array-expression-subscript.f90 index 60180b5e305df..8d262d3044139 100644 --- a/flang/test/Lower/array-expression-subscript.f90 +++ b/flang/test/Lower/array-expression-subscript.f90 @@ -30,7 +30,7 @@ ! CHECK: %[[VAL_35:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_36:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_37:.*]] = arith.subi %[[VAL_25]], %[[VAL_35]] : index -! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_35]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_7]]) -> (!fir.array<10xi32>) { +! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_35]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_7]]) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_41:.*]] = fir.array_fetch %[[VAL_23]], %[[VAL_39]] : (!fir.array<20xi32>, index) -> i32 ! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (i32) -> index ! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_42]], %[[VAL_8]] : index @@ -78,7 +78,7 @@ end subroutine test1a ! CHECK: %[[VAL_35:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_36:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_37:.*]] = arith.subi %[[VAL_23]], %[[VAL_35]] : index -! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_35]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_32]]) -> (!fir.array<10xi32>) { +! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_35]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_32]]) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_41:.*]] = fir.array_fetch %[[VAL_34]], %[[VAL_39]] : (!fir.array<10xi32>, index) -> i32 ! CHECK: %[[VAL_42:.*]] = fir.array_fetch %[[VAL_21]], %[[VAL_39]] : (!fir.array<20xi32>, index) -> i32 ! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_42]] : (i32) -> index @@ -119,7 +119,7 @@ end subroutine test1b ! CHECK: %[[VAL_30:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_31:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_20]], %[[VAL_30]] : index -! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_9]]) -> (!fir.array<10xi32>) { +! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_9]]) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_36:.*]] = fir.array_fetch %[[VAL_13]], %[[VAL_34]] : (!fir.array<10xi32>, index) -> i32 ! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (i32) -> index ! CHECK: %[[VAL_38:.*]] = arith.subi %[[VAL_37]], %[[VAL_11]] : index @@ -163,7 +163,7 @@ end subroutine test2a ! CHECK: %[[VAL_30:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_31:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_18]], %[[VAL_30]] : index -! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_27]]) -> (!fir.array<10xi32>) { +! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_27]]) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_36:.*]] = fir.array_fetch %[[VAL_29]], %[[VAL_34]] : (!fir.array<10xi32>, index) -> i32 ! CHECK: %[[VAL_37:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_34]] : (!fir.array<10xi32>, index) -> i32 ! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_37]] : (i32) -> index diff --git a/flang/test/Lower/array-expression.f90 b/flang/test/Lower/array-expression.f90 index bdfbe6dd35095..c671f05c29524 100644 --- a/flang/test/Lower/array-expression.f90 +++ b/flang/test/Lower/array-expression.f90 @@ -47,7 +47,7 @@ end subroutine test1b ! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_9:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_4]]#1, %[[VAL_8]] : index -! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_5]]) -> (!fir.array) { +! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_5]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_14:.*]] = fir.array_fetch %[[VAL_6]], %[[VAL_12]] : (!fir.array, index) -> f32 ! CHECK: %[[VAL_15:.*]] = fir.array_fetch %[[VAL_7]], %[[VAL_12]] : (!fir.array, index) -> f32 ! CHECK: %[[VAL_16:.*]] = arith.addf %[[VAL_14]], %[[VAL_15]] {{.*}}: f32 @@ -147,7 +147,7 @@ end subroutine test5 ! CHECK: %[[VAL_30:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_31:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_23]], %[[VAL_30]] : index -! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_26]]) -> (!fir.array) { +! CHECK: %[[VAL_33:.*]] = fir.do_loop %[[VAL_34:.*]] = %[[VAL_31]] to %[[VAL_32]] step %[[VAL_30]] unordered iter_args(%[[VAL_35:.*]] = %[[VAL_26]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_36:.*]] = fir.array_fetch %[[VAL_28]], %[[VAL_34]] : (!fir.array, index) -> f32 ! CHECK: %[[VAL_37:.*]] = arith.addf %[[VAL_36]], %[[VAL_29]] {{.*}}: f32 ! CHECK: %[[VAL_38:.*]] = fir.array_update %[[VAL_35]], %[[VAL_37]], %[[VAL_34]] : (!fir.array, f32, index) -> !fir.array @@ -188,7 +188,7 @@ end subroutine test6 ! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_22:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_4]], %[[VAL_21]] : index -! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_6]]) -> (!fir.array<10xf32>) { +! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_6]]) -> (!fir.array<10xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_27:.*]] = fir.array_fetch %[[VAL_20]], %[[VAL_11]], %[[VAL_25]] : (!fir.array<10x50xf32>, index, index) -> f32 ! CHECK: %[[VAL_28:.*]] = fir.array_update %[[VAL_26]], %[[VAL_27]], %[[VAL_25]] : (!fir.array<10xf32>, f32, index) -> !fir.array<10xf32> ! CHECK: fir.result %[[VAL_28]] : !fir.array<10xf32> @@ -234,7 +234,7 @@ end subroutine test6a ! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_21]], %[[VAL_27]] : index -! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_24]]) -> (!fir.array<10x50xf32>) { +! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_24]]) -> (!fir.array<10x50xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_33:.*]] = fir.array_fetch %[[VAL_26]], %[[VAL_31]] : (!fir.array<10xf32>, index) -> f32 ! CHECK: %[[VAL_34:.*]] = fir.array_update %[[VAL_32]], %[[VAL_33]], %[[VAL_9]], %[[VAL_31]] : (!fir.array<10x50xf32>, f32, index, index) -> !fir.array<10x50xf32> ! CHECK: fir.result %[[VAL_34]] : !fir.array<10x50xf32> @@ -273,7 +273,7 @@ end subroutine test6b ! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_17:.*]] = arith.subi %[[VAL_5]], %[[VAL_15]] : index -! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_10]]) -> (!fir.array) { +! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_10]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_21:.*]] = fir.array_fetch %[[VAL_12]], %[[VAL_19]] : (!fir.array, index) -> f32 ! CHECK: %[[VAL_22:.*]] = fir.array_fetch %[[VAL_14]], %[[VAL_19]] : (!fir.array, index) -> f32 ! CHECK: %[[VAL_23:.*]] = arith.addf %[[VAL_21]], %[[VAL_22]] {{.*}}: f32 @@ -306,7 +306,7 @@ end subroutine test7 ! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_11:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_12:.*]] = arith.subi %[[VAL_2]], %[[VAL_10]] : index -! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_4]]) -> (!fir.array<100xi32>) { +! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_4]]) -> (!fir.array<100xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_16:.*]] = fir.array_update %[[VAL_15]], %[[VAL_9]], %[[VAL_14]] : (!fir.array<100xi32>, i32, index) -> !fir.array<100xi32> ! CHECK: fir.result %[[VAL_16]] : !fir.array<100xi32> ! CHECK: } @@ -359,7 +359,7 @@ end subroutine test10 ! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_22:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_12]], %[[VAL_21]] : index -! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_20]]) -> (!fir.array<100xf32>) { +! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_20]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_27:.*]] = fir.array_fetch %[[VAL_15]], %[[VAL_25]] : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[VAL_28:.*]] = fir.array_fetch %[[VAL_17]], %[[VAL_25]] : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[VAL_29:.*]] = arith.addf %[[VAL_27]], %[[VAL_28]] {{.*}}: f32 @@ -372,7 +372,7 @@ end subroutine test10 ! CHECK: %[[VAL_34:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_35:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_36:.*]] = arith.subi %[[VAL_4]], %[[VAL_34]] : index -! CHECK: %[[VAL_37:.*]] = fir.do_loop %[[VAL_38:.*]] = %[[VAL_35]] to %[[VAL_36]] step %[[VAL_34]] unordered iter_args(%[[VAL_39:.*]] = %[[VAL_9]]) -> (!fir.array<100xf32>) { +! CHECK: %[[VAL_37:.*]] = fir.do_loop %[[VAL_38:.*]] = %[[VAL_35]] to %[[VAL_36]] step %[[VAL_34]] unordered iter_args(%[[VAL_39:.*]] = %[[VAL_9]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_40:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_38]] : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[VAL_41:.*]] = arith.addf %[[VAL_40]], %[[VAL_33]] {{.*}}: f32 ! CHECK: %[[VAL_42:.*]] = fir.array_update %[[VAL_39]], %[[VAL_41]], %[[VAL_38]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> @@ -452,7 +452,7 @@ real elemental function f1(i) end function f1 end interface real :: a(100), b(100) - ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) { + ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[ishift:.*]] = arith.addi %[[i]], %c1{{.*}} : index ! CHECK: %[[tmp:.*]] = fir.array_coor %[[a]](%{{.*}}) %[[ishift]] : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref ! CHECK: %[[fres:.*]] = fir.call @_QPf1(%[[tmp]]) {{.*}}: (!fir.ref) -> f32 @@ -469,7 +469,7 @@ subroutine test15(a,b) ! CHECK-DAG: %[[barr:.*]] = fir.array_load %[[b]](%{{.*}}) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> ! CHECK-DAG: %[[aarr:.*]] = fir.array_load %[[a]](%{{.*}}) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xf32> real :: a(100), b(100) - ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) { + ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[val:.*]] = fir.array_fetch %[[aarr]], %[[i]] : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[fres:.*]] = math.absf %[[val]] {{.*}}: f32 ! CHECK: %[[res:.*]] = fir.array_update %[[bth]], %[[fres]], %[[i]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> @@ -490,7 +490,7 @@ real elemental function f2(i) end function f2 end interface real :: a(100), b(100) - ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) { + ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[val:.*]] = fir.array_fetch %[[aarr]], %[[i]] : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[fres:.*]] = fir.call @_QPf2(%[[val]]) {{.*}}: (f32) -> f32 ! CHECK: %[[res:.*]] = fir.array_update %[[bth]], %[[fres]], %[[i]] : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32> @@ -512,7 +512,7 @@ real elemental impure function f3(i,j,k) end function f3 end interface real :: a(100), b(2:101), c(3:102) - ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) { + ! CHECK: %[[loop:.*]] = fir.do_loop %[[i:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%[[bth:.*]] = %[[barr]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { ! CHECK-DAG: %[[val:.*]] = fir.array_fetch %[[aarr]], %[[i]] : (!fir.array<100xf32>, index) -> f32 ! CHECK-DAG: %[[ic:.*]] = arith.addi %[[i]], %c3{{.*}} : index ! CHECK-DAG: %[[ccoor:.*]] = fir.array_coor %[[c]](%{{.*}}) %[[ic]] : (!fir.ref>, !fir.shapeshift<1>, index) -> !fir.ref @@ -579,8 +579,8 @@ end subroutine test18 ! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_9:.*]] = arith.subi %[[VAL_1]], %[[VAL_7]] : index ! CHECK: %[[VAL_10:.*]] = arith.subi %[[VAL_2]], %[[VAL_7]] : index -! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_7]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_4]]) -> (!fir.array<2x3xf32>) { -! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_7]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_13]]) -> (!fir.array<2x3xf32>) { +! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_7]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_4]]) -> (!fir.array<2x3xf32>) attributes {operandSegmentSizes = array} { +! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_7]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_13]]) -> (!fir.array<2x3xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_17:.*]] = fir.array_update %[[VAL_16]], %[[VAL_6]], %[[VAL_15]], %[[VAL_12]] : (!fir.array<2x3xf32>, f32, index, index) -> !fir.array<2x3xf32> ! CHECK: fir.result %[[VAL_17]] : !fir.array<2x3xf32> ! CHECK: } @@ -616,7 +616,7 @@ subroutine test_column_and_row_order(x) ! CHECK: %[[VAL_17:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_18:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_13]], %[[VAL_17]] : index -! CHECK: %[[VAL_20:.*]] = fir.do_loop %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_17]] unordered iter_args(%[[VAL_22:.*]] = %[[VAL_15]]) -> (!fir.array) { +! CHECK: %[[VAL_20:.*]] = fir.do_loop %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_17]] unordered iter_args(%[[VAL_22:.*]] = %[[VAL_15]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_23:.*]] = fir.array_update %[[VAL_22]], %[[VAL_16]], %[[VAL_21]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[VAL_23]] : !fir.array ! CHECK: } @@ -644,7 +644,7 @@ subroutine test_assigning_to_assumed_shape_slices(x) ! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_4]], %[[VAL_12]] : index -! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_9]]) -> (!fir.array<10x!fir.char<1,10>>) { +! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_9]]) -> (!fir.array<10x!fir.char<1,10>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_18:.*]] = fir.array_access %[[VAL_11]], %[[VAL_16]] : (!fir.array<10x!fir.char<1,10>>, index) -> !fir.ref> ! CHECK: %[[VAL_19:.*]] = fir.array_access %[[VAL_17]], %[[VAL_16]] : (!fir.array<10x!fir.char<1,10>>, index) -> !fir.ref> ! CHECK: %[[VAL_20:.*]] = arith.constant 10 : index @@ -684,7 +684,7 @@ end subroutine test19a ! CHECK: %[[VAL_13:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_15:.*]] = arith.subi %[[VAL_4]], %[[VAL_13]] : index -! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_13]] unordered iter_args(%[[VAL_18:.*]] = %[[VAL_10]]) -> (!fir.array<20x!fir.char<2,8>>) { +! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_13]] unordered iter_args(%[[VAL_18:.*]] = %[[VAL_10]]) -> (!fir.array<20x!fir.char<2,8>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = fir.array_access %[[VAL_12]], %[[VAL_17]] : (!fir.array<20x!fir.char<2,10>>, index) -> !fir.ref> ! CHECK: %[[VAL_20:.*]] = fir.array_access %[[VAL_18]], %[[VAL_17]] : (!fir.array<20x!fir.char<2,8>>, index) -> !fir.ref> ! CHECK: %[[VAL_21:.*]] = arith.constant 8 : index @@ -703,7 +703,7 @@ end subroutine test19a ! CHECK: %[[VAL_33:.*]] = fir.undefined !fir.char<2> ! CHECK: %[[VAL_34:.*]] = fir.insert_value %[[VAL_33]], %[[VAL_32]], [0 : index] : (!fir.char<2>, i16) -> !fir.char<2> ! CHECK: %[[VAL_35:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_36:.*]] = %[[VAL_23]] to %[[VAL_31]] step %[[VAL_35]] { +! CHECK: fir.do_loop %[[VAL_36:.*]] = %[[VAL_23]] to %[[VAL_31]] step %[[VAL_35]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_20]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_38:.*]] = fir.coordinate_of %[[VAL_37]], %[[VAL_36]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_34]] to %[[VAL_38]] : !fir.ref> @@ -741,7 +741,7 @@ end subroutine test19b ! CHECK: %[[VAL_18:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_19:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_20:.*]] = arith.subi %[[VAL_13]], %[[VAL_18]] : index -! CHECK: %[[VAL_21:.*]] = fir.do_loop %[[VAL_22:.*]] = %[[VAL_19]] to %[[VAL_20]] step %[[VAL_18]] unordered iter_args(%[[VAL_23:.*]] = %[[VAL_15]]) -> (!fir.array<30x!fir.char<4,?>>) { +! CHECK: %[[VAL_21:.*]] = fir.do_loop %[[VAL_22:.*]] = %[[VAL_19]] to %[[VAL_20]] step %[[VAL_18]] unordered iter_args(%[[VAL_23:.*]] = %[[VAL_15]]) -> (!fir.array<30x!fir.char<4,?>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_24:.*]] = fir.array_access %[[VAL_17]], %[[VAL_22]] : (!fir.array<30x!fir.char<4,10>>, index) -> !fir.ref> ! CHECK: %[[VAL_25:.*]] = fir.array_access %[[VAL_23]], %[[VAL_22]] typeparams %[[VAL_11]] : (!fir.array<30x!fir.char<4,?>>, index, i32) -> !fir.ref> ! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_11]] : (i32) -> index @@ -761,7 +761,7 @@ end subroutine test19b ! CHECK: %[[VAL_39:.*]] = fir.insert_value %[[VAL_38]], %[[VAL_37]], [0 : index] : (!fir.char<4>, i32) -> !fir.char<4> ! CHECK: %[[VAL_40:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_36]] : (i32) -> index -! CHECK: fir.do_loop %[[VAL_42:.*]] = %[[VAL_28]] to %[[VAL_41]] step %[[VAL_40]] { +! CHECK: fir.do_loop %[[VAL_42:.*]] = %[[VAL_28]] to %[[VAL_41]] step %[[VAL_40]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_25]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_44:.*]] = fir.coordinate_of %[[VAL_43]], %[[VAL_42]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_39]] to %[[VAL_44]] : !fir.ref> @@ -802,7 +802,7 @@ end subroutine test19c ! CHECK: %[[VAL_22:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_23:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_24:.*]] = arith.subi %[[VAL_10]], %[[VAL_22]] : index -! CHECK: %[[VAL_25:.*]] = fir.do_loop %[[VAL_26:.*]] = %[[VAL_23]] to %[[VAL_24]] step %[[VAL_22]] unordered iter_args(%[[VAL_27:.*]] = %[[VAL_19]]) -> (!fir.array<40x!fir.char<1,?>>) { +! CHECK: %[[VAL_25:.*]] = fir.do_loop %[[VAL_26:.*]] = %[[VAL_23]] to %[[VAL_24]] step %[[VAL_22]] unordered iter_args(%[[VAL_27:.*]] = %[[VAL_19]]) -> (!fir.array<40x!fir.char<1,?>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_28:.*]] = fir.array_access %[[VAL_21]], %[[VAL_26]] typeparams %[[VAL_15]] : (!fir.array<40x!fir.char<1,?>>, index, i32) -> !fir.ref> ! CHECK: %[[VAL_29:.*]] = fir.array_access %[[VAL_27]], %[[VAL_26]] typeparams %[[VAL_8]] : (!fir.array<40x!fir.char<1,?>>, index, i32) -> !fir.ref> ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_8]] : (i32) -> index @@ -823,7 +823,7 @@ end subroutine test19c ! CHECK: %[[VAL_44:.*]] = fir.insert_value %[[VAL_43]], %[[VAL_42]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_45:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_41]] : (i32) -> index -! CHECK: fir.do_loop %[[VAL_47:.*]] = %[[VAL_33]] to %[[VAL_46]] step %[[VAL_45]] { +! CHECK: fir.do_loop %[[VAL_47:.*]] = %[[VAL_33]] to %[[VAL_46]] step %[[VAL_45]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_29]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_49:.*]] = fir.coordinate_of %[[VAL_48]], %[[VAL_47]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_44]] to %[[VAL_49]] : !fir.ref> @@ -856,7 +856,7 @@ end subroutine test19d ! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_4]], %[[VAL_12]] : index -! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_9]]) -> (!fir.array<50x!fir.char<1,?>>) { +! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_9]]) -> (!fir.array<50x!fir.char<1,?>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_18:.*]] = fir.array_access %[[VAL_11]], %[[VAL_16]] typeparams %[[VAL_5]]#1 : (!fir.array<50x!fir.char<1,?>>, index, index) -> !fir.ref> ! CHECK: %[[VAL_19:.*]] = fir.array_access %[[VAL_17]], %[[VAL_16]] typeparams %[[VAL_2]]#1 : (!fir.array<50x!fir.char<1,?>>, index, index) -> !fir.ref> ! CHECK: %[[VAL_20:.*]] = arith.cmpi slt, %[[VAL_2]]#1, %[[VAL_5]]#1 : index @@ -874,7 +874,7 @@ end subroutine test19d ! CHECK: %[[VAL_31:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_32:.*]] = fir.insert_value %[[VAL_31]], %[[VAL_30]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_34:.*]] = %[[VAL_21]] to %[[VAL_29]] step %[[VAL_33]] { +! CHECK: fir.do_loop %[[VAL_34:.*]] = %[[VAL_21]] to %[[VAL_29]] step %[[VAL_33]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_19]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_36:.*]] = fir.coordinate_of %[[VAL_35]], %[[VAL_34]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_32]] to %[[VAL_36]] : !fir.ref> @@ -909,7 +909,7 @@ end subroutine test19e ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]] = arith.subi %[[VAL_4]], %[[VAL_14]] : index -! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_9]]) -> (!fir.array<60x!fir.char<1,?>>) { +! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_9]]) -> (!fir.array<60x!fir.char<1,?>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_20:.*]] = fir.array_access %[[VAL_13]], %[[VAL_18]] typeparams %[[VAL_5]]#1 : (!fir.array<60x!fir.char<1,?>>, index, index) -> !fir.ref> ! CHECK: %[[VAL_21:.*]] = arith.addi %[[VAL_11]], %[[VAL_5]]#1 : index ! CHECK: %[[VAL_22:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_21]] : index) {bindc_name = ".chrtmp"} @@ -922,7 +922,7 @@ end subroutine test19e ! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_27]], %[[VAL_28]], %[[VAL_25]], %[[VAL_26]]) {{.*}}: (!fir.ref, !fir.ref, i64, i1) -> () ! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_30:.*]] = arith.subi %[[VAL_21]], %[[VAL_29]] : index -! CHECK: fir.do_loop %[[VAL_31:.*]] = %[[VAL_11]] to %[[VAL_30]] step %[[VAL_29]] { +! CHECK: fir.do_loop %[[VAL_31:.*]] = %[[VAL_11]] to %[[VAL_30]] step %[[VAL_29]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_31]], %[[VAL_11]] : index ! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_20]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_34:.*]] = fir.coordinate_of %[[VAL_33]], %[[VAL_32]] : (!fir.ref>>, index) -> !fir.ref> @@ -947,7 +947,7 @@ end subroutine test19e ! CHECK: %[[VAL_50:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_51:.*]] = fir.insert_value %[[VAL_50]], %[[VAL_49]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_52:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_53:.*]] = %[[VAL_40]] to %[[VAL_48]] step %[[VAL_52]] { +! CHECK: fir.do_loop %[[VAL_53:.*]] = %[[VAL_40]] to %[[VAL_48]] step %[[VAL_52]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_38]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_55:.*]] = fir.coordinate_of %[[VAL_54]], %[[VAL_53]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_51]] to %[[VAL_55]] : !fir.ref> @@ -995,7 +995,7 @@ end subroutine test19f ! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_13]], %[[VAL_27]] : index -! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_15]]) -> (!fir.array<70x!fir.char<4,?>>) { +! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_15]]) -> (!fir.array<70x!fir.char<4,?>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_33:.*]] = fir.array_access %[[VAL_24]], %[[VAL_31]] : (!fir.array<140x!fir.char<2,13>>, index) -> !fir.ref> ! CHECK: %[[VAL_34:.*]] = fir.alloca !fir.char<4,?>(%[[VAL_4]] : index) ! CHECK: %[[VAL_46:.*]] = fir.array_access %[[VAL_32]], %[[VAL_31]] typeparams %[[VAL_11]] : (!fir.array<70x!fir.char<4,?>>, index, i32) -> !fir.ref> @@ -1017,7 +1017,7 @@ end subroutine test19f ! CHECK: %[[VAL_61:.*]] = fir.insert_value %[[VAL_60]], %[[VAL_59]], [0 : index] : (!fir.char<4>, i32) -> !fir.char<4> ! CHECK: %[[VAL_62:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_63:.*]] = fir.convert %[[VAL_58]] : (i32) -> index -! CHECK: fir.do_loop %[[VAL_64:.*]] = %[[VAL_50]] to %[[VAL_63]] step %[[VAL_62]] { +! CHECK: fir.do_loop %[[VAL_64:.*]] = %[[VAL_50]] to %[[VAL_63]] step %[[VAL_62]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_65:.*]] = fir.convert %[[VAL_46]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_66:.*]] = fir.coordinate_of %[[VAL_65]], %[[VAL_64]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_61]] to %[[VAL_66]] : !fir.ref> @@ -1066,7 +1066,7 @@ end subroutine test19g ! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_10]], %[[VAL_27]] : index -! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_17]]) -> (!fir.array<70x!fir.char<1,?>>) { +! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_28]] to %[[VAL_29]] step %[[VAL_27]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_17]]) -> (!fir.array<70x!fir.char<1,?>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_33:.*]] = fir.array_access %[[VAL_26]], %[[VAL_31]] typeparams %[[VAL_11]]#1 : (!fir.array>, index, index) -> !fir.ref> ! CHECK: %[[VAL_34:.*]] = fir.array_access %[[VAL_32]], %[[VAL_31]] typeparams %[[VAL_8]] : (!fir.array<70x!fir.char<1,?>>, index, i32) -> !fir.ref> ! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_8]] : (i32) -> index @@ -1086,7 +1086,7 @@ end subroutine test19g ! CHECK: %[[VAL_48:.*]] = fir.insert_value %[[VAL_47]], %[[VAL_46]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_49:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_45]] : (i32) -> index -! CHECK: fir.do_loop %[[VAL_51:.*]] = %[[VAL_37]] to %[[VAL_50]] step %[[VAL_49]] { +! CHECK: fir.do_loop %[[VAL_51:.*]] = %[[VAL_37]] to %[[VAL_50]] step %[[VAL_49]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_34]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_53:.*]] = fir.coordinate_of %[[VAL_52]], %[[VAL_51]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_48]] to %[[VAL_53]] : !fir.ref> @@ -1127,7 +1127,7 @@ end subroutine test19h ! CHECK: %[[VAL_21:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_22:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_15]], %[[VAL_21]] : index -! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_20]]) -> (!fir.array<10xi32>) { +! CHECK: %[[VAL_24:.*]] = fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_21]] unordered iter_args(%[[VAL_26:.*]] = %[[VAL_20]]) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_28:.*]] = arith.addi %[[VAL_25]], %[[VAL_27]] : index ! CHECK: %[[VAL_29:.*]] = fir.array_coor %[[VAL_3]](%[[VAL_16]]) %[[VAL_28]] typeparams %[[VAL_2]]#1 : (!fir.ref>>, !fir.shape<1>, index, index) -> !fir.ref> @@ -1168,7 +1168,7 @@ subroutine test_elemental_character_intrinsic(c1, c2) ! CHECK: %[[Y:.*]] = fir.array_load %[[ARG1]]({{.*}}) : (!fir.ref>, !fir.shape<1>) -> !fir.array<4xi32> ! CHECK: %[[TEMP:.*]] = fir.allocmem !fir.array<4xi32> ! CHECK: %[[TEMP2:.*]] = fir.array_load %[[TEMP]]({{.*}}) : (!fir.heap>, !fir.shape<1>) -> !fir.array<4xi32> -! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP3:.*]] = %[[TEMP2]]) -> (!fir.array<4xi32>) { +! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP3:.*]] = %[[TEMP2]]) -> (!fir.array<4xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[XI:.*]] = fir.array_fetch %[[X]], %[[I]] : (!fir.array<4xi32>, index) -> i32 ! CHECK: %[[YI:.*]] = fir.array_fetch %[[Y]], %[[I]] : (!fir.array<4xi32>, index) -> i32 ! CHECK: %[[ADD:.*]] = arith.addi %[[XI]], %[[YI]] : i32 @@ -1189,15 +1189,15 @@ subroutine test20a(x, y, z) ! CHECK: %[[X:.*]] = fir.array_load %[[ARG0]]({{.*}}) : (!fir.ref>, !fir.shape<1>) -> !fir.array<4xi32> ! CHECK: %[[TEMP:.*]] = fir.allocmem !fir.array<4xi32> ! CHECK: %[[TEMP2:.*]] = fir.array_load %[[TEMP]]({{.*}}) : (!fir.heap>, !fir.shape<1>) -> !fir.array<4xi32> -! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP3:.*]] = %[[TEMP2]]) -> (!fir.array<4xi32>) { +! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP3:.*]] = %[[TEMP2]]) -> (!fir.array<4xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[XI:.*]] = fir.array_fetch %[[X]], %[[I]] : (!fir.array<4xi32>, index) -> i32 ! CHECK: {{.*}} = fir.array_update %[[TEMP3]], %[[XI]], %[[I]] : (!fir.array<4xi32>, i32, index) -> !fir.array<4xi32> ! CHECK: } ! CHECK: %[[Y:.*]] = fir.array_load %[[ARG1]]({{.*}}) : (!fir.ref>, !fir.shape<2>) -> !fir.array<2x2xi32> ! CHECK: %[[TEMP4:.*]] = fir.allocmem !fir.array<2x2xi32> ! CHECK: %[[TEMP5:.*]] = fir.array_load %[[TEMP4]]({{.*}}) : (!fir.heap>, !fir.shape<2>) -> !fir.array<2x2xi32> -! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP6:.*]] = %[[TEMP5]]) -> (!fir.array<2x2xi32>) { -! CHECK: {{.*}} = fir.do_loop %[[J:.*]] = {{.*}} iter_args(%[[TEMP7:.*]] = %[[TEMP6]]) -> (!fir.array<2x2xi32>) { +! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP6:.*]] = %[[TEMP5]]) -> (!fir.array<2x2xi32>) attributes {operandSegmentSizes = array} { +! CHECK: {{.*}} = fir.do_loop %[[J:.*]] = {{.*}} iter_args(%[[TEMP7:.*]] = %[[TEMP6]]) -> (!fir.array<2x2xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[YJI:.*]] = fir.array_fetch %[[Y]], %[[J]], %[[I]] : (!fir.array<2x2xi32>, index, index) -> i32 ! CHECK: {{.*}} = fir.array_update %[[TEMP7]], %[[YJI]], %[[J]], %[[I]] : (!fir.array<2x2xi32>, i32, index, index) -> !fir.array<2x2xi32> ! CHECK: } @@ -1215,7 +1215,7 @@ subroutine test20b(x, y, z) ! CHECK: %[[X:.*]] = fir.array_load %[[ARG0]]({{.*}}) : (!fir.ref>, !fir.shape<1>) -> !fir.array<4xi32> ! CHECK: %[[ACX_MEM:.*]] = fir.allocmem !fir.array<4xi32> ! CHECK: %[[ACX:.*]] = fir.array_load %[[ACX_MEM]]({{.*}}) : (!fir.heap>, !fir.shape<1>) -> !fir.array<4xi32> -! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP:.*]] = %[[ACX]]) -> (!fir.array<4xi32>) { +! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP:.*]] = %[[ACX]]) -> (!fir.array<4xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[XI:.*]] = fir.array_fetch %[[X]], %[[I]] : (!fir.array<4xi32>, index) -> i32 ! CHECK: {{.*}} = fir.array_update %[[TEMP]], %[[XI]], %[[I]] : (!fir.array<4xi32>, i32, index) -> !fir.array<4xi32> ! CHECK: } @@ -1229,8 +1229,8 @@ subroutine test20b(x, y, z) ! CHECK: %[[Y:.*]] = fir.array_load %[[ARG1]]({{.*}}) : (!fir.ref>, !fir.shape<2>) -> !fir.array<2x2xi32> ! CHECK: %[[ACY_MEM:.*]] = fir.allocmem !fir.array<2x2xi32> ! CHECK: %[[ACY:.*]] = fir.array_load %[[ACY_MEM]]({{.*}}) : (!fir.heap>, !fir.shape<2>) -> !fir.array<2x2xi32> -! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP:.*]] = %[[ACY]]) -> (!fir.array<2x2xi32>) { -! CHECK: {{.*}} = fir.do_loop %[[J:.*]] = {{.*}} iter_args(%[[TEMP2:.*]] = %[[TEMP]]) -> (!fir.array<2x2xi32>) { +! CHECK: {{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP:.*]] = %[[ACY]]) -> (!fir.array<2x2xi32>) attributes {operandSegmentSizes = array} { +! CHECK: {{.*}} = fir.do_loop %[[J:.*]] = {{.*}} iter_args(%[[TEMP2:.*]] = %[[TEMP]]) -> (!fir.array<2x2xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[YJI:.*]] = fir.array_fetch %[[Y]], %[[J]], %[[I]] : (!fir.array<2x2xi32>, index, index) -> i32 ! CHECK: {{.*}} = fir.array_update %[[TEMP2]], %[[YJI]], %[[J]], %[[I]] : (!fir.array<2x2xi32>, i32, index, index) -> !fir.array<2x2xi32> ! CHECK: } @@ -1244,7 +1244,7 @@ subroutine test20b(x, y, z) ! (/x/) /= (/y/) ! CHECK: %[[RES_MEM:.*]] = fir.allocmem !fir.array<4x!fir.logical<4>> ! CHECK: %[[RES:.*]] = fir.array_load %[[RES_MEM]]({{.*}}) : (!fir.heap>>, !fir.shape<1>) -> !fir.array<4x!fir.logical<4>> -! CHECK: %{{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP:.*]] = %[[RES]]) -> (!fir.array<4x!fir.logical<4>>) { +! CHECK: %{{.*}} = fir.do_loop %[[I:.*]] = {{.*}} iter_args(%[[TEMP:.*]] = %[[RES]]) -> (!fir.array<4x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[XI:.*]] = fir.array_fetch %[[ACX2]], %[[I]] : (!fir.array<4xi32>, index) -> i32 ! CHECK: %[[YI:.*]] = fir.array_fetch %[[ACY2]], %[[I]] : (!fir.array<4xi32>, index) -> i32 ! CHECK: %[[T1:.*]] = arith.cmpi ne, %[[XI]], %[[YI]] : i32 diff --git a/flang/test/Lower/array-user-def-assignments.f90 b/flang/test/Lower/array-user-def-assignments.f90 index 97090ff77678c..9dbfa402fe40b 100644 --- a/flang/test/Lower/array-user-def-assignments.f90 +++ b/flang/test/Lower/array-user-def-assignments.f90 @@ -43,7 +43,7 @@ elemental subroutine assign_real_to_logical(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_8:[0-9]+]] = arith.subi %[[C_100]], %[[C_1]] : index -! CHECK: %[[V_9:[0-9]+]] = fir.do_loop %arg1 = %[[C_0]] to %[[V_8]] step %[[C_1]] unordered iter_args(%arg2 = %[[V_1]]) -> (!fir.array<100x!fir.type<_QMdefined_assignmentsTt{i:i32}>>) { +! CHECK: %[[V_9:[0-9]+]] = fir.do_loop %arg1 = %[[C_0]] to %[[V_8]] step %[[C_1]] unordered iter_args(%arg2 = %[[V_1]]) -> (!fir.array<100x!fir.type<_QMdefined_assignmentsTt{i:i32}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_10:[0-9]+]] = fir.array_access %[[V_7]], %arg1 : (!fir.array<100x!fir.type<_QMdefined_assignmentsTt{i:i32}>>, index) -> !fir.ref> ! CHECK: %[[V_11:[0-9]+]] = fir.no_reassoc %[[V_10:[0-9]+]] : !fir.ref> ! CHECK: %[[V_12:[0-9]+]]:2 = fir.array_modify %arg2, %arg1 : (!fir.array<100x!fir.type<_QMdefined_assignmentsTt{i:i32}>>, index) -> (!fir.ref>, !fir.array<100x!fir.type<_QMdefined_assignmentsTt{i:i32}>>) @@ -73,7 +73,7 @@ elemental subroutine assign_real_to_logical(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_9:[0-9]+]] = arith.subi %[[C_100]], %[[C_1]] : index -! CHECK: %[[V_10:[0-9]+]] = fir.do_loop %arg1 = %[[C_0]] to %[[V_9]] step %[[C_1]] unordered iter_args(%arg2 = %[[V_2]]) -> (!fir.array<100xf32>) { +! CHECK: %[[V_10:[0-9]+]] = fir.do_loop %arg1 = %[[C_0]] to %[[V_9]] step %[[C_1]] unordered iter_args(%arg2 = %[[V_2]]) -> (!fir.array<100xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_11:[0-9]+]] = fir.array_fetch %[[V_8]], %arg1 : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[V_12:[0-9]+]] = arith.cmpf olt, %[[V_11]], %[[C_st]] {{.*}} : f32 ! CHECK: %[[V_13:[0-9]+]]:2 = fir.array_modify %arg2, %arg1 : (!fir.array<100xf32>, index) -> (!fir.ref, !fir.array<100xf32>) @@ -98,7 +98,7 @@ elemental subroutine assign_real_to_logical(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_5:[0-9]+]] = arith.subi %[[C_100]], %[[C_1]] : index -! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[C_0]] to %[[V_5]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_2]]) -> (!fir.array<100x!fir.logical<4>>) { +! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[C_0]] to %[[V_5]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_2]]) -> (!fir.array<100x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_7:[0-9]+]] = fir.array_fetch %[[V_4]], %arg2 : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[V_8:[0-9]+]] = fir.no_reassoc %[[V_7:[0-9]+]] : f32 ! CHECK: %[[V_9:[0-9]+]]:2 = fir.array_modify %arg3, %arg2 : (!fir.array<100x!fir.logical<4>>, index) -> (!fir.ref>, !fir.array<100x!fir.logical<4>>) @@ -122,7 +122,7 @@ elemental subroutine assign_real_to_logical(a,b) ! CHECK: %[[C_1_0:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0_1:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_5:[0-9]+]] = arith.subi %[[V_0]]#1, %[[C_1_0]] : index -! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[C_0_1]] to %[[V_5]] step %[[C_1_0]] unordered iter_args(%arg3 = %[[V_1]]) -> (!fir.array) { +! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[C_0_1]] to %[[V_5]] step %[[C_1_0]] unordered iter_args(%arg3 = %[[V_1]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_7:[0-9]+]] = fir.array_access %[[V_2]], %arg2 typeparams %[[V_4:[0-9]+]] : (!fir.array>, index, index) -> !fir.ref> ! CHECK: %[[V_8:[0-9]+]] = fir.box_elesize %arg1 : (!fir.box>>) -> index ! CHECK: %[[V_9:[0-9]+]] = fir.no_reassoc %[[V_7:[0-9]+]] : !fir.ref> @@ -145,7 +145,7 @@ elemental subroutine assign_real_to_logical(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0_0:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_4:[0-9]+]] = arith.subi %[[V_1]]#1, %[[C_1]] : index -! CHECK: %[[V_5:[0-9]+]] = fir.do_loop %arg2 = %[[C_0_0]] to %[[V_4]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_2]]) -> (!fir.array>) { +! CHECK: %[[V_5:[0-9]+]] = fir.do_loop %arg2 = %[[C_0_0]] to %[[V_4]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_2]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_6:[0-9]+]] = fir.array_fetch %[[V_3]], %arg2 : (!fir.array, index) -> i32 ! CHECK: %[[V_7:[0-9]+]] = fir.no_reassoc %[[V_6:[0-9]+]] : i32 ! CHECK: %[[V_8:[0-9]+]]:2 = fir.array_modify %arg3, %arg2 : (!fir.array>, index) -> (!fir.ref>, !fir.array>) @@ -221,7 +221,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[V_5:[0-9]+]] = fir.array_load %arg0(%[[V_4]]) : (!fir.ref>>, !fir.shape<1>) -> !fir.array<10x!fir.logical<4>> ! CHECK: %[[V_6:[0-9]+]] = fir.shape %[[C_10_0]] : (index) -> !fir.shape<1> ! CHECK: %[[V_7:[0-9]+]] = fir.array_load %arg1(%[[V_6]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array<10xf32> -! CHECK: %[[V_8:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_5]]) -> (!fir.array<10x!fir.logical<4>>) { +! CHECK: %[[V_8:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_5]]) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_9:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_9]] to %[[V_1:[0-9]+]] : !fir.ref ! CHECK: %[[C_1_1:[-0-9a-z_]+]] = arith.constant 1 : index @@ -257,7 +257,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_4:[0-9]+]] = fir.shape %[[C_10]] : (index) -> !fir.shape<1> ! CHECK: %[[V_5:[0-9]+]] = fir.array_load %arg1(%[[V_4]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array<10xf32> -! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_5]]) -> (!fir.array<10xf32>) { +! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_5]]) -> (!fir.array<10xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_7:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_7]] to %[[V_1:[0-9]+]] : !fir.ref ! CHECK: %[[C_1_0:[-0-9a-z_]+]] = arith.constant 1 : index @@ -298,7 +298,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_6:[0-9]+]] = arith.subi %[[C_10_2]], %[[C_1]] : index -! CHECK: %[[V_7:[0-9]+]] = fir.do_loop %arg3 = %[[C_0]] to %[[V_6]] step %[[C_1]] unordered iter_args(%arg4 = %[[V_5]]) -> (!fir.array<10x!fir.logical<4>>) { +! CHECK: %[[V_7:[0-9]+]] = fir.do_loop %arg3 = %[[C_0]] to %[[V_6]] step %[[C_1]] unordered iter_args(%arg4 = %[[V_5]]) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_15:[0-9]+]] = fir.array_fetch %[[V_2]], %arg3 : (!fir.array<10x!fir.logical<4>>, index) -> !fir.logical<4> ! CHECK: %[[V_16:[0-9]+]] = fir.array_update %arg4, %[[V_15]], %arg3 : (!fir.array<10x!fir.logical<4>>, !fir.logical<4>, index) -> !fir.array<10x!fir.logical<4>> ! CHECK: fir.result %[[V_16:[0-9]+]] : !fir.array<10x!fir.logical<4>> @@ -312,7 +312,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1_3:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0_4:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_13:[0-9]+]] = arith.subi %[[C_10_0]], %[[C_1_3]] : index -! CHECK: %[[V_14:[0-9]+]] = fir.do_loop %arg3 = %[[C_0_4]] to %[[V_13]] step %[[C_1_3]] unordered iter_args(%arg4 = %[[V_10]]) -> (!fir.array<10x!fir.logical<4>>) { +! CHECK: %[[V_14:[0-9]+]] = fir.do_loop %arg3 = %[[C_0_4]] to %[[V_13]] step %[[C_1_3]] unordered iter_args(%arg4 = %[[V_10]]) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[C_1_5:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_15:[0-9]+]] = arith.addi %arg3, %[[C_1_5]] : index ! CHECK: %[[V_16:[0-9]+]] = fir.array_coor %[[V_3]](%[[V_8]]) %[[V_15:[0-9]+]] : (!fir.heap>>, !fir.shape<1>, index) -> !fir.ref> @@ -349,7 +349,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_6:[0-9]+]] = arith.subi %[[C_10_1]], %[[C_1]] : index -! CHECK: %[[V_7:[0-9]+]] = fir.do_loop %arg3 = %[[C_0]] to %[[V_6]] step %[[C_1]] unordered iter_args(%arg4 = %[[V_5]]) -> (!fir.array<10x!fir.logical<4>>) { +! CHECK: %[[V_7:[0-9]+]] = fir.do_loop %arg3 = %[[C_0]] to %[[V_6]] step %[[C_1]] unordered iter_args(%arg4 = %[[V_5]]) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_15:[0-9]+]] = fir.array_fetch %[[V_2]], %arg3 : (!fir.array<10x!fir.logical<4>>, index) -> !fir.logical<4> ! CHECK: %[[V_16:[0-9]+]] = fir.array_update %arg4, %[[V_15]], %arg3 : (!fir.array<10x!fir.logical<4>>, !fir.logical<4>, index) -> !fir.array<10x!fir.logical<4>> ! CHECK: fir.result %[[V_16:[0-9]+]] : !fir.array<10x!fir.logical<4>> @@ -364,7 +364,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1_2:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0_3:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_13:[0-9]+]] = arith.subi %[[C_10_0]], %[[C_1_2]] : index -! CHECK: %[[V_14:[0-9]+]] = fir.do_loop %arg3 = %[[C_0_3]] to %[[V_13]] step %[[C_1_2]] unordered iter_args(%arg4 = %[[V_10]]) -> (!fir.array<10xf32>) { +! CHECK: %[[V_14:[0-9]+]] = fir.do_loop %arg3 = %[[C_0_3]] to %[[V_13]] step %[[C_1_2]] unordered iter_args(%arg4 = %[[V_10]]) -> (!fir.array<10xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[C_1_4:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_15:[0-9]+]] = arith.addi %arg3, %[[C_1_4]] : index ! CHECK: %[[V_16:[0-9]+]] = fir.array_coor %[[V_3]](%[[V_8]]) %[[V_15:[0-9]+]] : (!fir.heap>>, !fir.shape<1>, index) -> !fir.ref> @@ -403,7 +403,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[V_5:[0-9]+]] = fir.array_load %arg0(%[[V_4]]) : (!fir.ref>>, !fir.shape<1>) -> !fir.array<100x!fir.logical<4>> ! CHECK: %[[V_6:[0-9]+]] = fir.shape %[[C_100_0]] : (index) -> !fir.shape<1> ! CHECK: %[[V_7:[0-9]+]] = fir.array_load %arg1(%[[V_6]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array<100xi32> -! CHECK: %[[V_8:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_5]]) -> (!fir.array<100x!fir.logical<4>>) { +! CHECK: %[[V_8:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_5]]) -> (!fir.array<100x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_9:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_9]] to %[[V_1:[0-9]+]] : !fir.ref ! CHECK: %[[C_1_1:[-0-9a-z_]+]] = arith.constant 1 : index @@ -439,7 +439,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_4:[0-9]+]] = fir.shape %[[C_10]] : (index) -> !fir.shape<1> ! CHECK: %[[V_5:[0-9]+]] = fir.array_load %arg0(%[[V_4]]) : (!fir.ref>>, !fir.shape<1>) -> !fir.array<10x!fir.logical<4>> -! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_5]]) -> (!fir.array<10x!fir.logical<4>>) { +! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_5]]) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_7:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_7]] to %[[V_1:[0-9]+]] : !fir.ref ! CHECK: %[[V_8:[0-9]+]] = fir.call @_QPreturns_alloc(%[[V_1]]) fastmath : (!fir.ref) -> !fir.box> @@ -535,7 +535,7 @@ pure function returns_alloc(i) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_4:[0-9]+]] = fir.array_load %arg0 : (!fir.box>>) -> !fir.array> ! CHECK: %[[V_5:[0-9]+]] = fir.array_load %arg1 : (!fir.box>) -> !fir.array -! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_4]]) -> (!fir.array>) { +! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_4]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_7:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_7]] to %[[V_1:[0-9]+]] : !fir.ref ! CHECK: %[[C_1_0:[-0-9a-z_]+]] = arith.constant 1 : index @@ -565,7 +565,7 @@ pure function returns_alloc(i) ! CHECK: %[[C_1_4:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0_5:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_26:[0-9]+]] = arith.subi %[[V_20]], %[[C_1_4]] : index -! CHECK: %[[V_27:[0-9]+]] = fir.do_loop %arg4 = %[[C_0_5]] to %[[V_26]] step %[[C_1_4]] unordered iter_args(%arg5 = %arg3) -> (!fir.array>) { +! CHECK: %[[V_27:[0-9]+]] = fir.do_loop %arg4 = %[[C_0_5]] to %[[V_26]] step %[[C_1_4]] unordered iter_args(%arg5 = %arg3) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_28:[0-9]+]] = arith.subi %[[C_1_2]], %[[C_1_2]] : index ! CHECK: %[[V_29:[0-9]+]] = arith.muli %arg4, %[[V_25:[0-9]+]] : index ! CHECK: %[[V_30:[0-9]+]] = arith.addi %[[V_28]], %[[V_29:[0-9]+]] : index @@ -602,7 +602,7 @@ subroutine test_forall_array(x, y) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_3:[0-9]+]] = fir.array_load %arg0 : (!fir.box>) -> !fir.array ! CHECK: %[[V_4:[0-9]+]] = fir.array_load %arg1 : (!fir.box>>) -> !fir.array> -! CHECK: %[[V_5:[0-9]+]] = fir.do_loop %arg2 = %[[V_1]] to %[[V_2]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_3]]) -> (!fir.array) { +! CHECK: %[[V_5:[0-9]+]] = fir.do_loop %arg2 = %[[V_1]] to %[[V_2]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_3]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_6:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_6]] to %[[V_0:[0-9]+]] : !fir.ref ! CHECK: %[[C_1_0:[-0-9a-z_]+]] = arith.constant 1 : index @@ -641,7 +641,7 @@ subroutine test_forall_array(x, y) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_4:[0-9]+]] = fir.array_load %arg1 : (!fir.box>>) -> !fir.array> ! CHECK: %[[V_5:[0-9]+]] = fir.array_load %arg0 : (!fir.box>) -> !fir.array -! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_4]]) -> (!fir.array>) { +! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_4]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_7:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_7]] to %[[V_1:[0-9]+]] : !fir.ref ! CHECK: %[[C_1_0:[-0-9a-z_]+]] = arith.constant 1 : index @@ -701,7 +701,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_3:[0-9]+]] = fir.array_load %arg0 : (!fir.box>) -> !fir.array ! CHECK: %[[V_4:[0-9]+]] = fir.array_load %arg1 : (!fir.box>>) -> !fir.array> -! CHECK: %[[V_5:[0-9]+]] = fir.do_loop %arg2 = %[[V_1]] to %[[V_2]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_3]]) -> (!fir.array) { +! CHECK: %[[V_5:[0-9]+]] = fir.do_loop %arg2 = %[[V_1]] to %[[V_2]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_3]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_6:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_6]] to %[[V_0:[0-9]+]] : !fir.ref ! CHECK: %[[C_1_0:[-0-9a-z_]+]] = arith.constant 1 : index @@ -731,7 +731,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1_4:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0_5:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_25:[0-9]+]] = arith.subi %[[V_19]], %[[C_1_4]] : index -! CHECK: %[[V_26:[0-9]+]] = fir.do_loop %arg4 = %[[C_0_5]] to %[[V_25]] step %[[C_1_4]] unordered iter_args(%arg5 = %arg3) -> (!fir.array) { +! CHECK: %[[V_26:[0-9]+]] = fir.do_loop %arg4 = %[[C_0_5]] to %[[V_25]] step %[[C_1_4]] unordered iter_args(%arg5 = %arg3) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_27:[0-9]+]] = arith.subi %[[C_1_2]], %[[C_1_2]] : index ! CHECK: %[[V_28:[0-9]+]] = arith.muli %arg4, %[[V_24:[0-9]+]] : index ! CHECK: %[[V_29:[0-9]+]] = arith.addi %[[V_27]], %[[V_28:[0-9]+]] : index @@ -766,7 +766,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[V_4:[0-9]+]] = fir.array_load %arg1 : (!fir.box>>) -> !fir.array> ! CHECK: %[[V_5:[0-9]+]] = fir.array_load %arg0 : (!fir.box>) -> !fir.array -! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_4]]) -> (!fir.array>) { +! CHECK: %[[V_6:[0-9]+]] = fir.do_loop %arg2 = %[[V_2]] to %[[V_3]] step %[[C_1]] unordered iter_args(%arg3 = %[[V_4]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_7:[0-9]+]] = fir.convert %arg2 : (index) -> i32 ! CHECK: fir.store %[[V_7]] to %[[V_1:[0-9]+]] : !fir.ref ! CHECK: %[[C_1_0:[-0-9a-z_]+]] = arith.constant 1 : index @@ -796,7 +796,7 @@ elemental subroutine sto_char(a,b) ! CHECK: %[[C_1_4:[-0-9a-z_]+]] = arith.constant 1 : index ! CHECK: %[[C_0_5:[-0-9a-z_]+]] = arith.constant 0 : index ! CHECK: %[[V_26:[0-9]+]] = arith.subi %[[V_20]], %[[C_1_4]] : index -! CHECK: %[[V_27:[0-9]+]] = fir.do_loop %arg4 = %[[C_0_5]] to %[[V_26]] step %[[C_1_4]] unordered iter_args(%arg5 = %arg3) -> (!fir.array>) { +! CHECK: %[[V_27:[0-9]+]] = fir.do_loop %arg4 = %[[C_0_5]] to %[[V_26]] step %[[C_1_4]] unordered iter_args(%arg5 = %arg3) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_28:[0-9]+]] = arith.subi %[[C_1_2]], %[[C_1_2]] : index ! CHECK: %[[V_29:[0-9]+]] = arith.muli %arg4, %[[V_25:[0-9]+]] : index ! CHECK: %[[V_30:[0-9]+]] = arith.addi %[[V_28]], %[[V_29:[0-9]+]] : index diff --git a/flang/test/Lower/assignment.f90 b/flang/test/Lower/assignment.f90 index 6be53463a1c71..e75699e1dcd4c 100644 --- a/flang/test/Lower/assignment.f90 +++ b/flang/test/Lower/assignment.f90 @@ -336,7 +336,7 @@ subroutine sub2_arr(a) ! CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index ! CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index ! CHECK-DAG: %[[UB:.*]] = arith.subi %[[C10_0]], %c1 : index -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[ARG1:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG2:.*]] = %[[LOAD]]) -> (!fir.array<10xi32>) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[ARG1:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG2:.*]] = %[[LOAD]]) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[RES:.*]] = fir.array_update %[[ARG2]], %[[C10_1]], %[[ARG1]] : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32> ! CHECK: fir.result %[[RES]] : !fir.array<10xi32> ! CHECK: } diff --git a/flang/test/Lower/assumed-shape-caller.f90 b/flang/test/Lower/assumed-shape-caller.f90 index 5277dc76aa54b..54e93f5d48a59 100644 --- a/flang/test/Lower/assumed-shape-caller.f90 +++ b/flang/test/Lower/assumed-shape-caller.f90 @@ -76,7 +76,7 @@ subroutine takes_box(y) ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]] = arith.subi %[[VAL_9]], %[[VAL_14]] : index -! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_13]]) -> (!fir.array) { +! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_13]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_20:.*]] = fir.array_fetch %[[VAL_7]], %[[VAL_18]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> index ! CHECK: %[[VAL_22:.*]] = arith.subi %[[VAL_21]], %[[VAL_2]] : index diff --git a/flang/test/Lower/call-parenthesized-arg.f90 b/flang/test/Lower/call-parenthesized-arg.f90 index 2940ecfceb444..6a27fccb1d5db 100644 --- a/flang/test/Lower/call-parenthesized-arg.f90 +++ b/flang/test/Lower/call-parenthesized-arg.f90 @@ -61,7 +61,7 @@ subroutine foo_num_array(x) ! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_11:.*]] = arith.subi %[[VAL_3]], %[[VAL_9]] : index -! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_9]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_8]]) -> (!fir.array<100xi32>) { +! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_9]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_8]]) -> (!fir.array<100xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_15:.*]] = fir.array_fetch %[[VAL_5]], %[[VAL_13]] : (!fir.array<100xi32>, index) -> i32 ! CHECK: %[[VAL_16:.*]] = fir.no_reassoc %[[VAL_15]] : i32 ! CHECK: %[[VAL_17:.*]] = fir.array_update %[[VAL_14]], %[[VAL_16]], %[[VAL_13]] : (!fir.array<100xi32>, i32, index) -> !fir.array<100xi32> @@ -94,7 +94,7 @@ subroutine foo_char_array(x) ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]] = arith.subi %[[VAL_8]], %[[VAL_14]] : index - ! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_13]]) -> (!fir.array<100x!fir.char<1,10>>) { + ! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_13]]) -> (!fir.array<100x!fir.char<1,10>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_20:.*]] = fir.array_access %[[VAL_10]], %[[VAL_18]] : (!fir.array<100x!fir.char<1,10>>, index) -> !fir.ref> ! CHECK: %[[VAL_21:.*]] = fir.no_reassoc %[[VAL_20]] : !fir.ref> ! CHECK: %[[VAL_22:.*]] = fir.array_access %[[VAL_19]], %[[VAL_18]] : (!fir.array<100x!fir.char<1,10>>, index) -> !fir.ref> @@ -140,7 +140,7 @@ subroutine foo_num_array_box(x) ! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_6]], %[[VAL_12]] : index - ! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (!fir.array<100xi32>) { + ! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (!fir.array<100xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_18:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_16]] : (!fir.array<100xi32>, index) -> i32 ! CHECK: %[[VAL_19:.*]] = fir.no_reassoc %[[VAL_18]] : i32 ! CHECK: %[[VAL_20:.*]] = fir.array_update %[[VAL_17]], %[[VAL_19]], %[[VAL_16]] : (!fir.array<100xi32>, i32, index) -> !fir.array<100xi32> @@ -188,7 +188,7 @@ subroutine foo_char_array_box(x, n) ! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_16:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_17:.*]] = arith.subi %[[VAL_6]], %[[VAL_15]] : index - ! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_14]]) -> (!fir.array>) { + ! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_15]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_14]]) -> (!fir.array>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_21:.*]] = fir.array_access %[[VAL_11]], %[[VAL_19]] : (!fir.array>, index) -> !fir.ref> ! CHECK: %[[VAL_22:.*]] = fir.no_reassoc %[[VAL_21]] : !fir.ref> ! CHECK: %[[VAL_23:.*]] = fir.array_access %[[VAL_20]], %[[VAL_19]] : (!fir.array>, index) -> !fir.ref> diff --git a/flang/test/Lower/character-assignment.f90 b/flang/test/Lower/character-assignment.f90 index 1d873c0cfd02a..366336af11927 100644 --- a/flang/test/Lower/character-assignment.f90 +++ b/flang/test/Lower/character-assignment.f90 @@ -19,7 +19,7 @@ subroutine assign1(lhs, rhs) ! Padding ! CHECK-DAG: %[[blank:.*]] = fir.insert_value %{{.*}}, %c32{{.*}}, [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> - ! CHECK: fir.do_loop %[[ij:.*]] = + ! CHECK: fir.do_loop %[[ij:.*]] = %{{.*}} attributes ! CHECK-DAG: %[[lhs_cast:.*]] = fir.convert %[[lhs]]#0 ! CHECK: %[[lhs_addr:.*]] = fir.coordinate_of %[[lhs_cast]], %[[ij]] ! CHECK: fir.store %[[blank]] to %[[lhs_addr]] @@ -76,7 +76,7 @@ subroutine assign_constant(lhs) ! Padding ! CHECK-DAG: %[[blank:.*]] = fir.insert_value %{{.*}}, %c32{{.*}}, [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> - ! CHECK: fir.do_loop %[[j:.*]] = %{{.*}} to %{{.*}} { + ! CHECK: fir.do_loop %[[j:.*]] = %{{.*}} to %{{.*}} attributes {operandSegmentSizes = array} { ! CHECK-DAG: %[[jhs_cast:.*]] = fir.convert %[[lhs]]#0 : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[jhs_addr:.*]] = fir.coordinate_of %[[jhs_cast]], %[[j]] ! CHECK: fir.store %[[blank]] to %[[jhs_addr]] @@ -92,8 +92,8 @@ subroutine assign_zero_size_array(n) ! CHECK: %[[VAL_1:.*]] = arith.cmpi ne, %{{.*}}, %c0{{.*}} : i64 ! CHECK: %[[VAL_2:.*]]:2 = fir.if %[[VAL_1]] -> (i1, !fir.heap>>) { ! CHECK: %{{.*}} = fir.if %{{.*}} -> (!fir.heap>>) { - ! CHECK: %{{.*}} = fir.do_loop %{{.*}} = %c0{{.*}} to %{{.*}} step %c1{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array>) { - ! CHECK: fir.do_loop %[[ARG_0:.*]] = %{{.*}} to {{.*}} step %c1{{.*}} { + ! CHECK: %{{.*}} = fir.do_loop %{{.*}} = %c0{{.*}} to %{{.*}} step %c1{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array>) attributes {operandSegmentSizes = array} { + ! CHECK: fir.do_loop %[[ARG_0:.*]] = %{{.*}} to {{.*}} step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %{{.*}} = fir.coordinate_of %{{.*}}, %[[ARG_0]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.if %[[VAL_2]]#0 { ! CHECK: fir.if %[[VAL_1]] { diff --git a/flang/test/Lower/character-concatenation.f90 b/flang/test/Lower/character-concatenation.f90 index ae55b93902bb0..221a5e702a3e2 100644 --- a/flang/test/Lower/character-concatenation.f90 +++ b/flang/test/Lower/character-concatenation.f90 @@ -25,7 +25,7 @@ subroutine concat_1(a, b) ! CHECK: %[[c1_0:.*]] = arith.constant 1 ! CHECK: %[[count2:.*]] = arith.subi %[[len]], %[[c1_0]] - ! CHECK: fir.do_loop %[[index2:.*]] = %[[a]]#1 to %[[count2]] step %[[c1_0]] { + ! CHECK: fir.do_loop %[[index2:.*]] = %[[a]]#1 to %[[count2]] step %[[c1_0]] attributes {operandSegmentSizes = array} { ! CHECK: %[[b_index:.*]] = arith.subi %[[index2]], %[[a]]#1 ! CHECK: %[[b_cast:.*]] = fir.convert %[[b]]#0 ! CHECK: %[[b_addr:.*]] = fir.coordinate_of %[[b_cast]], %[[b_index]] diff --git a/flang/test/Lower/character-substrings.f90 b/flang/test/Lower/character-substrings.f90 index 874f2944cff19..0259e8b4fab1a 100644 --- a/flang/test/Lower/character-substrings.f90 +++ b/flang/test/Lower/character-substrings.f90 @@ -116,7 +116,7 @@ subroutine substring_assignment(a,b) ! CHECK: %[[VAL_45:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_46:.*]] = fir.insert_value %[[VAL_45]], %[[VAL_44]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_47:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_48:.*]] = %[[VAL_35]] to %[[VAL_43]] step %[[VAL_47]] { +! CHECK: fir.do_loop %[[VAL_48:.*]] = %[[VAL_35]] to %[[VAL_43]] step %[[VAL_47]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_49:.*]] = fir.convert %[[VAL_28]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_50:.*]] = fir.coordinate_of %[[VAL_49]], %[[VAL_48]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_46]] to %[[VAL_50]] : !fir.ref> @@ -152,7 +152,7 @@ end subroutine substring_assignment ! CHECK: %[[VAL_20:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_21:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_22:.*]] = arith.subi %[[VAL_14]], %[[VAL_20]] : index -! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_21]] to %[[VAL_22]] step %[[VAL_20]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_17]]) -> (!fir.array<6x!fir.char<1,5>>) { +! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_21]] to %[[VAL_22]] step %[[VAL_20]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_17]]) -> (!fir.array<6x!fir.char<1,5>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_26:.*]] = fir.array_access %[[VAL_25]], %[[VAL_24]] : (!fir.array<6x!fir.char<1,5>>, index) -> !fir.ref> ! CHECK: %[[VAL_27:.*]] = arith.constant 3 : i64 ! CHECK: %[[VAL_28:.*]] = arith.constant 5 : i64 @@ -172,7 +172,7 @@ end subroutine substring_assignment ! CHECK: %[[VAL_42:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_40]] : (index) -> index ! CHECK: %[[VAL_44:.*]] = arith.subi %[[VAL_43]], %[[VAL_42]] : index -! CHECK: fir.do_loop %[[VAL_45:.*]] = %[[VAL_41]] to %[[VAL_44]] step %[[VAL_42]] { +! CHECK: fir.do_loop %[[VAL_45:.*]] = %[[VAL_41]] to %[[VAL_44]] step %[[VAL_42]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_19]] : (index) -> index ! CHECK: %[[VAL_47:.*]] = arith.cmpi slt, %[[VAL_45]], %[[VAL_46]] : index ! CHECK: fir.if %[[VAL_47]] { @@ -204,7 +204,7 @@ end subroutine substring_assignment ! CHECK: %[[VAL_67:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_68:.*]] = fir.insert_value %[[VAL_67]], %[[VAL_66]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_69:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_70:.*]] = %[[VAL_57]] to %[[VAL_65]] step %[[VAL_69]] { +! CHECK: fir.do_loop %[[VAL_70:.*]] = %[[VAL_57]] to %[[VAL_65]] step %[[VAL_69]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_71:.*]] = fir.convert %[[VAL_35]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_72:.*]] = fir.coordinate_of %[[VAL_71]], %[[VAL_70]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_68]] to %[[VAL_72]] : !fir.ref> @@ -240,7 +240,7 @@ end subroutine array_substring_assignment ! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_11:.*]] = arith.subi %[[select]], %[[VAL_9]] : index -! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_9]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_6]]) -> (!fir.array<8x!fir.char<1,7>>) { +! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_9]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_6]]) -> (!fir.array<8x!fir.char<1,7>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_15:.*]] = fir.array_access %[[VAL_14]], %[[VAL_13]] : (!fir.array<8x!fir.char<1,7>>, index) -> !fir.ref> ! CHECK: %[[VAL_16:.*]] = arith.constant 4 : i64 ! CHECK: %[[VAL_17:.*]] = arith.constant 7 : i64 @@ -260,7 +260,7 @@ end subroutine array_substring_assignment ! CHECK: %[[VAL_31:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_29]] : (index) -> index ! CHECK: %[[VAL_33:.*]] = arith.subi %[[VAL_32]], %[[VAL_31]] : index -! CHECK: fir.do_loop %[[VAL_34:.*]] = %[[VAL_30]] to %[[VAL_33]] step %[[VAL_31]] { +! CHECK: fir.do_loop %[[VAL_34:.*]] = %[[VAL_30]] to %[[VAL_33]] step %[[VAL_31]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_8]] : (index) -> index ! CHECK: %[[VAL_36:.*]] = arith.cmpi slt, %[[VAL_34]], %[[VAL_35]] : index ! CHECK: fir.if %[[VAL_36]] { @@ -292,7 +292,7 @@ end subroutine array_substring_assignment ! CHECK: %[[VAL_56:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_57:.*]] = fir.insert_value %[[VAL_56]], %[[VAL_55]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_58:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_59:.*]] = %[[VAL_46]] to %[[VAL_54]] step %[[VAL_58]] { +! CHECK: fir.do_loop %[[VAL_59:.*]] = %[[VAL_46]] to %[[VAL_54]] step %[[VAL_58]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_24]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_61:.*]] = fir.coordinate_of %[[VAL_60]], %[[VAL_59]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_57]] to %[[VAL_61]] : !fir.ref> @@ -335,7 +335,7 @@ end subroutine array_substring_assignment2 ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]] = arith.subi %[[select]], %[[VAL_14]] : index -! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_8]]) -> (!fir.array<8x!fir.char<1,7>>) { +! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_14]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_8]]) -> (!fir.array<8x!fir.char<1,7>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_20:.*]] = fir.array_access %[[VAL_13]], %[[VAL_18]] : (!fir.array<8x!fir.char<1,7>>, index) -> !fir.ref> ! CHECK: %[[VAL_21:.*]] = arith.constant 2 : i64 ! CHECK: %[[VAL_22:.*]] = arith.constant 5 : i64 @@ -370,7 +370,7 @@ end subroutine array_substring_assignment2 ! CHECK: %[[VAL_51:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_49]] : (index) -> index ! CHECK: %[[VAL_53:.*]] = arith.subi %[[VAL_52]], %[[VAL_51]] : index -! CHECK: fir.do_loop %[[VAL_54:.*]] = %[[VAL_50]] to %[[VAL_53]] step %[[VAL_51]] { +! CHECK: fir.do_loop %[[VAL_54:.*]] = %[[VAL_50]] to %[[VAL_53]] step %[[VAL_51]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_34]] : (index) -> index ! CHECK: %[[VAL_56:.*]] = arith.cmpi slt, %[[VAL_54]], %[[VAL_55]] : index ! CHECK: fir.if %[[VAL_56]] { @@ -402,7 +402,7 @@ end subroutine array_substring_assignment2 ! CHECK: %[[VAL_76:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_77:.*]] = fir.insert_value %[[VAL_76]], %[[VAL_75]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_78:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_79:.*]] = %[[VAL_66]] to %[[VAL_74]] step %[[VAL_78]] { +! CHECK: fir.do_loop %[[VAL_79:.*]] = %[[VAL_66]] to %[[VAL_74]] step %[[VAL_78]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_80:.*]] = fir.convert %[[VAL_44]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_81:.*]] = fir.coordinate_of %[[VAL_80]], %[[VAL_79]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_77]] to %[[VAL_81]] : !fir.ref> diff --git a/flang/test/Lower/cray-pointer.f90 b/flang/test/Lower/cray-pointer.f90 index 06910bce35a14..555885a090353 100644 --- a/flang/test/Lower/cray-pointer.f90 +++ b/flang/test/Lower/cray-pointer.f90 @@ -289,7 +289,7 @@ subroutine cray_array() ! CHECK: %[[c1:.*]] = arith.constant 1 : index ! CHECK: %[[c0:.*]] = arith.constant 0 : index ! CHECK: %[[sub:.*]] = arith.subi %[[c3]], %[[c1]] : index -! CHECK: %[[doloop:.*]] = fir.do_loop %arg0 = %[[c0]] to %[[sub]] step %[[c1]] unordered iter_args(%arg1 = %[[arrayld1]]) -> (!fir.array<3xi32>) { +! CHECK: %[[doloop:.*]] = fir.do_loop %arg0 = %[[c0]] to %[[sub]] step %[[c1]] unordered iter_args(%arg1 = %[[arrayld1]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[arrayfetch:.*]] = fir.array_fetch %[[arrayld]], %arg0 : (!fir.array<3xi32>, index) -> i32 ! CHECK: %[[arrayupdate:.*]] = fir.array_update %arg1, %[[arrayfetch]], %arg0 : (!fir.array<3xi32>, i32, index) -> !fir.array<3xi32> ! CHECK: fir.result %[[arrayupdate]] : !fir.array<3xi32> @@ -308,7 +308,7 @@ subroutine cray_array() ! CHECK: %[[c1:.*]] = arith.constant 1 : index ! CHECK: %[[c0:.*]] = arith.constant 0 : index ! CHECK: %[[sub1:.*]] = arith.subi %[[c31]], %[[c1]] : index -! CHECK: %[[doloop:.*]] = fir.do_loop %arg0 = %[[c0]] to %[[sub1]] step %[[c1]] unordered iter_args(%arg1 = %[[arrayld]]) -> (!fir.array<3xi32>) { +! CHECK: %[[doloop:.*]] = fir.do_loop %arg0 = %[[c0]] to %[[sub1]] step %[[c1]] unordered iter_args(%arg1 = %[[arrayld]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[arrayupdate:.*]] = fir.array_update %arg1, %[[c2n]], %arg0 : (!fir.array<3xi32>, i32, index) -> !fir.array<3xi32> ! CHECK: fir.result %[[arrayupdate]] : !fir.array<3xi32> ! CHECK: fir.array_merge_store %[[arrayld]], %[[doloop]] to %[[ld]] : !fir.array<3xi32>, !fir.array<3xi32>, !fir.ptr> @@ -359,7 +359,7 @@ subroutine cray_arraySection() ! CHECK: %[[c1_3:.*]] = arith.constant 1 : index ! CHECK: %[[c0_4:.*]] = arith.constant 0 : index ! CHECK: %[[sub:.*]] = arith.subi %[[c2]], %[[c1_3]] : index -! CHECK: %[[doloop:.*]] = fir.do_loop %arg0 = %[[c0_4]] to %[[sub]] step %[[c1_3]] unordered iter_args(%arg1 = %[[arrayld1]]) -> (!fir.array<2xi32>) { +! CHECK: %[[doloop:.*]] = fir.do_loop %arg0 = %[[c0_4]] to %[[sub]] step %[[c1_3]] unordered iter_args(%arg1 = %[[arrayld1]]) -> (!fir.array<2xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[arrayfetch:.*]] = fir.array_fetch %[[arrayld]], %arg0 : (!fir.array<3xi32>, index) -> i32 ! CHECK: %[[arrayupdate:.*]] = fir.array_update %arg1, %[[arrayfetch]], %arg0 : (!fir.array<2xi32>, i32, index) -> !fir.array<2xi32> ! CHECK: fir.result %[[arrayupdate]] : !fir.array<2xi32> @@ -391,7 +391,7 @@ subroutine cray_arraySection() ! CHECK: %[[c1_9:.*]] = arith.constant 1 : index ! CHECK: %[[c0_8:.*]] = arith.constant 0 : index ! CHECK: %[[sub1:.*]] = arith.subi %[[sel]], %[[c1_9]] : index -! CHECK: %[[doloop:.*]] = fir.do_loop %arg0 = %[[c0_8]] to %[[sub1]] step %[[c1_9]] unordered iter_args(%arg1 = %[[arrayld]]) -> (!fir.array<3xi32>) { +! CHECK: %[[doloop:.*]] = fir.do_loop %arg0 = %[[c0_8]] to %[[sub1]] step %[[c1_9]] unordered iter_args(%arg1 = %[[arrayld]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[arrayupdate:.*]] = fir.array_update %arg1, %[[c2n]], %arg0 : (!fir.array<3xi32>, i32, index) -> !fir.array<3xi32> ! CHECK: fir.result %[[arrayupdate]] : !fir.array<3xi32> ! CHECK: fir.array_merge_store %[[arrayld]], %[[doloop]] to %[[ld]][%[[slice]]] : !fir.array<3xi32>, !fir.array<3xi32>, !fir.ptr>, !fir.slice<1> diff --git a/flang/test/Lower/derived-assignments.f90 b/flang/test/Lower/derived-assignments.f90 index c3ceacd4abd69..e4ca371c0bd0c 100644 --- a/flang/test/Lower/derived-assignments.f90 +++ b/flang/test/Lower/derived-assignments.f90 @@ -115,7 +115,7 @@ subroutine test_array_comp(t1, t2) ! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_7:.*]] = arith.constant 9 : index - ! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_6]] { + ! CHECK: fir.do_loop %[[VAL_8:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_6]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_9:.*]] = fir.coordinate_of %[[VAL_4]], %[[VAL_8]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[VAL_10:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_8]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_10]] : !fir.ref diff --git a/flang/test/Lower/do_loop.f90 b/flang/test/Lower/do_loop.f90 index a46e6c947391b..2376897b4edd0 100644 --- a/flang/test/Lower/do_loop.f90 +++ b/flang/test/Lower/do_loop.f90 @@ -23,7 +23,7 @@ subroutine simple_loop ! CHECK: %[[LI_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! NSW: %[[LI_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! CHECK-SAME: %[[C1_CVT]] to %[[C5_CVT]] step %[[C1]] - ! CHECK-SAME: iter_args(%[[IV:.*]] = %[[LB]]) -> (index, i32) { + ! CHECK-SAME: iter_args(%[[IV:.*]] = %[[LB]]) -> (index, i32) attributes {operandSegmentSizes = array} { do i=1,5 ! CHECK: fir.store %[[IV]] to %[[I_REF]] : !fir.ref ! CHECK: %[[LI_NEXT:.*]] = arith.addi %[[LI]], %[[C1]] : index @@ -64,7 +64,7 @@ subroutine nested_loop ! CHECK: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! NSW: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! CHECK-SAME: %[[S_I_CVT]] to %[[E_I_CVT]] step %[[ST_I]] - ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) { + ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) attributes {operandSegmentSizes = array} { do i=1,5 ! CHECK: fir.store %[[I_IV]] to %[[I_REF]] : !fir.ref ! CHECK: %[[S_J:.*]] = arith.constant 1 : i32 @@ -76,7 +76,7 @@ subroutine nested_loop ! CHECK: %[[J_RES:.*]]:2 = fir.do_loop %[[LJ:[^ ]*]] = ! NSW: %[[J_RES:.*]]:2 = fir.do_loop %[[LJ:[^ ]*]] = ! CHECK-SAME: %[[S_J_CVT]] to %[[E_J_CVT]] step %[[ST_J]] - ! CHECK-SAME: iter_args(%[[J_IV:.*]] = %[[J_LB]]) -> (index, i32) { + ! CHECK-SAME: iter_args(%[[J_IV:.*]] = %[[J_LB]]) -> (index, i32) attributes {operandSegmentSizes = array} { do j=1,5 ! CHECK: fir.store %[[J_IV]] to %[[J_REF]] : !fir.ref ! CHECK: %[[ASUM:.*]] = fir.load %[[ASUM_REF]] : !fir.ref @@ -135,7 +135,7 @@ subroutine down_counting_loop() ! CHECK: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! NSW: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! CHECK-SAME: %[[C5_CVT]] to %[[C1_CVT]] step %[[CMINUS1_STEP_CVT]] - ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) { + ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) attributes {operandSegmentSizes = array} { do i=5,1,-1 ! CHECK: fir.store %[[I_IV]] to %[[I_REF]] : !fir.ref ! CHECK: %[[LI_NEXT:.*]] = arith.addi %[[LI]], %[[CMINUS1_STEP_CVT]] : index @@ -168,7 +168,7 @@ subroutine loop_with_variable_step(s,e,st) ! CHECK: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! NSW: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! CHECK-SAME: %[[S_CVT]] to %[[E_CVT]] step %[[ST_CVT]] - ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) { + ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) attributes {operandSegmentSizes = array} { do i=s,e,st ! CHECK: fir.store %[[I_IV]] to %[[I_REF]] : !fir.ref ! CHECK: %[[LI_NEXT:.*]] = arith.addi %[[LI]], %[[ST_CVT]] : index @@ -227,7 +227,7 @@ subroutine loop_with_pointer_variables(s,e,st) ! CHECK: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! NSW: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! CHECK-SAME: %[[S_CVT]] to %[[E_CVT]] step %[[ST_CVT]] -! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) { +! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) attributes {operandSegmentSizes = array} { do iptr=sptr,eptr,stptr ! CHECK: fir.store %[[I_IV]] to %[[I_PTR]] : !fir.ptr ! CHECK: %[[LI_NEXT:.*]] = arith.addi %[[LI]], %[[ST_CVT]] : index @@ -263,7 +263,7 @@ subroutine loop_with_non_default_integer(s,e,st) ! CHECK: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! NSW: %[[I_RES:.*]]:2 = fir.do_loop %[[LI:[^ ]*]] = ! CHECK-SAME: %[[S_CVT]] to %[[E_CVT]] step %[[ST_CVT]] - ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i64) { + ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i64) attributes {operandSegmentSizes = array} { do i=s,e,st ! CHECK: fir.store %[[I_IV]] to %[[I_REF]] : !fir.ref ! CHECK: %[[LI_NEXT:.*]] = arith.addi %[[LI]], %[[ST_CVT]] : index diff --git a/flang/test/Lower/do_loop_unstructured.f90 b/flang/test/Lower/do_loop_unstructured.f90 index e1a669e09c9a8..e814a6b76d25d 100644 --- a/flang/test/Lower/do_loop_unstructured.f90 +++ b/flang/test/Lower/do_loop_unstructured.f90 @@ -357,7 +357,7 @@ subroutine nested_structured_in_unstructured() ! CHECK: ^[[BODY]]: ! CHECK: %{{.*}} = fir.do_loop %[[J_INDEX:[^ ]*]] = ! CHECK-SAME: %{{.*}} to %{{.*}} step %[[ST:[^ ]*]] -! CHECK-SAME: iter_args(%[[J_IV:.*]] = %{{.*}}) -> (index, i32) { +! CHECK-SAME: iter_args(%[[J_IV:.*]] = %{{.*}}) -> (index, i32) {{.*}} { ! CHECK: fir.store %[[J_IV]] to %[[LOOP_VAR_J_REF]] : !fir.ref ! CHECK: %[[J_INDEX_NEXT:.*]] = arith.addi %[[J_INDEX]], %[[ST]] : index ! CHECK: %[[LOOP_VAR_J:.*]] = fir.load %[[LOOP_VAR_J_REF]] : !fir.ref @@ -396,7 +396,7 @@ subroutine nested_structured_in_unstructured() ! NSW: ^[[BODY]]: ! NSW: %{{.*}} = fir.do_loop %[[J_INDEX:[^ ]*]] = ! NSW-SAME: %{{.*}} to %{{.*}} step %[[ST:[^ ]*]] -! NSW-SAME: iter_args(%[[J_IV:.*]] = %{{.*}}) -> (index, i32) { +! NSW-SAME: iter_args(%[[J_IV:.*]] = %{{.*}}) -> (index, i32) {{.*}} { ! NSW: fir.store %[[J_IV]] to %[[LOOP_VAR_J_REF]] : !fir.ref ! NSW: %[[J_INDEX_NEXT:.*]] = arith.addi %[[J_INDEX]], %[[ST]] overflow : index ! NSW: %[[LOOP_VAR_J:.*]] = fir.load %[[LOOP_VAR_J_REF]] : !fir.ref diff --git a/flang/test/Lower/dummy-argument-contiguous.f90 b/flang/test/Lower/dummy-argument-contiguous.f90 index 118370cef9aa4..ba5f396ad3cac 100644 --- a/flang/test/Lower/dummy-argument-contiguous.f90 +++ b/flang/test/Lower/dummy-argument-contiguous.f90 @@ -80,11 +80,11 @@ subroutine test_assign_in_array_ref(x, y) real :: y(:) x = 42. ! CHECK: %[[xload:.*]] = fir.array_load %[[xaddr]]({{.*}}) : (!fir.ref>, !fir.shapeshift<1>) -> !fir.array - ! CHECK: %[[xloop:.*]] = fir.do_loop {{.*}} iter_args(%arg3 = %[[xload]]) -> (!fir.array) + ! CHECK: %[[xloop:.*]] = fir.do_loop {{.*}} iter_args(%arg3 = %[[xload]]) -> (!fir.array) attributes {operandSegmentSizes = array} ! CHECK: fir.array_merge_store %[[xload]], %[[xloop]] to %[[xaddr]] : !fir.array, !fir.array, !fir.ref> y = 42. ! CHECK: %[[yload:.*]] = fir.array_load %arg1 : (!fir.box>) -> !fir.array - ! CHECK: %[[yloop:.*]] = fir.do_loop {{.*}} iter_args(%arg3 = %[[yload]]) -> (!fir.array) { + ! CHECK: %[[yloop:.*]] = fir.do_loop {{.*}} iter_args(%arg3 = %[[yload]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: fir.array_merge_store %[[yload]], %[[yloop]] to %arg1 : !fir.array, !fir.array, !fir.box> end subroutine diff --git a/flang/test/Lower/entry-statement.f90 b/flang/test/Lower/entry-statement.f90 index 0ec650f8699a5..cf1d613aedf6a 100644 --- a/flang/test/Lower/entry-statement.f90 +++ b/flang/test/Lower/entry-statement.f90 @@ -376,7 +376,7 @@ subroutine s2 ! CHECK: %[[V_10:[0-9]+]] = arith.subi %[[V_2]]#1, %c1{{.*}} : index ! CHECK: %[[V_11:[0-9]+]] = fir.undefined !fir.char<1> ! CHECK: %[[V_12:[0-9]+]] = fir.insert_value %[[V_11]], %c32{{.*}}_i8, [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> - ! CHECK: fir.do_loop %arg1 = %[[V_5]] to %[[V_10]] step %c1{{.*}} { + ! CHECK: fir.do_loop %arg1 = %[[V_5]] to %[[V_10]] step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_13:[0-9]+]] = fir.convert %[[V_2]]#0 : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[V_14:[0-9]+]] = fir.coordinate_of %[[V_13]], %arg1 : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[V_12]] to %[[V_14]] : !fir.ref> @@ -402,7 +402,7 @@ subroutine s3 ! CHECK: %[[V_10:[0-9]+]] = arith.subi %[[V_2]]#1, %c1{{.*}} : index ! CHECK: %[[V_11:[0-9]+]] = fir.undefined !fir.char<1> ! CHECK: %[[V_12:[0-9]+]] = fir.insert_value %[[V_11]], %c32{{.*}}_i8, [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> - ! CHECK: fir.do_loop %arg1 = %[[V_5]] to %[[V_10]] step %c1{{.*}} { + ! CHECK: fir.do_loop %arg1 = %[[V_5]] to %[[V_10]] step %c1{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[V_13:[0-9]+]] = fir.convert %[[V_2]]#0 : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[V_14:[0-9]+]] = fir.coordinate_of %[[V_13]], %arg1 : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[V_12]] to %[[V_14]] : !fir.ref> diff --git a/flang/test/Lower/forall/array-constructor.f90 b/flang/test/Lower/forall/array-constructor.f90 index ad21ed33fba2d..379fda9d8e0aa 100644 --- a/flang/test/Lower/forall/array-constructor.f90 +++ b/flang/test/Lower/forall/array-constructor.f90 @@ -25,7 +25,7 @@ end subroutine ac1 ! CHECK: %[[VAL_9:.*]] = arith.constant 2 : i32 ! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i32) -> index ! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_10]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_11]]) -> (!fir.array) { +! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_10]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_11]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_13]] : (index) -> i32 ! CHECK: fir.store %[[VAL_15]] to %[[VAL_4]] : !fir.ref ! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index @@ -86,7 +86,7 @@ end subroutine ac1 ! CHECK: %[[VAL_63:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_64:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_65:.*]] = arith.subi %[[VAL_33]], %[[VAL_63]] : index -! CHECK: %[[VAL_66:.*]] = fir.do_loop %[[VAL_67:.*]] = %[[VAL_64]] to %[[VAL_65]] step %[[VAL_63]] unordered iter_args(%[[VAL_68:.*]] = %[[VAL_62]]) -> (!fir.array<1xi32>) { +! CHECK: %[[VAL_66:.*]] = fir.do_loop %[[VAL_67:.*]] = %[[VAL_64]] to %[[VAL_65]] step %[[VAL_63]] unordered iter_args(%[[VAL_68:.*]] = %[[VAL_62]]) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_69:.*]] = fir.array_fetch %[[VAL_59]], %[[VAL_67]] : (!fir.array<1xi32>, index) -> i32 ! CHECK: %[[VAL_70:.*]] = fir.array_update %[[VAL_68]], %[[VAL_69]], %[[VAL_67]] : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> ! CHECK: fir.result %[[VAL_70]] : !fir.array<1xi32> @@ -99,7 +99,7 @@ end subroutine ac1 ! CHECK: %[[VAL_76:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_77:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_78:.*]] = arith.subi %[[VAL_32]], %[[VAL_76]] : index -! CHECK: %[[VAL_79:.*]] = fir.do_loop %[[VAL_80:.*]] = %[[VAL_77]] to %[[VAL_78]] step %[[VAL_76]] unordered iter_args(%[[VAL_81:.*]] = %[[VAL_14]]) -> (!fir.array) { +! CHECK: %[[VAL_79:.*]] = fir.do_loop %[[VAL_80:.*]] = %[[VAL_77]] to %[[VAL_78]] step %[[VAL_76]] unordered iter_args(%[[VAL_81:.*]] = %[[VAL_14]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_82:.*]] = arith.subi %[[VAL_19]], %[[VAL_16]] : index ! CHECK: %[[VAL_83:.*]] = arith.muli %[[VAL_80]], %[[VAL_21]] : index ! CHECK: %[[VAL_84:.*]] = arith.addi %[[VAL_82]], %[[VAL_83]] : index @@ -154,7 +154,7 @@ end subroutine ac2 ! CHECK: %[[VAL_10:.*]] = arith.constant 2 : i32 ! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i32) -> index ! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_11]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (!fir.array) { +! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_11]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32 ! CHECK: fir.store %[[VAL_16]] to %[[VAL_5]] : !fir.ref ! CHECK: %[[VAL_17:.*]] = arith.constant 1 : index @@ -215,7 +215,7 @@ end subroutine ac2 ! CHECK: %[[VAL_64:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_65:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_66:.*]] = arith.subi %[[VAL_34]], %[[VAL_64]] : index -! CHECK: %[[VAL_67:.*]] = fir.do_loop %[[VAL_68:.*]] = %[[VAL_65]] to %[[VAL_66]] step %[[VAL_64]] unordered iter_args(%[[VAL_69:.*]] = %[[VAL_63]]) -> (!fir.array<1xi32>) { +! CHECK: %[[VAL_67:.*]] = fir.do_loop %[[VAL_68:.*]] = %[[VAL_65]] to %[[VAL_66]] step %[[VAL_64]] unordered iter_args(%[[VAL_69:.*]] = %[[VAL_63]]) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_70:.*]] = fir.array_fetch %[[VAL_60]], %[[VAL_68]] : (!fir.array<1xi32>, index) -> i32 ! CHECK: %[[VAL_71:.*]] = fir.array_update %[[VAL_69]], %[[VAL_70]], %[[VAL_68]] : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> ! CHECK: fir.result %[[VAL_71]] : !fir.array<1xi32> @@ -242,7 +242,7 @@ end subroutine ac2 ! CHECK: %[[VAL_87:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_88:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_89:.*]] = arith.subi %[[VAL_33]], %[[VAL_87]] : index -! CHECK: %[[VAL_90:.*]] = fir.do_loop %[[VAL_91:.*]] = %[[VAL_88]] to %[[VAL_89]] step %[[VAL_87]] unordered iter_args(%[[VAL_92:.*]] = %[[VAL_15]]) -> (!fir.array) { +! CHECK: %[[VAL_90:.*]] = fir.do_loop %[[VAL_91:.*]] = %[[VAL_88]] to %[[VAL_89]] step %[[VAL_87]] unordered iter_args(%[[VAL_92:.*]] = %[[VAL_15]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_93:.*]] = fir.array_fetch %[[VAL_86]], %[[VAL_91]] : (!fir.array<3xi32>, index) -> i32 ! CHECK: %[[VAL_94:.*]] = arith.subi %[[VAL_20]], %[[VAL_17]] : index ! CHECK: %[[VAL_95:.*]] = arith.muli %[[VAL_91]], %[[VAL_22]] : index @@ -276,7 +276,7 @@ end subroutine ac2 ! CHECK: %[[VAL_13:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_15:.*]] = arith.subi %[[VAL_1]], %[[VAL_13]] : index -! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_13]] unordered iter_args(%[[VAL_18:.*]] = %[[VAL_4]]) -> (!fir.array<3xi32>) { +! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_13]] unordered iter_args(%[[VAL_18:.*]] = %[[VAL_4]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = fir.array_fetch %[[VAL_12]], %[[VAL_17]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_20:.*]] = fir.array_update %[[VAL_18]], %[[VAL_19]], %[[VAL_17]] : (!fir.array<3xi32>, i32, index) -> !fir.array<3xi32> ! CHECK: fir.result %[[VAL_20]] : !fir.array<3xi32> diff --git a/flang/test/Lower/forall/array-pointer.f90 b/flang/test/Lower/forall/array-pointer.f90 index 1e8f7a6a55002..f3fd8f2430a6e 100644 --- a/flang/test/Lower/forall/array-pointer.f90 +++ b/flang/test/Lower/forall/array-pointer.f90 @@ -67,7 +67,7 @@ end subroutine s1 ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_8:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>}>>>) -> !fir.array>}>> ! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array>}>>) { +! CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_11]] : (index) -> i32 ! CHECK: fir.store %[[VAL_13]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index @@ -119,7 +119,7 @@ end subroutine s1_1 ! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_0]](%[[VAL_10]]) : (!fir.ref>}>>>, !fir.shape<1>) -> !fir.array<10x!fir.type<_QMarray_of_pointer_testTt{ip:!fir.box>}>> ! CHECK: %[[VAL_12:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_13:.*]] = fir.array_load %[[VAL_1]](%[[VAL_12]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array<10xi32> -! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_9]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_11]]) -> (!fir.array<10x!fir.type<_QMarray_of_pointer_testTt{ip:!fir.box>}>>) { +! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_9]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_11]]) -> (!fir.array<10x!fir.type<_QMarray_of_pointer_testTt{ip:!fir.box>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_15]] : (index) -> i32 ! CHECK: fir.store %[[VAL_17]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_18:.*]] = arith.constant 1 : index @@ -179,7 +179,7 @@ end subroutine s2 ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_8:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>}>>>) -> !fir.array>}>> ! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array>}>>) { +! CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_11]] : (index) -> i32 ! CHECK: fir.store %[[VAL_13]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index @@ -229,7 +229,7 @@ end subroutine s2_1 ! CHECK: %[[VAL_11:.*]]:3 = fir.box_dims %[[VAL_9]], %[[VAL_10]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_12:.*]] = fir.shift %[[VAL_11]]#0 : (index) -> !fir.shift<1> ! CHECK: %[[VAL_13:.*]] = fir.array_load %[[VAL_9]](%[[VAL_12]]) : (!fir.box>>, !fir.shift<1>) -> !fir.array -! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_8]]) -> (!fir.array>}>>) { +! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_8]]) -> (!fir.array>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_15]] : (index) -> i32 ! CHECK: fir.store %[[VAL_17]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_2]] : !fir.ref @@ -279,7 +279,7 @@ end subroutine s2_2 ! CHECK: %[[VAL_12:.*]] = fir.box_addr %[[VAL_9]] : (!fir.box>>) -> !fir.heap> ! CHECK: %[[VAL_13:.*]] = fir.shape_shift %[[VAL_11]]#0, %[[VAL_11]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_14:.*]] = fir.array_load %[[VAL_12]](%[[VAL_13]]) : (!fir.heap>, !fir.shapeshift<1>) -> !fir.array -! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_8]]) -> (!fir.array>}>>) { +! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_8]]) -> (!fir.array>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_16]] : (index) -> i32 ! CHECK: fir.store %[[VAL_18]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_19:.*]] = fir.load %[[VAL_2]] : !fir.ref @@ -335,7 +335,7 @@ end subroutine s2_3 ! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_3]] : !fir.ref>> ! CHECK: %[[VAL_16:.*]] = fir.shape_shift %[[VAL_13]], %[[VAL_14]] : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_17:.*]] = fir.array_load %[[VAL_15]](%[[VAL_16]]) : (!fir.heap>, !fir.shapeshift<1>) -> !fir.array -! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_11]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_12]]) -> (!fir.array>}>>) { +! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_11]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_12]]) -> (!fir.array>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_19]] : (index) -> i32 ! CHECK: fir.store %[[VAL_21]] to %[[VAL_1]] : !fir.ref ! CHECK: %[[VAL_22:.*]] = fir.load %[[VAL_1]] : !fir.ref @@ -392,7 +392,7 @@ end subroutine s3 ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_8:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>>}>>>) -> !fir.array>>}>> ! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array>>}>>) { +! CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array>>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_11]] : (index) -> i32 ! CHECK: fir.store %[[VAL_13]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index @@ -441,7 +441,7 @@ end subroutine s3_1 ! CHECK: %[[VAL_7:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_8:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>>}>>>) -> !fir.array>>}>> ! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array>>}>>) { +! CHECK: %[[VAL_10:.*]] = fir.do_loop %[[VAL_11:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_7]] unordered iter_args(%[[VAL_12:.*]] = %[[VAL_8]]) -> (!fir.array>>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_11]] : (index) -> i32 ! CHECK: fir.store %[[VAL_13]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_14:.*]] = arith.constant 1 : index @@ -509,7 +509,7 @@ end subroutine s5 ! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>>}>>>) -> !fir.array>>}>> ! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_2]] : (!fir.box>>}>>>) -> !fir.array>>}>> -! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_11]]) -> (!fir.array>>}>>) { +! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_11]]) -> (!fir.array>>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32 ! CHECK: fir.store %[[VAL_16]] to %[[VAL_5]] : !fir.ref ! CHECK: %[[VAL_17:.*]] = arith.constant 1 : i64 @@ -583,10 +583,10 @@ end subroutine s6 ! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i32) -> index ! CHECK: %[[VAL_15:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>>}>>>>}>>>) -> !fir.array>>}>>>>}>> ! CHECK: %[[VAL_16:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_15]]) -> (!fir.array>>}>>>>}>>) { +! CHECK: %[[VAL_17:.*]] = fir.do_loop %[[VAL_18:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_19:.*]] = %[[VAL_15]]) -> (!fir.array>>}>>>>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_18]] : (index) -> i32 ! CHECK: fir.store %[[VAL_20]] to %[[VAL_3]] : !fir.ref -! CHECK: %[[VAL_21:.*]] = fir.do_loop %[[VAL_22:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_14]] unordered iter_args(%[[VAL_23:.*]] = %[[VAL_19]]) -> (!fir.array>>}>>>>}>>) { +! CHECK: %[[VAL_21:.*]] = fir.do_loop %[[VAL_22:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_14]] unordered iter_args(%[[VAL_23:.*]] = %[[VAL_19]]) -> (!fir.array>>}>>>>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_22]] : (index) -> i32 ! CHECK: fir.store %[[VAL_24]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_25:.*]] = arith.constant 1 : index @@ -645,7 +645,7 @@ end subroutine s7 ! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_9:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>}>>>) -> !fir.array>}>> ! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_9]]) -> (!fir.array>}>>) { +! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_9]]) -> (!fir.array>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_12]] : (index) -> i32 ! CHECK: fir.store %[[VAL_14]] to %[[VAL_3]] : !fir.ref ! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index @@ -706,7 +706,7 @@ end subroutine s8 ! CHECK: %[[VAL_11:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_12:.*]]:3 = fir.box_dims %[[VAL_10]], %[[VAL_11]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_13:.*]] = fir.shift %[[VAL_12]]#0 : (index) -> !fir.shift<1> -! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_9]]) -> (!fir.array>>}>>) { +! CHECK: %[[VAL_14:.*]] = fir.do_loop %[[VAL_15:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_16:.*]] = %[[VAL_9]]) -> (!fir.array>>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_15]] : (index) -> i32 ! CHECK: fir.store %[[VAL_17]] to %[[VAL_3]] : !fir.ref ! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_3]] : !fir.ref @@ -752,7 +752,7 @@ end subroutine s8_1 ! CHECK: %[[VAL_12:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_13:.*]]:3 = fir.box_dims %[[VAL_11]], %[[VAL_12]] : (!fir.box>>, index) -> (index, index, index) ! CHECK: %[[VAL_14:.*]] = fir.shift %[[VAL_13]]#0 : (index) -> !fir.shift<1> -! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_9]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_10]]) -> (!fir.array>>}>>) { +! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_9]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_10]]) -> (!fir.array>>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_16]] : (index) -> i32 ! CHECK: fir.store %[[VAL_18]] to %[[VAL_4]] : !fir.ref ! CHECK: %[[VAL_19:.*]] = fir.load %[[VAL_4]] : !fir.ref diff --git a/flang/test/Lower/forall/degenerate.f90 b/flang/test/Lower/forall/degenerate.f90 index c10c0a9edf829..d2ab6dab23915 100644 --- a/flang/test/Lower/forall/degenerate.f90 +++ b/flang/test/Lower/forall/degenerate.f90 @@ -19,7 +19,7 @@ subroutine pointer_forall_degenerated_assignment() ! CHECK: %[[VAL_4:.*]] = arith.constant 1 : i32 ! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> index ! CHECK: %[[VAL_6:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_3]] to %[[VAL_5]] step %[[VAL_6]] unordered { +! CHECK: fir.do_loop %[[VAL_7:.*]] = %[[VAL_3]] to %[[VAL_5]] step %[[VAL_6]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (index) -> i32 ! CHECK: fir.store %[[VAL_8]] to %[[VAL_0]] : !fir.ref ! CHECK: %[[VAL_9:.*]] = arith.constant true diff --git a/flang/test/Lower/forall/forall-2.f90 b/flang/test/Lower/forall/forall-2.f90 index cdafb4f3d49e7..e54c5f97c9414 100644 --- a/flang/test/Lower/forall/forall-2.f90 +++ b/flang/test/Lower/forall/forall-2.f90 @@ -50,7 +50,7 @@ end subroutine conflicting_allocatable ! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i32) -> index ! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>>}>>>) -> !fir.array>>}>> ! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>>}>>>) -> !fir.array>>}>> -! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_11]]) -> (!fir.array>>}>>) { +! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_11]]) -> (!fir.array>>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32 ! CHECK: fir.store %[[VAL_16]] to %[[VAL_4]] : !fir.ref ! CHECK-DAG: %[[VAL_17:.*]] = arith.constant 1 : index @@ -110,7 +110,7 @@ end subroutine forall_pointer_assign ! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_3]](%[[VAL_9]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<10x10xi32> -! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (!fir.array<10x10xi32>) { +! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (!fir.array<10x10xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_12]] : (index) -> i32 ! CHECK: fir.store %[[VAL_14]] to %[[VAL_0]] : !fir.ref ! CHECK: %[[VAL_15:.*]] = arith.constant 1 : index @@ -137,7 +137,7 @@ end subroutine forall_pointer_assign ! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_28]], %[[VAL_33]] : index -! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_34]] to %[[VAL_35]] step %[[VAL_33]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_13]]) -> (!fir.array<10x10xi32>) { +! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_34]] to %[[VAL_35]] step %[[VAL_33]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_13]]) -> (!fir.array<10x10xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_42:.*]] = arith.subi %[[VAL_17]], %[[VAL_15]] : index ! CHECK: %[[VAL_43:.*]] = arith.muli %[[VAL_37]], %[[VAL_19]] : index ! CHECK: %[[VAL_44:.*]] = arith.addi %[[VAL_42]], %[[VAL_43]] : index @@ -171,7 +171,7 @@ end subroutine slice_with_explicit_iters ! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]](%[[VAL_11]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array<1xi32> -! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (!fir.array<1xi32>) { +! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32 ! CHECK: fir.store %[[VAL_16]] to %[[VAL_2]] : !fir.ref ! CHECK-DAG: %[[VAL_18:.*]] = arith.constant 1 : index diff --git a/flang/test/Lower/forall/forall-allocatable-2.f90 b/flang/test/Lower/forall/forall-allocatable-2.f90 index 95bd290f27350..dd32ba0b2dd96 100644 --- a/flang/test/Lower/forall/forall-allocatable-2.f90 +++ b/flang/test/Lower/forall/forall-allocatable-2.f90 @@ -38,7 +38,7 @@ end subroutine forall_with_allocatable2 ! CHECK: %[[VAL_20:.*]] = fir.shape_shift %[[VAL_18]]#0, %[[VAL_18]]#1 : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_21:.*]] = fir.array_load %[[VAL_19]](%[[VAL_20]]) : (!fir.heap>, !fir.shapeshift<1>) -> !fir.array ! CHECK: %[[VAL_22:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_13]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_21]]) -> (!fir.array) { +! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_13]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_21]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_24]] : (index) -> i32 ! CHECK: fir.store %[[VAL_26]] to %[[VAL_1]] : !fir.ref ! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index diff --git a/flang/test/Lower/forall/forall-allocatable.f90 b/flang/test/Lower/forall/forall-allocatable.f90 index 96cd37ea3ed8a..1d141b295a690 100644 --- a/flang/test/Lower/forall/forall-allocatable.f90 +++ b/flang/test/Lower/forall/forall-allocatable.f90 @@ -30,7 +30,7 @@ end subroutine forall_with_allocatable ! CHECK: %[[VAL_15:.*]] = fir.shape_shift %[[VAL_12]], %[[VAL_13]] : (index, index) -> !fir.shapeshift<1> ! CHECK: %[[VAL_16:.*]] = fir.array_load %[[VAL_14]](%[[VAL_15]]) : (!fir.heap>, !fir.shapeshift<1>) -> !fir.array ! CHECK: %[[VAL_17:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_11]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_16]]) -> (!fir.array) { +! CHECK: %[[VAL_18:.*]] = fir.do_loop %[[VAL_19:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_11]] unordered iter_args(%[[VAL_20:.*]] = %[[VAL_16]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_19]] : (index) -> i32 ! CHECK: fir.store %[[VAL_21]] to %[[VAL_1]] : !fir.ref ! CHECK: %[[VAL_22:.*]] = arith.constant 1 : index diff --git a/flang/test/Lower/forall/forall-array.f90 b/flang/test/Lower/forall/forall-array.f90 index 2abc5a30610a9..c6239fdd6fa1b 100644 --- a/flang/test/Lower/forall/forall-array.f90 +++ b/flang/test/Lower/forall/forall-array.f90 @@ -32,7 +32,7 @@ end subroutine test_forall_with_array_assignment ! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]](%[[VAL_11]]) : (!fir.ref,block2:!fir.array<64xi64>}>>>, !fir.shape<1>) -> !fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>> ! CHECK: %[[VAL_13:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_14:.*]] = fir.array_load %[[VAL_1]](%[[VAL_13]]) : (!fir.ref,block2:!fir.array<64xi64>}>>>, !fir.shape<1>) -> !fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>> -! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_10]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_12]]) -> (!fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>>) { +! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_10]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_12]]) -> (!fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_16]] : (index) -> i32 ! CHECK: fir.store %[[VAL_18]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_19:.*]] = arith.constant 1 : index @@ -53,7 +53,7 @@ end subroutine test_forall_with_array_assignment ! CHECK: %[[VAL_35:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_36:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_37:.*]] = arith.subi %[[VAL_26]], %[[VAL_35]] : index -! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_35]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_17]]) -> (!fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>>) { +! CHECK: %[[VAL_38:.*]] = fir.do_loop %[[VAL_39:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_35]] unordered iter_args(%[[VAL_40:.*]] = %[[VAL_17]]) -> (!fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_41:.*]] = fir.array_fetch %[[VAL_14]], %[[VAL_33]], %[[VAL_34]], %[[VAL_39]] : (!fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>>, index, !fir.field, index) -> i64 ! CHECK: %[[VAL_42:.*]] = fir.array_update %[[VAL_40]], %[[VAL_41]], %[[VAL_23]], %[[VAL_24]], %[[VAL_39]] : (!fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>>, i64, index, !fir.field, index) -> !fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>> ! CHECK: fir.result %[[VAL_42]] : !fir.array<10x!fir.type<_QFtest_forall_with_array_assignmentTt{block1:!fir.array<64xi64>,block2:!fir.array<64xi64>}>> diff --git a/flang/test/Lower/forall/forall-construct-2.f90 b/flang/test/Lower/forall/forall-construct-2.f90 index 3bca192ef8e2e..bce8662f90e4f 100644 --- a/flang/test/Lower/forall/forall-construct-2.f90 +++ b/flang/test/Lower/forall/forall-construct-2.f90 @@ -37,10 +37,10 @@ end subroutine test2_forall_construct ! CHECK: %[[VAL_23:.*]] = fir.array_load %[[VAL_1]](%[[VAL_22]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<200x200xf32> ! CHECK: %[[VAL_24:.*]] = fir.shape %[[VAL_8]], %[[VAL_9]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_25:.*]] = fir.array_load %[[VAL_1]](%[[VAL_24]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<200x200xf32> -! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_14]] unordered iter_args(%[[VAL_28:.*]] = %[[VAL_21]]) -> (!fir.array<100x400xf32>) { +! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_14]] unordered iter_args(%[[VAL_28:.*]] = %[[VAL_21]]) -> (!fir.array<100x400xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_27]] : (index) -> i32 ! CHECK: fir.store %[[VAL_29]] to %[[VAL_5]] : !fir.ref -! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_19]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_28]]) -> (!fir.array<100x400xf32>) { +! CHECK: %[[VAL_30:.*]] = fir.do_loop %[[VAL_31:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_19]] unordered iter_args(%[[VAL_32:.*]] = %[[VAL_28]]) -> (!fir.array<100x400xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_31]] : (index) -> i32 ! CHECK: fir.store %[[VAL_33]] to %[[VAL_4]] : !fir.ref ! CHECK: %[[VAL_34:.*]] = arith.constant 1 : index @@ -85,10 +85,10 @@ end subroutine test2_forall_construct ! CHECK: %[[VAL_70:.*]] = fir.array_load %[[VAL_0]](%[[VAL_69]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<100x400xf32> ! CHECK: %[[VAL_71:.*]] = fir.shape %[[VAL_8]], %[[VAL_9]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_72:.*]] = fir.array_load %[[VAL_1]](%[[VAL_71]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<200x200xf32> -! CHECK: %[[VAL_73:.*]] = fir.do_loop %[[VAL_74:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_14]] unordered iter_args(%[[VAL_75:.*]] = %[[VAL_70]]) -> (!fir.array<100x400xf32>) { +! CHECK: %[[VAL_73:.*]] = fir.do_loop %[[VAL_74:.*]] = %[[VAL_11]] to %[[VAL_13]] step %[[VAL_14]] unordered iter_args(%[[VAL_75:.*]] = %[[VAL_70]]) -> (!fir.array<100x400xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_76:.*]] = fir.convert %[[VAL_74]] : (index) -> i32 ! CHECK: fir.store %[[VAL_76]] to %[[VAL_3]] : !fir.ref -! CHECK: %[[VAL_77:.*]] = fir.do_loop %[[VAL_78:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_19]] unordered iter_args(%[[VAL_79:.*]] = %[[VAL_75]]) -> (!fir.array<100x400xf32>) { +! CHECK: %[[VAL_77:.*]] = fir.do_loop %[[VAL_78:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_19]] unordered iter_args(%[[VAL_79:.*]] = %[[VAL_75]]) -> (!fir.array<100x400xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_80:.*]] = fir.convert %[[VAL_78]] : (index) -> i32 ! CHECK: fir.store %[[VAL_80]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_81:.*]] = arith.constant 1.000000e+00 : f32 diff --git a/flang/test/Lower/forall/forall-construct-3.f90 b/flang/test/Lower/forall/forall-construct-3.f90 index 59583330eb084..275a88806c592 100644 --- a/flang/test/Lower/forall/forall-construct-3.f90 +++ b/flang/test/Lower/forall/forall-construct-3.f90 @@ -38,10 +38,10 @@ end subroutine test3_forall_construct ! CHECK: %[[VAL_24:.*]] = fir.array_load %[[VAL_1]](%[[VAL_23]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<200x200xf32> ! CHECK: %[[VAL_25:.*]] = fir.shape %[[VAL_9]], %[[VAL_10]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_26:.*]] = fir.array_load %[[VAL_1]](%[[VAL_25]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<200x200xf32> -! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_28:.*]] = %[[VAL_12]] to %[[VAL_14]] step %[[VAL_15]] unordered iter_args(%[[VAL_29:.*]] = %[[VAL_22]]) -> (!fir.array<100x400xf32>) { +! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_28:.*]] = %[[VAL_12]] to %[[VAL_14]] step %[[VAL_15]] unordered iter_args(%[[VAL_29:.*]] = %[[VAL_22]]) -> (!fir.array<100x400xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_28]] : (index) -> i32 ! CHECK: fir.store %[[VAL_30]] to %[[VAL_6]] : !fir.ref -! CHECK: %[[VAL_31:.*]] = fir.do_loop %[[VAL_32:.*]] = %[[VAL_17]] to %[[VAL_19]] step %[[VAL_20]] unordered iter_args(%[[VAL_33:.*]] = %[[VAL_29]]) -> (!fir.array<100x400xf32>) { +! CHECK: %[[VAL_31:.*]] = fir.do_loop %[[VAL_32:.*]] = %[[VAL_17]] to %[[VAL_19]] step %[[VAL_20]] unordered iter_args(%[[VAL_33:.*]] = %[[VAL_29]]) -> (!fir.array<100x400xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_32]] : (index) -> i32 ! CHECK: fir.store %[[VAL_34]] to %[[VAL_5]] : !fir.ref ! CHECK: %[[VAL_35:.*]] = fir.load %[[VAL_6]] : !fir.ref @@ -102,10 +102,10 @@ end subroutine test3_forall_construct ! CHECK: %[[VAL_84:.*]] = fir.array_load %[[VAL_0]](%[[VAL_83]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<100x400xf32> ! CHECK: %[[VAL_85:.*]] = fir.shape %[[VAL_9]], %[[VAL_10]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_86:.*]] = fir.array_load %[[VAL_1]](%[[VAL_85]]) : (!fir.ref>, !fir.shape<2>) -> !fir.array<200x200xf32> -! CHECK: %[[VAL_87:.*]] = fir.do_loop %[[VAL_88:.*]] = %[[VAL_12]] to %[[VAL_14]] step %[[VAL_15]] unordered iter_args(%[[VAL_89:.*]] = %[[VAL_84]]) -> (!fir.array<100x400xf32>) { +! CHECK: %[[VAL_87:.*]] = fir.do_loop %[[VAL_88:.*]] = %[[VAL_12]] to %[[VAL_14]] step %[[VAL_15]] unordered iter_args(%[[VAL_89:.*]] = %[[VAL_84]]) -> (!fir.array<100x400xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_90:.*]] = fir.convert %[[VAL_88]] : (index) -> i32 ! CHECK: fir.store %[[VAL_90]] to %[[VAL_4]] : !fir.ref -! CHECK: %[[VAL_91:.*]] = fir.do_loop %[[VAL_92:.*]] = %[[VAL_17]] to %[[VAL_19]] step %[[VAL_20]] unordered iter_args(%[[VAL_93:.*]] = %[[VAL_89]]) -> (!fir.array<100x400xf32>) { +! CHECK: %[[VAL_91:.*]] = fir.do_loop %[[VAL_92:.*]] = %[[VAL_17]] to %[[VAL_19]] step %[[VAL_20]] unordered iter_args(%[[VAL_93:.*]] = %[[VAL_89]]) -> (!fir.array<100x400xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_94:.*]] = fir.convert %[[VAL_92]] : (index) -> i32 ! CHECK: fir.store %[[VAL_94]] to %[[VAL_3]] : !fir.ref ! CHECK: %[[VAL_95:.*]] = fir.load %[[VAL_4]] : !fir.ref diff --git a/flang/test/Lower/forall/forall-construct.f90 b/flang/test/Lower/forall/forall-construct.f90 index 6d4dad580ec96..9b797d3b7c1e2 100644 --- a/flang/test/Lower/forall/forall-construct.f90 +++ b/flang/test/Lower/forall/forall-construct.f90 @@ -43,10 +43,10 @@ end subroutine test_forall_construct ! CHECK: %[[VAL_29:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_30:.*]] = fir.array_load %[[VAL_0]] : (!fir.box>) -> !fir.array ! CHECK: %[[VAL_31:.*]] = fir.array_load %[[VAL_1]] : (!fir.box>) -> !fir.array -! CHECK: %[[VAL_32:.*]] = fir.do_loop %[[VAL_33:.*]] = %[[VAL_5]] to %[[VAL_15]] step %[[VAL_16]] unordered iter_args(%[[VAL_34:.*]] = %[[VAL_30]]) -> (!fir.array) { +! CHECK: %[[VAL_32:.*]] = fir.do_loop %[[VAL_33:.*]] = %[[VAL_5]] to %[[VAL_15]] step %[[VAL_16]] unordered iter_args(%[[VAL_34:.*]] = %[[VAL_30]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_33]] : (index) -> i32 ! CHECK: fir.store %[[VAL_35]] to %[[VAL_3]] : !fir.ref -! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_18]] to %[[VAL_28]] step %[[VAL_29]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_34]]) -> (!fir.array) { +! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_18]] to %[[VAL_28]] step %[[VAL_29]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_34]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (index) -> i32 ! CHECK: fir.store %[[VAL_39]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_2]] : !fir.ref diff --git a/flang/test/Lower/forall/forall-ranked.f90 b/flang/test/Lower/forall/forall-ranked.f90 index 9e56be926e78e..0acaa502fee89 100644 --- a/flang/test/Lower/forall/forall-ranked.f90 +++ b/flang/test/Lower/forall/forall-ranked.f90 @@ -14,7 +14,7 @@ ! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_3]](%[[VAL_9]]) : (!fir.ref}>>>, !fir.shape<2>) -> !fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>> -! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>) { +! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_12]] : (index) -> i32 ! CHECK: fir.store %[[VAL_14]] to %[[VAL_0]] : !fir.ref ! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index @@ -44,7 +44,7 @@ ! CHECK: %[[VAL_39:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_40:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_31]], %[[VAL_39]] : index -! CHECK: %[[VAL_42:.*]] = fir.do_loop %[[VAL_43:.*]] = %[[VAL_40]] to %[[VAL_41]] step %[[VAL_39]] unordered iter_args(%[[VAL_44:.*]] = %[[VAL_13]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>) { +! CHECK: %[[VAL_42:.*]] = fir.do_loop %[[VAL_43:.*]] = %[[VAL_40]] to %[[VAL_41]] step %[[VAL_39]] unordered iter_args(%[[VAL_44:.*]] = %[[VAL_13]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_46:.*]] = arith.subi %[[VAL_17]], %[[VAL_17]] : index ! CHECK: %[[VAL_47:.*]] = arith.muli %[[VAL_43]], %[[VAL_23]] : index ! CHECK: %[[VAL_48:.*]] = arith.addi %[[VAL_46]], %[[VAL_47]] : index diff --git a/flang/test/Lower/forall/forall-slice.f90 b/flang/test/Lower/forall/forall-slice.f90 index 05148cea2e941..dacc781b311d4 100644 --- a/flang/test/Lower/forall/forall-slice.f90 +++ b/flang/test/Lower/forall/forall-slice.f90 @@ -21,10 +21,10 @@ ! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_4]], %[[VAL_5]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_18:.*]] = fir.array_load %[[VAL_6]](%[[VAL_17]]) : (!fir.ref}>>>, !fir.shape<2>) -> !fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>> -! CHECK: %[[VAL_19:.*]] = fir.do_loop %[[VAL_20:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_11]] unordered iter_args(%[[VAL_21:.*]] = %[[VAL_18]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>) { +! CHECK: %[[VAL_19:.*]] = fir.do_loop %[[VAL_20:.*]] = %[[VAL_8]] to %[[VAL_10]] step %[[VAL_11]] unordered iter_args(%[[VAL_21:.*]] = %[[VAL_18]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_20]] : (index) -> i32 ! CHECK: fir.store %[[VAL_22]] to %[[VAL_3]] : !fir.ref -! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_16]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_21]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>) { +! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_16]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_21]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_24]] : (index) -> i32 ! CHECK: fir.store %[[VAL_26]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index @@ -57,7 +57,7 @@ ! CHECK: %[[VAL_53:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_54:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_52]], %[[VAL_53]] : index -! CHECK: %[[VAL_56:.*]] = fir.do_loop %[[VAL_57:.*]] = %[[VAL_54]] to %[[VAL_55]] step %[[VAL_53]] unordered iter_args(%[[VAL_58:.*]] = %[[VAL_25]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>) { +! CHECK: %[[VAL_56:.*]] = fir.do_loop %[[VAL_57:.*]] = %[[VAL_54]] to %[[VAL_55]] step %[[VAL_53]] unordered iter_args(%[[VAL_58:.*]] = %[[VAL_25]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_60:.*]] = arith.subi %[[VAL_40]], %[[VAL_37]] : index ! CHECK: %[[VAL_61:.*]] = arith.muli %[[VAL_57]], %[[VAL_43]] : index ! CHECK: %[[VAL_62:.*]] = arith.addi %[[VAL_60]], %[[VAL_61]] : index diff --git a/flang/test/Lower/forall/forall-stmt.f90 b/flang/test/Lower/forall/forall-stmt.f90 index 8dbc807b57161..dba456654c870 100644 --- a/flang/test/Lower/forall/forall-stmt.f90 +++ b/flang/test/Lower/forall/forall-stmt.f90 @@ -21,7 +21,7 @@ end subroutine test_forall_stmt ! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_0]](%[[VAL_9]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array<200xf32> -! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (!fir.array<200xf32>) { +! CHECK: %[[VAL_11:.*]] = fir.do_loop %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (!fir.array<200xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_12]] : (index) -> i32 ! CHECK: fir.store %[[VAL_14]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_2]] : !fir.ref diff --git a/flang/test/Lower/forall/forall-where.f90 b/flang/test/Lower/forall/forall-where.f90 index af309e63535fa..1b206987060fe 100644 --- a/flang/test/Lower/forall/forall-where.f90 +++ b/flang/test/Lower/forall/forall-where.f90 @@ -69,10 +69,10 @@ end subroutine test_nested_forall_where ! CHECK: %[[VAL_43:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_44:.*]] = fir.array_load %[[VAL_0]] : (!fir.box}>>>) -> !fir.array}>> ! CHECK: %[[VAL_45:.*]] = fir.array_load %[[VAL_1]] : (!fir.box}>>>) -> !fir.array}>> -! CHECK: %[[VAL_46:.*]] = fir.do_loop %[[VAL_47:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_48:.*]] = %[[VAL_44]]) -> (!fir.array}>>) { +! CHECK: %[[VAL_46:.*]] = fir.do_loop %[[VAL_47:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_48:.*]] = %[[VAL_44]]) -> (!fir.array}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_49:.*]] = fir.convert %[[VAL_47]] : (index) -> i32 ! CHECK: fir.store %[[VAL_49]] to %[[VAL_7]] : !fir.ref -! CHECK: %[[VAL_50:.*]] = fir.do_loop %[[VAL_51:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_52:.*]] = %[[VAL_48]]) -> (!fir.array}>>) { +! CHECK: %[[VAL_50:.*]] = fir.do_loop %[[VAL_51:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_52:.*]] = %[[VAL_48]]) -> (!fir.array}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_51]] : (index) -> i32 ! CHECK: fir.store %[[VAL_53]] to %[[VAL_6]] : !fir.ref ! CHECK: %[[VAL_54:.*]] = arith.constant 1 : i64 @@ -170,7 +170,7 @@ end subroutine test_nested_forall_where ! CHECK: %[[VAL_139:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_140:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_141:.*]] = arith.subi %[[VAL_114]], %[[VAL_139]] : index -! CHECK: %[[VAL_142:.*]] = fir.do_loop %[[VAL_143:.*]] = %[[VAL_140]] to %[[VAL_141]] step %[[VAL_139]] unordered iter_args(%[[VAL_144:.*]] = %[[VAL_122]]) -> (!fir.array) { +! CHECK: %[[VAL_142:.*]] = fir.do_loop %[[VAL_143:.*]] = %[[VAL_140]] to %[[VAL_141]] step %[[VAL_139]] unordered iter_args(%[[VAL_144:.*]] = %[[VAL_122]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_145:.*]] = fir.array_fetch %[[VAL_116]], %[[VAL_143]] : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[VAL_146:.*]] = arith.cmpf ogt, %[[VAL_145]], %[[VAL_117]] {{.*}} : f32 ! CHECK: %[[VAL_147:.*]] = arith.constant 1 : i32 @@ -188,10 +188,10 @@ end subroutine test_nested_forall_where ! CHECK: } ! CHECK: fir.result %[[VAL_155:.*]] : !fir.array}>> ! CHECK: } -! CHECK: %[[VAL_156:.*]] = fir.do_loop %[[VAL_157:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_158:.*]] = %[[VAL_44]]) -> (!fir.array}>>) { +! CHECK: %[[VAL_156:.*]] = fir.do_loop %[[VAL_157:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_158:.*]] = %[[VAL_44]]) -> (!fir.array}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_159:.*]] = fir.convert %[[VAL_157]] : (index) -> i32 ! CHECK: fir.store %[[VAL_159]] to %[[VAL_5]] : !fir.ref -! CHECK: %[[VAL_160:.*]] = fir.do_loop %[[VAL_161:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_162:.*]] = %[[VAL_158]]) -> (!fir.array}>>) { +! CHECK: %[[VAL_160:.*]] = fir.do_loop %[[VAL_161:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_162:.*]] = %[[VAL_158]]) -> (!fir.array}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_163:.*]] = fir.convert %[[VAL_161]] : (index) -> i32 ! CHECK: fir.store %[[VAL_163]] to %[[VAL_4]] : !fir.ref ! CHECK: %[[VAL_164:.*]] = arith.constant 0 : i64 @@ -262,7 +262,7 @@ end subroutine test_nested_forall_where ! CHECK: %[[VAL_229:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_230:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_231:.*]] = arith.subi %[[VAL_206]], %[[VAL_229]] : index -! CHECK: %[[VAL_232:.*]] = fir.do_loop %[[VAL_233:.*]] = %[[VAL_230]] to %[[VAL_231]] step %[[VAL_229]] unordered iter_args(%[[VAL_234:.*]] = %[[VAL_162]]) -> (!fir.array}>>) { +! CHECK: %[[VAL_232:.*]] = fir.do_loop %[[VAL_233:.*]] = %[[VAL_230]] to %[[VAL_231]] step %[[VAL_229]] unordered iter_args(%[[VAL_234:.*]] = %[[VAL_162]]) -> (!fir.array}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_235:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_236:.*]] = arith.addi %[[VAL_233]], %[[VAL_235]] : index ! CHECK: %[[VAL_237:.*]] = fir.array_coor %[[VAL_199]](%[[VAL_207]]) %[[VAL_236]] : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref @@ -285,10 +285,10 @@ end subroutine test_nested_forall_where ! CHECK: fir.array_merge_store %[[VAL_44]], %[[VAL_247:.*]] to %[[VAL_0]] : !fir.array}>>, !fir.array}>>, !fir.box}>>> ! CHECK: %[[VAL_248:.*]] = fir.array_load %[[VAL_0]] : (!fir.box}>>>) -> !fir.array}>> ! CHECK: %[[VAL_249:.*]] = fir.array_load %[[VAL_1]] : (!fir.box}>>>) -> !fir.array}>> -! CHECK: %[[VAL_250:.*]] = fir.do_loop %[[VAL_251:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_252:.*]] = %[[VAL_248]]) -> (!fir.array}>>) { +! CHECK: %[[VAL_250:.*]] = fir.do_loop %[[VAL_251:.*]] = %[[VAL_19]] to %[[VAL_29]] step %[[VAL_30]] unordered iter_args(%[[VAL_252:.*]] = %[[VAL_248]]) -> (!fir.array}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_253:.*]] = fir.convert %[[VAL_251]] : (index) -> i32 ! CHECK: fir.store %[[VAL_253]] to %[[VAL_3]] : !fir.ref -! CHECK: %[[VAL_254:.*]] = fir.do_loop %[[VAL_255:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_256:.*]] = %[[VAL_252]]) -> (!fir.array}>>) { +! CHECK: %[[VAL_254:.*]] = fir.do_loop %[[VAL_255:.*]] = %[[VAL_32]] to %[[VAL_42]] step %[[VAL_43]] unordered iter_args(%[[VAL_256:.*]] = %[[VAL_252]]) -> (!fir.array}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_257:.*]] = fir.convert %[[VAL_255]] : (index) -> i32 ! CHECK: fir.store %[[VAL_257]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_258:.*]] = arith.constant 0 : i64 @@ -358,7 +358,7 @@ end subroutine test_nested_forall_where ! CHECK: %[[VAL_322:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_323:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_324:.*]] = arith.subi %[[VAL_300]], %[[VAL_322]] : index -! CHECK: %[[VAL_325:.*]] = fir.do_loop %[[VAL_326:.*]] = %[[VAL_323]] to %[[VAL_324]] step %[[VAL_322]] unordered iter_args(%[[VAL_327:.*]] = %[[VAL_256]]) -> (!fir.array}>>) { +! CHECK: %[[VAL_325:.*]] = fir.do_loop %[[VAL_326:.*]] = %[[VAL_323]] to %[[VAL_324]] step %[[VAL_322]] unordered iter_args(%[[VAL_327:.*]] = %[[VAL_256]]) -> (!fir.array}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_328:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_329:.*]] = arith.addi %[[VAL_326]], %[[VAL_328]] : index ! CHECK: %[[VAL_330:.*]] = fir.array_coor %[[VAL_293]](%[[VAL_301]]) %[[VAL_329]] : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref diff --git a/flang/test/Lower/forall/scalar-substring.f90 b/flang/test/Lower/forall/scalar-substring.f90 index 0608efe7f0d49..af17c75ca30aa 100644 --- a/flang/test/Lower/forall/scalar-substring.f90 +++ b/flang/test/Lower/forall/scalar-substring.f90 @@ -17,7 +17,7 @@ end subroutine s ! CHECK: %[[VAL_6:.*]] = arith.constant 4 : i32 ! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i32) -> index ! CHECK: %[[VAL_8:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered { +! CHECK: fir.do_loop %[[VAL_9:.*]] = %[[VAL_5]] to %[[VAL_7]] step %[[VAL_8]] unordered attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (index) -> i32 ! CHECK: fir.store %[[VAL_10]] to %[[VAL_1]] : !fir.ref ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_1]] : !fir.ref @@ -71,7 +71,7 @@ end subroutine s ! CHECK: %[[VAL_58:.*]] = fir.undefined !fir.char<1> ! CHECK: %[[VAL_59:.*]] = fir.insert_value %[[VAL_58]], %[[VAL_57]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1> ! CHECK: %[[VAL_60:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_61:.*]] = %[[VAL_48]] to %[[VAL_56]] step %[[VAL_60]] { +! CHECK: fir.do_loop %[[VAL_61:.*]] = %[[VAL_48]] to %[[VAL_56]] step %[[VAL_60]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_62:.*]] = fir.convert %[[VAL_41]] : (!fir.ref>) -> !fir.ref>> ! CHECK: %[[VAL_63:.*]] = fir.coordinate_of %[[VAL_62]], %[[VAL_61]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: fir.store %[[VAL_59]] to %[[VAL_63]] : !fir.ref> diff --git a/flang/test/Lower/forall/test9.f90 b/flang/test/Lower/forall/test9.f90 index 88107cb6f6037..ec41b785791ee 100644 --- a/flang/test/Lower/forall/test9.f90 +++ b/flang/test/Lower/forall/test9.f90 @@ -45,7 +45,7 @@ end subroutine test9 ! CHECK: %[[VAL_26:.*]] = fir.array_load %[[VAL_0]](%[[VAL_25]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array ! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_15]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_28:.*]] = fir.array_load %[[VAL_1]](%[[VAL_27]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array -! CHECK: %[[VAL_29:.*]] = fir.do_loop %[[VAL_30:.*]] = %[[VAL_17]] to %[[VAL_21]] step %[[VAL_22]] unordered iter_args(%[[VAL_31:.*]] = %[[VAL_24]]) -> (!fir.array) { +! CHECK: %[[VAL_29:.*]] = fir.do_loop %[[VAL_30:.*]] = %[[VAL_17]] to %[[VAL_21]] step %[[VAL_22]] unordered iter_args(%[[VAL_31:.*]] = %[[VAL_24]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_30]] : (index) -> i32 ! CHECK: fir.store %[[VAL_32]] to %[[VAL_3]] : !fir.ref ! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index diff --git a/flang/test/Lower/infinite_loop.f90 b/flang/test/Lower/infinite_loop.f90 index 6942dda8d7a23..72b9a60b5c94d 100644 --- a/flang/test/Lower/infinite_loop.f90 +++ b/flang/test/Lower/infinite_loop.f90 @@ -94,7 +94,7 @@ subroutine structured_loop_in_infinite(i) ! CHECK: %[[J_LB:.*]] = fir.convert %[[C1_INDEX]] : (index) -> i32 ! CHECK: %[[J_FINAL:.*]]:2 = fir.do_loop %[[J:[^ ]*]] = ! CHECK-SAME: %[[C1_INDEX]] to %[[C10_INDEX]] step %[[C1_1]] -! CHECK-SAME: iter_args(%[[J_IV:.*]] = %[[J_LB]]) -> (index, i32) { +! CHECK-SAME: iter_args(%[[J_IV:.*]] = %[[J_LB]]) -> (index, i32) {{.*}} { ! CHECK: fir.store %[[J_IV]] to %[[J_REF]] : !fir.ref ! CHECK: %[[J_NEXT:.*]] = arith.addi %[[J]], %[[C1_1]] : index ! CHECK: %[[J_STEPCAST:.*]] = fir.convert %[[C1_1]] : (index) -> i32 @@ -127,7 +127,7 @@ subroutine structured_loop_in_infinite(i) ! NSW: %[[J_LB:.*]] = fir.convert %[[C1_INDEX]] : (index) -> i32 ! NSW: %[[J_FINAL:.*]]:2 = fir.do_loop %[[J:[^ ]*]] = ! NSW-SAME: %[[C1_INDEX]] to %[[C10_INDEX]] step %[[C1_1]] -! NSW-SAME: iter_args(%[[J_IV:.*]] = %[[J_LB]]) -> (index, i32) { +! NSW-SAME: iter_args(%[[J_IV:.*]] = %[[J_LB]]) -> (index, i32) {{.*}} { ! NSW: fir.store %[[J_IV]] to %[[J_REF]] : !fir.ref ! NSW: %[[J_NEXT:.*]] = arith.addi %[[J]], %[[C1_1]] overflow : index ! NSW: %[[J_STEPCAST:.*]] = fir.convert %[[C1_1]] : (index) -> i32 diff --git a/flang/test/Lower/io-implied-do-fixes.f90 b/flang/test/Lower/io-implied-do-fixes.f90 index a6c115fa80ded..57d58713d4048 100644 --- a/flang/test/Lower/io-implied-do-fixes.f90 +++ b/flang/test/Lower/io-implied-do-fixes.f90 @@ -5,7 +5,7 @@ ! CHECK-LABEL: func @_QPido1 ! CHECK: %[[J_REF_ADDR:.*]] = fir.alloca !fir.ptr {uniq_name = "_QFido1Eiptr.addr"} ! CHECK: %[[J_ADDR:.*]] = fir.load %[[J_REF_ADDR]] : !fir.ref> -! CHECK: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} -> index { +! CHECK: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} {{.*}} { ! CHECK: %[[J_VAL_CVT1:.*]] = fir.convert %[[J_VAL]] : (index) -> i32 ! CHECK: fir.store %[[J_VAL_CVT1]] to %[[J_ADDR]] : !fir.ptr ! CHECK: %[[J_VAL_NEXT:.*]] = arith.addi %[[J_VAL]], %{{[^ ]*}} : index @@ -17,7 +17,7 @@ ! NSW-LABEL: func @_QPido1 ! NSW: %[[J_REF_ADDR:.*]] = fir.alloca !fir.ptr {uniq_name = "_QFido1Eiptr.addr"} ! NSW: %[[J_ADDR:.*]] = fir.load %[[J_REF_ADDR]] : !fir.ref> -! NSW: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} -> index { +! NSW: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} -> index {{.*}} { ! NSW: %[[J_VAL_CVT1:.*]] = fir.convert %[[J_VAL]] : (index) -> i32 ! NSW: fir.store %[[J_VAL_CVT1]] to %[[J_ADDR]] : !fir.ptr ! NSW: %[[J_VAL_NEXT:.*]] = arith.addi %[[J_VAL]], %{{[^ ]*}} overflow : index @@ -35,7 +35,7 @@ subroutine ido1 ! CHECK-LABEL: func @_QPido2 ! CHECK: %[[J_REF_ADDR:.*]] = fir.alloca !fir.heap {uniq_name = "_QFido2Eiptr.addr"} ! CHECK: %[[J_ADDR:.*]] = fir.load %[[J_REF_ADDR]] : !fir.ref> -! CHECK: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} -> index { +! CHECK: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} -> index {{.*}} { ! CHECK: %[[J_VAL_CVT1:.*]] = fir.convert %[[J_VAL]] : (index) -> i32 ! CHECK: fir.store %[[J_VAL_CVT1]] to %[[J_ADDR]] : !fir.heap ! CHECK: %[[J_VAL_NEXT:.*]] = arith.addi %[[J_VAL]], %{{[^ ]*}} : index @@ -47,7 +47,7 @@ subroutine ido1 ! NSW-LABEL: func @_QPido2 ! NSW: %[[J_REF_ADDR:.*]] = fir.alloca !fir.heap {uniq_name = "_QFido2Eiptr.addr"} ! NSW: %[[J_ADDR:.*]] = fir.load %[[J_REF_ADDR]] : !fir.ref> -! NSW: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} -> index { +! NSW: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} -> index {{.*}} { ! NSW: %[[J_VAL_CVT1:.*]] = fir.convert %[[J_VAL]] : (index) -> i32 ! NSW: fir.store %[[J_VAL_CVT1]] to %[[J_ADDR]] : !fir.heap ! NSW: %[[J_VAL_NEXT:.*]] = arith.addi %[[J_VAL]], %{{[^ ]*}} overflow : index diff --git a/flang/test/Lower/loops.f90 b/flang/test/Lower/loops.f90 index ea65ba3e4d66d..b080ec66b4a36 100644 --- a/flang/test/Lower/loops.f90 +++ b/flang/test/Lower/loops.f90 @@ -111,14 +111,14 @@ subroutine lis(n) integer, pointer :: p(:,:,:) ! local_init locality p => a - ! CHECK: fir.do_loop %arg1 = %c0{{.*}} to %{{.*}} step %c1{{.*}} unordered iter_args(%arg2 = %{{.*}}) -> (!fir.array) { - ! CHECK: fir.do_loop %arg3 = %c0{{.*}} to %{{.*}} step %c1{{.*}} unordered iter_args(%arg4 = %arg2) -> (!fir.array) { + ! CHECK: fir.do_loop %arg1 = %c0{{.*}} to %{{.*}} step %c1{{.*}} unordered iter_args(%arg2 = %{{.*}}) -> (!fir.array) attributes {operandSegmentSizes = array} { + ! CHECK: fir.do_loop %arg3 = %c0{{.*}} to %{{.*}} step %c1{{.*}} unordered iter_args(%arg4 = %arg2) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: } ! CHECK: } r = 0 - ! CHECK: fir.do_loop %arg1 = %{{.*}} to %{{.*}} step %{{.*}} unordered { - ! CHECK: fir.do_loop %arg2 = %{{.*}} to %{{.*}} step %c1{{.*}} iter_args(%arg3 = %{{.*}}) -> (index, i32) { + ! CHECK: fir.do_loop %arg1 = %{{.*}} to %{{.*}} step %{{.*}} unordered attributes {operandSegmentSizes = array} { + ! CHECK: fir.do_loop %arg2 = %{{.*}} to %{{.*}} step %c1{{.*}} iter_args(%arg3 = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { ! CHECK: } ! CHECK: } do concurrent (integer(kind=1)::i=n:1:-1) @@ -128,14 +128,14 @@ subroutine lis(n) enddo enddo - ! CHECK: fir.do_loop %arg1 = %{{.*}} to %{{.*}} step %c1{{.*}} unordered { - ! CHECK: fir.do_loop %arg2 = %{{.*}} to %{{.*}} step %c1{{.*}} unordered { + ! CHECK: fir.do_loop %arg1 = %{{.*}} to %{{.*}} step %c1{{.*}} unordered attributes {operandSegmentSizes = array} { + ! CHECK: fir.do_loop %arg2 = %{{.*}} to %{{.*}} step %c1{{.*}} unordered attributes {operandSegmentSizes = array} { ! CHECK: fir.if %{{.*}} { ! CHECK: %[[V_95:[0-9]+]] = fir.alloca !fir.array, %{{.*}}, %{{.*}} {bindc_name = "t", pinned, uniq_name = "_QFlisEt"} ! CHECK: %[[V_96:[0-9]+]] = fir.alloca !fir.box>> {bindc_name = "p", pinned, uniq_name = "_QFlisEp"} ! CHECK: fir.store %{{.*}} to %[[V_96]] : !fir.ref>>> - ! CHECK: fir.do_loop %arg3 = %{{.*}} to %{{.*}} step %c1{{.*}} iter_args(%arg4 = %{{.*}}) -> (index, i32) { - ! CHECK: fir.do_loop %arg5 = %{{.*}} to %{{.*}} step %c1{{.*}} unordered { + ! CHECK: fir.do_loop %arg3 = %{{.*}} to %{{.*}} step %c1{{.*}} iter_args(%arg4 = %{{.*}}) -> (index, i32) attributes {operandSegmentSizes = array} { + ! CHECK: fir.do_loop %arg5 = %{{.*}} to %{{.*}} step %c1{{.*}} unordered attributes {operandSegmentSizes = array} { ! CHECK: fir.load %[[V_96]] : !fir.ref>>> ! CHECK: fir.convert %[[V_95]] : (!fir.ref>) -> !fir.ref> ! CHECK: } diff --git a/flang/test/Lower/loops3.f90 b/flang/test/Lower/loops3.f90 new file mode 100644 index 0000000000000..f6a6c9d69dbe8 --- /dev/null +++ b/flang/test/Lower/loops3.f90 @@ -0,0 +1,21 @@ +! Test do concurrent reduction +! RUN: bbc -emit-fir -hlfir=false -o - %s | FileCheck %s + +! CHECK-LABEL: loop_test +subroutine loop_test + integer(4) :: i, j, k, tmp, sum = 0 + real :: m + + i = 100 + j = 200 + k = 300 + + ! CHECK: %[[VAL_0:.*]] = fir.reduce %{{.*}} {name = "sum"} : (!fir.ref) -> !fir.ref + ! CHECK: %[[VAL_1:.*]] = fir.reduce %{{.*}} {name = "m"} : (!fir.ref) -> !fir.ref + ! CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered reduce(#fir.reduce_attr -> %[[VAL_0]] : !fir.ref, #fir.reduce_attr -> %[[VAL_1]] : !fir.ref) attributes {operandSegmentSizes = array} { + do concurrent (i=1:5, j=1:5, k=1:5) local(tmp) reduce(+:sum) reduce(max:m) + tmp = i + j + k + sum = tmp + sum + m = max(m, sum) + enddo +end subroutine loop_test diff --git a/flang/test/Lower/mixed_loops.f90 b/flang/test/Lower/mixed_loops.f90 index 1aa0225129bed..a7e37aed3d7df 100644 --- a/flang/test/Lower/mixed_loops.f90 +++ b/flang/test/Lower/mixed_loops.f90 @@ -94,7 +94,7 @@ subroutine do_inside_while_loop ! CHECK: %[[I_LB:.*]] = fir.convert %[[C8]] : (index) -> i32 ! CHECK: %[[RESULT:.*]]:2 = fir.do_loop %[[IDX:[^ ]*]] = ! CHECK-SAME: %[[C8]] to %[[C13]] step %[[C1]] - ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) { + ! CHECK-SAME: iter_args(%[[I_IV:.*]] = %[[I_LB]]) -> (index, i32) attributes {operandSegmentSizes = array} { ! CHECK: fir.store %[[I_IV]] to %[[I_REF]] : !fir.ref ! CHECK-DAG: %[[J2:.*]] = fir.load %[[J_REF]] : !fir.ref ! CHECK-DAG: %[[C2:.*]] = arith.constant 2 : i32 diff --git a/flang/test/Lower/nested-where.f90 b/flang/test/Lower/nested-where.f90 index b1b6367174ebd..83a1fe671730e 100644 --- a/flang/test/Lower/nested-where.f90 +++ b/flang/test/Lower/nested-where.f90 @@ -45,7 +45,7 @@ program nested_where ! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_34:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_35:.*]] = fir.array_load %[[VAL_5]](%[[VAL_34]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array<3xi32> - ! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) { + ! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (index) -> i32 ! CHECK: fir.store %[[VAL_39]] to %[[VAL_2]] : !fir.ref ! CHECK: %[[VAL_40:.*]] = arith.constant 1 : i64 @@ -114,7 +114,7 @@ program nested_where ! CHECK: %[[VAL_97:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_98:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_99:.*]] = arith.subi %[[VAL_8]], %[[VAL_97]] : index - ! CHECK: %[[VAL_100:.*]] = fir.do_loop %[[VAL_101:.*]] = %[[VAL_98]] to %[[VAL_99]] step %[[VAL_97]] unordered iter_args(%[[VAL_102:.*]] = %[[VAL_80]]) -> (!fir.array) { + ! CHECK: %[[VAL_100:.*]] = fir.do_loop %[[VAL_101:.*]] = %[[VAL_98]] to %[[VAL_99]] step %[[VAL_97]] unordered iter_args(%[[VAL_102:.*]] = %[[VAL_80]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_103:.*]] = fir.array_fetch %[[VAL_75]], %[[VAL_101]] : (!fir.array<3x!fir.logical<4>>, index) -> !fir.logical<4> ! CHECK: %[[VAL_104:.*]] = arith.constant 1 : i32 ! CHECK: %[[VAL_105:.*]] = fir.coordinate_of %[[VAL_73]], %[[VAL_104]] : (!fir.ref>, !fir.heap>>>, i32) -> !fir.ref>> @@ -129,7 +129,7 @@ program nested_where ! CHECK: } ! CHECK: fir.result %[[VAL_38]] : !fir.array<3xi32> ! CHECK: } - ! CHECK: %[[VAL_112:.*]] = fir.do_loop %[[VAL_113:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_114:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) { + ! CHECK: %[[VAL_112:.*]] = fir.do_loop %[[VAL_113:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_114:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_115:.*]] = fir.convert %[[VAL_113]] : (index) -> i32 ! CHECK: fir.store %[[VAL_115]] to %[[VAL_1]] : !fir.ref ! CHECK: %[[VAL_116:.*]] = arith.constant 1 : i64 @@ -198,7 +198,7 @@ program nested_where ! CHECK: %[[VAL_173:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_174:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_175:.*]] = arith.subi %[[VAL_10]], %[[VAL_173]] : index - ! CHECK: %[[VAL_176:.*]] = fir.do_loop %[[VAL_177:.*]] = %[[VAL_174]] to %[[VAL_175]] step %[[VAL_173]] unordered iter_args(%[[VAL_178:.*]] = %[[VAL_156]]) -> (!fir.array) { + ! CHECK: %[[VAL_176:.*]] = fir.do_loop %[[VAL_177:.*]] = %[[VAL_174]] to %[[VAL_175]] step %[[VAL_173]] unordered iter_args(%[[VAL_178:.*]] = %[[VAL_156]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_179:.*]] = fir.array_fetch %[[VAL_151]], %[[VAL_177]] : (!fir.array<3x!fir.logical<4>>, index) -> !fir.logical<4> ! CHECK: %[[VAL_180:.*]] = arith.constant 1 : i32 ! CHECK: %[[VAL_181:.*]] = fir.coordinate_of %[[VAL_149]], %[[VAL_180]] : (!fir.ref>, !fir.heap>>>, i32) -> !fir.ref>> @@ -213,7 +213,7 @@ program nested_where ! CHECK: } ! CHECK: fir.result %[[VAL_114]] : !fir.array<3xi32> ! CHECK: } - ! CHECK: %[[VAL_188:.*]] = fir.do_loop %[[VAL_189:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_190:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) { + ! CHECK: %[[VAL_188:.*]] = fir.do_loop %[[VAL_189:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_190:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_191:.*]] = fir.convert %[[VAL_189]] : (index) -> i32 ! CHECK: fir.store %[[VAL_191]] to %[[VAL_0]] : !fir.ref ! CHECK: %[[VAL_192:.*]] = arith.constant 0 : i64 @@ -282,7 +282,7 @@ program nested_where ! CHECK: %[[VAL_255:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_256:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_257:.*]] = arith.subi %[[VAL_221]], %[[VAL_255]] : index - ! CHECK: %[[VAL_258:.*]] = fir.do_loop %[[VAL_259:.*]] = %[[VAL_256]] to %[[VAL_257]] step %[[VAL_255]] unordered iter_args(%[[VAL_260:.*]] = %[[VAL_190]]) -> (!fir.array<3xi32>) { + ! CHECK: %[[VAL_258:.*]] = fir.do_loop %[[VAL_259:.*]] = %[[VAL_256]] to %[[VAL_257]] step %[[VAL_255]] unordered iter_args(%[[VAL_260:.*]] = %[[VAL_190]]) -> (!fir.array<3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_261:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_262:.*]] = arith.addi %[[VAL_259]], %[[VAL_261]] : index ! CHECK: %[[VAL_263:.*]] = fir.array_coor %[[VAL_214]](%[[VAL_222]]) %[[VAL_262]] : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref diff --git a/flang/test/Lower/optional-value-caller.f90 b/flang/test/Lower/optional-value-caller.f90 index a1e6ebf3e2182..d671a9be6bf57 100644 --- a/flang/test/Lower/optional-value-caller.f90 +++ b/flang/test/Lower/optional-value-caller.f90 @@ -190,7 +190,7 @@ subroutine test_array(i) ! CHECK: %[[VAL_9:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_11:.*]] = arith.subi %[[VAL_1]], %[[VAL_9]] : index -! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_9]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_6]]) -> (!fir.array<100xi32>) { +! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_9]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_6]]) -> (!fir.array<100xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_15:.*]] = fir.array_fetch %[[VAL_8]], %[[VAL_13]] : (!fir.array<100xi32>, index) -> i32 ! CHECK: %[[VAL_16:.*]] = fir.array_update %[[VAL_14]], %[[VAL_15]], %[[VAL_13]] : (!fir.array<100xi32>, i32, index) -> !fir.array<100xi32> ! CHECK: fir.result %[[VAL_16]] : !fir.array<100xi32> diff --git a/flang/test/Lower/pointer-references.f90 b/flang/test/Lower/pointer-references.f90 index 02394e7ec76b0..f209ce3177043 100644 --- a/flang/test/Lower/pointer-references.f90 +++ b/flang/test/Lower/pointer-references.f90 @@ -102,7 +102,7 @@ subroutine arr_contig_ptr_read(p) ! CHECK: %[[VAL_23:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_24:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_25:.*]] = arith.subi %[[VAL_17]], %[[VAL_23]] : index - ! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] unordered iter_args(%[[VAL_28:.*]] = %[[VAL_20]]) -> (!fir.array) { + ! CHECK: %[[VAL_26:.*]] = fir.do_loop %[[VAL_27:.*]] = %[[VAL_24]] to %[[VAL_25]] step %[[VAL_23]] unordered iter_args(%[[VAL_28:.*]] = %[[VAL_20]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_29:.*]] = fir.array_fetch %[[VAL_22]], %[[VAL_27]] : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[VAL_30:.*]] = fir.array_update %[[VAL_28]], %[[VAL_29]], %[[VAL_27]] : (!fir.array, f32, index) -> !fir.array ! CHECK: fir.result %[[VAL_30]] : !fir.array @@ -147,7 +147,7 @@ subroutine arr_ptr_target_write(p) ! CHECK: %[[VAL_24:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_25:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_26:.*]] = arith.subi %[[VAL_18]], %[[VAL_24]] : index - ! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_28:.*]] = %[[VAL_25]] to %[[VAL_26]] step %[[VAL_24]] unordered iter_args(%[[VAL_29:.*]] = %[[VAL_21]]) -> (!fir.array) { + ! CHECK: %[[VAL_27:.*]] = fir.do_loop %[[VAL_28:.*]] = %[[VAL_25]] to %[[VAL_26]] step %[[VAL_24]] unordered iter_args(%[[VAL_29:.*]] = %[[VAL_21]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_30:.*]] = fir.array_fetch %[[VAL_23]], %[[VAL_28]] : (!fir.array<100xf32>, index) -> f32 ! CHECK: %[[VAL_31:.*]] = fir.array_update %[[VAL_29]], %[[VAL_30]], %[[VAL_28]] : (!fir.array, f32, index) -> !fir.array ! CHECK: fir.result %[[VAL_31]] : !fir.array diff --git a/flang/test/Lower/polymorphic.f90 b/flang/test/Lower/polymorphic.f90 index 14ec8a06a964f..ffc7c4ae243ee 100644 --- a/flang/test/Lower/polymorphic.f90 +++ b/flang/test/Lower/polymorphic.f90 @@ -164,7 +164,7 @@ subroutine implicit_loop_with_polymorphic() ! CHECK-LABEL: func.func @_QMpolymorphic_testPimplicit_loop_with_polymorphic() { ! CHECK: %{{.*}} = fir.array_load %{{.*}}(%{{.*}}) [%{{.*}}] : (!fir.class>>>, !fir.shift<1>, !fir.slice<1>) -> !fir.array -! CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array) { +! CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %{{.*}} = fir.array_fetch %{{.*}}, %{{.*}} : (!fir.array<3xi32>, index) -> i32 ! CHECK: %{{.*}} = fir.array_update %{{.*}}, %{{.*}}, %{{.*}} : (!fir.array, i32, index) -> !fir.array ! CHECK: } @@ -498,7 +498,7 @@ subroutine test_elemental_assign() ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[C3_0]], %[[C1]] : index -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[ARG0:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG1:.*]] = %[[LOAD_PA]]) -> (!fir.array<3x!fir.type<_QMpolymorphic_testTp1{a:i32,b:i32}>>) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[ARG0:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG1:.*]] = %[[LOAD_PA]]) -> (!fir.array<3x!fir.type<_QMpolymorphic_testTp1{a:i32,b:i32}>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[FETCH_INT:.*]] = fir.array_fetch %[[LOAD_INT_ARRAY]], %[[ARG0]] : (!fir.array<3xi32>, index) -> i32 ! CHECK: %[[ARRAY_MOD:.*]]:2 = fir.array_modify %[[ARG1]], %[[ARG0]] : (!fir.array<3x!fir.type<_QMpolymorphic_testTp1{a:i32,b:i32}>>, index) -> (!fir.ref>, !fir.array<3x!fir.type<_QMpolymorphic_testTp1{a:i32,b:i32}>>) ! CHECK: %[[EMBOXED:.*]] = fir.embox %10#0 : (!fir.ref>) -> !fir.class> @@ -547,7 +547,7 @@ subroutine test_elemental_array() ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[C5]], %[[C1]] : index -! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG1:.*]] = %[[ARRAY_LOAD_TMP]]) -> (!fir.array<5xi32>) { +! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG1:.*]] = %[[ARRAY_LOAD_TMP]]) -> (!fir.array<5xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[P]], %[[IND]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] : (!fir.ref>) -> !fir.class> ! CHECK: %[[RES:.*]] = fir.call @_QMpolymorphic_testPelemental_fct(%[[EMBOXED]]) {{.*}} : (!fir.class>) -> i32 @@ -575,7 +575,7 @@ subroutine test_elemental_poly_array(p) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[C5]], %[[C1]] : index -! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD_TMP]]) -> (!fir.array<5xi32>) { +! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD_TMP]]) -> (!fir.array<5xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[P]], %[[IND]] : (!fir.class>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] source_box %[[P]] : (!fir.ref>, !fir.class>>) -> !fir.class> ! CHECK: %[[RES:.*]] = fir.dispatch "elemental_fct"(%[[EMBOXED]] : !fir.class>) (%[[EMBOXED]] : !fir.class>) -> i32 {pass_arg_pos = 0 : i32} @@ -605,8 +605,8 @@ subroutine test_elemental_poly_array_2d(p) ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB0:.*]] = arith.subi %[[C5]], %[[C1]] : index ! CHECK: %[[UB1:.*]] = arith.subi %[[C5_0]], %[[C1]] : index -! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND0:.*]] = %[[C0]] to %[[UB1]] step %[[C1]] unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD_TMP]]) -> (!fir.array<5x5xi32>) { -! CHECK: %[[LOOP_RES0:.*]] = fir.do_loop %[[IND1:.*]] = %[[C0]] to %[[UB0]] step %[[C1]] unordered iter_args(%[[ARG0:.*]] = %[[ARG]]) -> (!fir.array<5x5xi32>) { +! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND0:.*]] = %[[C0]] to %[[UB1]] step %[[C1]] unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD_TMP]]) -> (!fir.array<5x5xi32>) attributes {operandSegmentSizes = array} { +! CHECK: %[[LOOP_RES0:.*]] = fir.do_loop %[[IND1:.*]] = %[[C0]] to %[[UB0]] step %[[C1]] unordered iter_args(%[[ARG0:.*]] = %[[ARG]]) -> (!fir.array<5x5xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[P]], %[[IND1]], %[[IND0]] : (!fir.class>>, index, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] source_box %[[P]] : (!fir.ref>, !fir.class>>) -> !fir.class> ! CHECK: %[[RES:.*]] = fir.dispatch "elemental_fct"(%[[EMBOXED]] : !fir.class>) (%[[EMBOXED]] : !fir.class>) -> i32 {pass_arg_pos = 0 : i32} @@ -634,7 +634,7 @@ subroutine test_elemental_sub_array() ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index -! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] { +! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[T]], %[[IND]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] : (!fir.ref>) -> !fir.class> ! CHECK: fir.call @_QMpolymorphic_testPelemental_sub(%[[EMBOXED]]) {{.*}} : (!fir.class>) -> () @@ -642,7 +642,7 @@ subroutine test_elemental_sub_array() ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index -! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] { +! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[T]], %[[IND]] : (!fir.ref>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] : (!fir.ref>) -> !fir.class> ! CHECK: fir.call @_QMpolymorphic_testPelemental_sub_pass(%{{.*}}, %[[EMBOXED]]) {{.*}} : (!fir.ref, !fir.class>) -> () @@ -660,7 +660,7 @@ subroutine test_elemental_sub_poly_array(p) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index -! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] { +! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[P]], %[[IND]] : (!fir.class>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] source_box %[[P]] : (!fir.ref>, !fir.class>>) -> !fir.class> ! CHECK: fir.dispatch "elemental_sub"(%[[EMBOXED]] : !fir.class>) (%[[EMBOXED]] : !fir.class>) {pass_arg_pos = 0 : i32} @@ -668,7 +668,7 @@ subroutine test_elemental_sub_poly_array(p) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index -! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] { +! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[P]], %[[IND]] : (!fir.class>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] source_box %[[P]] : (!fir.ref>, !fir.class>>) -> !fir.class> ! CHECK: fir.dispatch "elemental_sub_pass"(%[[EMBOXED]] : !fir.class>) (%{{.*}}, %[[EMBOXED]] : !fir.ref, !fir.class>) {pass_arg_pos = 1 : i32} @@ -687,7 +687,7 @@ subroutine test_elemental_sub_array_assumed(t) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[T_DIMS]]#1, %[[C1]] : index -! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] { +! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[T]], %[[IND]] : (!fir.box>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] : (!fir.ref>) -> !fir.class> ! CHECK: fir.call @_QMpolymorphic_testPelemental_sub(%[[EMBOXED]]) {{.*}} : (!fir.class>) -> () @@ -696,7 +696,7 @@ subroutine test_elemental_sub_array_assumed(t) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[T_DIMS]]#1, %[[C1]] : index -! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] { +! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[T]], %[[IND]] : (!fir.box>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] : (!fir.ref>) -> !fir.class> ! CHECK: fir.call @_QMpolymorphic_testPelemental_sub_pass(%{{.*}}, %[[EMBOXED]]) {{.*}} : (!fir.ref, !fir.class>) -> () @@ -715,7 +715,7 @@ subroutine test_elemental_sub_poly_array_assumed(p) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[P_DIMS]]#1, %[[C1]] : index -! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] { +! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[P]], %[[IND]] : (!fir.class>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] source_box %[[P]] : (!fir.ref>, !fir.class>>) -> !fir.class> ! CHECK: fir.dispatch "elemental_sub"(%[[EMBOXED]] : !fir.class>) (%[[EMBOXED]] : !fir.class>) {pass_arg_pos = 0 : i32} @@ -725,7 +725,7 @@ subroutine test_elemental_sub_poly_array_assumed(p) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[P_DIMS]]#1, %[[C1]] : index -! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] { +! CHECK: fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] attributes {operandSegmentSizes = array} { ! CHECK: %[[COORD:.*]] = fir.coordinate_of %[[P]], %[[IND]] : (!fir.class>>, index) -> !fir.ref> ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD]] source_box %[[P]] : (!fir.ref>, !fir.class>>) -> !fir.class> ! CHECK: fir.dispatch "elemental_sub_pass"(%[[EMBOXED]] : !fir.class>) (%{{.*}}, %[[EMBOXED]] : !fir.ref, !fir.class>) {pass_arg_pos = 1 : i32} @@ -1158,7 +1158,7 @@ program test ! CHECK: %[[O:.*]] = fir.load %[[ADDR_O]] : !fir.ref}>>>> ! CHECK: %[[FIELD_INNER:.*]] = fir.field_index inner, !fir.type<_QMpolymorphic_testTouter{inner:!fir.type<_QMpolymorphic_testTp1{a:i32,b:i32}>}> ! CHECK: %[[COORD_INNER:.*]] = fir.coordinate_of %[[O]], %[[FIELD_INNER]] : (!fir.box}>>>, !fir.field) -> !fir.ref> -! CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%arg1 = %9) -> (!fir.array<5x!fir.logical<4>>) { +! CHECK: %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%arg1 = %9) -> (!fir.array<5x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[EMBOXED:.*]] = fir.embox %[[COORD_INNER]] : (!fir.ref>) -> !fir.class> ! CHECK: %{{.*}} = fir.call @_QMpolymorphic_testPlt(%17, %[[EMBOXED]]) {{.*}} : (!fir.ref, !fir.class>) -> !fir.logical<4> ! CHECK: } diff --git a/flang/test/Lower/select-type.f90 b/flang/test/Lower/select-type.f90 index e4ff2fef0efd3..f1d856b25e8ba 100644 --- a/flang/test/Lower/select-type.f90 +++ b/flang/test/Lower/select-type.f90 @@ -476,7 +476,7 @@ subroutine select_type8(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[SELECTOR_DIMS:.*]]#1, %[[C1]] : index -! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND:.*]] = %[[C0:.*]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND:.*]] = %[[C0:.*]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %[[C100]], %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -491,7 +491,7 @@ subroutine select_type8(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[SELECTOR_DIMS]]#1, %[[C1]] : index -! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[LOOP_RES:.*]] = fir.do_loop %[[IND:.*]] = %[[C0]] to %[[UB]] step %[[C1]] unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %[[VALUE]], %[[IND]] : (!fir.array, f32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -508,7 +508,7 @@ subroutine select_type8(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_A]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[EXACT_BOX]] [%[[SLICE]]] : (!fir.box>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -519,7 +519,7 @@ subroutine select_type8(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_B]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[EXACT_BOX]] [%[[SLICE]]] : (!fir.box>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %c{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %c{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -533,7 +533,7 @@ subroutine select_type8(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_A]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[CLASS_BOX]] [%[[SLICE]]] : (!fir.class>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -544,7 +544,7 @@ subroutine select_type8(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_B]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[CLASS_BOX]] [%[[SLICE]]] : (!fir.class>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -555,7 +555,7 @@ subroutine select_type8(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_C]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[CLASS_BOX]] [%[[SLICE]]] : (!fir.class>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -590,7 +590,7 @@ subroutine select_type9(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_A]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[EXACT_BOX]] [%[[SLICE]]] : (!fir.box>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -601,7 +601,7 @@ subroutine select_type9(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_B]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[EXACT_BOX]] [%[[SLICE]]] : (!fir.box>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %c{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %c{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -615,7 +615,7 @@ subroutine select_type9(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_A]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[EXACT_BOX]] [%[[SLICE]]] : (!fir.box>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -626,7 +626,7 @@ subroutine select_type9(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_B]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[EXACT_BOX]] [%[[SLICE]]] : (!fir.box>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } @@ -637,7 +637,7 @@ subroutine select_type9(a) ! CHECK: %[[C1:.*]] = arith.constant 1 : index ! CHECK: %[[SLICE:.*]] = fir.slice %[[C1]], %[[BOX_DIMS]]#1, %[[C1]] path %[[FIELD_C]] : (index, index, index, !fir.field) -> !fir.slice<1> ! CHECK: %[[ARRAY_LOAD:.*]] = fir.array_load %[[EXACT_BOX]] [%[[SLICE]]] : (!fir.box>>, !fir.slice<1>) -> !fir.array -! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) { +! CHECK: %[[DO_RES:.*]] = fir.do_loop %[[IND:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[ARG:.*]] = %[[ARRAY_LOAD]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[ARR_UP:.*]] = fir.array_update %[[ARG]], %{{.*}}, %[[IND]] : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[ARR_UP]] : !fir.array ! CHECK: } diff --git a/flang/test/Lower/statement-function.f90 b/flang/test/Lower/statement-function.f90 index 96d39f9ce0d23..7c2c7c316d554 100644 --- a/flang/test/Lower/statement-function.f90 +++ b/flang/test/Lower/statement-function.f90 @@ -176,6 +176,6 @@ subroutine truncate_arg ! CHECK: %[[c1_i64:.*]] = arith.constant 1 : i64 ! CHECK: %[[ub:.*]] = arith.subi %[[c10]], %[[c1_i64]] : i64 ! CHECK: %[[ub_index:.*]] = fir.convert %[[ub]] : (i64) -> index -! CHECK: fir.do_loop %{{.*}} = %[[select]] to %[[ub_index]] step %{{.*}} { +! CHECK: fir.do_loop %{{.*}} = %[[select]] to %[[ub_index]] step %{{.*}} attributes {operandSegmentSizes = array} { ! CHECK: %[[cast_temp:.*]] = fir.convert %[[temp:.*]] : (!fir.ref>) -> !fir.ref ! CHECK: %{{.*}} = fir.call @_FortranAioOutputAscii(%{{.*}}, %[[cast_temp]], %[[c10]]) {{.*}}: (!fir.ref, !fir.ref, i64) -> i1 diff --git a/flang/test/Lower/structure-constructors.f90 b/flang/test/Lower/structure-constructors.f90 index 14d8bfe04d1f0..ef7da305d94f9 100644 --- a/flang/test/Lower/structure-constructors.f90 +++ b/flang/test/Lower/structure-constructors.f90 @@ -74,7 +74,7 @@ subroutine test_simple_array(x, j) ! CHECK: %[[icoor:.*]] = fir.coordinate_of %[[tmp]], %[[ifield]] : (!fir.ref}>>, !fir.field) -> !fir.ref> ! CHECK: %[[iload:.*]] = fir.array_load %[[icoor]](%{{.*}}) : (!fir.ref>, !fir.shape<1>) -> !fir.array<5xi32> ! CHECK: %[[jload:.*]] = fir.array_load %[[j]](%{{.*}}) : (!fir.ref>, !fir.shape<1>) -> !fir.array<5xi32> - ! CHECK: %[[loop:.*]] = fir.do_loop %[[idx:.*]] = %c0{{.*}} to %{{.*}} step %c1{{.*}} iter_args(%[[res:.*]] = %[[iload]]) -> (!fir.array<5xi32>) { + ! CHECK: %[[loop:.*]] = fir.do_loop %[[idx:.*]] = %c0{{.*}} to %{{.*}} step %c1{{.*}} iter_args(%[[res:.*]] = %[[iload]]) -> (!fir.array<5xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[jval:.*]] = fir.array_fetch %[[jload]], %[[idx]] : (!fir.array<5xi32>, index) -> i32 ! CHECK: %[[ival:.*]] = arith.muli %c2{{.*}}, %[[jval]] : i32 ! CHECK: %[[iupdate:.*]] = fir.array_update %[[res]], %[[ival]], %[[idx]] : (!fir.array<5xi32>, i32, index) -> !fir.array<5xi32> @@ -105,7 +105,7 @@ subroutine test_char_array(x, c1) ! CHECK: %[[VAL_17:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_18:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_12]], %[[VAL_17]] : index - ! CHECK: %[[VAL_20:.*]] = fir.do_loop %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_17]] unordered iter_args(%[[VAL_22:.*]] = %[[VAL_14]]) -> (!fir.array<5x!fir.char<1,3>>) { + ! CHECK: %[[VAL_20:.*]] = fir.do_loop %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_17]] unordered iter_args(%[[VAL_22:.*]] = %[[VAL_14]]) -> (!fir.array<5x!fir.char<1,3>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_23:.*]] = fir.array_access %[[VAL_16]], %[[VAL_21]] : (!fir.array<5x!fir.char<1,3>>, index) -> !fir.ref> ! CHECK: %[[VAL_24:.*]] = fir.array_access %[[VAL_22]], %[[VAL_21]] : (!fir.array<5x!fir.char<1,3>>, index) -> !fir.ref> ! CHECK: %[[VAL_25:.*]] = arith.constant 3 : index @@ -189,7 +189,7 @@ subroutine test_nested(x, d) ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_17:.*]] = arith.constant 4 : index - ! CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_17]] step %[[VAL_16]] { + ! CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_17]] step %[[VAL_16]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_19:.*]] = fir.coordinate_of %[[VAL_14]], %[[VAL_18]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[VAL_20:.*]] = fir.coordinate_of %[[VAL_13]], %[[VAL_18]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[VAL_21:.*]] = fir.load %[[VAL_20]] : !fir.ref @@ -253,7 +253,7 @@ subroutine print_nested(t) ! CHECK: %[[VAL_26:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_27:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_28:.*]] = arith.subi %[[VAL_19]], %[[VAL_26]] : index -! CHECK: %[[VAL_29:.*]] = fir.do_loop %[[VAL_30:.*]] = %[[VAL_27]] to %[[VAL_28]] step %[[VAL_26]] unordered iter_args(%[[VAL_31:.*]] = %[[VAL_21]]) -> (!fir.array<2xi32>) { +! CHECK: %[[VAL_29:.*]] = fir.do_loop %[[VAL_30:.*]] = %[[VAL_27]] to %[[VAL_28]] step %[[VAL_26]] unordered iter_args(%[[VAL_31:.*]] = %[[VAL_21]]) -> (!fir.array<2xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_32:.*]] = fir.array_fetch %[[VAL_25]], %[[VAL_30]] : (!fir.array<2xi32>, index) -> i32 ! CHECK: %[[VAL_33:.*]] = fir.array_update %[[VAL_31]], %[[VAL_32]], %[[VAL_30]] : (!fir.array<2xi32>, i32, index) -> !fir.array<2xi32> ! CHECK: fir.result %[[VAL_33]] : !fir.array<2xi32> @@ -273,7 +273,7 @@ subroutine print_nested(t) ! CHECK: %[[VAL_45:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_46:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_47:.*]] = arith.constant 1 : index -! CHECK: fir.do_loop %[[VAL_48:.*]] = %[[VAL_45]] to %[[VAL_47]] step %[[VAL_46]] { +! CHECK: fir.do_loop %[[VAL_48:.*]] = %[[VAL_45]] to %[[VAL_47]] step %[[VAL_46]] attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_49:.*]] = fir.coordinate_of %[[VAL_44]], %[[VAL_48]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[VAL_50:.*]] = fir.coordinate_of %[[VAL_42]], %[[VAL_48]] : (!fir.ref>, index) -> !fir.ref ! CHECK: %[[VAL_51:.*]] = fir.load %[[VAL_50]] : !fir.ref diff --git a/flang/test/Lower/submodule.f90 b/flang/test/Lower/submodule.f90 index acb39b948f61b..6eb6bd70f73c7 100644 --- a/flang/test/Lower/submodule.f90 +++ b/flang/test/Lower/submodule.f90 @@ -35,7 +35,7 @@ end function fff ! CHECK: %[[V_8:[0-9]+]] = fir.array_load %[[V_6]](%[[V_7]]) : (!fir.ref>, !fir.shape<1>) -> !fir.array ! CHECK: %[[V_9:[0-9]+]] = fir.call @_QMmmSss1Pfff(%arg0) {{.*}} : (!fir.ref) -> i32 ! CHECK: %[[V_10:[0-9]+]] = arith.subi %[[V_5]], %c1{{.*}} : index - ! CHECK: %[[V_11:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_10]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_8]]) -> (!fir.array) { + ! CHECK: %[[V_11:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_10]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_8]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_13:[0-9]+]] = fir.array_update %arg2, %[[V_9]], %arg1 : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[V_13]] : !fir.array ! CHECK: } @@ -64,7 +64,7 @@ end function fff ! CHECK: %[[V_10:[0-9]+]] = fir.load %[[V_0]] : !fir.ref ! CHECK: %[[V_11:[0-9]+]] = arith.addi %[[V_10]], %c2{{.*}} : i32 ! CHECK: %[[V_12:[0-9]+]] = arith.subi %[[V_6]], %c1{{.*}} : index - ! CHECK: %[[V_13:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_12]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_9]]) -> (!fir.array) { + ! CHECK: %[[V_13:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_12]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_9]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_15:[0-9]+]] = fir.array_update %arg2, %[[V_11]], %arg1 : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[V_15]] : !fir.array ! CHECK: } @@ -112,7 +112,7 @@ end function ff1 ! CHECK: %[[V_12:[0-9]+]] = arith.muli %[[V_10]], %[[V_11]] : i32 ! CHECK: %[[V_13:[0-9]+]] = arith.addi %[[V_12]], %c6{{.*}} : i32 ! CHECK: %[[V_14:[0-9]+]] = arith.subi %[[V_6]], %c1{{.*}} : index - ! CHECK: %[[V_15:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_14]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_9]]) -> (!fir.array) { + ! CHECK: %[[V_15:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_14]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_9]]) -> (!fir.array) attributes {operandSegmentSizes = array} { ! CHECK: %[[V_17:[0-9]+]] = fir.array_update %arg2, %[[V_13]], %arg1 : (!fir.array, i32, index) -> !fir.array ! CHECK: fir.result %[[V_17]] : !fir.array ! CHECK: } diff --git a/flang/test/Lower/transformational-intrinsics.f90 b/flang/test/Lower/transformational-intrinsics.f90 index 3dfb689f18d81..4dfe79b0b1564 100644 --- a/flang/test/Lower/transformational-intrinsics.f90 +++ b/flang/test/Lower/transformational-intrinsics.f90 @@ -170,8 +170,8 @@ subroutine in_elem_expr(x, y, z) ! CHECK: %[[VAL_42:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_6]], %[[VAL_41]] : index ! CHECK: %[[VAL_44:.*]] = arith.subi %[[VAL_7]], %[[VAL_41]] : index - ! CHECK: %[[VAL_45:.*]] = fir.do_loop %[[VAL_46:.*]] = %[[VAL_42]] to %[[VAL_44]] step %[[VAL_41]] unordered iter_args(%[[VAL_47:.*]] = %[[VAL_16]]) -> (!fir.array<3x3xi32>) { - ! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %[[VAL_42]] to %[[VAL_43]] step %[[VAL_41]] unordered iter_args(%[[VAL_50:.*]] = %[[VAL_47]]) -> (!fir.array<3x3xi32>) { + ! CHECK: %[[VAL_45:.*]] = fir.do_loop %[[VAL_46:.*]] = %[[VAL_42]] to %[[VAL_44]] step %[[VAL_41]] unordered iter_args(%[[VAL_47:.*]] = %[[VAL_16]]) -> (!fir.array<3x3xi32>) attributes {operandSegmentSizes = array} { + ! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %[[VAL_42]] to %[[VAL_43]] step %[[VAL_41]] unordered iter_args(%[[VAL_50:.*]] = %[[VAL_47]]) -> (!fir.array<3x3xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_51:.*]] = fir.array_fetch %[[VAL_40]], %[[VAL_49]], %[[VAL_46]] : (!fir.array, index, index) -> i32 ! CHECK: %[[VAL_52:.*]] = fir.array_update %[[VAL_50]], %[[VAL_51]], %[[VAL_49]], %[[VAL_46]] : (!fir.array<3x3xi32>, i32, index, index) -> !fir.array<3x3xi32> ! CHECK: fir.result %[[VAL_52]] : !fir.array<3x3xi32> @@ -208,7 +208,7 @@ subroutine in_elem_expr(x, y, z) ! CHECK: %[[VAL_78:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_79:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_80:.*]] = arith.subi %[[VAL_13]], %[[VAL_78]] : index - ! CHECK: %[[VAL_81:.*]] = fir.do_loop %[[VAL_82:.*]] = %[[VAL_79]] to %[[VAL_80]] step %[[VAL_78]] unordered iter_args(%[[VAL_83:.*]] = %[[VAL_56]]) -> (!fir.array<6xi32>) { + ! CHECK: %[[VAL_81:.*]] = fir.do_loop %[[VAL_82:.*]] = %[[VAL_79]] to %[[VAL_80]] step %[[VAL_78]] unordered iter_args(%[[VAL_83:.*]] = %[[VAL_56]]) -> (!fir.array<6xi32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_84:.*]] = fir.array_fetch %[[VAL_77]], %[[VAL_82]] : (!fir.array, index) -> i32 ! CHECK: %[[VAL_85:.*]] = fir.array_update %[[VAL_83]], %[[VAL_84]], %[[VAL_82]] : (!fir.array<6xi32>, i32, index) -> !fir.array<6xi32> ! CHECK: fir.result %[[VAL_85]] : !fir.array<6xi32> diff --git a/flang/test/Lower/where.f90 b/flang/test/Lower/where.f90 index 277cead48f486..c19e3aa709482 100644 --- a/flang/test/Lower/where.f90 +++ b/flang/test/Lower/where.f90 @@ -15,7 +15,7 @@ ! CHECK: %[[VAL_12:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_5]], %[[VAL_12]] : index - ! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (!fir.array<10x!fir.logical<4>>) { + ! CHECK: %[[VAL_15:.*]] = fir.do_loop %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_12]] unordered iter_args(%[[VAL_17:.*]] = %[[VAL_11]]) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_18:.*]] = fir.array_fetch %[[VAL_7]], %[[VAL_16]] : (!fir.array<10xf32>, index) -> f32 ! CHECK: %[[VAL_19:.*]] = arith.cmpf ogt, %[[VAL_18]], %[[VAL_8]] {{.*}} : f32 ! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i1) -> !fir.logical<4> @@ -31,7 +31,7 @@ ! CHECK: %[[VAL_28:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_29:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_30:.*]] = arith.subi %[[VAL_3]], %[[VAL_28]] : index - ! CHECK: %[[VAL_31:.*]] = fir.do_loop %[[VAL_32:.*]] = %[[VAL_29]] to %[[VAL_30]] step %[[VAL_28]] unordered iter_args(%[[VAL_33:.*]] = %[[VAL_25]]) -> (!fir.array<10xf32>) { + ! CHECK: %[[VAL_31:.*]] = fir.do_loop %[[VAL_32:.*]] = %[[VAL_29]] to %[[VAL_30]] step %[[VAL_28]] unordered iter_args(%[[VAL_33:.*]] = %[[VAL_25]]) -> (!fir.array<10xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_34:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_35:.*]] = arith.addi %[[VAL_32]], %[[VAL_34]] : index ! CHECK: %[[VAL_36:.*]] = fir.array_coor %[[VAL_9]](%[[VAL_23]]) %[[VAL_35]] : (!fir.heap>>, !fir.shape<1>, index) -> !fir.ref> @@ -59,7 +59,7 @@ ! CHECK: %[[VAL_53:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_54:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_46]], %[[VAL_53]] : index - ! CHECK: %[[VAL_56:.*]] = fir.do_loop %[[VAL_57:.*]] = %[[VAL_54]] to %[[VAL_55]] step %[[VAL_53]] unordered iter_args(%[[VAL_58:.*]] = %[[VAL_52]]) -> (!fir.array<10x!fir.logical<4>>) { + ! CHECK: %[[VAL_56:.*]] = fir.do_loop %[[VAL_57:.*]] = %[[VAL_54]] to %[[VAL_55]] step %[[VAL_53]] unordered iter_args(%[[VAL_58:.*]] = %[[VAL_52]]) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_59:.*]] = fir.array_fetch %[[VAL_48]], %[[VAL_57]] : (!fir.array<10xf32>, index) -> f32 ! CHECK: %[[VAL_60:.*]] = arith.cmpf ogt, %[[VAL_59]], %[[VAL_49]] {{.*}} : f32 ! CHECK: %[[VAL_61:.*]] = fir.convert %[[VAL_60]] : (i1) -> !fir.logical<4> @@ -76,7 +76,7 @@ ! CHECK: %[[VAL_70:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_71:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_72:.*]] = arith.subi %[[VAL_3]], %[[VAL_70]] : index - ! CHECK: %[[VAL_73:.*]] = fir.do_loop %[[VAL_74:.*]] = %[[VAL_71]] to %[[VAL_72]] step %[[VAL_70]] unordered iter_args(%[[VAL_75:.*]] = %[[VAL_66]]) -> (!fir.array<10xf32>) { + ! CHECK: %[[VAL_73:.*]] = fir.do_loop %[[VAL_74:.*]] = %[[VAL_71]] to %[[VAL_72]] step %[[VAL_70]] unordered iter_args(%[[VAL_75:.*]] = %[[VAL_66]]) -> (!fir.array<10xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_76:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_77:.*]] = arith.addi %[[VAL_74]], %[[VAL_76]] : index ! CHECK: %[[VAL_78:.*]] = fir.array_coor %[[VAL_50]](%[[VAL_64]]) %[[VAL_77]] : (!fir.heap>>, !fir.shape<1>, index) -> !fir.ref> @@ -103,7 +103,7 @@ ! CHECK: %[[VAL_95:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_96:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_97:.*]] = arith.subi %[[VAL_88]], %[[VAL_95]] : index - ! CHECK: %[[VAL_98:.*]] = fir.do_loop %[[VAL_99:.*]] = %[[VAL_96]] to %[[VAL_97]] step %[[VAL_95]] unordered iter_args(%[[VAL_100:.*]] = %[[VAL_94]]) -> (!fir.array<10x!fir.logical<4>>) { + ! CHECK: %[[VAL_98:.*]] = fir.do_loop %[[VAL_99:.*]] = %[[VAL_96]] to %[[VAL_97]] step %[[VAL_95]] unordered iter_args(%[[VAL_100:.*]] = %[[VAL_94]]) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_101:.*]] = fir.array_fetch %[[VAL_90]], %[[VAL_99]] : (!fir.array<10xf32>, index) -> f32 ! CHECK: %[[VAL_102:.*]] = arith.cmpf ogt, %[[VAL_101]], %[[VAL_91]] {{.*}} : f32 ! CHECK: %[[VAL_103:.*]] = fir.convert %[[VAL_102]] : (i1) -> !fir.logical<4> @@ -120,7 +120,7 @@ ! CHECK: %[[VAL_112:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_113:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_114:.*]] = arith.subi %[[VAL_3]], %[[VAL_112]] : index - ! CHECK: %[[VAL_115:.*]] = fir.do_loop %[[VAL_116:.*]] = %[[VAL_113]] to %[[VAL_114]] step %[[VAL_112]] unordered iter_args(%[[VAL_117:.*]] = %[[VAL_108]]) -> (!fir.array<10xf32>) { + ! CHECK: %[[VAL_115:.*]] = fir.do_loop %[[VAL_116:.*]] = %[[VAL_113]] to %[[VAL_114]] step %[[VAL_112]] unordered iter_args(%[[VAL_117:.*]] = %[[VAL_108]]) -> (!fir.array<10xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_118:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_119:.*]] = arith.addi %[[VAL_116]], %[[VAL_118]] : index ! CHECK: %[[VAL_120:.*]] = fir.array_coor %[[VAL_50]](%[[VAL_64]]) %[[VAL_119]] : (!fir.heap>>, !fir.shape<1>, index) -> !fir.ref> @@ -155,7 +155,7 @@ ! CHECK: %[[VAL_141:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_142:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_143:.*]] = arith.subi %[[VAL_1]], %[[VAL_141]] : index - ! CHECK: %[[VAL_144:.*]] = fir.do_loop %[[VAL_145:.*]] = %[[VAL_142]] to %[[VAL_143]] step %[[VAL_141]] unordered iter_args(%[[VAL_146:.*]] = %[[VAL_137]]) -> (!fir.array<10xf32>) { + ! CHECK: %[[VAL_144:.*]] = fir.do_loop %[[VAL_145:.*]] = %[[VAL_142]] to %[[VAL_143]] step %[[VAL_141]] unordered iter_args(%[[VAL_146:.*]] = %[[VAL_137]]) -> (!fir.array<10xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_147:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_148:.*]] = arith.addi %[[VAL_145]], %[[VAL_147]] : index ! CHECK: %[[VAL_149:.*]] = fir.array_coor %[[VAL_50]](%[[VAL_64]]) %[[VAL_148]] : (!fir.heap>>, !fir.shape<1>, index) -> !fir.ref> @@ -190,7 +190,7 @@ ! CHECK: %[[VAL_170:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_171:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_172:.*]] = arith.subi %[[VAL_1]], %[[VAL_170]] : index - ! CHECK: %[[VAL_173:.*]] = fir.do_loop %[[VAL_174:.*]] = %[[VAL_171]] to %[[VAL_172]] step %[[VAL_170]] unordered iter_args(%[[VAL_175:.*]] = %[[VAL_166]]) -> (!fir.array<10xf32>) { + ! CHECK: %[[VAL_173:.*]] = fir.do_loop %[[VAL_174:.*]] = %[[VAL_171]] to %[[VAL_172]] step %[[VAL_170]] unordered iter_args(%[[VAL_175:.*]] = %[[VAL_166]]) -> (!fir.array<10xf32>) attributes {operandSegmentSizes = array} { ! CHECK: %[[VAL_176:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_177:.*]] = arith.addi %[[VAL_174]], %[[VAL_176]] : index ! CHECK: %[[VAL_178:.*]] = fir.array_coor %[[VAL_50]](%[[VAL_64]]) %[[VAL_177]] : (!fir.heap>>, !fir.shape<1>, index) -> !fir.ref> diff --git a/flang/test/Semantics/resolve123.f90 b/flang/test/Semantics/resolve123.f90 new file mode 100644 index 0000000000000..1b2c4613f2fef --- /dev/null +++ b/flang/test/Semantics/resolve123.f90 @@ -0,0 +1,79 @@ +! RUN: %python %S/test_errors.py %s %flang_fc1 +! Tests for F'2023 C1131: +! A variable-name that appears in a REDUCE locality-spec shall not have the +! ASYNCHRONOUS, INTENT (IN), OPTIONAL, or VOLATILE attribute, shall not be +! coindexed, and shall not be an assumed-size array. A variable-name that is not +! permitted to appear in a variable definition context shall not appear in a +! REDUCE locality-spec. + +subroutine s1() +! Cannot have ASYNCHRONOUS variable in a REDUCE locality spec + integer, asynchronous :: k +!ERROR: ASYNCHRONOUS variable 'k' not allowed in a REDUCE locality-spec + do concurrent(i=1:5) reduce(+:k) + k = k + i + end do +end subroutine s1 + +subroutine s2(arg) +! Cannot have a dummy OPTIONAL in a REDUCE locality spec + integer, optional :: arg +!ERROR: OPTIONAL argument 'arg' not allowed in a locality-spec + do concurrent(i=1:5) reduce(*:arg) + arg = arg * 1 + end do +end subroutine s2 + +subroutine s3(arg) +! This is OK + real :: arg + integer :: reduce, reduce2, reduce3 + do concurrent(i=1:5) reduce(max:arg,reduce) reduce(iand:reduce2,reduce3) + arg = max(arg, i) + reduce = max(reduce, i) + reduce3 = iand(reduce3, i) + end do +end subroutine s3 + +subroutine s4(arg) +! Cannot have a dummy INTENT(IN) in a REDUCE locality spec + real, intent(in) :: arg +!ERROR: INTENT IN argument 'arg' not allowed in a locality-spec + do concurrent(i=1:5) reduce(min:arg) +!ERROR: Left-hand side of assignment is not definable +!ERROR: 'arg' is an INTENT(IN) dummy argument + arg = min(arg, i) + end do +end subroutine s4 + +module m +contains + subroutine s5() + ! Cannot have VOLATILE variable in a REDUCE locality spec + integer, volatile :: var + !ERROR: VOLATILE variable 'var' not allowed in a REDUCE locality-spec + do concurrent(i=1:5) reduce(ieor:var) + var = ieor(var, i) + end do + end subroutine s5 + subroutine f(x) + integer :: x + end subroutine f +end module m + +subroutine s8(arg) +! Cannot have an assumed size array + integer, dimension(*) :: arg +!ERROR: Assumed size array 'arg' not allowed in a locality-spec + do concurrent(i=1:5) reduce(ior:arg) + arg(i) = ior(arg(i), i) + end do +end subroutine s8 + +subroutine s9() +! Reduction variable should not appear in a variable definition context + integer :: i +!ERROR: 'i' is already declared in this scoping unit + do concurrent(i=1:5) reduce(+:i) + end do +end subroutine s9 diff --git a/flang/test/Semantics/resolve124.f90 b/flang/test/Semantics/resolve124.f90 new file mode 100644 index 0000000000000..efb920c6f5d7f --- /dev/null +++ b/flang/test/Semantics/resolve124.f90 @@ -0,0 +1,89 @@ +! RUN: %python %S/test_errors.py %s %flang_fc1 +! Tests for F'2023 C1132: +! A variable-name that appears in a REDUCE locality-spec shall be of intrinsic +! type suitable for the intrinsic operation or function specified by its +! reduce-operation. + +subroutine s1(n) +! This is OK + integer :: i1, i2, i3, i4, i5, i6, i7, n + real(8) :: r1, r2, r3, r4 + complex :: c1, c2 + logical :: l1, l2, l3(n,n), l4(n) + do concurrent(i=1:5) & + & reduce(+:i1,r1,c1) reduce(*:i2,r2,c2) reduce(iand:i3) reduce(ieor:i4) & + & reduce(ior:i5) reduce(max:i6,r3) reduce(min:i7,r4) reduce(.and.:l1) & + & reduce(.or.:l2) reduce(.eqv.:l3) reduce(.neqv.:l4) + end do +end subroutine s1 + +subroutine s2() +! Cannot apply logical operations to integer variables + integer :: i1, i2, i3, i4 +!ERROR: Reduction variable 'i1' does not have a suitable type. +!ERROR: Reduction variable 'i2' does not have a suitable type. +!ERROR: Reduction variable 'i3' does not have a suitable type. +!ERROR: Reduction variable 'i4' does not have a suitable type. + do concurrent(i=1:5) & + & reduce(.and.:i1) reduce(.or.:i2) reduce(.eqv.:i3) reduce(.neqv.:i4) + end do +end subroutine s2 + +subroutine s3() +! Cannot apply integer/logical operations to real variables + real :: r1, r2, r3, r4 +!ERROR: Reduction variable 'r1' does not have a suitable type. +!ERROR: Reduction variable 'r2' does not have a suitable type. +!ERROR: Reduction variable 'r3' does not have a suitable type. +!ERROR: Reduction variable 'r4' does not have a suitable type. +!ERROR: Reduction variable 'r5' does not have a suitable type. +!ERROR: Reduction variable 'r6' does not have a suitable type. +!ERROR: Reduction variable 'r7' does not have a suitable type. + do concurrent(i=1:5) & + & reduce(iand:r1) reduce(ieor:r2) reduce(ior:r3) reduce(.and.:r4) & + & reduce(.or.:r5) reduce(.eqv.:r6) reduce(.neqv.:r7) + end do +end subroutine s3 + +subroutine s4() +! Cannot apply integer/logical operations to complex variables + complex :: c1, c2, c3, c4, c5, c6, c7, c8, c9 +!ERROR: Reduction variable 'c1' does not have a suitable type. +!ERROR: Reduction variable 'c2' does not have a suitable type. +!ERROR: Reduction variable 'c3' does not have a suitable type. +!ERROR: Reduction variable 'c4' does not have a suitable type. +!ERROR: Reduction variable 'c5' does not have a suitable type. +!ERROR: Reduction variable 'c6' does not have a suitable type. +!ERROR: Reduction variable 'c7' does not have a suitable type. +!ERROR: Reduction variable 'c8' does not have a suitable type. +!ERROR: Reduction variable 'c9' does not have a suitable type. + do concurrent(i=1:5) & + & reduce(iand:c1) reduce(ieor:c2) reduce(ior:c3) reduce(max:c4) & + & reduce(min:c5) reduce(.and.:c6) reduce(.or.:c7) reduce(.eqv.:c8) & + & reduce(.neqv.:c9) + end do +end subroutine s4 + +subroutine s5() +! Cannot apply integer operations to logical variables + logical :: l1, l2, l3, l4, l5, l6, l7 +!ERROR: Reduction variable 'l1' does not have a suitable type. +!ERROR: Reduction variable 'l2' does not have a suitable type. +!ERROR: Reduction variable 'l3' does not have a suitable type. +!ERROR: Reduction variable 'l4' does not have a suitable type. +!ERROR: Reduction variable 'l5' does not have a suitable type. +!ERROR: Reduction variable 'l6' does not have a suitable type. +!ERROR: Reduction variable 'l7' does not have a suitable type. + do concurrent(i=1:5) & + & reduce(+:l1) reduce(*:l2) reduce(iand:l3) reduce(ieor:l4) & + & reduce(ior:l5) reduce(max:l6) reduce(min:l7) + end do +end subroutine s5 + +subroutine s6() +! Cannot reduce a character + character ch +!ERROR: Reduction variable 'ch' does not have a suitable type. + do concurrent(i=1:5) reduce(+:ch) + end do +end subroutine s6 diff --git a/flang/test/Semantics/resolve55.f90 b/flang/test/Semantics/resolve55.f90 index 1133e791fa389..54ecb341a82e4 100644 --- a/flang/test/Semantics/resolve55.f90 +++ b/flang/test/Semantics/resolve55.f90 @@ -1,16 +1,19 @@ ! RUN: %python %S/test_errors.py %s %flang_fc1 -! Tests for C1128: +! Tests for C1128 and F'2023 C1130: ! A variable-name that appears in a LOCAL or LOCAL_INIT locality-spec shall not ! have the ALLOCATABLE; INTENT (IN); or OPTIONAL attribute; shall not be of ! finalizable type; shall not be a nonpointer polymorphic dummy argument; and ! shall not be a coarray or an assumed-size array. subroutine s1() -! Cannot have ALLOCATABLE variable in a locality spec +! Cannot have ALLOCATABLE variable in a LOCAL/LOCAL_INIT locality spec integer, allocatable :: k -!ERROR: ALLOCATABLE variable 'k' not allowed in a locality-spec +!ERROR: ALLOCATABLE variable 'k' not allowed in a LOCAL locality-spec do concurrent(i=1:5) local(k) end do +!ERROR: ALLOCATABLE variable 'k' not allowed in a LOCAL_INIT locality-spec + do concurrent(i=1:5) local_init(k) + end do end subroutine s1 subroutine s2(arg) @@ -37,7 +40,7 @@ subroutine s4(arg) end subroutine s4 module m -! Cannot have a variable of a finalizable type in a locality spec +! Cannot have a variable of a finalizable type in a LOCAL locality spec type t1 integer :: i contains @@ -46,7 +49,7 @@ module m contains subroutine s5() type(t1) :: var - !ERROR: Finalizable variable 'var' not allowed in a locality-spec + !ERROR: Finalizable variable 'var' not allowed in a LOCAL locality-spec do concurrent(i=1:5) local(var) end do end subroutine s5 @@ -56,7 +59,7 @@ end subroutine f end module m subroutine s6 -! Cannot have a nonpointer polymorphic dummy argument in a locality spec +! Cannot have a nonpointer polymorphic dummy argument in a LOCAL locality spec type :: t integer :: field end type t @@ -70,7 +73,7 @@ subroutine s(x, y) end do ! This is not allowed -!ERROR: Nonpointer polymorphic argument 'y' not allowed in a locality-spec +!ERROR: Nonpointer polymorphic argument 'y' not allowed in a LOCAL locality-spec do concurrent(i=1:5) local(y) end do end subroutine s @@ -79,7 +82,7 @@ end subroutine s6 subroutine s7() ! Cannot have a coarray integer, codimension[*] :: coarray_var -!ERROR: Coarray 'coarray_var' not allowed in a locality-spec +!ERROR: Coarray 'coarray_var' not allowed in a LOCAL locality-spec do concurrent(i=1:5) local(coarray_var) end do end subroutine s7 diff --git a/flang/test/Transforms/loop-versioning.fir b/flang/test/Transforms/loop-versioning.fir index 0c62741656347..26c026e3ab9e8 100644 --- a/flang/test/Transforms/loop-versioning.fir +++ b/flang/test/Transforms/loop-versioning.fir @@ -25,7 +25,7 @@ module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry : %4 = fir.convert %3 : (i32) -> index %c1 = arith.constant 1 : index %5 = fir.convert %2 : (index) -> i32 - %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) { + %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg3 to %0 : !fir.ref %7 = fir.load %1 : !fir.ref %8 = fir.load %0 : !fir.ref @@ -89,7 +89,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %4 = fir.convert %3 : (i32) -> index %c1 = arith.constant 1 : index %5 = fir.convert %2 : (index) -> i32 - %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) { + %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg3 to %0 : !fir.ref %7 = fir.load %1 : !fir.ref %8 = fir.load %0 : !fir.ref @@ -134,7 +134,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %c1_0 = arith.constant 1 : index %c0_1 = arith.constant 0 : index %5 = arith.subi %3#1, %c1_0 : index - fir.do_loop %arg2 = %c0_1 to %5 step %c1_0 { + fir.do_loop %arg2 = %c0_1 to %5 step %c1_0 attributes {operandSegmentSizes = array} { %7 = fir.coordinate_of %arg1, %arg2 : (!fir.box>, index) -> !fir.ref %8 = fir.load %7 : !fir.ref %9 = fir.convert %8 : (i32) -> index @@ -157,7 +157,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, // CHECK: fir.if %[[COMP]] { // CHECK: %[[CONV:.*]] = fir.convert %[[Y]] : {{.*}} // CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[CONV]] : {{.*}} -// CHECK: fir.do_loop %[[INDEX:.*]] = {{.*}} +// CHECK: fir.do_loop %[[INDEX:.*]] = {{.*}} attributes {{.*}} // CHECK: %[[YADDR:.*]] = fir.coordinate_of %[[BOX_ADDR]], %[[INDEX]] // CHECK: %[[YINT:.*]] = fir.load %[[YADDR]] : {{.*}} // CHECK: %[[YINDEX:.*]] = fir.convert %[[YINT]] @@ -165,7 +165,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, // CHECK: fir.call @Func(%[[XADDR]]) // CHECK-NEXT: } // CHECK-NEXT: } else { -// CHECK: fir.do_loop %[[INDEX2:.*]] = {{.*}} +// CHECK: fir.do_loop %[[INDEX2:.*]] = {{.*}} attributes {{.*}} // CHECK: %[[YADDR2:.*]] = fir.coordinate_of %[[Y]], %[[INDEX2]] // CHECK: %[[YINT2:.*]] = fir.load %[[YADDR2]] : {{.*}} // CHECK: %[[YINDEX2:.*]] = fir.convert %[[YINT2]] @@ -206,7 +206,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %9 = fir.load %arg3 : !fir.ref %10 = fir.convert %9 : (i32) -> i64 %11 = fir.convert %10 : (i64) -> index - %12 = fir.do_loop %arg4 = %5 to %8 step %11 iter_args(%arg5 = %4) -> (!fir.heap) { + %12 = fir.do_loop %arg4 = %5 to %8 step %11 iter_args(%arg5 = %4) -> (!fir.heap) attributes {operandSegmentSizes = array} { %c1_i64_2 = arith.constant 1 : i64 %19 = fir.convert %c1_i64_2 : (i64) -> index %20 = fir.load %arg2 : !fir.ref @@ -215,7 +215,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %23 = fir.load %arg3 : !fir.ref %24 = fir.convert %23 : (i32) -> i64 %25 = fir.convert %24 : (i64) -> index - %26 = fir.do_loop %arg6 = %19 to %22 step %25 iter_args(%arg7 = %arg5) -> (!fir.heap) { + %26 = fir.do_loop %arg6 = %19 to %22 step %25 iter_args(%arg7 = %arg5) -> (!fir.heap) attributes {operandSegmentSizes = array} { %27 = fir.convert %arg4 : (index) -> i32 %28 = fir.convert %27 : (i32) -> i64 %c1_i64_3 = arith.constant 1 : i64 @@ -247,7 +247,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %c1 = arith.constant 1 : index %c0_1 = arith.constant 0 : index %17 = arith.subi %2#1, %c1 : index - %18 = fir.do_loop %arg4 = %c0_1 to %17 step %c1 unordered iter_args(%arg5 = %3) -> (!fir.array) { + %18 = fir.do_loop %arg4 = %c0_1 to %17 step %c1 unordered iter_args(%arg5 = %3) -> (!fir.array) attributes {operandSegmentSizes = array} { %19 = fir.array_fetch %16, %arg4 : (!fir.array, index) -> f32 %20 = fir.array_update %arg5, %19, %arg4 : (!fir.array, f32, index) -> !fir.array fir.result %20 : !fir.array @@ -310,7 +310,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %5 = fir.convert %4 : (i32) -> index %c1 = arith.constant 1 : index %6 = fir.convert %3 : (index) -> i32 - %7:2 = fir.do_loop %arg3 = %3 to %5 step %c1 iter_args(%arg4 = %6) -> (index, i32) { + %7:2 = fir.do_loop %arg3 = %3 to %5 step %c1 iter_args(%arg4 = %6) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg4 to %0 : !fir.ref %c1_i32_0 = arith.constant 1 : i32 %8 = fir.convert %c1_i32_0 : (i32) -> index @@ -318,7 +318,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %10 = fir.convert %9 : (i32) -> index %c1_1 = arith.constant 1 : index %11 = fir.convert %8 : (index) -> i32 - %12:2 = fir.do_loop %arg5 = %8 to %10 step %c1_1 iter_args(%arg6 = %11) -> (index, i32) { + %12:2 = fir.do_loop %arg5 = %8 to %10 step %c1_1 iter_args(%arg6 = %11) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg6 to %1 : !fir.ref %17 = fir.load %2 : !fir.ref %18 = fir.load %1 : !fir.ref @@ -419,7 +419,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %6 = fir.convert %5 : (i32) -> index %c1 = arith.constant 1 : index %7 = fir.convert %4 : (index) -> i32 - %8:2 = fir.do_loop %arg4 = %4 to %6 step %c1 iter_args(%arg5 = %7) -> (index, i32) { + %8:2 = fir.do_loop %arg4 = %4 to %6 step %c1 iter_args(%arg5 = %7) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg5 to %2 : !fir.ref %c1_i32_0 = arith.constant 1 : i32 %9 = fir.convert %c1_i32_0 : (i32) -> index @@ -427,7 +427,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %11 = fir.convert %10 : (i32) -> index %c1_1 = arith.constant 1 : index %12 = fir.convert %9 : (index) -> i32 - %13:2 = fir.do_loop %arg6 = %9 to %11 step %c1_1 iter_args(%arg7 = %12) -> (index, i32) { + %13:2 = fir.do_loop %arg6 = %9 to %11 step %c1_1 iter_args(%arg7 = %12) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg7 to %1 : !fir.ref %c0_i32 = arith.constant 0 : i32 %18 = fir.convert %c0_i32 : (i32) -> index @@ -435,7 +435,7 @@ func.func @sum1dfixed(%arg0: !fir.ref> {fir.bindc_name = "a"}, %20 = fir.convert %19 : (i32) -> index %c1_2 = arith.constant 1 : index %21 = fir.convert %18 : (index) -> i32 - %22:2 = fir.do_loop %arg8 = %18 to %20 step %c1_2 iter_args(%arg9 = %21) -> (index, i32) { + %22:2 = fir.do_loop %arg8 = %18 to %20 step %c1_2 iter_args(%arg9 = %21) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg9 to %0 : !fir.ref %27 = fir.load %3 : !fir.ref %28 = fir.load %0 : !fir.ref @@ -528,7 +528,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name %c0_i64 = arith.constant 0 : i64 %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMcheck_modFtestEi"} %1 = fir.convert %c1 : (index) -> i32 - %2:2 = fir.do_loop %arg1 = %c1 to %c20 step %c1 iter_args(%arg2 = %1) -> (index, i32) { + %2:2 = fir.do_loop %arg1 = %c1 to %c20 step %c1 iter_args(%arg2 = %1) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %0 : !fir.ref %3 = fir.is_present %arg0 : (!fir.box>) -> i1 fir.if %3 { @@ -551,7 +551,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK-NEXT: %[[VAL_3:.*]] = arith.constant 0 : i64 // CHECK-NEXT: %[[VAL_4:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QMcheck_modFtestEi"} // CHECK-NEXT: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (index) -> i32 -// CHECK-NEXT: %[[VAL_6:.*]]:2 = fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] iter_args(%[[VAL_8:.*]] = %[[VAL_5]]) -> (index, i32) { +// CHECK-NEXT: %[[VAL_6:.*]]:2 = fir.do_loop %[[VAL_7:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_1]] iter_args(%[[VAL_8:.*]] = %[[VAL_5]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: fir.store %[[VAL_8]] to %[[VAL_4]] : !fir.ref // CHECK-NEXT: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.box>) -> i1 // CHECK-NEXT: fir.if %[[VAL_9]] { @@ -583,7 +583,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name %7 = fir.load %4 : !fir.ref %8 = fir.convert %7 : (i32) -> index %9 = fir.convert %c1 : (index) -> i32 - %10:2 = fir.do_loop %arg2 = %c1 to %8 step %c1 iter_args(%arg3 = %9) -> (index, i32) { + %10:2 = fir.do_loop %arg2 = %c1 to %8 step %c1 iter_args(%arg3 = %9) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg3 to %3 : !fir.ref %11 = fir.load %6 : !fir.ref %12 = fir.load %3 : !fir.ref @@ -623,7 +623,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: %[[VAL_18:.*]]:2 = fir.if %[[VAL_17]] -> (index, i32) { // CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_5]] : (!fir.box>) -> !fir.box> // CHECK: %[[VAL_20:.*]] = fir.box_addr %[[VAL_19]] : (!fir.box>) -> !fir.ref> -// CHECK: %[[VAL_21:.*]]:2 = fir.do_loop %[[VAL_22:.*]] = %[[VAL_2]] to %[[VAL_12]] step %[[VAL_2]] iter_args(%[[VAL_23:.*]] = %[[VAL_13]]) -> (index, i32) { +// CHECK: %[[VAL_21:.*]]:2 = fir.do_loop %[[VAL_22:.*]] = %[[VAL_2]] to %[[VAL_12]] step %[[VAL_2]] iter_args(%[[VAL_23:.*]] = %[[VAL_13]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_23]] to %[[VAL_7]] : !fir.ref // CHECK: %[[VAL_24:.*]] = fir.load %[[VAL_10]] : !fir.ref // CHECK: %[[VAL_25:.*]] = fir.load %[[VAL_7]] : !fir.ref @@ -642,7 +642,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: } // CHECK: fir.result %[[VAL_36:.*]]#0, %[[VAL_36]]#1 : index, i32 // CHECK: } else { -// CHECK: %[[VAL_37:.*]]:2 = fir.do_loop %[[VAL_38:.*]] = %[[VAL_2]] to %[[VAL_12]] step %[[VAL_2]] iter_args(%[[VAL_39:.*]] = %[[VAL_13]]) -> (index, i32) { +// CHECK: %[[VAL_37:.*]]:2 = fir.do_loop %[[VAL_38:.*]] = %[[VAL_2]] to %[[VAL_12]] step %[[VAL_2]] iter_args(%[[VAL_39:.*]] = %[[VAL_13]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_39]] to %[[VAL_7]] : !fir.ref // CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_10]] : !fir.ref // CHECK: %[[VAL_41:.*]] = fir.load %[[VAL_7]] : !fir.ref @@ -680,11 +680,11 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name %10 = fir.load %6 : !fir.ref %11 = fir.convert %10 : (i32) -> index %12 = fir.convert %c1 : (index) -> i32 - %13:2 = fir.do_loop %arg3 = %c1 to %11 step %c1 iter_args(%arg4 = %12) -> (index, i32) { + %13:2 = fir.do_loop %arg3 = %c1 to %11 step %c1 iter_args(%arg4 = %12) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg4 to %3 : !fir.ref %14 = fir.load %7 : !fir.ref %15 = fir.convert %14 : (i32) -> index - %16:2 = fir.do_loop %arg5 = %c1 to %15 step %c1 iter_args(%arg6 = %12) -> (index, i32) { + %16:2 = fir.do_loop %arg5 = %c1 to %15 step %c1 iter_args(%arg6 = %12) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg6 to %5 : !fir.ref %20 = fir.load %9 : !fir.ref %21 = fir.load %5 : !fir.ref @@ -729,7 +729,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_11]] : !fir.ref // CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i32) -> index // CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_3]] : (index) -> i32 -// CHECK: %[[VAL_18:.*]]:2 = fir.do_loop %[[VAL_19:.*]] = %[[VAL_3]] to %[[VAL_16]] step %[[VAL_3]] iter_args(%[[VAL_20:.*]] = %[[VAL_17]]) -> (index, i32) { +// CHECK: %[[VAL_18:.*]]:2 = fir.do_loop %[[VAL_19:.*]] = %[[VAL_3]] to %[[VAL_16]] step %[[VAL_3]] iter_args(%[[VAL_20:.*]] = %[[VAL_17]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_20]] to %[[VAL_8]] : !fir.ref // CHECK: %[[VAL_21:.*]] = fir.load %[[VAL_12]] : !fir.ref // CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_21]] : (i32) -> index @@ -742,7 +742,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: %[[VAL_29:.*]]:2 = fir.if %[[VAL_28]] -> (index, i32) { // CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_6]] : (!fir.box>) -> !fir.box> // CHECK: %[[VAL_31:.*]] = fir.box_addr %[[VAL_30]] : (!fir.box>) -> !fir.ref> -// CHECK: %[[VAL_32:.*]]:2 = fir.do_loop %[[VAL_33:.*]] = %[[VAL_3]] to %[[VAL_22]] step %[[VAL_3]] iter_args(%[[VAL_34:.*]] = %[[VAL_17]]) -> (index, i32) { +// CHECK: %[[VAL_32:.*]]:2 = fir.do_loop %[[VAL_33:.*]] = %[[VAL_3]] to %[[VAL_22]] step %[[VAL_3]] iter_args(%[[VAL_34:.*]] = %[[VAL_17]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_34]] to %[[VAL_10]] : !fir.ref // CHECK: %[[VAL_35:.*]] = fir.load %[[VAL_14]] : !fir.ref // CHECK: %[[VAL_36:.*]] = fir.load %[[VAL_10]] : !fir.ref @@ -770,7 +770,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: } // CHECK: fir.result %[[VAL_56:.*]]#0, %[[VAL_56]]#1 : index, i32 // CHECK: } else { -// CHECK: %[[VAL_57:.*]]:2 = fir.do_loop %[[VAL_58:.*]] = %[[VAL_3]] to %[[VAL_22]] step %[[VAL_3]] iter_args(%[[VAL_59:.*]] = %[[VAL_17]]) -> (index, i32) { +// CHECK: %[[VAL_57:.*]]:2 = fir.do_loop %[[VAL_58:.*]] = %[[VAL_3]] to %[[VAL_22]] step %[[VAL_3]] iter_args(%[[VAL_59:.*]] = %[[VAL_17]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_59]] to %[[VAL_10]] : !fir.ref // CHECK: %[[VAL_60:.*]] = fir.load %[[VAL_14]] : !fir.ref // CHECK: %[[VAL_61:.*]] = fir.load %[[VAL_10]] : !fir.ref @@ -820,16 +820,16 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name %13 = fir.load %10 : !fir.ref %14 = fir.convert %13 : (i32) -> index %15 = fir.convert %c1 : (index) -> i32 - %16:2 = fir.do_loop %arg4 = %c1 to %14 step %c1 iter_args(%arg5 = %15) -> (index, i32) { + %16:2 = fir.do_loop %arg4 = %c1 to %14 step %c1 iter_args(%arg5 = %15) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg5 to %7 : !fir.ref %17 = fir.load %9 : !fir.ref %18 = fir.convert %17 : (i32) -> index - %19:2 = fir.do_loop %arg6 = %c1 to %18 step %c1 iter_args(%arg7 = %15) -> (index, i32) { + %19:2 = fir.do_loop %arg6 = %c1 to %18 step %c1 iter_args(%arg7 = %15) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg7 to %5 : !fir.ref %23 = fir.load %8 : !fir.ref %24 = fir.convert %23 : (i32) -> index %25 = fir.convert %c0 : (index) -> i32 - %26:2 = fir.do_loop %arg8 = %c0 to %24 step %c1 iter_args(%arg9 = %25) -> (index, i32) { + %26:2 = fir.do_loop %arg8 = %c0 to %24 step %c1 iter_args(%arg9 = %25) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg9 to %3 : !fir.ref %30 = fir.load %12 : !fir.ref %31 = fir.load %3 : !fir.ref @@ -887,11 +887,11 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: %[[VAL_20:.*]] = fir.load %[[VAL_17]] : !fir.ref // CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> index // CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_5]] : (index) -> i32 -// CHECK: %[[VAL_23:.*]]:2 = fir.do_loop %[[VAL_24:.*]] = %[[VAL_5]] to %[[VAL_21]] step %[[VAL_5]] iter_args(%[[VAL_25:.*]] = %[[VAL_22]]) -> (index, i32) { +// CHECK: %[[VAL_23:.*]]:2 = fir.do_loop %[[VAL_24:.*]] = %[[VAL_5]] to %[[VAL_21]] step %[[VAL_5]] iter_args(%[[VAL_25:.*]] = %[[VAL_22]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_25]] to %[[VAL_14]] : !fir.ref // CHECK: %[[VAL_26:.*]] = fir.load %[[VAL_16]] : !fir.ref // CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i32) -> index -// CHECK: %[[VAL_28:.*]]:2 = fir.do_loop %[[VAL_29:.*]] = %[[VAL_5]] to %[[VAL_27]] step %[[VAL_5]] iter_args(%[[VAL_30:.*]] = %[[VAL_22]]) -> (index, i32) { +// CHECK: %[[VAL_28:.*]]:2 = fir.do_loop %[[VAL_29:.*]] = %[[VAL_5]] to %[[VAL_27]] step %[[VAL_5]] iter_args(%[[VAL_30:.*]] = %[[VAL_22]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_30]] to %[[VAL_12]] : !fir.ref // CHECK: %[[VAL_31:.*]] = fir.load %[[VAL_15]] : !fir.ref // CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_31]] : (i32) -> index @@ -907,7 +907,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: %[[VAL_42:.*]]:2 = fir.if %[[VAL_41]] -> (index, i32) { // CHECK: %[[VAL_43:.*]] = fir.convert %[[VAL_8]] : (!fir.box>) -> !fir.box> // CHECK: %[[VAL_44:.*]] = fir.box_addr %[[VAL_43]] : (!fir.box>) -> !fir.ref> -// CHECK: %[[VAL_45:.*]]:2 = fir.do_loop %[[VAL_46:.*]] = %[[VAL_4]] to %[[VAL_32]] step %[[VAL_5]] iter_args(%[[VAL_47:.*]] = %[[VAL_33]]) -> (index, i32) { +// CHECK: %[[VAL_45:.*]]:2 = fir.do_loop %[[VAL_46:.*]] = %[[VAL_4]] to %[[VAL_32]] step %[[VAL_5]] iter_args(%[[VAL_47:.*]] = %[[VAL_33]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_47]] to %[[VAL_10]] : !fir.ref // CHECK: %[[VAL_48:.*]] = fir.load %[[VAL_19]] : !fir.ref // CHECK: %[[VAL_49:.*]] = fir.load %[[VAL_10]] : !fir.ref @@ -942,7 +942,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: } // CHECK: fir.result %[[VAL_76:.*]]#0, %[[VAL_76]]#1 : index, i32 // CHECK: } else { -// CHECK: %[[VAL_77:.*]]:2 = fir.do_loop %[[VAL_78:.*]] = %[[VAL_4]] to %[[VAL_32]] step %[[VAL_5]] iter_args(%[[VAL_79:.*]] = %[[VAL_33]]) -> (index, i32) { +// CHECK: %[[VAL_77:.*]]:2 = fir.do_loop %[[VAL_78:.*]] = %[[VAL_4]] to %[[VAL_32]] step %[[VAL_5]] iter_args(%[[VAL_79:.*]] = %[[VAL_33]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_79]] to %[[VAL_10]] : !fir.ref // CHECK: %[[VAL_80:.*]] = fir.load %[[VAL_19]] : !fir.ref // CHECK: %[[VAL_81:.*]] = fir.load %[[VAL_10]] : !fir.ref @@ -1017,14 +1017,14 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name %31 = arith.subi %30, %c1_i32 : i32 %32 = fir.convert %31 : (i32) -> index %33 = fir.convert %29 : (index) -> i32 - %34:2 = fir.do_loop %arg10 = %29 to %32 step %c1 iter_args(%arg11 = %33) -> (index, i32) { + %34:2 = fir.do_loop %arg10 = %29 to %32 step %c1 iter_args(%arg11 = %33) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg11 to %6 : !fir.ref %35 = fir.load %4 : !fir.ref %36 = fir.convert %35 : (i32) -> index %37 = fir.load %3 : !fir.ref %38 = fir.convert %37 : (i32) -> index %39 = fir.convert %36 : (index) -> i32 - %40:2 = fir.do_loop %arg12 = %36 to %38 step %c1 iter_args(%arg13 = %39) -> (index, i32) { + %40:2 = fir.do_loop %arg12 = %36 to %38 step %c1 iter_args(%arg13 = %39) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg13 to %1 : !fir.ref %45 = fir.load %14 : !fir.ref %46 = fir.convert %45 : (i32) -> index @@ -1032,7 +1032,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name %48 = arith.subi %47, %c1_i32 : i32 %49 = fir.convert %48 : (i32) -> index %50 = fir.convert %46 : (index) -> i32 - %51:2 = fir.do_loop %arg14 = %46 to %49 step %c1 iter_args(%arg15 = %50) -> (index, i32) { + %51:2 = fir.do_loop %arg14 = %46 to %49 step %c1 iter_args(%arg15 = %50) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg15 to %11 : !fir.ref %56 = fir.load %11 : !fir.ref %57 = fir.convert %56 : (i32) -> i64 @@ -1127,14 +1127,14 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_42]], %[[VAL_10]] : i32 // CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_43]] : (i32) -> index // CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_41]] : (index) -> i32 -// CHECK: %[[VAL_46:.*]]:2 = fir.do_loop %[[VAL_47:.*]] = %[[VAL_41]] to %[[VAL_44]] step %[[VAL_11]] iter_args(%[[VAL_48:.*]] = %[[VAL_45]]) -> (index, i32) { +// CHECK: %[[VAL_46:.*]]:2 = fir.do_loop %[[VAL_47:.*]] = %[[VAL_41]] to %[[VAL_44]] step %[[VAL_11]] iter_args(%[[VAL_48:.*]] = %[[VAL_45]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_48]] to %[[VAL_18]] : !fir.ref // CHECK: %[[VAL_49:.*]] = fir.load %[[VAL_16]] : !fir.ref // CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i32) -> index // CHECK: %[[VAL_51:.*]] = fir.load %[[VAL_15]] : !fir.ref // CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_51]] : (i32) -> index // CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_50]] : (index) -> i32 -// CHECK: %[[VAL_54:.*]]:2 = fir.do_loop %[[VAL_55:.*]] = %[[VAL_50]] to %[[VAL_52]] step %[[VAL_11]] iter_args(%[[VAL_56:.*]] = %[[VAL_53]]) -> (index, i32) { +// CHECK: %[[VAL_54:.*]]:2 = fir.do_loop %[[VAL_55:.*]] = %[[VAL_50]] to %[[VAL_52]] step %[[VAL_11]] iter_args(%[[VAL_56:.*]] = %[[VAL_53]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_56]] to %[[VAL_13]] : !fir.ref // CHECK: %[[VAL_57:.*]] = fir.load %[[VAL_26]] : !fir.ref // CHECK: %[[VAL_58:.*]] = fir.convert %[[VAL_57]] : (i32) -> index @@ -1153,7 +1153,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: %[[VAL_71:.*]]:2 = fir.if %[[VAL_70]] -> (index, i32) { // CHECK: %[[VAL_72:.*]] = fir.convert %[[VAL_37]] : (!fir.box>) -> !fir.box> // CHECK: %[[VAL_73:.*]] = fir.box_addr %[[VAL_72]] : (!fir.box>) -> !fir.ref> -// CHECK: %[[VAL_74:.*]]:2 = fir.do_loop %[[VAL_75:.*]] = %[[VAL_58]] to %[[VAL_61]] step %[[VAL_11]] iter_args(%[[VAL_76:.*]] = %[[VAL_62]]) -> (index, i32) { +// CHECK: %[[VAL_74:.*]]:2 = fir.do_loop %[[VAL_75:.*]] = %[[VAL_58]] to %[[VAL_61]] step %[[VAL_11]] iter_args(%[[VAL_76:.*]] = %[[VAL_62]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_76]] to %[[VAL_23]] : !fir.ref // CHECK: %[[VAL_77:.*]] = fir.load %[[VAL_23]] : !fir.ref // CHECK: %[[VAL_78:.*]] = fir.convert %[[VAL_77]] : (i32) -> i64 @@ -1215,7 +1215,7 @@ func.func @test_optional_arg(%arg0: !fir.box> {fir.bindc_name // CHECK: } // CHECK: fir.result %[[VAL_129:.*]]#0, %[[VAL_129]]#1 : index, i32 // CHECK: } else { -// CHECK: %[[VAL_130:.*]]:2 = fir.do_loop %[[VAL_131:.*]] = %[[VAL_58]] to %[[VAL_61]] step %[[VAL_11]] iter_args(%[[VAL_132:.*]] = %[[VAL_62]]) -> (index, i32) { +// CHECK: %[[VAL_130:.*]]:2 = fir.do_loop %[[VAL_131:.*]] = %[[VAL_58]] to %[[VAL_61]] step %[[VAL_11]] iter_args(%[[VAL_132:.*]] = %[[VAL_62]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_132]] to %[[VAL_23]] : !fir.ref // CHECK: %[[VAL_133:.*]] = fir.load %[[VAL_23]] : !fir.ref // CHECK: %[[VAL_134:.*]] = fir.convert %[[VAL_133]] : (i32) -> i64 @@ -1288,7 +1288,7 @@ func.func @_QPtest_slice(%arg0: !fir.box> {fir.bindc_name = %c1 = arith.constant 1 : index %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_sliceEi"} %1 = fir.convert %c10 : (index) -> i32 - %2:2 = fir.do_loop %arg1 = %c10 to %c100 step %c1 iter_args(%arg2 = %1) -> (index, i32) { + %2:2 = fir.do_loop %arg1 = %c10 to %c100 step %c1 iter_args(%arg2 = %1) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %0 : !fir.ref %3 = fir.load %0 : !fir.ref %4 = fir.convert %3 : (i32) -> i64 @@ -1301,7 +1301,7 @@ func.func @_QPtest_slice(%arg0: !fir.box> {fir.bindc_name = %10 = fir.convert %7 : (i32) -> index %11 = fir.slice %8, %9, %9, %c3, %c5, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2> %12 = fir.undefined !fir.array - %13 = fir.do_loop %arg3 = %c0 to %c2 step %c1 unordered iter_args(%arg4 = %12) -> (!fir.array) { + %13 = fir.do_loop %arg3 = %c0 to %c2 step %c1 unordered iter_args(%arg4 = %12) -> (!fir.array) attributes {operandSegmentSizes = array} { %18 = arith.addi %arg3, %c1 : index %19 = fir.array_coor %arg0 [%11] %10, %18 : (!fir.box>, !fir.slice<2>, index, index) -> !fir.ref fir.store %cst to %19 : !fir.ref @@ -1341,7 +1341,7 @@ func.func @_QPtest_independent_args(%arg0: !fir.box> {fir.bi %c1 = arith.constant 1 : index %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_independent_argsEi"} %1 = fir.convert %c10 : (index) -> i32 - %2:2 = fir.do_loop %arg2 = %c10 to %c100 step %c1 iter_args(%arg3 = %1) -> (index, i32) { + %2:2 = fir.do_loop %arg2 = %c10 to %c100 step %c1 iter_args(%arg3 = %1) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg3 to %0 : !fir.ref %3 = fir.load %0 : !fir.ref %4 = fir.convert %3 : (i32) -> i64 @@ -1354,7 +1354,7 @@ func.func @_QPtest_independent_args(%arg0: !fir.box> {fir.bi %10 = fir.convert %7 : (i32) -> index %11 = fir.slice %8, %9, %9, %c3, %c5, %c1 : (i64, index, index, index, index, index) -> !fir.slice<2> %12 = fir.undefined !fir.array - %13 = fir.do_loop %arg4 = %c0 to %c2 step %c1 unordered iter_args(%arg5 = %12) -> (!fir.array) { + %13 = fir.do_loop %arg4 = %c0 to %c2 step %c1 unordered iter_args(%arg5 = %12) -> (!fir.array) attributes {operandSegmentSizes = array} { %18 = arith.addi %arg4, %c1 : index %19 = fir.array_coor %arg1 [%11] %10, %18 : (!fir.box>, !fir.slice<2>, index, index) -> !fir.ref fir.store %cst to %19 : !fir.ref @@ -1400,14 +1400,14 @@ func.func @_QPtest_loop_nest(%arg0: !fir.box> {fir.bindc_name %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_loop_nestEi"} %1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFtest_loop_nestEj"} %2 = fir.convert %c10 : (index) -> i32 - %3:2 = fir.do_loop %arg1 = %c10 to %c100 step %c1 iter_args(%arg2 = %2) -> (index, i32) { + %3:2 = fir.do_loop %arg1 = %c10 to %c100 step %c1 iter_args(%arg2 = %2) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %0 : !fir.ref %4 = fir.load %0 : !fir.ref %5 = fir.convert %4 : (i32) -> i64 %6 = arith.subi %5, %c1_i64 : i64 %7 = fir.coordinate_of %arg0, %6 : (!fir.box>, i64) -> !fir.ref fir.store %cst_0 to %7 : !fir.ref - %8:2 = fir.do_loop %arg3 = %c10 to %c100 step %c1 iter_args(%arg4 = %2) -> (index, i32) { + %8:2 = fir.do_loop %arg3 = %c10 to %c100 step %c1 iter_args(%arg4 = %2) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg4 to %1 : !fir.ref %13 = fir.load %1 : !fir.ref %14 = fir.convert %13 : (i32) -> i64 @@ -1451,7 +1451,7 @@ func.func @sum1drebox(%arg0: !fir.box> {fir.bindc_name = "a"}, %4 = fir.convert %3 : (i32) -> index %c1 = arith.constant 1 : index %5 = fir.convert %2 : (index) -> i32 - %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) { + %6:2 = fir.do_loop %arg2 = %2 to %4 step %c1 iter_args(%arg3 = %5) -> (index, i32) attributes {operandSegmentSizes = array} { // rebox is not dominating the loop. %rebox = fir.rebox %decl : (!fir.box>) -> !fir.box> fir.store %arg3 to %0 : !fir.ref @@ -1501,7 +1501,7 @@ func.func @minloc(%arg0: !fir.box> {fir.bindc_name = "x"}, %ar fir.store %c0_i32 to %0 : !fir.ref %10:3 = fir.box_dims %7, %c0 : (!fir.box>, index) -> (index, index, index) %11 = arith.subi %10#1, %c1 : index - %12 = fir.do_loop %arg2 = %c0 to %11 step %c1 iter_args(%arg3 = %c2147483647_i32) -> (i32) { + %12 = fir.do_loop %arg2 = %c0 to %11 step %c1 iter_args(%arg3 = %c2147483647_i32) -> (i32) attributes {operandSegmentSizes = array} { %18 = arith.addi %arg2, %c1 : index %19 = fir.array_coor %3 %18 : (!fir.box>, index) -> !fir.ref %20 = fir.load %19 : !fir.ref @@ -1537,7 +1537,7 @@ func.func @minloc(%arg0: !fir.box> {fir.bindc_name = "x"}, %ar } %15 = fir.slice %c5, %c5, %c1 : (index, index, index) -> !fir.slice<1> %16 = fir.rebox %7 [%15] : (!fir.box>, !fir.slice<1>) -> !fir.box> - fir.do_loop %arg2 = %c1 to %c1 step %c1 unordered { + fir.do_loop %arg2 = %c1 to %c1 step %c1 unordered attributes {operandSegmentSizes = array} { %18 = fir.array_coor %1(%8) %arg2 : (!fir.ref>, !fir.shape<1>, index) -> !fir.ref %19 = fir.load %18 : !fir.ref %20 = fir.array_coor %16 %arg2 : (!fir.box>, index) -> !fir.ref @@ -1570,7 +1570,7 @@ func.func @_QPtest_real10(%arg0: !fir.box> {fir.bindc_name = %7 = fir.declare %6 {fortran_attrs = #fir.var_attrs, uniq_name = "_QFtest_real10ECxdp"} : (!fir.ref) -> !fir.ref fir.store %cst to %5 : !fir.ref %8 = fir.convert %c1 : (index) -> i32 - %9:2 = fir.do_loop %arg1 = %c1 to %c10 step %c1 iter_args(%arg2 = %8) -> (index, i32) { + %9:2 = fir.do_loop %arg1 = %c1 to %c10 step %c1 iter_args(%arg2 = %8) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %3 : !fir.ref %11 = fir.load %5 : !fir.ref %12 = fir.load %3 : !fir.ref @@ -1614,7 +1614,7 @@ func.func @_QPtest_complex10(%arg0: !fir.box>> { %10 = fir.insert_value %9, %cst, [1 : index] : (!fir.complex<10>, f80) -> !fir.complex<10> fir.store %10 to %5 : !fir.ref> %11 = fir.convert %c1 : (index) -> i32 - %12:2 = fir.do_loop %arg1 = %c1 to %c10 step %c1 iter_args(%arg2 = %11) -> (index, i32) { + %12:2 = fir.do_loop %arg1 = %c1 to %c10 step %c1 iter_args(%arg2 = %11) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg2 to %3 : !fir.ref %14 = fir.load %5 : !fir.ref> %15 = fir.load %3 : !fir.ref diff --git a/flang/test/Transforms/omp-reduction-cfg-conversion.fir b/flang/test/Transforms/omp-reduction-cfg-conversion.fir index 707e665132afb..3b8a3c3d0bc2b 100644 --- a/flang/test/Transforms/omp-reduction-cfg-conversion.fir +++ b/flang/test/Transforms/omp-reduction-cfg-conversion.fir @@ -30,7 +30,7 @@ omp.declare_reduction @add_reduction_i_32_box_3_byref : !fir.ref>> %2:3 = fir.box_dims %0, %c0 : (!fir.box>, index) -> (index, index, index) %3 = fir.shape_shift %2#0, %2#1 : (index, index) -> !fir.shapeshift<1> - fir.do_loop %arg2 = %c1 to %2#1 step %c1 unordered { + fir.do_loop %arg2 = %c1 to %2#1 step %c1 unordered attributes {operandSegmentSizes = array} { %4 = fir.array_coor %0(%3) %arg2 : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref %5 = fir.array_coor %1(%3) %arg2 : (!fir.box>, !fir.shapeshift<1>, index) -> !fir.ref %6 = fir.load %4 : !fir.ref diff --git a/flang/test/Transforms/simplifyintrinsics.fir b/flang/test/Transforms/simplifyintrinsics.fir index f21776e03ded8..8f791cee68007 100644 --- a/flang/test/Transforms/simplifyintrinsics.fir +++ b/flang/test/Transforms/simplifyintrinsics.fir @@ -49,7 +49,7 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.targ // CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM:.*]] = %[[CI32_0]]) -> (i32) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM:.*]] = %[[CI32_0]]) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref // CHECK: %[[NEW_SUM:.*]] = arith.addi %[[ITEM_VAL]], %[[SUM]] : i32 @@ -111,8 +111,8 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.targ // CHECK: %[[DIMIDX_1:.*]] = arith.constant 1 : index // CHECK: %[[DIMS_1:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_1]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT_1:.*]] = arith.subi %[[DIMS_1]]#1, %[[CINDEX_1]] : index -// CHECK: %[[RES_1:.*]] = fir.do_loop %[[ITER_1:.*]] = %[[CINDEX_0]] to %[[EXTENT_1]] step %[[CINDEX_1]] iter_args(%[[SUM_1:.*]] = %[[CI32_0]]) -> (i32) { -// CHECK: %[[RES_0:.*]] = fir.do_loop %[[ITER_0:.*]] = %[[CINDEX_0]] to %[[EXTENT_0]] step %[[CINDEX_1]] iter_args(%[[SUM_0:.*]] = %[[SUM_1]]) -> (i32) { +// CHECK: %[[RES_1:.*]] = fir.do_loop %[[ITER_1:.*]] = %[[CINDEX_0]] to %[[EXTENT_1]] step %[[CINDEX_1]] iter_args(%[[SUM_1:.*]] = %[[CI32_0]]) -> (i32) attributes {operandSegmentSizes = array} { +// CHECK: %[[RES_0:.*]] = fir.do_loop %[[ITER_0:.*]] = %[[CINDEX_0]] to %[[EXTENT_0]] step %[[CINDEX_1]] iter_args(%[[SUM_0:.*]] = %[[SUM_1]]) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER_0]], %[[ITER_1]] : (!fir.box>, index, index) -> !fir.ref // CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref // CHECK: %[[NEW_SUM:.*]] = arith.addi %[[ITEM_VAL]], %[[SUM_0]] : i32 @@ -174,7 +174,7 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.targ // CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_F64]], %[[DIMIDX_0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM]] = %[[ZERO]]) -> (f64) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM]] = %[[ZERO]]) -> (f64) attributes {operandSegmentSizes = array} { // CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_F64]], %[[ITER]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref // CHECK: %[[NEW_SUM:.*]] = arith.addf %[[ITEM_VAL]], %[[SUM]] : f64 @@ -234,7 +234,7 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.targ // CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_F32]], %[[DIMIDX_0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM]] = %[[ZERO]]) -> (f32) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[SUM]] = %[[ZERO]]) -> (f32) attributes {operandSegmentSizes = array} { // CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_F32]], %[[ITER]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref // CHECK: %[[NEW_SUM:.*]] = arith.addf %[[ITEM_VAL]], %[[SUM]] : f32 @@ -396,7 +396,7 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.targ // CHECK: %[[CINDEX_1:.*]] = arith.constant 1 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %{{.*}} : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %{{.*}} to %[[EXTENT]] step %[[CINDEX_1]] iter_args({{.*}}) -> (i32) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %{{.*}} to %[[EXTENT]] step %[[CINDEX_1]] iter_args({{.*}}) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %{{.*}} = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box>, index) -> !fir.ref // CHECK: } // CHECK: return %[[RES]] : i32 @@ -498,7 +498,7 @@ func.func @dot_f32(%arg0: !fir.box> {fir.bindc_name = "a"}, %a // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ACAST]], %[[IZERO]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[IONE:.*]] = arith.constant 1 : index // CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[FZERO]]) -> (f32) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[FZERO]]) -> (f32) attributes {operandSegmentSizes = array} { // CHECK: %[[ALOC:.*]] = fir.coordinate_of %[[ACAST]], %[[IDX]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[AVAL:.*]] = fir.load %[[ALOC]] : !fir.ref // CHECK: %[[AVALCAST:.*]] = fir.convert %[[AVAL]] : (f32) -> f32 @@ -635,7 +635,7 @@ fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> { // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ACAST]], %[[IZERO]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[IONE:.*]] = arith.constant 1 : index // CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[I32ZERO]]) -> (i32) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[I32ZERO]]) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[ALOC:.*]] = fir.coordinate_of %[[ACAST]], %[[IDX]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[AVAL:.*]] = fir.load %[[ALOC]] : !fir.ref // CHECK: %[[AVALCAST:.*]] = fir.convert %[[AVAL]] : (i32) -> i32 @@ -776,7 +776,7 @@ fir.global linkonce @_QQclX2E2F646F742E66393000 constant : !fir.char<1,10> { // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ACAST]], %[[IZERO]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[IONE:.*]] = arith.constant 1 : index // CHECK: %[[LEN:.*]] = arith.subi %[[DIMS]]#1, %[[IONE]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[FZERO]]) -> (f64) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[IDX:.*]] = %[[IZERO]] to %[[LEN]] step %[[IONE]] iter_args(%[[SUM:.*]] = %[[FZERO]]) -> (f64) attributes {operandSegmentSizes = array} { // CHECK: %[[ALOC:.*]] = fir.coordinate_of %[[ACAST]], %[[IDX]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[AVAL:.*]] = fir.load %[[ALOC]] : !fir.ref // CHECK: %[[AVALCAST:.*]] = fir.convert %[[AVAL]] : (f64) -> f64 @@ -838,7 +838,7 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.targ // CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MAX:.*]] = %[[CI32_MININT]]) -> (i32) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MAX:.*]] = %[[CI32_MININT]]) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref // CHECK: %[[NEW_MAX:.*]] = arith.maxsi %[[ITEM_VAL]], %[[MAX]] : i32 @@ -896,7 +896,7 @@ module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.targ // CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_F64]], %[[DIMIDX_0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MAX]] = %[[NEG_DBL_MAX]]) -> (f64) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MAX]] = %[[NEG_DBL_MAX]]) -> (f64) attributes {operandSegmentSizes = array} { // CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_F64]], %[[ITER]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref // CHECK: %[[CMP:.*]] = arith.cmpf ogt, %[[ITEM_VAL]], %[[MAX]] : f64 @@ -1148,7 +1148,7 @@ fir.global linkonce @_QQclX2E2F746573746661696C2E66393000 constant : !fir.char<1 // CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[DIMIDX_0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[COUNT:.*]] = %[[IZERO]]) -> (i64) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[COUNT:.*]] = %[[IZERO]]) -> (i64) attributes {operandSegmentSizes = array} { // CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref // CHECK: %[[I32_0:.*]] = arith.constant 0 : i32 @@ -1196,7 +1196,7 @@ func.func @_QPdiffkind(%arg0: !fir.ref>> {fir.bind // CHECK: %[[DIMIDX_0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I16]], %[[DIMIDX_0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index -// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[COUNT:.*]] = %[[IZERO]]) -> (i64) { +// CHECK: %[[RES:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[COUNT:.*]] = %[[IZERO]]) -> (i64) attributes {operandSegmentSizes = array} { // CHECK: %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I16]], %[[ITER]] : (!fir.box>, index) -> !fir.ref // CHECK: %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref // CHECK: %[[I16_0:.*]] = arith.constant 0 : i16 @@ -1246,7 +1246,7 @@ func.func @_QMtestPcount_generate_mask(%arg0: !fir.ref (!fir.array<10xi32>) { + %21 = fir.do_loop %arg1 = %c0_3 to %20 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10xi32>) attributes {operandSegmentSizes = array} { %23 = fir.array_fetch %19, %arg1 : (!fir.array, index) -> i32 %24 = fir.array_update %arg2, %23, %arg1 : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32> fir.result %24 : !fir.array<10xi32> @@ -1429,7 +1429,7 @@ func.func @_QPtestAny_DimArg(%arg0: !fir.ref>> %c1 = arith.constant 1 : index %c0_3 = arith.constant 0 : index %19 = arith.subi %c10_1, %c1 : index - %20 = fir.do_loop %arg1 = %c0_3 to %19 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10x!fir.logical<4>>) { + %20 = fir.do_loop %arg1 = %c0_3 to %19 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { %22 = fir.array_fetch %18, %arg1 : (!fir.array>, index) -> !fir.logical<4> %23 = fir.array_update %arg2, %22, %arg1 : (!fir.array<10x!fir.logical<4>>, !fir.logical<4>, index) -> !fir.array<10x!fir.logical<4>> fir.result %23 : !fir.array<10x!fir.logical<4>> @@ -1668,7 +1668,7 @@ func.func @_QPtestAll_DimArg(%arg0: !fir.ref>> %c1 = arith.constant 1 : index %c0_3 = arith.constant 0 : index %19 = arith.subi %c10_1, %c1 : index - %20 = fir.do_loop %arg1 = %c0_3 to %19 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10x!fir.logical<4>>) { + %20 = fir.do_loop %arg1 = %c0_3 to %19 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<10x!fir.logical<4>>) attributes {operandSegmentSizes = array} { %22 = fir.array_fetch %18, %arg1 : (!fir.array>, index) -> !fir.logical<4> %23 = fir.array_update %arg2, %22, %arg1 : (!fir.array<10x!fir.logical<4>>, !fir.logical<4>, index) -> !fir.array<10x!fir.logical<4>> fir.result %23 : !fir.array<10x!fir.logical<4>> @@ -1724,7 +1724,7 @@ func.func @_QPtestminloc_works1d(%arg0: !fir.ref> {fir.bindc_ %c1_2 = arith.constant 1 : index %c0_3 = arith.constant 0 : index %23 = arith.subi %c1, %c1_2 : index - %24 = fir.do_loop %arg2 = %c0_3 to %23 step %c1_2 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) { + %24 = fir.do_loop %arg2 = %c0_3 to %23 step %c1_2 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %26 = fir.array_fetch %22, %arg2 : (!fir.array, index) -> i32 %27 = fir.array_update %arg3, %26, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %27 : !fir.array<1xi32> @@ -1774,7 +1774,7 @@ func.func @_QPtestminloc_works1d(%arg0: !fir.ref> {fir.bindc_ // CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index -// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (i32) { +// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[MASK_ITEM:.*]] = fir.coordinate_of %[[BOX_MASK]], %[[ITER]] : (!fir.box>>, index) -> !fir.ref> // CHECK: %[[MASK_ITEMVAL:.*]] = fir.load %[[MASK_ITEM]] : !fir.ref> // CHECK: %[[MASK_IF_ITEM:.*]] = fir.convert %[[MASK_ITEMVAL]] : (!fir.logical<4>) -> i1 @@ -1847,7 +1847,7 @@ func.func @_QPtestminloc_works2d_nomask(%arg0: !fir.ref> { %c1 = arith.constant 1 : index %c0_2 = arith.constant 0 : index %21 = arith.subi %c2, %c1 : index - %22 = fir.do_loop %arg1 = %c0_2 to %21 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<2xi32>) { + %22 = fir.do_loop %arg1 = %c0_2 to %21 step %c1 unordered iter_args(%arg2 = %3) -> (!fir.array<2xi32>) attributes {operandSegmentSizes = array} { %24 = fir.array_fetch %20, %arg1 : (!fir.array, index) -> i64 %25 = fir.convert %24 : (i64) -> i32 %26 = fir.array_update %arg2, %25, %arg1 : (!fir.array<2xi32>, i32, index) -> !fir.array<2xi32> @@ -1894,8 +1894,8 @@ func.func @_QPtestminloc_works2d_nomask(%arg0: !fir.ref> { // CHECK: %[[DIM_INDEX1:.*]] = arith.constant 1 : index // CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX1]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT1:.*]] = arith.subi %[[DIMS1]]#1, %[[C_INDEX1]] : index -// CHECK: %[[DOLOOP0:.*]] = fir.do_loop %[[ITER0:.*]] = %[[C_INDEX0]] to %[[EXTENT1]] step %[[C_INDEX1]] iter_args(%[[MIN0:.*]] = %[[MAX]]) -> (i32) { -// CHECK: %[[DOLOOP1:.*]] = fir.do_loop %[[ITER1:.*]] = %[[C_INDEX0]] to %[[EXTENT0]] step %[[C_INDEX1]] iter_args(%[[MIN1:.*]] = %[[MIN0]]) -> (i32) { +// CHECK: %[[DOLOOP0:.*]] = fir.do_loop %[[ITER0:.*]] = %[[C_INDEX0]] to %[[EXTENT1]] step %[[C_INDEX1]] iter_args(%[[MIN0:.*]] = %[[MAX]]) -> (i32) attributes {operandSegmentSizes = array} { +// CHECK: %[[DOLOOP1:.*]] = fir.do_loop %[[ITER1:.*]] = %[[C_INDEX0]] to %[[EXTENT0]] step %[[C_INDEX1]] iter_args(%[[MIN1:.*]] = %[[MIN0]]) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i64 // CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref // CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER1]], %[[ITER0]] : (!fir.box>, index, index) -> !fir.ref @@ -1967,7 +1967,7 @@ func.func @_QPtestminloc_works1d_scalarmask_f64(%arg0: !fir.ref (!fir.array<1xi32>) { + %23 = fir.do_loop %arg2 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %25 = fir.array_fetch %21, %arg2 : (!fir.array, index) -> i32 %26 = fir.array_update %arg3, %25, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %26 : !fir.array<1xi32> @@ -2011,7 +2011,7 @@ func.func @_QPtestminloc_works1d_scalarmask_f64(%arg0: !fir.ref>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index -// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) { +// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) attributes {operandSegmentSizes = array} { // CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32 // CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref // CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box>, index) -> !fir.ref @@ -2080,7 +2080,7 @@ func.func @_QPtestminloc_doesntwork1d_back(%arg0: !fir.ref> { %c1_1 = arith.constant 1 : index %c0_2 = arith.constant 0 : index %22 = arith.subi %c1, %c1_1 : index - %23 = fir.do_loop %arg1 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) { + %23 = fir.do_loop %arg1 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %25 = fir.array_fetch %21, %arg1 : (!fir.array, index) -> i32 %26 = fir.array_update %arg2, %25, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %26 : !fir.array<1xi32> @@ -2131,7 +2131,7 @@ func.func @_QPtestminloc_1d_dim(%arg0: !fir.ref> {fir.bindc_n %c1_0 = arith.constant 1 : index %c0 = arith.constant 0 : index %19 = arith.subi %c1, %c1_0 : index - %20 = fir.do_loop %arg1 = %c0 to %19 step %c1_0 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) { + %20 = fir.do_loop %arg1 = %c0 to %19 step %c1_0 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %22 = fir.array_update %arg2, %18, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %22 : !fir.array<1xi32> } @@ -2163,7 +2163,7 @@ func.func @_QPtestminloc_1d_dim(%arg0: !fir.ref> {fir.bindc_n // CHECK-NEXT: %c0_3 = arith.constant 0 : index // CHECK-NEXT: %[[V6:.*]]:3 = fir.box_dims %[[V5]], %c0_3 : (!fir.box>, index) -> (index, index, index) // CHECK-NEXT: %[[V7:.*]] = arith.subi %[[V6]]#1, %c1_2 : index -// CHECK-NEXT: %[[V8:.*]] = fir.do_loop %arg3 = %c0_0 to %[[V7]] step %c1_2 iter_args(%arg4 = %c2147483647_i32) -> (i32) { +// CHECK-NEXT: %[[V8:.*]] = fir.do_loop %arg3 = %c0_0 to %[[V7]] step %c1_2 iter_args(%arg4 = %c2147483647_i32) -> (i32) attributes {operandSegmentSizes = array} { // CHECK-NEXT: %c1_i32_4 = arith.constant 1 : i32 // CHECK-NEXT: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref // CHECK-NEXT: %[[V12:.*]] = fir.coordinate_of %[[V5]], %arg3 : (!fir.box>, index) -> !fir.ref @@ -2230,7 +2230,7 @@ func.func @_QPtestminloc_doesntwork1d_unknownsize(%arg0: !fir.box (!fir.array<1xi32>) { + %21 = fir.do_loop %arg1 = %c0_2 to %20 step %c1_1 unordered iter_args(%arg2 = %3) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %23 = fir.array_fetch %19, %arg1 : (!fir.array, index) -> i32 %24 = fir.array_update %arg2, %23, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %24 : !fir.array<1xi32> @@ -2285,7 +2285,7 @@ func.func @_QPtestminloc_doesntwork1d_chars(%arg0: !fir.boxchar<1> {fir.bindc_na %c1_1 = arith.constant 1 : index %c0_2 = arith.constant 0 : index %24 = arith.subi %c1, %c1_1 : index - %25 = fir.do_loop %arg1 = %c0_2 to %24 step %c1_1 unordered iter_args(%arg2 = %5) -> (!fir.array<1xi32>) { + %25 = fir.do_loop %arg1 = %c0_2 to %24 step %c1_1 unordered iter_args(%arg2 = %5) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %27 = fir.array_fetch %23, %arg1 : (!fir.array, index) -> i32 %28 = fir.array_update %arg2, %27, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %28 : !fir.array<1xi32> @@ -2366,7 +2366,7 @@ func.func @_QPtestminloc_doesntwork1d_unknownmask(%arg0: !fir.ref (!fir.array<1xi32>) { + %43 = fir.do_loop %arg1 = %c0_4 to %42 step %c1_3 unordered iter_args(%arg2 = %14) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %45 = fir.array_fetch %41, %arg1 : (!fir.array, index) -> i32 %46 = fir.array_update %arg2, %45, %arg1 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %46 : !fir.array<1xi32> @@ -2421,7 +2421,7 @@ func.func @_QPtestmaxloc_works1d(%arg0: !fir.ref> {fir.bindc_ %c1_2 = arith.constant 1 : index %c0_3 = arith.constant 0 : index %23 = arith.subi %c1, %c1_2 : index - %24 = fir.do_loop %arg2 = %c0_3 to %23 step %c1_2 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) { + %24 = fir.do_loop %arg2 = %c0_3 to %23 step %c1_2 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %26 = fir.array_fetch %22, %arg2 : (!fir.array, index) -> i32 %27 = fir.array_update %arg3, %26, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %27 : !fir.array<1xi32> @@ -2471,7 +2471,7 @@ func.func @_QPtestmaxloc_works1d(%arg0: !fir.ref> {fir.bindc_ // CHECK: %[[DIM_INDEX0:.*]] = arith.constant 0 : index // CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[BOX_INARR]], %[[DIM_INDEX0]] : (!fir.box>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index -// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (i32) { +// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (i32) attributes {operandSegmentSizes = array} { // CHECK: %[[MASK_ITEM:.*]] = fir.coordinate_of %[[BOX_MASK]], %[[ITER]] : (!fir.box>>, index) -> !fir.ref> // CHECK: %[[MASK_ITEMVAL:.*]] = fir.load %[[MASK_ITEM]] : !fir.ref> // CHECK: %[[MASK_IF_ITEM:.*]] = fir.convert %[[MASK_ITEMVAL]] : (!fir.logical<4>) -> i1 @@ -2544,7 +2544,7 @@ func.func @_QPtestmaxloc_works1d_scalarmask_f64(%arg0: !fir.ref (!fir.array<1xi32>) { + %23 = fir.do_loop %arg2 = %c0_2 to %22 step %c1_1 unordered iter_args(%arg3 = %3) -> (!fir.array<1xi32>) attributes {operandSegmentSizes = array} { %25 = fir.array_fetch %21, %arg2 : (!fir.array, index) -> i32 %26 = fir.array_update %arg3, %25, %arg2 : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> fir.result %26 : !fir.array<1xi32> @@ -2588,7 +2588,7 @@ func.func @_QPtestmaxloc_works1d_scalarmask_f64(%arg0: !fir.ref>, index) -> (index, index, index) // CHECK: %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[C_INDEX1]] : index -// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) { +// CHECK: %[[DOLOOP:.*]] = fir.do_loop %[[ITER:.*]] = %[[C_INDEX0]] to %[[EXTENT]] step %[[C_INDEX1]] iter_args(%[[MIN:.*]] = %[[MAX]]) -> (f64) attributes {operandSegmentSizes = array} { // CHECK: %[[FLAG_SET2:.*]] = arith.constant 1 : i32 // CHECK: %[[ISFIRST:.*]] = fir.load %[[FLAG_ALLOC]] : !fir.ref // CHECK: %[[INARR_ITEM:.*]] = fir.coordinate_of %[[BOX_INARR]], %[[ITER]] : (!fir.box>, index) -> !fir.ref diff --git a/flang/test/Transforms/stack-arrays.fir b/flang/test/Transforms/stack-arrays.fir index a2ffe555091eb..f59047582b1de 100644 --- a/flang/test/Transforms/stack-arrays.fir +++ b/flang/test/Transforms/stack-arrays.fir @@ -157,7 +157,7 @@ func.func @placement3() { %c1_i32 = fir.convert %c1 : (index) -> i32 %c2 = arith.constant 2 : index %c10 = arith.constant 10 : index - %0:2 = fir.do_loop %arg0 = %c1 to %c10 step %c1 iter_args(%arg1 = %c1_i32) -> (index, i32) { + %0:2 = fir.do_loop %arg0 = %c1 to %c10 step %c1 iter_args(%arg1 = %c1_i32) -> (index, i32) attributes {operandSegmentSizes = array} { %3 = arith.addi %c1, %c2 : index // operand is now available %4 = fir.allocmem !fir.array, %3 @@ -220,7 +220,7 @@ func.func @placement5() { %c1_i32 = fir.convert %c1 : (index) -> i32 %c2 = arith.constant 2 : index %c10 = arith.constant 10 : index - %0:2 = fir.do_loop %arg0 = %c1 to %c10 step %c1 iter_args(%arg1 = %c1_i32) -> (index, i32) { + %0:2 = fir.do_loop %arg0 = %c1 to %c10 step %c1 iter_args(%arg1 = %c1_i32) -> (index, i32) attributes {operandSegmentSizes = array} { %3 = arith.addi %c1, %c2 : index // operand is now available %4 = fir.allocmem !fir.array, %3 diff --git a/flang/test/Transforms/tbaa2.fir b/flang/test/Transforms/tbaa2.fir index ab39f65cdade7..555b51093aac2 100644 --- a/flang/test/Transforms/tbaa2.fir +++ b/flang/test/Transforms/tbaa2.fir @@ -118,7 +118,7 @@ %36 = fir.load %17 : !fir.ref %37 = fir.convert %36 : (i32) -> index %38 = fir.convert %35 : (index) -> i32 - %39:2 = fir.do_loop %arg3 = %35 to %37 step %c1 iter_args(%arg4 = %38) -> (index, i32) { + %39:2 = fir.do_loop %arg3 = %35 to %37 step %c1 iter_args(%arg4 = %38) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg4 to %27 : !fir.ref %40 = fir.load %11 : !fir.ref %41 = arith.addi %40, %c1_i32 : i32 @@ -126,13 +126,13 @@ %43 = fir.load %13 : !fir.ref %44 = fir.convert %43 : (i32) -> index %45 = fir.convert %42 : (index) -> i32 - %46:2 = fir.do_loop %arg5 = %42 to %44 step %c1 iter_args(%arg6 = %45) -> (index, i32) { + %46:2 = fir.do_loop %arg5 = %42 to %44 step %c1 iter_args(%arg6 = %45) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg6 to %25 : !fir.ref %51 = fir.load %9 : !fir.ref %52 = arith.addi %51, %c1_i32 : i32 %53 = fir.convert %52 : (i32) -> index %54 = fir.convert %53 : (index) -> i32 - %55:2 = fir.do_loop %arg7 = %53 to %c0 step %c1 iter_args(%arg8 = %54) -> (index, i32) { + %55:2 = fir.do_loop %arg7 = %53 to %c0 step %c1 iter_args(%arg8 = %54) -> (index, i32) attributes {operandSegmentSizes = array} { fir.store %arg8 to %23 : !fir.ref %60 = fir.load %28 : !fir.ref>>> %61 = fir.load %23 : !fir.ref @@ -271,7 +271,7 @@ // CHECK: %[[VAL_43:.*]] = fir.load %[[VAL_24]] {tbaa = [#[[GLBL_ZSTOP_TAG]]]} : !fir.ref // CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_43]] : (i32) -> index // CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_42]] : (index) -> i32 -// CHECK: %[[VAL_46:.*]]:2 = fir.do_loop %[[VAL_47:.*]] = %[[VAL_42]] to %[[VAL_44]] step %[[VAL_5]] iter_args(%[[VAL_48:.*]] = %[[VAL_45]]) -> (index, i32) { +// CHECK: %[[VAL_46:.*]]:2 = fir.do_loop %[[VAL_47:.*]] = %[[VAL_42]] to %[[VAL_44]] step %[[VAL_5]] iter_args(%[[VAL_48:.*]] = %[[VAL_45]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_48]] to %[[VAL_34]] : !fir.ref // CHECK: %[[VAL_49:.*]] = fir.load %[[VAL_18]] {tbaa = [#[[GLBL_YSTART_TAG]]]} : !fir.ref // CHECK: %[[VAL_50:.*]] = arith.addi %[[VAL_49]], %[[VAL_6]] : i32 @@ -279,13 +279,13 @@ // CHECK: %[[VAL_52:.*]] = fir.load %[[VAL_20]] {tbaa = [#[[GLBL_YSTOP_TAG]]]} : !fir.ref // CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_52]] : (i32) -> index // CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_51]] : (index) -> i32 -// CHECK: %[[VAL_55:.*]]:2 = fir.do_loop %[[VAL_56:.*]] = %[[VAL_51]] to %[[VAL_53]] step %[[VAL_5]] iter_args(%[[VAL_57:.*]] = %[[VAL_54]]) -> (index, i32) { +// CHECK: %[[VAL_55:.*]]:2 = fir.do_loop %[[VAL_56:.*]] = %[[VAL_51]] to %[[VAL_53]] step %[[VAL_5]] iter_args(%[[VAL_57:.*]] = %[[VAL_54]]) -> (index, i32) attributes {operandSegmentSizes = array} { // CHECK: fir.store %[[VAL_57]] to %[[VAL_32]] : !fir.ref // CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_16]] {tbaa = [#[[GLBL_XSTART_TAG]]]} : !fir.ref // CHECK: %[[VAL_59:.*]] = arith.addi %[[VAL_58]], %[[VAL_6]] : i32 // CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i32) -> index // CHECK: %[[VAL_61:.*]] = fir.convert %[[VAL_60]] : (index) -> i32 -// CHECK: %[[VAL_62:.*]]:2 = fir.do_loop %[[VAL_63:.*]] = %[[VAL_60]] to %[[VAL_4]] step %[[VAL_5]] iter_args(%[[VAL_64:.*]] = %[[VAL_61]]) -> (index, i32) { +// CHECK: %[[VAL_62:.*]]:2 = fir.do_loop %[[VAL_63:.*]] = %[[VAL_60]] to %[[VAL_4]] step %[[VAL_5]] iter_args(%[[VAL_64:.*]] = %[[VAL_61]]) -> (index, i32) attributes {operandSegmentSizes = array} { // TODO: local allocation assumed to always alias // CHECK: fir.store %[[VAL_64]] to %[[VAL_30]] : !fir.ref // load from box tagged in CodeGen