292 void Init::anchor() {}
295 LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
303 Init *UnsetInit::getCastTo(RecTy *Ty) const {
307 Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
318 Init *BitInit::convertInitializerTo(RecTy *Ty) const {
335 ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
338   for (Init *I : Range)
342 BitsInit *BitsInit::get(ArrayRef<Init *> Range) {
352   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
356                           I->getTrailingObjects<Init *>());
362   ProfileBitsInit(ID, makeArrayRef(getTrailingObjects<Init *>(), NumBits));
365 Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
391 Init *
393   SmallVector<Init *, 16> NewBits(Bits.size());
415     if (Init *Bit = getBit(e-i-1))
425 Init *BitsInit::resolveReferences(Resolver &R) const {
427   SmallVector<Init *, 16> NewBits(getNumBits());
429   Init *CachedBitVarRef = nullptr;
430   Init *CachedBitVarResolved = nullptr;
433     Init *CurBit = getBit(i);
434     Init *NewBit = CurBit;
478 Init *IntInit::convertInitializerTo(RecTy *Ty) const {
494     SmallVector<Init *, 16> NewBits(BRT->getNumBits());
504 Init *
506   SmallVector<Init *, 16> NewBits(Bits.size());
542 Init *StringInit::convertInitializerTo(RecTy *Ty) const {
551 Init *CodeInit::convertInitializerTo(RecTy *Ty) const {
561                             ArrayRef<Init *> Range,
566   for (Init *I : Range)
570 ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
583   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
587                           I->getTrailingObjects<Init *>());
598 Init *ListInit::convertInitializerTo(RecTy *Ty) const {
603     SmallVector<Init*, 8> Elements;
610     for (Init *I : getValues())
611       if (Init *CI = I->convertInitializerTo(ElementType)) {
626 Init *ListInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
627   SmallVector<Init*, 8> Vals;
645 Init *ListInit::resolveReferences(Resolver &R) const {
646   SmallVector<Init*, 8> Resolved;
650   for (Init *CurElt : getValues()) {
651     Init *E = CurElt->resolveReferences(R);
662   for (Init *Element : *this) {
672   for (Init *Element : *this) {
680 Init *OpInit::getBit(unsigned Bit) const {
687 ProfileUnOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *Op, RecTy *Type) {
693 UnOpInit *UnOpInit::get(UnaryOp Opc, Init *LHS, RecTy *Type) {
712 Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
760     if (Init *NewInit = LHS->convertInitializerTo(getType()))
810 Init *UnOpInit::resolveReferences(Resolver &R) const {
811   Init *lhs = LHS->resolveReferences(R);
833 ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
841 BinOpInit *BinOpInit::get(BinaryOp Opc, Init *LHS,
842                           Init *RHS, RecTy *Type) {
868 Init *BinOpInit::getStrConcat(Init *I0, Init *I1) {
878   SmallVector<Init *, 8> Args;
884 Init *BinOpInit::getListConcat(TypedInit *LHS, Init *RHS) {
894 Init *BinOpInit::getListSplat(TypedInit *LHS, Init *RHS) {
898 Init *BinOpInit::Fold(Record *CurRec) const {
914       Init *Op = LOp ? LOp : ROp;
918       SmallVector<Init*, 8> Args;
936       SmallVector<Init *, 8> Args;
947       SmallVector<Init *, 8> Args(Size->getValue(), Value);
1003       SmallVector<Init*, 8> Args;
1045 Init *BinOpInit::resolveReferences(Resolver &R) const {
1046   Init *lhs = LHS->resolveReferences(R);
1047   Init *rhs = RHS->resolveReferences(R);
1081 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
1082                   Init *RHS, RecTy *Type) {
1090 TernOpInit *TernOpInit::get(TernaryOp Opc, Init *LHS, Init *MHS, Init *RHS,
1110 static Init *ForeachApply(Init *LHS, Init *MHSe, Init *RHS, Record *CurRec) {
1116 static Init *ForeachDagApply(Init *LHS, DagInit *MHSd, Init *RHS,
1119   Init *Val = ForeachApply(LHS, MHSd->getOperator(), RHS, CurRec);
1123   SmallVector<std::pair<Init *, StringInit *>, 8> NewArgs;
1125     Init *Arg = MHSd->getArg(i);
1126     Init *NewArg;
1145 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
1151     SmallVector<Init *, 8> NewList(MHSl->begin(), MHSl->end());
1153     for (Init *&Item : NewList) {
1154       Init *NewItem = ForeachApply(LHS, Item, RHS, CurRec);
1164 Init *TernOpInit::Fold(Record *CurRec) const {
1210     if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec))
1235       SmallVector<std::pair<Init *, StringInit *>, 8> Children;
1238         Init *Node = MHSl ? MHSl->getElement(i) : UnsetInit::get();
1239         Init *Name = RHSl ? RHSl->getElement(i) : UnsetInit::get();
1253 Init *TernOpInit::resolveReferences(Resolver &R) const {
1254   Init *lhs = LHS->resolveReferences(R);
1266   Init *mhs = MHS->resolveReferences(R);
1267   Init *rhs;
1297 static void ProfileFoldOpInit(FoldingSetNodeID &ID, Init *A, Init *B,
1298                               Init *Start, Init *List, Init *Expr,
1308 FoldOpInit *FoldOpInit::get(Init *Start, Init *List, Init *A, Init *B,
1309                             Init *Expr, RecTy *Type) {
1328 Init *FoldOpInit::Fold(Record *CurRec) const {
1330     Init *Accum = Start;
1331     for (Init *Elt : *LI) {
1342 Init *FoldOpInit::resolveReferences(Resolver &R) const {
1343   Init *NewStart = Start->resolveReferences(R);
1344   Init *NewList = List->resolveReferences(R);
1348   Init *NewExpr = Expr->resolveReferences(SR);
1357 Init *FoldOpInit::getBit(unsigned Bit) const {
1369                              Init *Expr) {
1374 IsAOpInit *IsAOpInit::get(RecTy *CheckType, Init *Expr) {
1393 Init *IsAOpInit::Fold() const {
1413 Init *IsAOpInit::resolveReferences(Resolver &R) const {
1414   Init *NewExpr = Expr->resolveReferences(R);
1420 Init *IsAOpInit::getBit(unsigned Bit) const {
1440 Init *
1452 Init *TypedInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
1457   SmallVector<Init *, 16> NewBits;
1468 Init *TypedInit::getCastTo(RecTy *Ty) const {
1473   if (Init *Converted = convertInitializerTo(Ty)) {
1486 Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
1493   SmallVector<Init*, 8> ListInits;
1503   Init *Value = StringInit::get(VN);
1507 VarInit *VarInit::get(Init *VN, RecTy *T) {
1508   using Key = std::pair<RecTy *, Init *>;
1524 Init *VarInit::getBit(unsigned Bit) const {
1530 Init *VarInit::resolveReferences(Resolver &R) const {
1531   if (Init *Val = R.resolve(VarName))
1552 Init *VarBitInit::resolveReferences(Resolver &R) const {
1553   Init *I = TI->resolveReferences(R);
1576 Init *VarListElementInit::resolveReferences(Resolver &R) const {
1577   Init *NewTI = TI->resolveReferences(R);
1589 Init *VarListElementInit::getBit(unsigned Bit) const {
1602 Init *DefInit::convertInitializerTo(RecTy *Ty) const {
1621                               ArrayRef<Init *> Args) {
1625   for (Init *I : Args)
1629 VarDefInit *VarDefInit::get(Record *Class, ArrayRef<Init *> Args) {
1639   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
1643                           I->getTrailingObjects<Init *>());
1665     ArrayRef<Init *> TArgs = Class->getTemplateArgs();
1698 Init *VarDefInit::resolveReferences(Resolver &R) const {
1701   SmallVector<Init *, 8> NewArgs;
1704   for (Init *Arg : args()) {
1705     Init *NewArg = Arg->resolveReferences(UR);
1719 Init *VarDefInit::Fold() const {
1724   for (Init *Arg : args())
1735   for (Init *Arg : args()) {
1743 FieldInit *FieldInit::get(Init *R, StringInit *FN) {
1744   using Key = std::pair<Init *, StringInit *>;
1754 Init *FieldInit::getBit(unsigned Bit) const {
1760 Init *FieldInit::resolveReferences(Resolver &R) const {
1761   Init *NewRec = Rec->resolveReferences(R);
1767 Init *FieldInit::Fold(Record *CurRec) const {
1775     Init *FieldVal = Def->getValue(FieldName)->getValue();
1783                              ArrayRef<Init *> CondRange,
1784                              ArrayRef<Init *> ValRange,
1789   ArrayRef<Init *>::iterator Case = CondRange.begin();
1790   ArrayRef<Init *>::iterator Val = ValRange.begin();
1800       makeArrayRef(getTrailingObjects<Init *>(), NumConds),
1801       makeArrayRef(getTrailingObjects<Init *>() + NumConds, NumConds),
1806 CondOpInit::get(ArrayRef<Init *> CondRange,
1807                 ArrayRef<Init *> ValRange, RecTy *Ty) {
1819   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(2*CondRange.size()),
1824                           I->getTrailingObjects<Init *>());
1826                           I->getTrailingObjects<Init *>()+CondRange.size());
1831 Init *CondOpInit::resolveReferences(Resolver &R) const {
1832   SmallVector<Init*, 4> NewConds;
1834   for (const Init *Case : getConds()) {
1835     Init *NewCase = Case->resolveReferences(R);
1840   SmallVector<Init*, 4> NewVals;
1841   for (const Init *Val : getVals()) {
1842     Init *NewVal = Val->resolveReferences(R);
1854 Init *CondOpInit::Fold(Record *CurRec) const {
1856     Init *Cond = getCond(i);
1857     Init *Val = getVal(i);
1875   for (const Init *Case : getConds())
1879   for (const Init *Val : getVals())
1887   for (const Init *Case : getConds())
1891   for (const Init *Val : getVals())
1909 Init *CondOpInit::getBit(unsigned Bit) const {
1913 static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, StringInit *VN,
1914                            ArrayRef<Init *> ArgRange,
1919   ArrayRef<Init *>::iterator Arg = ArgRange.begin();
1930 DagInit::get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange,
1941   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *, StringInit *>(ArgRange.size(), NameRange.size()), alignof(BitsInit));
1944                           I->getTrailingObjects<Init *>());
1952 DagInit::get(Init *V, StringInit *VN,
1953              ArrayRef<std::pair<Init*, StringInit*>> args) {
1954   SmallVector<Init *, 8> Args;
1966   ProfileDagInit(ID, Val, ValName, makeArrayRef(getTrailingObjects<Init *>(), NumArgs), makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames));
1976 Init *DagInit::resolveReferences(Resolver &R) const {
1977   SmallVector<Init*, 8> NewArgs;
1980   for (const Init *Arg : getArgs()) {
1981     Init *NewArg = Arg->resolveReferences(R);
1986   Init *Op = Val->resolveReferences(R);
1996   for (const Init *Elt : getArgs()) {
2022 RecordVal::RecordVal(Init *N, RecTy *T, bool P)
2032 bool RecordVal::setValue(Init *V) {
2040           SmallVector<Init *, 64> Bits;
2090 void Record::setName(Init *NewName) {
2101   // record name be an Init is to provide this flexibility.  The extra
2121     if (Init *V = Value.getValue()) {
2122       Init *VR = V->resolveReferences(R);
2138   Init *OldName = getNameInit();
2139   Init *NewName = Name->resolveReferences(R);
2164   ArrayRef<Init *> TArgs = R.getTemplateArgs();
2168     for (const Init *TA : TArgs) {
2197 Init *Record::getValueInit(StringRef FieldName) const {
2248   for (Init *I : List->getValues()) {
2276   for (Init *I : List->getValues()) {
2292   for (Init *I : List->getValues()) {
2389 Init *RecordKeeper::getNewAnonymousName() {
2407 Init *MapResolver::resolve(Init *VarName) {
2412   Init *I = It->second.V;
2425 Init *RecordResolver::resolve(Init *VarName) {
2426   Init *Val = Cache.lookup(VarName);
2430   for (Init *S : Stack) {
2448 Init *TrackUnresolvedResolver::resolve(Init *VarName) {
2449   Init *I = nullptr;
2468 Init *HasReferenceResolver::resolve(Init *VarName)

Indexes created Tue Jun 18 09:53:56 MDT 2024