switch (OffloadTargets.size()) {
default:
D.Diag(diag::err_drv_only_one_offload_target_supported);
- return llvm::None;
+ return std::nullopt;
case 0:
D.Diag(diag::err_drv_invalid_or_unsupported_offload_target) << "";
- return llvm::None;
+ return std::nullopt;
case 1:
break;
}
if (Args.hasArg(options::OPT_emit_llvm))
return TT;
D.Diag(diag::err_drv_cuda_offload_only_emit_bc);
- return llvm::None;
+ return std::nullopt;
}
D.Diag(diag::err_drv_invalid_or_unsupported_offload_target) << TT->str();
- return llvm::None;
+ return std::nullopt;
}
static llvm::Optional<llvm::Triple>
getHIPOffloadTargetTriple(const Driver &D, const ArgList &Args) {
}
auto TT = getOffloadTargetTriple(D, Args);
if (!TT)
- return llvm::None;
+ return std::nullopt;
if (TT->getArch() == llvm::Triple::amdgcn &&
TT->getVendor() == llvm::Triple::AMD &&
TT->getOS() == llvm::Triple::AMDHSA)
if (TT->getArch() == llvm::Triple::spirv64)
return TT;
D.Diag(diag::err_drv_invalid_or_unsupported_offload_target) << TT->str();
- return llvm::None;
+ return std::nullopt;
}
// static
NewLLDInvocation.replaceArguments(std::move(ArgList));
// Redirect stdout/stderr to /dev/null.
- NewLLDInvocation.Execute({None, {""}, {""}}, nullptr, nullptr);
+ NewLLDInvocation.Execute({std::nullopt, {""}, {""}}, nullptr, nullptr);
Diag(clang::diag::note_drv_command_failed_diag_msg) << BugReporMsg;
Diag(clang::diag::note_drv_command_failed_diag_msg) << TmpName;
Diag(clang::diag::note_drv_command_failed_diag_msg)
llvm::Optional<std::pair<llvm::StringRef, llvm::StringRef>>
getConflictOffloadArchCombination(
const std::set<StringRef> &GpuArchs) override {
- return llvm::None;
+ return std::nullopt;
}
ActionBuilderReturnCode
getConflictOffloadArchCombination(const llvm::DenseSet<StringRef> &Archs,
Action::OffloadKind Kind) {
if (Kind != Action::OFK_HIP)
- return None;
+ return std::nullopt;
std::set<StringRef> ArchSet;
llvm::copy(Archs, std::inserter(ArchSet, ArchSet.begin()));
if (llvm::sys::fs::exists(Twine(P)))
return std::string(P);
}
- return None;
+ return std::nullopt;
};
if (auto P = SearchPaths(PrefixDirs))
Expected<Optional<StringRef>> ReadBundleStart(MemoryBuffer &Input) final {
if (NextBundleInfo == BundlesInfo.end())
- return None;
+ return std::nullopt;
CurBundleInfo = NextBundleInfo++;
return CurBundleInfo->first();
}
// If it does not start with the reserved suffix, just skip this section.
if (!NameOrErr->startswith(OFFLOAD_BUNDLER_MAGIC_STR))
- return None;
+ return std::nullopt;
// Return the triple that is right after the reserved prefix.
return NameOrErr->substr(sizeof(OFFLOAD_BUNDLER_MAGIC_STR) - 1);
if (*TripleOrErr)
return **TripleOrErr;
}
- return None;
+ return std::nullopt;
}
Error ReadBundleEnd(MemoryBuffer &Input) final { return Error::success(); }
// Find start of the bundle.
ReadChars = FC.find(BundleStartString, ReadChars);
if (ReadChars == FC.npos)
- return None;
+ return std::nullopt;
// Get position of the triple.
size_t TripleStart = ReadChars = ReadChars + BundleStartString.size();
// Get position that closes the triple.
size_t TripleEnd = ReadChars = FC.find("\n", ReadChars);
if (TripleEnd == FC.npos)
- return None;
+ return std::nullopt;
// Next time we read after the new line.
++ReadChars;
auto ExpCommand = std::make_unique<Command>(
JA, *this, ResponseFileSupport::None(), CreateExportListExec,
CreateExportCmdArgs, Inputs, Output);
- ExpCommand->setRedirectFiles({None, std::string(ExportList), None});
+ ExpCommand->setRedirectFiles({std::nullopt, std::string(ExportList), None});
C.addCommand(std::move(ExpCommand));
CmdArgs.push_back(Args.MakeArgString(llvm::Twine("-bE:") + ExportList));
}
AMDGPUToolChain::getParsedTargetID(const llvm::opt::ArgList &DriverArgs) const {
StringRef TargetID = DriverArgs.getLastArgValue(options::OPT_mcpu_EQ);
if (TargetID.empty())
- return {None, None, None};
+ return {std::nullopt, std::nullopt, std::nullopt};
llvm::StringMap<bool> FeatureMap;
auto OptionalGpuArch = parseTargetID(getTriple(), TargetID, &FeatureMap);
if (!OptionalGpuArch)
- return {TargetID.str(), None, None};
+ return {TargetID.str(), std::nullopt, std::nullopt};
return {TargetID.str(), OptionalGpuArch->str(), FeatureMap};
}
for (const auto &MCU : MCUInfo)
if (MCU.Name == MCUName)
return Optional<StringRef>(MCU.Family);
- return None;
+ return std::nullopt;
}
llvm::Optional<unsigned> GetMCUSectionAddressData(StringRef MCUName) {
for (const auto &MCU : MCUInfo)
if (MCU.Name == MCUName && MCU.DataAddr > 0)
return Optional<unsigned>(MCU.DataAddr);
- return None;
+ return std::nullopt;
}
const StringRef PossibleAVRLibcLocations[] = {
return Path;
}
- return llvm::None;
+ return std::nullopt;
}
if (ArchKind == llvm::CSKY::ArchKind::INVALID) {
D.Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
- return llvm::None;
+ return std::nullopt;
}
return llvm::Optional<llvm::StringRef>(A->getValue());
}
llvm::CSKY::ArchKind ArchKind = llvm::CSKY::parseCPUArch(A->getValue());
if (ArchKind == llvm::CSKY::ArchKind::INVALID) {
D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
- return llvm::None;
+ return std::nullopt;
}
return llvm::Optional<llvm::StringRef>(llvm::CSKY::getArchName(ArchKind));
}
C.addCommand(std::make_unique<Command>(
JA, *this, ResponseFileSupport::None(),
TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())),
- CmdArgs, None, Output));
+ CmdArgs, std::nullopt, Output));
}
void OffloadBundler::ConstructJobMultipleOutputs(
C.addCommand(std::make_unique<Command>(
JA, *this, ResponseFileSupport::None(),
TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())),
- CmdArgs, None, Outputs));
+ CmdArgs, std::nullopt, Outputs));
}
void OffloadPackager::ConstructJob(Compilation &C, const JobAction &JA,
const char *Exec =
Args.MakeArgString(getToolChain().GetProgramPath("touch"));
CmdArgs.push_back(Output.getFilename());
- C.addCommand(std::make_unique<Command>(
- JA, *this, ResponseFileSupport::None(), Exec, CmdArgs, None, Output));
+ C.addCommand(std::make_unique<Command>(JA, *this,
+ ResponseFileSupport::None(), Exec,
+ CmdArgs, std::nullopt, Output));
return;
}
Darwin::WatchOS, WatchOSVersion,
WatchOSVersion->getOption().getID() ==
options::OPT_mwatchos_simulator_version_min_EQ);
- return None;
+ return std::nullopt;
}
/// Returns the deployment target that's specified using the
(Darwin::DarwinPlatformKind)Target.index(), EnvVars[Target.index()],
Target.value());
}
- return None;
+ return std::nullopt;
}
/// Returns the SDK name without the optional prefix that ends with a '.' or an
const Optional<DarwinSDKInfo> &SDKInfo) {
const Arg *A = Args.getLastArg(options::OPT_isysroot);
if (!A)
- return None;
+ return std::nullopt;
StringRef isysroot = A->getValue();
StringRef SDK = Darwin::getSDKName(isysroot);
if (!SDK.size())
- return None;
+ return std::nullopt;
std::string Version;
if (SDKInfo) {
Version = std::string(SDK.slice(StartVer, EndVer + 1));
}
if (Version.empty())
- return None;
+ return std::nullopt;
auto CreatePlatformFromSDKName =
[&](StringRef SDK) -> Optional<DarwinPlatform> {
/*IsSimulator=*/SDK.startswith("AppleTVSimulator"));
else if (SDK.startswith("DriverKit"))
return DarwinPlatform::createFromSDK(Darwin::DriverKit, Version);
- return None;
+ return std::nullopt;
};
if (auto Result = CreatePlatformFromSDKName(SDK))
return Result;
MachOArchName != "armv7em")
OSTy = llvm::Triple::MacOSX;
if (OSTy == llvm::Triple::UnknownOS)
- return None;
+ return std::nullopt;
return DarwinPlatform::createFromArch(OSTy,
getOSVersion(OSTy, Triple, TheDriver));
}
DerivedArgList &Args, const llvm::Triple &Triple, const Driver &TheDriver,
const Optional<DarwinSDKInfo> &SDKInfo) {
if (!Args.hasArg(options::OPT_target))
- return None;
+ return std::nullopt;
if (Triple.getOS() == llvm::Triple::Darwin ||
Triple.getOS() == llvm::Triple::UnknownOS)
- return None;
+ return std::nullopt;
std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
Optional<llvm::Triple> TargetVariantTriple;
for (const Arg *A : Args.filtered(options::OPT_darwin_target_variant)) {
const Optional<DarwinSDKInfo> &SDKInfo) {
auto *A = Args.getLastArg(options::OPT_mtargetos_EQ);
if (!A)
- return None;
+ return std::nullopt;
llvm::Triple TT(llvm::Twine("unknown-apple-") + A->getValue());
switch (TT.getOS()) {
case llvm::Triple::MacOSX:
default:
TheDriver.Diag(diag::err_drv_invalid_os_in_arg)
<< TT.getOSName() << A->getAsString(Args);
- return None;
+ return std::nullopt;
}
VersionTuple Version = TT.getOSVersion();
if (!Version.getMajor()) {
TheDriver.Diag(diag::err_drv_invalid_version_number)
<< A->getAsString(Args);
- return None;
+ return std::nullopt;
}
return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
TT.getEnvironment(), A, SDKInfo);
const Driver &TheDriver) {
const Arg *A = Args.getLastArg(options::OPT_isysroot);
if (!A)
- return None;
+ return std::nullopt;
StringRef isysroot = A->getValue();
auto SDKInfoOrErr = parseDarwinSDKInfo(VFS, isysroot);
if (!SDKInfoOrErr) {
llvm::consumeError(SDKInfoOrErr.takeError());
TheDriver.Diag(diag::warn_drv_darwin_sdk_invalid_settings);
- return None;
+ return std::nullopt;
}
return *SDKInfoOrErr;
}
SmallVector<StringRef, 3> Parts;
Profile.split(Parts, "_");
if (Parts.size() != 3)
- return None;
+ return std::nullopt;
Triple::EnvironmentType Kind =
StringSwitch<Triple::EnvironmentType>(Parts[0])
.Case("as", Triple::EnvironmentType::Amplification)
.Default(Triple::EnvironmentType::UnknownEnvironment);
if (Kind == Triple::EnvironmentType::UnknownEnvironment)
- return None;
+ return std::nullopt;
unsigned long long Major = 0;
if (llvm::getAsUnsignedInteger(Parts[1], 0, Major))
- return None;
+ return std::nullopt;
unsigned long long Minor = 0;
if (Parts[2] == "x" && Kind == Triple::EnvironmentType::Library)
Minor = OfflineLibMinor;
else if (llvm::getAsUnsignedInteger(Parts[2], 0, Minor))
- return None;
+ return std::nullopt;
// dxil-unknown-shadermodel-hull
llvm::Triple T;
if (isLegalShaderModel(T))
return T.getTriple();
else
- return None;
+ return std::nullopt;
}
bool isLegalValidatorVersion(StringRef ValVersionStr, const Driver &D) {
// to Features.
Arg *A = Args.getLastArg(FlagOn, FlagOff);
if (!A)
- return None;
+ return std::nullopt;
StringRef OptName = A->getOption().getName();
if (A->getOption().matches(FlagOff))
if (!HasHVX) {
D.Diag(diag::err_drv_needs_hvx) << withMinus(OptName);
- return None;
+ return std::nullopt;
}
if (HvxVerNum < MinVerNum) {
D.Diag(diag::err_drv_needs_hvx_version)
<< withMinus(OptName) << ("v" + std::to_string(HvxVerNum));
- return None;
+ return std::nullopt;
}
return makeFeature(OptName, true);
};
if (!Gn.getAsInteger(10, G))
return G;
- return None;
+ return std::nullopt;
}
std::string HexagonToolChain::getCompilerRTPath() const {