contrib/llvm-project/llvm/include/llvm/Transforms/Utils/Local.h

   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 ///===---------------------------------------------------------------------===//
 275 ///  Dbg Intrinsic utilities
 276 ///
 277
 278 /// Inserts a llvm.dbg.value intrinsic before a store to an alloca'd value
 279 /// that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic.
 280 void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII,
 281                                      StoreInst *SI, DIBuilder &Builder);
 282
 283 /// Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value
 284 /// that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic.
 285 void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII,
 286                                      LoadInst *LI, DIBuilder &Builder);
 287
 288 /// Inserts a llvm.dbg.value intrinsic after a phi that has an associated
 289 /// llvm.dbg.declare or llvm.dbg.addr intrinsic.
 290 void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII,
 291                                      PHINode *LI, DIBuilder &Builder);
 292
 293 /// Lowers llvm.dbg.declare intrinsics into appropriate set of
 294 /// llvm.dbg.value intrinsics.
 295 bool LowerDbgDeclare(Function &F);
 296
 297 /// Propagate dbg.value intrinsics through the newly inserted PHIs.
 298 void insertDebugValuesForPHIs(BasicBlock *BB,
 299                               SmallVectorImpl<PHINode *> &InsertedPHIs);
 300
 301 /// Finds all intrinsics declaring local variables as living in the memory that
 302 /// 'V' points to. This may include a mix of dbg.declare and
 303 /// dbg.addr intrinsics.
 304 TinyPtrVector<DbgVariableIntrinsic *> FindDbgAddrUses(Value *V);
 305
 306 /// Finds the llvm.dbg.value intrinsics describing a value.
 307 void findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V);
 308
 309 /// Finds the debug info intrinsics describing a value.
 310 void findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgInsts, Value *V);
 311
 312 /// Replaces llvm.dbg.declare instruction when the address it
 313 /// describes is replaced with a new value. If Deref is true, an
 314 /// additional DW_OP_deref is prepended to the expression. If Offset
 315 /// is non-zero, a constant displacement is added to the expression
 316 /// (between the optional Deref operations). Offset can be negative.
 317 bool replaceDbgDeclare(Value *Address, Value *NewAddress,
 318                        Instruction *InsertBefore, DIBuilder &Builder,
 319                        uint8_t DIExprFlags, int Offset);
 320
 321 /// Replaces llvm.dbg.declare instruction when the alloca it describes
 322 /// is replaced with a new value. If Deref is true, an additional
 323 /// DW_OP_deref is prepended to the expression. If Offset is non-zero,
 324 /// a constant displacement is added to the expression (between the
 325 /// optional Deref operations). Offset can be negative. The new
 326 /// llvm.dbg.declare is inserted immediately after AI.
 327 bool replaceDbgDeclareForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
 328                                 DIBuilder &Builder, uint8_t DIExprFlags,
 329                                 int Offset);
 330
 331 /// Replaces multiple llvm.dbg.value instructions when the alloca it describes
 332 /// is replaced with a new value. If Offset is non-zero, a constant displacement
 333 /// is added to the expression (after the mandatory Deref). Offset can be
 334 /// negative. New llvm.dbg.value instructions are inserted at the locations of
 335 /// the instructions they replace.
 336 void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
 337                               DIBuilder &Builder, int Offset = 0);
 338
 339 /// Finds alloca where the value comes from.
 340 AllocaInst *findAllocaForValue(Value *V,
 341                                DenseMap<Value *, AllocaInst *> &AllocaForValue);
 342
 343 /// Assuming the instruction \p I is going to be deleted, attempt to salvage
 344 /// debug users of \p I by writing the effect of \p I in a DIExpression.
 345 /// Returns true if any debug users were updated.
 346 bool salvageDebugInfo(Instruction &I);
 347
 348 /// Implementation of salvageDebugInfo, applying only to instructions in
 349 /// \p Insns, rather than all debug users of \p I.
 350 bool salvageDebugInfoForDbgValues(Instruction &I,
 351                                   ArrayRef<DbgVariableIntrinsic *> Insns);
 352
 353 /// Given an instruction \p I and DIExpression \p DIExpr operating on it, write
 354 /// the effects of \p I into the returned DIExpression, or return nullptr if
 355 /// it cannot be salvaged. \p StackVal: whether DW_OP_stack_value should be
 356 /// appended to the expression.
 357 DIExpression *salvageDebugInfoImpl(Instruction &I, DIExpression *DIExpr,
 358                                    bool StackVal);
 359
 360 /// Point debug users of \p From to \p To or salvage them. Use this function
 361 /// only when replacing all uses of \p From with \p To, with a guarantee that
 362 /// \p From is going to be deleted.
 363 ///
 364 /// Follow these rules to prevent use-before-def of \p To:
 365 ///   . If \p To is a linked Instruction, set \p DomPoint to \p To.
 366 ///   . If \p To is an unlinked Instruction, set \p DomPoint to the Instruction
 367 ///     \p To will be inserted after.
 368 ///   . If \p To is not an Instruction (e.g a Constant), the choice of
 369 ///     \p DomPoint is arbitrary. Pick \p From for simplicity.
 370 ///
 371 /// If a debug user cannot be preserved without reordering variable updates or
 372 /// introducing a use-before-def, it is either salvaged (\ref salvageDebugInfo)
 373 /// or deleted. Returns true if any debug users were updated.
 374 bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint,
 375                            DominatorTree &DT);
 376
 377 /// Remove all instructions from a basic block other than it's terminator
 378 /// and any present EH pad instructions.
 379 unsigned removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB);
 380
 381 /// Insert an unreachable instruction before the specified
 382 /// instruction, making it and the rest of the code in the block dead.
 383 unsigned changeToUnreachable(Instruction *I, bool UseLLVMTrap,
 384                              bool PreserveLCSSA = false,
 385                              DomTreeUpdater *DTU = nullptr,
 386                              MemorySSAUpdater *MSSAU = nullptr);
 387
 388 /// Convert the CallInst to InvokeInst with the specified unwind edge basic
 389 /// block.  This also splits the basic block where CI is located, because
 390 /// InvokeInst is a terminator instruction.  Returns the newly split basic
 391 /// block.
 392 BasicBlock *changeToInvokeAndSplitBasicBlock(CallInst *CI,
 393                                              BasicBlock *UnwindEdge);
 394
 395 /// Replace 'BB's terminator with one that does not have an unwind successor
 396 /// block. Rewrites `invoke` to `call`, etc. Updates any PHIs in unwind
 397 /// successor.
 398 ///
 399 /// \param BB  Block whose terminator will be replaced.  Its terminator must
 400 ///            have an unwind successor.
 401 void removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU = nullptr);
 402
 403 /// Remove all blocks that can not be reached from the function's entry.
 404 ///
 405 /// Returns true if any basic block was removed.
 406 bool removeUnreachableBlocks(Function &F, LazyValueInfo *LVI = nullptr,
 407                              DomTreeUpdater *DTU = nullptr,
 408                              MemorySSAUpdater *MSSAU = nullptr);
 409
 410 /// Combine the metadata of two instructions so that K can replace J. Some
 411 /// metadata kinds can only be kept if K does not move, meaning it dominated
 412 /// J in the original IR.
 413 ///
 414 /// Metadata not listed as known via KnownIDs is removed
 415 void combineMetadata(Instruction *K, const Instruction *J,
 416                      ArrayRef<unsigned> KnownIDs, bool DoesKMove);
 417
 418 /// Combine the metadata of two instructions so that K can replace J. This
 419 /// specifically handles the case of CSE-like transformations. Some
 420 /// metadata can only be kept if K dominates J. For this to be correct,
 421 /// K cannot be hoisted.
 422 ///
 423 /// Unknown metadata is removed.
 424 void combineMetadataForCSE(Instruction *K, const Instruction *J,
 425                            bool DoesKMove);
 426
 427 /// Patch the replacement so that it is not more restrictive than the value
 428 /// being replaced. It assumes that the replacement does not get moved from
 429 /// its original position.
 430 void patchReplacementInstruction(Instruction *I, Value *Repl);
 431
 432 // Replace each use of 'From' with 'To', if that use does not belong to basic
 433 // block where 'From' is defined. Returns the number of replacements made.
 434 unsigned replaceNonLocalUsesWith(Instruction *From, Value *To);
 435
 436 /// Replace each use of 'From' with 'To' if that use is dominated by
 437 /// the given edge.  Returns the number of replacements made.
 438 unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT,
 439                                   const BasicBlockEdge &Edge);
 440 /// Replace each use of 'From' with 'To' if that use is dominated by
 441 /// the end of the given BasicBlock. Returns the number of replacements made.
 442 unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT,
 443                                   const BasicBlock *BB);
 444
 445 /// Return true if this call calls a gc leaf function.
 446 ///
 447 /// A leaf function is a function that does not safepoint the thread during its
 448 /// execution.  During a call or invoke to such a function, the callers stack
 449 /// does not have to be made parseable.
 450 ///
 451 /// Most passes can and should ignore this information, and it is only used
 452 /// during lowering by the GC infrastructure.
 453 bool callsGCLeafFunction(const CallBase *Call, const TargetLibraryInfo &TLI);
 454
 455 /// Copy a nonnull metadata node to a new load instruction.
 456 ///
 457 /// This handles mapping it to range metadata if the new load is an integer
 458 /// load instead of a pointer load.
 459 void copyNonnullMetadata(const LoadInst &OldLI, MDNode *N, LoadInst &NewLI);
 460
 461 /// Copy a range metadata node to a new load instruction.
 462 ///
 463 /// This handles mapping it to nonnull metadata if the new load is a pointer
 464 /// load instead of an integer load and the range doesn't cover null.
 465 void copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI, MDNode *N,
 466                        LoadInst &NewLI);
 467
 468 /// Remove the debug intrinsic instructions for the given instruction.
 469 void dropDebugUsers(Instruction &I);
 470
 471 /// Hoist all of the instructions in the \p IfBlock to the dominant block
 472 /// \p DomBlock, by moving its instructions to the insertion point \p InsertPt.
 473 ///
 474 /// The moved instructions receive the insertion point debug location values
 475 /// (DILocations) and their debug intrinsic instructions are removed.
 476 void hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt,
 477                               BasicBlock *BB);
 478
 479 //===----------------------------------------------------------------------===//
 480 //  Intrinsic pattern matching
 481 //
 482
 483 /// Try to match a bswap or bitreverse idiom.
 484 ///
 485 /// If an idiom is matched, an intrinsic call is inserted before \c I. Any added
 486 /// instructions are returned in \c InsertedInsts. They will all have been added
 487 /// to a basic block.
 488 ///
 489 /// A bitreverse idiom normally requires around 2*BW nodes to be searched (where
 490 /// BW is the bitwidth of the integer type). A bswap idiom requires anywhere up
 491 /// to BW / 4 nodes to be searched, so is significantly faster.
 492 ///
 493 /// This function returns true on a successful match or false otherwise.
 494 bool recognizeBSwapOrBitReverseIdiom(
 495     Instruction *I, bool MatchBSwaps, bool MatchBitReversals,
 496     SmallVectorImpl<Instruction *> &InsertedInsts);
 497
 498 //===----------------------------------------------------------------------===//
 499 //  Sanitizer utilities
 500 //
 501
 502 /// Given a CallInst, check if it calls a string function known to CodeGen,
 503 /// and mark it with NoBuiltin if so.  To be used by sanitizers that intend
 504 /// to intercept string functions and want to avoid converting them to target
 505 /// specific instructions.
 506 void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI,
 507                                             const TargetLibraryInfo *TLI);
 508
 509 //===----------------------------------------------------------------------===//
 510 //  Transform predicates
 511 //
 512
 513 /// Given an instruction, is it legal to set operand OpIdx to a non-constant
 514 /// value?
 515 bool canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx);
 516
 517 } // end namespace llvm
 518
 519 #endif // LLVM_TRANSFORMS_UTILS_LOCAL_H