[TableGen] Add !setdagarg and !setdagname

[hliao]

Summary

• This patch proposes to add !setdagarg and !setdagname bang operators to produce a new DAG node after replacing the specified argument value/name from the given input DAG node. E.g., !setdagarg((foo 1, 2), 0, "x") produces (foo "x", 2) and !setdagname((foo 1:$a, 2:$b), 1, "c") produces (foo 1:$a, 2:$c).

[Paul-C-Anagnostopoulos]

I don't understand the descriptions of these new operators. I don't think you mean that it replaces the argument value with the key.

[hliao]

In D151842#4385757, @Paul-C-Anagnostopoulos wrote:

I don't understand the descriptions of these new operators. I don't think you mean that it replaces the argument value with the key.

As the naming suggests, it sets the argument name/value by the specified argument by either index or name (for argument value only.)

[simon_tatham]

As the naming suggests, it sets the argument name/value by the specified argument by either index or name (for argument value only.)

I think Paul's point is that the use of English is confusing. "Replace X by Y" is normally taken to mean the same thing as "Replace X with Y", and both of them mean putting Y where X used to be. So "replacing the argument name by the specified index" suggests that the function will put an integer index where a name used to be, which makes no sense.

It looks as if what you actually mean is something like:

!setdagarg(dag, key, arg) produces a DAG node with the same operator and argument list as dag, except that the argument identified by key (which can be a string name or an integer index) has its value replaced by arg.

!setdagname(dag, index, name) produces a DAG node with the same operator and argument list as dag, except that the argument identified by index (which must be an integer index) has its name field replaced by name.

[hliao]

Revise the documentation

[hliao]

Revise the commit message, which has different markdown syntax from rst.

[simon_tatham]

I wonder if it might make sense to allow !setdagname to take a string name argument, like !setdagarg and !getdagarg do?

Obviously, it makes no sense for !getdagname, because if you're trying to find the name of the argument called "foo", you already know the answer is "foo" (unless there isn't one at all, I suppose). But I can imagine that you might want to rename the "foo" argument to "bar", without first having to find out where it is.

If you abstract out the "look up by index or name" functionality as I suggest, then this wouldn't even be difficult to implement – just add another call to the same function.

llvm/docs/TableGen/ProgRef.rst

1825

Perhaps also mention that it has the same argument list apart from your one change.

1826

That comma is not standard English punctuation. It's better to remove it.

1831

Same with this one. Also, later in the line, there's a mis-spaced comma (space before it, not after it).

llvm/lib/TableGen/Record.cpp

1718–1750

This all looks very similar to the code in !getdagarg. Instead of cloning and hacking it, perhaps it would be better to factor out the code that maps Idx to an integer position, and call it from both cases?

[hliao]

In D151842#4387522, @simon_tatham wrote:

I wonder if it might make sense to allow !setdagname to take a string name argument, like !setdagarg and !getdagarg do?

Obviously, it makes no sense for !getdagname, because if you're trying to find the name of the argument called "foo", you already know the answer is "foo" (unless there isn't one at all, I suppose). But I can imagine that you might want to rename the "foo" argument to "bar", without first having to find out where it is.

If you abstract out the "look up by index or name" functionality as I suggest, then this wouldn't even be difficult to implement – just add another call to the same function.

not an issue of implementation, the only case where to use`!setdagname` by argument name should be renaming an argument. However, I would add that for completeness. Thanks for the suggestion.

[hliao]

Revise following reviewer's comments. Now, !setdagname also accepts name to lookup arguments

[simon_tatham]

llvm/lib/TableGen/Record.cpp

1327–1328

I'd intended to suggest that all of this code, not just the name lookup, could be factored out into a function that took an Init * and returned an optional<unsigned> argument number. It would handle both the integer and string cases, and construct an appropriate error message on failure (perhaps also given the name of the bang-operator it was being used by).

Then you'd only need one if statement in this case handler, and also for the ones in SETDAGARG and SETDAGNAME.

[hliao]

Add a common helper for !getdagarg, !setdagarg, and !setdagname

[simon_tatham]

Thanks, that looks much nicer!

There are three nitpicks still unaddressed in the documentation change in ProgRef.rst, but after that, I'm happy.

[hliao]

Revise documentation

[Paul-C-Anagnostopoulos]

llvm/docs/TableGen/ProgRef.rst

