[TableGen] : Extend !if semantics through new language feature !ifs

[javed.absar]

Summary

Currently, some TableGen expressions are forced to use multiple embedded '!if' which makes the the expression cumbersome. Below is an example (from an actual td file):

list<SubRegIndex> ret = !if(!eq(size, 2), ret2,
                                              !if(!eq(size, 3), ret3,
                                                  !if(!eq(size, 4), ret4,
                                                       !if(!eq(size, 8), ret8, ret16))));

This patch will allow such expession to be more easily written as:

list<SubRegIndex> ret =

!ifs(!eq(size, 2) : ret2,
      !eq(size, 3) : ret3,
      !eq(size, 4) : ret4,
      !eq(size, 8) : ret8,
      default: ret16);

The default can appear in the begining, end or anywhere within the !ifs.

The grammer of !ifs is :

SimpleValue ::= IFS '(' [Value ':' Value,]+ DEFAULT ':' Value ')'

We could call 'ifs' 'switch' although it is slightly different from C language switch as the case value is not a constant.
Some of the tests below are ported from !if as those check are required of !ifs as well.

`!ifs(cond1: val1, cond2 : val2, ..., default : valn)`

Instead of embedding !if inside !if which can get cumbersome, one can use !ifs.

!ifs returns 'val1' if the result of 'int' or 'bit' operator 'cond1' is nonzero.

Otherwise, checks 'cond2'. If 'cond2' is nonzero, returns 'val2', and so on.

If all conditions are zero, the default value 'valn' is returned.

The default value can appear anywhere, but there must be

one and only one default value. Below is an example to convert an integer 'x'

into string form:

 

string S =  !ifs(!lt(x,0) : "Negative",

                 !eq(x,0) : "zero",

                 !eq(x,1) : "one",

                 default  : "MoreThanOne");

[kristof.beyls]

docs/TableGen/LangIntro.rst

261–266

Right now, it seems "!ifs" is somewhat a mix of some syntactic sugar over nested ifs and a switch statement.
The syntax of the example below makes me instinctively read this as something akin a switch statement.
However, the semantics described above indicates clearly that order matters: the first nonzero condition matters.
If you want the logic of nested ifs, maybe it's easier to read to the non-expert Tablegen reader (which I guess is the majority of people reading Tablegen files) if the syntax still reflected nested ifs?

I wonder if it wouldn't be better overall to move to calling this "switch" rather than "ifs", but then also make it an error for more than 1 condition to be non-zero.
That way, the order wouldn't matter.
Would that actually be useful?

[javed.absar]

docs/TableGen/LangIntro.rst

261–266

I am fine with calling it 'switch' if that is more intuitive to the users. Making it an error for more than one condition to be true - I am not sure if users will like that restriction.

Other option could be to call it !cond( (test1, action1), (test2, action2)...) much like LISP cond - https://www.tutorialspoint.com/lisp/lisp_cond_construct.htm . It is an error if none of the conditions are true, and the 'default' can achieved by ending always with a true clause i.e. (1, actionN)

[hfinkel]

docs/TableGen/LangIntro.rst

261–266

FWIW, I like '!cond' better than '!ifs', although I like your original syntax matter than the more LISP-like syntax. Making it an error if none of the conditions are true, and there is no default, makes sense to me. I'd restrict default to appear last, unless there's some reason to do otherwise.

[javed.absar]

This comment has been deleted.

docs/TableGen/LangIntro.rst

261–266

Thanks Hal for the suggestion.
I will rework this patch to take following approach:

'!cond' '(' [ Value : Val ]+, DEFAULT: Value ')'

The default must be present and should be last.

[javed.absar]

Changes based on review comments. The new operator is now called '!cond', and 'default' must be the last clause.

[javed.absar]

Ping!

Hi Hal/Others:

I have changed the syntax from !ifs to '!cond' now, while retaining the others parts from original !ifs (instead of from LISP). Please let me know if changes are ok with you.

Thanks

[hfinkel]

include/llvm/Target/TargetInstrPredicate.td

220 ↗

