MachineModuleInfo.cpp Source File (original) (raw)

19#include

21using namespace llvm;

28 ObjFileMMI = nullptr;

29 NextFnNum = 0;

30}

33 Context.reset();

36 delete ObjFileMMI;

37 ObjFileMMI = nullptr;

38}

42 Context(TM.getTargetTriple(), TM.getMCAsmInfo(), TM.getMCRegisterInfo(),

43 TM.getMCSubtargetInfo(), nullptr, &TM.Options.MCOptions, false),

44 MachineFunctions(std::move(MMI.MachineFunctions)) {

45 Context.setObjectFileInfo(TM.getObjFileLowering());

46 ObjFileMMI = MMI.ObjFileMMI;

47 ExternalContext = MMI.ExternalContext;

48 TheModule = MMI.TheModule;

49}

52 : TM(*TM), Context(TM->getTargetTriple(), TM->getMCAsmInfo(),

53 TM->getMCRegisterInfo(), TM->getMCSubtargetInfo(),

55 Context.setObjectFileInfo(TM->getObjFileLowering());

57}

61 : TM(*TM), Context(TM->getTargetTriple(), TM->getMCAsmInfo(),

62 TM->getMCRegisterInfo(), TM->getMCSubtargetInfo(),

64 ExternalContext(ExtContext) {

65 Context.setObjectFileInfo(TM->getObjFileLowering());

67}

73 auto I = MachineFunctions.find(&F);

74 return I != MachineFunctions.end() ? I->second.get() : nullptr;

75}

80 if (LastRequest == &F)

81 return *LastResult;

83 auto I = MachineFunctions.insert(

84 std::make_pair(&F, std::unique_ptr()));

86 if (I.second) {

93 TM.registerMachineRegisterInfoCallback(*MF);

96 I.first->second.reset(MF);

97 } else {

98 MF = I.first->second.get();

99 }

100

101 LastRequest = &F;

102 LastResult = MF;

103 return *MF;

104}

105

107 MachineFunctions.erase(&F);

108 LastRequest = nullptr;

109 LastResult = nullptr;

110}

111

113 std::unique_ptr &&MF) {

114 auto I = MachineFunctions.insert(std::make_pair(&F, std::move(MF)));

115 assert(I.second && "machine function already mapped");

116 (void)I;

117}

118

119namespace {

120

121

122class FreeMachineFunction : public FunctionPass {

123public:

124 static char ID;

125

127

128 void getAnalysisUsage(AnalysisUsage &AU) const override {

131 }

132

134 MachineModuleInfo &MMI =

135 getAnalysis().getMMI();

137 return true;

138 }

139

140 StringRef getPassName() const override {

141 return "Free MachineFunction";

142 }

143};

144

145}

146

147char FreeMachineFunction::ID;

148

150 return new FreeMachineFunction();

151}

152

158

164

165

167 "Machine Module Information", false, false)

169

172

173 unsigned BufNum = SrcMgr.FindBufferContainingLoc(SMD.getLoc());

174 const MDNode *LocInfo = nullptr;

175 if (BufNum > 0 && BufNum <= LocInfos.size())

176 LocInfo = LocInfos[BufNum - 1];

177

178

179

181 if (LocInfo) {

182 unsigned ErrorLine = SMD.getLineNo() - 1;

183 if (ErrorLine >= LocInfo->getNumOperands())

184 ErrorLine = 0;

185

186 if (LocInfo->getNumOperands() != 0)

189 LocCookie = CI->getZExtValue();

190 }

191

192 return LocCookie;

193}

194

196 MMI.initialize();

197 MMI.TheModule = &M;

200 [&Ctx, &M](const SMDiagnostic &SMD, bool IsInlineAsm,

202 std::vector<const MDNode *> &LocInfos) {

204 if (IsInlineAsm)

206 Ctx.diagnose(

208 });

209 return false;

210}

211

213 MMI.finalize();

214 return false;

215}

216

218

221 MMI.TheModule = &M;

224 [&Ctx, &M](const SMDiagnostic &SMD, bool IsInlineAsm,

226 std::vector<const MDNode *> &LocInfos) {

227 unsigned LocCookie = 0;

228 if (IsInlineAsm)

230 Ctx.diagnose(

232 });

