Lines Matching defs:args
81 static bool isStaticallyAbsent(llvm::ArrayRef<fir::ExtendedValue> args,
83 return args.size() <= argIndex || isStaticallyAbsent(args[argIndex]);
85 static bool isStaticallyAbsent(llvm::ArrayRef<mlir::Value> args,
87 return args.size() <= argIndex || !args[argIndex];
819 llvm::ArrayRef<mlir::Value> args) {
824 return genLibCall(builder, loc, mathOp, libFuncType, args);
830 llvm::ArrayRef<mlir::Value> args) {
853 auto libCall = builder.create<fir::CallOp>(loc, funcOp, args);
867 libCall = builder.create<fir::CallOp>(loc, funcOp, args);
885 operands.append(args.begin(), args.end());
898 llvm::ArrayRef<mlir::Value> args) {
899 assert(args.size() == 2 && "Incorrect #args to genLibSplitComplexArgsCall");
901 auto getSplitComplexArgsType = [&builder, &args]() -> mlir::FunctionType {
902 mlir::Type ctype = args[0].getType();
908 mlir::Value cplx1 = args[0];
915 mlir::Value cplx2 = args[1];
930 llvm::ArrayRef<mlir::Value> args) {
958 result = genLibCall(builder, loc, mathOp, mathLibFuncType, args);
963 result = builder.create<T>(loc, args);
973 llvm::ArrayRef<mlir::Value> args) {
985 result = genLibCall(builder, loc, mathOp, mathLibFuncType, args);
998 result = builder.create<T>(loc, args);
1003 result = builder.create<T>(loc, realTy, args);
1780 llvm::ArrayRef<fir::ExtendedValue> args, bool outline) {
1782 for (const fir::ExtendedValue &arg : args)
1796 llvm::ArrayRef<fir::ExtendedValue> args, bool outline) {
1797 for (const fir::ExtendedValue &arg : args) {
1804 return outlineInExtendedWrapper(generator, name, resultType, args);
1805 return std::invoke(generator, *this, resultType, args);
1812 llvm::ArrayRef<fir::ExtendedValue> args, bool outline) {
1813 for (const fir::ExtendedValue &arg : args)
1818 return outlineInExtendedWrapper(generator, name, resultType, args);
1819 std::invoke(generator, *this, args);
1827 llvm::ArrayRef<fir::ExtendedValue> args, bool outline) {
1830 for (const fir::ExtendedValue &arg : args)
1835 return outlineInExtendedWrapper(generator, name, resultType, args);
1838 args);
1845 llvm::ArrayRef<fir::ExtendedValue> args, bool outline,
1848 return lib.genElementalCall(generator, handler.name, *resultType, args,
1856 llvm::ArrayRef<fir::ExtendedValue> args, bool outline,
1860 return lib.genElementalCall(generator, handler.name, *resultType, args,
1864 args);
1865 return std::invoke(generator, lib, *resultType, args);
1872 llvm::ArrayRef<fir::ExtendedValue> args, bool outline,
1875 return lib.genElementalCall(generator, handler.name, mlir::Type{}, args,
1879 args);
1880 std::invoke(generator, lib, args);
1888 llvm::ArrayRef<fir::ExtendedValue> args, bool outline,
1891 return lib.genElementalCall(generator, handler.name, mlir::Type{}, args,
1895 args);
1897 return std::invoke(generator, lib, resultType, args);
1902 llvm::ArrayRef<fir::ExtendedValue> args, IntrinsicLibrary &lib) {
1907 return invokeHandler(generator, *handler, resultType, args,
1921 llvm::ArrayRef<fir::ExtendedValue> args, IntrinsicLibrary &lib) {
1929 for (const fir::ExtendedValue &extendedVal : args) {
1942 return {lib.genElementalCall(runtimeCallGenerator, name, *resultType, args,
1951 llvm::ArrayRef<fir::ExtendedValue> args,
1956 return genIntrinsicCallHelper(handler, resultType, args, library);
1964 llvm::ArrayRef<fir::ExtendedValue> args) {
1971 return genIntrinsicCallHelper(handler, resultType, args, *this);
1979 llvm::ArrayRef<mlir::Value> args) {
1980 return std::invoke(generator, *this, resultType, args);
1986 llvm::ArrayRef<mlir::Value> args) {
1987 return generator(builder, loc, args);
1993 llvm::ArrayRef<mlir::Value> args) {
1995 for (mlir::Value arg : args)
2003 llvm::ArrayRef<mlir::Value> args) {
2005 for (mlir::Value arg : args)
2013 llvm::ArrayRef<mlir::Value> args) {
2015 for (mlir::Value arg : args)
2024 llvm::ArrayRef<mlir::Value> args) {
2026 for (mlir::Value arg : args)
2156 bool static hasAbsentOptional(llvm::ArrayRef<mlir::Value> args) {
2157 for (const mlir::Value &arg : args)
2162 bool static hasAbsentOptional(llvm::ArrayRef<fir::ExtendedValue> args) {
2163 for (const fir::ExtendedValue &arg : args)
2173 llvm::ArrayRef<mlir::Value> args) {
2174 if (hasAbsentOptional(args)) {
2183 mlir::FunctionType funcType = getFunctionType(resultType, args, builder);
2191 return builder.create<fir::CallOp>(loc, wrapper, args).getResult(0);
2198 llvm::ArrayRef<fir::ExtendedValue> args) {
2199 if (hasAbsentOptional(args))
2203 for (const auto &extendedVal : args)
2250 llvm::ArrayRef<mlir::Value> args) {
2252 for (auto [fst, snd] : llvm::zip(actualFuncType.getInputs(), args))
2345 llvm::ArrayRef<mlir::Value> args) {
2347 getFunctionType(resultType, args, builder);
2348 return getRuntimeCallGenerator(name, soughtFuncType)(builder, loc, args);
2352 llvm::ArrayRef<mlir::Value> args) {
2354 assert(args.size() >= 1);
2355 return builder.convertWithSemantics(loc, resultType, args[0]);
2359 void IntrinsicLibrary::genAbort(llvm::ArrayRef<fir::ExtendedValue> args) {
2360 assert(args.size() == 0);
2366 llvm::ArrayRef<mlir::Value> args) {
2367 assert(args.size() == 1);
2368 mlir::Value arg = args[0];
2373 return genRuntimeCall("abs", resultType, args);
2389 llvm::ArrayRef<mlir::Value> args) {
2390 assert(args.size() == 1);
2393 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
2397 mlir::Value factor = builder.createConvert(loc, args[0].getType(), dfactor);
2398 mlir::Value arg = builder.create<mlir::arith::MulFOp>(loc, args[0], factor);
2407 llvm::ArrayRef<fir::ExtendedValue> args) {
2408 assert(args.size() == 1);
2409 mlir::Value string = builder.createBox(loc, args[0]);
2425 llvm::ArrayRef<mlir::Value> args) {
2426 assert(args.size() == 1);
2428 args[0], /*isImagPart=*/true);
2433 llvm::ArrayRef<mlir::Value> args) {
2434 assert(args.size() >= 1 && args.size() <= 2);
2437 return genRuntimeCall("aint", resultType, {args[0]});
2443 llvm::ArrayRef<fir::ExtendedValue> args) {
2445 assert(args.size() == 2);
2447 mlir::Value mask = builder.createBox(loc, args[0]);
2449 fir::BoxValue maskArry = builder.createBox(loc, args[0]);
2454 bool absentDim = isStaticallyAbsent(args[1]);
2457 : fir::getBase(args[1]);
2480 llvm::ArrayRef<fir::ExtendedValue> args) {
2481 assert(args.size() == 1);
2482 return args[0].match(
2494 llvm::ArrayRef<mlir::Value> args) {
2495 assert(args.size() >= 1 && args.size() <= 2);
2498 return genRuntimeCall("anint", resultType, {args[0]});
2504 llvm::ArrayRef<fir::ExtendedValue> args) {
2506 assert(args.size() == 2);
2508 mlir::Value mask = builder.createBox(loc, args[0]);
2510 fir::BoxValue maskArry = builder.createBox(loc, args[0]);
2515 bool absentDim = isStaticallyAbsent(args[1]);
2518 : fir::getBase(args[1]);
2540 llvm::ArrayRef<mlir::Value> args) {
2541 assert(args.size() == 1);
2544 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
2548 mlir::Value factor = builder.createConvert(loc, args[0].getType(), dfactor);
2549 mlir::Value arg = builder.create<mlir::arith::MulFOp>(loc, args[0], factor);
2555 llvm::ArrayRef<mlir::Value> args) {
2557 assert(args.size() >= 1 && args.size() <= 2);
2563 if (args.size() == 2) {
2564 atan = builder.create<mlir::math::Atan2Op>(loc, fir::getBase(args[0]),
2565 fir::getBase(args[1]));
2568 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
2569 atan = getRuntimeCallGenerator("atan", ftype)(builder, loc, args);
2580 llvm::ArrayRef<mlir::Value> args) {
2582 assert(args.size() >= 1 && args.size() <= 2);
2588 if (args.size() == 2) {
2589 atan = builder.create<mlir::math::Atan2Op>(loc, fir::getBase(args[0]),
2590 fir::getBase(args[1]));
2593 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
2594 atan = getRuntimeCallGenerator("atan", ftype)(builder, loc, args);
2613 llvm::ArrayRef<mlir::Value> args) {
2614 assert(args.size() == 2);
2617 mlir::isa<mlir::IntegerType>(args[1].getType())
2620 return genAtomBinOp(builder, loc, binOp, args[0], args[1]);
2624 llvm::ArrayRef<mlir::Value> args) {
2625 assert(args.size() == 2);
2628 mlir::isa<mlir::IntegerType>(args[1].getType())
2631 return genAtomBinOp(builder, loc, binOp, args[0], args[1]);
2635 llvm::ArrayRef<mlir::Value> args) {
2636 assert(args.size() == 2);
2637 assert(mlir::isa<mlir::IntegerType>(args[1].getType()));
2640 return genAtomBinOp(builder, loc, binOp, args[0], args[1]);
2644 llvm::ArrayRef<mlir::Value> args) {
2645 assert(args.size() == 2);
2646 assert(mlir::isa<mlir::IntegerType>(args[1].getType()));
2649 return genAtomBinOp(builder, loc, binOp, args[0], args[1]);
2653 llvm::ArrayRef<mlir::Value> args) {
2654 assert(args.size() == 2);
2655 assert(mlir::isa<mlir::IntegerType>(args[1].getType()));
2658 return genAtomBinOp(builder, loc, binOp, args[0], args[1]);
2662 llvm::ArrayRef<mlir::Value> args) {
2663 assert(args.size() == 2);
2664 assert(mlir::isa<mlir::IntegerType>(args[1].getType()));
2667 return genAtomBinOp(builder, loc, binOp, args[0], args[1]);
2671 llvm::ArrayRef<mlir::Value> args) {
2672 assert(args.size() == 2);
2675 mlir::isa<mlir::IntegerType>(args[1].getType())
2678 return genAtomBinOp(builder, loc, binOp, args[0], args[1]);
2682 llvm::ArrayRef<mlir::Value> args) {
2683 assert(args.size() == 2);
2686 mlir::isa<mlir::IntegerType>(args[1].getType())
2689 return genAtomBinOp(builder, loc, binOp, args[0], args[1]);
2695 llvm::ArrayRef<fir::ExtendedValue> args) {
2696 assert(args.size() == 2);
2697 mlir::Type ptrTy = fir::getBase(args[0]).getType();
2702 ? builder.create<fir::LoadOp>(loc, fir::getBase(args[0]))
2703 : fir::getBase(args[0]);
2706 if (isStaticallyAbsent(args[1]))
2708 mlir::Value target = fir::getBase(args[1]);
2729 args[0].match([&](const fir::MutableBoxValue &x) { return &x; },
2733 const fir::ExtendedValue &target = args[1];
2746 llvm::ArrayRef<fir::ExtendedValue> args) {
2747 assert(args.size() == 2 || args.size() == 3);
2749 mlir::Value x = fir::getBase(args.back());
2751 if (args.size() == 2) {
2752 mlir::Value n = fir::getBase(args[0]);
2756 mlir::Value n1 = fir::getBase(args[0]);
2757 mlir::Value n2 = fir::getBase(args[1]);
2831 llvm::ArrayRef<fir::ExtendedValue> args) {
2832 assert(args.size() == 2 || args.size() == 3);
2834 mlir::Value x = fir::getBase(args.back());
2836 if (args.size() == 2) {
2837 mlir::Value n = fir::getBase(args[0]);
2841 mlir::Value n1 = fir::getBase(args[0]);
2842 mlir::Value n2 = fir::getBase(args[1]);
2917 llvm::ArrayRef<mlir::Value> args) {
2918 assert(args.size() == 2);
2920 mlir::Value arg0 = args[0];
2921 mlir::Value arg1 = args[1];
2954 llvm::ArrayRef<mlir::Value> args) {
2959 assert(args.size() == 2);
2960 mlir::Value word = args[0];
2966 mlir::Value shiftCount = builder.createConvert(loc, signlessType, args[1]);
2992 mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args,
2994 assert(args.size() == 1);
3001 assert(fir::isa_box_type(fir::getBase(args[0]).getType()) &&
3003 mlir::Value argAddr = getAddrFromBox(builder, loc, args[0], isFunc);
3013 mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args) {
3014 assert(args.size() == 2);
3015 mlir::Value cPtr1 = fir::getBase(args[0]);
3022 if (isStaticallyPresent(args[1])) {
3024 mlir::Value cPtr2 = fir::getBase(args[1]);
3046 mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args) {
3047 return genCAssociated(builder, loc, resultType, args);
3053 llvm::ArrayRef<fir::ExtendedValue> args) {
3054 return genCAssociated(builder, loc, resultType, args);
3060 llvm::ArrayRef<fir::ExtendedValue> args) {
3061 return genCLocOrCFunLoc(builder, loc, resultType, args, /*isFunc=*/false,
3066 void IntrinsicLibrary::genCFPointer(llvm::ArrayRef<fir::ExtendedValue> args) {
3067 assert(args.size() == 3);
3070 mlir::Value cPtr = fir::getBase(args[0]);
3075 const auto *fPtr = args[1].getBoxOf<fir::MutableBoxValue>();
3083 assert(isStaticallyPresent(args[2]) &&
3085 mlir::Value shape = fir::getBase(args[2]);
3117 llvm::ArrayRef<fir::ExtendedValue> args) {
3118 assert(args.size() == 2);
3120 fir::factory::genCPtrOrCFunptrValue(builder, loc, fir::getBase(args[0]));
3121 mlir::Value fptr = fir::getBase(args[1]);
3134 llvm::ArrayRef<fir::ExtendedValue> args) {
3135 return genCLocOrCFunLoc(builder, loc, resultType, args, /*isFunc=*/true);
3141 llvm::ArrayRef<fir::ExtendedValue> args) {
3142 return genCLocOrCFunLoc(builder, loc, resultType, args);
3149 llvm::ArrayRef<fir::ExtendedValue> args) {
3150 assert(args.size() == 2);
3151 mlir::Value cPtr1 = fir::getBase(args[0]);
3154 mlir::Value cPtr2 = fir::getBase(args[1]);
3164 llvm::ArrayRef<mlir::Value> args) {
3166 assert(args.size() >= 1);
3167 mlir::Value arg = args[0];
3178 llvm::ArrayRef<fir::ExtendedValue> args) {
3180 assert(args.size() >= 1);
3181 const mlir::Value *arg = args[0].getUnboxed();
3196 llvm::ArrayRef<fir::ExtendedValue> args) {
3197 assert((args.size() == 1 && resultType.has_value()) ||
3198 (args.size() >= 1 && !resultType.has_value()));
3199 mlir::Value name = fir::getBase(args[0]);
3206 if (!isStaticallyAbsent(args[1])) {
3207 mlir::Value statusAddr = fir::getBase(args[1]);
3224 llvm::ArrayRef<mlir::Value> args) {
3225 assert(args.size() >= 1);
3228 mlir::Value real = builder.createConvert(loc, partType, args[0]);
3229 mlir::Value imag = isStaticallyAbsent(args, 1)
3231 : builder.createConvert(loc, partType, args[1]);
3238 mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args) {
3239 assert(args.size() == 0);
3249 llvm::ArrayRef<mlir::Value> args) {
3250 assert(args.size() == 1);
3251 if (resultType != args[0].getType())
3254 mlir::Value cplx = args[0];
3264 llvm::ArrayRef<mlir::Value> args) {
3265 assert(args.size() == 1);
3268 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
3272 mlir::Value factor = builder.createConvert(loc, args[0].getType(), dfactor);
3273 mlir::Value arg = builder.create<mlir::arith::MulFOp>(loc, args[0], factor);
3280 llvm::ArrayRef<fir::ExtendedValue> args) {
3281 assert(args.size() == 3);
3284 fir::BoxValue mask = builder.createBox(loc, args[0]);
3290 bool absentDim = isStaticallyAbsent(args[1]);
3293 : fir::getBase(args[1]);
3306 bool absentKind = isStaticallyAbsent(args[2]);
3310 : fir::getBase(args[2]);
3327 void IntrinsicLibrary::genCpuTime(llvm::ArrayRef<fir::ExtendedValue> args) {
3328 assert(args.size() == 1);
3329 const mlir::Value *arg = args[0].getUnboxed();
3340 llvm::ArrayRef<fir::ExtendedValue> args) {
3341 assert(args.size() == 3);
3344 fir::BoxValue arrayBox = builder.createBox(loc, args[0]);
3359 const mlir::Value *shiftAddr = args[1].getUnboxed();
3367 mlir::Value shift = builder.createBox(loc, args[1]);
3371 isStaticallyAbsent(args[2])
3373 : fir::getBase(args[2]);
3380 void IntrinsicLibrary::genDateAndTime(llvm::ArrayRef<fir::ExtendedValue> args) {
3381 assert(args.size() == 4 && "date_and_time has 4 args");
3384 if (const fir::CharBoxValue *charBox = args[i].getCharBox())
3387 mlir::Value values = fir::getBase(args[3]);
3398 llvm::ArrayRef<mlir::Value> args) {
3399 assert(args.size() == 2);
3402 auto diff = builder.create<mlir::arith::SubIOp>(loc, args[0], args[1]);
3409 auto diff = builder.create<mlir::arith::SubFOp>(loc, args[0], args[1]);
3418 llvm::ArrayRef<fir::ExtendedValue> args) {
3419 assert(args.size() == 2);
3422 mlir::Value vectorA = fir::getBase(args[0]);
3423 mlir::Value vectorB = fir::getBase(args[1]);
3441 llvm::ArrayRef<mlir::Value> args) {
3442 assert(args.size() == 2);
3445 mlir::Value a = builder.createConvert(loc, resultType, args[0]);
3446 mlir::Value b = builder.createConvert(loc, resultType, args[1]);
3452 llvm::ArrayRef<mlir::Value> args) {
3453 assert(args.size() == 3);
3455 mlir::Value i = args[0];
3456 mlir::Value j = args[1];
3465 mlir::Value shift = builder.createConvert(loc, signlessType, args[2]);
3485 llvm::ArrayRef<mlir::Value> args) {
3486 assert(args.size() == 3);
3488 mlir::Value i = args[0];
3489 mlir::Value j = args[1];
3498 mlir::Value shift = builder.createConvert(loc, signlessType, args[2]);
3519 llvm::ArrayRef<fir::ExtendedValue> args) {
3520 assert(args.size() == 4);
3523 fir::BoxValue arrayBox = builder.createBox(loc, args[0]);
3537 isStaticallyAbsent(args[2])
3540 : builder.createBox(loc, args[2]);
3545 const mlir::Value *shiftAddr = args[1].getUnboxed();
3553 mlir::Value shift = builder.createBox(loc, args[1]);
3557 isStaticallyAbsent(args[3])
3559 : fir::getBase(args[3]);
3568 llvm::ArrayRef<fir::ExtendedValue> args) {
3569 assert(args.size() == 5);
3571 mlir::Value command = fir::getBase(args[0]);
3573 const fir::ExtendedValue &wait = args[1];
3574 const fir::ExtendedValue &exitstat = args[2];
3575 const fir::ExtendedValue &cmdstat = args[3];
3576 const fir::ExtendedValue &cmdmsg = args[4];
3626 llvm::ArrayRef<fir::ExtendedValue> args) {
3627 assert((args.size() == 2 && !resultType.has_value()) ||
3628 (args.size() == 1 && resultType.has_value()));
3630 mlir::Value values = fir::getBase(args[0]);
3642 mlir::Value time = fir::getBase(args[1]);
3655 void IntrinsicLibrary::genExit(llvm::ArrayRef<fir::ExtendedValue> args) {
3656 assert(args.size() == 1);
3659 isStaticallyAbsent(args[0])
3662 : fir::getBase(args[0]);
3672 llvm::ArrayRef<mlir::Value> args) {
3673 assert(args.size() == 1);
3678 fir::getBase(args[0])));
3684 llvm::ArrayRef<fir::ExtendedValue> args) {
3685 assert(args.size() == 2);
3689 fir::runtime::genExtendsTypeOf(builder, loc, fir::getBase(args[0]),
3690 fir::getBase(args[1])));
3696 llvm::ArrayRef<fir::ExtendedValue> args) {
3697 assert(args.size() == 6);
3700 mlir::Value array = builder.createBox(loc, args[0]);
3705 mlir::Value val = builder.createBox(loc, args[1]);
3708 bool absentDim = isStaticallyAbsent(args[2]);
3711 auto mask = isStaticallyAbsent(args[3])
3714 : builder.createBox(loc, args[3]);
3717 auto kind = isStaticallyAbsent(args[4])
3721 : fir::getBase(args[4]);
3724 auto back = isStaticallyAbsent(args[5]) ? builder.createBool(loc, false)
3725 : fir::getBase(args[5]);
3736 mlir::Value dim = fir::getBase(args[2]);
3757 mlir::Value dim = fir::getBase(args[2]);
3766 llvm::ArrayRef<mlir::Value> args) {
3768 assert(args.size() >= 1);
3769 mlir::Value arg = args[0];
3777 llvm::ArrayRef<mlir::Value> args) {
3778 assert(args.size() == 1);
3782 fir::runtime::genFraction(builder, loc, fir::getBase(args[0])));
3785 void IntrinsicLibrary::genFree(llvm::ArrayRef<fir::ExtendedValue> args) {
3786 assert(args.size() == 1);
3788 fir::runtime::genFree(builder, loc, fir::getBase(args[0]));
3794 llvm::ArrayRef<fir::ExtendedValue> args) {
3795 assert((args.size() == 1 && resultType.has_value()) ||
3796 (args.size() >= 1 && !resultType.has_value()));
3798 mlir::Value cwd = fir::getBase(args[0]);
3806 const fir::ExtendedValue &status = args[1];
3823 void IntrinsicLibrary::genGetCommand(llvm::ArrayRef<fir::ExtendedValue> args) {
3824 assert(args.size() == 4);
3825 const fir::ExtendedValue &command = args[0];
3826 const fir::ExtendedValue &length = args[1];
3827 const fir::ExtendedValue &status = args[2];
3828 const fir::ExtendedValue &errmsg = args[3];
3862 llvm::ArrayRef<mlir::Value> args) {
3863 assert(args.size() == 0 && "getgid takes no input");
3870 llvm::ArrayRef<mlir::Value> args) {
3871 assert(args.size() == 0 && "getpid takes no input");
3878 llvm::ArrayRef<mlir::Value> args) {
3879 assert(args.size() == 0 && "getgid takes no input");
3886 llvm::ArrayRef<fir::ExtendedValue> args) {
3887 assert(args.size() == 5);
3888 mlir::Value number = fir::getBase(args[0]);
3889 const fir::ExtendedValue &value = args[1];
3890 const fir::ExtendedValue &length = args[2];
3891 const fir::ExtendedValue &status = args[3];
3892 const fir::ExtendedValue &errmsg = args[4];
3929 llvm::ArrayRef<fir::ExtendedValue> args) {
3930 assert(args.size() == 6);
3931 mlir::Value name = fir::getBase(args[0]);
3932 const fir::ExtendedValue &value = args[1];
3933 const fir::ExtendedValue &length = args[2];
3934 const fir::ExtendedValue &status = args[3];
3935 const fir::ExtendedValue &trimName = args[4];
3936 const fir::ExtendedValue &errmsg = args[5];
4024 llvm::ArrayRef<fir::ExtendedValue> args) {
4026 assert(args.size() == 3);
4029 fir::BoxValue arryTmp = builder.createBox(loc, args[0]);
4035 auto mask = isStaticallyAbsent(args[2])
4038 : builder.createBox(loc, args[2]);
4040 bool absentDim = isStaticallyAbsent(args[1]);
4059 genFuncDim(funcDim, resultType, builder, loc, array, args[1], mask, rank);
4066 llvm::ArrayRef<fir::ExtendedValue> args) {
4068 resultType, args);
4073 llvm::ArrayRef<mlir::Value> args) {
4074 assert(args.size() == 2);
4075 return builder.createUnsigned<mlir::arith::AndIOp>(loc, resultType, args[0],
4076 args[1]);
4082 llvm::ArrayRef<fir::ExtendedValue> args) {
4084 resultType, args);
4089 llvm::ArrayRef<mlir::Value> args) {
4094 assert(args.size() == 2);
4100 mlir::Value pos = builder.createConvert(loc, signlessType, args[1]);
4103 return builder.createUnsigned<mlir::arith::AndIOp>(loc, resultType, args[0],
4109 llvm::ArrayRef<mlir::Value> args) {
4118 assert(args.size() == 3);
4122 mlir::Value word = args[0];
4125 mlir::Value pos = builder.createConvert(loc, signlessType, args[1]);
4126 mlir::Value len = builder.createConvert(loc, signlessType, args[2]);
4149 llvm::ArrayRef<mlir::Value> args) {
4154 assert(args.size() == 2);
4159 mlir::Value pos = builder.createConvert(loc, signlessType, args[1]);
4161 return builder.createUnsigned<mlir::arith::OrIOp>(loc, resultType, args[0],
4168 llvm::ArrayRef<fir::ExtendedValue> args) {
4170 assert(args.size() == 2);
4171 const fir::CharBoxValue *charBox = args[0].getCharBox();
4225 llvm::ArrayRef<mlir::Value> args,
4227 assert(args.size() == 1);
4230 builder.create<mlir::LLVM::IsFPClass>(loc, i1Ty, args[0], fpclass);
4279 llvm::ArrayRef<mlir::Value> args) {
4280 assert(args.size() == 2);
4281 auto [leftRef, fieldTy] = getFieldRef(builder, loc, args[0]);
4282 auto [rightRef, ignore] = getFieldRef(builder, loc, args[1]);
4290 llvm::ArrayRef<mlir::Value> args) {
4310 assert(args.size() == 1);
4311 mlir::Value realVal = args[0];
4555 llvm::ArrayRef<mlir::Value> args) {
4557 assert(args.size() == 2);
4558 mlir::Value xRealVal = args[0];
4559 mlir::Value yRealVal = args[1];
4606 void IntrinsicLibrary::genIeeeGetFlag(llvm::ArrayRef<fir::ExtendedValue> args) {
4607 assert(args.size() == 2);
4609 mlir::Value flag = fir::getBase(args[0]);
4610 mlir::Value flagValue = fir::getBase(args[1]);
4630 llvm::ArrayRef<fir::ExtendedValue> args) {
4632 assert(args.size() == 2);
4633 mlir::Value flag = fir::getBase(args[0]);
4634 mlir::Value halting = fir::getBase(args[1]);
4658 llvm::ArrayRef<fir::ExtendedValue> args) {
4659 assert(args.size() == 1);
4675 getFieldRef(builder, loc, fir::getBase(args[0]), 1);
4703 addr = builder.create<fir::ConvertOp>(loc, ptrTy, getBase(args[0]));
4727 llvm::ArrayRef<fir::ExtendedValue> args) {
4731 assert(args.size() == 1 || args.size() == 2);
4732 if (args.size() == 2)
4733 checkRadix(builder, loc, fir::getBase(args[1]), "ieee_get_rounding_mode");
4734 auto [fieldRef, fieldTy] = getFieldRef(builder, loc, fir::getBase(args[0]));
4743 llvm::ArrayRef<fir::ExtendedValue> args) {
4744 assert(args.size() == 1);
4746 builder.createStoreWithConvert(loc, flag, fir::getBase(args[0]));
4751 llvm::ArrayRef<mlir::Value> args) {
4759 assert(args.size() == 3);
4760 mlir::FloatType realType = mlir::cast<mlir::FloatType>(args[0].getType());
4761 mlir::Value realResult = genIeeeRint(realType, {args[0], args[1]});
4790 loc, mlir::arith::CmpFPredicate::ONE, args[0], realResult);
4808 llvm::ArrayRef<mlir::Value> args) {
4810 assert(args.size() == 1);
4811 return genIsFPClass(resultType, args, finiteTest);
4816 llvm::ArrayRef<mlir::Value> args) {
4818 assert(args.size() == 1);
4819 return genIsFPClass(resultType, args, nanTest);
4825 llvm::ArrayRef<mlir::Value> args) {
4827 assert(args.size() == 1);
4828 return genIsFPClass(resultType, args, negativeTest);
4834 llvm::ArrayRef<mlir::Value> args) {
4836 assert(args.size() == 1);
4837 return genIsFPClass(resultType, args, normalTest);
4842 llvm::ArrayRef<mlir::Value> args) {
4849 assert(args.size() == 1);
4850 mlir::Value realVal = args[0];
4923 mlir::Value isFinite = genIsFPClass(i1Ty, args, finiteTest);
4928 mlir::Value isNormal = genIsFPClass(i1Ty, args, normalTest);
4976 llvm::ArrayRef<mlir::Value> args) {
4995 assert(args.size() == 2);
4996 mlir::Value x = args[0];
4997 mlir::Value y = args[1];
5053 loc, genIsFPClass(builder.getI1Type(), args[0], snanTest),
5054 genIsFPClass(builder.getI1Type(), args[1], snanTest));
5072 llvm::ArrayRef<mlir::Value> args) {
5074 assert(args.size() == 2);
5076 loc, genIsFPClass(builder.getI1Type(), args[0], snanTest),
5077 genIsFPClass(builder.getI1Type(), args[1], snanTest));
5079 builder.create<mlir::arith::CmpFOp>(loc, pred, args[0], args[1]);
5086 llvm::ArrayRef<mlir::Value> args) {
5124 assert(args.size() == 2);
5127 mlir::Value a = args[0];
5318 llvm::ArrayRef<mlir::Value> args) {
5322 assert(args.size() == 2);
5323 mlir::Value x = args[0];
5324 mlir::Value y = args[1];
5344 llvm::ArrayRef<mlir::Value> args) {
5349 assert(args.size() == 2);
5350 mlir::Value a = args[0];
5354 if (isStaticallyPresent(args[1])) {
5356 genIeeeSetRoundingMode({args[1]});
5363 if (isStaticallyPresent(args[1])) {
5367 loc, mlir::arith::CmpFPredicate::ONE, args[0], result);
5376 llvm::ArrayRef<fir::ExtendedValue> args) {
5379 assert(args.size() == 2);
5382 auto [fieldRef, ignore] = getFieldRef(builder, loc, getBase(args[0]));
5387 loc, builder.create<fir::ConvertOp>(loc, i1Ty, getBase(args[1])),
5398 llvm::ArrayRef<fir::ExtendedValue> args) {
5402 assert(args.size() == 1 || args.size() == 2);
5403 if (args.size() == 2)
5404 checkRadix(builder, loc, fir::getBase(args[1]), "ieee_set_rounding_mode");
5405 auto [fieldRef, ignore] = getFieldRef(builder, loc, fir::getBase(args[0]));
5415 llvm::ArrayRef<fir::ExtendedValue> args) {
5416 assert(args.size() == 1);
5418 getBase(args[0]));
5427 llvm::ArrayRef<mlir::Value> args) {
5429 assert(args.size() == 2);
5430 mlir::Value hasNaNOp = genIeeeUnordered(mlir::Type{}, args);
5432 builder.create<mlir::arith::CmpFOp>(loc, pred, args[0], args[1]);
5439 llvm::ArrayRef<mlir::Value> args) {
5441 assert(args.size() == 1);
5442 mlir::Value realVal = args[0];
5462 llvm::ArrayRef<fir::ExtendedValue> args) {
5467 assert(args.size() == 1 || args.size() == 2);
5468 auto [fieldRef, fieldTy] = getFieldRef(builder, loc, fir::getBase(args[0]));
5485 mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args) {
5489 assert(args.size() == 1);
5491 auto [fieldRef, ignore] = getFieldRef(builder, loc, getBase(args[0]));
5502 llvm::ArrayRef<mlir::Value> args) {
5512 assert(args.size() == 1 || args.size() == 2);
5513 auto [fieldRef, fieldTy] = getFieldRef(builder, loc, args[0]);
5529 llvm::ArrayRef<mlir::Value> args) {
5530 // Check if REAL args X or Y or both are (signaling or quiet) NaNs.
5532 assert(args.size() == 2);
5533 if (args[0].getType() == args[1].getType()) {
5535 loc, mlir::arith::CmpFPredicate::UNO, args[0], args[1]);
5540 mlir::Value xIsNan = genIsFPClass(i1Ty, args[0], nanTest);
5541 mlir::Value yIsNan = genIsFPClass(i1Ty, args[1], nanTest);
5548 llvm::ArrayRef<mlir::Value> args) {
5555 assert(args.size() == 1 || args.size() == 2);
5665 if (args.size() == 2) { // user call
5666 auto [index, ignore] = getFieldRef(builder, loc, args[1]);
5669 which = args[0];
5687 llvm::ArrayRef<mlir::Value> args) {
5688 assert(args.size() == 2);
5689 return builder.createUnsigned<mlir::arith::XOrIOp>(loc, resultType, args[0],
5690 args[1]);
5696 llvm::ArrayRef<fir::ExtendedValue> args) {
5697 assert(args.size() >= 2 && args.size() <= 4);
5699 mlir::Value stringBase = fir::getBase(args[0]);
5703 mlir::Value stringLen = fir::getLen(args[0]);
5704 mlir::Value substringBase = fir::getBase(args[1]);
5705 mlir::Value substringLen = fir::getLen(args[1]);
5707 isStaticallyAbsent(args, 2)
5709 : fir::getBase(args[2]);
5710 if (isStaticallyAbsent(args, 3))
5717 mlir::Value string = builder.createBox(loc, args[0]);
5718 mlir::Value substring = builder.createBox(loc, args[1]);
5727 mlir::Value backOpt = isStaticallyAbsent(args, 2)
5730 : makeRefThenEmbox(fir::getBase(args[2]));
5731 mlir::Value kindVal = isStaticallyAbsent(args, 3)
5735 : fir::getBase(args[3]);
5749 llvm::ArrayRef<mlir::Value> args) {
5750 assert(args.size() == 2);
5751 return builder.createUnsigned<mlir::arith::OrIOp>(loc, resultType, args[0],
5752 args[1]);
5758 llvm::ArrayRef<fir::ExtendedValue> args) {
5760 "IPARITY", resultType, args);
5766 llvm::ArrayRef<fir::ExtendedValue> args) {
5767 assert(args.size() == 1);
5770 fir::runtime::genIsContiguous(builder, loc, fir::getBase(args[0])));
5777 llvm::ArrayRef<mlir::Value> args) {
5778 assert(args.size() == 1);
5780 loc, mlir::arith::CmpIPredicate::eq, args[0],
5781 builder.createIntegerConstant(loc, args[0].getType(), value));
5786 llvm::ArrayRef<mlir::Value> args) {
5794 assert(args.size() == 2);
5802 mlir::Value shift = builder.createConvert(loc, signlessType, args[1]);
5804 mlir::Value word = args[0];
5824 llvm::ArrayRef<mlir::Value> args) {
5841 assert(args.size() == 3);
5848 mlir::Value word = args[0];
5851 mlir::Value shift = builder.createConvert(loc, signlessType, args[1]);
5853 args[2] ? builder.createConvert(loc, signlessType, args[2]) : bitSize;
5900 llvm::ArrayRef<mlir::Value> args) {
5901 assert(args.size() == 1);
5904 builder.create<mlir::math::CountLeadingZerosOp>(loc, args);
5914 llvm::ArrayRef<fir::ExtendedValue> args) {
5916 assert(args.size() == 1 || args.size() == 2);
5917 mlir::Value len = fir::factory::readCharLen(builder, loc, args[0]);
5924 llvm::ArrayRef<fir::ExtendedValue> args) {
5926 assert(args.size() == 1 || args.size() == 2);
5927 const fir::CharBoxValue *charBox = args[0].getCharBox();
5939 llvm::ArrayRef<fir::ExtendedValue> args) {
5940 assert(args.size() == 2);
5942 builder, loc, pred, fir::getBase(args[0]), fir::getLen(args[0]),
5943 fir::getBase(args[1]), fir::getLen(args[1]));
5955 llvm::ArrayRef<fir::ExtendedValue> args) {
5956 assert(args.size() == 1);
5957 mlir::Value box = fir::getBase(args[0]);
5962 mlir::Value argAddr = getAddrFromBox(builder, loc, args[0], isFunc);
5977 mlir::Value argAddr = getAddrFromBox(builder, loc, args[0], isFunc);
5989 llvm::ArrayRef<mlir::Value> args) {
5990 assert(args.size() == 1);
5992 fir::runtime::genMalloc(builder, loc, args[0]));
5998 llvm::ArrayRef<mlir::Value> args) {
5999 assert(args.size() == 2);
6008 mlir::Value bitsToSet = builder.createConvert(loc, signlessType, args[0]);
6030 llvm::ArrayRef<fir::ExtendedValue> args) {
6031 assert(args.size() == 2);
6034 fir::BoxValue matrixTmpA = builder.createBox(loc, args[0]);
6036 fir::BoxValue matrixTmpB = builder.createBox(loc, args[1]);
6057 llvm::ArrayRef<fir::ExtendedValue> args) {
6058 assert(args.size() == 2);
6061 fir::BoxValue matrixTmpA = builder.createBox(loc, args[0]);
6063 fir::BoxValue matrixTmpB = builder.createBox(loc, args[1]);
6084 llvm::ArrayRef<fir::ExtendedValue> args) {
6085 assert(args.size() == 3);
6086 mlir::Value tsource = fir::getBase(args[0]);
6087 mlir::Value fsource = fir::getBase(args[1]);
6088 mlir::Value rawMask = fir::getBase(args[2]);
6126 const fir::CharBoxValue *charBox = args[0].getCharBox();
6135 llvm::ArrayRef<mlir::Value> args) {
6136 assert(args.size() == 3);
6144 loc, resultType, args[2], ones);
6146 loc, resultType, args[0], args[2]);
6148 loc, resultType, args[1], notMask);
6154 llvm::ArrayRef<mlir::Value> args) {
6155 assert(args.size() == 2);
6161 args[0], args[1]);
6164 return builder.create<mlir::arith::RemSIOp>(loc, args[0], args[1]);
6168 loc, resultType, fir::runtime::genMod(builder, loc, args[0], args[1]));
6173 llvm::ArrayRef<mlir::Value> args) {
6176 assert(args.size() == 2);
6190 args[0], args[1]);
6194 builder.create<mlir::arith::RemSIOp>(loc, args[0], args[1]);
6195 auto argXor = builder.create<mlir::arith::XOrIOp>(loc, args[0], args[1]);
6204 builder.create<mlir::arith::AddIOp>(loc, remainder, args[1]);
6217 fir::runtime::genModulo(builder, loc, args[0], args[1]));
6219 auto remainder = builder.create<mlir::arith::RemFOp>(loc, args[0], args[1]);
6224 loc, mlir::arith::CmpFPredicate::OLT, args[0], zero);
6226 loc, mlir::arith::CmpFPredicate::OLT, args[1], zero);
6231 auto remPlusP = builder.create<mlir::arith::AddFOp>(loc, remainder, args[1]);
6236 void IntrinsicLibrary::genMoveAlloc(llvm::ArrayRef<fir::ExtendedValue> args) {
6237 assert(args.size() == 4);
6239 const fir::ExtendedValue &from = args[0];
6240 const fir::ExtendedValue &to = args[1];
6241 const fir::ExtendedValue &status = args[2];
6242 const fir::ExtendedValue &errMsg = args[3];
6277 void IntrinsicLibrary::genMvbits(llvm::ArrayRef<fir::ExtendedValue> args) {
6287 assert(args.size() == 5);
6293 mlir::Value from = unbox(args[0]);
6299 builder.createConvert(loc, signlessType, unbox(args[1]));
6300 mlir::Value len = builder.createConvert(loc, signlessType, unbox(args[2]));
6301 mlir::Value toAddr = unbox(args[3]);
6306 mlir::Value topos = builder.createConvert(loc, signlessType, unbox(args[4]));
6337 llvm::ArrayRef<mlir::Value> args) {
6364 assert(args.size() == 1 || args.size() == 2);
6365 mlir::Value x = args[0];
6372 loc, genIsFPClass(i1Ty, args[1], nanTest), genQNan(xType), x);
6382 builder.create<fir::IfOp>(loc, genIsFPClass(i1Ty, args[1], zeroTest),
6388 mlir::Value sSign = IntrinsicLibrary::genIeeeSignbit(intType, {args[1]});
6397 mlir::Value y = args[1];
6398 mlir::FloatType yType = mlir::dyn_cast<mlir::FloatType>(args[1].getType());
6424 IntrinsicLibrary::genIeeeSignbit(i1Ty, {args[0]}));
6518 llvm::ArrayRef<mlir::Value> args) {
6519 assert(args.size() >= 1);
6522 return genRuntimeCall("nint", resultType, {args[0]});
6528 llvm::ArrayRef<fir::ExtendedValue> args) {
6529 assert(args.size() == 2);
6532 mlir::Value array = builder.createBox(loc, args[0]);
6537 bool absentDim = isStaticallyAbsent(args[1]);
6552 mlir::Value dim = fir::getBase(args[1]);
6561 llvm::ArrayRef<mlir::Value> args) {
6562 assert(args.size() == 1);
6567 return builder.createUnsigned<mlir::arith::XOrIOp>(loc, resultType, args[0],
6573 IntrinsicLibrary::genNull(mlir::Type, llvm::ArrayRef<fir::ExtendedValue> args) {
6576 assert(args.size() == 1 && isStaticallyPresent(args[0]) &&
6578 mlir::Type ptrTy = fir::getBase(args[0]).getType();
6587 const auto *mold = args[0].getBoxOf<fir::MutableBoxValue>();
6600 llvm::ArrayRef<fir::ExtendedValue> args) {
6601 [[maybe_unused]] auto numArgs = args.size();
6605 mlir::Value array = builder.createBox(loc, args[0]);
6608 mlir::Value mask = builder.createBox(loc, args[1]);
6611 mlir::Value vector = isStaticallyAbsent(args, 2)
6614 : builder.createBox(loc, args[2]);
6632 llvm::ArrayRef<fir::ExtendedValue> args) {
6634 assert(args.size() == 2);
6636 mlir::Value mask = builder.createBox(loc, args[0]);
6638 fir::BoxValue maskArry = builder.createBox(loc, args[0]);
6643 bool absentDim = isStaticallyAbsent(args[1]);
6646 : fir::getBase(args[1]);
6669 llvm::ArrayRef<mlir::Value> args) {
6670 assert(args.size() == 1);
6672 mlir::Value count = builder.create<mlir::math::CtPopOp>(loc, args);
6679 llvm::ArrayRef<mlir::Value> args) {
6680 assert(args.size() == 1);
6682 mlir::Value count = genPopcnt(resultType, args);
6691 llvm::ArrayRef<fir::ExtendedValue> args) {
6692 assert(args.size() == 1);
6694 fir::getBase(args[0]));
6700 llvm::ArrayRef<fir::ExtendedValue> args) {
6702 "PRODUCT", resultType, args);
6706 void IntrinsicLibrary::genRandomInit(llvm::ArrayRef<fir::ExtendedValue> args) {
6707 assert(args.size() == 2);
6708 fir::runtime::genRandomInit(builder, loc, fir::getBase(args[0]),
6709 fir::getBase(args[1]));
6714 llvm::ArrayRef<fir::ExtendedValue> args) {
6715 assert(args.size() == 1);
6716 fir::runtime::genRandomNumber(builder, loc, fir::getBase(args[0]));
6720 void IntrinsicLibrary::genRandomSeed(llvm::ArrayRef<fir::ExtendedValue> args) {
6721 assert(args.size() == 3);
6724 return isStaticallyPresent(args[i])
6725 ? fir::getBase(args[i])
6737 llvm::ArrayRef<fir::ExtendedValue> args) {
6738 assert(args.size() == 6);
6740 fir::BoxValue arrayTmp = builder.createBox(loc, args[0]);
6742 mlir::Value operation = fir::getBase(args[1]);
6767 bool absentDim = isStaticallyAbsent(args[2]);
6769 auto mask = isStaticallyAbsent(args[3])
6772 : builder.createBox(loc, args[3]);
6775 isStaticallyAbsent(args[4])
6777 : fir::getBase(args[4]);
6779 mlir::Value ordered = isStaticallyAbsent(args[5])
6781 : fir::getBase(args[5]);
6819 mlir::Value dim = fir::getBase(args[2]);
6828 mlir::ArrayRef<fir::ExtendedValue> args) {
6829 assert((args.size() == 3 && !resultType.has_value()) ||
6830 (args.size() == 2 && resultType.has_value()));
6832 mlir::Value path1 = fir::getBase(args[0]);
6833 mlir::Value path2 = fir::getBase(args[1]);
6846 auto status = args[2];
6859 llvm::ArrayRef<fir::ExtendedValue> args) {
6860 assert(args.size() == 2);
6861 mlir::Value string = builder.createBox(loc, args[0]);
6862 mlir::Value ncopies = fir::getBase(args[1]);
6878 llvm::ArrayRef<fir::ExtendedValue> args) {
6879 assert(args.size() == 4);
6882 mlir::Value source = builder.createBox(loc, args[0]);
6885 mlir::Value shape = builder.createBox(loc, args[1]);
6895 mlir::Value pad = isStaticallyAbsent(args[2])
6898 : builder.createBox(loc, args[2]);
6901 mlir::Value order = isStaticallyAbsent(args[3])
6904 : builder.createBox(loc, args[3]);
6923 llvm::ArrayRef<mlir::Value> args) {
6924 assert(args.size() == 1);
6928 fir::runtime::genRRSpacing(builder, loc, fir::getBase(args[0])));
6933 llvm::ArrayRef<mlir::Value> args) {
6934 assert(args.size() == 1);
6938 fir::runtime::genErfcScaled(builder, loc, fir::getBase(args[0])));
6944 llvm::ArrayRef<fir::ExtendedValue> args) {
6945 assert(args.size() == 2);
6949 fir::runtime::genSameTypeAs(builder, loc, fir::getBase(args[0]),
6950 fir::getBase(args[1])));
6955 llvm::ArrayRef<mlir::Value> args) {
6956 assert(args.size() == 2);
6958 mlir::Value realX = fir::getBase(args[0]);
6959 mlir::Value intI = fir::getBase(args[1]);
6968 llvm::ArrayRef<fir::ExtendedValue> args) {
6970 assert(args.size() == 4);
6972 if (isStaticallyAbsent(args[3])) {
6977 mlir::Value stringBase = fir::getBase(args[0]);
6980 mlir::Value setBase = fir::getBase(args[1]);
6988 mlir::Value stringLen = fir::getLen(args[0]);
6991 mlir::Value setLen = fir::getLen(args[1]);
6995 isStaticallyAbsent(args[2])
6997 : fir::getBase(args[2]);
7015 mlir::Value back = fir::isUnboxedValue(args[2])
7016 ? makeRefThenEmbox(*args[2].getUnboxed())
7021 mlir::Value string = builder.createBox(loc, args[0]);
7024 mlir::Value set = builder.createBox(loc, args[1]);
7027 mlir::Value kind = fir::getBase(args[3]);
7045 mlir::ArrayRef<fir::ExtendedValue> args) {
7046 assert((args.size() == 1 && !resultType) || (args.empty() && resultType));
7053 result = args[0];
7066 llvm::ArrayRef<fir::ExtendedValue> args) {
7067 assert(args.size() == 1);
7071 fir::runtime::genSelectedCharKind(builder, loc, fir::getBase(args[0]),
7072 fir::getLen(args[0])));
7078 llvm::ArrayRef<mlir::Value> args) {
7079 assert(args.size() == 1);
7083 fir::runtime::genSelectedIntKind(builder, loc, fir::getBase(args[0])));
7089 llvm::ArrayRef<mlir::Value> args) {
7090 assert(args.size() == 1);
7094 builder, loc, fir::getBase(args[0])));
7100 llvm::ArrayRef<mlir::Value> args) {
7101 assert(args.size() == 3);
7105 isStaticallyAbsent(args[0])
7108 : fir::getBase(args[0]);
7112 isStaticallyAbsent(args[1])
7115 : fir::getBase(args[1]);
7119 isStaticallyAbsent(args[2])
7122 : fir::getBase(args[2]);
7131 llvm::ArrayRef<mlir::Value> args) {
7132 assert(args.size() == 2);
7136 fir::runtime::genSetExponent(builder, loc, fir::getBase(args[0]),
7137 fir::getBase(args[1])));
7178 mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args,
7180 const fir::ExtendedValue &array = args[0];
7193 mlir::Value kind = isStaticallyAbsent(args, kindPos)
7197 : fir::getBase(args[kindPos]);
7219 llvm::ArrayRef<fir::ExtendedValue> args) {
7220 assert(args.size() >= 1);
7221 const fir::ExtendedValue &array = args[0];
7223 return genBoundInquiry(builder, loc, resultType, args,
7250 llvm::ArrayRef<mlir::Value> args) {
7251 assert(args.size() == 2);
7263 mlir::Value shift = builder.createConvert(loc, signlessType, args[1]);
7271 mlir::Value word = args[0];
7284 llvm::ArrayRef<mlir::Value> args) {
7290 mlir::Value shift = builder.createConvert(loc, signlessType, args[1]);
7301 mlir::Value word = args[0];
7318 llvm::ArrayRef<fir::ExtendedValue> args) {
7319 assert(args.size() == 2 || args.size() == 3);
7320 mlir::Value number = fir::getBase(args[0]);
7321 mlir::Value handler = fir::getBase(args[1]);
7323 if (args.size() == 3)
7324 status = fir::getBase(args[2]);
7330 llvm::ArrayRef<mlir::Value> args) {
7331 assert(args.size() == 2);
7333 mlir::Value abs = genAbs(resultType, {args[0]});
7337 loc, mlir::arith::CmpIPredicate::slt, args[1], zero);
7340 return genRuntimeCall("sign", resultType, args);
7345 llvm::ArrayRef<mlir::Value> args) {
7346 assert(args.size() == 1);
7349 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
7353 mlir::Value factor = builder.createConvert(loc, args[0].getType(), dfactor);
7354 mlir::Value arg = builder.create<mlir::arith::MulFOp>(loc, args[0], factor);
7361 llvm::ArrayRef<fir::ExtendedValue> args) {
7364 assert(args.size() == 3);
7367 mlir::Value array = builder.createBox(loc, args[0]);
7372 if (isStaticallyAbsent(args, 1))
7377 mlir::Value dim = fir::getBase(args[1]);
7378 if (!args[0].hasAssumedRank())
7413 llvm::ArrayRef<fir::ExtendedValue> args) {
7414 assert(args.size() == 1);
7415 mlir::Value box = fir::getBase(args[0]);
7417 if (!fir::isArray(args[0]))
7426 llvm::ArrayRef<mlir::Value> args) {
7427 assert(args.size() == 1);
7430 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
7434 mlir::Value factor = builder.createConvert(loc, args[0].getType(), dfactor);
7435 mlir::Value arg = builder.create<mlir::arith::MulFOp>(loc, args[0], factor);
7441 llvm::ArrayRef<mlir::Value> args) {
7442 assert(args.size() == 1);
7445 builder.create<mlir::math::CountTrailingZerosOp>(loc, args);
7482 llvm::ArrayRef<fir::ExtendedValue> args) {
7483 assert(args.size() == 2 || args.size() == 3);
7484 const fir::ExtendedValue &array = args[0];
7487 const bool dimIsAbsent = args.size() == 2 || isStaticallyAbsent(args, 1);
7489 int kindPos = args.size() == 2 ? 1 : 2;
7490 return genBoundInquiry(builder, loc, resultType, args, kindPos,
7521 mlir::Value dim = fir::getBase(args[1]);
7543 llvm::ArrayRef<fir::ExtendedValue> args) {
7544 assert(args.size() == 3 || args.size() == 2);
7545 const bool dimIsAbsent = args.size() == 2 || isStaticallyAbsent(args, 1);
7548 mlir::Value extent = fir::getBase(genSize(resultType, args));
7549 mlir::Value lbound = fir::getBase(genLbound(resultType, args));
7556 int kindPos = args.size() == 2 ? 1 : 2;
7557 return genBoundInquiry(builder, loc, resultType, args, kindPos,
7564 llvm::ArrayRef<mlir::Value> args) {
7565 assert(args.size() == 1);
7569 fir::runtime::genSpacing(builder, loc, fir::getBase(args[0])));
7575 llvm::ArrayRef<fir::ExtendedValue> args) {
7577 assert(args.size() == 3);
7580 mlir::Value source = builder.createBox(loc, args[0]);
7585 mlir::Value dim = fir::getBase(args[1]);
7588 mlir::Value ncopies = fir::getBase(args[2]);
7607 llvm::ArrayRef<fir::ExtendedValue> args) {
7608 assert(args.size() == 2 || args.size() == 1);
7609 mlir::Value box = fir::getBase(args[0]);
7623 const fir::MutableBoxValue *mutBox = args[0].getBoxOf<fir::MutableBoxValue>();
7635 bool absentKind = isStaticallyAbsent(args, 1);
7637 mlir::Operation *defKind = fir::getBase(args[1]).getDefiningOp();
7645 box = builder.createBox(loc, args[0],
7646 /*isPolymorphic=*/args[0].isPolymorphic());
7655 llvm::ArrayRef<fir::ExtendedValue> args) {
7657 resultType, args);
7661 void IntrinsicLibrary::genSyncThreads(llvm::ArrayRef<fir::ExtendedValue> args) {
7673 llvm::ArrayRef<mlir::Value> args) {
7677 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
7679 return builder.create<fir::CallOp>(loc, funcOp, args).getResult(0);
7685 llvm::ArrayRef<mlir::Value> args) {
7689 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
7691 return builder.create<fir::CallOp>(loc, funcOp, args).getResult(0);
7697 llvm::ArrayRef<mlir::Value> args) {
7701 mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
7703 return builder.create<fir::CallOp>(loc, funcOp, args).getResult(0);
7709 llvm::ArrayRef<fir::ExtendedValue> args) {
7710 assert((!resultType && (args.size() == 2)) ||
7711 (resultType && (args.size() == 1)));
7712 mlir::Value command = fir::getBase(args[0]);
7720 exitstat = args[1];
7753 void IntrinsicLibrary::genSystemClock(llvm::ArrayRef<fir::ExtendedValue> args) {
7754 assert(args.size() == 3);
7755 fir::runtime::genSystemClock(builder, loc, fir::getBase(args[0]),
7756 fir::getBase(args[1]), fir::getBase(args[2]));
7760 void IntrinsicLibrary::genSleep(llvm::ArrayRef<fir::ExtendedValue> args) {
7761 assert(args.size() == 1 && "SLEEP has one compulsory argument");
7762 fir::runtime::genSleep(builder, loc, fir::getBase(args[0]));
7768 llvm::ArrayRef<fir::ExtendedValue> args) {
7770 assert(args.size() >= 2); // args.size() == 2 when size argument is omitted.
7773 mlir::Value source = builder.createBox(loc, args[0]);
7776 mlir::Value mold = builder.createBox(loc, args[1]);
7780 bool absentSize = (args.size() == 2);
7804 mlir::Value sizeArg = fir::getBase(args[2]);
7815 llvm::ArrayRef<fir::ExtendedValue> args) {
7817 assert(args.size() == 1);
7820 mlir::Value source = builder.createBox(loc, args[0]);
7837 void IntrinsicLibrary::genThreadFence(llvm::ArrayRef<fir::ExtendedValue> args) {
7848 llvm::ArrayRef<fir::ExtendedValue> args) {
7859 llvm::ArrayRef<fir::ExtendedValue> args) {
7871 llvm::ArrayRef<fir::ExtendedValue> args) {
7872 assert(args.size() == 1);
7873 mlir::Value string = builder.createBox(loc, args[0]);
7960 llvm::ArrayRef<fir::ExtendedValue> args) {
7961 assert(args.size() == 3);
7964 mlir::Value vector = builder.createBox(loc, args[0]);
7967 fir::BoxValue maskBox = builder.createBox(loc, args[1]);
7972 mlir::Value field = builder.createBox(loc, args[2]);
7990 llvm::ArrayRef<fir::ExtendedValue> args) {
7992 assert(args.size() == 4);
7994 if (isStaticallyAbsent(args[3])) {
7999 mlir::Value stringBase = fir::getBase(args[0]);
8002 mlir::Value setBase = fir::getBase(args[1]);
8010 mlir::Value stringLen = fir::getLen(args[0]);
8013 mlir::Value setLen = fir::getLen(args[1]);
8017 isStaticallyAbsent(args[2])
8019 : fir::getBase(args[2]);
8037 mlir::Value back = fir::isUnboxedValue(args[2])
8038 ? makeRefThenEmbox(*args[2].getUnboxed())
8043 mlir::Value string = builder.createBox(loc, args[0]);
8046 mlir::Value set = builder.createBox(loc, args[1]);
8049 mlir::Value kind = fir::getBase(args[3]);
8069 llvm::ArrayRef<fir::ExtendedValue> args) {
8071 assert(args.size() == 5);
8074 mlir::Value array = builder.createBox(loc, args[0]);
8079 auto mask = isStaticallyAbsent(args[2])
8082 : builder.createBox(loc, args[2]);
8085 auto kind = isStaticallyAbsent(args[3])
8089 : fir::getBase(args[3]);
8092 auto back = isStaticallyAbsent(args[4]) ? builder.createBool(loc, false)
8093 : fir::getBase(args[4]);
8095 bool absentDim = isStaticallyAbsent(args[1]);
8101 mlir::Value dim = fir::getBase(args[1]);
8131 mlir::Value dim = fir::getBase(args[1]);
8140 llvm::ArrayRef<fir::ExtendedValue> args) {
8142 "MAXLOC", resultType, args);
8150 llvm::ArrayRef<fir::ExtendedValue> args) {
8152 assert(args.size() == 3);
8155 fir::BoxValue arryTmp = builder.createBox(loc, args[0]);
8162 auto mask = isStaticallyAbsent(args[2])
8165 : builder.createBox(loc, args[2]);
8167 bool absentDim = isStaticallyAbsent(args[1]);
8189 genFuncDim(funcDim, resultType, builder, loc, array, args[1], mask, rank);
8196 llvm::ArrayRef<fir::ExtendedValue> args) {
8199 args);
8205 llvm::ArrayRef<fir::ExtendedValue> args) {
8207 "MINLOC", resultType, args);
8213 llvm::ArrayRef<fir::ExtendedValue> args) {
8216 args);
8222 llvm::ArrayRef<mlir::Value> args) {
8223 assert(args.size() >= 1);
8224 mlir::Value result = args[0];
8225 for (auto arg : args.drop_front()) {
8266 assert(position < sizeof(rules.args) / (sizeof(decltype(*rules.args))) &&
8268 return {rules.args[position].lowerAs,
8269 rules.args[position].handleDynamicOptional};
8279 llvm::ArrayRef<fir::ExtendedValue> args,
8282 name, resultType, args);
8286 llvm::ArrayRef<mlir::Value> args) {
8287 assert(args.size() > 0 && "max requires at least one argument");
8289 .genExtremum<Extremum::Max, ExtremumBehavior::MinMaxss>(args[0].getType(),
8290 args);
8294 llvm::ArrayRef<mlir::Value> args) {
8295 assert(args.size() > 0 && "min requires at least one argument");
8297 .genExtremum<Extremum::Min, ExtremumBehavior::MinMaxss>(args[0].getType(),
8298 args);