PassManagerInternal.h Source File (original) (raw)

17#ifndef LLVM_IR_PASSMANAGERINTERNAL_H

18#define LLVM_IR_PASSMANAGERINTERNAL_H

24#include

25#include <type_traits>

26#include

28namespace llvm {

31template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;

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

50 ExtraArgTs... ExtraArgs) = 0;

52 virtual void

63};

70template <typename IRUnitT, typename PassT, typename AnalysisManagerT,

71 typename... ExtraArgTs>

90 ExtraArgTs... ExtraArgs) override {

91 return Pass.run(IR, AM, ExtraArgs...);

92 }

97 Pass.printPipeline(OS, MapClassName2PassName);

98 }

101

102 template

103 using has_required_t = decltype(std::declval<T &>().isRequired());

104

107 return T::isRequired();

108 return false;

109 }

110

112

114};

115

116

117

118

119

120template <typename IRUnitT, typename InvalidatorT>

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

140 InvalidatorT &Inv) = 0;

141};

142

143

144

146 using EnabledType = char;

147 struct DisabledType {

148 char a, b;

149 };

150

151

152

153

154 template struct Nonce { using Type = EnabledType; };

155 template

156 static typename Nonce<decltype(std::declval().invalidate(

157 std::declval<IRUnitT &>(), std::declval()))>::Type

159

160

161

162

163

164 template <typename T, typename U> static DisabledType NonceFunction(T U::*);

165 struct CheckerBase { int invalidate; };

166 template struct Checker : CheckerBase, std::remove_cv_t {};

167 template

168 static decltype(NonceFunction(&Checker::invalidate)) check(rank<1>);

169

170

171

172 template

173 static EnabledType check(rank<0>);

174

175public:

176 enum { Value = sizeof(check(rank<2>())) == sizeof(EnabledType) };

177};

178

179

180

181

182

183

184

185template <typename IRUnitT, typename PassT, typename ResultT,

186 typename InvalidatorT,

187 bool HasInvalidateHandler =

190

191

192

193template <typename IRUnitT, typename PassT, typename ResultT,

194 typename InvalidatorT>

198

199

203

208

213

214

215

216

217

218

220 InvalidatorT &) override {

221 auto PAC = PA.template getChecker();

222 return !PAC.preserved() &&

223 !PAC.template preservedSet<AllAnalysesOn>();

224 }

225

227};

228

229

230

231template <typename IRUnitT, typename PassT, typename ResultT,

232 typename InvalidatorT>

236

237

241

246

251

252

254 InvalidatorT &Inv) override {

255 return Result.invalidate(IR, PA, Inv);

256 }

257

259};

260

261

262

263

264

265template <typename IRUnitT, typename InvalidatorT, typename... ExtraArgTs>

268

269

270

271

272 virtual std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>

274 ExtraArgTs... ExtraArgs) = 0;

275

276

278};

279

280

281

282

283

284

285template <typename IRUnitT, typename PassT, typename InvalidatorT,

286 typename... ExtraArgTs>

290

291

294

299

304

305

308

309

310

311

312 std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>

314 ExtraArgTs... ExtraArgs) override {

315 return std::make_unique(

316 Pass.run(IR, AM, std::forward(ExtraArgs)...));

317 }

318

319

320

321

323

325};

326

327}

328

329}

330

331#endif

Legalize the Machine IR a function s Machine IR

This templated class represents "all analyses that operate over " (e....

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

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

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

The instances of the Type class are immutable: once they are created, they are never changed.

SFINAE metafunction for computing whether ResultT provides an invalidate member function.

Definition PassManagerInternal.h:145

@ Value

Definition PassManagerInternal.h:176

An efficient, type-erasing, non-owning reference to a callable.

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

Pass manager infrastructure for declaring and invalidating analyses.

A self-contained host- and target-independent arbitrary-precision floating-point software implementat...

This is an optimization pass for GlobalISel generic memory operations.

typename detail::detector< void, Op, Args... >::value_t is_detected

Detects if a given trait holds for some set of arguments 'Args'.

OutputIt move(R &&Range, OutputIt Out)

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

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

void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)

Implement std::swap in terms of BitVector swap.

Abstract concept of an analysis pass.

Definition PassManagerInternal.h:266

virtual StringRef name() const =0

Polymorphic method to access the name of a pass.

