/build/source/llvm/lib/TableGen/Record.cpp

Bug Summary

File:	build/source/llvm/lib/TableGen/Record.cpp
Warning:	line 1780, column 51 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name Record.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm -resource-dir /usr/lib/llvm-16/lib/clang/16 -I lib/TableGen -I /build/source/llvm/lib/TableGen -I include -I /build/source/llvm/include -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm=build-llvm -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm=build-llvm -fcoverage-prefix-map=/build/source/= -source-date-epoch 1674602410 -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-01-25-024556-16494-1 -x c++ /build/source/llvm/lib/TableGen/Record.cpp
1//===- Record.cpp - Record implementation ---------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Implement the tablegen record classes.
10//
11//===----------------------------------------------------------------------===//

13#include "llvm/TableGen/Record.h"
14#include "llvm/ADT/ArrayRef.h"
15#include "llvm/ADT/DenseMap.h"
16#include "llvm/ADT/FoldingSet.h"
17#include "llvm/ADT/SmallString.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/ADT/StringMap.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/Config/llvm-config.h"
23#include "llvm/Support/Allocator.h"
24#include "llvm/Support/Casting.h"
25#include "llvm/Support/Compiler.h"
26#include "llvm/Support/ErrorHandling.h"
27#include "llvm/Support/MathExtras.h"
28#include "llvm/Support/SMLoc.h"
29#include "llvm/Support/raw_ostream.h"
30#include "llvm/TableGen/Error.h"
31#include <cassert>
32#include <cstdint>
33#include <map>
34#include <memory>
35#include <string>
36#include <utility>
37#include <vector>

39using namespace llvm;

41#define DEBUG_TYPE"tblgen-records" "tblgen-records"

43//===----------------------------------------------------------------------===//
44//    Context
45//===----------------------------------------------------------------------===//

47namespace llvm {
48namespace detail {
49/// This class represents the internal implementation of the RecordKeeper.
50/// It contains all of the contextual static state of the Record classes. It is
51/// kept out-of-line to simplify dependencies, and also make it easier for
52/// internal classes to access the uniquer state of the keeper.
53struct RecordKeeperImpl {
RecordKeeperImpl(RecordKeeper &RK)
    : SharedBitRecTy(RK), SharedIntRecTy(RK), SharedStringRecTy(RK),
      SharedDagRecTy(RK), AnyRecord(RK, 0), TheUnsetInit(RK),
      TrueBitInit(true, &SharedBitRecTy),
      FalseBitInit(false, &SharedBitRecTy), StringInitStringPool(Allocator),
      StringInitCodePool(Allocator), AnonCounter(0), LastRecordID(0) {}

BumpPtrAllocator Allocator;
std::vector<BitsRecTy *> SharedBitsRecTys;
BitRecTy SharedBitRecTy;
IntRecTy SharedIntRecTy;
StringRecTy SharedStringRecTy;
DagRecTy SharedDagRecTy;

RecordRecTy AnyRecord;
UnsetInit TheUnsetInit;
BitInit TrueBitInit;
BitInit FalseBitInit;

FoldingSet<BitsInit> TheBitsInitPool;
std::map<int64_t, IntInit *> TheIntInitPool;
StringMap<StringInit *, BumpPtrAllocator &> StringInitStringPool;
StringMap<StringInit *, BumpPtrAllocator &> StringInitCodePool;
FoldingSet<ListInit> TheListInitPool;
FoldingSet<UnOpInit> TheUnOpInitPool;
FoldingSet<BinOpInit> TheBinOpInitPool;
FoldingSet<TernOpInit> TheTernOpInitPool;
FoldingSet<FoldOpInit> TheFoldOpInitPool;
FoldingSet<IsAOpInit> TheIsAOpInitPool;
FoldingSet<ExistsOpInit> TheExistsOpInitPool;
DenseMap<std::pair<RecTy *, Init *>, VarInit *> TheVarInitPool;
DenseMap<std::pair<TypedInit *, unsigned>, VarBitInit *> TheVarBitInitPool;
DenseMap<std::pair<TypedInit *, unsigned>, VarListElementInit *>
    TheVarListElementInitPool;
FoldingSet<VarDefInit> TheVarDefInitPool;
DenseMap<std::pair<Init *, StringInit *>, FieldInit *> TheFieldInitPool;
FoldingSet<CondOpInit> TheCondOpInitPool;
FoldingSet<DagInit> TheDagInitPool;
FoldingSet<RecordRecTy> RecordTypePool;

unsigned AnonCounter;
unsigned LastRecordID;
96};
97} // namespace detail
98} // namespace llvm

100//===----------------------------------------------------------------------===//
101//    Type implementations
102//===----------------------------------------------------------------------===//

104#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
105LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void RecTy::dump() const { print(errs()); }
106#endif

108ListRecTy *RecTy::getListTy() {
if (!ListTy)
  ListTy = new (RK.getImpl().Allocator) ListRecTy(this);
return ListTy;
112}

114bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
assert(RHS && "NULL pointer")(static_cast <bool> (RHS && "NULL pointer") ? void
 (0) : __assert_fail ("RHS && \"NULL pointer\"", "llvm/lib/TableGen/Record.cpp"
, 115, __extension__ __PRETTY_FUNCTION__));
return Kind == RHS->getRecTyKind();
117}

119bool RecTy::typeIsA(const RecTy *RHS) const { return this == RHS; }

121BitRecTy *BitRecTy::get(RecordKeeper &RK) {
return &RK.getImpl().SharedBitRecTy;
123}

125bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
if (RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind)
  return true;
if (const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
  return BitsTy->getNumBits() == 1;
return false;
131}

133BitsRecTy *BitsRecTy::get(RecordKeeper &RK, unsigned Sz) {
detail::RecordKeeperImpl &RKImpl = RK.getImpl();
if (Sz >= RKImpl.SharedBitsRecTys.size())
  RKImpl.SharedBitsRecTys.resize(Sz + 1);
BitsRecTy *&Ty = RKImpl.SharedBitsRecTys[Sz];
if (!Ty)
  Ty = new (RKImpl.Allocator) BitsRecTy(RK, Sz);
return Ty;
141}

143std::string BitsRecTy::getAsString() const {
return "bits<" + utostr(Size) + ">";
145}

147bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
if (RecTy::typeIsConvertibleTo(RHS)) //argument and the sender are same type
  return cast<BitsRecTy>(RHS)->Size == Size;
RecTyKind kind = RHS->getRecTyKind();
return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind);
152}

154bool BitsRecTy::typeIsA(const RecTy *RHS) const {
if (const BitsRecTy *RHSb = dyn_cast<BitsRecTy>(RHS))
  return RHSb->Size == Size;
return false;
158}

160IntRecTy *IntRecTy::get(RecordKeeper &RK) {
return &RK.getImpl().SharedIntRecTy;
162}

164bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
RecTyKind kind = RHS->getRecTyKind();
return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
167}

169StringRecTy *StringRecTy::get(RecordKeeper &RK) {
return &RK.getImpl().SharedStringRecTy;
171}

173std::string StringRecTy::getAsString() const {
return "string";
175}

177bool StringRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
RecTyKind Kind = RHS->getRecTyKind();
return Kind == StringRecTyKind;
180}

182std::string ListRecTy::getAsString() const {
return "list<" + ElementTy->getAsString() + ">";
184}

186bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
if (const auto *ListTy = dyn_cast<ListRecTy>(RHS))
  return ElementTy->typeIsConvertibleTo(ListTy->getElementType());
return false;
190}

192bool ListRecTy::typeIsA(const RecTy *RHS) const {
if (const ListRecTy *RHSl = dyn_cast<ListRecTy>(RHS))
  return getElementType()->typeIsA(RHSl->getElementType());
return false;
196}

198DagRecTy *DagRecTy::get(RecordKeeper &RK) {
return &RK.getImpl().SharedDagRecTy;
200}

202std::string DagRecTy::getAsString() const {
return "dag";
204}

206static void ProfileRecordRecTy(FoldingSetNodeID &ID,
                             ArrayRef<Record *> Classes) {
ID.AddInteger(Classes.size());
for (Record *R : Classes)
  ID.AddPointer(R);
211}

213RecordRecTy *RecordRecTy::get(RecordKeeper &RK,
                            ArrayRef<Record *> UnsortedClasses) {
detail::RecordKeeperImpl &RKImpl = RK.getImpl();
if (UnsortedClasses.empty())
  return &RKImpl.AnyRecord;

FoldingSet<RecordRecTy> &ThePool = RKImpl.RecordTypePool;

SmallVector<Record *, 4> Classes(UnsortedClasses.begin(),
                                 UnsortedClasses.end());
llvm::sort(Classes, [](Record *LHS, Record *RHS) {
  return LHS->getNameInitAsString() < RHS->getNameInitAsString();
});

FoldingSetNodeID ID;
ProfileRecordRecTy(ID, Classes);

void *IP = nullptr;
if (RecordRecTy *Ty = ThePool.FindNodeOrInsertPos(ID, IP))
  return Ty;

234#ifndef NDEBUG
// Check for redundancy.
for (unsigned i = 0; i < Classes.size(); ++i) {
  for (unsigned j = 0; j < Classes.size(); ++j) {
    assert(i == j || !Classes[i]->isSubClassOf(Classes[j]))(static_cast <bool> (i == j || !Classes[i]->isSubClassOf
(Classes[j])) ? void (0) : __assert_fail ("i == j || !Classes[i]->isSubClassOf(Classes[j])"
, "llvm/lib/TableGen/Record.cpp", 238, __extension__ __PRETTY_FUNCTION__
));
  }
  assert(&Classes[0]->getRecords() == &Classes[i]->getRecords())(static_cast <bool> (&Classes[0]->getRecords() ==
 &Classes[i]->getRecords()) ? void (0) : __assert_fail
 ("&Classes[0]->getRecords() == &Classes[i]->getRecords()"
, "llvm/lib/TableGen/Record.cpp", 240, __extension__ __PRETTY_FUNCTION__
));
}
242#endif

void *Mem = RKImpl.Allocator.Allocate(
    totalSizeToAlloc<Record *>(Classes.size()), alignof(RecordRecTy));
RecordRecTy *Ty = new (Mem) RecordRecTy(RK, Classes.size());
std::uninitialized_copy(Classes.begin(), Classes.end(),
                        Ty->getTrailingObjects<Record *>());
ThePool.InsertNode(Ty, IP);
return Ty;
251}
252RecordRecTy *RecordRecTy::get(Record *Class) {
assert(Class && "unexpected null class")(static_cast <bool> (Class && "unexpected null class"
) ? void (0) : __assert_fail ("Class && \"unexpected null class\""
, "llvm/lib/TableGen/Record.cpp", 253, __extension__ __PRETTY_FUNCTION__
));
return get(Class->getRecords(), Class);
255}

257void RecordRecTy::Profile(FoldingSetNodeID &ID) const {
ProfileRecordRecTy(ID, getClasses());
259}

261std::string RecordRecTy::getAsString() const {
if (NumClasses == 1)
  return getClasses()[0]->getNameInitAsString();

std::string Str = "{";
bool First = true;
for (Record *R : getClasses()) {
  if (!First)
    Str += ", ";
  First = false;
  Str += R->getNameInitAsString();
}
Str += "}";
return Str;
275}

277bool RecordRecTy::isSubClassOf(Record *Class) const {
return llvm::any_of(getClasses(), [Class](Record *MySuperClass) {
                                    return MySuperClass == Class ||
                                           MySuperClass->isSubClassOf(Class);
                                  });
282}

284bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
if (this == RHS)
  return true;

const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS);
if (!RTy)
  return false;

return llvm::all_of(RTy->getClasses(), [this](Record *TargetClass) {
                                         return isSubClassOf(TargetClass);
                                       });
295}

297bool RecordRecTy::typeIsA(const RecTy *RHS) const {
return typeIsConvertibleTo(RHS);
299}

301static RecordRecTy *resolveRecordTypes(RecordRecTy *T1, RecordRecTy *T2) {
SmallVector<Record *, 4> CommonSuperClasses;
SmallVector<Record *, 4> Stack(T1->classes_begin(), T1->classes_end());

while (!Stack.empty()) {
  Record *R = Stack.pop_back_val();

  if (T2->isSubClassOf(R)) {
    CommonSuperClasses.push_back(R);
  } else {
    R->getDirectSuperClasses(Stack);
  }
}

return RecordRecTy::get(T1->getRecordKeeper(), CommonSuperClasses);
316}

318RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
if (T1 == T2)
  return T1;

if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) {
  if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2))
    return resolveRecordTypes(RecTy1, RecTy2);
}

if (T1->typeIsConvertibleTo(T2))
  return T2;
if (T2->typeIsConvertibleTo(T1))
  return T1;

if (ListRecTy *ListTy1 = dyn_cast<ListRecTy>(T1)) {
  if (ListRecTy *ListTy2 = dyn_cast<ListRecTy>(T2)) {
    RecTy* NewType = resolveTypes(ListTy1->getElementType(),
                                  ListTy2->getElementType());
    if (NewType)
      return NewType->getListTy();
  }
}

return nullptr;
342}

344//===----------------------------------------------------------------------===//
345//    Initializer implementations
346//===----------------------------------------------------------------------===//

348void Init::anchor() {}

350#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
351LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void Init::dump() const { return print(errs()); }
352#endif

354RecordKeeper &Init::getRecordKeeper() const {
if (auto *TyInit = dyn_cast<TypedInit>(this))
  return TyInit->getType()->getRecordKeeper();
return cast<UnsetInit>(this)->getRecordKeeper();
358}

360UnsetInit *UnsetInit::get(RecordKeeper &RK) {
return &RK.getImpl().TheUnsetInit;
362}

364Init *UnsetInit::getCastTo(RecTy *Ty) const {
return const_cast<UnsetInit *>(this);
366}

368Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
return const_cast<UnsetInit *>(this);
370}

372BitInit *BitInit::get(RecordKeeper &RK, bool V) {
return V ? &RK.getImpl().TrueBitInit : &RK.getImpl().FalseBitInit;
374}

