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