Skip to content

Commit f137c3d

Browse files
nikicnikic
authored
[TargetRegistry] Accept Triple in createTargetMachine() (NFC) (llvm#130940)
This avoids doing a Triple -> std::string -> Triple round trip in lots of places, now that the Module stores a Triple.
1 parent 71582c6 commit f137c3d

File tree

62 files changed

+134
-120
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

62 files changed

+134
-120
lines changed

‎bolt/lib/Passes/AsmDump.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -143,7 +143,7 @@ void dumpFunction(const BinaryFunction &BF) {
143143
std::move(MCEInstance.MCE), std::move(MAB)));
144144
AsmStreamer->initSections(true, *BC.STI);
145145
std::unique_ptr<TargetMachine> TM(BC.TheTarget->createTargetMachine(
146-
BC.TripleName, "", "", TargetOptions(), std::nullopt));
146+
*BC.TheTriple, "", "", TargetOptions(), std::nullopt));
147147
std::unique_ptr<AsmPrinter> MAP(
148148
BC.TheTarget->createAsmPrinter(*TM, std::move(AsmStreamer)));
149149

‎clang/lib/CodeGen/BackendUtil.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -595,7 +595,7 @@ static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts) {
595595
void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
596596
// Create the TargetMachine for generating code.
597597
std::string Error;
598-
std::string Triple = TheModule->getTargetTriple().str();
598+
const llvm::Triple &Triple = TheModule->getTargetTriple();
599599
const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
600600
if (!TheTarget) {
601601
if (MustCreateTM)

‎clang/lib/Interpreter/DeviceOffload.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,7 @@ llvm::Expected<llvm::StringRef> IncrementalCUDADeviceParser::GeneratePTX() {
8383
std::error_code());
8484
llvm::TargetOptions TO = llvm::TargetOptions();
8585
llvm::TargetMachine *TargetMachine = Target->createTargetMachine(
86-
PTU.TheModule->getTargetTriple().str(), TargetOpts.CPU, "", TO,
86+
PTU.TheModule->getTargetTriple(), TargetOpts.CPU, "", TO,
8787
llvm::Reloc::Model::PIC_);
8888
PTU.TheModule->setDataLayout(TargetMachine->createDataLayout());
8989

‎clang/lib/Interpreter/Wasm.cpp

+2-3
Original file line numberDiff line numberDiff line change
@@ -73,9 +73,8 @@ llvm::Error WasmIncrementalExecutor::addModule(PartialTranslationUnit &PTU) {
7373
}
7474

7575
llvm::TargetOptions TO = llvm::TargetOptions();
76-
llvm::TargetMachine *TargetMachine =
77-
Target->createTargetMachine(PTU.TheModule->getTargetTriple().str(), "",
78-
"", TO, llvm::Reloc::Model::PIC_);
76+
llvm::TargetMachine *TargetMachine = Target->createTargetMachine(
77+
PTU.TheModule->getTargetTriple(), "", "", TO, llvm::Reloc::Model::PIC_);
7978
PTU.TheModule->setDataLayout(TargetMachine->createDataLayout());
8079
std::string ObjectFileName = PTU.TheModule->getName().str() + ".o";
8180
std::string BinaryFileName = PTU.TheModule->getName().str() + ".wasm";

‎clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -127,8 +127,8 @@ static std::string OptLLVM(const std::string &IR, CodeGenOptLevel OLvl) {
127127
ErrorAndExit(E);
128128

129129
std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
130-
M->getTargetTriple().str(), codegen::getCPUStr(),
131-
codegen::getFeaturesStr(), Options, codegen::getExplicitRelocModel(),
130+
M->getTargetTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
131+
Options, codegen::getExplicitRelocModel(),
132132
codegen::getExplicitCodeModel(), OLvl));
133133
if (!TM)
134134
ErrorAndExit("Could not create target machine");

‎clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -637,7 +637,7 @@ Expected<StringRef> compileModule(Module &M, OffloadKind Kind) {
637637
StringRef CPU = "";
638638
StringRef Features = "";
639639
std::unique_ptr<TargetMachine> TM(
640-
T->createTargetMachine(M.getTargetTriple().str(), CPU, Features, Options,
640+
T->createTargetMachine(M.getTargetTriple(), CPU, Features, Options,
641641
Reloc::PIC_, M.getCodeModel()));
642642

643643
if (M.getDataLayout().isDefault())

‎clang/tools/driver/cc1_main.cpp

+10-6
Original file line numberDiff line numberDiff line change
@@ -111,9 +111,10 @@ static void ensureSufficientStack() {}
111111

112112
/// Print supported cpus of the given target.
113113
static int PrintSupportedCPUs(std::string TargetStr) {
114+
llvm::Triple Triple(TargetStr);
114115
std::string Error;
115116
const llvm::Target *TheTarget =
116-
llvm::TargetRegistry::lookupTarget(TargetStr, Error);
117+
llvm::TargetRegistry::lookupTarget(Triple, Error);
117118
if (!TheTarget) {
118119
llvm::errs() << Error;
119120
return 1;
@@ -122,23 +123,24 @@ static int PrintSupportedCPUs(std::string TargetStr) {
122123
// the target machine will handle the mcpu printing
123124
llvm::TargetOptions Options;
124125
std::unique_ptr<llvm::TargetMachine> TheTargetMachine(
125-
TheTarget->createTargetMachine(TargetStr, "", "+cpuhelp", Options,
126+
TheTarget->createTargetMachine(Triple, "", "+cpuhelp", Options,
126127
std::nullopt));
127128
return 0;
128129
}
129130

130131
static int PrintSupportedExtensions(std::string TargetStr) {
132+
llvm::Triple Triple(TargetStr);
131133
std::string Error;
132134
const llvm::Target *TheTarget =
133-
llvm::TargetRegistry::lookupTarget(TargetStr, Error);
135+
llvm::TargetRegistry::lookupTarget(Triple, Error);
134136
if (!TheTarget) {
135137
llvm::errs() << Error;
136138
return 1;
137139
}
138140

139141
llvm::TargetOptions Options;
140142
std::unique_ptr<llvm::TargetMachine> TheTargetMachine(
141-
TheTarget->createTargetMachine(TargetStr, "", "", Options, std::nullopt));
143+
TheTarget->createTargetMachine(Triple, "", "", Options, std::nullopt));
142144
const llvm::Triple &MachineTriple = TheTargetMachine->getTargetTriple();
143145
const llvm::MCSubtargetInfo *MCInfo = TheTargetMachine->getMCSubtargetInfo();
144146
const llvm::ArrayRef<llvm::SubtargetFeatureKV> Features =
@@ -165,9 +167,10 @@ static int PrintSupportedExtensions(std::string TargetStr) {
165167
}
166168

167169
static int PrintEnabledExtensions(const TargetOptions& TargetOpts) {
170+
llvm::Triple Triple(TargetOpts.Triple);
168171
std::string Error;
169172
const llvm::Target *TheTarget =
170-
llvm::TargetRegistry::lookupTarget(TargetOpts.Triple, Error);
173+
llvm::TargetRegistry::lookupTarget(Triple, Error);
171174
if (!TheTarget) {
172175
llvm::errs() << Error;
173176
return 1;
@@ -179,7 +182,8 @@ static int PrintEnabledExtensions(const TargetOptions& TargetOpts) {
179182
llvm::TargetOptions BackendOptions;
180183
std::string FeaturesStr = llvm::join(TargetOpts.FeaturesAsWritten, ",");
181184
std::unique_ptr<llvm::TargetMachine> TheTargetMachine(
182-
TheTarget->createTargetMachine(TargetOpts.Triple, TargetOpts.CPU, FeaturesStr, BackendOptions, std::nullopt));
185+
TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
186+
BackendOptions, std::nullopt));
183187
const llvm::Triple &MachineTriple = TheTargetMachine->getTargetTriple();
184188
const llvm::MCSubtargetInfo *MCInfo = TheTargetMachine->getMCSubtargetInfo();
185189

‎flang/tools/bbc/bbc.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -280,7 +280,7 @@ createTargetMachine(llvm::StringRef targetTriple, std::string &error) {
280280
if (!theTarget)
281281
return nullptr;
282282
return std::unique_ptr<llvm::TargetMachine>{
283-
theTarget->createTargetMachine(triple, /*CPU=*/"",
283+
theTarget->createTargetMachine(llvm::Triple(triple), /*CPU=*/"",
284284
/*Features=*/"", llvm::TargetOptions(),
285285
/*Reloc::Model=*/std::nullopt)};
286286
}

‎flang/tools/flang-driver/fc1_main.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -45,8 +45,8 @@ static int printSupportedCPUs(llvm::StringRef triple) {
4545
// the target machine will handle the mcpu printing
4646
llvm::TargetOptions targetOpts;
4747
std::unique_ptr<llvm::TargetMachine> targetMachine(
48-
target->createTargetMachine(triple, "", "+cpuhelp", targetOpts,
49-
std::nullopt));
48+
target->createTargetMachine(llvm::Triple(triple), "", "+cpuhelp",
49+
targetOpts, std::nullopt));
5050
return 0;
5151
}
5252

‎llvm/examples/Kaleidoscope/Chapter8/toy.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -1243,7 +1243,7 @@ int main() {
12431243

12441244
TargetOptions opt;
12451245
auto TheTargetMachine = Target->createTargetMachine(
1246-
TargetTriple, CPU, Features, opt, Reloc::PIC_);
1246+
Triple(TargetTriple), CPU, Features, opt, Reloc::PIC_);
12471247

12481248
TheModule->setDataLayout(TheTargetMachine->createDataLayout());
12491249

‎llvm/include/llvm/MC/TargetRegistry.h

+13-3
Original file line numberDiff line numberDiff line change
@@ -453,14 +453,24 @@ class Target {
453453
/// either the target triple from the module, or the target triple of the
454454
/// host if that does not exist.
455455
TargetMachine *createTargetMachine(
456-
StringRef TT, StringRef CPU, StringRef Features,
456+
const Triple &TT, StringRef CPU, StringRef Features,
457457
const TargetOptions &Options, std::optional<Reloc::Model> RM,
458458
std::optional<CodeModel::Model> CM = std::nullopt,
459459
CodeGenOptLevel OL = CodeGenOptLevel::Default, bool JIT = false) const {
460460
if (!TargetMachineCtorFn)
461461
return nullptr;
462-
return TargetMachineCtorFn(*this, Triple(TT), CPU, Features, Options, RM,
463-
CM, OL, JIT);
462+
return TargetMachineCtorFn(*this, TT, CPU, Features, Options, RM, CM, OL,
463+
JIT);
464+
}
465+
466+
[[deprecated("Use overload accepting Triple instead")]]
467+
TargetMachine *createTargetMachine(
468+
StringRef TT, StringRef CPU, StringRef Features,
469+
const TargetOptions &Options, std::optional<Reloc::Model> RM,
470+
std::optional<CodeModel::Model> CM = std::nullopt,
471+
CodeGenOptLevel OL = CodeGenOptLevel::Default, bool JIT = false) const {
472+
return createTargetMachine(Triple(TT), CPU, Features, Options, RM, CM, OL,
473+
JIT);
464474
}
465475

466476
/// createMCAsmBackend - Create a target specific assembly parser.

‎llvm/lib/CodeGen/CommandFlags.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -764,7 +764,7 @@ codegen::createTargetMachineForTriple(StringRef TargetTriple,
764764
if (!TheTarget)
765765
return createStringError(inconvertibleErrorCode(), Error);
766766
auto *Target = TheTarget->createTargetMachine(
767-
TheTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
767+
TheTriple, codegen::getCPUStr(), codegen::getFeaturesStr(),
768768
codegen::InitTargetOptionsFromCodeGenFlags(TheTriple),
769769
codegen::getExplicitRelocModel(), codegen::getExplicitCodeModel(),
770770
OptLevel);

‎llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,7 @@ Error DwarfStreamer::init(Triple TheTriple,
123123
TripleName.c_str());
124124

125125
// Finally create the AsmPrinter we'll use to emit the DIEs.
126-
TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
126+
TM.reset(TheTarget->createTargetMachine(TheTriple, "", "", TargetOptions(),
127127
std::nullopt));
128128
if (!TM)
129129
return createStringError(std::errc::invalid_argument,

‎llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -102,7 +102,7 @@ Error DwarfEmitterImpl::init(Triple TheTriple,
102102
TripleName.c_str());
103103

104104
// Finally create the AsmPrinter we'll use to emit the DIEs.
105-
TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
105+
TM.reset(TheTarget->createTargetMachine(TheTriple, "", "", TargetOptions(),
106106
std::nullopt));
107107
if (!TM)
108108
return createStringError(std::errc::invalid_argument,

‎llvm/lib/ExecutionEngine/Orc/JITTargetMachineBuilder.cpp

+2-3
Original file line numberDiff line numberDiff line change
@@ -47,9 +47,8 @@ JITTargetMachineBuilder::createTargetMachine() {
4747
return make_error<StringError>("Target has no JIT support",
4848
inconvertibleErrorCode());
4949

50-
auto *TM =
51-
TheTarget->createTargetMachine(TT.getTriple(), CPU, Features.getString(),
52-
Options, RM, CM, OptLevel, /*JIT*/ true);
50+
auto *TM = TheTarget->createTargetMachine(
51+
TT, CPU, Features.getString(), Options, RM, CM, OptLevel, /*JIT=*/true);
5352
if (!TM)
5453
return make_error<StringError>("Could not allocate target machine",
5554
inconvertibleErrorCode());

‎llvm/lib/ExecutionEngine/TargetSelect.cpp

+3-4
Original file line numberDiff line numberDiff line change
@@ -84,10 +84,9 @@ TargetMachine *EngineBuilder::selectTarget(const Triple &TargetTriple,
8484
}
8585

8686
// Allocate a target...
87-
TargetMachine *Target =
88-
TheTarget->createTargetMachine(TheTriple.getTriple(), MCPU, FeaturesStr,
89-
Options, RelocModel, CMModel, OptLevel,
90-
/*JIT*/ true);
87+
TargetMachine *Target = TheTarget->createTargetMachine(
88+
TheTriple, MCPU, FeaturesStr, Options, RelocModel, CMModel, OptLevel,
89+
/*JIT=*/true);
9190
Target->Options.EmulatedTLS = EmulatedTLS;
9291

9392
assert(Target && "Could not allocate target machine!");

‎llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -5505,7 +5505,7 @@ createTargetMachine(Function *F, CodeGenOptLevel OptLevel) {
55055505

55065506
StringRef CPU = F->getFnAttribute("target-cpu").getValueAsString();
55075507
StringRef Features = F->getFnAttribute("target-features").getValueAsString();
5508-
const std::string &Triple = M->getTargetTriple().str();
5508+
const llvm::Triple &Triple = M->getTargetTriple();
55095509

55105510
std::string Error;
55115511
const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);

‎llvm/lib/LTO/LTOBackend.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -227,7 +227,7 @@ createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M) {
227227
}
228228

229229
std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine(
230-
TheTriple.str(), Conf.CPU, Features.getString(), TargetOpts, RelocModel,
230+
TheTriple, Conf.CPU, Features.getString(), TargetOpts, RelocModel,
231231
CodeModel, Conf.CGOptLevel));
232232

233233
assert(TM && "Failed to create target machine");

‎llvm/lib/LTO/LTOCodeGenerator.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -420,8 +420,8 @@ bool LTOCodeGenerator::determineTarget() {
420420
std::unique_ptr<TargetMachine> LTOCodeGenerator::createTargetMachine() {
421421
assert(MArch && "MArch is not set!");
422422
return std::unique_ptr<TargetMachine>(MArch->createTargetMachine(
423-
TripleStr, Config.CPU, FeatureStr, Config.Options, Config.RelocModel,
424-
std::nullopt, Config.CGOptLevel));
423+
Triple(TripleStr), Config.CPU, FeatureStr, Config.Options,
424+
Config.RelocModel, std::nullopt, Config.CGOptLevel));
425425
}
426426

427427
// If a linkonce global is present in the MustPreserveSymbols, we need to make

‎llvm/lib/LTO/LTOModule.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -228,8 +228,8 @@ LTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
228228
CPU = "cyclone";
229229
}
230230

231-
TargetMachine *target = march->createTargetMachine(
232-
Triple.str(), CPU, FeatureStr, options, std::nullopt);
231+
TargetMachine *target = march->createTargetMachine(Triple, CPU, FeatureStr,
232+
options, std::nullopt);
233233

234234
std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target));
235235
Ret->parseSymbols();

‎llvm/lib/LTO/ThinLTOCodeGenerator.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -588,7 +588,7 @@ std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const {
588588
std::string FeatureStr = Features.getString();
589589

590590
std::unique_ptr<TargetMachine> TM(
591-
TheTarget->createTargetMachine(TheTriple.str(), MCpu, FeatureStr, Options,
591+
TheTarget->createTargetMachine(TheTriple, MCpu, FeatureStr, Options,
592592
RelocModel, std::nullopt, CGOptLevel));
593593
assert(TM && "Cannot create target machine");
594594

‎llvm/lib/Target/SPIRV/SPIRVAPI.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -94,7 +94,7 @@ SPIRVTranslate(Module *M, std::string &SpirvObj, std::string &ErrMsg,
9494
std::optional<Reloc::Model> RM;
9595
std::optional<CodeModel::Model> CM;
9696
std::unique_ptr<TargetMachine> Target(TheTarget->createTargetMachine(
97-
TargetTriple.getTriple(), "", "", Options, RM, CM, OLevel));
97+
TargetTriple, "", "", Options, RM, CM, OLevel));
9898
if (!Target) {
9999
ErrMsg = "Could not allocate target machine!";
100100
return false;

‎llvm/lib/Target/TargetMachineC.cpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -197,14 +197,14 @@ void LLVMTargetMachineOptionsSetCodeModel(LLVMTargetMachineOptionsRef Options,
197197
}
198198

199199
LLVMTargetMachineRef
200-
LLVMCreateTargetMachineWithOptions(LLVMTargetRef T, const char *Triple,
200+
LLVMCreateTargetMachineWithOptions(LLVMTargetRef T, const char *TripleStr,
201201
LLVMTargetMachineOptionsRef Options) {
202202
auto *Opt = unwrap(Options);
203203
TargetOptions TO;
204204
TO.MCOptions.ABIName = Opt->ABI;
205-
return wrap(unwrap(T)->createTargetMachine(Triple, Opt->CPU, Opt->Features,
206-
TO, Opt->RM, Opt->CM, Opt->OL,
207-
Opt->JIT));
205+
return wrap(unwrap(T)->createTargetMachine(Triple(TripleStr), Opt->CPU,
206+
Opt->Features, TO, Opt->RM,
207+
Opt->CM, Opt->OL, Opt->JIT));
208208
}
209209

210210
LLVMTargetMachineRef

‎llvm/tools/llc/llc.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -555,7 +555,7 @@ static int compileModule(char **argv, LLVMContext &Context) {
555555

556556
InitializeOptions(TheTriple);
557557
Target = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
558-
TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM, CM, OLvl));
558+
TheTriple, CPUStr, FeaturesStr, Options, RM, CM, OLvl));
559559
assert(Target && "Could not allocate target machine!");
560560

561561
return Target->createDataLayout().getStringRepresentation();
@@ -598,7 +598,7 @@ static int compileModule(char **argv, LLVMContext &Context) {
598598

599599
InitializeOptions(TheTriple);
600600
Target = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
601-
TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM, CM, OLvl));
601+
TheTriple, CPUStr, FeaturesStr, Options, RM, CM, OLvl));
602602
assert(Target && "Could not allocate target machine!");
603603

604604
// If we don't have a module then just exit now. We do this down

‎llvm/tools/llvm-exegesis/lib/LlvmState.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ Expected<LLVMState> LLVMState::Create(std::string TripleName,
5757
}
5858
const TargetOptions Options;
5959
std::unique_ptr<const TargetMachine> TM(TheTarget->createTargetMachine(
60-
TripleName, CpuName, Features, Options, Reloc::Model::Static));
60+
TheTriple, CpuName, Features, Options, Reloc::Model::Static));
6161
if (!TM) {
6262
return make_error<StringError>("unable to create target machine",
6363
inconvertibleErrorCode());
@@ -93,7 +93,7 @@ LLVMState::LLVMState(std::unique_ptr<const TargetMachine> TM,
9393
std::unique_ptr<TargetMachine> LLVMState::createTargetMachine() const {
9494
return std::unique_ptr<TargetMachine>(
9595
TheTargetMachine->getTarget().createTargetMachine(
96-
TheTargetMachine->getTargetTriple().normalize(),
96+
Triple(TheTargetMachine->getTargetTriple().normalize()),
9797
TheTargetMachine->getTargetCPU(),
9898
TheTargetMachine->getTargetFeatureString(), TheTargetMachine->Options,
9999
Reloc::Model::Static));

‎llvm/tools/llvm-split/llvm-split.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -92,7 +92,7 @@ int main(int argc, char **argv) {
9292

9393
TargetOptions Options;
9494
TM = std::unique_ptr<TargetMachine>(T->createTargetMachine(
95-
MTriple, MCPU, /*FS*/ "", Options, std::nullopt, std::nullopt));
95+
Triple(MTriple), MCPU, /*FS*/ "", Options, std::nullopt, std::nullopt));
9696
}
9797

9898
std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);

‎llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,7 @@ class AArch64SelectionDAGTest : public testing::Test {
4545

4646
TargetOptions Options;
4747
TM = std::unique_ptr<TargetMachine>(
48-
T->createTargetMachine("AArch64", "", "+sve", Options, std::nullopt,
48+
T->createTargetMachine(TargetTriple, "", "+sve", Options, std::nullopt,
4949
std::nullopt, CodeGenOptLevel::Aggressive));
5050
if (!TM)
5151
GTEST_SKIP();

‎llvm/unittests/CodeGen/AMDGPUMetadataTest.cpp

+3-2
Original file line numberDiff line numberDiff line change
@@ -52,13 +52,14 @@ class AMDGPUSelectionDAGTest : public testing::Test {
5252

5353
void SetUp() override {
5454
std::string Error;
55-
const Target *T = TargetRegistry::lookupTarget("amdgcn--amdpal", Error);
55+
Triple TargetTriple("amdgcn--amdpal");
56+
const Target *T = TargetRegistry::lookupTarget(TargetTriple, Error);
5657
if (!T)
5758
GTEST_SKIP();
5859

5960
TargetOptions Options;
6061
TM = std::unique_ptr<TargetMachine>(T->createTargetMachine(
61-
"amdgcn--amdpal", "gfx1010", "", Options, std::nullopt));
62+
TargetTriple, "gfx1010", "", Options, std::nullopt));
6263
if (!TM)
6364
GTEST_SKIP();
6465

‎llvm/unittests/CodeGen/DroppedVariableStatsMIRTest.cpp

+2-1
Original file line numberDiff line numberDiff line change
@@ -33,8 +33,9 @@ using namespace llvm;
3333
namespace {
3434

3535
std::unique_ptr<TargetMachine>
36-
createTargetMachine(std::string TT, StringRef CPU, StringRef FS) {
36+
createTargetMachine(std::string TargetStr, StringRef CPU, StringRef FS) {
3737
std::string Error;
38+
Triple TT(TargetStr);
3839
const Target *T = TargetRegistry::lookupTarget(TT, Error);
3940
if (!T)
4041
return nullptr;

0 commit comments

Comments
 (0)