llvm::isSafeToSpeculativelyExecute

bool
isSafeToSpeculativelyExecute(
    Instruction const* I,
    Instruction const* CtxI = nullptr,
    AssumptionCache* AC = nullptr,
    DominatorTree const* DT = nullptr,
    TargetLibraryInfo const* TLI = nullptr,
    bool UseVariableInfo = true,
    bool IgnoreUBImplyingAttrs = true);

Description

This method never returns true for an instruction that returns true for mayHaveSideEffects; however, this method also does some other checks in addition. It checks for undefined behavior, like dividing by zero or loading from an invalid pointer (but not for undefined results, like a shift with a shift amount larger than the width of the result). It checks for malloc and alloca because speculatively executing them might cause a memory leak. It also returns false for instructions related to control flow, specifically terminators and PHI nodes.

If the CtxI is specified this method performs context-sensitive analysis and returns true if it is safe to execute the instruction immediately before the CtxI. If the instruction has (transitive) operands that don't dominate CtxI, the analysis is performed under the assumption that these operands will also be speculated to a point before CxtI.

If the CtxI is NOT specified this method only looks at the instruction itself and its operands, so if this method returns true, it is safe to move the instruction as long as the correct dominance relationships for the operands and users hold.

If UseVariableInfo is true, the information from non-constant operands will be taken into account.

If IgnoreUBImplyingAttrs is true, UB-implying attributes will be ignored. The caller is responsible for correctly propagating them after hoisting.

This method can return true for instructions that read memory; for such instructions, moving them may change the resulting value.