1832

Add period after *arg*

[hliao]

My bad. Add the missing period.

[hliao]

Revise the statement on !setdagname

[simon_tatham]

LGTM, thanks!

llvm/docs/TableGen/ProgRef.rst

 .. productionlist::
    BangOperator: one of
                : !add         !and         !cast        !con         !dag
                : !div         !empty       !eq          !exists      !filter
                : !find        !foldl       !foreach     !ge          !getdagarg
                : !getdagname  !getdagop    !gt          !head        !if
                : !interleave  !isa         !le          !listconcat  !listremove
                : !listsplat   !logtwo      !lt          !mul         !ne
-               : !not         !or          !range       !setdagop    !shl
-               : !size        !sra         !srl         !strconcat   !sub
-               : !subst       !substr      !tail        !tolower     !toupper
-               : !xor
+               : !not         !or          !range       !setdagarg   !setdagname
+               : !setdagop    !shl         !size        !sra         !srl
+               : !strconcat   !sub         !subst       !substr      !tail
+               : !tolower     !toupper     !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``, ``!getdagarg``, ``!getdagname``,
-``!getdagop``, ``!setdagop``, ``!size``.
+``!getdagop``, ``!setdagarg``, ``!setdagname``, ``!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. Template arguments of ``class`` or ``multiclass`` can be
 used in the value expression. The scope of the variable extends from the
``!range([``\ *a*\ ``,``] *b*\ ``)``
     This operator produces half-open range sequence ``[a : b)`` as ``list<int>``.
     *a* is ``0`` by default. ``!range(4)`` is equivalent to ``!range(0, 4)``.
     The result is `[0, 1, 2, 3]`.
     If *a* ``>=`` *b*, then the result is `[]<list<int>>`.
 
 ``!range(``\ *list*\ ``)``
     Equivalent to ``!range(0, !size(list))``.
 
+``!setdagarg(``\ *dag*\ ``,``\ *key*\ ``,``\ *arg*\ ``)``
+    This operator produces a DAG node with the same operator as *dag*, but
+    replacing the value of the argument, specified by the *key*, which is
+    either an integer index or a string name, with *arg*.
+
+``!setdagname(``\ *dag*\ ``,``\ *index*\ ``,``\ *name*\ ``)``
+    This operator produces a DAG node with the same operator as *dag*, but
+    replacing the name of the argument, specified by the *index* ,with *name*.
+
 ``!setdagop(``\ *dag*\ ``,`` *op*\ ``)``
     This operator produces a DAG node with the same arguments as *dag*, but with its
     operator replaced with *op*.
 
     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

llvm/include/llvm/TableGen/Record.h

public:
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;
 };
 
 /// !op (X, Y, Z) - Combine two inits.
 class TernOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum TernaryOp : uint8_t { SUBST, FOREACH, FILTER, IF, DAG, SUBSTR, FIND };
