FunctionSpecialization.h Source File (original) (raw)

81#ifndef LLVM_TRANSFORMS_IPO_FUNCTIONSPECIALIZATION_H

82#define LLVM_TRANSFORMS_IPO_FUNCTIONSPECIALIZATION_H

95namespace llvm {

101

102

104

105

107

108

109

126

127

129

131

132

134

135

137

138

140

141

143

144

146

151};

152

159

161

163

165

166

167

168

170

172

173public:

177 : GetBFI(GetBFI), F(F), DL(DL), TTI(TTI), Solver(Solver) {}

178

180 return Solver.isBlockExecutable(BB) && !DeadBlocks.contains(BB);

181 }

182

184

186

188

189private:

191

193

195

198

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216 bool discoverTransitivelyIncomingValues(Constant *Const, PHINode *Root,

218

230};

231

233

234

236

238

239

241

242

247

252 unsigned NGlobals = 0;

253

254public:

261 : Solver(Solver), M(M), FAM(FAM), GetBFI(GetBFI), GetTLI(GetTLI),

262 GetTTI(GetTTI), GetAC(GetAC) {}

263

265

267

269 auto &TTI = GetTTI(*F);

271 }

272

274

275private:

277

278

279

280

282

283

284

285 void promoteConstantStackValues(Function *F);

286

287

288 void removeDeadFunctions();

289

290

291 void cleanUpSSA();

292

293

294

295

296

297

298

299 bool findSpecializations(Function *F, unsigned FuncSize,

301

302

304

305 bool isCandidateFunction(Function *F);

306

307

308

309

310

312

313

314

315 bool isArgumentInteresting(Argument *A);

316

317

318

320

321

322

323

324

325 void updateCallSites(Function *F, const Spec *Begin, const Spec *End);

326};

327}

328

329#endif

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

This pass exposes codegen information to IR-level passes.

an instruction to allocate memory on the stack

This class represents an incoming formal argument to a Function.

A cache of @llvm.assume calls within a function.

LLVM Basic Block Representation.

BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...

Conditional or Unconditional Branch instruction.

Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...

This class represents a function call, abstracting a target machine's calling convention.

This is the base class for all instructions that perform data casts.

This class is the base class for the comparison instructions.

This is an important base class in LLVM.

A parsed version of the target data layout string in and methods for querying it.

DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator

Implements a dense probed hash-table based set.

This class represents a freeze function that returns random concrete value if an operand is either a ...

LLVM_ABI ~FunctionSpecializer()

LLVM_ABI bool run()

Attempt to specialize functions in the module to enable constant propagation across function boundari...

FunctionSpecializer(SCCPSolver &Solver, Module &M, FunctionAnalysisManager *FAM, std::function< BlockFrequencyInfo &(Function &)> GetBFI, std::function< const TargetLibraryInfo &(Function &)> GetTLI, std::function< TargetTransformInfo &(Function &)> GetTTI, std::function< AssumptionCache &(Function &)> GetAC)

Definition FunctionSpecialization.h:255

InstCostVisitor getInstCostVisitorFor(Function *F)

Definition FunctionSpecialization.h:268

bool isDeadFunction(Function *F)

Definition FunctionSpecialization.h:273

an instruction for type-safe pointer arithmetic to access elements of arrays and structs

LLVM_ABI Cost getLatencySavingsForKnownConstants()

Compute the latency savings from replacing all arguments with constants for a specialization candidat...

LLVM_ABI Cost getCodeSizeSavingsForArg(Argument *A, Constant *C)

Compute the codesize savings for replacing argument A with constant C.

LLVM_ABI Cost getCodeSizeSavingsFromPendingPHIs()

InstCostVisitor(std::function< BlockFrequencyInfo &(Function &)> GetBFI, Function *F, const DataLayout &DL, TargetTransformInfo &TTI, SCCPSolver &Solver)

Definition FunctionSpecialization.h:174

bool isBlockExecutable(BasicBlock *BB) const

Definition FunctionSpecialization.h:179

Base class for instruction visitors.

An instruction for reading from memory.

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

SCCPSolver - This interface class is a general purpose solver for Sparse Conditional Constant Propaga...

This class represents the LLVM 'select' instruction.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Provides information about what library functions are available for the current target.