include/llvm/Transforms/Vectorize/LoopVectorize.h

   1 //===- LoopVectorize.h ------------------------------------------*- 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 is the LLVM loop vectorizer. This pass modifies 'vectorizable' loops
  10 // and generates target-independent LLVM-IR.
  11 // The vectorizer uses the TargetTransformInfo analysis to estimate the costs
  12 // of instructions in order to estimate the profitability of vectorization.
  13 //
  14 // The loop vectorizer combines consecutive loop iterations into a single
  15 // 'wide' iteration. After this transformation the index is incremented
  16 // by the SIMD vector width, and not by one.
  17 //
  18 // This pass has three parts:
  19 // 1. The main loop pass that drives the different parts.
  20 // 2. LoopVectorizationLegality - A unit that checks for the legality
  21 //    of the vectorization.
  22 // 3. InnerLoopVectorizer - A unit that performs the actual
  23 //    widening of instructions.
  24 // 4. LoopVectorizationCostModel - A unit that checks for the profitability
  25 //    of vectorization. It decides on the optimal vector width, which
  26 //    can be one, if vectorization is not profitable.
  27 //
  28 // There is a development effort going on to migrate loop vectorizer to the
  29 // VPlan infrastructure and to introduce outer loop vectorization support (see
  30 // docs/Proposal/VectorizationPlan.rst and
  31 // http://lists.llvm.org/pipermail/llvm-dev/2017-December/119523.html). For this
  32 // purpose, we temporarily introduced the VPlan-native vectorization path: an
  33 // alternative vectorization path that is natively implemented on top of the
  34 // VPlan infrastructure. See EnableVPlanNativePath for enabling.
  35 //
  36 //===----------------------------------------------------------------------===//
  37 //
  38 // The reduction-variable vectorization is based on the paper:
  39 //  D. Nuzman and R. Henderson. Multi-platform Auto-vectorization.
  40 //
  41 // Variable uniformity checks are inspired by:
  42 //  Karrenberg, R. and Hack, S. Whole Function Vectorization.
  43 //
  44 // The interleaved access vectorization is based on the paper:
  45 //  Dorit Nuzman, Ira Rosen and Ayal Zaks.  Auto-Vectorization of Interleaved
  46 //  Data for SIMD
  47 //
  48 // Other ideas/concepts are from:
  49 //  A. Zaks and D. Nuzman. Autovectorization in GCC-two years later.
  50 //
  51 //  S. Maleki, Y. Gao, M. Garzaran, T. Wong and D. Padua.  An Evaluation of
  52 //  Vectorizing Compilers.
  53 //
  54 //===----------------------------------------------------------------------===//
  55
  56 #ifndef LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H
  57 #define LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H
  58
  59 #include "llvm/Analysis/AliasAnalysis.h"
  60 #include "llvm/IR/PassManager.h"
  61 #include <functional>
  62
  63 namespace llvm {
  64
  65 class AssumptionCache;
  66 class BlockFrequencyInfo;
  67 class DemandedBits;
  68 class DominatorTree;
  69 class Function;
  70 class Loop;
  71 class LoopAccessInfo;
  72 class LoopInfo;
  73 class OptimizationRemarkEmitter;
  74 class ScalarEvolution;
  75 class TargetLibraryInfo;
  76 class TargetTransformInfo;
  77
  78 /// The LoopVectorize Pass.
  79 struct LoopVectorizePass : public PassInfoMixin<LoopVectorizePass> {
  80   /// If false, consider all loops for interleaving.
  81   /// If true, only loops that explicitly request interleaving are considered.
  82   bool InterleaveOnlyWhenForced = false;
  83
  84   /// If false, consider all loops for vectorization.
  85   /// If true, only loops that explicitly request vectorization are considered.
  86   bool VectorizeOnlyWhenForced = false;
  87
  88   ScalarEvolution *SE;
  89   LoopInfo *LI;
  90   TargetTransformInfo *TTI;
  91   DominatorTree *DT;
  92   BlockFrequencyInfo *BFI;
  93   TargetLibraryInfo *TLI;
  94   DemandedBits *DB;
  95   AliasAnalysis *AA;
  96   AssumptionCache *AC;
  97   std::function<const LoopAccessInfo &(Loop &)> *GetLAA;
  98   OptimizationRemarkEmitter *ORE;
  99
 100   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 101
 102   // Shim for old PM.
 103   bool runImpl(Function &F, ScalarEvolution &SE_, LoopInfo &LI_,
 104                TargetTransformInfo &TTI_, DominatorTree &DT_,
 105                BlockFrequencyInfo &BFI_, TargetLibraryInfo *TLI_,
 106                DemandedBits &DB_, AliasAnalysis &AA_, AssumptionCache &AC_,
 107                std::function<const LoopAccessInfo &(Loop &)> &GetLAA_,
 108                OptimizationRemarkEmitter &ORE);
 109
 110   bool processLoop(Loop *L);
 111 };
 112
 113 } // end namespace llvm
 114
 115 #endif // LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H