(On Diff #179471)

This is necessary because "default" is now a keyword? Should we name it something else less likely to be used already... what about if we named this 'otherwise' instead of 'default'? Maybe just 'else' would be better? Limiting downstream churn and confusion seems worthwhile. If we have this many things to change upstream, I imagine there are even more downstream .td. files that would break.

[simon_tatham]

include/llvm/Target/TargetInstrPredicate.td

220 ↗

(On Diff #179471)

I was wondering if a nicer approach to the 'default' problem would be to default to the undefined value if no clause matches, since Tablegen does have that concept already.

That might be all you need in some cases (e.g. if you're confident that one of your explicit conditions should always match anyway). And if you wanted a default of your own you could just make the last argument pair read 1: my_def_value, in exactly the same way that users of Lisp cond often write the last clause as (t my-def-value). Then there's no need to define a new keyword.

If a particular user thinks it's clearer to write default, then perhaps that user could define default in a way that makes it evaluate to true! :-)

[greened]

include/llvm/Target/TargetInstrPredicate.td

220 ↗

(On Diff #179471)

I like Smon's suggestion here. I have a slight preference for a hard error if no condition matches rather than returning undefined. It think it's pretty common for developers to expect one of the conditions to match and if they don't they'll want a fast failure.

lib/TableGen/Record.cpp

1698

Rather than CaseRange, consider CondRange. CaseRange could be confusing to developers who look at this in the future, thinking it's a switch statement rather than a generalized if/condition.

[simon_tatham]

include/llvm/Target/TargetInstrPredicate.td

220 ↗

(On Diff #179471)

I hadn't actually considered the possibility of a hard error, but now you suggest it, I agree that it would be better, not least because it strictly increases the functionality. No other suggested design even offers the option of a hard error, and you're clearly right that it's something that at least some users are likely to want. So with your plan, a user can get a hard error if they want one, or put a default of their choice in front of it if they don't.

[javed.absar]

Hi all:
I have made the changes as requested. That is, removed explicit 'default' while sticking to overall syntax as before. I found that removing default in fact simplifies the implementation somewhat. Also, have split the tests to cleaner separate ones.

[simon_tatham]

docs/TableGen/LangIntro.rst

261

I've just remembered that docs/TableGen/LangRef.rst contains a BNF description of the entire TableGen grammar, which should be updated if you're adding a new !foo operator at all (it includes a list of them all in the production for BangOperator). In this case, your new operator doesn't even have the same syntax as the rest of them, because of the unprecedented colon that separates the halves of each case, so it'll need a whole extra grammar rule :-)

[javed.absar]

Added BNF grammer for !cond as suggested .

[javed.absar]

Ping!

[hfinkel]

LGTM

docs/TableGen/LangIntro.rst

``!empty(a)``
     An integer {0,1} indicating whether list 'a' is empty.
 
 ``!size(a)``
     An integer indicating the number of elements in list 'a'.
 
 ``!if(a,b,c)``
   'b' if the result of 'int' or 'bit' operator 'a' is nonzero, 'c' otherwise.
 
+``!ifs(condition1 : val1, condition2 : val2, ..., default : valn)``
+    Instead of embedding !if inside !if which can get cumbersome,
+    one can use !ifs. !ifs returns 'val1' if the result of 'int' or 'bit'
+    operator 'condition1' is nonzero. Otherwise, it checks 'condition2'.
+    If 'condition2' is nonzero, returns 'val2', and so on.
+    If all conditions are zero, the default value 'valn' is returned.
+
+    The default value can appear anywhere, but there must be
+    one and only one default value.
+    Below is an example to convert an integer 'x' into a string:
+
+    !ifs(!lt(x,0) : "Negative",
+         !eq(x,0) : "zero",
+         !eq(x,1) : "one,
+         default  : "MoreThanOne")
+
 ``!eq(a,b)``
     'bit 1' if string a is equal to string b, 0 otherwise.  This only operates
     on string, int and bit objects.  Use !cast<string> to compare other types of
     objects.
 
 ``!ne(a,b)``
     The negation of ``!eq(a,b)``.
 

include/llvm/TableGen/Record.h

enum InitKind : uint8_t {
     IK_FieldInit,
     IK_IntInit,
     IK_ListInit,
     IK_FirstOpInit,
     IK_BinOpInit,
     IK_TernOpInit,
     IK_UnOpInit,
     IK_LastOpInit,
+    IK_IfsOpInit,
     IK_FoldOpInit,
     IK_IsAOpInit,
     IK_StringInit,
     IK_VarInit,
     IK_VarListElementInit,
     IK_VarBitInit,
     IK_VarDefInit,
     IK_LastTypedInit,
bool isComplete() const override {
     return LHS->isComplete() && MHS->isComplete() && RHS->isComplete();
   }
 
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;
 };
 
+/// !ifs(condition1: value1, condition2: value2, ... ,default: value)
+/// Selects the first value for which corresponding condition is true.
+/// Otherwise returns the default value
+class IfsOpInit final : public TypedInit, public FoldingSetNode,
+                      public TrailingObjects<IfsOpInit, Init *> {
+  friend TrailingObjects;
+  unsigned NumCases;
+  Init *Default;
+  RecTy *RetType;
+
+  IfsOpInit(unsigned NC, Init *D, RecTy *Type)
+    : TypedInit(IK_IfsOpInit, Type),
+      NumCases(NC), Default(D), RetType(Type) {}
+
+  size_t numTrailingObjects(OverloadToken<Init *>) const {
+    return 2*NumCases;
+  }
+
+public:
+  IfsOpInit(const IfsOpInit &) = delete;
+  IfsOpInit &operator=(const IfsOpInit &) = delete;
+
+  static bool classof(const Init *I) {
+    return I->getKind() == IK_IfsOpInit;
+  }
+
+  static IfsOpInit *get(ArrayRef<Init*> C, ArrayRef<Init*> V,
+                        Init *D, RecTy *Type);
+
+  void Profile(FoldingSetNodeID &ID) const;
+
+  Init *getDefault() const { return Default; }
+  RecTy *getReturnType() const { return RetType; }
+
+  unsigned getNumCases() const { return NumCases; }
+
+  Init *getCase(unsigned Num) const {
+    assert(Num < NumCases && "Case number out of range!");
+    return getTrailingObjects<Init *>()[Num];
+  }
+
+  Init *getVal(unsigned Num) const {
+    assert(Num < NumCases && "Val number out of range!");
+    return getTrailingObjects<Init *>()[Num+NumCases];
+  }
+
+  ArrayRef<Init *> getCases() const {
+    return makeArrayRef(getTrailingObjects<Init *>(), NumCases);
+  }
+
+  ArrayRef<Init *> getVals() const {
+    return makeArrayRef(getTrailingObjects<Init *>()+NumCases, NumCases);
+  }
+
+  Init *Fold(Record *CurRec) const;
+
+  Init *resolveReferences(Resolver &R) const override;
+
+  bool isConcrete() const override;
+  std::string getAsString() const override;
+
+  using const_case_iterator = SmallVectorImpl<Init*>::const_iterator;
+  using const_val_iterator = SmallVectorImpl<Init*>::const_iterator;
+
+  inline const_case_iterator  arg_begin() const { return getCases().begin(); }
+  inline const_case_iterator  arg_end  () const { return getCases().end(); }
+
+  inline size_t              case_size () const { return NumCases; }
+  inline bool                case_empty() const { return NumCases == 0; }
+
+  inline const_val_iterator name_begin() const { return getVals().begin();}
+  inline const_val_iterator name_end  () const { return getVals().end(); }
+
+  inline size_t              val_size () const { return NumCases; }
+  inline bool                val_empty() const { return NumCases == 0; }
+
+  Init *getBit(unsigned Bit) const override;
+};
+
 /// !foldl (a, b, expr, start, lst) - Fold over a list.
 class FoldOpInit : public TypedInit, public FoldingSetNode {
 private:
   Init *Start;
   Init *List;
   Init *A;
   Init *B;
   Init *Expr;

lib/TableGen/Record.cpp

if (Def == CurRec)
                       Rec->getAsString() + "' is a forbidden self-reference");
     Init *FieldVal = Def->getValue(FieldName)->getValue();
     if (FieldVal->isComplete())
       return FieldVal;
   }
   return const_cast<FieldInit *>(this);
 }
 
+static void ProfileIfsOpInit(FoldingSetNodeID &ID,
+                             ArrayRef<Init *> CaseRange,
+                             ArrayRef<Init *> ValRange,
+                             const Init *Default, const RecTy *RetType) {
+  assert(CaseRange.size() == ValRange.size() &&
+         "Number of conditions and values must match (excl. default)!");
+  ID.AddPointer(Default);
+  ID.AddPointer(RetType);
+  ArrayRef<Init *>::iterator Case = CaseRange.begin();
+  ArrayRef<Init *>::iterator Val = ValRange.begin();
+
+  while (Case != CaseRange.end()) {
+    ID.AddPointer(*Case++);
+    ID.AddPointer(*Val++);
+  }
+}
+
+void IfsOpInit::Profile(FoldingSetNodeID &ID) const {
+  ProfileIfsOpInit(ID,
+      makeArrayRef(getTrailingObjects<Init *>(), NumCases),
+      makeArrayRef(getTrailingObjects<Init *>() + NumCases, NumCases),
+      Default, RetType);
+}
+
+IfsOpInit *
+IfsOpInit::get(ArrayRef<Init *> CaseRange, ArrayRef<Init *> ValRange,
+               Init *D, RecTy *Ty) {
+  assert(CaseRange.size() == ValRange.size() &&
+         "Number of conditions and values must match (excl. default)!");
+
+  static FoldingSet<IfsOpInit> ThePool;
+  FoldingSetNodeID ID;
+  ProfileIfsOpInit(ID, CaseRange, ValRange, D, Ty);
+
+  void *IP = nullptr;
+  if (IfsOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
+    return I;
+
+  void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(2*CaseRange.size()),
+                                 alignof(BitsInit));
+  IfsOpInit *I = new(Mem) IfsOpInit(CaseRange.size(), D, Ty);
+
+  std::uninitialized_copy(CaseRange.begin(), CaseRange.end(),
+                          I->getTrailingObjects<Init *>());
+  std::uninitialized_copy(ValRange.begin(), ValRange.end(),
+                          I->getTrailingObjects<Init *>()+CaseRange.size());
+  ThePool.InsertNode(I, IP);
+  return I;
+}
+
+Init *IfsOpInit::resolveReferences(Resolver &R) const {
+  SmallVector<Init*, 4> NewCases;
+  bool Changed = false;
+  for (const Init *Case : getCases()) {
+    Init *NewCase = Case->resolveReferences(R);
+    NewCases.push_back(NewCase);
+    Changed |= NewCase != Case;
+  }
+
+  SmallVector<Init*, 4> NewVals;
+  for (const Init *Val : getVals()) {
+    Init *NewVal = Val->resolveReferences(R);
+    NewVals.push_back(NewVal);
+    Changed |= NewVal != Val;
+  }
+
+  Init *NewD = Default->resolveReferences(R);
+  if (NewD != Default || Changed)
+    return (IfsOpInit::get(NewCases, NewVals, NewD,
+            getReturnType()))->Fold(R.getCurrentRecord());
+
+  return const_cast<IfsOpInit *>(this);
+}
+
+Init *IfsOpInit::Fold(Record *CurRec) const {
+  for ( unsigned i = 0; i < NumCases; ++i) {
+    Init *LHS = getCase(i);
+    Init *RHS = getVal(i);
+    if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
+            LHS->convertInitializerTo(IntRecTy::get()))) {
+      if (LHSi->getValue())
+        return RHS;
+    } else
+    return const_cast<IfsOpInit *>(this);
+  }
+  return Default;
+}
+
+bool IfsOpInit::isConcrete() const {
+  if (!Default->isConcrete())
+    return false;
+  for (const Init *Case : getCases()) {
+    if (!Case->isConcrete())
+      return false;
+  }
+  for (const Init *Val : getVals()) {
+    if (!Val->isConcrete())
+      return false;
+  }
+  return true;
+}
+
+std::string IfsOpInit::getAsString() const {
+  std::string Result = "!ifs(";
+  for (unsigned i = 0; i < getNumCases(); i++) {
+    Result += getCase(i)->getAsString() + ": ";
+    Result += getVal(i)->getAsString() + ", ";
+  }
+  return Result + "default: " + Default->getAsString() + ")";
+}
+
+Init *IfsOpInit::getBit(unsigned Bit) const {
+  return VarBitInit::get(const_cast<IfsOpInit *>(this), Bit);
+}
+
 static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, StringInit *VN,
                            ArrayRef<Init *> ArgRange,
                            ArrayRef<StringInit *> NameRange) {
   ID.AddPointer(V);
   ID.AddPointer(VN);
 
   ArrayRef<Init *>::iterator Arg = ArgRange.begin();
   ArrayRef<StringInit *>::iterator Name = NameRange.begin();

lib/TableGen/TGLexer.h

enum TokKind {
     less, greater,      // < >
     colon, semi,        // : ;
     comma, period,      // , .
     equal, question,    // = ?
     paste,              // #
 
     // Keywords.
     Bit, Bits, Class, Code, Dag, Def, Foreach, Defm, Field, In, Int, Let, List,
-    MultiClass, String, Defset,
+    MultiClass, String, Defset, Default,
 
     // !keywords.
     XConcat, XADD, XAND, XOR, XSRA, XSRL, XSHL, XListConcat, XStrConcat, XCast,
-    XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty, XIf, XEq, XIsA, XDag,
+    XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty, XIf, XIfs, XEq, XIsA, XDag,
     XNe, XLe, XLt, XGe, XGt,
 
     // Integer value.
     IntVal,
 
     // Binary constant.  Note that these are sized according to the number of
     // bits given.
     BinaryIntVal,

lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind = StringSwitch<tgtok::TokKind>(Str)
     .Case("def", tgtok::Def)
     .Case("foreach", tgtok::Foreach)
     .Case("defm", tgtok::Defm)
     .Case("defset", tgtok::Defset)
     .Case("multiclass", tgtok::MultiClass)
     .Case("field", tgtok::Field)
     .Case("let", tgtok::Let)
     .Case("in", tgtok::In)
+    .Case("default", tgtok::Default)
     .Default(tgtok::Id);
 
   if (Kind == tgtok::Id)
     CurStrVal.assign(Str.begin(), Str.end());
   return Kind;
 }
 
 /// LexInclude - We just read the "include" token.  Get the string token that
tgtok::TokKind Kind =
     StringSwitch<tgtok::TokKind>(StringRef(Start, CurPtr - Start))
     .Case("eq", tgtok::XEq)
     .Case("ne", tgtok::XNe)
     .Case("le", tgtok::XLe)
     .Case("lt", tgtok::XLt)
     .Case("ge", tgtok::XGe)
     .Case("gt", tgtok::XGt)
     .Case("if", tgtok::XIf)
+    .Case("ifs", tgtok::XIfs)
     .Case("isa", tgtok::XIsA)
     .Case("head", tgtok::XHead)
     .Case("tail", tgtok::XTail)
     .Case("size", tgtok::XSize)
     .Case("con", tgtok::XConcat)
     .Case("dag", tgtok::XDag)
     .Case("add", tgtok::XADD)
     .Case("and", tgtok::XAND)

lib/TableGen/TGParser.h

void ParseDagArgList(
       SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result,
       Record *CurRec);
   bool ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges);
   bool ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges);
   void ParseRangeList(SmallVectorImpl<unsigned> &Result);
   bool ParseRangePiece(SmallVectorImpl<unsigned> &Ranges);
   RecTy *ParseType();
   Init *ParseOperation(Record *CurRec, RecTy *ItemType);
