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