+  enum TernaryOp : uint8_t {
+    SUBST,
+    FOREACH,
+    FILTER,
+    IF,
+    DAG,
+    SUBSTR,
+    FIND,
+    SETDAGARG,
+    SETDAGNAME,
+  };
 
 private:
   Init *LHS, *MHS, *RHS;
 
   TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
              RecTy *Type) :
       OpInit(IK_TernOpInit, Type, opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
 
public:
 
   unsigned getNumArgs() const { return NumArgs; }
 
   Init *getArg(unsigned Num) const {
     assert(Num < NumArgs && "Arg number out of range!");
     return getTrailingObjects<Init *>()[Num];
   }
 
+  /// This method looks up the specified argument name and returns its argument
+  /// number or std::nullopt if that argument name does not exist.
+  std::optional<unsigned> getArgNo(StringRef Name) const;
+
   StringInit *getArgName(unsigned Num) const {
     assert(Num < NumArgNames && "Arg number out of range!");
     return getTrailingObjects<StringInit *>()[Num];
   }
 
   StringRef getArgNameStr(unsigned Num) const {
     StringInit *Init = getArgName(Num);
     return Init ? Init->getValue() : StringRef();

llvm/lib/TableGen/Record.cpp

if (Opc == EQ || Opc == NE) {
     DefInit *RHSd = dyn_cast<DefInit>(RHS);
     if (LHSd && RHSd)
       return (Opc == EQ) ? LHSd == RHSd : LHSd != RHSd;
   }
 
   return std::nullopt;
 }
 
+static std::optional<unsigned> getDagArgNoByKey(DagInit *Dag, Init *Key,
+                                                std::string &Error) {
+  // Accessor by index
+  if (IntInit *Idx = dyn_cast<IntInit>(Key)) {
+    int64_t Pos = Idx->getValue();
+    if (Pos < 0) {
+      // The index is negative.
+      Error =
+          (Twine("index ") + std::to_string(Pos) + Twine(" is negative")).str();
+      return std::nullopt;
+    }
+    if (Pos >= Dag->getNumArgs()) {
+      // The index is out-of-range.
+      Error = (Twine("index ") + std::to_string(Pos) +
+               " is out of range (dag has " +
+               std::to_string(Dag->getNumArgs()) + " arguments)")
+                  .str();
+      return std::nullopt;
+    }
+    return Pos;
+  }
+  assert(isa<StringInit>(Key));
+  // Accessor by name
+  StringInit *Name = dyn_cast<StringInit>(Key);
+  auto ArgNo = Dag->getArgNo(Name->getValue());
+  if (!ArgNo) {
+    // The key is not found.
+    Error = (Twine("key '") + Name->getValue() + Twine("' is not found")).str();
+    return std::nullopt;
+  }
+  return *ArgNo;
+}
+
 Init *BinOpInit::Fold(Record *CurRec) const {
   switch (getOpcode()) {
   case CONCAT: {
     DagInit *LHSs = dyn_cast<DagInit>(LHS);
     DagInit *RHSs = dyn_cast<DagInit>(RHS);
     if (LHSs && RHSs) {
       DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
       DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
Init *BinOpInit::Fold(Record *CurRec) const {
   case GE:
   case GT: {
     if (std::optional<bool> Result = CompareInit(getOpcode(), LHS, RHS))
       return BitInit::get(getRecordKeeper(), *Result);
     break;
   }
   case GETDAGARG: {
     DagInit *Dag = dyn_cast<DagInit>(LHS);
-    if (!Dag)
-      break;
+    if (Dag && isa<IntInit, StringInit>(RHS)) {
+      std::string Error;
+      auto ArgNo = getDagArgNoByKey(Dag, RHS, Error);
+      if (!ArgNo)
+        PrintFatalError(CurRec->getLoc(), "!getdagarg " + Error);
+
+      assert(*ArgNo < Dag->getNumArgs());
 
-    // Helper returning the specified argument.
-    auto getDagArgAsType = [](DagInit *Dag, unsigned Pos,
-                              RecTy *Type) -> Init * {
-      assert(Pos < Dag->getNumArgs());
-      Init *Arg = Dag->getArg(Pos);
+      Init *Arg = Dag->getArg(*ArgNo);
       if (auto *TI = dyn_cast<TypedInit>(Arg))
-        if (!TI->getType()->typeIsConvertibleTo(Type))
+        if (!TI->getType()->typeIsConvertibleTo(getType()))
           return UnsetInit::get(Dag->getRecordKeeper());
       return Arg;
-    };
-
-    // Accessor by index
-    if (IntInit *Idx = dyn_cast<IntInit>(RHS)) {
-      int64_t Pos = Idx->getValue();
-      if (Pos < 0) {
-        // The index is negative.
-        PrintFatalError(CurRec->getLoc(), Twine("!getdagarg index ") +
-                                              std::to_string(Pos) +
-                                              Twine(" is negative"));
-      }
-      if (Pos >= Dag->getNumArgs()) {
-        // The index is out-of-range.
-        PrintFatalError(CurRec->getLoc(),
-                        Twine("!getdagarg index ") + std::to_string(Pos) +
-                            " is out of range (dag has " +
-                            std::to_string(Dag->getNumArgs()) + " arguments)");
-      }
-      return getDagArgAsType(Dag, Pos, getType());
-    }
-    // Accessor by name
-    if (StringInit *Key = dyn_cast<StringInit>(RHS)) {
-      for (unsigned i = 0, e = Dag->getNumArgs(); i < e; ++i) {
-        StringInit *ArgName = Dag->getArgName(i);
-        if (!ArgName || ArgName->getValue() != Key->getValue())
-          continue;
-        // Found
-        return getDagArgAsType(Dag, i, getType());
-      }
-      // The key is not found.
-      PrintFatalError(CurRec->getLoc(), Twine("!getdagarg key '") +
-                                            Key->getValue() +
-                                            Twine("' is not found"));
     }
     break;
   }
   case GETDAGNAME: {
     DagInit *Dag = dyn_cast<DagInit>(LHS);
     IntInit *Idx = dyn_cast<IntInit>(RHS);
     if (Dag && Idx) {
       int64_t Pos = Idx->getValue();
       if (Pos < 0 || Pos >= Dag->getNumArgs()) {
if (LHSs && MHSs && RHSi) {
                        std::to_string(Start));
       auto I = LHSs->getValue().find(MHSs->getValue(), Start);
       if (I == std::string::npos)
         return IntInit::get(RK, -1);
       return IntInit::get(RK, I);
     }
     break;
   }
+
+  case SETDAGARG: {
+    DagInit *Dag = dyn_cast<DagInit>(LHS);
+    if (Dag && isa<IntInit, StringInit>(MHS)) {
+      std::string Error;
+      auto ArgNo = getDagArgNoByKey(Dag, MHS, Error);
+      if (!ArgNo)
+        PrintFatalError(CurRec->getLoc(), "!setdagarg " + Error);
+
+      assert(*ArgNo < Dag->getNumArgs());
+
+      SmallVector<Init *, 8> Args(Dag->getArgs());
+      SmallVector<StringInit *, 8> Names(Dag->getArgNames());
+      Args[*ArgNo] = RHS;
+      return DagInit::get(Dag->getOperator(), Dag->getName(), Args, Names);
+    }
+    break;
+  }
+
+  case SETDAGNAME: {
+    DagInit *Dag = dyn_cast<DagInit>(LHS);
+    if (Dag && isa<IntInit, StringInit>(MHS)) {
+      std::string Error;
+      auto ArgNo = getDagArgNoByKey(Dag, MHS, Error);
+      if (!ArgNo)
+        PrintFatalError(CurRec->getLoc(), "!setdagname " + Error);
+
+      assert(*ArgNo < Dag->getNumArgs());
+
+      SmallVector<Init *, 8> Args(Dag->getArgs());
+      SmallVector<StringInit *, 8> Names(Dag->getArgNames());
+      Names[*ArgNo] = dyn_cast<StringInit>(RHS);
+      return DagInit::get(Dag->getOperator(), Dag->getName(), Args, Names);
+    }
+    break;
+  }
   }
 
   return const_cast<TernOpInit *>(this);
 }
 
 Init *TernOpInit::resolveReferences(Resolver &R) const {
   Init *lhs = LHS->resolveReferences(R);
 
   if (getOpcode() == IF && lhs != LHS) {
     if (IntInit *Value = dyn_cast_or_null<IntInit>(
             lhs->convertInitializerTo(IntRecTy::get(getRecordKeeper())))) {
       // Short-circuit
       if (Value->getValue())
         return MHS->resolveReferences(R);
       return RHS->resolveReferences(R);
     }
   }
std::string TernOpInit::getAsString() const {
   switch (getOpcode()) {
   case DAG: Result = "!dag"; break;
   case FILTER: Result = "!filter"; UnquotedLHS = true; break;
   case FOREACH: Result = "!foreach"; UnquotedLHS = true; break;
   case IF: Result = "!if"; break;
   case SUBST: Result = "!subst"; break;
   case SUBSTR: Result = "!substr"; break;
   case FIND: Result = "!find"; break;
+  case SETDAGARG:
+    Result = "!setdagarg";
+    break;
+  case SETDAGNAME:
+    Result = "!setdagname";
+    break;
   }
   return (Result + "(" +
           (UnquotedLHS ? LHS->getAsUnquotedString() : LHS->getAsString()) +
           ", " + MHS->getAsString() + ", " + RHS->getAsString() + ")");
 }
 
 static void ProfileFoldOpInit(FoldingSetNodeID &ID, Init *Start, Init *List,
                               Init *A, Init *B, Init *Expr, RecTy *Type) {

 
 Record *DagInit::getOperatorAsDef(ArrayRef<SMLoc> Loc) const {
   if (DefInit *DefI = dyn_cast<DefInit>(Val))
     return DefI->getDef();
   PrintFatalError(Loc, "Expected record as operator");
   return nullptr;
 }
 
+std::optional<unsigned> DagInit::getArgNo(StringRef Name) const {
+  for (unsigned i = 0, e = getNumArgs(); i < e; ++i) {
+    StringInit *ArgName = getArgName(i);
+    if (ArgName && ArgName->getValue() == Name)
+      return i;
+  }
+  return std::nullopt;
+}
+
 Init *DagInit::resolveReferences(Resolver &R) const {
   SmallVector<Init*, 8> NewArgs;
   NewArgs.reserve(arg_size());
   bool ArgsChanged = false;
   for (const Init *Arg : getArgs()) {
     Init *NewArg = Arg->resolveReferences(R);
     NewArgs.push_back(NewArg);
     ArgsChanged |= NewArg != Arg;

llvm/lib/TableGen/TGLexer.h

enum TokKind {
   XGetDagOp,
   XExists,
   XListRemove,
   XToLower,
   XToUpper,
   XRange,
   XGetDagArg,
   XGetDagName,
+  XSetDagArg,
+  XSetDagName,
 
   // Boolean literals.
   TrueVal,
   FalseVal,
 
   // Integer value.
   IntVal,
 

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind =
           .Case("strconcat", tgtok::XStrConcat)
           .Case("interleave", tgtok::XInterleave)
           .Case("substr", tgtok::XSubstr)
           .Case("find", tgtok::XFind)
           .Cases("setdagop", "setop", tgtok::XSetDagOp) // !setop is deprecated.
           .Cases("getdagop", "getop", tgtok::XGetDagOp) // !getop is deprecated.
           .Case("getdagarg", tgtok::XGetDagArg)
           .Case("getdagname", tgtok::XGetDagName)
+          .Case("setdagarg", tgtok::XSetDagArg)
+          .Case("setdagname", tgtok::XSetDagName)
           .Case("exists", tgtok::XExists)
           .Case("tolower", tgtok::XToLower)
           .Case("toupper", tgtok::XToUpper)
           .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
 

llvm/lib/TableGen/TGParser.cpp

case tgtok::XSetDagOp: { // Value ::= !binop '(' Value ',' Value ')'
     return nullptr;
   }
 
   case tgtok::XForEach:
   case tgtok::XFilter: {
     return ParseOperationForEachFilter(CurRec, ItemType);
   }
 
+  case tgtok::XSetDagArg:
+  case tgtok::XSetDagName:
   case tgtok::XDag:
   case tgtok::XIf:
   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:
       Code = TernOpInit::DAG;
       Type = DagRecTy::get(Records);
       ItemType = nullptr;
       break;
     case tgtok::XIf:
       Code = TernOpInit::IF;
       break;
     case tgtok::XSubst:
       Code = TernOpInit::SUBST;
       break;
+    case tgtok::XSetDagArg:
+      Code = TernOpInit::SETDAGARG;
+      Type = DagRecTy::get(Records);
+      ItemType = nullptr;
+      break;
+    case tgtok::XSetDagName:
+      Code = TernOpInit::SETDAGNAME;
+      Type = DagRecTy::get(Records);
+      ItemType = nullptr;
+      break;
     }
     if (!consume(tgtok::l_paren)) {
       TokError("expected '(' after ternary operator");
       return nullptr;
     }
 
     Init *LHS = ParseValue(CurRec);
     if (!LHS) return nullptr;
case tgtok::XSubst: {
       TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
       if (!RHSt) {
         TokError("could not get type for !subst");
         return nullptr;
       }
       Type = RHSt->getType();
       break;
     }
+    case tgtok::XSetDagArg: {
+      TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
+      if (!MHSt || !isa<IntRecTy, StringRecTy>(MHSt->getType())) {
+        Error(MHSLoc, Twine("expected integer index or string name, got ") +
+                          (MHSt ? ("type '" + MHSt->getType()->getAsString())
+                                : ("'" + MHS->getAsString())) +
+                          "'");
+        return nullptr;
+      }
+      break;
+    }
+    case tgtok::XSetDagName: {
+      TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
+      if (!MHSt || !isa<IntRecTy, StringRecTy>(MHSt->getType())) {
+        Error(MHSLoc, Twine("expected integer index or string name, got ") +
+                          (MHSt ? ("type '" + MHSt->getType()->getAsString())
+                                : ("'" + MHS->getAsString())) +
+                          "'");
+        return nullptr;
+      }
+      TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
+      // The name could be a string or unset.
+      if (RHSt && !isa<StringRecTy>(RHSt->getType())) {
+        Error(RHSLoc, Twine("expected string or unset name, got type '") +
+                          RHSt->getType()->getAsString() + "'");
+        return nullptr;
+      }
+      break;
+    }
     }
     return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
   }
 
   case tgtok::XSubstr:
     return ParseOperationSubstr(CurRec, ItemType);
 
   case tgtok::XFind:
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::XListSplat:
   case tgtok::XListRemove:
   case tgtok::XRange:
   case tgtok::XStrConcat:
   case tgtok::XInterleave:
   case tgtok::XGetDagArg:
   case tgtok::XGetDagName:
   case tgtok::XSetDagOp: // Value ::= !binop '(' Value ',' Value ')'
+  case tgtok::XSetDagArg:
+  case tgtok::XSetDagName:
   case tgtok::XIf:
   case tgtok::XCond:
   case tgtok::XFoldl:
   case tgtok::XForEach:
   case tgtok::XFilter:
   case tgtok::XSubst:
   case tgtok::XSubstr:
   case tgtok::XFind: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'

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
 // RUN: not llvm-tblgen -DERROR4 %s 2>&1 | FileCheck --check-prefix=ERROR4 %s
 // RUN: not llvm-tblgen -DERROR5 %s 2>&1 | FileCheck --check-prefix=ERROR5 %s
 // RUN: not llvm-tblgen -DERROR6 %s 2>&1 | FileCheck --check-prefix=ERROR6 %s
+// RUN: not llvm-tblgen -DERROR7 %s 2>&1 | FileCheck --check-prefix=ERROR7 %s
+// RUN: not llvm-tblgen -DERROR8 %s 2>&1 | FileCheck --check-prefix=ERROR8 %s
+// RUN: not llvm-tblgen -DERROR9 %s 2>&1 | FileCheck --check-prefix=ERROR9 %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;
 
 class Super : Base;
#endif
 
   dag in5 = (foo foo:$a, bar:$b, foo:$c);
   // CHECK: OtherBase misMatchType2 = ?;
   OtherBase misMatchType2 = !getdagarg<OtherBase>(in5, 1);
 
   dag in6 = (foo alice:$a, bob:$b);
   // CHECK: Base base = bob;
   Base base = !getdagarg<Base>(in6, 1);
+
+  // CHECK: dag orig_set_val = (foo 1, 2:$a, "val":$b);
+  dag orig_set_val = !setdagarg(orig, 2, "val");
+  // CHECK: dag orig_set_val_by_name = (foo 1, 2:$a, "aval":$b);
+  dag orig_set_val_by_name = !setdagarg(orig, "b", "aval");
+  // CHECK: dag orig_set_dag_val = (foo 1, 2:$a, (bar foo:$p, qux:$q):$b);
+  dag orig_set_dag_val = !setdagarg(orig, "b", (bar foo:$p, qux:$q));
+  // CHECK: dag orig_clr_val = (foo 1, ?:$a, ?:$b);
+  dag orig_clr_val = !setdagarg(orig, "a", ?);
+  // CHECK: dag orig_set_name = (foo 1:$c, 2:$a, ?:$b);
+  dag orig_set_name = !setdagname(orig, 0, "c");
+  // CHECK: dag orig_clr_name = (foo 1, 2, ?:$b);
+  dag orig_clr_name = !setdagname(orig, 1, ?);
+  // CHECK: dag orig_rename = (foo 1, 2:$x, ?:$y);
+  dag orig_rename = !setdagname(!setdagname(orig, "a", "x"), "b", "y");
+
+#ifdef ERROR7
+  // ERROR7: error: !setdagarg index -1 is negative
+  dag orig_negative = !setdagarg(orig, -1, "val");
+#endif
+
+#ifdef ERROR8
+  // ERROR8: error: !setdagarg index 3 is out of range (dag has 3 arguments)
+  dag orig_out_of_range = !setdagarg(orig, 3, "val");
+#endif
+
+#ifdef ERROR9
+  // ERROR9: error: expected integer index or string name, got type 'Base'
+  dag orig_out_of_range = !setdagarg(orig, foo, (foo qux:$a));
+#endif
 }