maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/TableGen/TGParser.h

195 lines
6.8 KiB
C
Raw Normal View History

Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
//===- TGParser.h - Parser for TableGen Files -------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
remove attributions from utils. llvm-svn: 45419
2007-12-30 04:37:13 +08:00
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
//
//===----------------------------------------------------------------------===//
//
// This class represents the Parser for tablegen files.
//
//===----------------------------------------------------------------------===//
Canonicalize header guards into a common format. Add header guards to files that were missing guards. Remove #endif comments as they don't seem common in LLVM (we can easily add them back if we decide they're useful) Changes made by clang-tidy with minor tweaks. llvm-svn: 215558
2014-08-14 00:26:38 +08:00
#ifndef LLVM_LIB_TABLEGEN_TGPARSER_H
#define LLVM_LIB_TABLEGEN_TGPARSER_H
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
#include "TGLexer.h"
Push twines deeper into SourceMgr's error handling methods. llvm-svn: 114847
2010-09-28 01:42:11 +08:00
#include "llvm/ADT/Twine.h"
move TGSourceMgr class out of TableGen into libsupport. llvm-svn: 73842
2009-06-21 11:36:54 +08:00
#include "llvm/Support/SourceMgr.h"
Sort includes for all of the .h files under the 'lib' tree. These were missed in the first pass because the script didn't yet handle include guards. Note that the script is now able to handle all of these headers without manual edits. =] llvm-svn: 169224
2012-12-04 15:12:27 +08:00
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
#include <map>
namespace llvm {
class Record;
class RecordVal;
eliminate the Records global variable, patch by Garrison Venn! llvm-svn: 121659
2010-12-13 08:23:57 +08:00
class RecordKeeper;
Intern all RecTy subclass instances to avoid duplicates. Make all of the RecTy constructors private, and use get() factory methods instead. Return singleton instances when it makes sense. ListTy instance pointers are stored in the element RecTy instance. BitsRecTy instance pointers, one per length, are stored in a static vector. Also unique DefInit instances. A Record has a unique DefInit which has a unique RecordRecTy instance. This saves some 200k-300k RecTy allocations when parsing ARM.td. It reduces TableGen's heap usage by almost 50%. llvm-svn: 135399
2011-07-19 01:02:57 +08:00
class RecTy;
struct Init -> class Init Rename struct Init to class Init for consistency and in preparation for making Init a FoldingSetNode. llvm-svn: 135097
2011-07-14 06:25:51 +08:00
class Init;
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
struct MultiClass;
Fix the Win32 VS2008 build: - Make type declarations match the struct/class keyword of the definition. - Move AddSignalHandler into the namespace where it belongs. - Correctly call functions from template base. - Some other small changes. With this patch, LLVM and Clang should build properly and with far less noise under VS2008. llvm-svn: 67347
2009-03-20 07:26:52 +08:00
struct SubClassReference;
Implement multiclass inheritance. llvm-svn: 69810
2009-04-23 00:42:54 +08:00
struct SubMultiClassReference;
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
struct LetRecord {
std::string Name;
std::vector<unsigned> Bits;
Unconstify Inits Remove const qualifiers from Init references, per Chris' request. llvm-svn: 136531
2011-07-30 06:43:06 +08:00
Init *Value;
rename TGLoc -> SMLoc. llvm-svn: 73843
2009-06-21 11:39:35 +08:00
SMLoc Loc;
Unconstify Inits Remove const qualifiers from Init references, per Chris' request. llvm-svn: 136531
2011-07-30 06:43:06 +08:00
LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V,
Revert r134921, 134917, 134908 and 134907. They're causing failures in multiple buildbots. llvm-svn: 134936
2011-07-12 07:06:52 +08:00
SMLoc L)
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
: Name(N), Bits(B), Value(V), Loc(L) {
}
};
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
/// ForeachLoop - Record the iteration state associated with a for loop.
/// This is used to instantiate items in the loop body.
struct ForeachLoop {
Simplify TGParser::ProcessForEachDefs. Use static type checking. llvm-svn: 157430
2012-05-25 06:17:33 +08:00
VarInit *IterVar;
ListInit *ListValue;
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
Simplify TGParser::ProcessForEachDefs. Use static type checking. llvm-svn: 157430
2012-05-25 06:17:33 +08:00
ForeachLoop(VarInit *IVar, ListInit *LValue)
: IterVar(IVar), ListValue(LValue) {}
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
};
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
class TGParser {
TGLexer Lex;
std::vector<std::vector<LetRecord> > LetStack;
Replace std::map<K, V*> with std::map<K, std::unique_ptr<V>> to handle ownership and deletion of the values. Ideally we would store the MultiClasses by value directly in the maps, but I had some trouble with that before and this at least fixes the leak. llvm-svn: 223997
2014-12-11 13:25:30 +08:00
std::map<std::string, std::unique_ptr<MultiClass>> MultiClasses;
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
/// Loops - Keep track of any foreach loops we are within.
///
typedef std::vector<ForeachLoop> LoopVector;
LoopVector Loops;
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
/// CurMultiClass - If we are parsing a 'multiclass' definition, this is the
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
/// current value.
MultiClass *CurMultiClass;
eliminate the Records global variable, patch by Garrison Venn! llvm-svn: 121659
2010-12-13 08:23:57 +08:00
// Record tracker
various cleanups to tblgen, patch by Garrison Venn! llvm-svn: 121837
2010-12-15 12:48:22 +08:00
RecordKeeper &Records;
Make ID Parsing More Flexible Add a mode control to value and ID parsers. The two modes are: - Parse a value. Expect the parsed ID to map to an existing object. - Parse a name. Expect the parsed ID to not map to any existing object. The first is used when parsing an identifier to be looked up, for example a record field or template argument. The second is used for parsing declarations. Paste functionality implies that declarations can contain arbitrary expressions so we need to be able to call into the general value parser to parse declarations with paste operators. So we need a way to parse a value-like thing without expecting that the result will map to some existing object. This parse mode provides that. llvm-svn: 142519
2011-10-19 21:04:20 +08:00
TableGen: Generate valid identifiers for anonymous records Backends like OptParserEmitter assume that record names can be used as valid identifiers. The period '.' in generated anonymous names broke that assumption, causing a build-time error and in practice forcing all records to be named. llvm-svn: 197869
2013-12-22 02:51:00 +08:00
unsigned AnonCounter;
Make ID Parsing More Flexible Add a mode control to value and ID parsers. The two modes are: - Parse a value. Expect the parsed ID to map to an existing object. - Parse a name. Expect the parsed ID to not map to any existing object. The first is used when parsing an identifier to be looked up, for example a record field or template argument. The second is used for parsing declarations. Paste functionality implies that declarations can contain arbitrary expressions so we need to be able to call into the general value parser to parse declarations with paste operators. So we need a way to parse a value-like thing without expecting that the result will map to some existing object. This parse mode provides that. llvm-svn: 142519
2011-10-19 21:04:20 +08:00
// A "named boolean" indicating how to parse identifiers. Usually
// identifiers map to some existing object but in special cases
// (e.g. parsing def names) no such object exists yet because we are
// in the middle of creating in. For those situations, allow the
// parser to ignore missing object errors.
enum IDParseMode {
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
ParseValueMode, // We are parsing a value we expect to look up.
ParseNameMode, // We are parsing a name of an object that does not yet
// exist.
ParseForeachMode // We are parsing a foreach init.
Make ID Parsing More Flexible Add a mode control to value and ID parsers. The two modes are: - Parse a value. Expect the parsed ID to map to an existing object. - Parse a name. Expect the parsed ID to not map to any existing object. The first is used when parsing an identifier to be looked up, for example a record field or template argument. The second is used for parsing declarations. Paste functionality implies that declarations can contain arbitrary expressions so we need to be able to call into the general value parser to parse declarations with paste operators. So we need a way to parse a value-like thing without expecting that the result will map to some existing object. This parse mode provides that. llvm-svn: 142519
2011-10-19 21:04:20 +08:00
};
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
public:
TableGen: Generate valid identifiers for anonymous records Backends like OptParserEmitter assume that record names can be used as valid identifiers. The period '.' in generated anonymous names broke that assumption, causing a build-time error and in practice forcing all records to be named. llvm-svn: 197869
2013-12-22 02:51:00 +08:00
TGParser(SourceMgr &SrcMgr, RecordKeeper &records)
[C++] Use 'nullptr'. llvm-svn: 207394
2014-04-28 12:05:08 +08:00
: Lex(SrcMgr), CurMultiClass(nullptr), Records(records), AnonCounter(0) {}
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
/// ParseFile - Main entrypoint for parsing a tblgen file. These parser
/// routines return true on error, or false on success.
bool ParseFile();
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
Push twines deeper into SourceMgr's error handling methods. llvm-svn: 114847
2010-09-28 01:42:11 +08:00
bool Error(SMLoc L, const Twine &Msg) const {
Consolidate some TableGen diagnostic helper functions. TableGen had diagnostic printers sprinkled about in a few places. Pull them together into a single location in Error.cpp. llvm-svn: 133568
2011-06-22 06:55:50 +08:00
PrintError(L, Msg);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
return true;
}
Push twines deeper into SourceMgr's error handling methods. llvm-svn: 114847
2010-09-28 01:42:11 +08:00
bool TokError(const Twine &Msg) const {
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
return Error(Lex.getLoc(), Msg);
}
tblgen: Diagnose duplicate includes. A double inclusion will pretty much always be an error in TableGen, so there's no point going on just to die with "def already defined" or whatnot. I'm not too thrilled about the "public: ... private: ..." to expose the DependenciesMapTy, but I really didn't see a better way to keep that type centralized. It's a smell that indicates that some refactoring is needed to make this code more loosely coupled. This should avoid all bugs of the same nature as PR15189. llvm-svn: 174582
2013-02-07 12:30:39 +08:00
const TGLexer::DependenciesMapTy &getDependencies() const {
Add new -d option to tblgen. It writes a make(1)-style dependency file. llvm-svn: 132395
2011-06-01 21:10:15 +08:00
return Lex.getDependencies();
}
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
private: // Semantic analysis methods.
rename TGLoc -> SMLoc. llvm-svn: 73843
2009-06-21 11:39:35 +08:00
bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
bool SetValue(Record *TheRec, SMLoc Loc, Init *ValName,
Unconstify Inits Remove const qualifiers from Init references, per Chris' request. llvm-svn: 136531
2011-07-30 06:43:06 +08:00
const std::vector<unsigned> &BitList, Init *V);
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
bool SetValue(Record *TheRec, SMLoc Loc, const std::string &ValName,
Let SetValue Take and Init Name Convert SetValue to take the value name as an Init. This allows us to set values for variables whose names are not yet fully resolved. llvm-svn: 142499
2011-10-19 21:02:39 +08:00
const std::vector<unsigned> &BitList, Init *V) {
return SetValue(TheRec, Loc, StringInit::get(ValName), BitList, V);
}
Unbreak the build on win32. Cleanup some warning. Remark: when struct/class are declared differently than they are defined, this make problem for VC++ since it seems to mangle class differently that struct. These error are very hard to understand and find. So please, try to keep your definition/declaration in sync. Only tested with VS2008. hope it does not break anything. feel free to revert. llvm-svn: 64554
2009-02-15 00:06:42 +08:00
bool AddSubClass(Record *Rec, SubClassReference &SubClass);
Rename the CurMultiClass formal parameter of TGParser::AddSubMultiClass so that it doesn't shadow the instance variable of the same name. Make the parameter names in method declarations match the definitions. llvm-svn: 70502
2009-05-01 02:26:19 +08:00
bool AddSubMultiClass(MultiClass *CurMC,
SubMultiClassReference &SubMultiClass);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
TableGen: Generate valid identifiers for anonymous records Backends like OptParserEmitter assume that record names can be used as valid identifiers. The period '.' in generated anonymous names broke that assumption, causing a build-time error and in practice forcing all records to be named. llvm-svn: 197869
2013-12-22 02:51:00 +08:00
std::string GetNewAnonymousName();
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
// IterRecord: Map an iterator name to a value.
struct IterRecord {
Simplify TGParser::ProcessForEachDefs. Use static type checking. llvm-svn: 157430
2012-05-25 06:17:33 +08:00
VarInit *IterVar;
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
Init *IterValue;
Simplify TGParser::ProcessForEachDefs. Use static type checking. llvm-svn: 157430
2012-05-25 06:17:33 +08:00
IterRecord(VarInit *Var, Init *Val) : IterVar(Var), IterValue(Val) {}
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
};
// IterSet: The set of all iterator values at some point in the
// iteration space.
typedef std::vector<IterRecord> IterSet;
Simplify TGParser::ProcessForEachDefs. Use static type checking. llvm-svn: 157430
2012-05-25 06:17:33 +08:00
bool ProcessForeachDefs(Record *CurRec, SMLoc Loc);
bool ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals);
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
private: // Parser methods.
[C++] Use 'nullptr'. llvm-svn: 207394
2014-04-28 12:05:08 +08:00
bool ParseObjectList(MultiClass *MC = nullptr);
Teach tablegen to allow "let" expressions inside multiclasses, providing more ways to factor out commonality from the records. llvm-svn: 105776
2010-06-10 10:42:59 +08:00
bool ParseObject(MultiClass *MC);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
bool ParseClass();
bool ParseMultiClass();
Refactor Multiclass Def Processing Move the code to instantiate a multiclass def, bind its arguments and resolve its members into three helper functions. These will be reused to support a new kind of multiclass def: a multidef. llvm-svn: 141229
2011-10-06 06:42:07 +08:00
Record *InstantiateMulticlassDef(MultiClass &MC,
Record *DefProto,
[TableGen] Use the same anonymous name as the prefix on all multiclass defs TableGen had been generating a different name for an anonymous multiclass's NAME for every def in the multiclass. This had an unfortunate side effect: it was impossible to reference one def within the multiclass from another (in the parameter list, for example). By making sure we only generate an anonymous name once per multiclass (which, as it turns out, requires only changing the name parameter to reference type), we can now concatenate NAME within the multiclass with a def name in order to generate a reference to that def. This does not matter so much, in and of itself, but is necessary for a follow-up commit that will fix variable capturing in implicit anonymous multiclass defs (and that is important). llvm-svn: 198340
2014-01-03 03:35:33 +08:00
Init *&DefmPrefix,
TableGen: Keep track of superclass reference ranges. def foo : bar; ~~~ This allows us to produce more precise diagnostics about a certain superclass, and even provide fixits. llvm-svn: 172085
2013-01-11 02:50:11 +08:00
SMRange DefmPrefixRange);
Refactor Multiclass Def Processing Move the code to instantiate a multiclass def, bind its arguments and resolve its members into three helper functions. These will be reused to support a new kind of multiclass def: a multidef. llvm-svn: 141229
2011-10-06 06:42:07 +08:00
bool ResolveMulticlassDefArgs(MultiClass &MC,
Record *DefProto,
SMLoc DefmPrefixLoc,
SMLoc SubClassLoc,
Make Template Arg Names Inits Allow template arg names to be Inits. This is further work to implement paste as it allows template names to participate in paste operations. llvm-svn: 142500
2011-10-19 21:02:42 +08:00
const std::vector<Init *> &TArgs,
Refactor Multiclass Def Processing Move the code to instantiate a multiclass def, bind its arguments and resolve its members into three helper functions. These will be reused to support a new kind of multiclass def: a multidef. llvm-svn: 141229
2011-10-06 06:42:07 +08:00
std::vector<Init *> &TemplateVals,
bool DeleteArgs);
bool ResolveMulticlassDef(MultiClass &MC,
Record *CurRec,
Record *DefProto,
SMLoc DefmPrefixLoc);
Teach tablegen to allow "let" expressions inside multiclasses, providing more ways to factor out commonality from the records. llvm-svn: 105776
2010-06-10 10:42:59 +08:00
bool ParseDefm(MultiClass *CurMultiClass);
bool ParseDef(MultiClass *CurMultiClass);
Add Foreach Loop Add some data structures to represent for loops. These will be referenced during object processing to do any needed iteration and instantiation. Add foreach keyword support to the lexer. Add a mode to indicate that we're parsing a foreach loop. This allows the value parser to early-out when processing the foreach value list. Add a routine to parse foreach iteration declarations. This is separate from ParseDeclaration because the type of the named value (the iterator) doesn't match the type of the initializer value (the value list). It also needs to add two values to the foreach record: the iterator and the value list. Add parsing support for foreach. Add the code to process foreach loops and create defs based on iterator values. Allow foreach loops to be matched at the top level. When parsing an IDValue check if it is a foreach loop iterator for one of the active loops. If so, return a VarInit for it. Add Emacs keyword support for foreach. Add VIM keyword support for foreach. Add tests to check foreach operation. Add TableGen documentation for foreach. Support foreach with multiple objects. Support non-braced foreach body with one object. Do not require types for the foreach declaration. Assume the iterator type from the iteration list element type. llvm-svn: 151164
2012-02-23 00:09:41 +08:00
bool ParseForeach(MultiClass *CurMultiClass);
Teach tablegen to allow "let" expressions inside multiclasses, providing more ways to factor out commonality from the records. llvm-svn: 105776
2010-06-10 10:42:59 +08:00
bool ParseTopLevelLet(MultiClass *CurMultiClass);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
std::vector<LetRecord> ParseLetList();
bool ParseObjectBody(Record *CurRec);
bool ParseBody(Record *CurRec);
bool ParseBodyItem(Record *CurRec);
bool ParseTemplateArgList(Record *CurRec);
Make Template Arg Names Inits Allow template arg names to be Inits. This is further work to implement paste as it allows template names to participate in paste operations. llvm-svn: 142500
2011-10-19 21:02:42 +08:00
Init *ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs);
Simplify TGParser::ProcessForEachDefs. Use static type checking. llvm-svn: 157430
2012-05-25 06:17:33 +08:00
VarInit *ParseForeachDeclaration(ListInit *&ForeachListValue);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
Rename the CurMultiClass formal parameter of TGParser::AddSubMultiClass so that it doesn't shadow the instance variable of the same name. Make the parameter names in method declarations match the definitions. llvm-svn: 70502
2009-05-01 02:26:19 +08:00
SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
Make ID Parsing More Flexible Add a mode control to value and ID parsers. The two modes are: - Parse a value. Expect the parsed ID to map to an existing object. - Parse a name. Expect the parsed ID to not map to any existing object. The first is used when parsing an identifier to be looked up, for example a record field or template argument. The second is used for parsing declarations. Paste functionality implies that declarations can contain arbitrary expressions so we need to be able to call into the general value parser to parse declarations with paste operators. So we need a way to parse a value-like thing without expecting that the result will map to some existing object. This parse mode provides that. llvm-svn: 142519
2011-10-19 21:04:20 +08:00
Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc,
IDParseMode Mode = ParseValueMode);
[C++] Use 'nullptr'. llvm-svn: 207394
2014-04-28 12:05:08 +08:00
Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = nullptr,
Make ID Parsing More Flexible Add a mode control to value and ID parsers. The two modes are: - Parse a value. Expect the parsed ID to map to an existing object. - Parse a name. Expect the parsed ID to not map to any existing object. The first is used when parsing an identifier to be looked up, for example a record field or template argument. The second is used for parsing declarations. Paste functionality implies that declarations can contain arbitrary expressions so we need to be able to call into the general value parser to parse declarations with paste operators. So we need a way to parse a value-like thing without expecting that the result will map to some existing object. This parse mode provides that. llvm-svn: 142519
2011-10-19 21:04:20 +08:00
IDParseMode Mode = ParseValueMode);
[C++] Use 'nullptr'. llvm-svn: 207394
2014-04-28 12:05:08 +08:00
Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr,
Make ID Parsing More Flexible Add a mode control to value and ID parsers. The two modes are: - Parse a value. Expect the parsed ID to map to an existing object. - Parse a name. Expect the parsed ID to not map to any existing object. The first is used when parsing an identifier to be looked up, for example a record field or template argument. The second is used for parsing declarations. Paste functionality implies that declarations can contain arbitrary expressions so we need to be able to call into the general value parser to parse declarations with paste operators. So we need a way to parse a value-like thing without expecting that the result will map to some existing object. This parse mode provides that. llvm-svn: 142519
2011-10-19 21:04:20 +08:00
IDParseMode Mode = ParseValueMode);
[C++] Use 'nullptr'. llvm-svn: 207394
2014-04-28 12:05:08 +08:00
std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = nullptr,
RecTy *EltTy = nullptr);
Unconstify Inits Remove const qualifiers from Init references, per Chris' request. llvm-svn: 136531
2011-07-30 06:43:06 +08:00
std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
bool ParseOptionalRangeList(std::vector<unsigned> &Ranges);
bool ParseOptionalBitList(std::vector<unsigned> &Ranges);
std::vector<unsigned> ParseRangeList();
bool ParseRangePiece(std::vector<unsigned> &Ranges);
RecTy *ParseType();
Fix error in tablegen when either operand of !if is an empty list. !if([Something], []) would error with "No type for list". llvm-svn: 210572
2014-06-11 04:10:08 +08:00
Init *ParseOperation(Record *CurRec, RecTy *ItemType);
Operation Enhancements Create an OpInit class to serve as a base for all operation Inits. Move parsing of operation constructs to separate functions and reference from multiple places. Add some commented out new operations. Coming soon. llvm-svn: 71789
2009-05-15 04:54:48 +08:00
RecTy *ParseOperatorType();
Parse Def ID as Value Allow def and defm IDs to be general values. We need this for paste functionality. llvm-svn: 142522
2011-10-19 21:04:29 +08:00
Init *ParseObjectName(MultiClass *CurMultiClass);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
Record *ParseClassID();
Implement multiclass inheritance. llvm-svn: 69810
2009-04-23 00:42:54 +08:00
MultiClass *ParseMultiClassID();
tblgen: Factor out common code. llvm-svn: 171951
2013-01-09 12:49:14 +08:00
bool ApplyLetStack(Record *CurRec);
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
};
tblgen: Whitespace and 80-col cleanup. llvm-svn: 165190
2012-10-04 08:54:27 +08:00
Rewrite the tblgen parser in a recursive descent style, eliminating the bison parser. This makes the parser much easier to understand, eliminates a ton of global variables, and gives tblgen nice caret diagnostics. It is also faster, but tblgen probably doesn't care about performance. There are a couple of FIXMEs which I will take care of next. llvm-svn: 44274
2007-11-23 04:49:04 +08:00
} // end namespace llvm
#endif