376Init *BitInit::convertInitializerTo(RecTy *Ty) const {
if (isa<BitRecTy>(Ty))
  return const_cast<BitInit *>(this);

if (isa<IntRecTy>(Ty))
  return IntInit::get(getRecordKeeper(), getValue());

if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
  // Can only convert single bit.
  if (BRT->getNumBits() == 1)
    return BitsInit::get(getRecordKeeper(), const_cast<BitInit *>(this));
}

return nullptr;
390}

392static void
393ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
ID.AddInteger(Range.size());

for (Init *I : Range)
  ID.AddPointer(I);
398}

400BitsInit *BitsInit::get(RecordKeeper &RK, ArrayRef<Init *> Range) {
FoldingSetNodeID ID;
ProfileBitsInit(ID, Range);

detail::RecordKeeperImpl &RKImpl = RK.getImpl();
void *IP = nullptr;
if (BitsInit *I = RKImpl.TheBitsInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

void *Mem = RKImpl.Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
                                      alignof(BitsInit));
BitsInit *I = new (Mem) BitsInit(RK, Range.size());
std::uninitialized_copy(Range.begin(), Range.end(),
                        I->getTrailingObjects<Init *>());
RKImpl.TheBitsInitPool.InsertNode(I, IP);
return I;
416}

418void BitsInit::Profile(FoldingSetNodeID &ID) const {
ProfileBitsInit(ID, ArrayRef(getTrailingObjects<Init *>(), NumBits));
420}

422Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
if (isa<BitRecTy>(Ty)) {
  if (getNumBits() != 1) return nullptr; // Only accept if just one bit!
  return getBit(0);
}

if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
  // If the number of bits is right, return it.  Otherwise we need to expand
  // or truncate.
  if (getNumBits() != BRT->getNumBits()) return nullptr;
  return const_cast<BitsInit *>(this);
}

if (isa<IntRecTy>(Ty)) {
  int64_t Result = 0;
  for (unsigned i = 0, e = getNumBits(); i != e; ++i)
    if (auto *Bit = dyn_cast<BitInit>(getBit(i)))
      Result |= static_cast<int64_t>(Bit->getValue()) << i;
    else
      return nullptr;
  return IntInit::get(getRecordKeeper(), Result);
}

return nullptr;
446}

448Init *
449BitsInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
SmallVector<Init *, 16> NewBits(Bits.size());

for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
  if (Bits[i] >= getNumBits())
    return nullptr;
  NewBits[i] = getBit(Bits[i]);
}
return BitsInit::get(getRecordKeeper(), NewBits);
458}

460bool BitsInit::isConcrete() const {
for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
  if (!getBit(i)->isConcrete())
    return false;
}
return true;
466}

468std::string BitsInit::getAsString() const {
std::string Result = "{ ";
for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
  if (i) Result += ", ";
  if (Init *Bit = getBit(e-i-1))
    Result += Bit->getAsString();
  else
    Result += "*";
}
return Result + " }";
478}

480// resolveReferences - If there are any field references that refer to fields
481// that have been filled in, we can propagate the values now.
482Init *BitsInit::resolveReferences(Resolver &R) const {
bool Changed = false;
SmallVector<Init *, 16> NewBits(getNumBits());

Init *CachedBitVarRef = nullptr;
Init *CachedBitVarResolved = nullptr;

for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
  Init *CurBit = getBit(i);
  Init *NewBit = CurBit;

  if (VarBitInit *CurBitVar = dyn_cast<VarBitInit>(CurBit)) {
    if (CurBitVar->getBitVar() != CachedBitVarRef) {
      CachedBitVarRef = CurBitVar->getBitVar();
      CachedBitVarResolved = CachedBitVarRef->resolveReferences(R);
    }
    assert(CachedBitVarResolved && "Unresolved bitvar reference")(static_cast <bool> (CachedBitVarResolved && "Unresolved bitvar reference"
) ? void (0) : __assert_fail ("CachedBitVarResolved && \"Unresolved bitvar reference\""
, "llvm/lib/TableGen/Record.cpp", 498, __extension__ __PRETTY_FUNCTION__
));
    NewBit = CachedBitVarResolved->getBit(CurBitVar->getBitNum());
  } else {
    // getBit(0) implicitly converts int and bits<1> values to bit.
    NewBit = CurBit->resolveReferences(R)->getBit(0);
  }

  if (isa<UnsetInit>(NewBit) && R.keepUnsetBits())
    NewBit = CurBit;
  NewBits[i] = NewBit;
  Changed |= CurBit != NewBit;
}

if (Changed)
  return BitsInit::get(getRecordKeeper(), NewBits);

return const_cast<BitsInit *>(this);
515}

517IntInit *IntInit::get(RecordKeeper &RK, int64_t V) {
IntInit *&I = RK.getImpl().TheIntInitPool[V];
if (!I)
  I = new (RK.getImpl().Allocator) IntInit(RK, V);
return I;
522}

524std::string IntInit::getAsString() const {
return itostr(Value);
526}

528static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
// For example, with NumBits == 4, we permit Values from [-7 .. 15].
return (NumBits >= sizeof(Value) * 8) ||
       (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1);
532}

534Init *IntInit::convertInitializerTo(RecTy *Ty) const {
if (isa<IntRecTy>(Ty))
  return const_cast<IntInit *>(this);

if (isa<BitRecTy>(Ty)) {
  int64_t Val = getValue();
  if (Val != 0 && Val != 1) return nullptr;  // Only accept 0 or 1 for a bit!
  return BitInit::get(getRecordKeeper(), Val != 0);
}

if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
  int64_t Value = getValue();
  // Make sure this bitfield is large enough to hold the integer value.
  if (!canFitInBitfield(Value, BRT->getNumBits()))
    return nullptr;

  SmallVector<Init *, 16> NewBits(BRT->getNumBits());
  for (unsigned i = 0; i != BRT->getNumBits(); ++i)
    NewBits[i] =
        BitInit::get(getRecordKeeper(), Value & ((i < 64) ? (1LL << i) : 0));

  return BitsInit::get(getRecordKeeper(), NewBits);
}

return nullptr;
559}

561Init *
562IntInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
SmallVector<Init *, 16> NewBits(Bits.size());

for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
  if (Bits[i] >= 64)
    return nullptr;

  NewBits[i] =
      BitInit::get(getRecordKeeper(), Value & (INT64_C(1)1L << Bits[i]));
}
return BitsInit::get(getRecordKeeper(), NewBits);
573}

575AnonymousNameInit *AnonymousNameInit::get(RecordKeeper &RK, unsigned V) {
return new (RK.getImpl().Allocator) AnonymousNameInit(RK, V);
577}

579StringInit *AnonymousNameInit::getNameInit() const {
return StringInit::get(getRecordKeeper(), getAsString());
581}

583std::string AnonymousNameInit::getAsString() const {
return "anonymous_" + utostr(Value);
585}

587Init *AnonymousNameInit::resolveReferences(Resolver &R) const {
auto *Old = const_cast<Init *>(static_cast<const Init *>(this));
auto *New = R.resolve(Old);
New = New ? New : Old;
if (R.isFinal())
  if (auto *Anonymous = dyn_cast<AnonymousNameInit>(New))
    return Anonymous->getNameInit();
return New;
595}

597StringInit *StringInit::get(RecordKeeper &RK, StringRef V, StringFormat Fmt) {
detail::RecordKeeperImpl &RKImpl = RK.getImpl();
auto &InitMap = Fmt == SF_String ? RKImpl.StringInitStringPool
                                 : RKImpl.StringInitCodePool;
auto &Entry = *InitMap.insert(std::make_pair(V, nullptr)).first;
if (!Entry.second)
  Entry.second = new (RKImpl.Allocator) StringInit(RK, Entry.getKey(), Fmt);
return Entry.second;
605}

607Init *StringInit::convertInitializerTo(RecTy *Ty) const {
if (isa<StringRecTy>(Ty))
  return const_cast<StringInit *>(this);

return nullptr;
612}

614static void ProfileListInit(FoldingSetNodeID &ID,
                          ArrayRef<Init *> Range,
                          RecTy *EltTy) {
ID.AddInteger(Range.size());
ID.AddPointer(EltTy);

for (Init *I : Range)
  ID.AddPointer(I);
622}

624ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
FoldingSetNodeID ID;
ProfileListInit(ID, Range, EltTy);

detail::RecordKeeperImpl &RK = EltTy->getRecordKeeper().getImpl();
void *IP = nullptr;
if (ListInit *I = RK.TheListInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

assert(Range.empty() || !isa<TypedInit>(Range[0]) ||(static_cast <bool> (Range.empty() || !isa<TypedInit
>(Range[0]) || cast<TypedInit>(Range[0])->getType
()->typeIsConvertibleTo(EltTy)) ? void (0) : __assert_fail
 ("Range.empty() || !isa<TypedInit>(Range[0]) || cast<TypedInit>(Range[0])->getType()->typeIsConvertibleTo(EltTy)"
, "llvm/lib/TableGen/Record.cpp", 634, __extension__ __PRETTY_FUNCTION__
))
       cast<TypedInit>(Range[0])->getType()->typeIsConvertibleTo(EltTy))(static_cast <bool> (Range.empty() || !isa<TypedInit
>(Range[0]) || cast<TypedInit>(Range[0])->getType
()->typeIsConvertibleTo(EltTy)) ? void (0) : __assert_fail
 ("Range.empty() || !isa<TypedInit>(Range[0]) || cast<TypedInit>(Range[0])->getType()->typeIsConvertibleTo(EltTy)"
, "llvm/lib/TableGen/Record.cpp", 634, __extension__ __PRETTY_FUNCTION__
));

void *Mem = RK.Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
                                  alignof(ListInit));
ListInit *I = new (Mem) ListInit(Range.size(), EltTy);
std::uninitialized_copy(Range.begin(), Range.end(),
                        I->getTrailingObjects<Init *>());
RK.TheListInitPool.InsertNode(I, IP);
return I;
643}

645void ListInit::Profile(FoldingSetNodeID &ID) const {
RecTy *EltTy = cast<ListRecTy>(getType())->getElementType();

ProfileListInit(ID, getValues(), EltTy);
649}

651Init *ListInit::convertInitializerTo(RecTy *Ty) const {
if (getType() == Ty)
  return const_cast<ListInit*>(this);

if (auto *LRT = dyn_cast<ListRecTy>(Ty)) {
  SmallVector<Init*, 8> Elements;
  Elements.reserve(getValues().size());

  // Verify that all of the elements of the list are subclasses of the
  // appropriate class!
  bool Changed = false;
  RecTy *ElementType = LRT->getElementType();
  for (Init *I : getValues())
    if (Init *CI = I->convertInitializerTo(ElementType)) {
      Elements.push_back(CI);
      if (CI != I)
        Changed = true;
    } else
      return nullptr;

  if (!Changed)
    return const_cast<ListInit*>(this);
  return ListInit::get(Elements, ElementType);
}

return nullptr;
677}

679Init *ListInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
if (Elements.size() == 1) {
  if (Elements[0] >= size())
    return nullptr;
  return getElement(Elements[0]);
}

SmallVector<Init*, 8> Vals;
Vals.reserve(Elements.size());
for (unsigned Element : Elements) {
  if (Element >= size())
    return nullptr;
  Vals.push_back(getElement(Element));
}
return ListInit::get(Vals, getElementType());
694}

696Record *ListInit::getElementAsRecord(unsigned i) const {
assert(i < NumValues && "List element index out of range!")(static_cast <bool> (i < NumValues && "List element index out of range!"
) ? void (0) : __assert_fail ("i < NumValues && \"List element index out of range!\""
, "llvm/lib/TableGen/Record.cpp", 697, __extension__ __PRETTY_FUNCTION__
));
DefInit *DI = dyn_cast<DefInit>(getElement(i));
if (!DI)
  PrintFatalError("Expected record in list!");
return DI->getDef();
702}

704Init *ListInit::resolveReferences(Resolver &R) const {
SmallVector<Init*, 8> Resolved;
Resolved.reserve(size());
bool Changed = false;

for (Init *CurElt : getValues()) {
  Init *E = CurElt->resolveReferences(R);
  Changed |= E != CurElt;
  Resolved.push_back(E);
}

if (Changed)
  return ListInit::get(Resolved, getElementType());
return const_cast<ListInit *>(this);
718}

720bool ListInit::isComplete() const {
for (Init *Element : *this) {
  if (!Element->isComplete())
    return false;
}
return true;
726}

728bool ListInit::isConcrete() const {
for (Init *Element : *this) {
  if (!Element->isConcrete())
    return false;
}
return true;
734}

736std::string ListInit::getAsString() const {
std::string Result = "[";
const char *sep = "";
for (Init *Element : *this) {
  Result += sep;
  sep = ", ";
  Result += Element->getAsString();
}
return Result + "]";
745}

747Init *OpInit::getBit(unsigned Bit) const {
if (getType() == BitRecTy::get(getRecordKeeper()))
  return const_cast<OpInit*>(this);
return VarBitInit::get(const_cast<OpInit*>(this), Bit);
751}

753static void
754ProfileUnOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *Op, RecTy *Type) {
ID.AddInteger(Opcode);
ID.AddPointer(Op);
ID.AddPointer(Type);
758}