virtual std::unique_ptr< AnalysisResultConcept< IRUnitT, InvalidatorT > > run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs... ExtraArgs)=0

Method to run this analysis over a unit of IR.

virtual ~AnalysisPassConcept()=default

AnalysisPassModel(const AnalysisPassModel &Arg)

Definition PassManagerInternal.h:292

StringRef name() const override

The model delegates to a static PassT::name method.

Definition PassManagerInternal.h:322

AnalysisPassModel(PassT Pass)

Definition PassManagerInternal.h:289

AnalysisResultModel< IRUnitT, PassT, typename PassT::Result, InvalidatorT > ResultModelT

Definition PassManagerInternal.h:306

std::unique_ptr< AnalysisResultConcept< IRUnitT, InvalidatorT > > run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs... ExtraArgs) override

The model delegates to the PassT::run method.

Definition PassManagerInternal.h:313

friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS)

Definition PassManagerInternal.h:295

AnalysisPassModel & operator=(AnalysisPassModel RHS)

Definition PassManagerInternal.h:300

PassT Pass

Definition PassManagerInternal.h:324

AnalysisPassModel(AnalysisPassModel &&Arg)

Definition PassManagerInternal.h:293

Abstract concept of an analysis result.

Definition PassManagerInternal.h:121

virtual ~AnalysisResultConcept()=default

virtual bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA, InvalidatorT &Inv)=0

Method to try and mark a result as invalid.

ResultT Result

Definition PassManagerInternal.h:226

AnalysisResultModel & operator=(AnalysisResultModel RHS)

Definition PassManagerInternal.h:209

AnalysisResultModel(const AnalysisResultModel &Arg)

Definition PassManagerInternal.h:200

AnalysisResultModel(ResultT Result)

Definition PassManagerInternal.h:197

bool invalidate(IRUnitT &, const PreservedAnalyses &PA, InvalidatorT &) override

The model bases invalidation solely on being in the preserved set.

Definition PassManagerInternal.h:219

AnalysisResultModel(AnalysisResultModel &&Arg)

Definition PassManagerInternal.h:201

friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS)

Definition PassManagerInternal.h:204

AnalysisResultModel(ResultT Result)

Definition PassManagerInternal.h:235

ResultT Result

Definition PassManagerInternal.h:258

AnalysisResultModel & operator=(AnalysisResultModel RHS)

Definition PassManagerInternal.h:247

AnalysisResultModel(AnalysisResultModel &&Arg)

Definition PassManagerInternal.h:239

AnalysisResultModel(const AnalysisResultModel &Arg)

Definition PassManagerInternal.h:238

bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA, InvalidatorT &Inv) override

The model delegates to the ResultT method.

Definition PassManagerInternal.h:253

friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS)

Definition PassManagerInternal.h:242

Wrapper to model the analysis result concept.

Definition PassManagerInternal.h:189

Template for the abstract base class used to dispatch polymorphically over pass objects.

Definition PassManagerInternal.h:40

virtual StringRef name() const =0

Polymorphic method to access the name of a pass.

virtual void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)=0

virtual bool isRequired() const =0

Polymorphic method to let a pass optionally exempted from skipping by PassInstrumentation.

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

The polymorphic API which runs the pass over a given IR entity.

virtual ~PassConcept()=default

friend void swap(PassModel &LHS, PassModel &RHS)

Definition PassManagerInternal.h:79

PassModel(PassT Pass)

Definition PassManagerInternal.h:73

decltype(std::declval< T & >().isRequired()) has_required_t

Definition PassManagerInternal.h:103

void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName) override

Definition PassManagerInternal.h:94

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

The polymorphic API which runs the pass over a given IR entity.

Definition PassManagerInternal.h:89

PassModel & operator=(PassModel RHS)

Definition PassManagerInternal.h:84

static bool passIsRequiredImpl()

Definition PassManagerInternal.h:105

bool isRequired() const override

Polymorphic method to let a pass optionally exempted from skipping by PassInstrumentation.

Definition PassManagerInternal.h:111

PassModel(const PassModel &Arg)

Definition PassManagerInternal.h:76

PassModel(PassModel &&Arg)

Definition PassManagerInternal.h:77

StringRef name() const override

Polymorphic method to access the name of a pass.

Definition PassManagerInternal.h:100

PassT Pass

Definition PassManagerInternal.h:113

Utility type to build an inheritance chain that makes it easy to rank overload candidates.