MemorySSAUpdater.h Source File (original) (raw)

31#ifndef LLVM_ANALYSIS_MEMORYSSAUPDATER_H

32#define LLVM_ANALYSIS_MEMORYSSAUPDATER_H

42namespace llvm {

45class DominatorTree;

46class Instruction;

47class LoopBlocksRPO;

48template <typename T, unsigned int N> class SmallSetVector;

55private:

65public:

100

101

102

106 bool IgnoreIncomingWithNoClones = false);

107

108

111

112

119

120

121

122

124 bool UpdateDTFirst = false);

125

127

132

133

134

135

136

137

138

139

140

141

142

143

144

147

148

149

150

151

152

153

154

155

156

157

158

159

160

163

164

165

166

167

170 bool IdenticalEdgesWereMerged = true);

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

194 bool CreationMustSucceed = true);

195

196

197

198

202

203

204

208

209

210

211

212

213

214

216

217

218

219

223 }

224

225

226

227

228

229

230

231

233

234

235

236

238

239

241

242private:

243

244 template

246

247

255 getPreviousDefRecursive(BasicBlock *,

259 template

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

287 bool CloneWasSimplified = false);

288

289 template

291 Iter ValuesBegin, Iter ValuesEnd,

295};

296}

297

298#endif

BlockVerifier::State From

mir Rename Register Operands

This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...

This file defines the SmallPtrSet class.

This file defines the SmallSet class.

This file defines the SmallVector class.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

LLVM Basic Block Representation.

Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.

Wrapper class to LoopBlocksDFS that provides a standard begin()/end() interface for the DFS reverse p...

Represents a read-write access to memory, whether it is a must-alias, or a may-alias.

Represents phi nodes for memory accesses.

MemorySSA * getMemorySSA() const

Get handle on MemorySSA.

MemoryUseOrDef * createMemoryAccessBefore(Instruction *I, MemoryAccess *Definition, MemoryUseOrDef *InsertPt)

Create a MemoryAccess in MemorySSA before an existing MemoryAccess.

void insertDef(MemoryDef *Def, bool RenameUses=false)

Insert a definition into the MemorySSA IR.

void moveAfter(MemoryUseOrDef *What, MemoryUseOrDef *Where)

void removeEdge(BasicBlock *From, BasicBlock *To)

Update the MemoryPhi in To following an edge deletion between From and To.

void updateForClonedLoop(const LoopBlocksRPO &LoopBlocks, ArrayRef< BasicBlock * > ExitBlocks, const ValueToValueMapTy &VM, bool IgnoreIncomingWithNoClones=false)

Update MemorySSA after a loop was cloned, given the blocks in RPO order, the exit blocks and a 1:1 ma...

void changeToUnreachable(const Instruction *I)

Instruction I will be changed to an unreachable.

void removeDuplicatePhiEdgesBetween(const BasicBlock *From, const BasicBlock *To)

Update the MemoryPhi in To to have a single incoming edge from From, following a CFG change that repl...

void updatePhisWhenInsertingUniqueBackedgeBlock(BasicBlock *LoopHeader, BasicBlock *LoopPreheader, BasicBlock *BackedgeBlock)

Update MemorySSA when inserting a unique backedge block for a loop.

void insertUse(MemoryUse *Use, bool RenameUses=false)

MemorySSAUpdater(MemorySSA *MSSA)

void removeBlocks(const SmallSetVector< BasicBlock *, 8 > &DeadBlocks)

Remove all MemoryAcceses in a set of BasicBlocks about to be deleted.

void moveAllAfterSpliceBlocks(BasicBlock *From, BasicBlock *To, Instruction *Start)

From block was spliced into From and To.

MemoryAccess * createMemoryAccessInBB(Instruction *I, MemoryAccess *Definition, const BasicBlock *BB, MemorySSA::InsertionPlace Point, bool CreationMustSucceed=true)

Create a MemoryAccess in MemorySSA at a specified point in a block.

void removeMemoryAccess(MemoryAccess *, bool OptimizePhis=false)

Remove a MemoryAccess from MemorySSA, including updating all definitions and uses.

void applyInsertUpdates(ArrayRef< CFGUpdate > Updates, DominatorTree &DT)

Apply CFG insert updates, analogous with the DT edge updates.

MemoryUseOrDef * createMemoryAccessAfter(Instruction *I, MemoryAccess *Definition, MemoryAccess *InsertPt)

Create a MemoryAccess in MemorySSA after an existing MemoryAccess.

void updateForClonedBlockIntoPred(BasicBlock *BB, BasicBlock *P1, const ValueToValueMapTy &VM)

void applyUpdates(ArrayRef< CFGUpdate > Updates, DominatorTree &DT, bool UpdateDTFirst=false)

Apply CFG updates, analogous with the DT edge updates.

void moveAllAfterMergeBlocks(BasicBlock *From, BasicBlock *To, Instruction *Start)

From block was merged into To.

void moveToPlace(MemoryUseOrDef *What, BasicBlock *BB, MemorySSA::InsertionPlace Where)

void wireOldPredecessorsToNewImmediatePredecessor(BasicBlock *Old, BasicBlock *New, ArrayRef< BasicBlock * > Preds, bool IdenticalEdgesWereMerged=true)

A new empty BasicBlock (New) now branches directly to Old.

void updateExitBlocksForClonedLoop(ArrayRef< BasicBlock * > ExitBlocks, const ValueToValueMapTy &VMap, DominatorTree &DT)

Update phi nodes in exit block successors following cloning.

void removeMemoryAccess(const Instruction *I, bool OptimizePhis=false)

Remove MemoryAccess for a given instruction, if a MemoryAccess exists.

void moveBefore(MemoryUseOrDef *What, MemoryUseOrDef *Where)

Encapsulates MemorySSA, including all data associated with memory accesses.

InsertionPlace

Used in various insertion functions to specify whether we are talking about the beginning or end of a...

MemoryUseOrDef * getMemoryAccess(const Instruction *I) const

Given a memory Mod/Ref'ing instruction, get the MemorySSA access associated with it.

Class that has the common methods + fields of memory uses/defs.

Represents read-only accesses to memory.

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

A SetVector that performs no allocations if smaller than a certain size.

SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...

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.

Value handle that tracks a Value across RAUW.

A Use represents the edge between a Value definition and its users.

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

@ BasicBlock

Various leaf nodes.

This is an optimization pass for GlobalISel generic memory operations.