760UnOpInit *UnOpInit::get(UnaryOp Opc, Init *LHS, RecTy *Type) {
FoldingSetNodeID ID;
ProfileUnOpInit(ID, Opc, LHS, Type);

detail::RecordKeeperImpl &RK = Type->getRecordKeeper().getImpl();
void *IP = nullptr;
if (UnOpInit *I = RK.TheUnOpInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

UnOpInit *I = new (RK.Allocator) UnOpInit(Opc, LHS, Type);
RK.TheUnOpInitPool.InsertNode(I, IP);
return I;
772}

774void UnOpInit::Profile(FoldingSetNodeID &ID) const {
ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
776}

778Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
RecordKeeper &RK = getRecordKeeper();
switch (getOpcode()) {
case CAST:
  if (isa<StringRecTy>(getType())) {
    if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
      return LHSs;

    if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
      return StringInit::get(RK, LHSd->getAsString());

    if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
            LHS->convertInitializerTo(IntRecTy::get(RK))))
      return StringInit::get(RK, LHSi->getAsString());

  } else if (isa<RecordRecTy>(getType())) {
    if (StringInit *Name = dyn_cast<StringInit>(LHS)) {
      if (!CurRec && !IsFinal)
        break;
      assert(CurRec && "NULL pointer")(static_cast <bool> (CurRec && "NULL pointer") ?
 void (0) : __assert_fail ("CurRec && \"NULL pointer\""
, "llvm/lib/TableGen/Record.cpp", 797, __extension__ __PRETTY_FUNCTION__
));
      Record *D;

      // Self-references are allowed, but their resolution is delayed until
      // the final resolve to ensure that we get the correct type for them.
      auto *Anonymous = dyn_cast<AnonymousNameInit>(CurRec->getNameInit());
      if (Name == CurRec->getNameInit() ||
          (Anonymous && Name == Anonymous->getNameInit())) {
        if (!IsFinal)
          break;
        D = CurRec;
      } else {
        D = CurRec->getRecords().getDef(Name->getValue());
        if (!D) {
          if (IsFinal)
            PrintFatalError(CurRec->getLoc(),
                            Twine("Undefined reference to record: '") +
                            Name->getValue() + "'\n");
          break;
        }
      }

      DefInit *DI = DefInit::get(D);
      if (!DI->getType()->typeIsA(getType())) {
        PrintFatalError(CurRec->getLoc(),
                        Twine("Expected type '") +
                        getType()->getAsString() + "', got '" +
                        DI->getType()->getAsString() + "' in: " +
                        getAsString() + "\n");
      }
      return DI;
    }
  }

  if (Init *NewInit = LHS->convertInitializerTo(getType()))
    return NewInit;
  break;

case NOT:
  if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
          LHS->convertInitializerTo(IntRecTy::get(RK))))
    return IntInit::get(RK, LHSi->getValue() ? 0 : 1);
  break;

case HEAD:
  if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
    assert(!LHSl->empty() && "Empty list in head")(static_cast <bool> (!LHSl->empty() && "Empty list in head"
) ? void (0) : __assert_fail ("!LHSl->empty() && \"Empty list in head\""
, "llvm/lib/TableGen/Record.cpp", 843, __extension__ __PRETTY_FUNCTION__
));
    return LHSl->getElement(0);
  }
  break;

case TAIL:
  if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
    assert(!LHSl->empty() && "Empty list in tail")(static_cast <bool> (!LHSl->empty() && "Empty list in tail"
) ? void (0) : __assert_fail ("!LHSl->empty() && \"Empty list in tail\""
, "llvm/lib/TableGen/Record.cpp", 850, __extension__ __PRETTY_FUNCTION__
));
    // Note the +1.  We can't just pass the result of getValues()
    // directly.
    return ListInit::get(LHSl->getValues().slice(1), LHSl->getElementType());
  }
  break;

case SIZE:
  if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
    return IntInit::get(RK, LHSl->size());
  if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
    return IntInit::get(RK, LHSd->arg_size());
  if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
    return IntInit::get(RK, LHSs->getValue().size());
  break;

case EMPTY:
  if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
    return IntInit::get(RK, LHSl->empty());
  if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
    return IntInit::get(RK, LHSd->arg_empty());
  if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
    return IntInit::get(RK, LHSs->getValue().empty());
  break;

case GETDAGOP:
  if (DagInit *Dag = dyn_cast<DagInit>(LHS)) {
    DefInit *DI = DefInit::get(Dag->getOperatorAsDef({}));
    if (!DI->getType()->typeIsA(getType())) {
      PrintFatalError(CurRec->getLoc(),
                      Twine("Expected type '") +
                      getType()->getAsString() + "', got '" +
                      DI->getType()->getAsString() + "' in: " +
                      getAsString() + "\n");
    } else {
      return DI;
    }
  }
  break;

case LOG2:
  if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
          LHS->convertInitializerTo(IntRecTy::get(RK)))) {
    int64_t LHSv = LHSi->getValue();
    if (LHSv <= 0) {
      PrintFatalError(CurRec->getLoc(),
                      "Illegal operation: logtwo is undefined "
                      "on arguments less than or equal to 0");
    } else {
      uint64_t Log = Log2_64(LHSv);
      assert(Log <= INT64_MAX &&(static_cast <bool> (Log <= (9223372036854775807L) &&
 "Log of an int64_t must be smaller than INT64_MAX") ? void (
0) : __assert_fail ("Log <= INT64_MAX && \"Log of an int64_t must be smaller than INT64_MAX\""
, "llvm/lib/TableGen/Record.cpp", 901, __extension__ __PRETTY_FUNCTION__
))
             "Log of an int64_t must be smaller than INT64_MAX")(static_cast <bool> (Log <= (9223372036854775807L) &&
 "Log of an int64_t must be smaller than INT64_MAX") ? void (
0) : __assert_fail ("Log <= INT64_MAX && \"Log of an int64_t must be smaller than INT64_MAX\""
, "llvm/lib/TableGen/Record.cpp", 901, __extension__ __PRETTY_FUNCTION__
));
      return IntInit::get(RK, static_cast<int64_t>(Log));
    }
  }
  break;
}
return const_cast<UnOpInit *>(this);
908}

910Init *UnOpInit::resolveReferences(Resolver &R) const {
Init *lhs = LHS->resolveReferences(R);

if (LHS != lhs || (R.isFinal() && getOpcode() == CAST))
  return (UnOpInit::get(getOpcode(), lhs, getType()))
      ->Fold(R.getCurrentRecord(), R.isFinal());
return const_cast<UnOpInit *>(this);
917}

919std::string UnOpInit::getAsString() const {
std::string Result;
switch (getOpcode()) {
case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
case NOT: Result = "!not"; break;
case HEAD: Result = "!head"; break;
case TAIL: Result = "!tail"; break;
case SIZE: Result = "!size"; break;
case EMPTY: Result = "!empty"; break;
case GETDAGOP: Result = "!getdagop"; break;
case LOG2 : Result = "!logtwo"; break;
}
return Result + "(" + LHS->getAsString() + ")";
932}

934static void
935ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
               RecTy *Type) {
ID.AddInteger(Opcode);
ID.AddPointer(LHS);
ID.AddPointer(RHS);
ID.AddPointer(Type);
941}

943BinOpInit *BinOpInit::get(BinaryOp Opc, Init *LHS, Init *RHS, RecTy *Type) {
FoldingSetNodeID ID;
ProfileBinOpInit(ID, Opc, LHS, RHS, Type);

detail::RecordKeeperImpl &RK = LHS->getRecordKeeper().getImpl();
void *IP = nullptr;
if (BinOpInit *I = RK.TheBinOpInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

BinOpInit *I = new (RK.Allocator) BinOpInit(Opc, LHS, RHS, Type);
RK.TheBinOpInitPool.InsertNode(I, IP);
return I;
955}

957void BinOpInit::Profile(FoldingSetNodeID &ID) const {
ProfileBinOpInit(ID, getOpcode(), getLHS(), getRHS(), getType());
959}

961static StringInit *ConcatStringInits(const StringInit *I0,
                                   const StringInit *I1) {
SmallString<80> Concat(I0->getValue());
Concat.append(I1->getValue());
return StringInit::get(
    I0->getRecordKeeper(), Concat,
    StringInit::determineFormat(I0->getFormat(), I1->getFormat()));
968}

970static StringInit *interleaveStringList(const ListInit *List,
                                      const StringInit *Delim) {
if (List->size() == 0)
  return StringInit::get(List->getRecordKeeper(), "");
StringInit *Element = dyn_cast<StringInit>(List->getElement(0));
if (!Element)
  return nullptr;
SmallString<80> Result(Element->getValue());
StringInit::StringFormat Fmt = StringInit::SF_String;

for (unsigned I = 1, E = List->size(); I < E; ++I) {
  Result.append(Delim->getValue());
  StringInit *Element = dyn_cast<StringInit>(List->getElement(I));
  if (!Element)
    return nullptr;
  Result.append(Element->getValue());
  Fmt = StringInit::determineFormat(Fmt, Element->getFormat());
}
return StringInit::get(List->getRecordKeeper(), Result, Fmt);
989}

991static StringInit *interleaveIntList(const ListInit *List,
                                   const StringInit *Delim) {
RecordKeeper &RK = List->getRecordKeeper();
if (List->size() == 0)
  return StringInit::get(RK, "");
IntInit *Element = dyn_cast_or_null<IntInit>(
    List->getElement(0)->convertInitializerTo(IntRecTy::get(RK)));
if (!Element)
  return nullptr;
SmallString<80> Result(Element->getAsString());

for (unsigned I = 1, E = List->size(); I < E; ++I) {
  Result.append(Delim->getValue());
  IntInit *Element = dyn_cast_or_null<IntInit>(
      List->getElement(I)->convertInitializerTo(IntRecTy::get(RK)));
  if (!Element)
    return nullptr;
  Result.append(Element->getAsString());
}
return StringInit::get(RK, Result);
1011}

1013Init *BinOpInit::getStrConcat(Init *I0, Init *I1) {
// Shortcut for the common case of concatenating two strings.
if (const StringInit *I0s = dyn_cast<StringInit>(I0))
  if (const StringInit *I1s = dyn_cast<StringInit>(I1))
    return ConcatStringInits(I0s, I1s);
return BinOpInit::get(BinOpInit::STRCONCAT, I0, I1,
                      StringRecTy::get(I0->getRecordKeeper()));
1020}

1022static ListInit *ConcatListInits(const ListInit *LHS,
                               const ListInit *RHS) {
SmallVector<Init *, 8> Args;
llvm::append_range(Args, *LHS);
llvm::append_range(Args, *RHS);
return ListInit::get(Args, LHS->getElementType());
1028}

1030Init *BinOpInit::getListConcat(TypedInit *LHS, Init *RHS) {
assert(isa<ListRecTy>(LHS->getType()) && "First arg must be a list")(static_cast <bool> (isa<ListRecTy>(LHS->getType
()) && "First arg must be a list") ? void (0) : __assert_fail
 ("isa<ListRecTy>(LHS->getType()) && \"First arg must be a list\""
, "llvm/lib/TableGen/Record.cpp", 1031, __extension__ __PRETTY_FUNCTION__
));

// Shortcut for the common case of concatenating two lists.
 if (const ListInit *LHSList = dyn_cast<ListInit>(LHS))
   if (const ListInit *RHSList = dyn_cast<ListInit>(RHS))
     return ConcatListInits(LHSList, RHSList);
 return BinOpInit::get(BinOpInit::LISTCONCAT, LHS, RHS, LHS->getType());
1038}

1040std::optional<bool> BinOpInit::CompareInit(unsigned Opc, Init *LHS, Init *RHS) const {
 // First see if we have two bit, bits, or int.
 IntInit *LHSi = dyn_cast_or_null<IntInit>(
     LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
 IntInit *RHSi = dyn_cast_or_null<IntInit>(
     RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));

 if (LHSi && RHSi) {
   bool Result;
   switch (Opc) {
   case EQ:
     Result = LHSi->getValue() == RHSi->getValue();
     break;
   case NE:
     Result = LHSi->getValue() != RHSi->getValue();
     break;
   case LE:
     Result = LHSi->getValue() <= RHSi->getValue();
     break;
   case LT:
     Result = LHSi->getValue() < RHSi->getValue();
     break;
   case GE:
     Result = LHSi->getValue() >= RHSi->getValue();
     break;
   case GT:
     Result = LHSi->getValue() > RHSi->getValue();
     break;
   default:
     llvm_unreachable("unhandled comparison")::llvm::llvm_unreachable_internal("unhandled comparison", "llvm/lib/TableGen/Record.cpp"
, 1069);
   }
   return Result;
 }

 // Next try strings.
 StringInit *LHSs = dyn_cast<StringInit>(LHS);
 StringInit *RHSs = dyn_cast<StringInit>(RHS);

 if (LHSs && RHSs) {
   bool Result;
   switch (Opc) {
   case EQ:
     Result = LHSs->getValue() == RHSs->getValue();
     break;
   case NE:
     Result = LHSs->getValue() != RHSs->getValue();
     break;
   case LE:
     Result = LHSs->getValue() <= RHSs->getValue();
     break;
   case LT:
     Result = LHSs->getValue() < RHSs->getValue();
     break;
   case GE:
     Result = LHSs->getValue() >= RHSs->getValue();
     break;
   case GT:
     Result = LHSs->getValue() > RHSs->getValue();
     break;
   default:
     llvm_unreachable("unhandled comparison")::llvm::llvm_unreachable_internal("unhandled comparison", "llvm/lib/TableGen/Record.cpp"
, 1100);
   }
   return Result;
 }

 // Finally, !eq and !ne can be used with records.
 if (Opc == EQ || Opc == NE) {
   DefInit *LHSd = dyn_cast<DefInit>(LHS);
   DefInit *RHSd = dyn_cast<DefInit>(RHS);
   if (LHSd && RHSd)
     return (Opc == EQ) ? LHSd == RHSd : LHSd != RHSd;
 }

 return std::nullopt;
1114}

Init *BinOpInit::Fold(Record *CurRec) const {
switch (getOpcode()) {
case CONCAT: {
  DagInit *LHSs = dyn_cast<DagInit>(LHS);
  DagInit *RHSs = dyn_cast<DagInit>(RHS);
  if (LHSs && RHSs) {
    DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
    DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
    if ((!LOp && !isa<UnsetInit>(LHSs->getOperator())) ||
        (!ROp && !isa<UnsetInit>(RHSs->getOperator())))
      break;
    if (LOp && ROp && LOp->getDef() != ROp->getDef()) {
      PrintFatalError(Twine("Concatenated Dag operators do not match: '") +
                      LHSs->getAsString() + "' vs. '" + RHSs->getAsString() +
                      "'");
    }
    Init *Op = LOp ? LOp : ROp;
    if (!Op)
      Op = UnsetInit::get(getRecordKeeper());

    SmallVector<Init*, 8> Args;
    SmallVector<StringInit*, 8> ArgNames;
    for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
      Args.push_back(LHSs->getArg(i));
      ArgNames.push_back(LHSs->getArgName(i));
    }
    for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) {
      Args.push_back(RHSs->getArg(i));
      ArgNames.push_back(RHSs->getArgName(i));
    }
    return DagInit::get(Op, nullptr, Args, ArgNames);
  }
  break;
}
case LISTCONCAT: {
  ListInit *LHSs = dyn_cast<ListInit>(LHS);
  ListInit *RHSs = dyn_cast<ListInit>(RHS);
  if (LHSs && RHSs) {
    SmallVector<Init *, 8> Args;
    llvm::append_range(Args, *LHSs);
    llvm::append_range(Args, *RHSs);
    return ListInit::get(Args, LHSs->getElementType());
  }
  break;
}
case LISTSPLAT: {
  TypedInit *Value = dyn_cast<TypedInit>(LHS);
  IntInit *Size = dyn_cast<IntInit>(RHS);
  if (Value && Size) {
    SmallVector<Init *, 8> Args(Size->getValue(), Value);
    return ListInit::get(Args, Value->getType());
  }
  break;
}
case LISTREMOVE: {
  ListInit *LHSs = dyn_cast<ListInit>(LHS);
  ListInit *RHSs = dyn_cast<ListInit>(RHS);
  if (LHSs && RHSs) {
    SmallVector<Init *, 8> Args;
    for (Init *EltLHS : *LHSs) {
      bool Found = false;
      for (Init *EltRHS : *RHSs) {
        if (std::optional<bool> Result = CompareInit(EQ, EltLHS, EltRHS)) {
          if (*Result) {
            Found = true;
            break;
          }
        }
      }
      if (!Found)
        Args.push_back(EltLHS);
    }
    return ListInit::get(Args, LHSs->getElementType());
  }
  break;
}
case STRCONCAT: {
  StringInit *LHSs = dyn_cast<StringInit>(LHS);
  StringInit *RHSs = dyn_cast<StringInit>(RHS);
  if (LHSs && RHSs)
    return ConcatStringInits(LHSs, RHSs);
  break;
}
case INTERLEAVE: {
  ListInit *List = dyn_cast<ListInit>(LHS);
  StringInit *Delim = dyn_cast<StringInit>(RHS);
  if (List && Delim) {
    StringInit *Result;
    if (isa<StringRecTy>(List->getElementType()))
      Result = interleaveStringList(List, Delim);
    else
      Result = interleaveIntList(List, Delim);
    if (Result)
      return Result;
  }
  break;
}
case EQ:
case NE:
case LE:
case LT:
case GE:
case GT: {
  if (std::optional<bool> Result = CompareInit(getOpcode(), LHS, RHS))
    return BitInit::get(getRecordKeeper(), *Result);
  break;
}
case SETDAGOP: {
  DagInit *Dag = dyn_cast<DagInit>(LHS);
  DefInit *Op = dyn_cast<DefInit>(RHS);
  if (Dag && Op) {
    SmallVector<Init*, 8> Args;
    SmallVector<StringInit*, 8> ArgNames;
    for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
      Args.push_back(Dag->getArg(i));
      ArgNames.push_back(Dag->getArgName(i));
    }
    return DagInit::get(Op, nullptr, Args, ArgNames);
  }
  break;
}
case ADD:
case SUB:
case MUL:
case DIV:
case AND:
case OR:
case XOR:
case SHL:
case SRA:
case SRL: {
  IntInit *LHSi = dyn_cast_or_null<IntInit>(
      LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
  IntInit *RHSi = dyn_cast_or_null<IntInit>(
      RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
  if (LHSi && RHSi) {
    int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
    int64_t Result;
    switch (getOpcode()) {
    default: llvm_unreachable("Bad opcode!")::llvm::llvm_unreachable_internal("Bad opcode!", "llvm/lib/TableGen/Record.cpp"
, 1255);
    case ADD: Result = LHSv + RHSv; break;
    case SUB: Result = LHSv - RHSv; break;
    case MUL: Result = LHSv * RHSv; break;
    case DIV:
      if (RHSv == 0)
        PrintFatalError(CurRec->getLoc(),
                        "Illegal operation: division by zero");
      else if (LHSv == INT64_MIN(-9223372036854775807L -1) && RHSv == -1)
        PrintFatalError(CurRec->getLoc(),
                        "Illegal operation: INT64_MIN / -1");
      else
        Result = LHSv / RHSv;
      break;
    case AND: Result = LHSv & RHSv; break;
    case OR:  Result = LHSv | RHSv; break;
    case XOR: Result = LHSv ^ RHSv; break;
    case SHL: Result = (uint64_t)LHSv << (uint64_t)RHSv; break;
    case SRA: Result = LHSv >> RHSv; break;
    case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
    }
    return IntInit::get(getRecordKeeper(), Result);
  }
  break;
}
}
return const_cast<BinOpInit *>(this);
1282}

