Lines Matching +defs:mode +defs:name
67 /// If no generator is given for an intrinsic name, a math runtime library
210 {{{"name", asAddr}, {"status", asAddr, handleDynamicOptional}}},
304 {{{"name", asBox},
619 {{{"name", asAddr}}},
731 isSorted &= std::string_view{lastSeen->name} < std::string_view{x.name};
738 static const IntrinsicHandler *findIntrinsicHandler(llvm::StringRef name) {
739 auto compare = [](const IntrinsicHandler &handler, llvm::StringRef name) {
740 return name.compare(handler.name) > 0;
742 auto result = llvm::lower_bound(handlers, name, compare);
743 return result != std::end(handlers) && result->name == name ? result
776 /// Return a string containing the given Fortran intrinsic name
781 llvm::StringRef prefix, llvm::StringRef name,
785 if (name == "pow") {
794 sstream << name.upper() << "(";
797 name);
800 << mlirTypeToIntrinsicFortran(builder, argType, loc, name);
850 // was just created from user functions with the same name.
855 // FP mode. Set appropriate Fast-Math Flags otherwise.
857 // with 'pure' attribute (of course, not in strict FP mode).
862 // The function with the same name already exists.
869 // A function with the same name might have been declared
937 // * For "relaxed" FP mode set all Fast-Math Flags
940 // * For "fast" FP mode set all Fast-Math Flags except 'afn'.
941 // * For "precise/strict" FP mode generate fir.calls to libm
944 // Elsewhere, "precise/strict" FP mode should also set
1568 /// operation defined by \p name with its result' and operands' types
1600 /// Implementation of the operation defined by \p name with type
1605 static void checkPrecisionLoss(llvm::StringRef name,
1620 name, "'", funcType);
1702 static bool isIntrinsicModuleProcedure(llvm::StringRef name) {
1703 return name.starts_with("c_") || name.starts_with("compiler_") ||
1704 name.starts_with("ieee_") || name.starts_with("__ppc_");
1707 static bool isCoarrayIntrinsic(llvm::StringRef name) {
1708 return name.starts_with("atomic_") || name.starts_with("co_") ||
1709 name.contains("image") || name.ends_with("cobound") ||
1710 name == "team_number";
1713 /// Return the generic name of an intrinsic module procedure specific name.
1718 llvm::StringRef name = specificName.starts_with(builtin)
1721 size_t size = name.size();
1722 if (isIntrinsicModuleProcedure(name))
1723 while (isdigit(name[size - 1]))
1724 while (name[--size] != '_')
1726 return name.drop_back(name.size() - size);
1730 lookupRuntimeGenerator(llvm::StringRef name, bool isPPCTarget) {
1731 if (auto range = mathOps.equal_range(name); range.first != range.second)
1736 if (auto range = checkPPCMathOperationsRange(name);
1747 llvm::StringRef name = genericName(intrinsicName);
1748 if (const IntrinsicHandler *handler = findIntrinsicHandler(name))
1753 if (const IntrinsicHandler *ppcHandler = findPPCIntrinsicHandler(name))
1760 if (auto runtimeGeneratorRange = lookupRuntimeGenerator(name, isPPCTarget))
1768 llvm::StringRef name = genericName(intrinsicName);
1769 if (isIntrinsicModuleProcedure(name))
1770 TODO(loc, "intrinsic module procedure: " + llvm::Twine(name));
1771 else if (isCoarrayIntrinsic(name))
1772 TODO(loc, "coarray: intrinsic " + llvm::Twine(name));
1774 TODO(loc, "intrinsic: " + llvm::Twine(name.upper()));
1779 GeneratorType generator, llvm::StringRef name, mlir::Type resultType,
1788 return outlineInWrapper(generator, name, resultType, scalarArgs);
1795 ExtendedGenerator generator, llvm::StringRef name, mlir::Type resultType,
1804 return outlineInExtendedWrapper(generator, name, resultType, args);
1811 SubroutineGenerator generator, llvm::StringRef name, mlir::Type resultType,
1816 crashOnMissingIntrinsic(loc, name);
1818 return outlineInExtendedWrapper(generator, name, resultType, args);
1826 DualGenerator generator, llvm::StringRef name, mlir::Type resultType,
1833 crashOnMissingIntrinsic(loc, name);
1835 return outlineInExtendedWrapper(generator, name, resultType, args);
1848 return lib.genElementalCall(generator, handler.name, *resultType, args,
1860 return lib.genElementalCall(generator, handler.name, *resultType, args,
1863 return lib.outlineInExtendedWrapper(generator, handler.name, *resultType,
1875 return lib.genElementalCall(generator, handler.name, mlir::Type{}, args,
1878 return lib.outlineInExtendedWrapper(generator, handler.name, resultType,
1891 return lib.genElementalCall(generator, handler.name, mlir::Type{}, args,
1894 return lib.outlineInExtendedWrapper(generator, handler.name, resultType,
1926 llvm::StringRef name = range.first->key;
1934 crashOnMissingIntrinsic(loc, name);
1942 return {lib.genElementalCall(runtimeCallGenerator, name, *resultType, args,
2071 /// Returns a name suitable to define mlir functions for Fortran intrinsic
2077 /// fir.<generic name>.<result type>.<arg type>...
2080 /// a unique mangled name, we use "void" as the return type. As in:
2081 /// fir.<generic name>.void.<arg type>...
2085 std::string name = "fir.";
2086 name.append(intrinsic.str()).append(".");
2088 name.append(typeToString(funTy.getResult(0)));
2090 name.append("void");
2095 name.append(".").append(typeToString(funTy.getInput(i)));
2096 return name;
2101 llvm::StringRef name,
2104 std::string wrapperName = mangleIntrinsicProcedure(name, funcType);
2172 llvm::StringRef name, mlir::Type resultType,
2179 TODO(loc, "cannot outline call to intrinsic " + llvm::Twine(name) +
2184 std::string funcName{name};
2196 GeneratorType generator, llvm::StringRef name,
2200 TODO(loc, "cannot outline call to intrinsic " + llvm::Twine(name) +
2206 mlir::func::FuncOp wrapper = getWrapper(generator, name, funcType);
2219 llvm::StringRef name = range.first->key;
2230 checkPrecisionLoss(name, soughtFuncType, bestMatchDistance, builder, loc);
2237 sstream << name << "\nrequested type: " << soughtFuncType;
2262 IntrinsicLibrary::getRuntimeCallGenerator(llvm::StringRef name,
2266 lookupRuntimeGenerator(name, isPPCTarget);
2268 crashOnMissingIntrinsic(loc, name);
2273 llvm::StringRef name, mlir::FunctionType signature) {
2280 if (const IntrinsicHandler *handler = findIntrinsicHandler(name))
2283 return getWrapper(generator, name, signature, loadRefArguments);
2298 getRuntimeCallGenerator(name, soughtFuncType);
2299 funcOp = getWrapper(rtCallGenerator, name, signature, loadRefArguments);
2343 mlir::Value IntrinsicLibrary::genRuntimeCall(llvm::StringRef name,
2348 return getRuntimeCallGenerator(name, soughtFuncType)(builder, loc, args);
3199 mlir::Value name = fir::getBase(args[0]);
3200 mlir::Value status = fir::runtime::genChdir(builder, loc, name);
3931 mlir::Value name = fir::getBase(args[0]);
3938 if (!name)
3983 mlir::Value stat = fir::runtime::genGetEnvVariable(builder, loc, name, valBox,
4728 // Set arg ROUNDING_VALUE to the current floating point rounding mode.
4736 mlir::Value mode = builder.create<fir::CallOp>(loc, getRound).getResult(0);
4737 mode = builder.createConvert(loc, fieldTy, mode);
4738 builder.create<fir::StoreOp>(loc, mode, fieldRef);
5088 // Round according to the current rounding mode.
5106 // // rounding mode ieee_other is an alias for mode ieee_nearest
5108 // if (mode == ieee_nearest && odd(r)) result = ieee_next_down(r)
5109 // if (mode == ieee_other && odd(r)) result = ieee_next_down(r)
5110 // if (mode == ieee_to_zero && a > 0) result = ieee_next_down(r)
5111 // if (mode == ieee_away && a < 0) result = ieee_next_down(r)
5112 // if (mode == ieee_down) result = ieee_next_down(r)
5114 // if (mode == ieee_nearest && odd(r)) result = ieee_next_up(r)
5115 // if (mode == ieee_other && odd(r)) result = ieee_next_up(r)
5116 // if (mode == ieee_to_zero && a < 0) result = ieee_next_up(r)
5117 // if (mode == ieee_away && a > 0) result = ieee_next_up(r)
5118 // if (mode == ieee_up) result = ieee_next_up(r)
5186 mlir::Value mode = builder.create<fir::CallOp>(loc, getRound).getResult(0);
5207 // Check for a rounding mode match.
5210 loc, mlir::arith::CmpIPredicate::eq, mode,
5211 builder.createIntegerConstant(loc, mode.getType(), m));
5347 // mode. If ROUND is not present, signal IEEE_INEXACT if A is not an exact
5353 mlir::Value mode;
5355 mode = builder.create<fir::CallOp>(loc, getRound).getResult(0);
5364 builder.create<fir::CallOp>(loc, setRound, mode);
5378 // IEEE_SET_HALTING: Set an exception halting mode FLAG to a HALTING value.
5399 // Set the current floating point rounding mode to the value of arg
5407 mlir::Value mode = builder.create<fir::LoadOp>(loc, fieldRef);
5408 mode = builder.create<fir::ConvertOp>(
5409 loc, setRound.getFunctionType().getInput(0), mode);
5410 builder.create<fir::CallOp>(loc, setRound, mode);
5503 // Check if floating point rounding mode ROUND_VALUE is supported.
5514 mlir::Value mode = builder.create<fir::LoadOp>(loc, fieldRef);
5516 loc, mlir::arith::CmpIPredicate::sge, mode,
5520 loc, mlir::arith::CmpIPredicate::sle, mode,
8240 llvm::StringRef name = genericName(specificName);
8241 if (const IntrinsicHandler *handler = findIntrinsicHandler(name))
8244 if (const IntrinsicHandler *ppcHandler = findPPCIntrinsicHandler(name))
8278 llvm::StringRef name, std::optional<mlir::Type> resultType,
8282 name, resultType, args);
8310 // "precise/strict" FP mode.
8320 mlir::Location loc, llvm::StringRef name,
8323 name, signature);