Movatterモバイル変換

Go to the documentation of this file.

1//===- PassManagerImpl.h - Pass management infrastructure -------*- C++ -*-===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

8/// \file

9/// Provides implementations for PassManager and AnalysisManager template

10/// methods. These classes should be explicitly instantiated for any IR unit,

11/// and files doing the explicit instantiation should include this header.

12///

13//===----------------------------------------------------------------------===//

15#ifndef LLVM_IR_PASSMANAGERIMPL_H

16#define LLVM_IR_PASSMANAGERIMPL_H

18#include "llvm/IR/Function.h"

19#include "llvm/IR/PassInstrumentation.h"

20#include "llvm/IR/PassManager.h"

21#include "llvm/Support/CommandLine.h"

22#include "llvm/Support/PrettyStackTrace.h"

24externllvm::cl::opt<bool>UseNewDbgInfoFormat;

26namespacellvm {

28template <typename IRUnitT,typename AnalysisManagerT,typename... ExtraArgTs>

29PreservedAnalyses PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>::run(

30 IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {

31classStackTraceEntry :publicPrettyStackTraceEntry {

32constPassInstrumentation &PI;

33 IRUnitT &IR;

34PassConceptT *Pass =nullptr;

36public:

37explicit StackTraceEntry(constPassInstrumentation &PI, IRUnitT &IR)

38 : PI(PI),IR(IR) {}

40void setPass(PassConceptT *P) {Pass =P; }

42voidprint(raw_ostream &OS) const override{

43OS <<"Running pass \"";

44if (Pass)

45Pass->printPipeline(OS, [this](StringRef ClassName) {

46autoPassName = PI.getPassNameForClassName(ClassName);

47returnPassName.empty() ? ClassName :PassName;

48 });

49else

50OS <<"unknown";

51OS <<"\" on ";

52printIRUnitNameForStackTrace(OS,IR);

53OS <<"\n";

54 }

55 };

57PreservedAnalyses PA =PreservedAnalyses::all();

59// Request PassInstrumentation from analysis manager, will use it to run

60// instrumenting callbacks for the passes later.

61// Here we use std::tuple wrapper over getResult which helps to extract

62// AnalysisManager's arguments out of the whole ExtraArgs set.

63PassInstrumentation PI =

64 detail::getAnalysisResult<PassInstrumentationAnalysis>(

65 AM,IR, std::tuple<ExtraArgTs...>(ExtraArgs...));

67// RemoveDIs: if requested, convert debug-info to DbgRecord representation

68// for duration of these passes.

69ScopedDbgInfoFormatSetter FormatSetter(IR,UseNewDbgInfoFormat);

71 StackTraceEntry Entry(PI,IR);

72for (auto &Pass :Passes) {

73 Entry.setPass(&*Pass);

75// Check the PassInstrumentation's BeforePass callbacks before running the

76// pass, skip its execution completely if asked to (callback returns

77// false).

78if (!PI.runBeforePass<IRUnitT>(*Pass,IR))

79continue;

81PreservedAnalyses PassPA =Pass->run(IR, AM, ExtraArgs...);

83// Update the analysis manager as each pass runs and potentially

84// invalidates analyses.

85 AM.invalidate(IR, PassPA);

87// Call onto PassInstrumentation's AfterPass callbacks immediately after

88// running the pass.

89 PI.runAfterPass<IRUnitT>(*Pass,IR, PassPA);

91// Finally, intersect the preserved analyses to compute the aggregate

92// preserved set for this pass manager.

93 PA.intersect(std::move(PassPA));

94 }

96// Invalidation was handled after each pass in the above loop for the

97// current unit of IR. Therefore, the remaining analysis results in the

98// AnalysisManager are preserved. We mark this with a set so that we don't

99// need to inspect each one individually.

100 PA.preserveSet<AllAnalysesOn<IRUnitT>>();

101

102return PA;

103}

104

105template <typename IRUnitT,typename... ExtraArgTs>

106inlineAnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager() =default;

107

108template <typename IRUnitT,typename... ExtraArgTs>

109inlineAnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager(

110AnalysisManager &&) =default;

111

112template <typename IRUnitT,typename... ExtraArgTs>

113inlineAnalysisManager<IRUnitT, ExtraArgTs...> &

114AnalysisManager<IRUnitT, ExtraArgTs...>::operator=(AnalysisManager &&) =

115default;

116

117template <typename IRUnitT,typename... ExtraArgTs>

118inlinevoid

119AnalysisManager<IRUnitT, ExtraArgTs...>::clear(IRUnitT &IR,

120llvm::StringRef Name) {

121if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))

122 PI->runAnalysesCleared(Name);

123

124auto ResultsListI = AnalysisResultLists.find(&IR);

125if (ResultsListI == AnalysisResultLists.end())

126return;

127// Delete the map entries that point into the results list.

128for (auto &IDAndResult : ResultsListI->second)

129 AnalysisResults.erase({IDAndResult.first, &IR});

130

131// And actually destroy and erase the results associated with this IR.

132 AnalysisResultLists.erase(ResultsListI);

133}

134