1284Init *BinOpInit::resolveReferences(Resolver &R) const {
Init *lhs = LHS->resolveReferences(R);
Init *rhs = RHS->resolveReferences(R);

if (LHS != lhs || RHS != rhs)
  return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))
      ->Fold(R.getCurrentRecord());
return const_cast<BinOpInit *>(this);
1292}

1294std::string BinOpInit::getAsString() const {
std::string Result;
switch (getOpcode()) {
case CONCAT: Result = "!con"; break;
case ADD: Result = "!add"; break;
case SUB: Result = "!sub"; break;
case MUL: Result = "!mul"; break;
case DIV: Result = "!div"; break;
case AND: Result = "!and"; break;
case OR: Result = "!or"; break;
case XOR: Result = "!xor"; break;
case SHL: Result = "!shl"; break;
case SRA: Result = "!sra"; break;
case SRL: Result = "!srl"; break;
case EQ: Result = "!eq"; break;
case NE: Result = "!ne"; break;
case LE: Result = "!le"; break;
case LT: Result = "!lt"; break;
case GE: Result = "!ge"; break;
case GT: Result = "!gt"; break;
case LISTCONCAT: Result = "!listconcat"; break;
case LISTSPLAT: Result = "!listsplat"; break;
case LISTREMOVE: Result = "!listremove"; break;
case STRCONCAT: Result = "!strconcat"; break;
case INTERLEAVE: Result = "!interleave"; break;
case SETDAGOP: Result = "!setdagop"; break;
}
return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
1322}

1324static void
1325ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
                Init *RHS, RecTy *Type) {
ID.AddInteger(Opcode);
ID.AddPointer(LHS);
ID.AddPointer(MHS);
ID.AddPointer(RHS);
ID.AddPointer(Type);
1332}

1334TernOpInit *TernOpInit::get(TernaryOp Opc, Init *LHS, Init *MHS, Init *RHS,
                          RecTy *Type) {
FoldingSetNodeID ID;
ProfileTernOpInit(ID, Opc, LHS, MHS, RHS, Type);

detail::RecordKeeperImpl &RK = LHS->getRecordKeeper().getImpl();
void *IP = nullptr;
if (TernOpInit *I = RK.TheTernOpInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

TernOpInit *I = new (RK.Allocator) TernOpInit(Opc, LHS, MHS, RHS, Type);
RK.TheTernOpInitPool.InsertNode(I, IP);
return I;
1347}

1349void TernOpInit::Profile(FoldingSetNodeID &ID) const {
ProfileTernOpInit(ID, getOpcode(), getLHS(), getMHS(), getRHS(), getType());
1351}

1353static Init *ItemApply(Init *LHS, Init *MHSe, Init *RHS, Record *CurRec) {
MapResolver R(CurRec);
R.set(LHS, MHSe);
return RHS->resolveReferences(R);
1357}

1359static Init *ForeachDagApply(Init *LHS, DagInit *MHSd, Init *RHS,
                           Record *CurRec) {
bool Change = false;
Init *Val = ItemApply(LHS, MHSd->getOperator(), RHS, CurRec);
if (Val != MHSd->getOperator())
  Change = true;

SmallVector<std::pair<Init *, StringInit *>, 8> NewArgs;
for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
  Init *Arg = MHSd->getArg(i);
  Init *NewArg;
  StringInit *ArgName = MHSd->getArgName(i);

  if (DagInit *Argd = dyn_cast<DagInit>(Arg))
    NewArg = ForeachDagApply(LHS, Argd, RHS, CurRec);
  else
    NewArg = ItemApply(LHS, Arg, RHS, CurRec);

  NewArgs.push_back(std::make_pair(NewArg, ArgName));
  if (Arg != NewArg)
    Change = true;
}

if (Change)
  return DagInit::get(Val, nullptr, NewArgs);
return MHSd;
1385}

1387// Applies RHS to all elements of MHS, using LHS as a temp variable.
1388static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
                         Record *CurRec) {
if (DagInit *MHSd = dyn_cast<DagInit>(MHS))
  return ForeachDagApply(LHS, MHSd, RHS, CurRec);

if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) {
  SmallVector<Init *, 8> NewList(MHSl->begin(), MHSl->end());

  for (Init *&Item : NewList) {
    Init *NewItem = ItemApply(LHS, Item, RHS, CurRec);
    if (NewItem != Item)
      Item = NewItem;
  }
  return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
}

return nullptr;
1405}

1407// Evaluates RHS for all elements of MHS, using LHS as a temp variable.
1408// Creates a new list with the elements that evaluated to true.
1409static Init *FilterHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
                        Record *CurRec) {
if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) {
  SmallVector<Init *, 8> NewList;

  for (Init *Item : MHSl->getValues()) {
    Init *Include = ItemApply(LHS, Item, RHS, CurRec);
    if (!Include)
      return nullptr;
    if (IntInit *IncludeInt =
            dyn_cast_or_null<IntInit>(Include->convertInitializerTo(
                IntRecTy::get(LHS->getRecordKeeper())))) {
      if (IncludeInt->getValue())
        NewList.push_back(Item);
    } else {
      return nullptr;
    }
  }
  return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
}

return nullptr;
1431}

1433Init *TernOpInit::Fold(Record *CurRec) const {
RecordKeeper &RK = getRecordKeeper();
switch (getOpcode()) {
case SUBST: {
  DefInit *LHSd = dyn_cast<DefInit>(LHS);
  VarInit *LHSv = dyn_cast<VarInit>(LHS);
  StringInit *LHSs = dyn_cast<StringInit>(LHS);

  DefInit *MHSd = dyn_cast<DefInit>(MHS);
  VarInit *MHSv = dyn_cast<VarInit>(MHS);
  StringInit *MHSs = dyn_cast<StringInit>(MHS);

  DefInit *RHSd = dyn_cast<DefInit>(RHS);
  VarInit *RHSv = dyn_cast<VarInit>(RHS);
  StringInit *RHSs = dyn_cast<StringInit>(RHS);

  if (LHSd && MHSd && RHSd) {
    Record *Val = RHSd->getDef();
    if (LHSd->getAsString() == RHSd->getAsString())
      Val = MHSd->getDef();
    return DefInit::get(Val);
  }
  if (LHSv && MHSv && RHSv) {
    std::string Val = std::string(RHSv->getName());
    if (LHSv->getAsString() == RHSv->getAsString())
      Val = std::string(MHSv->getName());
    return VarInit::get(Val, getType());
  }
  if (LHSs && MHSs && RHSs) {
    std::string Val = std::string(RHSs->getValue());

    std::string::size_type found;
    std::string::size_type idx = 0;
    while (true) {
      found = Val.find(std::string(LHSs->getValue()), idx);
      if (found == std::string::npos)
        break;
      Val.replace(found, LHSs->getValue().size(),
                  std::string(MHSs->getValue()));
      idx = found + MHSs->getValue().size();
    }

    return StringInit::get(RK, Val);
  }
  break;
}

case FOREACH: {
  if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec))
    return Result;
  break;
}

case FILTER: {
  if (Init *Result = FilterHelper(LHS, MHS, RHS, getType(), CurRec))
    return Result;
  break;
}

case IF: {
  if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
          LHS->convertInitializerTo(IntRecTy::get(RK)))) {
    if (LHSi->getValue())
      return MHS;
    return RHS;
  }
  break;
}

case DAG: {
  ListInit *MHSl = dyn_cast<ListInit>(MHS);
  ListInit *RHSl = dyn_cast<ListInit>(RHS);
  bool MHSok = MHSl || isa<UnsetInit>(MHS);
  bool RHSok = RHSl || isa<UnsetInit>(RHS);

  if (isa<UnsetInit>(MHS) && isa<UnsetInit>(RHS))
    break; // Typically prevented by the parser, but might happen with template args

  if (MHSok && RHSok && (!MHSl || !RHSl || MHSl->size() == RHSl->size())) {
    SmallVector<std::pair<Init *, StringInit *>, 8> Children;
    unsigned Size = MHSl ? MHSl->size() : RHSl->size();
    for (unsigned i = 0; i != Size; ++i) {
      Init *Node = MHSl ? MHSl->getElement(i) : UnsetInit::get(RK);
      Init *Name = RHSl ? RHSl->getElement(i) : UnsetInit::get(RK);
      if (!isa<StringInit>(Name) && !isa<UnsetInit>(Name))
        return const_cast<TernOpInit *>(this);
      Children.emplace_back(Node, dyn_cast<StringInit>(Name));
    }
    return DagInit::get(LHS, nullptr, Children);
  }
  break;
}