234}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

This file contains the declarations for the subclasses of Constant, which represent the different fla...

static bool runOnFunction(Function &F, bool PostInlining)

Module.h This file contains the declarations for the Module class.

static INITIALIZE_PASS(MachineModuleInfoWrapperPass, "machinemoduleinfo", "Machine Module Information", false, false) char MachineModuleInfoWrapperPass uint64_t getLocCookie(const SMDiagnostic &SMD, const SourceMgr &SrcMgr, std::vector< const MDNode * > &LocInfos)

Definition MachineModuleInfo.cpp:170

#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

AnalysisUsage & addPreserved()

Add the specified Pass class to the set of analyses preserved by this pass.

This is the shared class of boolean and integer constants.

Diagnostic information for SMDiagnostic reporting.

FunctionPass class - This class is used to implement most global optimizations.

This is an important class for using LLVM in a threaded context.

LLVM_ABI void setDiagnosticHandler(std::unique_ptr< DiagnosticHandler > &&DH, bool RespectFilters=false)

setDiagnosticHandler - This method sets unique_ptr to object of DiagnosticHandler to provide custom d...

Context object for machine code objects.

void initTargetMachineFunctionInfo(const TargetSubtargetInfo &STI)

Initialize the target specific MachineFunctionInfo.

void erase(iterator MBBI)

LLVM_ABI Result run(Module &M, ModuleAnalysisManager &)

Run the analysis pass and produce machine module information.

Definition MachineModuleInfo.cpp:220

virtual ~MachineModuleInfoImpl()

bool doFinalization(Module &) override

doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...

Definition MachineModuleInfo.cpp:212

MachineModuleInfoWrapperPass(const TargetMachine *TM=nullptr)

Definition MachineModuleInfo.cpp:153

bool doInitialization(Module &) override

doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...

Definition MachineModuleInfo.cpp:195

LLVM_ABI MachineModuleInfo(const TargetMachine *TM=nullptr)

Definition MachineModuleInfo.cpp:51

LLVM_ABI void initialize()

Definition MachineModuleInfo.cpp:27

LLVM_ABI void insertFunction(const Function &F, std::unique_ptr< MachineFunction > &&MF)

Add an externally created MachineFunction MF for F.

Definition MachineModuleInfo.cpp:112

const MCContext & getContext() const

LLVM_ABI MachineFunction & getOrCreateMachineFunction(Function &F)

Returns the MachineFunction constructed for the IR function F.

Definition MachineModuleInfo.cpp:77

LLVM_ABI ~MachineModuleInfo()

Definition MachineModuleInfo.cpp:69

LLVM_ABI MachineFunction * getMachineFunction(const Function &F) const

Returns the MachineFunction associated to IR function F if there is one, otherwise nullptr.

Definition MachineModuleInfo.cpp:72

LLVM_ABI void finalize()

Definition MachineModuleInfo.cpp:32

LLVM_ABI void deleteMachineFunctionFor(Function &F)

Delete the MachineFunction MF and reset the link in the IR Function to Machine Function map.

Definition MachineModuleInfo.cpp:106

A Module instance is used to store all the information related to an LLVM module.

static LLVM_ABI PassRegistry * getPassRegistry()

getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...

Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...

This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.

Primary interface to the complete machine description for the target machine.

TargetSubtargetInfo - Generic base class for all target subtargets.

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

Calculates the starting offsets for various sections within the .debug_names section.

std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > dyn_extract(Y &&MD)

Extract a Value from Metadata, if any.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI void initializeMachineModuleInfoWrapperPassPass(PassRegistry &)

OutputIt move(R &&Range, OutputIt Out)

Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.

LLVM_ABI FunctionPass * createFreeMachineFunctionPass()

This pass frees the memory occupied by the MachineFunction.

Definition MachineModuleInfo.cpp:149

AnalysisManager< Module > ModuleAnalysisManager

Convenience typedef for the Module analysis manager.

Implement std::hash so that hash_code can be used in STL containers.

A special type used by analysis passes to provide an address that identifies that particular analysis...