[llvm] a8f8613 - Introduce and use codegen::createTargetMachineForTriple()
Alex Richardson via llvm-commits
llvm-commits at lists.llvm.org
Wed Oct 4 13:45:48 PDT 2023
Author: Alex Richardson
Date: 2023-10-04T13:45:16-07:00
New Revision: a8f8613dec435cfb78bf202c392f2acf150a5937
URL: https://github.com/llvm/llvm-project/commit/a8f8613dec435cfb78bf202c392f2acf150a5937
DIFF: https://github.com/llvm/llvm-project/commit/a8f8613dec435cfb78bf202c392f2acf150a5937.diff
LOG: Introduce and use codegen::createTargetMachineForTriple()
This creates a TargetMachine with the default options (from the command
line flags). This allows us to share a bit more code between tools.
Differential Revision: https://reviews.llvm.org/D141057
Added:
Modified:
llvm/include/llvm/CodeGen/CommandFlags.h
llvm/lib/CodeGen/CommandFlags.cpp
llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp
llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp
llvm/tools/llvm-reduce/ReducerWorkItem.cpp
llvm/tools/opt/opt.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/CodeGen/CommandFlags.h b/llvm/include/llvm/CodeGen/CommandFlags.h
index 732d6d0211c9969..918e69352effe79 100644
--- a/llvm/include/llvm/CodeGen/CommandFlags.h
+++ b/llvm/include/llvm/CodeGen/CommandFlags.h
@@ -28,6 +28,7 @@ class Module;
class AttrBuilder;
class Function;
class Triple;
+class TargetMachine;
namespace codegen {
@@ -186,6 +187,14 @@ void setFunctionAttributes(StringRef CPU, StringRef Features, Module &M);
/// Should value-tracking variable locations / instruction referencing be
/// enabled by default for this triple?
bool getDefaultValueTrackingVariableLocations(const llvm::Triple &T);
+
+/// Creates a TargetMachine instance with the options defined on the command
+/// line. This can be used for tools that do not need further customization of
+/// the TargetOptions.
+Expected<std::unique_ptr<TargetMachine>> createTargetMachineForTriple(
+ StringRef TargetTriple,
+ CodeGenOptLevel OptLevel = CodeGenOptLevel::Default);
+
} // namespace codegen
} // namespace llvm
diff --git a/llvm/lib/CodeGen/CommandFlags.cpp b/llvm/lib/CodeGen/CommandFlags.cpp
index 1eba979f83db0c9..c6d7827f36dfd63 100644
--- a/llvm/lib/CodeGen/CommandFlags.cpp
+++ b/llvm/lib/CodeGen/CommandFlags.cpp
@@ -18,8 +18,10 @@
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCTargetOptionsCommandFlags.h"
+#include "llvm/MC/TargetRegistry.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Target/TargetMachine.h"
#include "llvm/TargetParser/Host.h"
#include "llvm/TargetParser/SubtargetFeature.h"
#include "llvm/TargetParser/Triple.h"
@@ -732,3 +734,24 @@ void codegen::setFunctionAttributes(StringRef CPU, StringRef Features,
for (Function &F : M)
setFunctionAttributes(CPU, Features, F);
}
+
+Expected<std::unique_ptr<TargetMachine>>
+codegen::createTargetMachineForTriple(StringRef TargetTriple,
+ CodeGenOptLevel OptLevel) {
+ Triple TheTriple(TargetTriple);
+ std::string Error;
+ const auto *TheTarget =
+ TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
+ if (!TheTarget)
+ return createStringError(inconvertibleErrorCode(), Error);
+ auto *Target = TheTarget->createTargetMachine(
+ TheTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
+ codegen::InitTargetOptionsFromCodeGenFlags(TheTriple),
+ codegen::getExplicitRelocModel(), codegen::getExplicitCodeModel(),
+ OptLevel);
+ if (!Target)
+ return createStringError(inconvertibleErrorCode(),
+ Twine("could not allocate target machine for ") +
+ TargetTriple);
+ return std::unique_ptr<TargetMachine>(Target);
+}
diff --git a/llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp b/llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp
index 9f47609394a5d36..742f7b94e116f32 100644
--- a/llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp
+++ b/llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp
@@ -129,20 +129,7 @@ extern "C" LLVM_ATTRIBUTE_USED int LLVMFuzzerInitialize(int *argc,
exit(1);
}
- Triple TheTriple = Triple(Triple::normalize(TargetTriple));
-
- // Get the target specific parser.
- std::string Error;
- const Target *TheTarget =
- TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
- if (!TheTarget) {
- errs() << argv[0] << ": " << Error;
- return 1;
- }
-
// Set up the pipeline like llc does.
- std::string CPUStr = codegen::getCPUStr(),
- FeaturesStr = codegen::getFeaturesStr();
CodeGenOptLevel OLvl;
if (auto Level = CodeGenOpt::parseLevel(OptLevel)) {
@@ -151,11 +138,9 @@ extern "C" LLVM_ATTRIBUTE_USED int LLVMFuzzerInitialize(int *argc,
errs() << argv[0] << ": invalid optimization level.\n";
return 1;
}
-
- TargetOptions Options = codegen::InitTargetOptionsFromCodeGenFlags(TheTriple);
- TM.reset(TheTarget->createTargetMachine(
- TheTriple.getTriple(), CPUStr, FeaturesStr, Options,
- codegen::getExplicitRelocModel(), codegen::getExplicitCodeModel(), OLvl));
+ ExitOnError ExitOnErr(std::string(*argv[0]) + ": error:");
+ TM = ExitOnErr(codegen::createTargetMachineForTriple(
+ Triple::normalize(TargetTriple), OLvl));
assert(TM && "Could not allocate target machine!");
// Make sure we print the summary and the current unit when LLVM errors out.
diff --git a/llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp b/llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp
index 0b2cb9598e5bf6f..fcccf0e07ef8d2b 100644
--- a/llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp
+++ b/llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp
@@ -198,23 +198,9 @@ extern "C" LLVM_ATTRIBUTE_USED int LLVMFuzzerInitialize(int *argc,
errs() << *argv[0] << ": -mtriple must be specified\n";
exit(1);
}
- Triple TargetTriple = Triple(Triple::normalize(TargetTripleStr));
-
- std::string Error;
- const Target *TheTarget =
- TargetRegistry::lookupTarget(codegen::getMArch(), TargetTriple, Error);
- if (!TheTarget) {
- errs() << *argv[0] << ": " << Error;
- exit(1);
- }
-
- TargetOptions Options =
- codegen::InitTargetOptionsFromCodeGenFlags(TargetTriple);
- TM.reset(TheTarget->createTargetMachine(
- TargetTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
- Options, codegen::getExplicitRelocModel(),
- codegen::getExplicitCodeModel(), CodeGenOptLevel::Default));
- assert(TM && "Could not allocate target machine!");
+ ExitOnError ExitOnErr(std::string(*argv[0]) + ": error:");
+ TM = ExitOnErr(codegen::createTargetMachineForTriple(
+ Triple::normalize(TargetTripleStr)));
// Check that pass pipeline is specified and correct
//
diff --git a/llvm/tools/llvm-reduce/ReducerWorkItem.cpp b/llvm/tools/llvm-reduce/ReducerWorkItem.cpp
index c377fe557cb1692..2a327bf134601d6 100644
--- a/llvm/tools/llvm-reduce/ReducerWorkItem.cpp
+++ b/llvm/tools/llvm-reduce/ReducerWorkItem.cpp
@@ -764,31 +764,17 @@ llvm::parseReducerWorkItem(StringRef ToolName, StringRef Filename,
auto SetDataLayout = [&](StringRef DataLayoutTargetTriple,
StringRef OldDLStr) -> std::optional<std::string> {
- // If we are supposed to override the target triple, do so now.
+ // NB: We always call createTargetMachineForTriple() even if an explicit
+ // DataLayout is already set in the module since we want to use this
+ // callback to setup the TargetMachine rather than doing it later.
std::string IRTargetTriple = DataLayoutTargetTriple.str();
if (!TargetTriple.empty())
IRTargetTriple = Triple::normalize(TargetTriple);
TheTriple = Triple(IRTargetTriple);
if (TheTriple.getTriple().empty())
TheTriple.setTriple(sys::getDefaultTargetTriple());
-
- std::string Error;
- const Target *TheTarget =
- TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
- if (!TheTarget) {
- WithColor::error(errs(), ToolName) << Error;
- exit(1);
- }
-
- // Hopefully the MIR parsing doesn't depend on any options.
- TargetOptions Options;
- std::optional<Reloc::Model> RM = codegen::getExplicitRelocModel();
- std::string CPUStr = codegen::getCPUStr();
- std::string FeaturesStr = codegen::getFeaturesStr();
- TM = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
- TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM,
- codegen::getExplicitCodeModel(), CodeGenOptLevel::Default));
- assert(TM && "Could not allocate target machine!");
+ ExitOnError ExitOnErr(std::string(ToolName) + ": error: ");
+ TM = ExitOnErr(codegen::createTargetMachineForTriple(TheTriple.str()));
return TM->createDataLayout().getStringRepresentation();
};
diff --git a/llvm/tools/opt/opt.cpp b/llvm/tools/opt/opt.cpp
index cf4b629ec01977c..a578bea7d62172c 100644
--- a/llvm/tools/opt/opt.cpp
+++ b/llvm/tools/opt/opt.cpp
@@ -286,24 +286,6 @@ static CodeGenOptLevel GetCodeGenOptLevel() {
return static_cast<CodeGenOptLevel>(unsigned(CodeGenOptLevelCL));
}
-// Returns the TargetMachine instance or zero if no triple is provided.
-static TargetMachine* GetTargetMachine(Triple TheTriple, StringRef CPUStr,
- StringRef FeaturesStr,
- const TargetOptions &Options) {
- std::string Error;
- const Target *TheTarget =
- TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
- // Some modules don't specify a triple, and this is okay.
- if (!TheTarget) {
- return nullptr;
- }
-
- return TheTarget->createTargetMachine(
- TheTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
- Options, codegen::getExplicitRelocModel(),
- codegen::getExplicitCodeModel(), GetCodeGenOptLevel());
-}
-
struct TimeTracerRAII {
TimeTracerRAII(StringRef ProgramName) {
if (TimeTrace)
@@ -410,6 +392,7 @@ static bool shouldForceLegacyPM() {
//
int main(int argc, char **argv) {
InitLLVM X(argc, argv);
+ ExitOnError ExitOnErr(std::string(argv[0]) + ": error: ");
// Enable debug stream buffering.
EnableDebugBuffering = true;
@@ -611,14 +594,12 @@ int main(int argc, char **argv) {
Triple ModuleTriple(M->getTargetTriple());
std::string CPUStr, FeaturesStr;
- TargetMachine *Machine = nullptr;
- const TargetOptions Options =
- codegen::InitTargetOptionsFromCodeGenFlags(ModuleTriple);
-
+ std::unique_ptr<TargetMachine> TM;
if (ModuleTriple.getArch()) {
CPUStr = codegen::getCPUStr();
FeaturesStr = codegen::getFeaturesStr();
- Machine = GetTargetMachine(ModuleTriple, CPUStr, FeaturesStr, Options);
+ TM = ExitOnErr(codegen::createTargetMachineForTriple(ModuleTriple.str(),
+ GetCodeGenOptLevel()));
} else if (ModuleTriple.getArchName() != "unknown" &&
ModuleTriple.getArchName() != "") {
errs() << argv[0] << ": unrecognized architecture '"
@@ -626,8 +607,6 @@ int main(int argc, char **argv) {
return 1;
}
- std::unique_ptr<TargetMachine> TM(Machine);
-
// Override function attributes based on CPUStr, FeaturesStr, and command line
// flags.
codegen::setFunctionAttributes(CPUStr, FeaturesStr, *M);
More information about the llvm-commits
mailing list