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 //===----------------------------------------------------------------------===//
12
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/DenseMap.h"
15 #include "llvm/ADT/FoldingSet.h"
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/ADT/SmallVector.h"
18 #include "llvm/ADT/Statistic.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/ADT/StringMap.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/ADT/StringSet.h"
23 #include "llvm/Config/llvm-config.h"
24 #include "llvm/Support/Allocator.h"
25 #include "llvm/Support/Casting.h"
26 #include "llvm/Support/Compiler.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/SMLoc.h"
29 #include "llvm/Support/raw_ostream.h"
30 #include "llvm/TableGen/Error.h"
31 #include "llvm/TableGen/Record.h"
32 #include <cassert>
33 #include <cstdint>
34 #include <memory>
35 #include <map>
36 #include <string>
37 #include <utility>
38 #include <vector>
39
40 using namespace llvm;
41
42 #define DEBUG_TYPE "tblgen-records"
43
44 static BumpPtrAllocator Allocator;
45
46 //===----------------------------------------------------------------------===//
47 // Type implementations
48 //===----------------------------------------------------------------------===//
49
50 BitRecTy BitRecTy::Shared;
51 IntRecTy IntRecTy::Shared;
52 StringRecTy StringRecTy::Shared;
53 DagRecTy DagRecTy::Shared;
54
55 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump() const56 LLVM_DUMP_METHOD void RecTy::dump() const { print(errs()); }
57 #endif
58
getListTy()59 ListRecTy *RecTy::getListTy() {
60 if (!ListTy)
61 ListTy = new(Allocator) ListRecTy(this);
62 return ListTy;
63 }
64
typeIsConvertibleTo(const RecTy * RHS) const65 bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
66 assert(RHS && "NULL pointer");
67 return Kind == RHS->getRecTyKind();
68 }
69
typeIsA(const RecTy * RHS) const70 bool RecTy::typeIsA(const RecTy *RHS) const { return this == RHS; }
71
typeIsConvertibleTo(const RecTy * RHS) const72 bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
73 if (RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind)
74 return true;
75 if (const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
76 return BitsTy->getNumBits() == 1;
77 return false;
78 }
79
get(unsigned Sz)80 BitsRecTy *BitsRecTy::get(unsigned Sz) {
81 static std::vector<BitsRecTy*> Shared;
82 if (Sz >= Shared.size())
83 Shared.resize(Sz + 1);
84 BitsRecTy *&Ty = Shared[Sz];
85 if (!Ty)
86 Ty = new(Allocator) BitsRecTy(Sz);
87 return Ty;
88 }
89
getAsString() const90 std::string BitsRecTy::getAsString() const {
91 return "bits<" + utostr(Size) + ">";
92 }
93
typeIsConvertibleTo(const RecTy * RHS) const94 bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
95 if (RecTy::typeIsConvertibleTo(RHS)) //argument and the sender are same type
96 return cast<BitsRecTy>(RHS)->Size == Size;
97 RecTyKind kind = RHS->getRecTyKind();
98 return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind);
99 }
100
typeIsA(const RecTy * RHS) const101 bool BitsRecTy::typeIsA(const RecTy *RHS) const {
102 if (const BitsRecTy *RHSb = dyn_cast<BitsRecTy>(RHS))
103 return RHSb->Size == Size;
104 return false;
105 }
106
typeIsConvertibleTo(const RecTy * RHS) const107 bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
108 RecTyKind kind = RHS->getRecTyKind();
109 return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
110 }
111
getAsString() const112 std::string StringRecTy::getAsString() const {
113 return "string";
114 }
115
typeIsConvertibleTo(const RecTy * RHS) const116 bool StringRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
117 RecTyKind Kind = RHS->getRecTyKind();
118 return Kind == StringRecTyKind;
119 }
120
getAsString() const121 std::string ListRecTy::getAsString() const {
122 return "list<" + ElementTy->getAsString() + ">";
123 }
124
typeIsConvertibleTo(const RecTy * RHS) const125 bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
126 if (const auto *ListTy = dyn_cast<ListRecTy>(RHS))
127 return ElementTy->typeIsConvertibleTo(ListTy->getElementType());
128 return false;
129 }
130
typeIsA(const RecTy * RHS) const131 bool ListRecTy::typeIsA(const RecTy *RHS) const {
132 if (const ListRecTy *RHSl = dyn_cast<ListRecTy>(RHS))
133 return getElementType()->typeIsA(RHSl->getElementType());
134 return false;
135 }
136
getAsString() const137 std::string DagRecTy::getAsString() const {
138 return "dag";
139 }
140
ProfileRecordRecTy(FoldingSetNodeID & ID,ArrayRef<Record * > Classes)141 static void ProfileRecordRecTy(FoldingSetNodeID &ID,
142 ArrayRef<Record *> Classes) {
143 ID.AddInteger(Classes.size());
144 for (Record *R : Classes)
145 ID.AddPointer(R);
146 }
147
get(ArrayRef<Record * > UnsortedClasses)148 RecordRecTy *RecordRecTy::get(ArrayRef<Record *> UnsortedClasses) {
149 if (UnsortedClasses.empty()) {
150 static RecordRecTy AnyRecord(0);
151 return &AnyRecord;
152 }
153
154 FoldingSet<RecordRecTy> &ThePool =
155 UnsortedClasses[0]->getRecords().RecordTypePool;
156
157 SmallVector<Record *, 4> Classes(UnsortedClasses.begin(),
158 UnsortedClasses.end());
159 llvm::sort(Classes, [](Record *LHS, Record *RHS) {
160 return LHS->getNameInitAsString() < RHS->getNameInitAsString();
161 });
162
163 FoldingSetNodeID ID;
164 ProfileRecordRecTy(ID, Classes);
165
166 void *IP = nullptr;
167 if (RecordRecTy *Ty = ThePool.FindNodeOrInsertPos(ID, IP))
168 return Ty;
169
170 #ifndef NDEBUG
171 // Check for redundancy.
172 for (unsigned i = 0; i < Classes.size(); ++i) {
173 for (unsigned j = 0; j < Classes.size(); ++j) {
174 assert(i == j || !Classes[i]->isSubClassOf(Classes[j]));
175 }
176 assert(&Classes[0]->getRecords() == &Classes[i]->getRecords());
177 }
178 #endif
179
180 void *Mem = Allocator.Allocate(totalSizeToAlloc<Record *>(Classes.size()),
181 alignof(RecordRecTy));
182 RecordRecTy *Ty = new(Mem) RecordRecTy(Classes.size());
183 std::uninitialized_copy(Classes.begin(), Classes.end(),
184 Ty->getTrailingObjects<Record *>());
185 ThePool.InsertNode(Ty, IP);
186 return Ty;
187 }
188
Profile(FoldingSetNodeID & ID) const189 void RecordRecTy::Profile(FoldingSetNodeID &ID) const {
190 ProfileRecordRecTy(ID, getClasses());
191 }
192
getAsString() const193 std::string RecordRecTy::getAsString() const {
194 if (NumClasses == 1)
195 return getClasses()[0]->getNameInitAsString();
196
197 std::string Str = "{";
198 bool First = true;
199 for (Record *R : getClasses()) {
200 if (!First)
201 Str += ", ";
202 First = false;
203 Str += R->getNameInitAsString();
204 }
205 Str += "}";
206 return Str;
207 }
208
isSubClassOf(Record * Class) const209 bool RecordRecTy::isSubClassOf(Record *Class) const {
210 return llvm::any_of(getClasses(), [Class](Record *MySuperClass) {
211 return MySuperClass == Class ||
212 MySuperClass->isSubClassOf(Class);
213 });
214 }
215
typeIsConvertibleTo(const RecTy * RHS) const216 bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
217 if (this == RHS)
218 return true;
219
220 const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS);
221 if (!RTy)
222 return false;
223
224 return llvm::all_of(RTy->getClasses(), [this](Record *TargetClass) {
225 return isSubClassOf(TargetClass);
226 });
227 }
228
typeIsA(const RecTy * RHS) const229 bool RecordRecTy::typeIsA(const RecTy *RHS) const {
230 return typeIsConvertibleTo(RHS);
231 }
232
resolveRecordTypes(RecordRecTy * T1,RecordRecTy * T2)233 static RecordRecTy *resolveRecordTypes(RecordRecTy *T1, RecordRecTy *T2) {
234 SmallVector<Record *, 4> CommonSuperClasses;
235 SmallVector<Record *, 4> Stack(T1->classes_begin(), T1->classes_end());
236
237 while (!Stack.empty()) {
238 Record *R = Stack.pop_back_val();
239
240 if (T2->isSubClassOf(R)) {
241 CommonSuperClasses.push_back(R);
242 } else {
243 R->getDirectSuperClasses(Stack);
244 }
245 }
246
247 return RecordRecTy::get(CommonSuperClasses);
248 }
249
resolveTypes(RecTy * T1,RecTy * T2)250 RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
251 if (T1 == T2)
252 return T1;
253
254 if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) {
255 if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2))
256 return resolveRecordTypes(RecTy1, RecTy2);
257 }
258
259 if (T1->typeIsConvertibleTo(T2))
260 return T2;
261 if (T2->typeIsConvertibleTo(T1))
262 return T1;
263
264 if (ListRecTy *ListTy1 = dyn_cast<ListRecTy>(T1)) {
265 if (ListRecTy *ListTy2 = dyn_cast<ListRecTy>(T2)) {
266 RecTy* NewType = resolveTypes(ListTy1->getElementType(),
267 ListTy2->getElementType());
268 if (NewType)
269 return NewType->getListTy();
270 }
271 }
272
273 return nullptr;
274 }
275
276 //===----------------------------------------------------------------------===//
277 // Initializer implementations
278 //===----------------------------------------------------------------------===//
279
anchor()280 void Init::anchor() {}
281
282 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump() const283 LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
284 #endif
285
get()286 UnsetInit *UnsetInit::get() {
287 static UnsetInit TheInit;
288 return &TheInit;
289 }
290
getCastTo(RecTy * Ty) const291 Init *UnsetInit::getCastTo(RecTy *Ty) const {
292 return const_cast<UnsetInit *>(this);
293 }
294
convertInitializerTo(RecTy * Ty) const295 Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
296 return const_cast<UnsetInit *>(this);
297 }
298
get(bool V)299 BitInit *BitInit::get(bool V) {
300 static BitInit True(true);
301 static BitInit False(false);
302
303 return V ? &True : &False;
304 }
305
convertInitializerTo(RecTy * Ty) const306 Init *BitInit::convertInitializerTo(RecTy *Ty) const {
307 if (isa<BitRecTy>(Ty))
308 return const_cast<BitInit *>(this);
309
310 if (isa<IntRecTy>(Ty))
311 return IntInit::get(getValue());
312
313 if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
314 // Can only convert single bit.
315 if (BRT->getNumBits() == 1)
316 return BitsInit::get(const_cast<BitInit *>(this));
317 }
318
319 return nullptr;
320 }
321
322 static void
ProfileBitsInit(FoldingSetNodeID & ID,ArrayRef<Init * > Range)323 ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
324 ID.AddInteger(Range.size());
325
326 for (Init *I : Range)
327 ID.AddPointer(I);
328 }
329
get(ArrayRef<Init * > Range)330 BitsInit *BitsInit::get(ArrayRef<Init *> Range) {
331 static FoldingSet<BitsInit> ThePool;
332
333 FoldingSetNodeID ID;
334 ProfileBitsInit(ID, Range);
335
336 void *IP = nullptr;
337 if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
338 return I;
339
340 void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
341 alignof(BitsInit));
342 BitsInit *I = new(Mem) BitsInit(Range.size());
343 std::uninitialized_copy(Range.begin(), Range.end(),
344 I->getTrailingObjects<Init *>());
345 ThePool.InsertNode(I, IP);
346 return I;
347 }
348
Profile(FoldingSetNodeID & ID) const349 void BitsInit::Profile(FoldingSetNodeID &ID) const {
350 ProfileBitsInit(ID, makeArrayRef(getTrailingObjects<Init *>(), NumBits));
351 }
352
convertInitializerTo(RecTy * Ty) const353 Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
354 if (isa<BitRecTy>(Ty)) {
355 if (getNumBits() != 1) return nullptr; // Only accept if just one bit!
356 return getBit(0);
357 }
358
359 if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
360 // If the number of bits is right, return it. Otherwise we need to expand
361 // or truncate.
362 if (getNumBits() != BRT->getNumBits()) return nullptr;
363 return const_cast<BitsInit *>(this);
364 }
365
366 if (isa<IntRecTy>(Ty)) {
367 int64_t Result = 0;
368 for (unsigned i = 0, e = getNumBits(); i != e; ++i)
369 if (auto *Bit = dyn_cast<BitInit>(getBit(i)))
370 Result |= static_cast<int64_t>(Bit->getValue()) << i;
371 else
372 return nullptr;
373 return IntInit::get(Result);
374 }
375
376 return nullptr;
377 }
378
379 Init *
convertInitializerBitRange(ArrayRef<unsigned> Bits) const380 BitsInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
381 SmallVector<Init *, 16> NewBits(Bits.size());
382
383 for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
384 if (Bits[i] >= getNumBits())
385 return nullptr;
386 NewBits[i] = getBit(Bits[i]);
387 }
388 return BitsInit::get(NewBits);
389 }
390
isConcrete() const391 bool BitsInit::isConcrete() const {
392 for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
393 if (!getBit(i)->isConcrete())
394 return false;
395 }
396 return true;
397 }
398
getAsString() const399 std::string BitsInit::getAsString() const {
400 std::string Result = "{ ";
401 for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
402 if (i) Result += ", ";
403 if (Init *Bit = getBit(e-i-1))
404 Result += Bit->getAsString();
405 else
406 Result += "*";
407 }
408 return Result + " }";
409 }
410
411 // resolveReferences - If there are any field references that refer to fields
412 // that have been filled in, we can propagate the values now.
resolveReferences(Resolver & R) const413 Init *BitsInit::resolveReferences(Resolver &R) const {
414 bool Changed = false;
415 SmallVector<Init *, 16> NewBits(getNumBits());
416
417 Init *CachedBitVarRef = nullptr;
418 Init *CachedBitVarResolved = nullptr;
419
420 for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
421 Init *CurBit = getBit(i);
422 Init *NewBit = CurBit;
423
424 if (VarBitInit *CurBitVar = dyn_cast<VarBitInit>(CurBit)) {
425 if (CurBitVar->getBitVar() != CachedBitVarRef) {
426 CachedBitVarRef = CurBitVar->getBitVar();
427 CachedBitVarResolved = CachedBitVarRef->resolveReferences(R);
428 }
429 assert(CachedBitVarResolved && "Unresolved bitvar reference");
430 NewBit = CachedBitVarResolved->getBit(CurBitVar->getBitNum());
431 } else {
432 // getBit(0) implicitly converts int and bits<1> values to bit.
433 NewBit = CurBit->resolveReferences(R)->getBit(0);
434 }
435
436 if (isa<UnsetInit>(NewBit) && R.keepUnsetBits())
437 NewBit = CurBit;
438 NewBits[i] = NewBit;
439 Changed |= CurBit != NewBit;
440 }
441
442 if (Changed)
443 return BitsInit::get(NewBits);
444
445 return const_cast<BitsInit *>(this);
446 }
447
get(int64_t V)448 IntInit *IntInit::get(int64_t V) {
449 static std::map<int64_t, IntInit*> ThePool;
450
451 IntInit *&I = ThePool[V];
452 if (!I) I = new(Allocator) IntInit(V);
453 return I;
454 }
455
getAsString() const456 std::string IntInit::getAsString() const {
457 return itostr(Value);
458 }
459
canFitInBitfield(int64_t Value,unsigned NumBits)460 static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
461 // For example, with NumBits == 4, we permit Values from [-7 .. 15].
462 return (NumBits >= sizeof(Value) * 8) ||
463 (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1);
464 }
465
convertInitializerTo(RecTy * Ty) const466 Init *IntInit::convertInitializerTo(RecTy *Ty) const {
467 if (isa<IntRecTy>(Ty))
468 return const_cast<IntInit *>(this);
469
470 if (isa<BitRecTy>(Ty)) {
471 int64_t Val = getValue();
472 if (Val != 0 && Val != 1) return nullptr; // Only accept 0 or 1 for a bit!
473 return BitInit::get(Val != 0);
474 }
475
476 if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
477 int64_t Value = getValue();
478 // Make sure this bitfield is large enough to hold the integer value.
479 if (!canFitInBitfield(Value, BRT->getNumBits()))
480 return nullptr;
481
482 SmallVector<Init *, 16> NewBits(BRT->getNumBits());
483 for (unsigned i = 0; i != BRT->getNumBits(); ++i)
484 NewBits[i] = BitInit::get(Value & ((i < 64) ? (1LL << i) : 0));
485
486 return BitsInit::get(NewBits);
487 }
488
489 return nullptr;
490 }
491
492 Init *
convertInitializerBitRange(ArrayRef<unsigned> Bits) const493 IntInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
494 SmallVector<Init *, 16> NewBits(Bits.size());
495
496 for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
497 if (Bits[i] >= 64)
498 return nullptr;
499
500 NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i]));
501 }
502 return BitsInit::get(NewBits);
503 }
504
get(unsigned V)505 AnonymousNameInit *AnonymousNameInit::get(unsigned V) {
506 return new (Allocator) AnonymousNameInit(V);
507 }
508
getNameInit() const509 StringInit *AnonymousNameInit::getNameInit() const {
510 return StringInit::get(getAsString());
511 }
512
getAsString() const513 std::string AnonymousNameInit::getAsString() const {
514 return "anonymous_" + utostr(Value);
515 }
516
resolveReferences(Resolver & R) const517 Init *AnonymousNameInit::resolveReferences(Resolver &R) const {
518 auto *Old = const_cast<Init *>(static_cast<const Init *>(this));
519 auto *New = R.resolve(Old);
520 New = New ? New : Old;
521 if (R.isFinal())
522 if (auto *Anonymous = dyn_cast<AnonymousNameInit>(New))
523 return Anonymous->getNameInit();
524 return New;
525 }
526
get(StringRef V,StringFormat Fmt)527 StringInit *StringInit::get(StringRef V, StringFormat Fmt) {
528 static StringMap<StringInit*, BumpPtrAllocator &> StringPool(Allocator);
529 static StringMap<StringInit*, BumpPtrAllocator &> CodePool(Allocator);
530
531 if (Fmt == SF_String) {
532 auto &Entry = *StringPool.insert(std::make_pair(V, nullptr)).first;
533 if (!Entry.second)
534 Entry.second = new (Allocator) StringInit(Entry.getKey(), Fmt);
535 return Entry.second;
536 } else {
537 auto &Entry = *CodePool.insert(std::make_pair(V, nullptr)).first;
538 if (!Entry.second)
539 Entry.second = new (Allocator) StringInit(Entry.getKey(), Fmt);
540 return Entry.second;
541 }
542 }
543
convertInitializerTo(RecTy * Ty) const544 Init *StringInit::convertInitializerTo(RecTy *Ty) const {
545 if (isa<StringRecTy>(Ty))
546 return const_cast<StringInit *>(this);
547
548 return nullptr;
549 }
550
ProfileListInit(FoldingSetNodeID & ID,ArrayRef<Init * > Range,RecTy * EltTy)551 static void ProfileListInit(FoldingSetNodeID &ID,
552 ArrayRef<Init *> Range,
553 RecTy *EltTy) {
554 ID.AddInteger(Range.size());
555 ID.AddPointer(EltTy);
556
557 for (Init *I : Range)
558 ID.AddPointer(I);
559 }
560
get(ArrayRef<Init * > Range,RecTy * EltTy)561 ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
562 static FoldingSet<ListInit> ThePool;
563
564 FoldingSetNodeID ID;
565 ProfileListInit(ID, Range, EltTy);
566
567 void *IP = nullptr;
568 if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
569 return I;
570
571 assert(Range.empty() || !isa<TypedInit>(Range[0]) ||
572 cast<TypedInit>(Range[0])->getType()->typeIsConvertibleTo(EltTy));
573
574 void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
575 alignof(ListInit));
576 ListInit *I = new(Mem) ListInit(Range.size(), EltTy);
577 std::uninitialized_copy(Range.begin(), Range.end(),
578 I->getTrailingObjects<Init *>());
579 ThePool.InsertNode(I, IP);
580 return I;
581 }
582
Profile(FoldingSetNodeID & ID) const583 void ListInit::Profile(FoldingSetNodeID &ID) const {
584 RecTy *EltTy = cast<ListRecTy>(getType())->getElementType();
585
586 ProfileListInit(ID, getValues(), EltTy);
587 }
588
convertInitializerTo(RecTy * Ty) const589 Init *ListInit::convertInitializerTo(RecTy *Ty) const {
590 if (getType() == Ty)
591 return const_cast<ListInit*>(this);
592
593 if (auto *LRT = dyn_cast<ListRecTy>(Ty)) {
594 SmallVector<Init*, 8> Elements;
595 Elements.reserve(getValues().size());
596
597 // Verify that all of the elements of the list are subclasses of the
598 // appropriate class!
599 bool Changed = false;
600 RecTy *ElementType = LRT->getElementType();
601 for (Init *I : getValues())
602 if (Init *CI = I->convertInitializerTo(ElementType)) {
603 Elements.push_back(CI);
604 if (CI != I)
605 Changed = true;
606 } else
607 return nullptr;
608
609 if (!Changed)
610 return const_cast<ListInit*>(this);
611 return ListInit::get(Elements, ElementType);
612 }
613
614 return nullptr;
615 }
616
convertInitListSlice(ArrayRef<unsigned> Elements) const617 Init *ListInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
618 if (Elements.size() == 1) {
619 if (Elements[0] >= size())
620 return nullptr;
621 return getElement(Elements[0]);
622 }
623
624 SmallVector<Init*, 8> Vals;
625 Vals.reserve(Elements.size());
626 for (unsigned Element : Elements) {
627 if (Element >= size())
628 return nullptr;
629 Vals.push_back(getElement(Element));
630 }
631 return ListInit::get(Vals, getElementType());
632 }
633
getElementAsRecord(unsigned i) const634 Record *ListInit::getElementAsRecord(unsigned i) const {
635 assert(i < NumValues && "List element index out of range!");
636 DefInit *DI = dyn_cast<DefInit>(getElement(i));
637 if (!DI)
638 PrintFatalError("Expected record in list!");
639 return DI->getDef();
640 }
641
resolveReferences(Resolver & R) const642 Init *ListInit::resolveReferences(Resolver &R) const {
643 SmallVector<Init*, 8> Resolved;
644 Resolved.reserve(size());
645 bool Changed = false;
646
647 for (Init *CurElt : getValues()) {
648 Init *E = CurElt->resolveReferences(R);
649 Changed |= E != CurElt;
650 Resolved.push_back(E);
651 }
652
653 if (Changed)
654 return ListInit::get(Resolved, getElementType());
655 return const_cast<ListInit *>(this);
656 }
657
isComplete() const658 bool ListInit::isComplete() const {
659 for (Init *Element : *this) {
660 if (!Element->isComplete())
661 return false;
662 }
663 return true;
664 }
665
isConcrete() const666 bool ListInit::isConcrete() const {
667 for (Init *Element : *this) {
668 if (!Element->isConcrete())
669 return false;
670 }
671 return true;
672 }
673
getAsString() const674 std::string ListInit::getAsString() const {
675 std::string Result = "[";
676 const char *sep = "";
677 for (Init *Element : *this) {
678 Result += sep;
679 sep = ", ";
680 Result += Element->getAsString();
681 }
682 return Result + "]";
683 }
684
getBit(unsigned Bit) const685 Init *OpInit::getBit(unsigned Bit) const {
686 if (getType() == BitRecTy::get())
687 return const_cast<OpInit*>(this);
688 return VarBitInit::get(const_cast<OpInit*>(this), Bit);
689 }
690
691 static void
ProfileUnOpInit(FoldingSetNodeID & ID,unsigned Opcode,Init * Op,RecTy * Type)692 ProfileUnOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *Op, RecTy *Type) {
693 ID.AddInteger(Opcode);
694 ID.AddPointer(Op);
695 ID.AddPointer(Type);
696 }
697
get(UnaryOp Opc,Init * LHS,RecTy * Type)698 UnOpInit *UnOpInit::get(UnaryOp Opc, Init *LHS, RecTy *Type) {
699 static FoldingSet<UnOpInit> ThePool;
700
701 FoldingSetNodeID ID;
702 ProfileUnOpInit(ID, Opc, LHS, Type);
703
704 void *IP = nullptr;
705 if (UnOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
706 return I;
707
708 UnOpInit *I = new(Allocator) UnOpInit(Opc, LHS, Type);
709 ThePool.InsertNode(I, IP);
710 return I;
711 }
712
Profile(FoldingSetNodeID & ID) const713 void UnOpInit::Profile(FoldingSetNodeID &ID) const {
714 ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
715 }
716
Fold(Record * CurRec,bool IsFinal) const717 Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
718 switch (getOpcode()) {
719 case CAST:
720 if (isa<StringRecTy>(getType())) {
721 if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
722 return LHSs;
723
724 if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
725 return StringInit::get(LHSd->getAsString());
726
727 if (IntInit *LHSi =
728 dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())))
729 return StringInit::get(LHSi->getAsString());
730
731 } else if (isa<RecordRecTy>(getType())) {
732 if (StringInit *Name = dyn_cast<StringInit>(LHS)) {
733 if (!CurRec && !IsFinal)
734 break;
735 assert(CurRec && "NULL pointer");
736 Record *D;
737
738 // Self-references are allowed, but their resolution is delayed until
739 // the final resolve to ensure that we get the correct type for them.
740 auto *Anonymous = dyn_cast<AnonymousNameInit>(CurRec->getNameInit());
741 if (Name == CurRec->getNameInit() ||
742 (Anonymous && Name == Anonymous->getNameInit())) {
743 if (!IsFinal)
744 break;
745 D = CurRec;
746 } else {
747 D = CurRec->getRecords().getDef(Name->getValue());
748 if (!D) {
749 if (IsFinal)
750 PrintFatalError(CurRec->getLoc(),
751 Twine("Undefined reference to record: '") +
752 Name->getValue() + "'\n");
753 break;
754 }
755 }
756
757 DefInit *DI = DefInit::get(D);
758 if (!DI->getType()->typeIsA(getType())) {
759 PrintFatalError(CurRec->getLoc(),
760 Twine("Expected type '") +
761 getType()->getAsString() + "', got '" +
762 DI->getType()->getAsString() + "' in: " +
763 getAsString() + "\n");
764 }
765 return DI;
766 }
767 }
768
769 if (Init *NewInit = LHS->convertInitializerTo(getType()))
770 return NewInit;
771 break;
772
773 case NOT:
774 if (IntInit *LHSi =
775 dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())))
776 return IntInit::get(LHSi->getValue() ? 0 : 1);
777 break;
778
779 case HEAD:
780 if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
781 assert(!LHSl->empty() && "Empty list in head");
782 return LHSl->getElement(0);
783 }
784 break;
785
786 case TAIL:
787 if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
788 assert(!LHSl->empty() && "Empty list in tail");
789 // Note the +1. We can't just pass the result of getValues()
790 // directly.
791 return ListInit::get(LHSl->getValues().slice(1), LHSl->getElementType());
792 }
793 break;
794
795 case SIZE:
796 if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
797 return IntInit::get(LHSl->size());
798 if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
799 return IntInit::get(LHSd->arg_size());
800 if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
801 return IntInit::get(LHSs->getValue().size());
802 break;
803
804 case EMPTY:
805 if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
806 return IntInit::get(LHSl->empty());
807 if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
808 return IntInit::get(LHSd->arg_empty());
809 if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
810 return IntInit::get(LHSs->getValue().empty());
811 break;
812
813 case GETDAGOP:
814 if (DagInit *Dag = dyn_cast<DagInit>(LHS)) {
815 DefInit *DI = DefInit::get(Dag->getOperatorAsDef({}));
816 if (!DI->getType()->typeIsA(getType())) {
817 PrintFatalError(CurRec->getLoc(),
818 Twine("Expected type '") +
819 getType()->getAsString() + "', got '" +
820 DI->getType()->getAsString() + "' in: " +
821 getAsString() + "\n");
822 } else {
823 return DI;
824 }
825 }
826 break;
827 }
828 return const_cast<UnOpInit *>(this);
829 }
830
resolveReferences(Resolver & R) const831 Init *UnOpInit::resolveReferences(Resolver &R) const {
832 Init *lhs = LHS->resolveReferences(R);
833
834 if (LHS != lhs || (R.isFinal() && getOpcode() == CAST))
835 return (UnOpInit::get(getOpcode(), lhs, getType()))
836 ->Fold(R.getCurrentRecord(), R.isFinal());
837 return const_cast<UnOpInit *>(this);
838 }
839
getAsString() const840 std::string UnOpInit::getAsString() const {
841 std::string Result;
842 switch (getOpcode()) {
843 case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
844 case NOT: Result = "!not"; break;
845 case HEAD: Result = "!head"; break;
846 case TAIL: Result = "!tail"; break;
847 case SIZE: Result = "!size"; break;
848 case EMPTY: Result = "!empty"; break;
849 case GETDAGOP: Result = "!getdagop"; break;
850 }
851 return Result + "(" + LHS->getAsString() + ")";
852 }
853
854 static void
ProfileBinOpInit(FoldingSetNodeID & ID,unsigned Opcode,Init * LHS,Init * RHS,RecTy * Type)855 ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
856 RecTy *Type) {
857 ID.AddInteger(Opcode);
858 ID.AddPointer(LHS);
859 ID.AddPointer(RHS);
860 ID.AddPointer(Type);
861 }
862
get(BinaryOp Opc,Init * LHS,Init * RHS,RecTy * Type)863 BinOpInit *BinOpInit::get(BinaryOp Opc, Init *LHS,
864 Init *RHS, RecTy *Type) {
865 static FoldingSet<BinOpInit> ThePool;
866
867 FoldingSetNodeID ID;
868 ProfileBinOpInit(ID, Opc, LHS, RHS, Type);
869
870 void *IP = nullptr;
871 if (BinOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
872 return I;
873
874 BinOpInit *I = new(Allocator) BinOpInit(Opc, LHS, RHS, Type);
875 ThePool.InsertNode(I, IP);
876 return I;
877 }
878
Profile(FoldingSetNodeID & ID) const879 void BinOpInit::Profile(FoldingSetNodeID &ID) const {
880 ProfileBinOpInit(ID, getOpcode(), getLHS(), getRHS(), getType());
881 }
882
ConcatStringInits(const StringInit * I0,const StringInit * I1)883 static StringInit *ConcatStringInits(const StringInit *I0,
884 const StringInit *I1) {
885 SmallString<80> Concat(I0->getValue());
886 Concat.append(I1->getValue());
887 return StringInit::get(Concat,
888 StringInit::determineFormat(I0->getFormat(),
889 I1->getFormat()));
890 }
891
interleaveStringList(const ListInit * List,const StringInit * Delim)892 static StringInit *interleaveStringList(const ListInit *List,
893 const StringInit *Delim) {
894 if (List->size() == 0)
895 return StringInit::get("");
896 StringInit *Element = dyn_cast<StringInit>(List->getElement(0));
897 if (!Element)
898 return nullptr;
899 SmallString<80> Result(Element->getValue());
900 StringInit::StringFormat Fmt = StringInit::SF_String;
901
902 for (unsigned I = 1, E = List->size(); I < E; ++I) {
903 Result.append(Delim->getValue());
904 StringInit *Element = dyn_cast<StringInit>(List->getElement(I));
905 if (!Element)
906 return nullptr;
907 Result.append(Element->getValue());
908 Fmt = StringInit::determineFormat(Fmt, Element->getFormat());
909 }
910 return StringInit::get(Result, Fmt);
911 }
912
interleaveIntList(const ListInit * List,const StringInit * Delim)913 static StringInit *interleaveIntList(const ListInit *List,
914 const StringInit *Delim) {
915 if (List->size() == 0)
916 return StringInit::get("");
917 IntInit *Element =
918 dyn_cast_or_null<IntInit>(List->getElement(0)
919 ->convertInitializerTo(IntRecTy::get()));
920 if (!Element)
921 return nullptr;
922 SmallString<80> Result(Element->getAsString());
923
924 for (unsigned I = 1, E = List->size(); I < E; ++I) {
925 Result.append(Delim->getValue());
926 IntInit *Element =
927 dyn_cast_or_null<IntInit>(List->getElement(I)
928 ->convertInitializerTo(IntRecTy::get()));
929 if (!Element)
930 return nullptr;
931 Result.append(Element->getAsString());
932 }
933 return StringInit::get(Result);
934 }
935
getStrConcat(Init * I0,Init * I1)936 Init *BinOpInit::getStrConcat(Init *I0, Init *I1) {
937 // Shortcut for the common case of concatenating two strings.
938 if (const StringInit *I0s = dyn_cast<StringInit>(I0))
939 if (const StringInit *I1s = dyn_cast<StringInit>(I1))
940 return ConcatStringInits(I0s, I1s);
941 return BinOpInit::get(BinOpInit::STRCONCAT, I0, I1, StringRecTy::get());
942 }
943
ConcatListInits(const ListInit * LHS,const ListInit * RHS)944 static ListInit *ConcatListInits(const ListInit *LHS,
945 const ListInit *RHS) {
946 SmallVector<Init *, 8> Args;
947 llvm::append_range(Args, *LHS);
948 llvm::append_range(Args, *RHS);
949 return ListInit::get(Args, LHS->getElementType());
950 }
951
getListConcat(TypedInit * LHS,Init * RHS)952 Init *BinOpInit::getListConcat(TypedInit *LHS, Init *RHS) {
953 assert(isa<ListRecTy>(LHS->getType()) && "First arg must be a list");
954
955 // Shortcut for the common case of concatenating two lists.
956 if (const ListInit *LHSList = dyn_cast<ListInit>(LHS))
957 if (const ListInit *RHSList = dyn_cast<ListInit>(RHS))
958 return ConcatListInits(LHSList, RHSList);
959 return BinOpInit::get(BinOpInit::LISTCONCAT, LHS, RHS, LHS->getType());
960 }
961
Fold(Record * CurRec) const962 Init *BinOpInit::Fold(Record *CurRec) const {
963 switch (getOpcode()) {
964 case CONCAT: {
965 DagInit *LHSs = dyn_cast<DagInit>(LHS);
966 DagInit *RHSs = dyn_cast<DagInit>(RHS);
967 if (LHSs && RHSs) {
968 DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
969 DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
970 if ((!LOp && !isa<UnsetInit>(LHSs->getOperator())) ||
971 (!ROp && !isa<UnsetInit>(RHSs->getOperator())))
972 break;
973 if (LOp && ROp && LOp->getDef() != ROp->getDef()) {
974 PrintFatalError(Twine("Concatenated Dag operators do not match: '") +
975 LHSs->getAsString() + "' vs. '" + RHSs->getAsString() +
976 "'");
977 }
978 Init *Op = LOp ? LOp : ROp;
979 if (!Op)
980 Op = UnsetInit::get();
981
982 SmallVector<Init*, 8> Args;
983 SmallVector<StringInit*, 8> ArgNames;
984 for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
985 Args.push_back(LHSs->getArg(i));
986 ArgNames.push_back(LHSs->getArgName(i));
987 }
988 for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) {
989 Args.push_back(RHSs->getArg(i));
990 ArgNames.push_back(RHSs->getArgName(i));
991 }
992 return DagInit::get(Op, nullptr, Args, ArgNames);
993 }
994 break;
995 }
996 case LISTCONCAT: {
997 ListInit *LHSs = dyn_cast<ListInit>(LHS);
998 ListInit *RHSs = dyn_cast<ListInit>(RHS);
999 if (LHSs && RHSs) {
1000 SmallVector<Init *, 8> Args;
1001 llvm::append_range(Args, *LHSs);
1002 llvm::append_range(Args, *RHSs);
1003 return ListInit::get(Args, LHSs->getElementType());
1004 }
1005 break;
1006 }
1007 case LISTSPLAT: {
1008 TypedInit *Value = dyn_cast<TypedInit>(LHS);
1009 IntInit *Size = dyn_cast<IntInit>(RHS);
1010 if (Value && Size) {
1011 SmallVector<Init *, 8> Args(Size->getValue(), Value);
1012 return ListInit::get(Args, Value->getType());
1013 }
1014 break;
1015 }
1016 case STRCONCAT: {
1017 StringInit *LHSs = dyn_cast<StringInit>(LHS);
1018 StringInit *RHSs = dyn_cast<StringInit>(RHS);
1019 if (LHSs && RHSs)
1020 return ConcatStringInits(LHSs, RHSs);
1021 break;
1022 }
1023 case INTERLEAVE: {
1024 ListInit *List = dyn_cast<ListInit>(LHS);
1025 StringInit *Delim = dyn_cast<StringInit>(RHS);
1026 if (List && Delim) {
1027 StringInit *Result;
1028 if (isa<StringRecTy>(List->getElementType()))
1029 Result = interleaveStringList(List, Delim);
1030 else
1031 Result = interleaveIntList(List, Delim);
1032 if (Result)
1033 return Result;
1034 }
1035 break;
1036 }
1037 case EQ:
1038 case NE:
1039 case LE:
1040 case LT:
1041 case GE:
1042 case GT: {
1043 // First see if we have two bit, bits, or int.
1044 IntInit *LHSi =
1045 dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
1046 IntInit *RHSi =
1047 dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
1048
1049 if (LHSi && RHSi) {
1050 bool Result;
1051 switch (getOpcode()) {
1052 case EQ: Result = LHSi->getValue() == RHSi->getValue(); break;
1053 case NE: Result = LHSi->getValue() != RHSi->getValue(); break;
1054 case LE: Result = LHSi->getValue() <= RHSi->getValue(); break;
1055 case LT: Result = LHSi->getValue() < RHSi->getValue(); break;
1056 case GE: Result = LHSi->getValue() >= RHSi->getValue(); break;
1057 case GT: Result = LHSi->getValue() > RHSi->getValue(); break;
1058 default: llvm_unreachable("unhandled comparison");
1059 }
1060 return BitInit::get(Result);
1061 }
1062
1063 // Next try strings.
1064 StringInit *LHSs = dyn_cast<StringInit>(LHS);
1065 StringInit *RHSs = dyn_cast<StringInit>(RHS);
1066
1067 if (LHSs && RHSs) {
1068 bool Result;
1069 switch (getOpcode()) {
1070 case EQ: Result = LHSs->getValue() == RHSs->getValue(); break;
1071 case NE: Result = LHSs->getValue() != RHSs->getValue(); break;
1072 case LE: Result = LHSs->getValue() <= RHSs->getValue(); break;
1073 case LT: Result = LHSs->getValue() < RHSs->getValue(); break;
1074 case GE: Result = LHSs->getValue() >= RHSs->getValue(); break;
1075 case GT: Result = LHSs->getValue() > RHSs->getValue(); break;
1076 default: llvm_unreachable("unhandled comparison");
1077 }
1078 return BitInit::get(Result);
1079 }
1080
1081 // Finally, !eq and !ne can be used with records.
1082 if (getOpcode() == EQ || getOpcode() == NE) {
1083 DefInit *LHSd = dyn_cast<DefInit>(LHS);
1084 DefInit *RHSd = dyn_cast<DefInit>(RHS);
1085 if (LHSd && RHSd)
1086 return BitInit::get((getOpcode() == EQ) ? LHSd == RHSd
1087 : LHSd != RHSd);
1088 }
1089
1090 break;
1091 }
1092 case SETDAGOP: {
1093 DagInit *Dag = dyn_cast<DagInit>(LHS);
1094 DefInit *Op = dyn_cast<DefInit>(RHS);
1095 if (Dag && Op) {
1096 SmallVector<Init*, 8> Args;
1097 SmallVector<StringInit*, 8> ArgNames;
1098 for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
1099 Args.push_back(Dag->getArg(i));
1100 ArgNames.push_back(Dag->getArgName(i));
1101 }
1102 return DagInit::get(Op, nullptr, Args, ArgNames);
1103 }
1104 break;
1105 }
1106 case ADD:
1107 case SUB:
1108 case MUL:
1109 case AND:
1110 case OR:
1111 case XOR:
1112 case SHL:
1113 case SRA:
1114 case SRL: {
1115 IntInit *LHSi =
1116 dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
1117 IntInit *RHSi =
1118 dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
1119 if (LHSi && RHSi) {
1120 int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
1121 int64_t Result;
1122 switch (getOpcode()) {
1123 default: llvm_unreachable("Bad opcode!");
1124 case ADD: Result = LHSv + RHSv; break;
1125 case SUB: Result = LHSv - RHSv; break;
1126 case MUL: Result = LHSv * RHSv; break;
1127 case AND: Result = LHSv & RHSv; break;
1128 case OR: Result = LHSv | RHSv; break;
1129 case XOR: Result = LHSv ^ RHSv; break;
1130 case SHL: Result = (uint64_t)LHSv << (uint64_t)RHSv; break;
1131 case SRA: Result = LHSv >> RHSv; break;
1132 case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
1133 }
1134 return IntInit::get(Result);
1135 }
1136 break;
1137 }
1138 }
1139 return const_cast<BinOpInit *>(this);
1140 }
1141
resolveReferences(Resolver & R) const1142 Init *BinOpInit::resolveReferences(Resolver &R) const {
1143 Init *lhs = LHS->resolveReferences(R);
1144 Init *rhs = RHS->resolveReferences(R);
1145
1146 if (LHS != lhs || RHS != rhs)
1147 return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))
1148 ->Fold(R.getCurrentRecord());
1149 return const_cast<BinOpInit *>(this);
1150 }
1151
getAsString() const1152 std::string BinOpInit::getAsString() const {
1153 std::string Result;
1154 switch (getOpcode()) {
1155 case CONCAT: Result = "!con"; break;
1156 case ADD: Result = "!add"; break;
1157 case SUB: Result = "!sub"; break;
1158 case MUL: Result = "!mul"; break;
1159 case AND: Result = "!and"; break;
1160 case OR: Result = "!or"; break;
1161 case XOR: Result = "!xor"; break;
1162 case SHL: Result = "!shl"; break;
1163 case SRA: Result = "!sra"; break;
1164 case SRL: Result = "!srl"; break;
1165 case EQ: Result = "!eq"; break;
1166 case NE: Result = "!ne"; break;
1167 case LE: Result = "!le"; break;
1168 case LT: Result = "!lt"; break;
1169 case GE: Result = "!ge"; break;
1170 case GT: Result = "!gt"; break;
1171 case LISTCONCAT: Result = "!listconcat"; break;
1172 case LISTSPLAT: Result = "!listsplat"; break;
1173 case STRCONCAT: Result = "!strconcat"; break;
1174 case INTERLEAVE: Result = "!interleave"; break;
1175 case SETDAGOP: Result = "!setdagop"; break;
1176 }
1177 return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
1178 }
1179
1180 static void
ProfileTernOpInit(FoldingSetNodeID & ID,unsigned Opcode,Init * LHS,Init * MHS,Init * RHS,RecTy * Type)1181 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
1182 Init *RHS, RecTy *Type) {
1183 ID.AddInteger(Opcode);
1184 ID.AddPointer(LHS);
1185 ID.AddPointer(MHS);
1186 ID.AddPointer(RHS);
1187 ID.AddPointer(Type);
1188 }
1189
get(TernaryOp Opc,Init * LHS,Init * MHS,Init * RHS,RecTy * Type)1190 TernOpInit *TernOpInit::get(TernaryOp Opc, Init *LHS, Init *MHS, Init *RHS,
1191 RecTy *Type) {
1192 static FoldingSet<TernOpInit> ThePool;
1193
1194 FoldingSetNodeID ID;
1195 ProfileTernOpInit(ID, Opc, LHS, MHS, RHS, Type);
1196
1197 void *IP = nullptr;
1198 if (TernOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
1199 return I;
1200
1201 TernOpInit *I = new(Allocator) TernOpInit(Opc, LHS, MHS, RHS, Type);
1202 ThePool.InsertNode(I, IP);
1203 return I;
1204 }
1205
Profile(FoldingSetNodeID & ID) const1206 void TernOpInit::Profile(FoldingSetNodeID &ID) const {
1207 ProfileTernOpInit(ID, getOpcode(), getLHS(), getMHS(), getRHS(), getType());
1208 }
1209
ItemApply(Init * LHS,Init * MHSe,Init * RHS,Record * CurRec)1210 static Init *ItemApply(Init *LHS, Init *MHSe, Init *RHS, Record *CurRec) {
1211 MapResolver R(CurRec);
1212 R.set(LHS, MHSe);
1213 return RHS->resolveReferences(R);
1214 }
1215
ForeachDagApply(Init * LHS,DagInit * MHSd,Init * RHS,Record * CurRec)1216 static Init *ForeachDagApply(Init *LHS, DagInit *MHSd, Init *RHS,
1217 Record *CurRec) {
1218 bool Change = false;
1219 Init *Val = ItemApply(LHS, MHSd->getOperator(), RHS, CurRec);
1220 if (Val != MHSd->getOperator())
1221 Change = true;
1222
1223 SmallVector<std::pair<Init *, StringInit *>, 8> NewArgs;
1224 for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
1225 Init *Arg = MHSd->getArg(i);
1226 Init *NewArg;
1227 StringInit *ArgName = MHSd->getArgName(i);
1228
1229 if (DagInit *Argd = dyn_cast<DagInit>(Arg))
1230 NewArg = ForeachDagApply(LHS, Argd, RHS, CurRec);
1231 else
1232 NewArg = ItemApply(LHS, Arg, RHS, CurRec);
1233
1234 NewArgs.push_back(std::make_pair(NewArg, ArgName));
1235 if (Arg != NewArg)
1236 Change = true;
1237 }
1238
1239 if (Change)
1240 return DagInit::get(Val, nullptr, NewArgs);
1241 return MHSd;
1242 }
1243
1244 // Applies RHS to all elements of MHS, using LHS as a temp variable.
ForeachHelper(Init * LHS,Init * MHS,Init * RHS,RecTy * Type,Record * CurRec)1245 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
1246 Record *CurRec) {
1247 if (DagInit *MHSd = dyn_cast<DagInit>(MHS))
1248 return ForeachDagApply(LHS, MHSd, RHS, CurRec);
1249
1250 if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) {
1251 SmallVector<Init *, 8> NewList(MHSl->begin(), MHSl->end());
1252
1253 for (Init *&Item : NewList) {
1254 Init *NewItem = ItemApply(LHS, Item, RHS, CurRec);
1255 if (NewItem != Item)
1256 Item = NewItem;
1257 }
1258 return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
1259 }
1260
1261 return nullptr;
1262 }
1263
1264 // Evaluates RHS for all elements of MHS, using LHS as a temp variable.
1265 // Creates a new list with the elements that evaluated to true.
FilterHelper(Init * LHS,Init * MHS,Init * RHS,RecTy * Type,Record * CurRec)1266 static Init *FilterHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
1267 Record *CurRec) {
1268 if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) {
1269 SmallVector<Init *, 8> NewList;
1270
1271 for (Init *Item : MHSl->getValues()) {
1272 Init *Include = ItemApply(LHS, Item, RHS, CurRec);
1273 if (!Include)
1274 return nullptr;
1275 if (IntInit *IncludeInt = dyn_cast_or_null<IntInit>(
1276 Include->convertInitializerTo(IntRecTy::get()))) {
1277 if (IncludeInt->getValue())
1278 NewList.push_back(Item);
1279 } else {
1280 return nullptr;
1281 }
1282 }
1283 return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
1284 }
1285
1286 return nullptr;
1287 }
1288
Fold(Record * CurRec) const1289 Init *TernOpInit::Fold(Record *CurRec) const {
1290 switch (getOpcode()) {
1291 case SUBST: {
1292 DefInit *LHSd = dyn_cast<DefInit>(LHS);
1293 VarInit *LHSv = dyn_cast<VarInit>(LHS);
1294 StringInit *LHSs = dyn_cast<StringInit>(LHS);
1295
1296 DefInit *MHSd = dyn_cast<DefInit>(MHS);
1297 VarInit *MHSv = dyn_cast<VarInit>(MHS);
1298 StringInit *MHSs = dyn_cast<StringInit>(MHS);
1299
1300 DefInit *RHSd = dyn_cast<DefInit>(RHS);
1301 VarInit *RHSv = dyn_cast<VarInit>(RHS);
1302 StringInit *RHSs = dyn_cast<StringInit>(RHS);
1303
1304 if (LHSd && MHSd && RHSd) {
1305 Record *Val = RHSd->getDef();
1306 if (LHSd->getAsString() == RHSd->getAsString())
1307 Val = MHSd->getDef();
1308 return DefInit::get(Val);
1309 }
1310 if (LHSv && MHSv && RHSv) {
1311 std::string Val = std::string(RHSv->getName());
1312 if (LHSv->getAsString() == RHSv->getAsString())
1313 Val = std::string(MHSv->getName());
1314 return VarInit::get(Val, getType());
1315 }
1316 if (LHSs && MHSs && RHSs) {
1317 std::string Val = std::string(RHSs->getValue());
1318
1319 std::string::size_type found;
1320 std::string::size_type idx = 0;
1321 while (true) {
1322 found = Val.find(std::string(LHSs->getValue()), idx);
1323 if (found == std::string::npos)
1324 break;
1325 Val.replace(found, LHSs->getValue().size(),
1326 std::string(MHSs->getValue()));
1327 idx = found + MHSs->getValue().size();
1328 }
1329
1330 return StringInit::get(Val);
1331 }
1332 break;
1333 }
1334
1335 case FOREACH: {
1336 if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec))
1337 return Result;
1338 break;
1339 }
1340
1341 case FILTER: {
1342 if (Init *Result = FilterHelper(LHS, MHS, RHS, getType(), CurRec))
1343 return Result;
1344 break;
1345 }
1346
1347 case IF: {
1348 if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
1349 LHS->convertInitializerTo(IntRecTy::get()))) {
1350 if (LHSi->getValue())
1351 return MHS;
1352 return RHS;
1353 }
1354 break;
1355 }
1356
1357 case DAG: {
1358 ListInit *MHSl = dyn_cast<ListInit>(MHS);
1359 ListInit *RHSl = dyn_cast<ListInit>(RHS);
1360 bool MHSok = MHSl || isa<UnsetInit>(MHS);
1361 bool RHSok = RHSl || isa<UnsetInit>(RHS);
1362
1363 if (isa<UnsetInit>(MHS) && isa<UnsetInit>(RHS))
1364 break; // Typically prevented by the parser, but might happen with template args
1365
1366 if (MHSok && RHSok && (!MHSl || !RHSl || MHSl->size() == RHSl->size())) {
1367 SmallVector<std::pair<Init *, StringInit *>, 8> Children;
1368 unsigned Size = MHSl ? MHSl->size() : RHSl->size();
1369 for (unsigned i = 0; i != Size; ++i) {
1370 Init *Node = MHSl ? MHSl->getElement(i) : UnsetInit::get();
1371 Init *Name = RHSl ? RHSl->getElement(i) : UnsetInit::get();
1372 if (!isa<StringInit>(Name) && !isa<UnsetInit>(Name))
1373 return const_cast<TernOpInit *>(this);
1374 Children.emplace_back(Node, dyn_cast<StringInit>(Name));
1375 }
1376 return DagInit::get(LHS, nullptr, Children);
1377 }
1378 break;
1379 }
1380
1381 case SUBSTR: {
1382 StringInit *LHSs = dyn_cast<StringInit>(LHS);
1383 IntInit *MHSi = dyn_cast<IntInit>(MHS);
1384 IntInit *RHSi = dyn_cast<IntInit>(RHS);
1385 if (LHSs && MHSi && RHSi) {
1386 int64_t StringSize = LHSs->getValue().size();
1387 int64_t Start = MHSi->getValue();
1388 int64_t Length = RHSi->getValue();
1389 if (Start < 0 || Start > StringSize)
1390 PrintError(CurRec->getLoc(),
1391 Twine("!substr start position is out of range 0...") +
1392 std::to_string(StringSize) + ": " +
1393 std::to_string(Start));
1394 if (Length < 0)
1395 PrintError(CurRec->getLoc(), "!substr length must be nonnegative");
1396 return StringInit::get(LHSs->getValue().substr(Start, Length),
1397 LHSs->getFormat());
1398 }
1399 break;
1400 }
1401
1402 case FIND: {
1403 StringInit *LHSs = dyn_cast<StringInit>(LHS);
1404 StringInit *MHSs = dyn_cast<StringInit>(MHS);
1405 IntInit *RHSi = dyn_cast<IntInit>(RHS);
1406 if (LHSs && MHSs && RHSi) {
1407 int64_t SourceSize = LHSs->getValue().size();
1408 int64_t Start = RHSi->getValue();
1409 if (Start < 0 || Start > SourceSize)
1410 PrintError(CurRec->getLoc(),
1411 Twine("!find start position is out of range 0...") +
1412 std::to_string(SourceSize) + ": " +
1413 std::to_string(Start));
1414 auto I = LHSs->getValue().find(MHSs->getValue(), Start);
1415 if (I == std::string::npos)
1416 return IntInit::get(-1);
1417 return IntInit::get(I);
1418 }
1419 break;
1420 }
1421 }
1422
1423 return const_cast<TernOpInit *>(this);
1424 }
1425
resolveReferences(Resolver & R) const1426 Init *TernOpInit::resolveReferences(Resolver &R) const {
1427 Init *lhs = LHS->resolveReferences(R);
1428
1429 if (getOpcode() == IF && lhs != LHS) {
1430 if (IntInit *Value = dyn_cast_or_null<IntInit>(
1431 lhs->convertInitializerTo(IntRecTy::get()))) {
1432 // Short-circuit
1433 if (Value->getValue())
1434 return MHS->resolveReferences(R);
1435 return RHS->resolveReferences(R);
1436 }
1437 }
1438
1439 Init *mhs = MHS->resolveReferences(R);
1440 Init *rhs;
1441
1442 if (getOpcode() == FOREACH || getOpcode() == FILTER) {
1443 ShadowResolver SR(R);
1444 SR.addShadow(lhs);
1445 rhs = RHS->resolveReferences(SR);
1446 } else {
1447 rhs = RHS->resolveReferences(R);
1448 }
1449
1450 if (LHS != lhs || MHS != mhs || RHS != rhs)
1451 return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, getType()))
1452 ->Fold(R.getCurrentRecord());
1453 return const_cast<TernOpInit *>(this);
1454 }
1455
getAsString() const1456 std::string TernOpInit::getAsString() const {
1457 std::string Result;
1458 bool UnquotedLHS = false;
1459 switch (getOpcode()) {
1460 case DAG: Result = "!dag"; break;
1461 case FILTER: Result = "!filter"; UnquotedLHS = true; break;
1462 case FOREACH: Result = "!foreach"; UnquotedLHS = true; break;
1463 case IF: Result = "!if"; break;
1464 case SUBST: Result = "!subst"; break;
1465 case SUBSTR: Result = "!substr"; break;
1466 case FIND: Result = "!find"; break;
1467 }
1468 return (Result + "(" +
1469 (UnquotedLHS ? LHS->getAsUnquotedString() : LHS->getAsString()) +
1470 ", " + MHS->getAsString() + ", " + RHS->getAsString() + ")");
1471 }
1472
ProfileFoldOpInit(FoldingSetNodeID & ID,Init * A,Init * B,Init * Start,Init * List,Init * Expr,RecTy * Type)1473 static void ProfileFoldOpInit(FoldingSetNodeID &ID, Init *A, Init *B,
1474 Init *Start, Init *List, Init *Expr,
1475 RecTy *Type) {
1476 ID.AddPointer(Start);
1477 ID.AddPointer(List);
1478 ID.AddPointer(A);
1479 ID.AddPointer(B);
1480 ID.AddPointer(Expr);
1481 ID.AddPointer(Type);
1482 }
1483
get(Init * Start,Init * List,Init * A,Init * B,Init * Expr,RecTy * Type)1484 FoldOpInit *FoldOpInit::get(Init *Start, Init *List, Init *A, Init *B,
1485 Init *Expr, RecTy *Type) {
1486 static FoldingSet<FoldOpInit> ThePool;
1487
1488 FoldingSetNodeID ID;
1489 ProfileFoldOpInit(ID, Start, List, A, B, Expr, Type);
1490
1491 void *IP = nullptr;
1492 if (FoldOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
1493 return I;
1494
1495 FoldOpInit *I = new (Allocator) FoldOpInit(Start, List, A, B, Expr, Type);
1496 ThePool.InsertNode(I, IP);
1497 return I;
1498 }
1499
Profile(FoldingSetNodeID & ID) const1500 void FoldOpInit::Profile(FoldingSetNodeID &ID) const {
1501 ProfileFoldOpInit(ID, Start, List, A, B, Expr, getType());
1502 }
1503
Fold(Record * CurRec) const1504 Init *FoldOpInit::Fold(Record *CurRec) const {
1505 if (ListInit *LI = dyn_cast<ListInit>(List)) {
1506 Init *Accum = Start;
1507 for (Init *Elt : *LI) {
1508 MapResolver R(CurRec);
1509 R.set(A, Accum);
1510 R.set(B, Elt);
1511 Accum = Expr->resolveReferences(R);
1512 }
1513 return Accum;
1514 }
1515 return const_cast<FoldOpInit *>(this);
1516 }
1517
resolveReferences(Resolver & R) const1518 Init *FoldOpInit::resolveReferences(Resolver &R) const {
1519 Init *NewStart = Start->resolveReferences(R);
1520 Init *NewList = List->resolveReferences(R);
1521 ShadowResolver SR(R);
1522 SR.addShadow(A);
1523 SR.addShadow(B);
1524 Init *NewExpr = Expr->resolveReferences(SR);
1525
1526 if (Start == NewStart && List == NewList && Expr == NewExpr)
1527 return const_cast<FoldOpInit *>(this);
1528
1529 return get(NewStart, NewList, A, B, NewExpr, getType())
1530 ->Fold(R.getCurrentRecord());
1531 }
1532
getBit(unsigned Bit) const1533 Init *FoldOpInit::getBit(unsigned Bit) const {
1534 return VarBitInit::get(const_cast<FoldOpInit *>(this), Bit);
1535 }
1536
getAsString() const1537 std::string FoldOpInit::getAsString() const {
1538 return (Twine("!foldl(") + Start->getAsString() + ", " + List->getAsString() +
1539 ", " + A->getAsUnquotedString() + ", " + B->getAsUnquotedString() +
1540 ", " + Expr->getAsString() + ")")
1541 .str();
1542 }
1543
ProfileIsAOpInit(FoldingSetNodeID & ID,RecTy * CheckType,Init * Expr)1544 static void ProfileIsAOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
1545 Init *Expr) {
1546 ID.AddPointer(CheckType);
1547 ID.AddPointer(Expr);
1548 }
1549
get(RecTy * CheckType,Init * Expr)1550 IsAOpInit *IsAOpInit::get(RecTy *CheckType, Init *Expr) {
1551 static FoldingSet<IsAOpInit> ThePool;
1552
1553 FoldingSetNodeID ID;
1554 ProfileIsAOpInit(ID, CheckType, Expr);
1555
1556 void *IP = nullptr;
1557 if (IsAOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
1558 return I;
1559
1560 IsAOpInit *I = new (Allocator) IsAOpInit(CheckType, Expr);
1561 ThePool.InsertNode(I, IP);
1562 return I;
1563 }
1564
Profile(FoldingSetNodeID & ID) const1565 void IsAOpInit::Profile(FoldingSetNodeID &ID) const {
1566 ProfileIsAOpInit(ID, CheckType, Expr);
1567 }
1568
Fold() const1569 Init *IsAOpInit::Fold() const {
1570 if (TypedInit *TI = dyn_cast<TypedInit>(Expr)) {
1571 // Is the expression type known to be (a subclass of) the desired type?
1572 if (TI->getType()->typeIsConvertibleTo(CheckType))
1573 return IntInit::get(1);
1574
1575 if (isa<RecordRecTy>(CheckType)) {
1576 // If the target type is not a subclass of the expression type, or if
1577 // the expression has fully resolved to a record, we know that it can't
1578 // be of the required type.
1579 if (!CheckType->typeIsConvertibleTo(TI->getType()) || isa<DefInit>(Expr))
1580 return IntInit::get(0);
1581 } else {
1582 // We treat non-record types as not castable.
1583 return IntInit::get(0);
1584 }
1585 }
1586 return const_cast<IsAOpInit *>(this);
1587 }
1588
resolveReferences(Resolver & R) const1589 Init *IsAOpInit::resolveReferences(Resolver &R) const {
1590 Init *NewExpr = Expr->resolveReferences(R);
1591 if (Expr != NewExpr)
1592 return get(CheckType, NewExpr)->Fold();
1593 return const_cast<IsAOpInit *>(this);
1594 }
1595
getBit(unsigned Bit) const1596 Init *IsAOpInit::getBit(unsigned Bit) const {
1597 return VarBitInit::get(const_cast<IsAOpInit *>(this), Bit);
1598 }
1599
getAsString() const1600 std::string IsAOpInit::getAsString() const {
1601 return (Twine("!isa<") + CheckType->getAsString() + ">(" +
1602 Expr->getAsString() + ")")
1603 .str();
1604 }
1605
getFieldType(StringInit * FieldName) const1606 RecTy *TypedInit::getFieldType(StringInit *FieldName) const {
1607 if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) {
1608 for (Record *Rec : RecordType->getClasses()) {
1609 if (RecordVal *Field = Rec->getValue(FieldName))
1610 return Field->getType();
1611 }
1612 }
1613 return nullptr;
1614 }
1615
1616 Init *
convertInitializerTo(RecTy * Ty) const1617 TypedInit::convertInitializerTo(RecTy *Ty) const {
1618 if (getType() == Ty || getType()->typeIsA(Ty))
1619 return const_cast<TypedInit *>(this);
1620
1621 if (isa<BitRecTy>(getType()) && isa<BitsRecTy>(Ty) &&
1622 cast<BitsRecTy>(Ty)->getNumBits() == 1)
1623 return BitsInit::get({const_cast<TypedInit *>(this)});
1624
1625 return nullptr;
1626 }
1627
convertInitializerBitRange(ArrayRef<unsigned> Bits) const1628 Init *TypedInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
1629 BitsRecTy *T = dyn_cast<BitsRecTy>(getType());
1630 if (!T) return nullptr; // Cannot subscript a non-bits variable.
1631 unsigned NumBits = T->getNumBits();
1632
1633 SmallVector<Init *, 16> NewBits;
1634 NewBits.reserve(Bits.size());
1635 for (unsigned Bit : Bits) {
1636 if (Bit >= NumBits)
1637 return nullptr;
1638
1639 NewBits.push_back(VarBitInit::get(const_cast<TypedInit *>(this), Bit));
1640 }
1641 return BitsInit::get(NewBits);
1642 }
1643
getCastTo(RecTy * Ty) const1644 Init *TypedInit::getCastTo(RecTy *Ty) const {
1645 // Handle the common case quickly
1646 if (getType() == Ty || getType()->typeIsA(Ty))
1647 return const_cast<TypedInit *>(this);
1648
1649 if (Init *Converted = convertInitializerTo(Ty)) {
1650 assert(!isa<TypedInit>(Converted) ||
1651 cast<TypedInit>(Converted)->getType()->typeIsA(Ty));
1652 return Converted;
1653 }
1654
1655 if (!getType()->typeIsConvertibleTo(Ty))
1656 return nullptr;
1657
1658 return UnOpInit::get(UnOpInit::CAST, const_cast<TypedInit *>(this), Ty)
1659 ->Fold(nullptr);
1660 }
1661
convertInitListSlice(ArrayRef<unsigned> Elements) const1662 Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
1663 ListRecTy *T = dyn_cast<ListRecTy>(getType());
1664 if (!T) return nullptr; // Cannot subscript a non-list variable.
1665
1666 if (Elements.size() == 1)
1667 return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
1668
1669 SmallVector<Init*, 8> ListInits;
1670 ListInits.reserve(Elements.size());
1671 for (unsigned Element : Elements)
1672 ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this),
1673 Element));
1674 return ListInit::get(ListInits, T->getElementType());
1675 }
1676
1677
get(StringRef VN,RecTy * T)1678 VarInit *VarInit::get(StringRef VN, RecTy *T) {
1679 Init *Value = StringInit::get(VN);
1680 return VarInit::get(Value, T);
1681 }
1682
get(Init * VN,RecTy * T)1683 VarInit *VarInit::get(Init *VN, RecTy *T) {
1684 using Key = std::pair<RecTy *, Init *>;
1685 static DenseMap<Key, VarInit*> ThePool;
1686
1687 Key TheKey(std::make_pair(T, VN));
1688
1689 VarInit *&I = ThePool[TheKey];
1690 if (!I)
1691 I = new(Allocator) VarInit(VN, T);
1692 return I;
1693 }
1694
getName() const1695 StringRef VarInit::getName() const {
1696 StringInit *NameString = cast<StringInit>(getNameInit());
1697 return NameString->getValue();
1698 }
1699
getBit(unsigned Bit) const1700 Init *VarInit::getBit(unsigned Bit) const {
1701 if (getType() == BitRecTy::get())
1702 return const_cast<VarInit*>(this);
1703 return VarBitInit::get(const_cast<VarInit*>(this), Bit);
1704 }
1705
resolveReferences(Resolver & R) const1706 Init *VarInit::resolveReferences(Resolver &R) const {
1707 if (Init *Val = R.resolve(VarName))
1708 return Val;
1709 return const_cast<VarInit *>(this);
1710 }
1711
get(TypedInit * T,unsigned B)1712 VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) {
1713 using Key = std::pair<TypedInit *, unsigned>;
1714 static DenseMap<Key, VarBitInit*> ThePool;
1715
1716 Key TheKey(std::make_pair(T, B));
1717
1718 VarBitInit *&I = ThePool[TheKey];
1719 if (!I)
1720 I = new(Allocator) VarBitInit(T, B);
1721 return I;
1722 }
1723
getAsString() const1724 std::string VarBitInit::getAsString() const {
1725 return TI->getAsString() + "{" + utostr(Bit) + "}";
1726 }
1727
resolveReferences(Resolver & R) const1728 Init *VarBitInit::resolveReferences(Resolver &R) const {
1729 Init *I = TI->resolveReferences(R);
1730 if (TI != I)
1731 return I->getBit(getBitNum());
1732
1733 return const_cast<VarBitInit*>(this);
1734 }
1735
get(TypedInit * T,unsigned E)1736 VarListElementInit *VarListElementInit::get(TypedInit *T,
1737 unsigned E) {
1738 using Key = std::pair<TypedInit *, unsigned>;
1739 static DenseMap<Key, VarListElementInit*> ThePool;
1740
1741 Key TheKey(std::make_pair(T, E));
1742
1743 VarListElementInit *&I = ThePool[TheKey];
1744 if (!I) I = new(Allocator) VarListElementInit(T, E);
1745 return I;
1746 }
1747
getAsString() const1748 std::string VarListElementInit::getAsString() const {
1749 return TI->getAsString() + "[" + utostr(Element) + "]";
1750 }
1751
resolveReferences(Resolver & R) const1752 Init *VarListElementInit::resolveReferences(Resolver &R) const {
1753 Init *NewTI = TI->resolveReferences(R);
1754 if (ListInit *List = dyn_cast<ListInit>(NewTI)) {
1755 // Leave out-of-bounds array references as-is. This can happen without
1756 // being an error, e.g. in the untaken "branch" of an !if expression.
1757 if (getElementNum() < List->size())
1758 return List->getElement(getElementNum());
1759 }
1760 if (NewTI != TI && isa<TypedInit>(NewTI))
1761 return VarListElementInit::get(cast<TypedInit>(NewTI), getElementNum());
1762 return const_cast<VarListElementInit *>(this);
1763 }
1764
getBit(unsigned Bit) const1765 Init *VarListElementInit::getBit(unsigned Bit) const {
1766 if (getType() == BitRecTy::get())
1767 return const_cast<VarListElementInit*>(this);
1768 return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit);
1769 }
1770
DefInit(Record * D)1771 DefInit::DefInit(Record *D)
1772 : TypedInit(IK_DefInit, D->getType()), Def(D) {}
1773
get(Record * R)1774 DefInit *DefInit::get(Record *R) {
1775 return R->getDefInit();
1776 }
1777
convertInitializerTo(RecTy * Ty) const1778 Init *DefInit::convertInitializerTo(RecTy *Ty) const {
1779 if (auto *RRT = dyn_cast<RecordRecTy>(Ty))
1780 if (getType()->typeIsConvertibleTo(RRT))
1781 return const_cast<DefInit *>(this);
1782 return nullptr;
1783 }
1784
getFieldType(StringInit * FieldName) const1785 RecTy *DefInit::getFieldType(StringInit *FieldName) const {
1786 if (const RecordVal *RV = Def->getValue(FieldName))
1787 return RV->getType();
1788 return nullptr;
1789 }
1790
getAsString() const1791 std::string DefInit::getAsString() const { return std::string(Def->getName()); }
1792
ProfileVarDefInit(FoldingSetNodeID & ID,Record * Class,ArrayRef<Init * > Args)1793 static void ProfileVarDefInit(FoldingSetNodeID &ID,
1794 Record *Class,
1795 ArrayRef<Init *> Args) {
1796 ID.AddInteger(Args.size());
1797 ID.AddPointer(Class);
1798
1799 for (Init *I : Args)
1800 ID.AddPointer(I);
1801 }
1802
get(Record * Class,ArrayRef<Init * > Args)1803 VarDefInit *VarDefInit::get(Record *Class, ArrayRef<Init *> Args) {
1804 static FoldingSet<VarDefInit> ThePool;
1805
1806 FoldingSetNodeID ID;
1807 ProfileVarDefInit(ID, Class, Args);
1808
1809 void *IP = nullptr;
1810 if (VarDefInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
1811 return I;
1812
1813 void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
1814 alignof(VarDefInit));
1815 VarDefInit *I = new(Mem) VarDefInit(Class, Args.size());
1816 std::uninitialized_copy(Args.begin(), Args.end(),
1817 I->getTrailingObjects<Init *>());
1818 ThePool.InsertNode(I, IP);
1819 return I;
1820 }
1821
Profile(FoldingSetNodeID & ID) const1822 void VarDefInit::Profile(FoldingSetNodeID &ID) const {
1823 ProfileVarDefInit(ID, Class, args());
1824 }
1825
instantiate()1826 DefInit *VarDefInit::instantiate() {
1827 if (!Def) {
1828 RecordKeeper &Records = Class->getRecords();
1829 auto NewRecOwner = std::make_unique<Record>(Records.getNewAnonymousName(),
1830 Class->getLoc(), Records,
1831 /*IsAnonymous=*/true);
1832 Record *NewRec = NewRecOwner.get();
1833
1834 // Copy values from class to instance
1835 for (const RecordVal &Val : Class->getValues())
1836 NewRec->addValue(Val);
1837
1838 // Copy assertions from class to instance.
1839 NewRec->appendAssertions(Class);
1840
1841 // Substitute and resolve template arguments
1842 ArrayRef<Init *> TArgs = Class->getTemplateArgs();
1843 MapResolver R(NewRec);
1844
1845 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
1846 if (i < args_size())
1847 R.set(TArgs[i], getArg(i));
1848 else
1849 R.set(TArgs[i], NewRec->getValue(TArgs[i])->getValue());
1850
1851 NewRec->removeValue(TArgs[i]);
1852 }
1853
1854 NewRec->resolveReferences(R);
1855
1856 // Add superclasses.
1857 ArrayRef<std::pair<Record *, SMRange>> SCs = Class->getSuperClasses();
1858 for (const auto &SCPair : SCs)
1859 NewRec->addSuperClass(SCPair.first, SCPair.second);
1860
1861 NewRec->addSuperClass(Class,
1862 SMRange(Class->getLoc().back(),
1863 Class->getLoc().back()));
1864
1865 // Resolve internal references and store in record keeper
1866 NewRec->resolveReferences();
1867 Records.addDef(std::move(NewRecOwner));
1868
1869 // Check the assertions.
1870 NewRec->checkRecordAssertions();
1871
1872 Def = DefInit::get(NewRec);
1873 }
1874
1875 return Def;
1876 }
1877
resolveReferences(Resolver & R) const1878 Init *VarDefInit::resolveReferences(Resolver &R) const {
1879 TrackUnresolvedResolver UR(&R);
1880 bool Changed = false;
1881 SmallVector<Init *, 8> NewArgs;
1882 NewArgs.reserve(args_size());
1883
1884 for (Init *Arg : args()) {
1885 Init *NewArg = Arg->resolveReferences(UR);
1886 NewArgs.push_back(NewArg);
1887 Changed |= NewArg != Arg;
1888 }
1889
1890 if (Changed) {
1891 auto New = VarDefInit::get(Class, NewArgs);
1892 if (!UR.foundUnresolved())
1893 return New->instantiate();
1894 return New;
1895 }
1896 return const_cast<VarDefInit *>(this);
1897 }
1898
Fold() const1899 Init *VarDefInit::Fold() const {
1900 if (Def)
1901 return Def;
1902
1903 TrackUnresolvedResolver R;
1904 for (Init *Arg : args())
1905 Arg->resolveReferences(R);
1906
1907 if (!R.foundUnresolved())
1908 return const_cast<VarDefInit *>(this)->instantiate();
1909 return const_cast<VarDefInit *>(this);
1910 }
1911
getAsString() const1912 std::string VarDefInit::getAsString() const {
1913 std::string Result = Class->getNameInitAsString() + "<";
1914 const char *sep = "";
1915 for (Init *Arg : args()) {
1916 Result += sep;
1917 sep = ", ";
1918 Result += Arg->getAsString();
1919 }
1920 return Result + ">";
1921 }
1922
get(Init * R,StringInit * FN)1923 FieldInit *FieldInit::get(Init *R, StringInit *FN) {
1924 using Key = std::pair<Init *, StringInit *>;
1925 static DenseMap<Key, FieldInit*> ThePool;
1926
1927 Key TheKey(std::make_pair(R, FN));
1928
1929 FieldInit *&I = ThePool[TheKey];
1930 if (!I) I = new(Allocator) FieldInit(R, FN);
1931 return I;
1932 }
1933
getBit(unsigned Bit) const1934 Init *FieldInit::getBit(unsigned Bit) const {
1935 if (getType() == BitRecTy::get())
1936 return const_cast<FieldInit*>(this);
1937 return VarBitInit::get(const_cast<FieldInit*>(this), Bit);
1938 }
1939
resolveReferences(Resolver & R) const1940 Init *FieldInit::resolveReferences(Resolver &R) const {
1941 Init *NewRec = Rec->resolveReferences(R);
1942 if (NewRec != Rec)
1943 return FieldInit::get(NewRec, FieldName)->Fold(R.getCurrentRecord());
1944 return const_cast<FieldInit *>(this);
1945 }
1946
Fold(Record * CurRec) const1947 Init *FieldInit::Fold(Record *CurRec) const {
1948 if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
1949 Record *Def = DI->getDef();
1950 if (Def == CurRec)
1951 PrintFatalError(CurRec->getLoc(),
1952 Twine("Attempting to access field '") +
1953 FieldName->getAsUnquotedString() + "' of '" +
1954 Rec->getAsString() + "' is a forbidden self-reference");
1955 Init *FieldVal = Def->getValue(FieldName)->getValue();
1956 if (FieldVal->isConcrete())
1957 return FieldVal;
1958 }
1959 return const_cast<FieldInit *>(this);
1960 }
1961
isConcrete() const1962 bool FieldInit::isConcrete() const {
1963 if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
1964 Init *FieldVal = DI->getDef()->getValue(FieldName)->getValue();
1965 return FieldVal->isConcrete();
1966 }
1967 return false;
1968 }
1969
ProfileCondOpInit(FoldingSetNodeID & ID,ArrayRef<Init * > CondRange,ArrayRef<Init * > ValRange,const RecTy * ValType)1970 static void ProfileCondOpInit(FoldingSetNodeID &ID,
1971 ArrayRef<Init *> CondRange,
1972 ArrayRef<Init *> ValRange,
1973 const RecTy *ValType) {
1974 assert(CondRange.size() == ValRange.size() &&
1975 "Number of conditions and values must match!");
1976 ID.AddPointer(ValType);
1977 ArrayRef<Init *>::iterator Case = CondRange.begin();
1978 ArrayRef<Init *>::iterator Val = ValRange.begin();
1979
1980 while (Case != CondRange.end()) {
1981 ID.AddPointer(*Case++);
1982 ID.AddPointer(*Val++);
1983 }
1984 }
1985
Profile(FoldingSetNodeID & ID) const1986 void CondOpInit::Profile(FoldingSetNodeID &ID) const {
1987 ProfileCondOpInit(ID,
1988 makeArrayRef(getTrailingObjects<Init *>(), NumConds),
1989 makeArrayRef(getTrailingObjects<Init *>() + NumConds, NumConds),
1990 ValType);
1991 }
1992
1993 CondOpInit *
get(ArrayRef<Init * > CondRange,ArrayRef<Init * > ValRange,RecTy * Ty)1994 CondOpInit::get(ArrayRef<Init *> CondRange,
1995 ArrayRef<Init *> ValRange, RecTy *Ty) {
1996 assert(CondRange.size() == ValRange.size() &&
1997 "Number of conditions and values must match!");
1998
1999 static FoldingSet<CondOpInit> ThePool;
2000 FoldingSetNodeID ID;
2001 ProfileCondOpInit(ID, CondRange, ValRange, Ty);
2002
2003 void *IP = nullptr;
2004 if (CondOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
2005 return I;
2006
2007 void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(2*CondRange.size()),
2008 alignof(BitsInit));
2009 CondOpInit *I = new(Mem) CondOpInit(CondRange.size(), Ty);
2010
2011 std::uninitialized_copy(CondRange.begin(), CondRange.end(),
2012 I->getTrailingObjects<Init *>());
2013 std::uninitialized_copy(ValRange.begin(), ValRange.end(),
2014 I->getTrailingObjects<Init *>()+CondRange.size());
2015 ThePool.InsertNode(I, IP);
2016 return I;
2017 }
2018
resolveReferences(Resolver & R) const2019 Init *CondOpInit::resolveReferences(Resolver &R) const {
2020 SmallVector<Init*, 4> NewConds;
2021 bool Changed = false;
2022 for (const Init *Case : getConds()) {
2023 Init *NewCase = Case->resolveReferences(R);
2024 NewConds.push_back(NewCase);
2025 Changed |= NewCase != Case;
2026 }
2027
2028 SmallVector<Init*, 4> NewVals;
2029 for (const Init *Val : getVals()) {
2030 Init *NewVal = Val->resolveReferences(R);
2031 NewVals.push_back(NewVal);
2032 Changed |= NewVal != Val;
2033 }
2034
2035 if (Changed)
2036 return (CondOpInit::get(NewConds, NewVals,
2037 getValType()))->Fold(R.getCurrentRecord());
2038
2039 return const_cast<CondOpInit *>(this);
2040 }
2041
Fold(Record * CurRec) const2042 Init *CondOpInit::Fold(Record *CurRec) const {
2043 for ( unsigned i = 0; i < NumConds; ++i) {
2044 Init *Cond = getCond(i);
2045 Init *Val = getVal(i);
2046
2047 if (IntInit *CondI = dyn_cast_or_null<IntInit>(
2048 Cond->convertInitializerTo(IntRecTy::get()))) {
2049 if (CondI->getValue())
2050 return Val->convertInitializerTo(getValType());
2051 } else
2052 return const_cast<CondOpInit *>(this);
2053 }
2054
2055 PrintFatalError(CurRec->getLoc(),
2056 CurRec->getName() +
2057 " does not have any true condition in:" +
2058 this->getAsString());
2059 return nullptr;
2060 }
2061
isConcrete() const2062 bool CondOpInit::isConcrete() const {
2063 for (const Init *Case : getConds())
2064 if (!Case->isConcrete())
2065 return false;
2066
2067 for (const Init *Val : getVals())
2068 if (!Val->isConcrete())
2069 return false;
2070
2071 return true;
2072 }
2073
isComplete() const2074 bool CondOpInit::isComplete() const {
2075 for (const Init *Case : getConds())
2076 if (!Case->isComplete())
2077 return false;
2078
2079 for (const Init *Val : getVals())
2080 if (!Val->isConcrete())
2081 return false;
2082
2083 return true;
2084 }
2085
getAsString() const2086 std::string CondOpInit::getAsString() const {
2087 std::string Result = "!cond(";
2088 for (unsigned i = 0; i < getNumConds(); i++) {
2089 Result += getCond(i)->getAsString() + ": ";
2090 Result += getVal(i)->getAsString();
2091 if (i != getNumConds()-1)
2092 Result += ", ";
2093 }
2094 return Result + ")";
2095 }
2096
getBit(unsigned Bit) const2097 Init *CondOpInit::getBit(unsigned Bit) const {
2098 return VarBitInit::get(const_cast<CondOpInit *>(this), Bit);
2099 }
2100
ProfileDagInit(FoldingSetNodeID & ID,Init * V,StringInit * VN,ArrayRef<Init * > ArgRange,ArrayRef<StringInit * > NameRange)2101 static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, StringInit *VN,
2102 ArrayRef<Init *> ArgRange,
2103 ArrayRef<StringInit *> NameRange) {
2104 ID.AddPointer(V);
2105 ID.AddPointer(VN);
2106
2107 ArrayRef<Init *>::iterator Arg = ArgRange.begin();
2108 ArrayRef<StringInit *>::iterator Name = NameRange.begin();
2109 while (Arg != ArgRange.end()) {
2110 assert(Name != NameRange.end() && "Arg name underflow!");
2111 ID.AddPointer(*Arg++);
2112 ID.AddPointer(*Name++);
2113 }
2114 assert(Name == NameRange.end() && "Arg name overflow!");
2115 }
2116
2117 DagInit *
get(Init * V,StringInit * VN,ArrayRef<Init * > ArgRange,ArrayRef<StringInit * > NameRange)2118 DagInit::get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange,
2119 ArrayRef<StringInit *> NameRange) {
2120 static FoldingSet<DagInit> ThePool;
2121
2122 FoldingSetNodeID ID;
2123 ProfileDagInit(ID, V, VN, ArgRange, NameRange);
2124
2125 void *IP = nullptr;
2126 if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
2127 return I;
2128
2129 void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *, StringInit *>(ArgRange.size(), NameRange.size()), alignof(BitsInit));
2130 DagInit *I = new(Mem) DagInit(V, VN, ArgRange.size(), NameRange.size());
2131 std::uninitialized_copy(ArgRange.begin(), ArgRange.end(),
2132 I->getTrailingObjects<Init *>());
2133 std::uninitialized_copy(NameRange.begin(), NameRange.end(),
2134 I->getTrailingObjects<StringInit *>());
2135 ThePool.InsertNode(I, IP);
2136 return I;
2137 }
2138
2139 DagInit *
get(Init * V,StringInit * VN,ArrayRef<std::pair<Init *,StringInit * >> args)2140 DagInit::get(Init *V, StringInit *VN,
2141 ArrayRef<std::pair<Init*, StringInit*>> args) {
2142 SmallVector<Init *, 8> Args;
2143 SmallVector<StringInit *, 8> Names;
2144
2145 for (const auto &Arg : args) {
2146 Args.push_back(Arg.first);
2147 Names.push_back(Arg.second);
2148 }
2149
2150 return DagInit::get(V, VN, Args, Names);
2151 }
2152
Profile(FoldingSetNodeID & ID) const2153 void DagInit::Profile(FoldingSetNodeID &ID) const {
2154 ProfileDagInit(ID, Val, ValName, makeArrayRef(getTrailingObjects<Init *>(), NumArgs), makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames));
2155 }
2156
getOperatorAsDef(ArrayRef<SMLoc> Loc) const2157 Record *DagInit::getOperatorAsDef(ArrayRef<SMLoc> Loc) const {
2158 if (DefInit *DefI = dyn_cast<DefInit>(Val))
2159 return DefI->getDef();
2160 PrintFatalError(Loc, "Expected record as operator");
2161 return nullptr;
2162 }
2163
resolveReferences(Resolver & R) const2164 Init *DagInit::resolveReferences(Resolver &R) const {
2165 SmallVector<Init*, 8> NewArgs;
2166 NewArgs.reserve(arg_size());
2167 bool ArgsChanged = false;
2168 for (const Init *Arg : getArgs()) {
2169 Init *NewArg = Arg->resolveReferences(R);
2170 NewArgs.push_back(NewArg);
2171 ArgsChanged |= NewArg != Arg;
2172 }
2173
2174 Init *Op = Val->resolveReferences(R);
2175 if (Op != Val || ArgsChanged)
2176 return DagInit::get(Op, ValName, NewArgs, getArgNames());
2177
2178 return const_cast<DagInit *>(this);
2179 }
2180
isConcrete() const2181 bool DagInit::isConcrete() const {
2182 if (!Val->isConcrete())
2183 return false;
2184 for (const Init *Elt : getArgs()) {
2185 if (!Elt->isConcrete())
2186 return false;
2187 }
2188 return true;
2189 }
2190
getAsString() const2191 std::string DagInit::getAsString() const {
2192 std::string Result = "(" + Val->getAsString();
2193 if (ValName)
2194 Result += ":" + ValName->getAsUnquotedString();
2195 if (!arg_empty()) {
2196 Result += " " + getArg(0)->getAsString();
2197 if (getArgName(0)) Result += ":$" + getArgName(0)->getAsUnquotedString();
2198 for (unsigned i = 1, e = getNumArgs(); i != e; ++i) {
2199 Result += ", " + getArg(i)->getAsString();
2200 if (getArgName(i)) Result += ":$" + getArgName(i)->getAsUnquotedString();
2201 }
2202 }
2203 return Result + ")";
2204 }
2205
2206 //===----------------------------------------------------------------------===//
2207 // Other implementations
2208 //===----------------------------------------------------------------------===//
2209
RecordVal(Init * N,RecTy * T,FieldKind K)2210 RecordVal::RecordVal(Init *N, RecTy *T, FieldKind K)
2211 : Name(N), TyAndKind(T, K) {
2212 setValue(UnsetInit::get());
2213 assert(Value && "Cannot create unset value for current type!");
2214 }
2215
2216 // This constructor accepts the same arguments as the above, but also
2217 // a source location.
RecordVal(Init * N,SMLoc Loc,RecTy * T,FieldKind K)2218 RecordVal::RecordVal(Init *N, SMLoc Loc, RecTy *T, FieldKind K)
2219 : Name(N), Loc(Loc), TyAndKind(T, K) {
2220 setValue(UnsetInit::get());
2221 assert(Value && "Cannot create unset value for current type!");
2222 }
2223
getName() const2224 StringRef RecordVal::getName() const {
2225 return cast<StringInit>(getNameInit())->getValue();
2226 }
2227
getPrintType() const2228 std::string RecordVal::getPrintType() const {
2229 if (getType() == StringRecTy::get()) {
2230 if (auto *StrInit = dyn_cast<StringInit>(Value)) {
2231 if (StrInit->hasCodeFormat())
2232 return "code";
2233 else
2234 return "string";
2235 } else {
2236 return "string";
2237 }
2238 } else {
2239 return TyAndKind.getPointer()->getAsString();
2240 }
2241 }
2242
setValue(Init * V)2243 bool RecordVal::setValue(Init *V) {
2244 if (V) {
2245 Value = V->getCastTo(getType());
2246 if (Value) {
2247 assert(!isa<TypedInit>(Value) ||
2248 cast<TypedInit>(Value)->getType()->typeIsA(getType()));
2249 if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
2250 if (!isa<BitsInit>(Value)) {
2251 SmallVector<Init *, 64> Bits;
2252 Bits.reserve(BTy->getNumBits());
2253 for (unsigned I = 0, E = BTy->getNumBits(); I < E; ++I)
2254 Bits.push_back(Value->getBit(I));
2255 Value = BitsInit::get(Bits);
2256 }
2257 }
2258 }
2259 return Value == nullptr;
2260 }
2261 Value = nullptr;
2262 return false;
2263 }
2264
2265 // This version of setValue takes a source location and resets the
2266 // location in the RecordVal.
setValue(Init * V,SMLoc NewLoc)2267 bool RecordVal::setValue(Init *V, SMLoc NewLoc) {
2268 Loc = NewLoc;
2269 if (V) {
2270 Value = V->getCastTo(getType());
2271 if (Value) {
2272 assert(!isa<TypedInit>(Value) ||
2273 cast<TypedInit>(Value)->getType()->typeIsA(getType()));
2274 if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
2275 if (!isa<BitsInit>(Value)) {
2276 SmallVector<Init *, 64> Bits;
2277 Bits.reserve(BTy->getNumBits());
2278 for (unsigned I = 0, E = BTy->getNumBits(); I < E; ++I)
2279 Bits.push_back(Value->getBit(I));
2280 Value = BitsInit::get(Bits);
2281 }
2282 }
2283 }
2284 return Value == nullptr;
2285 }
2286 Value = nullptr;
2287 return false;
2288 }
2289
2290 #include "llvm/TableGen/Record.h"
2291 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump() const2292 LLVM_DUMP_METHOD void RecordVal::dump() const { errs() << *this; }
2293 #endif
2294
print(raw_ostream & OS,bool PrintSem) const2295 void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
2296 if (isNonconcreteOK()) OS << "field ";
2297 OS << getPrintType() << " " << getNameInitAsString();
2298
2299 if (getValue())
2300 OS << " = " << *getValue();
2301
2302 if (PrintSem) OS << ";\n";
2303 }
2304
2305 unsigned Record::LastID = 0;
2306
checkName()2307 void Record::checkName() {
2308 // Ensure the record name has string type.
2309 const TypedInit *TypedName = cast<const TypedInit>(Name);
2310 if (!isa<StringRecTy>(TypedName->getType()))
2311 PrintFatalError(getLoc(), Twine("Record name '") + Name->getAsString() +
2312 "' is not a string!");
2313 }
2314
getType()2315 RecordRecTy *Record::getType() {
2316 SmallVector<Record *, 4> DirectSCs;
2317 getDirectSuperClasses(DirectSCs);
2318 return RecordRecTy::get(DirectSCs);
2319 }
2320
getDefInit()2321 DefInit *Record::getDefInit() {
2322 if (!CorrespondingDefInit)
2323 CorrespondingDefInit = new (Allocator) DefInit(this);
2324 return CorrespondingDefInit;
2325 }
2326
setName(Init * NewName)2327 void Record::setName(Init *NewName) {
2328 Name = NewName;
2329 checkName();
2330 // DO NOT resolve record values to the name at this point because
2331 // there might be default values for arguments of this def. Those
2332 // arguments might not have been resolved yet so we don't want to
2333 // prematurely assume values for those arguments were not passed to
2334 // this def.
2335 //
2336 // Nonetheless, it may be that some of this Record's values
2337 // reference the record name. Indeed, the reason for having the
2338 // record name be an Init is to provide this flexibility. The extra
2339 // resolve steps after completely instantiating defs takes care of
2340 // this. See TGParser::ParseDef and TGParser::ParseDefm.
2341 }
2342
2343 // NOTE for the next two functions:
2344 // Superclasses are in post-order, so the final one is a direct
2345 // superclass. All of its transitive superclases immediately precede it,
2346 // so we can step through the direct superclasses in reverse order.
2347
hasDirectSuperClass(const Record * Superclass) const2348 bool Record::hasDirectSuperClass(const Record *Superclass) const {
2349 ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses();
2350
2351 for (int I = SCs.size() - 1; I >= 0; --I) {
2352 const Record *SC = SCs[I].first;
2353 if (SC == Superclass)
2354 return true;
2355 I -= SC->getSuperClasses().size();
2356 }
2357
2358 return false;
2359 }
2360
getDirectSuperClasses(SmallVectorImpl<Record * > & Classes) const2361 void Record::getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const {
2362 ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses();
2363
2364 while (!SCs.empty()) {
2365 Record *SC = SCs.back().first;
2366 SCs = SCs.drop_back(1 + SC->getSuperClasses().size());
2367 Classes.push_back(SC);
2368 }
2369 }
2370
resolveReferences(Resolver & R,const RecordVal * SkipVal)2371 void Record::resolveReferences(Resolver &R, const RecordVal *SkipVal) {
2372 Init *OldName = getNameInit();
2373 Init *NewName = Name->resolveReferences(R);
2374 if (NewName != OldName) {
2375 // Re-register with RecordKeeper.
2376 setName(NewName);
2377 }
2378
2379 // Resolve the field values.
2380 for (RecordVal &Value : Values) {
2381 if (SkipVal == &Value) // Skip resolve the same field as the given one
2382 continue;
2383 if (Init *V = Value.getValue()) {
2384 Init *VR = V->resolveReferences(R);
2385 if (Value.setValue(VR)) {
2386 std::string Type;
2387 if (TypedInit *VRT = dyn_cast<TypedInit>(VR))
2388 Type =
2389 (Twine("of type '") + VRT->getType()->getAsString() + "' ").str();
2390 PrintFatalError(
2391 getLoc(),
2392 Twine("Invalid value ") + Type + "found when setting field '" +
2393 Value.getNameInitAsString() + "' of type '" +
2394 Value.getType()->getAsString() +
2395 "' after resolving references: " + VR->getAsUnquotedString() +
2396 "\n");
2397 }
2398 }
2399 }
2400
2401 // Resolve the assertion expressions.
2402 for (auto &Assertion : Assertions) {
2403 Init *Value = Assertion.Condition->resolveReferences(R);
2404 Assertion.Condition = Value;
2405 Value = Assertion.Message->resolveReferences(R);
2406 Assertion.Message = Value;
2407 }
2408 }
2409
resolveReferences(Init * NewName)2410 void Record::resolveReferences(Init *NewName) {
2411 RecordResolver R(*this);
2412 R.setName(NewName);
2413 R.setFinal(true);
2414 resolveReferences(R);
2415 }
2416
2417 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump() const2418 LLVM_DUMP_METHOD void Record::dump() const { errs() << *this; }
2419 #endif
2420
operator <<(raw_ostream & OS,const Record & R)2421 raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
2422 OS << R.getNameInitAsString();
2423
2424 ArrayRef<Init *> TArgs = R.getTemplateArgs();
2425 if (!TArgs.empty()) {
2426 OS << "<";
2427 bool NeedComma = false;
2428 for (const Init *TA : TArgs) {
2429 if (NeedComma) OS << ", ";
2430 NeedComma = true;
2431 const RecordVal *RV = R.getValue(TA);
2432 assert(RV && "Template argument record not found??");
2433 RV->print(OS, false);
2434 }
2435 OS << ">";
2436 }
2437
2438 OS << " {";
2439 ArrayRef<std::pair<Record *, SMRange>> SC = R.getSuperClasses();
2440 if (!SC.empty()) {
2441 OS << "\t//";
2442 for (const auto &SuperPair : SC)
2443 OS << " " << SuperPair.first->getNameInitAsString();
2444 }
2445 OS << "\n";
2446
2447 for (const RecordVal &Val : R.getValues())
2448 if (Val.isNonconcreteOK() && !R.isTemplateArg(Val.getNameInit()))
2449 OS << Val;
2450 for (const RecordVal &Val : R.getValues())
2451 if (!Val.isNonconcreteOK() && !R.isTemplateArg(Val.getNameInit()))
2452 OS << Val;
2453
2454 return OS << "}\n";
2455 }
2456
getFieldLoc(StringRef FieldName) const2457 SMLoc Record::getFieldLoc(StringRef FieldName) const {
2458 const RecordVal *R = getValue(FieldName);
2459 if (!R)
2460 PrintFatalError(getLoc(), "Record `" + getName() +
2461 "' does not have a field named `" + FieldName + "'!\n");
2462 return R->getLoc();
2463 }
2464
getValueInit(StringRef FieldName) const2465 Init *Record::getValueInit(StringRef FieldName) const {
2466 const RecordVal *R = getValue(FieldName);
2467 if (!R || !R->getValue())
2468 PrintFatalError(getLoc(), "Record `" + getName() +
2469 "' does not have a field named `" + FieldName + "'!\n");
2470 return R->getValue();
2471 }
2472
getValueAsString(StringRef FieldName) const2473 StringRef Record::getValueAsString(StringRef FieldName) const {
2474 llvm::Optional<StringRef> S = getValueAsOptionalString(FieldName);
2475 if (!S.hasValue())
2476 PrintFatalError(getLoc(), "Record `" + getName() +
2477 "' does not have a field named `" + FieldName + "'!\n");
2478 return S.getValue();
2479 }
2480
2481 llvm::Optional<StringRef>
getValueAsOptionalString(StringRef FieldName) const2482 Record::getValueAsOptionalString(StringRef FieldName) const {
2483 const RecordVal *R = getValue(FieldName);
2484 if (!R || !R->getValue())
2485 return llvm::Optional<StringRef>();
2486 if (isa<UnsetInit>(R->getValue()))
2487 return llvm::Optional<StringRef>();
2488
2489 if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
2490 return SI->getValue();
2491
2492 PrintFatalError(getLoc(),
2493 "Record `" + getName() + "', ` field `" + FieldName +
2494 "' exists but does not have a string initializer!");
2495 }
2496
getValueAsBitsInit(StringRef FieldName) const2497 BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
2498 const RecordVal *R = getValue(FieldName);
2499 if (!R || !R->getValue())
2500 PrintFatalError(getLoc(), "Record `" + getName() +
2501 "' does not have a field named `" + FieldName + "'!\n");
2502
2503 if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue()))
2504 return BI;
2505 PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName +
2506 "' exists but does not have a bits value");
2507 }
2508
getValueAsListInit(StringRef FieldName) const2509 ListInit *Record::getValueAsListInit(StringRef FieldName) const {
2510 const RecordVal *R = getValue(FieldName);
2511 if (!R || !R->getValue())
2512 PrintFatalError(getLoc(), "Record `" + getName() +
2513 "' does not have a field named `" + FieldName + "'!\n");
2514
2515 if (ListInit *LI = dyn_cast<ListInit>(R->getValue()))
2516 return LI;
2517 PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName +
2518 "' exists but does not have a list value");
2519 }
2520
2521 std::vector<Record*>
getValueAsListOfDefs(StringRef FieldName) const2522 Record::getValueAsListOfDefs(StringRef FieldName) const {
2523 ListInit *List = getValueAsListInit(FieldName);
2524 std::vector<Record*> Defs;
2525 for (Init *I : List->getValues()) {
2526 if (DefInit *DI = dyn_cast<DefInit>(I))
2527 Defs.push_back(DI->getDef());
2528 else
2529 PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2530 FieldName + "' list is not entirely DefInit!");
2531 }
2532 return Defs;
2533 }
2534
getValueAsInt(StringRef FieldName) const2535 int64_t Record::getValueAsInt(StringRef FieldName) const {
2536 const RecordVal *R = getValue(FieldName);
2537 if (!R || !R->getValue())
2538 PrintFatalError(getLoc(), "Record `" + getName() +
2539 "' does not have a field named `" + FieldName + "'!\n");
2540
2541 if (IntInit *II = dyn_cast<IntInit>(R->getValue()))
2542 return II->getValue();
2543 PrintFatalError(getLoc(), Twine("Record `") + getName() + "', field `" +
2544 FieldName +
2545 "' exists but does not have an int value: " +
2546 R->getValue()->getAsString());
2547 }
2548
2549 std::vector<int64_t>
getValueAsListOfInts(StringRef FieldName) const2550 Record::getValueAsListOfInts(StringRef FieldName) const {
2551 ListInit *List = getValueAsListInit(FieldName);
2552 std::vector<int64_t> Ints;
2553 for (Init *I : List->getValues()) {
2554 if (IntInit *II = dyn_cast<IntInit>(I))
2555 Ints.push_back(II->getValue());
2556 else
2557 PrintFatalError(getLoc(),
2558 Twine("Record `") + getName() + "', field `" + FieldName +
2559 "' exists but does not have a list of ints value: " +
2560 I->getAsString());
2561 }
2562 return Ints;
2563 }
2564
2565 std::vector<StringRef>
getValueAsListOfStrings(StringRef FieldName) const2566 Record::getValueAsListOfStrings(StringRef FieldName) const {
2567 ListInit *List = getValueAsListInit(FieldName);
2568 std::vector<StringRef> Strings;
2569 for (Init *I : List->getValues()) {
2570 if (StringInit *SI = dyn_cast<StringInit>(I))
2571 Strings.push_back(SI->getValue());
2572 else
2573 PrintFatalError(getLoc(),
2574 Twine("Record `") + getName() + "', field `" + FieldName +
2575 "' exists but does not have a list of strings value: " +
2576 I->getAsString());
2577 }
2578 return Strings;
2579 }
2580
getValueAsDef(StringRef FieldName) const2581 Record *Record::getValueAsDef(StringRef FieldName) const {
2582 const RecordVal *R = getValue(FieldName);
2583 if (!R || !R->getValue())
2584 PrintFatalError(getLoc(), "Record `" + getName() +
2585 "' does not have a field named `" + FieldName + "'!\n");
2586
2587 if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
2588 return DI->getDef();
2589 PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2590 FieldName + "' does not have a def initializer!");
2591 }
2592
getValueAsOptionalDef(StringRef FieldName) const2593 Record *Record::getValueAsOptionalDef(StringRef FieldName) const {
2594 const RecordVal *R = getValue(FieldName);
2595 if (!R || !R->getValue())
2596 PrintFatalError(getLoc(), "Record `" + getName() +
2597 "' does not have a field named `" + FieldName + "'!\n");
2598
2599 if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
2600 return DI->getDef();
2601 if (isa<UnsetInit>(R->getValue()))
2602 return nullptr;
2603 PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2604 FieldName + "' does not have either a def initializer or '?'!");
2605 }
2606
2607
getValueAsBit(StringRef FieldName) const2608 bool Record::getValueAsBit(StringRef FieldName) const {
2609 const RecordVal *R = getValue(FieldName);
2610 if (!R || !R->getValue())
2611 PrintFatalError(getLoc(), "Record `" + getName() +
2612 "' does not have a field named `" + FieldName + "'!\n");
2613
2614 if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
2615 return BI->getValue();
2616 PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2617 FieldName + "' does not have a bit initializer!");
2618 }
2619
getValueAsBitOrUnset(StringRef FieldName,bool & Unset) const2620 bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const {
2621 const RecordVal *R = getValue(FieldName);
2622 if (!R || !R->getValue())
2623 PrintFatalError(getLoc(), "Record `" + getName() +
2624 "' does not have a field named `" + FieldName.str() + "'!\n");
2625
2626 if (isa<UnsetInit>(R->getValue())) {
2627 Unset = true;
2628 return false;
2629 }
2630 Unset = false;
2631 if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
2632 return BI->getValue();
2633 PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2634 FieldName + "' does not have a bit initializer!");
2635 }
2636
getValueAsDag(StringRef FieldName) const2637 DagInit *Record::getValueAsDag(StringRef FieldName) const {
2638 const RecordVal *R = getValue(FieldName);
2639 if (!R || !R->getValue())
2640 PrintFatalError(getLoc(), "Record `" + getName() +
2641 "' does not have a field named `" + FieldName + "'!\n");
2642
2643 if (DagInit *DI = dyn_cast<DagInit>(R->getValue()))
2644 return DI;
2645 PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2646 FieldName + "' does not have a dag initializer!");
2647 }
2648
2649 // Check all record assertions: For each one, resolve the condition
2650 // and message, then call CheckAssert().
2651 // Note: The condition and message are probably already resolved,
2652 // but resolving again allows calls before records are resolved.
checkRecordAssertions()2653 void Record::checkRecordAssertions() {
2654 RecordResolver R(*this);
2655 R.setFinal(true);
2656
2657 for (auto Assertion : getAssertions()) {
2658 Init *Condition = Assertion.Condition->resolveReferences(R);
2659 Init *Message = Assertion.Message->resolveReferences(R);
2660 CheckAssert(Assertion.Loc, Condition, Message);
2661 }
2662 }
2663
2664 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump() const2665 LLVM_DUMP_METHOD void RecordKeeper::dump() const { errs() << *this; }
2666 #endif
2667
operator <<(raw_ostream & OS,const RecordKeeper & RK)2668 raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
2669 OS << "------------- Classes -----------------\n";
2670 for (const auto &C : RK.getClasses())
2671 OS << "class " << *C.second;
2672
2673 OS << "------------- Defs -----------------\n";
2674 for (const auto &D : RK.getDefs())
2675 OS << "def " << *D.second;
2676 return OS;
2677 }
2678
2679 /// GetNewAnonymousName - Generate a unique anonymous name that can be used as
2680 /// an identifier.
getNewAnonymousName()2681 Init *RecordKeeper::getNewAnonymousName() {
2682 return AnonymousNameInit::get(AnonCounter++);
2683 }
2684
2685 // These functions implement the phase timing facility. Starting a timer
2686 // when one is already running stops the running one.
2687
startTimer(StringRef Name)2688 void RecordKeeper::startTimer(StringRef Name) {
2689 if (TimingGroup) {
2690 if (LastTimer && LastTimer->isRunning()) {
2691 LastTimer->stopTimer();
2692 if (BackendTimer) {
2693 LastTimer->clear();
2694 BackendTimer = false;
2695 }
2696 }
2697
2698 LastTimer = new Timer("", Name, *TimingGroup);
2699 LastTimer->startTimer();
2700 }
2701 }
2702
stopTimer()2703 void RecordKeeper::stopTimer() {
2704 if (TimingGroup) {
2705 assert(LastTimer && "No phase timer was started");
2706 LastTimer->stopTimer();
2707 }
2708 }
2709
startBackendTimer(StringRef Name)2710 void RecordKeeper::startBackendTimer(StringRef Name) {
2711 if (TimingGroup) {
2712 startTimer(Name);
2713 BackendTimer = true;
2714 }
2715 }
2716
stopBackendTimer()2717 void RecordKeeper::stopBackendTimer() {
2718 if (TimingGroup) {
2719 if (BackendTimer) {
2720 stopTimer();
2721 BackendTimer = false;
2722 }
2723 }
2724 }
2725
2726 // We cache the record vectors for single classes. Many backends request
2727 // the same vectors multiple times.
getAllDerivedDefinitions(StringRef ClassName) const2728 std::vector<Record *> RecordKeeper::getAllDerivedDefinitions(
2729 StringRef ClassName) const {
2730
2731 auto Pair = ClassRecordsMap.try_emplace(ClassName);
2732 if (Pair.second)
2733 Pair.first->second = getAllDerivedDefinitions(makeArrayRef(ClassName));
2734
2735 return Pair.first->second;
2736 }
2737
getAllDerivedDefinitions(ArrayRef<StringRef> ClassNames) const2738 std::vector<Record *> RecordKeeper::getAllDerivedDefinitions(
2739 ArrayRef<StringRef> ClassNames) const {
2740 SmallVector<Record *, 2> ClassRecs;
2741 std::vector<Record *> Defs;
2742
2743 assert(ClassNames.size() > 0 && "At least one class must be passed.");
2744 for (const auto &ClassName : ClassNames) {
2745 Record *Class = getClass(ClassName);
2746 if (!Class)
2747 PrintFatalError("The class '" + ClassName + "' is not defined\n");
2748 ClassRecs.push_back(Class);
2749 }
2750
2751 for (const auto &OneDef : getDefs()) {
2752 if (all_of(ClassRecs, [&OneDef](const Record *Class) {
2753 return OneDef.second->isSubClassOf(Class);
2754 }))
2755 Defs.push_back(OneDef.second.get());
2756 }
2757
2758 return Defs;
2759 }
2760
resolve(Init * VarName)2761 Init *MapResolver::resolve(Init *VarName) {
2762 auto It = Map.find(VarName);
2763 if (It == Map.end())
2764 return nullptr;
2765
2766 Init *I = It->second.V;
2767
2768 if (!It->second.Resolved && Map.size() > 1) {
2769 // Resolve mutual references among the mapped variables, but prevent
2770 // infinite recursion.
2771 Map.erase(It);
2772 I = I->resolveReferences(*this);
2773 Map[VarName] = {I, true};
2774 }
2775
2776 return I;
2777 }
2778
resolve(Init * VarName)2779 Init *RecordResolver::resolve(Init *VarName) {
2780 Init *Val = Cache.lookup(VarName);
2781 if (Val)
2782 return Val;
2783
2784 if (llvm::is_contained(Stack, VarName))
2785 return nullptr; // prevent infinite recursion
2786
2787 if (RecordVal *RV = getCurrentRecord()->getValue(VarName)) {
2788 if (!isa<UnsetInit>(RV->getValue())) {
2789 Val = RV->getValue();
2790 Stack.push_back(VarName);
2791 Val = Val->resolveReferences(*this);
2792 Stack.pop_back();
2793 }
2794 } else if (Name && VarName == getCurrentRecord()->getNameInit()) {
2795 Stack.push_back(VarName);
2796 Val = Name->resolveReferences(*this);
2797 Stack.pop_back();
2798 }
2799
2800 Cache[VarName] = Val;
2801 return Val;
2802 }
2803
resolve(Init * VarName)2804 Init *TrackUnresolvedResolver::resolve(Init *VarName) {
2805 Init *I = nullptr;
2806
2807 if (R) {
2808 I = R->resolve(VarName);
2809 if (I && !FoundUnresolved) {
2810 // Do not recurse into the resolved initializer, as that would change
2811 // the behavior of the resolver we're delegating, but do check to see
2812 // if there are unresolved variables remaining.
2813 TrackUnresolvedResolver Sub;
2814 I->resolveReferences(Sub);
2815 FoundUnresolved |= Sub.FoundUnresolved;
2816 }
2817 }
2818
2819 if (!I)
2820 FoundUnresolved = true;
2821 return I;
2822 }
2823
resolve(Init * VarName)2824 Init *HasReferenceResolver::resolve(Init *VarName)
2825 {
2826 if (VarName == VarNameToTrack)
2827 Found = true;
2828 return nullptr;
2829 }
2830