Scalar.h

Go to the documentation of this file.

//===-- Scalar.h - Scalar Transformations -----------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This header file defines prototypes for accessor functions that expose passes
// in the Scalar transformations library.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_TRANSFORMS_SCALAR_H
#define LLVM_TRANSFORMS_SCALAR_H
 
#include "llvm/Support/Compiler.h"
#include "llvm/Transforms/Utils/SimplifyCFGOptions.h"
#include <functional>
 
namespace llvm {
 
class Function;
class FunctionPass;
class Pass;
 
//===----------------------------------------------------------------------===//
//
// DeadCodeElimination - This pass is more powerful than DeadInstElimination,
// because it is worklist driven that can potentially revisit instructions when
// their other instructions become dead, to eliminate chains of dead
// computations.
//
LLVM_ABI FunctionPass *createDeadCodeEliminationPass();
 
//===----------------------------------------------------------------------===//
//
// DeadStoreElimination - This pass deletes stores that are post-dominated by
// must-aliased stores and are not loaded used between the stores.
//
LLVM_ABI FunctionPass *createDeadStoreEliminationPass();
 
//===----------------------------------------------------------------------===//
//
// SROA - Replace aggregates or pieces of aggregates with scalar SSA values.
//
LLVM_ABI FunctionPass *createSROAPass(bool PreserveCFG = true,
                                      bool AggregateToVector = false);
 
//===----------------------------------------------------------------------===//
//
// LICM - This pass is a loop invariant code motion and memory promotion pass.
//
LLVM_ABI Pass *createLICMPass();
 
//===----------------------------------------------------------------------===//
//
// LoopStrengthReduce - This pass is strength reduces GEP instructions that use
// a loop's canonical induction variable as one of their indices.
//
LLVM_ABI Pass *createLoopStrengthReducePass();
 
//===----------------------------------------------------------------------===//
//
// LoopTermFold -  This pass attempts to eliminate the last use of an IV in
// a loop terminator instruction by rewriting it in terms of another IV.
// Expected to be run immediately after LSR.
//
LLVM_ABI Pass *createLoopTermFoldPass();
 
//===----------------------------------------------------------------------===//
//
// LoopUnroll - This pass is a simple loop unrolling pass.
//
LLVM_ABI Pass *createLoopUnrollPass(int OptLevel = 2,
                                    bool OnlyWhenForced = false,
                                    bool ForgetAllSCEV = false,
                                    int Threshold = -1, int Count = -1,
                                    int AllowPartial = -1, int Runtime = -1,
                                    int UpperBound = -1, int AllowPeeling = -1);
 
//===----------------------------------------------------------------------===//
//
// Reassociate - This pass reassociates commutative expressions in an order that
// is designed to promote better constant propagation, GCSE, LICM, PRE...
//
// For example:  4 + (x + 5)  ->  x + (4 + 5)
//
LLVM_ABI FunctionPass *createReassociatePass();
 
//===----------------------------------------------------------------------===//
//
// CFGSimplification - Merge basic blocks, eliminate unreachable blocks,
// simplify terminator instructions, convert switches to lookup tables, etc.
//
LLVM_ABI FunctionPass *createCFGSimplificationPass(
    SimplifyCFGOptions Options = SimplifyCFGOptions(),
    std::function<bool(const Function &)> Ftor = nullptr);
 
//===----------------------------------------------------------------------===//
//
// FlattenCFG - flatten CFG, reduce number of conditional branches by using
// parallel-and and parallel-or mode, etc...
//
LLVM_ABI FunctionPass *createFlattenCFGPass();
 
//===----------------------------------------------------------------------===//
//
// CFG Structurization - Remove irreducible control flow
//
///
/// When \p SkipUniformRegions is true the structizer will not structurize
/// regions that only contain uniform branches.
LLVM_ABI Pass *createStructurizeCFGPass(bool SkipUniformRegions = false);
 
//===----------------------------------------------------------------------===//
//
// TailCallElimination - This pass eliminates call instructions to the current
// function which occur immediately before return instructions.
//
LLVM_ABI FunctionPass *createTailCallEliminationPass();
 
//===----------------------------------------------------------------------===//
//
// EarlyCSE - This pass performs a simple and fast CSE pass over the dominator
// tree.
//
LLVM_ABI FunctionPass *createEarlyCSEPass(bool UseMemorySSA = false);
 
//===----------------------------------------------------------------------===//
//
// ConstantHoisting - This pass prepares a function for expensive constants.
//
LLVM_ABI FunctionPass *createConstantHoistingPass();
 
//===----------------------------------------------------------------------===//
//
// Sink - Code Sinking
//
LLVM_ABI FunctionPass *createSinkingPass();
 
//===----------------------------------------------------------------------===//
//
// LowerAtomic - Lower atomic intrinsics to non-atomic form
//
LLVM_ABI Pass *createLowerAtomicPass();
 
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
//
// InferAddressSpaces - Modify users of addrspacecast instructions with values
// in the source address space if using the destination address space is slower
// on the target. If AddressSpace is left to its default value, it will be
// obtained from the TargetTransformInfo.
//
LLVM_ABI FunctionPass *
createInferAddressSpacesPass(unsigned AddressSpace = ~0u);
LLVM_ABI extern char &InferAddressSpacesID;
 
//===----------------------------------------------------------------------===//
//
// PartiallyInlineLibCalls - Tries to inline the fast path of library
// calls such as sqrt.
//
LLVM_ABI FunctionPass *createPartiallyInlineLibCallsPass();
 
//===----------------------------------------------------------------------===//
//
// SeparateConstOffsetFromGEP - Split GEPs for better CSE
//
LLVM_ABI FunctionPass *
createSeparateConstOffsetFromGEPPass(bool LowerGEP = false);
 
//===----------------------------------------------------------------------===//
//
// SpeculativeExecution - Aggressively hoist instructions to enable
// speculative execution on targets where branches are expensive.
//
LLVM_ABI FunctionPass *createSpeculativeExecutionPass();
 
// Same as createSpeculativeExecutionPass, but does nothing unless
// TargetTransformInfo::hasBranchDivergence() is true.
LLVM_ABI FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass();
 
//===----------------------------------------------------------------------===//
//
// StraightLineStrengthReduce - This pass strength-reduces some certain
// instruction patterns in straight-line code.
//
LLVM_ABI FunctionPass *createStraightLineStrengthReducePass();
 
//===----------------------------------------------------------------------===//
//
// NaryReassociate - Simplify n-ary operations by reassociation.
//
LLVM_ABI FunctionPass *createNaryReassociatePass();
 
//===----------------------------------------------------------------------===//
//
// LoopDataPrefetch - Perform data prefetching in loops.
//
LLVM_ABI FunctionPass *createLoopDataPrefetchPass();
 
//===----------------------------------------------------------------------===//
//
// This pass does instruction simplification on each
// instruction in a function.
//
LLVM_ABI FunctionPass *createInstSimplifyLegacyPass();
 
//===----------------------------------------------------------------------===//
//
// createScalarizeMaskedMemIntrinPass - Replace masked load, store, gather
// and scatter intrinsics with scalar code when target doesn't support them.
//
LLVM_ABI FunctionPass *createScalarizeMaskedMemIntrinLegacyPass();
} // End llvm namespace
 
#endif