135template <typename IRUnitT,typename... ExtraArgTs>

136inlinetypenameAnalysisManager<IRUnitT, ExtraArgTs...>::ResultConceptT &

137AnalysisManager<IRUnitT, ExtraArgTs...>::getResultImpl(

138AnalysisKey *ID, IRUnitT &IR, ExtraArgTs... ExtraArgs) {

139typename AnalysisResultMapT::iterator RI;

140bool Inserted;

141 std::tie(RI, Inserted) = AnalysisResults.insert(std::make_pair(

142 std::make_pair(ID, &IR),typename AnalysisResultListT::iterator()));

143

144// If we don't have a cached result for this function, look up the pass and

145// run it to produce a result, which we then add to the cache.

146if (Inserted) {

147auto &P = this->lookUpPass(ID);

148

149PassInstrumentation PI;

150if (ID !=PassInstrumentationAnalysis::ID()) {

151 PI = getResult<PassInstrumentationAnalysis>(IR, ExtraArgs...);

152 PI.runBeforeAnalysis(P,IR);

153 }

154

155 AnalysisResultListT &ResultList = AnalysisResultLists[&IR];

156 ResultList.emplace_back(ID,P.run(IR, *this, ExtraArgs...));

157

158 PI.runAfterAnalysis(P,IR);

159

160// P.run may have inserted elements into AnalysisResults and invalidated

161// RI.

162 RI = AnalysisResults.find({ID, &IR});

163assert(RI != AnalysisResults.end() &&"we just inserted it!");

164

165 RI->second = std::prev(ResultList.end());

166 }

167

168return *RI->second->second;

169}

170

171template <typename IRUnitT,typename... ExtraArgTs>

172inlinevoidAnalysisManager<IRUnitT, ExtraArgTs...>::invalidate(

173 IRUnitT &IR,constPreservedAnalyses &PA) {

174// We're done if all analyses on this IR unit are preserved.

175if (PA.allAnalysesInSetPreserved<AllAnalysesOn<IRUnitT>>())

176return;

177

178// Track whether each analysis's result is invalidated in

179// IsResultInvalidated.

180SmallDenseMap<AnalysisKey *, bool, 8> IsResultInvalidated;

181Invalidator Inv(IsResultInvalidated, AnalysisResults);

182 AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];

183for (auto &AnalysisResultPair : ResultsList) {

184// This is basically the same thing as Invalidator::invalidate, but we

185// can't call it here because we're operating on the type-erased result.

186// Moreover if we instead called invalidate() directly, it would do an

187// unnecessary look up in ResultsList.

188AnalysisKey *ID = AnalysisResultPair.first;

189auto &Result = *AnalysisResultPair.second;

190

191auto IMapI = IsResultInvalidated.find(ID);

192if (IMapI != IsResultInvalidated.end())

193// This result was already handled via the Invalidator.

194continue;

195

196// Try to invalidate the result, giving it the Invalidator so it can

197// recursively query for any dependencies it has and record the result.

198// Note that we cannot reuse 'IMapI' here or pre-insert the ID, as

199// Result.invalidate may insert things into the map, invalidating our

200// iterator.

201bool Inserted =

202 IsResultInvalidated.insert({ID, Result.invalidate(IR, PA, Inv)}).second;

203 (void)Inserted;

204assert(Inserted &&"Should never have already inserted this ID, likely "

205"indicates a cycle!");

206 }

207

208// Now erase the results that were marked above as invalidated.

209if (!IsResultInvalidated.empty()) {

210for (autoI = ResultsList.begin(),E = ResultsList.end();I !=E;) {

211 AnalysisKey *ID =I->first;

212if (!IsResultInvalidated.lookup(ID)) {

213 ++I;

214continue;

215 }

216

217if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))

218 PI->runAnalysisInvalidated(this->lookUpPass(ID),IR);

219

220I = ResultsList.erase(I);

221 AnalysisResults.erase({ID, &IR});

222 }

223 }

224

225if (ResultsList.empty())

226 AnalysisResultLists.erase(&IR);

227}

228}// end namespace llvm

229

230#endif// LLVM_IR_PASSMANAGERIMPL_H

static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)

Definition:ArchiveWriter.cpp:205

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

CommandLine.h

Name

std::string Name

Definition:ELFObjHandler.cpp:77

Function.h

PassManager.h

This header defines various interfaces for pass management in LLVM.

Legalize the Machine IR a function s Machine IR

Definition:Legalizer.cpp:80

#define I(x, y, z)

Definition:MD5.cpp:58

#define P(N)

Passes

Function const char * Passes

Definition:PassBuilderBindings.cpp:51

PassInstrumentation.h

This file defines the Pass Instrumentation classes that provide instrumentation points into the pass ...

UseNewDbgInfoFormat

llvm::cl::opt< bool > UseNewDbgInfoFormat

PrettyStackTrace.h

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

raw_pwrite_stream & OS

Definition:SampleProfWriter.cpp:51

PassName

static const char PassName[]

Definition:X86LowerAMXIntrinsics.cpp:666

llvm::AllAnalysesOn

