/build/llvm-toolchain-snapshot-8~svn350071/lib/TableGen/TGParser.cpp

Bug Summary

File:	lib/TableGen/TGParser.cpp
Warning:	line 2042, column 51 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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/lib/TableGen -I /build/llvm-toolchain-snapshot-8~svn350071/lib/TableGen -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn350071/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/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.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++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/lib/TableGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-8~svn350071=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-12-27-042839-1215-1 -x c++ /build/llvm-toolchain-snapshot-8~svn350071/lib/TableGen/TGParser.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn350071/lib/TableGen/TGParser.cpp

→

1//===- TGParser.cpp - Parser for TableGen Files ---------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// Implement the Parser for TableGen.
11//
12//===----------------------------------------------------------------------===//

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

29using namespace llvm;

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

35namespace llvm {

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

SubClassReference() : Rec(nullptr) {}

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

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

SubMultiClassReference() : MC(nullptr) {}

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

58#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
59LLVM_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();
67}
68#endif

70} // end namespace llvm

72static 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;
89}

91static 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());
    }
  }
}
111}

113/// Return an Init with a qualifier prefix referring
114/// to CurRec's name.
115static 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;
129}

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

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

141bool 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;
156}

158/// SetValue -
159/// Return true on error, false on success.
160bool 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;
225}

227/// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
228/// args as SubClass's template arguments.
229bool 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;
290}

292bool 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;
302}

304/// AddSubMultiClass - Add SubMultiClass as a subclass to
305/// CurMC, resolving its template args as SubMultiClass's
306/// template arguments.
307bool 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);
341}

343/// Add a record or foreach loop to the current context (global record keeper,
344/// current inner-most foreach loop, or multiclass).
345bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 346, __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));
365}

367/// Resolve the entries in \p Loop, going over inner loops recursively
368/// and making the given subsitutions of (name, value) pairs.
369///
370/// The resulting records are stored in \p Dest if non-null. Otherwise, they
371/// are added to the global record keeper.
372bool 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(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) {
  Substs.emplace_back(Loop.IterVar->getNameInit(), Elt);
  Error = resolve(Loop.Entries, Substs, Final, Dest);
  Substs.pop_back();
  if (Error)
    break;
}
return Error;
402}

404/// Resolve the entries in \p Source, going over loops recursively and
405/// making the given substitutions of (name, value) pairs.
406///
407/// The resulting records are stored in \p Dest if non-null. Otherwise, they
408/// are added to the global record keeper.
409bool 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 = 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;
435}

437/// Resolve the record fully and add it to the record keeper.
438bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 460, __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;
476}

478//===----------------------------------------------------------------------===//
479// Parser Code
480//===----------------------------------------------------------------------===//

482/// isObjectStart - Return true if this is a valid first token for an Object.
483static 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;
487}

489/// ParseObjectName - If a valid object name is specified, return it. If no
490/// name is specified, return the unset initializer. Return nullptr on parse
491/// error.
492///   ObjectName ::= Value [ '#' Value ]*
493///   ObjectName ::= /*empty*/
494///
495Init *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;
526}

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

Record *Result = Records.getClass(Lex.getCurStrVal());
if (!Result)
  TokError("Couldn't find class '" + Lex.getCurStrVal() + "'");

Lex.Lex();
return Result;
545}

547/// ParseMultiClassID - Parse and resolve a reference to a multiclass name.
548/// This returns null on error.
549///
550///    MultiClassID ::= ID
551///
552MultiClass *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;
564}

566/// ParseSubClassReference - Parse a reference to a subclass or to a templated
567/// subclass.  This returns a SubClassRefTy with a null Record* on error.
568///
569///  SubClassRef ::= ClassID
570///  SubClassRef ::= ClassID '<' ValueList '>'
571///
572SubClassReference TGParser::
573ParseSubClassReference(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;
613}

615/// ParseSubMultiClassReference - Parse a reference to a subclass or to a
616/// templated submulticlass.  This returns a SubMultiClassRefTy with a null
617/// Record* on error.
618///
619///  SubMultiClassRef ::= MultiClassID
620///  SubMultiClassRef ::= MultiClassID '<' ValueList '>'
621///
622SubMultiClassReference TGParser::
623ParseSubMultiClassReference(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;
658}

660/// ParseRangePiece - Parse a bit/value range.
661///   RangePiece ::= INTVAL
662///   RangePiece ::= INTVAL '-' INTVAL
663///   RangePiece ::= INTVAL INTVAL
664bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges) {
if (Lex.getCode() != tgtok::IntVal) {
  TokError("expected integer or bitrange");
  return true;
}
int64_t Start = Lex.getCurIntVal();
int64_t End;

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

switch (Lex.Lex()) {  // eat first character.
default:
  Ranges.push_back(Start);
  return false;
case tgtok::minus:
  if (Lex.Lex() != tgtok::IntVal) {
    TokError("expected integer value as end of range");
    return true;
  }
  End = Lex.getCurIntVal();
  break;
case tgtok::IntVal:
  End = -Lex.getCurIntVal();
  break;
}
if (End < 0)
  return TokError("invalid range, cannot be negative");
Lex.Lex();

// 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;
702}