+  Init *ParseOperationIfs(Record *CurRec, RecTy *ItemType);
   RecTy *ParseOperatorType();
   Init *ParseObjectName(MultiClass *CurMultiClass);
   Record *ParseClassID();
   MultiClass *ParseMultiClassID();
   bool ApplyLetStack(Record *CurRec);
   bool ApplyLetStack(RecordsEntry &Entry);
 };
 
 } // end namespace llvm
 
 #endif

lib/TableGen/TGParser.cpp

case tgtok::XSubst: {
       }
       Type = RHSt->getType();
       break;
     }
     }
     return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
   }
 
+  case tgtok::XIfs:
+    return ParseOperationIfs(CurRec, ItemType);
+
   case tgtok::XFoldl: {
     // Value ::= !foldl '(' Id ',' Id ',' Value ',' Value ',' Value ')'
     Lex.Lex(); // eat the operation
     if (Lex.getCode() != tgtok::l_paren) {
       TokError("expected '(' after !foldl");
       return nullptr;
     }
     Lex.Lex(); // eat the '('
if (Lex.getCode() != tgtok::greater) {
     TokError("expected type name for operator");
     return nullptr;
   }
   Lex.Lex();  // eat the >
 
   return Type;
 }
 
+Init *TGParser::ParseOperationIfs(Record *CurRec, RecTy *ItemType) {
+  Lex.Lex();  // eat the operation 'switch'
+  if (Lex.getCode() != tgtok::l_paren) {
+     TokError("expected '(' after !ifs operator");
+     return nullptr;
+  }
+  Lex.Lex();  // eat the '('
+
+  // Parse through odd number of Vals: '[[Case: Val,]+ default: Val)'
+  SmallVector<Init *, 4> Case;
+  SmallVector<Init *, 4> Val;
+  Init *Default = nullptr;
+  while (true) {
+    if (Lex.getCode() == tgtok::r_paren) {
+      Lex.Lex(); // eat the ')'
+      break;
+    }
+    if (Lex.getCode() == tgtok::comma) {
+      Lex.Lex(); // eat the possibly spurious comma or one following default
+      continue;
+    }
+
+    if (Lex.getCode() == tgtok::Default) {
+      if (Default) {
+        TokError("multiple defaults defined in !switch");
+        return nullptr;
+      }
+      Lex.Lex(); // eat the 'default'
+
+      if (Lex.getCode() != tgtok::colon) {
+        TokError("expected ':' after 'default' in !switch operator");
+        return nullptr;
+      }
+      Lex.Lex(); // eat the ':'
+      Default = ParseValue(CurRec, ItemType);
+      if (!Default)
+        return nullptr;
+     continue;
+    }
+
+    Init *V = ParseValue(CurRec);
+    if (!V)
+      return nullptr;
+    Case.push_back(V);
+
+    if (Lex.getCode() != tgtok::colon) {
+      TokError("expected ':'  following a condition in !switch operator");
+      return nullptr;
+    }
+    Lex.Lex(); // eat the ':'
+
+    V = ParseValue(CurRec, ItemType);
+    if (!V)
+      return nullptr;
+    Val.push_back(V);
+
+    if (Lex.getCode() == tgtok::r_paren) {
+      Lex.Lex(); // eat the ')'
+      break;
+    }
+
+    if (Lex.getCode() != tgtok::comma) {
+      TokError("expected ',' or ')' following a value in !ifs operator");
+      return nullptr;
+    }
+  }
+
+  if (Case.size() < 1) {
+    TokError("there should be at least 1 'condition : value' to the !switch operator");
+    return nullptr;
+  }
+  if (!Default){
+    TokError("no default defined for the !switch operator");
+    return nullptr;
+  }
+
+  // resolve type
+  RecTy *Type = nullptr;
+  for (Init *V : Val) {
+    RecTy *VTy = nullptr;
+    if (TypedInit *Vt = dyn_cast<TypedInit>(V))
+      VTy = Vt->getType();
+    if (BitsInit *Vbits = dyn_cast<BitsInit>(V))
+      VTy = BitsRecTy::get(Vbits->getNumBits());
+    if (isa<BitInit>(V))
+      VTy = BitRecTy::get();
+
+    if (Type == nullptr) {
+      if (!isa<UnsetInit>(V))
+        Type = VTy;
+    } else {
+      if (!isa<UnsetInit>(V)) {
+        RecTy *RType = resolveTypes(Type, VTy);
+        if (!RType) {
+          TokError(Twine("inconsistent types '") + Type->getAsString() +
+                         "' and '" + VTy->getAsString() + "' for !ifs");
+          return nullptr;
+        }
+        Type = RType;
+      }
+    }
+  }
+
+  RecTy *DTy = nullptr;
+  if (TypedInit *Dt = dyn_cast<TypedInit>(Default))
+    DTy = Dt->getType();
+  if (BitsInit *Dbits = dyn_cast<BitsInit>(Default))
+    DTy = BitsRecTy::get(Dbits->getNumBits());
+  if (isa<BitInit>(Default))
+    DTy = BitRecTy::get();
+
+  if (Type == nullptr) {
+    if (!isa<UnsetInit>(Default))
+        Type = DTy;
+    } else {
+      if (!isa<UnsetInit>(Default)) {
+        RecTy *RType = resolveTypes(Type, DTy);
+        if (!RType) {
+          TokError(Twine("inconsistent types '") + Type->getAsString() +
+                         "' and '" + DTy->getAsString() + "' for !ifs");
+          return nullptr;
+        }
+        Type = RType;
+    }
+  }
+
+  if (!Type) {
+    TokError("could not get type for !switch from its arguments");
+    return nullptr;
+  }
+
+  return IfsOpInit::get(Case, Val, Default, Type)->Fold(CurRec);
+}
+
 /// ParseSimpleValue - Parse a tblgen value.  This returns null on error.
 ///
 ///   SimpleValue ::= IDValue
 ///   SimpleValue ::= INTVAL
 ///   SimpleValue ::= STRVAL+
 ///   SimpleValue ::= CODEFRAGMENT
 ///   SimpleValue ::= '?'
 ///   SimpleValue ::= '{' ValueList '}'
 ///   SimpleValue ::= ID '<' ValueListNE '>'
 ///   SimpleValue ::= '[' ValueList ']'
 ///   SimpleValue ::= '(' IDValue DagArgList ')'
 ///   SimpleValue ::= CONCATTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= ADDTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SHLTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SRATOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SRLTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= LISTCONCATTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
