/usr/src/gnu/usr.bin/clang/libLLVMTableGen/../../../llvm/llvm/lib/TableGen/Record.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libLLVMTableGen/../../../llvm/llvm/lib/TableGen/Record.cpp
Warning:	line 422, column 11 Value stored to 'NewBit' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Record.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVMTableGen/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVMTableGen/../../../llvm/llvm/include/llvm/TableGen -I /usr/src/gnu/usr.bin/clang/libLLVMTableGen/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVMTableGen/../include -I /usr/src/gnu/usr.bin/clang/libLLVMTableGen/obj -I /usr/src/gnu/usr.bin/clang/libLLVMTableGen/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVMTableGen/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVMTableGen/../../../llvm/llvm/lib/TableGen/Record.cpp

1	//===- Record.cpp - Record implementation ---------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// Implement the tablegen record classes.
10	//
11	//===----------------------------------------------------------------------===//
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" "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(NDEBUG1) \|\| defined(LLVM_ENABLE_DUMP)
56	LLVM_DUMP_METHOD__attribute__((noinline)) void RecTy::dump() const { print(errs()); }
57	#endif
58
59	ListRecTy *RecTy::getListTy() {
60	if (!ListTy)
61	ListTy = new(Allocator) ListRecTy(this);
62	return ListTy;
63	}
64
65	bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
66	assert(RHS && "NULL pointer")((void)0);
67	return Kind == RHS->getRecTyKind();
68	}
69
70	bool RecTy::typeIsA(const RecTy *RHS) const { return this == RHS; }
71
72	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
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
90	std::string BitsRecTy::getAsString() const {
91	return "bits<" + utostr(Size) + ">";
92	}
93
94	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
101	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
107	bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
108	RecTyKind kind = RHS->getRecTyKind();
109	return kind==BitRecTyKind \|\| kind==BitsRecTyKind \|\| kind==IntRecTyKind;
110	}
111
112	std::string StringRecTy::getAsString() const {
113	return "string";
114	}
115
116	bool StringRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
117	RecTyKind Kind = RHS->getRecTyKind();
118	return Kind == StringRecTyKind;
119	}
120
121	std::string ListRecTy::getAsString() const {
122	return "list<" + ElementTy->getAsString() + ">";
123	}
124
125	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
131	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
137	std::string DagRecTy::getAsString() const {
138	return "dag";
139	}
140
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
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 NDEBUG1
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]))((void)0);
175	}
176	assert(&Classes[0]->getRecords() == &Classes[i]->getRecords())((void)0);
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
189	void RecordRecTy::Profile(FoldingSetNodeID &ID) const {
190	ProfileRecordRecTy(ID, getClasses());
191	}
192
193	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
209	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
216	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
229	bool RecordRecTy::typeIsA(const RecTy *RHS) const {
230	return typeIsConvertibleTo(RHS);
231	}
232
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
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
280	void Init::anchor() {}
281
282	#if !defined(NDEBUG1) \|\| defined(LLVM_ENABLE_DUMP)
283	LLVM_DUMP_METHOD__attribute__((noinline)) void Init::dump() const { return print(errs()); }
284	#endif
285
286	UnsetInit *UnsetInit::get() {
287	static UnsetInit TheInit;
288	return &TheInit;
289	}
290
291	Init UnsetInit::getCastTo(RecTy Ty) const {
292	return const_cast<UnsetInit *>(this);
293	}
294
295	Init UnsetInit::convertInitializerTo(RecTy Ty) const {
296	return const_cast<UnsetInit *>(this);
297	}
298
299	BitInit *BitInit::get(bool V) {
300	static BitInit True(true);
301	static BitInit False(false);
302
303	return V ? &True : &False;
304	}
305
306	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
323	ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
324	ID.AddInteger(Range.size());
325
326	for (Init *I : Range)
327	ID.AddPointer(I);
328	}
329
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
349	void BitsInit::Profile(FoldingSetNodeID &ID) const {
350	ProfileBitsInit(ID, makeArrayRef(getTrailingObjects<Init *>(), NumBits));
351	}
352
353	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 *
380	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
391	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
399	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.
413	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;
	Value stored to 'NewBit' during its initialization is never read
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")((void)0);
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
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
456	std::string IntInit::getAsString() const {
457	return itostr(Value);
458	}
459
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
466	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 *
493	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)1LL << Bits[i]));
501	}
502	return BitsInit::get(NewBits);
503	}
504
505	AnonymousNameInit *AnonymousNameInit::get(unsigned V) {
506	return new (Allocator) AnonymousNameInit(V);
507	}
508
509	StringInit *AnonymousNameInit::getNameInit() const {
510	return StringInit::get(getAsString());
511	}
512
513	std::string AnonymousNameInit::getAsString() const {
514	return "anonymous_" + utostr(Value);
515	}
516
517	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
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
544	Init StringInit::convertInitializerTo(RecTy Ty) const {
545	if (isa<StringRecTy>(Ty))
546	return const_cast<StringInit *>(this);
547
548	return nullptr;
549	}
550
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
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]) \|\|((void)0)
572	cast<TypedInit>(Range[0])->getType()->typeIsConvertibleTo(EltTy))((void)0);
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
583	void ListInit::Profile(FoldingSetNodeID &ID) const {
584	RecTy *EltTy = cast<ListRecTy>(getType())->getElementType();
585
586	ProfileListInit(ID, getValues(), EltTy);
587	}
588
589	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
617	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
634	Record *ListInit::getElementAsRecord(unsigned i) const {
635	assert(i < NumValues && "List element index out of range!")((void)0);
636	DefInit *DI = dyn_cast<DefInit>(getElement(i));
637	if (!DI)
638	PrintFatalError("Expected record in list!");
639	return DI->getDef();
640	}
641
642	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
658	bool ListInit::isComplete() const {
659	for (Init Element : this) {
660	if (!Element->isComplete())
661	return false;
662	}
663	return true;
664	}
665
666	bool ListInit::isConcrete() const {
667	for (Init Element : this) {
668	if (!Element->isConcrete())
669	return false;
670	}
671	return true;
672	}
673
674	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
685	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
692	ProfileUnOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init Op, RecTy Type) {
693	ID.AddInteger(Opcode);
694	ID.AddPointer(Op);
695	ID.AddPointer(Type);
696	}
697
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
713	void UnOpInit::Profile(FoldingSetNodeID &ID) const {
714	ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
715	}
716
717	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")((void)0);
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")((void)0);
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")((void)0);
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
831	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
840	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
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
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
879	void BinOpInit::Profile(FoldingSetNodeID &ID) const {
880	ProfileBinOpInit(ID, getOpcode(), getLHS(), getRHS(), getType());
881	}
882
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
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
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
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
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
952	Init BinOpInit::getListConcat(TypedInit LHS, Init *RHS) {
953	assert(isa<ListRecTy>(LHS->getType()) && "First arg must be a list")((void)0);
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
962	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")__builtin_unreachable();
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")__builtin_unreachable();
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!")__builtin_unreachable();
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
1142	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
1152	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
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
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
1206	void TernOpInit::Profile(FoldingSetNodeID &ID) const {
1207	ProfileTernOpInit(ID, getOpcode(), getLHS(), getMHS(), getRHS(), getType());
1208	}
1209
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
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.
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.
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
1289	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
1426	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
1456	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
1473	static void ProfileFoldOpInit(FoldingSetNodeID &ID, Init Start, Init List,
1474	Init A, Init B, Init Expr, RecTy Type) {
1475	ID.AddPointer(Start);
1476	ID.AddPointer(List);
1477	ID.AddPointer(A);
1478	ID.AddPointer(B);
1479	ID.AddPointer(Expr);
1480	ID.AddPointer(Type);
1481	}
1482
1483	FoldOpInit FoldOpInit::get(Init Start, Init List, Init A, Init *B,
1484	Init Expr, RecTy Type) {
1485	static FoldingSet<FoldOpInit> ThePool;
1486
1487	FoldingSetNodeID ID;
1488	ProfileFoldOpInit(ID, Start, List, A, B, Expr, Type);
1489
1490	void *IP = nullptr;
1491	if (FoldOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
1492	return I;
1493
1494	FoldOpInit *I = new (Allocator) FoldOpInit(Start, List, A, B, Expr, Type);
1495	ThePool.InsertNode(I, IP);
1496	return I;
1497	}
1498
1499	void FoldOpInit::Profile(FoldingSetNodeID &ID) const {
1500	ProfileFoldOpInit(ID, Start, List, A, B, Expr, getType());
1501	}
1502
1503	Init FoldOpInit::Fold(Record CurRec) const {
1504	if (ListInit *LI = dyn_cast<ListInit>(List)) {
1505	Init *Accum = Start;
1506	for (Init Elt : LI) {
1507	MapResolver R(CurRec);
1508	R.set(A, Accum);
1509	R.set(B, Elt);
1510	Accum = Expr->resolveReferences(R);
1511	}
1512	return Accum;
1513	}
1514	return const_cast<FoldOpInit *>(this);
1515	}
1516
1517	Init *FoldOpInit::resolveReferences(Resolver &R) const {
1518	Init *NewStart = Start->resolveReferences(R);
1519	Init *NewList = List->resolveReferences(R);
1520	ShadowResolver SR(R);
1521	SR.addShadow(A);
1522	SR.addShadow(B);
1523	Init *NewExpr = Expr->resolveReferences(SR);
1524
1525	if (Start == NewStart && List == NewList && Expr == NewExpr)
1526	return const_cast<FoldOpInit *>(this);
1527
1528	return get(NewStart, NewList, A, B, NewExpr, getType())
1529	->Fold(R.getCurrentRecord());
1530	}
1531
1532	Init *FoldOpInit::getBit(unsigned Bit) const {
1533	return VarBitInit::get(const_cast<FoldOpInit *>(this), Bit);
1534	}
1535
1536	std::string FoldOpInit::getAsString() const {
1537	return (Twine("!foldl(") + Start->getAsString() + ", " + List->getAsString() +
1538	", " + A->getAsUnquotedString() + ", " + B->getAsUnquotedString() +
1539	", " + Expr->getAsString() + ")")
1540	.str();
1541	}
1542
1543	static void ProfileIsAOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
1544	Init *Expr) {
1545	ID.AddPointer(CheckType);
1546	ID.AddPointer(Expr);
1547	}
1548
1549	IsAOpInit IsAOpInit::get(RecTy CheckType, Init *Expr) {
1550	static FoldingSet<IsAOpInit> ThePool;
1551
1552	FoldingSetNodeID ID;
1553	ProfileIsAOpInit(ID, CheckType, Expr);
1554
1555	void *IP = nullptr;
1556	if (IsAOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
1557	return I;
1558
1559	IsAOpInit *I = new (Allocator) IsAOpInit(CheckType, Expr);
1560	ThePool.InsertNode(I, IP);
1561	return I;
1562	}
1563
1564	void IsAOpInit::Profile(FoldingSetNodeID &ID) const {
1565	ProfileIsAOpInit(ID, CheckType, Expr);
1566	}
1567
1568	Init *IsAOpInit::Fold() const {
1569	if (TypedInit *TI = dyn_cast<TypedInit>(Expr)) {
1570	// Is the expression type known to be (a subclass of) the desired type?
1571	if (TI->getType()->typeIsConvertibleTo(CheckType))
1572	return IntInit::get(1);
1573
1574	if (isa<RecordRecTy>(CheckType)) {
1575	// If the target type is not a subclass of the expression type, or if
1576	// the expression has fully resolved to a record, we know that it can't
1577	// be of the required type.
1578	if (!CheckType->typeIsConvertibleTo(TI->getType()) \|\| isa<DefInit>(Expr))
1579	return IntInit::get(0);
1580	} else {
1581	// We treat non-record types as not castable.
1582	return IntInit::get(0);
1583	}
1584	}
1585	return const_cast<IsAOpInit *>(this);
1586	}
1587
1588	Init *IsAOpInit::resolveReferences(Resolver &R) const {
1589	Init *NewExpr = Expr->resolveReferences(R);
1590	if (Expr != NewExpr)
1591	return get(CheckType, NewExpr)->Fold();
1592	return const_cast<IsAOpInit *>(this);
1593	}
1594
1595	Init *IsAOpInit::getBit(unsigned Bit) const {
1596	return VarBitInit::get(const_cast<IsAOpInit *>(this), Bit);
1597	}
1598
1599	std::string IsAOpInit::getAsString() const {
1600	return (Twine("!isa<") + CheckType->getAsString() + ">(" +
1601	Expr->getAsString() + ")")
1602	.str();
1603	}
1604
1605	RecTy TypedInit::getFieldType(StringInit FieldName) const {
1606	if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) {
1607	for (Record *Rec : RecordType->getClasses()) {
1608	if (RecordVal *Field = Rec->getValue(FieldName))
1609	return Field->getType();
1610	}
1611	}
1612	return nullptr;
1613	}
1614
1615	Init *
1616	TypedInit::convertInitializerTo(RecTy *Ty) const {
1617	if (getType() == Ty \|\| getType()->typeIsA(Ty))
1618	return const_cast<TypedInit *>(this);
1619
1620	if (isa<BitRecTy>(getType()) && isa<BitsRecTy>(Ty) &&
1621	cast<BitsRecTy>(Ty)->getNumBits() == 1)
1622	return BitsInit::get({const_cast<TypedInit *>(this)});
1623
1624	return nullptr;
1625	}
1626
1627	Init *TypedInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
1628	BitsRecTy *T = dyn_cast<BitsRecTy>(getType());
1629	if (!T) return nullptr; // Cannot subscript a non-bits variable.
1630	unsigned NumBits = T->getNumBits();
1631
1632	SmallVector<Init *, 16> NewBits;
1633	NewBits.reserve(Bits.size());
1634	for (unsigned Bit : Bits) {
1635	if (Bit >= NumBits)
1636	return nullptr;
1637
1638	NewBits.push_back(VarBitInit::get(const_cast<TypedInit *>(this), Bit));
1639	}
1640	return BitsInit::get(NewBits);
1641	}
1642
1643	Init TypedInit::getCastTo(RecTy Ty) const {
1644	// Handle the common case quickly
1645	if (getType() == Ty \|\| getType()->typeIsA(Ty))
1646	return const_cast<TypedInit *>(this);
1647
1648	if (Init *Converted = convertInitializerTo(Ty)) {
1649	assert(!isa<TypedInit>(Converted) \|\|((void)0)
1650	cast<TypedInit>(Converted)->getType()->typeIsA(Ty))((void)0);
1651	return Converted;
1652	}
1653
1654	if (!getType()->typeIsConvertibleTo(Ty))
1655	return nullptr;
1656
1657	return UnOpInit::get(UnOpInit::CAST, const_cast<TypedInit *>(this), Ty)
1658	->Fold(nullptr);
1659	}
1660
1661	Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
1662	ListRecTy *T = dyn_cast<ListRecTy>(getType());
1663	if (!T) return nullptr; // Cannot subscript a non-list variable.
1664
1665	if (Elements.size() == 1)
1666	return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
1667
1668	SmallVector<Init*, 8> ListInits;
1669	ListInits.reserve(Elements.size());
1670	for (unsigned Element : Elements)
1671	ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this),
1672	Element));
1673	return ListInit::get(ListInits, T->getElementType());
1674	}
1675
1676
1677	VarInit VarInit::get(StringRef VN, RecTy T) {
1678	Init *Value = StringInit::get(VN);
1679	return VarInit::get(Value, T);
1680	}
1681
1682	VarInit VarInit::get(Init VN, RecTy *T) {
1683	using Key = std::pair<RecTy , Init >;
1684	static DenseMap<Key, VarInit*> ThePool;
1685
1686	Key TheKey(std::make_pair(T, VN));
1687
1688	VarInit *&I = ThePool[TheKey];
1689	if (!I)
1690	I = new(Allocator) VarInit(VN, T);
1691	return I;
1692	}
1693
1694	StringRef VarInit::getName() const {
1695	StringInit *NameString = cast<StringInit>(getNameInit());
1696	return NameString->getValue();
1697	}
1698
1699	Init *VarInit::getBit(unsigned Bit) const {
1700	if (getType() == BitRecTy::get())
1701	return const_cast<VarInit*>(this);
1702	return VarBitInit::get(const_cast<VarInit*>(this), Bit);
1703	}
1704
1705	Init *VarInit::resolveReferences(Resolver &R) const {
1706	if (Init *Val = R.resolve(VarName))
1707	return Val;
1708	return const_cast<VarInit *>(this);
1709	}
1710
1711	VarBitInit VarBitInit::get(TypedInit T, unsigned B) {
1712	using Key = std::pair<TypedInit *, unsigned>;
1713	static DenseMap<Key, VarBitInit*> ThePool;
1714
1715	Key TheKey(std::make_pair(T, B));
1716
1717	VarBitInit *&I = ThePool[TheKey];
1718	if (!I)
1719	I = new(Allocator) VarBitInit(T, B);
1720	return I;
1721	}
1722
1723	std::string VarBitInit::getAsString() const {
1724	return TI->getAsString() + "{" + utostr(Bit) + "}";
1725	}
1726
1727	Init *VarBitInit::resolveReferences(Resolver &R) const {
1728	Init *I = TI->resolveReferences(R);
1729	if (TI != I)
1730	return I->getBit(getBitNum());
1731
1732	return const_cast<VarBitInit*>(this);
1733	}
1734
1735	VarListElementInit VarListElementInit::get(TypedInit T,
1736	unsigned E) {
1737	using Key = std::pair<TypedInit *, unsigned>;
1738	static DenseMap<Key, VarListElementInit*> ThePool;
1739
1740	Key TheKey(std::make_pair(T, E));
1741
1742	VarListElementInit *&I = ThePool[TheKey];
1743	if (!I) I = new(Allocator) VarListElementInit(T, E);
1744	return I;
1745	}
1746
1747	std::string VarListElementInit::getAsString() const {
1748	return TI->getAsString() + "[" + utostr(Element) + "]";
1749	}
1750
1751	Init *VarListElementInit::resolveReferences(Resolver &R) const {
1752	Init *NewTI = TI->resolveReferences(R);
1753	if (ListInit *List = dyn_cast<ListInit>(NewTI)) {
1754	// Leave out-of-bounds array references as-is. This can happen without
1755	// being an error, e.g. in the untaken "branch" of an !if expression.
1756	if (getElementNum() < List->size())
1757	return List->getElement(getElementNum());
1758	}
1759	if (NewTI != TI && isa<TypedInit>(NewTI))
1760	return VarListElementInit::get(cast<TypedInit>(NewTI), getElementNum());
1761	return const_cast<VarListElementInit *>(this);
1762	}
1763
1764	Init *VarListElementInit::getBit(unsigned Bit) const {
1765	if (getType() == BitRecTy::get())
1766	return const_cast<VarListElementInit*>(this);
1767	return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit);
1768	}
1769
1770	DefInit::DefInit(Record *D)
1771	: TypedInit(IK_DefInit, D->getType()), Def(D) {}
1772
1773	DefInit DefInit::get(Record R) {
1774	return R->getDefInit();
1775	}
1776
1777	Init DefInit::convertInitializerTo(RecTy Ty) const {
1778	if (auto *RRT = dyn_cast<RecordRecTy>(Ty))
1779	if (getType()->typeIsConvertibleTo(RRT))
1780	return const_cast<DefInit *>(this);
1781	return nullptr;
1782	}
1783
1784	RecTy DefInit::getFieldType(StringInit FieldName) const {
1785	if (const RecordVal *RV = Def->getValue(FieldName))
1786	return RV->getType();
1787	return nullptr;
1788	}
1789
1790	std::string DefInit::getAsString() const { return std::string(Def->getName()); }
1791
1792	static void ProfileVarDefInit(FoldingSetNodeID &ID,
1793	Record *Class,
1794	ArrayRef<Init *> Args) {
1795	ID.AddInteger(Args.size());
1796	ID.AddPointer(Class);
1797
1798	for (Init *I : Args)
1799	ID.AddPointer(I);
1800	}
1801
1802	VarDefInit VarDefInit::get(Record Class, ArrayRef<Init *> Args) {
1803	static FoldingSet<VarDefInit> ThePool;
1804
1805	FoldingSetNodeID ID;
1806	ProfileVarDefInit(ID, Class, Args);
1807
1808	void *IP = nullptr;
1809	if (VarDefInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
1810	return I;
1811
1812	void Mem = Allocator.Allocate(totalSizeToAlloc<Init >(Args.size()),
1813	alignof(VarDefInit));
1814	VarDefInit *I = new(Mem) VarDefInit(Class, Args.size());
1815	std::uninitialized_copy(Args.begin(), Args.end(),
1816	I->getTrailingObjects<Init *>());
1817	ThePool.InsertNode(I, IP);
1818	return I;
1819	}
1820
1821	void VarDefInit::Profile(FoldingSetNodeID &ID) const {
1822	ProfileVarDefInit(ID, Class, args());
1823	}
1824
1825	DefInit *VarDefInit::instantiate() {
1826	if (!Def) {
1827	RecordKeeper &Records = Class->getRecords();
1828	auto NewRecOwner = std::make_unique<Record>(Records.getNewAnonymousName(),
1829	Class->getLoc(), Records,
1830	/IsAnonymous=/true);
1831	Record *NewRec = NewRecOwner.get();
1832
1833	// Copy values from class to instance
1834	for (const RecordVal &Val : Class->getValues())
1835	NewRec->addValue(Val);
1836
1837	// Copy assertions from class to instance.
1838	NewRec->appendAssertions(Class);
1839
1840	// Substitute and resolve template arguments
1841	ArrayRef<Init *> TArgs = Class->getTemplateArgs();
1842	MapResolver R(NewRec);
1843
1844	for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
1845	if (i < args_size())
1846	R.set(TArgs[i], getArg(i));
1847	else
1848	R.set(TArgs[i], NewRec->getValue(TArgs[i])->getValue());
1849
1850	NewRec->removeValue(TArgs[i]);
1851	}
1852
1853	NewRec->resolveReferences(R);
1854
1855	// Add superclasses.
1856	ArrayRef<std::pair<Record *, SMRange>> SCs = Class->getSuperClasses();
1857	for (const auto &SCPair : SCs)
1858	NewRec->addSuperClass(SCPair.first, SCPair.second);
1859
1860	NewRec->addSuperClass(Class,
1861	SMRange(Class->getLoc().back(),
1862	Class->getLoc().back()));
1863
1864	// Resolve internal references and store in record keeper
1865	NewRec->resolveReferences();
1866	Records.addDef(std::move(NewRecOwner));
1867
1868	// Check the assertions.
1869	NewRec->checkRecordAssertions();
1870
1871	Def = DefInit::get(NewRec);
1872	}
1873
1874	return Def;
1875	}
1876
1877	Init *VarDefInit::resolveReferences(Resolver &R) const {
1878	TrackUnresolvedResolver UR(&R);
1879	bool Changed = false;
1880	SmallVector<Init *, 8> NewArgs;
1881	NewArgs.reserve(args_size());
1882
1883	for (Init *Arg : args()) {
1884	Init *NewArg = Arg->resolveReferences(UR);
1885	NewArgs.push_back(NewArg);
1886	Changed \|= NewArg != Arg;
1887	}
1888
1889	if (Changed) {
1890	auto New = VarDefInit::get(Class, NewArgs);
1891	if (!UR.foundUnresolved())
1892	return New->instantiate();
1893	return New;
1894	}
1895	return const_cast<VarDefInit *>(this);
1896	}
1897
1898	Init *VarDefInit::Fold() const {
1899	if (Def)
1900	return Def;
1901
1902	TrackUnresolvedResolver R;
1903	for (Init *Arg : args())
1904	Arg->resolveReferences(R);
1905
1906	if (!R.foundUnresolved())
1907	return const_cast<VarDefInit *>(this)->instantiate();
1908	return const_cast<VarDefInit *>(this);
1909	}
1910
1911	std::string VarDefInit::getAsString() const {
1912	std::string Result = Class->getNameInitAsString() + "<";
1913	const char *sep = "";
1914	for (Init *Arg : args()) {
1915	Result += sep;
1916	sep = ", ";
1917	Result += Arg->getAsString();
1918	}
1919	return Result + ">";
1920	}
1921
1922	FieldInit FieldInit::get(Init R, StringInit *FN) {
1923	using Key = std::pair<Init , StringInit >;
1924	static DenseMap<Key, FieldInit*> ThePool;
1925
1926	Key TheKey(std::make_pair(R, FN));
1927
1928	FieldInit *&I = ThePool[TheKey];
1929	if (!I) I = new(Allocator) FieldInit(R, FN);
1930	return I;
1931	}
1932
1933	Init *FieldInit::getBit(unsigned Bit) const {
1934	if (getType() == BitRecTy::get())
1935	return const_cast<FieldInit*>(this);
1936	return VarBitInit::get(const_cast<FieldInit*>(this), Bit);
1937	}
1938
1939	Init *FieldInit::resolveReferences(Resolver &R) const {
1940	Init *NewRec = Rec->resolveReferences(R);
1941	if (NewRec != Rec)
1942	return FieldInit::get(NewRec, FieldName)->Fold(R.getCurrentRecord());
1943	return const_cast<FieldInit *>(this);
1944	}
1945
1946	Init FieldInit::Fold(Record CurRec) const {
1947	if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
1948	Record *Def = DI->getDef();
1949	if (Def == CurRec)
1950	PrintFatalError(CurRec->getLoc(),
1951	Twine("Attempting to access field '") +
1952	FieldName->getAsUnquotedString() + "' of '" +
1953	Rec->getAsString() + "' is a forbidden self-reference");
1954	Init *FieldVal = Def->getValue(FieldName)->getValue();
1955	if (FieldVal->isConcrete())
1956	return FieldVal;
1957	}
1958	return const_cast<FieldInit *>(this);
1959	}
1960
1961	bool FieldInit::isConcrete() const {
1962	if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
1963	Init *FieldVal = DI->getDef()->getValue(FieldName)->getValue();
1964	return FieldVal->isConcrete();
1965	}
1966	return false;
1967	}
1968
1969	static void ProfileCondOpInit(FoldingSetNodeID &ID,
1970	ArrayRef<Init *> CondRange,
1971	ArrayRef<Init *> ValRange,
1972	const RecTy *ValType) {
1973	assert(CondRange.size() == ValRange.size() &&((void)0)
1974	"Number of conditions and values must match!")((void)0);
1975	ID.AddPointer(ValType);
1976	ArrayRef<Init *>::iterator Case = CondRange.begin();
1977	ArrayRef<Init *>::iterator Val = ValRange.begin();
1978
1979	while (Case != CondRange.end()) {
1980	ID.AddPointer(*Case++);
1981	ID.AddPointer(*Val++);
1982	}
1983	}
1984
1985	void CondOpInit::Profile(FoldingSetNodeID &ID) const {
1986	ProfileCondOpInit(ID,
1987	makeArrayRef(getTrailingObjects<Init *>(), NumConds),
1988	makeArrayRef(getTrailingObjects<Init *>() + NumConds, NumConds),
1989	ValType);
1990	}
1991
1992	CondOpInit *
1993	CondOpInit::get(ArrayRef<Init *> CondRange,
1994	ArrayRef<Init > ValRange, RecTy Ty) {
1995	assert(CondRange.size() == ValRange.size() &&((void)0)
1996	"Number of conditions and values must match!")((void)0);
1997
1998	static FoldingSet<CondOpInit> ThePool;
1999	FoldingSetNodeID ID;
2000	ProfileCondOpInit(ID, CondRange, ValRange, Ty);
2001
2002	void *IP = nullptr;
2003	if (CondOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
2004	return I;
2005
2006	void Mem = Allocator.Allocate(totalSizeToAlloc<Init >(2*CondRange.size()),
2007	alignof(BitsInit));
2008	CondOpInit *I = new(Mem) CondOpInit(CondRange.size(), Ty);
2009
2010	std::uninitialized_copy(CondRange.begin(), CondRange.end(),
2011	I->getTrailingObjects<Init *>());
2012	std::uninitialized_copy(ValRange.begin(), ValRange.end(),
2013	I->getTrailingObjects<Init *>()+CondRange.size());
2014	ThePool.InsertNode(I, IP);
2015	return I;
2016	}
2017
2018	Init *CondOpInit::resolveReferences(Resolver &R) const {
2019	SmallVector<Init*, 4> NewConds;
2020	bool Changed = false;
2021	for (const Init *Case : getConds()) {
2022	Init *NewCase = Case->resolveReferences(R);
2023	NewConds.push_back(NewCase);
2024	Changed \|= NewCase != Case;
2025	}
2026
2027	SmallVector<Init*, 4> NewVals;
2028	for (const Init *Val : getVals()) {
2029	Init *NewVal = Val->resolveReferences(R);
2030	NewVals.push_back(NewVal);
2031	Changed \|= NewVal != Val;
2032	}
2033
2034	if (Changed)
2035	return (CondOpInit::get(NewConds, NewVals,
2036	getValType()))->Fold(R.getCurrentRecord());
2037
2038	return const_cast<CondOpInit *>(this);
2039	}
2040
2041	Init CondOpInit::Fold(Record CurRec) const {
2042	for ( unsigned i = 0; i < NumConds; ++i) {
2043	Init *Cond = getCond(i);
2044	Init *Val = getVal(i);
2045
2046	if (IntInit *CondI = dyn_cast_or_null<IntInit>(
2047	Cond->convertInitializerTo(IntRecTy::get()))) {
2048	if (CondI->getValue())
2049	return Val->convertInitializerTo(getValType());
2050	} else
2051	return const_cast<CondOpInit *>(this);
2052	}
2053
2054	PrintFatalError(CurRec->getLoc(),
2055	CurRec->getName() +
2056	" does not have any true condition in:" +
2057	this->getAsString());
2058	return nullptr;
2059	}
2060
2061	bool CondOpInit::isConcrete() const {
2062	for (const Init *Case : getConds())
2063	if (!Case->isConcrete())
2064	return false;
2065
2066	for (const Init *Val : getVals())
2067	if (!Val->isConcrete())
2068	return false;
2069
2070	return true;
2071	}
2072
2073	bool CondOpInit::isComplete() const {
2074	for (const Init *Case : getConds())
2075	if (!Case->isComplete())
2076	return false;
2077
2078	for (const Init *Val : getVals())
2079	if (!Val->isConcrete())
2080	return false;
2081
2082	return true;
2083	}
2084
2085	std::string CondOpInit::getAsString() const {
2086	std::string Result = "!cond(";
2087	for (unsigned i = 0; i < getNumConds(); i++) {
2088	Result += getCond(i)->getAsString() + ": ";
2089	Result += getVal(i)->getAsString();
2090	if (i != getNumConds()-1)
2091	Result += ", ";
2092	}
2093	return Result + ")";
2094	}
2095
2096	Init *CondOpInit::getBit(unsigned Bit) const {
2097	return VarBitInit::get(const_cast<CondOpInit *>(this), Bit);
2098	}
2099
2100	static void ProfileDagInit(FoldingSetNodeID &ID, Init V, StringInit VN,
2101	ArrayRef<Init *> ArgRange,
2102	ArrayRef<StringInit *> NameRange) {
2103	ID.AddPointer(V);
2104	ID.AddPointer(VN);
2105
2106	ArrayRef<Init *>::iterator Arg = ArgRange.begin();
2107	ArrayRef<StringInit *>::iterator Name = NameRange.begin();
2108	while (Arg != ArgRange.end()) {
2109	assert(Name != NameRange.end() && "Arg name underflow!")((void)0);
2110	ID.AddPointer(*Arg++);
2111	ID.AddPointer(*Name++);
2112	}
2113	assert(Name == NameRange.end() && "Arg name overflow!")((void)0);
2114	}
2115
2116	DagInit *
2117	DagInit::get(Init V, StringInit VN, ArrayRef<Init *> ArgRange,
2118	ArrayRef<StringInit *> NameRange) {
2119	static FoldingSet<DagInit> ThePool;
2120
2121	FoldingSetNodeID ID;
2122	ProfileDagInit(ID, V, VN, ArgRange, NameRange);
2123
2124	void *IP = nullptr;
2125	if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
2126	return I;
2127
2128	void Mem = Allocator.Allocate(totalSizeToAlloc<Init , StringInit *>(ArgRange.size(), NameRange.size()), alignof(BitsInit));
2129	DagInit *I = new(Mem) DagInit(V, VN, ArgRange.size(), NameRange.size());
2130	std::uninitialized_copy(ArgRange.begin(), ArgRange.end(),
2131	I->getTrailingObjects<Init *>());
2132	std::uninitialized_copy(NameRange.begin(), NameRange.end(),
2133	I->getTrailingObjects<StringInit *>());
2134	ThePool.InsertNode(I, IP);
2135	return I;
2136	}
2137
2138	DagInit *
2139	DagInit::get(Init V, StringInit VN,
2140	ArrayRef<std::pair<Init, StringInit>> args) {
2141	SmallVector<Init *, 8> Args;
2142	SmallVector<StringInit *, 8> Names;
2143
2144	for (const auto &Arg : args) {
2145	Args.push_back(Arg.first);
2146	Names.push_back(Arg.second);
2147	}
2148
2149	return DagInit::get(V, VN, Args, Names);
2150	}
2151
2152	void DagInit::Profile(FoldingSetNodeID &ID) const {
2153	ProfileDagInit(ID, Val, ValName, makeArrayRef(getTrailingObjects<Init >(), NumArgs), makeArrayRef(getTrailingObjects<StringInit >(), NumArgNames));
2154	}
2155
2156	Record *DagInit::getOperatorAsDef(ArrayRef<SMLoc> Loc) const {
2157	if (DefInit *DefI = dyn_cast<DefInit>(Val))
2158	return DefI->getDef();
2159	PrintFatalError(Loc, "Expected record as operator");
2160	return nullptr;
2161	}
2162
2163	Init *DagInit::resolveReferences(Resolver &R) const {
2164	SmallVector<Init*, 8> NewArgs;
2165	NewArgs.reserve(arg_size());
2166	bool ArgsChanged = false;
2167	for (const Init *Arg : getArgs()) {
2168	Init *NewArg = Arg->resolveReferences(R);
2169	NewArgs.push_back(NewArg);
2170	ArgsChanged \|= NewArg != Arg;
2171	}
2172
2173	Init *Op = Val->resolveReferences(R);
2174	if (Op != Val \|\| ArgsChanged)
2175	return DagInit::get(Op, ValName, NewArgs, getArgNames());
2176
2177	return const_cast<DagInit *>(this);
2178	}
2179
2180	bool DagInit::isConcrete() const {
2181	if (!Val->isConcrete())
2182	return false;
2183	for (const Init *Elt : getArgs()) {
2184	if (!Elt->isConcrete())
2185	return false;
2186	}
2187	return true;
2188	}
2189
2190	std::string DagInit::getAsString() const {
2191	std::string Result = "(" + Val->getAsString();
2192	if (ValName)
2193	Result += ":" + ValName->getAsUnquotedString();
2194	if (!arg_empty()) {
2195	Result += " " + getArg(0)->getAsString();
2196	if (getArgName(0)) Result += ":$" + getArgName(0)->getAsUnquotedString();
2197	for (unsigned i = 1, e = getNumArgs(); i != e; ++i) {
2198	Result += ", " + getArg(i)->getAsString();
2199	if (getArgName(i)) Result += ":$" + getArgName(i)->getAsUnquotedString();
2200	}
2201	}
2202	return Result + ")";
2203	}
2204
2205	//===----------------------------------------------------------------------===//
2206	// Other implementations
2207	//===----------------------------------------------------------------------===//
2208
2209	RecordVal::RecordVal(Init N, RecTy T, FieldKind K)
2210	: Name(N), TyAndKind(T, K) {
2211	setValue(UnsetInit::get());
2212	assert(Value && "Cannot create unset value for current type!")((void)0);
2213	}
2214
2215	// This constructor accepts the same arguments as the above, but also
2216	// a source location.
2217	RecordVal::RecordVal(Init N, SMLoc Loc, RecTy T, FieldKind K)
2218	: Name(N), Loc(Loc), TyAndKind(T, K) {
2219	setValue(UnsetInit::get());
2220	assert(Value && "Cannot create unset value for current type!")((void)0);
2221	}
2222
2223	StringRef RecordVal::getName() const {
2224	return cast<StringInit>(getNameInit())->getValue();
2225	}
2226
2227	std::string RecordVal::getPrintType() const {
2228	if (getType() == StringRecTy::get()) {
2229	if (auto *StrInit = dyn_cast<StringInit>(Value)) {
2230	if (StrInit->hasCodeFormat())
2231	return "code";
2232	else
2233	return "string";
2234	} else {
2235	return "string";
2236	}
2237	} else {
2238	return TyAndKind.getPointer()->getAsString();
2239	}
2240	}
2241
2242	bool RecordVal::setValue(Init *V) {
2243	if (V) {
2244	Value = V->getCastTo(getType());
2245	if (Value) {
2246	assert(!isa<TypedInit>(Value) \|\|((void)0)
2247	cast<TypedInit>(Value)->getType()->typeIsA(getType()))((void)0);
2248	if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
2249	if (!isa<BitsInit>(Value)) {
2250	SmallVector<Init *, 64> Bits;
2251	Bits.reserve(BTy->getNumBits());
2252	for (unsigned I = 0, E = BTy->getNumBits(); I < E; ++I)
2253	Bits.push_back(Value->getBit(I));
2254	Value = BitsInit::get(Bits);
2255	}
2256	}
2257	}
2258	return Value == nullptr;
2259	}
2260	Value = nullptr;
2261	return false;
2262	}
2263
2264	// This version of setValue takes a source location and resets the
2265	// location in the RecordVal.
2266	bool RecordVal::setValue(Init *V, SMLoc NewLoc) {
2267	Loc = NewLoc;
2268	if (V) {
2269	Value = V->getCastTo(getType());
2270	if (Value) {
2271	assert(!isa<TypedInit>(Value) \|\|((void)0)
2272	cast<TypedInit>(Value)->getType()->typeIsA(getType()))((void)0);
2273	if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
2274	if (!isa<BitsInit>(Value)) {
2275	SmallVector<Init *, 64> Bits;
2276	Bits.reserve(BTy->getNumBits());
2277	for (unsigned I = 0, E = BTy->getNumBits(); I < E; ++I)
2278	Bits.push_back(Value->getBit(I));
2279	Value = BitsInit::get(Bits);
2280	}
2281	}
2282	}
2283	return Value == nullptr;
2284	}
2285	Value = nullptr;
2286	return false;
2287	}
2288
2289	#include "llvm/TableGen/Record.h"
2290	#if !defined(NDEBUG1) \|\| defined(LLVM_ENABLE_DUMP)
2291	LLVM_DUMP_METHOD__attribute__((noinline)) void RecordVal::dump() const { errs() << *this; }
2292	#endif
2293
2294	void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
2295	if (isNonconcreteOK()) OS << "field ";
2296	OS << getPrintType() << " " << getNameInitAsString();
2297
2298	if (getValue())
2299	OS << " = " << *getValue();
2300
2301	if (PrintSem) OS << ";\n";
2302	}
2303
2304	unsigned Record::LastID = 0;
2305
2306	void Record::checkName() {
2307	// Ensure the record name has string type.
2308	const TypedInit *TypedName = cast<const TypedInit>(Name);
2309	if (!isa<StringRecTy>(TypedName->getType()))
2310	PrintFatalError(getLoc(), Twine("Record name '") + Name->getAsString() +
2311	"' is not a string!");
2312	}
2313
2314	RecordRecTy *Record::getType() {
2315	SmallVector<Record *, 4> DirectSCs;
2316	getDirectSuperClasses(DirectSCs);
2317	return RecordRecTy::get(DirectSCs);
2318	}
2319
2320	DefInit *Record::getDefInit() {
2321	if (!CorrespondingDefInit)
2322	CorrespondingDefInit = new (Allocator) DefInit(this);
2323	return CorrespondingDefInit;
2324	}
2325
2326	void Record::setName(Init *NewName) {
2327	Name = NewName;
2328	checkName();
2329	// DO NOT resolve record values to the name at this point because
2330	// there might be default values for arguments of this def. Those
2331	// arguments might not have been resolved yet so we don't want to
2332	// prematurely assume values for those arguments were not passed to
2333	// this def.
2334	//
2335	// Nonetheless, it may be that some of this Record's values
2336	// reference the record name. Indeed, the reason for having the
2337	// record name be an Init is to provide this flexibility. The extra
2338	// resolve steps after completely instantiating defs takes care of
2339	// this. See TGParser::ParseDef and TGParser::ParseDefm.
2340	}
2341
2342	// NOTE for the next two functions:
2343	// Superclasses are in post-order, so the final one is a direct
2344	// superclass. All of its transitive superclases immediately precede it,
2345	// so we can step through the direct superclasses in reverse order.
2346
2347	bool Record::hasDirectSuperClass(const Record *Superclass) const {
2348	ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses();
2349
2350	for (int I = SCs.size() - 1; I >= 0; --I) {
2351	const Record *SC = SCs[I].first;
2352	if (SC == Superclass)
2353	return true;
2354	I -= SC->getSuperClasses().size();
2355	}
2356
2357	return false;
2358	}
2359
2360	void Record::getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const {
2361	ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses();
2362
2363	while (!SCs.empty()) {
2364	Record *SC = SCs.back().first;
2365	SCs = SCs.drop_back(1 + SC->getSuperClasses().size());
2366	Classes.push_back(SC);
2367	}
2368	}
2369
2370	void Record::resolveReferences(Resolver &R, const RecordVal *SkipVal) {
2371	Init *OldName = getNameInit();
2372	Init *NewName = Name->resolveReferences(R);
2373	if (NewName != OldName) {
2374	// Re-register with RecordKeeper.
2375	setName(NewName);
2376	}
2377
2378	// Resolve the field values.
2379	for (RecordVal &Value : Values) {
2380	if (SkipVal == &Value) // Skip resolve the same field as the given one
2381	continue;
2382	if (Init *V = Value.getValue()) {
2383	Init *VR = V->resolveReferences(R);
2384	if (Value.setValue(VR)) {
2385	std::string Type;
2386	if (TypedInit *VRT = dyn_cast<TypedInit>(VR))
2387	Type =
2388	(Twine("of type '") + VRT->getType()->getAsString() + "' ").str();
2389	PrintFatalError(
2390	getLoc(),
2391	Twine("Invalid value ") + Type + "found when setting field '" +
2392	Value.getNameInitAsString() + "' of type '" +
2393	Value.getType()->getAsString() +
2394	"' after resolving references: " + VR->getAsUnquotedString() +
2395	"\n");
2396	}
2397	}
2398	}
2399
2400	// Resolve the assertion expressions.
2401	for (auto &Assertion : Assertions) {
2402	Init *Value = Assertion.Condition->resolveReferences(R);
2403	Assertion.Condition = Value;
2404	Value = Assertion.Message->resolveReferences(R);
2405	Assertion.Message = Value;
2406	}
2407	}
2408
2409	void Record::resolveReferences(Init *NewName) {
2410	RecordResolver R(*this);
2411	R.setName(NewName);
2412	R.setFinal(true);
2413	resolveReferences(R);
2414	}
2415
2416	#if !defined(NDEBUG1) \|\| defined(LLVM_ENABLE_DUMP)
2417	LLVM_DUMP_METHOD__attribute__((noinline)) void Record::dump() const { errs() << *this; }
2418	#endif
2419
2420	raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
2421	OS << R.getNameInitAsString();
2422
2423	ArrayRef<Init *> TArgs = R.getTemplateArgs();
2424	if (!TArgs.empty()) {
2425	OS << "<";
2426	bool NeedComma = false;
2427	for (const Init *TA : TArgs) {
2428	if (NeedComma) OS << ", ";
2429	NeedComma = true;
2430	const RecordVal *RV = R.getValue(TA);
2431	assert(RV && "Template argument record not found??")((void)0);
2432	RV->print(OS, false);
2433	}
2434	OS << ">";
2435	}
2436
2437	OS << " {";
2438	ArrayRef<std::pair<Record *, SMRange>> SC = R.getSuperClasses();
2439	if (!SC.empty()) {
2440	OS << "\t//";
2441	for (const auto &SuperPair : SC)
2442	OS << " " << SuperPair.first->getNameInitAsString();
2443	}
2444	OS << "\n";
2445
2446	for (const RecordVal &Val : R.getValues())
2447	if (Val.isNonconcreteOK() && !R.isTemplateArg(Val.getNameInit()))
2448	OS << Val;
2449	for (const RecordVal &Val : R.getValues())
2450	if (!Val.isNonconcreteOK() && !R.isTemplateArg(Val.getNameInit()))
2451	OS << Val;
2452
2453	return OS << "}\n";
2454	}
2455
2456	SMLoc Record::getFieldLoc(StringRef FieldName) const {
2457	const RecordVal *R = getValue(FieldName);
2458	if (!R)
2459	PrintFatalError(getLoc(), "Record `" + getName() +
2460	"' does not have a field named `" + FieldName + "'!\n");
2461	return R->getLoc();
2462	}
2463
2464	Init *Record::getValueInit(StringRef FieldName) const {
2465	const RecordVal *R = getValue(FieldName);
2466	if (!R \|\| !R->getValue())
2467	PrintFatalError(getLoc(), "Record `" + getName() +
2468	"' does not have a field named `" + FieldName + "'!\n");
2469	return R->getValue();
2470	}
2471
2472	StringRef Record::getValueAsString(StringRef FieldName) const {
2473	llvm::Optional<StringRef> S = getValueAsOptionalString(FieldName);
2474	if (!S.hasValue())
2475	PrintFatalError(getLoc(), "Record `" + getName() +
2476	"' does not have a field named `" + FieldName + "'!\n");
2477	return S.getValue();
2478	}
2479
2480	llvm::Optional<StringRef>
2481	Record::getValueAsOptionalString(StringRef FieldName) const {
2482	const RecordVal *R = getValue(FieldName);
2483	if (!R \|\| !R->getValue())
2484	return llvm::Optional<StringRef>();
2485	if (isa<UnsetInit>(R->getValue()))
2486	return llvm::Optional<StringRef>();
2487
2488	if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
2489	return SI->getValue();
2490
2491	PrintFatalError(getLoc(),
2492	"Record `" + getName() + "', ` field `" + FieldName +
2493	"' exists but does not have a string initializer!");
2494	}
2495
2496	BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
2497	const RecordVal *R = getValue(FieldName);
2498	if (!R \|\| !R->getValue())
2499	PrintFatalError(getLoc(), "Record `" + getName() +
2500	"' does not have a field named `" + FieldName + "'!\n");
2501
2502	if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue()))
2503	return BI;
2504	PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName +
2505	"' exists but does not have a bits value");
2506	}
2507
2508	ListInit *Record::getValueAsListInit(StringRef FieldName) const {
2509	const RecordVal *R = getValue(FieldName);
2510	if (!R \|\| !R->getValue())
2511	PrintFatalError(getLoc(), "Record `" + getName() +
2512	"' does not have a field named `" + FieldName + "'!\n");
2513
2514	if (ListInit *LI = dyn_cast<ListInit>(R->getValue()))
2515	return LI;
2516	PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName +
2517	"' exists but does not have a list value");
2518	}
2519
2520	std::vector<Record*>
2521	Record::getValueAsListOfDefs(StringRef FieldName) const {
2522	ListInit *List = getValueAsListInit(FieldName);
2523	std::vector<Record*> Defs;
2524	for (Init *I : List->getValues()) {
2525	if (DefInit *DI = dyn_cast<DefInit>(I))
2526	Defs.push_back(DI->getDef());
2527	else
2528	PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2529	FieldName + "' list is not entirely DefInit!");
2530	}
2531	return Defs;
2532	}
2533
2534	int64_t Record::getValueAsInt(StringRef FieldName) const {
2535	const RecordVal *R = getValue(FieldName);
2536	if (!R \|\| !R->getValue())
2537	PrintFatalError(getLoc(), "Record `" + getName() +
2538	"' does not have a field named `" + FieldName + "'!\n");
2539
2540	if (IntInit *II = dyn_cast<IntInit>(R->getValue()))
2541	return II->getValue();
2542	PrintFatalError(getLoc(), Twine("Record `") + getName() + "', field `" +
2543	FieldName +
2544	"' exists but does not have an int value: " +
2545	R->getValue()->getAsString());
2546	}
2547
2548	std::vector<int64_t>
2549	Record::getValueAsListOfInts(StringRef FieldName) const {
2550	ListInit *List = getValueAsListInit(FieldName);
2551	std::vector<int64_t> Ints;
2552	for (Init *I : List->getValues()) {
2553	if (IntInit *II = dyn_cast<IntInit>(I))
2554	Ints.push_back(II->getValue());
2555	else
2556	PrintFatalError(getLoc(),
2557	Twine("Record `") + getName() + "', field `" + FieldName +
2558	"' exists but does not have a list of ints value: " +
2559	I->getAsString());
2560	}
2561	return Ints;
2562	}
2563
2564	std::vector<StringRef>
2565	Record::getValueAsListOfStrings(StringRef FieldName) const {
2566	ListInit *List = getValueAsListInit(FieldName);
2567	std::vector<StringRef> Strings;
2568	for (Init *I : List->getValues()) {
2569	if (StringInit *SI = dyn_cast<StringInit>(I))
2570	Strings.push_back(SI->getValue());
2571	else
2572	PrintFatalError(getLoc(),
2573	Twine("Record `") + getName() + "', field `" + FieldName +
2574	"' exists but does not have a list of strings value: " +
2575	I->getAsString());
2576	}
2577	return Strings;
2578	}
2579
2580	Record *Record::getValueAsDef(StringRef FieldName) const {
2581	const RecordVal *R = getValue(FieldName);
2582	if (!R \|\| !R->getValue())
2583	PrintFatalError(getLoc(), "Record `" + getName() +
2584	"' does not have a field named `" + FieldName + "'!\n");
2585
2586	if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
2587	return DI->getDef();
2588	PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2589	FieldName + "' does not have a def initializer!");
2590	}
2591
2592	Record *Record::getValueAsOptionalDef(StringRef FieldName) const {
2593	const RecordVal *R = getValue(FieldName);
2594	if (!R \|\| !R->getValue())
2595	PrintFatalError(getLoc(), "Record `" + getName() +
2596	"' does not have a field named `" + FieldName + "'!\n");
2597
2598	if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
2599	return DI->getDef();
2600	if (isa<UnsetInit>(R->getValue()))
2601	return nullptr;
2602	PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2603	FieldName + "' does not have either a def initializer or '?'!");
2604	}
2605
2606
2607	bool Record::getValueAsBit(StringRef FieldName) const {
2608	const RecordVal *R = getValue(FieldName);
2609	if (!R \|\| !R->getValue())
2610	PrintFatalError(getLoc(), "Record `" + getName() +
2611	"' does not have a field named `" + FieldName + "'!\n");
2612
2613	if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
2614	return BI->getValue();
2615	PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2616	FieldName + "' does not have a bit initializer!");
2617	}
2618
2619	bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const {
2620	const RecordVal *R = getValue(FieldName);
2621	if (!R \|\| !R->getValue())
2622	PrintFatalError(getLoc(), "Record `" + getName() +
2623	"' does not have a field named `" + FieldName.str() + "'!\n");
2624
2625	if (isa<UnsetInit>(R->getValue())) {
2626	Unset = true;
2627	return false;
2628	}
2629	Unset = false;
2630	if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
2631	return BI->getValue();
2632	PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2633	FieldName + "' does not have a bit initializer!");
2634	}
2635
2636	DagInit *Record::getValueAsDag(StringRef FieldName) const {
2637	const RecordVal *R = getValue(FieldName);
2638	if (!R \|\| !R->getValue())
2639	PrintFatalError(getLoc(), "Record `" + getName() +
2640	"' does not have a field named `" + FieldName + "'!\n");
2641
2642	if (DagInit *DI = dyn_cast<DagInit>(R->getValue()))
2643	return DI;
2644	PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
2645	FieldName + "' does not have a dag initializer!");
2646	}
2647
2648	// Check all record assertions: For each one, resolve the condition
2649	// and message, then call CheckAssert().
2650	// Note: The condition and message are probably already resolved,
2651	// but resolving again allows calls before records are resolved.
2652	void Record::checkRecordAssertions() {
2653	RecordResolver R(*this);
2654	R.setFinal(true);
2655
2656	for (auto Assertion : getAssertions()) {
2657	Init *Condition = Assertion.Condition->resolveReferences(R);
2658	Init *Message = Assertion.Message->resolveReferences(R);
2659	CheckAssert(Assertion.Loc, Condition, Message);
2660	}
2661	}
2662
2663	#if !defined(NDEBUG1) \|\| defined(LLVM_ENABLE_DUMP)
2664	LLVM_DUMP_METHOD__attribute__((noinline)) void RecordKeeper::dump() const { errs() << *this; }
2665	#endif
2666
2667	raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
2668	OS << "------------- Classes -----------------\n";
2669	for (const auto &C : RK.getClasses())
2670	OS << "class " << *C.second;
2671
2672	OS << "------------- Defs -----------------\n";
2673	for (const auto &D : RK.getDefs())
2674	OS << "def " << *D.second;
2675	return OS;
2676	}
2677
2678	/// GetNewAnonymousName - Generate a unique anonymous name that can be used as
2679	/// an identifier.
2680	Init *RecordKeeper::getNewAnonymousName() {
2681	return AnonymousNameInit::get(AnonCounter++);
2682	}
2683
2684	// These functions implement the phase timing facility. Starting a timer
2685	// when one is already running stops the running one.
2686
2687	void RecordKeeper::startTimer(StringRef Name) {
2688	if (TimingGroup) {
2689	if (LastTimer && LastTimer->isRunning()) {
2690	LastTimer->stopTimer();
2691	if (BackendTimer) {
2692	LastTimer->clear();
2693	BackendTimer = false;
2694	}
2695	}
2696
2697	LastTimer = new Timer("", Name, *TimingGroup);
2698	LastTimer->startTimer();
2699	}
2700	}
2701
2702	void RecordKeeper::stopTimer() {
2703	if (TimingGroup) {
2704	assert(LastTimer && "No phase timer was started")((void)0);
2705	LastTimer->stopTimer();
2706	}
2707	}
2708
2709	void RecordKeeper::startBackendTimer(StringRef Name) {
2710	if (TimingGroup) {
2711	startTimer(Name);
2712	BackendTimer = true;
2713	}
2714	}
2715
2716	void RecordKeeper::stopBackendTimer() {
2717	if (TimingGroup) {
2718	if (BackendTimer) {
2719	stopTimer();
2720	BackendTimer = false;
2721	}
2722	}
2723	}
2724
2725	// We cache the record vectors for single classes. Many backends request
2726	// the same vectors multiple times.
2727	std::vector<Record *> RecordKeeper::getAllDerivedDefinitions(
2728	StringRef ClassName) const {
2729
2730	auto Pair = ClassRecordsMap.try_emplace(ClassName);
2731	if (Pair.second)
2732	Pair.first->second = getAllDerivedDefinitions(makeArrayRef(ClassName));
2733
2734	return Pair.first->second;
2735	}
2736
2737	std::vector<Record *> RecordKeeper::getAllDerivedDefinitions(
2738	ArrayRef<StringRef> ClassNames) const {
2739	SmallVector<Record *, 2> ClassRecs;
2740	std::vector<Record *> Defs;
2741
2742	assert(ClassNames.size() > 0 && "At least one class must be passed.")((void)0);
2743	for (const auto &ClassName : ClassNames) {
2744	Record *Class = getClass(ClassName);
2745	if (!Class)
2746	PrintFatalError("The class '" + ClassName + "' is not defined\n");
2747	ClassRecs.push_back(Class);
2748	}
2749
2750	for (const auto &OneDef : getDefs()) {
2751	if (all_of(ClassRecs, [&OneDef](const Record *Class) {
2752	return OneDef.second->isSubClassOf(Class);
2753	}))
2754	Defs.push_back(OneDef.second.get());
2755	}
2756
2757	return Defs;
2758	}
2759
2760	Init MapResolver::resolve(Init VarName) {
2761	auto It = Map.find(VarName);
2762	if (It == Map.end())
2763	return nullptr;
2764
2765	Init *I = It->second.V;
2766
2767	if (!It->second.Resolved && Map.size() > 1) {
2768	// Resolve mutual references among the mapped variables, but prevent
2769	// infinite recursion.
2770	Map.erase(It);
2771	I = I->resolveReferences(*this);
2772	Map[VarName] = {I, true};
2773	}
2774
2775	return I;
2776	}
2777
2778	Init RecordResolver::resolve(Init VarName) {
2779	Init *Val = Cache.lookup(VarName);
2780	if (Val)
2781	return Val;
2782
2783	if (llvm::is_contained(Stack, VarName))
2784	return nullptr; // prevent infinite recursion
2785
2786	if (RecordVal *RV = getCurrentRecord()->getValue(VarName)) {
2787	if (!isa<UnsetInit>(RV->getValue())) {
2788	Val = RV->getValue();
2789	Stack.push_back(VarName);
2790	Val = Val->resolveReferences(*this);
2791	Stack.pop_back();
2792	}
2793	} else if (Name && VarName == getCurrentRecord()->getNameInit()) {
2794	Stack.push_back(VarName);
2795	Val = Name->resolveReferences(*this);
2796	Stack.pop_back();
2797	}
2798
2799	Cache[VarName] = Val;
2800	return Val;
2801	}
2802
2803	Init TrackUnresolvedResolver::resolve(Init VarName) {
2804	Init *I = nullptr;
2805
2806	if (R) {
2807	I = R->resolve(VarName);
2808	if (I && !FoundUnresolved) {
2809	// Do not recurse into the resolved initializer, as that would change
2810	// the behavior of the resolver we're delegating, but do check to see
2811	// if there are unresolved variables remaining.
2812	TrackUnresolvedResolver Sub;
2813	I->resolveReferences(Sub);
2814	FoundUnresolved \|= Sub.FoundUnresolved;
2815	}
2816	}
2817
2818	if (!I)
2819	FoundUnresolved = true;
2820	return I;
2821	}
2822
2823	Init HasReferenceResolver::resolve(Init VarName)
2824	{
2825	if (VarName == VarNameToTrack)
2826	Found = true;
2827	return nullptr;
2828	}