704/// ParseRangeList - Parse a list of scalars and ranges into scalar values.
705///
706///   RangeList ::= RangePiece (',' RangePiece)*
707///
708void 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;
  }
}
723}

725/// ParseOptionalRangeList - Parse either a range list in <>'s or nothing.
726///   OptionalRangeList ::= '<' RangeList '>'
727///   OptionalRangeList ::= /*empty*/
728bool 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;
745}

747/// ParseOptionalBitList - Parse either a bit list in {}'s or nothing.
748///   OptionalBitList ::= '{' RangeList '}'
749///   OptionalBitList ::= /*empty*/
750bool 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;
767}

769/// ParseType - Parse and return a tblgen type.  This returns null on error.
770///
771///   Type ::= STRING                       // string type
772///   Type ::= CODE                         // code type
773///   Type ::= BIT                          // bit type
774///   Type ::= BITS '<' INTVAL '>'          // bits<x> type
775///   Type ::= INT                          // int type
776///   Type ::= LIST '<' Type '>'            // list<x> type
777///   Type ::= DAG                          // dag type
778///   Type ::= ClassID                      // Record Type
779///
780RecTy *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);
}
}
826}

828/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
829/// has already been read.
830Init *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-8~svn350071/lib/TableGen/TGParser.cpp"
, 848, __PRETTY_FUNCTION__));
    return VarInit::get(TemplateArgName, RV->getType());
  } else if (Name->getValue() == "NAME") {
    return VarInit::get(TemplateArgName, StringRecTy::get());
  }
}

// If this is in a foreach loop, make sure it's not a loop iterator
for (const auto &L : Loops) {
  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;
876}

878/// ParseOperation - Parse an operator.  This returns null on error.
879///
880/// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
881///
882Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
switch (Lex.getCode()) {
default:
  TokError("unknown operation");
  return nullptr;
case tgtok::XHead:
case tgtok::XTail:
case tgtok::XSize:
case tgtok::XEmpty:
case tgtok::XCast: {  // 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 896);
  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;
  }
  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-8~svn350071/lib/TableGen/TGParser.cpp"
, 979, __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::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::XStrConcat: {  // 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 1046);
  case tgtok::XConcat: Code = BinOpInit::CONCAT; break;
  case tgtok::XADD:    Code = BinOpInit::ADD; 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::XStrConcat: Code = BinOpInit::STRCONCAT; break;
  }

  RecTy *Type = nullptr;
  RecTy *ArgType = nullptr;
  switch (OpTok) {
  default:
    llvm_unreachable("Unhandled code!")::llvm::llvm_unreachable_internal("Unhandled code!", "/build/llvm-toolchain-snapshot-8~svn350071/lib/TableGen/TGParser.cpp"
, 1068);
  case tgtok::XConcat:
    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:
    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::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;

    // All BinOps require their arguments to be of compatible types.
    TypedInit *TI = dyn_cast<TypedInit>(InitList.back());
    if (!ArgType) {
      ArgType = TI->getType();

      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::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-8~svn350071/lib/TableGen/TGParser.cpp"
, 1146);
      }
    } else {
      RecTy *Resolved = resolveTypes(ArgType, TI->getType());
      if (!Resolved) {
        Error(InitLoc, Twine("expected value of type '") +
                       ArgType->getAsString() + "', got '" +
                       TI->getType()->getAsString() + "'");
        return nullptr;
      }
      if (Code != BinOpInit::ADD && Code != BinOpInit::AND &&
          Code != BinOpInit::OR && Code != BinOpInit::SRA &&
          Code != BinOpInit::SRL && Code != BinOpInit::SHL)
        ArgType = Resolved;
    }

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

  if (Code == BinOpInit::LISTCONCAT)
    Type = ArgType;

  // 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) {
    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 = 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 1316);
  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-8~svn350071/lib/TableGen/TGParser.cpp"
, 1367);
  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::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 = 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);
}
}
1574}

1576/// ParseOperatorType - Parse a type for an operator.  This returns
1577/// null on error.
1578///
1579/// OperatorType ::= '<' Type '>'
1580///
1581RecTy *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;
1604}