+///   SimpleValue ::= IFS '(' [Value ':' Value,]+ DEFAULT ':' Value ')'
 ///
 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
                                  IDParseMode Mode) {
   Init *R = nullptr;
   switch (Lex.getCode()) {
   default: TokError("Unknown token when parsing a value"); break;
   case tgtok::paste:
     // This is a leading paste operation.  This is deprecated but
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::XNe:
   case tgtok::XLe:
   case tgtok::XLt:
   case tgtok::XGe:
   case tgtok::XGt:
   case tgtok::XListConcat:
   case tgtok::XStrConcat:   // Value ::= !binop '(' Value ',' Value ')'
   case tgtok::XIf:
+  case tgtok::XIfs:
   case tgtok::XFoldl:
   case tgtok::XForEach:
   case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     return ParseOperation(CurRec, ItemType);
   }
   }
 
   return R;

test/TableGen/ifs-empty-list-arg.td

+// RUN: llvm-tblgen %s
+// XFAIL: vg_leak
+
+class C<bit cond> {
+  list<int> X = !ifs(cond: [1, 2, 3], default: []);
+  list<int> Y = !ifs(cond: [], default: [4, 5, 6]);
+}

test/TableGen/ifs-type.td

+// RUN: not llvm-tblgen %s 2>&1 | FileCheck %s
+// XFAIL: vg_leak
+
+class A<int dummy> {}
+class B<int dummy> : A<dummy> {}
+class C<int dummy> : A<dummy> {}
+
+// CHECK: Value 'x' of type 'C' is incompatible with initializer '{{.*}}' of type 'A'
+class X<int cc, B b, C c> {
+  C x = !ifs(cc: b,
+             default: c);
+}

