lib/Transforms/Vectorize/VPlanValue.h

   1 //===- VPlanValue.h - Represent Values in Vectorizer Plan -----------------===//
   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 /// \file
  10 /// This file contains the declarations of the entities induced by Vectorization
  11 /// Plans, e.g. the instructions the VPlan intends to generate if executed.
  12 /// VPlan models the following entities:
  13 /// VPValue
  14 ///  |-- VPUser
  15 ///  |    |-- VPInstruction
  16 /// These are documented in docs/VectorizationPlan.rst.
  17 ///
  18 //===----------------------------------------------------------------------===//
  19
  20 #ifndef LLVM_TRANSFORMS_VECTORIZE_VPLAN_VALUE_H
  21 #define LLVM_TRANSFORMS_VECTORIZE_VPLAN_VALUE_H
  22
  23 #include "llvm/ADT/DenseMap.h"
  24 #include "llvm/ADT/SmallVector.h"
  25 #include "llvm/IR/Value.h"
  26 #include "llvm/Support/Debug.h"
  27 #include "llvm/Support/raw_ostream.h"
  28
  29 namespace llvm {
  30
  31 // Forward declarations.
  32 class VPUser;
  33
  34 // This is the base class of the VPlan Def/Use graph, used for modeling the data
  35 // flow into, within and out of the VPlan. VPValues can stand for live-ins
  36 // coming from the input IR, instructions which VPlan will generate if executed
  37 // and live-outs which the VPlan will need to fix accordingly.
  38 class VPValue {
  39   friend class VPBuilder;
  40   friend class VPlanHCFGTransforms;
  41   friend class VPBasicBlock;
  42   friend class VPInterleavedAccessInfo;
  43
  44 private:
  45   const unsigned char SubclassID; ///< Subclass identifier (for isa/dyn_cast).
  46
  47   SmallVector<VPUser *, 1> Users;
  48
  49 protected:
  50   // Hold the underlying Value, if any, attached to this VPValue.
  51   Value *UnderlyingVal;
  52
  53   VPValue(const unsigned char SC, Value *UV = nullptr)
  54       : SubclassID(SC), UnderlyingVal(UV) {}
  55
  56   // DESIGN PRINCIPLE: Access to the underlying IR must be strictly limited to
  57   // the front-end and back-end of VPlan so that the middle-end is as
  58   // independent as possible of the underlying IR. We grant access to the
  59   // underlying IR using friendship. In that way, we should be able to use VPlan
  60   // for multiple underlying IRs (Polly?) by providing a new VPlan front-end,
  61   // back-end and analysis information for the new IR.
  62
  63   /// Return the underlying Value attached to this VPValue.
  64   Value *getUnderlyingValue() { return UnderlyingVal; }
  65
  66   // Set \p Val as the underlying Value of this VPValue.
  67   void setUnderlyingValue(Value *Val) {
  68     assert(!UnderlyingVal && "Underlying Value is already set.");
  69     UnderlyingVal = Val;
  70   }
  71
  72 public:
  73   /// An enumeration for keeping track of the concrete subclass of VPValue that
  74   /// are actually instantiated. Values of this enumeration are kept in the
  75   /// SubclassID field of the VPValue objects. They are used for concrete
  76   /// type identification.
  77   enum { VPValueSC, VPUserSC, VPInstructionSC };
  78
  79   VPValue(Value *UV = nullptr) : VPValue(VPValueSC, UV) {}
  80   VPValue(const VPValue &) = delete;
  81   VPValue &operator=(const VPValue &) = delete;
  82
  83   /// \return an ID for the concrete type of this object.
  84   /// This is used to implement the classof checks. This should not be used
  85   /// for any other purpose, as the values may change as LLVM evolves.
  86   unsigned getVPValueID() const { return SubclassID; }
  87
  88   void printAsOperand(raw_ostream &OS) const {
  89     OS << "%vp" << (unsigned short)(unsigned long long)this;
  90   }
  91
  92   unsigned getNumUsers() const { return Users.size(); }
  93   void addUser(VPUser &User) { Users.push_back(&User); }
  94
  95   typedef SmallVectorImpl<VPUser *>::iterator user_iterator;
  96   typedef SmallVectorImpl<VPUser *>::const_iterator const_user_iterator;
  97   typedef iterator_range<user_iterator> user_range;
  98   typedef iterator_range<const_user_iterator> const_user_range;
  99
 100   user_iterator user_begin() { return Users.begin(); }
 101   const_user_iterator user_begin() const { return Users.begin(); }
 102   user_iterator user_end() { return Users.end(); }
 103   const_user_iterator user_end() const { return Users.end(); }
 104   user_range users() { return user_range(user_begin(), user_end()); }
 105   const_user_range users() const {
 106     return const_user_range(user_begin(), user_end());
 107   }
 108
 109   /// Returns true if the value has more than one unique user.
 110   bool hasMoreThanOneUniqueUser() {
 111     if (getNumUsers() == 0)
 112       return false;
 113
 114     // Check if all users match the first user.
 115     auto Current = std::next(user_begin());
 116     while (Current != user_end() && *user_begin() == *Current)
 117       Current++;
 118     return Current != user_end();
 119   }
 120
 121   void replaceAllUsesWith(VPValue *New);
 122 };
 123
 124 typedef DenseMap<Value *, VPValue *> Value2VPValueTy;
 125 typedef DenseMap<VPValue *, Value *> VPValue2ValueTy;
 126
 127 raw_ostream &operator<<(raw_ostream &OS, const VPValue &V);
 128
 129 /// This class augments VPValue with operands which provide the inverse def-use
 130 /// edges from VPValue's users to their defs.
 131 class VPUser : public VPValue {
 132 private:
 133   SmallVector<VPValue *, 2> Operands;
 134
 135 protected:
 136   VPUser(const unsigned char SC) : VPValue(SC) {}
 137   VPUser(const unsigned char SC, ArrayRef<VPValue *> Operands) : VPValue(SC) {
 138     for (VPValue *Operand : Operands)
 139       addOperand(Operand);
 140   }
 141
 142 public:
 143   VPUser() : VPValue(VPValue::VPUserSC) {}
 144   VPUser(ArrayRef<VPValue *> Operands) : VPUser(VPValue::VPUserSC, Operands) {}
 145   VPUser(std::initializer_list<VPValue *> Operands)
 146       : VPUser(ArrayRef<VPValue *>(Operands)) {}
 147   VPUser(const VPUser &) = delete;
 148   VPUser &operator=(const VPUser &) = delete;
 149
 150   /// Method to support type inquiry through isa, cast, and dyn_cast.
 151   static inline bool classof(const VPValue *V) {
 152     return V->getVPValueID() >= VPUserSC &&
 153            V->getVPValueID() <= VPInstructionSC;
 154   }
 155
 156   void addOperand(VPValue *Operand) {
 157     Operands.push_back(Operand);
 158     Operand->addUser(*this);
 159   }
 160
 161   unsigned getNumOperands() const { return Operands.size(); }
 162   inline VPValue *getOperand(unsigned N) const {
 163     assert(N < Operands.size() && "Operand index out of bounds");
 164     return Operands[N];
 165   }
 166
 167   void setOperand(unsigned I, VPValue *New) { Operands[I] = New; }
 168
 169   typedef SmallVectorImpl<VPValue *>::iterator operand_iterator;
 170   typedef SmallVectorImpl<VPValue *>::const_iterator const_operand_iterator;
 171   typedef iterator_range<operand_iterator> operand_range;
 172   typedef iterator_range<const_operand_iterator> const_operand_range;
 173
 174   operand_iterator op_begin() { return Operands.begin(); }
 175   const_operand_iterator op_begin() const { return Operands.begin(); }
 176   operand_iterator op_end() { return Operands.end(); }
 177   const_operand_iterator op_end() const { return Operands.end(); }
 178   operand_range operands() { return operand_range(op_begin(), op_end()); }
 179   const_operand_range operands() const {
 180     return const_operand_range(op_begin(), op_end());
 181   }
 182 };
 183
 184 } // namespace llvm
 185
 186 #endif // LLVM_TRANSFORMS_VECTORIZE_VPLAN_VALUE_H