1606/// ParseSimpleValue - Parse a tblgen value.  This returns null on error.
1607///
1608///   SimpleValue ::= IDValue
1609///   SimpleValue ::= INTVAL
1610///   SimpleValue ::= STRVAL+
1611///   SimpleValue ::= CODEFRAGMENT
1612///   SimpleValue ::= '?'
1613///   SimpleValue ::= '{' ValueList '}'
1614///   SimpleValue ::= ID '<' ValueListNE '>'
1615///   SimpleValue ::= '[' ValueList ']'
1616///   SimpleValue ::= '(' IDValue DagArgList ')'
1617///   SimpleValue ::= CONCATTOK '(' Value ',' Value ')'
1618///   SimpleValue ::= ADDTOK '(' Value ',' Value ')'
1619///   SimpleValue ::= SHLTOK '(' Value ',' Value ')'
1620///   SimpleValue ::= SRATOK '(' Value ',' Value ')'
1621///   SimpleValue ::= SRLTOK '(' Value ',' Value ')'
1622///   SimpleValue ::= LISTCONCATTOK '(' Value ',' Value ')'
1623///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
1624///
1625Init *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.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) {
    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:  // Value ::= !unop '(' Value ')'
case tgtok::XIsA:
case tgtok::XConcat:
case tgtok::XDag:
case tgtok::XADD:
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::XStrConcat:   // Value ::= !binop '(' Value ',' Value ')'
case tgtok::XIf:
case tgtok::XFoldl:
case tgtok::XForEach:
case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
  return ParseOperation(CurRec, ItemType);
}
}

return R;
1944}

1946/// ParseValue - Parse a tblgen value.  This returns null on error.
1947///
1948///   Value       ::= SimpleValue ValueSuffix*
1949///   ValueSuffix ::= '{' BitList '}'
1950///   ValueSuffix ::= '[' BitList ']'
1951///   ValueSuffix ::= '.' ID
1952///
1953Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
if (!Result) return nullptr;
23
←
Assuming 'Result' is non-null→
24
←
Taking false branch→

// Parse the suffixes now if present.
while (true) {
25
←
Loop condition is true.  Entering loop body→
  switch (Lex.getCode()) {
26
←
Control jumps to 'case paste:'  at line 2025→
  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();

    // Create a !strconcat() operation, first casting each operand to
    // a string if necessary.

    TypedInit *LHS = dyn_cast<TypedInit>(Result);
    if (!LHS) {
27
←
Assuming 'LHS' is non-null→
28
←
Taking false branch→
      Error(PasteLoc, "LHS of paste is not typed!");
      return nullptr;
    }

    if (LHS->getType() != StringRecTy::get()) {
29
←
Taking true branch→
      LHS = dyn_cast<TypedInit>(
30
←
Calling 'dyn_cast<llvm::TypedInit, llvm::Init>'→
35
←
Returning from 'dyn_cast<llvm::TypedInit, llvm::Init>'→
36
←
Value assigned to 'LHS'→
          UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get())
              ->Fold(CurRec));
      if (!LHS) {
37
←
Assuming 'LHS' is null→
38
←
Taking true branch→
        Error(PasteLoc, Twine("can't cast '") + LHS->getAsString() +
39
←
Called C++ object pointer is null
                            "' to string");
        return nullptr;
      }
    }

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

      break;
    }

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

2091/// ParseDagArgList - Parse the argument list for a dag literal expression.
2092///
2093///    DagArg     ::= Value (':' VARNAME)?
2094///    DagArg     ::= VARNAME
2095///    DagArgList ::= DagArg
2096///    DagArgList ::= DagArgList ',' DagArg
2097void 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 ','
}
2133}

2135/// ParseValueList - Parse a comma separated list of values, returning them as a
2136/// vector.  Note that this always expects to be able to parse at least one
2137/// value.  It returns an empty list if this is not possible.
2138///
2139///   ValueList ::= Value (',' Value)
2140///
2141void 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2157, __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

  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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2178, __PRETTY_FUNCTION__));
    ItemType = RV->getType();
    ++ArgN;
  }
  Result.push_back(ParseValue(CurRec, ItemType));
  if (!Result.back()) {
    Result.clear();
    return;
  }
}
2188}

2190/// ParseDeclaration - Read a declaration, returning the name of field ID, or an
2191/// empty string on error.  This can happen in a number of different context's,
2192/// including within a def or in the template args for a def (which which case
2193/// CurRec will be non-null) and within the template args for a multiclass (in
2194/// which case CurRec will be null, but CurMultiClass will be set).  This can
2195/// also happen within a def that is within a multiclass, which will set both
2196/// CurRec and CurMultiClass.
2197///
2198///  Declaration ::= FIELD? Type ID ('=' Value)?
2199///
2200Init *TGParser::ParseDeclaration(Record *CurRec,
                                     bool ParsingTemplateArgs) {
// Read the field prefix if present.
bool HasField = Lex.getCode() == tgtok::Field;
11
←
Assuming the condition is false→
if (HasField) Lex.Lex();
12
←
Taking false branch→

RecTy *Type = ParseType();
if (!Type) return nullptr;
13
←
Assuming 'Type' is non-null→
14
←
Taking false branch→

if (Lex.getCode() != tgtok::Id) {
15
←
Assuming the condition is false→
16
←
Taking false branch→
  TokError("Expected identifier in declaration");
  return nullptr;
}

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

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

if (ParsingTemplateArgs) {
18
←
Taking false branch→
  if (CurRec)
    DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":");
  else
    assert(CurMultiClass)((CurMultiClass) ? static_cast<void> (0) : __assert_fail
 ("CurMultiClass", "/build/llvm-toolchain-snapshot-8~svn350071/lib/TableGen/TGParser.cpp"
, 2228, __PRETTY_FUNCTION__));
  if (CurMultiClass)
    DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName,
                           "::");
}