test/TableGen/ifs-usage.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// Check that !ifs picks the first true value
+// CHECK:       class A
+// CHECK-NEXT:  string S = !ifs(!eq(A:x, 10): "ten", !eq(A:x, 11): "eleven", !eq(A:x, 10): "TEN", !gt(A:x, 9): "MoreThanNine", default: "unknown");
+// CHECK: B1
+// CHECK-NEXT: string S = "unknown"
+// CHECK: B10
+// CHECK-NEXT: string S = "ten";
+// CHECK: def B11
+// CHECK-NEXT: string S = "eleven";
+// CHECK: def B12
+// CHECK-NEXT:  string S = "MoreThanNine";
+// CHECK: def B9
+// CHECK-NEXT: string S = "unknown"
+
+class A<int x> {
+  string S = !ifs(!eq(x,10) : "ten",
+                  !eq(x,11) : "eleven",
+                  !eq(x,10) : "TEN",
+                  !gt(x,9) : "MoreThanNine",
+                  default : "unknown");
+}
+def B1  : A<1>;
+def B9  : A<9>;
+def B10 : A<10>;
+def B11 : A<11>;
+def B12 : A<12>;
+
+
+// Check that order of default does not matter, by putting default first in the above test
+// CHECK: Bditto1
+// CHECK-NEXT: string S = "unknown"
+// CHECK: Bditto10
+// CHECK-NEXT: string S = "ten";
+// CHECK: def Bditto11
+// CHECK-NEXT: string S = "eleven";
+// CHECK: def Bditto12
+// CHECK-NEXT:  string S = "MoreThanNine";
+// CHECK: def Bditto9
+// CHECK-NEXT: string S = "unknown"
+class Aditto<int x> {
+  string S = !ifs(default : "unknown",
+                  !eq(x,10) : "ten",
+                  !eq(x,11) : "eleven",
+                  !eq(x,10) : "TEN",
+                  !gt(x,9) : "MoreThanNine");
+}
+
+def Bditto1  : Aditto<1>;
+def Bditto9  : Aditto<9>;
+def Bditto10 : Aditto<10>;
+def Bditto11 : Aditto<11>;
+def Bditto12 : Aditto<12>;

