https://github.com/arsenm created
https://github.com/llvm/llvm-project/pull/157321
Avoids more Triple->string->Triple round trip. This
is a continuation of f137c3d592e96330e450a8fd63ef7e8877fc1908
>From 233037d81eee84cc6aafd0708758f898e6b96593 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <matthew.arsena...@amd.com>
Date: Sun, 7 Sep 2025 09:03:22 +0900
Subject: [PATCH] MC: Add Triple overloads for more MC constructors
Avoids more Triple->string->Triple round trip. This
is a continuation of f137c3d592e96330e450a8fd63ef7e8877fc1908
---
bolt/lib/Core/BinaryContext.cpp | 6 +-
clang/lib/Parse/ParseStmtAsm.cpp | 9 +--
clang/tools/driver/cc1as_main.cpp | 17 +++---
llvm/include/llvm/MC/TargetRegistry.h | 61 +++++++++++++++----
llvm/lib/CodeGen/CodeGenTargetMachineImpl.cpp | 10 +--
.../lib/DWARFLinker/Classic/DWARFStreamer.cpp | 6 +-
.../DWARFLinker/Parallel/DWARFEmitterImpl.cpp | 6 +-
.../Parallel/DebugLineSectionEmitter.h | 6 +-
.../LogicalView/Readers/LVBinaryReader.cpp | 15 ++---
.../RuntimeDyld/RuntimeDyldChecker.cpp | 6 +-
llvm/lib/MC/MCDisassembler/Disassembler.cpp | 15 +++--
llvm/lib/Object/ModuleSymbolTable.cpp | 7 +--
llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp | 2 +-
llvm/lib/Target/Mips/MipsAsmPrinter.cpp | 3 +-
.../llvm-cfi-verify/lib/FileAnalysis.cpp | 8 ++-
llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp | 2 +-
llvm/tools/llvm-dwp/llvm-dwp.cpp | 7 ++-
.../llvm-exegesis/lib/DisassemblerHelper.cpp | 4 +-
llvm/tools/llvm-exegesis/lib/LlvmState.cpp | 2 +-
llvm/tools/llvm-jitlink/llvm-jitlink.cpp | 6 +-
llvm/tools/llvm-mc/Disassembler.cpp | 21 ++++---
llvm/tools/llvm-mc/Disassembler.h | 6 +-
llvm/tools/llvm-mc/llvm-mc.cpp | 11 ++--
llvm/tools/llvm-mca/llvm-mca.cpp | 6 +-
llvm/tools/llvm-ml/Disassembler.cpp | 5 +-
llvm/tools/llvm-ml/llvm-ml.cpp | 10 ++-
llvm/tools/llvm-objdump/MachODump.cpp | 45 +++++++-------
llvm/tools/llvm-objdump/llvm-objdump.cpp | 37 +++++------
llvm/tools/llvm-profgen/ProfiledBinary.cpp | 24 ++++----
llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp | 10 +--
llvm/tools/sancov/sancov.cpp | 6 +-
.../DWARFExpressionCompactPrinterTest.cpp | 2 +-
.../DWARF/DWARFExpressionCopyBytesTest.cpp | 12 ++--
.../DebugInfo/DWARF/DwarfGenerator.cpp | 6 +-
llvm/unittests/MC/AMDGPU/Disassembler.cpp | 34 ++++++-----
llvm/unittests/MC/DwarfLineTableHeaders.cpp | 20 +++---
llvm/unittests/MC/DwarfLineTables.cpp | 13 ++--
llvm/unittests/MC/MCInstPrinter.cpp | 11 ++--
.../MC/SystemZ/SystemZAsmLexerTest.cpp | 15 +++--
.../MC/SystemZ/SystemZMCDisassemblerTest.cpp | 14 ++---
.../MC/X86/X86MCDisassemblerTest.cpp | 15 ++---
.../llvm-exegesis/AArch64/TargetTest.cpp | 6 +-
.../llvm-exegesis/PowerPC/AnalysisTest.cpp | 6 +-
.../llvm-exegesis/PowerPC/TargetTest.cpp | 6 +-
llvm/unittests/tools/llvm-mca/MCATestBase.cpp | 8 +--
mlir/lib/Target/LLVM/ROCDL/Target.cpp | 7 +--
46 files changed, 306 insertions(+), 248 deletions(-)
diff --git a/bolt/lib/Core/BinaryContext.cpp b/bolt/lib/Core/BinaryContext.cpp
index dd0d041692484..23a5a65c2c5f0 100644
--- a/bolt/lib/Core/BinaryContext.cpp
+++ b/bolt/lib/Core/BinaryContext.cpp
@@ -207,7 +207,7 @@ Expected<std::unique_ptr<BinaryContext>>
BinaryContext::createBinaryContext(
Twine("BOLT-ERROR: ", Error));
std::unique_ptr<const MCRegisterInfo> MRI(
- TheTarget->createMCRegInfo(TripleName));
+ TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
return createStringError(
make_error_code(std::errc::not_supported),
@@ -215,7 +215,7 @@ Expected<std::unique_ptr<BinaryContext>>
BinaryContext::createBinaryContext(
// Set up disassembler.
std::unique_ptr<MCAsmInfo> AsmInfo(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCTargetOptions()));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCTargetOptions()));
if (!AsmInfo)
return createStringError(
make_error_code(std::errc::not_supported),
@@ -227,7 +227,7 @@ Expected<std::unique_ptr<BinaryContext>>
BinaryContext::createBinaryContext(
AsmInfo->setAllowAtInName(true);
std::unique_ptr<const MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, "", FeaturesStr));
+ TheTarget->createMCSubtargetInfo(TheTriple, "", FeaturesStr));
if (!STI)
return createStringError(
make_error_code(std::errc::not_supported),
diff --git a/clang/lib/Parse/ParseStmtAsm.cpp b/clang/lib/Parse/ParseStmtAsm.cpp
index c679aa6fe7b27..48338566e789d 100644
--- a/clang/lib/Parse/ParseStmtAsm.cpp
+++ b/clang/lib/Parse/ParseStmtAsm.cpp
@@ -543,7 +543,8 @@ StmtResult
Parser::ParseMicrosoftAsmStatement(SourceLocation AsmLoc) {
std::string FeaturesStr =
llvm::join(TO.Features.begin(), TO.Features.end(), ",");
- std::unique_ptr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
+ std::unique_ptr<llvm::MCRegisterInfo> MRI(
+ TheTarget->createMCRegInfo(TheTriple));
if (!MRI) {
Diag(AsmLoc, diag::err_msasm_unable_to_create_target)
<< "target MC unavailable";
@@ -552,11 +553,11 @@ StmtResult
Parser::ParseMicrosoftAsmStatement(SourceLocation AsmLoc) {
// FIXME: init MCOptions from sanitizer flags here.
llvm::MCTargetOptions MCOptions;
std::unique_ptr<llvm::MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
// Get the instruction descriptor.
std::unique_ptr<llvm::MCInstrInfo> MII(TheTarget->createMCInstrInfo());
std::unique_ptr<llvm::MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TT, TO.CPU, FeaturesStr));
+ TheTarget->createMCSubtargetInfo(TheTriple, TO.CPU, FeaturesStr));
// Target MCTargetDesc may not be linked in clang-based tools.
if (!MAI || !MII || !STI) {
@@ -591,7 +592,7 @@ StmtResult
Parser::ParseMicrosoftAsmStatement(SourceLocation AsmLoc) {
}
std::unique_ptr<llvm::MCInstPrinter> IP(
- TheTarget->createMCInstPrinter(llvm::Triple(TT), 1, *MAI, *MII, *MRI));
+ TheTarget->createMCInstPrinter(TheTriple, 1, *MAI, *MII, *MRI));
// Change to the Intel dialect.
Parser->setAssemblerDialect(1);
diff --git a/clang/tools/driver/cc1as_main.cpp
b/clang/tools/driver/cc1as_main.cpp
index dda601c46472c..5c30de33c7b46 100644
--- a/clang/tools/driver/cc1as_main.cpp
+++ b/clang/tools/driver/cc1as_main.cpp
@@ -71,8 +71,8 @@ struct AssemblerInvocation {
/// @name Target Options
/// @{
- /// The name of the target triple to assemble for.
- std::string Triple;
+ /// The target triple to assemble for.
+ llvm::Triple Triple;
/// If given, the name of the target CPU to determine which instructions
/// are legal.
@@ -192,9 +192,12 @@ struct AssemblerInvocation {
std::string AsSecureLogFile;
/// @}
+ void setTriple(llvm::StringRef Str) {
+ Triple = llvm::Triple(llvm::Triple::normalize(Str));
+ }
+
public:
AssemblerInvocation() {
- Triple = "";
NoInitialTextSection = 0;
InputFile = "-";
OutputPath = "-";
@@ -261,7 +264,7 @@ bool
AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
// Construct the invocation.
// Target Options
- Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
+ Opts.setTriple(Args.getLastArgValue(OPT_triple));
if (Arg *A = Args.getLastArg(options::OPT_darwin_target_variant_triple))
Opts.DarwinTargetVariantTriple = llvm::Triple(A->getValue());
if (Arg *A = Args.getLastArg(OPT_darwin_target_variant_sdk_version_EQ)) {
@@ -278,7 +281,7 @@ bool
AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
// Use the default target triple if unspecified.
if (Opts.Triple.empty())
- Opts.Triple = llvm::sys::getDefaultTargetTriple();
+ Opts.setTriple(llvm::sys::getDefaultTargetTriple());
// Language Options
Opts.IncludePaths = Args.getAllArgValues(OPT_I);
@@ -419,7 +422,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
std::string Error;
const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
if (!TheTarget)
- return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
+ return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple.str();
ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
MemoryBuffer::getFileOrSTDIN(Opts.InputFile, /*IsText=*/true);
@@ -604,7 +607,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
std::unique_ptr<MCTargetAsmParser> TAP(
TheTarget->createMCAsmParser(*STI, *Parser, *MCII, MCOptions));
if (!TAP)
- Failed = Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
+ Failed = Diags.Report(diag::err_target_unknown_triple) <<
Opts.Triple.str();
// Set values for symbols, if any.
for (auto &S : Opts.SymbolDefs) {
diff --git a/llvm/include/llvm/MC/TargetRegistry.h
b/llvm/include/llvm/MC/TargetRegistry.h
index efff08d7f8ea5..019ee602975f7 100644
--- a/llvm/include/llvm/MC/TargetRegistry.h
+++ b/llvm/include/llvm/MC/TargetRegistry.h
@@ -389,18 +389,26 @@ class Target {
/// @name Feature Constructors
/// @{
- /// createMCAsmInfo - Create a MCAsmInfo implementation for the specified
+ [[deprecated("Use overload accepting Triple instead")]]
+ MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple,
+ const MCTargetOptions &Options) const {
+ if (!MCAsmInfoCtorFn)
+ return nullptr;
+ return MCAsmInfoCtorFn(MRI, Triple(TheTriple), Options);
+ }
+
+ /// Create a MCAsmInfo implementation for the specified
/// target triple.
///
/// \param TheTriple This argument is used to determine the target machine
/// feature set; it should always be provided. Generally this should be
/// either the target triple from the module, or the target triple of the
/// host if that does not exist.
- MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple,
+ MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI, const Triple
&TheTriple,
const MCTargetOptions &Options) const {
if (!MCAsmInfoCtorFn)
return nullptr;
- return MCAsmInfoCtorFn(MRI, Triple(TheTriple), Options);
+ return MCAsmInfoCtorFn(MRI, TheTriple, Options);
}
/// Create a MCObjectFileInfo implementation for the specified target
@@ -432,14 +440,28 @@ class Target {
return MCInstrAnalysisCtorFn(Info);
}
- /// createMCRegInfo - Create a MCRegisterInfo implementation.
- ///
+ [[deprecated("Use overload accepting Triple instead")]]
MCRegisterInfo *createMCRegInfo(StringRef TT) const {
if (!MCRegInfoCtorFn)
return nullptr;
return MCRegInfoCtorFn(Triple(TT));
}
+ /// Create a MCRegisterInfo implementation.
+ MCRegisterInfo *createMCRegInfo(const Triple &TT) const {
+ if (!MCRegInfoCtorFn)
+ return nullptr;
+ return MCRegInfoCtorFn(TT);
+ }
+
+ [[deprecated("Use overload accepting Triple instead")]]
+ MCSubtargetInfo *createMCSubtargetInfo(StringRef TheTriple, StringRef CPU,
+ StringRef Features) const {
+ if (!MCSubtargetInfoCtorFn)
+ return nullptr;
+ return MCSubtargetInfoCtorFn(Triple(TheTriple), CPU, Features);
+ }
+
/// createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
///
/// \param TheTriple This argument is used to determine the target machine
@@ -449,11 +471,11 @@ class Target {
/// \param CPU This specifies the name of the target CPU.
/// \param Features This specifies the string representation of the
/// additional target features.
- MCSubtargetInfo *createMCSubtargetInfo(StringRef TheTriple, StringRef CPU,
+ MCSubtargetInfo *createMCSubtargetInfo(const Triple &TheTriple, StringRef
CPU,
StringRef Features) const {
if (!MCSubtargetInfoCtorFn)
return nullptr;
- return MCSubtargetInfoCtorFn(Triple(TheTriple), CPU, Features);
+ return MCSubtargetInfoCtorFn(TheTriple, CPU, Features);
}
/// createTargetMachine - Create a target specific machine implementation
@@ -577,15 +599,31 @@ class Target {
return nullptr;
}
+ [[deprecated("Use overload accepting Triple instead")]]
+ MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) const
{
+ return createMCRelocationInfo(Triple(TT), Ctx);
+ }
+
/// createMCRelocationInfo - Create a target specific MCRelocationInfo.
///
/// \param TT The target triple.
/// \param Ctx The target context.
- MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) const
{
+ MCRelocationInfo *createMCRelocationInfo(const Triple &TT,
+ MCContext &Ctx) const {
MCRelocationInfoCtorTy Fn = MCRelocationInfoCtorFn
? MCRelocationInfoCtorFn
: llvm::createMCRelocationInfo;
- return Fn(Triple(TT), Ctx);
+ return Fn(TT, Ctx);
+ }
+
+ [[deprecated("Use overload accepting Triple instead")]]
+ MCSymbolizer *
+ createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
+ LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo,
+ MCContext *Ctx,
+ std::unique_ptr<MCRelocationInfo> &&RelInfo) const {
+ return createMCSymbolizer(Triple(TT), GetOpInfo, SymbolLookUp, DisInfo,
Ctx,
+ std::move(RelInfo));
}
/// createMCSymbolizer - Create a target specific MCSymbolizer.
@@ -601,14 +639,13 @@ class Target {
/// \param RelInfo The relocation information for this target. Takes
/// ownership.
MCSymbolizer *
- createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
+ createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo,
LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo,
MCContext *Ctx,
std::unique_ptr<MCRelocationInfo> &&RelInfo) const {
MCSymbolizerCtorTy Fn =
MCSymbolizerCtorFn ? MCSymbolizerCtorFn : llvm::createMCSymbolizer;
- return Fn(Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
- std::move(RelInfo));
+ return Fn(TT, GetOpInfo, SymbolLookUp, DisInfo, Ctx, std::move(RelInfo));
}
/// createCustomBehaviour - Create a target specific CustomBehaviour.
diff --git a/llvm/lib/CodeGen/CodeGenTargetMachineImpl.cpp
b/llvm/lib/CodeGen/CodeGenTargetMachineImpl.cpp
index 442ec38409307..5d7e2b59c2047 100644
--- a/llvm/lib/CodeGen/CodeGenTargetMachineImpl.cpp
+++ b/llvm/lib/CodeGen/CodeGenTargetMachineImpl.cpp
@@ -45,7 +45,7 @@ static cl::opt<bool> EnableNoTrapAfterNoreturn(
"after noreturn calls, even if --trap-unreachable is set."));
void CodeGenTargetMachineImpl::initAsmInfo() {
- MRI.reset(TheTarget.createMCRegInfo(getTargetTriple().str()));
+ MRI.reset(TheTarget.createMCRegInfo(getTargetTriple()));
assert(MRI && "Unable to create reg info");
MII.reset(TheTarget.createMCInstrInfo());
assert(MII && "Unable to create instruction info");
@@ -53,12 +53,12 @@ void CodeGenTargetMachineImpl::initAsmInfo() {
// to some backends having subtarget feature dependent module level
// code generation. This is similar to the hack in the AsmPrinter for
// module level assembly etc.
- STI.reset(TheTarget.createMCSubtargetInfo(
- getTargetTriple().str(), getTargetCPU(), getTargetFeatureString()));
+ STI.reset(TheTarget.createMCSubtargetInfo(getTargetTriple(), getTargetCPU(),
+ getTargetFeatureString()));
assert(STI && "Unable to create subtarget info");
- MCAsmInfo *TmpAsmInfo = TheTarget.createMCAsmInfo(
- *MRI, getTargetTriple().str(), Options.MCOptions);
+ MCAsmInfo *TmpAsmInfo =
+ TheTarget.createMCAsmInfo(*MRI, getTargetTriple(), Options.MCOptions);
// TargetSelect.h moved to a different directory between LLVM 2.9 and 3.0,
// and if the old one gets included then MCAsmInfo will be NULL and
// we'll crash later.
diff --git a/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
b/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
index 4e4d86e5cb8d1..1c0ddc8e1ca30 100644
--- a/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
+++ b/llvm/lib/DWARFLinker/Classic/DWARFStreamer.cpp
@@ -55,7 +55,7 @@ Error DwarfStreamer::init(Triple TheTriple,
TripleName = TheTriple.getTriple();
// Create all the MC Objects.
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
return createStringError(std::errc::invalid_argument,
"no register info for target %s",
@@ -64,12 +64,12 @@ Error DwarfStreamer::init(Triple TheTriple,
MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
MCOptions.AsmVerbose = true;
MCOptions.MCUseDwarfDirectory = MCTargetOptions::EnableDwarfDirectory;
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI)
return createStringError(std::errc::invalid_argument,
"no asm info for target %s", TripleName.c_str());
- MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ MSTI.reset(TheTarget->createMCSubtargetInfo(TheTriple, "", ""));
if (!MSTI)
return createStringError(std::errc::invalid_argument,
"no subtarget info for target %s",
diff --git a/llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp
b/llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp
index 379f60b0bfb96..9222235d7a41e 100644
--- a/llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp
+++ b/llvm/lib/DWARFLinker/Parallel/DWARFEmitterImpl.cpp
@@ -35,7 +35,7 @@ Error DwarfEmitterImpl::init(Triple TheTriple,
TripleName = TheTriple.getTriple();
// Create all the MC Objects.
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
return createStringError(std::errc::invalid_argument,
"no register info for target %s",
@@ -44,12 +44,12 @@ Error DwarfEmitterImpl::init(Triple TheTriple,
MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
MCOptions.AsmVerbose = true;
MCOptions.MCUseDwarfDirectory = MCTargetOptions::EnableDwarfDirectory;
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI)
return createStringError(std::errc::invalid_argument,
"no asm info for target %s", TripleName.c_str());
- MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ MSTI.reset(TheTarget->createMCSubtargetInfo(TheTriple, "", ""));
if (!MSTI)
return createStringError(std::errc::invalid_argument,
"no subtarget info for target %s",
diff --git a/llvm/lib/DWARFLinker/Parallel/DebugLineSectionEmitter.h
b/llvm/lib/DWARFLinker/Parallel/DebugLineSectionEmitter.h
index b035c4b1d6c30..03c0566f58f82 100644
--- a/llvm/lib/DWARFLinker/Parallel/DebugLineSectionEmitter.h
+++ b/llvm/lib/DWARFLinker/Parallel/DebugLineSectionEmitter.h
@@ -73,19 +73,19 @@ class DebugLineSectionEmitter {
TripleName = TheTriple.getTriple();
// Create all the MC Objects.
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
return createStringError(std::errc::invalid_argument,
"no register info for target %s",
TripleName.c_str());
MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI)
return createStringError(std::errc::invalid_argument,
"no asm info for target %s",
TripleName.c_str());
- MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ MSTI.reset(TheTarget->createMCSubtargetInfo(TheTriple, "", ""));
if (!MSTI)
return createStringError(std::errc::invalid_argument,
"no subtarget info for target %s",
diff --git a/llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp
b/llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp
index 0df9137a3bd37..0d0383158dd48 100644
--- a/llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp
+++ b/llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp
@@ -274,9 +274,10 @@ void LVBinaryReader::mapVirtualAddress(const
object::COFFObjectFile &COFFObj) {
});
}
-Error LVBinaryReader::loadGenericTargetInfo(StringRef TheTriple,
+Error LVBinaryReader::loadGenericTargetInfo(StringRef TripleName,
StringRef TheFeatures,
StringRef TheCPU) {
+ Triple TheTriple(TripleName);
std::string TargetLookupError;
const Target *TheTarget =
TargetRegistry::lookupTarget(TheTriple, TargetLookupError);
@@ -287,7 +288,7 @@ Error LVBinaryReader::loadGenericTargetInfo(StringRef
TheTriple,
MCRegisterInfo *RegisterInfo = TheTarget->createMCRegInfo(TheTriple);
if (!RegisterInfo)
return createStringError(errc::invalid_argument,
- "no register info for target " + TheTriple);
+ "no register info for target " + TripleName);
MRI.reset(RegisterInfo);
// Assembler properties and features.
@@ -295,7 +296,7 @@ Error LVBinaryReader::loadGenericTargetInfo(StringRef
TheTriple,
MCAsmInfo *AsmInfo(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!AsmInfo)
return createStringError(errc::invalid_argument,
- "no assembly info for target " + TheTriple);
+ "no assembly info for target " + TripleName);
MAI.reset(AsmInfo);
// Target subtargets.
@@ -303,14 +304,14 @@ Error LVBinaryReader::loadGenericTargetInfo(StringRef
TheTriple,
TheTarget->createMCSubtargetInfo(TheTriple, TheCPU, TheFeatures));
if (!SubtargetInfo)
return createStringError(errc::invalid_argument,
- "no subtarget info for target " + TheTriple);
+ "no subtarget info for target " + TripleName);
STI.reset(SubtargetInfo);
// Instructions Info.
MCInstrInfo *InstructionInfo(TheTarget->createMCInstrInfo());
if (!InstructionInfo)
return createStringError(errc::invalid_argument,
- "no instruction info for target " + TheTriple);
+ "no instruction info for target " + TripleName);
MII.reset(InstructionInfo);
MC = std::make_unique<MCContext>(Triple(TheTriple), MAI.get(), MRI.get(),
@@ -320,7 +321,7 @@ Error LVBinaryReader::loadGenericTargetInfo(StringRef
TheTriple,
MCDisassembler *DisAsm(TheTarget->createMCDisassembler(*STI, *MC));
if (!DisAsm)
return createStringError(errc::invalid_argument,
- "no disassembler for target " + TheTriple);
+ "no disassembler for target " + TripleName);
MD.reset(DisAsm);
MCInstPrinter *InstructionPrinter(TheTarget->createMCInstPrinter(
@@ -328,7 +329,7 @@ Error LVBinaryReader::loadGenericTargetInfo(StringRef
TheTriple,
if (!InstructionPrinter)
return createStringError(errc::invalid_argument,
"no target assembly language printer for target "
+
- TheTriple);
+ TripleName);
MIP.reset(InstructionPrinter);
InstructionPrinter->setPrintImmHex(true);
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
index ff48a938cbd42..df702130450d5 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
@@ -767,13 +767,13 @@ class RuntimeDyldCheckerExprEval {
inconvertibleErrorCode());
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, CPU, TF.getString()));
+ TheTarget->createMCSubtargetInfo(TT, CPU, TF.getString()));
if (!STI)
return make_error<StringError>("Unable to create subtarget for " +
TripleName,
inconvertibleErrorCode());
- std::unique_ptr<MCRegisterInfo>
MRI(TheTarget->createMCRegInfo(TripleName));
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
if (!MRI)
return make_error<StringError>("Unable to create target register info "
"for " +
@@ -782,7 +782,7 @@ class RuntimeDyldCheckerExprEval {
MCTargetOptions MCOptions;
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
if (!MAI)
return make_error<StringError>("Unable to create target asm info " +
TripleName,
diff --git a/llvm/lib/MC/MCDisassembler/Disassembler.cpp
b/llvm/lib/MC/MCDisassembler/Disassembler.cpp
index a79b43837085c..3065917675c82 100644
--- a/llvm/lib/MC/MCDisassembler/Disassembler.cpp
+++ b/llvm/lib/MC/MCDisassembler/Disassembler.cpp
@@ -50,14 +50,16 @@ LLVMCreateDisasmCPUFeatures(const char *TT, const char *CPU,
if (!TheTarget)
return nullptr;
- std::unique_ptr<const MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
+ Triple TheTriple(TT);
+ std::unique_ptr<const MCRegisterInfo> MRI(
+ TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
return nullptr;
MCTargetOptions MCOptions;
// Get the assembler info needed to setup the MCContext.
std::unique_ptr<const MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI)
return nullptr;
@@ -66,7 +68,7 @@ LLVMCreateDisasmCPUFeatures(const char *TT, const char *CPU,
return nullptr;
std::unique_ptr<const MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TT, CPU, Features));
+ TheTarget->createMCSubtargetInfo(TheTriple, CPU, Features));
if (!STI)
return nullptr;
@@ -83,12 +85,13 @@ LLVMCreateDisasmCPUFeatures(const char *TT, const char *CPU,
return nullptr;
std::unique_ptr<MCRelocationInfo> RelInfo(
- TheTarget->createMCRelocationInfo(TT, *Ctx));
+ TheTarget->createMCRelocationInfo(TheTriple, *Ctx));
if (!RelInfo)
return nullptr;
- std::unique_ptr<MCSymbolizer> Symbolizer(TheTarget->createMCSymbolizer(
- TT, GetOpInfo, SymbolLookUp, DisInfo, Ctx.get(), std::move(RelInfo)));
+ std::unique_ptr<MCSymbolizer> Symbolizer(
+ TheTarget->createMCSymbolizer(TheTriple, GetOpInfo, SymbolLookUp,
DisInfo,
+ Ctx.get(), std::move(RelInfo)));
DisAsm->setSymbolizer(std::move(Symbolizer));
// Set up the instruction printer.
diff --git a/llvm/lib/Object/ModuleSymbolTable.cpp
b/llvm/lib/Object/ModuleSymbolTable.cpp
index 1706772912772..9442becdb7d33 100644
--- a/llvm/lib/Object/ModuleSymbolTable.cpp
+++ b/llvm/lib/Object/ModuleSymbolTable.cpp
@@ -81,17 +81,16 @@ initializeRecordStreamer(const Module &M,
const Target *T = TargetRegistry::lookupTarget(TT, Err);
assert(T && T->hasMCAsmParser());
- std::unique_ptr<MCRegisterInfo> MRI(T->createMCRegInfo(TT.str()));
+ std::unique_ptr<MCRegisterInfo> MRI(T->createMCRegInfo(TT));
if (!MRI)
return;
MCTargetOptions MCOptions;
- std::unique_ptr<MCAsmInfo> MAI(T->createMCAsmInfo(*MRI, TT.str(),
MCOptions));
+ std::unique_ptr<MCAsmInfo> MAI(T->createMCAsmInfo(*MRI, TT, MCOptions));
if (!MAI)
return;
- std::unique_ptr<MCSubtargetInfo> STI(
- T->createMCSubtargetInfo(TT.str(), "", ""));
+ std::unique_ptr<MCSubtargetInfo> STI(T->createMCSubtargetInfo(TT, "", ""));
if (!STI)
return;
diff --git a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
index da344305f39d9..fa050526b722c 100644
--- a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
+++ b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
@@ -734,7 +734,7 @@ void AArch64AsmPrinter::emitHwasanMemaccessSymbols(Module
&M) {
const Triple &TT = TM.getTargetTriple();
assert(TT.isOSBinFormatELF());
std::unique_ptr<MCSubtargetInfo> STI(
- TM.getTarget().createMCSubtargetInfo(TT.str(), "", ""));
+ TM.getTarget().createMCSubtargetInfo(TT, "", ""));
assert(STI && "Unable to create subtarget info");
this->STI = static_cast<const AArch64Subtarget *>(&*STI);
diff --git a/llvm/lib/Target/Mips/MipsAsmPrinter.cpp
b/llvm/lib/Target/Mips/MipsAsmPrinter.cpp
index ae91c97e2a803..9d8b9f86daf7a 100644
--- a/llvm/lib/Target/Mips/MipsAsmPrinter.cpp
+++ b/llvm/lib/Target/Mips/MipsAsmPrinter.cpp
@@ -967,8 +967,7 @@ void MipsAsmPrinter::EmitFPCallStub(
// freed) and since we're at the global level we can use the default
// constructed subtarget.
std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
- TM.getTargetTriple().str(), TM.getTargetCPU(),
- TM.getTargetFeatureString()));
+ TM.getTargetTriple(), TM.getTargetCPU(), TM.getTargetFeatureString()));
//
// .global xxxx
diff --git a/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp
b/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp
index 25ad985c52584..4209e235e165b 100644
--- a/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp
+++ b/llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp
@@ -377,6 +377,8 @@ Error FileAnalysis::initialiseDisassemblyMembers() {
MCPU = "";
std::string ErrorString;
+ Triple TheTriple(TripleName);
+
LLVMSymbolizer::Options Opt;
Opt.UseSymbolTable = false;
Symbolizer.reset(new LLVMSymbolizer(Opt));
@@ -389,19 +391,19 @@ Error FileAnalysis::initialiseDisassemblyMembers() {
"\", failed with error: " + ErrorString)
.str());
- RegisterInfo.reset(ObjectTarget->createMCRegInfo(TripleName));
+ RegisterInfo.reset(ObjectTarget->createMCRegInfo(TheTriple));
if (!RegisterInfo)
return make_error<UnsupportedDisassembly>(
"Failed to initialise RegisterInfo.");
MCTargetOptions MCOptions;
AsmInfo.reset(
- ObjectTarget->createMCAsmInfo(*RegisterInfo, TripleName, MCOptions));
+ ObjectTarget->createMCAsmInfo(*RegisterInfo, TheTriple, MCOptions));
if (!AsmInfo)
return make_error<UnsupportedDisassembly>("Failed to initialise AsmInfo.");
SubtargetInfo.reset(ObjectTarget->createMCSubtargetInfo(
- TripleName, MCPU, Features.getString()));
+ TheTriple, MCPU, Features.getString()));
if (!SubtargetInfo)
return make_error<UnsupportedDisassembly>(
"Failed to initialise SubtargetInfo.");
diff --git a/llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp
b/llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp
index 5749b19d7ad49..79f05278c329d 100644
--- a/llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp
+++ b/llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp
@@ -678,7 +678,7 @@ createRegInfo(const object::ObjectFile &Obj) {
const Target *TheTarget = TargetRegistry::lookupTarget(TT,
TargetLookupError);
if (!TargetLookupError.empty())
return nullptr;
- MCRegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
+ MCRegInfo.reset(TheTarget->createMCRegInfo(TT));
return MCRegInfo;
}
diff --git a/llvm/tools/llvm-dwp/llvm-dwp.cpp b/llvm/tools/llvm-dwp/llvm-dwp.cpp
index e34fcadfde5fc..61ba82d0634ac 100644
--- a/llvm/tools/llvm-dwp/llvm-dwp.cpp
+++ b/llvm/tools/llvm-dwp/llvm-dwp.cpp
@@ -217,20 +217,21 @@ int llvm_dwp_main(int argc, char **argv, const
llvm::ToolContext &) {
if (!TheTarget)
return error(ErrorStr, Context);
std::string TripleName = ErrOrTriple->getTriple();
+ Triple TheTriple(TripleName);
// Create all the MC Objects.
- std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
return error(Twine("no register info for target ") + TripleName, Context);
MCTargetOptions MCOptions = llvm::mc::InitMCTargetOptionsFromFlags();
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI)
return error("no asm info for target " + TripleName, Context);
std::unique_ptr<MCSubtargetInfo> MSTI(
- TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ TheTarget->createMCSubtargetInfo(TheTriple, "", ""));
if (!MSTI)
return error("no subtarget info for target " + TripleName, Context);
diff --git a/llvm/tools/llvm-exegesis/lib/DisassemblerHelper.cpp
b/llvm/tools/llvm-exegesis/lib/DisassemblerHelper.cpp
index bc37aa44db0cb..ff19ddce4ac9c 100644
--- a/llvm/tools/llvm-exegesis/lib/DisassemblerHelper.cpp
+++ b/llvm/tools/llvm-exegesis/lib/DisassemblerHelper.cpp
@@ -17,8 +17,8 @@ DisassemblerHelper::DisassemblerHelper(const LLVMState
&State) : State_(State) {
MCTargetOptions MCOptions;
const auto &TM = State.getTargetMachine();
const auto &Triple = TM.getTargetTriple();
- AsmInfo_.reset(TM.getTarget().createMCAsmInfo(State_.getRegInfo(),
- Triple.str(), MCOptions));
+ AsmInfo_.reset(
+ TM.getTarget().createMCAsmInfo(State_.getRegInfo(), Triple, MCOptions));
InstPrinter_.reset(TM.getTarget().createMCInstPrinter(
Triple, 0 /*default variant*/, *AsmInfo_, State_.getInstrInfo(),
State_.getRegInfo()));
diff --git a/llvm/tools/llvm-exegesis/lib/LlvmState.cpp
b/llvm/tools/llvm-exegesis/lib/LlvmState.cpp
index 88c0d67694afb..2c6f5d275cf00 100644
--- a/llvm/tools/llvm-exegesis/lib/LlvmState.cpp
+++ b/llvm/tools/llvm-exegesis/lib/LlvmState.cpp
@@ -55,7 +55,7 @@ Expected<LLVMState> LLVMState::Create(std::string TripleName,
}
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, CpuName, ""));
+ TheTarget->createMCSubtargetInfo(TheTriple, CpuName, ""));
assert(STI && "Unable to create subtarget info!");
if (!STI->isCPUStringValid(CpuName)) {
return make_error<StringError>(Twine("invalid CPU name (")
diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
index de8dc16f2eba9..6ff91b4bf47b8 100644
--- a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
+++ b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
@@ -2591,13 +2591,13 @@ getTargetInfo(const Triple &TT,
inconvertibleErrorCode()));
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, "", TF.getString()));
+ TheTarget->createMCSubtargetInfo(TT, "", TF.getString()));
if (!STI)
ExitOnErr(
make_error<StringError>("Unable to create subtarget for " + TripleName,
inconvertibleErrorCode()));
- std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
if (!MRI)
ExitOnErr(make_error<StringError>("Unable to create target register info "
"for " +
@@ -2606,7 +2606,7 @@ getTargetInfo(const Triple &TT,
MCTargetOptions MCOptions;
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
if (!MAI)
ExitOnErr(make_error<StringError>("Unable to create target asm info " +
TripleName,
diff --git a/llvm/tools/llvm-mc/Disassembler.cpp
b/llvm/tools/llvm-mc/Disassembler.cpp
index 2ee422126dbfb..9a61f68b12d31 100644
--- a/llvm/tools/llvm-mc/Disassembler.cpp
+++ b/llvm/tools/llvm-mc/Disassembler.cpp
@@ -165,28 +165,29 @@ static bool byteArrayFromString(ByteArrayTy &ByteArray,
StringRef &Str,
return false;
}
-int Disassembler::disassemble(const Target &T, const std::string &Triple,
- MCSubtargetInfo &STI, MCStreamer &Streamer,
- MemoryBuffer &Buffer, SourceMgr &SM,
- MCContext &Ctx, const MCTargetOptions &MCOptions,
- bool HexBytes, unsigned NumBenchmarkRuns) {
- std::unique_ptr<const MCRegisterInfo> MRI(T.createMCRegInfo(Triple));
+int Disassembler::disassemble(const Target &T, MCSubtargetInfo &STI,
+ MCStreamer &Streamer, MemoryBuffer &Buffer,
+ SourceMgr &SM, MCContext &Ctx,
+ const MCTargetOptions &MCOptions, bool HexBytes,
+ unsigned NumBenchmarkRuns) {
+ const Triple &TheTriple = STI.getTargetTriple();
+ std::unique_ptr<const MCRegisterInfo> MRI(T.createMCRegInfo(TheTriple));
if (!MRI) {
- errs() << "error: no register info for target " << Triple << "\n";
+ errs() << "error: no register info for target " << TheTriple.str() << '\n';
return -1;
}
std::unique_ptr<const MCAsmInfo> MAI(
- T.createMCAsmInfo(*MRI, Triple, MCOptions));
+ T.createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI) {
- errs() << "error: no assembly info for target " << Triple << "\n";
+ errs() << "error: no assembly info for target " << TheTriple.str() << '\n';
return -1;
}
std::unique_ptr<const MCDisassembler> DisAsm(
T.createMCDisassembler(STI, Ctx));
if (!DisAsm) {
- errs() << "error: no disassembler for target " << Triple << "\n";
+ errs() << "error: no disassembler for target " << TheTriple.str() << '\n';
return -1;
}
diff --git a/llvm/tools/llvm-mc/Disassembler.h
b/llvm/tools/llvm-mc/Disassembler.h
index 5ee47d54200be..dd8525d73200e 100644
--- a/llvm/tools/llvm-mc/Disassembler.h
+++ b/llvm/tools/llvm-mc/Disassembler.h
@@ -29,9 +29,9 @@ class MCTargetOptions;
class Disassembler {
public:
- static int disassemble(const Target &T, const std::string &Triple,
- MCSubtargetInfo &STI, MCStreamer &Streamer,
- MemoryBuffer &Buffer, SourceMgr &SM, MCContext &Ctx,
+ static int disassemble(const Target &T, MCSubtargetInfo &STI,
+ MCStreamer &Streamer, MemoryBuffer &Buffer,
+ SourceMgr &SM, MCContext &Ctx,
const MCTargetOptions &MCOptions, bool HexBytes,
unsigned NumBenchmarkRuns);
};
diff --git a/llvm/tools/llvm-mc/llvm-mc.cpp b/llvm/tools/llvm-mc/llvm-mc.cpp
index f69f7c725c6b4..136cd69526a3c 100644
--- a/llvm/tools/llvm-mc/llvm-mc.cpp
+++ b/llvm/tools/llvm-mc/llvm-mc.cpp
@@ -440,11 +440,11 @@ int main(int argc, char **argv) {
// it later.
SrcMgr.setIncludeDirs(IncludeDirs);
- std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TheTriple));
assert(MRI && "Unable to create target register info!");
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
assert(MAI && "Unable to create target asm info!");
if (CompressDebugSections != DebugCompressionType::None) {
@@ -468,7 +468,7 @@ int main(int argc, char **argv) {
}
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr));
+ TheTarget->createMCSubtargetInfo(TheTriple, MCPU, FeaturesStr));
assert(STI && "Unable to create subtarget info!");
// FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
@@ -652,9 +652,8 @@ int main(int argc, char **argv) {
break;
}
if (disassemble)
- Res = Disassembler::disassemble(*TheTarget, TripleName, *STI, *Str,
*Buffer,
- SrcMgr, Ctx, MCOptions, HexBytes,
- NumBenchmarkRuns);
+ Res = Disassembler::disassemble(*TheTarget, *STI, *Str, *Buffer, SrcMgr,
+ Ctx, MCOptions, HexBytes,
NumBenchmarkRuns);
// Keep output if no errors.
if (Res == 0) {
diff --git a/llvm/tools/llvm-mca/llvm-mca.cpp b/llvm/tools/llvm-mca/llvm-mca.cpp
index 4b0611186d21f..d330b44894e7a 100644
--- a/llvm/tools/llvm-mca/llvm-mca.cpp
+++ b/llvm/tools/llvm-mca/llvm-mca.cpp
@@ -419,7 +419,7 @@ int main(int argc, char **argv) {
}
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr));
+ TheTarget->createMCSubtargetInfo(TheTriple, MCPU, FeaturesStr));
assert(STI && "Unable to create subtarget info!");
if (!STI->isCPUStringValid(MCPU))
return 1;
@@ -441,12 +441,12 @@ int main(int argc, char **argv) {
bool IsOutOfOrder = STI->getSchedModel().isOutOfOrder();
processViewOptions(IsOutOfOrder);
- std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TheTriple));
assert(MRI && "Unable to create target register info!");
MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
assert(MAI && "Unable to create target asm info!");
SourceMgr SrcMgr;
diff --git a/llvm/tools/llvm-ml/Disassembler.cpp
b/llvm/tools/llvm-ml/Disassembler.cpp
index e55561f3b7f86..0b34a1e14d5b7 100644
--- a/llvm/tools/llvm-ml/Disassembler.cpp
+++ b/llvm/tools/llvm-ml/Disassembler.cpp
@@ -127,7 +127,8 @@ int Disassembler::disassemble(const Target &T, const
std::string &TripleName,
MCSubtargetInfo &STI, MCStreamer &Streamer,
MemoryBuffer &Buffer, SourceMgr &SM,
raw_ostream &Out) {
- std::unique_ptr<const MCRegisterInfo> MRI(T.createMCRegInfo(TripleName));
+ Triple TheTriple(TripleName);
+ std::unique_ptr<const MCRegisterInfo> MRI(T.createMCRegInfo(TheTriple));
if (!MRI) {
errs() << "error: no register info for target " << TripleName << "\n";
return -1;
@@ -135,7 +136,7 @@ int Disassembler::disassemble(const Target &T, const
std::string &TripleName,
MCTargetOptions MCOptions;
std::unique_ptr<const MCAsmInfo> MAI(
- T.createMCAsmInfo(*MRI, TripleName, MCOptions));
+ T.createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI) {
errs() << "error: no assembly info for target " << TripleName << "\n";
return -1;
diff --git a/llvm/tools/llvm-ml/llvm-ml.cpp b/llvm/tools/llvm-ml/llvm-ml.cpp
index c8e49edd34e04..ae58b0da6d69b 100644
--- a/llvm/tools/llvm-ml/llvm-ml.cpp
+++ b/llvm/tools/llvm-ml/llvm-ml.cpp
@@ -277,8 +277,6 @@ int llvm_ml_main(int Argc, char **Argv, const
llvm::ToolContext &) {
WithColor::error(errs(), ProgName) << Error;
return 1;
}
- const std::string &TripleName = TheTriple.getTriple();
-
bool SafeSEH = InputArgs.hasArg(OPT_safeseh);
if (SafeSEH && !(TheTriple.isArch32Bit() && TheTriple.isX86())) {
WithColor::warning()
@@ -316,17 +314,17 @@ int llvm_ml_main(int Argc, char **Argv, const
llvm::ToolContext &) {
}
SrcMgr.setIncludeDirs(IncludeDirs);
- std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TheTriple));
assert(MRI && "Unable to create target register info!");
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
assert(MAI && "Unable to create target asm info!");
MAI->setPreserveAsmComments(InputArgs.hasArg(OPT_preserve_comments));
- std::unique_ptr<MCSubtargetInfo> STI(TheTarget->createMCSubtargetInfo(
- TripleName, /*CPU=*/"", /*Features=*/""));
+ std::unique_ptr<MCSubtargetInfo> STI(
+ TheTarget->createMCSubtargetInfo(TheTriple, /*CPU=*/"",
/*Features=*/""));
assert(STI && "Unable to create subtarget info!");
// FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
diff --git a/llvm/tools/llvm-objdump/MachODump.cpp
b/llvm/tools/llvm-objdump/MachODump.cpp
index 8105a248a33be..fa41f6f59b7a8 100644
--- a/llvm/tools/llvm-objdump/MachODump.cpp
+++ b/llvm/tools/llvm-objdump/MachODump.cpp
@@ -127,7 +127,8 @@ void objdump::parseMachOOptions(const
llvm::opt::InputArgList &InputArgs) {
static const Target *GetTarget(const MachOObjectFile *MachOObj,
const char **McpuDefault,
- const Target **ThumbTarget) {
+ const Target **ThumbTarget,
+ Triple &ThumbTriple) {
// Figure out the target triple.
Triple TT(TripleName);
if (TripleName.empty()) {
@@ -138,7 +139,6 @@ static const Target *GetTarget(const MachOObjectFile
*MachOObj,
if (TT.getArch() == Triple::arm) {
// We've inferred a 32-bit ARM target from the object file. All MachO CPUs
// that support ARM are also capable of Thumb mode.
- Triple ThumbTriple = TT;
std::string ThumbName = (Twine("thumb") +
TT.getArchName().substr(3)).str();
ThumbTriple.setArchName(ThumbName);
ThumbTripleName = ThumbTriple.str();
@@ -7238,7 +7238,9 @@ static void DisassembleMachO(StringRef Filename,
MachOObjectFile *MachOOF,
StringRef DisSegName, StringRef DisSectName) {
const char *McpuDefault = nullptr;
const Target *ThumbTarget = nullptr;
- const Target *TheTarget = GetTarget(MachOOF, &McpuDefault, &ThumbTarget);
+ Triple ThumbTriple;
+ const Target *TheTarget =
+ GetTarget(MachOOF, &McpuDefault, &ThumbTarget, ThumbTriple);
if (!TheTarget) {
// GetTarget prints out stuff.
return;
@@ -7285,34 +7287,36 @@ static void DisassembleMachO(StringRef Filename,
MachOObjectFile *MachOOF,
FeaturesStr = Features.getString();
}
+ Triple TheTriple(TripleName);
+
MCTargetOptions MCOptions;
// Set up disassembler.
std::unique_ptr<const MCRegisterInfo> MRI(
- TheTarget->createMCRegInfo(TripleName));
+ TheTarget->createMCRegInfo(TheTriple));
CHECK_TARGET_INFO_CREATION(MRI);
std::unique_ptr<const MCAsmInfo> AsmInfo(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
CHECK_TARGET_INFO_CREATION(AsmInfo);
std::unique_ptr<const MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, MachOMCPU, FeaturesStr));
+ TheTarget->createMCSubtargetInfo(TheTriple, MachOMCPU, FeaturesStr));
CHECK_TARGET_INFO_CREATION(STI);
- MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), STI.get());
+ MCContext Ctx(TheTriple, AsmInfo.get(), MRI.get(), STI.get());
std::unique_ptr<MCDisassembler> DisAsm(
TheTarget->createMCDisassembler(*STI, Ctx));
CHECK_TARGET_INFO_CREATION(DisAsm);
std::unique_ptr<MCSymbolizer> Symbolizer;
struct DisassembleInfo SymbolizerInfo(nullptr, nullptr, nullptr, false);
std::unique_ptr<MCRelocationInfo> RelInfo(
- TheTarget->createMCRelocationInfo(TripleName, Ctx));
+ TheTarget->createMCRelocationInfo(TheTriple, Ctx));
if (RelInfo) {
Symbolizer.reset(TheTarget->createMCSymbolizer(
- TripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
- &SymbolizerInfo, &Ctx, std::move(RelInfo)));
+ TheTriple, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
&SymbolizerInfo,
+ &Ctx, std::move(RelInfo)));
DisAsm->setSymbolizer(std::move(Symbolizer));
}
int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
- Triple(TripleName), AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI));
+ TheTriple, AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI));
CHECK_TARGET_INFO_CREATION(IP);
// Set the display preference for hex vs. decimal immediates.
IP->setPrintImmHex(PrintImmHex);
@@ -7341,32 +7345,31 @@ static void DisassembleMachO(StringRef Filename,
MachOObjectFile *MachOOF,
struct DisassembleInfo ThumbSymbolizerInfo(nullptr, nullptr, nullptr, false);
std::unique_ptr<MCRelocationInfo> ThumbRelInfo;
if (ThumbTarget) {
- ThumbMRI.reset(ThumbTarget->createMCRegInfo(ThumbTripleName));
+ ThumbMRI.reset(ThumbTarget->createMCRegInfo(ThumbTriple));
CHECK_THUMB_TARGET_INFO_CREATION(ThumbMRI);
ThumbAsmInfo.reset(
- ThumbTarget->createMCAsmInfo(*ThumbMRI, ThumbTripleName, MCOptions));
+ ThumbTarget->createMCAsmInfo(*ThumbMRI, ThumbTriple, MCOptions));
CHECK_THUMB_TARGET_INFO_CREATION(ThumbAsmInfo);
- ThumbSTI.reset(
- ThumbTarget->createMCSubtargetInfo(ThumbTripleName, MachOMCPU,
- FeaturesStr));
+ ThumbSTI.reset(ThumbTarget->createMCSubtargetInfo(ThumbTriple, MachOMCPU,
+ FeaturesStr));
CHECK_THUMB_TARGET_INFO_CREATION(ThumbSTI);
- ThumbCtx.reset(new MCContext(Triple(ThumbTripleName), ThumbAsmInfo.get(),
+ ThumbCtx.reset(new MCContext(ThumbTriple, ThumbAsmInfo.get(),
ThumbMRI.get(), ThumbSTI.get()));
ThumbDisAsm.reset(ThumbTarget->createMCDisassembler(*ThumbSTI, *ThumbCtx));
CHECK_THUMB_TARGET_INFO_CREATION(ThumbDisAsm);
MCContext *PtrThumbCtx = ThumbCtx.get();
ThumbRelInfo.reset(
- ThumbTarget->createMCRelocationInfo(ThumbTripleName, *PtrThumbCtx));
+ ThumbTarget->createMCRelocationInfo(ThumbTriple, *PtrThumbCtx));
if (ThumbRelInfo) {
ThumbSymbolizer.reset(ThumbTarget->createMCSymbolizer(
- ThumbTripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
+ ThumbTriple, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
&ThumbSymbolizerInfo, PtrThumbCtx, std::move(ThumbRelInfo)));
ThumbDisAsm->setSymbolizer(std::move(ThumbSymbolizer));
}
int ThumbAsmPrinterVariant = ThumbAsmInfo->getAssemblerDialect();
ThumbIP.reset(ThumbTarget->createMCInstPrinter(
- Triple(ThumbTripleName), ThumbAsmPrinterVariant, *ThumbAsmInfo,
- *ThumbInstrInfo, *ThumbMRI));
+ ThumbTriple, ThumbAsmPrinterVariant, *ThumbAsmInfo, *ThumbInstrInfo,
+ *ThumbMRI));
CHECK_THUMB_TARGET_INFO_CREATION(ThumbIP);
// Set the display preference for hex vs. decimal immediates.
ThumbIP->setPrintImmHex(PrintImmHex);
diff --git a/llvm/tools/llvm-objdump/llvm-objdump.cpp
b/llvm/tools/llvm-objdump/llvm-objdump.cpp
index 815759dfec309..9a1ffbded7d13 100644
--- a/llvm/tools/llvm-objdump/llvm-objdump.cpp
+++ b/llvm/tools/llvm-objdump/llvm-objdump.cpp
@@ -1099,6 +1099,7 @@ PrettyPrinter &selectPrettyPrinter(Triple const &Triple) {
class DisassemblerTarget {
public:
const Target *TheTarget;
+ const Triple TheTriple;
std::unique_ptr<const MCSubtargetInfo> SubtargetInfo;
std::shared_ptr<MCContext> Context;
std::unique_ptr<MCDisassembler> DisAsm;
@@ -1122,18 +1123,19 @@ class DisassemblerTarget {
DisassemblerTarget::DisassemblerTarget(const Target *TheTarget, ObjectFile
&Obj,
StringRef TripleName, StringRef MCPU,
SubtargetFeatures &Features)
- : TheTarget(TheTarget), Printer(&selectPrettyPrinter(Triple(TripleName))),
- RegisterInfo(TheTarget->createMCRegInfo(TripleName)) {
+ : TheTarget(TheTarget), TheTriple(TripleName),
+ Printer(&selectPrettyPrinter(TheTriple)),
+ RegisterInfo(TheTarget->createMCRegInfo(TheTriple)) {
if (!RegisterInfo)
reportError(Obj.getFileName(), "no register info for target " +
TripleName);
// Set up disassembler.
- AsmInfo.reset(TheTarget->createMCAsmInfo(*RegisterInfo, TripleName,
Options));
+ AsmInfo.reset(TheTarget->createMCAsmInfo(*RegisterInfo, TheTriple, Options));
if (!AsmInfo)
reportError(Obj.getFileName(), "no assembly info for target " +
TripleName);
SubtargetInfo.reset(
- TheTarget->createMCSubtargetInfo(TripleName, MCPU,
Features.getString()));
+ TheTarget->createMCSubtargetInfo(TheTriple, MCPU, Features.getString()));
if (!SubtargetInfo)
reportError(Obj.getFileName(),
"no subtarget info for target " + TripleName);
@@ -1141,9 +1143,8 @@ DisassemblerTarget::DisassemblerTarget(const Target
*TheTarget, ObjectFile &Obj,
if (!InstrInfo)
reportError(Obj.getFileName(),
"no instruction info for target " + TripleName);
- Context =
- std::make_shared<MCContext>(Triple(TripleName), AsmInfo.get(),
- RegisterInfo.get(), SubtargetInfo.get());
+ Context = std::make_shared<MCContext>(
+ TheTriple, AsmInfo.get(), RegisterInfo.get(), SubtargetInfo.get());
// FIXME: for now initialize MCObjectFileInfo with default values
ObjectFileInfo.reset(
@@ -1160,9 +1161,8 @@ DisassemblerTarget::DisassemblerTarget(const Target
*TheTarget, ObjectFile &Obj,
InstrAnalysis.reset(TheTarget->createMCInstrAnalysis(InstrInfo.get()));
int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
- InstPrinter.reset(TheTarget->createMCInstPrinter(Triple(TripleName),
- AsmPrinterVariant, *AsmInfo,
- *InstrInfo, *RegisterInfo));
+ InstPrinter.reset(TheTarget->createMCInstPrinter(
+ TheTriple, AsmPrinterVariant, *AsmInfo, *InstrInfo, *RegisterInfo));
if (!InstPrinter)
reportError(Obj.getFileName(),
"no instruction printer for target " + TripleName);
@@ -1188,7 +1188,7 @@ DisassemblerTarget::DisassemblerTarget(const Target
*TheTarget, ObjectFile &Obj,
DisassemblerTarget::DisassemblerTarget(DisassemblerTarget &Other,
SubtargetFeatures &Features)
: TheTarget(Other.TheTarget),
- SubtargetInfo(TheTarget->createMCSubtargetInfo(TripleName, MCPU,
+ SubtargetInfo(TheTarget->createMCSubtargetInfo(TheTriple, MCPU,
Features.getString())),
Context(Other.Context),
DisAsm(TheTarget->createMCDisassembler(*SubtargetInfo, *Context)),
@@ -1615,17 +1615,17 @@ collectLocalBranchTargets(ArrayRef<uint8_t> Bytes,
MCInstrAnalysis *MIA,
// This is currently only used on AMDGPU, and assumes the format of the
// void * argument passed to AMDGPU's createMCSymbolizer.
static void addSymbolizer(
- MCContext &Ctx, const Target *Target, StringRef TripleName,
+ MCContext &Ctx, const Target *Target, const Triple &TheTriple,
MCDisassembler *DisAsm, uint64_t SectionAddr, ArrayRef<uint8_t> Bytes,
SectionSymbolsTy &Symbols,
std::vector<std::unique_ptr<std::string>> &SynthesizedLabelNames) {
std::unique_ptr<MCRelocationInfo> RelInfo(
- Target->createMCRelocationInfo(TripleName, Ctx));
+ Target->createMCRelocationInfo(TheTriple, Ctx));
if (!RelInfo)
return;
std::unique_ptr<MCSymbolizer> Symbolizer(Target->createMCSymbolizer(
- TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
+ TheTriple, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
MCSymbolizer *SymbolizerPtr = &*Symbolizer;
DisAsm->setSymbolizer(std::move(Symbolizer));
@@ -1662,9 +1662,9 @@ static void addSymbolizer(
}
llvm::stable_sort(Symbols);
// Recreate the symbolizer with the new symbols list.
- RelInfo.reset(Target->createMCRelocationInfo(TripleName, Ctx));
+ RelInfo.reset(Target->createMCRelocationInfo(TheTriple, Ctx));
Symbolizer.reset(Target->createMCSymbolizer(
- TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
+ TheTriple, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
DisAsm->setSymbolizer(std::move(Symbolizer));
}
@@ -1973,8 +1973,9 @@ disassembleObject(ObjectFile &Obj, const ObjectFile
&DbgObj,
std::vector<std::unique_ptr<std::string>> SynthesizedLabelNames;
if (Obj.isELF() && Obj.getArch() == Triple::amdgcn) {
// AMDGPU disassembler uses symbolizer for printing labels
- addSymbolizer(*DT->Context, DT->TheTarget, TripleName, DT->DisAsm.get(),
- SectionAddr, Bytes, Symbols, SynthesizedLabelNames);
+ addSymbolizer(*DT->Context, DT->TheTarget, DT->TheTriple,
+ DT->DisAsm.get(), SectionAddr, Bytes, Symbols,
+ SynthesizedLabelNames);
}
StringRef SegmentName = getSegmentName(MachO, Section);
diff --git a/llvm/tools/llvm-profgen/ProfiledBinary.cpp
b/llvm/tools/llvm-profgen/ProfiledBinary.cpp
index 31cac4d5c7721..0f3ece275e6f5 100644
--- a/llvm/tools/llvm-profgen/ProfiledBinary.cpp
+++ b/llvm/tools/llvm-profgen/ProfiledBinary.cpp
@@ -628,43 +628,43 @@ bool ProfiledBinary::dissassembleSymbol(std::size_t SI,
ArrayRef<uint8_t> Bytes,
void ProfiledBinary::setUpDisassembler(const ObjectFile *Obj) {
const Target *TheTarget = getTarget(Obj);
- std::string TripleName = TheTriple.getTriple();
StringRef FileName = Obj->getFileName();
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
- exitWithError("no register info for target " + TripleName, FileName);
+ exitWithError("no register info for target " + TheTriple.str(), FileName);
MCTargetOptions MCOptions;
- AsmInfo.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ AsmInfo.reset(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!AsmInfo)
- exitWithError("no assembly info for target " + TripleName, FileName);
+ exitWithError("no assembly info for target " + TheTriple.str(), FileName);
Expected<SubtargetFeatures> Features = Obj->getFeatures();
if (!Features)
exitWithError(Features.takeError(), FileName);
STI.reset(
- TheTarget->createMCSubtargetInfo(TripleName, "", Features->getString()));
+ TheTarget->createMCSubtargetInfo(TheTriple, "", Features->getString()));
if (!STI)
- exitWithError("no subtarget info for target " + TripleName, FileName);
+ exitWithError("no subtarget info for target " + TheTriple.str(), FileName);
MII.reset(TheTarget->createMCInstrInfo());
if (!MII)
- exitWithError("no instruction info for target " + TripleName, FileName);
+ exitWithError("no instruction info for target " + TheTriple.str(),
+ FileName);
- MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), STI.get());
+ MCContext Ctx(TheTriple, AsmInfo.get(), MRI.get(), STI.get());
std::unique_ptr<MCObjectFileInfo> MOFI(
TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
Ctx.setObjectFileInfo(MOFI.get());
DisAsm.reset(TheTarget->createMCDisassembler(*STI, Ctx));
if (!DisAsm)
- exitWithError("no disassembler for target " + TripleName, FileName);
+ exitWithError("no disassembler for target " + TheTriple.str(), FileName);
MIA.reset(TheTarget->createMCInstrAnalysis(MII.get()));
int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
- IPrinter.reset(TheTarget->createMCInstPrinter(
- Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
+ IPrinter.reset(TheTarget->createMCInstPrinter(TheTriple, AsmPrinterVariant,
+ *AsmInfo, *MII, *MRI));
IPrinter->setPrintBranchImmAsAddress(true);
}
diff --git a/llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp
b/llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp
index aa44f35a2d9cc..922241eb9da62 100644
--- a/llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp
+++ b/llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp
@@ -793,21 +793,21 @@ static int linkAndVerify() {
TripleName = TheTriple.getTriple();
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, MCPU, ""));
+ TheTarget->createMCSubtargetInfo(TheTriple, MCPU, ""));
if (!STI)
ErrorAndExit("Unable to create subtarget info!");
- std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
ErrorAndExit("Unable to create target register info!");
MCTargetOptions MCOptions;
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI)
ErrorAndExit("Unable to create target asm info!");
- MCContext Ctx(Triple(TripleName), MAI.get(), MRI.get(), STI.get());
+ MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get());
std::unique_ptr<MCDisassembler> Disassembler(
TheTarget->createMCDisassembler(*STI, Ctx));
@@ -819,7 +819,7 @@ static int linkAndVerify() {
ErrorAndExit("Unable to create target instruction info!");
std::unique_ptr<MCInstPrinter> InstPrinter(
- TheTarget->createMCInstPrinter(Triple(TripleName), 0, *MAI, *MII, *MRI));
+ TheTarget->createMCInstPrinter(TheTriple, 0, *MAI, *MII, *MRI));
// Load any dylibs requested on the command line.
loadDylibs();
diff --git a/llvm/tools/sancov/sancov.cpp b/llvm/tools/sancov/sancov.cpp
index 38893cf974a10..b57a9d703459a 100644
--- a/llvm/tools/sancov/sancov.cpp
+++ b/llvm/tools/sancov/sancov.cpp
@@ -710,16 +710,16 @@ static void getObjectCoveragePoints(const
object::ObjectFile &O,
failIfNotEmpty(Error);
std::unique_ptr<const MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ TheTarget->createMCSubtargetInfo(TheTriple, "", ""));
failIfEmpty(STI, "no subtarget info for target " + TripleName);
std::unique_ptr<const MCRegisterInfo> MRI(
- TheTarget->createMCRegInfo(TripleName));
+ TheTarget->createMCRegInfo(TheTriple));
failIfEmpty(MRI, "no register info for target " + TripleName);
MCTargetOptions MCOptions;
std::unique_ptr<const MCAsmInfo> AsmInfo(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
failIfEmpty(AsmInfo, "no asm info for target " + TripleName);
MCContext Ctx(TheTriple, AsmInfo.get(), MRI.get(), STI.get());
diff --git
a/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp
b/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp
index 3e0cc8fed84c0..db7690668facc 100644
--- a/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp
@@ -42,7 +42,7 @@ class DWARFExpressionCompactPrinterTest : public
::testing::Test {
if (!TheTarget)
return;
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(Triple(TripleName)));
}
void TestExprPrinter(ArrayRef<uint8_t> ExprData, StringRef Expected);
diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCopyBytesTest.cpp
b/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCopyBytesTest.cpp
index 78d383ed0b22e..b67dd6a9d237d 100644
--- a/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCopyBytesTest.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCopyBytesTest.cpp
@@ -45,13 +45,15 @@ namespace {
/// debug info from input to output binary.
class DWARFExpressionCopyBytesTest : public ::testing::Test {
public:
- const char *TripleName = "x86_64-pc-linux";
+ static constexpr char TripleName[] = "x86_64-pc-linux";
+ Triple TheTriple;
+
std::unique_ptr<MCRegisterInfo> MRI;
std::unique_ptr<MCAsmInfo> MAI;
std::unique_ptr<const MCSubtargetInfo> STI;
const Target *TheTarget;
- DWARFExpressionCopyBytesTest() {
+ DWARFExpressionCopyBytesTest() : TheTriple(TripleName) {
InitializeAllTargets();
InitializeAllTargetMCs();
InitializeAllAsmPrinters();
@@ -61,9 +63,9 @@ class DWARFExpressionCopyBytesTest : public ::testing::Test {
if (!TheTarget)
return;
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCTargetOptions()));
- STI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ MRI.reset(TheTarget->createMCRegInfo(TheTriple));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCTargetOptions()));
+ STI.reset(TheTarget->createMCSubtargetInfo(TheTriple, "", ""));
}
struct StreamerContext {
diff --git a/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
index f8d161d8c50b6..6f1935a4588ed 100644
--- a/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
@@ -454,19 +454,19 @@ llvm::Error dwarfgen::Generator::init(Triple TheTriple,
uint16_t V) {
TripleName = TheTriple.getTriple();
// Create all the MC Objects.
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TheTriple));
if (!MRI)
return make_error<StringError>(Twine("no register info for target ") +
TripleName,
inconvertibleErrorCode());
MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
if (!MAI)
return make_error<StringError>("no asm info for target " + TripleName,
inconvertibleErrorCode());
- MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ MSTI.reset(TheTarget->createMCSubtargetInfo(TheTriple, "", ""));
if (!MSTI)
return make_error<StringError>("no subtarget info for target " +
TripleName,
inconvertibleErrorCode());
diff --git a/llvm/unittests/MC/AMDGPU/Disassembler.cpp
b/llvm/unittests/MC/AMDGPU/Disassembler.cpp
index 23413030136ab..7174ad54c8248 100644
--- a/llvm/unittests/MC/AMDGPU/Disassembler.cpp
+++ b/llvm/unittests/MC/AMDGPU/Disassembler.cpp
@@ -32,8 +32,8 @@ static const char *symbolLookupCallback(void *DisInfo,
uint64_t ReferenceValue,
return nullptr;
}
-static const char *TripleName = "amdgcn--amdpal";
-static const char *CPUName = "gfx1030";
+static constexpr char TripleName[] = "amdgcn--amdpal";
+static constexpr char CPUName[] = "gfx1030";
// Basic smoke test.
TEST(AMDGPUDisassembler, Basic) {
@@ -77,18 +77,19 @@ TEST(AMDGPUDisassembler, MultiDisassembler) {
if (!TheTarget)
GTEST_SKIP();
- std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+ Triple TT(TripleName);
+
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCTargetOptions()));
+ TheTarget->createMCAsmInfo(*MRI, TT, MCTargetOptions()));
std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, CPUName, ""));
- auto Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(),
- MRI.get(), STI.get());
+ TheTarget->createMCSubtargetInfo(TT, CPUName, ""));
+ auto Ctx = std::make_unique<MCContext>(TT, MAI.get(), MRI.get(), STI.get());
int AsmPrinterVariant = MAI->getAssemblerDialect();
- std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
- Triple(TripleName), AsmPrinterVariant, *MAI, *MII, *MRI));
+ std::unique_ptr<MCInstPrinter> IP(
+ TheTarget->createMCInstPrinter(TT, AsmPrinterVariant, *MAI, *MII, *MRI));
SmallVector<char, 64> InsnStr, AnnoStr;
raw_svector_ostream OS(InsnStr);
@@ -147,14 +148,15 @@ TEST(AMDGPUDisassembler, UCVersionOverride) {
if (!TheTarget)
GTEST_SKIP();
- std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+ Triple TT(TripleName);
+
+ std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
std::unique_ptr<MCAsmInfo> MAI(
- TheTarget->createMCAsmInfo(*MRI, TripleName, MCTargetOptions()));
+ TheTarget->createMCAsmInfo(*MRI, TT, MCTargetOptions()));
std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, CPUName, ""));
- auto Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(),
- MRI.get(), STI.get());
+ TheTarget->createMCSubtargetInfo(TT, CPUName, ""));
+ auto Ctx = std::make_unique<MCContext>(TT, MAI.get(), MRI.get(), STI.get());
// Define custom UC_VERSION before initializing disassembler.
const uint8_t UC_VERSION_GFX10_DEFAULT = 0x04;
@@ -163,8 +165,8 @@ TEST(AMDGPUDisassembler, UCVersionOverride) {
Sym->setVariableValue(MCConstantExpr::create(UC_VERSION_GFX10_NEW, *Ctx));
int AsmPrinterVariant = MAI->getAssemblerDialect();
- std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
- Triple(TripleName), AsmPrinterVariant, *MAI, *MII, *MRI));
+ std::unique_ptr<MCInstPrinter> IP(
+ TheTarget->createMCInstPrinter(TT, AsmPrinterVariant, *MAI, *MII, *MRI));
testing::internal::CaptureStderr();
std::unique_ptr<MCDisassembler> DisAsm(
diff --git a/llvm/unittests/MC/DwarfLineTableHeaders.cpp
b/llvm/unittests/MC/DwarfLineTableHeaders.cpp
index 1fad1ba6ce638..fec8b438ee5db 100644
--- a/llvm/unittests/MC/DwarfLineTableHeaders.cpp
+++ b/llvm/unittests/MC/DwarfLineTableHeaders.cpp
@@ -36,7 +36,8 @@ namespace {
class DwarfLineTableHeaders : public ::testing::Test {
public:
- const char *TripleName = "x86_64-pc-linux";
+ static constexpr char TripleName[] = "x86_64-pc-linux";
+ Triple TT;
std::unique_ptr<MCRegisterInfo> MRI;
std::unique_ptr<MCAsmInfo> MAI;
std::unique_ptr<const MCSubtargetInfo> STI;
@@ -49,7 +50,7 @@ class DwarfLineTableHeaders : public ::testing::Test {
std::unique_ptr<MCStreamer> Streamer;
};
- DwarfLineTableHeaders() {
+ DwarfLineTableHeaders() : TT(TripleName) {
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();
@@ -60,18 +61,17 @@ class DwarfLineTableHeaders : public ::testing::Test {
if (!TheTarget)
return;
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TT));
MCTargetOptions MCOptions;
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
- STI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
+ STI.reset(TheTarget->createMCSubtargetInfo(TT, "", ""));
}
/// Create all data structures necessary to operate an assembler
StreamerContext createStreamer(raw_pwrite_stream &OS) {
StreamerContext Res;
- Res.Ctx =
- std::make_unique<MCContext>(Triple(TripleName), MAI.get(), MRI.get(),
- /*MSTI=*/nullptr);
+ Res.Ctx = std::make_unique<MCContext>(TT, MAI.get(), MRI.get(),
+ /*MSTI=*/nullptr);
Res.MOFI.reset(TheTarget->createMCObjectFileInfo(*Res.Ctx,
/*PIC=*/false));
Res.Ctx->setObjectFileInfo(Res.MOFI.get());
@@ -82,8 +82,8 @@ class DwarfLineTableHeaders : public ::testing::Test {
TheTarget->createMCAsmBackend(*STI, *MRI, MCTargetOptions());
std::unique_ptr<MCObjectWriter> OW = MAB->createObjectWriter(OS);
Res.Streamer.reset(TheTarget->createMCObjectStreamer(
- Triple(TripleName), *Res.Ctx, std::unique_ptr<MCAsmBackend>(MAB),
- std::move(OW), std::unique_ptr<MCCodeEmitter>(MCE), *STI));
+ TT, *Res.Ctx, std::unique_ptr<MCAsmBackend>(MAB), std::move(OW),
+ std::unique_ptr<MCCodeEmitter>(MCE), *STI));
return Res;
}
diff --git a/llvm/unittests/MC/DwarfLineTables.cpp
b/llvm/unittests/MC/DwarfLineTables.cpp
index 0b604bb4c3a9f..479b4a896dcd0 100644
--- a/llvm/unittests/MC/DwarfLineTables.cpp
+++ b/llvm/unittests/MC/DwarfLineTables.cpp
@@ -22,26 +22,27 @@ using namespace llvm;
namespace {
struct Context {
- const char *TripleName = "x86_64-pc-linux";
+ static constexpr char TripleName[] = "x86_64-pc-linux";
+ Triple TT;
std::unique_ptr<MCRegisterInfo> MRI;
std::unique_ptr<MCAsmInfo> MAI;
std::unique_ptr<MCContext> Ctx;
- Context() {
+ Context() : TT(TripleName) {
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();
// If we didn't build x86, do not run the test.
std::string Error;
- const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
+ const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
if (!TheTarget)
return;
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TT));
MCTargetOptions MCOptions;
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
- Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(), MRI.get(),
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
+ Ctx = std::make_unique<MCContext>(TT, MAI.get(), MRI.get(),
/*MSTI=*/nullptr);
}
diff --git a/llvm/unittests/MC/MCInstPrinter.cpp
b/llvm/unittests/MC/MCInstPrinter.cpp
index 9002045d539f4..0b7c3fa9cc11a 100644
--- a/llvm/unittests/MC/MCInstPrinter.cpp
+++ b/llvm/unittests/MC/MCInstPrinter.cpp
@@ -31,7 +31,8 @@ class MCInstPrinterTest : public ::testing::Test {
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
- std::string TripleName = "x86_64-pc-linux";
+ StringRef TripleName = "x86_64-pc-linux";
+ Triple TT(TripleName);
std::string ErrorStr;
const Target *TheTarget =
@@ -41,12 +42,12 @@ class MCInstPrinterTest : public ::testing::Test {
if (!TheTarget)
return;
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TT));
MCTargetOptions MCOptions;
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
MII.reset(TheTarget->createMCInstrInfo());
- Printer.reset(TheTarget->createMCInstPrinter(
- Triple(TripleName), MAI->getAssemblerDialect(), *MAI, *MII, *MRI));
+ Printer.reset(TheTarget->createMCInstPrinter(TT,
MAI->getAssemblerDialect(),
+ *MAI, *MII, *MRI));
}
template <typename T> std::string formatHex(T i) {
diff --git a/llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp
b/llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp
index 4635fc92fd41e..6480f60b3667d 100644
--- a/llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp
+++ b/llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp
@@ -46,34 +46,33 @@ class SystemZAsmLexerTest : public ::testing::Test {
std::unique_ptr<MCTargetAsmParser> TargetAsmParser;
SourceMgr SrcMgr;
- std::string TripleName;
- llvm::Triple Triple;
+ StringRef TripleName;
+ const llvm::Triple Triple;
const Target *TheTarget;
const MCTargetOptions MCOptions;
SystemZAsmLexerTest() = delete;
- SystemZAsmLexerTest(std::string SystemZTriple) {
+ SystemZAsmLexerTest(StringRef SystemZTriple)
+ : TripleName(SystemZTriple), Triple(SystemZTriple) {
// We will use the SystemZ triple, because of missing
// Object File and Streamer support for the z/OS target.
- TripleName = SystemZTriple;
- Triple = llvm::Triple(TripleName);
std::string Error;
TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
EXPECT_NE(TheTarget, nullptr);
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(Triple));
EXPECT_NE(MRI, nullptr);
MII.reset(TheTarget->createMCInstrInfo());
EXPECT_NE(MII, nullptr);
- STI.reset(TheTarget->createMCSubtargetInfo(TripleName, "z10", ""));
+ STI.reset(TheTarget->createMCSubtargetInfo(Triple, "z10", ""));
EXPECT_NE(STI, nullptr);
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, Triple, MCOptions));
EXPECT_NE(MAI, nullptr);
}
diff --git a/llvm/unittests/MC/SystemZ/SystemZMCDisassemblerTest.cpp
b/llvm/unittests/MC/SystemZ/SystemZMCDisassemblerTest.cpp
index df59fcb402e21..2e98252146579 100644
--- a/llvm/unittests/MC/SystemZ/SystemZMCDisassemblerTest.cpp
+++ b/llvm/unittests/MC/SystemZ/SystemZMCDisassemblerTest.cpp
@@ -23,14 +23,15 @@ using namespace llvm;
namespace {
struct Context {
- const char *TripleName = "systemz-unknown";
+ static constexpr char TripleName[] = "systemz-unknown";
+ Triple TT;
std::unique_ptr<MCRegisterInfo> MRI;
std::unique_ptr<MCAsmInfo> MAI;
std::unique_ptr<MCContext> Ctx;
std::unique_ptr<MCSubtargetInfo> STI;
std::unique_ptr<MCDisassembler> DisAsm;
- Context() {
+ Context() : TT(TripleName) {
LLVMInitializeSystemZTargetInfo();
LLVMInitializeSystemZTargetMC();
LLVMInitializeSystemZDisassembler();
@@ -41,11 +42,10 @@ struct Context {
if (!TheTarget)
return;
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCTargetOptions()));
- STI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
- Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(), MRI.get(),
- STI.get());
+ MRI.reset(TheTarget->createMCRegInfo(TT));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TT, MCTargetOptions()));
+ STI.reset(TheTarget->createMCSubtargetInfo(TT, "", ""));
+ Ctx = std::make_unique<MCContext>(TT, MAI.get(), MRI.get(), STI.get());
DisAsm.reset(TheTarget->createMCDisassembler(*STI, *Ctx));
}
diff --git a/llvm/unittests/MC/X86/X86MCDisassemblerTest.cpp
b/llvm/unittests/MC/X86/X86MCDisassemblerTest.cpp
index 5ae10bb7ace7a..a028a164595e1 100644
--- a/llvm/unittests/MC/X86/X86MCDisassemblerTest.cpp
+++ b/llvm/unittests/MC/X86/X86MCDisassemblerTest.cpp
@@ -23,14 +23,15 @@ using namespace llvm;
namespace {
struct Context {
- const char *TripleName = "x86_64-unknown-elf";
+ static constexpr char TripleName[] = "x86_64-unknown-elf";
+ const Triple TheTriple;
std::unique_ptr<MCRegisterInfo> MRI;
std::unique_ptr<MCAsmInfo> MAI;
std::unique_ptr<MCContext> Ctx;
std::unique_ptr<MCSubtargetInfo> STI;
std::unique_ptr<MCDisassembler> DisAsm;
- Context() {
+ Context() : TheTriple(TripleName) {
LLVMInitializeX86TargetInfo();
LLVMInitializeX86TargetMC();
LLVMInitializeX86Disassembler();
@@ -41,11 +42,11 @@ struct Context {
if (!TheTarget)
return;
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCTargetOptions()));
- STI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
- Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(), MRI.get(),
- STI.get());
+ MRI.reset(TheTarget->createMCRegInfo(TheTriple));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCTargetOptions()));
+ STI.reset(TheTarget->createMCSubtargetInfo(TheTriple, "", ""));
+ Ctx =
+ std::make_unique<MCContext>(TheTriple, MAI.get(), MRI.get(),
STI.get());
DisAsm.reset(TheTarget->createMCDisassembler(*STI, *Ctx));
}
diff --git a/llvm/unittests/tools/llvm-exegesis/AArch64/TargetTest.cpp
b/llvm/unittests/tools/llvm-exegesis/AArch64/TargetTest.cpp
index ca5416eef39d5..635b3eeff72ad 100644
--- a/llvm/unittests/tools/llvm-exegesis/AArch64/TargetTest.cpp
+++ b/llvm/unittests/tools/llvm-exegesis/AArch64/TargetTest.cpp
@@ -32,14 +32,16 @@ constexpr const char kTriple[] = "aarch64-unknown-linux";
class AArch64TargetTest : public ::testing::Test {
protected:
+ const Triple TT;
+
AArch64TargetTest()
- : ExegesisTarget_(ExegesisTarget::lookup(Triple(kTriple))) {
+ : TT(kTriple), ExegesisTarget_(ExegesisTarget::lookup(TT)) {
EXPECT_THAT(ExegesisTarget_, NotNull());
std::string error;
Target_ = TargetRegistry::lookupTarget(kTriple, error);
EXPECT_THAT(Target_, NotNull());
STI_.reset(
- Target_->createMCSubtargetInfo(kTriple, "generic", /*no features*/
""));
+ Target_->createMCSubtargetInfo(TT, "generic", /*no features*/ ""));
}
static void SetUpTestCase() {
diff --git a/llvm/unittests/tools/llvm-exegesis/PowerPC/AnalysisTest.cpp
b/llvm/unittests/tools/llvm-exegesis/PowerPC/AnalysisTest.cpp
index 1aca1cb974a63..47314e2174cc1 100644
--- a/llvm/unittests/tools/llvm-exegesis/PowerPC/AnalysisTest.cpp
+++ b/llvm/unittests/tools/llvm-exegesis/PowerPC/AnalysisTest.cpp
@@ -26,9 +26,11 @@ using testing::UnorderedElementsAre;
class PPCAnalysisTest : public ::testing::Test {
protected:
PPCAnalysisTest() {
- const std::string TT = "powerpc64le-unknown-linux";
+ const StringRef TripleName = "powerpc64le-unknown-linux";
+ const Triple TT(TripleName);
std::string error;
- const Target *const TheTarget = TargetRegistry::lookupTarget(TT, error);
+ const Target *const TheTarget =
+ TargetRegistry::lookupTarget(TripleName, error);
if (!TheTarget) {
errs() << error << "\n";
return;
diff --git a/llvm/unittests/tools/llvm-exegesis/PowerPC/TargetTest.cpp
b/llvm/unittests/tools/llvm-exegesis/PowerPC/TargetTest.cpp
index da24ae8cae2a4..959086f5887f1 100644
--- a/llvm/unittests/tools/llvm-exegesis/PowerPC/TargetTest.cpp
+++ b/llvm/unittests/tools/llvm-exegesis/PowerPC/TargetTest.cpp
@@ -33,8 +33,10 @@ constexpr const char kTriple[] = "powerpc64le-unknown-linux";
class PowerPCTargetTest : public PPCTestBase {
protected:
+ const Triple TT;
+
PowerPCTargetTest()
- : ExegesisTarget_(ExegesisTarget::lookup(Triple(kTriple))) {
+ : TT(kTriple), ExegesisTarget_(ExegesisTarget::lookup(TT)) {
EXPECT_THAT(ExegesisTarget_, NotNull());
std::string error;
Target_ = TargetRegistry::lookupTarget(kTriple, error);
@@ -47,7 +49,7 @@ class PowerPCTargetTest : public PPCTestBase {
TEST_F(PowerPCTargetTest, SetRegToConstant) {
const std::unique_ptr<MCSubtargetInfo> STI(
- Target_->createMCSubtargetInfo(kTriple, "generic", ""));
+ Target_->createMCSubtargetInfo(TT, "generic", ""));
const auto Insts = ExegesisTarget_->setRegTo(*STI, PPC::X0, APInt());
EXPECT_THAT(Insts, Not(IsEmpty()));
}
diff --git a/llvm/unittests/tools/llvm-mca/MCATestBase.cpp
b/llvm/unittests/tools/llvm-mca/MCATestBase.cpp
index cd3258ef96d64..2b8415b13cf45 100644
--- a/llvm/unittests/tools/llvm-mca/MCATestBase.cpp
+++ b/llvm/unittests/tools/llvm-mca/MCATestBase.cpp
@@ -31,17 +31,15 @@ void MCATestBase::SetUp() {
TheTarget = getLLVMTarget();
ASSERT_NE(TheTarget, nullptr);
- StringRef TripleName = TheTriple.getTriple();
-
- STI.reset(TheTarget->createMCSubtargetInfo(TripleName, CPUName, MAttr));
+ STI.reset(TheTarget->createMCSubtargetInfo(TheTriple, CPUName, MAttr));
ASSERT_TRUE(STI);
ASSERT_TRUE(STI->isCPUStringValid(CPUName));
- MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ MRI.reset(TheTarget->createMCRegInfo(TheTriple));
ASSERT_TRUE(MRI);
auto MCOptions = getMCTargetOptions();
- MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
ASSERT_TRUE(MAI);
Ctx = std::make_unique<MCContext>(TheTriple, MAI.get(), MRI.get(),
STI.get());
diff --git a/mlir/lib/Target/LLVM/ROCDL/Target.cpp
b/mlir/lib/Target/LLVM/ROCDL/Target.cpp
index fc839e6674df8..c9888c39ac891 100644
--- a/mlir/lib/Target/LLVM/ROCDL/Target.cpp
+++ b/mlir/lib/Target/LLVM/ROCDL/Target.cpp
@@ -299,12 +299,11 @@ SerializeGPUModuleBase::assembleIsa(StringRef isa) {
srcMgr.AddNewSourceBuffer(llvm::MemoryBuffer::getMemBuffer(isa), SMLoc());
const llvm::MCTargetOptions mcOptions;
- std::unique_ptr<llvm::MCRegisterInfo> mri(
- target->createMCRegInfo(targetTriple));
+ std::unique_ptr<llvm::MCRegisterInfo> mri(target->createMCRegInfo(triple));
std::unique_ptr<llvm::MCAsmInfo> mai(
- target->createMCAsmInfo(*mri, targetTriple, mcOptions));
+ target->createMCAsmInfo(*mri, triple, mcOptions));
std::unique_ptr<llvm::MCSubtargetInfo> sti(
- target->createMCSubtargetInfo(targetTriple, chip, features));
+ target->createMCSubtargetInfo(triple, chip, features));
llvm::MCContext ctx(triple, mai.get(), mri.get(), sti.get(), &srcMgr,
&mcOptions);
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
