1 | //===- Local.h - Functions to perform local transformations -----*- 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 | // |
9 | // This family of functions perform various local transformations to the |
10 | // program. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_TRANSFORMS_UTILS_LOCAL_H |
15 | #define LLVM_TRANSFORMS_UTILS_LOCAL_H |
16 | |
17 | #include "llvm/ADT/ArrayRef.h" |
18 | #include "llvm/IR/Dominators.h" |
19 | #include "llvm/Support/CommandLine.h" |
20 | #include "llvm/Transforms/Utils/SimplifyCFGOptions.h" |
21 | #include <cstdint> |
22 | |
23 | namespace llvm { |
24 | |
25 | class DataLayout; |
26 | class Value; |
27 | class WeakTrackingVH; |
28 | class WeakVH; |
29 | template <typename T> class SmallVectorImpl; |
30 | class AAResults; |
31 | class AllocaInst; |
32 | class AssumptionCache; |
33 | class BasicBlock; |
34 | class BranchInst; |
35 | class CallBase; |
36 | class CallInst; |
37 | class DbgVariableIntrinsic; |
38 | class DIBuilder; |
39 | class DomTreeUpdater; |
40 | class Function; |
41 | class Instruction; |
42 | class InvokeInst; |
43 | class LoadInst; |
44 | class MDNode; |
45 | class MemorySSAUpdater; |
46 | class PHINode; |
47 | class StoreInst; |
48 | class TargetLibraryInfo; |
49 | class TargetTransformInfo; |
50 | |
51 | //===----------------------------------------------------------------------===// |
52 | // Local constant propagation. |
53 | // |
54 | |
55 | /// If a terminator instruction is predicated on a constant value, convert it |
56 | /// into an unconditional branch to the constant destination. |
57 | /// This is a nontrivial operation because the successors of this basic block |
58 | /// must have their PHI nodes updated. |
59 | /// Also calls RecursivelyDeleteTriviallyDeadInstructions() on any branch/switch |
60 | /// conditions and indirectbr addresses this might make dead if |
61 | /// DeleteDeadConditions is true. |
62 | bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions = false, |
63 | const TargetLibraryInfo *TLI = nullptr, |
64 | DomTreeUpdater *DTU = nullptr); |
65 | |
66 | //===----------------------------------------------------------------------===// |
67 | // Local dead code elimination. |
68 | // |
69 | |
70 | /// Return true if the result produced by the instruction is not used, and the |
71 | /// instruction will return. Certain side-effecting instructions are also |
72 | /// considered dead if there are no uses of the instruction. |
73 | bool isInstructionTriviallyDead(Instruction *I, |
74 | const TargetLibraryInfo *TLI = nullptr); |
75 | |
76 | /// Return true if the result produced by the instruction would have no side |
77 | /// effects if it was not used. This is equivalent to checking whether |
78 | /// isInstructionTriviallyDead would be true if the use count was 0. |
79 | bool wouldInstructionBeTriviallyDead(const Instruction *I, |
80 | const TargetLibraryInfo *TLI = nullptr); |
81 | |
82 | /// Return true if the result produced by the instruction has no side effects on |
83 | /// any paths other than where it is used. This is less conservative than |
84 | /// wouldInstructionBeTriviallyDead which is based on the assumption |
85 | /// that the use count will be 0. An example usage of this API is for |
86 | /// identifying instructions that can be sunk down to use(s). |
87 | bool wouldInstructionBeTriviallyDeadOnUnusedPaths( |
88 | Instruction *I, const TargetLibraryInfo *TLI = nullptr); |
89 | |
90 | /// If the specified value is a trivially dead instruction, delete it. |
91 | /// If that makes any of its operands trivially dead, delete them too, |
92 | /// recursively. Return true if any instructions were deleted. |
93 | bool RecursivelyDeleteTriviallyDeadInstructions( |
94 | Value *V, const TargetLibraryInfo *TLI = nullptr, |
95 | MemorySSAUpdater *MSSAU = nullptr, |
96 | std::function<void(Value *)> AboutToDeleteCallback = |
97 | std::function<void(Value *)>()); |
98 | |
99 | /// Delete all of the instructions in `DeadInsts`, and all other instructions |
100 | /// that deleting these in turn causes to be trivially dead. |
101 | /// |
102 | /// The initial instructions in the provided vector must all have empty use |
103 | /// lists and satisfy `isInstructionTriviallyDead`. |
104 | /// |
105 | /// `DeadInsts` will be used as scratch storage for this routine and will be |
106 | /// empty afterward. |
107 | void RecursivelyDeleteTriviallyDeadInstructions( |
108 | SmallVectorImpl<WeakTrackingVH> &DeadInsts, |
109 | const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr, |
110 | std::function<void(Value *)> AboutToDeleteCallback = |
111 | std::function<void(Value *)>()); |
112 | |
113 | /// Same functionality as RecursivelyDeleteTriviallyDeadInstructions, but allow |
114 | /// instructions that are not trivially dead. These will be ignored. |
115 | /// Returns true if any changes were made, i.e. any instructions trivially dead |
116 | /// were found and deleted. |
117 | bool RecursivelyDeleteTriviallyDeadInstructionsPermissive( |
118 | SmallVectorImpl<WeakTrackingVH> &DeadInsts, |
119 | const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr, |
120 | std::function<void(Value *)> AboutToDeleteCallback = |
121 | std::function<void(Value *)>()); |
122 | |
123 | /// If the specified value is an effectively dead PHI node, due to being a |
124 | /// def-use chain of single-use nodes that either forms a cycle or is terminated |
125 | /// by a trivially dead instruction, delete it. If that makes any of its |
126 | /// operands trivially dead, delete them too, recursively. Return true if a |
127 | /// change was made. |
128 | bool RecursivelyDeleteDeadPHINode(PHINode *PN, |
129 | const TargetLibraryInfo *TLI = nullptr, |
130 | MemorySSAUpdater *MSSAU = nullptr); |
131 | |
132 | /// Scan the specified basic block and try to simplify any instructions in it |
133 | /// and recursively delete dead instructions. |
134 | /// |
135 | /// This returns true if it changed the code, note that it can delete |
136 | /// instructions in other blocks as well in this block. |
137 | bool SimplifyInstructionsInBlock(BasicBlock *BB, |
138 | const TargetLibraryInfo *TLI = nullptr); |
139 | |
140 | /// Replace all the uses of an SSA value in @llvm.dbg intrinsics with |
141 | /// undef. This is useful for signaling that a variable, e.g. has been |
142 | /// found dead and hence it's unavailable at a given program point. |
143 | /// Returns true if the dbg values have been changed. |
144 | bool replaceDbgUsesWithUndef(Instruction *I); |
145 | |
146 | //===----------------------------------------------------------------------===// |
147 | // Control Flow Graph Restructuring. |
148 | // |
149 | |
150 | /// BB is a block with one predecessor and its predecessor is known to have one |
151 | /// successor (BB!). Eliminate the edge between them, moving the instructions in |
152 | /// the predecessor into BB. This deletes the predecessor block. |
153 | void MergeBasicBlockIntoOnlyPred(BasicBlock *BB, DomTreeUpdater *DTU = nullptr); |
154 | |
155 | /// BB is known to contain an unconditional branch, and contains no instructions |
156 | /// other than PHI nodes, potential debug intrinsics and the branch. If |
157 | /// possible, eliminate BB by rewriting all the predecessors to branch to the |
158 | /// successor block and return true. If we can't transform, return false. |
159 | bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB, |
160 | DomTreeUpdater *DTU = nullptr); |
161 | |
162 | /// Check for and eliminate duplicate PHI nodes in this block. This doesn't try |
163 | /// to be clever about PHI nodes which differ only in the order of the incoming |
164 | /// values, but instcombine orders them so it usually won't matter. |
165 | /// |
166 | /// This overload removes the duplicate PHI nodes directly. |
167 | bool EliminateDuplicatePHINodes(BasicBlock *BB); |
168 | |
169 | /// Check for and eliminate duplicate PHI nodes in this block. This doesn't try |
170 | /// to be clever about PHI nodes which differ only in the order of the incoming |
171 | /// values, but instcombine orders them so it usually won't matter. |
172 | /// |
173 | /// This overload collects the PHI nodes to be removed into the ToRemove set. |
174 | bool EliminateDuplicatePHINodes(BasicBlock *BB, |
175 | SmallPtrSetImpl<PHINode *> &ToRemove); |
176 | |
177 | /// This function is used to do simplification of a CFG. For example, it |
178 | /// adjusts branches to branches to eliminate the extra hop, it eliminates |
179 | /// unreachable basic blocks, and does other peephole optimization of the CFG. |
180 | /// It returns true if a modification was made, possibly deleting the basic |
181 | /// block that was pointed to. LoopHeaders is an optional input parameter |
182 | /// providing the set of loop headers that SimplifyCFG should not eliminate. |
183 | extern cl::opt<bool> RequireAndPreserveDomTree; |
184 | bool simplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI, |
185 | DomTreeUpdater *DTU = nullptr, |
186 | const SimplifyCFGOptions &Options = {}, |
187 | ArrayRef<WeakVH> = {}); |
188 | |
189 | /// This function is used to flatten a CFG. For example, it uses parallel-and |
190 | /// and parallel-or mode to collapse if-conditions and merge if-regions with |
191 | /// identical statements. |
192 | bool FlattenCFG(BasicBlock *BB, AAResults *AA = nullptr); |
193 | |
194 | /// If this basic block is ONLY a setcc and a branch, and if a predecessor |
195 | /// branches to us and one of our successors, fold the setcc into the |
196 | /// predecessor and use logical operations to pick the right destination. |
197 | bool FoldBranchToCommonDest(BranchInst *BI, llvm::DomTreeUpdater *DTU = nullptr, |
198 | MemorySSAUpdater *MSSAU = nullptr, |
199 | const TargetTransformInfo *TTI = nullptr, |
200 | unsigned BonusInstThreshold = 1); |
201 | |
202 | /// This function takes a virtual register computed by an Instruction and |
203 | /// replaces it with a slot in the stack frame, allocated via alloca. |
204 | /// This allows the CFG to be changed around without fear of invalidating the |
205 | /// SSA information for the value. It returns the pointer to the alloca inserted |
206 | /// to create a stack slot for X. |
207 | AllocaInst *DemoteRegToStack(Instruction &X, |
208 | bool VolatileLoads = false, |
209 | std::optional<BasicBlock::iterator> AllocaPoint = std::nullopt); |
210 | |
211 | /// This function takes a virtual register computed by a phi node and replaces |
212 | /// it with a slot in the stack frame, allocated via alloca. The phi node is |
213 | /// deleted and it returns the pointer to the alloca inserted. |
214 | AllocaInst *DemotePHIToStack(PHINode *P, std::optional<BasicBlock::iterator> AllocaPoint = std::nullopt); |
215 | |
216 | /// If the specified pointer points to an object that we control, try to modify |
217 | /// the object's alignment to PrefAlign. Returns a minimum known alignment of |
218 | /// the value after the operation, which may be lower than PrefAlign. |
219 | /// |
220 | /// Increating value alignment isn't often possible though. If alignment is |
221 | /// important, a more reliable approach is to simply align all global variables |
222 | /// and allocation instructions to their preferred alignment from the beginning. |
223 | Align tryEnforceAlignment(Value *V, Align PrefAlign, const DataLayout &DL); |
224 | |
225 | /// Try to ensure that the alignment of \p V is at least \p PrefAlign bytes. If |
226 | /// the owning object can be modified and has an alignment less than \p |
227 | /// PrefAlign, it will be increased and \p PrefAlign returned. If the alignment |
228 | /// cannot be increased, the known alignment of the value is returned. |
229 | /// |
230 | /// It is not always possible to modify the alignment of the underlying object, |
231 | /// so if alignment is important, a more reliable approach is to simply align |
232 | /// all global variables and allocation instructions to their preferred |
233 | /// alignment from the beginning. |
234 | Align getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign, |
235 | const DataLayout &DL, |
236 | const Instruction *CxtI = nullptr, |
237 | AssumptionCache *AC = nullptr, |
238 | const DominatorTree *DT = nullptr); |
239 | |
240 | /// Try to infer an alignment for the specified pointer. |
241 | inline Align getKnownAlignment(Value *V, const DataLayout &DL, |
242 | const Instruction *CxtI = nullptr, |
243 | AssumptionCache *AC = nullptr, |
244 | const DominatorTree *DT = nullptr) { |
245 | return getOrEnforceKnownAlignment(V, PrefAlign: MaybeAlign(), DL, CxtI, AC, DT); |
246 | } |
247 | |
248 | /// Create a call that matches the invoke \p II in terms of arguments, |
249 | /// attributes, debug information, etc. The call is not placed in a block and it |
250 | /// will not have a name. The invoke instruction is not removed, nor are the |
251 | /// uses replaced by the new call. |
252 | CallInst *createCallMatchingInvoke(InvokeInst *II); |
253 | |
254 | /// This function converts the specified invoke into a normal call. |
255 | CallInst *changeToCall(InvokeInst *II, DomTreeUpdater *DTU = nullptr); |
256 | |
257 | ///===---------------------------------------------------------------------===// |
258 | /// Dbg Intrinsic utilities |
259 | /// |
260 | |
261 | /// Inserts a llvm.dbg.value intrinsic before a store to an alloca'd value |
262 | /// that has an associated llvm.dbg.declare intrinsic. |
263 | void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, |
264 | StoreInst *SI, DIBuilder &Builder); |
265 | void ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, StoreInst *SI, |
266 | DIBuilder &Builder); |
267 | |
268 | /// Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value |
269 | /// that has an associated llvm.dbg.declare intrinsic. |
270 | void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, |
271 | LoadInst *LI, DIBuilder &Builder); |
272 | void ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, LoadInst *LI, |
273 | DIBuilder &Builder); |
274 | |
275 | /// Inserts a llvm.dbg.value intrinsic after a phi that has an associated |
276 | /// llvm.dbg.declare intrinsic. |
277 | void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, |
278 | PHINode *LI, DIBuilder &Builder); |
279 | void ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, PHINode *LI, |
280 | DIBuilder &Builder); |
281 | |
282 | /// Lowers llvm.dbg.declare intrinsics into appropriate set of |
283 | /// llvm.dbg.value intrinsics. |
284 | bool LowerDbgDeclare(Function &F); |
285 | |
286 | /// Propagate dbg.value intrinsics through the newly inserted PHIs. |
287 | void insertDebugValuesForPHIs(BasicBlock *BB, |
288 | SmallVectorImpl<PHINode *> &InsertedPHIs); |
289 | |
290 | /// Replaces llvm.dbg.declare instruction when the address it |
291 | /// describes is replaced with a new value. If Deref is true, an |
292 | /// additional DW_OP_deref is prepended to the expression. If Offset |
293 | /// is non-zero, a constant displacement is added to the expression |
294 | /// (between the optional Deref operations). Offset can be negative. |
295 | bool replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder, |
296 | uint8_t DIExprFlags, int Offset); |
297 | |
298 | /// Replaces multiple llvm.dbg.value instructions when the alloca it describes |
299 | /// is replaced with a new value. If Offset is non-zero, a constant displacement |
300 | /// is added to the expression (after the mandatory Deref). Offset can be |
301 | /// negative. New llvm.dbg.value instructions are inserted at the locations of |
302 | /// the instructions they replace. |
303 | void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress, |
304 | DIBuilder &Builder, int Offset = 0); |
305 | |
306 | /// Assuming the instruction \p I is going to be deleted, attempt to salvage |
307 | /// debug users of \p I by writing the effect of \p I in a DIExpression. If it |
308 | /// cannot be salvaged changes its debug uses to undef. |
309 | void salvageDebugInfo(Instruction &I); |
310 | |
311 | /// Implementation of salvageDebugInfo, applying only to instructions in |
312 | /// \p Insns, rather than all debug users from findDbgUsers( \p I). |
313 | /// Mark undef if salvaging cannot be completed. |
314 | void salvageDebugInfoForDbgValues(Instruction &I, |
315 | ArrayRef<DbgVariableIntrinsic *> Insns, |
316 | ArrayRef<DbgVariableRecord *> DPInsns); |
317 | |
318 | /// Given an instruction \p I and DIExpression \p DIExpr operating on |
319 | /// it, append the effects of \p I to the DIExpression operand list |
320 | /// \p Ops, or return \p nullptr if it cannot be salvaged. |
321 | /// \p CurrentLocOps is the number of SSA values referenced by the |
322 | /// incoming \p Ops. \return the first non-constant operand |
323 | /// implicitly referred to by Ops. If \p I references more than one |
324 | /// non-constant operand, any additional operands are added to |
325 | /// \p AdditionalValues. |
326 | /// |
327 | /// \example |
328 | //// |
329 | /// I = add %a, i32 1 |
330 | /// |
331 | /// Return = %a |
332 | /// Ops = llvm::dwarf::DW_OP_lit1 llvm::dwarf::DW_OP_add |
333 | /// |
334 | /// I = add %a, %b |
335 | /// |
336 | /// Return = %a |
337 | /// Ops = llvm::dwarf::DW_OP_LLVM_arg0 llvm::dwarf::DW_OP_add |
338 | /// AdditionalValues = %b |
339 | Value *salvageDebugInfoImpl(Instruction &I, uint64_t CurrentLocOps, |
340 | SmallVectorImpl<uint64_t> &Ops, |
341 | SmallVectorImpl<Value *> &AdditionalValues); |
342 | |
343 | /// Point debug users of \p From to \p To or salvage them. Use this function |
344 | /// only when replacing all uses of \p From with \p To, with a guarantee that |
345 | /// \p From is going to be deleted. |
346 | /// |
347 | /// Follow these rules to prevent use-before-def of \p To: |
348 | /// . If \p To is a linked Instruction, set \p DomPoint to \p To. |
349 | /// . If \p To is an unlinked Instruction, set \p DomPoint to the Instruction |
350 | /// \p To will be inserted after. |
351 | /// . If \p To is not an Instruction (e.g a Constant), the choice of |
352 | /// \p DomPoint is arbitrary. Pick \p From for simplicity. |
353 | /// |
354 | /// If a debug user cannot be preserved without reordering variable updates or |
355 | /// introducing a use-before-def, it is either salvaged (\ref salvageDebugInfo) |
356 | /// or deleted. Returns true if any debug users were updated. |
357 | bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, |
358 | DominatorTree &DT); |
359 | |
360 | /// If a terminator in an unreachable basic block has an operand of type |
361 | /// Instruction, transform it into poison. Return true if any operands |
362 | /// are changed to poison. Original Values prior to being changed to poison |
363 | /// are returned in \p PoisonedValues. |
364 | bool handleUnreachableTerminator(Instruction *I, |
365 | SmallVectorImpl<Value *> &PoisonedValues); |
366 | |
367 | /// Remove all instructions from a basic block other than its terminator |
368 | /// and any present EH pad instructions. Returns a pair where the first element |
369 | /// is the number of instructions (excluding debug info intrinsics) that have |
370 | /// been removed, and the second element is the number of debug info intrinsics |
371 | /// that have been removed. |
372 | std::pair<unsigned, unsigned> |
373 | removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB); |
374 | |
375 | /// Insert an unreachable instruction before the specified |
376 | /// instruction, making it and the rest of the code in the block dead. |
377 | unsigned changeToUnreachable(Instruction *I, bool PreserveLCSSA = false, |
378 | DomTreeUpdater *DTU = nullptr, |
379 | MemorySSAUpdater *MSSAU = nullptr); |
380 | |
381 | /// Convert the CallInst to InvokeInst with the specified unwind edge basic |
382 | /// block. This also splits the basic block where CI is located, because |
383 | /// InvokeInst is a terminator instruction. Returns the newly split basic |
384 | /// block. |
385 | BasicBlock *changeToInvokeAndSplitBasicBlock(CallInst *CI, |
386 | BasicBlock *UnwindEdge, |
387 | DomTreeUpdater *DTU = nullptr); |
388 | |
389 | /// Replace 'BB's terminator with one that does not have an unwind successor |
390 | /// block. Rewrites `invoke` to `call`, etc. Updates any PHIs in unwind |
391 | /// successor. Returns the instruction that replaced the original terminator, |
392 | /// which might be a call in case the original terminator was an invoke. |
393 | /// |
394 | /// \param BB Block whose terminator will be replaced. Its terminator must |
395 | /// have an unwind successor. |
396 | Instruction *removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU = nullptr); |
397 | |
398 | /// Remove all blocks that can not be reached from the function's entry. |
399 | /// |
400 | /// Returns true if any basic block was removed. |
401 | bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU = nullptr, |
402 | MemorySSAUpdater *MSSAU = nullptr); |
403 | |
404 | /// Combine the metadata of two instructions so that K can replace J. Some |
405 | /// metadata kinds can only be kept if K does not move, meaning it dominated |
406 | /// J in the original IR. |
407 | /// |
408 | /// Metadata not listed as known via KnownIDs is removed |
409 | void combineMetadata(Instruction *K, const Instruction *J, |
410 | ArrayRef<unsigned> KnownIDs, bool DoesKMove); |
411 | |
412 | /// Combine the metadata of two instructions so that K can replace J. This |
413 | /// specifically handles the case of CSE-like transformations. Some |
414 | /// metadata can only be kept if K dominates J. For this to be correct, |
415 | /// K cannot be hoisted. |
416 | /// |
417 | /// Unknown metadata is removed. |
418 | void combineMetadataForCSE(Instruction *K, const Instruction *J, |
419 | bool DoesKMove); |
420 | |
421 | /// Copy the metadata from the source instruction to the destination (the |
422 | /// replacement for the source instruction). |
423 | void copyMetadataForLoad(LoadInst &Dest, const LoadInst &Source); |
424 | |
425 | /// Patch the replacement so that it is not more restrictive than the value |
426 | /// being replaced. It assumes that the replacement does not get moved from |
427 | /// its original position. |
428 | void patchReplacementInstruction(Instruction *I, Value *Repl); |
429 | |
430 | // Replace each use of 'From' with 'To', if that use does not belong to basic |
431 | // block where 'From' is defined. Returns the number of replacements made. |
432 | unsigned replaceNonLocalUsesWith(Instruction *From, Value *To); |
433 | |
434 | /// Replace each use of 'From' with 'To' if that use is dominated by |
435 | /// the given edge. Returns the number of replacements made. |
436 | unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, |
437 | const BasicBlockEdge &Edge); |
438 | /// Replace each use of 'From' with 'To' if that use is dominated by |
439 | /// the end of the given BasicBlock. Returns the number of replacements made. |
440 | unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, |
441 | const BasicBlock *BB); |
442 | /// Replace each use of 'From' with 'To' if that use is dominated by |
443 | /// the given edge and the callback ShouldReplace returns true. Returns the |
444 | /// number of replacements made. |
445 | unsigned replaceDominatedUsesWithIf( |
446 | Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge, |
447 | function_ref<bool(const Use &U, const Value *To)> ShouldReplace); |
448 | /// Replace each use of 'From' with 'To' if that use is dominated by |
449 | /// the end of the given BasicBlock and the callback ShouldReplace returns true. |
450 | /// Returns the number of replacements made. |
451 | unsigned replaceDominatedUsesWithIf( |
452 | Value *From, Value *To, DominatorTree &DT, const BasicBlock *BB, |
453 | function_ref<bool(const Use &U, const Value *To)> ShouldReplace); |
454 | |
455 | /// Return true if this call calls a gc leaf function. |
456 | /// |
457 | /// A leaf function is a function that does not safepoint the thread during its |
458 | /// execution. During a call or invoke to such a function, the callers stack |
459 | /// does not have to be made parseable. |
460 | /// |
461 | /// Most passes can and should ignore this information, and it is only used |
462 | /// during lowering by the GC infrastructure. |
463 | bool callsGCLeafFunction(const CallBase *Call, const TargetLibraryInfo &TLI); |
464 | |
465 | /// Copy a nonnull metadata node to a new load instruction. |
466 | /// |
467 | /// This handles mapping it to range metadata if the new load is an integer |
468 | /// load instead of a pointer load. |
469 | void copyNonnullMetadata(const LoadInst &OldLI, MDNode *N, LoadInst &NewLI); |
470 | |
471 | /// Copy a range metadata node to a new load instruction. |
472 | /// |
473 | /// This handles mapping it to nonnull metadata if the new load is a pointer |
474 | /// load instead of an integer load and the range doesn't cover null. |
475 | void copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI, MDNode *N, |
476 | LoadInst &NewLI); |
477 | |
478 | /// Remove the debug intrinsic instructions for the given instruction. |
479 | void dropDebugUsers(Instruction &I); |
480 | |
481 | /// Hoist all of the instructions in the \p IfBlock to the dominant block |
482 | /// \p DomBlock, by moving its instructions to the insertion point \p InsertPt. |
483 | /// |
484 | /// The moved instructions receive the insertion point debug location values |
485 | /// (DILocations) and their debug intrinsic instructions are removed. |
486 | void hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt, |
487 | BasicBlock *BB); |
488 | |
489 | /// Given a constant, create a debug information expression. |
490 | DIExpression *getExpressionForConstant(DIBuilder &DIB, const Constant &C, |
491 | Type &Ty); |
492 | |
493 | //===----------------------------------------------------------------------===// |
494 | // Intrinsic pattern matching |
495 | // |
496 | |
497 | /// Try to match a bswap or bitreverse idiom. |
498 | /// |
499 | /// If an idiom is matched, an intrinsic call is inserted before \c I. Any added |
500 | /// instructions are returned in \c InsertedInsts. They will all have been added |
501 | /// to a basic block. |
502 | /// |
503 | /// A bitreverse idiom normally requires around 2*BW nodes to be searched (where |
504 | /// BW is the bitwidth of the integer type). A bswap idiom requires anywhere up |
505 | /// to BW / 4 nodes to be searched, so is significantly faster. |
506 | /// |
507 | /// This function returns true on a successful match or false otherwise. |
508 | bool recognizeBSwapOrBitReverseIdiom( |
509 | Instruction *I, bool MatchBSwaps, bool MatchBitReversals, |
510 | SmallVectorImpl<Instruction *> &InsertedInsts); |
511 | |
512 | //===----------------------------------------------------------------------===// |
513 | // Sanitizer utilities |
514 | // |
515 | |
516 | /// Given a CallInst, check if it calls a string function known to CodeGen, |
517 | /// and mark it with NoBuiltin if so. To be used by sanitizers that intend |
518 | /// to intercept string functions and want to avoid converting them to target |
519 | /// specific instructions. |
520 | void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI, |
521 | const TargetLibraryInfo *TLI); |
522 | |
523 | //===----------------------------------------------------------------------===// |
524 | // Transform predicates |
525 | // |
526 | |
527 | /// Given an instruction, is it legal to set operand OpIdx to a non-constant |
528 | /// value? |
529 | bool canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx); |
530 | |
531 | //===----------------------------------------------------------------------===// |
532 | // Value helper functions |
533 | // |
534 | |
535 | /// Invert the given true/false value, possibly reusing an existing copy. |
536 | Value *invertCondition(Value *Condition); |
537 | |
538 | |
539 | //===----------------------------------------------------------------------===// |
540 | // Assorted |
541 | // |
542 | |
543 | /// If we can infer one attribute from another on the declaration of a |
544 | /// function, explicitly materialize the maximal set in the IR. |
545 | bool inferAttributesFromOthers(Function &F); |
546 | |
547 | } // end namespace llvm |
548 | |
549 | #endif // LLVM_TRANSFORMS_UTILS_LOCAL_H |
550 | |