From: Matthias Braun Date: Tue, 23 Aug 2016 05:17:11 +0000 (+0000) Subject: Revert "(HEAD -> master, origin/master, origin/HEAD) CodeGen: Remove MachineFunctionA... X-Git-Tag: llvmorg-4.0.0-rc1~11700 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=7f66202d38148a7c5b1cf6723de9d442f5566e46;p=platform%2Fupstream%2Fllvm.git Revert "(HEAD -> master, origin/master, origin/HEAD) CodeGen: Remove MachineFunctionAnalysis => Enable (Machine)ModulePasses" Reverting while tracking down a use after free. This reverts commit r279502. llvm-svn: 279503 --- diff --git a/llvm/include/llvm/CodeGen/AsmPrinter.h b/llvm/include/llvm/CodeGen/AsmPrinter.h index 5a02fa2..de618d1 100644 --- a/llvm/include/llvm/CodeGen/AsmPrinter.h +++ b/llvm/include/llvm/CodeGen/AsmPrinter.h @@ -204,7 +204,11 @@ public: bool doFinalization(Module &M) override; /// Emit the specified function out to the OutStreamer. - bool runOnMachineFunction(MachineFunction &MF) override; + bool runOnMachineFunction(MachineFunction &MF) override { + SetupMachineFunction(MF); + EmitFunctionBody(); + return false; + } //===------------------------------------------------------------------===// // Coarse grained IR lowering routines. diff --git a/llvm/include/llvm/CodeGen/MachineFunctionAnalysis.h b/llvm/include/llvm/CodeGen/MachineFunctionAnalysis.h new file mode 100644 index 0000000..4c0f5e6 --- /dev/null +++ b/llvm/include/llvm/CodeGen/MachineFunctionAnalysis.h @@ -0,0 +1,55 @@ +//===-- MachineFunctionAnalysis.h - Owner of MachineFunctions ----*-C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file declares the MachineFunctionAnalysis class. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CODEGEN_MACHINEFUNCTIONANALYSIS_H +#define LLVM_CODEGEN_MACHINEFUNCTIONANALYSIS_H + +#include "llvm/Pass.h" + +namespace llvm { + +class MachineFunction; +class MachineFunctionInitializer; +class TargetMachine; + +/// MachineFunctionAnalysis - This class is a Pass that manages a +/// MachineFunction object. +struct MachineFunctionAnalysis : public FunctionPass { +private: + const TargetMachine &TM; + MachineFunction *MF; + unsigned NextFnNum; + MachineFunctionInitializer *MFInitializer; + +public: + static char ID; + explicit MachineFunctionAnalysis(const TargetMachine &tm, + MachineFunctionInitializer *MFInitializer); + ~MachineFunctionAnalysis() override; + + MachineFunction &getMF() const { return *MF; } + + const char* getPassName() const override { + return "Machine Function Analysis"; + } + +private: + bool doInitialization(Module &M) override; + bool runOnFunction(Function &F) override; + void releaseMemory() override; + void getAnalysisUsage(AnalysisUsage &AU) const override; +}; + +} // End llvm namespace + +#endif diff --git a/llvm/include/llvm/CodeGen/MachineModuleInfo.h b/llvm/include/llvm/CodeGen/MachineModuleInfo.h index 0f61b21..f095876 100644 --- a/llvm/include/llvm/CodeGen/MachineModuleInfo.h +++ b/llvm/include/llvm/CodeGen/MachineModuleInfo.h @@ -54,7 +54,6 @@ class BlockAddress; class MDNode; class MMIAddrLabelMap; class MachineBasicBlock; -class MachineFunctionInitializer; class MachineFunction; class Module; class PointerType; @@ -108,8 +107,6 @@ protected: /// schemes and reformated for specific use. /// class MachineModuleInfo : public ImmutablePass { - const TargetMachine &TM; - /// Context - This is the MCContext used for the entire code generator. MCContext Context; @@ -187,12 +184,6 @@ class MachineModuleInfo : public ImmutablePass { EHPersonality PersonalityTypeCache; - MachineFunctionInitializer *MFInitializer; - /// Maps IR Functions to their corresponding MachineFunctions. - DenseMap> MachineFunctions; - const Function *LastRequest = nullptr; ///< Used for shortcut/cache. - MachineFunction *LastResult = nullptr; ///< Used for shortcut/cache. - public: static char ID; // Pass identification, replacement for typeid @@ -211,9 +202,8 @@ public: MachineModuleInfo(); // DUMMY CONSTRUCTOR, DO NOT CALL. // Real constructor. - MachineModuleInfo(const TargetMachine &TM, const MCAsmInfo &MAI, - const MCRegisterInfo &MRI, const MCObjectFileInfo *MOFI, - MachineFunctionInitializer *MFInitializer = nullptr); + MachineModuleInfo(const MCAsmInfo &MAI, const MCRegisterInfo &MRI, + const MCObjectFileInfo *MOFI); ~MachineModuleInfo() override; // Initialization and Finalization @@ -230,15 +220,6 @@ public: void setModule(const Module *M) { TheModule = M; } const Module *getModule() const { return TheModule; } - /// Returns the MachineFunction constructed for the IR function \p F. - /// Creates a new MachineFunction and runs the MachineFunctionInitializer - /// if none exists yet. - MachineFunction &getMachineFunction(const Function &F); - - /// \brief Delete the MachineFunction \p MF and reset the link in the IR - /// Function to Machine Function map. - void deleteMachineFunction(MachineFunction &MF); - /// getInfo - Keep track of various per-function pieces of information for /// backends that would like to do so. /// diff --git a/llvm/include/llvm/Target/TargetMachine.h b/llvm/include/llvm/Target/TargetMachine.h index 7905c57..563fef9 100644 --- a/llvm/include/llvm/Target/TargetMachine.h +++ b/llvm/include/llvm/Target/TargetMachine.h @@ -314,8 +314,11 @@ public: bool DisableVerify = true) override; /// Add MachineModuleInfo pass to pass manager. - MachineModuleInfo &addMachineModuleInfo(PassManagerBase &PM, - MachineFunctionInitializer *MFI = nullptr) const; + MachineModuleInfo &addMachineModuleInfo(PassManagerBase &PM) const; + + /// Add MachineFunctionAnalysis pass to pass manager. + void addMachineFunctionAnalysis(PassManagerBase &PM, + MachineFunctionInitializer *MFInitializer) const; }; } // End llvm namespace diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index cbd878d..0fed4e9 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -2571,14 +2571,7 @@ isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const { return true; } -bool AsmPrinter::runOnMachineFunction(MachineFunction &MF) { - SetupMachineFunction(MF); - EmitFunctionBody(); - MachineModuleInfo &MMI = getAnalysis(); - MMI.deleteMachineFunction(MF); - return false; -} GCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy &S) { if (!S.usesMetadata()) diff --git a/llvm/lib/CodeGen/CMakeLists.txt b/llvm/lib/CodeGen/CMakeLists.txt index cc9ed95..f522435 100644 --- a/llvm/lib/CodeGen/CMakeLists.txt +++ b/llvm/lib/CodeGen/CMakeLists.txt @@ -59,6 +59,7 @@ add_llvm_library(LLVMCodeGen MachineCSE.cpp MachineDominanceFrontier.cpp MachineDominators.cpp + MachineFunctionAnalysis.cpp MachineFunction.cpp MachineFunctionPass.cpp MachineFunctionPrinterPass.cpp diff --git a/llvm/lib/CodeGen/LLVMTargetMachine.cpp b/llvm/lib/CodeGen/LLVMTargetMachine.cpp index e5678ba..9ed61c6 100644 --- a/llvm/lib/CodeGen/LLVMTargetMachine.cpp +++ b/llvm/lib/CodeGen/LLVMTargetMachine.cpp @@ -15,6 +15,7 @@ #include "llvm/Analysis/Passes.h" #include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/BasicTTIImpl.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/TargetPassConfig.h" @@ -102,15 +103,19 @@ TargetIRAnalysis LLVMTargetMachine::getTargetIRAnalysis() { } MachineModuleInfo & -LLVMTargetMachine::addMachineModuleInfo(PassManagerBase &PM, - MachineFunctionInitializer *MFI) const { - MachineModuleInfo *MMI = new MachineModuleInfo(*this, *getMCAsmInfo(), +LLVMTargetMachine::addMachineModuleInfo(PassManagerBase &PM) const { + MachineModuleInfo *MMI = new MachineModuleInfo(*getMCAsmInfo(), *getMCRegisterInfo(), - getObjFileLowering(), MFI); + getObjFileLowering()); PM.add(MMI); return *MMI; } +void LLVMTargetMachine::addMachineFunctionAnalysis(PassManagerBase &PM, + MachineFunctionInitializer *MFInitializer) const { + PM.add(new MachineFunctionAnalysis(*this, MFInitializer)); +} + /// addPassesToX helper drives creation and initialization of TargetPassConfig. static MCContext * addPassesToGenerateCode(LLVMTargetMachine *TM, PassManagerBase &PM, @@ -145,7 +150,8 @@ addPassesToGenerateCode(LLVMTargetMachine *TM, PassManagerBase &PM, PassConfig->addISelPrepare(); - MachineModuleInfo &MMI = TM->addMachineModuleInfo(PM, MFInitializer); + MachineModuleInfo &MMI = TM->addMachineModuleInfo(PM); + TM->addMachineFunctionAnalysis(PM, MFInitializer); // Enable FastISel with -fast, but allow that to be overridden. TM->setO0WantsFastISel(EnableFastISelOption != cl::BOU_FALSE); diff --git a/llvm/lib/CodeGen/MachineFunctionAnalysis.cpp b/llvm/lib/CodeGen/MachineFunctionAnalysis.cpp new file mode 100644 index 0000000..3b69ed5 --- /dev/null +++ b/llvm/lib/CodeGen/MachineFunctionAnalysis.cpp @@ -0,0 +1,62 @@ +//===-- MachineFunctionAnalysis.cpp ---------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file contains the definitions of the MachineFunctionAnalysis members. +// +//===----------------------------------------------------------------------===// + +#include "llvm/CodeGen/MachineFunctionAnalysis.h" +#include "llvm/CodeGen/GCMetadata.h" +#include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineModuleInfo.h" +#include "llvm/CodeGen/MachineFunctionInitializer.h" +using namespace llvm; + +char MachineFunctionAnalysis::ID = 0; + +MachineFunctionAnalysis::MachineFunctionAnalysis( + const TargetMachine &tm, MachineFunctionInitializer *MFInitializer) + : FunctionPass(ID), TM(tm), MF(nullptr), MFInitializer(MFInitializer) { + initializeMachineModuleInfoPass(*PassRegistry::getPassRegistry()); +} + +MachineFunctionAnalysis::~MachineFunctionAnalysis() { + releaseMemory(); + assert(!MF && "MachineFunctionAnalysis left initialized!"); +} + +void MachineFunctionAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + AU.addRequired(); +} + +bool MachineFunctionAnalysis::doInitialization(Module &M) { + MachineModuleInfo *MMI = getAnalysisIfAvailable(); + assert(MMI && "MMI not around yet??"); + MMI->setModule(&M); + NextFnNum = 0; + return false; +} + + +bool MachineFunctionAnalysis::runOnFunction(Function &F) { + assert(!MF && "MachineFunctionAnalysis already initialized!"); + MF = new MachineFunction(&F, TM, NextFnNum++, + getAnalysis()); + if (MFInitializer) { + if (MFInitializer->initializeMachineFunction(*MF)) + report_fatal_error("Unable to initialize machine function"); + } + return false; +} + +void MachineFunctionAnalysis::releaseMemory() { + delete MF; + MF = nullptr; +} diff --git a/llvm/lib/CodeGen/MachineFunctionPass.cpp b/llvm/lib/CodeGen/MachineFunctionPass.cpp index 43cd2ed..524ebdb 100644 --- a/llvm/lib/CodeGen/MachineFunctionPass.cpp +++ b/llvm/lib/CodeGen/MachineFunctionPass.cpp @@ -22,7 +22,7 @@ #include "llvm/Analysis/ScalarEvolution.h" #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h" #include "llvm/CodeGen/MachineFunction.h" -#include "llvm/CodeGen/MachineModuleInfo.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/StackProtector.h" #include "llvm/IR/Dominators.h" @@ -41,9 +41,7 @@ bool MachineFunctionPass::runOnFunction(Function &F) { if (F.hasAvailableExternallyLinkage()) return false; - MachineModuleInfo &MMI = getAnalysis(); - MachineFunction &MF = MMI.getMachineFunction(F); - + MachineFunction &MF = getAnalysis().getMF(); MachineFunctionProperties &MFProps = MF.getProperties(); #ifndef NDEBUG @@ -67,8 +65,8 @@ bool MachineFunctionPass::runOnFunction(Function &F) { } void MachineFunctionPass::getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired(); - AU.addPreserved(); + AU.addRequired(); + AU.addPreserved(); // MachineFunctionPass preserves all LLVM IR passes, but there's no // high-level way to express this. Instead, just list a bunch of diff --git a/llvm/lib/CodeGen/MachineModuleInfo.cpp b/llvm/lib/CodeGen/MachineModuleInfo.cpp index 4b4c693..244e3fb 100644 --- a/llvm/lib/CodeGen/MachineModuleInfo.cpp +++ b/llvm/lib/CodeGen/MachineModuleInfo.cpp @@ -13,7 +13,6 @@ #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" @@ -187,19 +186,15 @@ void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) { //===----------------------------------------------------------------------===// -MachineModuleInfo::MachineModuleInfo(const TargetMachine &TM, - const MCAsmInfo &MAI, +MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI, const MCRegisterInfo &MRI, - const MCObjectFileInfo *MOFI, - MachineFunctionInitializer *MFI) - : ImmutablePass(ID), TM(TM), Context(&MAI, &MRI, MOFI, nullptr, false), - MFInitializer(MFI) { + const MCObjectFileInfo *MOFI) + : ImmutablePass(ID), Context(&MAI, &MRI, MOFI, nullptr, false) { initializeMachineModuleInfoPass(*PassRegistry::getPassRegistry()); } MachineModuleInfo::MachineModuleInfo() - : ImmutablePass(ID), TM(*((TargetMachine*)nullptr)), - Context(nullptr, nullptr, nullptr) { + : ImmutablePass(ID), Context(nullptr, nullptr, nullptr) { llvm_unreachable("This MachineModuleInfo constructor should never be called, " "MMI should always be explicitly constructed by " "LLVMTargetMachine"); @@ -218,7 +213,7 @@ bool MachineModuleInfo::doInitialization(Module &M) { DbgInfoAvailable = UsesVAFloatArgument = UsesMorestackAddr = false; PersonalityTypeCache = EHPersonality::Unknown; AddrLabelSymbols = nullptr; - TheModule = &M; + TheModule = nullptr; return false; } @@ -466,42 +461,3 @@ 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 *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); -} diff --git a/llvm/lib/CodeGen/StackMapLivenessAnalysis.cpp b/llvm/lib/CodeGen/StackMapLivenessAnalysis.cpp index 86dab76..9da22db 100644 --- a/llvm/lib/CodeGen/StackMapLivenessAnalysis.cpp +++ b/llvm/lib/CodeGen/StackMapLivenessAnalysis.cpp @@ -17,6 +17,7 @@ #include "llvm/CodeGen/LivePhysRegs.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/Passes.h" #include "llvm/Support/CommandLine.h" diff --git a/llvm/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp b/llvm/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp index e82c9ed..64dcb45 100644 --- a/llvm/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp +++ b/llvm/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp @@ -18,6 +18,7 @@ #include "llvm/ADT/Statistic.h" #include "llvm/CodeGen/MachineDominators.h" #include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/MachineInstrBuilder.h" #include "llvm/CodeGen/MachineJumpTableInfo.h" @@ -143,10 +144,11 @@ public: } void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.addPreserved(); + AU.addRequired(); AU.addRequired(); AU.addRequired(); AU.addRequired(); - MachineFunctionPass::getAnalysisUsage(AU); } /// Perform the CFG structurization diff --git a/llvm/lib/Target/Hexagon/HexagonCommonGEP.cpp b/llvm/lib/Target/Hexagon/HexagonCommonGEP.cpp index 6b4450c..982a534 100644 --- a/llvm/lib/Target/Hexagon/HexagonCommonGEP.cpp +++ b/llvm/lib/Target/Hexagon/HexagonCommonGEP.cpp @@ -14,6 +14,7 @@ #include "llvm/ADT/STLExtras.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/PostDominators.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/Function.h" diff --git a/llvm/lib/Target/Hexagon/HexagonGenExtract.cpp b/llvm/lib/Target/Hexagon/HexagonGenExtract.cpp index ca10846..f46b6d2 100644 --- a/llvm/lib/Target/Hexagon/HexagonGenExtract.cpp +++ b/llvm/lib/Target/Hexagon/HexagonGenExtract.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "llvm/ADT/STLExtras.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/Function.h" @@ -59,6 +60,7 @@ namespace { virtual void getAnalysisUsage(AnalysisUsage &AU) const override { AU.addRequired(); AU.addPreserved(); + AU.addPreserved(); FunctionPass::getAnalysisUsage(AU); } private: diff --git a/llvm/lib/Target/Hexagon/HexagonNewValueJump.cpp b/llvm/lib/Target/Hexagon/HexagonNewValueJump.cpp index 14f3246..f622dad 100644 --- a/llvm/lib/Target/Hexagon/HexagonNewValueJump.cpp +++ b/llvm/lib/Target/Hexagon/HexagonNewValueJump.cpp @@ -29,6 +29,7 @@ #include "HexagonTargetMachine.h" #include "llvm/ADT/Statistic.h" #include "llvm/CodeGen/LiveVariables.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/MachineInstrBuilder.h" #include "llvm/CodeGen/MachineRegisterInfo.h" diff --git a/llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp b/llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp index 1c7495a..7937a79 100644 --- a/llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp +++ b/llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp @@ -12,6 +12,7 @@ // //===----------------------------------------------------------------------===// +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/StackProtector.h" #include "llvm/IR/Function.h" #include "llvm/IR/Instructions.h" @@ -42,6 +43,8 @@ namespace { } void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.addRequired(); + AU.addPreserved(); AU.addPreserved(); FunctionPass::getAnalysisUsage(AU); } diff --git a/llvm/lib/Target/Hexagon/HexagonVLIWPacketizer.cpp b/llvm/lib/Target/Hexagon/HexagonVLIWPacketizer.cpp index 8b347a8..4789284 100644 --- a/llvm/lib/Target/Hexagon/HexagonVLIWPacketizer.cpp +++ b/llvm/lib/Target/Hexagon/HexagonVLIWPacketizer.cpp @@ -22,6 +22,7 @@ #include "HexagonVLIWPacketizer.h" #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/CodeGen/MachineDominators.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/MachineLoopInfo.h" #include "llvm/CodeGen/MachineRegisterInfo.h" diff --git a/llvm/lib/Target/NVPTX/NVPTXAllocaHoisting.cpp b/llvm/lib/Target/NVPTX/NVPTXAllocaHoisting.cpp index c6e6455..4f3ccf4 100644 --- a/llvm/lib/Target/NVPTX/NVPTXAllocaHoisting.cpp +++ b/llvm/lib/Target/NVPTX/NVPTXAllocaHoisting.cpp @@ -12,6 +12,7 @@ //===----------------------------------------------------------------------===// #include "NVPTXAllocaHoisting.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/StackProtector.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Function.h" @@ -27,6 +28,7 @@ public: NVPTXAllocaHoisting() : FunctionPass(ID) {} void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.addPreserved(); AU.addPreserved(); } diff --git a/llvm/lib/Target/NVPTX/NVPTXGenericToNVVM.cpp b/llvm/lib/Target/NVPTX/NVPTXGenericToNVVM.cpp index 3907762..55d2557 100644 --- a/llvm/lib/Target/NVPTX/NVPTXGenericToNVVM.cpp +++ b/llvm/lib/Target/NVPTX/NVPTXGenericToNVVM.cpp @@ -15,6 +15,7 @@ #include "NVPTX.h" #include "MCTargetDesc/NVPTXBaseInfo.h" #include "NVPTXUtilities.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/ValueTypes.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DerivedTypes.h" diff --git a/llvm/lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp b/llvm/lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp index 23f482e..f770c2a 100644 --- a/llvm/lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp +++ b/llvm/lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp @@ -14,6 +14,7 @@ //===----------------------------------------------------------------------===// #include "NVPTXLowerAggrCopies.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/StackProtector.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" @@ -40,6 +41,7 @@ struct NVPTXLowerAggrCopies : public FunctionPass { NVPTXLowerAggrCopies() : FunctionPass(ID) {} void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.addPreserved(); AU.addPreserved(); } diff --git a/llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp b/llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp index 05df3e4c..d95b42a 100644 --- a/llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp +++ b/llvm/lib/Target/NVPTX/NVPTXTargetMachine.cpp @@ -20,6 +20,7 @@ #include "NVPTXTargetTransformInfo.h" #include "llvm/Analysis/Passes.h" #include "llvm/CodeGen/AsmPrinter.h" +#include "llvm/CodeGen/MachineFunctionAnalysis.h" #include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/TargetPassConfig.h" diff --git a/llvm/test/CodeGen/Generic/stop-after.ll b/llvm/test/CodeGen/Generic/stop-after.ll index 3ceba91..07a60f7 100644 --- a/llvm/test/CodeGen/Generic/stop-after.ll +++ b/llvm/test/CodeGen/Generic/stop-after.ll @@ -3,6 +3,7 @@ ; STOP: -loop-reduce ; STOP: Loop Strength Reduction +; STOP-NEXT: Machine Function Analysis ; STOP-NEXT: MIR Printing Pass ; START: -machine-branch-prob -pre-isel-intrinsic-lowering diff --git a/llvm/test/CodeGen/X86/hidden-vis-pic.ll b/llvm/test/CodeGen/X86/hidden-vis-pic.ll index 23bdb84..96adf62 100644 --- a/llvm/test/CodeGen/X86/hidden-vis-pic.ll +++ b/llvm/test/CodeGen/X86/hidden-vis-pic.ll @@ -17,7 +17,7 @@ entry: ; This must use movl of the stub, not an lea, since the function isn't being ; emitted here. -; CHECK: movl L__ZNSbIcED1Ev$non_lazy_ptr-L0$pb( +; CHECK: movl L__ZNSbIcED1Ev$non_lazy_ptr-L1$pb( diff --git a/llvm/tools/llc/llc.cpp b/llvm/tools/llc/llc.cpp index 22273d4..250d276 100644 --- a/llvm/tools/llc/llc.cpp +++ b/llvm/tools/llc/llc.cpp @@ -450,7 +450,8 @@ static int compileModule(char **argv, LLVMContext &Context) { LLVMTargetMachine &LLVMTM = static_cast(*Target); TargetPassConfig &TPC = *LLVMTM.createPassConfig(PM); PM.add(&TPC); - LLVMTM.addMachineModuleInfo(PM, MIR.get()); + LLVMTM.addMachineModuleInfo(PM); + LLVMTM.addMachineFunctionAnalysis(PM, MIR.get()); TPC.printAndVerify(""); for (const std::string &RunPassName : *RunPassNames) { diff --git a/llvm/unittests/MI/LiveIntervalTest.cpp b/llvm/unittests/MI/LiveIntervalTest.cpp index 5fe5c91..12c3ad6 100644 --- a/llvm/unittests/MI/LiveIntervalTest.cpp +++ b/llvm/unittests/MI/LiveIntervalTest.cpp @@ -70,7 +70,8 @@ std::unique_ptr parseMIR(LLVMContext &Context, return nullptr; const LLVMTargetMachine &LLVMTM = static_cast(TM); - LLVMTM.addMachineModuleInfo(PM, MIR.get()); + LLVMTM.addMachineModuleInfo(PM); + LLVMTM.addMachineFunctionAnalysis(PM, MIR.get()); return M; }