maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

MachineModuleInfo: Store more specific reference to LLVMTargetMachine; NFC 

MachineModuleInfo can only be used in code using lib/CodeGen, hence we
can keep a more specific reference to LLVMTargetMachine rather than just
TargetMachine around.

llvm-svn: 346182
This commit is contained in:
Matthias Braun 2018-11-05 23:49:13 +00:00
parent 54d23a8eb7
commit 3d849f67cb
9 changed files with 50 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
llvm/include/llvm/CodeGen/MachineModuleInfo.h
View File

@ -46,10 +46,10 @@ namespace llvm {
class BasicBlock;
class CallInst;
class Function;
class MachineFunction;
class LLVMTargetMachine;
class MMIAddrLabelMap;
class MachineFunction;
class Module;
class TargetMachine;
//===----------------------------------------------------------------------===//
/// This class can be derived from and used by targets to hold private
@ -76,7 +76,7 @@ protected:
/// for specific use.
///
class MachineModuleInfo : public ImmutablePass {
const TargetMachine &TM;
const LLVMTargetMachine &TM;
/// This is the MCContext used for the entire code generator.
MCContext Context;
@ -145,7 +145,7 @@ class MachineModuleInfo : public ImmutablePass {
public:
static char ID; // Pass identification, replacement for typeid
explicit MachineModuleInfo(const TargetMachine *TM = nullptr);
explicit MachineModuleInfo(const LLVMTargetMachine *TM = nullptr);
~MachineModuleInfo() override;
// Initialization and Finalization

2
llvm/lib/CodeGen/MachineModuleInfo.cpp
View File

@ -194,7 +194,7 @@ void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2));
}
MachineModuleInfo::MachineModuleInfo(const TargetMachine *TM)
MachineModuleInfo::MachineModuleInfo(const LLVMTargetMachine *TM)
: ImmutablePass(ID), TM(*TM),
Context(TM->getMCAsmInfo(), TM->getMCRegisterInfo(),
TM->getObjFileLowering(), nullptr, false) {

4
llvm/tools/llvm-exegesis/lib/Assembler.cpp
View File

@ -142,8 +142,10 @@ llvm::BitVector getFunctionReservedRegs(const llvm::TargetMachine &TM) {
llvm::make_unique<llvm::LLVMContext>();
std::unique_ptr<llvm::Module> Module =
createModule(Context, TM.createDataLayout());
// TODO: This only works for targets implementing LLVMTargetMachine.
const LLVMTargetMachine &LLVMTM = static_cast<const LLVMTargetMachine&>(TM);
std::unique_ptr<llvm::MachineModuleInfo> MMI =
llvm::make_unique<llvm::MachineModuleInfo>(&TM);
llvm::make_unique<llvm::MachineModuleInfo>(&LLVMTM);
llvm::MachineFunction &MF =
createVoidVoidPtrMachineFunction(FunctionID, Module.get(), MMI.get());
// Saving reserved registers for client.

7
llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp
View File

@ -42,8 +42,9 @@ protected:
return;
TargetOptions Options;
TM = std::unique_ptr<TargetMachine>(T->createTargetMachine(
"AArch64", "", "", Options, None, None, CodeGenOpt::Aggressive));
TM = std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine*>(
T->createTargetMachine("AArch64", "", "", Options, None, None,
CodeGenOpt::Aggressive)));
if (!TM)
return;
@ -70,7 +71,7 @@ protected:
}
LLVMContext Context;
std::unique_ptr<TargetMachine> TM = nullptr;
std::unique_ptr<LLVMTargetMachine> TM;
std::unique_ptr<Module> M;
Function *F;
std::unique_ptr<MachineFunction> MF;

11
llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.h
View File

