Lines Matching defs:iters
3613 ccStoreToDest = [=](IterSpace iters) {
3620 auto seqTy = fir::SequenceType::get(eleTy, iters.iterVec().size());
3625 loc, builder, castTo.getType(), shape, iters.iterVec());
3630 builder.createConvert(loc, eleTy, iters.getElement());
3632 return iters.innerArgument();
3671 ccStoreToDest = [=](IterSpace iters) -> ExtValue {
3672 auto modifiedArray = genArrayModify(iters);
3679 iters.elementExv());
3753 IterationSpace iters;
3754 iters.setElement(genarr(rhs)(iters));
3757 auto lexv = genarr(lhs)(iters);
3806 IterationSpace iters;
3807 iters.setElement(genarr(rhs)(iters));
3808 fir::ExtendedValue elementalExv = iters.elementExv();
3811 auto lexv = genarr(lhs)(iters);
4033 /// `iters.element` into the destination array, `iters.innerArgument`. Handles
4200 return [=, builder = &converter.getFirOpBuilder()](IterSpace iters) {
4207 loc, *builder, tmp.getType(), shape, iters.iterVec());
4453 auto [iters, afterLoopNest] = genImplicitLoops(shape, inner);
4454 mlir::Value innerArg = iters.innerArgument();
4461 auto genCond = [&](Fortran::lower::FrontEndExpr e, IterSpace iters) {
4462 return implicitSpace->getBoundClosure(e)(iters);
4490 genFalseBlock(e, genCond(e, iters));
4494 genTrueBlock(e, genCond(e, iters));
4500 return {iters, afterLoopNest};
4626 return [=](IterSpace iters) -> ExtValue {
4627 return createInMemoryScalarCopy(builder, loc, cc(iters));
4632 return [=](IterSpace iters) -> ExtValue {
4633 return placeScalarValueInMemory(builder, loc, cc(iters), storageType);
4672 [=](IterSpace iters) -> ExtValue {
4693 return [=](IterSpace iters) -> ExtValue {
4695 return operands[i].first(iters);
4745 operands.emplace_back([=](IterSpace iters) {
4746 return builder.createBox(loc, lambda(iters));
4757 return [=](IterSpace iters) {
4760 args.push_back(cc(iters));
4828 [=](IterSpace iters) -> ExtValue { return temp; });
4837 operands.emplace_back([=](IterSpace iters) { return exv; });
4844 operands.emplace_back([=](IterSpace iters) {
4846 .createTempFrom(lambda(iters));
4852 [=](IterSpace iters) -> ExtValue { return argVal; });
4870 [=](IterSpace iters) -> ExtValue { return tuple; });
4884 operands.emplace_back([=](IterSpace iters) -> ExtValue {
4887 iters.iterVec());
4898 [=](IterSpace iters) -> ExtValue { return exv; });
4902 operands.emplace_back([=](IterSpace iters) -> ExtValue {
4926 caller = std::move(caller)](IterSpace iters) mutable -> ExtValue {
4929 auto exv = cc(iters);
4979 return [=](IterSpace iters) {
4980 assert(iters.iterVec().size() == 2 &&
4982 IterationSpace newIters(iters, {iters.iterValue(1), iters.iterValue(0)});
5026 // Elide any implicit loop iters.
5039 // Elide any implicit loop iters.
5117 return [=](IterSpace iters) -> ExtValue {
5118 auto exv = lambda(iters);
5133 return [=](IterSpace iters) -> ExtValue {
5134 mlir::Value lhs = fir::getBase(lambda(iters));
5151 return [=](IterSpace iters) -> ExtValue {
5152 auto val = f(iters);
5164 return [=](IterSpace iters) -> ExtValue {
5165 mlir::Value val = fir::getBase(f(iters));
5193 return [=](IterSpace iters) -> ExtValue {
5194 return builder.create<mlir::arith::NegFOp>(loc, fir::getBase(f(iters)));
5202 return [=](IterSpace iters) -> ExtValue {
5203 return builder.create<fir::NegcOp>(loc, fir::getBase(f(iters)));
5216 return [=](IterSpace iters) -> ExtValue {
5217 mlir::Value left = fir::getBase(lambda(iters));
5218 mlir::Value right = fir::getBase(rf(iters));
5256 return [=](IterSpace iters) -> ExtValue {
5257 mlir::Value lhs = fir::getBase(lf(iters));
5258 mlir::Value rhs = fir::getBase(rf(iters));
5270 return [=](IterSpace iters) -> ExtValue {
5271 mlir::Value lhs = fir::getBase(lf(iters));
5272 mlir::Value rhs = fir::getBase(rf(iters));
5284 return [=](IterSpace iters) -> ExtValue {
5285 mlir::Value lhs = fir::getBase(lf(iters));
5286 mlir::Value rhs = fir::getBase(rf(iters));
5290 return [=](IterSpace iters) -> ExtValue {
5291 mlir::Value lhs = fir::getBase(lf(iters));
5292 mlir::Value rhs = fir::getBase(rf(iters));
5308 return [=](IterSpace iters) {
5309 mlir::Value lhs = fir::getBase(lf(iters));
5310 mlir::Value rhs = fir::getBase(rf(iters));
5319 return [=](IterSpace iters) -> ExtValue {
5320 mlir::Value lhs = fir::getBase(lf(iters));
5321 mlir::Value rhs = fir::getBase(rf(iters));
5332 return [=](IterSpace iters) -> ExtValue {
5333 auto lhs = lf(iters);
5334 auto rhs = rf(iters);
5355 return [=](IterSpace iters) -> ExtValue {
5357 .createAssign(temp, lf(iters));
5485 IterSpace iters, std::size_t dim) {
5486 IterationSpace vecIters(iters,
5487 llvm::ArrayRef<mlir::Value>{iters.iterValue(dim)});
5545 pc = [=](IterSpace iters) {
5546 IterationSpace newIters = currentPC(iters);
5582 pc = [=](IterSpace iters) {
5583 IterationSpace newIters = currentPC(iters);
5631 pc = [=](IterSpace iters) {
5632 IterationSpace newIters = currentPC(iters);
5645 pc = [=](IterSpace iters) {
5646 IterationSpace newIters = currentPC(iters);
5847 return [=](IterSpace iters) -> ExtValue {
5850 loc, builder, memref.getType(), shape, iters.iterVec());
5860 fir::getTypeParams(extMemref), iters.iterVec(),
5895 return [=](IterSpace iters) -> ExtValue { return lambda(iters); };
5902 return [=](IterSpace iters) -> ExtValue {
5903 mlir::Value innerArg = iters.innerArgument();
5905 mlir::Type eleTy = fir::applyPathToType(resTy, iters.iterVec());
5909 loc, mlir::TypeRange{refEleTy, resTy}, innerArg, iters.iterVec(),
5929 return [=](IterSpace iters) -> ExtValue {
5931 mlir::Type eleTy = fir::applyPathToType(arrTy, iters.iterVec());
5935 loc, eleRefTy, arrLd, iters.iterVec(), arrLdTypeParams);
5938 loc, eleTy, arrLd, iters.iterVec(), arrLdTypeParams);
5951 return [=](IterSpace iters) -> ExtValue {
5952 mlir::Type eleTy = fir::applyPathToType(arrTy, iters.iterVec());
5956 loc, eleRefTy, arrLd, iters.iterVec(), arrLdTypeParams);
5962 builder, loc, arrLoad, iters.iterVec(), substringBounds);
5972 loc, eleTy, arrLd, iters.iterVec(), arrLdTypeParams);
6026 auto cc = [=](IterSpace iters) -> ExtValue {
6028 loc, eleType, arrLd, iters.iterVec(), arrLdTypeParams);
6053 return [=](IterSpace iters) -> ExtValue { return elementValue; };
6060 return [=](IterSpace iters) -> ExtValue {
6066 builder.create<fir::ResultOp>(loc, fir::getBase(cc(iters)));
6547 return [](IterSpace iters) -> ExtValue { return mlir::Value{}; };
6551 return [](IterSpace iters) -> ExtValue { return mlir::Value{}; };
6555 return [](IterSpace iters) -> ExtValue { return mlir::Value{}; };
6568 return [=](IterSpace iters) -> ExtValue {
6569 mlir::Value logical = fir::getBase(lambda(iters));
6580 return [=](IterSpace iters) -> ExtValue {
6581 mlir::Value left = fir::getBase(lf(iters));
6582 mlir::Value right = fir::getBase(rf(iters));
6594 return [=](IterSpace iters) -> ExtValue {
6595 mlir::Value left = fir::getBase(lf(iters));
6596 mlir::Value right = fir::getBase(rf(iters));
6631 return [=](IterSpace iters) -> ExtValue {
6632 mlir::Value lhs = fir::getBase(lf(iters));
6633 mlir::Value rhs = fir::getBase(rf(iters));
6649 return [=](IterSpace iters) -> ExtValue {
6650 auto lhs = lf(iters);
6651 auto rhs = rf(iters);
6885 suffix = components.suffixComponents](IterSpace iters) {
6887 return IterationSpace(currentPC(iters), prefix, suffix);
6894 auto lambda = [=, esp = this->explicitSpace](IterSpace iters) mutable {
6899 loc, eleRefTy, innerArg, iters.iterVec(),
6903 builder, loc, load, iters.iterVec(), substringBounds);
6905 loc, builder, arrayOp, dstLen, iters.elementExv(), innerArg,
6907 return arrayLoadExtValue(builder, loc, load, iters.iterVec(), amend,
6913 iters.elementExv(), eleTy, innerArg);
6914 return arrayLoadExtValue(builder, loc, load, iters.iterVec(),
6922 fir::applyPathToType(innerArg.getType(), iters.iterVec());
6927 loc, builder.getRefType(eleBoxTy), innerArg, iters.iterVec(),
6941 auto ele = convertElementForUpdate(loc, eleTy, iters.getElement());
6945 return arrayLoadExtValue(builder, loc, load, iters.iterVec(), amend);
6947 auto ele = convertElementForUpdate(loc, eleTy, iters.getElement());
6949 loc, innerArg.getType(), innerArg, ele, iters.iterVec(),
6951 return arrayLoadExtValue(builder, loc, load, iters.iterVec(), update);
6953 return [=](IterSpace iters) mutable { return lambda(pc(iters)); };
6959 auto lambda = [=](IterSpace iters) mutable {
6965 iters.iterVec(), load.getTypeparams());
6966 return arrayLoadExtValue(builder, loc, load, iters.iterVec(),
6969 return [=](IterSpace iters) mutable { return lambda(pc(iters)); };
6971 auto lambda = [=, semant = this->semant](IterSpace iters) mutable {
6977 loc, resTy, load, iters.iterVec(),
6982 builder, loc, load, iters.iterVec(), substringBounds);
6989 return arrayLoadExtValue(builder, loc, load, iters.iterVec(), newBase,
6992 return arrayLoadExtValue(builder, loc, load, iters.iterVec(), newBase);
6995 auto eleBoxTy = fir::applyPathToType(load.getType(), iters.iterVec());
7000 loc, builder.getRefType(eleBoxTy), load, iters.iterVec(),
7004 return arrayLoadExtValue(builder, loc, load, iters.iterVec(), addr);
7007 auto eleTy = fir::applyPathToType(load.getType(), iters.iterVec());
7013 loc, builder.getRefType(eleTy), load, iters.iterVec(),
7029 return arrayLoadExtValue(builder, loc, load, iters.iterVec(), embox);
7033 loc, eleTy, load, iters.iterVec(), load.getTypeparams());
7034 return arrayLoadExtValue(builder, loc, load, iters.iterVec(), fetch);
7036 return [=](IterSpace iters) mutable { return lambda(pc(iters)); };
7045 return [=](IterSpace iters) { return lambda(components.pc(iters)); };
7067 return [=](IterSpace iters) { return lambda(components.pc(iters)); };
7075 IterSpace iters) -> ExtValue {
7082 exv, iters.elementExv());
7089 auto eleVal = convertElementForUpdate(loc, eleTy, iters.getElement());