case SUBSTR: {
  StringInit *LHSs = dyn_cast<StringInit>(LHS);
  IntInit *MHSi = dyn_cast<IntInit>(MHS);
  IntInit *RHSi = dyn_cast<IntInit>(RHS);
  if (LHSs && MHSi && RHSi) {
    int64_t StringSize = LHSs->getValue().size();
    int64_t Start = MHSi->getValue();
    int64_t Length = RHSi->getValue();
    if (Start < 0 || Start > StringSize)
      PrintError(CurRec->getLoc(),
                 Twine("!substr start position is out of range 0...") +
                     std::to_string(StringSize) + ": " +
                     std::to_string(Start));
    if (Length < 0)
      PrintError(CurRec->getLoc(), "!substr length must be nonnegative");
    return StringInit::get(RK, LHSs->getValue().substr(Start, Length),
                           LHSs->getFormat());
  }
  break;
}

case FIND: {
  StringInit *LHSs = dyn_cast<StringInit>(LHS);
  StringInit *MHSs = dyn_cast<StringInit>(MHS);
  IntInit *RHSi = dyn_cast<IntInit>(RHS);
  if (LHSs && MHSs && RHSi) {
    int64_t SourceSize = LHSs->getValue().size();
    int64_t Start = RHSi->getValue();
    if (Start < 0 || Start > SourceSize)
      PrintError(CurRec->getLoc(),
                 Twine("!find start position is out of range 0...") +
                     std::to_string(SourceSize) + ": " +
                     std::to_string(Start));
    auto I = LHSs->getValue().find(MHSs->getValue(), Start);
    if (I == std::string::npos)
      return IntInit::get(RK, -1);
    return IntInit::get(RK, I);
  }
  break;
}
}

return const_cast<TernOpInit *>(this);
1569}

1571Init *TernOpInit::resolveReferences(Resolver &R) const {
Init *lhs = LHS->resolveReferences(R);

if (getOpcode() == IF && lhs != LHS) {
  if (IntInit *Value = dyn_cast_or_null<IntInit>(
          lhs->convertInitializerTo(IntRecTy::get(getRecordKeeper())))) {
    // Short-circuit
    if (Value->getValue())
      return MHS->resolveReferences(R);
    return RHS->resolveReferences(R);
  }
}

Init *mhs = MHS->resolveReferences(R);
Init *rhs;

if (getOpcode() == FOREACH || getOpcode() == FILTER) {
  ShadowResolver SR(R);
  SR.addShadow(lhs);
  rhs = RHS->resolveReferences(SR);
} else {
  rhs = RHS->resolveReferences(R);
}

if (LHS != lhs || MHS != mhs || RHS != rhs)
  return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, getType()))
      ->Fold(R.getCurrentRecord());
return const_cast<TernOpInit *>(this);
1599}

1601std::string TernOpInit::getAsString() const {
std::string Result;
bool UnquotedLHS = false;
switch (getOpcode()) {
case DAG: Result = "!dag"; break;
case FILTER: Result = "!filter"; UnquotedLHS = true; break;
case FOREACH: Result = "!foreach"; UnquotedLHS = true; break;
case IF: Result = "!if"; break;
case SUBST: Result = "!subst"; break;
case SUBSTR: Result = "!substr"; break;
case FIND: Result = "!find"; break;
}
return (Result + "(" +
        (UnquotedLHS ? LHS->getAsUnquotedString() : LHS->getAsString()) +
        ", " + MHS->getAsString() + ", " + RHS->getAsString() + ")");
1616}

1618static void ProfileFoldOpInit(FoldingSetNodeID &ID, Init *Start, Init *List,
                            Init *A, Init *B, Init *Expr, RecTy *Type) {
ID.AddPointer(Start);
ID.AddPointer(List);
ID.AddPointer(A);
ID.AddPointer(B);
ID.AddPointer(Expr);
ID.AddPointer(Type);
1626}

1628FoldOpInit *FoldOpInit::get(Init *Start, Init *List, Init *A, Init *B,
                          Init *Expr, RecTy *Type) {
FoldingSetNodeID ID;
ProfileFoldOpInit(ID, Start, List, A, B, Expr, Type);

detail::RecordKeeperImpl &RK = Start->getRecordKeeper().getImpl();
void *IP = nullptr;
if (FoldOpInit *I = RK.TheFoldOpInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

FoldOpInit *I = new (RK.Allocator) FoldOpInit(Start, List, A, B, Expr, Type);
RK.TheFoldOpInitPool.InsertNode(I, IP);
return I;
1641}

1643void FoldOpInit::Profile(FoldingSetNodeID &ID) const {
ProfileFoldOpInit(ID, Start, List, A, B, Expr, getType());
1645}

1647Init *FoldOpInit::Fold(Record *CurRec) const {
if (ListInit *LI = dyn_cast<ListInit>(List)) {
  Init *Accum = Start;
  for (Init *Elt : *LI) {
    MapResolver R(CurRec);
    R.set(A, Accum);
    R.set(B, Elt);
    Accum = Expr->resolveReferences(R);
  }
  return Accum;
}
return const_cast<FoldOpInit *>(this);
1659}

1661Init *FoldOpInit::resolveReferences(Resolver &R) const {
Init *NewStart = Start->resolveReferences(R);
Init *NewList = List->resolveReferences(R);
ShadowResolver SR(R);
SR.addShadow(A);
SR.addShadow(B);
Init *NewExpr = Expr->resolveReferences(SR);

if (Start == NewStart && List == NewList && Expr == NewExpr)
  return const_cast<FoldOpInit *>(this);

return get(NewStart, NewList, A, B, NewExpr, getType())
    ->Fold(R.getCurrentRecord());
1674}

1676Init *FoldOpInit::getBit(unsigned Bit) const {
return VarBitInit::get(const_cast<FoldOpInit *>(this), Bit);
1678}

1680std::string FoldOpInit::getAsString() const {
return (Twine("!foldl(") + Start->getAsString() + ", " + List->getAsString() +
        ", " + A->getAsUnquotedString() + ", " + B->getAsUnquotedString() +
        ", " + Expr->getAsString() + ")")
    .str();
1685}

1687static void ProfileIsAOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
                           Init *Expr) {
ID.AddPointer(CheckType);
ID.AddPointer(Expr);
1691}

1693IsAOpInit *IsAOpInit::get(RecTy *CheckType, Init *Expr) {

FoldingSetNodeID ID;
ProfileIsAOpInit(ID, CheckType, Expr);

detail::RecordKeeperImpl &RK = Expr->getRecordKeeper().getImpl();
void *IP = nullptr;
if (IsAOpInit *I = RK.TheIsAOpInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

IsAOpInit *I = new (RK.Allocator) IsAOpInit(CheckType, Expr);
RK.TheIsAOpInitPool.InsertNode(I, IP);
return I;
1706}

1708void IsAOpInit::Profile(FoldingSetNodeID &ID) const {
ProfileIsAOpInit(ID, CheckType, Expr);
1710}

1712Init *IsAOpInit::Fold() const {
if (TypedInit *TI = dyn_cast<TypedInit>(Expr)) {
  // Is the expression type known to be (a subclass of) the desired type?
  if (TI->getType()->typeIsConvertibleTo(CheckType))
    return IntInit::get(getRecordKeeper(), 1);

  if (isa<RecordRecTy>(CheckType)) {
    // If the target type is not a subclass of the expression type, or if
    // the expression has fully resolved to a record, we know that it can't
    // be of the required type.
    if (!CheckType->typeIsConvertibleTo(TI->getType()) || isa<DefInit>(Expr))
      return IntInit::get(getRecordKeeper(), 0);
  } else {
    // We treat non-record types as not castable.
    return IntInit::get(getRecordKeeper(), 0);
  }
}
return const_cast<IsAOpInit *>(this);
1730}

1732Init *IsAOpInit::resolveReferences(Resolver &R) const {
Init *NewExpr = Expr->resolveReferences(R);
if (Expr != NewExpr)
  return get(CheckType, NewExpr)->Fold();
return const_cast<IsAOpInit *>(this);
1737}

1739Init *IsAOpInit::getBit(unsigned Bit) const {
return VarBitInit::get(const_cast<IsAOpInit *>(this), Bit);
1741}

1743std::string IsAOpInit::getAsString() const {
return (Twine("!isa<") + CheckType->getAsString() + ">(" +
        Expr->getAsString() + ")")
    .str();
1747}

1749static void ProfileExistsOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
                              Init *Expr) {
ID.AddPointer(CheckType);
ID.AddPointer(Expr);
1753}

1755ExistsOpInit *ExistsOpInit::get(RecTy *CheckType, Init *Expr) {
FoldingSetNodeID ID;
ProfileExistsOpInit(ID, CheckType, Expr);

detail::RecordKeeperImpl &RK = Expr->getRecordKeeper().getImpl();
void *IP = nullptr;
if (ExistsOpInit *I = RK.TheExistsOpInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

ExistsOpInit *I = new (RK.Allocator) ExistsOpInit(CheckType, Expr);
RK.TheExistsOpInitPool.InsertNode(I, IP);
return I;
1767}

1769void ExistsOpInit::Profile(FoldingSetNodeID &ID) const {
ProfileExistsOpInit(ID, CheckType, Expr);
1771}

1773Init *ExistsOpInit::Fold(Record *CurRec, bool IsFinal) const {
if (StringInit *Name5.1
'Name' is non-null
 = dyn_cast<StringInit>(Expr)) {
5
←
Assuming field 'Expr' is a 'CastReturnType'→
  if (!CurRec && !IsFinal)
6
←
Assuming 'CurRec' is null→
7
←
Assuming 'IsFinal' is true→
8
←
Taking false branch→
    return const_cast<ExistsOpInit *>(this);

  // Self-references are allowed, but their resolution is delayed until
  // the final resolve to ensure that we get the correct type for them.
  auto *Anonymous = dyn_cast<AnonymousNameInit>(CurRec->getNameInit());
9
←
Called C++ object pointer is null
  if (Name == CurRec->getNameInit() ||
      (Anonymous && Name == Anonymous->getNameInit())) {
    if (!IsFinal)
      return const_cast<ExistsOpInit *>(this);

    // No doubt that there exists a record, so we should check if types are
    // compatiable.
    return IntInit::get(getRecordKeeper(),
                        CurRec->getType()->typeIsA(CheckType));
  }

  // Look up all defined records to see if we can find one.
  Record *D = CheckType->getRecordKeeper().getDef(Name->getValue());
  if (!D) {
    if (IsFinal)
      return IntInit::get(getRecordKeeper(), 0);
    return const_cast<ExistsOpInit *>(this);
  }

  // Check if types are compatiable.
  return IntInit::get(getRecordKeeper(),
                      DefInit::get(D)->getType()->typeIsA(CheckType));
}
return const_cast<ExistsOpInit *>(this);
1805}

1807Init *ExistsOpInit::resolveReferences(Resolver &R) const {
Init *NewExpr = Expr->resolveReferences(R);
1
Value assigned to field 'CurRec'→
if (Expr != NewExpr || R.isFinal())
2
←
Assuming 'NewExpr' is not equal to field 'Expr'→
  return get(CheckType, NewExpr)->Fold(R.getCurrentRecord(), R.isFinal());
3
←
Passing value via 1st parameter 'CurRec'→
4
←
Calling 'ExistsOpInit::Fold'→
return const_cast<ExistsOpInit *>(this);
1812}

1814Init *ExistsOpInit::getBit(unsigned Bit) const {
return VarBitInit::get(const_cast<ExistsOpInit *>(this), Bit);
1816}

1818std::string ExistsOpInit::getAsString() const {
return (Twine("!exists<") + CheckType->getAsString() + ">(" +
        Expr->getAsString() + ")")
    .str();
1822}

1824RecTy *TypedInit::getFieldType(StringInit *FieldName) const {
if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) {
  for (Record *Rec : RecordType->getClasses()) {
    if (RecordVal *Field = Rec->getValue(FieldName))
      return Field->getType();
  }
}
return nullptr;
1832}

1834Init *
1835TypedInit::convertInitializerTo(RecTy *Ty) const {
if (getType() == Ty || getType()->typeIsA(Ty))
  return const_cast<TypedInit *>(this);

if (isa<BitRecTy>(getType()) && isa<BitsRecTy>(Ty) &&
    cast<BitsRecTy>(Ty)->getNumBits() == 1)
  return BitsInit::get(getRecordKeeper(), {const_cast<TypedInit *>(this)});

return nullptr;
1844}

1846Init *TypedInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
BitsRecTy *T = dyn_cast<BitsRecTy>(getType());
if (!T) return nullptr;  // Cannot subscript a non-bits variable.
unsigned NumBits = T->getNumBits();

SmallVector<Init *, 16> NewBits;
NewBits.reserve(Bits.size());
for (unsigned Bit : Bits) {
  if (Bit >= NumBits)
    return nullptr;

  NewBits.push_back(VarBitInit::get(const_cast<TypedInit *>(this), Bit));
}
return BitsInit::get(getRecordKeeper(), NewBits);
1860}

1862Init *TypedInit::getCastTo(RecTy *Ty) const {
// Handle the common case quickly
if (getType() == Ty || getType()->typeIsA(Ty))
  return const_cast<TypedInit *>(this);

if (Init *Converted = convertInitializerTo(Ty)) {
  assert(!isa<TypedInit>(Converted) ||(static_cast <bool> (!isa<TypedInit>(Converted) ||
 cast<TypedInit>(Converted)->getType()->typeIsA(Ty
)) ? void (0) : __assert_fail ("!isa<TypedInit>(Converted) || cast<TypedInit>(Converted)->getType()->typeIsA(Ty)"
, "llvm/lib/TableGen/Record.cpp", 1869, __extension__ __PRETTY_FUNCTION__
))
         cast<TypedInit>(Converted)->getType()->typeIsA(Ty))(static_cast <bool> (!isa<TypedInit>(Converted) ||
 cast<TypedInit>(Converted)->getType()->typeIsA(Ty
)) ? void (0) : __assert_fail ("!isa<TypedInit>(Converted) || cast<TypedInit>(Converted)->getType()->typeIsA(Ty)"
, "llvm/lib/TableGen/Record.cpp", 1869, __extension__ __PRETTY_FUNCTION__
));
  return Converted;
}

if (!getType()->typeIsConvertibleTo(Ty))
  return nullptr;

return UnOpInit::get(UnOpInit::CAST, const_cast<TypedInit *>(this), Ty)
    ->Fold(nullptr);
1878}

