]>
git.proxmox.com Git - rustc.git/blob - src/llvm/lib/TableGen/TGParser.h
1 //===- TGParser.h - Parser for TableGen Files -------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This class represents the Parser for tablegen files.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_LIB_TABLEGEN_TGPARSER_H
15 #define LLVM_LIB_TABLEGEN_TGPARSER_H
18 #include "llvm/ADT/Twine.h"
19 #include "llvm/Support/SourceMgr.h"
20 #include "llvm/TableGen/Error.h"
21 #include "llvm/TableGen/Record.h"
31 struct SubClassReference
;
32 struct SubMultiClassReference
;
36 std::vector
<unsigned> Bits
;
39 LetRecord(const std::string
&N
, const std::vector
<unsigned> &B
, Init
*V
,
41 : Name(N
), Bits(B
), Value(V
), Loc(L
) {
45 /// ForeachLoop - Record the iteration state associated with a for loop.
46 /// This is used to instantiate items in the loop body.
51 ForeachLoop(VarInit
*IVar
, ListInit
*LValue
)
52 : IterVar(IVar
), ListValue(LValue
) {}
57 std::vector
<std::vector
<LetRecord
> > LetStack
;
58 std::map
<std::string
, std::unique_ptr
<MultiClass
>> MultiClasses
;
60 /// Loops - Keep track of any foreach loops we are within.
62 typedef std::vector
<ForeachLoop
> LoopVector
;
65 /// CurMultiClass - If we are parsing a 'multiclass' definition, this is the
67 MultiClass
*CurMultiClass
;
70 RecordKeeper
&Records
;
74 // A "named boolean" indicating how to parse identifiers. Usually
75 // identifiers map to some existing object but in special cases
76 // (e.g. parsing def names) no such object exists yet because we are
77 // in the middle of creating in. For those situations, allow the
78 // parser to ignore missing object errors.
80 ParseValueMode
, // We are parsing a value we expect to look up.
81 ParseNameMode
, // We are parsing a name of an object that does not yet
83 ParseForeachMode
// We are parsing a foreach init.
87 TGParser(SourceMgr
&SrcMgr
, RecordKeeper
&records
)
88 : Lex(SrcMgr
), CurMultiClass(nullptr), Records(records
), AnonCounter(0) {}
90 /// ParseFile - Main entrypoint for parsing a tblgen file. These parser
91 /// routines return true on error, or false on success.
94 bool Error(SMLoc L
, const Twine
&Msg
) const {
98 bool TokError(const Twine
&Msg
) const {
99 return Error(Lex
.getLoc(), Msg
);
101 const TGLexer::DependenciesMapTy
&getDependencies() const {
102 return Lex
.getDependencies();
105 private: // Semantic analysis methods.
106 bool AddValue(Record
*TheRec
, SMLoc Loc
, const RecordVal
&RV
);
107 bool SetValue(Record
*TheRec
, SMLoc Loc
, Init
*ValName
,
108 const std::vector
<unsigned> &BitList
, Init
*V
);
109 bool SetValue(Record
*TheRec
, SMLoc Loc
, const std::string
&ValName
,
110 const std::vector
<unsigned> &BitList
, Init
*V
) {
111 return SetValue(TheRec
, Loc
, StringInit::get(ValName
), BitList
, V
);
113 bool AddSubClass(Record
*Rec
, SubClassReference
&SubClass
);
114 bool AddSubMultiClass(MultiClass
*CurMC
,
115 SubMultiClassReference
&SubMultiClass
);
117 std::string
GetNewAnonymousName();
119 // IterRecord: Map an iterator name to a value.
123 IterRecord(VarInit
*Var
, Init
*Val
) : IterVar(Var
), IterValue(Val
) {}
126 // IterSet: The set of all iterator values at some point in the
128 typedef std::vector
<IterRecord
> IterSet
;
130 bool ProcessForeachDefs(Record
*CurRec
, SMLoc Loc
);
131 bool ProcessForeachDefs(Record
*CurRec
, SMLoc Loc
, IterSet
&IterVals
);
133 private: // Parser methods.
134 bool ParseObjectList(MultiClass
*MC
= nullptr);
135 bool ParseObject(MultiClass
*MC
);
137 bool ParseMultiClass();
138 Record
*InstantiateMulticlassDef(MultiClass
&MC
,
141 SMRange DefmPrefixRange
);
142 bool ResolveMulticlassDefArgs(MultiClass
&MC
,
146 const std::vector
<Init
*> &TArgs
,
147 std::vector
<Init
*> &TemplateVals
,
149 bool ResolveMulticlassDef(MultiClass
&MC
,
152 SMLoc DefmPrefixLoc
);
153 bool ParseDefm(MultiClass
*CurMultiClass
);
154 bool ParseDef(MultiClass
*CurMultiClass
);
155 bool ParseForeach(MultiClass
*CurMultiClass
);
156 bool ParseTopLevelLet(MultiClass
*CurMultiClass
);
157 std::vector
<LetRecord
> ParseLetList();
159 bool ParseObjectBody(Record
*CurRec
);
160 bool ParseBody(Record
*CurRec
);
161 bool ParseBodyItem(Record
*CurRec
);
163 bool ParseTemplateArgList(Record
*CurRec
);
164 Init
*ParseDeclaration(Record
*CurRec
, bool ParsingTemplateArgs
);
165 VarInit
*ParseForeachDeclaration(ListInit
*&ForeachListValue
);
167 SubClassReference
ParseSubClassReference(Record
*CurRec
, bool isDefm
);
168 SubMultiClassReference
ParseSubMultiClassReference(MultiClass
*CurMC
);
170 Init
*ParseIDValue(Record
*CurRec
, const std::string
&Name
, SMLoc NameLoc
,
171 IDParseMode Mode
= ParseValueMode
);
172 Init
*ParseSimpleValue(Record
*CurRec
, RecTy
*ItemType
= nullptr,
173 IDParseMode Mode
= ParseValueMode
);
174 Init
*ParseValue(Record
*CurRec
, RecTy
*ItemType
= nullptr,
175 IDParseMode Mode
= ParseValueMode
);
176 std::vector
<Init
*> ParseValueList(Record
*CurRec
, Record
*ArgsRec
= nullptr,
177 RecTy
*EltTy
= nullptr);
178 std::vector
<std::pair
<llvm::Init
*, std::string
> > ParseDagArgList(Record
*);
179 bool ParseOptionalRangeList(std::vector
<unsigned> &Ranges
);
180 bool ParseOptionalBitList(std::vector
<unsigned> &Ranges
);
181 std::vector
<unsigned> ParseRangeList();
182 bool ParseRangePiece(std::vector
<unsigned> &Ranges
);
184 Init
*ParseOperation(Record
*CurRec
, RecTy
*ItemType
);
185 RecTy
*ParseOperatorType();
186 Init
*ParseObjectName(MultiClass
*CurMultiClass
);
187 Record
*ParseClassID();
188 MultiClass
*ParseMultiClassID();
189 bool ApplyLetStack(Record
*CurRec
);
192 } // end namespace llvm