/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp

Bug Summary

File:	llvm/lib/TableGen/TGParser.cpp
Warning:	line 1788, column 38 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name TGParser.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-11/lib/clang/11.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/lib/TableGen -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-11/lib/clang/11.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/lib/TableGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-03-09-184146-41876-1 -x c++ /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp
1//===- TGParser.cpp - Parser for TableGen Files ---------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Implement the Parser for TableGen.
10//
11//===----------------------------------------------------------------------===//

13#include "TGParser.h"
14#include "llvm/ADT/None.h"
15#include "llvm/ADT/STLExtras.h"
16#include "llvm/ADT/SmallVector.h"
17#include "llvm/ADT/StringExtras.h"
18#include "llvm/Config/llvm-config.h"
19#include "llvm/Support/Casting.h"
20#include "llvm/Support/Compiler.h"
21#include "llvm/Support/ErrorHandling.h"
22#include "llvm/Support/raw_ostream.h"
23#include "llvm/TableGen/Record.h"
24#include <algorithm>
25#include <cassert>
26#include <cstdint>

28using namespace llvm;

30//===----------------------------------------------------------------------===//
31// Support Code for the Semantic Actions.
32//===----------------------------------------------------------------------===//

34namespace llvm {

36struct SubClassReference {
SMRange RefRange;
Record *Rec;
SmallVector<Init*, 4> TemplateArgs;

SubClassReference() : Rec(nullptr) {}

bool isInvalid() const { return Rec == nullptr; }
44};

46struct SubMultiClassReference {
SMRange RefRange;
MultiClass *MC;
SmallVector<Init*, 4> TemplateArgs;

SubMultiClassReference() : MC(nullptr) {}

bool isInvalid() const { return MC == nullptr; }
void dump() const;
55};

57#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
58LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void SubMultiClassReference::dump() const {
errs() << "Multiclass:\n";

MC->dump();

errs() << "Template args:\n";
for (Init *TA : TemplateArgs)
  TA->dump();
66}
67#endif

69} // end namespace llvm

71static bool checkBitsConcrete(Record &R, const RecordVal &RV) {
BitsInit *BV = cast<BitsInit>(RV.getValue());
for (unsigned i = 0, e = BV->getNumBits(); i != e; ++i) {
  Init *Bit = BV->getBit(i);
  bool IsReference = false;
  if (auto VBI = dyn_cast<VarBitInit>(Bit)) {
    if (auto VI = dyn_cast<VarInit>(VBI->getBitVar())) {
      if (R.getValue(VI->getName()))
        IsReference = true;
    }
  } else if (isa<VarInit>(Bit)) {
    IsReference = true;
  }
  if (!(IsReference || Bit->isConcrete()))
    return false;
}
return true;
88}

90static void checkConcrete(Record &R) {
for (const RecordVal &RV : R.getValues()) {
  // HACK: Disable this check for variables declared with 'field'. This is
  // done merely because existing targets have legitimate cases of
  // non-concrete variables in helper defs. Ideally, we'd introduce a
  // 'maybe' or 'optional' modifier instead of this.
  if (RV.getPrefix())
    continue;

  if (Init *V = RV.getValue()) {
    bool Ok = isa<BitsInit>(V) ? checkBitsConcrete(R, RV) : V->isConcrete();
    if (!Ok) {
      PrintError(R.getLoc(),
                 Twine("Initializer of '") + RV.getNameInitAsString() +
                 "' in '" + R.getNameInitAsString() +
                 "' could not be fully resolved: " +
                 RV.getValue()->getAsString());
    }
  }
}
110}

112/// Return an Init with a qualifier prefix referring
113/// to CurRec's name.
114static Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
                      Init *Name, StringRef Scoper) {
Init *NewName =
    BinOpInit::getStrConcat(CurRec.getNameInit(), StringInit::get(Scoper));
NewName = BinOpInit::getStrConcat(NewName, Name);
if (CurMultiClass && Scoper != "::") {
  Init *Prefix = BinOpInit::getStrConcat(CurMultiClass->Rec.getNameInit(),
                                         StringInit::get("::"));
  NewName = BinOpInit::getStrConcat(Prefix, NewName);
}

if (BinOpInit *BinOp = dyn_cast<BinOpInit>(NewName))
  NewName = BinOp->Fold(&CurRec);
return NewName;
128}

130/// Return the qualified version of the implicit 'NAME' template argument.
131static Init *QualifiedNameOfImplicitName(Record &Rec,
                                       MultiClass *MC = nullptr) {
return QualifyName(Rec, MC, StringInit::get("NAME"), MC ? "::" : ":");
134}

136static Init *QualifiedNameOfImplicitName(MultiClass *MC) {
return QualifiedNameOfImplicitName(MC->Rec, MC);
138}

140bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
if (!CurRec)
  CurRec = &CurMultiClass->Rec;

if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) {
  // The value already exists in the class, treat this as a set.
  if (ERV->setValue(RV.getValue()))
    return Error(Loc, "New definition of '" + RV.getName() + "' of type '" +
                 RV.getType()->getAsString() + "' is incompatible with " +
                 "previous definition of type '" +
                 ERV->getType()->getAsString() + "'");
} else {
  CurRec->addValue(RV);
}
return false;
155}

157/// SetValue -
158/// Return true on error, false on success.
159bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
                      ArrayRef<unsigned> BitList, Init *V,
                      bool AllowSelfAssignment) {
if (!V) return false;

if (!CurRec) CurRec = &CurMultiClass->Rec;

RecordVal *RV = CurRec->getValue(ValName);
if (!RV)
  return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
               "' unknown!");

// Do not allow assignments like 'X = X'.  This will just cause infinite loops
// in the resolution machinery.
if (BitList.empty())
  if (VarInit *VI = dyn_cast<VarInit>(V))
    if (VI->getNameInit() == ValName && !AllowSelfAssignment)
      return Error(Loc, "Recursion / self-assignment forbidden");

// If we are assigning to a subset of the bits in the value... then we must be
// assigning to a field of BitsRecTy, which must have a BitsInit
// initializer.
//
if (!BitList.empty()) {
  BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue());
  if (!CurVal)
    return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
                 "' is not a bits type");

  // Convert the incoming value to a bits type of the appropriate size...
  Init *BI = V->getCastTo(BitsRecTy::get(BitList.size()));
  if (!BI)
    return Error(Loc, "Initializer is not compatible with bit range");

  SmallVector<Init *, 16> NewBits(CurVal->getNumBits());

  // Loop over bits, assigning values as appropriate.
  for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
    unsigned Bit = BitList[i];
    if (NewBits[Bit])
      return Error(Loc, "Cannot set bit #" + Twine(Bit) + " of value '" +
                   ValName->getAsUnquotedString() + "' more than once");
    NewBits[Bit] = BI->getBit(i);
  }

  for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
    if (!NewBits[i])
      NewBits[i] = CurVal->getBit(i);

  V = BitsInit::get(NewBits);
}

if (RV->setValue(V)) {
  std::string InitType;
  if (BitsInit *BI = dyn_cast<BitsInit>(V))
    InitType = (Twine("' of type bit initializer with length ") +
                Twine(BI->getNumBits())).str();
  else if (TypedInit *TI = dyn_cast<TypedInit>(V))
    InitType = (Twine("' of type '") + TI->getType()->getAsString()).str();
  return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
                        "' of type '" + RV->getType()->getAsString() +
                        "' is incompatible with initializer '" +
                        V->getAsString() + InitType + "'");
}
return false;
224}

226/// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
227/// args as SubClass's template arguments.
228bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
Record *SC = SubClass.Rec;
// Add all of the values in the subclass into the current class.
for (const RecordVal &Val : SC->getValues())
  if (AddValue(CurRec, SubClass.RefRange.Start, Val))
    return true;

ArrayRef<Init *> TArgs = SC->getTemplateArgs();

// Ensure that an appropriate number of template arguments are specified.
if (TArgs.size() < SubClass.TemplateArgs.size())
  return Error(SubClass.RefRange.Start,
               "More template args specified than expected");

// Loop over all of the template arguments, setting them to the specified
// value or leaving them as the default if necessary.
MapResolver R(CurRec);

for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
  if (i < SubClass.TemplateArgs.size()) {
    // If a value is specified for this template arg, set it now.
    if (SetValue(CurRec, SubClass.RefRange.Start, TArgs[i],
                 None, SubClass.TemplateArgs[i]))
      return true;
  } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
    return Error(SubClass.RefRange.Start,
                 "Value not specified for template argument #" +
                 Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
                 ") of subclass '" + SC->getNameInitAsString() + "'!");
  }

  R.set(TArgs[i], CurRec->getValue(TArgs[i])->getValue());

  CurRec->removeValue(TArgs[i]);
}

Init *Name;
if (CurRec->isClass())
  Name =
      VarInit::get(QualifiedNameOfImplicitName(*CurRec), StringRecTy::get());
else
  Name = CurRec->getNameInit();
R.set(QualifiedNameOfImplicitName(*SC), Name);

CurRec->resolveReferences(R);

// Since everything went well, we can now set the "superclass" list for the
// current record.
ArrayRef<std::pair<Record *, SMRange>> SCs = SC->getSuperClasses();
for (const auto &SCPair : SCs) {
  if (CurRec->isSubClassOf(SCPair.first))
    return Error(SubClass.RefRange.Start,
                 "Already subclass of '" + SCPair.first->getName() + "'!\n");
  CurRec->addSuperClass(SCPair.first, SCPair.second);
}

if (CurRec->isSubClassOf(SC))
  return Error(SubClass.RefRange.Start,
               "Already subclass of '" + SC->getName() + "'!\n");
CurRec->addSuperClass(SC, SubClass.RefRange);
return false;
289}

291bool TGParser::AddSubClass(RecordsEntry &Entry, SubClassReference &SubClass) {
if (Entry.Rec)
  return AddSubClass(Entry.Rec.get(), SubClass);

for (auto &E : Entry.Loop->Entries) {
  if (AddSubClass(E, SubClass))
    return true;
}

return false;
301}

303/// AddSubMultiClass - Add SubMultiClass as a subclass to
304/// CurMC, resolving its template args as SubMultiClass's
305/// template arguments.
306bool TGParser::AddSubMultiClass(MultiClass *CurMC,
                              SubMultiClassReference &SubMultiClass) {
MultiClass *SMC = SubMultiClass.MC;

ArrayRef<Init *> SMCTArgs = SMC->Rec.getTemplateArgs();
if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size())
  return Error(SubMultiClass.RefRange.Start,
               "More template args specified than expected");

// Prepare the mapping of template argument name to value, filling in default
// values if necessary.
SubstStack TemplateArgs;
for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) {
  if (i < SubMultiClass.TemplateArgs.size()) {
    TemplateArgs.emplace_back(SMCTArgs[i], SubMultiClass.TemplateArgs[i]);
  } else {
    Init *Default = SMC->Rec.getValue(SMCTArgs[i])->getValue();
    if (!Default->isComplete()) {
      return Error(SubMultiClass.RefRange.Start,
                   "value not specified for template argument #" + Twine(i) +
                       " (" + SMCTArgs[i]->getAsUnquotedString() +
                       ") of multiclass '" + SMC->Rec.getNameInitAsString() +
                       "'");
    }
    TemplateArgs.emplace_back(SMCTArgs[i], Default);
  }
}

TemplateArgs.emplace_back(
    QualifiedNameOfImplicitName(SMC),
    VarInit::get(QualifiedNameOfImplicitName(CurMC), StringRecTy::get()));

// Add all of the defs in the subclass into the current multiclass.
return resolve(SMC->Entries, TemplateArgs, false, &CurMC->Entries);
340}

342/// Add a record or foreach loop to the current context (global record keeper,
343/// current inner-most foreach loop, or multiclass).
344bool TGParser::addEntry(RecordsEntry E) {
assert(!E.Rec || !E.Loop)((!E.Rec || !E.Loop) ? static_cast<void> (0) : __assert_fail
 ("!E.Rec || !E.Loop", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 345, __PRETTY_FUNCTION__));

if (!Loops.empty()) {
  Loops.back()->Entries.push_back(std::move(E));
  return false;
}

if (E.Loop) {
  SubstStack Stack;
  return resolve(*E.Loop, Stack, CurMultiClass == nullptr,
                 CurMultiClass ? &CurMultiClass->Entries : nullptr);
}

if (CurMultiClass) {
  CurMultiClass->Entries.push_back(std::move(E));
  return false;
}

return addDefOne(std::move(E.Rec));
364}

366/// Resolve the entries in \p Loop, going over inner loops recursively
367/// and making the given subsitutions of (name, value) pairs.
368///
369/// The resulting records are stored in \p Dest if non-null. Otherwise, they
370/// are added to the global record keeper.
371bool TGParser::resolve(const ForeachLoop &Loop, SubstStack &Substs,
                     bool Final, std::vector<RecordsEntry> *Dest,
                     SMLoc *Loc) {
MapResolver R;
for (const auto &S : Substs)
  R.set(S.first, S.second);
Init *List = Loop.ListValue->resolveReferences(R);
auto LI = dyn_cast<ListInit>(List);
if (!LI) {
  if (!Final) {
    Dest->emplace_back(std::make_unique<ForeachLoop>(Loop.Loc, Loop.IterVar,
                                                List));
    return resolve(Loop.Entries, Substs, Final, &Dest->back().Loop->Entries,
                   Loc);
  }

  PrintError(Loop.Loc, Twine("attempting to loop over '") +
                            List->getAsString() + "', expected a list");
  return true;
}

bool Error = false;
for (auto Elt : *LI) {
  if (Loop.IterVar)
    Substs.emplace_back(Loop.IterVar->getNameInit(), Elt);
  Error = resolve(Loop.Entries, Substs, Final, Dest);
  if (Loop.IterVar)
    Substs.pop_back();
  if (Error)
    break;
}
return Error;
403}