test/TableGen/ifs.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// Support for an `!ifs' operator as part of a `let' statement.
+// CHECK:      class C
+// CHECK-NEXT: bits<16> n = { ?, ?, ?, ?, !ifs({ C:y{3} }: 1, { C:y{2} }: { C:x{0} }, { C:y{1} }: { C:x{1} }, { C:y{0} }: { C:x{2} }, default: ?){0}, !ifs({ C:x{2} }: { C:y{3}, C:y{2} }, { C:x{1} }: { C:y{2}, C:y{1} }, { C:x{0} }: { C:y{1}, C:y{0} }, default: ?){1}, !ifs({ C:x{2} }: { C:y{3}, C:y{2} }, { C:x{1} }: { C:y{2}, C:y{1} }, { C:x{0} }: { C:y{1}, C:y{0} }, default: ?){0}, !ifs({ C:x{2} }: { 0, 1, 0 }, default: { 1, 1, 0 }){2}, !ifs({ C:x{2} }: { 0, 1, 0 }, default: { 1, 1, 0 }){1}, !ifs({ C:x{2} }: { 0, 1, 0 }, default: { 1, 1, 0 }){0}, !ifs({ C:x{1} }: { C:y{3}, C:y{2} }, default: { 0, 1 }){1}, !ifs({ C:x{1} }: { C:y{3}, C:y{2} }, default: { 0, 1 }){0}, !ifs({ C:x{0} }: { C:y{3}, C:y{2}, C:y{1}, C:y{0} }, default: { C:z, C:y{2}, C:y{1}, C:y{0} }){3}, !ifs({ C:x{0} }: { C:y{3}, C:y{2}, C:y{1}, C:y{0} }, default: { C:z, C:y{2}, C:y{1}, C:y{0} }){2}, !ifs({ C:x{0} }: { C:y{3}, C:y{2}, C:y{1}, C:y{0} }, default: { C:z, C:y{2}, C:y{1}, C:y{0} }){1}, !ifs({ C:x{0} }: { C:y{3}, C:y{2}, C:y{1}, C:y{0} }, default: { C:z, C:y{2}, C:y{1}, C:y{0} }){0} };
+
+class C<bits<3> x, bits<4> y, bit z> {
+  bits<16> n;
+
+  let n{11}  = !ifs(y{3}: 1,
+                    y{2}: x{0},
+                    y{1}: x{1},
+                    y{0}: x{2},
+                    default :?);
+  let n{10-9}= !ifs(x{2}: y{3-2},
+                    x{1}: y{2-1},
+                    x{0}: y{1-0},
+                    default: ?);
+  let n{8-6} = !ifs(x{2}: 0b010, default: 0b110);
+  let n{5-4} = !ifs(x{1}: y{3-2},default:  {0, 1});
+  let n{3-0} = !ifs(x{0}: y{3-0}, default: {z, y{2}, y{1}, y{0}});
+}
+
+def C1 : C<{1, 0, 1}, {0, 1, 0, 1}, 0>;
+def C2 : C<{0, 1, 0}, {1, 0, 1, 0}, 1>;
+def C3 : C<{0, 0, 0}, {1, 0, 1, 0}, 0>;
+def C4 : C<{0, 0, 0}, {0, 0, 0, 0}, 0>;
+
+// CHECK: def C1
+// CHECK-NEXT: bits<16> n = { ?, ?, ?, ?, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 };
+// CHECK: def C2
+// CHECK-NEXT: bits<16> n = { ?, ?, ?, ?, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0 };
+// CHECK: def C3
+// CHECK-NEXT: bits<16> n = { ?, ?, ?, ?, 1, ?, ?, 1, 1, 0, 0, 1, 0, 0, 1, 0 };
+// CHECK: def C4
+// CHECK-NEXT: bits<16> n = { ?, ?, ?, ?, ?, ?, ?, 1, 1, 0, 0, 1, 0, 0, 0, 0 };
+
+class S<int s> {
+  bits<2> val = !ifs(!eq(s, 8):  {0, 0},
+                    !eq(s, 16): 0b01,
+                    !eq(s, 32): 2,
+                    !eq(s, 64): {1, 1},
+                    default: ?);
+}
+
+def D8  : S<8>;
+def D16 : S<16>;
+def D32 : S<32>;
+def D64 : S<64>;
+def D128: S<128>;
+// CHECK: def D128
+// CHECK-NEXT: bits<2> val = { ?, ? };
+// CHECK: def D16
+// CHECK-NEXT: bits<2> val = { 0, 1 };
+// CHECK: def D32
+// CHECK-NEXT: bits<2> val = { 1, 0 };
+// CHECK: def D64
+// CHECK-NEXT: bits<2> val = { 1, 1 };
+// CHECK: def D8
+// CHECK-NEXT: bits<2> val = { 0, 0 };
+
+// Make sure !ifs gets propagated across multiple layers of inheritance.
+class getInt<int c> {
+  int ret = !ifs(c: 0, default: 1);
+}
+class I1<int c> {
+  int i = getInt<c>.ret;
+}
+class I2<int c> : I1<c>;
+
+// CHECK: def DI1 {     // I1
+// CHECK-NEXT: int i = 0;
+def DI1: I1<1>;
+
+// CHECK: def DI2 {     // I1 I2
+// CHECK-NEXT: int i = 0;
+def DI2: I2<1>;
+
+// Check that !ifs with operands of different subtypes can initialize a
+// supertype variable.
+//
+// CHECK: def EXd1 {
+// CHECK:   E x = E1d;
+// CHECK: }
+//
+// CHECK: def EXd2 {
+// CHECK:   E x = E2d;
+// CHECK: }
+class E<int dummy> {}
+class E1<int dummy> : E<dummy> {}
+class E2<int dummy> : E<dummy> {}
+
+class EX<int cc, E1 b, E2 c> {
+  E x = !ifs(cc: b, default: c);
+}
+
+def E1d : E1<0>;
+def E2d : E2<0>;
+
+def EXd1 : EX<1, E1d, E2d>;
+def EXd2 : EX<0, E1d, E2d>;
+
+// CHECK:      def One
+// CHECK-NEXT: list<int> first = [1, 2, 3];
+// CHECK-NEXT: list<int> rest = [1, 2, 3];
+
+// CHECK:      def OneB
+// CHECK-NEXT: list<int> vals = [1, 2, 3];
+
+// CHECK:      def Two
+// CHECK-NEXT: list<int> first = [1, 2, 3];
+// CHECK-NEXT: list<int> rest = [4, 5, 6];
+
+// CHECK:      def TwoB
+// CHECK-NEXT: list<int> vals = [4, 5, 6];
+
+class A<list<list<int>> vals> {
+  list<int> first = vals[0];
+  list<int> rest  = !ifs(!empty(!tail(vals)): vals[0],
+                         default            : vals[1]);
+}
+
+def One : A<[[1,2,3]]>;
+def Two : A<[[1,2,3], [4,5,6]]>;
+
+class B<list<int> v> {
+  list<int> vals = v;
+}
+
+class BB<list<list<int>> vals> : B<!ifs(!empty(!tail(vals)): vals[0], default: vals[1])>;
+class BBB<list<list<int>> vals> : BB<vals>;
+
+def OneB : BBB<[[1,2,3]]>;
+def TwoB : BBB<[[1,2,3],[4,5,6]]>;

test/TableGen/ifsbit.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+// CHECK: a = 6
+// CHECK: a = 5
+
+class A<bit b = 1> {
+  int a = !ifs(b: 5, default: 6);
+  bit c = !ifs(b: 0, default: 1);
+  bits<1> d = !ifs(b: 0, default: 1);
+}
+
+def X : A<0>;
+def Y : A;