diff options
Diffstat (limited to 'flang/lib/Lower/IO.cpp')
| -rw-r--r-- | flang/lib/Lower/IO.cpp | 296 |
1 files changed, 152 insertions, 144 deletions
diff --git a/flang/lib/Lower/IO.cpp b/flang/lib/Lower/IO.cpp index 53bf619..51f192e 100644 --- a/flang/lib/Lower/IO.cpp +++ b/flang/lib/Lower/IO.cpp @@ -153,8 +153,8 @@ static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter, if (csi.ioMsg) { mlir::func::FuncOp getIoMsg = fir::runtime::getIORuntimeFunc<mkIOKey(GetIoMsg)>(loc, builder); - builder.create<fir::CallOp>( - loc, getIoMsg, + fir::CallOp::create( + builder, loc, getIoMsg, mlir::ValueRange{ cookie, builder.createConvert(loc, getIoMsg.getFunctionType().getInput(1), @@ -164,12 +164,12 @@ static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter, } mlir::func::FuncOp endIoStatement = fir::runtime::getIORuntimeFunc<mkIOKey(EndIoStatement)>(loc, builder); - auto call = builder.create<fir::CallOp>(loc, endIoStatement, - mlir::ValueRange{cookie}); + auto call = fir::CallOp::create(builder, loc, endIoStatement, + mlir::ValueRange{cookie}); mlir::Value iostat = call.getResult(0); if (csi.bigUnitIfOp) { stmtCtx.finalizeAndPop(); - builder.create<fir::ResultOp>(loc, iostat); + fir::ResultOp::create(builder, loc, iostat); builder.setInsertionPointAfter(csi.bigUnitIfOp); iostat = csi.bigUnitIfOp.getResult(0); } @@ -178,7 +178,7 @@ static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter, fir::getBase(converter.genExprAddr(loc, csi.ioStatExpr, stmtCtx)); mlir::Value ioStatResult = builder.createConvert(loc, converter.genType(*csi.ioStatExpr), iostat); - builder.create<fir::StoreOp>(loc, ioStatResult, ioStatVar); + fir::StoreOp::create(builder, loc, ioStatResult, ioStatVar); } return csi.hasTransferConditionSpec() ? iostat : mlir::Value{}; } @@ -203,8 +203,8 @@ static void makeNextConditionalOn(fir::FirOpBuilder &builder, mlir::IntegerType boolTy = builder.getI1Type(); if (inLoop) resTy = boolTy; - auto ifOp = builder.create<fir::IfOp>(loc, resTy, ok, - /*withElseRegion=*/inLoop); + auto ifOp = fir::IfOp::create(builder, loc, resTy, ok, + /*withElseRegion=*/inLoop); builder.setInsertionPointToStart(&ifOp.getThenRegion().front()); } @@ -259,10 +259,10 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, ? fir::NameUniquer::doGenerated("default" + suffix) : converter.mangleName(suffix); if (auto table = builder.getNamedGlobal(tableMangleName)) - return builder.createConvert( - loc, refTy, - builder.create<fir::AddrOfOp>(loc, table.resultType(), - table.getSymbol())); + return builder.createConvert(loc, refTy, + fir::AddrOfOp::create(builder, loc, + table.resultType(), + table.getSymbol())); mlir::StringAttr linkOnce = builder.createLinkOnceLinkage(); mlir::Type idxTy = builder.getIndexType(); @@ -281,11 +281,12 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, // Define the list of NonTbpDefinedIo procedures. bool tableIsLocal = !definedIoProcMap.empty() && hasLocalDefinedIoProc(definedIoProcMap); - mlir::Value listAddr = - tableIsLocal ? builder.create<fir::AllocaOp>(loc, listTy) : mlir::Value{}; + mlir::Value listAddr = tableIsLocal + ? fir::AllocaOp::create(builder, loc, listTy) + : mlir::Value{}; std::string listMangleName = tableMangleName + ".list"; auto listFunc = [&](fir::FirOpBuilder &builder) { - mlir::Value list = builder.create<fir::UndefOp>(loc, listTy); + mlir::Value list = fir::UndefOp::create(builder, loc, listTy); mlir::IntegerAttr intAttr[4]; for (int i = 0; i < 4; ++i) intAttr[i] = builder.getIntegerAttr(idxTy, i); @@ -294,8 +295,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, int n0 = 0, n1; auto insert = [&](mlir::Value val) { idx[1] = intAttr[n1++]; - list = builder.create<fir::InsertValueOp>(loc, listTy, list, val, - builder.getArrayAttr(idx)); + list = fir::InsertValueOp::create(builder, loc, listTy, list, val, + builder.getArrayAttr(idx)); }; for (auto &iface : definedIoProcMap) { idx[0] = builder.getIntegerAttr(idxTy, n0++); @@ -305,8 +306,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, std::string dtName = converter.mangleName(dtSym); insert(builder.createConvert( loc, refTy, - builder.create<fir::AddrOfOp>( - loc, fir::ReferenceType::get(converter.genType(dtSym)), + fir::AddrOfOp::create( + builder, loc, fir::ReferenceType::get(converter.genType(dtSym)), builder.getSymbolRefAttr(dtName)))); // defined IO procedure [void (*subroutine)()], may be null const Fortran::semantics::Symbol *procSym = iface.second.subroutine; @@ -316,8 +317,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, TODO(loc, "defined IO procedure pointers"); } else if (Fortran::semantics::IsDummy(*procSym)) { Fortran::lower::StatementContext stmtCtx; - insert(builder.create<fir::BoxAddrOp>( - loc, refTy, + insert(fir::BoxAddrOp::create( + builder, loc, refTy, fir::getBase(converter.genExprAddr( loc, Fortran::lower::SomeExpr{ @@ -330,8 +331,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, builder.getSymbolRefAttr(procDef.getSymName()); insert(builder.createConvert( loc, refTy, - builder.create<fir::AddrOfOp>(loc, procDef.getFunctionType(), - nameAttr))); + fir::AddrOfOp::create(builder, loc, procDef.getFunctionType(), + nameAttr))); } } else { insert(builder.createNullConstant(loc, refTy)); @@ -346,9 +347,9 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, insert(builder.createIntegerConstant(loc, byteTy, iface.second.flags)); } if (tableIsLocal) - builder.create<fir::StoreOp>(loc, list, listAddr); + fir::StoreOp::create(builder, loc, list, listAddr); else - builder.create<fir::HasValueOp>(loc, list); + fir::HasValueOp::create(builder, loc, list); }; if (!definedIoProcMap.empty()) { if (tableIsLocal) @@ -360,33 +361,34 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, // Define the NonTbpDefinedIoTable. mlir::Value tableAddr = tableIsLocal - ? builder.create<fir::AllocaOp>(loc, tableTy) + ? fir::AllocaOp::create(builder, loc, tableTy) : mlir::Value{}; auto tableFunc = [&](fir::FirOpBuilder &builder) { - mlir::Value table = builder.create<fir::UndefOp>(loc, tableTy); + mlir::Value table = fir::UndefOp::create(builder, loc, tableTy); // list item count [std::size_t items] - table = builder.create<fir::InsertValueOp>( - loc, tableTy, table, + table = fir::InsertValueOp::create( + builder, loc, tableTy, table, builder.createIntegerConstant(loc, sizeTy, definedIoProcMap.size()), builder.getArrayAttr(builder.getIntegerAttr(idxTy, 0))); // item list [const NonTbpDefinedIo *item] if (definedIoProcMap.empty()) listAddr = builder.createNullConstant(loc, builder.getRefType(listTy)); else if (fir::GlobalOp list = builder.getNamedGlobal(listMangleName)) - listAddr = builder.create<fir::AddrOfOp>(loc, list.resultType(), - list.getSymbol()); + listAddr = fir::AddrOfOp::create(builder, loc, list.resultType(), + list.getSymbol()); assert(listAddr && "missing namelist object list"); - table = builder.create<fir::InsertValueOp>( - loc, tableTy, table, listAddr, + table = fir::InsertValueOp::create( + builder, loc, tableTy, table, listAddr, builder.getArrayAttr(builder.getIntegerAttr(idxTy, 1))); // [bool ignoreNonTbpEntries] conservatively set to true - table = builder.create<fir::InsertValueOp>( - loc, tableTy, table, builder.createIntegerConstant(loc, boolTy, true), + table = fir::InsertValueOp::create( + builder, loc, tableTy, table, + builder.createIntegerConstant(loc, boolTy, true), builder.getArrayAttr(builder.getIntegerAttr(idxTy, 2))); if (tableIsLocal) - builder.create<fir::StoreOp>(loc, table, tableAddr); + fir::StoreOp::create(builder, loc, table, tableAddr); else - builder.create<fir::HasValueOp>(loc, table); + fir::HasValueOp::create(builder, loc, table); }; if (tableIsLocal) { tableFunc(builder); @@ -394,8 +396,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter, fir::GlobalOp table = builder.createGlobal( loc, tableTy, tableMangleName, /*isConst=*/true, /*isTarget=*/false, tableFunc, linkOnce); - tableAddr = builder.create<fir::AddrOfOp>( - loc, fir::ReferenceType::get(tableTy), table.getSymbol()); + tableAddr = fir::AddrOfOp::create( + builder, loc, fir::ReferenceType::get(tableTy), table.getSymbol()); } assert(tableAddr && "missing NonTbpDefinedIo table result"); return builder.createConvert(loc, refTy, tableAddr); @@ -420,8 +422,8 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, mlir::Location loc = converter.getCurrentLocation(); std::string groupMangleName = converter.mangleName(symbol); if (auto group = builder.getNamedGlobal(groupMangleName)) - return builder.create<fir::AddrOfOp>(loc, group.resultType(), - group.getSymbol()); + return fir::AddrOfOp::create(builder, loc, group.resultType(), + group.getSymbol()); const auto &details = symbol.GetUltimate().get<Fortran::semantics::NamelistDetails>(); @@ -466,20 +468,23 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, fir::BoxType boxTy = fir::BoxType::get(fir::PointerType::get(converter.genType(s))); auto descFunc = [&](fir::FirOpBuilder &b) { + bool couldBeInEquivalence = + Fortran::semantics::FindEquivalenceSet(s) != nullptr; auto box = Fortran::lower::genInitialDataTarget( - converter, loc, boxTy, *expr, /*couldBeInEquivalence=*/true); - b.create<fir::HasValueOp>(loc, box); + converter, loc, boxTy, *expr, couldBeInEquivalence); + fir::HasValueOp::create(b, loc, box); }; builder.createGlobalConstant(loc, boxTy, mangleName, descFunc, linkOnce); } } // Define the list of Items. - mlir::Value listAddr = - groupIsLocal ? builder.create<fir::AllocaOp>(loc, listTy) : mlir::Value{}; + mlir::Value listAddr = groupIsLocal + ? fir::AllocaOp::create(builder, loc, listTy) + : mlir::Value{}; std::string listMangleName = groupMangleName + ".list"; auto listFunc = [&](fir::FirOpBuilder &builder) { - mlir::Value list = builder.create<fir::UndefOp>(loc, listTy); + mlir::Value list = fir::UndefOp::create(builder, loc, listTy); mlir::IntegerAttr zero = builder.getIntegerAttr(idxTy, 0); mlir::IntegerAttr one = builder.getIntegerAttr(idxTy, 1); llvm::SmallVector<mlir::Attribute, 2> idx = {mlir::Attribute{}, @@ -490,14 +495,14 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, idx[1] = zero; mlir::Value nameAddr = builder.createConvert(loc, charRefTy, fir::getBase(stringAddress(s))); - list = builder.create<fir::InsertValueOp>(loc, listTy, list, nameAddr, - builder.getArrayAttr(idx)); + list = fir::InsertValueOp::create(builder, loc, listTy, list, nameAddr, + builder.getArrayAttr(idx)); idx[1] = one; mlir::Value descAddr; if (auto desc = builder.getNamedGlobal( Fortran::lower::mangle::globalNamelistDescriptorName(s))) { - descAddr = builder.create<fir::AddrOfOp>(loc, desc.resultType(), - desc.getSymbol()); + descAddr = fir::AddrOfOp::create(builder, loc, desc.resultType(), + desc.getSymbol()); } else if (Fortran::semantics::FindCommonBlockContaining(s) && IsAllocatableOrPointer(s)) { mlir::Type symType = converter.genType(s); @@ -505,8 +510,8 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, Fortran::semantics::FindCommonBlockContaining(s); std::string commonBlockName = converter.mangleName(*commonBlockSym); fir::GlobalOp commonGlobal = builder.getNamedGlobal(commonBlockName); - mlir::Value commonBlockAddr = builder.create<fir::AddrOfOp>( - loc, commonGlobal.resultType(), commonGlobal.getSymbol()); + mlir::Value commonBlockAddr = fir::AddrOfOp::create( + builder, loc, commonGlobal.resultType(), commonGlobal.getSymbol()); mlir::IntegerType i8Ty = builder.getIntegerType(8); mlir::Type i8Ptr = builder.getRefType(i8Ty); mlir::Type seqTy = builder.getRefType(builder.getVarLenSeqTy(i8Ty)); @@ -514,8 +519,8 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, std::size_t byteOffset = s.GetUltimate().offset(); mlir::Value offs = builder.createIntegerConstant( loc, builder.getIndexType(), byteOffset); - mlir::Value varAddr = builder.create<fir::CoordinateOp>( - loc, i8Ptr, base, mlir::ValueRange{offs}); + mlir::Value varAddr = fir::CoordinateOp::create( + builder, loc, i8Ptr, base, mlir::ValueRange{offs}); descAddr = builder.createConvert(loc, builder.getRefType(symType), varAddr); } else { @@ -531,13 +536,13 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, /*lbounds=*/{}); } descAddr = builder.createConvert(loc, descRefTy, descAddr); - list = builder.create<fir::InsertValueOp>(loc, listTy, list, descAddr, - builder.getArrayAttr(idx)); + list = fir::InsertValueOp::create(builder, loc, listTy, list, descAddr, + builder.getArrayAttr(idx)); } if (groupIsLocal) - builder.create<fir::StoreOp>(loc, list, listAddr); + fir::StoreOp::create(builder, loc, list, listAddr); else - builder.create<fir::HasValueOp>(loc, list); + fir::HasValueOp::create(builder, loc, list); }; if (groupIsLocal) listFunc(builder); @@ -547,39 +552,39 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, // Define the group. mlir::Value groupAddr = groupIsLocal - ? builder.create<fir::AllocaOp>(loc, groupTy) + ? fir::AllocaOp::create(builder, loc, groupTy) : mlir::Value{}; auto groupFunc = [&](fir::FirOpBuilder &builder) { - mlir::Value group = builder.create<fir::UndefOp>(loc, groupTy); + mlir::Value group = fir::UndefOp::create(builder, loc, groupTy); // group name [const char *groupName] - group = builder.create<fir::InsertValueOp>( - loc, groupTy, group, + group = fir::InsertValueOp::create( + builder, loc, groupTy, group, builder.createConvert(loc, charRefTy, fir::getBase(stringAddress(symbol))), builder.getArrayAttr(builder.getIntegerAttr(idxTy, 0))); // list item count [std::size_t items] - group = builder.create<fir::InsertValueOp>( - loc, groupTy, group, + group = fir::InsertValueOp::create( + builder, loc, groupTy, group, builder.createIntegerConstant(loc, sizeTy, details.objects().size()), builder.getArrayAttr(builder.getIntegerAttr(idxTy, 1))); // item list [const Item *item] if (fir::GlobalOp list = builder.getNamedGlobal(listMangleName)) - listAddr = builder.create<fir::AddrOfOp>(loc, list.resultType(), - list.getSymbol()); + listAddr = fir::AddrOfOp::create(builder, loc, list.resultType(), + list.getSymbol()); assert(listAddr && "missing namelist object list"); - group = builder.create<fir::InsertValueOp>( - loc, groupTy, group, listAddr, + group = fir::InsertValueOp::create( + builder, loc, groupTy, group, listAddr, builder.getArrayAttr(builder.getIntegerAttr(idxTy, 2))); // non-type-bound defined IO procedures // [const NonTbpDefinedIoTable *nonTbpDefinedIo] - group = builder.create<fir::InsertValueOp>( - loc, groupTy, group, + group = fir::InsertValueOp::create( + builder, loc, groupTy, group, getNonTbpDefinedIoTableAddr(converter, definedIoProcMap), builder.getArrayAttr(builder.getIntegerAttr(idxTy, 3))); if (groupIsLocal) - builder.create<fir::StoreOp>(loc, group, groupAddr); + fir::StoreOp::create(builder, loc, group, groupAddr); else - builder.create<fir::HasValueOp>(loc, group); + fir::HasValueOp::create(builder, loc, group); }; if (groupIsLocal) { groupFunc(builder); @@ -587,8 +592,8 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter, fir::GlobalOp group = builder.createGlobal( loc, groupTy, groupMangleName, /*isConst=*/true, /*isTarget=*/false, groupFunc, linkOnce); - groupAddr = builder.create<fir::AddrOfOp>(loc, group.resultType(), - group.getSymbol()); + groupAddr = fir::AddrOfOp::create(builder, loc, group.resultType(), + group.getSymbol()); } assert(groupAddr && "missing namelist group result"); return groupAddr; @@ -608,7 +613,7 @@ static void genNamelistIO(Fortran::lower::AbstractConverter &converter, getNamelistGroup(converter, symbol.GetUltimate(), stmtCtx); groupAddr = builder.createConvert(loc, argType, groupAddr); llvm::SmallVector<mlir::Value> args = {cookie, groupAddr}; - ok = builder.create<fir::CallOp>(loc, funcOp, args).getResult(0); + ok = fir::CallOp::create(builder, loc, funcOp, args).getResult(0); } /// Is \p type a derived type or an array of derived type? @@ -751,7 +756,7 @@ static void genOutputItemList( outputFuncArgs.push_back(itemValue); } } - ok = builder.create<fir::CallOp>(loc, outputFunc, outputFuncArgs) + ok = fir::CallOp::create(builder, loc, outputFunc, outputFuncArgs) .getResult(0); } } @@ -812,12 +817,12 @@ static void boolRefToLogical(mlir::Location loc, fir::FirOpBuilder &builder, mlir::Value addr) { auto boolType = builder.getRefType(builder.getI1Type()); auto boolAddr = builder.createConvert(loc, boolType, addr); - auto boolValue = builder.create<fir::LoadOp>(loc, boolAddr); + auto boolValue = fir::LoadOp::create(builder, loc, boolAddr); auto logicalType = fir::unwrapPassByRefType(addr.getType()); // The convert avoid making any assumptions about how LOGICALs are actually // represented (it might end-up being either a signed or zero extension). auto logicalValue = builder.createConvert(loc, logicalType, boolValue); - builder.create<fir::StoreOp>(loc, logicalValue, addr); + fir::StoreOp::create(builder, loc, logicalValue, addr); } static mlir::Value @@ -849,12 +854,13 @@ createIoRuntimeCallForItem(Fortran::lower::AbstractConverter &converter, inputFuncArgs.push_back(builder.createConvert( loc, inputFunc.getFunctionType().getInput(2), len)); } else if (mlir::isa<mlir::IntegerType>(itemTy)) { - inputFuncArgs.push_back(builder.create<mlir::arith::ConstantOp>( - loc, builder.getI32IntegerAttr( - mlir::cast<mlir::IntegerType>(itemTy).getWidth() / 8))); + inputFuncArgs.push_back(mlir::arith::ConstantOp::create( + builder, loc, + builder.getI32IntegerAttr( + mlir::cast<mlir::IntegerType>(itemTy).getWidth() / 8))); } } - auto call = builder.create<fir::CallOp>(loc, inputFunc, inputFuncArgs); + auto call = fir::CallOp::create(builder, loc, inputFunc, inputFuncArgs); auto itemAddr = fir::getBase(item); auto itemTy = fir::unwrapRefType(itemAddr.getType()); if (mlir::isa<fir::LogicalType>(itemTy)) @@ -951,7 +957,7 @@ static void genIoLoop(Fortran::lower::AbstractConverter &converter, mlir::Value stepValue = control.step.has_value() ? genControlValue(*control.step) - : builder.create<mlir::arith::ConstantIndexOp>(loc, 1); + : mlir::arith::ConstantIndexOp::create(builder, loc, 1); auto genItemList = [&](const D &ioImpliedDo) { if constexpr (std::is_same_v<D, Fortran::parser::InputImpliedDo>) genInputItemList(converter, cookie, itemList, isFormatted, checkResult, @@ -962,35 +968,36 @@ static void genIoLoop(Fortran::lower::AbstractConverter &converter, }; if (!checkResult) { // No IO call result checks - the loop is a fir.do_loop op. - auto doLoopOp = builder.create<fir::DoLoopOp>( - loc, lowerValue, upperValue, stepValue, /*unordered=*/false, - /*finalCountValue=*/true); + auto doLoopOp = fir::DoLoopOp::create(builder, loc, lowerValue, upperValue, + stepValue, /*unordered=*/false, + /*finalCountValue=*/true); builder.setInsertionPointToStart(doLoopOp.getBody()); mlir::Value lcv = builder.createConvert( loc, fir::unwrapRefType(loopVar.getType()), doLoopOp.getInductionVar()); - builder.create<fir::StoreOp>(loc, lcv, loopVar); + fir::StoreOp::create(builder, loc, lcv, loopVar); genItemList(ioImpliedDo); builder.setInsertionPointToEnd(doLoopOp.getBody()); - mlir::Value result = builder.create<mlir::arith::AddIOp>( - loc, doLoopOp.getInductionVar(), doLoopOp.getStep(), iofAttr); - builder.create<fir::ResultOp>(loc, result); + mlir::Value result = mlir::arith::AddIOp::create( + builder, loc, doLoopOp.getInductionVar(), doLoopOp.getStep(), iofAttr); + fir::ResultOp::create(builder, loc, result); builder.setInsertionPointAfter(doLoopOp); // The loop control variable may be used after the loop. lcv = builder.createConvert(loc, fir::unwrapRefType(loopVar.getType()), doLoopOp.getResult(0)); - builder.create<fir::StoreOp>(loc, lcv, loopVar); + fir::StoreOp::create(builder, loc, lcv, loopVar); return; } // Check IO call results - the loop is a fir.iterate_while op. if (!ok) ok = builder.createBool(loc, true); - auto iterWhileOp = builder.create<fir::IterWhileOp>( - loc, lowerValue, upperValue, stepValue, ok, /*finalCountValue*/ true); + auto iterWhileOp = + fir::IterWhileOp::create(builder, loc, lowerValue, upperValue, stepValue, + ok, /*finalCountValue*/ true); builder.setInsertionPointToStart(iterWhileOp.getBody()); mlir::Value lcv = builder.createConvert(loc, fir::unwrapRefType(loopVar.getType()), iterWhileOp.getInductionVar()); - builder.create<fir::StoreOp>(loc, lcv, loopVar); + fir::StoreOp::create(builder, loc, lcv, loopVar); ok = iterWhileOp.getIterateVar(); mlir::Value falseValue = builder.createIntegerConstant(loc, builder.getI1Type(), 0); @@ -1003,28 +1010,28 @@ static void genIoLoop(Fortran::lower::AbstractConverter &converter, builder.setInsertionPointAfter(lastOp); // The primary ifOp result is the result of an IO call or loop. if (mlir::isa<fir::CallOp, fir::IfOp>(*lastOp)) - builder.create<fir::ResultOp>(loc, lastOp->getResult(0)); + fir::ResultOp::create(builder, loc, lastOp->getResult(0)); else - builder.create<fir::ResultOp>(loc, ok); // loop result + fir::ResultOp::create(builder, loc, ok); // loop result // The else branch propagates an early exit false result. builder.setInsertionPointToStart(&ifOp.getElseRegion().front()); - builder.create<fir::ResultOp>(loc, falseValue); + fir::ResultOp::create(builder, loc, falseValue); } builder.setInsertionPointToEnd(iterWhileOp.getBody()); mlir::OpResult iterateResult = builder.getBlock()->back().getResult(0); mlir::Value inductionResult0 = iterWhileOp.getInductionVar(); - auto inductionResult1 = builder.create<mlir::arith::AddIOp>( - loc, inductionResult0, iterWhileOp.getStep(), iofAttr); - auto inductionResult = builder.create<mlir::arith::SelectOp>( - loc, iterateResult, inductionResult1, inductionResult0); + auto inductionResult1 = mlir::arith::AddIOp::create( + builder, loc, inductionResult0, iterWhileOp.getStep(), iofAttr); + auto inductionResult = mlir::arith::SelectOp::create( + builder, loc, iterateResult, inductionResult1, inductionResult0); llvm::SmallVector<mlir::Value> results = {inductionResult, iterateResult}; - builder.create<fir::ResultOp>(loc, results); + fir::ResultOp::create(builder, loc, results); ok = iterWhileOp.getResult(1); builder.setInsertionPointAfter(iterWhileOp); // The loop control variable may be used after the loop. lcv = builder.createConvert(loc, fir::unwrapRefType(loopVar.getType()), iterWhileOp.getResult(0)); - builder.create<fir::StoreOp>(loc, lcv, loopVar); + fir::StoreOp::create(builder, loc, lcv, loopVar); } //===----------------------------------------------------------------------===// @@ -1046,15 +1053,15 @@ static mlir::Value locToLineNo(Fortran::lower::AbstractConverter &converter, static mlir::Value getDefaultScratch(fir::FirOpBuilder &builder, mlir::Location loc, mlir::Type toType) { - mlir::Value null = builder.create<mlir::arith::ConstantOp>( - loc, builder.getI64IntegerAttr(0)); + mlir::Value null = mlir::arith::ConstantOp::create( + builder, loc, builder.getI64IntegerAttr(0)); return builder.createConvert(loc, toType, null); } static mlir::Value getDefaultScratchLen(fir::FirOpBuilder &builder, mlir::Location loc, mlir::Type toType) { - return builder.create<mlir::arith::ConstantOp>( - loc, builder.getIntegerAttr(toType, 0)); + return mlir::arith::ConstantOp::create(builder, loc, + builder.getIntegerAttr(toType, 0)); } /// Generate a reference to a buffer and the length of buffer given @@ -1105,8 +1112,8 @@ lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc, mlir::Value kind; if (ty2) { auto kindVal = expr->GetType().value().kind(); - kind = builder.create<mlir::arith::ConstantOp>( - loc, builder.getIntegerAttr(ty2, kindVal)); + kind = mlir::arith::ConstantOp::create( + builder, loc, builder.getIntegerAttr(ty2, kindVal)); } return {buff, len, kind}; } @@ -1146,7 +1153,7 @@ mlir::Value genIntIOOption(Fortran::lower::AbstractConverter &converter, loc, Fortran::semantics::GetExpr(spec.v), localStatementCtx)); mlir::Value val = builder.createConvert(loc, ioFuncTy.getInput(1), expr); llvm::SmallVector<mlir::Value> ioArgs = {cookie, val}; - return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); + return fir::CallOp::create(builder, loc, ioFunc, ioArgs).getResult(0); } /// Generic to build a string argument to the runtime. This passes a CHARACTER @@ -1164,7 +1171,7 @@ mlir::Value genCharIOOption(Fortran::lower::AbstractConverter &converter, ioFuncTy.getInput(1), ioFuncTy.getInput(2)); llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup), std::get<1>(tup)}; - return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); + return fir::CallOp::create(builder, loc, ioFunc, ioArgs).getResult(0); } template <typename A> @@ -1197,7 +1204,7 @@ mlir::Value genIOOption<Fortran::parser::FileNameExpr>( ioFuncTy.getInput(1), ioFuncTy.getInput(2)); llvm::SmallVector<mlir::Value> ioArgs{cookie, std::get<0>(tup), std::get<1>(tup)}; - return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); + return fir::CallOp::create(builder, loc, ioFunc, ioArgs).getResult(0); } template <> @@ -1262,7 +1269,7 @@ mlir::Value genIOOption<Fortran::parser::ConnectSpec::CharExpr>( ioFuncTy.getInput(1), ioFuncTy.getInput(2)); llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup), std::get<1>(tup)}; - return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); + return fir::CallOp::create(builder, loc, ioFunc, ioArgs).getResult(0); } template <> @@ -1316,7 +1323,7 @@ mlir::Value genIOOption<Fortran::parser::IoControlSpec::CharExpr>( ioFuncTy.getInput(1), ioFuncTy.getInput(2)); llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup), std::get<1>(tup)}; - return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); + return fir::CallOp::create(builder, loc, ioFunc, ioArgs).getResult(0); } template <> @@ -1352,7 +1359,7 @@ static void genIOGetVar(Fortran::lower::AbstractConverter &converter, mlir::func::FuncOp ioFunc = fir::runtime::getIORuntimeFunc<IoRuntimeKey>(loc, builder); mlir::Value value = - builder.create<fir::CallOp>(loc, ioFunc, mlir::ValueRange{cookie}) + fir::CallOp::create(builder, loc, ioFunc, mlir::ValueRange{cookie}) .getResult(0); Fortran::lower::StatementContext localStatementCtx; fir::ExtendedValue var = converter.genExprAddr( @@ -1480,8 +1487,8 @@ genConditionHandlerCall(Fortran::lower::AbstractConverter &converter, fir::runtime::getIORuntimeFunc<mkIOKey(EnableHandlers)>(loc, builder); mlir::Type boolType = enableHandlers.getFunctionType().getInput(1); auto boolValue = [&](bool specifierIsPresent) { - return builder.create<mlir::arith::ConstantOp>( - loc, builder.getIntegerAttr(boolType, specifierIsPresent)); + return mlir::arith::ConstantOp::create( + builder, loc, builder.getIntegerAttr(boolType, specifierIsPresent)); }; llvm::SmallVector<mlir::Value> ioArgs = {cookie, boolValue(csi.ioStatExpr != nullptr), @@ -1489,7 +1496,7 @@ genConditionHandlerCall(Fortran::lower::AbstractConverter &converter, boolValue(csi.hasEnd), boolValue(csi.hasEor), boolValue(csi.ioMsg.has_value())}; - builder.create<fir::CallOp>(loc, enableHandlers, ioArgs); + fir::CallOp::create(builder, loc, enableHandlers, ioArgs); } //===----------------------------------------------------------------------===// @@ -1663,7 +1670,7 @@ lowerReferenceAsStringSelect(Fortran::lower::AbstractConverter &converter, // Pass the format string reference and the string length out of the select // statement. llvm::SmallVector<mlir::Value> args = {stringRef, stringLen}; - builder.create<mlir::cf::BranchOp>(loc, endBlock, args); + mlir::cf::BranchOp::create(builder, loc, endBlock, args); // Add block to the list of cases and make a new one. blockList.push_back(block); @@ -1678,13 +1685,13 @@ lowerReferenceAsStringSelect(Fortran::lower::AbstractConverter &converter, builder, loc, "Assigned format variable '" + symbol->name().ToString() + "' has not been assigned a valid format label"); - builder.create<fir::UnreachableOp>(loc); + fir::UnreachableOp::create(builder, loc); blockList.push_back(unitBlock); // Lower the selectOp. builder.setInsertionPointToEnd(startBlock); auto label = fir::getBase(converter.genExprValue(loc, &expr, stmtCtx)); - builder.create<fir::SelectOp>(loc, label, indexList, blockList); + fir::SelectOp::create(builder, loc, label, indexList, blockList); builder.setInsertionPointToEnd(endBlock); endBlock->addArgument(strTy, loc); @@ -1814,17 +1821,17 @@ static mlir::Value genIOUnitNumber(Fortran::lower::AbstractConverter &converter, mlir::Value line = locToLineNo(converter, loc, funcTy.getInput(5)); args.push_back(file); args.push_back(line); - auto checkCall = builder.create<fir::CallOp>(loc, check, args); + auto checkCall = fir::CallOp::create(builder, loc, check, args); if (csi.hasErrorConditionSpec()) { mlir::Value iostat = checkCall.getResult(0); mlir::Type iostatTy = iostat.getType(); mlir::Value zero = fir::factory::createZeroValue(builder, loc, iostatTy); - mlir::Value unitIsOK = builder.create<mlir::arith::CmpIOp>( - loc, mlir::arith::CmpIPredicate::eq, iostat, zero); - auto ifOp = builder.create<fir::IfOp>(loc, iostatTy, unitIsOK, - /*withElseRegion=*/true); + mlir::Value unitIsOK = mlir::arith::CmpIOp::create( + builder, loc, mlir::arith::CmpIPredicate::eq, iostat, zero); + auto ifOp = fir::IfOp::create(builder, loc, iostatTy, unitIsOK, + /*withElseRegion=*/true); builder.setInsertionPointToStart(&ifOp.getElseRegion().front()); - builder.create<fir::ResultOp>(loc, iostat); + fir::ResultOp::create(builder, loc, iostat); builder.setInsertionPointToStart(&ifOp.getThenRegion().front()); stmtCtx.pushScope(); csi.bigUnitIfOp = ifOp; @@ -1846,8 +1853,8 @@ static mlir::Value genIOUnit(Fortran::lower::AbstractConverter &converter, &iounit->u)) return genIOUnitNumber(converter, loc, Fortran::semantics::GetExpr(*e), ty, csi, stmtCtx); - return builder.create<mlir::arith::ConstantOp>( - loc, builder.getIntegerAttr(ty, defaultUnitNumber)); + return mlir::arith::ConstantOp::create( + builder, loc, builder.getIntegerAttr(ty, defaultUnitNumber)); } template <typename A> @@ -1879,8 +1886,8 @@ static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter, mlir::Value un = builder.createConvert(loc, beginFuncTy.getInput(0), unit); mlir::Value file = locToFilename(converter, loc, beginFuncTy.getInput(1)); mlir::Value line = locToLineNo(converter, loc, beginFuncTy.getInput(2)); - auto call = builder.create<fir::CallOp>(loc, beginFunc, - mlir::ValueRange{un, file, line}); + auto call = fir::CallOp::create(builder, loc, beginFunc, + mlir::ValueRange{un, file, line}); mlir::Value cookie = call.getResult(0); genConditionHandlerCall(converter, loc, cookie, stmt.v, csi); mlir::Value ok; @@ -1934,7 +1941,7 @@ genNewunitSpec(Fortran::lower::AbstractConverter &converter, mlir::Location loc, auto kind = builder.createIntegerConstant(loc, ioFuncTy.getInput(2), var->GetType().value().kind()); llvm::SmallVector<mlir::Value> ioArgs = {cookie, addr, kind}; - return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); + return fir::CallOp::create(builder, loc, ioFunc, ioArgs).getResult(0); } llvm_unreachable("missing Newunit spec"); } @@ -1969,7 +1976,7 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter, beginArgs.push_back(locToLineNo(converter, loc, beginFuncTy.getInput(1))); } auto cookie = - builder.create<fir::CallOp>(loc, beginFunc, beginArgs).getResult(0); + fir::CallOp::create(builder, loc, beginFunc, beginArgs).getResult(0); genConditionHandlerCall(converter, loc, cookie, stmt.v, csi); mlir::Value ok; auto insertPt = builder.saveInsertionPoint(); @@ -2013,7 +2020,7 @@ Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter, args.push_back(locToFilename(converter, loc, beginFuncTy.getInput(1))); args.push_back(locToLineNo(converter, loc, beginFuncTy.getInput(2))); } - auto cookie = builder.create<fir::CallOp>(loc, beginFunc, args).getResult(0); + auto cookie = fir::CallOp::create(builder, loc, beginFunc, args).getResult(0); genConditionHandlerCall(converter, loc, cookie, stmt.v, csi); return genEndIO(converter, converter.getCurrentLocation(), cookie, csi, stmtCtx); @@ -2149,9 +2156,10 @@ void genBeginDataTransferCallArgs( } } else { // PRINT - maybe explicit format; default unit maybeGetFormatArgs(); - ioArgs.push_back(builder.create<mlir::arith::ConstantOp>( - loc, builder.getIntegerAttr(ioFuncTy.getInput(ioArgs.size()), - defaultUnitNumber))); + ioArgs.push_back(mlir::arith::ConstantOp::create( + builder, loc, + builder.getIntegerAttr(ioFuncTy.getInput(ioArgs.size()), + defaultUnitNumber))); } // File name and line number are always the last two arguments. ioArgs.push_back( @@ -2198,7 +2206,7 @@ genDataTransferStmt(Fortran::lower::AbstractConverter &converter, ioArgs, converter, loc, stmt, ioFunc.getFunctionType(), isFormatted, isList || isNml, isInternal, descRef, csi, stmtCtx); mlir::Value cookie = - builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); + fir::CallOp::create(builder, loc, ioFunc, ioArgs).getResult(0); auto insertPt = builder.saveInsertionPoint(); mlir::Value ok; @@ -2332,7 +2340,7 @@ mlir::Value genInquireSpec<Fortran::parser::InquireSpec::CharVar>( .c_str())), builder.createConvert(loc, specFuncTy.getInput(2), fir::getBase(str)), builder.createConvert(loc, specFuncTy.getInput(3), fir::getLen(str))}; - return builder.create<fir::CallOp>(loc, specFunc, args).getResult(0); + return fir::CallOp::create(builder, loc, specFunc, args).getResult(0); } /// Specialization for INTEGER. template <> @@ -2369,7 +2377,7 @@ mlir::Value genInquireSpec<Fortran::parser::InquireSpec::IntVar>( .c_str())), builder.createConvert(loc, specFuncTy.getInput(2), addr), builder.createConvert(loc, specFuncTy.getInput(3), kind)}; - return builder.create<fir::CallOp>(loc, specFunc, args).getResult(0); + return fir::CallOp::create(builder, loc, specFunc, args).getResult(0); } /// Specialization for LOGICAL and (PENDING + ID). template <> @@ -2406,7 +2414,7 @@ mlir::Value genInquireSpec<Fortran::parser::InquireSpec::LogVar>( Fortran::parser::InquireSpec::LogVar::EnumToString(logVarKind)} .c_str()))); args.push_back(builder.createConvert(loc, specFuncTy.getInput(2), addr)); - auto call = builder.create<fir::CallOp>(loc, specFunc, args); + auto call = fir::CallOp::create(builder, loc, specFunc, args); boolRefToLogical(loc, builder, addr); return call.getResult(0); } @@ -2502,7 +2510,7 @@ mlir::Value Fortran::lower::genInquireStatement( beginArgs = {locToFilename(converter, loc, beginFuncTy.getInput(0)), locToLineNo(converter, loc, beginFuncTy.getInput(1))}; auto cookie = - builder.create<fir::CallOp>(loc, beginFunc, beginArgs).getResult(0); + fir::CallOp::create(builder, loc, beginFunc, beginArgs).getResult(0); mlir::Value ok; genOutputItemList( converter, cookie, @@ -2523,14 +2531,14 @@ mlir::Value Fortran::lower::genInquireStatement( .getResult(0); mlir::Value length1 = builder.createConvert(loc, converter.genType(*ioLengthVar), length); - builder.create<fir::StoreOp>(loc, length1, ioLengthVarAddr); + fir::StoreOp::create(builder, loc, length1, ioLengthVarAddr); return genEndIO(converter, loc, cookie, csi, stmtCtx); } // Common handling for inquire by unit or file. assert(list && "inquire-spec list must be present"); auto cookie = - builder.create<fir::CallOp>(loc, beginFunc, beginArgs).getResult(0); + fir::CallOp::create(builder, loc, beginFunc, beginArgs).getResult(0); genConditionHandlerCall(converter, loc, cookie, *list, csi); // Handle remaining arguments in specifier list. mlir::Value ok; |