1 files changed, 99 insertions, 62 deletions
diff --git a/utils/TableGen/CodeGenIntrinsics.h b/utils/TableGen/CodeGenIntrinsics.h
index 7bdb7e1bc537..ea3ec67d62ed 100644
--- a/utils/TableGen/CodeGenIntrinsics.h
+++ b/utils/TableGen/CodeGenIntrinsics.h
@@ -19,85 +19,122 @@
 #include <vector>
 
 namespace llvm {
-  class Record;
-  class RecordKeeper;
-  class CodeGenTarget;
+class Record;
+class RecordKeeper;
+class CodeGenTarget;
 
-  struct CodeGenIntrinsic {
-    Record *TheDef;            // The actual record defining this intrinsic.
-    std::string Name;          // The name of the LLVM function "llvm.bswap.i32"
-    std::string EnumName;      // The name of the enum "bswap_i32"
-    std::string GCCBuiltinName;// Name of the corresponding GCC builtin, or "".
-    std::string MSBuiltinName; // Name of the corresponding MS builtin, or "".
-    std::string TargetPrefix;  // Target prefix, e.g. "ppc" for t-s intrinsics.
+struct CodeGenIntrinsic {
+  Record *TheDef;             // The actual record defining this intrinsic.
+  std::string Name;           // The name of the LLVM function "llvm.bswap.i32"
+  std::string EnumName;       // The name of the enum "bswap_i32"
+  std::string GCCBuiltinName; // Name of the corresponding GCC builtin, or "".
+  std::string MSBuiltinName;  // Name of the corresponding MS builtin, or "".
+  std::string TargetPrefix;   // Target prefix, e.g. "ppc" for t-s intrinsics.
 
-    /// IntrinsicSignature - This structure holds the return values and
-    /// parameter values of an intrinsic. If the number of return values is > 1,
-    /// then the intrinsic implicitly returns a first-class aggregate. The
-    /// numbering of the types starts at 0 with the first return value and
-    /// continues from there through the parameter list. This is useful for
-    /// "matching" types.
-    struct IntrinsicSignature {
-      /// RetVTs - The MVT::SimpleValueType for each return type. Note that this
-      /// list is only populated when in the context of a target .td file. When
-      /// building Intrinsics.td, this isn't available, because we don't know
-      /// the target pointer size.
-      std::vector<MVT::SimpleValueType> RetVTs;
+  /// This structure holds the return values and parameter values of an
+  /// intrinsic. If the number of return values is > 1, then the intrinsic
+  /// implicitly returns a first-class aggregate. The numbering of the types
+  /// starts at 0 with the first return value and continues from there through
+  /// the parameter list. This is useful for "matching" types.
+  struct IntrinsicSignature {
+    /// The MVT::SimpleValueType for each return type. Note that this list is
+    /// only populated when in the context of a target .td file. When building
+    /// Intrinsics.td, this isn't available, because we don't know the target
+    /// pointer size.
+    std::vector<MVT::SimpleValueType> RetVTs;
 
-      /// RetTypeDefs - The records for each return type.
-      std::vector<Record*> RetTypeDefs;
+    /// The records for each return type.
+    std::vector<Record *> RetTypeDefs;
 
-      /// ParamVTs - The MVT::SimpleValueType for each parameter type. Note that
-      /// this list is only populated when in the context of a target .td file.
-      /// When building Intrinsics.td, this isn't available, because we don't
-      /// know the target pointer size.
-      std::vector<MVT::SimpleValueType> ParamVTs;
+    /// The MVT::SimpleValueType for each parameter type. Note that this list is
+    /// only populated when in the context of a target .td file.  When building
+    /// Intrinsics.td, this isn't available, because we don't know the target
+    /// pointer size.
+    std::vector<MVT::SimpleValueType> ParamVTs;
 
-      /// ParamTypeDefs - The records for each parameter type.
-      std::vector<Record*> ParamTypeDefs;
-    };
+    /// The records for each parameter type.
+    std::vector<Record *> ParamTypeDefs;
+  };
+
+  IntrinsicSignature IS;
+
+  /// Bit flags describing the type (ref/mod) and location of memory
+  /// accesses that may be performed by the intrinsics. Analogous to
+  /// \c FunctionModRefBehaviour.
+  enum ModRefBits {
+    /// The intrinsic may access memory anywhere, i.e. it is not restricted
+    /// to access through pointer arguments.
+    MR_Anywhere = 1,
+
+    /// The intrinsic may read memory.
+    MR_Ref = 2,
+
+    /// The intrinsic may write memory.
+    MR_Mod = 4,
 
-    IntrinsicSignature IS;
+    /// The intrinsic may both read and write memory.
+    MR_ModRef = MR_Ref | MR_Mod,
+  };
+
+  /// Memory mod/ref behavior of this intrinsic, corresponding to intrinsic
+  /// properties (IntrReadMem, IntrArgMemOnly, etc.).
+  enum ModRefBehavior {
+    NoMem = 0,
+    ReadArgMem = MR_Ref,
+    ReadMem = MR_Ref | MR_Anywhere,
+    WriteArgMem = MR_Mod,
+    WriteMem = MR_Mod | MR_Anywhere,
+    ReadWriteArgMem = MR_ModRef,
+    ReadWriteMem = MR_ModRef | MR_Anywhere,
+  };
+  ModRefBehavior ModRef;
 
-    // Memory mod/ref behavior of this intrinsic.
-    enum ModRefKind {
-      NoMem, ReadArgMem, ReadMem, ReadWriteArgMem, ReadWriteMem
-    };
-    ModRefKind ModRef;
+  /// This is set to true if the intrinsic is overloaded by its argument
+  /// types.
+  bool isOverloaded;
 
-    /// This is set to true if the intrinsic is overloaded by its argument
-    /// types.
-    bool isOverloaded;
+  /// True if the intrinsic is commutative.
+  bool isCommutative;
 
-    /// isCommutative - True if the intrinsic is commutative.
-    bool isCommutative;
+  /// True if the intrinsic can throw.
+  bool canThrow;
 
-    /// canThrow - True if the intrinsic can throw.
-    bool canThrow;
+  /// True if the intrinsic is marked as noduplicate.
+  bool isNoDuplicate;
 
-    /// isNoDuplicate - True if the intrinsic is marked as noduplicate.
-    bool isNoDuplicate;
+  /// True if the intrinsic is no-return.
+  bool isNoReturn;
 
-    /// isNoReturn - True if the intrinsic is no-return.
-    bool isNoReturn;
+  /// True if the intrinsic is marked as convergent.
+  bool isConvergent;
 
-    /// isConvergent - True if the intrinsic is marked as convergent.
-    bool isConvergent;
+  enum ArgAttribute { NoCapture, Returned, ReadOnly, WriteOnly, ReadNone };
+  std::vector<std::pair<unsigned, ArgAttribute>> ArgumentAttributes;
 
-    enum ArgAttribute {
-      NoCapture,
-      ReadOnly,
-      ReadNone
-    };
-    std::vector<std::pair<unsigned, ArgAttribute> > ArgumentAttributes;
+  CodeGenIntrinsic(Record *R);
+};
 
-    CodeGenIntrinsic(Record *R);
+class CodeGenIntrinsicTable {
+  std::vector<CodeGenIntrinsic> Intrinsics;
+
+public:
+  struct TargetSet {
+    std::string Name;
+    size_t Offset;
+    size_t Count;
   };
+  std::vector<TargetSet> Targets;
+
+  explicit CodeGenIntrinsicTable(const RecordKeeper &RC, bool TargetOnly);
+  CodeGenIntrinsicTable() = default;
 
-  /// LoadIntrinsics - Read all of the intrinsics defined in the specified
-  /// .td file.
-  std::vector<CodeGenIntrinsic> LoadIntrinsics(const RecordKeeper &RC,
-                                               bool TargetOnly);
+  bool empty() const { return Intrinsics.empty(); }
+  size_t size() const { return Intrinsics.size(); }
+  CodeGenIntrinsic &operator[](size_t Pos) { return Intrinsics[Pos]; }
+  const CodeGenIntrinsic &operator[](size_t Pos) const {
+    return Intrinsics[Pos];
+  }
+};
 }
 
 #endif