1880Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
ListRecTy *T = dyn_cast<ListRecTy>(getType());
if (!T) return nullptr;  // Cannot subscript a non-list variable.

if (Elements.size() == 1)
  return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);

SmallVector<Init*, 8> ListInits;
ListInits.reserve(Elements.size());
for (unsigned Element : Elements)
  ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this),
                                              Element));
return ListInit::get(ListInits, T->getElementType());
1893}


1896VarInit *VarInit::get(StringRef VN, RecTy *T) {
Init *Value = StringInit::get(T->getRecordKeeper(), VN);
return VarInit::get(Value, T);
1899}

1901VarInit *VarInit::get(Init *VN, RecTy *T) {
detail::RecordKeeperImpl &RK = T->getRecordKeeper().getImpl();
VarInit *&I = RK.TheVarInitPool[std::make_pair(T, VN)];
if (!I)
  I = new (RK.Allocator) VarInit(VN, T);
return I;
1907}

1909StringRef VarInit::getName() const {
StringInit *NameString = cast<StringInit>(getNameInit());
return NameString->getValue();
1912}

1914Init *VarInit::getBit(unsigned Bit) const {
if (getType() == BitRecTy::get(getRecordKeeper()))
  return const_cast<VarInit*>(this);
return VarBitInit::get(const_cast<VarInit*>(this), Bit);
1918}

1920Init *VarInit::resolveReferences(Resolver &R) const {
if (Init *Val = R.resolve(VarName))
  return Val;
return const_cast<VarInit *>(this);
1924}

1926VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) {
detail::RecordKeeperImpl &RK = T->getRecordKeeper().getImpl();
VarBitInit *&I = RK.TheVarBitInitPool[std::make_pair(T, B)];
if (!I)
  I = new (RK.Allocator) VarBitInit(T, B);
return I;
1932}

1934std::string VarBitInit::getAsString() const {
return TI->getAsString() + "{" + utostr(Bit) + "}";
1936}

1938Init *VarBitInit::resolveReferences(Resolver &R) const {
Init *I = TI->resolveReferences(R);
if (TI != I)
  return I->getBit(getBitNum());

return const_cast<VarBitInit*>(this);
1944}

1946VarListElementInit *VarListElementInit::get(TypedInit *T, unsigned E) {
detail::RecordKeeperImpl &RK = T->getRecordKeeper().getImpl();
VarListElementInit *&I = RK.TheVarListElementInitPool[std::make_pair(T, E)];
if (!I)
  I = new (RK.Allocator) VarListElementInit(T, E);
return I;
1952}

1954std::string VarListElementInit::getAsString() const {
return TI->getAsString() + "[" + utostr(Element) + "]";
1956}

1958Init *VarListElementInit::resolveReferences(Resolver &R) const {
Init *NewTI = TI->resolveReferences(R);
if (ListInit *List = dyn_cast<ListInit>(NewTI)) {
  // Leave out-of-bounds array references as-is. This can happen without
  // being an error, e.g. in the untaken "branch" of an !if expression.
  if (getElementNum() < List->size())
    return List->getElement(getElementNum());
}
if (NewTI != TI && isa<TypedInit>(NewTI))
  return VarListElementInit::get(cast<TypedInit>(NewTI), getElementNum());
return const_cast<VarListElementInit *>(this);
1969}

1971Init *VarListElementInit::getBit(unsigned Bit) const {
if (getType() == BitRecTy::get(getRecordKeeper()))
  return const_cast<VarListElementInit*>(this);
return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit);
1975}

1977DefInit::DefInit(Record *D)
  : TypedInit(IK_DefInit, D->getType()), Def(D) {}

1980DefInit *DefInit::get(Record *R) {
return R->getDefInit();
1982}

1984Init *DefInit::convertInitializerTo(RecTy *Ty) const {
if (auto *RRT = dyn_cast<RecordRecTy>(Ty))
  if (getType()->typeIsConvertibleTo(RRT))
    return const_cast<DefInit *>(this);
return nullptr;
1989}

1991RecTy *DefInit::getFieldType(StringInit *FieldName) const {
if (const RecordVal *RV = Def->getValue(FieldName))
  return RV->getType();
return nullptr;
1995}

1997std::string DefInit::getAsString() const { return std::string(Def->getName()); }

1999static void ProfileVarDefInit(FoldingSetNodeID &ID,
                            Record *Class,
                            ArrayRef<Init *> Args) {
ID.AddInteger(Args.size());
ID.AddPointer(Class);

for (Init *I : Args)
  ID.AddPointer(I);
2007}

2009VarDefInit::VarDefInit(Record *Class, unsigned N)
  : TypedInit(IK_VarDefInit, RecordRecTy::get(Class)), Class(Class),
    NumArgs(N) {}

2013VarDefInit *VarDefInit::get(Record *Class, ArrayRef<Init *> Args) {
FoldingSetNodeID ID;
ProfileVarDefInit(ID, Class, Args);

detail::RecordKeeperImpl &RK = Class->getRecords().getImpl();
void *IP = nullptr;
if (VarDefInit *I = RK.TheVarDefInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

void *Mem = RK.Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
                                  alignof(VarDefInit));
VarDefInit *I = new (Mem) VarDefInit(Class, Args.size());
std::uninitialized_copy(Args.begin(), Args.end(),
                        I->getTrailingObjects<Init *>());
RK.TheVarDefInitPool.InsertNode(I, IP);
return I;
2029}

2031void VarDefInit::Profile(FoldingSetNodeID &ID) const {
ProfileVarDefInit(ID, Class, args());
2033}

2035DefInit *VarDefInit::instantiate() {
if (!Def) {
  RecordKeeper &Records = Class->getRecords();
  auto NewRecOwner = std::make_unique<Record>(Records.getNewAnonymousName(),
                                         Class->getLoc(), Records,
                                         /*IsAnonymous=*/true);
  Record *NewRec = NewRecOwner.get();

  // Copy values from class to instance
  for (const RecordVal &Val : Class->getValues())
    NewRec->addValue(Val);

  // Copy assertions from class to instance.
  NewRec->appendAssertions(Class);

  // Substitute and resolve template arguments
  ArrayRef<Init *> TArgs = Class->getTemplateArgs();
  MapResolver R(NewRec);

  for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
    if (i < args_size())
      R.set(TArgs[i], getArg(i));
    else
      R.set(TArgs[i], NewRec->getValue(TArgs[i])->getValue());

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

  NewRec->resolveReferences(R);

  // Add superclasses.
  ArrayRef<std::pair<Record *, SMRange>> SCs = Class->getSuperClasses();
  for (const auto &SCPair : SCs)
    NewRec->addSuperClass(SCPair.first, SCPair.second);

  NewRec->addSuperClass(Class,
                        SMRange(Class->getLoc().back(),
                                Class->getLoc().back()));

  // Resolve internal references and store in record keeper
  NewRec->resolveReferences();
  Records.addDef(std::move(NewRecOwner));

  // Check the assertions.
  NewRec->checkRecordAssertions();

  Def = DefInit::get(NewRec);
}

return Def;
2085}

2087Init *VarDefInit::resolveReferences(Resolver &R) const {
TrackUnresolvedResolver UR(&R);
bool Changed = false;
SmallVector<Init *, 8> NewArgs;
NewArgs.reserve(args_size());

for (Init *Arg : args()) {
  Init *NewArg = Arg->resolveReferences(UR);
  NewArgs.push_back(NewArg);
  Changed |= NewArg != Arg;
}

if (Changed) {
  auto New = VarDefInit::get(Class, NewArgs);
  if (!UR.foundUnresolved())
    return New->instantiate();
  return New;
}
return const_cast<VarDefInit *>(this);
2106}

2108Init *VarDefInit::Fold() const {
if (Def)
  return Def;

TrackUnresolvedResolver R;
for (Init *Arg : args())
  Arg->resolveReferences(R);

if (!R.foundUnresolved())
  return const_cast<VarDefInit *>(this)->instantiate();
return const_cast<VarDefInit *>(this);
2119}

2121std::string VarDefInit::getAsString() const {
std::string Result = Class->getNameInitAsString() + "<";
const char *sep = "";
for (Init *Arg : args()) {
  Result += sep;
  sep = ", ";
  Result += Arg->getAsString();
}
return Result + ">";
2130}

2132FieldInit *FieldInit::get(Init *R, StringInit *FN) {
detail::RecordKeeperImpl &RK = R->getRecordKeeper().getImpl();
FieldInit *&I = RK.TheFieldInitPool[std::make_pair(R, FN)];
if (!I)
  I = new (RK.Allocator) FieldInit(R, FN);
return I;
2138}

2140Init *FieldInit::getBit(unsigned Bit) const {
if (getType() == BitRecTy::get(getRecordKeeper()))
  return const_cast<FieldInit*>(this);
return VarBitInit::get(const_cast<FieldInit*>(this), Bit);
2144}

2146Init *FieldInit::resolveReferences(Resolver &R) const {
Init *NewRec = Rec->resolveReferences(R);
if (NewRec != Rec)
  return FieldInit::get(NewRec, FieldName)->Fold(R.getCurrentRecord());
return const_cast<FieldInit *>(this);
2151}

2153Init *FieldInit::Fold(Record *CurRec) const {
if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
  Record *Def = DI->getDef();
  if (Def == CurRec)
    PrintFatalError(CurRec->getLoc(),
                    Twine("Attempting to access field '") +
                    FieldName->getAsUnquotedString() + "' of '" +
                    Rec->getAsString() + "' is a forbidden self-reference");
  Init *FieldVal = Def->getValue(FieldName)->getValue();
  if (FieldVal->isConcrete())
    return FieldVal;
}
return const_cast<FieldInit *>(this);
2166}

2168bool FieldInit::isConcrete() const {
if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
  Init *FieldVal = DI->getDef()->getValue(FieldName)->getValue();
  return FieldVal->isConcrete();
}
return false;
2174}

2176static void ProfileCondOpInit(FoldingSetNodeID &ID,
                           ArrayRef<Init *> CondRange,
                           ArrayRef<Init *> ValRange,
                           const RecTy *ValType) {
assert(CondRange.size() == ValRange.size() &&(static_cast <bool> (CondRange.size() == ValRange.size(
) && "Number of conditions and values must match!") ?
 void (0) : __assert_fail ("CondRange.size() == ValRange.size() && \"Number of conditions and values must match!\""
, "llvm/lib/TableGen/Record.cpp", 2181, __extension__ __PRETTY_FUNCTION__
))
       "Number of conditions and values must match!")(static_cast <bool> (CondRange.size() == ValRange.size(
) && "Number of conditions and values must match!") ?
 void (0) : __assert_fail ("CondRange.size() == ValRange.size() && \"Number of conditions and values must match!\""
, "llvm/lib/TableGen/Record.cpp", 2181, __extension__ __PRETTY_FUNCTION__
));
ID.AddPointer(ValType);
ArrayRef<Init *>::iterator Case = CondRange.begin();
ArrayRef<Init *>::iterator Val = ValRange.begin();

while (Case != CondRange.end()) {
  ID.AddPointer(*Case++);
  ID.AddPointer(*Val++);
}
2190}

2192void CondOpInit::Profile(FoldingSetNodeID &ID) const {
ProfileCondOpInit(ID, ArrayRef(getTrailingObjects<Init *>(), NumConds),
                  ArrayRef(getTrailingObjects<Init *>() + NumConds, NumConds),
                  ValType);
2196}

