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

184 lines
6.0 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 {
TableGen: Some more std::string->StringInit* replacements llvm-svn: 288653
2016-12-05 15:35:13 +08:00
StringInit *Name;
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<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;
TableGen: Some more std::string->StringInit* replacements llvm-svn: 288653
2016-12-05 15:35:13 +08:00
LetRecord(StringInit *N, ArrayRef<unsigned> B, Init *V, 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
};
TableGen: Add a defset statement Allows capturing a list of concrete instantiated defs. This can be combined with foreach to create parallel sets of def instantiations with less repetition in the source. This purpose is largely also served by multiclasses, but in some cases multiclasses can't be used. The motivating example for this change is having a large set of intrinsics, which are generated from the IntrinsicsBackend.td file included by Intrinsics.td, and a corresponding set of instruction selection patterns, which are generated via the backend's .td files. Multiclasses cannot be used to eliminate the redundancy in this case, because a multiclass cannot span both LLVM's common .td files and the backend .td files at the same time. Change-Id: I879e35042dceea542a5e6776fad23c5e0e69e76b Differential revision: https://reviews.llvm.org/D44109 llvm-svn: 327121
2018-03-09 20:24:42 +08:00
struct DefsetRecord {
SMLoc Loc;
RecTy *EltTy;
SmallVector<Init *, 16> Elements;
};
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;
TableGen/TGParser: Prefer SmallVector/ArrayRef over std::vector llvm-svn: 288649
2016-12-05 14:41:54 +08:00
std::vector<SmallVector<LetRecord, 4>> 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;
TableGen: Add a defset statement Allows capturing a list of concrete instantiated defs. This can be combined with foreach to create parallel sets of def instantiations with less repetition in the source. This purpose is largely also served by multiclasses, but in some cases multiclasses can't be used. The motivating example for this change is having a large set of intrinsics, which are generated from the IntrinsicsBackend.td file included by Intrinsics.td, and a corresponding set of instruction selection patterns, which are generated via the backend's .td files. Multiclasses cannot be used to eliminate the redundancy in this case, because a multiclass cannot span both LLVM's common .td files and the backend .td files at the same time. Change-Id: I879e35042dceea542a5e6776fad23c5e0e69e76b Differential revision: https://reviews.llvm.org/D44109 llvm-svn: 327121
2018-03-09 20:24:42 +08:00
SmallVector<DefsetRecord *, 2> Defsets;
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
// 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.
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)
TableGen: Move getNewAnonymousName into RecordKeeper Summary: So that we will be able to generate new anonymous names more easily outside the parser as well. Change-Id: I28f396a7bdbc3ff0c665d466abbd3d31376e21b4 Reviewers: arsenm, craig.topper, tra, MartinO Subscribers: wdng, llvm-commits Differential Revision: https://reviews.llvm.org/D43755 llvm-svn: 326787
2018-03-06 21:48:54 +08:00
: Lex(SrcMgr), CurMultiClass(nullptr), Records(records) {}
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,
[TableGen] Change TGParser::SetValue to take an ArrayRef instead of std::vector reference. Use None in many places where a default constructed vector was being passed. NFC llvm-svn: 256726
2016-01-04 11:15:08 +08:00
ArrayRef<unsigned> BitList, Init *V,
[TableGen] Fix a bug that caused the wrong name for a record built from a multiclass containing a defm called NAME that references another multiclass that contains a defm that uses NAME concatenated with other strings. It would end up doing the concatenations from the second multiclass twice. This occured because SetValue detected a self assignment when trying to set the value of NAME to a VarInit called NAME. NAME is special here and it will get cleaned up later. So add a flag to suppress the self assignment check for this case. Strangely the self-assignment error was returning false indicating it wasn't an error, but it wasn't doing the right thing. So this also changes it to report an error. This fixes the names of some AVX512 FMA instructions that showed this double expansion. llvm-svn: 256725
2016-01-04 11:05:14 +08:00
bool AllowSelfAssignment = false);
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
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;
TableGen: Streamline how defs are instantiated Summary: Instantiating def's and defm's needs to perform the following steps: - for defm's, clone multiclass def prototypes and subsitute template args - for def's and defm's, add subclass definitions, substituting template args - clone the record based on foreach loops and substitute loop iteration variables - override record variables based on the global 'let' stack - resolve the record name (this should be simple, but unfortunately it's not due to existing .td files relying on rather silly implementation details) - for def(m)s in multiclasses, add the unresolved record as a multiclass prototype - for top-level def(m)s, resolve all internal variable references and add them to the record keeper and any active defsets This change streamlines how we go through these steps, by having both def's and defm's feed into a single addDef() method that handles foreach, final resolve, and routing the record to the right place. This happens to make foreach inside of multiclasses work, as the new test case demonstrates. Previously, foreach inside multiclasses was not forbidden by the parser, but it was de facto broken. Another side effect is that the order of "instantiated from" notes in error messages is reversed, as the modified test case shows. This is arguably clearer, since the initial error message ends up pointing directly to whatever triggered the error, and subsequent notes will point to increasingly outer layers of multiclasses. This is consistent with how C++ compilers report nested #includes and nested template instantiations. Change-Id: Ica146d0db2bc133dd7ed88054371becf24320447 Reviewers: arsenm, craig.topper, tra, MartinO Subscribers: wdng, llvm-commits Differential Revision: https://reviews.llvm.org/D44478 llvm-svn: 328117
2018-03-22 01:12:53 +08:00
bool addDefOne(std::unique_ptr<Record> Rec, Init *DefmName,
IterSet &IterVals);
bool addDefForeach(Record *Rec, Init *DefmName, IterSet &IterVals);
bool addDef(std::unique_ptr<Record> Rec, Init *DefmName);
TableGen: Add a defset statement Allows capturing a list of concrete instantiated defs. This can be combined with foreach to create parallel sets of def instantiations with less repetition in the source. This purpose is largely also served by multiclasses, but in some cases multiclasses can't be used. The motivating example for this change is having a large set of intrinsics, which are generated from the IntrinsicsBackend.td file included by Intrinsics.td, and a corresponding set of instruction selection patterns, which are generated via the backend's .td files. Multiclasses cannot be used to eliminate the redundancy in this case, because a multiclass cannot span both LLVM's common .td files and the backend .td files at the same time. Change-Id: I879e35042dceea542a5e6776fad23c5e0e69e76b Differential revision: https://reviews.llvm.org/D44109 llvm-svn: 327121
2018-03-09 20:24:42 +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();
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);
TableGen: Add a defset statement Allows capturing a list of concrete instantiated defs. This can be combined with foreach to create parallel sets of def instantiations with less repetition in the source. This purpose is largely also served by multiclasses, but in some cases multiclasses can't be used. The motivating example for this change is having a large set of intrinsics, which are generated from the IntrinsicsBackend.td file included by Intrinsics.td, and a corresponding set of instruction selection patterns, which are generated via the backend's .td files. Multiclasses cannot be used to eliminate the redundancy in this case, because a multiclass cannot span both LLVM's common .td files and the backend .td files at the same time. Change-Id: I879e35042dceea542a5e6776fad23c5e0e69e76b Differential revision: https://reviews.llvm.org/D44109 llvm-svn: 327121
2018-03-09 20:24:42 +08:00
bool ParseDefset();
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);
TableGen/TGParser: Prefer SmallVector/ArrayRef over std::vector llvm-svn: 288649
2016-12-05 14:41:54 +08:00
void ParseLetList(SmallVectorImpl<LetRecord> &Result);
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 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
TableGen: Some more std::string->StringInit* replacements llvm-svn: 288653
2016-12-05 15:35:13 +08:00
Init *ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
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 *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);
TableGen/TGParser: Prefer SmallVector/ArrayRef over std::vector llvm-svn: 288649
2016-12-05 14:41:54 +08:00
void ParseValueList(SmallVectorImpl<llvm::Init*> &Result, Record *CurRec,
Record *ArgsRec = nullptr, RecTy *EltTy = nullptr);
TableGen/Record: Replace std::vector with SmallVector/ArrayRef llvm-svn: 288648
2016-12-05 14:41:51 +08:00
void ParseDagArgList(
SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result,
Record *CurRec);
TableGen/TGParser: Prefer SmallVector/ArrayRef over std::vector llvm-svn: 288649
2016-12-05 14:41:54 +08:00
bool ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges);
bool ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges);
void ParseRangeList(SmallVectorImpl<unsigned> &Result);
bool ParseRangePiece(SmallVectorImpl<unsigned> &Ranges);
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
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