llvm/utils/TableGen/CodeGenIntrinsics.h

   1 //===- CodeGenIntrinsic.h - Intrinsic Class Wrapper ------------*- 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 file defines a wrapper class for the 'Intrinsic' TableGen class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
  14 #define LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
  15
  16 #include "SDNodeProperties.h"
  17 #include "llvm/Support/MachineValueType.h"
  18 #include <string>
  19 #include <vector>
  20
  21 namespace llvm {
  22 class Record;
  23 class RecordKeeper;
  24 class CodeGenTarget;
  25
  26 struct CodeGenIntrinsic {
  27   Record *TheDef;             // The actual record defining this intrinsic.
  28   std::string Name;           // The name of the LLVM function "llvm.bswap.i32"
  29   std::string EnumName;       // The name of the enum "bswap_i32"
  30   std::string GCCBuiltinName; // Name of the corresponding GCC builtin, or "".
  31   std::string MSBuiltinName;  // Name of the corresponding MS builtin, or "".
  32   std::string TargetPrefix;   // Target prefix, e.g. "ppc" for t-s intrinsics.
  33
  34   /// This structure holds the return values and parameter values of an
  35   /// intrinsic. If the number of return values is > 1, then the intrinsic
  36   /// implicitly returns a first-class aggregate. The numbering of the types
  37   /// starts at 0 with the first return value and continues from there through
  38   /// the parameter list. This is useful for "matching" types.
  39   struct IntrinsicSignature {
  40     /// The MVT::SimpleValueType for each return type. Note that this list is
  41     /// only populated when in the context of a target .td file. When building
  42     /// Intrinsics.td, this isn't available, because we don't know the target
  43     /// pointer size.
  44     std::vector<MVT::SimpleValueType> RetVTs;
  45
  46     /// The records for each return type.
  47     std::vector<Record *> RetTypeDefs;
  48
  49     /// The MVT::SimpleValueType for each parameter type. Note that this list is
  50     /// only populated when in the context of a target .td file.  When building
  51     /// Intrinsics.td, this isn't available, because we don't know the target
  52     /// pointer size.
  53     std::vector<MVT::SimpleValueType> ParamVTs;
  54
  55     /// The records for each parameter type.
  56     std::vector<Record *> ParamTypeDefs;
  57   };
  58
  59   IntrinsicSignature IS;
  60
  61   /// Bit flags describing the type (ref/mod) and location of memory
  62   /// accesses that may be performed by the intrinsics. Analogous to
  63   /// \c FunctionModRefBehaviour.
  64   enum ModRefBits {
  65     /// The intrinsic may access memory that is otherwise inaccessible via
  66     /// LLVM IR.
  67     MR_InaccessibleMem = 1,
  68
  69     /// The intrinsic may access memory through pointer arguments.
  70     /// LLVM IR.
  71     MR_ArgMem = 2,
  72
  73     /// The intrinsic may access memory anywhere, i.e. it is not restricted
  74     /// to access through pointer arguments.
  75     MR_Anywhere = 4 | MR_ArgMem | MR_InaccessibleMem,
  76
  77     /// The intrinsic may read memory.
  78     MR_Ref = 8,
  79
  80     /// The intrinsic may write memory.
  81     MR_Mod = 16,
  82
  83     /// The intrinsic may both read and write memory.
  84     MR_ModRef = MR_Ref | MR_Mod,
  85   };
  86
  87   /// Memory mod/ref behavior of this intrinsic, corresponding to intrinsic
  88   /// properties (IntrReadMem, IntrArgMemOnly, etc.).
  89   enum ModRefBehavior {
  90     NoMem = 0,
  91     ReadArgMem = MR_Ref | MR_ArgMem,
  92     ReadInaccessibleMem = MR_Ref | MR_InaccessibleMem,
  93     ReadInaccessibleMemOrArgMem = MR_Ref | MR_ArgMem | MR_InaccessibleMem,
  94     ReadMem = MR_Ref | MR_Anywhere,
  95     WriteArgMem = MR_Mod | MR_ArgMem,
  96     WriteInaccessibleMem = MR_Mod | MR_InaccessibleMem,
  97     WriteInaccessibleMemOrArgMem = MR_Mod | MR_ArgMem | MR_InaccessibleMem,
  98     WriteMem = MR_Mod | MR_Anywhere,
  99     ReadWriteArgMem = MR_ModRef | MR_ArgMem,
 100     ReadWriteInaccessibleMem = MR_ModRef | MR_InaccessibleMem,
 101     ReadWriteInaccessibleMemOrArgMem = MR_ModRef | MR_ArgMem |
 102                                        MR_InaccessibleMem,
 103     ReadWriteMem = MR_ModRef | MR_Anywhere,
 104   };
 105   ModRefBehavior ModRef;
 106
 107   /// SDPatternOperator Properties applied to the intrinsic.
 108   unsigned Properties;
 109
 110   /// This is set to true if the intrinsic is overloaded by its argument
 111   /// types.
 112   bool isOverloaded;
 113
 114   /// True if the intrinsic is commutative.
 115   bool isCommutative;
 116
 117   /// True if the intrinsic can throw.
 118   bool canThrow;
 119
 120   /// True if the intrinsic is marked as noduplicate.
 121   bool isNoDuplicate;
 122
 123   /// True if the intrinsic is marked as nomerge.
 124   bool isNoMerge;
 125
 126   /// True if the intrinsic is no-return.
 127   bool isNoReturn;
 128
 129   /// True if the intrinsic is no-sync.
 130   bool isNoSync;
 131
 132   /// True if the intrinsic is no-free.
 133   bool isNoFree;
 134
 135   /// True if the intrinsic is will-return.
 136   bool isWillReturn;
 137
 138   /// True if the intrinsic is cold.
 139   bool isCold;
 140
 141   /// True if the intrinsic is marked as convergent.
 142   bool isConvergent;
 143
 144   /// True if the intrinsic has side effects that aren't captured by any
 145   /// of the other flags.
 146   bool hasSideEffects;
 147
 148   // True if the intrinsic is marked as speculatable.
 149   bool isSpeculatable;
 150
 151   enum ArgAttrKind {
 152     NoCapture,
 153     NoAlias,
 154     NoUndef,
 155     Returned,
 156     ReadOnly,
 157     WriteOnly,
 158     ReadNone,
 159     ImmArg,
 160     Alignment
 161   };
 162
 163   struct ArgAttribute {
 164     unsigned Index;
 165     ArgAttrKind Kind;
 166     uint64_t Value;
 167
 168     ArgAttribute(unsigned Idx, ArgAttrKind K, uint64_t V)
 169         : Index(Idx), Kind(K), Value(V) {}
 170
 171     bool operator<(const ArgAttribute &Other) const {
 172       return std::tie(Index, Kind, Value) <
 173              std::tie(Other.Index, Other.Kind, Other.Value);
 174     }
 175   };
 176
 177   std::vector<ArgAttribute> ArgumentAttributes;
 178
 179   bool hasProperty(enum SDNP Prop) const {
 180     return Properties & (1 << Prop);
 181   }
 182
 183   /// Goes through all IntrProperties that have IsDefault
 184   /// value set and sets the property.
 185   void setDefaultProperties(Record *R, std::vector<Record *> DefaultProperties);
 186
 187   /// Helper function to set property \p Name to true;
 188   void setProperty(Record *R);
 189
 190   /// Returns true if the parameter at \p ParamIdx is a pointer type. Returns
 191   /// false if the parameter is not a pointer, or \p ParamIdx is greater than
 192   /// the size of \p IS.ParamVTs.
 193   ///
 194   /// Note that this requires that \p IS.ParamVTs is available.
 195   bool isParamAPointer(unsigned ParamIdx) const;
 196
 197   bool isParamImmArg(unsigned ParamIdx) const;
 198
 199   CodeGenIntrinsic(Record *R, std::vector<Record *> DefaultProperties);
 200 };
 201
 202 class CodeGenIntrinsicTable {
 203   std::vector<CodeGenIntrinsic> Intrinsics;
 204
 205 public:
 206   struct TargetSet {
 207     std::string Name;
 208     size_t Offset;
 209     size_t Count;
 210   };
 211   std::vector<TargetSet> Targets;
 212
 213   explicit CodeGenIntrinsicTable(const RecordKeeper &RC);
 214   CodeGenIntrinsicTable() = default;
 215
 216   bool empty() const { return Intrinsics.empty(); }
 217   size_t size() const { return Intrinsics.size(); }
 218   CodeGenIntrinsic &operator[](size_t Pos) { return Intrinsics[Pos]; }
 219   const CodeGenIntrinsic &operator[](size_t Pos) const {
 220     return Intrinsics[Pos];
 221   }
 222 };
 223 }
 224
 225 #endif