405/// Resolve the entries in \p Source, going over loops recursively and
406/// making the given substitutions of (name, value) pairs.
407///
408/// The resulting records are stored in \p Dest if non-null. Otherwise, they
409/// are added to the global record keeper.
410bool TGParser::resolve(const std::vector<RecordsEntry> &Source,
                     SubstStack &Substs, bool Final,
                     std::vector<RecordsEntry> *Dest, SMLoc *Loc) {
bool Error = false;
for (auto &E : Source) {
  if (E.Loop) {
    Error = resolve(*E.Loop, Substs, Final, Dest);
  } else {
    auto Rec = std::make_unique<Record>(*E.Rec);
    if (Loc)
      Rec->appendLoc(*Loc);

    MapResolver R(Rec.get());
    for (const auto &S : Substs)
      R.set(S.first, S.second);
    Rec->resolveReferences(R);

    if (Dest)
      Dest->push_back(std::move(Rec));
    else
      Error = addDefOne(std::move(Rec));
  }
  if (Error)
    break;
}
return Error;
436}

438/// Resolve the record fully and add it to the record keeper.
439bool TGParser::addDefOne(std::unique_ptr<Record> Rec) {
if (Record *Prev = Records.getDef(Rec->getNameInitAsString())) {
  if (!Rec->isAnonymous()) {
    PrintError(Rec->getLoc(),
               "def already exists: " + Rec->getNameInitAsString());
    PrintNote(Prev->getLoc(), "location of previous definition");
    return true;
  }
  Rec->setName(Records.getNewAnonymousName());
}

Rec->resolveReferences();
checkConcrete(*Rec);

if (!isa<StringInit>(Rec->getNameInit())) {
  PrintError(Rec->getLoc(), Twine("record name '") +
                                Rec->getNameInit()->getAsString() +
                                "' could not be fully resolved");
  return true;
}

// If ObjectBody has template arguments, it's an error.
assert(Rec->getTemplateArgs().empty() && "How'd this get template args?")((Rec->getTemplateArgs().empty() && "How'd this get template args?"
) ? static_cast<void> (0) : __assert_fail ("Rec->getTemplateArgs().empty() && \"How'd this get template args?\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 461, __PRETTY_FUNCTION__));

for (DefsetRecord *Defset : Defsets) {
  DefInit *I = Rec->getDefInit();
  if (!I->getType()->typeIsA(Defset->EltTy)) {
    PrintError(Rec->getLoc(), Twine("adding record of incompatible type '") +
                                  I->getType()->getAsString() +
                                   "' to defset");
    PrintNote(Defset->Loc, "location of defset declaration");
    return true;
  }
  Defset->Elements.push_back(I);
}

Records.addDef(std::move(Rec));
return false;
477}

479//===----------------------------------------------------------------------===//
480// Parser Code
481//===----------------------------------------------------------------------===//

483/// isObjectStart - Return true if this is a valid first token for an Object.
484static bool isObjectStart(tgtok::TokKind K) {
return K == tgtok::Class || K == tgtok::Def || K == tgtok::Defm ||
       K == tgtok::Let || K == tgtok::MultiClass || K == tgtok::Foreach ||
       K == tgtok::Defset || K == tgtok::Defvar || K == tgtok::If;
488}

490/// ParseObjectName - If a valid object name is specified, return it. If no
491/// name is specified, return the unset initializer. Return nullptr on parse
492/// error.
493///   ObjectName ::= Value [ '#' Value ]*
494///   ObjectName ::= /*empty*/
495///
496Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) {
switch (Lex.getCode()) {
case tgtok::colon:
case tgtok::semi:
case tgtok::l_brace:
  // These are all of the tokens that can begin an object body.
  // Some of these can also begin values but we disallow those cases
  // because they are unlikely to be useful.
  return UnsetInit::get();
default:
  break;
}

Record *CurRec = nullptr;
if (CurMultiClass)
  CurRec = &CurMultiClass->Rec;

Init *Name = ParseValue(CurRec, StringRecTy::get(), ParseNameMode);
if (!Name)
  return nullptr;

if (CurMultiClass) {
  Init *NameStr = QualifiedNameOfImplicitName(CurMultiClass);
  HasReferenceResolver R(NameStr);
  Name->resolveReferences(R);
  if (!R.found())
    Name = BinOpInit::getStrConcat(VarInit::get(NameStr, StringRecTy::get()),
                                   Name);
}

return Name;
527}

529/// ParseClassID - Parse and resolve a reference to a class name.  This returns
530/// null on error.
531///
532///    ClassID ::= ID
533///
534Record *TGParser::ParseClassID() {
if (Lex.getCode() != tgtok::Id) {
  TokError("expected name for ClassID");
  return nullptr;
}

Record *Result = Records.getClass(Lex.getCurStrVal());
if (!Result) {
  std::string Msg("Couldn't find class '" + Lex.getCurStrVal() + "'");
  if (MultiClasses[Lex.getCurStrVal()].get())
    TokError(Msg + ". Use 'defm' if you meant to use multiclass '" +
             Lex.getCurStrVal() + "'");
  else
    TokError(Msg);
}

Lex.Lex();
return Result;
552}

554/// ParseMultiClassID - Parse and resolve a reference to a multiclass name.
555/// This returns null on error.
556///
557///    MultiClassID ::= ID
558///
559MultiClass *TGParser::ParseMultiClassID() {
if (Lex.getCode() != tgtok::Id) {
  TokError("expected name for MultiClassID");
  return nullptr;
}

MultiClass *Result = MultiClasses[Lex.getCurStrVal()].get();
if (!Result)
  TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'");

Lex.Lex();
return Result;
571}

573/// ParseSubClassReference - Parse a reference to a subclass or to a templated
574/// subclass.  This returns a SubClassRefTy with a null Record* on error.
575///
576///  SubClassRef ::= ClassID
577///  SubClassRef ::= ClassID '<' ValueList '>'
578///
579SubClassReference TGParser::
580ParseSubClassReference(Record *CurRec, bool isDefm) {
SubClassReference Result;
Result.RefRange.Start = Lex.getLoc();

if (isDefm) {
  if (MultiClass *MC = ParseMultiClassID())
    Result.Rec = &MC->Rec;
} else {
  Result.Rec = ParseClassID();
}
if (!Result.Rec) return Result;

// If there is no template arg list, we're done.
if (Lex.getCode() != tgtok::less) {
  Result.RefRange.End = Lex.getLoc();
  return Result;
}
Lex.Lex();  // Eat the '<'

if (Lex.getCode() == tgtok::greater) {
  TokError("subclass reference requires a non-empty list of template values");
  Result.Rec = nullptr;
  return Result;
}

ParseValueList(Result.TemplateArgs, CurRec, Result.Rec);
if (Result.TemplateArgs.empty()) {
  Result.Rec = nullptr;   // Error parsing value list.
  return Result;
}

if (Lex.getCode() != tgtok::greater) {
  TokError("expected '>' in template value list");
  Result.Rec = nullptr;
  return Result;
}
Lex.Lex();
Result.RefRange.End = Lex.getLoc();

return Result;
620}

622/// ParseSubMultiClassReference - Parse a reference to a subclass or to a
623/// templated submulticlass.  This returns a SubMultiClassRefTy with a null
624/// Record* on error.
625///
626///  SubMultiClassRef ::= MultiClassID
627///  SubMultiClassRef ::= MultiClassID '<' ValueList '>'
628///
629SubMultiClassReference TGParser::
630ParseSubMultiClassReference(MultiClass *CurMC) {
SubMultiClassReference Result;
Result.RefRange.Start = Lex.getLoc();

Result.MC = ParseMultiClassID();
if (!Result.MC) return Result;

// If there is no template arg list, we're done.
if (Lex.getCode() != tgtok::less) {
  Result.RefRange.End = Lex.getLoc();
  return Result;
}
Lex.Lex();  // Eat the '<'

if (Lex.getCode() == tgtok::greater) {
  TokError("subclass reference requires a non-empty list of template values");
  Result.MC = nullptr;
  return Result;
}

ParseValueList(Result.TemplateArgs, &CurMC->Rec, &Result.MC->Rec);
if (Result.TemplateArgs.empty()) {
  Result.MC = nullptr;   // Error parsing value list.
  return Result;
}

if (Lex.getCode() != tgtok::greater) {
  TokError("expected '>' in template value list");
  Result.MC = nullptr;
  return Result;
}
Lex.Lex();
Result.RefRange.End = Lex.getLoc();

return Result;
665}

667/// ParseRangePiece - Parse a bit/value range.
668///   RangePiece ::= INTVAL
669///   RangePiece ::= INTVAL '-' INTVAL
670///   RangePiece ::= INTVAL INTVAL
671bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges,
                             TypedInit *FirstItem) {
Init *CurVal = FirstItem;
if (!CurVal)
  CurVal = ParseValue(nullptr);

IntInit *II = dyn_cast_or_null<IntInit>(CurVal);
if (!II)
  return TokError("expected integer or bitrange");

int64_t Start = II->getValue();
int64_t End;

if (Start < 0)
  return TokError("invalid range, cannot be negative");

switch (Lex.getCode()) {
default:
  Ranges.push_back(Start);
  return false;
case tgtok::minus: {
  Lex.Lex(); // eat

  Init *I_End = ParseValue(nullptr);
  IntInit *II_End = dyn_cast_or_null<IntInit>(I_End);
  if (!II_End) {
    TokError("expected integer value as end of range");
    return true;
  }

  End = II_End->getValue();
  break;
}
case tgtok::IntVal: {
  End = -Lex.getCurIntVal();
  Lex.Lex();
  break;
}
}
if (End < 0)
  return TokError("invalid range, cannot be negative");

// Add to the range.
if (Start < End)
  for (; Start <= End; ++Start)
    Ranges.push_back(Start);
else
  for (; Start >= End; --Start)
    Ranges.push_back(Start);
return false;
721}

723/// ParseRangeList - Parse a list of scalars and ranges into scalar values.
724///
725///   RangeList ::= RangePiece (',' RangePiece)*
726///
727void TGParser::ParseRangeList(SmallVectorImpl<unsigned> &Result) {
// Parse the first piece.
if (ParseRangePiece(Result)) {
  Result.clear();
  return;
}
while (Lex.getCode() == tgtok::comma) {
  Lex.Lex();  // Eat the comma.

  // Parse the next range piece.
  if (ParseRangePiece(Result)) {
    Result.clear();
    return;
  }
}
742}

744/// ParseOptionalRangeList - Parse either a range list in <>'s or nothing.
745///   OptionalRangeList ::= '<' RangeList '>'
746///   OptionalRangeList ::= /*empty*/
747bool TGParser::ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges) {
if (Lex.getCode() != tgtok::less)
  return false;

SMLoc StartLoc = Lex.getLoc();
Lex.Lex(); // eat the '<'

// Parse the range list.
ParseRangeList(Ranges);
if (Ranges.empty()) return true;

if (Lex.getCode() != tgtok::greater) {
  TokError("expected '>' at end of range list");
  return Error(StartLoc, "to match this '<'");
}
Lex.Lex();   // eat the '>'.
return false;
764}

766/// ParseOptionalBitList - Parse either a bit list in {}'s or nothing.
767///   OptionalBitList ::= '{' RangeList '}'
768///   OptionalBitList ::= /*empty*/
769bool TGParser::ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges) {
if (Lex.getCode() != tgtok::l_brace)
  return false;

SMLoc StartLoc = Lex.getLoc();
Lex.Lex(); // eat the '{'

// Parse the range list.
ParseRangeList(Ranges);
if (Ranges.empty()) return true;

if (Lex.getCode() != tgtok::r_brace) {
  TokError("expected '}' at end of bit list");
  return Error(StartLoc, "to match this '{'");
}
Lex.Lex();   // eat the '}'.
return false;
786}

788/// ParseType - Parse and return a tblgen type.  This returns null on error.
789///
790///   Type ::= STRING                       // string type
791///   Type ::= CODE                         // code type
792///   Type ::= BIT                          // bit type
793///   Type ::= BITS '<' INTVAL '>'          // bits<x> type
794///   Type ::= INT                          // int type
795///   Type ::= LIST '<' Type '>'            // list<x> type
796///   Type ::= DAG                          // dag type
797///   Type ::= ClassID                      // Record Type
798///
799RecTy *TGParser::ParseType() {
switch (Lex.getCode()) {
default: TokError("Unknown token when expecting a type"); return nullptr;
case tgtok::String: Lex.Lex(); return StringRecTy::get();
case tgtok::Code:   Lex.Lex(); return CodeRecTy::get();
case tgtok::Bit:    Lex.Lex(); return BitRecTy::get();
case tgtok::Int:    Lex.Lex(); return IntRecTy::get();
case tgtok::Dag:    Lex.Lex(); return DagRecTy::get();
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 '<'
    TokError("expected integer in bits<n> type");
    return nullptr;
  }
  uint64_t Val = Lex.getCurIntVal();
  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'
    TokError("expected '<' after list type");
    return nullptr;
  }
  Lex.Lex();  // Eat '<'
  RecTy *SubType = ParseType();
  if (!SubType) return nullptr;

  if (Lex.getCode() != tgtok::greater) {
    TokError("expected '>' at end of list<ty> type");
    return nullptr;
  }
  Lex.Lex();  // Eat '>'
  return ListRecTy::get(SubType);
}
}
845}