// Add the value.
if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField)))
19
←
Taking false branch→
  return nullptr;

// If a value is present, parse it.
if (Lex.getCode() == tgtok::equal) {
20
←
Assuming the condition is true→
21
←
Taking true branch→
  Lex.Lex();
  SMLoc ValLoc = Lex.getLoc();
  Init *Val = ParseValue(CurRec, Type);
22
←
Calling 'TGParser::ParseValue'→
  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;
2252}

2254/// ParseForeachDeclaration - Read a foreach declaration, returning
2255/// the name of the declared object or a NULL Init on error.  Return
2256/// the name of the parsed initializer list through ForeachListName.
2257///
2258///  ForeachDeclaration ::= ID '=' '{' RangeList '}'
2259///  ForeachDeclaration ::= ID '=' RangePiece
2260///  ForeachDeclaration ::= ID '=' Value
2261///
2262VarInit *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::IntVal: { // RangePiece.
  if (ParseRangePiece(Ranges))
    return nullptr;
  break;
}

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);
  TypedInit *TI = dyn_cast<TypedInit>(I);
  if (!TI || !isa<ListRecTy>(TI->getType())) {
    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;
  }
  ForeachListValue = I;
  IterType = cast<ListRecTy>(TI->getType())->getElementType();
  break;
}
}

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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2320, __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);
2332}

2334/// ParseTemplateArgList - Read a template argument list, which is a non-empty
2335/// sequence of template-declarations in <>'s.  If CurRec is non-null, these are
2336/// template args for a def, which may or may not be in a multiclass.  If null,
2337/// these are the template args for a multiclass.
2338///
2339///    TemplateArgList ::= '<' Declaration (',' Declaration)* '>'
2340///
2341bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2342, __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;
2374}

2376/// ParseBodyItem - Parse a single item at within the body of a def or class.
2377///
2378///   BodyItem ::= Declaration ';'
2379///   BodyItem ::= LET ID OptionalBitList '=' Value ';'
2380bool TGParser::ParseBodyItem(Record *CurRec) {
if (Lex.getCode() != tgtok::Let) {
8
←
Assuming the condition is true→
9
←
Taking true branch→
  if (!ParseDeclaration(CurRec, false))
10
←
Calling 'TGParser::ParseDeclaration'→
    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();

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);
2422}

2424/// ParseBody - Read the body of a class or def.  Return true on error, false on
2425/// success.
2426///
2427///   Body     ::= ';'
2428///   Body     ::= '{' BodyList '}'
2429///   BodyList BodyItem*
2430///
2431bool TGParser::ParseBody(Record *CurRec) {
// If this is a null definition, just eat the semi and return.
if (Lex.getCode() == tgtok::semi) {
1
Assuming the condition is false→
2
←
Taking false branch→
  Lex.Lex();
  return false;
}

if (Lex.getCode() != tgtok::l_brace)
3
←
Assuming the condition is false→
4
←
Taking false branch→
  return TokError("Expected ';' or '{' to start body");
// Eat the '{'.
Lex.Lex();

while (Lex.getCode() != tgtok::r_brace)
5
←
Assuming the condition is true→
6
←
Loop condition is true.  Entering loop body→
  if (ParseBodyItem(CurRec))
7
←
Calling 'TGParser::ParseBodyItem'→
    return true;

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

2452/// Apply the current let bindings to \a CurRec.
2453/// \returns true on error, false otherwise.
2454bool 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;
2460}

2462bool 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;
2472}

2474/// ParseObjectBody - Parse the body of a def or class.  This consists of an
2475/// optional ClassList followed by a Body.  CurRec is the current def or class
2476/// that is being parsed.
2477///
2478///   ObjectBody      ::= BaseClassList Body
2479///   BaseClassList   ::= /*empty*/
2480///   BaseClassList   ::= ':' BaseClassListNE
2481///   BaseClassListNE ::= SubClassRef (',' SubClassRef)*
2482///
2483bool 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);
2508}

2510/// ParseDef - Parse and return a top level or multiclass def, return the record
2511/// corresponding to it.  This returns null on error.
2512///
2513///   DefInst ::= DEF ObjectName ObjectBody
2514///
2515bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2517, __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 = make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records,
                               /*Anonymous=*/true);
