Clean up doxygen comments in FunctionAttrs, promoting some non-doxygen

[oota-llvm.git] / utils / TableGen / CodeGenDAGPatterns.h

diff --git a/utils/TableGen/CodeGenDAGPatterns.h b/utils/TableGen/CodeGenDAGPatterns.h
index 5e688cfb110883736c616f966d13753373d8b7b8..f330e558f56a7b9ed2d74524c1ad92ee47a71e8e 100644 (file)
--- a/utils/TableGen/CodeGenDAGPatterns.h
+++ b/utils/TableGen/CodeGenDAGPatterns.h
@@ -132,14 +132,22 @@ namespace EEVT {
     /// this an other based on this information.
     bool EnforceSmallerThan(EEVT::TypeSet &Other, TreePattern &TP);
 
-    /// EnforceVectorEltTypeIs - 'this' is now constrainted to be a vector type
+    /// EnforceVectorEltTypeIs - 'this' is now constrained to be a vector type
     /// whose element is VT.
     bool EnforceVectorEltTypeIs(EEVT::TypeSet &VT, TreePattern &TP);
 
-    /// EnforceVectorSubVectorTypeIs - 'this' is now constrainted to
+    /// EnforceVectorEltTypeIs - 'this' is now constrained to be a vector type
+    /// whose element is VT.
+    bool EnforceVectorEltTypeIs(MVT::SimpleValueType VT, TreePattern &TP);
+
+    /// EnforceVectorSubVectorTypeIs - 'this' is now constrained to
     /// be a vector type VT.
     bool EnforceVectorSubVectorTypeIs(EEVT::TypeSet &VT, TreePattern &TP);
 
+    /// EnforceVectorSameNumElts - 'this' is now constrained to
+    /// be a vector with same num elements as VT.
+    bool EnforceVectorSameNumElts(EEVT::TypeSet &VT, TreePattern &TP);
+
     bool operator!=(const TypeSet &RHS) const { return TypeVec != RHS.TypeVec; }
     bool operator==(const TypeSet &RHS) const { return TypeVec == RHS.TypeVec; }
 
@@ -165,7 +173,7 @@ struct SDTypeConstraint {
   enum {
     SDTCisVT, SDTCisPtrTy, SDTCisInt, SDTCisFP, SDTCisVec, SDTCisSameAs,
     SDTCisVTSmallerThanOp, SDTCisOpSmallerThanOp, SDTCisEltOfVec,
-    SDTCisSubVecOfVec
+    SDTCisSubVecOfVec, SDTCVecEltisVT, SDTCisSameNumEltsAs
   } ConstraintType;
 
   union {   // The discriminated union.
@@ -187,6 +195,12 @@ struct SDTypeConstraint {
     struct {
       unsigned OtherOperandNum;
     } SDTCisSubVecOfVec_Info;
+    struct {
+      MVT::SimpleValueType VT;
+    } SDTCVecEltisVT_Info;
+    struct {
+      unsigned OtherOperandNum;
+    } SDTCisSameNumEltsAs_Info;
   } x;
 
   /// ApplyTypeConstraint - Given a node in a pattern, apply this type
@@ -294,7 +308,7 @@ private:
   std::string getPredCode() const;
   std::string getImmCode() const;
 };
-
+  
 
 /// FIXME: TreePatternNode's can be shared in some cases (due to dag-shaped
 /// patterns), and as such should be ref counted.  We currently just leak all
@@ -508,7 +522,7 @@ class TreePattern {
   /// Trees - The list of pattern trees which corresponds to this pattern.
   /// Note that PatFrag's only have a single tree.
   ///
-  std::vector<std::unique_ptr<TreePatternNode>> Trees;
+  std::vector<TreePatternNode*> Trees;
 
   /// NamedNodes - This is all of the nodes that have names in the trees in this
   /// pattern.
@@ -548,17 +562,15 @@ public:
               CodeGenDAGPatterns &ise);
   TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
               CodeGenDAGPatterns &ise);
-  TreePattern(Record *TheRec, std::unique_ptr<TreePatternNode> Pat,
-              bool isInput, CodeGenDAGPatterns &ise);
+  TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
+              CodeGenDAGPatterns &ise);
 
   /// getTrees - Return the tree patterns which corresponds to this pattern.
   ///
-  const std::vector<std::unique_ptr<TreePatternNode>> &getTrees() const {
-    return Trees;
-  }
+  const std::vector<TreePatternNode*> &getTrees() const { return Trees; }
   unsigned getNumTrees() const { return Trees.size(); }
-  TreePatternNode *getTree(unsigned i) const { return Trees[i].get(); }
-  std::unique_ptr<TreePatternNode> &getOnlyTree() {
+  TreePatternNode *getTree(unsigned i) const { return Trees[i]; }
+  TreePatternNode *getOnlyTree() const {
     assert(Trees.size() == 1 && "Doesn't have exactly one pattern!");
     return Trees[0];
   }
@@ -588,8 +600,7 @@ public:
   /// PatFrag references.
   void InlinePatternFragments() {
     for (unsigned i = 0, e = Trees.size(); i != e; ++i)
-      // Can leak, if InlinePatternFragments doesn't return 'this'
-      Trees[i].reset(Trees[i].release()->InlinePatternFragments(*this));
+      Trees[i] = Trees[i]->InlinePatternFragments(*this);
   }
 
   /// InferAllTypes - Infer/propagate as many types throughout the expression
@@ -612,7 +623,7 @@ public:
   void dump() const;
 
 private:
-  std::unique_ptr<TreePatternNode> ParseTreePattern(Init *DI, StringRef OpName);
+  TreePatternNode *ParseTreePattern(Init *DI, StringRef OpName);
   void ComputeNamedNodes();
   void ComputeNamedNodes(TreePatternNode *N);
 };
@@ -628,15 +639,14 @@ class DAGInstruction {
   std::vector<Record*> Results;
   std::vector<Record*> Operands;
   std::vector<Record*> ImpResults;
-  std::unique_ptr<TreePatternNode> ResultPattern;
-
+  TreePatternNode *ResultPattern;
 public:
   DAGInstruction(TreePattern *TP,
                  const std::vector<Record*> &results,
                  const std::vector<Record*> &operands,
                  const std::vector<Record*> &impresults)
     : Pattern(TP), Results(results), Operands(operands),
-      ImpResults(impresults)  {}
+      ImpResults(impresults), ResultPattern(nullptr) {}
 
   TreePattern *getPattern() const { return Pattern; }
   unsigned getNumResults() const { return Results.size(); }
@@ -644,9 +654,7 @@ public:
   unsigned getNumImpResults() const { return ImpResults.size(); }
   const std::vector<Record*>& getImpResults() const { return ImpResults; }
 
-  void setResultPattern(std::unique_ptr<TreePatternNode> R) {
-    ResultPattern = std::move(R);
-  }
+  void setResultPattern(TreePatternNode *R) { ResultPattern = R; }
 
   Record *getResult(unsigned RN) const {
     assert(RN < Results.size());
@@ -663,7 +671,7 @@ public:
     return ImpResults[RN];
   }
 
-  TreePatternNode *getResultPattern() const { return ResultPattern.get(); }
+  TreePatternNode *getResultPattern() const { return ResultPattern; }
 };
 
 /// PatternToMatch - Used by CodeGenDAGPatterns to keep tab of patterns