847/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
848/// has already been read.
849Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
                           IDParseMode Mode) {
if (CurRec) {
  if (const RecordVal *RV = CurRec->getValue(Name))
    return VarInit::get(Name, RV->getType());
}

if ((CurRec && CurRec->isClass()) || CurMultiClass) {
  Init *TemplateArgName;
  if (CurMultiClass) {
    TemplateArgName =
        QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::");
  } else
    TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, ":");

  Record *TemplateRec = CurMultiClass ? &CurMultiClass->Rec : CurRec;
  if (TemplateRec->isTemplateArg(TemplateArgName)) {
    const RecordVal *RV = TemplateRec->getValue(TemplateArgName);
    assert(RV && "Template arg doesn't exist??")((RV && "Template arg doesn't exist??") ? static_cast
<void> (0) : __assert_fail ("RV && \"Template arg doesn't exist??\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 867, __PRETTY_FUNCTION__));
    return VarInit::get(TemplateArgName, RV->getType());
  } else if (Name->getValue() == "NAME") {
    return VarInit::get(TemplateArgName, StringRecTy::get());
  }
}

if (CurLocalScope)
  if (Init *I = CurLocalScope->getVar(Name->getValue()))
    return I;

// If this is in a foreach loop, make sure it's not a loop iterator
for (const auto &L : Loops) {
  if (L->IterVar) {
    VarInit *IterVar = dyn_cast<VarInit>(L->IterVar);
    if (IterVar && IterVar->getNameInit() == Name)
      return IterVar;
  }
}

if (Mode == ParseNameMode)
  return Name;

if (Init *I = Records.getGlobal(Name->getValue()))
  return I;

// Allow self-references of concrete defs, but delay the lookup so that we
// get the correct type.
if (CurRec && !CurRec->isClass() && !CurMultiClass &&
    CurRec->getNameInit() == Name)
  return UnOpInit::get(UnOpInit::CAST, Name, CurRec->getType());

Error(NameLoc, "Variable not defined: '" + Name->getValue() + "'");
return nullptr;
901}

903/// ParseOperation - Parse an operator.  This returns null on error.
904///
905/// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
906///
907Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
switch (Lex.getCode()) {
1
Control jumps to 'case XCond:'  at line 1557→
default:
  TokError("unknown operation");
  return nullptr;
case tgtok::XHead:
case tgtok::XTail:
case tgtok::XSize:
case tgtok::XEmpty:
case tgtok::XCast:
case tgtok::XGetOp: {  // Value ::= !unop '(' Value ')'
  UnOpInit::UnaryOp Code;
  RecTy *Type = nullptr;

  switch (Lex.getCode()) {
  default: llvm_unreachable("Unhandled code!")::llvm::llvm_unreachable_internal("Unhandled code!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 922);
  case tgtok::XCast:
    Lex.Lex();  // eat the operation
    Code = UnOpInit::CAST;

    Type = ParseOperatorType();

    if (!Type) {
      TokError("did not get type for unary operator");
      return nullptr;
    }

    break;
  case tgtok::XHead:
    Lex.Lex();  // eat the operation
    Code = UnOpInit::HEAD;
    break;
  case tgtok::XTail:
    Lex.Lex();  // eat the operation
    Code = UnOpInit::TAIL;
    break;
  case tgtok::XSize:
    Lex.Lex();
    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:
    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)).
      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");
        // but keep parsing, to consume the operand
      }
    } else {
      Type = RecordRecTy::get({});
    }
    Code = UnOpInit::GETOP;
    break;
  }
  if (Lex.getCode() != tgtok::l_paren) {
    TokError("expected '(' after unary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the '('

  Init *LHS = ParseValue(CurRec);
  if (!LHS) return nullptr;

  if (Code == UnOpInit::HEAD ||
      Code == UnOpInit::TAIL ||
      Code == UnOpInit::EMPTY) {
    ListInit *LHSl = dyn_cast<ListInit>(LHS);
    StringInit *LHSs = dyn_cast<StringInit>(LHS);
    TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
    if (!LHSl && !LHSs && !LHSt) {
      TokError("expected list or string type argument in unary operator");
      return nullptr;
    }
    if (LHSt) {
      ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
      StringRecTy *SType = dyn_cast<StringRecTy>(LHSt->getType());
      if (!LType && !SType) {
        TokError("expected list or string type argument in unary operator");
        return nullptr;
      }
    }

    if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL ||
        Code == UnOpInit::SIZE) {
      if (!LHSl && !LHSt) {
        TokError("expected list type argument in unary operator");
        return nullptr;
      }
    }

    if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) {
      if (LHSl && LHSl->empty()) {
        TokError("empty list argument in unary operator");
        return nullptr;
      }
      if (LHSl) {
        Init *Item = LHSl->getElement(0);
        TypedInit *Itemt = dyn_cast<TypedInit>(Item);
        if (!Itemt) {
          TokError("untyped list element in unary operator");
          return nullptr;
        }
        Type = (Code == UnOpInit::HEAD) ? Itemt->getType()
                                        : ListRecTy::get(Itemt->getType());
      } else {
        assert(LHSt && "expected list type argument in unary operator")((LHSt && "expected list type argument in unary operator"
) ? static_cast<void> (0) : __assert_fail ("LHSt && \"expected list type argument in unary operator\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 1027, __PRETTY_FUNCTION__));
        ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
        if (!LType) {
          TokError("expected list type argument in unary operator");
          return nullptr;
        }
        Type = (Code == UnOpInit::HEAD) ? LType->getElementType() : LType;
      }
    }
  }

  if (Lex.getCode() != tgtok::r_paren) {
    TokError("expected ')' in unary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ')'
  return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec);
}

case tgtok::XIsA: {
  // Value ::= !isa '<' Type '>' '(' Value ')'
  Lex.Lex(); // eat the operation

  RecTy *Type = ParseOperatorType();
  if (!Type)
    return nullptr;

  if (Lex.getCode() != tgtok::l_paren) {
    TokError("expected '(' after type of !isa");
    return nullptr;
  }
  Lex.Lex(); // eat the '('

  Init *LHS = ParseValue(CurRec);
  if (!LHS)
    return nullptr;

  if (Lex.getCode() != tgtok::r_paren) {
    TokError("expected ')' in !isa");
    return nullptr;
  }
  Lex.Lex(); // eat the ')'

  return (IsAOpInit::get(Type, LHS))->Fold();
}

case tgtok::XConcat:
case tgtok::XADD:
case tgtok::XMUL:
case tgtok::XAND:
case tgtok::XOR:
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 ')'
  tgtok::TokKind OpTok = Lex.getCode();
  SMLoc OpLoc = Lex.getLoc();
  Lex.Lex();  // eat the operation

  BinOpInit::BinaryOp Code;
  switch (OpTok) {
  default: llvm_unreachable("Unhandled code!")::llvm::llvm_unreachable_internal("Unhandled code!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 1097);
  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::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;
  }

  RecTy *Type = nullptr;
  RecTy *ArgType = nullptr;
  switch (OpTok) {
  default:
    llvm_unreachable("Unhandled code!")::llvm::llvm_unreachable_internal("Unhandled code!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 1122);
  case tgtok::XConcat:
  case tgtok::XSetOp:
    Type = DagRecTy::get();
    ArgType = DagRecTy::get();
    break;
  case tgtok::XAND:
  case tgtok::XOR:
  case tgtok::XSRA:
  case tgtok::XSRL:
  case tgtok::XSHL:
  case tgtok::XADD:
  case tgtok::XMUL:
    Type = IntRecTy::get();
    ArgType = IntRecTy::get();
    break;
  case tgtok::XEq:
  case tgtok::XNe:
    Type = BitRecTy::get();
    // ArgType for Eq / Ne is not known at this point
    break;
  case tgtok::XLe:
  case tgtok::XLt:
  case tgtok::XGe:
  case tgtok::XGt:
    Type = BitRecTy::get();
    ArgType = IntRecTy::get();
    break;
  case tgtok::XListConcat:
    // We don't know the list type until we parse the first argument
    ArgType = ItemType;
    break;
  case tgtok::XListSplat:
    // Can't do any typechecking until we parse the first argument.
    break;
  case tgtok::XStrConcat:
    Type = StringRecTy::get();
    ArgType = StringRecTy::get();
    break;
  }

  if (Type && ItemType && !Type->typeIsConvertibleTo(ItemType)) {
    Error(OpLoc, Twine("expected value of type '") +
                 ItemType->getAsString() + "', got '" +
                 Type->getAsString() + "'");
    return nullptr;
  }

  if (Lex.getCode() != tgtok::l_paren) {
    TokError("expected '(' after binary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the '('

  SmallVector<Init*, 2> InitList;

  for (;;) {
    SMLoc InitLoc = Lex.getLoc();
    InitList.push_back(ParseValue(CurRec, ArgType));
    if (!InitList.back()) return nullptr;

    TypedInit *InitListBack = dyn_cast<TypedInit>(InitList.back());
    if (!InitListBack) {
      Error(OpLoc, Twine("expected value to be a typed value, got '" +
                         InitList.back()->getAsString() + "'"));
      return nullptr;
    }
    RecTy *ListType = InitListBack->getType();
    if (!ArgType) {
      ArgType = ListType;

      switch (Code) {
      case BinOpInit::LISTCONCAT:
        if (!isa<ListRecTy>(ArgType)) {
          Error(InitLoc, Twine("expected a list, got value of type '") +
                         ArgType->getAsString() + "'");
          return nullptr;
        }
        break;
      case BinOpInit::LISTSPLAT:
        if (ItemType && InitList.size() == 1) {
          if (!isa<ListRecTy>(ItemType)) {
            Error(OpLoc,
                  Twine("expected output type to be a list, got type '") +
                      ItemType->getAsString() + "'");
            return nullptr;
          }
          if (!ArgType->getListTy()->typeIsConvertibleTo(ItemType)) {
            Error(OpLoc, Twine("expected first arg type to be '") +
                             ArgType->getAsString() +
                             "', got value of type '" +
                             cast<ListRecTy>(ItemType)
                                 ->getElementType()
                                 ->getAsString() +
                             "'");
            return nullptr;
          }
        }
        if (InitList.size() == 2 && !isa<IntRecTy>(ArgType)) {
          Error(InitLoc, Twine("expected second parameter to be an int, got "
                               "value of type '") +
                             ArgType->getAsString() + "'");
          return nullptr;
        }
        ArgType = nullptr; // Broken invariant: types not identical.
        break;
      case BinOpInit::EQ:
      case BinOpInit::NE:
        if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
            !ArgType->typeIsConvertibleTo(StringRecTy::get())) {
          Error(InitLoc, Twine("expected int, bits, or string; got value of "
                               "type '") + ArgType->getAsString() + "'");
          return nullptr;
        }
        break;
      default: llvm_unreachable("other ops have fixed argument types")::llvm::llvm_unreachable_internal("other ops have fixed argument types"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 1237);
      }
    } else {
      RecTy *Resolved = resolveTypes(ArgType, ListType);
      if (!Resolved) {
        Error(InitLoc, Twine("expected value of type '") +
                           ArgType->getAsString() + "', got '" +
                           ListType->getAsString() + "'");
        return nullptr;
      }
      if (Code != BinOpInit::ADD && Code != BinOpInit::AND &&
          Code != BinOpInit::OR && 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:
        // After parsing the first dag argument, switch to expecting
        // a record, with no restriction on its superclasses.
        ArgType = RecordRecTy::get({});
        break;
      default:
        break;
    }

    if (Lex.getCode() != tgtok::comma)
      break;
    Lex.Lex();  // eat the ','
  }

  if (Lex.getCode() != tgtok::r_paren) {
    TokError("expected ')' in operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ')'

  // listconcat returns a list with type of the argument.
  if (Code == BinOpInit::LISTCONCAT)
    Type = ArgType;
  // listsplat returns a list of type of the *first* argument.
  if (Code == BinOpInit::LISTSPLAT)
    Type = cast<TypedInit>(InitList.front())->getType()->getListTy();

  // We allow multiple operands to associative operators like !strconcat as
  // shorthand for nesting them.
  if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT ||
      Code == BinOpInit::CONCAT || Code == BinOpInit::ADD ||
      Code == BinOpInit::AND || Code == BinOpInit::OR ||
      Code == BinOpInit::MUL) {
    while (InitList.size() > 2) {
      Init *RHS = InitList.pop_back_val();
      RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec);
      InitList.back() = RHS;
    }
  }

  if (InitList.size() == 2)
    return (BinOpInit::get(Code, InitList[0], InitList[1], Type))
        ->Fold(CurRec);

  Error(OpLoc, "expected two operands to operator");
  return nullptr;
}

case tgtok::XForEach: { // Value ::= !foreach '(' Id ',' Value ',' Value ')'
  SMLoc OpLoc = Lex.getLoc();
  Lex.Lex(); // eat the operation
  if (Lex.getCode() != tgtok::l_paren) {
    TokError("expected '(' after !foreach");
    return nullptr;
  }

  if (Lex.Lex() != tgtok::Id) { // eat the '('
    TokError("first argument of !foreach must be an identifier");
    return nullptr;
  }

  Init *LHS = StringInit::get(Lex.getCurStrVal());

  if (CurRec && CurRec->getValue(LHS)) {
    TokError((Twine("iteration variable '") + LHS->getAsString() +
              "' already defined")
                 .str());
    return nullptr;
  }

  if (Lex.Lex() != tgtok::comma) { // eat the id
    TokError("expected ',' in ternary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ','

  Init *MHS = ParseValue(CurRec);
  if (!MHS)
    return nullptr;

  if (Lex.getCode() != tgtok::comma) {
    TokError("expected ',' in ternary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ','

  TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
  if (!MHSt) {
    TokError("could not get type of !foreach input");
    return nullptr;
  }

  RecTy *InEltType = nullptr;
  RecTy *OutEltType = nullptr;
  bool IsDAG = false;

  if (ListRecTy *InListTy = dyn_cast<ListRecTy>(MHSt->getType())) {
    InEltType = InListTy->getElementType();
    if (ItemType) {
      if (ListRecTy *OutListTy = dyn_cast<ListRecTy>(ItemType)) {
        OutEltType = OutListTy->getElementType();
      } else {
        Error(OpLoc,
              "expected value of type '" + Twine(ItemType->getAsString()) +
              "', but got !foreach of list type");
        return nullptr;
      }
    }
  } else if (DagRecTy *InDagTy = dyn_cast<DagRecTy>(MHSt->getType())) {
    InEltType = InDagTy;
    if (ItemType && !isa<DagRecTy>(ItemType)) {
      Error(OpLoc,
            "expected value of type '" + Twine(ItemType->getAsString()) +
            "', but got !foreach of dag type");
      return nullptr;
    }
    IsDAG = true;
  } else {
    TokError("!foreach must have list or dag input");
    return nullptr;
  }

  // We need to create a temporary record to provide a scope for the iteration
  // variable while parsing top-level foreach's.
  std::unique_ptr<Record> ParseRecTmp;
  Record *ParseRec = CurRec;
  if (!ParseRec) {
    ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
    ParseRec = ParseRecTmp.get();
  }

  ParseRec->addValue(RecordVal(LHS, InEltType, false));
  Init *RHS = ParseValue(ParseRec, OutEltType);
  ParseRec->removeValue(LHS);
  if (!RHS)
    return nullptr;

  if (Lex.getCode() != tgtok::r_paren) {
    TokError("expected ')' in binary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ')'

  RecTy *OutType;
  if (IsDAG) {
    OutType = InEltType;
  } else {
    TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
    if (!RHSt) {
      TokError("could not get type of !foreach result");
      return nullptr;
    }
    OutType = RHSt->getType()->getListTy();
  }

  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 ')'
  TernOpInit::TernaryOp Code;
  RecTy *Type = nullptr;

  tgtok::TokKind LexCode = Lex.getCode();
  Lex.Lex();  // eat the operation
  switch (LexCode) {
  default: llvm_unreachable("Unhandled code!")::llvm::llvm_unreachable_internal("Unhandled code!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 1425);
  case tgtok::XDag:
    Code = TernOpInit::DAG;
    Type = DagRecTy::get();
    ItemType = nullptr;
    break;
  case tgtok::XIf:
    Code = TernOpInit::IF;
    break;
  case tgtok::XSubst:
    Code = TernOpInit::SUBST;
    break;
  }
  if (Lex.getCode() != tgtok::l_paren) {
    TokError("expected '(' after ternary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the '('

  Init *LHS = ParseValue(CurRec);
  if (!LHS) return nullptr;

  if (Lex.getCode() != tgtok::comma) {
    TokError("expected ',' in ternary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ','

  SMLoc MHSLoc = Lex.getLoc();
  Init *MHS = ParseValue(CurRec, ItemType);
  if (!MHS)
    return nullptr;

  if (Lex.getCode() != tgtok::comma) {
    TokError("expected ',' in ternary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ','

  SMLoc RHSLoc = Lex.getLoc();
  Init *RHS = ParseValue(CurRec, ItemType);
  if (!RHS)
    return nullptr;

  if (Lex.getCode() != tgtok::r_paren) {
    TokError("expected ')' in binary operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ')'

  switch (LexCode) {
  default: llvm_unreachable("Unhandled code!")::llvm::llvm_unreachable_internal("Unhandled code!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 1476);
  case tgtok::XDag: {
    TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
    if (!MHSt && !isa<UnsetInit>(MHS)) {
      Error(MHSLoc, "could not determine type of the child list in !dag");
      return nullptr;
    }
    if (MHSt && !isa<ListRecTy>(MHSt->getType())) {
      Error(MHSLoc, Twine("expected list of children, got type '") +
                        MHSt->getType()->getAsString() + "'");
      return nullptr;
    }

    TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
    if (!RHSt && !isa<UnsetInit>(RHS)) {
      Error(RHSLoc, "could not determine type of the name list in !dag");
      return nullptr;
    }
    if (RHSt && StringRecTy::get()->getListTy() != RHSt->getType()) {
      Error(RHSLoc, Twine("expected list<string>, got type '") +
                        RHSt->getType()->getAsString() + "'");
      return nullptr;
    }

    if (!MHSt && !RHSt) {
      Error(MHSLoc,
            "cannot have both unset children and unset names in !dag");
      return nullptr;
    }
    break;
  }
  case tgtok::XIf: {
    RecTy *MHSTy = nullptr;
    RecTy *RHSTy = nullptr;

    if (TypedInit *MHSt = dyn_cast<TypedInit>(MHS))
      MHSTy = MHSt->getType();
    if (BitsInit *MHSbits = dyn_cast<BitsInit>(MHS))
      MHSTy = BitsRecTy::get(MHSbits->getNumBits());
    if (isa<BitInit>(MHS))
      MHSTy = BitRecTy::get();

    if (TypedInit *RHSt = dyn_cast<TypedInit>(RHS))
      RHSTy = RHSt->getType();
    if (BitsInit *RHSbits = dyn_cast<BitsInit>(RHS))
      RHSTy = BitsRecTy::get(RHSbits->getNumBits());
    if (isa<BitInit>(RHS))
      RHSTy = BitRecTy::get();

    // For UnsetInit, it's typed from the other hand.
    if (isa<UnsetInit>(MHS))
      MHSTy = RHSTy;
    if (isa<UnsetInit>(RHS))
      RHSTy = MHSTy;

    if (!MHSTy || !RHSTy) {
      TokError("could not get type for !if");
      return nullptr;
    }

    Type = resolveTypes(MHSTy, RHSTy);
    if (!Type) {
      TokError(Twine("inconsistent types '") + MHSTy->getAsString() +
               "' and '" + RHSTy->getAsString() + "' for !if");
      return nullptr;
    }
    break;
  }
  case tgtok::XSubst: {
    TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
    if (!RHSt) {
      TokError("could not get type for !subst");
      return nullptr;
    }
    Type = RHSt->getType();
    break;
  }
  }
  return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
}

case tgtok::XCond:
  return ParseOperationCond(CurRec, ItemType);
2
←
Calling 'TGParser::ParseOperationCond'→

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 '('

  Init *StartUntyped = ParseValue(CurRec);
  if (!StartUntyped)
    return nullptr;

  TypedInit *Start = dyn_cast<TypedInit>(StartUntyped);
  if (!Start) {
    TokError(Twine("could not get type of !foldl start: '") +
             StartUntyped->getAsString() + "'");
    return nullptr;
  }

  if (Lex.getCode() != tgtok::comma) {
    TokError("expected ',' in !foldl");
    return nullptr;
  }
  Lex.Lex(); // eat the ','

  Init *ListUntyped = ParseValue(CurRec);
  if (!ListUntyped)
    return nullptr;

  TypedInit *List = dyn_cast<TypedInit>(ListUntyped);
  if (!List) {
    TokError(Twine("could not get type of !foldl list: '") +
             ListUntyped->getAsString() + "'");
    return nullptr;
  }

  ListRecTy *ListType = dyn_cast<ListRecTy>(List->getType());
  if (!ListType) {
    TokError(Twine("!foldl list must be a list, but is of type '") +
             List->getType()->getAsString());
    return nullptr;
  }

  if (Lex.getCode() != tgtok::comma) {
    TokError("expected ',' in !foldl");
    return nullptr;
  }

  if (Lex.Lex() != tgtok::Id) { // eat the ','
    TokError("third argument of !foldl must be an identifier");
    return nullptr;
  }

  Init *A = StringInit::get(Lex.getCurStrVal());
  if (CurRec && CurRec->getValue(A)) {
    TokError((Twine("left !foldl variable '") + A->getAsString() +
              "' already defined")
                 .str());
    return nullptr;
  }

  if (Lex.Lex() != tgtok::comma) { // eat the id
    TokError("expected ',' in !foldl");
    return nullptr;
  }

  if (Lex.Lex() != tgtok::Id) { // eat the ','
    TokError("fourth argument of !foldl must be an identifier");
    return nullptr;
  }

  Init *B = StringInit::get(Lex.getCurStrVal());
  if (CurRec && CurRec->getValue(B)) {
    TokError((Twine("right !foldl variable '") + B->getAsString() +
              "' already defined")
                 .str());
    return nullptr;
  }

  if (Lex.Lex() != tgtok::comma) { // eat the id
    TokError("expected ',' in !foldl");
    return nullptr;
  }
  Lex.Lex(); // eat the ','

  // We need to create a temporary record to provide a scope for the iteration
  // variable while parsing top-level foreach's.
  std::unique_ptr<Record> ParseRecTmp;
  Record *ParseRec = CurRec;
  if (!ParseRec) {
    ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
    ParseRec = ParseRecTmp.get();
  }

  ParseRec->addValue(RecordVal(A, Start->getType(), false));
  ParseRec->addValue(RecordVal(B, ListType->getElementType(), false));
  Init *ExprUntyped = ParseValue(ParseRec);
  ParseRec->removeValue(A);
  ParseRec->removeValue(B);
  if (!ExprUntyped)
    return nullptr;

  TypedInit *Expr = dyn_cast<TypedInit>(ExprUntyped);
  if (!Expr) {
    TokError("could not get type of !foldl expression");
    return nullptr;
  }

  if (Expr->getType() != Start->getType()) {
    TokError(Twine("!foldl expression must be of same type as start (") +
             Start->getType()->getAsString() + "), but is of type " +
             Expr->getType()->getAsString());
    return nullptr;
  }

  if (Lex.getCode() != tgtok::r_paren) {
    TokError("expected ')' in fold operator");
    return nullptr;
  }
  Lex.Lex(); // eat the ')'

  return FoldOpInit::get(Start, List, A, B, Expr, Start->getType())
      ->Fold(CurRec);
}
}
1686}

1688/// ParseOperatorType - Parse a type for an operator.  This returns
1689/// null on error.
1690///
1691/// OperatorType ::= '<' Type '>'
1692///
1693RecTy *TGParser::ParseOperatorType() {
RecTy *Type = nullptr;

if (Lex.getCode() != tgtok::less) {
  TokError("expected type name for operator");
  return nullptr;
}
Lex.Lex();  // eat the <

Type = ParseType();

if (!Type) {
  TokError("expected type name for operator");
  return nullptr;
}

if (Lex.getCode() != tgtok::greater) {
  TokError("expected type name for operator");
  return nullptr;
}
Lex.Lex();  // eat the >

return Type;
1716}

1718Init *TGParser::ParseOperationCond(Record *CurRec, RecTy *ItemType) {
Lex.Lex();  // eat the operation 'cond'

if (Lex.getCode() != tgtok::l_paren) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
   TokError("expected '(' after !cond operator");
   return nullptr;
}
Lex.Lex();  // eat the '('

// Parse through '[Case: Val,]+'
SmallVector<Init *, 4> Case;
SmallVector<Init *, 4> Val;
while (true) {
5
←
Loop condition is true.  Entering loop body→
  if (Lex.getCode() == tgtok::r_paren) {
6
←
Assuming the condition is false→
7
←
Taking false branch→
    Lex.Lex(); // eat the ')'
    break;
  }

  Init *V = ParseValue(CurRec);
  if (!V)
8
←
Assuming 'V' is non-null→
9
←
Taking false branch→
    return nullptr;
  Case.push_back(V);

  if (Lex.getCode() != tgtok::colon) {
10
←
Assuming the condition is false→
11
←
Taking false branch→
    TokError("expected ':'  following a condition in !cond operator");
    return nullptr;
  }
  Lex.Lex(); // eat the ':'

  V = ParseValue(CurRec, ItemType);
  if (!V)
12
←
Assuming 'V' is non-null→
13
←
Taking false branch→
    return nullptr;
  Val.push_back(V);

  if (Lex.getCode() == tgtok::r_paren) {
14
←
Assuming the condition is true→
15
←
Taking true branch→
    Lex.Lex(); // eat the ')'
    break;
16
←
 Execution continues on line 1764→
  }

  if (Lex.getCode() != tgtok::comma) {
    TokError("expected ',' or ')' following a value in !cond operator");
    return nullptr;
  }
  Lex.Lex();  // eat the ','
}

if (Case.size() < 1) {
17
←
Assuming the condition is false→
18
←
Taking false branch→
  TokError("there should be at least 1 'condition : value' in the !cond operator");
  return nullptr;
}

// resolve type
RecTy *Type = nullptr;
for (Init *V : Val) {
19
←
Assuming '__begin1' is not equal to '__end1'→
  RecTy *VTy = nullptr;
29
←
'VTy' initialized to a null pointer value→
  if (TypedInit *Vt20.1
'Vt' is non-null
1
'Vt' is null
 = dyn_cast<TypedInit>(V))
20
←
Assuming 'V' is a 'TypedInit'→
21
←
Taking true branch→
30
←
Assuming 'V' is not a 'TypedInit'→
31
←
Taking false branch→
    VTy = Vt->getType();
  if (BitsInit *Vbits22.1
'Vbits' is null
1
'Vbits' is null
 = dyn_cast<BitsInit>(V))
22
←
Assuming 'V' is not a 'BitsInit'→
23
←
Taking false branch→
32
←
Assuming 'V' is not a 'BitsInit'→
33
←
Taking false branch→
    VTy = BitsRecTy::get(Vbits->getNumBits());
  if (isa<BitInit>(V))
24
←
Assuming 'V' is not a 'BitInit'→
25
←
Taking false branch→
34
←
'V' is not a 'BitInit'→
35
←
Taking false branch→
    VTy = BitRecTy::get();

  if (Type == nullptr) {
26
←
Taking true branch→
36
←
Assuming the condition is false→
37
←
Taking false branch→
    if (!isa<UnsetInit>(V))
27
←
Assuming 'V' is not a 'UnsetInit'→
28
←
Taking true branch→
      Type = VTy;
  } else {
    if (!isa<UnsetInit>(V)) {
38
←
'V' is not a 'UnsetInit'→
39
←
Taking true branch→
      RecTy *RType = resolveTypes(Type, VTy);
      if (!RType) {
40
←
Assuming 'RType' is null→
41
←
Taking true branch→
        TokError(Twine("inconsistent types '") + Type->getAsString() +
                       "' and '" + VTy->getAsString() + "' for !cond");
42
←
Called C++ object pointer is null
        return nullptr;
      }
      Type = RType;
    }
  }
}

if (!Type) {
  TokError("could not determine type for !cond from its arguments");
  return nullptr;
}
return CondOpInit::get(Case, Val, Type)->Fold(CurRec);
1801}

1803/// ParseSimpleValue - Parse a tblgen value.  This returns null on error.
1804///
1805///   SimpleValue ::= IDValue
1806///   SimpleValue ::= INTVAL
1807///   SimpleValue ::= STRVAL+
1808///   SimpleValue ::= CODEFRAGMENT
1809///   SimpleValue ::= '?'
1810///   SimpleValue ::= '{' ValueList '}'
1811///   SimpleValue ::= ID '<' ValueListNE '>'
1812///   SimpleValue ::= '[' ValueList ']'
1813///   SimpleValue ::= '(' IDValue DagArgList ')'
1814///   SimpleValue ::= CONCATTOK '(' Value ',' Value ')'
1815///   SimpleValue ::= ADDTOK '(' Value ',' Value ')'
1816///   SimpleValue ::= SHLTOK '(' Value ',' Value ')'
1817///   SimpleValue ::= SRATOK '(' Value ',' Value ')'
1818///   SimpleValue ::= SRLTOK '(' Value ',' Value ')'
1819///   SimpleValue ::= LISTCONCATTOK '(' Value ',' Value ')'
1820///   SimpleValue ::= LISTSPLATTOK '(' Value ',' Value ')'
1821///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
1822///   SimpleValue ::= COND '(' [Value ':' Value,]+ ')'
1823///
1824Init *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
  // still exists in some .td files.  Ignore it.
  Lex.Lex();  // Skip '#'.
  return ParseSimpleValue(CurRec, ItemType, Mode);
case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break;
case tgtok::BinaryIntVal: {
  auto BinaryVal = Lex.getCurBinaryIntVal();
  SmallVector<Init*, 16> Bits(BinaryVal.second);
  for (unsigned i = 0, e = BinaryVal.second; i != e; ++i)
    Bits[i] = BitInit::get(BinaryVal.first & (1LL << i));
  R = BitsInit::get(Bits);
  Lex.Lex();
  break;
}
case tgtok::StrVal: {
  std::string Val = Lex.getCurStrVal();
  Lex.Lex();

  // Handle multiple consecutive concatenated strings.
  while (Lex.getCode() == tgtok::StrVal) {
    Val += Lex.getCurStrVal();
    Lex.Lex();
  }

  R = StringInit::get(Val);
  break;
}
case tgtok::CodeFragment:
  R = CodeInit::get(Lex.getCurStrVal(), Lex.getLoc());
  Lex.Lex();
  break;
case tgtok::question:
  R = UnsetInit::get();
  Lex.Lex();
  break;
case tgtok::Id: {
  SMLoc NameLoc = Lex.getLoc();
  StringInit *Name = StringInit::get(Lex.getCurStrVal());
  if (Lex.Lex() != tgtok::less)  // consume the Id.
    return ParseIDValue(CurRec, Name, NameLoc, Mode);    // Value ::= IDValue

  // Value ::= ID '<' ValueListNE '>'
  if (Lex.Lex() == tgtok::greater) {
    TokError("expected non-empty value list");
    return nullptr;
  }

  // This is a CLASS<initvalslist> expression.  This is supposed to synthesize
  // a new anonymous definition, deriving from CLASS<initvalslist> with no
  // body.
  Record *Class = Records.getClass(Name->getValue());
  if (!Class) {
    Error(NameLoc, "Expected a class name, got '" + Name->getValue() + "'");
    return nullptr;
  }

  SmallVector<Init *, 8> Args;
  ParseValueList(Args, CurRec, Class);
  if (Args.empty()) return nullptr;

  if (Lex.getCode() != tgtok::greater) {
    TokError("expected '>' at end of value list");
    return nullptr;
  }
  Lex.Lex();  // eat the '>'

  // Typecheck the template arguments list
  ArrayRef<Init *> ExpectedArgs = Class->getTemplateArgs();
  if (ExpectedArgs.size() < Args.size()) {
    Error(NameLoc,
          "More template args specified than expected");
    return nullptr;
  }

  for (unsigned i = 0, e = ExpectedArgs.size(); i != e; ++i) {
    RecordVal *ExpectedArg = Class->getValue(ExpectedArgs[i]);
    if (i < Args.size()) {
      if (TypedInit *TI = dyn_cast<TypedInit>(Args[i])) {
        RecTy *ExpectedType = ExpectedArg->getType();
        if (!TI->getType()->typeIsConvertibleTo(ExpectedType)) {
          Error(NameLoc,
                "Value specified for template argument #" + Twine(i) + " (" +
                ExpectedArg->getNameInitAsString() + ") is of type '" +
                TI->getType()->getAsString() + "', expected '" +
                ExpectedType->getAsString() + "': " + TI->getAsString());
          return nullptr;
        }
        continue;
      }
    } else if (ExpectedArg->getValue()->isComplete())
      continue;

    Error(NameLoc,
          "Value not specified for template argument #" + Twine(i) + " (" +
          ExpectedArgs[i]->getAsUnquotedString() + ")");
    return nullptr;
  }

  return VarDefInit::get(Class, Args)->Fold();
}
case tgtok::l_brace: {           // Value ::= '{' ValueList '}'
  SMLoc BraceLoc = Lex.getLoc();
  Lex.Lex(); // eat the '{'
  SmallVector<Init*, 16> Vals;

  if (Lex.getCode() != tgtok::r_brace) {
    ParseValueList(Vals, CurRec);
    if (Vals.empty()) return nullptr;
  }
  if (Lex.getCode() != tgtok::r_brace) {
    TokError("expected '}' at end of bit list value");
    return nullptr;
  }
  Lex.Lex();  // eat the '}'

  SmallVector<Init *, 16> NewBits;

  // As we parse { a, b, ... }, 'a' is the highest bit, but we parse it
  // first.  We'll first read everything in to a vector, then we can reverse
  // it to get the bits in the correct order for the BitsInit value.
  for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
    // FIXME: The following two loops would not be duplicated
    //        if the API was a little more orthogonal.

    // bits<n> values are allowed to initialize n bits.
    if (BitsInit *BI = dyn_cast<BitsInit>(Vals[i])) {
      for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
        NewBits.push_back(BI->getBit((e - i) - 1));
      continue;
    }
    // bits<n> can also come from variable initializers.
    if (VarInit *VI = dyn_cast<VarInit>(Vals[i])) {
      if (BitsRecTy *BitsRec = dyn_cast<BitsRecTy>(VI->getType())) {
        for (unsigned i = 0, e = BitsRec->getNumBits(); i != e; ++i)
          NewBits.push_back(VI->getBit((e - i) - 1));
        continue;
      }
      // Fallthrough to try convert this to a bit.
    }
    // All other values must be convertible to just a single bit.
    Init *Bit = Vals[i]->getCastTo(BitRecTy::get());
    if (!Bit) {
      Error(BraceLoc, "Element #" + Twine(i) + " (" + Vals[i]->getAsString() +
            ") is not convertable to a bit");
      return nullptr;
    }
    NewBits.push_back(Bit);
  }
  std::reverse(NewBits.begin(), NewBits.end());
  return BitsInit::get(NewBits);
}
case tgtok::l_square: {          // Value ::= '[' ValueList ']'
  Lex.Lex(); // eat the '['
  SmallVector<Init*, 16> Vals;

  RecTy *DeducedEltTy = nullptr;
  ListRecTy *GivenListTy = nullptr;

  if (ItemType) {
    ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType);
    if (!ListType) {
      TokError(Twine("Type mismatch for list, expected list type, got ") +
               ItemType->getAsString());
      return nullptr;
    }
    GivenListTy = ListType;
  }

  if (Lex.getCode() != tgtok::r_square) {
    ParseValueList(Vals, CurRec, nullptr,
                   GivenListTy ? GivenListTy->getElementType() : nullptr);
    if (Vals.empty()) return nullptr;
  }
  if (Lex.getCode() != tgtok::r_square) {
    TokError("expected ']' at end of list value");
    return nullptr;
  }
  Lex.Lex();  // eat the ']'

  RecTy *GivenEltTy = nullptr;
  if (Lex.getCode() == tgtok::less) {
    // Optional list element type
    Lex.Lex();  // eat the '<'

    GivenEltTy = ParseType();
    if (!GivenEltTy) {
      // Couldn't parse element type
      return nullptr;
    }

    if (Lex.getCode() != tgtok::greater) {
      TokError("expected '>' at end of list element type");
      return nullptr;
    }
    Lex.Lex();  // eat the '>'
  }

  // Check elements
  RecTy *EltTy = nullptr;
  for (Init *V : Vals) {
    TypedInit *TArg = dyn_cast<TypedInit>(V);
    if (TArg) {
      if (EltTy) {
        EltTy = resolveTypes(EltTy, TArg->getType());
        if (!EltTy) {
          TokError("Incompatible types in list elements");
          return nullptr;
        }
      } else {
        EltTy = TArg->getType();
      }
    }
  }

  if (GivenEltTy) {
    if (EltTy) {
      // Verify consistency
      if (!EltTy->typeIsConvertibleTo(GivenEltTy)) {
        TokError("Incompatible types in list elements");
        return nullptr;
      }
    }
    EltTy = GivenEltTy;
  }

  if (!EltTy) {
    if (!ItemType) {
      TokError("No type for list");
      return nullptr;
    }
    DeducedEltTy = GivenListTy->getElementType();
  } else {
    // Make sure the deduced type is compatible with the given type
    if (GivenListTy) {
      if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) {
        TokError(Twine("Element type mismatch for list: element type '") +
                 EltTy->getAsString() + "' not convertible to '" +
                 GivenListTy->getElementType()->getAsString());
        return nullptr;
      }
    }
    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) {
    TokError("expected identifier in dag init");
    return nullptr;
  }

  Init *Operator = ParseValue(CurRec);
  if (!Operator) return nullptr;

  // If the operator name is present, parse it.
  StringInit *OperatorName = nullptr;
  if (Lex.getCode() == tgtok::colon) {
    if (Lex.Lex() != tgtok::VarName) { // eat the ':'
      TokError("expected variable name in dag operator");
      return nullptr;
    }
    OperatorName = StringInit::get(Lex.getCurStrVal());
    Lex.Lex();  // eat the VarName.
  }

  SmallVector<std::pair<llvm::Init*, StringInit*>, 8> DagArgs;
  if (Lex.getCode() != tgtok::r_paren) {
    ParseDagArgList(DagArgs, CurRec);
    if (DagArgs.empty()) return nullptr;
  }

  if (Lex.getCode() != tgtok::r_paren) {
    TokError("expected ')' in dag init");
    return nullptr;
  }
  Lex.Lex();  // eat the ')'

  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::XIsA:
case tgtok::XConcat:
case tgtok::XDag:
case tgtok::XADD:
case tgtok::XMUL:
case tgtok::XAND:
case tgtok::XOR:
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::XIf:
case tgtok::XCond:
case tgtok::XFoldl:
case tgtok::XForEach:
case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
  return ParseOperation(CurRec, ItemType);
}
}

return R;
2149}

2151/// ParseValue - Parse a tblgen value.  This returns null on error.
2152///
2153///   Value       ::= SimpleValue ValueSuffix*
2154///   ValueSuffix ::= '{' BitList '}'
2155///   ValueSuffix ::= '[' BitList ']'
2156///   ValueSuffix ::= '.' ID
2157///
2158Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
if (!Result) return nullptr;

// Parse the suffixes now if present.
while (true) {
  switch (Lex.getCode()) {
  default: return Result;
  case tgtok::l_brace: {
    if (Mode == ParseNameMode)
      // This is the beginning of the object body.
      return Result;

    SMLoc CurlyLoc = Lex.getLoc();
    Lex.Lex(); // eat the '{'
    SmallVector<unsigned, 16> Ranges;
    ParseRangeList(Ranges);
    if (Ranges.empty()) return nullptr;

    // Reverse the bitlist.
    std::reverse(Ranges.begin(), Ranges.end());
    Result = Result->convertInitializerBitRange(Ranges);
    if (!Result) {
      Error(CurlyLoc, "Invalid bit range for value");
      return nullptr;
    }

    // Eat the '}'.
    if (Lex.getCode() != tgtok::r_brace) {
      TokError("expected '}' at end of bit range list");
      return nullptr;
    }
    Lex.Lex();
    break;
  }
  case tgtok::l_square: {
    SMLoc SquareLoc = Lex.getLoc();
    Lex.Lex(); // eat the '['
    SmallVector<unsigned, 16> Ranges;
    ParseRangeList(Ranges);
    if (Ranges.empty()) return nullptr;

    Result = Result->convertInitListSlice(Ranges);
    if (!Result) {
      Error(SquareLoc, "Invalid range for list slice");
      return nullptr;
    }

    // Eat the ']'.
    if (Lex.getCode() != tgtok::r_square) {
      TokError("expected ']' at end of list slice");
      return nullptr;
    }
    Lex.Lex();
    break;
  }
  case tgtok::period: {
    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;
    }
    Result = FieldInit::get(Result, FieldName)->Fold(CurRec);
    Lex.Lex();  // eat field name
    break;
  }

  case tgtok::paste:
    SMLoc PasteLoc = Lex.getLoc();
    TypedInit *LHS = dyn_cast<TypedInit>(Result);
    if (!LHS) {
      Error(PasteLoc, "LHS of paste is not typed!");
      return nullptr;
    }

    // Check if it's a 'listA # listB'
    if (isa<ListRecTy>(LHS->getType())) {
      Lex.Lex();  // Eat the '#'.

      switch (Lex.getCode()) {
      case tgtok::colon:
      case tgtok::semi:
      case tgtok::l_brace:
        Result = LHS; // trailing paste, ignore.
        break;
      default:
        Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode);
        Result = BinOpInit::getListConcat(LHS, RHSResult);
      }
      break;
    }

    // Create a !strconcat() operation, first casting each operand to
    // a string if necessary.
    if (LHS->getType() != StringRecTy::get()) {
      auto CastLHS = dyn_cast<TypedInit>(
          UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get())
              ->Fold(CurRec));
      if (!CastLHS) {
        Error(PasteLoc,
              Twine("can't cast '") + LHS->getAsString() + "' to string");
        return nullptr;
      }
      LHS = CastLHS;
    }

    TypedInit *RHS = nullptr;

    Lex.Lex();  // Eat the '#'.
    switch (Lex.getCode()) {
    case tgtok::colon:
    case tgtok::semi:
    case tgtok::l_brace:
      // These are all of the tokens that can begin an object body.
      // Some of these can also begin values but we disallow those cases
      // because they are unlikely to be useful.

      // Trailing paste, concat with an empty string.
      RHS = StringInit::get("");
      break;

    default:
      Init *RHSResult = ParseValue(CurRec, nullptr, ParseNameMode);
      RHS = dyn_cast<TypedInit>(RHSResult);
      if (!RHS) {
        Error(PasteLoc, "RHS of paste is not typed!");
        return nullptr;
      }

      if (RHS->getType() != StringRecTy::get()) {
        auto CastRHS = dyn_cast<TypedInit>(
            UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get())
                ->Fold(CurRec));
        if (!CastRHS) {
          Error(PasteLoc,
                Twine("can't cast '") + RHS->getAsString() + "' to string");
          return nullptr;
        }
        RHS = CastRHS;
      }

      break;
    }

    Result = BinOpInit::getStrConcat(LHS, RHS);
    break;
  }
}
2311}

2313/// ParseDagArgList - Parse the argument list for a dag literal expression.
2314///
2315///    DagArg     ::= Value (':' VARNAME)?
2316///    DagArg     ::= VARNAME
2317///    DagArgList ::= DagArg
2318///    DagArgList ::= DagArgList ',' DagArg
2319void TGParser::ParseDagArgList(
  SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result,
  Record *CurRec) {

while (true) {
  // DagArg ::= VARNAME
  if (Lex.getCode() == tgtok::VarName) {
    // A missing value is treated like '?'.
    StringInit *VarName = StringInit::get(Lex.getCurStrVal());
    Result.emplace_back(UnsetInit::get(), VarName);
    Lex.Lex();
  } else {
    // DagArg ::= Value (':' VARNAME)?
    Init *Val = ParseValue(CurRec);
    if (!Val) {
      Result.clear();
      return;
    }

    // If the variable name is present, add it.
    StringInit *VarName = nullptr;
    if (Lex.getCode() == tgtok::colon) {
      if (Lex.Lex() != tgtok::VarName) { // eat the ':'
        TokError("expected variable name in dag literal");
        Result.clear();
        return;
      }
      VarName = StringInit::get(Lex.getCurStrVal());
      Lex.Lex();  // eat the VarName.
    }

    Result.push_back(std::make_pair(Val, VarName));
  }
  if (Lex.getCode() != tgtok::comma) break;
  Lex.Lex(); // eat the ','
}
2355}

2357/// ParseValueList - Parse a comma separated list of values, returning them as a
2358/// vector.  Note that this always expects to be able to parse at least one
2359/// value.  It returns an empty list if this is not possible.
2360///
2361///   ValueList ::= Value (',' Value)
2362///
2363void TGParser::ParseValueList(SmallVectorImpl<Init*> &Result, Record *CurRec,
                            Record *ArgsRec, RecTy *EltTy) {
RecTy *ItemType = EltTy;
unsigned int ArgN = 0;
if (ArgsRec && !EltTy) {
  ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
  if (TArgs.empty()) {
    TokError("template argument provided to non-template class");
    Result.clear();
    return;
  }
  const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
  if (!RV) {
    errs() << "Cannot find template arg " << ArgN << " (" << TArgs[ArgN]
      << ")\n";
  }
  assert(RV && "Template argument record not found??")((RV && "Template argument record not found??") ? static_cast
<void> (0) : __assert_fail ("RV && \"Template argument record not found??\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2379, __PRETTY_FUNCTION__));
  ItemType = RV->getType();
  ++ArgN;
}
Result.push_back(ParseValue(CurRec, ItemType));
if (!Result.back()) {
  Result.clear();
  return;
}

while (Lex.getCode() == tgtok::comma) {
  Lex.Lex();  // Eat the comma

  // ignore trailing comma for lists
  if (Lex.getCode() == tgtok::r_square)
    return;

  if (ArgsRec && !EltTy) {
    ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
    if (ArgN >= TArgs.size()) {
      TokError("too many template arguments");
      Result.clear();
      return;
    }
    const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
    assert(RV && "Template argument record not found??")((RV && "Template argument record not found??") ? static_cast
<void> (0) : __assert_fail ("RV && \"Template argument record not found??\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2404, __PRETTY_FUNCTION__));
    ItemType = RV->getType();
    ++ArgN;
  }
  Result.push_back(ParseValue(CurRec, ItemType));
  if (!Result.back()) {
    Result.clear();
    return;
  }
}
2414}

2416/// ParseDeclaration - Read a declaration, returning the name of field ID, or an
2417/// empty string on error.  This can happen in a number of different context's,
2418/// including within a def or in the template args for a def (which which case
2419/// CurRec will be non-null) and within the template args for a multiclass (in
2420/// which case CurRec will be null, but CurMultiClass will be set).  This can
2421/// also happen within a def that is within a multiclass, which will set both
2422/// CurRec and CurMultiClass.
2423///
2424///  Declaration ::= FIELD? Type ID ('=' Value)?
2425///
2426Init *TGParser::ParseDeclaration(Record *CurRec,
                                     bool ParsingTemplateArgs) {
// Read the field prefix if present.
bool HasField = Lex.getCode() == tgtok::Field;
if (HasField) Lex.Lex();

RecTy *Type = ParseType();
if (!Type) return nullptr;

if (Lex.getCode() != tgtok::Id) {
  TokError("Expected identifier in declaration");
  return nullptr;
}

std::string Str = Lex.getCurStrVal();
if (Str == "NAME") {
  TokError("'" + Str + "' is a reserved variable name");
  return nullptr;
}

SMLoc IdLoc = Lex.getLoc();
Init *DeclName = StringInit::get(Str);
Lex.Lex();

if (ParsingTemplateArgs) {
  if (CurRec)
    DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":");
  else
    assert(CurMultiClass)((CurMultiClass) ? static_cast<void> (0) : __assert_fail
 ("CurMultiClass", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2454, __PRETTY_FUNCTION__));
  if (CurMultiClass)
    DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName,
                           "::");
}

// Add the value.
if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField)))
  return nullptr;

// If a value is present, parse it.
if (Lex.getCode() == tgtok::equal) {
  Lex.Lex();
  SMLoc ValLoc = Lex.getLoc();
  Init *Val = ParseValue(CurRec, Type);
  if (!Val ||
      SetValue(CurRec, ValLoc, DeclName, None, Val))
    // Return the name, even if an error is thrown.  This is so that we can
    // continue to make some progress, even without the value having been
    // initialized.
    return DeclName;
}

return DeclName;
2478}

2480/// ParseForeachDeclaration - Read a foreach declaration, returning
2481/// the name of the declared object or a NULL Init on error.  Return
2482/// the name of the parsed initializer list through ForeachListName.
2483///
2484///  ForeachDeclaration ::= ID '=' '{' RangeList '}'
2485///  ForeachDeclaration ::= ID '=' RangePiece
2486///  ForeachDeclaration ::= ID '=' Value
2487///
2488VarInit *TGParser::ParseForeachDeclaration(Init *&ForeachListValue) {
if (Lex.getCode() != tgtok::Id) {
  TokError("Expected identifier in foreach declaration");
  return nullptr;
}

Init *DeclName = StringInit::get(Lex.getCurStrVal());
Lex.Lex();

// If a value is present, parse it.
if (Lex.getCode() != tgtok::equal) {
  TokError("Expected '=' in foreach declaration");
  return nullptr;
}
Lex.Lex();  // Eat the '='

RecTy *IterType = nullptr;
SmallVector<unsigned, 16> Ranges;

switch (Lex.getCode()) {
case tgtok::l_brace: { // '{' RangeList '}'
  Lex.Lex(); // eat the '{'
  ParseRangeList(Ranges);
  if (Lex.getCode() != tgtok::r_brace) {
    TokError("expected '}' at end of bit range list");
    return nullptr;
  }
  Lex.Lex();
  break;
}

default: {
  SMLoc ValueLoc = Lex.getLoc();
  Init *I = ParseValue(nullptr);
  if (!I)
    return nullptr;

  TypedInit *TI = dyn_cast<TypedInit>(I);
  if (TI && isa<ListRecTy>(TI->getType())) {
    ForeachListValue = I;
    IterType = cast<ListRecTy>(TI->getType())->getElementType();
    break;
  }

  if (TI) {
    if (ParseRangePiece(Ranges, TI))
      return nullptr;
    break;
  }

  std::string Type;
  if (TI)
    Type = (Twine("' of type '") + TI->getType()->getAsString()).str();
  Error(ValueLoc, "expected a list, got '" + I->getAsString() + Type + "'");
  if (CurMultiClass) {
    PrintNote({}, "references to multiclass template arguments cannot be "
              "resolved at this time");
  }
  return nullptr;
}
}


if (!Ranges.empty()) {
  assert(!IterType && "Type already initialized?")((!IterType && "Type already initialized?") ? static_cast
<void> (0) : __assert_fail ("!IterType && \"Type already initialized?\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2552, __PRETTY_FUNCTION__));
  IterType = IntRecTy::get();
  std::vector<Init*> Values;
  for (unsigned R : Ranges)
    Values.push_back(IntInit::get(R));
  ForeachListValue = ListInit::get(Values, IterType);
}

if (!IterType)
  return nullptr;

return VarInit::get(DeclName, IterType);
2564}

2566/// ParseTemplateArgList - Read a template argument list, which is a non-empty
2567/// sequence of template-declarations in <>'s.  If CurRec is non-null, these are
2568/// template args for a def, which may or may not be in a multiclass.  If null,
2569/// these are the template args for a multiclass.
2570///
2571///    TemplateArgList ::= '<' Declaration (',' Declaration)* '>'
2572///
2573bool TGParser::ParseTemplateArgList(Record *CurRec) {
assert(Lex.getCode() == tgtok::less && "Not a template arg list!")((Lex.getCode() == tgtok::less && "Not a template arg list!"
) ? static_cast<void> (0) : __assert_fail ("Lex.getCode() == tgtok::less && \"Not a template arg list!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2574, __PRETTY_FUNCTION__));
Lex.Lex(); // eat the '<'

Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec;

// Read the first declaration.
Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
if (!TemplArg)
  return true;

TheRecToAddTo->addTemplateArg(TemplArg);

while (Lex.getCode() == tgtok::comma) {
  Lex.Lex(); // eat the ','

  // Read the following declarations.
  SMLoc Loc = Lex.getLoc();
  TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
  if (!TemplArg)
    return true;

  if (TheRecToAddTo->isTemplateArg(TemplArg))
    return Error(Loc, "template argument with the same name has already been "
                      "defined");

  TheRecToAddTo->addTemplateArg(TemplArg);
}

if (Lex.getCode() != tgtok::greater)
  return TokError("expected '>' at end of template argument list");
Lex.Lex(); // eat the '>'.
return false;
2606}

2608/// ParseBodyItem - Parse a single item at within the body of a def or class.
2609///
2610///   BodyItem ::= Declaration ';'
2611///   BodyItem ::= LET ID OptionalBitList '=' Value ';'
2612///   BodyItem ::= Defvar
2613bool TGParser::ParseBodyItem(Record *CurRec) {
if (Lex.getCode() == tgtok::Defvar)
  return ParseDefvar();

if (Lex.getCode() != tgtok::Let) {
  if (!ParseDeclaration(CurRec, false))
    return true;

  if (Lex.getCode() != tgtok::semi)
    return TokError("expected ';' after declaration");
  Lex.Lex();
  return false;
}

// LET ID OptionalRangeList '=' Value ';'
if (Lex.Lex() != tgtok::Id)
  return TokError("expected field identifier after let");

SMLoc IdLoc = Lex.getLoc();
StringInit *FieldName = StringInit::get(Lex.getCurStrVal());
Lex.Lex();  // eat the field name.

SmallVector<unsigned, 16> BitList;
if (ParseOptionalBitList(BitList))
  return true;
std::reverse(BitList.begin(), BitList.end());

if (Lex.getCode() != tgtok::equal)
  return TokError("expected '=' in let expression");
Lex.Lex();  // eat the '='.

RecordVal *Field = CurRec->getValue(FieldName);
if (!Field)
  return TokError("Value '" + FieldName->getValue() + "' unknown!");

RecTy *Type = Field->getType();
if (!BitList.empty() && isa<BitsRecTy>(Type)) {
  // When assigning to a subset of a 'bits' object, expect the RHS to have
  // the type of that subset instead of the type of the whole object.
  Type = BitsRecTy::get(BitList.size());
}

Init *Val = ParseValue(CurRec, Type);
if (!Val) return true;

if (Lex.getCode() != tgtok::semi)
  return TokError("expected ';' after let expression");
Lex.Lex();

return SetValue(CurRec, IdLoc, FieldName, BitList, Val);
2663}

2665/// ParseBody - Read the body of a class or def.  Return true on error, false on
2666/// success.
2667///
2668///   Body     ::= ';'
2669///   Body     ::= '{' BodyList '}'
2670///   BodyList BodyItem*
2671///
2672bool TGParser::ParseBody(Record *CurRec) {
// If this is a null definition, just eat the semi and return.
if (Lex.getCode() == tgtok::semi) {
  Lex.Lex();
  return false;
}

if (Lex.getCode() != tgtok::l_brace)
  return TokError("Expected ';' or '{' to start body");
// Eat the '{'.
Lex.Lex();

// An object body introduces a new scope for local variables.
TGLocalVarScope *BodyScope = PushLocalScope();

while (Lex.getCode() != tgtok::r_brace)
  if (ParseBodyItem(CurRec))
    return true;

PopLocalScope(BodyScope);

// Eat the '}'.
Lex.Lex();
return false;
2696}

2698/// Apply the current let bindings to \a CurRec.
2699/// \returns true on error, false otherwise.
2700bool TGParser::ApplyLetStack(Record *CurRec) {
for (SmallVectorImpl<LetRecord> &LetInfo : LetStack)
  for (LetRecord &LR : LetInfo)
    if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value))
      return true;
return false;
2706}

2708bool TGParser::ApplyLetStack(RecordsEntry &Entry) {
if (Entry.Rec)
  return ApplyLetStack(Entry.Rec.get());

for (auto &E : Entry.Loop->Entries) {
  if (ApplyLetStack(E))
    return true;
}

return false;
2718}

2720/// ParseObjectBody - Parse the body of a def or class.  This consists of an
2721/// optional ClassList followed by a Body.  CurRec is the current def or class
2722/// that is being parsed.
2723///
2724///   ObjectBody      ::= BaseClassList Body
2725///   BaseClassList   ::= /*empty*/
2726///   BaseClassList   ::= ':' BaseClassListNE
2727///   BaseClassListNE ::= SubClassRef (',' SubClassRef)*
2728///
2729bool TGParser::ParseObjectBody(Record *CurRec) {
// If there is a baseclass list, read it.
if (Lex.getCode() == tgtok::colon) {
  Lex.Lex();

  // Read all of the subclasses.
  SubClassReference SubClass = ParseSubClassReference(CurRec, false);
  while (true) {
    // Check for error.
    if (!SubClass.Rec) return true;

    // Add it.
    if (AddSubClass(CurRec, SubClass))
      return true;

    if (Lex.getCode() != tgtok::comma) break;
    Lex.Lex(); // eat ','.
    SubClass = ParseSubClassReference(CurRec, false);
  }
}

if (ApplyLetStack(CurRec))
  return true;

return ParseBody(CurRec);
2754}

2756/// ParseDef - Parse and return a top level or multiclass def, return the record
2757/// corresponding to it.  This returns null on error.
2758///
2759///   DefInst ::= DEF ObjectName ObjectBody
2760///
2761bool TGParser::ParseDef(MultiClass *CurMultiClass) {
SMLoc DefLoc = Lex.getLoc();
assert(Lex.getCode() == tgtok::Def && "Unknown tok")((Lex.getCode() == tgtok::Def && "Unknown tok") ? static_cast
<void> (0) : __assert_fail ("Lex.getCode() == tgtok::Def && \"Unknown tok\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2763, __PRETTY_FUNCTION__));
Lex.Lex();  // Eat the 'def' token.

// Parse ObjectName and make a record for it.
std::unique_ptr<Record> CurRec;
Init *Name = ParseObjectName(CurMultiClass);
if (!Name)
  return true;

if (isa<UnsetInit>(Name))
  CurRec = std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records,
                               /*Anonymous=*/true);
else
  CurRec = std::make_unique<Record>(Name, DefLoc, Records);

if (ParseObjectBody(CurRec.get()))
  return true;

return addEntry(std::move(CurRec));
2782}

2784/// ParseDefset - Parse a defset statement.
2785///
2786///   Defset ::= DEFSET Type Id '=' '{' ObjectList '}'
2787///
2788bool TGParser::ParseDefset() {
assert(Lex.getCode() == tgtok::Defset)((Lex.getCode() == tgtok::Defset) ? static_cast<void> (
0) : __assert_fail ("Lex.getCode() == tgtok::Defset", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2789, __PRETTY_FUNCTION__));
Lex.Lex(); // Eat the 'defset' token

DefsetRecord Defset;
Defset.Loc = Lex.getLoc();
RecTy *Type = ParseType();
if (!Type)
  return true;
if (!isa<ListRecTy>(Type))
  return Error(Defset.Loc, "expected list type");
Defset.EltTy = cast<ListRecTy>(Type)->getElementType();

if (Lex.getCode() != tgtok::Id)
  return TokError("expected identifier");
StringInit *DeclName = StringInit::get(Lex.getCurStrVal());
if (Records.getGlobal(DeclName->getValue()))
  return TokError("def or global variable of this name already exists");

if (Lex.Lex() != tgtok::equal) // Eat the identifier
  return TokError("expected '='");
if (Lex.Lex() != tgtok::l_brace) // Eat the '='
  return TokError("expected '{'");
SMLoc BraceLoc = Lex.getLoc();
Lex.Lex(); // Eat the '{'

Defsets.push_back(&Defset);
bool Err = ParseObjectList(nullptr);
Defsets.pop_back();
if (Err)
  return true;

if (Lex.getCode() != tgtok::r_brace) {
  TokError("expected '}' at end of defset");
  return Error(BraceLoc, "to match this '{'");
}
Lex.Lex();  // Eat the '}'

Records.addExtraGlobal(DeclName->getValue(),
                       ListInit::get(Defset.Elements, Defset.EltTy));
return false;
2829}

2831/// ParseDefvar - Parse a defvar statement.
2832///
2833///   Defvar ::= DEFVAR Id '=' Value ';'
2834///
2835bool TGParser::ParseDefvar() {
assert(Lex.getCode() == tgtok::Defvar)((Lex.getCode() == tgtok::Defvar) ? static_cast<void> (
0) : __assert_fail ("Lex.getCode() == tgtok::Defvar", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2836, __PRETTY_FUNCTION__));
Lex.Lex(); // Eat the 'defvar' token

if (Lex.getCode() != tgtok::Id)
  return TokError("expected identifier");
StringInit *DeclName = StringInit::get(Lex.getCurStrVal());
if (CurLocalScope) {
  if (CurLocalScope->varAlreadyDefined(DeclName->getValue()))
    return TokError("local variable of this name already exists");
} else {
  if (Records.getGlobal(DeclName->getValue()))
    return TokError("def or global variable of this name already exists");
}

if (Lex.Lex() != tgtok::equal) // Eat the identifier
  return TokError("expected '='");
Lex.Lex(); // Eat the '='

Init *Value = ParseValue(nullptr);
if (!Value)
  return true;

if (Lex.getCode() != tgtok::semi)
  return TokError("expected ';'");
Lex.Lex(); // Eat the ';'

if (CurLocalScope)
  CurLocalScope->addVar(DeclName->getValue(), Value);
else
  Records.addExtraGlobal(DeclName->getValue(), Value);

return false;
2868}

2870/// ParseForeach - Parse a for statement.  Return the record corresponding
2871/// to it.  This returns true on error.
2872///
2873///   Foreach ::= FOREACH Declaration IN '{ ObjectList '}'
2874///   Foreach ::= FOREACH Declaration IN Object
2875///
2876bool TGParser::ParseForeach(MultiClass *CurMultiClass) {
SMLoc Loc = Lex.getLoc();
assert(Lex.getCode() == tgtok::Foreach && "Unknown tok")((Lex.getCode() == tgtok::Foreach && "Unknown tok") ?
 static_cast<void> (0) : __assert_fail ("Lex.getCode() == tgtok::Foreach && \"Unknown tok\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2878, __PRETTY_FUNCTION__));
Lex.Lex();  // Eat the 'for' token.

// Make a temporary object to record items associated with the for
// loop.
Init *ListValue = nullptr;
VarInit *IterName = ParseForeachDeclaration(ListValue);
if (!IterName)
  return TokError("expected declaration in for");

if (Lex.getCode() != tgtok::In)
  return TokError("Unknown tok");
Lex.Lex();  // Eat the in

// Create a loop object and remember it.
Loops.push_back(std::make_unique<ForeachLoop>(Loc, IterName, ListValue));

// A foreach loop introduces a new scope for local variables.
TGLocalVarScope *ForeachScope = PushLocalScope();

if (Lex.getCode() != tgtok::l_brace) {
  // FOREACH Declaration IN Object
  if (ParseObject(CurMultiClass))
    return true;
} else {
  SMLoc BraceLoc = Lex.getLoc();
  // Otherwise, this is a group foreach.
  Lex.Lex();  // eat the '{'.

  // Parse the object list.
  if (ParseObjectList(CurMultiClass))
    return true;

  if (Lex.getCode() != tgtok::r_brace) {
    TokError("expected '}' at end of foreach command");
    return Error(BraceLoc, "to match this '{'");
  }
  Lex.Lex();  // Eat the }
}

PopLocalScope(ForeachScope);

// Resolve the loop or store it for later resolution.
std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back());
Loops.pop_back();

return addEntry(std::move(Loop));
2925}

2927/// ParseIf - Parse an if statement.
2928///
2929///   If ::= IF Value THEN IfBody
2930///   If ::= IF Value THEN IfBody ELSE IfBody
2931///
2932bool TGParser::ParseIf(MultiClass *CurMultiClass) {
SMLoc Loc = Lex.getLoc();
assert(Lex.getCode() == tgtok::If && "Unknown tok")((Lex.getCode() == tgtok::If && "Unknown tok") ? static_cast
<void> (0) : __assert_fail ("Lex.getCode() == tgtok::If && \"Unknown tok\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 2934, __PRETTY_FUNCTION__));
Lex.Lex(); // Eat the 'if' token.

// Make a temporary object to record items associated with the for
// loop.
Init *Condition = ParseValue(nullptr);
if (!Condition)
  return true;

if (Lex.getCode() != tgtok::Then)
  return TokError("Unknown tok");
Lex.Lex(); // Eat the 'then'

// We have to be able to save if statements to execute later, and they have
// to live on the same stack as foreach loops. The simplest implementation
// technique is to convert each 'then' or 'else' clause *into* a foreach
// loop, over a list of length 0 or 1 depending on the condition, and with no
// iteration variable being assigned.

ListInit *EmptyList = ListInit::get({}, BitRecTy::get());
ListInit *SingletonList = ListInit::get({BitInit::get(1)}, BitRecTy::get());
RecTy *BitListTy = ListRecTy::get(BitRecTy::get());

// The foreach containing the then-clause selects SingletonList if
// the condition is true.
Init *ThenClauseList =
    TernOpInit::get(TernOpInit::IF, Condition, SingletonList, EmptyList,
                    BitListTy)
        ->Fold(nullptr);
Loops.push_back(std::make_unique<ForeachLoop>(Loc, nullptr, ThenClauseList));

if (ParseIfBody(CurMultiClass, "then"))
  return true;

std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back());
Loops.pop_back();

if (addEntry(std::move(Loop)))
  return true;

// Now look for an optional else clause. The if-else syntax has the usual
// dangling-else ambiguity, and by greedily matching an else here if we can,
// we implement the usual resolution of pairing with the innermost unmatched
// if.
if (Lex.getCode() == tgtok::ElseKW) {
  Lex.Lex(); // Eat the 'else'

  // The foreach containing the else-clause uses the same pair of lists as
  // above, but this time, selects SingletonList if the condition is *false*.
  Init *ElseClauseList =
      TernOpInit::get(TernOpInit::IF, Condition, EmptyList, SingletonList,
                      BitListTy)
          ->Fold(nullptr);
  Loops.push_back(
      std::make_unique<ForeachLoop>(Loc, nullptr, ElseClauseList));

  if (ParseIfBody(CurMultiClass, "else"))
    return true;

  Loop = std::move(Loops.back());
  Loops.pop_back();

  if (addEntry(std::move(Loop)))
    return true;
}

return false;
3001}

3003/// ParseIfBody - Parse the then-clause or else-clause of an if statement.
3004///
3005///   IfBody ::= Object
3006///   IfBody ::= '{' ObjectList '}'
3007///
3008bool TGParser::ParseIfBody(MultiClass *CurMultiClass, StringRef Kind) {
TGLocalVarScope *BodyScope = PushLocalScope();

if (Lex.getCode() != tgtok::l_brace) {
  // A single object.
  if (ParseObject(CurMultiClass))
    return true;
} else {
  SMLoc BraceLoc = Lex.getLoc();
  // A braced block.
  Lex.Lex(); // eat the '{'.

  // Parse the object list.
  if (ParseObjectList(CurMultiClass))
    return true;

  if (Lex.getCode() != tgtok::r_brace) {
    TokError("expected '}' at end of '" + Kind + "' clause");
    return Error(BraceLoc, "to match this '{'");
  }

  Lex.Lex(); // Eat the }
}

PopLocalScope(BodyScope);
return false;
3034}

3036/// ParseClass - Parse a tblgen class definition.
3037///
3038///   ClassInst ::= CLASS ID TemplateArgList? ObjectBody
3039///
3040bool TGParser::ParseClass() {
assert(Lex.getCode() == tgtok::Class && "Unexpected token!")((Lex.getCode() == tgtok::Class && "Unexpected token!"
) ? static_cast<void> (0) : __assert_fail ("Lex.getCode() == tgtok::Class && \"Unexpected token!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 3041, __PRETTY_FUNCTION__));
Lex.Lex();

if (Lex.getCode() != tgtok::Id)
  return TokError("expected class name after 'class' keyword");

Record *CurRec = Records.getClass(Lex.getCurStrVal());
if (CurRec) {
  // If the body was previously defined, this is an error.
  if (!CurRec->getValues().empty() ||
      !CurRec->getSuperClasses().empty() ||
      !CurRec->getTemplateArgs().empty())
    return TokError("Class '" + CurRec->getNameInitAsString() +
                    "' already defined");
} else {
  // If this is the first reference to this class, create and add it.
  auto NewRec =
      std::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records,
                                /*Class=*/true);
  CurRec = NewRec.get();
  Records.addClass(std::move(NewRec));
}
Lex.Lex(); // eat the name.

// If there are template args, parse them.
if (Lex.getCode() == tgtok::less)
  if (ParseTemplateArgList(CurRec))
    return true;

return ParseObjectBody(CurRec);
3071}

3073/// ParseLetList - Parse a non-empty list of assignment expressions into a list
3074/// of LetRecords.
3075///
3076///   LetList ::= LetItem (',' LetItem)*
3077///   LetItem ::= ID OptionalRangeList '=' Value
3078///
3079void TGParser::ParseLetList(SmallVectorImpl<LetRecord> &Result) {
while (true) {
  if (Lex.getCode() != tgtok::Id) {
    TokError("expected identifier in let definition");
    Result.clear();
    return;
  }

  StringInit *Name = StringInit::get(Lex.getCurStrVal());
  SMLoc NameLoc = Lex.getLoc();
  Lex.Lex();  // Eat the identifier.

  // Check for an optional RangeList.
  SmallVector<unsigned, 16> Bits;
  if (ParseOptionalRangeList(Bits)) {
    Result.clear();
    return;
  }
  std::reverse(Bits.begin(), Bits.end());

  if (Lex.getCode() != tgtok::equal) {
    TokError("expected '=' in let expression");
    Result.clear();
    return;
  }
  Lex.Lex();  // eat the '='.

  Init *Val = ParseValue(nullptr);
  if (!Val) {
    Result.clear();
    return;
  }

  // Now that we have everything, add the record.
  Result.emplace_back(Name, Bits, Val, NameLoc);

  if (Lex.getCode() != tgtok::comma)
    return;
  Lex.Lex();  // eat the comma.
}
3119}

3121/// ParseTopLevelLet - Parse a 'let' at top level.  This can be a couple of
3122/// different related productions. This works inside multiclasses too.
3123///
3124///   Object ::= LET LetList IN '{' ObjectList '}'
3125///   Object ::= LET LetList IN Object
3126///
3127bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) {
assert(Lex.getCode() == tgtok::Let && "Unexpected token")((Lex.getCode() == tgtok::Let && "Unexpected token") ?
 static_cast<void> (0) : __assert_fail ("Lex.getCode() == tgtok::Let && \"Unexpected token\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 3128, __PRETTY_FUNCTION__));
Lex.Lex();

// Add this entry to the let stack.
SmallVector<LetRecord, 8> LetInfo;
ParseLetList(LetInfo);
if (LetInfo.empty()) return true;
LetStack.push_back(std::move(LetInfo));

if (Lex.getCode() != tgtok::In)
  return TokError("expected 'in' at end of top-level 'let'");
Lex.Lex();

TGLocalVarScope *LetScope = PushLocalScope();

// If this is a scalar let, just handle it now
if (Lex.getCode() != tgtok::l_brace) {
  // LET LetList IN Object
  if (ParseObject(CurMultiClass))
    return true;
} else {   // Object ::= LETCommand '{' ObjectList '}'
  SMLoc BraceLoc = Lex.getLoc();
  // Otherwise, this is a group let.
  Lex.Lex();  // eat the '{'.

  // Parse the object list.
  if (ParseObjectList(CurMultiClass))
    return true;

  if (Lex.getCode() != tgtok::r_brace) {
    TokError("expected '}' at end of top level let command");
    return Error(BraceLoc, "to match this '{'");
  }
  Lex.Lex();
}

PopLocalScope(LetScope);

// Outside this let scope, this let block is not active.
LetStack.pop_back();
return false;
3169}

3171/// ParseMultiClass - Parse a multiclass definition.
3172///
3173///  MultiClassInst ::= MULTICLASS ID TemplateArgList?
3174///                     ':' BaseMultiClassList '{' MultiClassObject+ '}'
3175///  MultiClassObject ::= DefInst
3176///  MultiClassObject ::= MultiClassInst
3177///  MultiClassObject ::= DefMInst
3178///  MultiClassObject ::= LETCommand '{' ObjectList '}'
3179///  MultiClassObject ::= LETCommand Object
3180///
3181bool TGParser::ParseMultiClass() {
assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token")((Lex.getCode() == tgtok::MultiClass && "Unexpected token"
) ? static_cast<void> (0) : __assert_fail ("Lex.getCode() == tgtok::MultiClass && \"Unexpected token\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 3182, __PRETTY_FUNCTION__));
Lex.Lex();  // Eat the multiclass token.

if (Lex.getCode() != tgtok::Id)
  return TokError("expected identifier after multiclass for name");
std::string Name = Lex.getCurStrVal();

auto Result =
  MultiClasses.insert(std::make_pair(Name,
                  std::make_unique<MultiClass>(Name, Lex.getLoc(),Records)));

if (!Result.second)
  return TokError("multiclass '" + Name + "' already defined");

CurMultiClass = Result.first->second.get();
Lex.Lex();  // Eat the identifier.

// If there are template args, parse them.
if (Lex.getCode() == tgtok::less)
  if (ParseTemplateArgList(nullptr))
    return true;

bool inherits = false;

// If there are submulticlasses, parse them.
if (Lex.getCode() == tgtok::colon) {
  inherits = true;

  Lex.Lex();

  // Read all of the submulticlasses.
  SubMultiClassReference SubMultiClass =
    ParseSubMultiClassReference(CurMultiClass);
  while (true) {
    // Check for error.
    if (!SubMultiClass.MC) return true;

    // Add it.
    if (AddSubMultiClass(CurMultiClass, SubMultiClass))
      return true;

    if (Lex.getCode() != tgtok::comma) break;
    Lex.Lex(); // eat ','.
    SubMultiClass = ParseSubMultiClassReference(CurMultiClass);
  }
}

if (Lex.getCode() != tgtok::l_brace) {
  if (!inherits)
    return TokError("expected '{' in multiclass definition");
  if (Lex.getCode() != tgtok::semi)
    return TokError("expected ';' in multiclass definition");
  Lex.Lex();  // eat the ';'.
} else {
  if (Lex.Lex() == tgtok::r_brace)  // eat the '{'.
    return TokError("multiclass must contain at least one def");

  // A multiclass body introduces a new scope for local variables.
  TGLocalVarScope *MulticlassScope = PushLocalScope();

  while (Lex.getCode() != tgtok::r_brace) {
    switch (Lex.getCode()) {
    default:
      return TokError("expected 'let', 'def', 'defm', 'defvar', 'foreach' "
                      "or 'if' in multiclass body");
    case tgtok::Let:
    case tgtok::Def:
    case tgtok::Defm:
    case tgtok::Defvar:
    case tgtok::Foreach:
    case tgtok::If:
      if (ParseObject(CurMultiClass))
        return true;
      break;
    }
  }
  Lex.Lex();  // eat the '}'.

  PopLocalScope(MulticlassScope);
}

CurMultiClass = nullptr;
return false;
3265}

3267/// ParseDefm - Parse the instantiation of a multiclass.
3268///
3269///   DefMInst ::= DEFM ID ':' DefmSubClassRef ';'
3270///
3271bool TGParser::ParseDefm(MultiClass *CurMultiClass) {
assert(Lex.getCode() == tgtok::Defm && "Unexpected token!")((Lex.getCode() == tgtok::Defm && "Unexpected token!"
) ? static_cast<void> (0) : __assert_fail ("Lex.getCode() == tgtok::Defm && \"Unexpected token!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 3272, __PRETTY_FUNCTION__));
Lex.Lex(); // eat the defm

Init *DefmName = ParseObjectName(CurMultiClass);
if (!DefmName)
  return true;
if (isa<UnsetInit>(DefmName)) {
  DefmName = Records.getNewAnonymousName();
  if (CurMultiClass)
    DefmName = BinOpInit::getStrConcat(
        VarInit::get(QualifiedNameOfImplicitName(CurMultiClass),
                     StringRecTy::get()),
        DefmName);
}

if (Lex.getCode() != tgtok::colon)
  return TokError("expected ':' after defm identifier");

// Keep track of the new generated record definitions.
std::vector<RecordsEntry> NewEntries;

// This record also inherits from a regular class (non-multiclass)?
bool InheritFromClass = false;

// eat the colon.
Lex.Lex();

SMLoc SubClassLoc = Lex.getLoc();
SubClassReference Ref = ParseSubClassReference(nullptr, true);

while (true) {
  if (!Ref.Rec) return true;

  // To instantiate a multiclass, we need to first get the multiclass, then
  // instantiate each def contained in the multiclass with the SubClassRef
  // template parameters.
  MultiClass *MC = MultiClasses[std::string(Ref.Rec->getName())].get();
  assert(MC && "Didn't lookup multiclass correctly?")((MC && "Didn't lookup multiclass correctly?") ? static_cast
<void> (0) : __assert_fail ("MC && \"Didn't lookup multiclass correctly?\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/TableGen/TGParser.cpp"
, 3309, __PRETTY_FUNCTION__));
  ArrayRef<Init*> TemplateVals = Ref.TemplateArgs;

  // Verify that the correct number of template arguments were specified.
  ArrayRef<Init *> TArgs = MC->Rec.getTemplateArgs();
  if (TArgs.size() < TemplateVals.size())
    return Error(SubClassLoc,
                 "more template args specified than multiclass expects");

  SubstStack Substs;
  for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
    if (i < TemplateVals.size()) {
      Substs.emplace_back(TArgs[i], TemplateVals[i]);
    } else {
      Init *Default = MC->Rec.getValue(TArgs[i])->getValue();
      if (!Default->isComplete()) {
        return Error(SubClassLoc,
                     "value not specified for template argument #" +
                         Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
                         ") of multiclass '" + MC->Rec.getNameInitAsString() +
                         "'");
      }
      Substs.emplace_back(TArgs[i], Default);
    }
  }

  Substs.emplace_back(QualifiedNameOfImplicitName(MC), DefmName);

  if (resolve(MC->Entries, Substs, CurMultiClass == nullptr, &NewEntries,
              &SubClassLoc))
    return true;

  if (Lex.getCode() != tgtok::comma) break;
  Lex.Lex(); // eat ','.

  if (Lex.getCode() != tgtok::Id)
    return TokError("expected identifier");

  SubClassLoc = Lex.getLoc();

  // A defm can inherit from regular classes (non-multiclass) as
  // long as they come in the end of the inheritance list.
  InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != nullptr);

  if (InheritFromClass)
    break;

  Ref = ParseSubClassReference(nullptr, true);
}

if (InheritFromClass) {
  // Process all the classes to inherit as if they were part of a
  // regular 'def' and inherit all record values.
  SubClassReference SubClass = ParseSubClassReference(nullptr, false);
  while (true) {
    // Check for error.
    if (!SubClass.Rec) return true;

    // Get the expanded definition prototypes and teach them about
    // the record values the current class to inherit has
    for (auto &E : NewEntries) {
      // Add it.
      if (AddSubClass(E, SubClass))
        return true;
    }

    if (Lex.getCode() != tgtok::comma) break;
    Lex.Lex(); // eat ','.
    SubClass = ParseSubClassReference(nullptr, false);
  }
}

for (auto &E : NewEntries) {
  if (ApplyLetStack(E))
    return true;

  addEntry(std::move(E));
}

if (Lex.getCode() != tgtok::semi)
  return TokError("expected ';' at end of defm");
Lex.Lex();

return false;
3393}

3395/// ParseObject
3396///   Object ::= ClassInst
3397///   Object ::= DefInst
3398///   Object ::= MultiClassInst
3399///   Object ::= DefMInst
3400///   Object ::= LETCommand '{' ObjectList '}'
3401///   Object ::= LETCommand Object
3402///   Object ::= Defset
3403///   Object ::= Defvar
3404bool TGParser::ParseObject(MultiClass *MC) {
switch (Lex.getCode()) {
default:
  return TokError("Expected class, def, defm, defset, multiclass, let, "
                  "foreach or if");
case tgtok::Let:   return ParseTopLevelLet(MC);
case tgtok::Def:   return ParseDef(MC);
case tgtok::Foreach:   return ParseForeach(MC);
case tgtok::If:    return ParseIf(MC);
case tgtok::Defm:  return ParseDefm(MC);
case tgtok::Defset:
  if (MC)
    return TokError("defset is not allowed inside multiclass");
  return ParseDefset();
case tgtok::Defvar:
  return ParseDefvar();
case tgtok::Class:
  if (MC)
    return TokError("class is not allowed inside multiclass");
  if (!Loops.empty())
    return TokError("class is not allowed inside foreach loop");
  return ParseClass();
case tgtok::MultiClass:
  if (!Loops.empty())
    return TokError("multiclass is not allowed inside foreach loop");
  return ParseMultiClass();
}
3431}

3433/// ParseObjectList
3434///   ObjectList :== Object*
3435bool TGParser::ParseObjectList(MultiClass *MC) {
while (isObjectStart(Lex.getCode())) {
  if (ParseObject(MC))
    return true;
}
return false;
3441}

3443bool TGParser::ParseFile() {
Lex.Lex(); // Prime the lexer.
if (ParseObjectList()) return true;

// If we have unread input at the end of the file, report it.
if (Lex.getCode() == tgtok::Eof)
  return false;

return TokError("Unexpected input at top level");
3452}

3454#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
3455LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void RecordsEntry::dump() const {
if (Loop)
  Loop->dump();
if (Rec)
  Rec->dump();
3460}

3462LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void ForeachLoop::dump() const {
errs() << "foreach " << IterVar->getAsString() << " = "
       << ListValue->getAsString() << " in {\n";

for (const auto &E : Entries)
  E.dump();

errs() << "}\n";
3470}

3472LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void MultiClass::dump() const {
errs() << "Record:\n";
Rec.dump();

errs() << "Defs:\n";
for (const auto &E : Entries)
  E.dump();
3479}
3480#endif