nicolas/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

CodeGen: Remove MachineFunctionAnalysis => Enable (Machine)ModulePasses

Browse Source 
This patch removes the MachineFunctionAnalysis. Instead we keep a
map from IR Function to MachineFunction in the MachineModuleInfo.

This allows the insertion of ModulePasses into the codegen pipeline
without breaking it because the MachineFunctionAnalysis gets dropped
before a module pass.

Peak memory should stay unchanged without a ModulePass in the codegen
pipeline: Previously the MachineFunction was freed at the end of a codegen
function pipeline because the MachineFunctionAnalysis was dropped; With
this patch the MachineFunction is freed after the AsmPrinter has
finished.

Differential Revision: http://reviews.llvm.org/D23736

llvm-svn: 279502
This commit is contained in:
Matthias Braun
2016-08-23 03:20:09 +00:00
parent 72ca69e403
commit fd936841eb
25 changed files with 95 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,6 +13,7 @@
#include "llvm/Analysis/EHPersonalities.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFunctionInitializer.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/IR/Constants.h"
@@ -186,15 +187,19 @@ void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
//===----------------------------------------------------------------------===//
MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI,
MachineModuleInfo::MachineModuleInfo(const TargetMachine &TM,
const MCAsmInfo &MAI,
const MCRegisterInfo &MRI,
const MCObjectFileInfo *MOFI)
: ImmutablePass(ID), Context(&MAI, &MRI, MOFI, nullptr, false) {
const MCObjectFileInfo *MOFI,
MachineFunctionInitializer *MFI)
: ImmutablePass(ID), TM(TM), Context(&MAI, &MRI, MOFI, nullptr, false),
MFInitializer(MFI) {
initializeMachineModuleInfoPass(*PassRegistry::getPassRegistry());
}
MachineModuleInfo::MachineModuleInfo()
: ImmutablePass(ID), Context(nullptr, nullptr, nullptr) {
: ImmutablePass(ID), TM(*((TargetMachine*)nullptr)),
Context(nullptr, nullptr, nullptr) {
llvm_unreachable("This MachineModuleInfo constructor should never be called, "
"MMI should always be explicitly constructed by "
"LLVMTargetMachine");
@@ -213,7 +218,7 @@ bool MachineModuleInfo::doInitialization(Module &M) {
DbgInfoAvailable = UsesVAFloatArgument = UsesMorestackAddr = false;
PersonalityTypeCache = EHPersonality::Unknown;
AddrLabelSymbols = nullptr;
TheModule = nullptr;
TheModule = &M;
return false;
}
@@ -461,3 +466,42 @@ try_next:;
FilterIds.push_back(0); // terminator
return FilterID;
}
MachineFunction &MachineModuleInfo::getMachineFunction(const Function &F) {
// Shortcut for the common case where a sequence of MachineFunctionPasses
// all query for the same Function.
if (LastRequest == &F)
return *LastResult;
auto I = MachineFunctions.insert(
std::make_pair(&F, std::unique_ptr<MachineFunction>()));
MachineFunction *MF;
if (I.second) {
// No pre-existing machine function, create a new one.
unsigned FunctionNum = (unsigned)MachineFunctions.size() - 1;
MF = new MachineFunction(&F, TM, FunctionNum, *this);
// Update the set entry.
I.first->second.reset(MF);
if (MFInitializer)
if (MFInitializer->initializeMachineFunction(*MF))
report_fatal_error("Unable to initialize machine function");
} else {
MF = I.first->second.get();
}
LastRequest = &F;
LastResult = MF;
return *MF;
}
void MachineModuleInfo::deleteMachineFunction(MachineFunction &MF) {
if (LastResult == &MF) {
LastRequest = nullptr;
LastResult = nullptr;
}
auto I = MachineFunctions.find(MF.getFunction());
assert(I != MachineFunctions.end() && "MachineFunction is known");
I->second.reset(nullptr);
}