[TableGen] Change !getop and !setop to !getdagop and !setdagop

[Paul-C-Anagnostopoulos]

Summary

In order to make the bang operators related to DAGs consistent, I'm adding 'dag' to the names that don't already include it. This will help with overall consistency when the new DAG operators are added over the next few weeks.

I updated the test, along with uses of the two operators in clang/Basic/arm_mve.td and Target/ARM/ARMInstrMVE.td

[nhaehnle]

LGTM

clang/include/clang/Basic/arm_mve.td

multiclass Reduction<Type Accumulator, string basename, list<Type> basetypes,
                      bit needSign = 0,
                      dag postCG = (seq (id $ret)),
                      dag accArg = (args Accumulator:$prev),
                      dag preCG = (seq)> {
   defvar intArgsBase   = (? $prev, $vec);
   defvar intArgsUnpred = !con(intArgsBase,
                               !if(needSign, (? (unsignedflag Scalar)), (?)));
   defvar intArgsPred   = !con(intArgsUnpred, (? $pred));
-  defvar intUnpred     = !setop(intArgsUnpred, IRInt<basename, basetypes>);
-  defvar intPred       = !setop(intArgsPred, IRInt<
+  defvar intUnpred     = !setdagop(intArgsUnpred, IRInt<basename, basetypes>);
+  defvar intPred       = !setdagop(intArgsPred, IRInt<
             basename#"_predicated", !listconcat(basetypes, [Predicate])>);
 
   def "": Intrinsic<
     Accumulator, !con(accArg, (args Vector:$vec)),
     !con(preCG, (seq intUnpred:$ret), postCG)>;
   def _p: Intrinsic<
     Accumulator, !con(accArg, (args Vector:$vec, Predicate:$pred)),
     !con(preCG, (seq intPred:$ret), postCG)>;

llvm/docs/TableGen/ProgRef.rst

 
 Bang operators
 --------------
 
 TableGen provides "bang operators" that have a wide variety of uses:
 
 .. productionlist::
    BangOperator: one of
-               : !add     !and         !cast        !con         !dag
-               : !empty   !eq          !foldl       !foreach     !ge
-               : !getop   !gt          !head        !if          !isa
-               : !le      !listconcat  !listsplat   !lt          !mul
-               : !ne      !not         !or          !setop       !shl
-               : !size    !sra         !srl         !strconcat   !subst
-               : !tail    !xor
+               : !add        !and         !cast        !con         !dag
+               : !empty      !eq          !foldl       !foreach     !ge
+               : !getdagop   !gt          !head        !if          !isa
+               : !le         !listconcat  !listsplat   !lt          !mul
+               : !ne         !not         !or          !setdagop    !shl
+               : !size       !sra         !srl         !strconcat   !subst
+               : !tail       !xor
 
 The ``!cond`` operator has a slightly different
 syntax compared to other bang operators, so it is defined separately:
 
 .. productionlist::
    CondOperator: !cond
 
 See `Appendix A: Bang Operators`_ for a description of each bang operator.

 
 The *value* can be any TableGen value. The *name*, if present, must be a
 :token:`TokVarName`, which starts with a dollar sign (``$``). The purpose of
 a name is to tag an operator or argument in a DAG with a particular meaning,
 or to associate an argument in one DAG with a like-named argument in another
 DAG.
 
 The following bang operators are useful for working with DAGs:
-``!con``, ``!dag``, ``!empty``, ``!foreach``, ``!getop``, ``!setop``, ``!size``.
+``!con``, ``!dag``, ``!empty``, ``!foreach``, ``!getdagop``, ``!setdagop``, ``!size``.
 
 Defvar in a record body
 -----------------------
 
 In addition to defining global variables, the ``defvar`` statement can
 be used inside the :token:`Body` of a class or record definition to define
 local variables. The scope of the variable extends from the ``defvar``
 statement to the end of the body. It cannot be set to a different value

 ==========================
 
 Bang operators act as functions in value expressions. A bang operator takes
 one or more arguments, operates on them, and produces a result. If the
 operator produces a boolean result, the result value will be 1 for true or 0
 for false. When an operator tests a boolean argument, it interprets 0 as false
 and non-0 as true.
 
+.. warning::
+  The ``!getop`` and ``!setop`` bang operators are deprecated in favor of
+  ``!getdagop`` and ``!setdagop``.
+
 ``!add(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator adds *a*, *b*, etc., and produces the sum.
 
 ``!and(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator does a bitwise AND on *a*, *b*, etc., and produces the
     result. A logical AND can be performed if all the arguments are either
     0 or 1.
 
``!foreach(``\ *var*\ ``,`` *seq*\ ``,`` *form*\ ``)``
     then evaluates the *form* expression. The form presumably refers to the
     variable *var* and calculates the result value.
 
 ``!ge(``\ *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is greater than or equal to *b*; 0 otherwise.
     The arguments must be ``bit``, ``int``, or ``string`` values.
     Use ``!cast<string>`` to compare other types of objects.
 
-``!getop(``\ *dag*\ ``)`` --or-- ``!getop<``\ *type*\ ``>(``\ *dag*\ ``)``
+``!getdagop(``\ *dag*\ ``)`` --or-- ``!getdagop<``\ *type*\ ``>(``\ *dag*\ ``)``
     This operator produces the operator of the given *dag* node.
-    Example: ``!getop((foo 1, 2))`` results in ``foo``.
+    Example: ``!getdagop((foo 1, 2))`` results in ``foo``. Recall that
+    DAG operators are always records.
 
-    The result of ``!getop`` can be used directly in a context where
-    any record value at all is acceptable (typically placing it into
+    The result of ``!getdagop`` can be used directly in a context where
+    any record class at all is acceptable (typically placing it into
     another dag value). But in other contexts, it must be explicitly
-    cast to a particular class type. The ``<``\ *type*\ ``>`` syntax is
+    cast to a particular class. The ``<``\ *type*\ ``>`` syntax is
     provided to make this easy.
 
     For example, to assign the result to a value of type ``BaseClass``, you
     could write either of these::
 
-      BaseClass b = !getop<BaseClass>(someDag);
-      BaseClass b = !cast<BaseClass>(!getop(someDag));
+      BaseClass b = !getdagop<BaseClass>(someDag);
+      BaseClass b = !cast<BaseClass>(!getdagop(someDag));
 
     But to create a new DAG node that reuses the operator from another, no
     cast is necessary::
 
-      dag d = !dag(!getop(someDag), args, names);
+      dag d = !dag(!getdagop(someDag), args, names);
 
 ``!gt(``\ *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is greater than *b*; 0 otherwise.
     The arguments must be ``bit``, ``int``, or ``string`` values.
     Use ``!cast<string>`` to compare other types of objects.
 
 ``!head(``\ *a*\ ``)``
     This operator produces the zeroth element of the list *a*.
``!not(``\ *a*\ ``)``
     an integer. The argument 0 results in 1 (true); any other
     argument results in 0 (false).
 
 ``!or(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator does a bitwise OR on *a*, *b*, etc., and produces the
     result. A logical OR can be performed if all the arguments are either
     0 or 1.
 
-``!setop(``\ *dag*\ ``,`` *op*\ ``)``
+``!setdagop(``\ *dag*\ ``,`` *op*\ ``)``
     This operator produces a DAG node with the same arguments as *dag*, but with its
     operator replaced with *op*.
 
-    Example: ``!setop((foo 1, 2), bar)`` results in ``(bar 1, 2)``.
+    Example: ``!setdagop((foo 1, 2), bar)`` results in ``(bar 1, 2)``.
 
 ``!shl(``\ *a*\ ``,`` *count*\ ``)``
     This operator shifts *a* left logically by *count* bits and produces the resulting
     value. The operation is performed on a 64-bit integer; the result
     is undefined for shift counts outside 0...63.
 
 ``!size(``\ *a*\ ``)``
     This operator produces the size of the string, list, or dag *a*.

llvm/include/llvm/TableGen/Record.h

public:
 
   Init *getBit(unsigned Bit) const override;
 };
 
 /// !op (X) - Transform an init.
 ///
 class UnOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum UnaryOp : uint8_t { CAST, NOT, HEAD, TAIL, SIZE, EMPTY, GETOP };
+  enum UnaryOp : uint8_t { CAST, NOT, HEAD, TAIL, SIZE, EMPTY, GETDAGOP };
 
 private:
   Init *LHS;
 
   UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
     : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {}
 
 public:
public:
   std::string getAsString() const override;
 };
 
 /// !op (X, Y) - Combine two inits.
 class BinOpInit : public OpInit, public FoldingSetNode {
 public:
   enum BinaryOp : uint8_t { ADD, MUL, AND, OR, XOR, SHL, SRA, SRL, LISTCONCAT,
                             LISTSPLAT, STRCONCAT, CONCAT, EQ, NE, LE, LT, GE,
-                            GT, SETOP };
+                            GT, SETDAGOP };
 
 private:
   Init *LHS, *RHS;
 
   BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
       OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {}
 
 public:

llvm/lib/TableGen/Record.cpp

case EMPTY:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
       return IntInit::get(LHSl->empty());
     if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
       return IntInit::get(LHSd->arg_empty());
     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
       return IntInit::get(LHSs->getValue().empty());
     break;
 
-  case GETOP:
+  case GETDAGOP:
     if (DagInit *Dag = dyn_cast<DagInit>(LHS)) {
       DefInit *DI = DefInit::get(Dag->getOperatorAsDef({}));
       if (!DI->getType()->typeIsA(getType())) {
         PrintFatalError(CurRec->getLoc(),
                         Twine("Expected type '") +
                         getType()->getAsString() + "', got '" +
                         DI->getType()->getAsString() + "' in: " +
                         getAsString() + "\n");
std::string UnOpInit::getAsString() const {
   std::string Result;
   switch (getOpcode()) {
   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
   case NOT: Result = "!not"; break;
   case HEAD: Result = "!head"; break;
   case TAIL: Result = "!tail"; break;
   case SIZE: Result = "!size"; break;
   case EMPTY: Result = "!empty"; break;
-  case GETOP: Result = "!getop"; break;
+  case GETDAGOP: Result = "!getdagop"; break;
   }
   return Result + "(" + LHS->getAsString() + ")";
 }
 
 static void
 ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
                  RecTy *Type) {
   ID.AddInteger(Opcode);
if (getOpcode() == EQ || getOpcode() == NE) {
       if (LHSs && RHSs) {
         bool Equal = LHSs->getValue() == RHSs->getValue();
         return BitInit::get(getOpcode() == EQ ? Equal : !Equal);
       }
     }
 
     break;
   }
-  case SETOP: {
+  case SETDAGOP: {
     DagInit *Dag = dyn_cast<DagInit>(LHS);
     DefInit *Op = dyn_cast<DefInit>(RHS);
     if (Dag && Op) {
       SmallVector<Init*, 8> Args;
       SmallVector<StringInit*, 8> ArgNames;
       for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
         Args.push_back(Dag->getArg(i));
         ArgNames.push_back(Dag->getArgName(i));
std::string BinOpInit::getAsString() const {
   case NE: Result = "!ne"; break;
   case LE: Result = "!le"; break;
   case LT: Result = "!lt"; break;
   case GE: Result = "!ge"; break;
   case GT: Result = "!gt"; break;
   case LISTCONCAT: Result = "!listconcat"; break;
   case LISTSPLAT: Result = "!listsplat"; break;
   case STRCONCAT: Result = "!strconcat"; break;
-  case SETOP: Result = "!setop"; break;
+  case SETDAGOP: Result = "!setdagop"; break;
   }
   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
 static void
 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
                   Init *RHS, RecTy *Type) {
   ID.AddInteger(Opcode);

llvm/lib/TableGen/TGLexer.h

enum TokKind {
     // that means the preprocessor #else.)
     Bit, Bits, Class, Code, Dag, Def, Foreach, Defm, Field, In, Int, Let, List,
     MultiClass, String, Defset, Defvar, If, Then, ElseKW,
 
     // !keywords.
     XConcat, XADD, XMUL, XNOT, XAND, XOR, XXOR, XSRA, XSRL, XSHL,
     XListConcat, XListSplat, XStrConcat, XCast, XSubst, XForEach, XFoldl,
     XHead, XTail, XSize, XEmpty, XIf, XCond, XEq, XIsA, XDag, XNe, XLe,
-    XLt, XGe, XGt, XSetOp, XGetOp,
+    XLt, XGe, XGt, XSetDagOp, XGetDagOp,
 
     // Integer value.
     IntVal,
 
     // Binary constant.  Note that these are sized according to the number of
     // bits given.
     BinaryIntVal,
 

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind =
     .Case("cast", tgtok::XCast)
     .Case("empty", tgtok::XEmpty)
     .Case("subst", tgtok::XSubst)
     .Case("foldl", tgtok::XFoldl)
     .Case("foreach", tgtok::XForEach)
     .Case("listconcat", tgtok::XListConcat)
     .Case("listsplat", tgtok::XListSplat)
     .Case("strconcat", tgtok::XStrConcat)
-    .Case("setop", tgtok::XSetOp)
-    .Case("getop", tgtok::XGetOp)
+    .Cases("setdagop", "setop", tgtok::XSetDagOp) // !setop is deprecated.
+    .Cases("getdagop", "getop", tgtok::XGetDagOp) // !getop is deprecated.
     .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
 
 bool TGLexer::prepExitInclude(bool IncludeStackMustBeEmpty) {
   // Report an error, if preprocessor control stack for the current
   // file is not empty.

llvm/lib/TableGen/TGParser.cpp

case tgtok::Id:
     if (Record *R = ParseClassID()) return RecordRecTy::get(R);
     TokError("unknown class name");
     return nullptr;
   case tgtok::Bits: {
     if (Lex.Lex() != tgtok::less) { // Eat 'bits'
       TokError("expected '<' after bits type");
       return nullptr;
     }
-    if (Lex.Lex() != tgtok::IntVal) {  // Eat '<'
+    if (Lex.Lex() != tgtok::IntVal) { // Eat '<'
       TokError("expected integer in bits<n> type");
       return nullptr;
     }
     uint64_t Val = Lex.getCurIntVal();
-    if (Lex.Lex() != tgtok::greater) {  // Eat count.
+    if (Lex.Lex() != tgtok::greater) { // Eat count.
       TokError("expected '>' at end of bits<n> type");
       return nullptr;
     }
     Lex.Lex();  // Eat '>'
     return BitsRecTy::get(Val);
   }
   case tgtok::List: {
     if (Lex.Lex() != tgtok::less) { // Eat 'bits'
default:
     TokError("unknown operation");
     return nullptr;
   case tgtok::XNOT:
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:
-  case tgtok::XGetOp: {  // Value ::= !unop '(' Value ')'
+  case tgtok::XGetDagOp: { // Value ::= !unop '(' Value ')'
     UnOpInit::UnaryOp Code;
     RecTy *Type = nullptr;
 
     switch (Lex.getCode()) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XCast:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::CAST;
case tgtok::XSize:
       Code = UnOpInit::SIZE;
       Type = IntRecTy::get();
       break;
     case tgtok::XEmpty:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::EMPTY;
       Type = IntRecTy::get();
       break;
-    case tgtok::XGetOp:
+    case tgtok::XGetDagOp:
       Lex.Lex();  // eat the operation
       if (Lex.getCode() == tgtok::less) {
         // Parse an optional type suffix, so that you can say
-        // !getop<BaseClass>(someDag) as a shorthand for
-        // !cast<BaseClass>(!getop(someDag)).
+        // !getdagop<BaseClass>(someDag) as a shorthand for
+        // !cast<BaseClass>(!getdagop(someDag)).
         Type = ParseOperatorType();
 
         if (!Type) {
           TokError("did not get type for unary operator");
           return nullptr;
         }
 
         if (!isa<RecordRecTy>(Type)) {
-          TokError("type for !getop must be a record type");
+          TokError("type for !getdagop must be a record type");
           // but keep parsing, to consume the operand
         }
       } else {
         Type = RecordRecTy::get({});
       }
-      Code = UnOpInit::GETOP;
+      Code = UnOpInit::GETDAGOP;
       break;
     }
     if (!consume(tgtok::l_paren)) {
       TokError("expected '(' after unary operator");
       return nullptr;
     }
 
     Init *LHS = ParseValue(CurRec);
Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   case tgtok::XNe:
   case tgtok::XLe:
   case tgtok::XLt:
   case tgtok::XGe:
   case tgtok::XGt:
   case tgtok::XListConcat:
   case tgtok::XListSplat:
   case tgtok::XStrConcat:
-  case tgtok::XSetOp: {  // Value ::= !binop '(' Value ',' Value ')'
+  case tgtok::XSetDagOp: { // Value ::= !binop '(' Value ',' Value ')'
     tgtok::TokKind OpTok = Lex.getCode();
     SMLoc OpLoc = Lex.getLoc();
     Lex.Lex();  // eat the operation
 
     BinOpInit::BinaryOp Code;
     switch (OpTok) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XConcat: Code = BinOpInit::CONCAT; break;
     case tgtok::XADD:    Code = BinOpInit::ADD; break;
     case tgtok::XMUL:    Code = BinOpInit::MUL; break;
     case tgtok::XAND:    Code = BinOpInit::AND; break;
     case tgtok::XOR:     Code = BinOpInit::OR; break;
     case tgtok::XXOR:    Code = BinOpInit::XOR; break;
     case tgtok::XSRA:    Code = BinOpInit::SRA; break;
     case tgtok::XSRL:    Code = BinOpInit::SRL; break;
     case tgtok::XSHL:    Code = BinOpInit::SHL; break;
     case tgtok::XEq:     Code = BinOpInit::EQ; break;
     case tgtok::XNe:     Code = BinOpInit::NE; break;
     case tgtok::XLe:     Code = BinOpInit::LE; break;
     case tgtok::XLt:     Code = BinOpInit::LT; break;
     case tgtok::XGe:     Code = BinOpInit::GE; break;
     case tgtok::XGt:     Code = BinOpInit::GT; break;
     case tgtok::XListConcat: Code = BinOpInit::LISTCONCAT; break;
-    case tgtok::XListSplat: Code = BinOpInit::LISTSPLAT; break;
-    case tgtok::XStrConcat: Code = BinOpInit::STRCONCAT; break;
-    case tgtok::XSetOp: Code = BinOpInit::SETOP; break;
+    case tgtok::XListSplat:  Code = BinOpInit::LISTSPLAT; break;
+    case tgtok::XStrConcat:  Code = BinOpInit::STRCONCAT; break;
+    case tgtok::XSetDagOp:   Code = BinOpInit::SETDAGOP; break;
     }
 
     RecTy *Type = nullptr;
     RecTy *ArgType = nullptr;
     switch (OpTok) {
     default:
       llvm_unreachable("Unhandled code!");
     case tgtok::XConcat:
-    case tgtok::XSetOp:
+    case tgtok::XSetDagOp:
       Type = DagRecTy::get();
       ArgType = DagRecTy::get();
       break;
     case tgtok::XAND:
     case tgtok::XOR:
     case tgtok::XXOR:
     case tgtok::XSRA:
     case tgtok::XSRL:
for (;;) {
             Code != BinOpInit::SRA && Code != BinOpInit::SRL &&
             Code != BinOpInit::SHL && Code != BinOpInit::MUL)
           ArgType = Resolved;
       }
 
       // Deal with BinOps whose arguments have different types, by
       // rewriting ArgType in between them.
       switch (Code) {
-        case BinOpInit::SETOP:
+        case BinOpInit::SETDAGOP:
           // After parsing the first dag argument, switch to expecting
           // a record, with no restriction on its superclasses.
           ArgType = RecordRecTy::get({});
           break;
         default:
           break;
       }
 
case tgtok::XForEach: {
     }
 
     return (TernOpInit::get(TernOpInit::FOREACH, LHS, MHS, RHS, OutType))
         ->Fold(CurRec);
   }
 
   case tgtok::XDag:
   case tgtok::XIf:
-  case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
+  case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     TernOpInit::TernaryOp Code;
     RecTy *Type = nullptr;
 
     tgtok::TokKind LexCode = Lex.getCode();
     Lex.Lex();  // eat the operation
     switch (LexCode) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XDag:
if (!EltTy) {
       DeducedEltTy = EltTy;
     }
 
     return ListInit::get(Vals, DeducedEltTy);
   }
   case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
     Lex.Lex();   // eat the '('
     if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast &&
-        Lex.getCode() != tgtok::question && Lex.getCode() != tgtok::XGetOp) {
+        Lex.getCode() != tgtok::question && Lex.getCode() != tgtok::XGetDagOp) {
       TokError("expected identifier in dag init");
       return nullptr;
     }
 
     Init *Operator = ParseValue(CurRec);
     if (!Operator) return nullptr;
 
     // If the operator name is present, parse it.
case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
     return DagInit::get(Operator, OperatorName, DagArgs);
   }
 
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:
-  case tgtok::XGetOp:  // Value ::= !unop '(' Value ')'
+  case tgtok::XGetDagOp: // Value ::= !unop '(' Value ')'
   case tgtok::XIsA:
   case tgtok::XConcat:
   case tgtok::XDag:
   case tgtok::XADD:
   case tgtok::XMUL:
   case tgtok::XNOT:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XXOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:
   case tgtok::XEq:
   case tgtok::XNe:
   case tgtok::XLe:
   case tgtok::XLt:
   case tgtok::XGe:
   case tgtok::XGt:
   case tgtok::XListConcat:
   case tgtok::XListSplat:
   case tgtok::XStrConcat:
-  case tgtok::XSetOp:   // Value ::= !binop '(' Value ',' Value ')'
+  case tgtok::XSetDagOp: // Value ::= !binop '(' Value ',' Value ')'
   case tgtok::XIf:
   case tgtok::XCond:
   case tgtok::XFoldl:
   case tgtok::XForEach:
-  case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
+  case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     return ParseOperation(CurRec, ItemType);
   }
   }
 
   return R;
 }
 
 /// ParseValue - Parse a tblgen value.  This returns null on error.
case tgtok::l_square: {
       // Eat the ']'.
       if (!consume(tgtok::r_square)) {
         TokError("expected ']' at end of list slice");
         return nullptr;
       }
       break;
     }
     case tgtok::dot: {
-      if (Lex.Lex() != tgtok::Id) {  // eat the .
+      if (Lex.Lex() != tgtok::Id) { // eat the .
         TokError("expected field identifier after '.'");
         return nullptr;
       }
       StringInit *FieldName = StringInit::get(Lex.getCurStrVal());
       if (!Result->getFieldType(FieldName)) {
         TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
                  Result->getAsString() + "'");
         return nullptr;

llvm/lib/Target/ARM/ARMInstrMVE.td

multiclass MVE_VSHRN_patterns<MVE_shift_imm_partial inst,
                               MVEVectorVTInfo OutVTI, MVEVectorVTInfo InVTI,
                               bit q, bit r, bit top> {
   defvar inparams = (? (OutVTI.Vec MQPR:$QdSrc), (InVTI.Vec MQPR:$Qm),
                        (inst.immediateType:$imm), (i32 q), (i32 r),
                        (i32 OutVTI.Unsigned), (i32 InVTI.Unsigned), (i32 top));
   defvar outparams = (inst (OutVTI.Vec MQPR:$QdSrc), (InVTI.Vec MQPR:$Qm),
                            (imm:$imm));
 
-  def : Pat<(OutVTI.Vec !setop(inparams, int_arm_mve_vshrn)),
+  def : Pat<(OutVTI.Vec !setdagop(inparams, int_arm_mve_vshrn)),
             (OutVTI.Vec outparams)>;
   def : Pat<(OutVTI.Vec !con(inparams, (int_arm_mve_vshrn_predicated
                                            (InVTI.Pred VCCR:$pred)))),
             (OutVTI.Vec !con(outparams, (? ARMVCCThen, VCCR:$pred)))>;
 }
 
 defm : MVE_VSHRN_patterns<MVE_VSHRNi16bh,    MVE_v16s8, MVE_v8s16, 0,0,0>;
 defm : MVE_VSHRN_patterns<MVE_VSHRNi16th,    MVE_v16s8, MVE_v8s16, 0,0,1>;
multiclass MVE_VSxI_patterns<MVE_VSxI_imm inst, string name,
                               MVEVectorVTInfo VTI> {
   defvar inparams = (? (VTI.Vec MQPR:$QdSrc), (VTI.Vec MQPR:$Qm),
                        (inst.immediateType:$imm));
   defvar outparams = (inst (VTI.Vec MQPR:$QdSrc), (VTI.Vec MQPR:$Qm),
                            (inst.immediateType:$imm));
   defvar unpred_int = !cast<Intrinsic>("int_arm_mve_" # name);
   defvar pred_int = !cast<Intrinsic>("int_arm_mve_" # name # "_predicated");
 
-  def : Pat<(VTI.Vec !setop(inparams, unpred_int)),
+  def : Pat<(VTI.Vec !setdagop(inparams, unpred_int)),
             (VTI.Vec outparams)>;
   def : Pat<(VTI.Vec !con(inparams, (pred_int (VTI.Pred VCCR:$pred)))),
             (VTI.Vec !con(outparams, (? ARMVCCThen, VCCR:$pred)))>;
 }
 
 defm : MVE_VSxI_patterns<MVE_VSLIimm8,  "vsli", MVE_v16i8>;
 defm : MVE_VSxI_patterns<MVE_VSLIimm16, "vsli", MVE_v8i16>;
 defm : MVE_VSxI_patterns<MVE_VSLIimm32, "vsli", MVE_v4i32>;

llvm/test/TableGen/getsetop.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // RUN: not llvm-tblgen -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
 // RUN: not llvm-tblgen -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s
 // RUN: not llvm-tblgen -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s
 
+// !setop and !getop are deprecated in favor of !setdagop and !getdagop.
+// Two tests retain the old names just to be sure they are still supported.
+
 class Base;
 class OtherBase;
 
 def foo: Base;
 def bar: Base;
 def qux: OtherBase;
 
 def test {
   dag orig = (foo 1, 2:$a, $b);
   dag another = (qux "hello", $world);
 
   // CHECK: dag replaceWithBar = (bar 1, 2:$a, ?:$b);
   dag replaceWithBar = !setop(orig, bar);
 
   // CHECK: dag replaceWithBaz = (qux 1, 2:$a, ?:$b);
-  dag replaceWithBaz = !setop(orig, qux);
+  dag replaceWithBaz = !setdagop(orig, qux);
 
   // CHECK: Base getopWithCast = foo;
   Base getopWithCast = !getop<Base>(orig);
 
   // CHECK: dag getopToSetop = (foo "hello", ?:$world);
-  dag getopToSetop = !setop(another, !getop(orig));
+  dag getopToSetop = !setdagop(another, !getdagop(orig));
 
   // CHECK: dag getopToBangDag = (foo 1:$a, 2:$b, 3:$c);
-  dag getopToBangDag = !dag(!getop(orig), [1, 2, 3], ["a", "b", "c"]);
+  dag getopToBangDag = !dag(!getdagop(orig), [1, 2, 3], ["a", "b", "c"]);
 
   // CHECK: dag getopToDagInit = (foo "it worked");
-  dag getopToDagInit = (!getop(orig) "it worked");
+  dag getopToDagInit = (!getdagop(orig) "it worked");
 
 #ifdef ERROR1
-  // !getop(...) has a static type of 'any record at all, with no
+  // !getdagop(...) has a static type of 'any record at all, with no
   // required superclasses'. That's too general to use in an
   // assignment whose LHS demands an instance of Base, so we expect a
   // static (parse-time) type-checking error.
 
-  // ERROR1: error: Field 'noCast' of type 'Base' is incompatible with value '!getop(orig)' of type '{}'
-  Base noCast = !getop(orig);
+  // ERROR1: error: Field 'noCast' of type 'Base' is incompatible with value '!getdagop(orig)' of type '{}'
+  Base noCast = !getdagop(orig);
 #endif
 
 #ifdef ERROR2
   // Here, we expect a _dynamic_ type error, when it turns out at
   // evaluation time that the operator of 'another' is a record that
   // isn't an instance of the specified base class.
 
-  // ERROR2: error: Expected type 'Base', got 'OtherBase' in: !getop((qux "hello", ?:$world))
-  Base badCast = !getop<Base>(another);
+  // ERROR2: error: Expected type 'Base', got 'OtherBase' in: !getdagop((qux "hello", ?:$world))
+  Base badCast = !getdagop<Base>(another);
 #endif
 
 #ifdef ERROR3
-  // Obviously, you shouldn't be able to give any type to !getop that
+  // Obviously, you shouldn't be able to give any type to !getdagop that
   // isn't a class type.
 
-  // ERROR3: error: type for !getop must be a record type
-  int ridiculousCast = !getop<int>(orig);
+  // ERROR3: error: type for !getdagop must be a record type
+  int ridiculousCast = !getdagop<int>(orig);
 #endif
 }