else
  CurRec = make_unique<Record>(Name, DefLoc, Records);

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

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

2538/// ParseDefset - Parse a defset statement.
2539///
2540///   Defset ::= DEFSET Type Id '=' '{' ObjectList '}'
2541///
2542bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2543, __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;
2583}

2585/// ParseForeach - Parse a for statement.  Return the record corresponding
2586/// to it.  This returns true on error.
2587///
2588///   Foreach ::= FOREACH Declaration IN '{ ObjectList '}'
2589///   Foreach ::= FOREACH Declaration IN Object
2590///
2591bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2593, __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(llvm::make_unique<ForeachLoop>(Loc, IterName, ListValue));

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 }
}

// 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));
2635}

2637/// ParseClass - Parse a tblgen class definition.
2638///
2639///   ClassInst ::= CLASS ID TemplateArgList? ObjectBody
2640///
2641bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2642, __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 =
      llvm::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);
2672}

2674/// ParseLetList - Parse a non-empty list of assignment expressions into a list
2675/// of LetRecords.
2676///
2677///   LetList ::= LetItem (',' LetItem)*
2678///   LetItem ::= ID OptionalRangeList '=' Value
2679///
2680void 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.
}
2720}

2722/// ParseTopLevelLet - Parse a 'let' at top level.  This can be a couple of
2723/// different related productions. This works inside multiclasses too.
2724///
2725///   Object ::= LET LetList IN '{' ObjectList '}'
2726///   Object ::= LET LetList IN Object
2727///
2728bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2729, __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();

// 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();
}

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

2768/// ParseMultiClass - Parse a multiclass definition.
2769///
2770///  MultiClassInst ::= MULTICLASS ID TemplateArgList?
2771///                     ':' BaseMultiClassList '{' MultiClassObject+ '}'
2772///  MultiClassObject ::= DefInst
2773///  MultiClassObject ::= MultiClassInst
2774///  MultiClassObject ::= DefMInst
2775///  MultiClassObject ::= LETCommand '{' ObjectList '}'
2776///  MultiClassObject ::= LETCommand Object
2777///
2778bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2779, __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,
                  llvm::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");

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

CurMultiClass = nullptr;
return false;
2855}

2857/// ParseDefm - Parse the instantiation of a multiclass.
2858///
2859///   DefMInst ::= DEFM ID ':' DefmSubClassRef ';'
2860///
2861bool 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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2862, __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[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-8~svn350071/lib/TableGen/TGParser.cpp"
, 2899, __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;
2983}

2985/// ParseObject
2986///   Object ::= ClassInst
2987///   Object ::= DefInst
2988///   Object ::= MultiClassInst
2989///   Object ::= DefMInst
2990///   Object ::= LETCommand '{' ObjectList '}'
2991///   Object ::= LETCommand Object
2992bool TGParser::ParseObject(MultiClass *MC) {
switch (Lex.getCode()) {
default:
  return TokError("Expected class, def, defm, defset, multiclass, let or "
                  "foreach");
case tgtok::Let:   return ParseTopLevelLet(MC);
case tgtok::Def:   return ParseDef(MC);
case tgtok::Foreach:   return ParseForeach(MC);
case tgtok::Defm:  return ParseDefm(MC);
case tgtok::Defset:
  if (MC)
    return TokError("defset is not allowed inside multiclass");
  return ParseDefset();
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();
}
3016}

3018/// ParseObjectList
3019///   ObjectList :== Object*
3020bool TGParser::ParseObjectList(MultiClass *MC) {
while (isObjectStart(Lex.getCode())) {
  if (ParseObject(MC))
    return true;
}
return false;
3026}

3028bool 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");
3037}

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

3047LLVM_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";
3055}

3057LLVM_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();
3064}
3065#endif

←

/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h