2198CondOpInit *CondOpInit::get(ArrayRef<Init *> CondRange,
                          ArrayRef<Init *> ValRange, RecTy *Ty) {
assert(CondRange.size() == ValRange.size() &&(static_cast <bool> (CondRange.size() == ValRange.size(
) && "Number of conditions and values must match!") ?
 void (0) : __assert_fail ("CondRange.size() == ValRange.size() && \"Number of conditions and values must match!\""
, "llvm/lib/TableGen/Record.cpp", 2201, __extension__ __PRETTY_FUNCTION__
))
       "Number of conditions and values must match!")(static_cast <bool> (CondRange.size() == ValRange.size(
) && "Number of conditions and values must match!") ?
 void (0) : __assert_fail ("CondRange.size() == ValRange.size() && \"Number of conditions and values must match!\""
, "llvm/lib/TableGen/Record.cpp", 2201, __extension__ __PRETTY_FUNCTION__
));

FoldingSetNodeID ID;
ProfileCondOpInit(ID, CondRange, ValRange, Ty);

detail::RecordKeeperImpl &RK = Ty->getRecordKeeper().getImpl();
void *IP = nullptr;
if (CondOpInit *I = RK.TheCondOpInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

void *Mem = RK.Allocator.Allocate(
    totalSizeToAlloc<Init *>(2 * CondRange.size()), alignof(BitsInit));
CondOpInit *I = new(Mem) CondOpInit(CondRange.size(), Ty);

std::uninitialized_copy(CondRange.begin(), CondRange.end(),
                        I->getTrailingObjects<Init *>());
std::uninitialized_copy(ValRange.begin(), ValRange.end(),
                        I->getTrailingObjects<Init *>()+CondRange.size());
RK.TheCondOpInitPool.InsertNode(I, IP);
return I;
2221}

2223Init *CondOpInit::resolveReferences(Resolver &R) const {
SmallVector<Init*, 4> NewConds;
bool Changed = false;
for (const Init *Case : getConds()) {
  Init *NewCase = Case->resolveReferences(R);
  NewConds.push_back(NewCase);
  Changed |= NewCase != Case;
}

SmallVector<Init*, 4> NewVals;
for (const Init *Val : getVals()) {
  Init *NewVal = Val->resolveReferences(R);
  NewVals.push_back(NewVal);
  Changed |= NewVal != Val;
}

if (Changed)
  return (CondOpInit::get(NewConds, NewVals,
          getValType()))->Fold(R.getCurrentRecord());

return const_cast<CondOpInit *>(this);
2244}

2246Init *CondOpInit::Fold(Record *CurRec) const {
RecordKeeper &RK = getRecordKeeper();
for ( unsigned i = 0; i < NumConds; ++i) {
  Init *Cond = getCond(i);
  Init *Val = getVal(i);

  if (IntInit *CondI = dyn_cast_or_null<IntInit>(
          Cond->convertInitializerTo(IntRecTy::get(RK)))) {
    if (CondI->getValue())
      return Val->convertInitializerTo(getValType());
  } else {
    return const_cast<CondOpInit *>(this);
  }
}

PrintFatalError(CurRec->getLoc(),
                CurRec->getName() +
                " does not have any true condition in:" +
                this->getAsString());
return nullptr;
2266}

2268bool CondOpInit::isConcrete() const {
for (const Init *Case : getConds())
  if (!Case->isConcrete())
    return false;

for (const Init *Val : getVals())
  if (!Val->isConcrete())
    return false;

return true;
2278}

2280bool CondOpInit::isComplete() const {
for (const Init *Case : getConds())
  if (!Case->isComplete())
    return false;

for (const Init *Val : getVals())
  if (!Val->isConcrete())
    return false;

return true;
2290}

2292std::string CondOpInit::getAsString() const {
std::string Result = "!cond(";
for (unsigned i = 0; i < getNumConds(); i++) {
  Result += getCond(i)->getAsString() + ": ";
  Result += getVal(i)->getAsString();
  if (i != getNumConds()-1)
    Result += ", ";
}
return Result + ")";
2301}

2303Init *CondOpInit::getBit(unsigned Bit) const {
return VarBitInit::get(const_cast<CondOpInit *>(this), Bit);
2305}

2307static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, StringInit *VN,
                         ArrayRef<Init *> ArgRange,
                         ArrayRef<StringInit *> NameRange) {
ID.AddPointer(V);
ID.AddPointer(VN);

ArrayRef<Init *>::iterator Arg = ArgRange.begin();
ArrayRef<StringInit *>::iterator Name = NameRange.begin();
while (Arg != ArgRange.end()) {
  assert(Name != NameRange.end() && "Arg name underflow!")(static_cast <bool> (Name != NameRange.end() &&
 "Arg name underflow!") ? void (0) : __assert_fail ("Name != NameRange.end() && \"Arg name underflow!\""
, "llvm/lib/TableGen/Record.cpp", 2316, __extension__ __PRETTY_FUNCTION__
));
  ID.AddPointer(*Arg++);
  ID.AddPointer(*Name++);
}
assert(Name == NameRange.end() && "Arg name overflow!")(static_cast <bool> (Name == NameRange.end() &&
 "Arg name overflow!") ? void (0) : __assert_fail ("Name == NameRange.end() && \"Arg name overflow!\""
, "llvm/lib/TableGen/Record.cpp", 2320, __extension__ __PRETTY_FUNCTION__
));
2321}

2323DagInit *DagInit::get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange,
                    ArrayRef<StringInit *> NameRange) {
assert(ArgRange.size() == NameRange.size())(static_cast <bool> (ArgRange.size() == NameRange.size(
)) ? void (0) : __assert_fail ("ArgRange.size() == NameRange.size()"
, "llvm/lib/TableGen/Record.cpp", 2325, __extension__ __PRETTY_FUNCTION__
));
FoldingSetNodeID ID;
ProfileDagInit(ID, V, VN, ArgRange, NameRange);

detail::RecordKeeperImpl &RK = V->getRecordKeeper().getImpl();
void *IP = nullptr;
if (DagInit *I = RK.TheDagInitPool.FindNodeOrInsertPos(ID, IP))
  return I;

void *Mem = RK.Allocator.Allocate(
    totalSizeToAlloc<Init *, StringInit *>(ArgRange.size(), NameRange.size()),
    alignof(BitsInit));
DagInit *I = new (Mem) DagInit(V, VN, ArgRange.size(), NameRange.size());
std::uninitialized_copy(ArgRange.begin(), ArgRange.end(),
                        I->getTrailingObjects<Init *>());
std::uninitialized_copy(NameRange.begin(), NameRange.end(),
                        I->getTrailingObjects<StringInit *>());
RK.TheDagInitPool.InsertNode(I, IP);
return I;
2344}

2346DagInit *
2347DagInit::get(Init *V, StringInit *VN,
           ArrayRef<std::pair<Init*, StringInit*>> args) {
SmallVector<Init *, 8> Args;
SmallVector<StringInit *, 8> Names;

for (const auto &Arg : args) {
  Args.push_back(Arg.first);
  Names.push_back(Arg.second);
}

return DagInit::get(V, VN, Args, Names);
2358}

2360void DagInit::Profile(FoldingSetNodeID &ID) const {
ProfileDagInit(ID, Val, ValName,
               ArrayRef(getTrailingObjects<Init *>(), NumArgs),
               ArrayRef(getTrailingObjects<StringInit *>(), NumArgNames));
2364}

2366Record *DagInit::getOperatorAsDef(ArrayRef<SMLoc> Loc) const {
if (DefInit *DefI = dyn_cast<DefInit>(Val))
  return DefI->getDef();
PrintFatalError(Loc, "Expected record as operator");
return nullptr;
2371}

2373Init *DagInit::resolveReferences(Resolver &R) const {
SmallVector<Init*, 8> NewArgs;
NewArgs.reserve(arg_size());
bool ArgsChanged = false;
for (const Init *Arg : getArgs()) {
  Init *NewArg = Arg->resolveReferences(R);
  NewArgs.push_back(NewArg);
  ArgsChanged |= NewArg != Arg;
}

Init *Op = Val->resolveReferences(R);
if (Op != Val || ArgsChanged)
  return DagInit::get(Op, ValName, NewArgs, getArgNames());

return const_cast<DagInit *>(this);
2388}

2390bool DagInit::isConcrete() const {
if (!Val->isConcrete())
  return false;
for (const Init *Elt : getArgs()) {
  if (!Elt->isConcrete())
    return false;
}
return true;
2398}

2400std::string DagInit::getAsString() const {
std::string Result = "(" + Val->getAsString();
if (ValName)
  Result += ":" + ValName->getAsUnquotedString();
if (!arg_empty()) {
  Result += " " + getArg(0)->getAsString();
  if (getArgName(0)) Result += ":$" + getArgName(0)->getAsUnquotedString();
  for (unsigned i = 1, e = getNumArgs(); i != e; ++i) {
    Result += ", " + getArg(i)->getAsString();
    if (getArgName(i)) Result += ":$" + getArgName(i)->getAsUnquotedString();
  }
}
return Result + ")";
2413}

2415//===----------------------------------------------------------------------===//
2416//    Other implementations
2417//===----------------------------------------------------------------------===//

2419RecordVal::RecordVal(Init *N, RecTy *T, FieldKind K)
  : Name(N), TyAndKind(T, K) {
setValue(UnsetInit::get(N->getRecordKeeper()));
assert(Value && "Cannot create unset value for current type!")(static_cast <bool> (Value && "Cannot create unset value for current type!"
) ? void (0) : __assert_fail ("Value && \"Cannot create unset value for current type!\""
, "llvm/lib/TableGen/Record.cpp", 2422, __extension__ __PRETTY_FUNCTION__
));
2423}

2425// This constructor accepts the same arguments as the above, but also
2426// a source location.
2427RecordVal::RecordVal(Init *N, SMLoc Loc, RecTy *T, FieldKind K)
  : Name(N), Loc(Loc), TyAndKind(T, K) {
setValue(UnsetInit::get(N->getRecordKeeper()));
assert(Value && "Cannot create unset value for current type!")(static_cast <bool> (Value && "Cannot create unset value for current type!"
) ? void (0) : __assert_fail ("Value && \"Cannot create unset value for current type!\""
, "llvm/lib/TableGen/Record.cpp", 2430, __extension__ __PRETTY_FUNCTION__
));
2431}

2433StringRef RecordVal::getName() const {
return cast<StringInit>(getNameInit())->getValue();
2435}

2437std::string RecordVal::getPrintType() const {
if (getType() == StringRecTy::get(getRecordKeeper())) {
  if (auto *StrInit = dyn_cast<StringInit>(Value)) {
    if (StrInit->hasCodeFormat())
      return "code";
    else
      return "string";
  } else {
    return "string";
  }
} else {
  return TyAndKind.getPointer()->getAsString();
}
2450}

2452bool RecordVal::setValue(Init *V) {
if (V) {
  Value = V->getCastTo(getType());
  if (Value) {
    assert(!isa<TypedInit>(Value) ||(static_cast <bool> (!isa<TypedInit>(Value) || cast
<TypedInit>(Value)->getType()->typeIsA(getType())
) ? void (0) : __assert_fail ("!isa<TypedInit>(Value) || cast<TypedInit>(Value)->getType()->typeIsA(getType())"
, "llvm/lib/TableGen/Record.cpp", 2457, __extension__ __PRETTY_FUNCTION__
))
           cast<TypedInit>(Value)->getType()->typeIsA(getType()))(static_cast <bool> (!isa<TypedInit>(Value) || cast
<TypedInit>(Value)->getType()->typeIsA(getType())
) ? void (0) : __assert_fail ("!isa<TypedInit>(Value) || cast<TypedInit>(Value)->getType()->typeIsA(getType())"
, "llvm/lib/TableGen/Record.cpp", 2457, __extension__ __PRETTY_FUNCTION__
));
    if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
      if (!isa<BitsInit>(Value)) {
        SmallVector<Init *, 64> Bits;
        Bits.reserve(BTy->getNumBits());
        for (unsigned I = 0, E = BTy->getNumBits(); I < E; ++I)
          Bits.push_back(Value->getBit(I));
        Value = BitsInit::get(V->getRecordKeeper(), Bits);
      }
    }
  }
  return Value == nullptr;
}
Value = nullptr;
return false;
2472}

2474// This version of setValue takes a source location and resets the
2475// location in the RecordVal.
2476bool RecordVal::setValue(Init *V, SMLoc NewLoc) {
Loc = NewLoc;
if (V) {
  Value = V->getCastTo(getType());
  if (Value) {
    assert(!isa<TypedInit>(Value) ||(static_cast <bool> (!isa<TypedInit>(Value) || cast
<TypedInit>(Value)->getType()->typeIsA(getType())
) ? void (0) : __assert_fail ("!isa<TypedInit>(Value) || cast<TypedInit>(Value)->getType()->typeIsA(getType())"
, "llvm/lib/TableGen/Record.cpp", 2482, __extension__ __PRETTY_FUNCTION__
))
           cast<TypedInit>(Value)->getType()->typeIsA(getType()))(static_cast <bool> (!isa<TypedInit>(Value) || cast
<TypedInit>(Value)->getType()->typeIsA(getType())
) ? void (0) : __assert_fail ("!isa<TypedInit>(Value) || cast<TypedInit>(Value)->getType()->typeIsA(getType())"
, "llvm/lib/TableGen/Record.cpp", 2482, __extension__ __PRETTY_FUNCTION__
));
    if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
      if (!isa<BitsInit>(Value)) {
        SmallVector<Init *, 64> Bits;
        Bits.reserve(BTy->getNumBits());
        for (unsigned I = 0, E = BTy->getNumBits(); I < E; ++I)
          Bits.push_back(Value->getBit(I));
        Value = BitsInit::get(getRecordKeeper(), Bits);
      }
    }
  }
  return Value == nullptr;
}
Value = nullptr;
return false;
2497}

2499#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
2500#include "llvm/TableGen/Record.h"
2501LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void RecordVal::dump() const { errs() << *this; }
2502#endif

2504void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
if (isNonconcreteOK()) OS << "field ";
OS << getPrintType() << " " << getNameInitAsString();

if (getValue())
  OS << " = " << *getValue();

if (PrintSem) OS << ";\n";
2512}

2514void Record::updateClassLoc(SMLoc Loc) {
assert(Locs.size() == 1)(static_cast <bool> (Locs.size() == 1) ? void (0) : __assert_fail
 ("Locs.size() == 1", "llvm/lib/TableGen/Record.cpp", 2515, __extension__
 __PRETTY_FUNCTION__));
ForwardDeclarationLocs.push_back(Locs.front());

Locs.clear();
Locs.push_back(Loc);
2520}

2522void Record::checkName() {
// Ensure the record name has string type.
const TypedInit *TypedName = cast<const TypedInit>(Name);
if (!isa<StringRecTy>(TypedName->getType()))
  PrintFatalError(getLoc(), Twine("Record name '") + Name->getAsString() +
                                "' is not a string!");
2528}

2530RecordRecTy *Record::getType() {
SmallVector<Record *, 4> DirectSCs;
getDirectSuperClasses(DirectSCs);
return RecordRecTy::get(TrackedRecords, DirectSCs);
2534}

2536DefInit *Record::getDefInit() {
if (!CorrespondingDefInit) {
  CorrespondingDefInit =
      new (TrackedRecords.getImpl().Allocator) DefInit(this);
}
return CorrespondingDefInit;
2542}

2544unsigned Record::getNewUID(RecordKeeper &RK) {
return RK.getImpl().LastRecordID++;
2546}

2548void Record::setName(Init *NewName) {
Name = NewName;
checkName();
// DO NOT resolve record values to the name at this point because
// there might be default values for arguments of this def.  Those
// arguments might not have been resolved yet so we don't want to
// prematurely assume values for those arguments were not passed to
// this def.
//
// Nonetheless, it may be that some of this Record's values
// reference the record name.  Indeed, the reason for having the
// record name be an Init is to provide this flexibility.  The extra
// resolve steps after completely instantiating defs takes care of
// this.  See TGParser::ParseDef and TGParser::ParseDefm.
2562}

2564// NOTE for the next two functions:
2565// Superclasses are in post-order, so the final one is a direct
2566// superclass. All of its transitive superclases immediately precede it,
2567// so we can step through the direct superclasses in reverse order.