@ -44,7 +44,7 @@ void initLLVM() {
/// Create a TargetMachine. As we lack a dedicated always available target for
/// unittests, we go for "AArch64".
std::unique_ptr<TargetMachine> createTargetMachine() {
std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
Triple TargetTriple("aarch64--");
std::string Error;
const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
@ -52,8 +52,9 @@ std::unique_ptr<TargetMachine> createTargetMachine() {
return nullptr;
TargetOptions Options;
return std::unique_ptr<TargetMachine>(T->createTargetMachine(
"AArch64", "", "", Options, None, None, CodeGenOpt::Aggressive));
return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine*>(
T->createTargetMachine("AArch64", "", "", Options, None, None,
CodeGenOpt::Aggressive)));
}
std::unique_ptr<Module> parseMIR(LLVMContext &Context,
@ -79,7 +80,7 @@ std::unique_ptr<Module> parseMIR(LLVMContext &Context,
}
std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
createDummyModule(LLVMContext &Context, const TargetMachine &TM,
createDummyModule(LLVMContext &Context, const LLVMTargetMachine &TM,
StringRef MIRFunc) {
SmallString<512> S;
StringRef MIRString = (Twine(R"MIR(
@ -136,7 +137,7 @@ protected:
B.setInsertPt(*EntryMBB, EntryMBB->end());
}
LLVMContext Context;
std::unique_ptr<TargetMachine> TM;
std::unique_ptr<LLVMTargetMachine> TM;
MachineFunction *MF;
std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
ModuleMMIPair;

21
llvm/unittests/CodeGen/GlobalISel/PatternMatchTest.cpp
View File

@ -43,7 +43,7 @@ void initLLVM() {
/// Create a TargetMachine. As we lack a dedicated always available target for
/// unittests, we go for "AArch64".
std::unique_ptr<TargetMachine> createTargetMachine() {
std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
Triple TargetTriple("aarch64--");
std::string Error;
const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
@ -51,8 +51,9 @@ std::unique_ptr<TargetMachine> createTargetMachine() {
return nullptr;
TargetOptions Options;
return std::unique_ptr<TargetMachine>(T->createTargetMachine(
"AArch64", "", "", Options, None, None, CodeGenOpt::Aggressive));
return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine*>(
T->createTargetMachine("AArch64", "", "", Options, None, None,
CodeGenOpt::Aggressive)));
}
std::unique_ptr<Module> parseMIR(LLVMContext &Context,
@ -78,7 +79,7 @@ std::unique_ptr<Module> parseMIR(LLVMContext &Context,
}
std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
createDummyModule(LLVMContext &Context, const TargetMachine &TM,
createDummyModule(LLVMContext &Context, const LLVMTargetMachine &TM,
StringRef MIRFunc) {
SmallString<512> S;
StringRef MIRString = (Twine(R"MIR(
@ -122,7 +123,7 @@ static void collectCopies(SmallVectorImpl<unsigned> &Copies,
TEST(PatternMatchInstr, MatchIntConstant) {
LLVMContext Context;
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
if (!TM)
return;
auto ModuleMMIPair = createDummyModule(Context, *TM, "");
@ -143,7 +144,7 @@ TEST(PatternMatchInstr, MatchIntConstant) {
TEST(PatternMatchInstr, MatchBinaryOp) {
LLVMContext Context;
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
if (!TM)
return;
auto ModuleMMIPair = createDummyModule(Context, *TM, "");
@ -270,7 +271,7 @@ TEST(PatternMatchInstr, MatchBinaryOp) {
TEST(PatternMatchInstr, MatchFPUnaryOp) {
LLVMContext Context;
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
if (!TM)
return;
auto ModuleMMIPair = createDummyModule(Context, *TM, "");
@ -341,7 +342,7 @@ TEST(PatternMatchInstr, MatchFPUnaryOp) {
TEST(PatternMatchInstr, MatchExtendsTrunc) {
LLVMContext Context;
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
if (!TM)
return;
auto ModuleMMIPair = createDummyModule(Context, *TM, "");
@ -397,7 +398,7 @@ TEST(PatternMatchInstr, MatchExtendsTrunc) {
TEST(PatternMatchInstr, MatchSpecificType) {
LLVMContext Context;
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
if (!TM)
return;
auto ModuleMMIPair = createDummyModule(Context, *TM, "");
@ -444,7 +445,7 @@ TEST(PatternMatchInstr, MatchSpecificType) {
TEST(PatternMatchInstr, MatchCombinators) {
LLVMContext Context;
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
if (!TM)
return;
auto ModuleMMIPair = createDummyModule(Context, *TM, "");

11
llvm/unittests/MI/LiveIntervalTest.cpp
View File

@ -35,7 +35,7 @@ void initLLVM() {
/// Create a TargetMachine. As we lack a dedicated always available target for
/// unittests, we go for "AMDGPU" to be able to test normal and subregister
/// liveranges.
std::unique_ptr<TargetMachine> createTargetMachine() {
std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
Triple TargetTriple("amdgcn--");
std::string Error;
const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
@ -43,13 +43,14 @@ std::unique_ptr<TargetMachine> createTargetMachine() {
return nullptr;
TargetOptions Options;
return std::unique_ptr<TargetMachine>(T->createTargetMachine(
"AMDGPU", "", "", Options, None, None, CodeGenOpt::Aggressive));
return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine*>(
T->createTargetMachine("AMDGPU", "", "", Options, None, None,
CodeGenOpt::Aggressive)));
}
std::unique_ptr<Module> parseMIR(LLVMContext &Context,
legacy::PassManagerBase &PM, std::unique_ptr<MIRParser> &MIR,
const TargetMachine &TM, StringRef MIRCode, const char *FuncName) {
const LLVMTargetMachine &TM, StringRef MIRCode, const char *FuncName) {
SMDiagnostic Diagnostic;
std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRCode);
MIR = createMIRParser(std::move(MBuffer), Context);
@ -128,7 +129,7 @@ static void testHandleMove(MachineFunction &MF, LiveIntervals &LIS,
static void liveIntervalTest(StringRef MIRFunc, LiveIntervalTest T) {
LLVMContext Context;
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
// This test is designed for the X86 backend; stop if it is not available.
if (!TM)
return;

15
llvm/unittests/Target/AArch64/InstSizes.cpp
View File

@ -10,7 +10,7 @@
using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine() {
std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
auto TT(Triple::normalize("aarch64--"));
std::string CPU("generic");
std::string FS("");
@ -22,8 +22,9 @@ std::unique_ptr<TargetMachine> createTargetMachine() {
std::string Error;
const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
TT, CPU, FS, TargetOptions(), None, None, CodeGenOpt::Default));
return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine*>(
TheTarget->createTargetMachine(TT, CPU, FS, TargetOptions(), None, None,
CodeGenOpt::Default)));
}
std::unique_ptr<AArch64InstrInfo> createInstrInfo(TargetMachine *TM) {
@ -37,7 +38,7 @@ std::unique_ptr<AArch64InstrInfo> createInstrInfo(TargetMachine *TM) {
/// TODO: Some of this might be useful for other architectures as well - extract
/// the platform-independent parts somewhere they can be reused.
void runChecks(
TargetMachine *TM, AArch64InstrInfo *II, const StringRef InputIRSnippet,
LLVMTargetMachine *TM, AArch64InstrInfo *II, const StringRef InputIRSnippet,
const StringRef InputMIRSnippet,
std::function<void(AArch64InstrInfo &, MachineFunction &)> Checks) {
LLVMContext Context;
@ -78,7 +79,7 @@ void runChecks(
} // anonymous namespace
TEST(InstSizes, STACKMAP) {
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
ASSERT_TRUE(TM);
std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
@ -93,7 +94,7 @@ TEST(InstSizes, STACKMAP) {
}
TEST(InstSizes, PATCHPOINT) {
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
runChecks(TM.get(), II.get(), "",
@ -108,7 +109,7 @@ TEST(InstSizes, PATCHPOINT) {
}
TEST(InstSizes, TLSDESC_CALLSEQ) {
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
runChecks(

13
llvm/unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp
View File

@ -22,7 +22,7 @@ using namespace llvm;
namespace {
std::unique_ptr<TargetMachine> createTargetMachine() {
std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
auto TT(Triple::normalize("wasm32-unknown-unknown"));
std::string CPU("");
std::string FS("");
@ -35,8 +35,9 @@ std::unique_ptr<TargetMachine> createTargetMachine() {
const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
assert(TheTarget);
return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
TT, CPU, FS, TargetOptions(), None, None, CodeGenOpt::Default));
return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine*>(
TheTarget->createTargetMachine(TT, CPU, FS, TargetOptions(), None, None,
CodeGenOpt::Default)));
}
std::unique_ptr<Module> parseMIR(LLVMContext &Context,
@ -64,7 +65,7 @@ std::unique_ptr<Module> parseMIR(LLVMContext &Context,
} // namespace
TEST(WebAssemblyExceptionInfoTest, TEST0) {
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
ASSERT_TRUE(TM);
StringRef MIRString = R"MIR(
@ -227,7 +228,7 @@ body: |
}
TEST(WebAssemblyExceptionInfoTest, TEST1) {
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
ASSERT_TRUE(TM);
StringRef MIRString = R"MIR(
@ -418,7 +419,7 @@ body: |
// Terminate pad test
TEST(WebAssemblyExceptionInfoTest, TEST2) {
std::unique_ptr<TargetMachine> TM = createTargetMachine();
std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
ASSERT_TRUE(TM);
StringRef MIRString = R"MIR(