[clang] f137c3d - [TargetRegistry] Accept Triple in createTargetMachine() (NFC) (#130940)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Mar 12 09:35:15 PDT 2025
Author: Nikita Popov
Date: 2025-03-12T17:35:09+01:00
New Revision: f137c3d592e96330e450a8fd63ef7e8877fc1908
URL: https://github.com/llvm/llvm-project/commit/f137c3d592e96330e450a8fd63ef7e8877fc1908
DIFF: https://github.com/llvm/llvm-project/commit/f137c3d592e96330e450a8fd63ef7e8877fc1908.diff
LOG: [TargetRegistry] Accept Triple in createTargetMachine() (NFC) (#130940)
This avoids doing a Triple -> std::string -> Triple round trip in lots
of places, now that the Module stores a Triple.
Added:
Modified:
bolt/lib/Passes/AsmDump.cpp
clang/lib/CodeGen/BackendUtil.cpp
clang/lib/Interpreter/DeviceOffload.cpp
clang/lib/Interpreter/Wasm.cpp
clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp
clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
clang/tools/driver/cc1_main.cpp
flang/tools/bbc/bbc.cpp
flang/tools/flang-driver/fc1_main.cpp
llvm/examples/Kaleidoscope/Chapter8/toy.cpp
llvm/include/llvm/MC/TargetRegistry.h
llvm/lib/CodeGen/CommandFlags.cpp
llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp
llvm/lib/ExecutionEngine/Orc/JITTargetMachineBuilder.cpp
llvm/lib/ExecutionEngine/TargetSelect.cpp
llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
llvm/lib/LTO/LTOBackend.cpp
llvm/lib/LTO/LTOCodeGenerator.cpp
llvm/lib/LTO/LTOModule.cpp
llvm/lib/LTO/ThinLTOCodeGenerator.cpp
llvm/lib/Target/SPIRV/SPIRVAPI.cpp
llvm/lib/Target/TargetMachineC.cpp
llvm/tools/llc/llc.cpp
llvm/tools/llvm-exegesis/lib/LlvmState.cpp
llvm/tools/llvm-split/llvm-split.cpp
llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp
llvm/unittests/CodeGen/AMDGPUMetadataTest.cpp
llvm/unittests/CodeGen/DroppedVariableStatsMIRTest.cpp
llvm/unittests/CodeGen/GlobalISel/GISelMITest.cpp
llvm/unittests/CodeGen/InstrRefLDVTest.cpp
llvm/unittests/CodeGen/MachineDomTreeUpdaterTest.cpp
llvm/unittests/CodeGen/PassManagerTest.cpp
llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp
llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
llvm/unittests/CodeGen/TargetOptionsTest.cpp
llvm/unittests/CodeGen/TestAsmPrinter.cpp
llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
llvm/unittests/MC/AMDGPU/DwarfRegMappings.cpp
llvm/unittests/MI/LiveIntervalTest.cpp
llvm/unittests/MIR/MachineMetadata.cpp
llvm/unittests/MIR/MachineStableHashTest.cpp
llvm/unittests/Target/AArch64/AArch64RegisterInfoTest.cpp
llvm/unittests/Target/AArch64/AArch64SVESchedPseudoTest.cpp
llvm/unittests/Target/AArch64/AddressingModes.cpp
llvm/unittests/Target/AArch64/Immediates.cpp
llvm/unittests/Target/AArch64/InstSizes.cpp
llvm/unittests/Target/AArch64/MatrixRegisterAliasing.cpp
llvm/unittests/Target/AMDGPU/AMDGPUUnitTests.cpp
llvm/unittests/Target/AMDGPU/PALMetadata.cpp
llvm/unittests/Target/ARM/InstSizes.cpp
llvm/unittests/Target/ARM/MachineInstrTest.cpp
llvm/unittests/Target/LoongArch/InstSizes.cpp
llvm/unittests/Target/PowerPC/AIXRelocModelTest.cpp
llvm/unittests/Target/RISCV/RISCVInstrInfoTest.cpp
llvm/unittests/Target/VE/MachineInstrTest.cpp
llvm/unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp
llvm/unittests/Target/X86/MachineSizeOptsTest.cpp
llvm/unittests/Target/X86/TernlogTest.cpp
llvm/unittests/tools/llvm-exegesis/Common/AssemblerUtils.h
mlir/lib/Target/LLVM/ModuleToObject.cpp
offload/plugins-nextgen/common/src/JIT.cpp
Removed:
################################################################################
diff --git a/bolt/lib/Passes/AsmDump.cpp b/bolt/lib/Passes/AsmDump.cpp
index 97f985d56ce64..08191669e72f3 100644
--- a/bolt/lib/Passes/AsmDump.cpp
+++ b/bolt/lib/Passes/AsmDump.cpp
@@ -143,7 +143,7 @@ void dumpFunction(const BinaryFunction &BF) {
std::move(MCEInstance.MCE), std::move(MAB)));
AsmStreamer->initSections(true, *BC.STI);
std::unique_ptr<TargetMachine> TM(BC.TheTarget->createTargetMachine(
- BC.TripleName, "", "", TargetOptions(), std::nullopt));
+ *BC.TheTriple, "", "", TargetOptions(), std::nullopt));
std::unique_ptr<AsmPrinter> MAP(
BC.TheTarget->createAsmPrinter(*TM, std::move(AsmStreamer)));
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
index 62a0e3c69bad1..7557cb8408921 100644
--- a/clang/lib/CodeGen/BackendUtil.cpp
+++ b/clang/lib/CodeGen/BackendUtil.cpp
@@ -595,7 +595,7 @@ static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts) {
void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
// Create the TargetMachine for generating code.
std::string Error;
- std::string Triple = TheModule->getTargetTriple().str();
+ const llvm::Triple &Triple = TheModule->getTargetTriple();
const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
if (!TheTarget) {
if (MustCreateTM)
diff --git a/clang/lib/Interpreter/DeviceOffload.cpp b/clang/lib/Interpreter/DeviceOffload.cpp
index 5e35fa035b2b8..1999d63d1aa04 100644
--- a/clang/lib/Interpreter/DeviceOffload.cpp
+++ b/clang/lib/Interpreter/DeviceOffload.cpp
@@ -83,7 +83,7 @@ llvm::Expected<llvm::StringRef> IncrementalCUDADeviceParser::GeneratePTX() {
std::error_code());
llvm::TargetOptions TO = llvm::TargetOptions();
llvm::TargetMachine *TargetMachine = Target->createTargetMachine(
- PTU.TheModule->getTargetTriple().str(), TargetOpts.CPU, "", TO,
+ PTU.TheModule->getTargetTriple(), TargetOpts.CPU, "", TO,
llvm::Reloc::Model::PIC_);
PTU.TheModule->setDataLayout(TargetMachine->createDataLayout());
diff --git a/clang/lib/Interpreter/Wasm.cpp b/clang/lib/Interpreter/Wasm.cpp
index 6f584fab52ba9..f7cb7598c77f8 100644
--- a/clang/lib/Interpreter/Wasm.cpp
+++ b/clang/lib/Interpreter/Wasm.cpp
@@ -73,9 +73,8 @@ llvm::Error WasmIncrementalExecutor::addModule(PartialTranslationUnit &PTU) {
}
llvm::TargetOptions TO = llvm::TargetOptions();
- llvm::TargetMachine *TargetMachine =
- Target->createTargetMachine(PTU.TheModule->getTargetTriple().str(), "",
- "", TO, llvm::Reloc::Model::PIC_);
+ llvm::TargetMachine *TargetMachine = Target->createTargetMachine(
+ PTU.TheModule->getTargetTriple(), "", "", TO, llvm::Reloc::Model::PIC_);
PTU.TheModule->setDataLayout(TargetMachine->createDataLayout());
std::string ObjectFileName = PTU.TheModule->getName().str() + ".o";
std::string BinaryFileName = PTU.TheModule->getName().str() + ".wasm";
diff --git a/clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp b/clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp
index 4618c0bcc6be8..798b34b3ef0af 100644
--- a/clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp
+++ b/clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp
@@ -127,8 +127,8 @@ static std::string OptLLVM(const std::string &IR, CodeGenOptLevel OLvl) {
ErrorAndExit(E);
std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
- M->getTargetTriple().str(), codegen::getCPUStr(),
- codegen::getFeaturesStr(), Options, codegen::getExplicitRelocModel(),
+ M->getTargetTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
+ Options, codegen::getExplicitRelocModel(),
codegen::getExplicitCodeModel(), OLvl));
if (!TM)
ErrorAndExit("Could not create target machine");
diff --git a/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp b/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
index dcfed14746200..8d63d2c414cef 100644
--- a/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
+++ b/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
@@ -637,7 +637,7 @@ Expected<StringRef> compileModule(Module &M, OffloadKind Kind) {
StringRef CPU = "";
StringRef Features = "";
std::unique_ptr<TargetMachine> TM(
- T->createTargetMachine(M.getTargetTriple().str(), CPU, Features, Options,
+ T->createTargetMachine(M.getTargetTriple(), CPU, Features, Options,
Reloc::PIC_, M.getCodeModel()));
if (M.getDataLayout().isDefault())
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
index 26b5e78cfb4b5..341520c6a6f73 100644
--- a/clang/tools/driver/cc1_main.cpp
+++ b/clang/tools/driver/cc1_main.cpp
@@ -111,9 +111,10 @@ static void ensureSufficientStack() {}
/// Print supported cpus of the given target.
static int PrintSupportedCPUs(std::string TargetStr) {
+ llvm::Triple Triple(TargetStr);
std::string Error;
const llvm::Target *TheTarget =
- llvm::TargetRegistry::lookupTarget(TargetStr, Error);
+ llvm::TargetRegistry::lookupTarget(Triple, Error);
if (!TheTarget) {
llvm::errs() << Error;
return 1;
@@ -122,15 +123,16 @@ static int PrintSupportedCPUs(std::string TargetStr) {
// the target machine will handle the mcpu printing
llvm::TargetOptions Options;
std::unique_ptr<llvm::TargetMachine> TheTargetMachine(
- TheTarget->createTargetMachine(TargetStr, "", "+cpuhelp", Options,
+ TheTarget->createTargetMachine(Triple, "", "+cpuhelp", Options,
std::nullopt));
return 0;
}
static int PrintSupportedExtensions(std::string TargetStr) {
+ llvm::Triple Triple(TargetStr);
std::string Error;
const llvm::Target *TheTarget =
- llvm::TargetRegistry::lookupTarget(TargetStr, Error);
+ llvm::TargetRegistry::lookupTarget(Triple, Error);
if (!TheTarget) {
llvm::errs() << Error;
return 1;
@@ -138,7 +140,7 @@ static int PrintSupportedExtensions(std::string TargetStr) {
llvm::TargetOptions Options;
std::unique_ptr<llvm::TargetMachine> TheTargetMachine(
- TheTarget->createTargetMachine(TargetStr, "", "", Options, std::nullopt));
+ TheTarget->createTargetMachine(Triple, "", "", Options, std::nullopt));
const llvm::Triple &MachineTriple = TheTargetMachine->getTargetTriple();
const llvm::MCSubtargetInfo *MCInfo = TheTargetMachine->getMCSubtargetInfo();
const llvm::ArrayRef<llvm::SubtargetFeatureKV> Features =
@@ -165,9 +167,10 @@ static int PrintSupportedExtensions(std::string TargetStr) {
}
static int PrintEnabledExtensions(const TargetOptions& TargetOpts) {
+ llvm::Triple Triple(TargetOpts.Triple);
std::string Error;
const llvm::Target *TheTarget =
- llvm::TargetRegistry::lookupTarget(TargetOpts.Triple, Error);
+ llvm::TargetRegistry::lookupTarget(Triple, Error);
if (!TheTarget) {
llvm::errs() << Error;
return 1;
@@ -179,7 +182,8 @@ static int PrintEnabledExtensions(const TargetOptions& TargetOpts) {
llvm::TargetOptions BackendOptions;
std::string FeaturesStr = llvm::join(TargetOpts.FeaturesAsWritten, ",");
std::unique_ptr<llvm::TargetMachine> TheTargetMachine(
- TheTarget->createTargetMachine(TargetOpts.Triple, TargetOpts.CPU, FeaturesStr, BackendOptions, std::nullopt));
+ TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
+ BackendOptions, std::nullopt));
const llvm::Triple &MachineTriple = TheTargetMachine->getTargetTriple();
const llvm::MCSubtargetInfo *MCInfo = TheTargetMachine->getMCSubtargetInfo();
diff --git a/flang/tools/bbc/bbc.cpp b/flang/tools/bbc/bbc.cpp
index 3b19a1c2a78d9..efaeb0c0a3891 100644
--- a/flang/tools/bbc/bbc.cpp
+++ b/flang/tools/bbc/bbc.cpp
@@ -280,7 +280,7 @@ createTargetMachine(llvm::StringRef targetTriple, std::string &error) {
if (!theTarget)
return nullptr;
return std::unique_ptr<llvm::TargetMachine>{
- theTarget->createTargetMachine(triple, /*CPU=*/"",
+ theTarget->createTargetMachine(llvm::Triple(triple), /*CPU=*/"",
/*Features=*/"", llvm::TargetOptions(),
/*Reloc::Model=*/std::nullopt)};
}
diff --git a/flang/tools/flang-driver/fc1_main.cpp b/flang/tools/flang-driver/fc1_main.cpp
index 561a0dd5524e3..49535275d084d 100644
--- a/flang/tools/flang-driver/fc1_main.cpp
+++ b/flang/tools/flang-driver/fc1_main.cpp
@@ -45,8 +45,8 @@ static int printSupportedCPUs(llvm::StringRef triple) {
// the target machine will handle the mcpu printing
llvm::TargetOptions targetOpts;
std::unique_ptr<llvm::TargetMachine> targetMachine(
- target->createTargetMachine(triple, "", "+cpuhelp", targetOpts,
- std::nullopt));
+ target->createTargetMachine(llvm::Triple(triple), "", "+cpuhelp",
+ targetOpts, std::nullopt));
return 0;
}
diff --git a/llvm/examples/Kaleidoscope/Chapter8/toy.cpp b/llvm/examples/Kaleidoscope/Chapter8/toy.cpp
index e2e54306dd2fd..739b8954aa8b2 100644
--- a/llvm/examples/Kaleidoscope/Chapter8/toy.cpp
+++ b/llvm/examples/Kaleidoscope/Chapter8/toy.cpp
@@ -1243,7 +1243,7 @@ int main() {
TargetOptions opt;
auto TheTargetMachine = Target->createTargetMachine(
- TargetTriple, CPU, Features, opt, Reloc::PIC_);
+ Triple(TargetTriple), CPU, Features, opt, Reloc::PIC_);
TheModule->setDataLayout(TheTargetMachine->createDataLayout());
diff --git a/llvm/include/llvm/MC/TargetRegistry.h b/llvm/include/llvm/MC/TargetRegistry.h
index 363fa03f27a70..f21809402936a 100644
--- a/llvm/include/llvm/MC/TargetRegistry.h
+++ b/llvm/include/llvm/MC/TargetRegistry.h
@@ -453,14 +453,24 @@ class Target {
/// either the target triple from the module, or the target triple of the
/// host if that does not exist.
TargetMachine *createTargetMachine(
- StringRef TT, StringRef CPU, StringRef Features,
+ const Triple &TT, StringRef CPU, StringRef Features,
const TargetOptions &Options, std::optional<Reloc::Model> RM,
std::optional<CodeModel::Model> CM = std::nullopt,
CodeGenOptLevel OL = CodeGenOptLevel::Default, bool JIT = false) const {
if (!TargetMachineCtorFn)
return nullptr;
- return TargetMachineCtorFn(*this, Triple(TT), CPU, Features, Options, RM,
- CM, OL, JIT);
+ return TargetMachineCtorFn(*this, TT, CPU, Features, Options, RM, CM, OL,
+ JIT);
+ }
+
+ [[deprecated("Use overload accepting Triple instead")]]
+ TargetMachine *createTargetMachine(
+ StringRef TT, StringRef CPU, StringRef Features,
+ const TargetOptions &Options, std::optional<Reloc::Model> RM,
+ std::optional<CodeModel::Model> CM = std::nullopt,
+ CodeGenOptLevel OL = CodeGenOptLevel::Default, bool JIT = false) const {
+ return createTargetMachine(Triple(TT), CPU, Features, Options, RM, CM, OL,
+ JIT);
}
/// createMCAsmBackend - Create a target specific assembly parser.
diff --git a/llvm/lib/CodeGen/CommandFlags.cpp b/llvm/lib/CodeGen/CommandFlags.cpp
index 023656cde0089..9512f7993bd93 100644
--- a/llvm/lib/CodeGen/CommandFlags.cpp
+++ b/llvm/lib/CodeGen/CommandFlags.cpp
@@ -764,7 +764,7 @@ codegen::createTargetMachineForTriple(StringRef TargetTriple,
if (!TheTarget)
return createStringError(inconvertibleErrorCode(), Error);
auto *Target = TheTarget->createTargetMachine(
- TheTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
+ TheTriple, codegen::getCPUStr(), codegen::getFeaturesStr(),
codegen::InitTargetOptionsFromCodeGenFlags(TheTriple),
codegen::getExplicitRelocModel(), codegen::getExplicitCodeModel(),
OptLevel);
diff --git a/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp b/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
index 947db9cbcd92d..55e40cd779cbf 100644
--- a/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
+++ b/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
@@ -123,7 +123,7 @@ Error DwarfStreamer::init(Triple TheTriple,
TripleName.c_str());
// Finally create the AsmPrinter we'll use to emit the DIEs.
- TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
+ TM.reset(TheTarget->createTargetMachine(TheTriple, "", "", TargetOptions(),
std::nullopt));
if (!TM)
return createStringError(std::errc::invalid_argument,
diff --git a/llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp b/llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp
index fbab6b25ca0f1..4cd1875b37f5b 100644
--- a/llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp
+++ b/llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp
@@ -102,7 +102,7 @@ Error DwarfEmitterImpl::init(Triple TheTriple,
TripleName.c_str());
// Finally create the AsmPrinter we'll use to emit the DIEs.
- TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
+ TM.reset(TheTarget->createTargetMachine(TheTriple, "", "", TargetOptions(),
std::nullopt));
if (!TM)
return createStringError(std::errc::invalid_argument,
diff --git a/llvm/lib/ExecutionEngine/Orc/JITTargetMachineBuilder.cpp b/llvm/lib/ExecutionEngine/Orc/JITTargetMachineBuilder.cpp
index 5ae1ac6e4250d..ff45af5843597 100644
--- a/llvm/lib/ExecutionEngine/Orc/JITTargetMachineBuilder.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/JITTargetMachineBuilder.cpp
@@ -47,9 +47,8 @@ JITTargetMachineBuilder::createTargetMachine() {
return make_error<StringError>("Target has no JIT support",
inconvertibleErrorCode());
- auto *TM =
- TheTarget->createTargetMachine(TT.getTriple(), CPU, Features.getString(),
- Options, RM, CM, OptLevel, /*JIT*/ true);
+ auto *TM = TheTarget->createTargetMachine(
+ TT, CPU, Features.getString(), Options, RM, CM, OptLevel, /*JIT=*/true);
if (!TM)
return make_error<StringError>("Could not allocate target machine",
inconvertibleErrorCode());
diff --git a/llvm/lib/ExecutionEngine/TargetSelect.cpp b/llvm/lib/ExecutionEngine/TargetSelect.cpp
index 4ce031d8dc337..bce90fc33d64f 100644
--- a/llvm/lib/ExecutionEngine/TargetSelect.cpp
+++ b/llvm/lib/ExecutionEngine/TargetSelect.cpp
@@ -84,10 +84,9 @@ TargetMachine *EngineBuilder::selectTarget(const Triple &TargetTriple,
}
// Allocate a target...
- TargetMachine *Target =
- TheTarget->createTargetMachine(TheTriple.getTriple(), MCPU, FeaturesStr,
- Options, RelocModel, CMModel, OptLevel,
- /*JIT*/ true);
+ TargetMachine *Target = TheTarget->createTargetMachine(
+ TheTriple, MCPU, FeaturesStr, Options, RelocModel, CMModel, OptLevel,
+ /*JIT=*/true);
Target->Options.EmulatedTLS = EmulatedTLS;
assert(Target && "Could not allocate target machine!");
diff --git a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
index 7718d8a98172f..8dcebcdb8791d 100644
--- a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
+++ b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
@@ -5505,7 +5505,7 @@ createTargetMachine(Function *F, CodeGenOptLevel OptLevel) {
StringRef CPU = F->getFnAttribute("target-cpu").getValueAsString();
StringRef Features = F->getFnAttribute("target-features").getValueAsString();
- const std::string &Triple = M->getTargetTriple().str();
+ const llvm::Triple &Triple = M->getTargetTriple();
std::string Error;
const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
diff --git a/llvm/lib/LTO/LTOBackend.cpp b/llvm/lib/LTO/LTOBackend.cpp
index 139c39abf8e6b..1c764a0188eda 100644
--- a/llvm/lib/LTO/LTOBackend.cpp
+++ b/llvm/lib/LTO/LTOBackend.cpp
@@ -227,7 +227,7 @@ createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M) {
}
std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
- TheTriple.str(), Conf.CPU, Features.getString(), TargetOpts, RelocModel,
+ TheTriple, Conf.CPU, Features.getString(), TargetOpts, RelocModel,
CodeModel, Conf.CGOptLevel));
assert(TM && "Failed to create target machine");
diff --git a/llvm/lib/LTO/LTOCodeGenerator.cpp b/llvm/lib/LTO/LTOCodeGenerator.cpp
index e855b45915521..6b66a88880053 100644
--- a/llvm/lib/LTO/LTOCodeGenerator.cpp
+++ b/llvm/lib/LTO/LTOCodeGenerator.cpp
@@ -420,8 +420,8 @@ bool LTOCodeGenerator::determineTarget() {
std::unique_ptr<TargetMachine> LTOCodeGenerator::createTargetMachine() {
assert(MArch && "MArch is not set!");
return std::unique_ptr<TargetMachine>(MArch->createTargetMachine(
- TripleStr, Config.CPU, FeatureStr, Config.Options, Config.RelocModel,
- std::nullopt, Config.CGOptLevel));
+ Triple(TripleStr), Config.CPU, FeatureStr, Config.Options,
+ Config.RelocModel, std::nullopt, Config.CGOptLevel));
}
// If a linkonce global is present in the MustPreserveSymbols, we need to make
diff --git a/llvm/lib/LTO/LTOModule.cpp b/llvm/lib/LTO/LTOModule.cpp
index 7e13646bfa0a8..d7d2fcce7bd43 100644
--- a/llvm/lib/LTO/LTOModule.cpp
+++ b/llvm/lib/LTO/LTOModule.cpp
@@ -228,8 +228,8 @@ LTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
CPU = "cyclone";
}
- TargetMachine *target = march->createTargetMachine(
- Triple.str(), CPU, FeatureStr, options, std::nullopt);
+ TargetMachine *target = march->createTargetMachine(Triple, CPU, FeatureStr,
+ options, std::nullopt);
std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target));
Ret->parseSymbols();
diff --git a/llvm/lib/LTO/ThinLTOCodeGenerator.cpp b/llvm/lib/LTO/ThinLTOCodeGenerator.cpp
index 16326395d0f74..11e88ca4a83eb 100644
--- a/llvm/lib/LTO/ThinLTOCodeGenerator.cpp
+++ b/llvm/lib/LTO/ThinLTOCodeGenerator.cpp
@@ -588,7 +588,7 @@ std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const {
std::string FeatureStr = Features.getString();
std::unique_ptr<TargetMachine> TM(
- TheTarget->createTargetMachine(TheTriple.str(), MCpu, FeatureStr, Options,
+ TheTarget->createTargetMachine(TheTriple, MCpu, FeatureStr, Options,
RelocModel, std::nullopt, CGOptLevel));
assert(TM && "Cannot create target machine");
diff --git a/llvm/lib/Target/SPIRV/SPIRVAPI.cpp b/llvm/lib/Target/SPIRV/SPIRVAPI.cpp
index 052dd296265be..145285a31dc10 100644
--- a/llvm/lib/Target/SPIRV/SPIRVAPI.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVAPI.cpp
@@ -94,7 +94,7 @@ SPIRVTranslate(Module *M, std::string &SpirvObj, std::string &ErrMsg,
std::optional<Reloc::Model> RM;
std::optional<CodeModel::Model> CM;
std::unique_ptr<TargetMachine> Target(TheTarget->createTargetMachine(
- TargetTriple.getTriple(), "", "", Options, RM, CM, OLevel));
+ TargetTriple, "", "", Options, RM, CM, OLevel));
if (!Target) {
ErrMsg = "Could not allocate target machine!";
return false;
diff --git a/llvm/lib/Target/TargetMachineC.cpp b/llvm/lib/Target/TargetMachineC.cpp
index d12fc65047d04..da6d35c8c8b43 100644
--- a/llvm/lib/Target/TargetMachineC.cpp
+++ b/llvm/lib/Target/TargetMachineC.cpp
@@ -197,14 +197,14 @@ void LLVMTargetMachineOptionsSetCodeModel(LLVMTargetMachineOptionsRef Options,
}
LLVMTargetMachineRef
-LLVMCreateTargetMachineWithOptions(LLVMTargetRef T, const char *Triple,
+LLVMCreateTargetMachineWithOptions(LLVMTargetRef T, const char *TripleStr,
LLVMTargetMachineOptionsRef Options) {
auto *Opt = unwrap(Options);
TargetOptions TO;
TO.MCOptions.ABIName = Opt->ABI;
- return wrap(unwrap(T)->createTargetMachine(Triple, Opt->CPU, Opt->Features,
- TO, Opt->RM, Opt->CM, Opt->OL,
- Opt->JIT));
+ return wrap(unwrap(T)->createTargetMachine(Triple(TripleStr), Opt->CPU,
+ Opt->Features, TO, Opt->RM,
+ Opt->CM, Opt->OL, Opt->JIT));
}
LLVMTargetMachineRef
diff --git a/llvm/tools/llc/llc.cpp b/llvm/tools/llc/llc.cpp
index 456d5f8f2a2f8..9f7824040a37d 100644
--- a/llvm/tools/llc/llc.cpp
+++ b/llvm/tools/llc/llc.cpp
@@ -555,7 +555,7 @@ static int compileModule(char **argv, LLVMContext &Context) {
InitializeOptions(TheTriple);
Target = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
- TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM, CM, OLvl));
+ TheTriple, CPUStr, FeaturesStr, Options, RM, CM, OLvl));
assert(Target && "Could not allocate target machine!");
return Target->createDataLayout().getStringRepresentation();
@@ -598,7 +598,7 @@ static int compileModule(char **argv, LLVMContext &Context) {
InitializeOptions(TheTriple);
Target = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
- TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM, CM, OLvl));
+ TheTriple, CPUStr, FeaturesStr, Options, RM, CM, OLvl));
assert(Target && "Could not allocate target machine!");
// If we don't have a module then just exit now. We do this down
diff --git a/llvm/tools/llvm-exegesis/lib/LlvmState.cpp b/llvm/tools/llvm-exegesis/lib/LlvmState.cpp
index 00d0d2cfd1cd3..9502cae993f67 100644
--- a/llvm/tools/llvm-exegesis/lib/LlvmState.cpp
+++ b/llvm/tools/llvm-exegesis/lib/LlvmState.cpp
@@ -57,7 +57,7 @@ Expected<LLVMState> LLVMState::Create(std::string TripleName,
}
const TargetOptions Options;
std::unique_ptr<const TargetMachine> TM(TheTarget->createTargetMachine(
- TripleName, CpuName, Features, Options, Reloc::Model::Static));
+ TheTriple, CpuName, Features, Options, Reloc::Model::Static));
if (!TM) {
return make_error<StringError>("unable to create target machine",
inconvertibleErrorCode());
@@ -93,7 +93,7 @@ LLVMState::LLVMState(std::unique_ptr<const TargetMachine> TM,
std::unique_ptr<TargetMachine> LLVMState::createTargetMachine() const {
return std::unique_ptr<TargetMachine>(
TheTargetMachine->getTarget().createTargetMachine(
- TheTargetMachine->getTargetTriple().normalize(),
+ Triple(TheTargetMachine->getTargetTriple().normalize()),
TheTargetMachine->getTargetCPU(),
TheTargetMachine->getTargetFeatureString(), TheTargetMachine->Options,
Reloc::Model::Static));
diff --git a/llvm/tools/llvm-split/llvm-split.cpp b/llvm/tools/llvm-split/llvm-split.cpp
index 1b1f97f44e274..9f6678a1fa466 100644
--- a/llvm/tools/llvm-split/llvm-split.cpp
+++ b/llvm/tools/llvm-split/llvm-split.cpp
@@ -92,7 +92,7 @@ int main(int argc, char **argv) {
TargetOptions Options;
TM = std::unique_ptr<TargetMachine>(T->createTargetMachine(
- MTriple, MCPU, /*FS*/ "", Options, std::nullopt, std::nullopt));
+ Triple(MTriple), MCPU, /*FS*/ "", Options, std::nullopt, std::nullopt));
}
std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
diff --git a/llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp b/llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp
index b00e8dc4424ab..cf92bdc281637 100644
--- a/llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp
+++ b/llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp
@@ -45,7 +45,7 @@ class AArch64SelectionDAGTest : public testing::Test {
TargetOptions Options;
TM = std::unique_ptr<TargetMachine>(
- T->createTargetMachine("AArch64", "", "+sve", Options, std::nullopt,
+ T->createTargetMachine(TargetTriple, "", "+sve", Options, std::nullopt,
std::nullopt, CodeGenOptLevel::Aggressive));
if (!TM)
GTEST_SKIP();
diff --git a/llvm/unittests/CodeGen/AMDGPUMetadataTest.cpp b/llvm/unittests/CodeGen/AMDGPUMetadataTest.cpp
index eb86f5dd88989..8165876e18a34 100644
--- a/llvm/unittests/CodeGen/AMDGPUMetadataTest.cpp
+++ b/llvm/unittests/CodeGen/AMDGPUMetadataTest.cpp
@@ -52,13 +52,14 @@ class AMDGPUSelectionDAGTest : public testing::Test {
void SetUp() override {
std::string Error;
- const Target *T = TargetRegistry::lookupTarget("amdgcn--amdpal", Error);
+ Triple TargetTriple("amdgcn--amdpal");
+ const Target *T = TargetRegistry::lookupTarget(TargetTriple, Error);
if (!T)
GTEST_SKIP();
TargetOptions Options;
TM = std::unique_ptr<TargetMachine>(T->createTargetMachine(
- "amdgcn--amdpal", "gfx1010", "", Options, std::nullopt));
+ TargetTriple, "gfx1010", "", Options, std::nullopt));
if (!TM)
GTEST_SKIP();
diff --git a/llvm/unittests/CodeGen/DroppedVariableStatsMIRTest.cpp b/llvm/unittests/CodeGen/DroppedVariableStatsMIRTest.cpp
index 6a890387f23c1..91f3d9ccbd655 100644
--- a/llvm/unittests/CodeGen/DroppedVariableStatsMIRTest.cpp
+++ b/llvm/unittests/CodeGen/DroppedVariableStatsMIRTest.cpp
@@ -33,8 +33,9 @@ using namespace llvm;
namespace {
std::unique_ptr<TargetMachine>
-createTargetMachine(std::string TT, StringRef CPU, StringRef FS) {
+createTargetMachine(std::string TargetStr, StringRef CPU, StringRef FS) {
std::string Error;
+ Triple TT(TargetStr);
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T)
return nullptr;
diff --git a/llvm/unittests/CodeGen/GlobalISel/GISelMITest.cpp b/llvm/unittests/CodeGen/GlobalISel/GISelMITest.cpp
index 15d2baa24b831..19b3161dd0313 100644
--- a/llvm/unittests/CodeGen/GlobalISel/GISelMITest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/GISelMITest.cpp
@@ -38,7 +38,7 @@ std::unique_ptr<TargetMachine> AArch64GISelMITest::createTargetMachine() const {
TargetOptions Options;
return std::unique_ptr<TargetMachine>(
- T->createTargetMachine("AArch64", "", "", Options, std::nullopt,
+ T->createTargetMachine(TargetTriple, "", "", Options, std::nullopt,
std::nullopt, CodeGenOptLevel::Aggressive));
}
@@ -74,9 +74,9 @@ std::unique_ptr<TargetMachine> AMDGPUGISelMITest::createTargetMachine() const {
return nullptr;
TargetOptions Options;
- return std::unique_ptr<TargetMachine>(T->createTargetMachine(
- "amdgcn-amd-amdhsa", "gfx900", "", Options, std::nullopt, std::nullopt,
- CodeGenOptLevel::Aggressive));
+ return std::unique_ptr<TargetMachine>(
+ T->createTargetMachine(TargetTriple, "gfx900", "", Options, std::nullopt,
+ std::nullopt, CodeGenOptLevel::Aggressive));
}
void AMDGPUGISelMITest::getTargetTestModuleString(
diff --git a/llvm/unittests/CodeGen/InstrRefLDVTest.cpp b/llvm/unittests/CodeGen/InstrRefLDVTest.cpp
index f943b48f6f4d3..53bc0246c126e 100644
--- a/llvm/unittests/CodeGen/InstrRefLDVTest.cpp
+++ b/llvm/unittests/CodeGen/InstrRefLDVTest.cpp
@@ -81,9 +81,9 @@ class InstrRefLDVTest : public testing::Test {
GTEST_SKIP();
TargetOptions Options;
- Machine = std::unique_ptr<TargetMachine>(T->createTargetMachine(
- Triple::normalize("x86_64--"), "", "", Options, std::nullopt,
- std::nullopt, CodeGenOptLevel::Aggressive));
+ Machine = std::unique_ptr<TargetMachine>(
+ T->createTargetMachine(TargetTriple, "", "", Options, std::nullopt,
+ std::nullopt, CodeGenOptLevel::Aggressive));
auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
auto F =
diff --git a/llvm/unittests/CodeGen/MachineDomTreeUpdaterTest.cpp b/llvm/unittests/CodeGen/MachineDomTreeUpdaterTest.cpp
index a60c8a2de02c0..85fdba0b3a9f7 100644
--- a/llvm/unittests/CodeGen/MachineDomTreeUpdaterTest.cpp
+++ b/llvm/unittests/CodeGen/MachineDomTreeUpdaterTest.cpp
@@ -57,7 +57,7 @@ class MachineDomTreeUpdaterTest : public testing::Test {
GTEST_SKIP();
TargetOptions Options;
TM = std::unique_ptr<TargetMachine>(
- T->createTargetMachine("X86", "", "", Options, std::nullopt));
+ T->createTargetMachine(TargetTriple, "", "", Options, std::nullopt));
if (!TM)
GTEST_SKIP();
MMI = std::make_unique<MachineModuleInfo>(TM.get());
@@ -116,7 +116,7 @@ body: |
successors: %bb.2, %bb.4
liveins: $rdi, $rsi
- %1:gr32 = COPY $rsi
+ %1:gr64 = COPY $rsi
%0:gr64 = COPY $rdi
MOV64mr %1, 1, $noreg, 0, $noreg, %0 :: (store (s64) into %ir.p)
%2:gr64 = SUB64ri32 %0, 1, implicit-def $eflags
@@ -206,7 +206,7 @@ body: |
successors: %bb.2, %bb.4
liveins: $rdi, $rsi
- %1:gr32 = COPY $rsi
+ %1:gr64 = COPY $rsi
%0:gr64 = COPY $rdi
MOV64mr %1, 1, $noreg, 0, $noreg, %0 :: (store (s64) into %ir.p)
%2:gr64 = SUB64ri32 %0, 1, implicit-def $eflags
diff --git a/llvm/unittests/CodeGen/PassManagerTest.cpp b/llvm/unittests/CodeGen/PassManagerTest.cpp
index 5e20c8db56fa8..ce0211e1f83c1 100644
--- a/llvm/unittests/CodeGen/PassManagerTest.cpp
+++ b/llvm/unittests/CodeGen/PassManagerTest.cpp
@@ -162,16 +162,14 @@ class PassManagerTest : public ::testing::Test {
// MachineModuleAnalysis needs a TargetMachine instance.
llvm::InitializeAllTargets();
- std::string TripleName = Triple::normalize(sys::getDefaultTargetTriple());
+ Triple TT(sys::getDefaultTargetTriple());
std::string Error;
- const Target *TheTarget =
- TargetRegistry::lookupTarget(TripleName, Error);
+ const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
if (!TheTarget)
return;
TargetOptions Options;
- TM.reset(TheTarget->createTargetMachine(TripleName, "", "", Options,
- std::nullopt));
+ TM.reset(TheTarget->createTargetMachine(TT, "", "", Options, std::nullopt));
}
};
diff --git a/llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp b/llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp
index 1958104720644..360fc9c8af842 100644
--- a/llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp
+++ b/llvm/unittests/CodeGen/SelectionDAGAddressAnalysisTest.cpp
@@ -48,7 +48,7 @@ class SelectionDAGAddressAnalysisTest : public testing::Test {
TargetOptions Options;
TM = std::unique_ptr<TargetMachine>(
- T->createTargetMachine("AArch64", "", "+sve", Options, std::nullopt,
+ T->createTargetMachine(TargetTriple, "", "+sve", Options, std::nullopt,
std::nullopt, CodeGenOptLevel::Aggressive));
if (!TM)
GTEST_SKIP();
diff --git a/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp b/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
index 736a36da97f57..51fec9b68b558 100644
--- a/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
+++ b/llvm/unittests/CodeGen/SelectionDAGPatternMatchTest.cpp
@@ -46,7 +46,7 @@ class SelectionDAGPatternMatchTest : public testing::Test {
TargetOptions Options;
TM = std::unique_ptr<TargetMachine>(T->createTargetMachine(
- "riscv64", "", "+m,+f,+d,+v", Options, std::nullopt, std::nullopt,
+ TargetTriple, "", "+m,+f,+d,+v", Options, std::nullopt, std::nullopt,
CodeGenOptLevel::Aggressive));
if (!TM)
GTEST_SKIP();
diff --git a/llvm/unittests/CodeGen/TargetOptionsTest.cpp b/llvm/unittests/CodeGen/TargetOptionsTest.cpp
index b8b6eaefceff9..ca6f294f7ac0a 100644
--- a/llvm/unittests/CodeGen/TargetOptionsTest.cpp
+++ b/llvm/unittests/CodeGen/TargetOptionsTest.cpp
@@ -39,8 +39,8 @@ std::unique_ptr<TargetMachine> createTargetMachine(bool EnableIPRA) {
TargetOptions Options;
Options.EnableIPRA = EnableIPRA;
return std::unique_ptr<TargetMachine>(
- T->createTargetMachine("X86", "", "", Options, std::nullopt, std::nullopt,
- CodeGenOptLevel::Aggressive));
+ T->createTargetMachine(TargetTriple, "", "", Options, std::nullopt,
+ std::nullopt, CodeGenOptLevel::Aggressive));
}
typedef std::function<void(bool)> TargetOptionsTest;
diff --git a/llvm/unittests/CodeGen/TestAsmPrinter.cpp b/llvm/unittests/CodeGen/TestAsmPrinter.cpp
index 861efa2691443..0c799ef901a0b 100644
--- a/llvm/unittests/CodeGen/TestAsmPrinter.cpp
+++ b/llvm/unittests/CodeGen/TestAsmPrinter.cpp
@@ -49,13 +49,13 @@ TestAsmPrinter::create(const std::string &TripleStr, uint16_t DwarfVersion,
llvm::Error TestAsmPrinter::init(const Target *TheTarget, StringRef TripleName,
uint16_t DwarfVersion,
dwarf::DwarfFormat DwarfFormat) {
- TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
+ Triple TheTriple(TripleName);
+ TM.reset(TheTarget->createTargetMachine(TheTriple, "", "", TargetOptions(),
std::nullopt));
if (!TM)
return make_error<StringError>("no target machine for target " + TripleName,
inconvertibleErrorCode());
- Triple TheTriple(TripleName);
MC.reset(new MCContext(TheTriple, TM->getMCAsmInfo(), TM->getMCRegisterInfo(),
TM->getMCSubtargetInfo()));
TM->getObjFileLowering()->Initialize(*MC, *TM);
diff --git a/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
index 2cbd4cc55df95..cf4a5f27585d0 100644
--- a/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
@@ -482,7 +482,7 @@ llvm::Error dwarfgen::Generator::init(Triple TheTriple, uint16_t V) {
TripleName,
inconvertibleErrorCode());
- TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
+ TM.reset(TheTarget->createTargetMachine(TheTriple, "", "", TargetOptions(),
std::nullopt));
if (!TM)
return make_error<StringError>("no target machine for target " + TripleName,
diff --git a/llvm/unittests/MC/AMDGPU/DwarfRegMappings.cpp b/llvm/unittests/MC/AMDGPU/DwarfRegMappings.cpp
index 259d68ed95b20..8236509fd0a47 100644
--- a/llvm/unittests/MC/AMDGPU/DwarfRegMappings.cpp
+++ b/llvm/unittests/MC/AMDGPU/DwarfRegMappings.cpp
@@ -32,13 +32,14 @@ createTargetMachine(std::string TStr, StringRef CPU, StringRef FS) {
InitializeAMDGPUTarget();
std::string Error;
- const Target *T = TargetRegistry::lookupTarget(TStr, Error);
+ Triple TT(TStr);
+ const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T)
return nullptr;
TargetOptions Options;
- return std::unique_ptr<TargetMachine>(T->createTargetMachine(
- TStr, CPU, FS, Options, std::nullopt, std::nullopt));
+ return std::unique_ptr<TargetMachine>(
+ T->createTargetMachine(TT, CPU, FS, Options, std::nullopt, std::nullopt));
}
TEST(AMDGPUDwarfRegMappingTests, TestWave64DwarfRegMapping) {
diff --git a/llvm/unittests/MI/LiveIntervalTest.cpp b/llvm/unittests/MI/LiveIntervalTest.cpp
index cd3307598de52..85a5085ece5fd 100644
--- a/llvm/unittests/MI/LiveIntervalTest.cpp
+++ b/llvm/unittests/MI/LiveIntervalTest.cpp
@@ -50,7 +50,7 @@ std::unique_ptr<TargetMachine> createTargetMachine() {
TargetOptions Options;
return std::unique_ptr<TargetMachine>(
- T->createTargetMachine("AMDGPU", "gfx900", "", Options, std::nullopt,
+ T->createTargetMachine(TargetTriple, "gfx900", "", Options, std::nullopt,
std::nullopt, CodeGenOptLevel::Aggressive));
}
diff --git a/llvm/unittests/MIR/MachineMetadata.cpp b/llvm/unittests/MIR/MachineMetadata.cpp
index 51204f23945c1..25025bdeec715 100644
--- a/llvm/unittests/MIR/MachineMetadata.cpp
+++ b/llvm/unittests/MIR/MachineMetadata.cpp
@@ -67,7 +67,8 @@ class MachineMetadataTest : public testing::Test {
}
std::unique_ptr<TargetMachine>
- createTargetMachine(std::string TT, StringRef CPU, StringRef FS) {
+ createTargetMachine(std::string TargetStr, StringRef CPU, StringRef FS) {
+ Triple TT(TargetStr);
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T)
diff --git a/llvm/unittests/MIR/MachineStableHashTest.cpp b/llvm/unittests/MIR/MachineStableHashTest.cpp
index 5ba391f0daf7a..ea0de1a73da62 100644
--- a/llvm/unittests/MIR/MachineStableHashTest.cpp
+++ b/llvm/unittests/MIR/MachineStableHashTest.cpp
@@ -38,8 +38,9 @@ class MachineStableHashTest : public testing::Test {
void SetUp() override { M = std::make_unique<Module>("Dummy", Context); }
std::unique_ptr<TargetMachine>
- createTargetMachine(std::string TT, StringRef CPU, StringRef FS) {
+ createTargetMachine(std::string TStr, StringRef CPU, StringRef FS) {
std::string Error;
+ Triple TT(TStr);
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T)
return nullptr;
diff --git a/llvm/unittests/Target/AArch64/AArch64RegisterInfoTest.cpp b/llvm/unittests/Target/AArch64/AArch64RegisterInfoTest.cpp
index 00e221eb43467..9efe97567331b 100644
--- a/llvm/unittests/Target/AArch64/AArch64RegisterInfoTest.cpp
+++ b/llvm/unittests/Target/AArch64/AArch64RegisterInfoTest.cpp
@@ -19,7 +19,7 @@ using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine(const std::string &CPU) {
- auto TT(Triple::normalize("aarch64--"));
+ Triple TT("aarch64--");
LLVMInitializeAArch64TargetInfo();
LLVMInitializeAArch64Target();
diff --git a/llvm/unittests/Target/AArch64/AArch64SVESchedPseudoTest.cpp b/llvm/unittests/Target/AArch64/AArch64SVESchedPseudoTest.cpp
index 5dd03ac07334a..ac34ff785f9a9 100644
--- a/llvm/unittests/Target/AArch64/AArch64SVESchedPseudoTest.cpp
+++ b/llvm/unittests/Target/AArch64/AArch64SVESchedPseudoTest.cpp
@@ -16,7 +16,7 @@
using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine(const std::string &CPU) {
- auto TT(Triple::normalize("aarch64--"));
+ Triple TT("aarch64--");
LLVMInitializeAArch64TargetInfo();
LLVMInitializeAArch64Target();
diff --git a/llvm/unittests/Target/AArch64/AddressingModes.cpp b/llvm/unittests/Target/AArch64/AddressingModes.cpp
index 0af18d886791a..46ab7dd02160b 100644
--- a/llvm/unittests/Target/AArch64/AddressingModes.cpp
+++ b/llvm/unittests/Target/AArch64/AddressingModes.cpp
@@ -202,7 +202,7 @@ TEST(AddressingModes, AddressingModes) {
LLVMInitializeAArch64TargetMC();
std::string Error;
- auto TT = Triple::normalize("aarch64");
+ Triple TT("aarch64");
const Target *T = TargetRegistry::lookupTarget(TT, Error);
std::unique_ptr<TargetMachine> TM(
diff --git a/llvm/unittests/Target/AArch64/Immediates.cpp b/llvm/unittests/Target/AArch64/Immediates.cpp
index a4551b083b440..b8424104ed383 100644
--- a/llvm/unittests/Target/AArch64/Immediates.cpp
+++ b/llvm/unittests/Target/AArch64/Immediates.cpp
@@ -88,7 +88,7 @@ TEST(Immediates, Immediates) {
LLVMInitializeAArch64TargetMC();
std::string Error;
- auto TT = Triple::normalize("aarch64");
+ Triple TT("aarch64");
const Target *T = TargetRegistry::lookupTarget(TT, Error);
std::unique_ptr<TargetMachine> TM(T->createTargetMachine(
diff --git a/llvm/unittests/Target/AArch64/InstSizes.cpp b/llvm/unittests/Target/AArch64/InstSizes.cpp
index fc21fbdd2d5d4..c9faee80e7e49 100644
--- a/llvm/unittests/Target/AArch64/InstSizes.cpp
+++ b/llvm/unittests/Target/AArch64/InstSizes.cpp
@@ -13,7 +13,7 @@ using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine() {
- auto TT(Triple::normalize("aarch64--"));
+ Triple TT("aarch64--");
std::string CPU("generic");
std::string FS("+pauth,+mops,+mte");
diff --git a/llvm/unittests/Target/AArch64/MatrixRegisterAliasing.cpp b/llvm/unittests/Target/AArch64/MatrixRegisterAliasing.cpp
index d5823660cf8cc..b864e9c3ec02d 100644
--- a/llvm/unittests/Target/AArch64/MatrixRegisterAliasing.cpp
+++ b/llvm/unittests/Target/AArch64/MatrixRegisterAliasing.cpp
@@ -8,7 +8,7 @@ using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine() {
- auto TT(Triple::normalize("aarch64--"));
+ Triple TT("aarch64--");
std::string CPU("generic");
std::string FS("+sme");
diff --git a/llvm/unittests/Target/AMDGPU/AMDGPUUnitTests.cpp b/llvm/unittests/Target/AMDGPU/AMDGPUUnitTests.cpp
index 8fbd470815b79..e22cfb1769561 100644
--- a/llvm/unittests/Target/AMDGPU/AMDGPUUnitTests.cpp
+++ b/llvm/unittests/Target/AMDGPU/AMDGPUUnitTests.cpp
@@ -32,15 +32,16 @@ std::unique_ptr<const GCNTargetMachine>
llvm::createAMDGPUTargetMachine(std::string TStr, StringRef CPU, StringRef FS) {
InitializeAMDGPUTarget();
+ Triple TT(TStr);
std::string Error;
- const Target *T = TargetRegistry::lookupTarget(TStr, Error);
+ const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T)
return nullptr;
TargetOptions Options;
return std::unique_ptr<GCNTargetMachine>(
static_cast<GCNTargetMachine *>(T->createTargetMachine(
- TStr, CPU, FS, Options, std::nullopt, std::nullopt)));
+ TT, CPU, FS, Options, std::nullopt, std::nullopt)));
}
static cl::opt<bool> PrintCpuRegLimits(
diff --git a/llvm/unittests/Target/AMDGPU/PALMetadata.cpp b/llvm/unittests/Target/AMDGPU/PALMetadata.cpp
index 86aa4753a2123..e9392195fcc01 100644
--- a/llvm/unittests/Target/AMDGPU/PALMetadata.cpp
+++ b/llvm/unittests/Target/AMDGPU/PALMetadata.cpp
@@ -40,16 +40,16 @@ class PALMetadata : public testing::Test {
}
PALMetadata() {
- StringRef Triple = "amdgcn--amdpal";
+ Triple TT("amdgcn--amdpal");
StringRef CPU = "gfx1010";
StringRef FS = "";
std::string Error;
- const Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
+ const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
TargetOptions Options;
TM.reset(static_cast<GCNTargetMachine *>(TheTarget->createTargetMachine(
- Triple, CPU, FS, Options, std::nullopt, std::nullopt)));
+ TT, CPU, FS, Options, std::nullopt, std::nullopt)));
Ctx = std::make_unique<LLVMContext>();
M = std::make_unique<Module>("Module", *Ctx);
diff --git a/llvm/unittests/Target/ARM/InstSizes.cpp b/llvm/unittests/Target/ARM/InstSizes.cpp
index 56ebfed11bdcd..ba4e0501e4f72 100644
--- a/llvm/unittests/Target/ARM/InstSizes.cpp
+++ b/llvm/unittests/Target/ARM/InstSizes.cpp
@@ -73,7 +73,7 @@ TEST(InstSizes, PseudoInst) {
LLVMInitializeARMTarget();
LLVMInitializeARMTargetMC();
- auto TT(Triple::normalize("thumbv8.1m.main-none-none-eabi"));
+ Triple TT("thumbv8.1m.main-none-none-eabi");
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T) {
diff --git a/llvm/unittests/Target/ARM/MachineInstrTest.cpp b/llvm/unittests/Target/ARM/MachineInstrTest.cpp
index 9d844b3bfaa3c..1b0775a921d59 100644
--- a/llvm/unittests/Target/ARM/MachineInstrTest.cpp
+++ b/llvm/unittests/Target/ARM/MachineInstrTest.cpp
@@ -74,7 +74,7 @@ TEST(MachineInstructionDoubleWidthResult, IsCorrect) {
LLVMInitializeARMTarget();
LLVMInitializeARMTargetMC();
- auto TT(Triple::normalize("thumbv8.1m.main-none-none-eabi"));
+ Triple TT("thumbv8.1m.main-none-none-eabi");
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T) {
@@ -230,7 +230,7 @@ TEST(MachineInstructionHorizontalReduction, IsCorrect) {
LLVMInitializeARMTarget();
LLVMInitializeARMTargetMC();
- auto TT(Triple::normalize("thumbv8.1m.main-none-none-eabi"));
+ Triple TT("thumbv8.1m.main-none-none-eabi");
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T) {
@@ -329,7 +329,7 @@ TEST(MachineInstructionRetainsPreviousHalfElement, IsCorrect) {
LLVMInitializeARMTarget();
LLVMInitializeARMTargetMC();
- auto TT(Triple::normalize("thumbv8.1m.main-none-none-eabi"));
+ Triple TT("thumbv8.1m.main-none-none-eabi");
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T) {
@@ -1035,7 +1035,7 @@ TEST(MachineInstrValidTailPredication, IsCorrect) {
LLVMInitializeARMTarget();
LLVMInitializeARMTargetMC();
- auto TT(Triple::normalize("thumbv8.1m.main-none-none-eabi"));
+ Triple TT("thumbv8.1m.main-none-none-eabi");
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T) {
@@ -1178,7 +1178,7 @@ TEST(MachineInstr, HasSideEffects) {
LLVMInitializeARMTarget();
LLVMInitializeARMTargetMC();
- auto TT(Triple::normalize("thumbv8.1m.main-none-none-eabi"));
+ Triple TT("thumbv8.1m.main-none-none-eabi");
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T) {
@@ -2058,7 +2058,7 @@ TEST(MachineInstr, MVEVecSize) {
LLVMInitializeARMTarget();
LLVMInitializeARMTargetMC();
- auto TT(Triple::normalize("thumbv8.1m.main-none-none-eabi"));
+ Triple TT("thumbv8.1m.main-none-none-eabi");
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T) {
diff --git a/llvm/unittests/Target/LoongArch/InstSizes.cpp b/llvm/unittests/Target/LoongArch/InstSizes.cpp
index cff0eb6c04ca4..0ff82974620ab 100644
--- a/llvm/unittests/Target/LoongArch/InstSizes.cpp
+++ b/llvm/unittests/Target/LoongArch/InstSizes.cpp
@@ -14,7 +14,7 @@ using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine() {
- auto TT(Triple::normalize("loongarch64--"));
+ Triple TT("loongarch64--");
std::string CPU("generic-la64");
std::string FS("+64bit");
diff --git a/llvm/unittests/Target/PowerPC/AIXRelocModelTest.cpp b/llvm/unittests/Target/PowerPC/AIXRelocModelTest.cpp
index 6df0e3ac655da..03e81ae0fb9a5 100644
--- a/llvm/unittests/Target/PowerPC/AIXRelocModelTest.cpp
+++ b/llvm/unittests/Target/PowerPC/AIXRelocModelTest.cpp
@@ -27,7 +27,7 @@ TEST_F(AIXRelocModelTest, DefalutToPIC) {
// Create a TargetMachine for powerpc--aix target, and deliberately leave its
// relocation model unset.
std::unique_ptr<TargetMachine> Target(TheTarget->createTargetMachine(
- /*TT*/ TheTriple.getTriple(), /*CPU*/ "", /*Features*/ "",
+ /*TT*/ TheTriple, /*CPU*/ "", /*Features*/ "",
/*Options*/ Options, /*RM*/ std::nullopt, /*CM*/ std::nullopt,
/*OL*/ CodeGenOptLevel::Default));
ASSERT_TRUE(Target) << "Could not allocate target machine!";
diff --git a/llvm/unittests/Target/RISCV/RISCVInstrInfoTest.cpp b/llvm/unittests/Target/RISCV/RISCVInstrInfoTest.cpp
index 38675a6461b3b..f7351f00ae282 100644
--- a/llvm/unittests/Target/RISCV/RISCVInstrInfoTest.cpp
+++ b/llvm/unittests/Target/RISCV/RISCVInstrInfoTest.cpp
@@ -43,7 +43,7 @@ class RISCVInstrInfoTest : public testing::TestWithParam<const char *> {
RISCVInstrInfoTest() {
std::string Error;
- auto TT(Triple::normalize(GetParam()));
+ Triple TT(GetParam());
const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
TargetOptions Options;
diff --git a/llvm/unittests/Target/VE/MachineInstrTest.cpp b/llvm/unittests/Target/VE/MachineInstrTest.cpp
index d8e7cc7b60112..5ad0e60bb2653 100644
--- a/llvm/unittests/Target/VE/MachineInstrTest.cpp
+++ b/llvm/unittests/Target/VE/MachineInstrTest.cpp
@@ -281,7 +281,7 @@ TEST(VETest, VLIndex) {
LLVMInitializeVETarget();
LLVMInitializeVETargetMC();
- auto TT(Triple::normalize("ve-unknown-linux-gnu"));
+ Triple TT("ve-unknown-linux-gnu");
std::string Error;
const Target *T = TargetRegistry::lookupTarget(TT, Error);
if (!T) {
diff --git a/llvm/unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp b/llvm/unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp
index 223a5714f62f2..d7f2908bb079b 100644
--- a/llvm/unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp
+++ b/llvm/unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp
@@ -23,7 +23,7 @@ using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine() {
- auto TT(Triple::normalize("wasm32-unknown-unknown"));
+ Triple TT("wasm32-unknown-unknown");
std::string CPU;
std::string FS;
diff --git a/llvm/unittests/Target/X86/MachineSizeOptsTest.cpp b/llvm/unittests/Target/X86/MachineSizeOptsTest.cpp
index f18df9d02db02..fcc28ab4afd96 100644
--- a/llvm/unittests/Target/X86/MachineSizeOptsTest.cpp
+++ b/llvm/unittests/Target/X86/MachineSizeOptsTest.cpp
@@ -29,7 +29,7 @@ using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine() {
- auto TT(Triple::normalize("x86_64--"));
+ Triple TT("x86_64--");
std::string Error;
const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
return std::unique_ptr<TargetMachine>(
diff --git a/llvm/unittests/Target/X86/TernlogTest.cpp b/llvm/unittests/Target/X86/TernlogTest.cpp
index edb4431a05a68..86a2797a425c0 100644
--- a/llvm/unittests/Target/X86/TernlogTest.cpp
+++ b/llvm/unittests/Target/X86/TernlogTest.cpp
@@ -25,7 +25,7 @@ static std::unique_ptr<TargetMachine> initTM() {
LLVMInitializeX86Target();
LLVMInitializeX86TargetMC();
- auto TT(Triple::normalize("x86_64--"));
+ Triple TT("x86_64--");
std::string Error;
const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
return std::unique_ptr<TargetMachine>(
diff --git a/llvm/unittests/tools/llvm-exegesis/Common/AssemblerUtils.h b/llvm/unittests/tools/llvm-exegesis/Common/AssemblerUtils.h
index 985f6f802e4ad..0b489c5343246 100644
--- a/llvm/unittests/tools/llvm-exegesis/Common/AssemblerUtils.h
+++ b/llvm/unittests/tools/llvm-exegesis/Common/AssemblerUtils.h
@@ -29,16 +29,15 @@ namespace exegesis {
class MachineFunctionGeneratorBaseTest : public ::testing::Test {
protected:
- MachineFunctionGeneratorBaseTest(const std::string &TT,
+ MachineFunctionGeneratorBaseTest(const std::string &TargetStr,
const std::string &CpuName)
- : TT(TT), CpuName(CpuName),
- CanExecute(Triple(TT).getArch() ==
- Triple(sys::getProcessTriple()).getArch()),
- ET(ExegesisTarget::lookup(Triple(TT))) {
+ : TT(TargetStr), CpuName(CpuName),
+ CanExecute(TT.getArch() == Triple(sys::getProcessTriple()).getArch()),
+ ET(ExegesisTarget::lookup(TT)) {
assert(ET);
if (!CanExecute) {
outs() << "Skipping execution, host:" << sys::getProcessTriple()
- << ", target:" << TT << "\n";
+ << ", target:" << TT.str() << "\n";
}
}
@@ -64,11 +63,11 @@ class MachineFunctionGeneratorBaseTest : public ::testing::Test {
std::unique_ptr<TargetMachine> createTargetMachine() {
std::string Error;
const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
- EXPECT_TRUE(TheTarget) << Error << " " << TT;
+ EXPECT_TRUE(TheTarget) << Error << " " << TT.str();
const TargetOptions Options;
TargetMachine *TM = TheTarget->createTargetMachine(TT, CpuName, "", Options,
Reloc::Model::Static);
- EXPECT_TRUE(TM) << TT << " " << CpuName;
+ EXPECT_TRUE(TM) << TT.str() << " " << CpuName;
return std::unique_ptr<TargetMachine>(TM);
}
@@ -90,7 +89,7 @@ class MachineFunctionGeneratorBaseTest : public ::testing::Test {
return std::move(*ExecFunc);
}
- const std::string TT;
+ const Triple TT;
const std::string CpuName;
const bool CanExecute;
const ExegesisTarget *const ET;
diff --git a/mlir/lib/Target/LLVM/ModuleToObject.cpp b/mlir/lib/Target/LLVM/ModuleToObject.cpp
index 7f90167cd5563..04e870acfc5fa 100644
--- a/mlir/lib/Target/LLVM/ModuleToObject.cpp
+++ b/mlir/lib/Target/LLVM/ModuleToObject.cpp
@@ -68,8 +68,8 @@ ModuleToObject::getOrCreateTargetMachine() {
}
// Create the target machine using the target.
- targetMachine.reset(
- target->createTargetMachine(triple, chip, features, {}, {}));
+ targetMachine.reset(target->createTargetMachine(llvm::Triple(triple), chip,
+ features, {}, {}));
if (!targetMachine)
return std::nullopt;
return targetMachine.get();
diff --git a/offload/plugins-nextgen/common/src/JIT.cpp b/offload/plugins-nextgen/common/src/JIT.cpp
index af5935b639a02..affedb1a33687 100644
--- a/offload/plugins-nextgen/common/src/JIT.cpp
+++ b/offload/plugins-nextgen/common/src/JIT.cpp
@@ -114,9 +114,9 @@ createTargetMachine(Module &M, std::string CPU, unsigned OptLevel) {
TargetOptions Options = codegen::InitTargetOptionsFromCodeGenFlags(TT);
- std::unique_ptr<TargetMachine> TM(T->createTargetMachine(
- M.getTargetTriple().str(), CPU, Features.getString(), Options, RelocModel,
- CodeModel, CGOptLevel));
+ std::unique_ptr<TargetMachine> TM(
+ T->createTargetMachine(M.getTargetTriple(), CPU, Features.getString(),
+ Options, RelocModel, CodeModel, CGOptLevel));
if (!TM)
return make_error<StringError>("Failed to create target machine",
inconvertibleErrorCode());
More information about the cfe-commits
mailing list