TGParser.h Source File (original) (raw)

31 std::vector Bits;

36};

41 std::unique_ptr Rec;

42 std::unique_ptr Loop;

43 std::unique_ptrRecord::AssertionInfo Assertion;

44 std::unique_ptrRecord::DumpInfo Dump;

46 void dump() const;

53};

65 std::vector Entries;

67 void dump() const;

71};

90public:

93private:

94 ScopeKind Kind;

95 std::unique_ptr Parent;

97 std::map<std::string, const Init *, std::less<>> Vars;

98 Record *CurRec = nullptr;

101

102public:

111 CurMultiClass(Multiclass) {}

112

114

115

116 return std::move(Parent);

117 }

118

121 bool TrackReferenceLocs) const;

122

124

125

126

127

128 return Vars.find(Name) != Vars.end();

129 }

130

132 bool Ins = Vars.try_emplace(Name.str(), I).second;

133 (void)Ins;

134 assert(Ins && "Local variable already exists");

135 }

136

137 bool isOutermost() const { return Parent == nullptr; }

138};

142 std::vector<SmallVector<LetRecord, 4>> LetStack;

143 std::map<std::string, std::unique_ptr> MultiClasses;

144 std::map<std::string, const RecTy *> TypeAliases;

145

146

147

148 std::vector<std::unique_ptr> Loops;

149

151

152

153

155

156

157 std::unique_ptr CurScope;

158

159

161

162

163

164

165

166

167 enum IDParseMode {

168 ParseValueMode,

169 ParseNameMode,

170

171 };

172

173 bool NoWarnOnUnusedTemplateArgs = false;

174 bool TrackReferenceLocs = false;

175

176public:

178 const bool NoWarnOnUnusedTemplateArgs = false,

179 const bool TrackReferenceLocs = false)

180 : Lex(SM, Macros), CurMultiClass(nullptr), Records(records),

181 NoWarnOnUnusedTemplateArgs(NoWarnOnUnusedTemplateArgs),

182 TrackReferenceLocs(TrackReferenceLocs) {}

183

184

185

187

194 return Lex.getDependencies();

195 }

196

198 CurScope = std::make_unique(std::move(CurScope));

199

200

201

202 return CurScope.get();

203 }

205 CurScope = std::make_unique(std::move(CurScope), Rec);

206 return CurScope.get();

207 }

209 CurScope = std::make_unique(std::move(CurScope), Loop);

210 return CurScope.get();

211 }

213 CurScope = std::make_unique(std::move(CurScope), Multiclass);

214 return CurScope.get();

215 }

217 assert(ExpectedStackTop == CurScope.get() &&

218 "Mismatched pushes and pops of local variable scopes");

219 CurScope = CurScope->extractParent();

220 }

221

222private:

224

225

226

229 bool AllowSelfAssignment = false, bool OverrideDefLoc = true);

232 bool AddSubMultiClass(MultiClass *CurMC,

234

236

238 bool resolve(const ForeachLoop &Loop, SubstStack &Stack, bool Final,

239 std::vector *Dest, SMLoc *Loc = nullptr);

240 bool resolve(const std::vector &Source, SubstStack &Substs,

241 bool Final, std::vector *Dest,

243 bool addDefOne(std::unique_ptr Rec);

244

245 using ArgValueHandler = std::function<void(const Init *, const Init *)>;

246 bool resolveArguments(

248 ArgValueHandler ArgValueHandler = [](const Init *, const Init *) {});

249 bool resolveArgumentsOfClass(MapResolver &R, const Record *Rec,

251 SMLoc Loc);

252 bool resolveArgumentsOfMultiClass(SubstStack &Substs, MultiClass *MC,

254 const Init *DefmName, SMLoc Loc);

255

256private:

258 bool ParseObjectList(MultiClass *MC = nullptr);

259 bool ParseObject(MultiClass *MC);

260 bool ParseClass();

261 bool ParseMultiClass();

262 bool ParseDefm(MultiClass *CurMultiClass);

263 bool ParseDef(MultiClass *CurMultiClass);

264 bool ParseDefset();

265 bool ParseDeftype();

266 bool ParseDefvar(Record *CurRec = nullptr);

267 bool ParseDump(MultiClass *CurMultiClass, Record *CurRec = nullptr);

268 bool ParseForeach(MultiClass *CurMultiClass);

269 bool ParseIf(MultiClass *CurMultiClass);

270 bool ParseIfBody(MultiClass *CurMultiClass, StringRef Kind);

271 bool ParseAssert(MultiClass *CurMultiClass, Record *CurRec = nullptr);

272 bool ParseTopLevelLet(MultiClass *CurMultiClass);

273 void ParseLetList(SmallVectorImpl &Result);

274

275 bool ParseObjectBody(Record *CurRec);

276 bool ParseBody(Record *CurRec);

277 bool ParseBodyItem(Record *CurRec);

278

279 bool ParseTemplateArgList(Record *CurRec);

280 const Init *ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs);

281 const VarInit *ParseForeachDeclaration(const Init *&ForeachListValue);

282

283 SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);

284 SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);

285

286 const Init *ParseIDValue(Record *CurRec, const StringInit *Name,

287 SMRange NameLoc, IDParseMode Mode = ParseValueMode);

288 const Init *ParseSimpleValue(Record *CurRec, const RecTy *ItemType = nullptr,

289 IDParseMode Mode = ParseValueMode);

290 const Init *ParseValue(Record *CurRec, const RecTy *ItemType = nullptr,

291 IDParseMode Mode = ParseValueMode);

292 void ParseValueList(SmallVectorImpl<const Init *> &Result, Record *CurRec,

293 const RecTy *ItemType = nullptr);

294 bool ParseTemplateArgValueList(SmallVectorImpl<const ArgumentInit *> &Result,

295 SmallVectorImpl &ArgLocs,

296 Record *CurRec, const Record *ArgsRec);

297 void ParseDagArgList(

298 SmallVectorImpl<std::pair<const Init *, const StringInit *>> &Result,

299 Record *CurRec);

300 bool ParseOptionalRangeList(SmallVectorImpl &Ranges);

301 bool ParseOptionalBitList(SmallVectorImpl &Ranges);

302 const TypedInit *ParseSliceElement(Record *CurRec);

303 const TypedInit *ParseSliceElements(Record *CurRec, bool Single = false);

304 void ParseRangeList(SmallVectorImpl &Result);

305 bool ParseRangePiece(SmallVectorImpl &Ranges,

306 const TypedInit *FirstItem = nullptr);

307 const RecTy *ParseType();

308 const Init *ParseOperation(Record *CurRec, const RecTy *ItemType);

309 const Init *ParseOperationSubstr(Record *CurRec, const RecTy *ItemType);

310 const Init *ParseOperationFind(Record *CurRec, const RecTy *ItemType);

311 const Init *ParseOperationForEachFilter(Record *CurRec,

312 const RecTy *ItemType);

313 const Init *ParseOperationCond(Record *CurRec, const RecTy *ItemType);

314 const RecTy *ParseOperatorType();

315 const Init *ParseObjectName(MultiClass *CurMultiClass);

316 const Record *ParseClassID();

317 MultiClass *ParseMultiClassID();

318 bool ApplyLetStack(Record *CurRec);

319 bool ApplyLetStack(RecordsEntry &Entry);

320 bool CheckTemplateArgValues(SmallVectorImpl<const ArgumentInit *> &Values,

322 const Record *ArgsRec);

323};