1//===- llvm/Support/Casting.h - Allow flexible, checked, casts --*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(), cast_or_null<X>(),
11// and dyn_cast_or_null<X>() templates.
12//
13//===----------------------------------------------------------------------===//
14 
15#ifndef LLVM_SUPPORT_CASTING_H
16#define LLVM_SUPPORT_CASTING_H
17 
18#include "llvm/Support/Compiler.h"
19#include "llvm/Support/type_traits.h"
20#include <cassert>
21#include <memory>
22#include <type_traits>
23 
24namespace llvm {
25 
26//===----------------------------------------------------------------------===//
27//                          isa<x> Support Templates
28//===----------------------------------------------------------------------===//
29 
30// Define a template that can be specialized by smart pointers to reflect the
31// fact that they are automatically dereferenced, and are not involved with the
32// template selection process...  the default implementation is a noop.
33//
34template<typename From> struct simplify_type {
35  using SimpleType = From; // The real type this represents...
36 
37  // An accessor to get the real value...
38  static SimpleType &getSimplifiedValue(From &Val) { return Val; }
39};
40 
41template<typename From> struct simplify_type<const From> {
42  using NonConstSimpleType = typename simplify_type<From>::SimpleType;
43  using SimpleType =
44      typename add_const_past_pointer<NonConstSimpleType>::type;
45  using RetType =
46      typename add_lvalue_reference_if_not_pointer<SimpleType>::type;
47 
48  static RetType getSimplifiedValue(const From& Val) {
49    return simplify_type<From>::getSimplifiedValue(const_cast<From&>(Val));
50  }
51};
52 
53// The core of the implementation of isa<X> is here; To and From should be
54// the names of classes.  This template can be specialized to customize the
55// implementation of isa<> without rewriting it from scratch.
56template <typename To, typename From, typename Enabler = void>
57struct isa_impl {
58  static inline bool doit(const From &Val) {
59    return To::classof(&Val);
60  }
61};
62 
63/// Always allow upcasts, and perform no dynamic check for them.
64template <typename To, typename From>
65struct isa_impl<
66    To, From, typename std::enable_if<std::is_base_of<To, From>::value>::type> {
67  static inline bool doit(const From &) { return true; }
68};
69 
70template <typename To, typename From> struct isa_impl_cl {
71  static inline bool doit(const From &Val) {
72    return isa_impl<To, From>::doit(Val);
73  }
74};
75 
76template <typename To, typename From> struct isa_impl_cl<To, const From> {
77  static inline bool doit(const From &Val) {
78    return isa_impl<To, From>::doit(Val);
79  }
80};
81 
82template <typename To, typename From>
83struct isa_impl_cl<To, const std::unique_ptr<From>> {
84  static inline bool doit(const std::unique_ptr<From> &Val) {
85    assert(Val && "isa<> used on a null pointer")((Val && "isa<> used on a null pointer") ? static_cast
<void> (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 85, __PRETTY_FUNCTION__));
86    return isa_impl_cl<To, From>::doit(*Val);
87  }
88};
89 
90template <typename To, typename From> struct isa_impl_cl<To, From*> {
91  static inline bool doit(const From *Val) {
92    assert(Val && "isa<> used on a null pointer")((Val && "isa<> used on a null pointer") ? static_cast
<void> (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 92, __PRETTY_FUNCTION__));
93    return isa_impl<To, From>::doit(*Val);
94  }
95};
96 
97template <typename To, typename From> struct isa_impl_cl<To, From*const> {
98  static inline bool doit(const From *Val) {
99    assert(Val && "isa<> used on a null pointer")((Val && "isa<> used on a null pointer") ? static_cast
<void> (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 99, __PRETTY_FUNCTION__));
100    return isa_impl<To, From>::doit(*Val);
101  }
102};
103 
104template <typename To, typename From> struct isa_impl_cl<To, const From*> {
105  static inline bool doit(const From *Val) {
106    assert(Val && "isa<> used on a null pointer")((Val && "isa<> used on a null pointer") ? static_cast
<void> (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 106, __PRETTY_FUNCTION__));
107    return isa_impl<To, From>::doit(*Val);
108  }
109};
110 
111template <typename To, typename From> struct isa_impl_cl<To, const From*const> {
112  static inline bool doit(const From *Val) {
113    assert(Val && "isa<> used on a null pointer")((Val && "isa<> used on a null pointer") ? static_cast
<void> (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 113, __PRETTY_FUNCTION__));
114    return isa_impl<To, From>::doit(*Val);
115  }
116};
117 
118template<typename To, typename From, typename SimpleFrom>
119struct isa_impl_wrap {
120  // When From != SimplifiedType, we can simplify the type some more by using
121  // the simplify_type template.
122  static bool doit(const From &Val) {
123    return isa_impl_wrap<To, SimpleFrom,
124      typename simplify_type<SimpleFrom>::SimpleType>::doit(
125                          simplify_type<const From>::getSimplifiedValue(Val));
126  }
127};
128 
129template<typename To, typename FromTy>
130struct isa_impl_wrap<To, FromTy, FromTy> {
131  // When From == SimpleType, we are as simple as we are going to get.
132  static bool doit(const FromTy &Val) {
133    return isa_impl_cl<To,FromTy>::doit(Val);
134  }
135};
136 
137// isa<X> - Return true if the parameter to the template is an instance of the
138// template type argument.  Used like this:
139//
140//  if (isa<Type>(myVal)) { ... }
141//
142template <class X, class Y> LLVM_NODISCARD[[clang::warn_unused_result]] inline bool isa(const Y &Val) {
143  return isa_impl_wrap<X, const Y,
144                       typename simplify_type<const Y>::SimpleType>::doit(Val);
145}
146 
147//===----------------------------------------------------------------------===//
148//                          cast<x> Support Templates
149//===----------------------------------------------------------------------===//
150 
151template<class To, class From> struct cast_retty;
152 
153// Calculate what type the 'cast' function should return, based on a requested
154// type of To and a source type of From.
155template<class To, class From> struct cast_retty_impl {
156  using ret_type = To &;       // Normal case, return Ty&
157};
158template<class To, class From> struct cast_retty_impl<To, const From> {
159  using ret_type = const To &; // Normal case, return Ty&
160};
161 
162template<class To, class From> struct cast_retty_impl<To, From*> {
163  using ret_type = To *;       // Pointer arg case, return Ty*
164};
165 
166template<class To, class From> struct cast_retty_impl<To, const From*> {
167  using ret_type = const To *; // Constant pointer arg case, return const Ty*
168};
169 
170template<class To, class From> struct cast_retty_impl<To, const From*const> {
171  using ret_type = const To *; // Constant pointer arg case, return const Ty*
172};
173 
174template <class To, class From>
175struct cast_retty_impl<To, std::unique_ptr<From>> {
176private:
177  using PointerType = typename cast_retty_impl<To, From *>::ret_type;
178  using ResultType = typename std::remove_pointer<PointerType>::type;
179 
180public:
181  using ret_type = std::unique_ptr<ResultType>;
182};
183 
184template<class To, class From, class SimpleFrom>
185struct cast_retty_wrap {
186  // When the simplified type and the from type are not the same, use the type
187  // simplifier to reduce the type, then reuse cast_retty_impl to get the
188  // resultant type.
189  using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
190};
191 
192template<class To, class FromTy>
193struct cast_retty_wrap<To, FromTy, FromTy> {
194  // When the simplified type is equal to the from type, use it directly.
195  using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
196};
197 
198template<class To, class From>
199struct cast_retty {
200  using ret_type = typename cast_retty_wrap<
201      To, From, typename simplify_type<From>::SimpleType>::ret_type;
202};
203 
204// Ensure the non-simple values are converted using the simplify_type template
205// that may be specialized by smart pointers...
206//
207template<class To, class From, class SimpleFrom> struct cast_convert_val {
208  // This is not a simple type, use the template to simplify it...
209  static typename cast_retty<To, From>::ret_type doit(From &Val) {
210    return cast_convert_val<To, SimpleFrom,
211      typename simplify_type<SimpleFrom>::SimpleType>::doit(
212                          simplify_type<From>::getSimplifiedValue(Val));
213  }
214};
215 
216template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
217  // This _is_ a simple type, just cast it.
218  static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
219    typename cast_retty<To, FromTy>::ret_type Res2
220     = (typename cast_retty<To, FromTy>::ret_type)const_cast<FromTy&>(Val);
221    return Res2;
222  }
223};
224 
225template <class X> struct is_simple_type {
226  static const bool value =
227      std::is_same<X, typename simplify_type<X>::SimpleType>::value;
228};
229 
230// cast<X> - Return the argument parameter cast to the specified type.  This
231// casting operator asserts that the type is correct, so it does not return null
232// on failure.  It does not allow a null argument (use cast_or_null for that).
233// It is typically used like this:
234//
235//  cast<Instruction>(myVal)->getParent()
236//
237template <class X, class Y>
238inline typename std::enable_if<!is_simple_type<Y>::value,
239                               typename cast_retty<X, const Y>::ret_type>::type
240cast(const Y &Val) {
241  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!")((isa<X>(Val) && "cast<Ty>() argument of incompatible type!"
) ? static_cast<void> (0) : __assert_fail ("isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 241, __PRETTY_FUNCTION__));
242  return cast_convert_val<
243      X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
244}
245 
246template <class X, class Y>
247inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
248  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!")((isa<X>(Val) && "cast<Ty>() argument of incompatible type!"
) ? static_cast<void> (0) : __assert_fail ("isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 248, __PRETTY_FUNCTION__));
249  return cast_convert_val<X, Y,
250                          typename simplify_type<Y>::SimpleType>::doit(Val);
251}
252 
253template <class X, class Y>
254inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
255  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!")((isa<X>(Val) && "cast<Ty>() argument of incompatible type!"
) ? static_cast<void> (0) : __assert_fail ("isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 255, __PRETTY_FUNCTION__));
256  return cast_convert_val<X, Y*,
257                          typename simplify_type<Y*>::SimpleType>::doit(Val);
258}
259 
260template <class X, class Y>
261inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
262cast(std::unique_ptr<Y> &&Val) {
263  assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!")((isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!"
) ? static_cast<void> (0) : __assert_fail ("isa<X>(Val.get()) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 263, __PRETTY_FUNCTION__));
264  using ret_type = typename cast_retty<X, std::unique_ptr<Y>>::ret_type;
265  return ret_type(
266      cast_convert_val<X, Y *, typename simplify_type<Y *>::SimpleType>::doit(
267          Val.release()));
268}
269 
270// cast_or_null<X> - Functionally identical to cast, except that a null value is
271// accepted.
272//
273template <class X, class Y>
274LLVM_NODISCARD[[clang::warn_unused_result]] inline
275    typename std::enable_if<!is_simple_type<Y>::value,
276                            typename cast_retty<X, const Y>::ret_type>::type
277    cast_or_null(const Y &Val) {
278  if (!Val)
279    return nullptr;
280  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!")((isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!"
) ? static_cast<void> (0) : __assert_fail ("isa<X>(Val) && \"cast_or_null<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 280, __PRETTY_FUNCTION__));
281  return cast<X>(Val);
282}
283 
284template <class X, class Y>
285LLVM_NODISCARD[[clang::warn_unused_result]] inline
286    typename std::enable_if<!is_simple_type<Y>::value,
287                            typename cast_retty<X, Y>::ret_type>::type
288    cast_or_null(Y &Val) {
289  if (!Val)
290    return nullptr;
291  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!")((isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!"
) ? static_cast<void> (0) : __assert_fail ("isa<X>(Val) && \"cast_or_null<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 291, __PRETTY_FUNCTION__));
292  return cast<X>(Val);
293}
294 
295template <class X, class Y>
296LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type
297cast_or_null(Y *Val) {
298  if (!Val) return nullptr;
299  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!")((isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!"
) ? static_cast<void> (0) : __assert_fail ("isa<X>(Val) && \"cast_or_null<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/Support/Casting.h"
, 299, __PRETTY_FUNCTION__));
300  return cast<X>(Val);
301}
302 
303template <class X, class Y>
304inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
305cast_or_null(std::unique_ptr<Y> &&Val) {
306  if (!Val)
307    return nullptr;
308  return cast<X>(std::move(Val));
309}
310 
311// dyn_cast<X> - Return the argument parameter cast to the specified type.  This
312// casting operator returns null if the argument is of the wrong type, so it can
313// be used to test for a type as well as cast if successful.  This should be
314// used in the context of an if statement like this:
315//
316//  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
317//
318 
319template <class X, class Y>
320LLVM_NODISCARD[[clang::warn_unused_result]] inline
321    typename std::enable_if<!is_simple_type<Y>::value,
322                            typename cast_retty<X, const Y>::ret_type>::type
323    dyn_cast(const Y &Val) {
324  return isa<X>(Val) ? cast<X>(Val) : nullptr;
325}
326 
327template <class X, class Y>
328LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
329  return isa<X>(Val) ? cast<X>(Val) : nullptr;
330}
331 
332template <class X, class Y>
333LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
334  return isa<X>(Val) ? cast<X>(Val) : nullptr;
31
←
Assuming the condition is true→
32
←
'?' condition is true→
33
←
Assigning value→
34
←
Returning pointer→
335}
336 
337// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
338// value is accepted.
339//
340template <class X, class Y>
341LLVM_NODISCARD[[clang::warn_unused_result]] inline
342    typename std::enable_if<!is_simple_type<Y>::value,
343                            typename cast_retty<X, const Y>::ret_type>::type
344    dyn_cast_or_null(const Y &Val) {
345  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
346}
347 
348template <class X, class Y>
349LLVM_NODISCARD[[clang::warn_unused_result]] inline
350    typename std::enable_if<!is_simple_type<Y>::value,
351                            typename cast_retty<X, Y>::ret_type>::type
352    dyn_cast_or_null(Y &Val) {
353  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
354}
355 
356template <class X, class Y>
357LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type
358dyn_cast_or_null(Y *Val) {
359  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
360}
361 
362// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
363// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
364// cast is successful, From refers to nullptr on exit and the casted value
365// is returned.  If the cast is unsuccessful, the function returns nullptr
366// and From is unchanged.
367template <class X, class Y>
368LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast(std::unique_ptr<Y> &Val)
369    -> decltype(cast<X>(Val)) {
370  if (!isa<X>(Val))
371    return nullptr;
372  return cast<X>(std::move(Val));
373}
374 
375template <class X, class Y>
376LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val)
377    -> decltype(cast<X>(Val)) {
378  return unique_dyn_cast<X, Y>(Val);
379}
380 
381// dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast, except that
382// a null value is accepted.
383template <class X, class Y>
384LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &Val)
385    -> decltype(cast<X>(Val)) {
386  if (!Val)
387    return nullptr;
388  return unique_dyn_cast<X, Y>(Val);
389}
390 
391template <class X, class Y>
392LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val)
393    -> decltype(cast<X>(Val)) {
394  return unique_dyn_cast_or_null<X, Y>(Val);
395}
396 
397} // end namespace llvm
398 
399#endif // LLVM_SUPPORT_CASTING_H