LLVM 20.0.0git
SSAUpdater.cpp
Go to the documentation of this file.
1//===- SSAUpdater.cpp - Unstructured SSA Update Tool ----------------------===//
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//
9// This file implements the SSAUpdater class.
10//
11//===----------------------------------------------------------------------===//
12
14#include "llvm/ADT/DenseMap.h"
15#include "llvm/ADT/STLExtras.h"
19#include "llvm/IR/BasicBlock.h"
20#include "llvm/IR/CFG.h"
21#include "llvm/IR/Constants.h"
22#include "llvm/IR/DebugInfo.h"
23#include "llvm/IR/DebugLoc.h"
24#include "llvm/IR/Instruction.h"
26#include "llvm/IR/Module.h"
27#include "llvm/IR/Use.h"
28#include "llvm/IR/Value.h"
30#include "llvm/Support/Debug.h"
33#include <cassert>
34#include <utility>
35
36using namespace llvm;
37
38#define DEBUG_TYPE "ssaupdater"
39
41
43 return *static_cast<AvailableValsTy*>(AV);
44}
45
47 : InsertedPHIs(NewPHI) {}
48
50 delete static_cast<AvailableValsTy*>(AV);
51}
52
54 if (!AV)
55 AV = new AvailableValsTy();
56 else
58 ProtoType = Ty;
59 ProtoName = std::string(Name);
60}
61
63 return getAvailableVals(AV).count(BB);
64}
65
67 return getAvailableVals(AV).lookup(BB);
68}
69
71 assert(ProtoType && "Need to initialize SSAUpdater");
72 assert(ProtoType == V->getType() &&
73 "All rewritten values must have the same type");
74 getAvailableVals(AV)[BB] = V;
75}
76
79 unsigned PHINumValues = PHI->getNumIncomingValues();
80 if (PHINumValues != ValueMapping.size())
81 return false;
82
83 // Scan the phi to see if it matches.
84 for (unsigned i = 0, e = PHINumValues; i != e; ++i)
85 if (ValueMapping[PHI->getIncomingBlock(i)] !=
86 PHI->getIncomingValue(i)) {
87 return false;
88 }
89
90 return true;
91}
92
94 Value *Res = GetValueAtEndOfBlockInternal(BB);
95 return Res;
96}
97
99 // If there is no definition of the renamed variable in this block, just use
100 // GetValueAtEndOfBlock to do our work.
101 if (!HasValueForBlock(BB))
102 return GetValueAtEndOfBlock(BB);
103
104 // Otherwise, we have the hard case. Get the live-in values for each
105 // predecessor.
107 Value *SingularValue = nullptr;
108
109 // We can get our predecessor info by walking the pred_iterator list, but it
110 // is relatively slow. If we already have PHI nodes in this block, walk one
111 // of them to get the predecessor list instead.
112 if (PHINode *SomePhi = dyn_cast<PHINode>(BB->begin())) {
113 for (unsigned i = 0, e = SomePhi->getNumIncomingValues(); i != e; ++i) {
114 BasicBlock *PredBB = SomePhi->getIncomingBlock(i);
115 Value *PredVal = GetValueAtEndOfBlock(PredBB);
116 PredValues.push_back(std::make_pair(PredBB, PredVal));
117
118 // Compute SingularValue.
119 if (i == 0)
120 SingularValue = PredVal;
121 else if (PredVal != SingularValue)
122 SingularValue = nullptr;
123 }
124 } else {
125 bool isFirstPred = true;
126 for (BasicBlock *PredBB : predecessors(BB)) {
127 Value *PredVal = GetValueAtEndOfBlock(PredBB);
128 PredValues.push_back(std::make_pair(PredBB, PredVal));
129
130 // Compute SingularValue.
131 if (isFirstPred) {
132 SingularValue = PredVal;
133 isFirstPred = false;
134 } else if (PredVal != SingularValue)
135 SingularValue = nullptr;
136 }
137 }
138
139 // If there are no predecessors, just return poison.
140 if (PredValues.empty())
141 return PoisonValue::get(ProtoType);
142
143 // Otherwise, if all the merged values are the same, just use it.
144 if (SingularValue)
145 return SingularValue;
146
147 // Otherwise, we do need a PHI: check to see if we already have one available
148 // in this block that produces the right value.
149 if (isa<PHINode>(BB->begin())) {
150 SmallDenseMap<BasicBlock *, Value *, 8> ValueMapping(PredValues.begin(),
151 PredValues.end());
152 for (PHINode &SomePHI : BB->phis()) {
153 if (IsEquivalentPHI(&SomePHI, ValueMapping))
154 return &SomePHI;
155 }
156 }
157
158 // Ok, we have no way out, insert a new one now.
159 PHINode *InsertedPHI =
160 PHINode::Create(ProtoType, PredValues.size(), ProtoName);
161 InsertedPHI->insertBefore(BB->begin());
162
163 // Fill in all the predecessors of the PHI.
164 for (const auto &PredValue : PredValues)
165 InsertedPHI->addIncoming(PredValue.second, PredValue.first);
166
167 // See if the PHI node can be merged to a single value. This can happen in
168 // loop cases when we get a PHI of itself and one other value.
169 if (Value *V =
170 simplifyInstruction(InsertedPHI, BB->getDataLayout())) {
171 InsertedPHI->eraseFromParent();
172 return V;
173 }
174
175 // Set the DebugLoc of the inserted PHI, if available.
176 DebugLoc DL;
177 if (const Instruction *I = BB->getFirstNonPHI())
178 DL = I->getDebugLoc();
179 InsertedPHI->setDebugLoc(DL);
180
181 // If the client wants to know about all new instructions, tell it.
182 if (InsertedPHIs) InsertedPHIs->push_back(InsertedPHI);
183
184 LLVM_DEBUG(dbgs() << " Inserted PHI: " << *InsertedPHI << "\n");
185 return InsertedPHI;
186}
187
189 Instruction *User = cast<Instruction>(U.getUser());
190
191 Value *V;
192 if (PHINode *UserPN = dyn_cast<PHINode>(User))
193 V = GetValueAtEndOfBlock(UserPN->getIncomingBlock(U));
194 else
195 V = GetValueInMiddleOfBlock(User->getParent());
196
197 U.set(V);
198}
199
202 SmallVector<DbgVariableRecord *, 4> DbgVariableRecords;
203 llvm::findDbgValues(DbgValues, I, &DbgVariableRecords);
204 for (auto &DbgValue : DbgValues) {
205 if (DbgValue->getParent() == I->getParent())
206 continue;
207 UpdateDebugValue(I, DbgValue);
208 }
209 for (auto &DVR : DbgVariableRecords) {
210 if (DVR->getParent() == I->getParent())
211 continue;
212 UpdateDebugValue(I, DVR);
213 }
214}
215
218 for (auto &DbgValue : DbgValues) {
219 UpdateDebugValue(I, DbgValue);
220 }
221}
222
224 Instruction *I, SmallVectorImpl<DbgVariableRecord *> &DbgVariableRecords) {
225 for (auto &DVR : DbgVariableRecords) {
226 UpdateDebugValue(I, DVR);
227 }
228}
229
230void SSAUpdater::UpdateDebugValue(Instruction *I, DbgValueInst *DbgValue) {
231 BasicBlock *UserBB = DbgValue->getParent();
232 if (HasValueForBlock(UserBB)) {
233 Value *NewVal = GetValueAtEndOfBlock(UserBB);
234 DbgValue->replaceVariableLocationOp(I, NewVal);
235 } else
236 DbgValue->setKillLocation();
237}
238
239void SSAUpdater::UpdateDebugValue(Instruction *I, DbgVariableRecord *DVR) {
240 BasicBlock *UserBB = DVR->getParent();
241 if (HasValueForBlock(UserBB)) {
242 Value *NewVal = GetValueAtEndOfBlock(UserBB);
243 DVR->replaceVariableLocationOp(I, NewVal);
244 } else
245 DVR->setKillLocation();
246}
247
249 Instruction *User = cast<Instruction>(U.getUser());
250
251 Value *V;
252 if (PHINode *UserPN = dyn_cast<PHINode>(User))
253 V = GetValueAtEndOfBlock(UserPN->getIncomingBlock(U));
254 else
255 V = GetValueAtEndOfBlock(User->getParent());
256
257 U.set(V);
258}
259
260namespace llvm {
261
262template<>
264public:
266 using ValT = Value *;
267 using PhiT = PHINode;
269
270 static BlkSucc_iterator BlkSucc_begin(BlkT *BB) { return succ_begin(BB); }
271 static BlkSucc_iterator BlkSucc_end(BlkT *BB) { return succ_end(BB); }
272
273 class PHI_iterator {
274 private:
275 PHINode *PHI;
276 unsigned idx;
277
278 public:
279 explicit PHI_iterator(PHINode *P) // begin iterator
280 : PHI(P), idx(0) {}
281 PHI_iterator(PHINode *P, bool) // end iterator
282 : PHI(P), idx(PHI->getNumIncomingValues()) {}
283
284 PHI_iterator &operator++() { ++idx; return *this; }
285 bool operator==(const PHI_iterator& x) const { return idx == x.idx; }
286 bool operator!=(const PHI_iterator& x) const { return !operator==(x); }
287
288 Value *getIncomingValue() { return PHI->getIncomingValue(idx); }
289 BasicBlock *getIncomingBlock() { return PHI->getIncomingBlock(idx); }
290 };
291
292 static PHI_iterator PHI_begin(PhiT *PHI) { return PHI_iterator(PHI); }
293 static PHI_iterator PHI_end(PhiT *PHI) {
294 return PHI_iterator(PHI, true);
295 }
296
297 /// FindPredecessorBlocks - Put the predecessors of Info->BB into the Preds
298 /// vector, set Info->NumPreds, and allocate space in Info->Preds.
301 // We can get our predecessor info by walking the pred_iterator list,
302 // but it is relatively slow. If we already have PHI nodes in this
303 // block, walk one of them to get the predecessor list instead.
304 if (PHINode *SomePhi = dyn_cast<PHINode>(BB->begin()))
305 append_range(*Preds, SomePhi->blocks());
306 else
307 append_range(*Preds, predecessors(BB));
308 }
309
310 /// GetPoisonVal - Get a poison value of the same type as the value
311 /// being handled.
312 static Value *GetPoisonVal(BasicBlock *BB, SSAUpdater *Updater) {
313 return PoisonValue::get(Updater->ProtoType);
314 }
315
316 /// CreateEmptyPHI - Create a new PHI instruction in the specified block.
317 /// Reserve space for the operands but do not fill them in yet.
318 static Value *CreateEmptyPHI(BasicBlock *BB, unsigned NumPreds,
319 SSAUpdater *Updater) {
320 PHINode *PHI =
321 PHINode::Create(Updater->ProtoType, NumPreds, Updater->ProtoName);
322 PHI->insertBefore(BB->begin());
323 return PHI;
324 }
325
326 /// AddPHIOperand - Add the specified value as an operand of the PHI for
327 /// the specified predecessor block.
328 static void AddPHIOperand(PHINode *PHI, Value *Val, BasicBlock *Pred) {
329 PHI->addIncoming(Val, Pred);
330 }
331
332 /// ValueIsPHI - Check if a value is a PHI.
333 static PHINode *ValueIsPHI(Value *Val, SSAUpdater *Updater) {
334 return dyn_cast<PHINode>(Val);
335 }
336
337 /// ValueIsNewPHI - Like ValueIsPHI but also check if the PHI has no source
338 /// operands, i.e., it was just added.
339 static PHINode *ValueIsNewPHI(Value *Val, SSAUpdater *Updater) {
340 PHINode *PHI = ValueIsPHI(Val, Updater);
341 if (PHI && PHI->getNumIncomingValues() == 0)
342 return PHI;
343 return nullptr;
344 }
345
346 /// GetPHIValue - For the specified PHI instruction, return the value
347 /// that it defines.
349 return PHI;
350 }
351};
352
353} // end namespace llvm
354
355/// Check to see if AvailableVals has an entry for the specified BB and if so,
356/// return it. If not, construct SSA form by first calculating the required
357/// placement of PHIs and then inserting new PHIs where needed.
358Value *SSAUpdater::GetValueAtEndOfBlockInternal(BasicBlock *BB) {
359 AvailableValsTy &AvailableVals = getAvailableVals(AV);
360 if (Value *V = AvailableVals[BB])
361 return V;
362
363 SSAUpdaterImpl<SSAUpdater> Impl(this, &AvailableVals, InsertedPHIs);
364 return Impl.GetValue(BB);
365}
366
367//===----------------------------------------------------------------------===//
368// LoadAndStorePromoter Implementation
369//===----------------------------------------------------------------------===//
370
373 SSAUpdater &S, StringRef BaseName) : SSA(S) {
374 if (Insts.empty()) return;
375
376 const Value *SomeVal;
377 if (const LoadInst *LI = dyn_cast<LoadInst>(Insts[0]))
378 SomeVal = LI;
379 else
380 SomeVal = cast<StoreInst>(Insts[0])->getOperand(0);
381
382 if (BaseName.empty())
383 BaseName = SomeVal->getName();
384 SSA.Initialize(SomeVal->getType(), BaseName);
385}
386
388 // First step: bucket up uses of the alloca by the block they occur in.
389 // This is important because we have to handle multiple defs/uses in a block
390 // ourselves: SSAUpdater is purely for cross-block references.
392
393 for (Instruction *User : Insts)
394 UsesByBlock[User->getParent()].push_back(User);
395
396 // Okay, now we can iterate over all the blocks in the function with uses,
397 // processing them. Keep track of which loads are loading a live-in value.
398 // Walk the uses in the use-list order to be determinstic.
399 SmallVector<LoadInst *, 32> LiveInLoads;
400 DenseMap<Value *, Value *> ReplacedLoads;
401
402 for (Instruction *User : Insts) {
403 BasicBlock *BB = User->getParent();
404 TinyPtrVector<Instruction *> &BlockUses = UsesByBlock[BB];
405
406 // If this block has already been processed, ignore this repeat use.
407 if (BlockUses.empty()) continue;
408
409 // Okay, this is the first use in the block. If this block just has a
410 // single user in it, we can rewrite it trivially.
411 if (BlockUses.size() == 1) {
412 // If it is a store, it is a trivial def of the value in the block.
413 if (StoreInst *SI = dyn_cast<StoreInst>(User)) {
414 updateDebugInfo(SI);
415 SSA.AddAvailableValue(BB, SI->getOperand(0));
416 } else
417 // Otherwise it is a load, queue it to rewrite as a live-in load.
418 LiveInLoads.push_back(cast<LoadInst>(User));
419 BlockUses.clear();
420 continue;
421 }
422
423 // Otherwise, check to see if this block is all loads.
424 bool HasStore = false;
425 for (Instruction *I : BlockUses) {
426 if (isa<StoreInst>(I)) {
427 HasStore = true;
428 break;
429 }
430 }
431
432 // If so, we can queue them all as live in loads. We don't have an
433 // efficient way to tell which on is first in the block and don't want to
434 // scan large blocks, so just add all loads as live ins.
435 if (!HasStore) {
436 for (Instruction *I : BlockUses)
437 LiveInLoads.push_back(cast<LoadInst>(I));
438 BlockUses.clear();
439 continue;
440 }
441
442 // Otherwise, we have mixed loads and stores (or just a bunch of stores).
443 // Since SSAUpdater is purely for cross-block values, we need to determine
444 // the order of these instructions in the block. If the first use in the
445 // block is a load, then it uses the live in value. The last store defines
446 // the live out value. We handle this by doing a linear scan of the block.
447 Value *StoredValue = nullptr;
448 for (Instruction &I : *BB) {
449 if (LoadInst *L = dyn_cast<LoadInst>(&I)) {
450 // If this is a load from an unrelated pointer, ignore it.
451 if (!isInstInList(L, Insts)) continue;
452
453 // If we haven't seen a store yet, this is a live in use, otherwise
454 // use the stored value.
455 if (StoredValue) {
456 replaceLoadWithValue(L, StoredValue);
457 L->replaceAllUsesWith(StoredValue);
458 ReplacedLoads[L] = StoredValue;
459 } else {
460 LiveInLoads.push_back(L);
461 }
462 continue;
463 }
464
465 if (StoreInst *SI = dyn_cast<StoreInst>(&I)) {
466 // If this is a store to an unrelated pointer, ignore it.
467 if (!isInstInList(SI, Insts)) continue;
468 updateDebugInfo(SI);
469
470 // Remember that this is the active value in the block.
471 StoredValue = SI->getOperand(0);
472 }
473 }
474
475 // The last stored value that happened is the live-out for the block.
476 assert(StoredValue && "Already checked that there is a store in block");
477 SSA.AddAvailableValue(BB, StoredValue);
478 BlockUses.clear();
479 }
480
481 // Okay, now we rewrite all loads that use live-in values in the loop,
482 // inserting PHI nodes as necessary.
483 for (LoadInst *ALoad : LiveInLoads) {
484 Value *NewVal = SSA.GetValueInMiddleOfBlock(ALoad->getParent());
485 replaceLoadWithValue(ALoad, NewVal);
486
487 // Avoid assertions in unreachable code.
488 if (NewVal == ALoad) NewVal = PoisonValue::get(NewVal->getType());
489 ALoad->replaceAllUsesWith(NewVal);
490 ReplacedLoads[ALoad] = NewVal;
491 }
492
493 // Allow the client to do stuff before we start nuking things.
495
496 // Now that everything is rewritten, delete the old instructions from the
497 // function. They should all be dead now.
498 for (Instruction *User : Insts) {
499 if (!shouldDelete(User))
500 continue;
501
502 // If this is a load that still has uses, then the load must have been added
503 // as a live value in the SSAUpdate data structure for a block (e.g. because
504 // the loaded value was stored later). In this case, we need to recursively
505 // propagate the updates until we get to the real value.
506 if (!User->use_empty()) {
507 Value *NewVal = ReplacedLoads[User];
508 assert(NewVal && "not a replaced load?");
509
510 // Propagate down to the ultimate replacee. The intermediately loads
511 // could theoretically already have been deleted, so we don't want to
512 // dereference the Value*'s.
513 DenseMap<Value*, Value*>::iterator RLI = ReplacedLoads.find(NewVal);
514 while (RLI != ReplacedLoads.end()) {
515 NewVal = RLI->second;
516 RLI = ReplacedLoads.find(NewVal);
517 }
518
519 replaceLoadWithValue(cast<LoadInst>(User), NewVal);
520 User->replaceAllUsesWith(NewVal);
521 }
522
524 User->eraseFromParent();
525 }
526}
527
528bool
531 const {
532 return is_contained(Insts, I);
533}
Rewrite undef for PHI
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file contains the declarations for the subclasses of Constant, which represent the different fla...
#define LLVM_DEBUG(X)
Definition: Debug.h:101
This file defines the DenseMap class.
std::string Name
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
This defines the Use class.
#define I(x, y, z)
Definition: MD5.cpp:58
static AvailableValsTy & getAvailableVals(void *AV)
DenseMap< MachineBasicBlock *, Register > AvailableValsTy
Memory SSA
Definition: MemorySSA.cpp:72
Module.h This file contains the declarations for the Module class.
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static AvailableValsTy & getAvailableVals(void *AV)
Definition: SSAUpdater.cpp:42
static bool IsEquivalentPHI(PHINode *PHI, SmallDenseMap< BasicBlock *, Value *, 8 > &ValueMapping)
Definition: SSAUpdater.cpp:77
This file contains some templates that are useful if you are working with the STL at all.
This file defines the SmallVector class.
Class recording the (high level) value of a variable.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
LLVM Basic Block Representation.
Definition: BasicBlock.h:61
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:448
iterator_range< const_phi_iterator > phis() const
Returns a range that iterates over the phis in the basic block.
Definition: BasicBlock.h:517
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:367
const DataLayout & getDataLayout() const
Get the data layout of the module this basic block belongs to.
Definition: BasicBlock.cpp:296
const BasicBlock * getParent() const
This represents the llvm.dbg.value instruction.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
void replaceVariableLocationOp(Value *OldValue, Value *NewValue, bool AllowEmpty=false)
A debug info location.
Definition: DebugLoc.h:33
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
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
unsigned size() const
Definition: DenseMap.h:99
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:151
iterator end()
Definition: DenseMap.h:84
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
Definition: Instruction.cpp:97
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:92
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:463
virtual void instructionDeleted(Instruction *I) const
Called before each instruction is deleted.
Definition: SSAUpdater.h:183
virtual void doExtraRewritesBeforeFinalDeletion()
This hook is invoked after all the stores are found and inserted as available values.
Definition: SSAUpdater.h:176
LoadAndStorePromoter(ArrayRef< const Instruction * > Insts, SSAUpdater &S, StringRef Name=StringRef())
Definition: SSAUpdater.cpp:372
virtual bool isInstInList(Instruction *I, const SmallVectorImpl< Instruction * > &Insts) const
Return true if the specified instruction is in the Inst list.
Definition: SSAUpdater.cpp:529
virtual void replaceLoadWithValue(LoadInst *LI, Value *V) const
Clients can choose to implement this to get notified right before a load is RAUW'd another value.
Definition: SSAUpdater.h:180
void run(const SmallVectorImpl< Instruction * > &Insts)
This does the promotion.
Definition: SSAUpdater.cpp:387
virtual void updateDebugInfo(Instruction *I) const
Called to update debug info associated with the instruction.
Definition: SSAUpdater.h:186
virtual bool shouldDelete(Instruction *I) const
Return false if a sub-class wants to keep one of the loads/stores after the SSA construction.
Definition: SSAUpdater.h:190
An instruction for reading from memory.
Definition: Instructions.h:174
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition: Constants.cpp:1852
bool operator!=(const PHI_iterator &x) const
Definition: SSAUpdater.cpp:286
bool operator==(const PHI_iterator &x) const
Definition: SSAUpdater.cpp:285
static BlkSucc_iterator BlkSucc_end(BlkT *BB)
Definition: SSAUpdater.cpp:271
static BlkSucc_iterator BlkSucc_begin(BlkT *BB)
Definition: SSAUpdater.cpp:270
static void FindPredecessorBlocks(BasicBlock *BB, SmallVectorImpl< BasicBlock * > *Preds)
FindPredecessorBlocks - Put the predecessors of Info->BB into the Preds vector, set Info->NumPreds,...
Definition: SSAUpdater.cpp:299
static Value * CreateEmptyPHI(BasicBlock *BB, unsigned NumPreds, SSAUpdater *Updater)
CreateEmptyPHI - Create a new PHI instruction in the specified block.
Definition: SSAUpdater.cpp:318
static PHINode * ValueIsNewPHI(Value *Val, SSAUpdater *Updater)
ValueIsNewPHI - Like ValueIsPHI but also check if the PHI has no source operands, i....
Definition: SSAUpdater.cpp:339
static PHI_iterator PHI_begin(PhiT *PHI)
Definition: SSAUpdater.cpp:292
static void AddPHIOperand(PHINode *PHI, Value *Val, BasicBlock *Pred)
AddPHIOperand - Add the specified value as an operand of the PHI for the specified predecessor block.
Definition: SSAUpdater.cpp:328
static Value * GetPHIValue(PHINode *PHI)
GetPHIValue - For the specified PHI instruction, return the value that it defines.
Definition: SSAUpdater.cpp:348
static Value * GetPoisonVal(BasicBlock *BB, SSAUpdater *Updater)
GetPoisonVal - Get a poison value of the same type as the value being handled.
Definition: SSAUpdater.cpp:312
static PHI_iterator PHI_end(PhiT *PHI)
Definition: SSAUpdater.cpp:293
static PHINode * ValueIsPHI(Value *Val, SSAUpdater *Updater)
ValueIsPHI - Check if a value is a PHI.
Definition: SSAUpdater.cpp:333
Helper class for SSA formation on a set of values defined in multiple blocks.
Definition: SSAUpdater.h:40
void RewriteUse(Use &U)
Rewrite a use of the symbolic value.
Definition: SSAUpdater.cpp:188
void RewriteUseAfterInsertions(Use &U)
Rewrite a use like RewriteUse but handling in-block definitions.
Definition: SSAUpdater.cpp:248
Value * FindValueForBlock(BasicBlock *BB) const
Return the value for the specified block if the SSAUpdater has one, otherwise return nullptr.
Definition: SSAUpdater.cpp:66
void Initialize(Type *Ty, StringRef Name)
Reset this object to get ready for a new set of SSA updates with type 'Ty'.
Definition: SSAUpdater.cpp:53
Value * GetValueInMiddleOfBlock(BasicBlock *BB)
Construct SSA form, materializing a value that is live in the middle of the specified block.
Definition: SSAUpdater.cpp:98
SSAUpdater(SmallVectorImpl< PHINode * > *InsertedPHIs=nullptr)
If InsertedPHIs is specified, it will be filled in with all PHI Nodes created by rewriting.
Definition: SSAUpdater.cpp:46
void UpdateDebugValues(Instruction *I)
Rewrite debug value intrinsics to conform to a new SSA form.
Definition: SSAUpdater.cpp:200
bool HasValueForBlock(BasicBlock *BB) const
Return true if the SSAUpdater already has a value for the specified block.
Definition: SSAUpdater.cpp:62
Value * GetValueAtEndOfBlock(BasicBlock *BB)
Construct SSA form, materializing a value that is live at the end of the specified block.
Definition: SSAUpdater.cpp:93
void AddAvailableValue(BasicBlock *BB, Value *V)
Indicate that a rewritten value is available in the specified block with the specified value.
Definition: SSAUpdater.cpp:70
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
An instruction for storing to memory.
Definition: Instructions.h:290
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
Definition: TinyPtrVector.h:29
bool empty() const
unsigned size() const
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:534
bool use_empty() const
Definition: Value.h:344
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition: STLExtras.h:2098
void findDbgValues(SmallVectorImpl< DbgValueInst * > &DbgValues, Value *V, SmallVectorImpl< DbgVariableRecord * > *DbgVariableRecords=nullptr)
Finds the llvm.dbg.value intrinsics describing a value.
Definition: DebugInfo.cpp:138
bool operator==(const AddressRangeValuePair &LHS, const AddressRangeValuePair &RHS)
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
SuccIterator< Instruction, BasicBlock > succ_iterator
Definition: CFG.h:242
RNSuccIterator< NodeRef, BlockT, RegionT > succ_begin(NodeRef Node)
RNSuccIterator< NodeRef, BlockT, RegionT > succ_end(NodeRef Node)
auto predecessors(const MachineBasicBlock *BB)
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
Definition: STLExtras.h:1886