|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/TableGen/Record.h 43 class Record;
include/llvm/TableGen/SetTheory.h 62 class Record;
lib/TableGen/TGParser.h 24 class Record;
tools/lldb/utils/TableGen/LLDBTableGenBackends.h 24 class Record;
tools/lldb/utils/TableGen/LLDBTableGenUtils.h 19 class Record;
utils/TableGen/AsmWriterInst.h 24 class Record;
utils/TableGen/CodeGenDAGPatterns.h 37 class Record;
utils/TableGen/CodeGenHwModes.h 22 class Record;
utils/TableGen/CodeGenInstruction.h 25 class Record;
utils/TableGen/CodeGenIntrinsics.h 22 class Record;
utils/TableGen/DAGISelMatcher.h 25 class Record;
utils/TableGen/InfoByHwMode.h 28 class Record;
utils/TableGen/SDNodeProperties.h 14 class Record;
utils/TableGen/SubtargetFeatureInfo.h 20 class Record;
References
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
127 ArrayRef(const std::vector<U *, A> &Vec,
129 std::is_convertible<U *const *, T const *>::value>::type* = 0)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/TableGen/Record.h 238 public TrailingObjects<RecordRecTy, Record *> {
258 static RecordRecTy *get(ArrayRef<Record *> Classes);
262 ArrayRef<Record *> getClasses() const {
263 return makeArrayRef(getTrailingObjects<Record *>(), NumClasses);
266 using const_record_iterator = Record * const *;
273 bool isSubClassOf(Record *Class) const;
694 Record *getElementAsRecord(unsigned i) const;
793 Init *Fold(Record *CurRec, bool IsFinal = false) const;
851 Init *Fold(Record *CurRec) const;
909 Init *Fold(Record *CurRec) const;
971 Init *Fold(Record *CurRec) const;
1023 Init *Fold(Record *CurRec) const;
1177 Record *Def;
1179 explicit DefInit(Record *D);
1189 static DefInit *get(Record*);
1193 Record *getDef() const { return Def; }
1211 Record *Class;
1215 explicit VarDefInit(Record *Class, unsigned N)
1230 static VarDefInit *get(Record *Class, ArrayRef<Init *> Args);
1292 Init *Fold(Record *CurRec) const;
1333 Record *getOperatorAsDef(ArrayRef<SMLoc> Loc) const;
1439 SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses;
1470 Record(const Record &O)
1509 ArrayRef<std::pair<Record *, SMRange>> getSuperClasses() const {
1514 void getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const;
1563 bool isSubClassOf(const Record *R) const {
1582 void addSuperClass(Record *R, SMRange Range) {
1649 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1664 Record *getValueAsDef(StringRef FieldName) const;
1670 Record *getValueAsOptionalDef(StringRef FieldName) const;
1693 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1697 using RecordMap = std::map<std::string, std::unique_ptr<Record>, std::less<>>;
1707 Record *getClass(StringRef Name) const {
1712 Record *getDef(StringRef Name) const {
1718 if (Record *R = getDef(Name))
1724 void addClass(std::unique_ptr<Record> R) {
1731 void addDef(std::unique_ptr<Record> R) {
1753 std::vector<Record *> getAllDerivedDefinitions(StringRef ClassName) const;
1760 bool operator()(const Record *Rec1, const Record *Rec2) const {
1760 bool operator()(const Record *Rec1, const Record *Rec2) const {
1770 bool operator()(const Record *LHS, const Record *RHS) const {
1770 bool operator()(const Record *LHS, const Record *RHS) const {
1778 bool operator()(const Record *Rec1, const Record *Rec2) const {
1778 bool operator()(const Record *Rec1, const Record *Rec2) const {
1818 bool operator()(const Record *Rec1, const Record *Rec2) const {
1818 bool operator()(const Record *Rec1, const Record *Rec2) const {
1871 Record *CurRec;
1875 explicit Resolver(Record *CurRec) : CurRec(CurRec) {}
1878 Record *getCurrentRecord() const { return CurRec; }
1910 explicit MapResolver(Record *CurRec = nullptr) : Resolver(CurRec) {}
1923 explicit RecordResolver(Record &R) : Resolver(&R) {}
1939 explicit RecordValResolver(Record &R, const RecordVal *RV)
include/llvm/TableGen/SetTheory.h 66 using RecVec = std::vector<Record *>;
67 using RecSet = SmallSetVector<Record *, 16>;
91 virtual void expand(SetTheory&, Record*, RecSet &Elts) = 0;
97 using ExpandMap = std::map<Record *, RecVec>;
139 const RecVec *expand(Record *Set);
lib/TableGen/JSONBackend.cpp 32 json::Array listSuperclasses(const Record &R);
142 auto &Def = *D.second;
lib/TableGen/Record.cpp 151 ArrayRef<Record *> Classes) {
153 for (Record *R : Classes)
157 RecordRecTy *RecordRecTy::get(ArrayRef<Record *> UnsortedClasses) {
166 SmallVector<Record *, 4> Classes(UnsortedClasses.begin(),
189 void *Mem = Allocator.Allocate(totalSizeToAlloc<Record *>(Classes.size()),
193 Ty->getTrailingObjects<Record *>());
208 for (Record *R : getClasses()) {
218 bool RecordRecTy::isSubClassOf(Record *Class) const {
243 SmallVector<Record *, 4> CommonSuperClasses;
244 SmallVector<Record *, 4> Stack;
249 Record *R = Stack.back();
637 Record *ListInit::getElementAsRecord(unsigned i) const {
712 Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
729 Record *D;
882 Init *BinOpInit::Fold(Record *CurRec) const {
1074 static Init *ForeachApply(Init *LHS, Init *MHSe, Init *RHS, Record *CurRec) {
1081 Record *CurRec) {
1110 Record *CurRec) {
1128 Init *TernOpInit::Fold(Record *CurRec) const {
1144 Record *Val = RHSd->getDef();
1292 Init *FoldOpInit::Fold(Record *CurRec) const {
1396 for (Record *Rec : RecordType->getClasses()) {
1559 DefInit::DefInit(Record *D)
1562 DefInit *DefInit::get(Record *R) {
1584 Record *Class,
1593 VarDefInit *VarDefInit::get(Record *Class, ArrayRef<Init *> Args) {
1619 auto NewRecOwner = std::make_unique<Record>(Records.getNewAnonymousName(),
1622 Record *NewRec = NewRecOwner.get();
1644 ArrayRef<std::pair<Record *, SMRange>> SCs = Class->getSuperClasses();
1731 Init *FieldInit::Fold(Record *CurRec) const {
1733 Record *Def = DI->getDef();
1818 Init *CondOpInit::Fold(Record *CurRec) const {
1933 Record *DagInit::getOperatorAsDef(ArrayRef<SMLoc> Loc) const {
2043 SmallVector<Record *, 4> DirectSCs;
2070 void Record::getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const {
2071 ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses();
2075 Record *SC = SCs.back().first;
2125 raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
2143 ArrayRef<std::pair<Record *, SMRange>> SC = R.getSuperClasses();
2208 std::vector<Record*>
2211 std::vector<Record*> Defs;
2268 Record *Record::getValueAsDef(StringRef FieldName) const {
2280 Record *Record::getValueAsOptionalDef(StringRef FieldName) const {
2357 std::vector<Record *>
2359 Record *Class = getClass(ClassName);
2363 std::vector<Record*> Defs;
lib/TableGen/SetTheory.cpp 225 Record *Rec = Records.getDef(OS.str());
246 void expand(SetTheory &ST, Record *Def, RecSet &Elts) override {
308 const RecVec *SetTheory::expand(Record *Set) {
315 ArrayRef<std::pair<Record *, SMRange>> SC = Set->getSuperClasses();
lib/TableGen/TGParser.cpp 38 Record *Rec;
71 static bool checkBitsConcrete(Record &R, const RecordVal &RV) {
90 static void checkConcrete(Record &R) {
114 static Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
131 static Init *QualifiedNameOfImplicitName(Record &Rec,
140 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
159 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
228 bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
229 Record *SC = SubClass.Rec;
276 ArrayRef<std::pair<Record *, SMRange>> SCs = SC->getSuperClasses();
416 auto Rec = std::make_unique<Record>(*E.Rec);
437 bool TGParser::addDefOne(std::unique_ptr<Record> Rec) {
438 if (Record *Prev = Records.getDef(Rec->getNameInitAsString())) {
507 Record *CurRec = nullptr;
532 Record *TGParser::ParseClassID() {
538 Record *Result = Records.getClass(Lex.getCurStrVal());
578 ParseSubClassReference(Record *CurRec, bool isDefm) {
806 if (Record *R = ParseClassID()) return RecordRecTy::get(R);
847 Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
862 Record *TemplateRec = CurMultiClass ? &CurMultiClass->Rec : CurRec;
899 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
1330 std::unique_ptr<Record> ParseRecTmp;
1331 Record *ParseRec = CurRec;
1333 ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
1597 std::unique_ptr<Record> ParseRecTmp;
1598 Record *ParseRec = CurRec;
1600 ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
1667 Init *TGParser::ParseOperationCond(Record *CurRec, RecTy *ItemType) {
1773 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
1829 Record *Class = Records.getClass(Name->getValue());
2104 Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
2267 Record *CurRec) {
2309 void TGParser::ParseValueList(SmallVectorImpl<Init*> &Result, Record *CurRec,
2310 Record *ArgsRec, RecTy *EltTy) {
2372 Init *TGParser::ParseDeclaration(Record *CurRec,
2519 bool TGParser::ParseTemplateArgList(Record *CurRec) {
2523 Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec;
2558 bool TGParser::ParseBodyItem(Record *CurRec) {
2609 bool TGParser::ParseBody(Record *CurRec) {
2632 bool TGParser::ApplyLetStack(Record *CurRec) {
2661 bool TGParser::ParseObjectBody(Record *CurRec) {
2699 std::unique_ptr<Record> CurRec;
2705 CurRec = std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records,
2708 CurRec = std::make_unique<Record>(Name, DefLoc, Records);
2826 Record *CurRec = Records.getClass(Lex.getCurStrVal());
2837 std::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records,
lib/TableGen/TGParser.h 46 std::unique_ptr<Record> Rec;
52 RecordsEntry(std::unique_ptr<Record> Rec) : Rec(std::move(Rec)) {}
78 Record Rec; // Placeholder for template args and Name.
137 bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
138 bool SetValue(Record *TheRec, SMLoc Loc, Init *ValName,
141 bool AddSubClass(Record *Rec, SubClassReference &SubClass);
154 bool addDefOne(std::unique_ptr<Record> Rec);
168 bool ParseObjectBody(Record *CurRec);
169 bool ParseBody(Record *CurRec);
170 bool ParseBodyItem(Record *CurRec);
172 bool ParseTemplateArgList(Record *CurRec);
173 Init *ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs);
176 SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
179 Init *ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
181 Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = nullptr,
183 Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr,
185 void ParseValueList(SmallVectorImpl<llvm::Init*> &Result, Record *CurRec,
186 Record *ArgsRec = nullptr, RecTy *EltTy = nullptr);
189 Record *CurRec);
196 Init *ParseOperation(Record *CurRec, RecTy *ItemType);
197 Init *ParseOperationCond(Record *CurRec, RecTy *ItemType);
200 Record *ParseClassID();
202 bool ApplyLetStack(Record *CurRec);
tools/clang/utils/TableGen/ClangASTNodesEmitter.cpp 31 typedef std::multimap<Record*, Record*> ChildMap;
31 typedef std::multimap<Record*, Record*> ChildMap;
35 Record *Root = nullptr;
59 std::string baseName(Record &R) {
68 std::pair<Record *, Record *> EmitNode(raw_ostream& OS, Record *Base);
68 std::pair<Record *, Record *> EmitNode(raw_ostream& OS, Record *Base);
68 std::pair<Record *, Record *> EmitNode(raw_ostream& OS, Record *Base);
85 std::pair<Record *, Record *> ClangASTNodesEmitter::EmitNode(raw_ostream &OS,
85 std::pair<Record *, Record *> ClangASTNodesEmitter::EmitNode(raw_ostream &OS,
86 Record *Base) {
91 Record *First = nullptr, *Last = nullptr;
96 Record *R = i->second;
113 const std::pair<Record *, Record *> &Result
113 const std::pair<Record *, Record *> &Result
148 const std::vector<Record*> Stmts
152 Record *R = Stmts[i];
218 typedef std::set<Record*> RecordSet;
219 typedef std::vector<Record*> RecordVector;
227 Record *R = *i;
229 if (Record *B = R->getValueAsOptionalDef(BaseFieldName)) {
tools/clang/utils/TableGen/ClangAttrEmitter.cpp 57 explicit FlattenedSpelling(const Record &Spelling) :
78 GetFlattenedSpellings(const Record &Attr) {
79 std::vector<Record *> Spellings = Attr.getValueAsListOfDefs("Spellings");
158 typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
162 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
165 for (const auto *Attr : Attrs) {
198 Argument(const Record &Arg, StringRef Attr)
257 SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
368 DefaultSimpleArgument(const Record &Arg, StringRef Attr,
387 StringArgument(const Record &Arg, StringRef Attr)
468 AlignedArgument(const Record &Arg, StringRef Attr)
642 VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
772 VariadicParamIdxArgument(const Record &Arg, StringRef Attr)
786 VariadicParamOrParamIdxArgument(const Record &Arg, StringRef Attr)
807 EnumArgument(const Record &Arg, StringRef Attr)
936 VariadicEnumArgument(const Record &Arg, StringRef Attr)
1032 VersionArgument(const Record &Arg, StringRef Attr)
1094 ExprArgument(const Record &Arg, StringRef Attr)
1131 VariadicExprArgument(const Record &Arg, StringRef Attr)
1190 VariadicIdentifierArgument(const Record &Arg, StringRef Attr)
1197 VariadicStringArgument(const Record &Arg, StringRef Attr)
1220 TypeArgument(const Record &Arg, StringRef Attr)
1252 createArgument(const Record &Arg, StringRef Attr,
1253 const Record *Search = nullptr) {
1309 ArrayRef<std::pair<Record*, SMRange>> Bases = Search->getSuperClasses();
1344 static void writeGetSpellingFunction(Record &R, raw_ostream &OS) {
1368 writePrettyPrintFunction(Record &R,
1553 static void writeAttrAccessorDefinition(const Record &R, raw_ostream &OS) {
1554 std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
1561 for (const auto *Accessor : Accessors) {
1660 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1662 for (const auto *Attr : Attrs) {
1679 static bool hasGNUorCXX11Spelling(const Record &Attribute) {
1691 const Record *MetaSubject;
1692 const Record *Constraint;
1694 AttributeSubjectMatchRule(const Record *MetaSubject, const Record *Constraint)
1694 AttributeSubjectMatchRule(const Record *MetaSubject, const Record *Constraint)
1701 std::vector<Record *> getSubjects() const {
1706 std::vector<Record *> getLangOpts() const {
1710 std::vector<Record *> Opts = Constraint->getValueAsListOfDefs("LangOpts");
1796 llvm::DenseMap<const Record *, RuleOrAggregateRuleSet> SubjectsToRules;
1800 bool isAttributedSupported(const Record &Attribute);
1804 std::string generateStrictConformsTo(const Record &Attr, raw_ostream &OS);
1811 static bool doesDeclDeriveFrom(const Record *D, const Record *Base) {
1811 static bool doesDeclDeriveFrom(const Record *D, const Record *Base) {
1812 const Record *CurrentBase = D->getValueAsOptionalDef(BaseFieldName);
1822 std::vector<Record *> MetaSubjects =
1828 std::vector<Record *> ApplicableSubjects =
1830 for (const auto *Subject : ApplicableSubjects) {
1843 for (const auto *MetaSubject : MetaSubjects) {
1845 std::vector<Record *> Constraints =
1847 for (const auto *Constraint : Constraints)
1851 std::vector<Record *> Aggregates =
1853 std::vector<Record *> DeclNodes =
1855 for (const auto *Aggregate : Aggregates) {
1856 Record *SubjectDecl = Aggregate->getValueAsDef("Subject");
1861 for (const auto *D : DeclNodes) {
1910 const Record &Attribute) {
1930 const Record *SubjectObj = Attribute.getValueAsDef("Subjects");
1931 std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
1934 for (const auto *Subject : Subjects) {
1941 static std::string GenerateTestExpression(ArrayRef<Record *> LangOpts) {
1944 for (auto *E : LangOpts) {
1966 PragmaClangAttributeSupport::generateStrictConformsTo(const Record &Attr,
1980 const Record *SubjectObj = Attr.getValueAsDef("Subjects");
1981 std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
1982 for (const auto *Subject : Subjects) {
1989 std::vector<Record *> LangOpts = Rule.getLangOpts();
2006 std::map<const Record *, std::vector<AttributeSubjectMatchRule>>
2091 static void forEachUniqueSpelling(const Record &Attr, Fn &&F) {
2103 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2105 for (const auto *Attr : Attrs) {
2107 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2128 const Record &Attr = *I.second;
2141 static bool isIdentifierArgument(Record *Arg) {
2150 static bool isVariadicIdentifierArgument(Record *Arg) {
2162 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2163 for (const auto *A : Attrs) {
2165 std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
2182 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2184 for (const auto *Attr : Attrs) {
2186 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2198 static bool keywordThisIsaIdentifierInArgument(const Record *Arg) {
2209 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2210 for (const auto *A : Attrs) {
2212 std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
2233 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2236 for (const auto *Attr : Attrs) {
2237 const Record &R = *Attr;
2253 ArrayRef<std::pair<Record *, SMRange>> Supers = R.getSuperClasses();
2258 const Record *R = Super.first;
2268 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2274 for (const auto *ArgRecord : ArgRecords) {
2499 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2501 for (auto *Attr : Attrs) {
2502 Record &R = *Attr;
2507 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2509 for (const auto *Arg : ArgRecords)
2536 for (const auto *Attr : Attrs) {
2537 const Record &R = *Attr;
2562 const std::vector<Record*> &AttrList) {
2569 static bool AttrHasPragmaSpelling(const Record *R) {
2608 Record *TheRecord;
2611 std::vector<Record*> Attrs;
2613 AttrClass(const AttrClassDescriptor &Descriptor, Record *R)
2636 void classifyAttrOnRoot(Record *Attr) {
2648 bool classifyAttr(Record *Attr) {
2664 Record *getFirstAttr() const {
2670 Record *getLastAttr() const {
2685 Record *ClassRecord = Records.getClass(Descriptor.TableGenName);
2728 void classifyAttr(Record *Attr) {
2734 AttrClass *findClassByRecord(Record *R) const {
2742 AttrClass *findSuperClass(Record *R) const {
2768 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2769 std::vector<Record *> PragmaAttrs;
2770 for (auto *Attr : Attrs) {
2813 Record *InhClass = Records.getClass("InheritableAttr");
2814 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
2819 for (const auto *Attr : Attrs) {
2820 const Record &R = *Attr;
2830 for (const auto *Arg : ArgRecords) {
2853 Record *InhClass = Records.getClass("InheritableAttr");
2854 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
2857 for (const auto *Attr : Attrs) {
2858 const Record &R = *Attr;
2870 for (const auto *Arg : Args)
2880 static bool GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test,
2910 static bool GenerateTargetSpecificAttrChecks(const Record *R,
2961 const std::vector<Record *> &Attrs, raw_ostream &OS,
2963 for (const auto *Attr : Attrs) {
2973 std::vector<Record *> Spellings = Attr->getValueAsListOfDefs("Spellings");
2987 const Record *R = Attr->getValueAsDef("Target");
3020 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3021 std::vector<Record *> Declspec, Microsoft, GNU, Pragma;
3022 std::map<std::string, std::vector<Record *>> CXX, C2x;
3026 for (auto *R : Attrs) {
3093 const Record &R = *I.second;
3115 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
3121 for (const auto *Attr : Attrs) {
3122 const Record &R = *Attr;
3135 for (const auto *Attr : Attrs) {
3136 const Record &R = *Attr;
3148 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
3149 for (const auto *Arg : ArgRecords)
3164 for (const auto *Attr : Attrs) {
3165 const Record &R = *Attr;
3179 void EmitClangAttrTemplateInstantiateHelper(const std::vector<Record *> &Attrs,
3184 for (const auto *Attr : Attrs) {
3185 const Record &R = *Attr;
3209 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
3213 for (const auto *ArgRecord : ArgRecords)
3235 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
3267 static bool isArgVariadic(const Record &R, StringRef AttrName) {
3271 static void emitArgInfo(const Record &R, raw_ostream &OS) {
3275 std::vector<Record *> Args = R.getValueAsListOfDefs("Args");
3278 for (const auto *Arg : Args) {
3300 static std::string GetDiagnosticSpelling(const Record &R) {
3314 static std::string CalculateDiagnostic(const Record &S) {
3322 std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects");
3323 for (const auto *Subject : Subjects) {
3324 const Record &R = *Subject;
3367 static std::string GetSubjectWithSuffix(const Record *R) {
3374 static std::string functionNameForCustomAppertainsTo(const Record &Subject) {
3378 static std::string GenerateCustomAppertainsTo(const Record &Subject,
3390 Record *Base = Subject.getValueAsDef(BaseFieldName);
3411 static std::string GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
3417 const Record *SubjectObj = Attr.getValueAsDef("Subjects");
3418 std::vector<Record*> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
3484 std::vector<Record *> Subjects = Rule.getSubjects();
3514 static std::string GenerateLangOptRequirements(const Record &R,
3518 std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts");
3556 static std::string GenerateTargetRequirements(const Record &Attr,
3565 const Record *R = Attr.getValueAsDef("Target");
3614 static std::string GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
3641 static bool IsKnownToGCC(const Record &Attr) {
3720 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3724 for (const auto *A : Attrs) {
3725 const Record &Attr = *A;
3818 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
3819 for (const auto *Attr : Attrs) {
3820 const Record &R = *Attr;
3836 for (const auto *Arg : Args)
3854 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
3855 for (const auto *Attr : Attrs) {
3856 const Record &R = *Attr;
3864 for (const auto *Arg : Args)
3913 void add(const Record &Attr, FlattenedSpelling Spelling) {
3944 const Record *Documentation;
3945 const Record *Attribute;
3949 DocumentationData(const Record &Documentation, const Record &Attribute,
3949 DocumentationData(const Record &Documentation, const Record &Attribute,
3956 static void WriteCategoryHeader(const Record *DocCategory,
3970 GetAttributeHeadingAndSpellings(const Record &Documentation,
3971 const Record &Attribute) {
4051 const Record &Deprecated = *Doc.Documentation->getValueAsDef("Deprecated");
4068 const Record *Documentation = Records.getDef("GlobalDocumentation");
4079 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
4080 std::map<const Record *, std::vector<DocumentationData>> SplitDocs;
4081 for (const auto *A : Attrs) {
4082 const Record &Attr = *A;
4083 std::vector<Record *> Docs = Attr.getValueAsListOfDefs("Documentation");
4084 for (const auto *D : Docs) {
4085 const Record &Doc = *D;
4086 const Record *Category = Doc.getValueAsDef("Category");
4133 const Record *SubjectObj = I.second->getValueAsDef("Subjects");
4134 std::vector<Record *> Subjects =
tools/clang/utils/TableGen/ClangCommentCommandInfoEmitter.cpp 29 std::vector<Record *> Tags = Records.getAllDerivedDefinitions("Command");
31 Record &Tag = *Tags[i];
65 Record &Tag = *Tags[i];
117 std::vector<Record *> Tags = Records.getAllDerivedDefinitions("Command");
119 Record &Tag = *Tags[i];
tools/clang/utils/TableGen/ClangCommentHTMLNamedCharacterReferenceEmitter.cpp 51 std::vector<Record *> Tags = Records.getAllDerivedDefinitions("NCR");
54 for (std::vector<Record *>::iterator I = Tags.begin(), E = Tags.end();
56 Record &Tag = **I;
tools/clang/utils/TableGen/ClangCommentHTMLTagsEmitter.cpp 23 std::vector<Record *> Tags = Records.getAllDerivedDefinitions("Tag");
25 for (Record *Tag : Tags) {
39 std::vector<Record *> Tags = Records.getAllDerivedDefinitions("Tag");
42 for (Record *Tag : Tags) {
tools/clang/utils/TableGen/ClangDataCollectorsEmitter.cpp 10 Record &R = *Entry.second;
tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp 42 std::map<const Record*, std::vector<Record*> > Mapping;
42 std::map<const Record*, std::vector<Record*> > Mapping;
45 std::vector<Record*> DiagGroups
48 std::vector<Record*> SubGroups =
55 const std::vector<Record*> &getParents(const Record *Group) {
55 const std::vector<Record*> &getParents(const Record *Group) {
62 getCategoryFromDiagGroup(const Record *Group,
70 const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
80 static std::string getDiagnosticCategory(const Record *R,
107 std::vector<Record*> Diags =
131 std::vector<const Record*> DiagsInGroup;
135 const Record *ExplicitDef;
141 static bool beforeThanCompare(const Record *LHS, const Record *RHS) {
141 static bool beforeThanCompare(const Record *LHS, const Record *RHS) {
147 static bool diagGroupBeforeByName(const Record *LHS, const Record *RHS) {
147 static bool diagGroupBeforeByName(const Record *LHS, const Record *RHS) {
160 static void groupDiagnostics(const std::vector<Record*> &Diags,
161 const std::vector<Record*> &DiagGroups,
165 const Record *R = Diags[i];
181 Record *Group = DiagGroups[i];
193 std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
210 MutableArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
219 ArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
223 for (ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
227 const Record *NextDiagGroup = GroupInit->getDef();
241 ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
246 const Record *NextDiagGroup = GroupInit->getDef();
266 typedef std::vector<const Record *> RecordVec;
267 typedef llvm::DenseSet<const Record *> RecordSet;
272 typedef llvm::DenseMap<const Record*,
276 const std::vector<Record*> &Diags;
277 const std::vector<Record*> DiagGroups;
279 llvm::DenseSet<const Record*> DiagsSet;
283 const std::vector<Record*> &Diags,
284 const std::vector<Record*> &DiagGroups,
298 bool isSubGroupOfGroup(const Record *Group,
302 bool isExtension(const Record *Diag);
305 bool isOffByDefault(const Record *Diag);
309 void markGroup(const Record *Group);
312 bool groupInPedantic(const Record *Group, bool increment = false);
316 bool InferPedantic::isSubGroupOfGroup(const Record *Group,
323 const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
332 bool InferPedantic::isExtension(const Record *Diag) {
337 bool InferPedantic::isOffByDefault(const Record *Diag) {
343 bool InferPedantic::groupInPedantic(const Record *Group, bool increment) {
360 void InferPedantic::markGroup(const Record *Group) {
366 const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
378 Record *R = Diags[i];
382 const Record *GroupRec = Group->getDef();
394 Record *R = Diags[i];
420 Record *Group = DiagGroups[i];
425 const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
607 for (auto *S : Records.getAllDerivedDefinitions("TextSubstitution")) {
615 for (Record *Diag : Records.getAllDerivedDefinitions("Diagnostic")) {
626 const Record *R);
627 std::string buildForDefinition(const Record *R);
674 const Record *EvaluatingRecord = nullptr;
676 EvaluatingRecordGuard(const Record **Dest, const Record *New)
676 EvaluatingRecordGuard(const Record **Dest, const Record *New)
681 const Record **Dest;
682 const Record *Old;
1144 const Record *R) {
1163 std::string DiagnosticTextBuilder::buildForDefinition(const Record *R) {
1178 static bool isError(const Record &Diag) {
1183 static bool isRemark(const Record &Diag) {
1205 std::vector<Record *> Diags = Records.getAllDerivedDefinitions("Diagnostic");
1207 std::vector<Record*> DiagGroups
1222 const Record &R = *Diags[i];
1228 const Record *GroupRec = Group->getDef();
1377 const std::vector<const Record *> &V = I.second.DiagsInGroup;
1478 const std::vector<const Record *> &V = I.second.DiagsInGroup;
1534 std::vector<Record *> Diags = Records.getAllDerivedDefinitions("Diagnostic");
1536 std::vector<Record *> DiagGroups =
1575 explicit RecordIndexElement(Record const &R):
1583 const std::vector<Record*> &Diags =
1589 const Record &R = *(Diags[i]);
1612 bool isRemarkGroup(const Record *DiagGroup,
1618 for (const Record *Diag : GroupInfo.DiagsInGroup)
1632 std::string getDefaultSeverity(const Record *Diag) {
1637 getDefaultSeverities(const Record *DiagGroup,
1643 for (const Record *Diag : GroupInfo.DiagsInGroup)
1656 void writeDiagnosticText(DiagnosticTextBuilder &Builder, const Record *R,
1676 const Record *Documentation = Records.getDef("GlobalDocumentation");
1687 std::vector<Record*> Diags =
1690 std::vector<Record*> DiagGroups =
1723 for (const Record *G : DiagGroups) {
1772 for (const Record *D : GroupInfo.DiagsInGroup) {
tools/clang/utils/TableGen/ClangOpcodesEmitter.cpp 24 Record Root;
37 void EmitEnum(raw_ostream &OS, StringRef N, Record *R);
40 void EmitInterp(raw_ostream &OS, StringRef N, Record *R);
43 void EmitDisasm(raw_ostream &OS, StringRef N, Record *R);
46 void EmitEmitter(raw_ostream &OS, StringRef N, Record *R);
49 void EmitProto(raw_ostream &OS, StringRef N, Record *R);
52 void EmitGroup(raw_ostream &OS, StringRef N, Record *R);
55 void EmitEval(raw_ostream &OS, StringRef N, Record *R);
57 void PrintTypes(raw_ostream &OS, ArrayRef<Record *> Types);
60 void Enumerate(const Record *R,
62 std::function<void(ArrayRef<Record *>, Twine)> &&F) {
63 llvm::SmallVector<Record *, 2> TypePath;
74 for (auto *Type : TypeClass->getDef()->getValueAsListOfDefs("Types")) {
89 for (auto *Opcode : Records.getAllDerivedDefinitions(Root.getName())) {
105 void ClangOpcodesEmitter::EmitEnum(raw_ostream &OS, StringRef N, Record *R) {
113 void ClangOpcodesEmitter::EmitInterp(raw_ostream &OS, StringRef N, Record *R) {
157 void ClangOpcodesEmitter::EmitDisasm(raw_ostream &OS, StringRef N, Record *R) {
164 for (auto *Arg : R->getValueAsListOfDefs("Args"))
173 void ClangOpcodesEmitter::EmitEmitter(raw_ostream &OS, StringRef N, Record *R) {
203 void ClangOpcodesEmitter::EmitProto(raw_ostream &OS, StringRef N, Record *R) {
208 for (auto *Arg : Args)
225 for (auto *Arg : Args)
234 void ClangOpcodesEmitter::EmitGroup(raw_ostream &OS, StringRef N, Record *R) {
246 for (auto *Arg : Args)
267 llvm::SmallVector<Record *, 2> TS;
295 for (auto *Case : Cases) {
316 void ClangOpcodesEmitter::EmitEval(raw_ostream &OS, StringRef N, Record *R) {
343 void ClangOpcodesEmitter::PrintTypes(raw_ostream &OS, ArrayRef<Record *> Types) {
tools/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp 97 void ExtractEnumTypes(std::vector<Record *> &Types,
99 std::vector<const Record *> &List);
149 std::vector<std::pair<std::vector<Record *>, unsigned>> SignaturesList;
161 MapVector<StringRef, std::vector<std::pair<const Record *, unsigned>>>
165 MapVector<const Record *, unsigned> TypeMap;
169 std::vector<const Record *> TypeList;
172 std::vector<const Record *> GenTypeList;
197 void BuiltinNameEmitter::ExtractEnumTypes(std::vector<Record *> &Types,
200 std::vector<const Record *> &List) {
203 for (const auto *T : Types) {
227 std::vector<Record *> GenTypes =
231 std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
289 static void VerifySignature(const std::vector<Record *> &Signature,
290 const Record *BuiltinRec) {
294 for (const auto *T : Signature) {
328 std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
336 std::vector<Record *> Builtins = Records.getAllDerivedDefinitions("Builtin");
337 for (const auto *B : Builtins) {
393 for (const Record *R : P.first) {
472 for (const auto *VectList : Records.getAllDerivedDefinitions("IntList")) {
486 std::vector<Record *> ImageTypes =
490 std::map<StringRef, SmallVector<Record *, 3>> ImageTypesMap;
491 for (auto *IT : ImageTypes) {
494 SmallVector<Record *, 3> ImageList;
527 for (const auto *GenType : Records.getAllDerivedDefinitions("GenericType")) {
538 for (const auto *T :
562 std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
565 for (const auto *T : Types) {
tools/clang/utils/TableGen/ClangOptionDocEmitter.cpp 27 Record *Option;
28 std::vector<Record*> Aliases;
36 Record *Group;
45 std::map<Record*, std::vector<Record*> > OptionsInGroup;
45 std::map<Record*, std::vector<Record*> > OptionsInGroup;
46 std::map<Record*, std::vector<Record*> > GroupsInGroup;
46 std::map<Record*, std::vector<Record*> > GroupsInGroup;
47 std::map<Record*, std::vector<Record*> > Aliases;
47 std::map<Record*, std::vector<Record*> > Aliases;
49 std::map<std::string, Record*> OptionsByName;
50 for (Record *R : Records.getAllDerivedDefinitions("Option"))
67 for (Record *R : Records.getAllDerivedDefinitions("OptionGroup")) {
71 Record *Group = nullptr;
77 for (Record *R : Records.getAllDerivedDefinitions("Option")) {
96 Record *Group = nullptr;
116 std::function<Documentation(Record *)> DocumentationForGroup =
122 for (Record *G : Groups) {
131 for (Record *O : Options)
141 std::pair<StringRef,StringRef> getSeparatorsForKind(const Record *OptionKind) {
154 unsigned getNumArgsForKind(Record *OptionKind, const Record *Option) {
154 unsigned getNumArgsForKind(Record *OptionKind, const Record *Option) {
164 bool hasFlag(const Record *OptionOrGroup, StringRef OptionFlag) {
165 for (const Record *Flag : OptionOrGroup->getValueAsListOfDefs("Flags"))
171 bool isExcluded(const Record *OptionOrGroup, const Record *DocInfo) {
171 bool isExcluded(const Record *OptionOrGroup, const Record *DocInfo) {
196 bool canSphinxCopeWithOption(const Record *Option) {
213 std::string getRSTStringWithTextFallback(const Record *R, StringRef Primary,
229 void emitOptionWithArgs(StringRef Prefix, const Record *Option,
243 void emitOptionName(StringRef Prefix, const Record *Option, raw_ostream &OS) {
274 Record *Alias = Option->getValueAsDef("Alias");
283 bool emitOptionNames(const Record *Option, raw_ostream &OS, bool EmittedAny) {
294 void forEachOptionName(const DocumentedOption &Option, const Record *DocInfo,
298 for (auto *Alias : Option.Aliases)
303 void emitOption(const DocumentedOption &Option, const Record *DocInfo,
353 const Record *DocInfo, raw_ostream &OS);
355 void emitGroup(int Depth, const DocumentedGroup &Group, const Record *DocInfo,
374 const Record *DocInfo, raw_ostream &OS) {
384 const Record *DocInfo = Records.getDef("GlobalDocumentation");
tools/clang/utils/TableGen/ClangSACheckersEmitter.cpp 27 static std::string getPackageFullName(const Record *R);
29 static std::string getParentPackageFullName(const Record *R) {
36 static std::string getPackageFullName(const Record *R) {
45 static std::string getCheckerFullName(const Record *R) {
54 static std::string getStringValue(const Record &R, StringRef field) {
61 static inline uint64_t getValueFromBitsInit(const BitsInit *B, const Record &R) {
76 static std::string getCheckerDocs(const Record &R) {
97 static std::string getCheckerOptionType(const Record &R) {
114 static std::string getDevelopmentStage(const Record &R) {
130 static bool isHidden(const Record *R) {
141 static void printChecker(llvm::raw_ostream &OS, const Record &R) {
160 const Record &R) {
179 std::vector<Record*> checkers = Records.getAllDerivedDefinitions("Checker");
180 std::vector<Record*> packages = Records.getAllDerivedDefinitions("Package");
182 using SortedRecords = llvm::StringMap<const Record *>;
200 const Record &R = *I->second;
227 for (const Record *Package : packages) {
232 std::vector<Record *> PackageOptions = Package
234 for (Record *PackageOpt : PackageOptions) {
254 for (const Record *checker : checkers) {
268 for (const Record *Checker : checkers) {
272 for (const Record *Dependency :
302 for (const Record *Checker : checkers) {
307 std::vector<Record *> CheckerOptions = Checker
309 for (Record *CheckerOpt : CheckerOptions) {
tools/clang/utils/TableGen/ClangTypeNodesEmitter.cpp 73 static StringRef getIdForType(Record *type) {
86 const std::vector<Record*> Types;
tools/clang/utils/TableGen/MveEmitter.cpp 234 ScalarType(const Record *Record) : CRegularNamedType(TypeKind::Scalar) {
823 ACLEIntrinsic(MveEmitter &ME, Record *R, const Type *Param);
851 const ScalarType *getScalarType(Record *R) {
887 const Type *getType(Record *R, const Type *Param);
920 const Type *MveEmitter::getType(Record *R, const Type *Param) {
938 Record *Op = cast<DefInit>(D->getOperator())->getDef();
988 Record *Op = cast<DefInit>(D->getOperator())->getDef();
1036 for (Record *RParam : Op->getValueAsListOfDefs("params"))
1090 ACLEIntrinsic::ACLEIntrinsic(MveEmitter &ME, Record *R, const Type *Param)
1106 Record *PolymorphicNameType = R->getValueAsDef("pnt");
1147 Record *TypeRec = TypeDI->getDef();
1149 Record *Bounds = TypeRec->getValueAsDef("bounds");
1184 Record *MainOp = cast<DefInit>(CodeDag->getOperator())->getDef();
1216 for (Record *R : Records.getAllDerivedDefinitions("PrimitiveType"))
1221 for (Record *R : Records.getAllDerivedDefinitions("Intrinsic")) {
1222 for (Record *RParam : R->getValueAsListOfDefs("params")) {
tools/clang/utils/TableGen/NeonEmitter.cpp 60 static Record *CurrentRecord = nullptr;
291 Record *R;
348 Intrinsic(Record *R, StringRef Name, StringRef Proto, TypeSpec OutTS,
382 Record *getRecord() const { return R; }
525 DenseMap<Record *, ClassKind> ClassMap;
529 void createIntrinsic(Record *R, SmallVectorImpl<Intrinsic *> &Out);
545 Record *SI = R.getClass("SInst");
546 Record *II = R.getClass("IInst");
547 Record *WI = R.getClass("WInst");
548 Record *SOpI = R.getClass("SOpInst");
549 Record *IOpI = R.getClass("IOpInst");
550 Record *WOpI = R.getClass("WOpInst");
551 Record *LOpI = R.getClass("LOpInst");
552 Record *NoTestOpI = R.getClass("NoTestOpInst");
1714 std::vector<Record *> Revved;
1731 void expand(SetTheory &ST, Record *R, SetTheory::RecSet &Elts) override {
2044 void NeonEmitter::createIntrinsic(Record *R,
2049 Record *OperationRec = R->getValueAsDef("Operation");
2247 Record *R = Def->getRecord();
2314 std::vector<Record *> RV = Records.getAllDerivedDefinitions("Inst");
2317 for (auto *R : RV)
2476 std::vector<Record *> RV = Records.getAllDerivedDefinitions("Inst");
2477 for (auto *R : RV)
2583 std::vector<Record *> RV = Records.getAllDerivedDefinitions("Inst");
2584 for (auto *R : RV)
tools/lldb/utils/TableGen/LLDBOptionDefEmitter.cpp 39 CommandOption(Record *Option) {
153 static void emitOptions(std::string Command, std::vector<Record *> Records,
156 for (Record *R : Records)
181 std::vector<Record *> Options = Records.getAllDerivedDefinitions("Option");
tools/lldb/utils/TableGen/LLDBPropertyDefEmitter.cpp 24 static void emitPropertyEnum(Record *Property, raw_ostream &OS) {
30 static void emitProperty(Record *Property, raw_ostream &OS) {
120 std::vector<Record *> PropertyRecords,
133 for (Record *R : PropertyRecords)
143 std::vector<Record *> PropertyRecords,
154 for (Record *R : PropertyRecords)
164 std::vector<Record *> Properties =
175 std::vector<Record *> Properties =
tools/lldb/utils/TableGen/LLDBTableGenUtils.cpp 15 RecordsByName lldb_private::getRecordsByName(std::vector<Record *> Records,
18 for (Record *R : Records)
tools/lldb/utils/TableGen/LLDBTableGenUtils.h 26 typedef std::map<std::string, std::vector<llvm::Record *>> RecordsByName;
29 RecordsByName getRecordsByName(std::vector<llvm::Record *> Records,
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/bits/unique_ptr.h 68 default_delete(const default_delete<_Up>&) noexcept { }
72 operator()(_Tp* __ptr) const
74 static_assert(!is_void<_Tp>::value,
76 static_assert(sizeof(_Tp)>0,
122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
252 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
297 __safe_conversion_up<_Up, _Ep>,
301 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
811 { typedef unique_ptr<_Tp> __single_object; };
823 inline typename _MakeUniq<_Tp>::__single_object
824 make_unique(_Args&&... __args)
825 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1633 { typedef _Tp type; };
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1983 { typedef _Up type; };
utils/TableGen/AsmMatcherEmitter.cpp 141 typedef std::set<Record*, LessRecordByID> RegisterSet;
400 Record *SingletonReg;
451 Record *Register;
483 static ResOperand getRegOp(Record *Reg) {
501 Record *const TheDef;
577 SmallPtrSetImpl<Record*> &SingletonRegisters,
714 Record *AsmParser;
729 typedef std::map<Record*, ClassInfo*, LessRecordByID> RegisterClassesTy;
733 std::map<Record *, SubtargetFeatureInfo, LessRecordByID> SubtargetFeatures;
736 std::map<Record*, ClassInfo*> AsmOperandClasses;
739 std::map<Record*, ClassInfo*> RegisterClassClasses;
752 ClassInfo *getOperandClass(Record *Rec, int SubOpIdx);
756 void buildRegisterClasses(SmallPtrSetImpl<Record*> &SingletonRegisters);
768 AsmMatcherInfo(Record *AsmParser,
781 const SubtargetFeatureInfo *getSubtargetFeature(Record *Def) const {
912 SmallPtrSetImpl<Record*> &SingletonRegisters,
941 for (Record *Predicate : TheDef->getValueAsListOfDefs("Predicates"))
949 if (Record *Reg = Op.SingletonReg)
1152 Record *Rec = OI.Rec;
1159 AsmMatcherInfo::getOperandClass(Record *Rec, int SubOpIdx) {
1170 Record *MatchClass = DI->getDef();
1176 Record *ClassRec = Rec->getValueAsDef("RegClass");
1194 Record *MatchClass = Rec->getValueAsDef("ParserMatchClass");
1214 buildRegisterClasses(SmallPtrSetImpl<Record*> &SingletonRegisters) {
1229 for (Record *Rec : SingletonRegisters) {
1236 std::map<Record*, RegisterSet> RegisterMap;
1299 Record *Def = RC.getDef();
1328 for (std::map<Record*, RegisterSet>::iterator it = RegisterMap.begin(),
1333 for (Record *Rec : SingletonRegisters) {
1347 std::vector<Record*> AsmOperands =
1351 for (Record *Rec : AsmOperands) {
1357 for (Record *Rec : AsmOperands) {
1431 AsmMatcherInfo::AsmMatcherInfo(Record *asmParser,
1471 const std::vector<std::pair<Record *, SubtargetFeatureInfo>>
1486 SmallPtrSet<Record*, 16> SingletonRegisters;
1489 Record *AsmVariant = Target.getAsmParserVariant(VC);
1533 std::vector<Record*> AllInstAliases =
1579 if (Record *RegRecord = Op.SingletonReg) {
1642 std::vector<Record*> AllTokenAliases =
1644 for (Record *Rec : AllTokenAliases) {
1687 Record *Rec = Operands[Idx].Rec;
1689 Record *MatchClass = Rec->getValueAsDef("ParserMatchClass");
1904 Record *Reg = CGA.ResultOperands[AliasOpNo].getRegister();
2595 static void emitMatchRegisterName(CodeGenTarget &Target, Record *AsmParser,
2620 static void emitMatchRegisterAltName(CodeGenTarget &Target, Record *AsmParser,
2695 static std::string GetAliasRequiredFeatures(Record *R,
2697 std::vector<Record*> ReqFeatures = R->getValueAsListOfDefs("Predicates");
2720 std::vector<Record*> &Aliases,
2725 std::map<std::string, std::vector<Record*> > AliasesFromMnemonic;
2727 for (Record *R : Aliases) {
2741 const std::vector<Record*> &ToVec = AliasEntry.second;
2750 Record *R = ToVec[i];
2778 Record *R = ToVec[AliasWithNoPredicate];
2801 std::vector<Record*> Aliases =
2810 Record *AsmVariant = Target.getAsmParserVariant(VC);
3059 Record *AsmVariant = Target.getAsmParserVariant(VC);
3118 getNameForFeatureBitset(const std::vector<Record *> &FeatureBitset) {
3127 Record *AsmParser = Target.getAsmParser();
3335 std::vector<std::vector<Record *>> FeatureBitsets;
3430 Record *AsmVariant = Target.getAsmParserVariant(VC);
3534 Record *AsmVariant = Target.getAsmParserVariant(VC);
utils/TableGen/AsmWriterEmitter.cpp 273 Record *AsmWriter = Target.getAsmWriter();
515 std::vector<Record*> AltNameList =
554 Record *AsmWriter = Target.getAsmWriter();
557 const std::vector<Record*> &AltNameIndices = Target.getRegAltNameIndices();
575 for (const Record *R : AltNameIndices)
583 for (const Record *R : AltNameIndices) {
760 Record *AsmWriter = Target.getAsmWriter();
774 std::vector<Record*> AllInstAliases =
781 for (Record *R : AllInstAliases) {
798 std::vector<const Record*> MCOpPredicates;
799 DenseMap<const Record*, unsigned> MCOpPredicateMap;
821 std::vector<Record *> ReqFeatures;
824 std::vector<Record *> RF =
867 const Record *Rec = RO.getRecord();
892 Record *R = CGA.ResultOperands[i].getRecord();
954 Record *R = *I;
1136 Record *AsmWriter = Target.getAsmWriter();
utils/TableGen/Attributes.cpp 31 const std::vector<Record *> &Records);
33 const std::vector<Record *> &Records);
44 std::vector<Record*> Attrs =
57 std::vector<Record*> Attrs =
111 std::vector<Record *> CompatRules =
114 for (auto *Rule : CompatRules) {
123 std::vector<Record *> MergeRules =
128 for (auto *Rule : MergeRules) {
139 const std::vector<Record *> &Records) {
141 for (const auto *R : Records) {
152 const std::vector<Record *> &Records) {
154 for (const auto *R : Records) {
utils/TableGen/CTagsEmitter.cpp 54 static SMLoc locate(const Record *R);
59 SMLoc CTagsEmitter::locate(const Record *R) {
utils/TableGen/CallingConvEmitter.cpp 30 void EmitCallingConv(Record *CC, raw_ostream &O);
31 void EmitAction(Record *Action, unsigned Indent, raw_ostream &O);
37 std::vector<Record*> CCs = Records.getAllDerivedDefinitions("CallingConv");
41 for (Record *CC : CCs) {
59 for (Record *CC : CCs) {
66 void CallingConvEmitter::EmitCallingConv(Record *CC, raw_ostream &O) {
92 void CallingConvEmitter::EmitAction(Record *Action,
102 Record *VT = VTs->getElementAsRecord(i);
119 Record *CC = Action->getValueAsDef("CC");
234 Record *DestTy = Action->getValueAsDef("DestTy");
248 Record *DestTy = Action->getValueAsDef("DestTy");
264 Record *DestTy = Action->getValueAsDef("DestTy");
268 Record *DestTy = Action->getValueAsDef("DestTy");
272 Record *DestTy = Action->getValueAsDef("DestTy");
utils/TableGen/CodeEmitterGen.cpp 48 std::string getInstructionCase(Record *R, CodeGenTarget &Target);
49 std::string getInstructionCaseForEncoding(Record *R, Record *EncodingDef,
49 std::string getInstructionCaseForEncoding(Record *R, Record *EncodingDef,
51 void AddCodeToMergeInOperand(Record *R, BitsInit *BI,
81 AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
266 std::string CodeEmitterGen::getInstructionCase(Record *R,
288 std::string CodeEmitterGen::getInstructionCaseForEncoding(Record *R, Record *EncodingDef,
288 std::string CodeEmitterGen::getInstructionCaseForEncoding(Record *R, Record *EncodingDef,
334 getNameForFeatureBitset(const std::vector<Record *> &FeatureBitset) {
358 Record *R = CGI->TheDef;
366 Record *EncodingDef = R;
391 std::vector<Record*> Insts = Records.getAllDerivedDefinitions("Instruction");
404 Record *R = CGI->TheDef;
464 for (std::vector<Record*>::iterator IC = Insts.begin(), EC = Insts.end();
466 Record *R = *IC;
529 std::map<Record *, SubtargetFeatureInfo, LessRecordByID> SubtargetFeatures;
550 std::vector<std::vector<Record *>> FeatureBitsets;
553 for (Record *Predicate : Inst->TheDef->getValueAsListOfDefs("Predicates")) {
615 for (Record *Predicate : Inst->TheDef->getValueAsListOfDefs("Predicates")) {
utils/TableGen/CodeGenDAGPatterns.cpp 866 Record *MemoryVT = getMemoryVT();
878 Record *ScalarMemoryVT = getScalarMemoryVT();
996 Record *MemoryVT = getMemoryVT();
1074 Record *ScalarMemoryVT = getScalarMemoryVT();
1182 Record *TreePredicateFn::getMemoryVT() const {
1183 Record *R = getOrigPatFragRecord()->getRecord();
1190 Record *R = getOrigPatFragRecord()->getRecord();
1197 Record *R = getOrigPatFragRecord()->getRecord();
1203 Record *TreePredicateFn::getScalarMemoryVT() const {
1204 Record *R = getOrigPatFragRecord()->getRecord();
1311 Record *Op = PatFragRec->getOnlyTree()->getOperator();
1334 Record *R = DI->getDef();
1418 SDTypeConstraint::SDTypeConstraint(Record *R, const CodeGenHwModes &CGH) {
1618 Record *Operand,
1627 Record *R = Operand->getValueAsDef("Type");
1638 Record *RC = nullptr;
1695 SDNodeInfo::SDNodeInfo(Record *R, const CodeGenHwModes &CGH) : Def(R) {
1698 Record *TypeProfile = R->getValueAsDef("TypeProfile");
1706 std::vector<Record*> ConstraintList =
1708 for (Record *R : ConstraintList)
1743 static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
1771 Record *Op = nullptr;
1788 Record *OperandNode = InstInfo.Operands[i].Rec;
1965 Record *Op = getOperator();
2097 static TypeSetByHwMode getImplicitType(Record *R, unsigned ResNo,
2108 Record *RegClass = R->getValueAsDef("RegClass");
2195 Record *T = R->getValueAsDef("Type");
2221 Record *Rec;
2508 Record *OperandNode = Inst.getOperand(i);
2537 Record *SubRec = cast<DefInit>(MIOpInfo->getArg(0))->getDef();
2655 TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
2663 TreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
2670 TreePattern::TreePattern(Record *TheRec, TreePatternNodePtr Pat, bool isInput,
2701 Record *R = DI->getDef();
2757 Record *Operator = OpDef->getDef();
3049 Record *CodeGenDAGPatterns::getSDNodeNamed(const std::string &Name) const {
3050 Record *N = Records.getDef(Name);
3059 std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode");
3063 Record *R = Nodes.back();
3077 std::vector<Record*> Xforms = Records.getAllDerivedDefinitions("SDNodeXForm");
3079 Record *XFormNode = Xforms.back();
3080 Record *SDNode = XFormNode->getValueAsDef("Opcode");
3089 std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern");
3103 std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrags");
3106 for (Record *Frag : Fragments) {
3159 Record *Transform = Frag->getValueAsDef("OperandTransform");
3167 for (Record *Frag : Fragments) {
3191 std::vector<Record*> DefaultOps;
3250 Record *Rec;
3269 Record *SlotRec;
3296 std::vector<Record *> &InstImpResults) {
3440 Record *LeafRec = DI->getDef();
3482 Record *PatDef) {
3545 Record *Operator = OpDef->getDef();
3573 getInstructionsInTree(TreePatternNode *Tree, SmallVectorImpl<Record*> &Instrs) {
3585 Record *Leaf) {
3618 std::vector<Record*> InstImpResults;
3652 std::vector<Record*> Results;
3675 Record *R = cast<DefInit>(RNode->getLeafValue())->getDef();
3696 std::vector<Record*> Operands;
3719 Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef();
3733 if (Record *Xform = OpNode->getTransformFn()) {
3771 Record *R = I.getRecord();
3783 std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction");
3785 for (Record *Instr : Instrs) {
3798 std::vector<Record*> Results;
3799 std::vector<Record*> Operands;
3814 std::vector<Record*> ImpResults;
3826 Record *Instr = Entry.first;
3929 SmallVector<Record*, 8> PatInstrs;
3988 SmallVector<Record*, 8> Instrs;
3997 for (const Record *Instr : Instrs) {
4035 for (const Record *Instr : Instrs) {
4081 if (Record *Xform = N->getTransformFn()) {
4097 void CodeGenDAGPatterns::ParseOnePattern(Record *TheDef,
4099 const std::vector<Record *> &InstImpResults) {
4192 std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern");
4194 for (Record *CurPattern : Patterns) {
4217 std::vector<Record*> InstImpResults;
4253 P.getAddedComplexity(), Record::getNewUID(),
4437 Record *Operator = N->getOperator();
4545 Record *RR = DI->getDef();
4678 PatternsToMatch[i].getAddedComplexity(), Record::getNewUID()));
utils/TableGen/CodeGenDAGPatterns.h 378 SDTypeConstraint(Record *R, const CodeGenHwModes &CGH);
450 Record *Def;
459 SDNodeInfo(Record *R, const CodeGenHwModes &CGH);
466 Record *getRecord() const { return Def; }
590 Record *getMemoryVT() const;
594 Record *getScalarMemoryVT() const;
643 Record *Operator;
661 Record *TransformFn;
666 TreePatternNode(Record *Op, std::vector<TreePatternNodePtr> Ch,
724 Record *getOperator() const { assert(!isLeaf()); return Operator; }
765 Record *getTransformFn() const { return TransformFn; }
766 void setTransformFn(Record *Fn) { TransformFn = Fn; }
844 bool UpdateNodeTypeFromInst(unsigned ResNo, Record *Operand, TreePattern &TP);
876 Record *TheRecord;
899 StringMap<std::pair<Record *, unsigned>> ComplexPatternOperands;
907 TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
909 TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
911 TreePattern(Record *TheRec, TreePatternNodePtr Pat, bool isInput,
934 Record *getRecord() const { return TheRecord; }
1016 std::vector<Record*> Results;
1017 std::vector<Record*> Operands;
1018 std::vector<Record*> ImpResults;
1023 DAGInstruction(const std::vector<Record*> &results,
1024 const std::vector<Record*> &operands,
1025 const std::vector<Record*> &impresults,
1034 const std::vector<Record*>& getImpResults() const { return ImpResults; }
1036 Record *getResult(unsigned RN) const {
1041 Record *getOperand(unsigned ON) const {
1046 Record *getImpResult(unsigned RN) const {
1063 Predicate(Record *R, bool C = true) : Def(R), IfCond(C), IsHwMode(false) {
1097 Record *Def; ///< Predicate definition from .td file, null for
1109 PatternToMatch(Record *srcrecord, std::vector<Predicate> preds,
1111 std::vector<Record *> dstregs, int complexity,
1117 Record *SrcRecord; // Originating Record for the pattern.
1122 std::vector<Record*> Dstregs; // Physical register defs being matched.
1127 Record *getSrcRecord() const { return SrcRecord; }
1132 const std::vector<Record*> &getDstRegs() const { return Dstregs; }
1149 std::map<Record*, SDNodeInfo, LessRecordByID> SDNodes;
1150 std::map<Record*, std::pair<Record*, std::string>, LessRecordByID>
1150 std::map<Record*, std::pair<Record*, std::string>, LessRecordByID>
1152 std::map<Record*, ComplexPattern, LessRecordByID> ComplexPatterns;
1153 std::map<Record *, std::unique_ptr<TreePattern>, LessRecordByID>
1155 std::map<Record*, DAGDefaultOperand, LessRecordByID> DefaultOperands;
1156 std::map<Record*, DAGInstruction, LessRecordByID> Instructions;
1159 Record *intrinsic_void_sdnode;
1160 Record *intrinsic_w_chain_sdnode, *intrinsic_wo_chain_sdnode;
1182 Record *getSDNodeNamed(const std::string &Name) const;
1184 const SDNodeInfo &getSDNodeInfo(Record *R) const {
1191 typedef std::pair<Record*, std::string> NodeXForm;
1192 const NodeXForm &getSDNodeTransform(Record *R) const {
1198 typedef std::map<Record*, NodeXForm, LessRecordByID>::const_iterator
1204 const ComplexPattern &getComplexPattern(Record *R) const {
1210 const CodeGenIntrinsic &getIntrinsic(Record *R) const {
1226 unsigned getIntrinsicID(Record *R) const {
1234 const DAGDefaultOperand &getDefaultOperand(Record *R) const {
1241 TreePattern *getPatternFragment(Record *R) const {
1246 TreePattern *getPatternFragmentIfRead(Record *R) const {
1253 typedef std::map<Record *, std::unique_ptr<TreePattern>,
1266 typedef std::map<Record*, DAGInstruction, LessRecordByID> DAGInstMap;
1271 const DAGInstruction &getInstruction(Record *R) const {
1277 Record *get_intrinsic_void_sdnode() const {
1280 Record *get_intrinsic_w_chain_sdnode() const {
1283 Record *get_intrinsic_wo_chain_sdnode() const {
1291 bool operandHasDefault(Record *Op) const {
1311 void ParseOnePattern(Record *TheDef,
1313 const std::vector<Record *> &InstImpResults);
1320 std::vector<Record *> &InstImpResults);
utils/TableGen/CodeGenHwModes.cpp 21 HwMode::HwMode(Record *R) {
31 HwModeSelect::HwModeSelect(Record *R, CodeGenHwModes &CGH) {
32 std::vector<Record*> Modes = R->getValueAsListOfDefs("Modes");
33 std::vector<Record*> Objects = R->getValueAsListOfDefs("Objects");
55 std::vector<Record*> MRs = Records.getAllDerivedDefinitions("HwMode");
65 for (Record *R : MRs) {
71 std::vector<Record*> MSs = Records.getAllDerivedDefinitions("HwModeSelect");
72 for (Record *R : MSs) {
87 const HwModeSelect &CodeGenHwModes::getHwModeSelect(Record *R) const {
utils/TableGen/CodeGenHwModes.h 28 HwMode(Record *R);
35 HwModeSelect(Record *R, CodeGenHwModes &CGH);
36 typedef std::pair<unsigned, Record*> PairType;
51 const HwModeSelect &getHwModeSelect(Record *R) const;
59 std::map<Record*,HwModeSelect> ModeSelects;
utils/TableGen/CodeGenInstruction.cpp 27 CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
75 Record *Rec = Arg->getDef();
229 Record *Rec) {
322 Record *Rec) {
361 CodeGenInstruction::CodeGenInstruction(Record *R)
450 Record *FirstImplicitDef = ImplicitDefs[0];
528 Record *InstOpRec, bool hasSubOps,
533 Record *ResultRecord = ADI ? ADI->getDef() : nullptr;
652 Record *Rec = getRecord();
665 CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T)
681 StringMap<Record*> NameClass;
689 Record *&Entry = NameClass[Result->getArgNameStr(i)];
717 Record *InstOpRec = ResultInst->Operands[i].Rec;
736 Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef();
757 Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef();
utils/TableGen/CodeGenInstruction.h 77 Record *Rec;
117 OperandInfo(Record *R, const std::string &N, const std::string &PMN,
136 CGIOperandList(Record *D);
138 Record *TheDef; // The actual record containing this OperandList.
218 Record *TheDef; // The actual record defining this instruction.
231 std::vector<Record*> ImplicitDefs, ImplicitUses;
291 Record *InferredFrom;
293 CodeGenInstruction(Record *R);
318 Record *TheDef; // The actual record defining this InstAlias.
335 Record *R;
345 ResultOperand(std::string N, Record *r)
348 ResultOperand(Record *r) : R(r), Kind(K_Reg) {}
355 Record *getRecord() const { assert(isRecord()); return R; }
357 Record *getRegister() const { assert(isReg()); return R; }
372 CodeGenInstAlias(Record *R, CodeGenTarget &T);
375 Record *InstOpRec, bool hasSubOps, ArrayRef<SMLoc> Loc,
utils/TableGen/CodeGenIntrinsics.h 27 Record *TheDef; // The actual record defining this intrinsic.
47 std::vector<Record *> RetTypeDefs;
56 std::vector<Record *> ParamTypeDefs;
165 CodeGenIntrinsic(Record *R);
utils/TableGen/CodeGenMapTable.cpp 82 typedef std::map<std::string, std::vector<Record*> > InstrRelMapTy;
84 typedef std::map<std::vector<Init*>, std::vector<Record*> > RowInstrMapTy;
100 InstrMap(Record* MapRec) {
190 std::vector<Record*> InstrDefs;
197 std::vector<Record*> KeyInstrVec;
198 DenseMap<Record*, std::vector<Record*> > MapTable;
198 DenseMap<Record*, std::vector<Record*> > MapTable;
201 MapTableEmitter(CodeGenTarget &Target, RecordKeeper &Records, Record *IMRec):
211 bool isKeyColInstr(Record* CurInstr);
215 Record *getInstrForColumn(Record *KeyInstr, ListInit *CurValueCol);
215 Record *getInstrForColumn(Record *KeyInstr, ListInit *CurValueCol);
241 for (Record *CurInstr : InstrDefs) {
268 bool MapTableEmitter::isKeyColInstr(Record* CurInstr) {
294 for (Record *CurKeyInstr : KeyInstrVec) {
295 std::vector<Record*> ColInstrVec(NumOfCols);
300 Record *ColInstr = getInstrForColumn(CurKeyInstr, CurValueCol);
311 Record *MapTableEmitter::getInstrForColumn(Record *KeyInstr,
311 Record *MapTableEmitter::getInstrForColumn(Record *KeyInstr,
326 const std::vector<Record*> &RelatedInstrVec = RowInstrMap[KeyValue];
329 Record *MatchInstr = nullptr;
333 Record *CurInstr = RelatedInstrVec[i];
385 Record *CurInstr = NumberedInstructions[i]->TheDef;
386 std::vector<Record*> ColInstrs = MapTable[CurInstr];
510 std::vector<Record*> InstrMapVec;
516 for (Record *CurMap : InstrMapVec) {
575 std::vector<Record*> InstrMapVec;
592 for (Record *CurMap : InstrMapVec) {
utils/TableGen/CodeGenRegisters.cpp 53 CodeGenSubRegIndex::CodeGenSubRegIndex(Record *R, unsigned Enum)
80 std::vector<Record*> Comps = TheDef->getValueAsListOfDefs("ComposedOf");
92 std::vector<Record*> Parts =
99 for (Record *Part : Parts)
156 CodeGenRegister::CodeGenRegister(Record *R, unsigned Enum)
169 std::vector<Record*> SRIs = TheDef->getValueAsListOfDefs("SubRegIndices");
170 std::vector<Record*> SRs = TheDef->getValueAsListOfDefs("SubRegs");
191 std::vector<Record*> Aliases = TheDef->getValueAsListOfDefs("Aliases");
192 for (Record *Alias : Aliases) {
613 std::vector<std::unique_ptr<Record>> &SynthDefs;
615 TupleExpander(std::vector<std::unique_ptr<Record>> &SynthDefs)
618 void expand(SetTheory &ST, Record *Def, SetTheory::RecSet &Elts) override {
619 std::vector<Record*> Indices = Def->getValueAsListOfDefs("SubRegIndices");
640 Record *RegisterCl = Def->getRecords().getClass("Register");
648 Record *Proto = Lists[0][n];
652 Record *Reg = Lists[i][n];
673 std::make_unique<Record>(Name, Def->getLoc(), Def->getRecords()));
674 Record *NewReg = SynthDefs.back().get();
678 ArrayRef<std::pair<Record *, SMRange>> Supers = Proto->getSuperClasses();
741 CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R)
747 std::vector<Record*> TypeList = R->getValueAsListOfDefs("RegTypes");
749 Record *Type = TypeList[i];
1105 std::vector<Record*> SRIs = Records.getAllDerivedDefinitions("SubRegIndex");
1114 std::vector<Record*> Regs = Records.getAllDerivedDefinitions("Register");
1121 std::vector<Record*> Tups =
1124 for (Record *R : Tups) {
1125 std::vector<Record *> TupRegs = *Sets.expand(R);
1127 for (Record *RC : TupRegs)
1187 std::vector<Record*> RCs = Records.getAllDerivedDefinitions("RegisterClass");
1192 for (auto *R : RCs) {
1217 CodeGenSubRegIndex *CodeGenRegBank::getSubRegIdx(Record *Def) {
1226 CodeGenRegister *CodeGenRegBank::getReg(Record *Def) {
1236 if (Record *Def = RC->getDef())
1262 CodeGenRegisterClass *CodeGenRegBank::getRegClass(Record *Def) {
2332 CodeGenRegBank::getRegClassForRegister(Record *R) {
2372 CodeGenRegBank::getMinimalPhysRegClass(Record *RegRecord,
2386 BitVector CodeGenRegBank::computeCoveredRegisters(ArrayRef<Record*> Regs) {
utils/TableGen/CodeGenRegisters.h 64 Record *const TheDef;
87 CodeGenSubRegIndex(Record *R, unsigned Enum);
151 Record *TheDef;
163 CodeGenRegister(Record *R, unsigned Enum);
295 std::vector<SmallVector<Record*, 16>> Orders;
301 Record *TheDef;
344 Record *getDef() const { return TheDef; }
426 ArrayRef<Record*> getOrder(unsigned No = 0) const {
444 CodeGenRegisterClass(CodeGenRegBank&, Record *R);
528 DenseMap<Record*, CodeGenSubRegIndex*> Def2SubRegIdx;
539 DenseMap<Record*, CodeGenRegister*> Def2Reg;
549 DenseMap<Record*, CodeGenRegisterClass*> Def2RC;
570 std::vector<std::unique_ptr<Record>> SynthDefs;
627 CodeGenSubRegIndex *getSubRegIdx(Record*);
645 CodeGenRegister *getReg(Record*);
707 CodeGenRegisterClass *getRegClass(Record*);
714 const CodeGenRegisterClass* getRegClassForRegister(Record *R);
721 getMinimalPhysRegClass(Record *RegRecord, ValueTypeByHwMode *VT = nullptr);
778 BitVector computeCoveredRegisters(ArrayRef<Record*> Regs);
utils/TableGen/CodeGenSchedule.cpp 238 DenseMap<StringRef, const Record *> Declarations;
242 for (const Record *R : Decls) {
258 for (const Record *R : Defs) {
287 const DenseMap<Record *, unsigned> &ProcModelMap) {
288 DenseMap<const Record *, unsigned> Opcode2Index;
289 using OpcodeMapPair = std::pair<const Record *, OpcodeInfo>;
293 DenseMap<const Record *, unsigned> Predicate2Index;
299 for (const Record *Def : Fn.getDefinitions()) {
301 for (const Record *EC : Classes) {
302 const Record *Pred = EC->getValueAsDef("Predicate");
307 for (const Record *Opcode : Opcodes) {
330 for (const Record *Def : Fn.getDefinitions()) {
332 const Record *SchedModel = Def->getValueAsDef("SchedModel");
337 for (const Record *EC : Classes) {
344 const Record *Pred = EC->getValueAsDef("Predicate");
348 for (const Record *Opcode : Opcodes) {
403 DenseMap<const Record *, unsigned> Decl2Index;
406 for (const Record *R : RV) {
407 const Record *Decl = R->getValueAsDef("Declaration");
428 const Record *Predicate) {
446 llvm::StringMap<const Record *> TIIPredicates(MCPredicates.size());
447 for (const Record *TIIPred : MCPredicates) {
449 StringMap<const Record *>::const_iterator It = TIIPredicates.find(Name);
467 for (Record *RCU : Units) {
482 for (Record *Queue : Queues) {
531 Record *NoModelDef = Records.getDef("NoSchedModel");
532 Record *NoItinsDef = Records.getDef("NoItineraries");
538 for (Record *ProcRecord : ProcRecords)
544 void CodeGenSchedModels::addProcModel(Record *ProcDef) {
545 Record *ModelKey = getModelOrItinDef(ProcDef);
551 Record *ItinsDef = ModelKey->getValueAsDef("Itineraries");
565 static void scanSchedRW(Record *RWDef, RecVec &RWDefs,
566 SmallPtrSet<Record*, 16> &RWSet) {
573 for (Record *WSRec : Seq)
579 for (Record *Variant : Vars) {
582 for (Record *SelDef : Selected)
595 SmallPtrSet<Record*, 16> RWSet;
600 Record *SchedDef = Inst->TheDef;
604 for (Record *RW : RWs) {
615 for (Record *InstRWDef : InstRWDefs) {
618 for (Record *RWDef : RWDefs) {
629 for (Record *ItinRWDef : ItinRWDefs) {
632 for (Record *RWDef : RWDefs) {
645 for (Record *ADef : AliasDefs) {
646 Record *MatchDef = ADef->getValueAsDef("MatchRW");
647 Record *AliasDef = ADef->getValueAsDef("AliasRW");
663 for (Record *SWDef : SWDefs) {
668 for (Record *SRDef : SRDefs) {
680 for (Record *ADef : AliasDefs) {
681 Record *AliasDef = ADef->getValueAsDef("AliasRW");
683 Record *MatchDef = ADef->getValueAsDef("MatchRW");
723 unsigned CodeGenSchedModels::getSchedRWIdx(const Record *Def,
731 bool CodeGenSchedModels::hasReadOfWrite(Record *WriteDef) const {
733 Record *ReadDef = Read.TheDef;
747 for (Record *RWDef : RWDefs) {
770 for (Record *RWDef : RWDefs) {
800 Record *AliasDef = nullptr;
801 for (const Record *Rec : SchedWrite.Aliases) {
804 Record *ModelDef = Rec->getValueAsDef("SchedModel");
876 Record *ItinDef = Inst->TheDef->getValueAsDef("Itinerary");
889 for (Record *RWDef : InstRWDefs)
936 for (Record *RWDef : RWDefs) {
974 CodeGenSchedModels::createSchedClassName(Record *ItinClassDef,
1007 unsigned CodeGenSchedModels::addSchedClass(Record *ItinClassDef,
1043 void CodeGenSchedModels::createInstRWClass(Record *InstRWDef) {
1048 SmallMapVector<unsigned, SmallVector<Record *, 8>, 4> ClassInstrs;
1054 for (Record *InstDef : *InstDefs) {
1065 ArrayRef<Record*> InstDefs = Entry.second;
1079 Record *RWModelDef = InstRWDef->getValueAsDef("SchedModel");
1082 for (Record *RWD : RWDefs) {
1085 for (Record *Inst : InstDefs) {
1118 Record *RWModelDef = InstRWDef->getValueAsDef("SchedModel");
1119 for (Record *OldRWDef : SchedClasses[OldSCIdx].InstRWs) {
1121 for (Record *InstDef : InstDefs) {
1137 for (Record *InstDef : InstDefs)
1166 for (Record *ItinData : ItinRecords) {
1167 const Record *ItinDef = ItinData->getValueAsDef("TheClass");
1200 for (Record *RWDef : ItinRWDefs) {
1203 Record *ModelDef = RWDef->getValueAsDef("SchedModel");
1216 for (Record *Pred : ProcModel.ModelDef->getValueAsListOfDefs("UnsupportedFeatures")) {
1247 void CodeGenSchedModels::inferFromItinClass(Record *ItinClassDef,
1253 for (const Record *Rec : PM.ItinRWDefs) {
1273 Record *Rec = SchedClasses[SCIdx].InstRWs[I];
1295 Record *VarOrSeqDef; // Variant or sequence.
1300 TransVariant(Record *def, unsigned rwi, unsigned pi, unsigned ti):
1309 Record *Predicate;
1311 PredCheck(bool r, unsigned w, Record *p): IsRead(r), RWIdx(w), Predicate(p) {}
1343 bool mutuallyExclusive(Record *PredDef, ArrayRef<PredCheck> Term);
1361 bool PredTransitions::mutuallyExclusive(Record *PredDef,
1383 for (Record *Alias : RW.Aliases) {
1430 Record *ModelDef = SchedRW.TheDef->getValueAsDef("SchedModel");
1435 for (Record *VarDef : VarDefs)
1447 Record *ModelDef = (*AI)->getValueAsDef("SchedModel");
1455 for (Record *VD : VarDefs)
1482 Record *PredDef = Variant.VarOrSeqDef->getValueAsDef("Predicate");
1517 Record *PredDef = VInfo.VarOrSeqDef->getValueAsDef("Predicate");
1790 for (Record *RF : RegisterFileDefs) {
1843 for (Record *RW : SC.InstRWs) {
1844 Record *RWModelDef = RW->getValueAsDef("SchedModel");
1855 for (Record *WR : WRDefs) {
1856 Record *ModelDef = WR->getValueAsDef("SchedModel");
1860 for (Record *SWR : SWRDefs) {
1861 Record *ModelDef = SWR->getValueAsDef("SchedModel");
1865 for (Record *RA : RADefs) {
1866 Record *ModelDef = RA->getValueAsDef("SchedModel");
1870 for (Record *SRA : SRADefs) {
1872 Record *ModelDef = SRA->getValueAsDef("SchedModel");
1879 for (Record *PRG : ProcResGroups) {
1887 for (Record *PRU : Records.getAllDerivedDefinitions("ProcResourceUnits")) {
1987 void CodeGenSchedModels::collectItinProcResources(Record *ItinClassDef) {
2055 Record *CodeGenSchedModels::findProcResUnits(Record *ProcResKind,
2055 Record *CodeGenSchedModels::findProcResUnits(Record *ProcResKind,
2061 Record *ProcUnitDef = nullptr;
2065 for (Record *ProcResDef : ProcResourceDefs) {
2076 for (Record *ProcResGroup : ProcResGroups) {
2096 void CodeGenSchedModels::addProcResource(Record *ProcResKind,
2100 Record *ProcResUnits = findProcResUnits(ProcResKind, PM, Loc);
2118 void CodeGenSchedModels::addWriteRes(Record *ProcWriteResDef, unsigned PIdx) {
2135 void CodeGenSchedModels::addReadAdvance(Record *ProcReadAdvanceDef,
2143 unsigned CodeGenProcModel::getProcResourceIdx(Record *PRDef) const {
2153 for (const Record *TheDef : UnsupportedFeaturesDefs) {
2154 for (const Record *PredDef : Inst.TheDef->getValueAsListOfDefs("Predicates")) {
utils/TableGen/CodeGenSchedule.h 31 using RecVec = std::vector<Record*>;
32 using RecIter = std::vector<Record*>::const_iterator;
47 Record *TheDef;
59 CodeGenSchedRW(unsigned Idx, Record *Def)
128 Record *ItinClassDef;
143 CodeGenSchedClass(unsigned Index, std::string Name, Record *ItinClassDef)
146 bool isKeyEqual(Record *IC, ArrayRef<unsigned> W,
167 Record *RCDef;
170 CodeGenRegisterCost(Record *RC, unsigned RegisterCost, bool AllowMoveElim = false)
183 Record *RegisterFileDef;
190 CodeGenRegisterFile(StringRef name, Record *def, unsigned MaxMoveElimPerCy = 0,
217 Record *ModelDef;
218 Record *ItinsDef;
246 Record *RetireControlUnit;
249 Record *LoadQueue;
250 Record *StoreQueue;
252 CodeGenProcModel(unsigned Idx, std::string Name, Record *MDef,
253 Record *IDef) :
270 unsigned getProcResourceIdx(Record *PRDef) const;
315 const Record *Predicate; // MCInstrPredicate definition.
316 PredicateInfo(llvm::APInt CpuMask, llvm::APInt Operands, const Record *Pred)
344 const Record *Predicate);
351 std::vector<const Record *> Opcodes;
360 void addOpcode(const Record *Opcode) {
366 ArrayRef<const Record *> getOpcodes() const { return Opcodes; }
374 const Record *FunctionDeclaration;
376 std::vector<const Record *> Definitions;
383 STIPredicateFunction(const Record *Rec) : FunctionDeclaration(Rec) {}
390 void addDefinition(const Record *Def) { Definitions.push_back(Def); }
391 void addOpcode(const Record *OpcodeRec, OpcodeInfo &&Info) {
401 const Record *getDefaultReturnPredicate() const {
405 const Record *getDeclaration() const { return FunctionDeclaration; }
406 ArrayRef<const Record *> getDefinitions() const { return Definitions; }
422 using ProcModelMapTy = DenseMap<Record*, unsigned>;
440 using InstClassMapTy = DenseMap<Record*, unsigned>;
468 Record *getModelOrItinDef(Record *ProcDef) const {
468 Record *getModelOrItinDef(Record *ProcDef) const {
469 Record *ModelDef = ProcDef->getValueAsDef("SchedModel");
470 Record *ItinsDef = ProcDef->getValueAsDef("ProcItin");
479 const CodeGenProcModel &getModelForProc(Record *ProcDef) const {
480 Record *ModelDef = getModelOrItinDef(ProcDef);
486 CodeGenProcModel &getProcModel(Record *ModelDef) {
491 const CodeGenProcModel &getProcModel(Record *ModelDef) const {
520 CodeGenSchedRW &getSchedRW(Record *Def) {
526 const CodeGenSchedRW &getSchedRW(Record *Def) const {
530 unsigned getSchedRWIdx(const Record *Def, bool IsRead) const;
533 bool hasReadOfWrite(Record *WriteDef) const;
563 unsigned addSchedClass(Record *ItinDef, ArrayRef<unsigned> OperWrites,
569 Record *findProcResUnits(Record *ProcResKind, const CodeGenProcModel &PM,
569 Record *findProcResUnits(Record *ProcResKind, const CodeGenProcModel &PM,
579 void addProcModel(Record *ProcDef);
594 std::string createSchedClassName(Record *ItinClassDef,
598 void createInstRWClass(Record *InstRWDef);
620 void inferFromItinClass(Record *ItinClassDef, unsigned FromClassIdx);
628 void collectItinProcResources(Record *ItinClassDef);
636 void addProcResource(Record *ProcResourceKind, CodeGenProcModel &PM,
639 void addWriteRes(Record *ProcWriteResDef, unsigned PIdx);
641 void addReadAdvance(Record *ProcReadAdvanceDef, unsigned PIdx);
utils/TableGen/CodeGenTarget.cpp 45 MVT::SimpleValueType llvm::getValueType(Record *Rec) {
206 std::string llvm::getQualifiedName(const Record *R) {
219 std::vector<Record*> Targets = Records.getAllDerivedDefinitions("Target");
245 Record *CodeGenTarget::getInstructionSet() const {
255 Record *CodeGenTarget::getAsmParser() const {
256 std::vector<Record*> LI = TargetRec->getValueAsListOfDefs("AssemblyParsers");
266 Record *CodeGenTarget::getAsmParserVariant(unsigned i) const {
267 std::vector<Record*> LI =
279 std::vector<Record*> LI =
286 Record *CodeGenTarget::getAsmWriter() const {
287 std::vector<Record*> LI = TargetRec->getValueAsListOfDefs("AssemblyWriters");
362 std::vector<ValueTypeByHwMode> CodeGenTarget::getRegisterVTs(Record *R)
400 std::vector<Record*> Insts = Records.getAllDerivedDefinitions("Instruction");
411 const DenseMap<const Record*,
414 const Record *Rec = Records.getDef(Name);
460 const auto &D1 = *Rec1->TheDef;
461 const auto &D2 = *Rec2->TheDef;
481 std::vector<Record *> Insts =
483 for (Record *R : Insts) {
526 ComplexPattern::ComplexPattern(Record *R) {
545 std::vector<Record*> PropList = R->getValueAsListOfDefs("Properties");
579 std::vector<Record*> Defs = RC.getAllDerivedDefinitions("Intrinsic");
602 CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
666 Record *TyEl = TypeList->getElementAsRecord(i);
683 Record *TyEl = TypeList->getElementAsRecord(i);
714 Record *TyEl = TypeList->getElementAsRecord(i);
750 Record *Property = PropList->getElementAsRecord(i);
utils/TableGen/CodeGenTarget.h 36 MVT::SimpleValueType getValueType(Record *Rec);
43 std::string getQualifiedName(const Record *R);
49 Record *TargetRec;
51 mutable DenseMap<const Record*,
54 mutable std::vector<Record*> RegAltNameIndices;
69 Record *getTargetRecord() const { return TargetRec; }
78 Record *getInstructionSet() const;
87 Record *getAsmParser() const;
92 Record *getAsmParserVariant(unsigned i) const;
101 Record *getAsmWriter() const;
116 const std::vector<Record*> &getRegAltNameIndices() const {
121 const CodeGenRegisterClass &getRegisterClass(Record *R) const {
127 std::vector<ValueTypeByHwMode> getRegisterVTs(Record *R) const;
140 DenseMap<const Record*, std::unique_ptr<CodeGenInstruction>> &
147 CodeGenInstruction &getInstruction(const Record *InstRec) const {
203 std::vector<Record*> RootNodes;
207 ComplexPattern(Record *R);
212 const std::vector<Record*> &getRootNodes() const {
utils/TableGen/DAGISelEmitter.cpp 45 Record *Op = P->getOperator();
64 Record *Op = P->getOperator();
utils/TableGen/DAGISelMatcher.h 963 Record *NodeXForm;
965 EmitNodeXFormMatcher(unsigned slot, Record *nodeXForm)
969 Record *getNodeXForm() const { return NodeXForm; }
utils/TableGen/DAGISelMatcherEmitter.cpp 65 DenseMap<Record*, unsigned> NodeXFormMap;
66 std::vector<Record*> NodeXForms;
148 unsigned getNodeXFormID(Record *Rec) {
202 static std::string getIncludePath(const Record *R) {
710 Record *PatRecord = SNT->getPattern().getSrcRecord();
787 Record *PatRecord = CM->getPattern().getSrcRecord();
955 Record *SDNode = Entry.first;
utils/TableGen/DAGISelMatcherGen.cpp 23 static MVT::SimpleValueType getRegisterValueType(Record *R,
92 SmallVector<std::pair<Record*, unsigned>, 2> PhysRegInputs;
230 Record *LeafRec = DI->getDef();
564 const std::vector<Record*> &OpNodes = CP->getRootNodes();
679 Record *Def = DI->getDef();
732 Record *Op = N->getOperator();
744 Record *OpRec = N->getOperator();
761 Record *Op = N->getOperator();
812 Record *OperandNode = II.Operands[InstOpNo].Rec;
897 Record *HandledReg = nullptr;
901 for (Record *Reg : Pattern.getDstRegs()) {
1002 Record *OpRec = N->getOperator();
1034 Record *HandledReg = nullptr;
1044 for (Record *Reg : Pattern.getDstRegs()) {
utils/TableGen/DFAEmitter.cpp 172 Record *R = nullptr;
177 Action(Record *R, unsigned I, std::string S) : R(R), I(I), S(S) {}
204 Transition(Record *R, Automaton *Parent);
214 Record *R;
222 Automaton(RecordKeeper &Records, Record *R);
254 for (Record *R : Records.getAllDerivedDefinitions("GenericAutomaton")) {
262 Automaton::Automaton(RecordKeeper &Records, Record *R)
270 for (Record *T : Records.getAllDerivedDefinitions(TransitionClass)) {
326 Transition::Transition(Record *R, Automaton *Parent) {
utils/TableGen/DFAPacketizerEmitter.cpp 125 int collectAllFuncUnits(std::vector<Record*> &ProcItinList,
134 int collectAllComboFuncs(std::vector<Record*> &ComboFuncList,
143 std::vector<Record*> &ProcItinList,
145 Record *ItinData,
153 std::vector<Record*> &ProcItinList,
155 std::vector<Record*> &ItinDataList,
161 std::vector<Record *> &ProcItinList,
202 std::vector<Record*> &ProcItinList,
214 Record *Proc = ProcItinList[i];
215 std::vector<Record*> FUs = Proc->getValueAsListOfDefs("FU");
244 std::vector<Record*> &ComboFuncList,
255 Record *Func = ComboFuncList[i];
256 std::vector<Record*> FUs = Func->getValueAsListOfDefs("CFD");
265 Record *FuncData = FUs[j];
266 Record *ComboFunc = FuncData->getValueAsDef("TheComboFunc");
267 const std::vector<Record*> &FuncList =
295 std::vector<Record*> &ProcItinList,
297 Record *ItinData,
299 const std::vector<Record*> &StageList =
312 const Record *Stage = StageList[i];
315 const std::vector<Record*> &UnitList =
361 std::vector<Record*> &ProcItinList,
363 std::vector<Record*> &ItinDataList,
377 Record *ItinData = ItinDataList[j];
403 std::vector<Record*> ProcItinList =
406 std::unordered_map<std::string, std::vector<Record*>> ItinsByNamespace;
407 for (Record *R : ProcItinList)
416 raw_ostream &OS, std::vector<Record *> &ProcItinList,
430 std::vector<Record*> ComboFuncList =
440 Record *Proc = ProcItinList[i];
456 std::vector<Record*> ItinDataList = Proc->getValueAsListOfDefs("IID");
utils/TableGen/ExegesisEmitter.cpp 52 void emitPfmCountersInfo(const Record &Def,
74 for (Record *Def : Records.getAllDerivedDefinitions("ProcPfmCounters")) {
77 for (const Record *IssueCounter :
99 std::vector<Record *> Targets = Records.getAllDerivedDefinitions("Target");
107 void ExegesisEmitter::emitPfmCountersInfo(const Record &Def,
164 for (const Record *Def : PfmCounterDefs) {
165 for (const Record *ICDef : Def->getValueAsListOfDefs("IssueCounters"))
175 for (const Record *Def : PfmCounterDefs)
182 std::vector<Record *> Bindings =
191 for (Record *Binding : Bindings) {
utils/TableGen/FastISelEmitter.cpp 224 Record *Rec = PredFn.getOrigPatFragRecord()->getRecord();
261 Record *OpLeafRec = OpDI->getDef();
416 static std::string getOpcodeName(Record *Op, CodeGenDAGPatterns &CGP) {
436 Record *OpLeafRec = cast<DefInit>(Op->getLeafValue())->getDef();
459 Record *Op = Dst->getOperator();
492 Record *Op0Rec = II.Operands[0].Rec;
520 Record *InstPatOp = InstPatNode->getOperator();
utils/TableGen/FixedLenDecoderEmitter.cpp 99 const Record *EncodingDef;
103 EncodingAndInst(const Record *EncodingDef, const CodeGenInstruction *Inst,
219 static BitsInit &getBitsField(const Record &def, StringRef str) {
441 const Record *EncodingDef = AllInstructions[Opcode].EncodingDef;
442 const Record *InstDef = AllInstructions[Opcode].Inst->TheDef;
1201 Record *Pred = Predicates->getElementAsRecord(i);
1229 Record *Pred = Predicates->getElementAsRecord(i);
1770 Record *Record = cast<DefInit>(TI)->getDef();
1795 populateInstruction(CodeGenTarget &Target, const Record &EncodingDef,
1798 const Record &Def = *CGI.TheDef;
1934 Record *TypeRecord = CGI.Operands[SO.first].Rec;
2026 Record *TypeRecord = cast<DefInit>(TI)->getDef();
2391 DenseMap<Record *, unsigned> IndexOfInstruction;
2443 const Record *EncodingDef = NumberedEncodings[i].EncodingDef;
2445 const Record *Def = Inst->TheDef;
utils/TableGen/GICombinerEmitter.cpp 62 const Record &TheDef;
74 CombineRule(const CodeGenTarget &Target, RuleID ID, const Record &R)
81 const Record &getDef() const { return TheDef; }
107 static Record *getDefOfSubClass(const Init &N, StringRef Cls) {
191 Record *Combiner;
193 std::unique_ptr<CombineRule> makeCombineRule(const Record &R);
196 const std::vector<Record *> &&RulesAndGroups);
200 StringRef Name, Record *Combiner);
217 StringRef Name, Record *Combiner)
247 GICombinerEmitter::makeCombineRule(const Record &TheDef) {
267 const std::vector<Record *> &&RulesAndGroups) {
268 for (Record *R : RulesAndGroups) {
286 const Record &RuleDef = Rule->getDef();
447 Record *CombinerDef = RK.getDef(Combiner);
utils/TableGen/GlobalISelEmitter.cpp 230 if (Record *VT = P.getMemoryVT())
232 if (Record *VT = P.getScalarMemoryVT())
278 std::string explainOperator(Record *Operator) {
374 static Record *getInitValueAsRegClass(Init *V) {
385 getNameForFeatureBitset(const std::vector<Record *> &FeatureBitset) {
834 DenseMap<Record *, OperandMatcher *> PhysRegOperands;
845 std::vector<Record *> RequiredFeatures;
850 typedef std::tuple<Record *, unsigned, unsigned>
872 void addRequiredFeature(Record *Feature);
873 const std::vector<Record *> &getRequiredFeatures() const;
918 void definePhysRegOperand(Record *Reg, OperandMatcher &OM);
920 Error defineComplexSubOperand(StringRef SymbolicName, Record *ComplexPattern,
943 const OperandMatcher &getPhysRegOperandMatcher(Record *) const;
1263 const Record &TheDef;
1272 const Record &TheDef)
1506 Optional<Kind *> addPredicate(Args &&... args) {
2049 SmallVector<std::pair<Record *, unsigned>, 2> PhysRegInputs;
2092 OperandMatcher &addPhysRegInput(Record *Reg, unsigned OpIdx,
2102 ArrayRef<std::pair<Record *, unsigned>> getPhysRegInputs() const {
2374 Record *PhysReg;
2377 CopyPhysRegRenderer(unsigned NewInsnID, Record *Reg)
2387 Record *getPhysReg() const { return PhysReg; }
2409 const Record *ZeroRegisterDef;
2413 StringRef SymbolicName, Record *ZeroRegisterDef)
2546 const Record *RegisterDef;
2550 AddRegisterRenderer(unsigned InsnID, const Record *RegisterDef,
2659 const Record &TheDef;
2674 RenderComplexPatternOperand(unsigned InsnID, const Record &TheDef,
2701 const Record &Renderer;
2706 CustomRenderer(unsigned InsnID, const Record &Renderer,
2805 Kind &addRenderer(Args&&... args) {
2953 void RuleMatcher::addRequiredFeature(Record *Feature) {
2957 const std::vector<Record *> &RuleMatcher::getRequiredFeatures() const {
3012 void RuleMatcher::definePhysRegOperand(Record *Reg, OperandMatcher &OM) {
3029 RuleMatcher::getPhysRegOperandMatcher(Record *Reg) const {
3245 DenseMap<Record *, Record *> NodeEquivs;
3245 DenseMap<Record *, Record *> NodeEquivs;
3250 DenseMap<const Record *, const Record *> ComplexPatternEquivs;
3250 DenseMap<const Record *, const Record *> ComplexPatternEquivs;
3255 DenseMap<const Record *, const Record *> SDNodeXFormEquivs;
3255 DenseMap<const Record *, const Record *> SDNodeXFormEquivs;
3271 Record *findNodeEquiv(Record *N) const;
3271 Record *findNodeEquiv(Record *N) const;
3272 const CodeGenInstruction *getEquivNode(Record &Equiv,
3280 Error importComplexPatternOperandMatcher(OperandMatcher &OM, Record *R,
3311 const std::vector<Record *> &ImplicitDefs) const;
3316 std::function<bool(const Record *R)> Filter);
3319 std::function<bool(const Record *R)> Filter);
3326 void declareSubtargetFeature(Record *Predicate);
3399 for (Record *Equiv : RK.getAllDerivedDefinitions("GINodeEquiv"))
3403 for (Record *Equiv : RK.getAllDerivedDefinitions("GIComplexPatternEquiv")) {
3404 Record *SelDAGEquiv = Equiv->getValueAsDef("SelDAGEquivalent");
3411 for (Record *Equiv : RK.getAllDerivedDefinitions("GISDNodeXFormEquiv")) {
3412 Record *SelDAGEquiv = Equiv->getValueAsDef("SelDAGEquivalent");
3419 Record *GlobalISelEmitter::findNodeEquiv(Record *N) const {
3419 Record *GlobalISelEmitter::findNodeEquiv(Record *N) const {
3424 GlobalISelEmitter::getEquivNode(Record &Equiv, const TreePatternNode *N) const {
3467 Record *SrcGIEquivOrNull = nullptr;
3697 Record *CCDef = DI ? DI->getDef() : nullptr;
3758 OperandMatcher &OM, Record *R, unsigned &TempOpIdx) const {
3772 Record *&PhysReg) {
3776 auto *ChildRec = ChildDefInit->getDef();
3794 Record *PhysReg = nullptr;
3882 auto *ChildRec = ChildDefInit->getDef();
4017 auto *ChildRec = ChildDefInit->getDef();
4205 Record *DstOp = Dst->getOperator();
4249 Record *RCDef = getInitValueAsRegClass(Dst->getChild(0)->getLeafValue());
4277 Record *RCDef = getInitValueAsRegClass(Dst->getChild(0)->getLeafValue());
4400 const std::vector<Record *> &ImplicitDefs) const {
4410 Record *RCRec = getInitValueAsRegClass(Leaf->getLeafValue());
4433 Record *OpRec = N->getOperator();
4461 Record *DstIOpRec = DstIOperand.Rec;
4580 Record *RCDef = getInitValueAsRegClass(Dst->getLeafValue());
4611 Record *DstOp = Dst->getOperator();
4630 Record *DstIOpRec = DstIOperand.Rec;
4709 Record *DstIOpRec =
4813 std::function<bool(const Record *R)> Filter) {
4814 std::vector<const Record *> MatchedRecords;
4827 for (const auto *Record : MatchedRecords) {
4843 for (const auto *Record : MatchedRecords) {
4861 std::function<bool(const Record *R)> Filter) {
5057 std::vector<Record *> ComplexPredicates =
5061 std::vector<Record *> CustomRendererFns =
5162 std::vector<std::vector<Record *>> FeatureBitsets;
5323 void GlobalISelEmitter::declareSubtargetFeature(Record *Predicate) {
utils/TableGen/InfoByHwMode.cpp 32 ValueTypeByHwMode::ValueTypeByHwMode(Record *R, const CodeGenHwModes &CGH) {
41 ValueTypeByHwMode::ValueTypeByHwMode(Record *R, MVT T) : ValueTypeByHwMode(T) {
109 ValueTypeByHwMode llvm::getValueTypeByHwMode(Record *Rec,
122 RegSizeInfo::RegSizeInfo(Record *R, const CodeGenHwModes &CGH) {
144 RegSizeInfoByHwMode::RegSizeInfoByHwMode(Record *R,
195 EncodingInfoByHwMode::EncodingInfoByHwMode(Record *R, const CodeGenHwModes &CGH) {
utils/TableGen/InfoByHwMode.h 121 ValueTypeByHwMode(Record *R, const CodeGenHwModes &CGH);
122 ValueTypeByHwMode(Record *R, MVT T);
145 ValueTypeByHwMode getValueTypeByHwMode(Record *Rec,
153 RegSizeInfo(Record *R, const CodeGenHwModes &CGH);
169 RegSizeInfoByHwMode(Record *R, const CodeGenHwModes &CGH);
187 struct EncodingInfoByHwMode : public InfoByHwMode<Record*> {
188 EncodingInfoByHwMode(Record *R, const CodeGenHwModes &CGH);
utils/TableGen/InstrDocsEmitter.cpp 70 Record *Inst = II->TheDef;
83 Record *AsmVariant = Target.getAsmParserVariant(VarNum);
164 Record *SubRec =
195 for (Record *Def : II->ImplicitDefs) {
208 for (Record *Use : II->ImplicitUses) {
218 std::vector<Record *> Predicates =
223 for (Record *P : Predicates) {
utils/TableGen/InstrInfoEmitter.cpp 75 Record *InstrInfo,
76 std::map<std::vector<Record*>, unsigned> &EL,
97 static void PrintDefList(const std::vector<Record*> &Uses,
100 for (Record *U : Uses)
131 auto *OpR = cast<DefInit>(MIOI->getArg(j))->getDef();
137 Record *OpR = OperandList[j].Rec;
334 std::vector<Record *> Operands = Records.getAllDerivedDefinitions("Operand");
335 std::vector<Record *> RegisterOperands =
337 std::vector<Record *> RegisterClasses =
348 for (const std::vector<Record *> *RecordsToAdd :
350 for (const Record *Op : *RecordsToAdd) {
372 std::vector<Record *> OperandRecords;
409 Record *OpR = OperandRecords[I];
445 for (const Record *Rec : TIIPredicates) {
464 for (const Record *Rec : TIIPredicates) {
489 for (const Record *Rec : TIIPredicates) {
523 Record *InstrInfo = Target.getInstructionSet();
526 std::map<std::vector<Record*>, unsigned> EmittedLists;
531 Record *Inst = II->TheDef;
532 std::vector<Record*> Uses = Inst->getValueAsListOfDefs("Uses");
537 std::vector<Record*> Defs = Inst->getValueAsListOfDefs("Defs");
646 Record *InstrInfo,
647 std::map<std::vector<Record*>, unsigned> &EmittedLists,
724 std::vector<Record*> UseList = Inst.TheDef->getValueAsListOfDefs("Uses");
730 std::vector<Record*> DefList = Inst.TheDef->getValueAsListOfDefs("Defs");
utils/TableGen/IntrinsicEmitter.cpp 265 static void EncodeFixedType(Record *R, std::vector<unsigned char> &ArgCodes,
373 static void UpdateArgCodes(Record *R, std::vector<unsigned char> &ArgCodes,
utils/TableGen/OptParserEmitter.cpp 45 static int CompareOptionRecords(Record *const *Av, Record *const *Bv) {
45 static int CompareOptionRecords(Record *const *Av, Record *const *Bv) {
46 const Record *A = *Av;
47 const Record *B = *Bv;
90 static const std::string getOptionName(const Record &R) {
111 const std::vector<Record*> &Groups =
113 std::vector<Record*> Opts = Records.getAllDerivedDefinitions("Option");
125 const Record &R = *Opts[i];
162 const Record &R = *Groups[i];
208 const Record &R = *Opts[i];
306 const Record &R = *Opts[I];
utils/TableGen/PredicateExpander.cpp 62 const Record *Reg,
111 void PredicateExpander::expandCheckOpcode(raw_ostream &OS, const Record *Inst) {
131 for (const Record *Rec : Opcodes) {
169 for (const Record *Rec : Sequence) {
217 const Record *Rec) {
229 const Record *Rec) {
231 for (const Record *Opcode : Opcodes) {
245 const Record *Default) {
250 for (const Record *Rec : Cases) {
271 void PredicateExpander::expandStatement(raw_ostream &OS, const Record *Rec) {
287 void PredicateExpander::expandPredicate(raw_ostream &OS, const Record *Rec) {
377 const Record *Rec = Fn.getDeclaration();
410 for (const Record *Delegate : Delegates) {
482 for (const Record *Opcode : Group.getOpcodes()) {
517 const Record *Rec = Fn.getDeclaration();
utils/TableGen/PredicateExpander.h 55 using RecVec = std::vector<Record *>;
64 void expandCheckRegOperand(raw_ostream &OS, int OpIndex, const Record *Reg,
70 void expandCheckOpcode(raw_ostream &OS, const Record *Inst);
83 void expandPredicate(raw_ostream &OS, const Record *Rec);
84 void expandReturnStatement(raw_ostream &OS, const Record *Rec);
85 void expandOpcodeSwitchCase(raw_ostream &OS, const Record *Rec);
87 const Record *Default);
88 void expandStatement(raw_ostream &OS, const Record *Rec);
utils/TableGen/PseudoLoweringEmitter.cpp 32 Record *Reg; // Physical register.
54 unsigned addDagOperandMapping(Record *Rec, DagInit *Dag,
58 void evaluateExpansion(Record *Pseudo);
73 addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn,
121 void PseudoLoweringEmitter::evaluateExpansion(Record *Rec) {
134 Record *Operator = OpDef->getDef();
239 Record *Reg = Expansion.OperandMap[MIOpNo + i].Data.Reg;
274 Record *ExpansionClass = Records.getClass("PseudoInstExpansion");
275 Record *InstructionClass = Records.getClass("Instruction");
279 std::vector<Record*> Insts;
utils/TableGen/RISCVCompressInstEmitter.cpp 81 Record *Reg; // Physical register.
88 std::vector<Record *>
97 std::vector<Record *> RF, IndexedMap<OpData> &SourceMap,
107 void addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Inst,
109 void evaluateCompressPat(Record *Compress);
111 bool validateTypes(Record *SubType, Record *Type, bool IsSourceInst);
111 bool validateTypes(Record *SubType, Record *Type, bool IsSourceInst);
112 bool validateRegister(Record *Reg, Record *RegClass);
112 bool validateRegister(Record *Reg, Record *RegClass);
113 void createDagOperandMapping(Record *Rec, StringMap<unsigned> &SourceOperands,
118 void createInstOperandMapping(Record *Rec, DagInit *SourceDag,
132 bool RISCVCompressInstEmitter::validateRegister(Record *Reg, Record *RegClass) {
132 bool RISCVCompressInstEmitter::validateRegister(Record *Reg, Record *RegClass) {
143 bool RISCVCompressInstEmitter::validateTypes(Record *DagOpType,
144 Record *InstOpType,
183 Record *Rec, DagInit *Dag, CodeGenInstruction &Inst,
293 Record *Rec, StringMap<unsigned> &SourceOperands,
340 Record *Rec, DagInit *SourceDag, DagInit *DestDag,
408 void RISCVCompressInstEmitter::evaluateCompressPat(Record *Rec) {
415 Record *Operator = SourceDag->getOperatorAsDef(Rec->getLoc());
427 Record *DestOperator = DestDag->getOperatorAsDef(Rec->getLoc());
459 std::vector<Record *> PatReqFeatures;
460 std::vector<Record *> RF = Rec->getValueAsListOfDefs("Predicates");
470 const std::vector<Record *> &ReqFeatures) {
485 unsigned getMCOpPredicate(DenseMap<const Record *, unsigned> &MCOpPredicateMap,
486 std::vector<const Record *> &MCOpPredicates,
487 Record *Rec) {
523 Record *AsmWriter = Target.getAsmWriter();
547 std::vector<const Record *> MCOpPredicates;
548 DenseMap<const Record *, unsigned> MCOpPredicateMap;
618 std::vector<Record *> ReqFeatures;
619 std::vector<Record *> RF = Dest.TheDef->getValueAsListOfDefs("Predicates");
664 Record *Reg = SourceOperandMap[OpNo].Data.Reg;
723 Record *Reg = DestOperandMap[OpNo].Data.Reg;
776 Record *CompressClass = Records.getClass("CompressPat");
778 std::vector<Record *> Insts;
utils/TableGen/RegisterBankEmitter.cpp 34 const Record &TheDef;
43 RegisterBank(const Record &TheDef)
59 const Record &getDef() const { return TheDef; }
278 std::vector<Record*> Targets = Records.getAllDerivedDefinitions("Target");
utils/TableGen/RegisterInfoEmitter.cpp 154 const std::vector<Record*> &RegAltNameIndices = Target.getRegAltNameIndices();
342 using DwarfRegNumsMapPair = std::pair<Record*, std::vector<int64_t>>;
351 const Record *LastSeenReg = nullptr;
378 Record *Reg = RE.TheDef;
411 std::map<uint64_t, Record*> Dwarf2LMap;
420 for (std::map<uint64_t, Record*>::iterator
444 Record *Reg = RE.TheDef;
450 Record *Alias = DI->getDef();
511 Record *Reg = RE.TheDef;
1038 ArrayRef<Record*> Order = RC.getOrder();
1049 for (Record *Reg : Order) {
1058 for (Record *Reg : Order) {
1095 Record *Reg = RE.TheDef;
1218 std::set<Record*> AllocatableRegs;
1222 ArrayRef<Record*> Order = RC.getOrder();
1372 ArrayRef<Record*> Elems = RC.getOrder(oi);
1534 std::vector<Record*> CSRSets =
1537 Record *CSRSet = CSRSets[i];
1572 for (Record *CSRSet : CSRSets)
1585 for (Record *CSRSet : CSRSets)
utils/TableGen/SDNodeProperties.cpp 15 unsigned llvm::parseSDPatternOperatorProperties(Record *R) {
17 for (Record *Property : R->getValueAsListOfDefs("Properties")) {
utils/TableGen/SDNodeProperties.h 35 unsigned parseSDPatternOperatorProperties(Record *R);
utils/TableGen/SearchableTableEmitter.cpp 39 int getInt(Record *R, StringRef Field) {
47 Record *Class;
50 DenseMap<Record *, Entry *> EntryMap;
74 std::vector<Record *> Entries;
92 DenseMap<Record *, GenericEnum *> EnumMap;
141 bool compareBy(Record *LHS, Record *RHS, const SearchIndex &Index);
141 bool compareBy(Record *LHS, Record *RHS, const SearchIndex &Index);
186 const std::vector<Record *> &Items);
188 const std::vector<Record *> &Items);
195 static int64_t getNumericKey(const SearchIndex &Index, Record *Rec) {
199 Record *EnumEntry = Rec->getValueAsDef(Index.Fields[0].Name);
208 bool SearchableTableEmitter::compareBy(Record *LHS, Record *RHS,
208 bool SearchableTableEmitter::compareBy(Record *LHS, Record *RHS,
232 Record *LHSr = cast<DefInit>(LHSI)->getDef();
233 Record *RHSr = cast<DefInit>(RHSI)->getDef();
301 std::vector<Record *> IndexRowsStorage;
302 ArrayRef<Record *> IndexRows;
321 std::vector<std::pair<Record *, unsigned>> Entries;
501 Record *Entry = Table.Entries[i];
529 Record *TypeRec = DI->getDef();
568 const std::vector<Record *> &Items) {
597 GenericTable &Table, const std::vector<Record *> &Items) {
623 Record *IntrinsicClass = Records.getClass("Intrinsic");
624 Record *InstructionClass = Records.getClass("Instruction");
638 DenseMap<Record *, GenericTable *> TableMap;
705 for (Record *IndexRec : Records.getAllDerivedDefinitions("SearchIndex")) {
706 Record *TableRec = IndexRec->getValueAsDef("Table");
721 Record *SearchableTable = Records.getClass("SearchableTable");
723 Record *Class = NameRec.second.get();
729 std::vector<Record *> Items = Records.getAllDerivedDefinitions(TableName);
utils/TableGen/SubtargetEmitter.cpp 76 void Enumeration(raw_ostream &OS, DenseMap<Record *, unsigned> &FeatureMap);
78 const DenseMap<Record *, unsigned> &FeatureMap);
80 const DenseMap<Record *, unsigned> &FeatureMap);
82 Record *ItinData, std::string &ItinString,
84 void FormItineraryOperandCycleString(Record *ItinData, std::string &ItinString,
87 Record *ItinData,
101 void EmitProcessorProp(raw_ostream &OS, const Record *R, StringRef Name,
107 Record *FindWriteResources(const CodeGenSchedRW &SchedWrite,
109 Record *FindReadAdvance(const CodeGenSchedRW &SchedRead,
143 DenseMap<Record *, unsigned> &FeatureMap) {
145 std::vector<Record*> DefList =
163 Record *Def = DefList[i];
181 const DenseMap<Record *, unsigned> &FeatureMap) {
202 raw_ostream &OS, const DenseMap<Record *, unsigned> &FeatureMap) {
204 std::vector<Record*> FeatureList =
221 Record *Feature = FeatureList[i];
255 const DenseMap<Record *, unsigned> &FeatureMap) {
257 std::vector<Record*> ProcessorList =
267 for (Record *Processor : ProcessorList) {
295 Record *ItinData,
305 const Record *Stage = StageList[i];
338 void SubtargetEmitter::FormItineraryOperandCycleString(Record *ItinData,
356 Record *ItinData,
382 SmallPtrSet<Record*, 8> ItinsDefSet;
457 Record *ItinData = ProcModel.ItinDefList[SchedClassIdx];
557 SmallPtrSet<Record*, 8> ItinsDefSet;
565 Record *ItinsDef = PI->ItinsDef;
608 void SubtargetEmitter::EmitProcessorProp(raw_ostream &OS, const Record *R,
626 Record *PRDef = ProcModel.ProcResourceDefs[i];
630 for (Record *RUDef : ResUnits) {
631 Record *const RU =
645 if (Record *RCU = ProcModel.RetireControlUnit) {
693 Record *Rec = RC.RCDef;
729 const Record *Queue = ProcModel.LoadQueue->getValueAsDef("QueueDescriptor");
739 const Record *Queue =
785 Record *PRDef = ProcModel.ProcResourceDefs[i];
787 Record *SuperDef = nullptr;
794 for (Record *RU : ResUnits) {
830 Record *SubtargetEmitter::FindWriteResources(
838 Record *AliasDef = nullptr;
839 for (Record *A : SchedWrite.Aliases) {
843 Record *ModelDef = AliasRW.TheDef->getValueAsDef("SchedModel");
857 Record *ResDef = nullptr;
858 for (Record *WR : ProcModel.WriteResDefs) {
883 Record *SubtargetEmitter::FindReadAdvance(const CodeGenSchedRW &SchedRead,
890 Record *AliasDef = nullptr;
891 for (Record *A : SchedRead.Aliases) {
895 Record *ModelDef = AliasRW.TheDef->getValueAsDef("SchedModel");
909 Record *ResDef = nullptr;
910 for (Record *RA : ProcModel.ReadAdvanceDefs) {
940 Record *PRDef = PRVec[i];
947 for (Record *SubDef = PRDef;
954 Record *SuperDef =
962 for (Record *PR : PM.ProcResourceDefs) {
1031 Record *RWDef = nullptr;
1032 for (Record *RW : SC.InstRWs) {
1033 Record *RWModelDef = RW->getValueAsDef("SchedModel");
1048 for (Record *I : ProcModel.ItinRWDefs) {
1088 Record *WriteRes =
1153 Record *ReadAdvance =
1168 for (Record *VW : ValidWrites) {
1435 std::vector<Record *> Prologs =
1438 for (Record *P : Prologs)
1468 for (const Record *Rec : T.PredTerm) {
1686 std::vector<Record*> Features =
1706 for (Record *R : Features) {
1790 DenseMap<Record *, unsigned> FeatureMap;
utils/TableGen/SubtargetFeatureInfo.cpp 25 std::vector<std::pair<Record *, SubtargetFeatureInfo>>
27 std::vector<std::pair<Record *, SubtargetFeatureInfo>> SubtargetFeatures;
28 std::vector<Record *> AllPredicates =
30 for (Record *Pred : AllPredicates) {
utils/TableGen/SubtargetFeatureInfo.h 24 using SubtargetFeatureInfoMap = std::map<Record *, SubtargetFeatureInfo, LessRecordByID>;
30 Record *TheDef;
35 SubtargetFeatureInfo(Record *D, uint64_t Idx) : TheDef(D), Index(Idx) {}
53 static std::vector<std::pair<Record *, SubtargetFeatureInfo>>
utils/TableGen/TableGen.cpp 209 for (Record *Rec : Records.getAllDerivedDefinitions(Class))
218 for (Record *Rec : Records.getAllDerivedDefinitions("Set")) {
220 const std::vector<Record*> *Elts = Sets.expand(Rec);
222 for (Record *Elt : *Elts)
utils/TableGen/WebAssemblyDisassemblerEmitter.cpp 33 auto &Def = *CGI.TheDef;
utils/TableGen/X86EVEX2VEXTablesEmitter.cpp 92 Record *RecE = EVEXInst->TheDef;
93 Record *RecV = VEXInst->TheDef;
123 Record *OpRec1 = EVEXInst->Operands[i].Rec;
124 Record *OpRec2 = VEXInst->Operands[i].Rec;
146 static inline bool isRegisterOperand(const Record *Rec) {
151 static inline bool isMemoryOperand(const Record *Rec) {
156 static inline bool isImmediateOperand(const Record *Rec) {
161 static inline unsigned int getRegOperandSize(const Record *RegRec) {
208 Record *AltInstRec = Records.getDef(AltInstStr);
utils/TableGen/X86FoldTablesEmitter.cpp 218 static inline unsigned int getRegOperandSize(const Record *RegRec) {
229 getMemOperandSize(const Record *MemRec, const bool IntrinsicSensitive = false) {
260 static inline bool hasRegisterFormat(const Record *Inst) {
269 static inline bool hasMemoryFormat(const Record *Inst) {
277 static inline bool isNOREXRegClass(const Record *Op) {
281 static inline bool isRegisterOperand(const Record *Rec) {
287 static inline bool isMemoryOperand(const Record *Rec) {
292 static inline bool isImmediateOperand(const Record *Rec) {
303 Record *AltRegInstRec = Records.getDef(AltRegInstStr);
320 Record *MemRec = MemInst->TheDef;
321 Record *RegRec = RegInst->TheDef;
390 Record *MemOpRec = MemInst->Operands[i].Rec;
391 Record *RegOpRec = RegInst->Operands[i + RegStartIdx].Rec;
461 Record *RegRec = RegInstr->TheDef;
462 Record *MemRec = MemInstr->TheDef;
479 Record *RegOpRec = RegInstr->Operands[FoldedInd].Rec;
480 Record *MemOpRec = MemInstr->Operands[FoldedInd].Rec;
517 Record *RegRec = RegInstr->TheDef;
518 Record *MemRec = MemInstr->TheDef;
535 Record *RegOpRec = RegInstr->Operands[i].Rec;
536 Record *MemOpRec = MemInstr->Operands[i].Rec;
565 Record *RegOpRec = RegInstr->Operands[RegOutSize - 1].Rec;
566 Record *MemOpRec = MemInstr->Operands[RegOutSize - 1].Rec;
590 const Record *Rec = Inst->TheDef;
649 Record *RegInstIter = Records.getDef(Entry.RegInstStr);
650 Record *MemInstIter = Records.getDef(Entry.MemInstStr);
utils/TableGen/X86RecognizableInstr.cpp 57 static uint8_t byteFromRec(const Record* rec, const std::string &name) {
110 std::vector<Record*> Predicates = Rec->getValueAsListOfDefs("Predicates");
utils/TableGen/X86RecognizableInstr.h 158 const Record* Rec;