1 //===- Record.cpp - Record implementation ---------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // Implement the tablegen record classes. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/TableGen/Record.h" 15 #include "llvm/TableGen/Error.h" 16 #include "llvm/Support/DataTypes.h" 17 #include "llvm/Support/ErrorHandling.h" 18 #include "llvm/Support/Format.h" 19 #include "llvm/ADT/DenseMap.h" 20 #include "llvm/ADT/FoldingSet.h" 21 #include "llvm/ADT/SmallVector.h" 22 #include "llvm/ADT/STLExtras.h" 23 #include "llvm/ADT/StringExtras.h" 24 #include "llvm/ADT/StringMap.h" 25 26 using namespace llvm; 27 28 //===----------------------------------------------------------------------===// 29 // std::string wrapper for DenseMap purposes 30 //===----------------------------------------------------------------------===// 31 32 /// TableGenStringKey - This is a wrapper for std::string suitable for 33 /// using as a key to a DenseMap. Because there isn't a particularly 34 /// good way to indicate tombstone or empty keys for strings, we want 35 /// to wrap std::string to indicate that this is a "special" string 36 /// not expected to take on certain values (those of the tombstone and 37 /// empty keys). This makes things a little safer as it clarifies 38 /// that DenseMap is really not appropriate for general strings. 39 40 class TableGenStringKey { 41 public: 42 TableGenStringKey(const std::string &str) : data(str) {} 43 TableGenStringKey(const char *str) : data(str) {} 44 45 const std::string &str() const { return data; } 46 47 private: 48 std::string data; 49 }; 50 51 /// Specialize DenseMapInfo for TableGenStringKey. 52 namespace llvm { 53 54 template<> struct DenseMapInfo<TableGenStringKey> { 55 static inline TableGenStringKey getEmptyKey() { 56 TableGenStringKey Empty("<<<EMPTY KEY>>>"); 57 return Empty; 58 } 59 static inline TableGenStringKey getTombstoneKey() { 60 TableGenStringKey Tombstone("<<<TOMBSTONE KEY>>>"); 61 return Tombstone; 62 } 63 static unsigned getHashValue(const TableGenStringKey& Val) { 64 return HashString(Val.str()); 65 } 66 static bool isEqual(const TableGenStringKey& LHS, 67 const TableGenStringKey& RHS) { 68 return LHS.str() == RHS.str(); 69 } 70 }; 71 72 } 73 74 //===----------------------------------------------------------------------===// 75 // Type implementations 76 //===----------------------------------------------------------------------===// 77 78 BitRecTy BitRecTy::Shared; 79 IntRecTy IntRecTy::Shared; 80 StringRecTy StringRecTy::Shared; 81 CodeRecTy CodeRecTy::Shared; 82 DagRecTy DagRecTy::Shared; 83 84 void RecTy::dump() const { print(errs()); } 85 86 ListRecTy *RecTy::getListTy() { 87 if (!ListTy) 88 ListTy = new ListRecTy(this); 89 return ListTy; 90 } 91 92 Init *BitRecTy::convertValue(BitsInit *BI) { 93 if (BI->getNumBits() != 1) return 0; // Only accept if just one bit! 94 return BI->getBit(0); 95 } 96 97 bool BitRecTy::baseClassOf(const BitsRecTy *RHS) const { 98 return RHS->getNumBits() == 1; 99 } 100 101 Init *BitRecTy::convertValue(IntInit *II) { 102 int64_t Val = II->getValue(); 103 if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit! 104 105 return BitInit::get(Val != 0); 106 } 107 108 Init *BitRecTy::convertValue(TypedInit *VI) { 109 if (dynamic_cast<BitRecTy*>(VI->getType())) 110 return VI; // Accept variable if it is already of bit type! 111 return 0; 112 } 113 114 BitsRecTy *BitsRecTy::get(unsigned Sz) { 115 static std::vector<BitsRecTy*> Shared; 116 if (Sz >= Shared.size()) 117 Shared.resize(Sz + 1); 118 BitsRecTy *&Ty = Shared[Sz]; 119 if (!Ty) 120 Ty = new BitsRecTy(Sz); 121 return Ty; 122 } 123 124 std::string BitsRecTy::getAsString() const { 125 return "bits<" + utostr(Size) + ">"; 126 } 127 128 Init *BitsRecTy::convertValue(UnsetInit *UI) { 129 SmallVector<Init *, 16> NewBits(Size); 130 131 for (unsigned i = 0; i != Size; ++i) 132 NewBits[i] = UnsetInit::get(); 133 134 return BitsInit::get(NewBits); 135 } 136 137 Init *BitsRecTy::convertValue(BitInit *UI) { 138 if (Size != 1) return 0; // Can only convert single bit. 139 return BitsInit::get(UI); 140 } 141 142 /// canFitInBitfield - Return true if the number of bits is large enough to hold 143 /// the integer value. 144 static bool canFitInBitfield(int64_t Value, unsigned NumBits) { 145 // For example, with NumBits == 4, we permit Values from [-7 .. 15]. 146 return (NumBits >= sizeof(Value) * 8) || 147 (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1); 148 } 149 150 /// convertValue from Int initializer to bits type: Split the integer up into the 151 /// appropriate bits. 152 /// 153 Init *BitsRecTy::convertValue(IntInit *II) { 154 int64_t Value = II->getValue(); 155 // Make sure this bitfield is large enough to hold the integer value. 156 if (!canFitInBitfield(Value, Size)) 157 return 0; 158 159 SmallVector<Init *, 16> NewBits(Size); 160 161 for (unsigned i = 0; i != Size; ++i) 162 NewBits[i] = BitInit::get(Value & (1LL << i)); 163 164 return BitsInit::get(NewBits); 165 } 166 167 Init *BitsRecTy::convertValue(BitsInit *BI) { 168 // If the number of bits is right, return it. Otherwise we need to expand or 169 // truncate. 170 if (BI->getNumBits() == Size) return BI; 171 return 0; 172 } 173 174 Init *BitsRecTy::convertValue(TypedInit *VI) { 175 if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType())) 176 if (BRT->Size == Size) { 177 SmallVector<Init *, 16> NewBits(Size); 178 179 for (unsigned i = 0; i != Size; ++i) 180 NewBits[i] = VarBitInit::get(VI, i); 181 return BitsInit::get(NewBits); 182 } 183 184 if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) 185 return BitsInit::get(VI); 186 187 if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) { 188 if (Tern->getOpcode() == TernOpInit::IF) { 189 Init *LHS = Tern->getLHS(); 190 Init *MHS = Tern->getMHS(); 191 Init *RHS = Tern->getRHS(); 192 193 IntInit *MHSi = dynamic_cast<IntInit*>(MHS); 194 IntInit *RHSi = dynamic_cast<IntInit*>(RHS); 195 196 if (MHSi && RHSi) { 197 int64_t MHSVal = MHSi->getValue(); 198 int64_t RHSVal = RHSi->getValue(); 199 200 if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) { 201 SmallVector<Init *, 16> NewBits(Size); 202 203 for (unsigned i = 0; i != Size; ++i) 204 NewBits[i] = 205 TernOpInit::get(TernOpInit::IF, LHS, 206 IntInit::get((MHSVal & (1LL << i)) ? 1 : 0), 207 IntInit::get((RHSVal & (1LL << i)) ? 1 : 0), 208 VI->getType()); 209 210 return BitsInit::get(NewBits); 211 } 212 } else { 213 BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS); 214 BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS); 215 216 if (MHSbs && RHSbs) { 217 SmallVector<Init *, 16> NewBits(Size); 218 219 for (unsigned i = 0; i != Size; ++i) 220 NewBits[i] = TernOpInit::get(TernOpInit::IF, LHS, 221 MHSbs->getBit(i), 222 RHSbs->getBit(i), 223 VI->getType()); 224 225 return BitsInit::get(NewBits); 226 } 227 } 228 } 229 } 230 231 return 0; 232 } 233 234 Init *IntRecTy::convertValue(BitInit *BI) { 235 return IntInit::get(BI->getValue()); 236 } 237 238 Init *IntRecTy::convertValue(BitsInit *BI) { 239 int64_t Result = 0; 240 for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) 241 if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) { 242 Result |= Bit->getValue() << i; 243 } else { 244 return 0; 245 } 246 return IntInit::get(Result); 247 } 248 249 Init *IntRecTy::convertValue(TypedInit *TI) { 250 if (TI->getType()->typeIsConvertibleTo(this)) 251 return TI; // Accept variable if already of the right type! 252 return 0; 253 } 254 255 Init *StringRecTy::convertValue(UnOpInit *BO) { 256 if (BO->getOpcode() == UnOpInit::CAST) { 257 Init *L = BO->getOperand()->convertInitializerTo(this); 258 if (L == 0) return 0; 259 if (L != BO->getOperand()) 260 return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy); 261 return BO; 262 } 263 264 return convertValue((TypedInit*)BO); 265 } 266 267 Init *StringRecTy::convertValue(BinOpInit *BO) { 268 if (BO->getOpcode() == BinOpInit::STRCONCAT) { 269 Init *L = BO->getLHS()->convertInitializerTo(this); 270 Init *R = BO->getRHS()->convertInitializerTo(this); 271 if (L == 0 || R == 0) return 0; 272 if (L != BO->getLHS() || R != BO->getRHS()) 273 return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy); 274 return BO; 275 } 276 277 return convertValue((TypedInit*)BO); 278 } 279 280 281 Init *StringRecTy::convertValue(TypedInit *TI) { 282 if (dynamic_cast<StringRecTy*>(TI->getType())) 283 return TI; // Accept variable if already of the right type! 284 return 0; 285 } 286 287 std::string ListRecTy::getAsString() const { 288 return "list<" + Ty->getAsString() + ">"; 289 } 290 291 Init *ListRecTy::convertValue(ListInit *LI) { 292 std::vector<Init*> Elements; 293 294 // Verify that all of the elements of the list are subclasses of the 295 // appropriate class! 296 for (unsigned i = 0, e = LI->getSize(); i != e; ++i) 297 if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) 298 Elements.push_back(CI); 299 else 300 return 0; 301 302 ListRecTy *LType = dynamic_cast<ListRecTy*>(LI->getType()); 303 if (LType == 0) { 304 return 0; 305 } 306 307 return ListInit::get(Elements, this); 308 } 309 310 Init *ListRecTy::convertValue(TypedInit *TI) { 311 // Ensure that TI is compatible with our class. 312 if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType())) 313 if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) 314 return TI; 315 return 0; 316 } 317 318 Init *CodeRecTy::convertValue(TypedInit *TI) { 319 if (TI->getType()->typeIsConvertibleTo(this)) 320 return TI; 321 return 0; 322 } 323 324 Init *DagRecTy::convertValue(TypedInit *TI) { 325 if (TI->getType()->typeIsConvertibleTo(this)) 326 return TI; 327 return 0; 328 } 329 330 Init *DagRecTy::convertValue(UnOpInit *BO) { 331 if (BO->getOpcode() == UnOpInit::CAST) { 332 Init *L = BO->getOperand()->convertInitializerTo(this); 333 if (L == 0) return 0; 334 if (L != BO->getOperand()) 335 return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy); 336 return BO; 337 } 338 return 0; 339 } 340 341 Init *DagRecTy::convertValue(BinOpInit *BO) { 342 if (BO->getOpcode() == BinOpInit::CONCAT) { 343 Init *L = BO->getLHS()->convertInitializerTo(this); 344 Init *R = BO->getRHS()->convertInitializerTo(this); 345 if (L == 0 || R == 0) return 0; 346 if (L != BO->getLHS() || R != BO->getRHS()) 347 return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy); 348 return BO; 349 } 350 return 0; 351 } 352 353 RecordRecTy *RecordRecTy::get(Record *R) { 354 return &dynamic_cast<RecordRecTy&>(*R->getDefInit()->getType()); 355 } 356 357 std::string RecordRecTy::getAsString() const { 358 return Rec->getName(); 359 } 360 361 Init *RecordRecTy::convertValue(DefInit *DI) { 362 // Ensure that DI is a subclass of Rec. 363 if (!DI->getDef()->isSubClassOf(Rec)) 364 return 0; 365 return DI; 366 } 367 368 Init *RecordRecTy::convertValue(TypedInit *TI) { 369 // Ensure that TI is compatible with Rec. 370 if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(TI->getType())) 371 if (RRT->getRecord()->isSubClassOf(getRecord()) || 372 RRT->getRecord() == getRecord()) 373 return TI; 374 return 0; 375 } 376 377 bool RecordRecTy::baseClassOf(const RecordRecTy *RHS) const { 378 if (Rec == RHS->getRecord() || RHS->getRecord()->isSubClassOf(Rec)) 379 return true; 380 381 const std::vector<Record*> &SC = Rec->getSuperClasses(); 382 for (unsigned i = 0, e = SC.size(); i != e; ++i) 383 if (RHS->getRecord()->isSubClassOf(SC[i])) 384 return true; 385 386 return false; 387 } 388 389 390 /// resolveTypes - Find a common type that T1 and T2 convert to. 391 /// Return 0 if no such type exists. 392 /// 393 RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { 394 if (!T1->typeIsConvertibleTo(T2)) { 395 if (!T2->typeIsConvertibleTo(T1)) { 396 // If one is a Record type, check superclasses 397 RecordRecTy *RecTy1 = dynamic_cast<RecordRecTy*>(T1); 398 if (RecTy1) { 399 // See if T2 inherits from a type T1 also inherits from 400 const std::vector<Record *> &T1SuperClasses = 401 RecTy1->getRecord()->getSuperClasses(); 402 for(std::vector<Record *>::const_iterator i = T1SuperClasses.begin(), 403 iend = T1SuperClasses.end(); 404 i != iend; 405 ++i) { 406 RecordRecTy *SuperRecTy1 = RecordRecTy::get(*i); 407 RecTy *NewType1 = resolveTypes(SuperRecTy1, T2); 408 if (NewType1 != 0) { 409 if (NewType1 != SuperRecTy1) { 410 delete SuperRecTy1; 411 } 412 return NewType1; 413 } 414 } 415 } 416 RecordRecTy *RecTy2 = dynamic_cast<RecordRecTy*>(T2); 417 if (RecTy2) { 418 // See if T1 inherits from a type T2 also inherits from 419 const std::vector<Record *> &T2SuperClasses = 420 RecTy2->getRecord()->getSuperClasses(); 421 for (std::vector<Record *>::const_iterator i = T2SuperClasses.begin(), 422 iend = T2SuperClasses.end(); 423 i != iend; 424 ++i) { 425 RecordRecTy *SuperRecTy2 = RecordRecTy::get(*i); 426 RecTy *NewType2 = resolveTypes(T1, SuperRecTy2); 427 if (NewType2 != 0) { 428 if (NewType2 != SuperRecTy2) { 429 delete SuperRecTy2; 430 } 431 return NewType2; 432 } 433 } 434 } 435 return 0; 436 } 437 return T2; 438 } 439 return T1; 440 } 441 442 443 //===----------------------------------------------------------------------===// 444 // Initializer implementations 445 //===----------------------------------------------------------------------===// 446 447 void Init::dump() const { return print(errs()); } 448 449 UnsetInit *UnsetInit::get() { 450 static UnsetInit TheInit; 451 return &TheInit; 452 } 453 454 BitInit *BitInit::get(bool V) { 455 static BitInit True(true); 456 static BitInit False(false); 457 458 return V ? &True : &False; 459 } 460 461 static void 462 ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) { 463 ID.AddInteger(Range.size()); 464 465 for (ArrayRef<Init *>::iterator i = Range.begin(), 466 iend = Range.end(); 467 i != iend; 468 ++i) 469 ID.AddPointer(*i); 470 } 471 472 BitsInit *BitsInit::get(ArrayRef<Init *> Range) { 473 typedef FoldingSet<BitsInit> Pool; 474 static Pool ThePool; 475 476 FoldingSetNodeID ID; 477 ProfileBitsInit(ID, Range); 478 479 void *IP = 0; 480 if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 481 return I; 482 483 BitsInit *I = new BitsInit(Range); 484 ThePool.InsertNode(I, IP); 485 486 return I; 487 } 488 489 void BitsInit::Profile(FoldingSetNodeID &ID) const { 490 ProfileBitsInit(ID, Bits); 491 } 492 493 Init * 494 BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 495 SmallVector<Init *, 16> NewBits(Bits.size()); 496 497 for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 498 if (Bits[i] >= getNumBits()) 499 return 0; 500 NewBits[i] = getBit(Bits[i]); 501 } 502 return BitsInit::get(NewBits); 503 } 504 505 std::string BitsInit::getAsString() const { 506 std::string Result = "{ "; 507 for (unsigned i = 0, e = getNumBits(); i != e; ++i) { 508 if (i) Result += ", "; 509 if (Init *Bit = getBit(e-i-1)) 510 Result += Bit->getAsString(); 511 else 512 Result += "*"; 513 } 514 return Result + " }"; 515 } 516 517 // resolveReferences - If there are any field references that refer to fields 518 // that have been filled in, we can propagate the values now. 519 // 520 Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const { 521 bool Changed = false; 522 SmallVector<Init *, 16> NewBits(getNumBits()); 523 524 for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 525 Init *B; 526 Init *CurBit = getBit(i); 527 528 do { 529 B = CurBit; 530 CurBit = CurBit->resolveReferences(R, RV); 531 Changed |= B != CurBit; 532 } while (B != CurBit); 533 NewBits[i] = CurBit; 534 } 535 536 if (Changed) 537 return BitsInit::get(NewBits); 538 539 return const_cast<BitsInit *>(this); 540 } 541 542 IntInit *IntInit::get(int64_t V) { 543 typedef DenseMap<int64_t, IntInit *> Pool; 544 static Pool ThePool; 545 546 IntInit *&I = ThePool[V]; 547 if (!I) I = new IntInit(V); 548 return I; 549 } 550 551 std::string IntInit::getAsString() const { 552 return itostr(Value); 553 } 554 555 Init * 556 IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 557 SmallVector<Init *, 16> NewBits(Bits.size()); 558 559 for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 560 if (Bits[i] >= 64) 561 return 0; 562 563 NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i])); 564 } 565 return BitsInit::get(NewBits); 566 } 567 568 StringInit *StringInit::get(const std::string &V) { 569 typedef StringMap<StringInit *> Pool; 570 static Pool ThePool; 571 572 StringInit *&I = ThePool[V]; 573 if (!I) I = new StringInit(V); 574 return I; 575 } 576 577 CodeInit *CodeInit::get(const std::string &V) { 578 typedef StringMap<CodeInit *> Pool; 579 static Pool ThePool; 580 581 CodeInit *&I = ThePool[V]; 582 if (!I) I = new CodeInit(V); 583 return I; 584 } 585 586 static void ProfileListInit(FoldingSetNodeID &ID, 587 ArrayRef<Init *> Range, 588 RecTy *EltTy) { 589 ID.AddInteger(Range.size()); 590 ID.AddPointer(EltTy); 591 592 for (ArrayRef<Init *>::iterator i = Range.begin(), 593 iend = Range.end(); 594 i != iend; 595 ++i) 596 ID.AddPointer(*i); 597 } 598 599 ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) { 600 typedef FoldingSet<ListInit> Pool; 601 static Pool ThePool; 602 603 // Just use the FoldingSetNodeID to compute a hash. Use a DenseMap 604 // for actual storage. 605 FoldingSetNodeID ID; 606 ProfileListInit(ID, Range, EltTy); 607 608 void *IP = 0; 609 if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 610 return I; 611 612 ListInit *I = new ListInit(Range, EltTy); 613 ThePool.InsertNode(I, IP); 614 return I; 615 } 616 617 void ListInit::Profile(FoldingSetNodeID &ID) const { 618 ListRecTy *ListType = dynamic_cast<ListRecTy *>(getType()); 619 assert(ListType && "Bad type for ListInit!"); 620 RecTy *EltTy = ListType->getElementType(); 621 622 ProfileListInit(ID, Values, EltTy); 623 } 624 625 Init * 626 ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 627 std::vector<Init*> Vals; 628 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 629 if (Elements[i] >= getSize()) 630 return 0; 631 Vals.push_back(getElement(Elements[i])); 632 } 633 return ListInit::get(Vals, getType()); 634 } 635 636 Record *ListInit::getElementAsRecord(unsigned i) const { 637 assert(i < Values.size() && "List element index out of range!"); 638 DefInit *DI = dynamic_cast<DefInit*>(Values[i]); 639 if (DI == 0) throw "Expected record in list!"; 640 return DI->getDef(); 641 } 642 643 Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { 644 std::vector<Init*> Resolved; 645 Resolved.reserve(getSize()); 646 bool Changed = false; 647 648 for (unsigned i = 0, e = getSize(); i != e; ++i) { 649 Init *E; 650 Init *CurElt = getElement(i); 651 652 do { 653 E = CurElt; 654 CurElt = CurElt->resolveReferences(R, RV); 655 Changed |= E != CurElt; 656 } while (E != CurElt); 657 Resolved.push_back(E); 658 } 659 660 if (Changed) 661 return ListInit::get(Resolved, getType()); 662 return const_cast<ListInit *>(this); 663 } 664 665 Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV, 666 unsigned Elt) const { 667 if (Elt >= getSize()) 668 return 0; // Out of range reference. 669 Init *E = getElement(Elt); 670 // If the element is set to some value, or if we are resolving a reference 671 // to a specific variable and that variable is explicitly unset, then 672 // replace the VarListElementInit with it. 673 if (IRV || !dynamic_cast<UnsetInit*>(E)) 674 return E; 675 return 0; 676 } 677 678 std::string ListInit::getAsString() const { 679 std::string Result = "["; 680 for (unsigned i = 0, e = Values.size(); i != e; ++i) { 681 if (i) Result += ", "; 682 Result += Values[i]->getAsString(); 683 } 684 return Result + "]"; 685 } 686 687 Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV, 688 unsigned Bit) const { 689 Init *Folded = Fold(&R, 0); 690 691 if (Folded != this) { 692 TypedInit *Typed = dynamic_cast<TypedInit *>(Folded); 693 if (Typed) { 694 return Typed->resolveBitReference(R, IRV, Bit); 695 } 696 } 697 698 return 0; 699 } 700 701 Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, 702 unsigned Elt) const { 703 Init *Resolved = resolveReferences(R, IRV); 704 OpInit *OResolved = dynamic_cast<OpInit *>(Resolved); 705 if (OResolved) { 706 Resolved = OResolved->Fold(&R, 0); 707 } 708 709 if (Resolved != this) { 710 TypedInit *Typed = dynamic_cast<TypedInit *>(Resolved); 711 assert(Typed && "Expected typed init for list reference"); 712 if (Typed) { 713 Init *New = Typed->resolveListElementReference(R, IRV, Elt); 714 if (New) 715 return New; 716 return VarListElementInit::get(Typed, Elt); 717 } 718 } 719 720 return 0; 721 } 722 723 UnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) { 724 typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key; 725 726 typedef DenseMap<Key, UnOpInit *> Pool; 727 static Pool ThePool; 728 729 Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type)); 730 731 UnOpInit *&I = ThePool[TheKey]; 732 if (!I) I = new UnOpInit(opc, lhs, Type); 733 return I; 734 } 735 736 Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 737 switch (getOpcode()) { 738 default: assert(0 && "Unknown unop"); 739 case CAST: { 740 if (getType()->getAsString() == "string") { 741 StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 742 if (LHSs) { 743 return LHSs; 744 } 745 746 DefInit *LHSd = dynamic_cast<DefInit*>(LHS); 747 if (LHSd) { 748 return StringInit::get(LHSd->getDef()->getName()); 749 } 750 } else { 751 StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 752 if (LHSs) { 753 std::string Name = LHSs->getValue(); 754 755 // From TGParser::ParseIDValue 756 if (CurRec) { 757 if (const RecordVal *RV = CurRec->getValue(Name)) { 758 if (RV->getType() != getType()) 759 throw "type mismatch in cast"; 760 return VarInit::get(Name, RV->getType()); 761 } 762 763 Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, 764 ":"); 765 766 if (CurRec->isTemplateArg(TemplateArgName)) { 767 const RecordVal *RV = CurRec->getValue(TemplateArgName); 768 assert(RV && "Template arg doesn't exist??"); 769 770 if (RV->getType() != getType()) 771 throw "type mismatch in cast"; 772 773 return VarInit::get(TemplateArgName, RV->getType()); 774 } 775 } 776 777 if (CurMultiClass) { 778 Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::"); 779 780 if (CurMultiClass->Rec.isTemplateArg(MCName)) { 781 const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 782 assert(RV && "Template arg doesn't exist??"); 783 784 if (RV->getType() != getType()) 785 throw "type mismatch in cast"; 786 787 return VarInit::get(MCName, RV->getType()); 788 } 789 } 790 791 if (Record *D = (CurRec->getRecords()).getDef(Name)) 792 return DefInit::get(D); 793 794 throw TGError(CurRec->getLoc(), "Undefined reference:'" + Name + "'\n"); 795 } 796 } 797 break; 798 } 799 case HEAD: { 800 ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 801 if (LHSl) { 802 if (LHSl->getSize() == 0) { 803 assert(0 && "Empty list in car"); 804 return 0; 805 } 806 return LHSl->getElement(0); 807 } 808 break; 809 } 810 case TAIL: { 811 ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 812 if (LHSl) { 813 if (LHSl->getSize() == 0) { 814 assert(0 && "Empty list in cdr"); 815 return 0; 816 } 817 // Note the +1. We can't just pass the result of getValues() 818 // directly. 819 ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1; 820 ArrayRef<Init *>::iterator end = LHSl->getValues().end(); 821 ListInit *Result = 822 ListInit::get(ArrayRef<Init *>(begin, end - begin), 823 LHSl->getType()); 824 return Result; 825 } 826 break; 827 } 828 case EMPTY: { 829 ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 830 if (LHSl) { 831 if (LHSl->getSize() == 0) { 832 return IntInit::get(1); 833 } else { 834 return IntInit::get(0); 835 } 836 } 837 StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 838 if (LHSs) { 839 if (LHSs->getValue().empty()) { 840 return IntInit::get(1); 841 } else { 842 return IntInit::get(0); 843 } 844 } 845 846 break; 847 } 848 } 849 return const_cast<UnOpInit *>(this); 850 } 851 852 Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 853 Init *lhs = LHS->resolveReferences(R, RV); 854 855 if (LHS != lhs) 856 return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0); 857 return Fold(&R, 0); 858 } 859 860 std::string UnOpInit::getAsString() const { 861 std::string Result; 862 switch (Opc) { 863 case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break; 864 case HEAD: Result = "!head"; break; 865 case TAIL: Result = "!tail"; break; 866 case EMPTY: Result = "!empty"; break; 867 } 868 return Result + "(" + LHS->getAsString() + ")"; 869 } 870 871 BinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs, 872 Init *rhs, RecTy *Type) { 873 typedef std::pair< 874 std::pair<std::pair<unsigned, Init *>, Init *>, 875 RecTy * 876 > Key; 877 878 typedef DenseMap<Key, BinOpInit *> Pool; 879 static Pool ThePool; 880 881 Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs), 882 Type)); 883 884 BinOpInit *&I = ThePool[TheKey]; 885 if (!I) I = new BinOpInit(opc, lhs, rhs, Type); 886 return I; 887 } 888 889 Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 890 switch (getOpcode()) { 891 default: assert(0 && "Unknown binop"); 892 case CONCAT: { 893 DagInit *LHSs = dynamic_cast<DagInit*>(LHS); 894 DagInit *RHSs = dynamic_cast<DagInit*>(RHS); 895 if (LHSs && RHSs) { 896 DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator()); 897 DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator()); 898 if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) 899 throw "Concated Dag operators do not match!"; 900 std::vector<Init*> Args; 901 std::vector<std::string> ArgNames; 902 for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) { 903 Args.push_back(LHSs->getArg(i)); 904 ArgNames.push_back(LHSs->getArgName(i)); 905 } 906 for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) { 907 Args.push_back(RHSs->getArg(i)); 908 ArgNames.push_back(RHSs->getArgName(i)); 909 } 910 return DagInit::get(LHSs->getOperator(), "", Args, ArgNames); 911 } 912 break; 913 } 914 case STRCONCAT: { 915 StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 916 StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 917 if (LHSs && RHSs) 918 return StringInit::get(LHSs->getValue() + RHSs->getValue()); 919 break; 920 } 921 case EQ: { 922 // try to fold eq comparison for 'bit' and 'int', otherwise fallback 923 // to string objects. 924 IntInit* L = 925 dynamic_cast<IntInit*>(LHS->convertInitializerTo(IntRecTy::get())); 926 IntInit* R = 927 dynamic_cast<IntInit*>(RHS->convertInitializerTo(IntRecTy::get())); 928 929 if (L && R) 930 return IntInit::get(L->getValue() == R->getValue()); 931 932 StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 933 StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 934 935 // Make sure we've resolved 936 if (LHSs && RHSs) 937 return IntInit::get(LHSs->getValue() == RHSs->getValue()); 938 939 break; 940 } 941 case SHL: 942 case SRA: 943 case SRL: { 944 IntInit *LHSi = dynamic_cast<IntInit*>(LHS); 945 IntInit *RHSi = dynamic_cast<IntInit*>(RHS); 946 if (LHSi && RHSi) { 947 int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); 948 int64_t Result; 949 switch (getOpcode()) { 950 default: assert(0 && "Bad opcode!"); 951 case SHL: Result = LHSv << RHSv; break; 952 case SRA: Result = LHSv >> RHSv; break; 953 case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break; 954 } 955 return IntInit::get(Result); 956 } 957 break; 958 } 959 } 960 return const_cast<BinOpInit *>(this); 961 } 962 963 Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 964 Init *lhs = LHS->resolveReferences(R, RV); 965 Init *rhs = RHS->resolveReferences(R, RV); 966 967 if (LHS != lhs || RHS != rhs) 968 return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0); 969 return Fold(&R, 0); 970 } 971 972 std::string BinOpInit::getAsString() const { 973 std::string Result; 974 switch (Opc) { 975 case CONCAT: Result = "!con"; break; 976 case SHL: Result = "!shl"; break; 977 case SRA: Result = "!sra"; break; 978 case SRL: Result = "!srl"; break; 979 case EQ: Result = "!eq"; break; 980 case STRCONCAT: Result = "!strconcat"; break; 981 } 982 return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; 983 } 984 985 TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, 986 Init *mhs, Init *rhs, 987 RecTy *Type) { 988 typedef std::pair< 989 std::pair< 990 std::pair<std::pair<unsigned, RecTy *>, Init *>, 991 Init * 992 >, 993 Init * 994 > Key; 995 996 typedef DenseMap<Key, TernOpInit *> Pool; 997 static Pool ThePool; 998 999 Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc, 1000 Type), 1001 lhs), 1002 mhs), 1003 rhs)); 1004 1005 TernOpInit *&I = ThePool[TheKey]; 1006 if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type); 1007 return I; 1008 } 1009 1010 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 1011 Record *CurRec, MultiClass *CurMultiClass); 1012 1013 static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, 1014 RecTy *Type, Record *CurRec, 1015 MultiClass *CurMultiClass) { 1016 std::vector<Init *> NewOperands; 1017 1018 TypedInit *TArg = dynamic_cast<TypedInit*>(Arg); 1019 1020 // If this is a dag, recurse 1021 if (TArg && TArg->getType()->getAsString() == "dag") { 1022 Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, 1023 CurRec, CurMultiClass); 1024 if (Result != 0) { 1025 return Result; 1026 } else { 1027 return 0; 1028 } 1029 } 1030 1031 for (int i = 0; i < RHSo->getNumOperands(); ++i) { 1032 OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i)); 1033 1034 if (RHSoo) { 1035 Init *Result = EvaluateOperation(RHSoo, LHS, Arg, 1036 Type, CurRec, CurMultiClass); 1037 if (Result != 0) { 1038 NewOperands.push_back(Result); 1039 } else { 1040 NewOperands.push_back(Arg); 1041 } 1042 } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1043 NewOperands.push_back(Arg); 1044 } else { 1045 NewOperands.push_back(RHSo->getOperand(i)); 1046 } 1047 } 1048 1049 // Now run the operator and use its result as the new leaf 1050 const OpInit *NewOp = RHSo->clone(NewOperands); 1051 Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); 1052 if (NewVal != NewOp) 1053 return NewVal; 1054 1055 return 0; 1056 } 1057 1058 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 1059 Record *CurRec, MultiClass *CurMultiClass) { 1060 DagInit *MHSd = dynamic_cast<DagInit*>(MHS); 1061 ListInit *MHSl = dynamic_cast<ListInit*>(MHS); 1062 1063 DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type); 1064 ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type); 1065 1066 OpInit *RHSo = dynamic_cast<OpInit*>(RHS); 1067 1068 if (!RHSo) { 1069 throw TGError(CurRec->getLoc(), "!foreach requires an operator\n"); 1070 } 1071 1072 TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); 1073 1074 if (!LHSt) { 1075 throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n"); 1076 } 1077 1078 if ((MHSd && DagType) || (MHSl && ListType)) { 1079 if (MHSd) { 1080 Init *Val = MHSd->getOperator(); 1081 Init *Result = EvaluateOperation(RHSo, LHS, Val, 1082 Type, CurRec, CurMultiClass); 1083 if (Result != 0) { 1084 Val = Result; 1085 } 1086 1087 std::vector<std::pair<Init *, std::string> > args; 1088 for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { 1089 Init *Arg; 1090 std::string ArgName; 1091 Arg = MHSd->getArg(i); 1092 ArgName = MHSd->getArgName(i); 1093 1094 // Process args 1095 Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, 1096 CurRec, CurMultiClass); 1097 if (Result != 0) { 1098 Arg = Result; 1099 } 1100 1101 // TODO: Process arg names 1102 args.push_back(std::make_pair(Arg, ArgName)); 1103 } 1104 1105 return DagInit::get(Val, "", args); 1106 } 1107 if (MHSl) { 1108 std::vector<Init *> NewOperands; 1109 std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); 1110 1111 for (std::vector<Init *>::iterator li = NewList.begin(), 1112 liend = NewList.end(); 1113 li != liend; 1114 ++li) { 1115 Init *Item = *li; 1116 NewOperands.clear(); 1117 for(int i = 0; i < RHSo->getNumOperands(); ++i) { 1118 // First, replace the foreach variable with the list item 1119 if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1120 NewOperands.push_back(Item); 1121 } else { 1122 NewOperands.push_back(RHSo->getOperand(i)); 1123 } 1124 } 1125 1126 // Now run the operator and use its result as the new list item 1127 const OpInit *NewOp = RHSo->clone(NewOperands); 1128 Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); 1129 if (NewItem != NewOp) 1130 *li = NewItem; 1131 } 1132 return ListInit::get(NewList, MHSl->getType()); 1133 } 1134 } 1135 return 0; 1136 } 1137 1138 Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 1139 switch (getOpcode()) { 1140 default: assert(0 && "Unknown binop"); 1141 case SUBST: { 1142 DefInit *LHSd = dynamic_cast<DefInit*>(LHS); 1143 VarInit *LHSv = dynamic_cast<VarInit*>(LHS); 1144 StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 1145 1146 DefInit *MHSd = dynamic_cast<DefInit*>(MHS); 1147 VarInit *MHSv = dynamic_cast<VarInit*>(MHS); 1148 StringInit *MHSs = dynamic_cast<StringInit*>(MHS); 1149 1150 DefInit *RHSd = dynamic_cast<DefInit*>(RHS); 1151 VarInit *RHSv = dynamic_cast<VarInit*>(RHS); 1152 StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 1153 1154 if ((LHSd && MHSd && RHSd) 1155 || (LHSv && MHSv && RHSv) 1156 || (LHSs && MHSs && RHSs)) { 1157 if (RHSd) { 1158 Record *Val = RHSd->getDef(); 1159 if (LHSd->getAsString() == RHSd->getAsString()) { 1160 Val = MHSd->getDef(); 1161 } 1162 return DefInit::get(Val); 1163 } 1164 if (RHSv) { 1165 std::string Val = RHSv->getName(); 1166 if (LHSv->getAsString() == RHSv->getAsString()) { 1167 Val = MHSv->getName(); 1168 } 1169 return VarInit::get(Val, getType()); 1170 } 1171 if (RHSs) { 1172 std::string Val = RHSs->getValue(); 1173 1174 std::string::size_type found; 1175 std::string::size_type idx = 0; 1176 do { 1177 found = Val.find(LHSs->getValue(), idx); 1178 if (found != std::string::npos) { 1179 Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); 1180 } 1181 idx = found + MHSs->getValue().size(); 1182 } while (found != std::string::npos); 1183 1184 return StringInit::get(Val); 1185 } 1186 } 1187 break; 1188 } 1189 1190 case FOREACH: { 1191 Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), 1192 CurRec, CurMultiClass); 1193 if (Result != 0) { 1194 return Result; 1195 } 1196 break; 1197 } 1198 1199 case IF: { 1200 IntInit *LHSi = dynamic_cast<IntInit*>(LHS); 1201 if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) 1202 LHSi = dynamic_cast<IntInit*>(I); 1203 if (LHSi) { 1204 if (LHSi->getValue()) { 1205 return MHS; 1206 } else { 1207 return RHS; 1208 } 1209 } 1210 break; 1211 } 1212 } 1213 1214 return const_cast<TernOpInit *>(this); 1215 } 1216 1217 Init *TernOpInit::resolveReferences(Record &R, 1218 const RecordVal *RV) const { 1219 Init *lhs = LHS->resolveReferences(R, RV); 1220 1221 if (Opc == IF && lhs != LHS) { 1222 IntInit *Value = dynamic_cast<IntInit*>(lhs); 1223 if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) 1224 Value = dynamic_cast<IntInit*>(I); 1225 if (Value != 0) { 1226 // Short-circuit 1227 if (Value->getValue()) { 1228 Init *mhs = MHS->resolveReferences(R, RV); 1229 return (TernOpInit::get(getOpcode(), lhs, mhs, 1230 RHS, getType()))->Fold(&R, 0); 1231 } else { 1232 Init *rhs = RHS->resolveReferences(R, RV); 1233 return (TernOpInit::get(getOpcode(), lhs, MHS, 1234 rhs, getType()))->Fold(&R, 0); 1235 } 1236 } 1237 } 1238 1239 Init *mhs = MHS->resolveReferences(R, RV); 1240 Init *rhs = RHS->resolveReferences(R, RV); 1241 1242 if (LHS != lhs || MHS != mhs || RHS != rhs) 1243 return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, 1244 getType()))->Fold(&R, 0); 1245 return Fold(&R, 0); 1246 } 1247 1248 std::string TernOpInit::getAsString() const { 1249 std::string Result; 1250 switch (Opc) { 1251 case SUBST: Result = "!subst"; break; 1252 case FOREACH: Result = "!foreach"; break; 1253 case IF: Result = "!if"; break; 1254 } 1255 return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " 1256 + RHS->getAsString() + ")"; 1257 } 1258 1259 RecTy *TypedInit::getFieldType(const std::string &FieldName) const { 1260 RecordRecTy *RecordType = dynamic_cast<RecordRecTy *>(getType()); 1261 if (RecordType) { 1262 RecordVal *Field = RecordType->getRecord()->getValue(FieldName); 1263 if (Field) { 1264 return Field->getType(); 1265 } 1266 } 1267 return 0; 1268 } 1269 1270 Init * 1271 TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 1272 BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType()); 1273 if (T == 0) return 0; // Cannot subscript a non-bits variable. 1274 unsigned NumBits = T->getNumBits(); 1275 1276 SmallVector<Init *, 16> NewBits(Bits.size()); 1277 for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 1278 if (Bits[i] >= NumBits) 1279 return 0; 1280 1281 NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]); 1282 } 1283 return BitsInit::get(NewBits); 1284 } 1285 1286 Init * 1287 TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 1288 ListRecTy *T = dynamic_cast<ListRecTy*>(getType()); 1289 if (T == 0) return 0; // Cannot subscript a non-list variable. 1290 1291 if (Elements.size() == 1) 1292 return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]); 1293 1294 std::vector<Init*> ListInits; 1295 ListInits.reserve(Elements.size()); 1296 for (unsigned i = 0, e = Elements.size(); i != e; ++i) 1297 ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this), 1298 Elements[i])); 1299 return ListInit::get(ListInits, T); 1300 } 1301 1302 1303 VarInit *VarInit::get(const std::string &VN, RecTy *T) { 1304 Init *Value = StringInit::get(VN); 1305 return VarInit::get(Value, T); 1306 } 1307 1308 VarInit *VarInit::get(Init *VN, RecTy *T) { 1309 typedef std::pair<RecTy *, Init *> Key; 1310 typedef DenseMap<Key, VarInit *> Pool; 1311 static Pool ThePool; 1312 1313 Key TheKey(std::make_pair(T, VN)); 1314 1315 VarInit *&I = ThePool[TheKey]; 1316 if (!I) I = new VarInit(VN, T); 1317 return I; 1318 } 1319 1320 const std::string &VarInit::getName() const { 1321 StringInit *NameString = 1322 dynamic_cast<StringInit *>(getNameInit()); 1323 assert(NameString && "VarInit name is not a string!"); 1324 return NameString->getValue(); 1325 } 1326 1327 Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV, 1328 unsigned Bit) const { 1329 if (R.isTemplateArg(getName())) return 0; 1330 if (IRV && IRV->getName() != getName()) return 0; 1331 1332 RecordVal *RV = R.getValue(getName()); 1333 assert(RV && "Reference to a non-existent variable?"); 1334 assert(dynamic_cast<BitsInit*>(RV->getValue())); 1335 BitsInit *BI = (BitsInit*)RV->getValue(); 1336 1337 assert(Bit < BI->getNumBits() && "Bit reference out of range!"); 1338 Init *B = BI->getBit(Bit); 1339 1340 // If the bit is set to some value, or if we are resolving a reference to a 1341 // specific variable and that variable is explicitly unset, then replace the 1342 // VarBitInit with it. 1343 if (IRV || !dynamic_cast<UnsetInit*>(B)) 1344 return B; 1345 return 0; 1346 } 1347 1348 Init *VarInit::resolveListElementReference(Record &R, 1349 const RecordVal *IRV, 1350 unsigned Elt) const { 1351 if (R.isTemplateArg(getName())) return 0; 1352 if (IRV && IRV->getName() != getName()) return 0; 1353 1354 RecordVal *RV = R.getValue(getName()); 1355 assert(RV && "Reference to a non-existent variable?"); 1356 ListInit *LI = dynamic_cast<ListInit*>(RV->getValue()); 1357 if (!LI) { 1358 TypedInit *VI = dynamic_cast<TypedInit*>(RV->getValue()); 1359 assert(VI && "Invalid list element!"); 1360 return VarListElementInit::get(VI, Elt); 1361 } 1362 1363 if (Elt >= LI->getSize()) 1364 return 0; // Out of range reference. 1365 Init *E = LI->getElement(Elt); 1366 // If the element is set to some value, or if we are resolving a reference 1367 // to a specific variable and that variable is explicitly unset, then 1368 // replace the VarListElementInit with it. 1369 if (IRV || !dynamic_cast<UnsetInit*>(E)) 1370 return E; 1371 return 0; 1372 } 1373 1374 1375 RecTy *VarInit::getFieldType(const std::string &FieldName) const { 1376 if (RecordRecTy *RTy = dynamic_cast<RecordRecTy*>(getType())) 1377 if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) 1378 return RV->getType(); 1379 return 0; 1380 } 1381 1382 Init *VarInit::getFieldInit(Record &R, const RecordVal *RV, 1383 const std::string &FieldName) const { 1384 if (dynamic_cast<RecordRecTy*>(getType())) 1385 if (const RecordVal *Val = R.getValue(VarName)) { 1386 if (RV != Val && (RV || dynamic_cast<UnsetInit*>(Val->getValue()))) 1387 return 0; 1388 Init *TheInit = Val->getValue(); 1389 assert(TheInit != this && "Infinite loop detected!"); 1390 if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) 1391 return I; 1392 else 1393 return 0; 1394 } 1395 return 0; 1396 } 1397 1398 /// resolveReferences - This method is used by classes that refer to other 1399 /// variables which may not be defined at the time the expression is formed. 1400 /// If a value is set for the variable later, this method will be called on 1401 /// users of the value to allow the value to propagate out. 1402 /// 1403 Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { 1404 if (RecordVal *Val = R.getValue(VarName)) 1405 if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue()))) 1406 return Val->getValue(); 1407 return const_cast<VarInit *>(this); 1408 } 1409 1410 VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) { 1411 typedef std::pair<TypedInit *, unsigned> Key; 1412 typedef DenseMap<Key, VarBitInit *> Pool; 1413 1414 static Pool ThePool; 1415 1416 Key TheKey(std::make_pair(T, B)); 1417 1418 VarBitInit *&I = ThePool[TheKey]; 1419 if (!I) I = new VarBitInit(T, B); 1420 return I; 1421 } 1422 1423 std::string VarBitInit::getAsString() const { 1424 return TI->getAsString() + "{" + utostr(Bit) + "}"; 1425 } 1426 1427 Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { 1428 if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum())) 1429 return I; 1430 return const_cast<VarBitInit *>(this); 1431 } 1432 1433 VarListElementInit *VarListElementInit::get(TypedInit *T, 1434 unsigned E) { 1435 typedef std::pair<TypedInit *, unsigned> Key; 1436 typedef DenseMap<Key, VarListElementInit *> Pool; 1437 1438 static Pool ThePool; 1439 1440 Key TheKey(std::make_pair(T, E)); 1441 1442 VarListElementInit *&I = ThePool[TheKey]; 1443 if (!I) I = new VarListElementInit(T, E); 1444 return I; 1445 } 1446 1447 std::string VarListElementInit::getAsString() const { 1448 return TI->getAsString() + "[" + utostr(Element) + "]"; 1449 } 1450 1451 Init * 1452 VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const { 1453 if (Init *I = getVariable()->resolveListElementReference(R, RV, 1454 getElementNum())) 1455 return I; 1456 return const_cast<VarListElementInit *>(this); 1457 } 1458 1459 Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV, 1460 unsigned Bit) const { 1461 // FIXME: This should be implemented, to support references like: 1462 // bit B = AA[0]{1}; 1463 return 0; 1464 } 1465 1466 Init *VarListElementInit:: resolveListElementReference(Record &R, 1467 const RecordVal *RV, 1468 unsigned Elt) const { 1469 Init *Result = TI->resolveListElementReference(R, RV, Element); 1470 1471 if (Result) { 1472 TypedInit *TInit = dynamic_cast<TypedInit *>(Result); 1473 if (TInit) { 1474 Init *Result2 = TInit->resolveListElementReference(R, RV, Elt); 1475 if (Result2) return Result2; 1476 return new VarListElementInit(TInit, Elt); 1477 } 1478 return Result; 1479 } 1480 1481 return 0; 1482 } 1483 1484 DefInit *DefInit::get(Record *R) { 1485 return R->getDefInit(); 1486 } 1487 1488 RecTy *DefInit::getFieldType(const std::string &FieldName) const { 1489 if (const RecordVal *RV = Def->getValue(FieldName)) 1490 return RV->getType(); 1491 return 0; 1492 } 1493 1494 Init *DefInit::getFieldInit(Record &R, const RecordVal *RV, 1495 const std::string &FieldName) const { 1496 return Def->getValue(FieldName)->getValue(); 1497 } 1498 1499 1500 std::string DefInit::getAsString() const { 1501 return Def->getName(); 1502 } 1503 1504 FieldInit *FieldInit::get(Init *R, const std::string &FN) { 1505 typedef std::pair<Init *, TableGenStringKey> Key; 1506 typedef DenseMap<Key, FieldInit *> Pool; 1507 static Pool ThePool; 1508 1509 Key TheKey(std::make_pair(R, FN)); 1510 1511 FieldInit *&I = ThePool[TheKey]; 1512 if (!I) I = new FieldInit(R, FN); 1513 return I; 1514 } 1515 1516 Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV, 1517 unsigned Bit) const { 1518 if (Init *BitsVal = Rec->getFieldInit(R, RV, FieldName)) 1519 if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) { 1520 assert(Bit < BI->getNumBits() && "Bit reference out of range!"); 1521 Init *B = BI->getBit(Bit); 1522 1523 if (dynamic_cast<BitInit*>(B)) // If the bit is set. 1524 return B; // Replace the VarBitInit with it. 1525 } 1526 return 0; 1527 } 1528 1529 Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, 1530 unsigned Elt) const { 1531 if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) 1532 if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) { 1533 if (Elt >= LI->getSize()) return 0; 1534 Init *E = LI->getElement(Elt); 1535 1536 // If the element is set to some value, or if we are resolving a 1537 // reference to a specific variable and that variable is explicitly 1538 // unset, then replace the VarListElementInit with it. 1539 if (RV || !dynamic_cast<UnsetInit*>(E)) 1540 return E; 1541 } 1542 return 0; 1543 } 1544 1545 Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { 1546 Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; 1547 1548 Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); 1549 if (BitsVal) { 1550 Init *BVR = BitsVal->resolveReferences(R, RV); 1551 return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this); 1552 } 1553 1554 if (NewRec != Rec) { 1555 return FieldInit::get(NewRec, FieldName); 1556 } 1557 return const_cast<FieldInit *>(this); 1558 } 1559 1560 void ProfileDagInit(FoldingSetNodeID &ID, 1561 Init *V, 1562 const std::string &VN, 1563 ArrayRef<Init *> ArgRange, 1564 ArrayRef<std::string> NameRange) { 1565 ID.AddPointer(V); 1566 ID.AddString(VN); 1567 1568 ArrayRef<Init *>::iterator Arg = ArgRange.begin(); 1569 ArrayRef<std::string>::iterator Name = NameRange.begin(); 1570 while (Arg != ArgRange.end()) { 1571 assert(Name != NameRange.end() && "Arg name underflow!"); 1572 ID.AddPointer(*Arg++); 1573 ID.AddString(*Name++); 1574 } 1575 assert(Name == NameRange.end() && "Arg name overflow!"); 1576 } 1577 1578 DagInit * 1579 DagInit::get(Init *V, const std::string &VN, 1580 ArrayRef<Init *> ArgRange, 1581 ArrayRef<std::string> NameRange) { 1582 typedef FoldingSet<DagInit> Pool; 1583 static Pool ThePool; 1584 1585 FoldingSetNodeID ID; 1586 ProfileDagInit(ID, V, VN, ArgRange, NameRange); 1587 1588 void *IP = 0; 1589 if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 1590 return I; 1591 1592 DagInit *I = new DagInit(V, VN, ArgRange, NameRange); 1593 ThePool.InsertNode(I, IP); 1594 1595 return I; 1596 } 1597 1598 DagInit * 1599 DagInit::get(Init *V, const std::string &VN, 1600 const std::vector<std::pair<Init*, std::string> > &args) { 1601 typedef std::pair<Init*, std::string> PairType; 1602 1603 std::vector<Init *> Args; 1604 std::vector<std::string> Names; 1605 1606 for (std::vector<PairType>::const_iterator i = args.begin(), 1607 iend = args.end(); 1608 i != iend; 1609 ++i) { 1610 Args.push_back(i->first); 1611 Names.push_back(i->second); 1612 } 1613 1614 return DagInit::get(V, VN, Args, Names); 1615 } 1616 1617 void DagInit::Profile(FoldingSetNodeID &ID) const { 1618 ProfileDagInit(ID, Val, ValName, Args, ArgNames); 1619 } 1620 1621 Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { 1622 std::vector<Init*> NewArgs; 1623 for (unsigned i = 0, e = Args.size(); i != e; ++i) 1624 NewArgs.push_back(Args[i]->resolveReferences(R, RV)); 1625 1626 Init *Op = Val->resolveReferences(R, RV); 1627 1628 if (Args != NewArgs || Op != Val) 1629 return DagInit::get(Op, ValName, NewArgs, ArgNames); 1630 1631 return const_cast<DagInit *>(this); 1632 } 1633 1634 1635 std::string DagInit::getAsString() const { 1636 std::string Result = "(" + Val->getAsString(); 1637 if (!ValName.empty()) 1638 Result += ":" + ValName; 1639 if (Args.size()) { 1640 Result += " " + Args[0]->getAsString(); 1641 if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0]; 1642 for (unsigned i = 1, e = Args.size(); i != e; ++i) { 1643 Result += ", " + Args[i]->getAsString(); 1644 if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i]; 1645 } 1646 } 1647 return Result + ")"; 1648 } 1649 1650 1651 //===----------------------------------------------------------------------===// 1652 // Other implementations 1653 //===----------------------------------------------------------------------===// 1654 1655 RecordVal::RecordVal(Init *N, RecTy *T, unsigned P) 1656 : Name(N), Ty(T), Prefix(P) { 1657 Value = Ty->convertValue(UnsetInit::get()); 1658 assert(Value && "Cannot create unset value for current type!"); 1659 } 1660 1661 RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) 1662 : Name(StringInit::get(N)), Ty(T), Prefix(P) { 1663 Value = Ty->convertValue(UnsetInit::get()); 1664 assert(Value && "Cannot create unset value for current type!"); 1665 } 1666 1667 const std::string &RecordVal::getName() const { 1668 StringInit *NameString = dynamic_cast<StringInit *>(Name); 1669 assert(NameString && "RecordVal name is not a string!"); 1670 return NameString->getValue(); 1671 } 1672 1673 void RecordVal::dump() const { errs() << *this; } 1674 1675 void RecordVal::print(raw_ostream &OS, bool PrintSem) const { 1676 if (getPrefix()) OS << "field "; 1677 OS << *getType() << " " << getNameInitAsString(); 1678 1679 if (getValue()) 1680 OS << " = " << *getValue(); 1681 1682 if (PrintSem) OS << ";\n"; 1683 } 1684 1685 unsigned Record::LastID = 0; 1686 1687 void Record::init() { 1688 checkName(); 1689 1690 // Every record potentially has a def at the top. This value is 1691 // replaced with the top-level def name at instantiation time. 1692 RecordVal DN("NAME", StringRecTy::get(), 0); 1693 addValue(DN); 1694 } 1695 1696 void Record::checkName() { 1697 // Ensure the record name has string type. 1698 const TypedInit *TypedName = dynamic_cast<const TypedInit *>(Name); 1699 assert(TypedName && "Record name is not typed!"); 1700 RecTy *Type = TypedName->getType(); 1701 if (dynamic_cast<StringRecTy *>(Type) == 0) { 1702 llvm_unreachable("Record name is not a string!"); 1703 } 1704 } 1705 1706 DefInit *Record::getDefInit() { 1707 if (!TheInit) 1708 TheInit = new DefInit(this, new RecordRecTy(this)); 1709 return TheInit; 1710 } 1711 1712 const std::string &Record::getName() const { 1713 const StringInit *NameString = 1714 dynamic_cast<const StringInit *>(Name); 1715 assert(NameString && "Record name is not a string!"); 1716 return NameString->getValue(); 1717 } 1718 1719 void Record::setName(Init *NewName) { 1720 if (TrackedRecords.getDef(Name->getAsUnquotedString()) == this) { 1721 TrackedRecords.removeDef(Name->getAsUnquotedString()); 1722 TrackedRecords.addDef(this); 1723 } else if (TrackedRecords.getClass(Name->getAsUnquotedString()) == this) { 1724 TrackedRecords.removeClass(Name->getAsUnquotedString()); 1725 TrackedRecords.addClass(this); 1726 } // Otherwise this isn't yet registered. 1727 Name = NewName; 1728 checkName(); 1729 // Since the Init for the name was changed, see if we can resolve 1730 // any of it using members of the Record. 1731 Init *ComputedName = Name->resolveReferences(*this, 0); 1732 if (ComputedName != Name) { 1733 setName(ComputedName); 1734 } 1735 // DO NOT resolve record values to the name at this point because 1736 // there might be default values for arguments of this def. Those 1737 // arguments might not have been resolved yet so we don't want to 1738 // prematurely assume values for those arguments were not passed to 1739 // this def. 1740 // 1741 // Nonetheless, it may be that some of this Record's values 1742 // reference the record name. Indeed, the reason for having the 1743 // record name be an Init is to provide this flexibility. The extra 1744 // resolve steps after completely instantiating defs takes care of 1745 // this. See TGParser::ParseDef and TGParser::ParseDefm. 1746 } 1747 1748 void Record::setName(const std::string &Name) { 1749 setName(StringInit::get(Name)); 1750 } 1751 1752 const RecordVal *Record::getValue(Init *Name) const { 1753 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1754 if (Values[i].getNameInit() == Name) return &Values[i]; 1755 return 0; 1756 } 1757 1758 RecordVal *Record::getValue(Init *Name) { 1759 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1760 if (Values[i].getNameInit() == Name) return &Values[i]; 1761 return 0; 1762 } 1763 1764 /// resolveReferencesTo - If anything in this record refers to RV, replace the 1765 /// reference to RV with the RHS of RV. If RV is null, we resolve all possible 1766 /// references. 1767 void Record::resolveReferencesTo(const RecordVal *RV) { 1768 for (unsigned i = 0, e = Values.size(); i != e; ++i) { 1769 if (Init *V = Values[i].getValue()) 1770 Values[i].setValue(V->resolveReferences(*this, RV)); 1771 } 1772 Init *OldName = getNameInit(); 1773 Init *NewName = Name->resolveReferences(*this, RV); 1774 if (NewName != OldName) { 1775 // Re-register with RecordKeeper. 1776 setName(NewName); 1777 } 1778 } 1779 1780 void Record::dump() const { errs() << *this; } 1781 1782 raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { 1783 OS << R.getNameInitAsString(); 1784 1785 const std::vector<Init *> &TArgs = R.getTemplateArgs(); 1786 if (!TArgs.empty()) { 1787 OS << "<"; 1788 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1789 if (i) OS << ", "; 1790 const RecordVal *RV = R.getValue(TArgs[i]); 1791 assert(RV && "Template argument record not found??"); 1792 RV->print(OS, false); 1793 } 1794 OS << ">"; 1795 } 1796 1797 OS << " {"; 1798 const std::vector<Record*> &SC = R.getSuperClasses(); 1799 if (!SC.empty()) { 1800 OS << "\t//"; 1801 for (unsigned i = 0, e = SC.size(); i != e; ++i) 1802 OS << " " << SC[i]->getNameInitAsString(); 1803 } 1804 OS << "\n"; 1805 1806 const std::vector<RecordVal> &Vals = R.getValues(); 1807 for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1808 if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1809 OS << Vals[i]; 1810 for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1811 if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1812 OS << Vals[i]; 1813 1814 return OS << "}\n"; 1815 } 1816 1817 /// getValueInit - Return the initializer for a value with the specified name, 1818 /// or throw an exception if the field does not exist. 1819 /// 1820 Init *Record::getValueInit(StringRef FieldName) const { 1821 const RecordVal *R = getValue(FieldName); 1822 if (R == 0 || R->getValue() == 0) 1823 throw "Record `" + getName() + "' does not have a field named `" + 1824 FieldName.str() + "'!\n"; 1825 return R->getValue(); 1826 } 1827 1828 1829 /// getValueAsString - This method looks up the specified field and returns its 1830 /// value as a string, throwing an exception if the field does not exist or if 1831 /// the value is not a string. 1832 /// 1833 std::string Record::getValueAsString(StringRef FieldName) const { 1834 const RecordVal *R = getValue(FieldName); 1835 if (R == 0 || R->getValue() == 0) 1836 throw "Record `" + getName() + "' does not have a field named `" + 1837 FieldName.str() + "'!\n"; 1838 1839 if (StringInit *SI = dynamic_cast<StringInit*>(R->getValue())) 1840 return SI->getValue(); 1841 throw "Record `" + getName() + "', field `" + FieldName.str() + 1842 "' does not have a string initializer!"; 1843 } 1844 1845 /// getValueAsBitsInit - This method looks up the specified field and returns 1846 /// its value as a BitsInit, throwing an exception if the field does not exist 1847 /// or if the value is not the right type. 1848 /// 1849 BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { 1850 const RecordVal *R = getValue(FieldName); 1851 if (R == 0 || R->getValue() == 0) 1852 throw "Record `" + getName() + "' does not have a field named `" + 1853 FieldName.str() + "'!\n"; 1854 1855 if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue())) 1856 return BI; 1857 throw "Record `" + getName() + "', field `" + FieldName.str() + 1858 "' does not have a BitsInit initializer!"; 1859 } 1860 1861 /// getValueAsListInit - This method looks up the specified field and returns 1862 /// its value as a ListInit, throwing an exception if the field does not exist 1863 /// or if the value is not the right type. 1864 /// 1865 ListInit *Record::getValueAsListInit(StringRef FieldName) const { 1866 const RecordVal *R = getValue(FieldName); 1867 if (R == 0 || R->getValue() == 0) 1868 throw "Record `" + getName() + "' does not have a field named `" + 1869 FieldName.str() + "'!\n"; 1870 1871 if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue())) 1872 return LI; 1873 throw "Record `" + getName() + "', field `" + FieldName.str() + 1874 "' does not have a list initializer!"; 1875 } 1876 1877 /// getValueAsListOfDefs - This method looks up the specified field and returns 1878 /// its value as a vector of records, throwing an exception if the field does 1879 /// not exist or if the value is not the right type. 1880 /// 1881 std::vector<Record*> 1882 Record::getValueAsListOfDefs(StringRef FieldName) const { 1883 ListInit *List = getValueAsListInit(FieldName); 1884 std::vector<Record*> Defs; 1885 for (unsigned i = 0; i < List->getSize(); i++) { 1886 if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) { 1887 Defs.push_back(DI->getDef()); 1888 } else { 1889 throw "Record `" + getName() + "', field `" + FieldName.str() + 1890 "' list is not entirely DefInit!"; 1891 } 1892 } 1893 return Defs; 1894 } 1895 1896 /// getValueAsInt - This method looks up the specified field and returns its 1897 /// value as an int64_t, throwing an exception if the field does not exist or if 1898 /// the value is not the right type. 1899 /// 1900 int64_t Record::getValueAsInt(StringRef FieldName) const { 1901 const RecordVal *R = getValue(FieldName); 1902 if (R == 0 || R->getValue() == 0) 1903 throw "Record `" + getName() + "' does not have a field named `" + 1904 FieldName.str() + "'!\n"; 1905 1906 if (IntInit *II = dynamic_cast<IntInit*>(R->getValue())) 1907 return II->getValue(); 1908 throw "Record `" + getName() + "', field `" + FieldName.str() + 1909 "' does not have an int initializer!"; 1910 } 1911 1912 /// getValueAsListOfInts - This method looks up the specified field and returns 1913 /// its value as a vector of integers, throwing an exception if the field does 1914 /// not exist or if the value is not the right type. 1915 /// 1916 std::vector<int64_t> 1917 Record::getValueAsListOfInts(StringRef FieldName) const { 1918 ListInit *List = getValueAsListInit(FieldName); 1919 std::vector<int64_t> Ints; 1920 for (unsigned i = 0; i < List->getSize(); i++) { 1921 if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) { 1922 Ints.push_back(II->getValue()); 1923 } else { 1924 throw "Record `" + getName() + "', field `" + FieldName.str() + 1925 "' does not have a list of ints initializer!"; 1926 } 1927 } 1928 return Ints; 1929 } 1930 1931 /// getValueAsListOfStrings - This method looks up the specified field and 1932 /// returns its value as a vector of strings, throwing an exception if the 1933 /// field does not exist or if the value is not the right type. 1934 /// 1935 std::vector<std::string> 1936 Record::getValueAsListOfStrings(StringRef FieldName) const { 1937 ListInit *List = getValueAsListInit(FieldName); 1938 std::vector<std::string> Strings; 1939 for (unsigned i = 0; i < List->getSize(); i++) { 1940 if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) { 1941 Strings.push_back(II->getValue()); 1942 } else { 1943 throw "Record `" + getName() + "', field `" + FieldName.str() + 1944 "' does not have a list of strings initializer!"; 1945 } 1946 } 1947 return Strings; 1948 } 1949 1950 /// getValueAsDef - This method looks up the specified field and returns its 1951 /// value as a Record, throwing an exception if the field does not exist or if 1952 /// the value is not the right type. 1953 /// 1954 Record *Record::getValueAsDef(StringRef FieldName) const { 1955 const RecordVal *R = getValue(FieldName); 1956 if (R == 0 || R->getValue() == 0) 1957 throw "Record `" + getName() + "' does not have a field named `" + 1958 FieldName.str() + "'!\n"; 1959 1960 if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue())) 1961 return DI->getDef(); 1962 throw "Record `" + getName() + "', field `" + FieldName.str() + 1963 "' does not have a def initializer!"; 1964 } 1965 1966 /// getValueAsBit - This method looks up the specified field and returns its 1967 /// value as a bit, throwing an exception if the field does not exist or if 1968 /// the value is not the right type. 1969 /// 1970 bool Record::getValueAsBit(StringRef FieldName) const { 1971 const RecordVal *R = getValue(FieldName); 1972 if (R == 0 || R->getValue() == 0) 1973 throw "Record `" + getName() + "' does not have a field named `" + 1974 FieldName.str() + "'!\n"; 1975 1976 if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue())) 1977 return BI->getValue(); 1978 throw "Record `" + getName() + "', field `" + FieldName.str() + 1979 "' does not have a bit initializer!"; 1980 } 1981 1982 /// getValueAsDag - This method looks up the specified field and returns its 1983 /// value as an Dag, throwing an exception if the field does not exist or if 1984 /// the value is not the right type. 1985 /// 1986 DagInit *Record::getValueAsDag(StringRef FieldName) const { 1987 const RecordVal *R = getValue(FieldName); 1988 if (R == 0 || R->getValue() == 0) 1989 throw "Record `" + getName() + "' does not have a field named `" + 1990 FieldName.str() + "'!\n"; 1991 1992 if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue())) 1993 return DI; 1994 throw "Record `" + getName() + "', field `" + FieldName.str() + 1995 "' does not have a dag initializer!"; 1996 } 1997 1998 std::string Record::getValueAsCode(StringRef FieldName) const { 1999 const RecordVal *R = getValue(FieldName); 2000 if (R == 0 || R->getValue() == 0) 2001 throw "Record `" + getName() + "' does not have a field named `" + 2002 FieldName.str() + "'!\n"; 2003 2004 if (CodeInit *CI = dynamic_cast<CodeInit*>(R->getValue())) 2005 return CI->getValue(); 2006 throw "Record `" + getName() + "', field `" + FieldName.str() + 2007 "' does not have a code initializer!"; 2008 } 2009 2010 2011 void MultiClass::dump() const { 2012 errs() << "Record:\n"; 2013 Rec.dump(); 2014 2015 errs() << "Defs:\n"; 2016 for (RecordVector::const_iterator r = DefPrototypes.begin(), 2017 rend = DefPrototypes.end(); 2018 r != rend; 2019 ++r) { 2020 (*r)->dump(); 2021 } 2022 } 2023 2024 2025 void RecordKeeper::dump() const { errs() << *this; } 2026 2027 raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) { 2028 OS << "------------- Classes -----------------\n"; 2029 const std::map<std::string, Record*> &Classes = RK.getClasses(); 2030 for (std::map<std::string, Record*>::const_iterator I = Classes.begin(), 2031 E = Classes.end(); I != E; ++I) 2032 OS << "class " << *I->second; 2033 2034 OS << "------------- Defs -----------------\n"; 2035 const std::map<std::string, Record*> &Defs = RK.getDefs(); 2036 for (std::map<std::string, Record*>::const_iterator I = Defs.begin(), 2037 E = Defs.end(); I != E; ++I) 2038 OS << "def " << *I->second; 2039 return OS; 2040 } 2041 2042 2043 /// getAllDerivedDefinitions - This method returns all concrete definitions 2044 /// that derive from the specified class name. If a class with the specified 2045 /// name does not exist, an error is printed and true is returned. 2046 std::vector<Record*> 2047 RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { 2048 Record *Class = getClass(ClassName); 2049 if (!Class) 2050 throw "ERROR: Couldn't find the `" + ClassName + "' class!\n"; 2051 2052 std::vector<Record*> Defs; 2053 for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(), 2054 E = getDefs().end(); I != E; ++I) 2055 if (I->second->isSubClassOf(Class)) 2056 Defs.push_back(I->second); 2057 2058 return Defs; 2059 } 2060 2061 /// QualifyName - Return an Init with a qualifier prefix referring 2062 /// to CurRec's name. 2063 Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 2064 Init *Name, const std::string &Scoper) { 2065 RecTy *Type = dynamic_cast<TypedInit *>(Name)->getType(); 2066 2067 BinOpInit *NewName = 2068 BinOpInit::get(BinOpInit::STRCONCAT, 2069 BinOpInit::get(BinOpInit::STRCONCAT, 2070 CurRec.getNameInit(), 2071 StringInit::get(Scoper), 2072 Type)->Fold(&CurRec, CurMultiClass), 2073 Name, 2074 Type); 2075 2076 if (CurMultiClass && Scoper != "::") { 2077 NewName = 2078 BinOpInit::get(BinOpInit::STRCONCAT, 2079 BinOpInit::get(BinOpInit::STRCONCAT, 2080 CurMultiClass->Rec.getNameInit(), 2081 StringInit::get("::"), 2082 Type)->Fold(&CurRec, CurMultiClass), 2083 NewName->Fold(&CurRec, CurMultiClass), 2084 Type); 2085 } 2086 2087 return NewName->Fold(&CurRec, CurMultiClass); 2088 } 2089 2090 /// QualifyName - Return an Init with a qualifier prefix referring 2091 /// to CurRec's name. 2092 Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 2093 const std::string &Name, 2094 const std::string &Scoper) { 2095 return QualifyName(CurRec, CurMultiClass, StringInit::get(Name), Scoper); 2096 } 2097