2569bool Record::hasDirectSuperClass(const Record *Superclass) const {
ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses();

for (int I = SCs.size() - 1; I >= 0; --I) {
  const Record *SC = SCs[I].first;
  if (SC == Superclass)
    return true;
  I -= SC->getSuperClasses().size();
}

return false;
2580}

2582void Record::getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const {
ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses();

while (!SCs.empty()) {
  Record *SC = SCs.back().first;
  SCs = SCs.drop_back(1 + SC->getSuperClasses().size());
  Classes.push_back(SC);
}
2590}

2592void Record::resolveReferences(Resolver &R, const RecordVal *SkipVal) {
Init *OldName = getNameInit();
Init *NewName = Name->resolveReferences(R);
if (NewName != OldName) {
  // Re-register with RecordKeeper.
  setName(NewName);
}

// Resolve the field values.
for (RecordVal &Value : Values) {
  if (SkipVal == &Value) // Skip resolve the same field as the given one
    continue;
  if (Init *V = Value.getValue()) {
    Init *VR = V->resolveReferences(R);
    if (Value.setValue(VR)) {
      std::string Type;
      if (TypedInit *VRT = dyn_cast<TypedInit>(VR))
        Type =
            (Twine("of type '") + VRT->getType()->getAsString() + "' ").str();
      PrintFatalError(
          getLoc(),
          Twine("Invalid value ") + Type + "found when setting field '" +
              Value.getNameInitAsString() + "' of type '" +
              Value.getType()->getAsString() +
              "' after resolving references: " + VR->getAsUnquotedString() +
              "\n");
    }
  }
}

// Resolve the assertion expressions.
for (auto &Assertion : Assertions) {
  Init *Value = Assertion.Condition->resolveReferences(R);
  Assertion.Condition = Value;
  Value = Assertion.Message->resolveReferences(R);
  Assertion.Message = Value;
}
2629}

2631void Record::resolveReferences(Init *NewName) {
RecordResolver R(*this);
R.setName(NewName);
R.setFinal(true);
resolveReferences(R);
2636}

2638#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
2639LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void Record::dump() const { errs() << *this; }
2640#endif

2642raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
OS << R.getNameInitAsString();

ArrayRef<Init *> TArgs = R.getTemplateArgs();
if (!TArgs.empty()) {
  OS << "<";
  bool NeedComma = false;
  for (const Init *TA : TArgs) {
    if (NeedComma) OS << ", ";
    NeedComma = true;
    const RecordVal *RV = R.getValue(TA);
    assert(RV && "Template argument record not found??")(static_cast <bool> (RV && "Template argument record not found??"
) ? void (0) : __assert_fail ("RV && \"Template argument record not found??\""
, "llvm/lib/TableGen/Record.cpp", 2653, __extension__ __PRETTY_FUNCTION__
));
    RV->print(OS, false);
  }
  OS << ">";
}

OS << " {";
ArrayRef<std::pair<Record *, SMRange>> SC = R.getSuperClasses();
if (!SC.empty()) {
  OS << "\t//";
  for (const auto &SuperPair : SC)
    OS << " " << SuperPair.first->getNameInitAsString();
}
OS << "\n";

for (const RecordVal &Val : R.getValues())
  if (Val.isNonconcreteOK() && !R.isTemplateArg(Val.getNameInit()))
    OS << Val;
for (const RecordVal &Val : R.getValues())
  if (!Val.isNonconcreteOK() && !R.isTemplateArg(Val.getNameInit()))
    OS << Val;

return OS << "}\n";
2676}

2678SMLoc Record::getFieldLoc(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R)
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");
return R->getLoc();
2684}

2686Init *Record::getValueInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");
return R->getValue();
2692}

2694StringRef Record::getValueAsString(StringRef FieldName) const {
std::optional<StringRef> S = getValueAsOptionalString(FieldName);
if (!S)
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");
return *S;
2700}

2702std::optional<StringRef>
2703Record::getValueAsOptionalString(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  return std::nullopt;
if (isa<UnsetInit>(R->getValue()))
  return std::nullopt;

if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
  return SI->getValue();

PrintFatalError(getLoc(),
                "Record `" + getName() + "', ` field `" + FieldName +
                    "' exists but does not have a string initializer!");
2716}

2718BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");

if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue()))
  return BI;
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName +
                              "' exists but does not have a bits value");
2728}

2730ListInit *Record::getValueAsListInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");

if (ListInit *LI = dyn_cast<ListInit>(R->getValue()))
  return LI;
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName +
                              "' exists but does not have a list value");
2740}

2742std::vector<Record*>
2743Record::getValueAsListOfDefs(StringRef FieldName) const {
ListInit *List = getValueAsListInit(FieldName);
std::vector<Record*> Defs;
for (Init *I : List->getValues()) {
  if (DefInit *DI = dyn_cast<DefInit>(I))
    Defs.push_back(DI->getDef());
  else
    PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
      FieldName + "' list is not entirely DefInit!");
}
return Defs;
2754}

2756int64_t Record::getValueAsInt(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");

if (IntInit *II = dyn_cast<IntInit>(R->getValue()))
  return II->getValue();
PrintFatalError(getLoc(), Twine("Record `") + getName() + "', field `" +
                              FieldName +
                              "' exists but does not have an int value: " +
                              R->getValue()->getAsString());
2768}

2770std::vector<int64_t>
2771Record::getValueAsListOfInts(StringRef FieldName) const {
ListInit *List = getValueAsListInit(FieldName);
std::vector<int64_t> Ints;
for (Init *I : List->getValues()) {
  if (IntInit *II = dyn_cast<IntInit>(I))
    Ints.push_back(II->getValue());
  else
    PrintFatalError(getLoc(),
                    Twine("Record `") + getName() + "', field `" + FieldName +
                        "' exists but does not have a list of ints value: " +
                        I->getAsString());
}
return Ints;
2784}

2786std::vector<StringRef>
2787Record::getValueAsListOfStrings(StringRef FieldName) const {
ListInit *List = getValueAsListInit(FieldName);
std::vector<StringRef> Strings;
for (Init *I : List->getValues()) {
  if (StringInit *SI = dyn_cast<StringInit>(I))
    Strings.push_back(SI->getValue());
  else
    PrintFatalError(getLoc(),
                    Twine("Record `") + getName() + "', field `" + FieldName +
                        "' exists but does not have a list of strings value: " +
                        I->getAsString());
}
return Strings;
2800}

2802Record *Record::getValueAsDef(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");

if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
  return DI->getDef();
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
  FieldName + "' does not have a def initializer!");
2812}

2814Record *Record::getValueAsOptionalDef(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");

if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
  return DI->getDef();
if (isa<UnsetInit>(R->getValue()))
  return nullptr;
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
  FieldName + "' does not have either a def initializer or '?'!");
2826}


2829bool Record::getValueAsBit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");

if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
  return BI->getValue();
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
  FieldName + "' does not have a bit initializer!");
2839}

2841bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName.str() + "'!\n");

if (isa<UnsetInit>(R->getValue())) {
  Unset = true;
  return false;
}
Unset = false;
if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
  return BI->getValue();
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
  FieldName + "' does not have a bit initializer!");
2856}

2858DagInit *Record::getValueAsDag(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (!R || !R->getValue())
  PrintFatalError(getLoc(), "Record `" + getName() +
    "' does not have a field named `" + FieldName + "'!\n");

if (DagInit *DI = dyn_cast<DagInit>(R->getValue()))
  return DI;
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
  FieldName + "' does not have a dag initializer!");
2868}

2870// Check all record assertions: For each one, resolve the condition
2871// and message, then call CheckAssert().
2872// Note: The condition and message are probably already resolved,
2873//       but resolving again allows calls before records are resolved.
2874void Record::checkRecordAssertions() {
RecordResolver R(*this);
R.setFinal(true);

for (const auto &Assertion : getAssertions()) {
  Init *Condition = Assertion.Condition->resolveReferences(R);
  Init *Message = Assertion.Message->resolveReferences(R);
  CheckAssert(Assertion.Loc, Condition, Message);
}
2883}

2885// Report a warning if the record has unused template arguments.
2886void Record::checkUnusedTemplateArgs() {
for (const Init *TA : getTemplateArgs()) {
  const RecordVal *Arg = getValue(TA);
  if (!Arg->isUsed())
    PrintWarning(Arg->getLoc(),
                 "unused template argument: " + Twine(Arg->getName()));
}
2893}

2895RecordKeeper::RecordKeeper()
  : Impl(std::make_unique<detail::RecordKeeperImpl>(*this)) {}
2897RecordKeeper::~RecordKeeper() = default;

2899#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
2900LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void RecordKeeper::dump() const { errs() << *this; }
2901#endif

2903raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
OS << "------------- Classes -----------------\n";
for (const auto &C : RK.getClasses())
  OS << "class " << *C.second;

OS << "------------- Defs -----------------\n";
for (const auto &D : RK.getDefs())
  OS << "def " << *D.second;
return OS;
2912}

2914/// GetNewAnonymousName - Generate a unique anonymous name that can be used as
2915/// an identifier.
2916Init *RecordKeeper::getNewAnonymousName() {
return AnonymousNameInit::get(*this, getImpl().AnonCounter++);
2918}

2920// These functions implement the phase timing facility. Starting a timer
2921// when one is already running stops the running one.

2923void RecordKeeper::startTimer(StringRef Name) {
if (TimingGroup) {
  if (LastTimer && LastTimer->isRunning()) {
    LastTimer->stopTimer();
    if (BackendTimer) {
      LastTimer->clear();
      BackendTimer = false;
    }
  }

  LastTimer = new Timer("", Name, *TimingGroup);
  LastTimer->startTimer();
}
2936}

2938void RecordKeeper::stopTimer() {
if (TimingGroup) {
  assert(LastTimer && "No phase timer was started")(static_cast <bool> (LastTimer && "No phase timer was started"
) ? void (0) : __assert_fail ("LastTimer && \"No phase timer was started\""
, "llvm/lib/TableGen/Record.cpp", 2940, __extension__ __PRETTY_FUNCTION__
));
  LastTimer->stopTimer();
}
2943}

2945void RecordKeeper::startBackendTimer(StringRef Name) {
if (TimingGroup) {
  startTimer(Name);
  BackendTimer = true;
}
2950}

2952void RecordKeeper::stopBackendTimer() {
if (TimingGroup) {
  if (BackendTimer) {
    stopTimer();
    BackendTimer = false;
  }
}
2959}

2961std::vector<Record *>
2962RecordKeeper::getAllDerivedDefinitions(StringRef ClassName) const {
// We cache the record vectors for single classes. Many backends request
// the same vectors multiple times.
auto Pair = ClassRecordsMap.try_emplace(ClassName);
if (Pair.second)
  Pair.first->second = getAllDerivedDefinitions(ArrayRef(ClassName));

return Pair.first->second;
2970}

2972std::vector<Record *> RecordKeeper::getAllDerivedDefinitions(
  ArrayRef<StringRef> ClassNames) const {
SmallVector<Record *, 2> ClassRecs;
std::vector<Record *> Defs;

assert(ClassNames.size() > 0 && "At least one class must be passed.")(static_cast <bool> (ClassNames.size() > 0 &&
 "At least one class must be passed.") ? void (0) : __assert_fail
 ("ClassNames.size() > 0 && \"At least one class must be passed.\""
, "llvm/lib/TableGen/Record.cpp", 2977, __extension__ __PRETTY_FUNCTION__
));
for (const auto &ClassName : ClassNames) {
  Record *Class = getClass(ClassName);
  if (!Class)
    PrintFatalError("The class '" + ClassName + "' is not defined\n");
  ClassRecs.push_back(Class);
}

for (const auto &OneDef : getDefs()) {
  if (all_of(ClassRecs, [&OneDef](const Record *Class) {
                          return OneDef.second->isSubClassOf(Class);
                        }))
    Defs.push_back(OneDef.second.get());
}

return Defs;
2993}

2995std::vector<Record *>
2996RecordKeeper::getAllDerivedDefinitionsIfDefined(StringRef ClassName) const {
return getClass(ClassName) ? getAllDerivedDefinitions(ClassName)
                           : std::vector<Record *>();
2999}

3001Init *MapResolver::resolve(Init *VarName) {
auto It = Map.find(VarName);
if (It == Map.end())
  return nullptr;

Init *I = It->second.V;

if (!It->second.Resolved && Map.size() > 1) {
  // Resolve mutual references among the mapped variables, but prevent
  // infinite recursion.
  Map.erase(It);
  I = I->resolveReferences(*this);
  Map[VarName] = {I, true};
}

return I;
3017}

3019Init *RecordResolver::resolve(Init *VarName) {
Init *Val = Cache.lookup(VarName);
if (Val)
  return Val;

if (llvm::is_contained(Stack, VarName))
  return nullptr; // prevent infinite recursion

if (RecordVal *RV = getCurrentRecord()->getValue(VarName)) {
  if (!isa<UnsetInit>(RV->getValue())) {
    Val = RV->getValue();
    Stack.push_back(VarName);
    Val = Val->resolveReferences(*this);
    Stack.pop_back();
  }
} else if (Name && VarName == getCurrentRecord()->getNameInit()) {
  Stack.push_back(VarName);
  Val = Name->resolveReferences(*this);
  Stack.pop_back();
}

Cache[VarName] = Val;
return Val;
3042}

3044Init *TrackUnresolvedResolver::resolve(Init *VarName) {
Init *I = nullptr;

if (R) {
  I = R->resolve(VarName);
  if (I && !FoundUnresolved) {
    // Do not recurse into the resolved initializer, as that would change
    // the behavior of the resolver we're delegating, but do check to see
    // if there are unresolved variables remaining.
    TrackUnresolvedResolver Sub;
    I->resolveReferences(Sub);
    FoundUnresolved |= Sub.FoundUnresolved;
  }
}

if (!I)
  FoundUnresolved = true;
return I;
3062}

3064Init *HasReferenceResolver::resolve(Init *VarName)
3065{
if (VarName == VarNameToTrack)
  Found = true;
return nullptr;
3069}