[llvm] 415fab6 - [TableGen] Eliminate the 'code' type
Paul C. Anagnostopoulos via llvm-commits
llvm-commits at lists.llvm.org
Thu Dec 3 07:20:18 PST 2020
Author: Paul C. Anagnostopoulos
Date: 2020-12-03T10:19:11-05:00
New Revision: 415fab6f67b4db59abe533130272d55b4efbf0cb
URL: https://github.com/llvm/llvm-project/commit/415fab6f67b4db59abe533130272d55b4efbf0cb
DIFF: https://github.com/llvm/llvm-project/commit/415fab6f67b4db59abe533130272d55b4efbf0cb.diff
LOG: [TableGen] Eliminate the 'code' type
Update the documentation.
Rework various backends that relied on the code type.
Differential Revision: https://reviews.llvm.org/D92269
Added:
Modified:
clang/utils/TableGen/ClangOptionDocEmitter.cpp
llvm/docs/TableGen/BackEnds.rst
llvm/docs/TableGen/BackGuide.rst
llvm/docs/TableGen/ProgRef.rst
llvm/include/llvm/TableGen/Error.h
llvm/include/llvm/TableGen/Record.h
llvm/include/llvm/TableGen/SearchableTable.td
llvm/lib/TableGen/Error.cpp
llvm/lib/TableGen/JSONBackend.cpp
llvm/lib/TableGen/Record.cpp
llvm/lib/TableGen/TGLexer.cpp
llvm/lib/TableGen/TGLexer.h
llvm/lib/TableGen/TGParser.cpp
llvm/lib/Target/AMDGPU/MIMGInstructions.td
llvm/test/TableGen/code.td
llvm/test/TableGen/generic-tables.td
llvm/test/TableGen/interleave.td
llvm/test/TableGen/unterminated-code-block.td
llvm/utils/TableGen/AsmWriterEmitter.cpp
llvm/utils/TableGen/DFAEmitter.cpp
llvm/utils/TableGen/GICombinerEmitter.cpp
llvm/utils/TableGen/RISCVCompressInstEmitter.cpp
llvm/utils/TableGen/SearchableTableEmitter.cpp
mlir/include/mlir/TableGen/Operator.h
mlir/lib/TableGen/Attribute.cpp
mlir/lib/TableGen/Dialect.cpp
mlir/lib/TableGen/Operator.cpp
mlir/lib/TableGen/Pattern.cpp
mlir/lib/TableGen/Type.cpp
mlir/lib/TableGen/TypeDef.cpp
mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
Removed:
################################################################################
diff --git a/clang/utils/TableGen/ClangOptionDocEmitter.cpp b/clang/utils/TableGen/ClangOptionDocEmitter.cpp
index 23aa31cc732f..0e079b6b505a 100644
--- a/clang/utils/TableGen/ClangOptionDocEmitter.cpp
+++ b/clang/utils/TableGen/ClangOptionDocEmitter.cpp
@@ -217,8 +217,6 @@ std::string getRSTStringWithTextFallback(const Record *R, StringRef Primary,
StringRef Value;
if (auto *SV = dyn_cast_or_null<StringInit>(V->getValue()))
Value = SV->getValue();
- else if (auto *CV = dyn_cast_or_null<CodeInit>(V->getValue()))
- Value = CV->getValue();
if (!Value.empty())
return Field == Primary ? Value.str() : escapeRST(Value);
}
diff --git a/llvm/docs/TableGen/BackEnds.rst b/llvm/docs/TableGen/BackEnds.rst
index b4ccdf95485e..1e1a4e71a1fd 100644
--- a/llvm/docs/TableGen/BackEnds.rst
+++ b/llvm/docs/TableGen/BackEnds.rst
@@ -693,8 +693,8 @@ This class provides six fields.
table that holds the entries. If unspecified, the ``FilterClass`` name is
used.
-* ``list<string> Fields``. A list of the names of the fields in the
- collected records that contain the data for the table entries. The order of
+* ``list<string> Fields``. A list of the names of the fields *in the
+ collected records* that contain the data for the table entries. The order of
this list determines the order of the values in the C++ initializers. See
below for information about the types of these fields.
@@ -706,13 +706,26 @@ This class provides six fields.
* ``bit PrimaryKeyEarlyOut``. See the third example below.
-TableGen attempts to deduce the type of each of the table fields. It can
-deduce ``bit``, ``bits<n>``, ``string``, ``Intrinsic``, and ``Instruction``.
-These can be used in the primary key. TableGen also deduces ``code``, but it
-cannot be used in the primary key. Any other field types must be specified
+TableGen attempts to deduce the type of each of the table fields so that it
+can format the C++ initializers in the emitted table. It can deduce ``bit``,
+``bits<n>``, ``string``, ``Intrinsic``, and ``Instruction``. These can be
+used in the primary key. Any other field types must be specified
explicitly; this is done as shown in the second example below. Such fields
cannot be used in the primary key.
+One special case of the field type has to do with code. Arbitrary code is
+represented by a string, but has to be emitted as a C++ initializer without
+quotes. If the code field was defined using a code literal (``[{...}]``),
+then TableGen will know to emit it without quotes. However, if it was
+defined using a string literal or complex string expression, then TableGen
+will not know. In this case, you can force TableGen to treat the field as
+code by including the following line in the ``GenericTable`` record, where
+*xxx* is the code field name.
+
+.. code-block:: text
+
+ string TypeOf_xxx = "code";
+
Here is an example where TableGen can deduce the field types. Note that the
table entry records are anonymous; the names of entry records are
irrelevant.
@@ -793,7 +806,7 @@ pointer if no entry is found.
This example includes a field whose type TableGen cannot deduce. The ``Kind``
field uses the enumerated type ``CEnum`` defined above. To inform TableGen
-of the type, the class derived from ``GenericTable`` must include a field
+of the type, the record derived from ``GenericTable`` must include a string field
named ``TypeOf_``\ *field*, where *field* is the name of the field whose type
is required.
@@ -802,7 +815,7 @@ is required.
def CTable : GenericTable {
let FilterClass = "CEntry";
let Fields = ["Name", "Kind", "Encoding"];
- GenericEnum TypeOf_Kind = CEnum;
+ string TypeOf_Kind = "CEnum";
let PrimaryKey = ["Encoding"];
let PrimaryKeyName = "lookupCEntryByEncoding";
}
diff --git a/llvm/docs/TableGen/BackGuide.rst b/llvm/docs/TableGen/BackGuide.rst
index 515eeab2403a..f21910c56ac2 100644
--- a/llvm/docs/TableGen/BackGuide.rst
+++ b/llvm/docs/TableGen/BackGuide.rst
@@ -287,9 +287,9 @@ value. The static function ``get()`` can be used to obtain the singleton
This class, a subclass of ``Init``, acts as the parent class of the classes
that represent specific value types (except for the unset value). These
-classes include ``BitInit``, ``BitsInit``, ``CodeInit``, ``DagInit``,
-``DefInit``, ``IntInit``, ``ListInit``, and ``StringInit``. (There are
-additional derived types used by the TableGen parser.)
+classes include ``BitInit``, ``BitsInit``, ``DagInit``, ``DefInit``,
+``IntInit``, ``ListInit``, and ``StringInit``. (There are additional derived
+types used by the TableGen parser.)
This class includes a data member that specifies the ``RecTy`` type of the
value. It provides a function to get that ``RecTy`` type.
@@ -330,18 +330,6 @@ The class provides the following additional functions.
* A function that gets a bit specified by an integer index.
-``CodeInit``
-~~~~~~~~~~~~
-
-The ``CodeInit`` class is a subclass of ``TypedInit``. Its instances
-represent arbitrary-length strings produced from ``code`` literals in the
-TableGen files. It includes a data member that contains a ``StringRef`` of
-the value.
-
-The class provides the usual ``get()`` and ``getValue()`` functions. The
-latter function returns the ``StringRef``.
-
-
``DagInit``
~~~~~~~~~~~
diff --git a/llvm/docs/TableGen/ProgRef.rst b/llvm/docs/TableGen/ProgRef.rst
index c805afc8ccc1..342b91a0c437 100644
--- a/llvm/docs/TableGen/ProgRef.rst
+++ b/llvm/docs/TableGen/ProgRef.rst
@@ -167,10 +167,11 @@ TableGen has two kinds of string literals:
.. productionlist::
TokString: '"' (non-'"' characters and escapes) '"'
- TokCodeFragment: "[{" (shortest text not containing "}]") "}]"
+ TokCode: "[{" (shortest text not containing "}]") "}]"
-A :token:`TokCodeFragment` is nothing more than a multi-line string literal
-delimited by ``[{`` and ``}]``. It can break across lines.
+A :token:`TokCode` is nothing more than a multi-line string literal
+delimited by ``[{`` and ``}]``. It can break across lines and the
+line breaks are retained in the string.
The current implementation accepts the following escape sequences::
@@ -254,7 +255,7 @@ high-level types (e.g., ``dag``). This flexibility allows you to describe a
wide range of records conveniently and compactly.
.. productionlist::
- Type: "bit" | "int" | "string" | "code" | "dag"
+ Type: "bit" | "int" | "string" | "dag"
:| "bits" "<" `TokInteger` ">"
:| "list" "<" `Type` ">"
:| `ClassID`
@@ -271,11 +272,6 @@ wide range of records conveniently and compactly.
The ``string`` type represents an ordered sequence of characters of arbitrary
length.
-``code``
- The ``code`` type represents a code fragment. The values are the same as
- those for the ``string`` type; the ``code`` type is provided just to indicate
- the programmer's intention.
-
``bits<``\ *n*\ ``>``
The ``bits`` type is a fixed-sized integer of arbitrary length *n* that
is treated as separate bits. These bits can be accessed individually.
@@ -348,12 +344,12 @@ Simple values
The :token:`SimpleValue` has a number of forms.
.. productionlist::
- SimpleValue: `TokInteger` | `TokString`+ | `TokCodeFragment`
+ SimpleValue: `TokInteger` | `TokString`+ | `TokCode`
-A value can be an integer literal, a string literal, or a code fragment
-literal. Multiple adjacent string literals are concatenated as in C/C++; the
-simple value is the concatenation of the strings. Code fragments become
-strings and then are indistinguishable from them.
+A value can be an integer literal, a string literal, or a code literal.
+Multiple adjacent string literals are concatenated as in C/C++; the simple
+value is the concatenation of the strings. Code literals become strings and
+are then indistinguishable from them.
.. productionlist::
SimpleValue2: "true" | "false"
@@ -616,14 +612,15 @@ name of a multiclass.
.. productionlist::
Body: ";" | "{" `BodyItem`* "}"
- BodyItem: `Type` `TokIdentifier` ["=" `Value`] ";"
+ BodyItem: (`Type` | "code") `TokIdentifier` ["=" `Value`] ";"
:| "let" `TokIdentifier` ["{" `RangeList` "}"] "=" `Value` ";"
:| "defvar" `TokIdentifier` "=" `Value` ";"
A field definition in the body specifies a field to be included in the class
or record. If no initial value is specified, then the field's value is
uninitialized. The type must be specified; TableGen will not infer it from
-the value.
+the value. The keyword ``code`` may be used to emphasize that the field
+has a string value that is code.
The ``let`` form is used to reset a field to a new value. This can be done
for fields defined directly in the body or fields inherited from
diff --git a/llvm/include/llvm/TableGen/Error.h b/llvm/include/llvm/TableGen/Error.h
index a742e9e1606c..f63b50ad786c 100644
--- a/llvm/include/llvm/TableGen/Error.h
+++ b/llvm/include/llvm/TableGen/Error.h
@@ -22,6 +22,7 @@ namespace llvm {
void PrintNote(const Twine &Msg);
void PrintNote(ArrayRef<SMLoc> NoteLoc, const Twine &Msg);
+LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(const Twine &Msg);
LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(ArrayRef<SMLoc> ErrorLoc,
const Twine &Msg);
LLVM_ATTRIBUTE_NORETURN void PrintFatalNote(const Record *Rec,
@@ -37,6 +38,7 @@ void PrintError(const Twine &Msg);
void PrintError(ArrayRef<SMLoc> ErrorLoc, const Twine &Msg);
void PrintError(const char *Loc, const Twine &Msg);
void PrintError(const Record *Rec, const Twine &Msg);
+void PrintError(const RecordVal *RecVal, const Twine &Msg);
LLVM_ATTRIBUTE_NORETURN void PrintFatalError(const Twine &Msg);
LLVM_ATTRIBUTE_NORETURN void PrintFatalError(ArrayRef<SMLoc> ErrorLoc,
diff --git a/llvm/include/llvm/TableGen/Record.h b/llvm/include/llvm/TableGen/Record.h
index 20b786dc6e42..1c3ec5fb21f5 100644
--- a/llvm/include/llvm/TableGen/Record.h
+++ b/llvm/include/llvm/TableGen/Record.h
@@ -58,7 +58,6 @@ class RecTy {
enum RecTyKind {
BitRecTyKind,
BitsRecTyKind,
- CodeRecTyKind,
IntRecTyKind,
StringRecTyKind,
ListRecTyKind,
@@ -138,24 +137,6 @@ class BitsRecTy : public RecTy {
bool typeIsA(const RecTy *RHS) const override;
};
-/// 'code' - Represent a code fragment
-class CodeRecTy : public RecTy {
- static CodeRecTy Shared;
-
- CodeRecTy() : RecTy(CodeRecTyKind) {}
-
-public:
- static bool classof(const RecTy *RT) {
- return RT->getRecTyKind() == CodeRecTyKind;
- }
-
- static CodeRecTy *get() { return &Shared; }
-
- std::string getAsString() const override { return "code"; }
-
- bool typeIsConvertibleTo(const RecTy *RHS) const override;
-};
-
/// 'int' - Represent an integer value of no particular size
class IntRecTy : public RecTy {
static IntRecTy Shared;
@@ -306,7 +287,6 @@ class Init {
IK_FirstTypedInit,
IK_BitInit,
IK_BitsInit,
- IK_CodeInit,
IK_DagInit,
IK_DefInit,
IK_FieldInit,
@@ -597,16 +577,18 @@ class IntInit : public TypedInit {
/// "foo" - Represent an initialization by a string value.
class StringInit : public TypedInit {
-//// enum StringFormat {
-//// SF_String, // Format as "text"
-//// SF_Code, // Format as [{text}]
-//// };
+public:
+ enum StringFormat {
+ SF_String, // Format as "text"
+ SF_Code, // Format as [{text}]
+ };
+private:
StringRef Value;
-//// StringFormat Format;
+ StringFormat Format;
- explicit StringInit(StringRef V)
- : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {}
+ explicit StringInit(StringRef V, StringFormat Fmt)
+ : TypedInit(IK_StringInit, StringRecTy::get()), Value(V), Format(Fmt) {}
public:
StringInit(const StringInit &) = delete;
@@ -616,48 +598,25 @@ class StringInit : public TypedInit {
return I->getKind() == IK_StringInit;
}
- static StringInit *get(StringRef);
-
- StringRef getValue() const { return Value; }
-
- Init *convertInitializerTo(RecTy *Ty) const override;
+ static StringInit *get(StringRef, StringFormat Fmt = SF_String);
- bool isConcrete() const override { return true; }
- std::string getAsString() const override { return "\"" + Value.str() + "\""; }
-
- std::string getAsUnquotedString() const override {
- return std::string(Value);
- }
-
- Init *getBit(unsigned Bit) const override {
- llvm_unreachable("Illegal bit reference off string");
- }
-};
-
-class CodeInit : public TypedInit {
- StringRef Value;
-
- explicit CodeInit(StringRef V)
- : TypedInit(IK_CodeInit, static_cast<RecTy *>(CodeRecTy::get())),
- Value(V) {}
-
-public:
- CodeInit(const StringInit &) = delete;
- CodeInit &operator=(const StringInit &) = delete;
-
- static bool classof(const Init *I) {
- return I->getKind() == IK_CodeInit;
+ static StringFormat determineFormat(StringFormat Fmt1, StringFormat Fmt2) {
+ return (Fmt1 == SF_Code || Fmt2 == SF_Code) ? SF_Code : SF_String;
}
- static CodeInit *get(StringRef);
-
StringRef getValue() const { return Value; }
+ StringFormat getFormat() const { return Format; }
+ bool hasCodeFormat() const { return Format == SF_Code; }
Init *convertInitializerTo(RecTy *Ty) const override;
bool isConcrete() const override { return true; }
+
std::string getAsString() const override {
- return "[{" + Value.str() + "}]";
+ if (Format == SF_String)
+ return "\"" + Value.str() + "\"";
+ else
+ return "[{" + Value.str() + "}]";
}
std::string getAsUnquotedString() const override {
@@ -1438,6 +1397,9 @@ class RecordVal {
/// Get the type of the field value as a RecTy.
RecTy *getType() const { return TyAndPrefix.getPointer(); }
+ /// Get the type of the field for printing purposes.
+ std::string getPrintType() const;
+
/// Get the value of the field as an Init.
Init *getValue() const { return Value; }
@@ -1675,11 +1637,6 @@ class Record {
/// not a string and llvm::Optional() if the field does not exist.
llvm::Optional<StringRef> getValueAsOptionalString(StringRef FieldName) const;
- /// This method looks up the specified field and returns
- /// its value as a string, throwing an exception if the field if the value is
- /// not a code block and llvm::Optional() if the field does not exist.
- llvm::Optional<StringRef> getValueAsOptionalCode(StringRef FieldName) const;
-
/// This method looks up the specified field and returns
/// its value as a BitsInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
diff --git a/llvm/include/llvm/TableGen/SearchableTable.td b/llvm/include/llvm/TableGen/SearchableTable.td
index 32b9829aa072..61dfa5c70706 100644
--- a/llvm/include/llvm/TableGen/SearchableTable.td
+++ b/llvm/include/llvm/TableGen/SearchableTable.td
@@ -67,9 +67,13 @@ class GenericTable {
// List of the names of fields of collected records that contain the data for
// table entries, in the order that is used for initialization in C++.
//
- // For each field of the table named XXX, TableGen will look for a value
- // called TypeOf_XXX and use that as a more detailed description of the
- // type of the field if present. This is required for fields whose type
+ // TableGen needs to know the type of the fields so that it can format
+ // the initializers correctly. It can infer the type of bit, bits, string,
+ // Intrinsic, and Instruction values.
+ //
+ // For each field of the table named xxx, TableGen will look for a field
+ // named TypeOf_xxx and use that as a more detailed description of the
+ // type of the field. This is required for fields whose type
// cannot be deduced automatically, such as enum fields. For example:
//
// def MyEnum : GenericEnum {
@@ -85,15 +89,15 @@ class GenericTable {
// def MyTable : GenericTable {
// let FilterClass = "MyTableEntry";
// let Fields = ["V", ...];
- // GenericEnum TypeOf_V = MyEnum;
+ // string TypeOf_V = "MyEnum";
// }
//
- // Fields of type bit, bits<N>, string, Intrinsic, and Instruction (or
- // derived classes of those) are supported natively.
+ // If a string field was initialized with a code literal, TableGen will
+ // emit the code verbatim. However, if a string field was initialized
+ // in some other way, but should be interpreted as code, then a TypeOf_xxx
+ // field is necessary, with a value of "code":
//
- // Additionally, fields of type `code` can appear, where the value is used
- // verbatim as an initializer. However, these fields cannot be used as
- // search keys.
+ // string TypeOf_Predicate = "code";
list<string> Fields;
// (Optional) List of fields that make up the primary key.
diff --git a/llvm/lib/TableGen/Error.cpp b/llvm/lib/TableGen/Error.cpp
index 015b1d350197..eed4de67942a 100644
--- a/llvm/lib/TableGen/Error.cpp
+++ b/llvm/lib/TableGen/Error.cpp
@@ -52,6 +52,13 @@ void PrintNote(ArrayRef<SMLoc> NoteLoc, const Twine &Msg) {
// Functions to print fatal notes.
+void PrintFatalNote(const Twine &Msg) {
+ PrintNote(Msg);
+ // The following call runs the file cleanup handlers.
+ sys::RunInterruptHandlers();
+ std::exit(1);
+}
+
void PrintFatalNote(ArrayRef<SMLoc> NoteLoc, const Twine &Msg) {
PrintNote(NoteLoc, Msg);
// The following call runs the file cleanup handlers.
@@ -107,6 +114,12 @@ void PrintError(const Record *Rec, const Twine &Msg) {
PrintMessage(Rec->getLoc(), SourceMgr::DK_Error, Msg);
}
+// This method takes a RecordVal and uses the source location
+// stored in it.
+void PrintError(const RecordVal *RecVal, const Twine &Msg) {
+ PrintMessage(RecVal->getLoc(), SourceMgr::DK_Error, Msg);
+}
+
// Functions to print fatal errors.
void PrintFatalError(const Twine &Msg) {
diff --git a/llvm/lib/TableGen/JSONBackend.cpp b/llvm/lib/TableGen/JSONBackend.cpp
index 196644cda667..ea82934e5d3b 100644
--- a/llvm/lib/TableGen/JSONBackend.cpp
+++ b/llvm/lib/TableGen/JSONBackend.cpp
@@ -59,8 +59,6 @@ json::Value JSONEmitter::translateInit(const Init &I) {
return Int->getValue();
} else if (auto *Str = dyn_cast<StringInit>(&I)) {
return Str->getValue();
- } else if (auto *Code = dyn_cast<CodeInit>(&I)) {
- return Code->getValue();
} else if (auto *List = dyn_cast<ListInit>(&I)) {
json::Array array;
for (auto val : *List)
diff --git a/llvm/lib/TableGen/Record.cpp b/llvm/lib/TableGen/Record.cpp
index a8f0e19a2bbd..1e2d75f3fe8d 100644
--- a/llvm/lib/TableGen/Record.cpp
+++ b/llvm/lib/TableGen/Record.cpp
@@ -43,15 +43,11 @@ using namespace llvm;
static BumpPtrAllocator Allocator;
-STATISTIC(CodeInitsConstructed,
- "The total number of unique CodeInits constructed");
-
//===----------------------------------------------------------------------===//
// Type implementations
//===----------------------------------------------------------------------===//
BitRecTy BitRecTy::Shared;
-CodeRecTy CodeRecTy::Shared;
IntRecTy IntRecTy::Shared;
StringRecTy StringRecTy::Shared;
DagRecTy DagRecTy::Shared;
@@ -113,18 +109,13 @@ bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
}
-bool CodeRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
- RecTyKind Kind = RHS->getRecTyKind();
- return Kind == CodeRecTyKind || Kind == StringRecTyKind;
-}
-
std::string StringRecTy::getAsString() const {
return "string";
}
bool StringRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
RecTyKind Kind = RHS->getRecTyKind();
- return Kind == StringRecTyKind || Kind == CodeRecTyKind;
+ return Kind == StringRecTyKind;
}
std::string ListRecTy::getAsString() const {
@@ -514,38 +505,26 @@ IntInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
return BitsInit::get(NewBits);
}
-CodeInit *CodeInit::get(StringRef V) {
- static StringMap<CodeInit*, BumpPtrAllocator &> ThePool(Allocator);
+StringInit *StringInit::get(StringRef V, StringFormat Fmt) {
+ static StringMap<StringInit*, BumpPtrAllocator &> StringPool(Allocator);
+ static StringMap<StringInit*, BumpPtrAllocator &> CodePool(Allocator);
- auto &Entry = *ThePool.insert(std::make_pair(V, nullptr)).first;
- if (!Entry.second)
- Entry.second = new(Allocator) CodeInit(Entry.getKey());
- return Entry.second;
-}
-
-StringInit *StringInit::get(StringRef V) {
- static StringMap<StringInit*, BumpPtrAllocator &> ThePool(Allocator);
-
- auto &Entry = *ThePool.insert(std::make_pair(V, nullptr)).first;
- if (!Entry.second)
- Entry.second = new(Allocator) StringInit(Entry.getKey());
- return Entry.second;
+ if (Fmt == SF_String) {
+ auto &Entry = *StringPool.insert(std::make_pair(V, nullptr)).first;
+ if (!Entry.second)
+ Entry.second = new (Allocator) StringInit(Entry.getKey(), Fmt);
+ return Entry.second;
+ } else {
+ auto &Entry = *CodePool.insert(std::make_pair(V, nullptr)).first;
+ if (!Entry.second)
+ Entry.second = new (Allocator) StringInit(Entry.getKey(), Fmt);
+ return Entry.second;
+ }
}
Init *StringInit::convertInitializerTo(RecTy *Ty) const {
if (isa<StringRecTy>(Ty))
return const_cast<StringInit *>(this);
- if (isa<CodeRecTy>(Ty))
- return CodeInit::get(getValue());
-
- return nullptr;
-}
-
-Init *CodeInit::convertInitializerTo(RecTy *Ty) const {
- if (isa<CodeRecTy>(Ty))
- return const_cast<CodeInit *>(this);
- if (isa<StringRecTy>(Ty))
- return StringInit::get(getValue());
return nullptr;
}
@@ -868,7 +847,9 @@ static StringInit *ConcatStringInits(const StringInit *I0,
const StringInit *I1) {
SmallString<80> Concat(I0->getValue());
Concat.append(I1->getValue());
- return StringInit::get(Concat);
+ return StringInit::get(Concat,
+ StringInit::determineFormat(I0->getFormat(),
+ I1->getFormat()));
}
static StringInit *interleaveStringList(const ListInit *List,
@@ -876,12 +857,15 @@ static StringInit *interleaveStringList(const ListInit *List,
if (List->size() == 0)
return StringInit::get("");
SmallString<80> Result(dyn_cast<StringInit>(List->getElement(0))->getValue());
+ StringInit::StringFormat Fmt = StringInit::SF_String;
for (unsigned I = 1, E = List->size(); I < E; ++I) {
Result.append(Delim->getValue());
- Result.append(dyn_cast<StringInit>(List->getElement(I))->getValue());
+ auto *StrInit = dyn_cast<StringInit>(List->getElement(I));
+ Result.append(StrInit->getValue());
+ Fmt = StringInit::determineFormat(Fmt, StrInit->getFormat());
}
- return StringInit::get(Result);
+ return StringInit::get(Result, Fmt);
}
static StringInit *interleaveIntList(const ListInit *List,
@@ -2139,6 +2123,21 @@ StringRef RecordVal::getName() const {
return cast<StringInit>(getNameInit())->getValue();
}
+std::string RecordVal::getPrintType() const {
+ if (getType() == StringRecTy::get()) {
+ if (auto *StrInit = dyn_cast<StringInit>(Value)) {
+ if (StrInit->hasCodeFormat())
+ return "code";
+ else
+ return "string";
+ } else {
+ return "string";
+ }
+ } else {
+ return TyAndPrefix.getPointer()->getAsString();
+ }
+}
+
bool RecordVal::setValue(Init *V) {
if (V) {
Value = V->getCastTo(getType());
@@ -2193,7 +2192,7 @@ LLVM_DUMP_METHOD void RecordVal::dump() const { errs() << *this; }
void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
if (getPrefix()) OS << "field ";
- OS << *getType() << " " << getNameInitAsString();
+ OS << getPrintType() << " " << getNameInitAsString();
if (getValue())
OS << " = " << *getValue();
@@ -2365,6 +2364,7 @@ StringRef Record::getValueAsString(StringRef FieldName) const {
"' does not have a field named `" + FieldName + "'!\n");
return S.getValue();
}
+
llvm::Optional<StringRef>
Record::getValueAsOptionalString(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
@@ -2375,28 +2375,11 @@ Record::getValueAsOptionalString(StringRef FieldName) const {
if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
return SI->getValue();
- if (CodeInit *CI = dyn_cast<CodeInit>(R->getValue()))
- return CI->getValue();
PrintFatalError(getLoc(),
"Record `" + getName() + "', ` field `" + FieldName +
"' exists but does not have a string initializer!");
}
-llvm::Optional<StringRef>
-Record::getValueAsOptionalCode(StringRef FieldName) const {
- const RecordVal *R = getValue(FieldName);
- if (!R || !R->getValue())
- return llvm::Optional<StringRef>();
- if (isa<UnsetInit>(R->getValue()))
- return llvm::Optional<StringRef>();
-
- if (CodeInit *CI = dyn_cast<CodeInit>(R->getValue()))
- return CI->getValue();
-
- PrintFatalError(getLoc(),
- "Record `" + getName() + "', field `" + FieldName +
- "' exists but does not have a code initializer!");
-}
BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
@@ -2473,8 +2456,6 @@ Record::getValueAsListOfStrings(StringRef FieldName) const {
for (Init *I : List->getValues()) {
if (StringInit *SI = dyn_cast<StringInit>(I))
Strings.push_back(SI->getValue());
- else if (CodeInit *CI = dyn_cast<CodeInit>(I))
- Strings.push_back(CI->getValue());
else
PrintFatalError(getLoc(),
Twine("Record `") + getName() + "', field `" + FieldName +
diff --git a/llvm/lib/TableGen/TGLexer.cpp b/llvm/lib/TableGen/TGLexer.cpp
index a54161c62d99..df0df96f40eb 100644
--- a/llvm/lib/TableGen/TGLexer.cpp
+++ b/llvm/lib/TableGen/TGLexer.cpp
@@ -540,7 +540,7 @@ tgtok::TokKind TGLexer::LexBracket() {
}
}
- return ReturnError(CodeStart-2, "Unterminated Code Block");
+ return ReturnError(CodeStart - 2, "Unterminated code block");
}
/// LexExclaim - Lex '!' and '![a-zA-Z]+'.
diff --git a/llvm/lib/TableGen/TGLexer.h b/llvm/lib/TableGen/TGLexer.h
index 607f428c96d8..1856bef3ea9b 100644
--- a/llvm/lib/TableGen/TGLexer.h
+++ b/llvm/lib/TableGen/TGLexer.h
@@ -86,8 +86,8 @@ class TGLexer {
// Information about the current token.
const char *TokStart = nullptr;
tgtok::TokKind CurCode = tgtok::TokKind::Eof;
- std::string CurStrVal; // This is valid for ID, STRVAL, VARNAME, CODEFRAGMENT
- int64_t CurIntVal = 0; // This is valid for INTVAL.
+ std::string CurStrVal; // This is valid for Id, StrVal, VarName, CodeFragment
+ int64_t CurIntVal = 0; // This is valid for IntVal.
/// CurBuffer - This is the current buffer index we're lexing from as managed
/// by the SourceMgr object.
diff --git a/llvm/lib/TableGen/TGParser.cpp b/llvm/lib/TableGen/TGParser.cpp
index 5c9cba5bc926..2671d29a7272 100644
--- a/llvm/lib/TableGen/TGParser.cpp
+++ b/llvm/lib/TableGen/TGParser.cpp
@@ -799,8 +799,8 @@ bool TGParser::ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges) {
RecTy *TGParser::ParseType() {
switch (Lex.getCode()) {
default: TokError("Unknown token when expecting a type"); return nullptr;
- case tgtok::String: Lex.Lex(); return StringRecTy::get();
- case tgtok::Code: Lex.Lex(); return CodeRecTy::get();
+ case tgtok::String:
+ case tgtok::Code: Lex.Lex(); return StringRecTy::get();
case tgtok::Bit: Lex.Lex(); return BitRecTy::get();
case tgtok::Int: Lex.Lex(); return IntRecTy::get();
case tgtok::Dag: Lex.Lex(); return DagRecTy::get();
@@ -1637,6 +1637,9 @@ RecTy *TGParser::ParseOperatorType() {
return nullptr;
}
+ if (Lex.getCode() == tgtok::Code)
+ TokError("the 'code' type is not allowed in bang operators; use 'string'");
+
Type = ParseType();
if (!Type) {
@@ -1920,7 +1923,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
break;
}
case tgtok::CodeFragment:
- R = CodeInit::get(Lex.getCurStrVal());
+ R = StringInit::get(Lex.getCurStrVal(), StringInit::SF_Code);
Lex.Lex();
break;
case tgtok::question:
diff --git a/llvm/lib/Target/AMDGPU/MIMGInstructions.td b/llvm/lib/Target/AMDGPU/MIMGInstructions.td
index 892c6dd7bd78..7baa6823d16a 100644
--- a/llvm/lib/Target/AMDGPU/MIMGInstructions.td
+++ b/llvm/lib/Target/AMDGPU/MIMGInstructions.td
@@ -51,7 +51,7 @@ def MIMGBaseOpcodesTable : GenericTable {
let Fields = ["BaseOpcode", "Store", "Atomic", "AtomicX2", "Sampler",
"Gather4", "NumExtraArgs", "Gradients", "G16", "Coordinates",
"LodOrClampOrMip", "HasD16"];
- GenericEnum TypeOf_BaseOpcode = MIMGBaseOpcode;
+ string TypeOf_BaseOpcode = "MIMGBaseOpcode";
let PrimaryKey = ["BaseOpcode"];
let PrimaryKeyName = "getMIMGBaseOpcodeInfo";
@@ -65,7 +65,7 @@ def MIMGDimInfoTable : GenericTable {
let FilterClass = "AMDGPUDimProps";
let CppTypeName = "MIMGDimInfo";
let Fields = ["Dim", "NumCoords", "NumGradients", "DA", "Encoding", "AsmSuffix"];
- GenericEnum TypeOf_Dim = MIMGDim;
+ string TypeOf_Dim = "MIMGDim";
let PrimaryKey = ["Dim"];
let PrimaryKeyName = "getMIMGDimInfo";
@@ -95,8 +95,8 @@ def MIMGLZMappingTable : GenericTable {
let FilterClass = "MIMGLZMapping";
let CppTypeName = "MIMGLZMappingInfo";
let Fields = ["L", "LZ"];
- GenericEnum TypeOf_L = MIMGBaseOpcode;
- GenericEnum TypeOf_LZ = MIMGBaseOpcode;
+ string TypeOf_L = "MIMGBaseOpcode";
+ string TypeOf_LZ = "MIMGBaseOpcode";
let PrimaryKey = ["L"];
let PrimaryKeyName = "getMIMGLZMappingInfo";
@@ -111,8 +111,8 @@ def MIMGMIPMappingTable : GenericTable {
let FilterClass = "MIMGMIPMapping";
let CppTypeName = "MIMGMIPMappingInfo";
let Fields = ["MIP", "NONMIP"];
- GenericEnum TypeOf_MIP = MIMGBaseOpcode;
- GenericEnum TypeOf_NONMIP = MIMGBaseOpcode;
+ string TypeOf_MIP = "MIMGBaseOpcode";
+ string TypeOf_NONMIP = "MIMGBaseOpcode";
let PrimaryKey = ["MIP"];
let PrimaryKeyName = "getMIMGMIPMappingInfo";
@@ -127,8 +127,8 @@ def MIMGG16MappingTable : GenericTable {
let FilterClass = "MIMGG16Mapping";
let CppTypeName = "MIMGG16MappingInfo";
let Fields = ["G", "G16"];
- GenericEnum TypeOf_G = MIMGBaseOpcode;
- GenericEnum TypeOf_G16 = MIMGBaseOpcode;
+ string TypeOf_G = "MIMGBaseOpcode";
+ string TypeOf_G16 = "MIMGBaseOpcode";
let PrimaryKey = ["G"];
let PrimaryKeyName = "getMIMGG16MappingInfo";
@@ -168,8 +168,8 @@ def MIMGInfoTable : GenericTable {
let FilterClass = "MIMG";
let CppTypeName = "MIMGInfo";
let Fields = ["Opcode", "BaseOpcode", "MIMGEncoding", "VDataDwords", "VAddrDwords"];
- GenericEnum TypeOf_BaseOpcode = MIMGBaseOpcode;
- GenericEnum TypeOf_MIMGEncoding = MIMGEncoding;
+ string TypeOf_BaseOpcode = "MIMGBaseOpcode";
+ string TypeOf_MIMGEncoding = "MIMGEncoding";
let PrimaryKey = ["BaseOpcode", "MIMGEncoding", "VDataDwords", "VAddrDwords"];
let PrimaryKeyName = "getMIMGOpcodeHelper";
@@ -926,8 +926,8 @@ def ImageDimIntrinsicTable : GenericTable {
"DMaskIndex", "VAddrStart", "GradientStart", "CoordStart", "LodIndex", "MipIndex", "VAddrEnd",
"RsrcIndex", "SampIndex", "UnormIndex", "TexFailCtrlIndex", "CachePolicyIndex",
"GradientTyArg", "CoordTyArg"];
- GenericEnum TypeOf_BaseOpcode = MIMGBaseOpcode;
- GenericEnum TypeOf_Dim = MIMGDim;
+ string TypeOf_BaseOpcode = "MIMGBaseOpcode";
+ string TypeOf_Dim = "MIMGDim";
let PrimaryKey = ["Intr"];
let PrimaryKeyName = "getImageDimIntrinsicInfo";
diff --git a/llvm/test/TableGen/code.td b/llvm/test/TableGen/code.td
index 317e3e4d3f05..d709b18855bc 100644
--- a/llvm/test/TableGen/code.td
+++ b/llvm/test/TableGen/code.td
@@ -1,22 +1,49 @@
// RUN: llvm-tblgen %s | FileCheck %s
+// RUN: not llvm-tblgen -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
// XFAIL: vg_leak
-// CHECK: --- Defs ---
+// CHECK: def A1
+// CHECK: code CodeCode = [{code here;}]
+// CHECK: code StringCode = [{code here;}]
-// CHECK: def A0 {
-// CHECK: code Code = [{Simple}];
-// CHECK: }
+// CHECK: def A2
+// CHECK: string CodeCode = "string here"
+// CHECK: string StringCode = "string here"
-// CHECK: def B0 {
-// CHECK: code Code = [{With paste 7}];
-// CHECK: }
+// CHECK: def B1
+// CHECK: string CodeCode = "with paste 7"
+// CHECK: string StringCode = "with paste 7"
+
+// CHECK: def C1
+// CHECK: code CodeCode = [{with concat 42}]
+// CHECK: code StringCode = [{with concat 42}]
+
+// CHECK: def D1
+// CHECK: code CodeCode = [{with concat 108!}]
+// CHECK: code StringCode = [{with concat 108!}]
class A<code c> {
- code Code = c;
+ code CodeCode = c;
+ string StringCode = c;
}
-def A0 : A<"Simple">;
+def A1 : A<[{code here;}]>;
+def A2 : A<"string here">;
+
+class B<int i> : A<"with paste " # i>;
+class C<int i> : A<!strconcat([{with concat }], !cast<string>(i))>;
+class D<int i> : A<!strconcat([{with concat }], !cast<string>(i), "!")>;
+
+def B1 : B<7>;
+def C1 : C<42>;
+def D1 : D<108>;
-class B<int i> : A<"With paste " # i>;
+#ifdef ERROR1
+
+// ERROR1: the 'code' type is not allowed
+
+def Zerror1 {
+ code Code = !cast<code>("i = 0;");
+}
-def B0 : B<7>;
+#endif
diff --git a/llvm/test/TableGen/generic-tables.td b/llvm/test/TableGen/generic-tables.td
index fefa82684294..e410159e6dfb 100644
--- a/llvm/test/TableGen/generic-tables.td
+++ b/llvm/test/TableGen/generic-tables.td
@@ -55,19 +55,26 @@ def ATable : GenericTable {
// CHECK-LABEL: GET_BTable_IMPL
+// CHECK: constexpr BTypeName BTable[] = {
+// CHECK: { "BAlice", 0xAC, },
+// CHECK: { "BBob", 0x14, Bob == 13 },
+// CHECK: { "BCharlie", 0x80, Charlie == 42 },
+// CHECK: { "BEve", 0x4C, Eve == 108 },
+// CHECK: };
// CHECK: const BTypeName *lookupBTableByName(StringRef Name) {
// CHECK: return &BTable[Idx->_index];
// CHECK: }
-class BEntry<bits<16> enc> {
+class BEntry<bits<16> enc, code test = [{}]> {
string Name = NAME;
bits<16> Encoding = enc;
+ code Test = test;
}
def BAlice : BEntry<0xac>;
-def BBob : BEntry<0x14>;
-def BCharlie : BEntry<0x80>;
-def BEve : BEntry<0x4c>;
+def BBob : BEntry<0x14, [{Bob == 13}]>;
+def BCharlie : BEntry<0x80, "Charlie == 42">;
+def BEve : BEntry<0x4c, [{Eve == }] # 108>;
def BValues : GenericEnum {
let FilterClass = "BEntry";
@@ -78,7 +85,8 @@ def BValues : GenericEnum {
def BTable : GenericTable {
let FilterClass = "BEntry";
string CppTypeName = "BTypeName";
- let Fields = ["Name", "Encoding"];
+ let Fields = ["Name", "Encoding", "Test"];
+ string TypeOf_Test = "code";
}
def lookupBTableByName : SearchIndex {
@@ -126,7 +134,7 @@ def CTable : GenericTable {
let FilterClass = "CEntry";
let Fields = ["Name", "Kind", "Encoding"];
- GenericEnum TypeOf_Kind = CEnum;
+ string TypeOf_Kind = "CEnum";
let PrimaryKey = ["Encoding"];
let PrimaryKeyName = "lookupCEntryByEncoding";
diff --git a/llvm/test/TableGen/interleave.td b/llvm/test/TableGen/interleave.td
index 7d6bfee15a56..098542ab29a1 100644
--- a/llvm/test/TableGen/interleave.td
+++ b/llvm/test/TableGen/interleave.td
@@ -28,9 +28,9 @@ def Rec1 {
}
// CHECK: def Rec2
-// CHECK: Test1 = "01234567";
-// CHECK: Test2 = "0, 1, 2, 3, 4, 5, 6, 7";
-// CHECK: Test3 = "0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 42";
+// CHECK: Test1 = "01234567";
+// CHECK: Test2 = "0, 1, 2, 3, 4, 5, 6, 7";
+// CHECK: Test3 = "0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 42";
def Rec2 {
string Test1 = !interleave(IntList, "");
@@ -39,9 +39,9 @@ def Rec2 {
}
// CHECK: def Rec3
-// CHECK: Test1 = "271";
-// CHECK: Test2 = "2, 7, 1";
-// CHECK: Test3 = "2 & 7 & 1 & 0";
+// CHECK: Test1 = "271";
+// CHECK: Test2 = "2, 7, 1";
+// CHECK: Test3 = "2 & 7 & 1 & 0";
def Rec3 {
string Test1 = !interleave(BitsList, "");
@@ -50,9 +50,9 @@ def Rec3 {
}
// CHECK: def Rec4
-// CHECK: Test1 = "01101";
-// CHECK: Test2 = "0, 1, 1, 0, 1";
-// CHECK: Test3 = "0 and 1 and 1 and 0 and 1 and 1";
+// CHECK: Test1 = "01101";
+// CHECK: Test2 = "0, 1, 1, 0, 1";
+// CHECK: Test3 = "0 and 1 and 1 and 0 and 1 and 1";
def Rec4 {
string Test1 = !interleave(BitList, "");
@@ -61,14 +61,23 @@ def Rec4 {
}
// CHECK: def Rec5
-// CHECK: Colors = ["red", "green", "yellow"];
-// CHECK: ColorList = "redify, greenify, yellowify";
+// CHECK: Colors = ["red", "green", "yellow"];
+// CHECK: ColorList = "redify, greenify, yellowify";
def Rec5 {
list<string> Colors = ["red", "green", "yellow"];
string ColorList = !interleave(Ishify<Colors>.ret, ", ");
}
+// CHECK: def Rec6
+// CHECK: code OperatorList = [{+, -, *, /, ?:, ;}];
+
+def Rec6 {
+ list<string> Operators = ["+", "-", "*", "/", "?:"];
+ code OperatorList = !interleave(!listconcat(Operators, [[{;}]]), ", ");
+}
+
+
#ifdef ERROR1
def op;
diff --git a/llvm/test/TableGen/unterminated-code-block.td b/llvm/test/TableGen/unterminated-code-block.td
index 86395abd789e..d6b6f50827a6 100644
--- a/llvm/test/TableGen/unterminated-code-block.td
+++ b/llvm/test/TableGen/unterminated-code-block.td
@@ -1,5 +1,5 @@
// RUN: not llvm-tblgen -I %p %s 2>&1 | FileCheck %s
-// CHECK: error: Unterminated Code Block
+// CHECK: error: Unterminated code block
include "unterminated-code-block-include.inc" }]>;
diff --git a/llvm/utils/TableGen/AsmWriterEmitter.cpp b/llvm/utils/TableGen/AsmWriterEmitter.cpp
index f903be169476..9a5908827b4e 100644
--- a/llvm/utils/TableGen/AsmWriterEmitter.cpp
+++ b/llvm/utils/TableGen/AsmWriterEmitter.cpp
@@ -1265,13 +1265,10 @@ void AsmWriterEmitter::EmitPrintAliasInstruction(raw_ostream &O) {
<< " break;\n";
for (unsigned i = 0; i < MCOpPredicates.size(); ++i) {
- Init *MCOpPred = MCOpPredicates[i]->getValueInit("MCOperandPredicate");
- if (CodeInit *SI = dyn_cast<CodeInit>(MCOpPred)) {
- O << " case " << i + 1 << ": {\n"
- << SI->getValue() << "\n"
- << " }\n";
- } else
- llvm_unreachable("Unexpected MCOperandPredicate field!");
+ StringRef MCOpPred = MCOpPredicates[i]->getValueAsString("MCOperandPredicate");
+ O << " case " << i + 1 << ": {\n"
+ << MCOpPred.data() << "\n"
+ << " }\n";
}
O << " }\n"
<< "}\n\n";
diff --git a/llvm/utils/TableGen/DFAEmitter.cpp b/llvm/utils/TableGen/DFAEmitter.cpp
index e87765085289..781cb0636fa1 100644
--- a/llvm/utils/TableGen/DFAEmitter.cpp
+++ b/llvm/utils/TableGen/DFAEmitter.cpp
@@ -346,8 +346,7 @@ Transition::Transition(Record *R, Automaton *Parent) {
} else if (isa<IntRecTy>(SymbolV->getType())) {
Actions.emplace_back(nullptr, R->getValueAsInt(A), "");
Types.emplace_back("unsigned");
- } else if (isa<StringRecTy>(SymbolV->getType()) ||
- isa<CodeRecTy>(SymbolV->getType())) {
+ } else if (isa<StringRecTy>(SymbolV->getType())) {
Actions.emplace_back(nullptr, 0, std::string(R->getValueAsString(A)));
Types.emplace_back("std::string");
} else {
diff --git a/llvm/utils/TableGen/GICombinerEmitter.cpp b/llvm/utils/TableGen/GICombinerEmitter.cpp
index d84d049e89f0..5f091467636d 100644
--- a/llvm/utils/TableGen/GICombinerEmitter.cpp
+++ b/llvm/utils/TableGen/GICombinerEmitter.cpp
@@ -150,7 +150,7 @@ class CombineRule {
/// A block of arbitrary C++ to finish testing the match.
/// FIXME: This is a temporary measure until we have actual pattern matching
- const CodeInit *MatchingFixupCode = nullptr;
+ const StringInit *MatchingFixupCode = nullptr;
/// The MatchData defined by the match stage and required by the apply stage.
/// This allows the plumbing of arbitrary data from C++ predicates between the
@@ -199,7 +199,7 @@ class CombineRule {
unsigned allocUID() { return UID++; }
StringRef getName() const { return TheDef.getName(); }
const Record &getDef() const { return TheDef; }
- const CodeInit *getMatchingFixupCode() const { return MatchingFixupCode; }
+ const StringInit *getMatchingFixupCode() const { return MatchingFixupCode; }
size_t getNumRoots() const { return Roots.size(); }
GIMatchDag &getMatchDag() { return MatchDag; }
@@ -514,10 +514,10 @@ bool CombineRule::parseMatcher(const CodeGenTarget &Target) {
// Parse arbitrary C++ code we have in lieu of supporting MIR matching
- if (const CodeInit *CodeI = dyn_cast<CodeInit>(Matchers->getArg(I))) {
+ if (const StringInit *StringI = dyn_cast<StringInit>(Matchers->getArg(I))) {
assert(!MatchingFixupCode &&
"Only one block of arbitrary code is currently permitted");
- MatchingFixupCode = CodeI;
+ MatchingFixupCode = StringI;
MatchDag.setHasPostMatchPredicate(true);
continue;
}
@@ -807,7 +807,7 @@ void GICombinerEmitter::generateCodeForTree(raw_ostream &OS,
}
OS << ") {\n" << Indent << " ";
- if (const CodeInit *Code = dyn_cast<CodeInit>(Applyer->getArg(0))) {
+ if (const StringInit *Code = dyn_cast<StringInit>(Applyer->getArg(0))) {
OS << CodeExpander(Code->getAsUnquotedString(), Expansions,
RuleDef.getLoc(), ShowExpansions)
<< "\n"
diff --git a/llvm/utils/TableGen/RISCVCompressInstEmitter.cpp b/llvm/utils/TableGen/RISCVCompressInstEmitter.cpp
index 200644213ca1..dcca207be7c1 100644
--- a/llvm/utils/TableGen/RISCVCompressInstEmitter.cpp
+++ b/llvm/utils/TableGen/RISCVCompressInstEmitter.cpp
@@ -533,14 +533,11 @@ static unsigned getPredicates(DenseMap<const Record *, unsigned> &PredicateMap,
static void printPredicates(std::vector<const Record *> &Predicates,
StringRef Name, raw_ostream &o) {
for (unsigned i = 0; i < Predicates.size(); ++i) {
- Init *Pred = Predicates[i]->getValueInit(Name);
- if (CodeInit *SI = dyn_cast<CodeInit>(Pred))
- o << " case " << i + 1 << ": {\n"
- << " // " << Predicates[i]->getName().str() << "\n"
- << " " << SI->getValue() << "\n"
- << " }\n";
- else
- llvm_unreachable("Unexpected predicate field!");
+ StringRef Pred = Predicates[i]->getValueAsString(Name);
+ o << " case " << i + 1 << ": {\n"
+ << " // " << Predicates[i]->getName().str() << "\n"
+ << " " << Pred.data() << "\n"
+ << " }\n";
}
}
diff --git a/llvm/utils/TableGen/SearchableTableEmitter.cpp b/llvm/utils/TableGen/SearchableTableEmitter.cpp
index 3c292f30dbcf..2e86b137ac58 100644
--- a/llvm/utils/TableGen/SearchableTableEmitter.cpp
+++ b/llvm/utils/TableGen/SearchableTableEmitter.cpp
@@ -54,6 +54,7 @@ struct GenericEnum {
struct GenericField {
std::string Name;
RecTy *RecType = nullptr;
+ bool IsCode = false;
bool IsIntrinsic = false;
bool IsInstruction = false;
GenericEnum *Enum = nullptr;
@@ -111,14 +112,15 @@ class SearchableTableEmitter {
std::string primaryRepresentation(SMLoc Loc, const GenericField &Field,
Init *I) {
- if (StringInit *SI = dyn_cast<StringInit>(I))
- return SI->getAsString();
- else if (BitsInit *BI = dyn_cast<BitsInit>(I))
+ if (StringInit *SI = dyn_cast<StringInit>(I)) {
+ if (Field.IsCode || SI->hasCodeFormat())
+ return std::string(SI->getValue());
+ else
+ return SI->getAsString();
+ } else if (BitsInit *BI = dyn_cast<BitsInit>(I))
return "0x" + utohexstr(getAsInt(BI));
else if (BitInit *BI = dyn_cast<BitInit>(I))
return BI->getValue() ? "true" : "false";
- else if (CodeInit *CI = dyn_cast<CodeInit>(I))
- return std::string(CI->getValue());
else if (Field.IsIntrinsic)
return "Intrinsic::" + getIntrinsic(I).EnumName;
else if (Field.IsInstruction)
@@ -150,10 +152,6 @@ class SearchableTableEmitter {
bool compareBy(Record *LHS, Record *RHS, const SearchIndex &Index);
- bool isIntegral(Init *I) {
- return isa<BitsInit>(I) || isa<CodeInit>(I) || isIntrinsic(I);
- }
-
std::string searchableFieldType(const GenericTable &Table,
const SearchIndex &Index,
const GenericField &Field, TypeContext Ctx) {
@@ -545,13 +543,19 @@ void SearchableTableEmitter::emitGenericTable(const GenericTable &Table,
OS << "#endif\n\n";
}
-bool SearchableTableEmitter::parseFieldType(GenericField &Field, Init *II) {
- if (auto DI = dyn_cast<DefInit>(II)) {
- Record *TypeRec = DI->getDef();
- if (TypeRec->isSubClassOf("GenericEnum")) {
- Field.Enum = EnumMap[TypeRec];
- Field.RecType = RecordRecTy::get(Field.Enum->Class);
+bool SearchableTableEmitter::parseFieldType(GenericField &Field, Init *TypeOf) {
+ if (auto Type = dyn_cast<StringInit>(TypeOf)) {
+ if (Type->getValue() == "code") {
+ Field.IsCode = true;
return true;
+ } else {
+ if (Record *TypeRec = Records.getDef(Type->getValue())) {
+ if (TypeRec->isSubClassOf("GenericEnum")) {
+ Field.Enum = EnumMap[TypeRec];
+ Field.RecType = RecordRecTy::get(Field.Enum->Class);
+ return true;
+ }
+ }
}
}
@@ -708,12 +712,14 @@ void SearchableTableEmitter::run(raw_ostream &OS) {
for (const auto &FieldName : Fields) {
Table->Fields.emplace_back(FieldName); // Construct a GenericField.
- if (auto TypeOfVal = TableRec->getValue(("TypeOf_" + FieldName).str())) {
- if (!parseFieldType(Table->Fields.back(), TypeOfVal->getValue())) {
- PrintFatalError(TypeOfVal,
- Twine("Table '") + Table->Name +
- "' has invalid 'TypeOf_" + FieldName +
- "': " + TypeOfVal->getValue()->getAsString());
+ if (auto TypeOfRecordVal = TableRec->getValue(("TypeOf_" + FieldName).str())) {
+ if (!parseFieldType(Table->Fields.back(), TypeOfRecordVal->getValue())) {
+ PrintError(TypeOfRecordVal,
+ Twine("Table '") + Table->Name +
+ "' has invalid 'TypeOf_" + FieldName +
+ "': " + TypeOfRecordVal->getValue()->getAsString());
+ PrintFatalNote("The 'TypeOf_xxx' field must be a string naming a "
+ "GenericEnum record, or \"code\"");
}
}
}
diff --git a/mlir/include/mlir/TableGen/Operator.h b/mlir/include/mlir/TableGen/Operator.h
index d7fac87af0be..16d154b3beb0 100644
--- a/mlir/include/mlir/TableGen/Operator.h
+++ b/mlir/include/mlir/TableGen/Operator.h
@@ -28,7 +28,6 @@
#include "llvm/Support/SMLoc.h"
namespace llvm {
-class CodeInit;
class DefInit;
class Record;
class StringInit;
diff --git a/mlir/lib/TableGen/Attribute.cpp b/mlir/lib/TableGen/Attribute.cpp
index 3377ec98c229..99d9d8ab9b3a 100644
--- a/mlir/lib/TableGen/Attribute.cpp
+++ b/mlir/lib/TableGen/Attribute.cpp
@@ -18,7 +18,6 @@
using namespace mlir;
using namespace mlir::tblgen;
-using llvm::CodeInit;
using llvm::DefInit;
using llvm::Init;
using llvm::Record;
@@ -27,8 +26,6 @@ using llvm::StringInit;
// Returns the initializer's value as string if the given TableGen initializer
// is a code or string initializer. Returns the empty StringRef otherwise.
static StringRef getValueAsString(const Init *init) {
- if (const auto *code = dyn_cast<CodeInit>(init))
- return code->getValue().trim();
if (const auto *str = dyn_cast<StringInit>(init))
return str->getValue().trim();
return {};
diff --git a/mlir/lib/TableGen/Dialect.cpp b/mlir/lib/TableGen/Dialect.cpp
index c17180c20483..0c1de78ce60e 100644
--- a/mlir/lib/TableGen/Dialect.cpp
+++ b/mlir/lib/TableGen/Dialect.cpp
@@ -38,7 +38,7 @@ std::string Dialect::getCppClassName() const {
static StringRef getAsStringOrEmpty(const llvm::Record &record,
StringRef fieldName) {
if (auto valueInit = record.getValueInit(fieldName)) {
- if (llvm::isa<llvm::CodeInit, llvm::StringInit>(valueInit))
+ if (llvm::isa<llvm::StringInit>(valueInit))
return record.getValueAsString(fieldName);
}
return "";
diff --git a/mlir/lib/TableGen/Operator.cpp b/mlir/lib/TableGen/Operator.cpp
index b59ffaf8d092..ca1442f547d5 100644
--- a/mlir/lib/TableGen/Operator.cpp
+++ b/mlir/lib/TableGen/Operator.cpp
@@ -547,12 +547,12 @@ StringRef Operator::getSummary() const {
bool Operator::hasAssemblyFormat() const {
auto *valueInit = def.getValueInit("assemblyFormat");
- return isa<llvm::CodeInit, llvm::StringInit>(valueInit);
+ return isa<llvm::StringInit>(valueInit);
}
StringRef Operator::getAssemblyFormat() const {
return TypeSwitch<llvm::Init *, StringRef>(def.getValueInit("assemblyFormat"))
- .Case<llvm::StringInit, llvm::CodeInit>(
+ .Case<llvm::StringInit>(
[&](auto *init) { return init->getValue(); });
}
diff --git a/mlir/lib/TableGen/Pattern.cpp b/mlir/lib/TableGen/Pattern.cpp
index 4128936d4b7f..0dae7ff71883 100644
--- a/mlir/lib/TableGen/Pattern.cpp
+++ b/mlir/lib/TableGen/Pattern.cpp
@@ -55,7 +55,7 @@ bool DagLeaf::isEnumAttrCase() const {
}
bool DagLeaf::isStringAttr() const {
- return isa<llvm::StringInit, llvm::CodeInit>(def);
+ return isa<llvm::StringInit>(def);
}
Constraint DagLeaf::getAsConstraint() const {
diff --git a/mlir/lib/TableGen/Type.cpp b/mlir/lib/TableGen/Type.cpp
index a3d6ac6a7e88..5fe6bbbd5e83 100644
--- a/mlir/lib/TableGen/Type.cpp
+++ b/mlir/lib/TableGen/Type.cpp
@@ -46,7 +46,7 @@ Optional<StringRef> TypeConstraint::getBuilderCall() const {
if (!builderCall || !builderCall->getValue())
return llvm::None;
return TypeSwitch<llvm::Init *, Optional<StringRef>>(builderCall->getValue())
- .Case<llvm::StringInit, llvm::CodeInit>([&](auto *init) {
+ .Case<llvm::StringInit>([&](auto *init) {
StringRef value = init->getValue();
return value.empty() ? Optional<StringRef>() : value;
})
diff --git a/mlir/lib/TableGen/TypeDef.cpp b/mlir/lib/TableGen/TypeDef.cpp
index aa7f36a3626b..d8412b6b4be5 100644
--- a/mlir/lib/TableGen/TypeDef.cpp
+++ b/mlir/lib/TableGen/TypeDef.cpp
@@ -78,10 +78,10 @@ llvm::Optional<StringRef> TypeDef::getMnemonic() const {
return def->getValueAsOptionalString("mnemonic");
}
llvm::Optional<StringRef> TypeDef::getPrinterCode() const {
- return def->getValueAsOptionalCode("printer");
+ return def->getValueAsOptionalString("printer");
}
llvm::Optional<StringRef> TypeDef::getParserCode() const {
- return def->getValueAsOptionalCode("parser");
+ return def->getValueAsOptionalString("parser");
}
bool TypeDef::genAccessors() const {
return def->getValueAsBit("genAccessors");
@@ -114,7 +114,7 @@ llvm::Optional<StringRef> TypeParameter::getAllocator() const {
llvm::RecordVal *code = typeParameter->getDef()->getValue("allocator");
if (!code)
return llvm::Optional<StringRef>();
- if (llvm::CodeInit *ci = dyn_cast<llvm::CodeInit>(code->getValue()))
+ if (llvm::StringInit *ci = dyn_cast<llvm::StringInit>(code->getValue()))
return ci->getValue();
if (isa<llvm::UnsetInit>(code->getValue()))
return llvm::Optional<StringRef>();
diff --git a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
index 6ab92c040c16..c96fde648eb2 100644
--- a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
+++ b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
@@ -137,7 +137,7 @@ static std::string replaceAllSubstrs(std::string str, const std::string &match,
static inline bool hasStringAttribute(const Record &record,
StringRef fieldName) {
auto valueInit = record.getValueInit(fieldName);
- return isa<CodeInit, StringInit>(valueInit);
+ return isa<StringInit>(valueInit);
}
static std::string getArgumentName(const Operator &op, int index) {
@@ -1796,15 +1796,15 @@ void OpEmitter::genPrinter() {
return;
auto valueInit = def.getValueInit("printer");
- CodeInit *codeInit = dyn_cast<CodeInit>(valueInit);
- if (!codeInit)
+ StringInit *stringInit = dyn_cast<StringInit>(valueInit);
+ if (!stringInit)
return;
auto *method =
opClass.addMethodAndPrune("void", "print", "::mlir::OpAsmPrinter &", "p");
FmtContext fctx;
fctx.addSubst("cppClass", opClass.getClassName());
- auto printer = codeInit->getValue().ltrim().rtrim(" \t\v\f\r");
+ auto printer = stringInit->getValue().ltrim().rtrim(" \t\v\f\r");
method->body() << " " << tgfmt(printer, &fctx);
}
@@ -1816,8 +1816,8 @@ void OpEmitter::genVerifier() {
<< "return ::mlir::failure();\n";
auto *valueInit = def.getValueInit("verifier");
- CodeInit *codeInit = dyn_cast<CodeInit>(valueInit);
- bool hasCustomVerify = codeInit && !codeInit->getValue().empty();
+ StringInit *stringInit = dyn_cast<StringInit>(valueInit);
+ bool hasCustomVerify = stringInit && !stringInit->getValue().empty();
populateSubstitutions(op, "this->getAttr", "this->getODSOperands",
"this->getODSResults", verifyCtx);
@@ -1841,7 +1841,7 @@ void OpEmitter::genVerifier() {
if (hasCustomVerify) {
FmtContext fctx;
fctx.addSubst("cppClass", opClass.getClassName());
- auto printer = codeInit->getValue().ltrim().rtrim(" \t\v\f\r");
+ auto printer = stringInit->getValue().ltrim().rtrim(" \t\v\f\r");
body << " " << tgfmt(printer, &fctx);
} else {
body << " return ::mlir::success();\n";
More information about the llvm-commits
mailing list