This templated class represents "all analyses that operate over <a particular IR unit>" (e....

Definition:Analysis.h:49

llvm::AnalysisManager::Invalidator

API to communicate dependencies between analyses during invalidation.

Definition:PassManager.h:292

llvm::AnalysisManager

A container for analyses that lazily runs them and caches their results.

Definition:PassManager.h:253

llvm::AnalysisManager::AnalysisManager

AnalysisManager()

Construct an empty analysis manager.

llvm::AnalysisManager::clear

void clear()

Clear all analysis results cached by this AnalysisManager.

Definition:PassManager.h:396

llvm::AnalysisManager::operator=

AnalysisManager & operator=(AnalysisManager &&)

llvm::AnalysisManager::invalidate

void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)

Invalidate cached analyses for an IR unit.

Definition:PassManagerImpl.h:172

llvm::DenseMapBase::lookup

ValueT lookup(const_arg_type_t< KeyT > Val) const

lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...

Definition:DenseMap.h:194

llvm::DenseMapBase::find

iterator find(const_arg_type_t< KeyT > Val)

Definition:DenseMap.h:156

llvm::DenseMapBase::empty

bool empty() const

Definition:DenseMap.h:98

llvm::DenseMapBase::end

iterator end()

Definition:DenseMap.h:84

llvm::DenseMapBase::insert

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

Definition:DenseMap.h:211

llvm::PassInstrumentation

This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks regis...

Definition:PassInstrumentation.h:207

llvm::PassInstrumentation::runBeforeAnalysis

void runBeforeAnalysis(const PassT &Analysis, const IRUnitT &IR) const

BeforeAnalysis instrumentation point - takes Analysis instance to be executed and constant reference ...

Definition:PassInstrumentation.h:290

llvm::PassInstrumentation::runAnalysisInvalidated

void runAnalysisInvalidated(const PassT &Analysis, const IRUnitT &IR) const

AnalysisInvalidated instrumentation point - takes Analysis instance that has just been invalidated an...

Definition:PassInstrumentation.h:309

llvm::PassInstrumentation::getPassNameForClassName

StringRef getPassNameForClassName(StringRef ClassName) const

Get the pass name for a given pass class name.

Definition:PassInstrumentation.h:345

llvm::PassInstrumentation::runAfterPass

void runAfterPass(const PassT &Pass, const IRUnitT &IR, const PreservedAnalyses &PA) const

AfterPass instrumentation point - takes Pass instance that has just been executed and constant refere...

Definition:PassInstrumentation.h:269

llvm::PassInstrumentation::runAfterAnalysis

void runAfterAnalysis(const PassT &Analysis, const IRUnitT &IR) const

AfterAnalysis instrumentation point - takes Analysis instance that has just been executed and constan...

Definition:PassInstrumentation.h:299

llvm::PassInstrumentation::runBeforePass

bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const

BeforePass instrumentation point - takes Pass instance to be executed and constant reference to IR it...

Definition:PassInstrumentation.h:244

llvm::PassManager::run

PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)

Run all of the passes in this manager over the given unit of IR.

Definition:PassManagerImpl.h:29

llvm::Pass

Pass interface - Implemented by all 'passes'.

Definition:Pass.h:94

llvm::PreservedAnalyses

A set of analyses that are preserved following a run of a transformation pass.

Definition:Analysis.h:111

llvm::PreservedAnalyses::all

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

Definition:Analysis.h:117

llvm::PreservedAnalyses::allAnalysesInSetPreserved

bool allAnalysesInSetPreserved() const

Directly test whether a set of analyses is preserved.

Definition:Analysis.h:289

llvm::PreservedAnalyses::intersect

void intersect(const PreservedAnalyses &Arg)

Intersect this set with another in place.

Definition:Analysis.h:182

llvm::PreservedAnalyses::preserveSet

void preserveSet()

Mark an analysis set as preserved.

Definition:Analysis.h:146

llvm::PrettyStackTraceEntry

PrettyStackTraceEntry - This class is used to represent a frame of the "pretty" stack trace that is d...

Definition:PrettyStackTrace.h:52

llvm::ScopedDbgInfoFormatSetter

Used to temporarily set the debug info format of a function, module, or basic block for the duration ...

Definition:DebugProgramInstruction.h:688

llvm::SmallDenseMap

Definition:DenseMap.h:883

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::cl::opt

Definition:CommandLine.h:1423

llvm::raw_ostream

This class implements an extremely fast bulk output stream that can only output to a stream.

Definition:raw_ostream.h:52

unsigned

llvm::CallingConv::ID

unsigned ID

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

Definition:CallingConv.h:24

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::printIRUnitNameForStackTrace

void printIRUnitNameForStackTrace(raw_ostream &OS, const IRUnitT &IR)

llvm::AnalysisInfoMixin< PassInstrumentationAnalysis >::ID

static AnalysisKey * ID()

Returns an opaque, unique ID for this analysis type.

Definition:PassManager.h:108

llvm::AnalysisKey

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

Definition:Analysis.h:28

llvm::detail::PassConcept< IRUnitT, AnalysisManagerT, ExtraArgTs... >