maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/utils/TableGen/TableGen.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

494 lines
19 KiB
C++
Raw Normal View History

Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
//===- TableGen.cpp - Top-Level TableGen implementation for Clang ---------===//
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
//
//===----------------------------------------------------------------------===//
//
// This file contains the main function for Clang's TableGen.
//
//===----------------------------------------------------------------------===//
Use InitLLVM to setup a pretty stack printer InitLLVM does not only save a few lines from main() but also makes the commands do the right thing for multibyte character pathnames on Windows (i.e. canonicalize argv's to UTF-8) because of the code we have in this file: https://github.com/llvm/llvm-project/blob/master/llvm/lib/Support/InitLLVM.cpp#L32 For many LLVM commands, we already have calls of InitLLVM, but there are still remainings. Differential Revision: https://reviews.llvm.org/D70702
2019-11-26 09:15:47 +08:00
#include "TableGenBackends.h" // Declares all backends.
[NFC] Rename ClangASTEmitters.h -> ASTTableGen.h
2019-10-26 09:38:07 +08:00
#include "ASTTableGen.h"
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Signals.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Main.h"
#include "llvm/TableGen/Record.h"
using namespace llvm;
Make clang-tblgen backends functions instead of TableGenBackends. Get rid of a bunch of header files. TableGen output should be unaffected. Patch by Sean Silva! llvm-svn: 158388
2012-06-13 13:12:41 +08:00
using namespace clang;
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
enum ActionType {
[clang-tblgen] Add -print-records and -dump-json modes. Currently, if clang-tblgen is run without a mode option, it defaults to the first mode in its 'enum Action', which happens to be -gen-clang-attr-classes. I think it makes more sense for it to behave the same way as llvm-tblgen, i.e. print a diagnostic dump if it's not given any more specific instructions. I've also added the same -dump-json that llvm-tblgen supports. This means any tblgen command line (whether llvm- or clang-) can be mechanically turned into one that processes the same input into JSON. Reviewers: nhaehnle Reviewed By: nhaehnle Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50771 llvm-svn: 340390
2018-08-22 17:20:39 +08:00
PrintRecords,
DumpJSON,
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
GenClangAttrClasses,
Consolidating several table-generated files containing parser-related string switches into a single file. This reduces build-related complexity by replacing four separate projects (and table-gen instantiations) with a single one. No functional changes intended. llvm-svn: 200424
2014-01-30 06:13:45 +08:00
GenClangAttrParserStringSwitches,
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
GenClangAttrSubjectMatchRulesParserStringSwitches,
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
GenClangAttrImpl,
GenClangAttrList,
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
GenClangAttrSubjectMatchRuleList,
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
GenClangAttrPCHRead,
GenClangAttrPCHWrite,
Reapplying r204952 a second time. Clean up the __has_attribute implementation without modifying its behavior. Replaces the tablegen-driven AttrSpellings.inc, which lived in the lexing layer with AttrHasAttributeImpl.inc, which lives in the basic layer. Updates the preprocessor to call through to this new functionality which can take additional information into account (such as scopes and syntaxes). Expose the ability for parts of the compiler to ask whether an attribute is supported for a given spelling (including scope), syntax, triple and language options. llvm-svn: 205181
2014-03-31 21:14:44 +08:00
GenClangAttrHasAttributeImpl,
PR14922: when printing an attribute, use the real syntax of the attribute (GNU, C++11, MS Declspec) instead of hardcoded GNU syntax. Introduce a spelling index to Attr class, which is an index into the attribute spelling list of an attribute defined in Attr.td. This index will determine the actual spelling used by an attribute, as it incorporates both the syntax and naming of the attribute. When constructing an attribute AST node, the spelling index is computed based on attribute kind, scope (if it's a C++11 attribute), and name, then passed to Attr that will use the index to print itself. Thanks to Richard Smith for the idea and review. llvm-svn: 173358
2013-01-25 00:46:58 +08:00
GenClangAttrSpellingListIndex,
Update RecursiveASTVisitor so that it visits attributes. This is currently important for thread safety attributes, which contain expressions that were not being visited, and were thus invisible to various tools. There are now Visit*Attr methods that can be overridden for every attribute. llvm-svn: 198224
2013-12-31 01:24:36 +08:00
GenClangAttrASTVisitor,
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
GenClangAttrTemplateInstantiate,
Refactor Clang sema attribute handling. This submission improves Clang sema handling by using Clang tablegen to generate common boilerplate code. As a start, it implements AttributeList enumerator generation and case statements for AttributeList::getKind. A new field "SemaHandler" is introduced in Attr.td and by default set to 1 as most of attributes in Attr.td have semantic checking in Sema. For a small number of attributes that don't appear in Sema, the value is set to 0. Also there are a small number of attributes that only appear in Sema but not in Attr.td. Currently these attributes are still hardcoded in Sema AttributeList. Reviewed by Delesley Hutchins. llvm-svn: 152169
2012-03-07 08:12:16 +08:00
GenClangAttrParsedAttrList,
Attribute tablegen now understands that attribute arguments can be optional. This allows for automated checking of the number of arguments expected vs number of arguments given for attributes. Greatly reduces the amount of manual checking required. llvm-svn: 190368
2013-09-10 07:33:17 +08:00
GenClangAttrParsedAttrImpl,
Refactor Clang sema attribute handling. This submission improves Clang sema handling by using Clang tablegen to generate common boilerplate code. As a start, it implements AttributeList enumerator generation and case statements for AttributeList::getKind. A new field "SemaHandler" is introduced in Attr.td and by default set to 1 as most of attributes in Attr.td have semantic checking in Sema. For a small number of attributes that don't appear in Sema, the value is set to 0. Also there are a small number of attributes that only appear in Sema but not in Attr.td. Currently these attributes are still hardcoded in Sema AttributeList. Reviewed by Delesley Hutchins. llvm-svn: 152169
2012-03-07 08:12:16 +08:00
GenClangAttrParsedAttrKinds,
Implement Attr dumping in terms of visitors Remove now-vestigial dumpType and dumpBareDeclRef methods. The old tablegen generated code used to expect them to be present, but the new generated code has no such requirement. Reviewers: aaron.ballman Subscribers: mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D55492 llvm-svn: 350958
2019-01-12 03:16:01 +08:00
GenClangAttrTextNodeDump,
GenClangAttrNodeTraverse,
Abstract serialization: TableGen "basic" reader/writer CRTP classes that serialize basic values
2019-12-14 10:52:16 +08:00
GenClangBasicReader,
GenClangBasicWriter,
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
GenClangDiagsDefs,
GenClangDiagGroups,
GenClangDiagsIndexName,
Implement AST classes for comments, a real parser for Doxygen comments and a very simple semantic analysis that just builds the AST; minor changes for lexer to pick up source locations I didn't think about before. Comments AST is modelled along the ideas of HTML AST: block and inline content. * Block content is a paragraph or a command that has a paragraph as an argument or verbatim command. * Inline content is placed within some block. Inline content includes plain text, inline commands and HTML as tag soup. llvm-svn: 159790
2012-07-06 08:28:32 +08:00
GenClangCommentNodes,
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
GenClangDeclNodes,
GenClangStmtNodes,
Emit TypeNodes.def with tblgen. The primary goal here is to make the type node hierarchy available to other tblgen backends, although it should also make it easier to generate more selective x-macros in the future. Because tblgen doesn't seem to allow backends to preserve the source order of defs, this is not NFC because it significantly re-orders IDs. I've fixed the one (fortunately obvious) place where we relied on the old order. Unfortunately, I wasn't able to share code with the existing AST-node x-macro generators because the x-macro schema we use for types is different in a number of ways. The main loss is that subclasses aren't ordered together, which doesn't seem important for types because the hierarchy is generally very shallow with little clustering. llvm-svn: 373407
2019-10-02 07:13:03 +08:00
GenClangTypeNodes,
Abstract serialization: TableGen the (de)serialization code for Types. The basic technical design here is that we have three levels of readers and writers: - At the lowest level, there's a `Basic{Reader,Writer}` that knows how to emit the basic structures of the AST. CRTP allows this to be metaprogrammed so that the client only needs to support a handful of primitive types (e.g. `uint64_t` and `IdentifierInfo*`) and more complicated "inline" structures such as `DeclarationName` can just be emitted in terms of those primitives. In Clang's binary-serialization code, these are `ASTRecord{Reader,Writer}`. For now, a large number of basic structures are still emitted explicitly by code on those classes rather than by either TableGen or CRTP metaprogramming, but I expect to move more of these over. - In the middle, there's a `Property{Reader,Writer}` which is responsible for processing the properties of a larger object. The object-level reader/writer asks the property-level reader/writer to project out a particular property, yielding a basic reader/writer which will be used to read/write the property's value, like so: ``` propertyWriter.find("count").writeUInt32(node->getCount()); ``` Clang's binary-serialization code ignores this level (it uses the basic reader/writer as the property reader/writer and has the projection methods just return `*this`) and simply relies on the roperties being read/written in a stable order. - At the highest level, there's an object reader/writer (e.g. `Type{Reader,Writer}` which emits a logical object with properties. Think of this as writing something like a JSON dictionary literal. I haven't introduced support for bitcode abbreviations yet --- it turns out that there aren't any operative abbreviations for types besides the QualType one --- but I do have some ideas of how they should work. At any rate, they'll be necessary in order to handle statements. I'm sorry for not disentangling the patches that added basic and type reader/writers; I made some effort to, but I ran out of energy after disentangling a number of other patches from the work. Negligible impact on module size, time to build a set of about 20 fairly large modules, or time to read a few declarations out of them.
2019-12-14 10:54:44 +08:00
GenClangTypeReader,
GenClangTypeWriter,
[Clang Interpreter] Initial patch for the constexpr interpreter Summary: This patch introduces the skeleton of the constexpr interpreter, capable of evaluating a simple constexpr functions consisting of if statements. The interpreter is described in more detail in the RFC. Further patches will add more features. Reviewers: Bigcheese, jfb, rsmith Subscribers: bruno, uenoku, ldionne, Tyker, thegameg, tschuett, dexonsmith, mgorny, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D64146 llvm-svn: 371834
2019-09-13 17:46:16 +08:00
GenClangOpcodes,
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
GenClangSACheckers,
Reland [Syntax] Add minimal TableGen for syntax nodes. NFC This reverts commit 09c6259d6d0eb51b282f6c3a28052a8146bc095b. (Fixed side-effecting code being buried in an assert)
2020-11-10 07:00:51 +08:00
GenClangSyntaxNodeList,
[Syntax] Start to move trivial Node class definitions to TableGen. NFC This defines two node archetypes with trivial class definitions: - Alternatives: the generated abstract classes are trivial as all functionality is via LLVM RTTI - Unconstrained: this is a placeholder, I think all of these are going to be Lists but today they have no special accessors etc, so we just say "could contain anything", and migrate them one-by-one to Sequence later. Compared to Dmitri's prototype, Nodes.td looks more like a class hierarchy and less like a grammar. (E.g. variants list the Alternatives parent rather than vice versa). The main reasons for this: - the hierarchy is an important part of the API we want direct control over. - e.g. we may introduce abstract bases like "loop" that the grammar doesn't care about in order to model is-a concepts that might make refactorings more expressive. This is less natural in a grammar-like idiom. - e.g. we're likely to have to model some alternatives as variants and others as class hierarchies, the choice will probably be based on natural is-a relationships. - it reduces the cognitive load of switching from editing *.td to working with code that uses the generated classes Differential Revision: https://reviews.llvm.org/D90543
2020-11-01 04:09:11 +08:00
GenClangSyntaxNodeClasses,
Comment HTML tag name machers: move from StringSwitch to an efficient TableGen-generated string matcher. llvm-svn: 162969
2012-08-31 10:21:44 +08:00
GenClangCommentHTMLTags,
GenClangCommentHTMLTagsProperties,
Comment parsing: resolve more named character references This reimplements r173850 with a better approach: (1) use a TableGen-generated matcher instead of doing a linear search; (2) avoid allocations for new strings by converting code points to string iterals with TableGen. llvm-svn: 173931
2013-01-30 22:29:28 +08:00
GenClangCommentHTMLNamedCharacterReferences,
Comment AST: TableGen'ize all command lists in CommentCommandTraits.cpp. Now we have a list of all commands. This is a good thing in itself, but it also enables us to easily implement typo correction for command names. With this change we have objects that contain information about each command, so it makes sense to resolve command name just once during lexing (currently we store command names as strings and do a linear search every time some property value is needed). Thus comment token and AST nodes were changed to contain a command ID -- index into a tables of builtin and registered commands. Unknown commands are registered during parsing and thus are also uniformly assigned an ID. Using an ID instead of a StringRef is also a nice memory optimization since ID is a small integer that fits into a common bitfield in Comment class. This change implies that to get any information about a command (even a command name) we need a CommandTraits object to resolve the command ID to CommandInfo*. Currently a fresh temporary CommandTraits object is created whenever it is needed since it does not have any state. But with this change it has state -- new commands can be registered, so a CommandTraits object was added to ASTContext. Also, in libclang CXComment has to be expanded to include a CXTranslationUnit so that all functions working on comment AST nodes can get a CommandTraits object. This breaks binary compatibility of CXComment APIs. Now clang_FullComment_getAsXML(CXTranslationUnit TU, CXComment CXC) doesn't need TU parameter anymore, so it was removed. This is a source-incompatible change for this C API. llvm-svn: 163540
2012-09-11 04:32:42 +08:00
GenClangCommentCommandInfo,
Comment parsing: improve the fidelity of XML output for many block commands This change introduces a 'kind' attribute for the <Para> tag, that captures the kind of the parent block command. For example: \todo Meow. used to be just <Para>Meow.</Para>, but now it is <Para kind="todo">Meow.</Para> llvm-svn: 174216
2013-02-02 04:23:57 +08:00
GenClangCommentCommandList,
[OpenCL] Declare builtin functions using TableGen This patch adds a `-fdeclare-opencl-builtins` command line option to the clang frontend. This enables clang to verify OpenCL C builtin function declarations using a fast StringMatcher lookup, instead of including the opencl-c.h file with the `-finclude-default-header` option. This avoids the large parse time penalty of the header file. This commit only adds the basic infrastructure and some of the OpenCL builtins. It does not cover all builtins defined by the various OpenCL specifications. As such, it is not a replacement for `-finclude-default-header` yet. RFC: http://lists.llvm.org/pipermail/cfe-dev/2018-November/060041.html Co-authored-by: Pierre Gondois Co-authored-by: Joey Gouly Co-authored-by: Sven van Haastregt Differential Revision: https://reviews.llvm.org/D60763 llvm-svn: 362371
2019-06-03 17:39:11 +08:00
GenClangOpenCLBuiltins,
[OpenCL] Add OpenCL builtin test generator Add a new clang-tblgen flag `-gen-clang-opencl-builtin-tests` that generates a .cl file containing calls to every builtin function defined in the .td input. This patch does not add any use of the new flag yet, so the only way to obtain a generated test file is through a manual invocation of clang-tblgen. A test making use of this emitter will be added in a followup commit. Differential Revision: https://reviews.llvm.org/D97869
2021-06-09 19:43:50 +08:00
GenClangOpenCLBuiltinTests,
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
GenArmNeon,
[AArch64] Add ARMv8.2-A FP16 scalar intrinsics https://reviews.llvm.org/D41792 llvm-svn: 323006
2018-01-20 07:11:18 +08:00
GenArmFP16,
[clang][BFloat] add NEON emitter for bfloat Summary: This patch adds the bfloat16_t struct typedefs (e.g. bfloat16x8x2_t) to arm_neon.h This patch is part of a series implementing the Bfloat16 extension of the Armv8.6-a architecture, as detailed here: https://community.arm.com/developer/ip-products/processors/b/processors-ip-blog/posts/arm-architecture-developments-armv8-6-a The bfloat type, and its properties are specified in the Arm Architecture Reference Manual: https://developer.arm.com/docs/ddi0487/latest/arm-architecture-reference-manual-armv8-for-armv8-a-architecture-profile The following people contributed to this patch: - Luke Cheeseman - Simon Tatham - Ties Stuij Reviewers: t.p.northover, fpetrogalli, sdesmalen, az, LukeGeeson Reviewed By: fpetrogalli Subscribers: SjoerdMeijer, LukeGeeson, pbarrio, mgorny, kristof.beyls, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D79708
2020-06-05 20:06:01 +08:00
GenArmBF16,
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
GenArmNeonSema,
Implements a declarative approach to documenting individual attributes in Clang via a Documentation tablegen class. Also updates the internals manual with information about how to use this new, required, documentation feature. This patch adds some very, very sparse initial documentation for some attributes. Additional effort from attribute authors is greatly appreciated. llvm-svn: 201515
2014-02-17 23:27:10 +08:00
GenArmNeonTest,
[clang,ARM] Initial ACLE intrinsics for MVE. This commit sets up the infrastructure for auto-generating <arm_mve.h> and doing clang-side code generation for the builtins it relies on, and demonstrates that it works by implementing a representative sample of the ACLE intrinsics, more or less matching the ones introduced in LLVM IR by D67158,D68699,D68700. Like NEON, that header file will provide a set of vector types like uint16x8_t and C functions with names like vaddq_u32(). Unlike NEON, the ACLE spec for <arm_mve.h> includes a polymorphism system, so that you can write plain vaddq() and disambiguate by the vector types you pass to it. Unlike the corresponding NEON code, I've arranged to make every user- facing ACLE intrinsic into a clang builtin, and implement all the code generation inside clang. So <arm_mve.h> itself contains nothing but typedefs and function declarations, with the latter all using the new `__attribute__((__clang_builtin))` system to arrange that the user- facing function names correspond to the right internal BuiltinIDs. So the new MveEmitter tablegen system specifies the full sequence of IRBuilder operations that each user-facing ACLE intrinsic should translate into. Where possible, the ACLE intrinsics map to standard IR operations such as vector-typed `add` and `fadd`; where no standard representation exists, I call down to the sample IR intrinsics introduced in an earlier commit. Doing it like this means that you get the polymorphism for free just by using __attribute__((overloadable)): the clang overload resolution decides which function declaration is the relevant one, and _then_ its BuiltinID is looked up, so by the time we're doing code generation, that's all been resolved by the standard system. It also means that you get really nice error messages if the user passes the wrong combination of types: clang will show the declarations from the header file and explain why each one doesn't match. (The obvious alternative approach would be to have wrapper functions in <arm_mve.h> which pass their arguments to the underlying builtins. But that doesn't work in the case where one of the arguments has to be a constant integer: the wrapper function can't pass the constantness through. So you'd have to do that case using a macro instead, and then use C11 `_Generic` to handle the polymorphism. Then you have to add horrible workarounds because `_Generic` requires even the untaken branches to type-check successfully, and //then// if the user gets the types wrong, the error message is totally unreadable!) Reviewers: dmgreen, miyuki, ostannard Subscribers: mgorny, javed.absar, kristof.beyls, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D67161
2019-09-02 22:50:50 +08:00
GenArmMveHeader,
GenArmMveBuiltinDef,
GenArmMveBuiltinSema,
GenArmMveBuiltinCG,
GenArmMveBuiltinAliases,
[Clang][SVE] Parse builtin type string for scalable vectors This patch adds 'q' to mean 'scalable vector' in the builtin type string, and for SVE will return the matching builtin type as defined in the C/C++ language extensions for SVE. This patch also adds some scaffolding to generate the arm_sve.h header file, and some builtin definitions (+CodeGen) to be able to implement some simple masked load intrinsics that use the ACLE types, such as: svint8_t test_svld1_s8(svbool_t pg, const int8_t *base) { return svld1_s8(pg, base); } Reviewers: efriedma, rjmccall, rovka, rsandifo-arm, rengolin Reviewed By: efriedma Tags: #clang Differential Revision: https://reviews.llvm.org/D75298
2020-03-15 22:29:45 +08:00
GenArmSveHeader,
Reland D75470 [SVE] Auto-generate builtins and header for svld1. Reworked the patch to avoid sharing a header (SVETypeFlags.h) between include/clang/Basic and utils/TableGen/SveEmitter.cpp. Now the patch generates the enum/flags which is included in TargetBuiltins.h. Also renamed one of the SveEmitter options to be in line with MVE. Summary: This is a first patch in a series for the SveEmitter to generate the arm_sve.h header file and builtins. I've tried my best to strip down this patch as best as I could, but there are still a few changes that are not necessarily exercised by the load intrinsics in this patch, mostly around the SVEType class which has some common logic to represent types from a type and prototype string. I thought it didn't make much sense to remove that from this patch and split it up.
2020-03-18 19:07:20 +08:00
GenArmSveBuiltins,
GenArmSveBuiltinCG,
GenArmSveTypeFlags,
[SveEmitter] Add range checks for immediates and predicate patterns. Summary: This patch adds a mechanism to easily add range checks for a builtin's immediate operands. This patch is tested with the qdech intrinsic, which takes both an enum for the predicate pattern, as well as an immediate for the multiplier. Reviewers: efriedma, SjoerdMeijer, rovka Reviewed By: efriedma, SjoerdMeijer Subscribers: mgorny, tschuett, mgrang, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D76678
2020-04-14 22:56:36 +08:00
GenArmSveRangeChecks,
[ARM,CDE] Generalize MVE intrinsics infrastructure to support CDE Summary: This patch generalizes the existing code to support CDE intrinsics which will share some properties with existing MVE intrinsics (some of the intrinsics will be polymorphic and accept/return values of MVE vector types). Specifically the patch: * Adds new tablegen backends -gen-arm-cde-builtin-def, -gen-arm-cde-builtin-codegen, -gen-arm-cde-builtin-sema, -gen-arm-cde-builtin-aliases, -gen-arm-cde-builtin-header based on existing MVE backends. * Renames the '__clang_arm_mve_alias' attribute into '__clang_arm_builtin_alias' (it will be used with CDE intrinsics as well as MVE intrinsics) * Implements semantic checks for the coprocessor argument of the CDE intrinsics as well as the existing coprocessor intrinsics. * Adds one CDE intrinsic __arm_cx1 to test the above changes Reviewers: simon_tatham, MarkMurrayARM, ostannard, dmgreen Reviewed By: simon_tatham Subscribers: sdesmalen, mgorny, kristof.beyls, danielkiss, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D75850
2020-03-10 22:01:42 +08:00
GenArmCdeHeader,
GenArmCdeBuiltinDef,
GenArmCdeBuiltinSema,
GenArmCdeBuiltinCG,
GenArmCdeBuiltinAliases,
[Clang][RISCV] Add custom TableGen backend for riscv-vector intrinsics. Demonstrate how to generate vadd/vfadd intrinsic functions 1. add -gen-riscv-vector-builtins for clang builtins. 2. add -gen-riscv-vector-builtin-codegen for clang codegen. 3. add -gen-riscv-vector-header for riscv_vector.h. It also generates ifdef directives with extension checking, base on D94403. 4. add -gen-riscv-vector-generic-header for riscv_vector_generic.h. Generate overloading version Header for generic api. https://github.com/riscv/rvv-intrinsic-doc/blob/master/rvv-intrinsic-rfc.md#c11-generic-interface 5. update tblgen doc for riscv related options. riscv_vector.td also defines some unused type transformers for vadd, because I think it could demonstrate how tranfer type work and we need them for the whole intrinsic functions implementation in the future. Authored-by: Roger Ferrer Ibanez <rofirrim@gmail.com> Co-Authored-by: Zakk Chen <zakk.chen@sifive.com> Reviewed By: jrtc27, craig.topper, HsiangKai, Jim, Paul-C-Anagnostopoulos Differential Revision: https://reviews.llvm.org/D95016
2021-03-05 23:40:28 +08:00
GenRISCVVectorHeader,
GenRISCVVectorBuiltins,
GenRISCVVectorBuiltinCG,
Add a mode to clang-tblgen to generate reference documentation for warning and remark flags. For now I'm checking in a copy of the built documentation, but we can replace this with a placeholder (as we do for the attributes reference documentation) once we enable building this server-side. llvm-svn: 281192
2016-09-12 13:58:29 +08:00
GenAttrDocs,
[docs] Add TableGen-based generator for command line argument documentation, and generate documentation for all (non-hidden) options supported by the 'clang' driver. llvm-svn: 292968
2017-01-25 03:39:46 +08:00
GenDiagDocs,
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
GenOptDocs,
[AST] Add TableGen for StmtDataCollectors Summary: This adds an option "-gen-clang-data-collectors" to the Clang TableGen that is used to generate StmtDataCollectors.inc. Reviewers: arphaman, teemperor! Subscribers: mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D37383 llvm-svn: 312634
2017-09-06 21:20:51 +08:00
GenDataCollectors,
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
GenTestPragmaAttributeSupportedAttributes
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
};
namespace {
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
cl::opt<ActionType> Action(
cl::desc("Action to perform:"),
cl::values(
[clang-tblgen] Add -print-records and -dump-json modes. Currently, if clang-tblgen is run without a mode option, it defaults to the first mode in its 'enum Action', which happens to be -gen-clang-attr-classes. I think it makes more sense for it to behave the same way as llvm-tblgen, i.e. print a diagnostic dump if it's not given any more specific instructions. I've also added the same -dump-json that llvm-tblgen supports. This means any tblgen command line (whether llvm- or clang-) can be mechanically turned into one that processes the same input into JSON. Reviewers: nhaehnle Reviewed By: nhaehnle Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50771 llvm-svn: 340390
2018-08-22 17:20:39 +08:00
clEnumValN(PrintRecords, "print-records",
"Print all records to stdout (default)"),
clEnumValN(DumpJSON, "dump-json",
"Dump all records as machine-readable JSON"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenClangAttrClasses, "gen-clang-attr-classes",
"Generate clang attribute clases"),
Consolidating several table-generated files containing parser-related string switches into a single file. This reduces build-related complexity by replacing four separate projects (and table-gen instantiations) with a single one. No functional changes intended. llvm-svn: 200424
2014-01-30 06:13:45 +08:00
clEnumValN(GenClangAttrParserStringSwitches,
"gen-clang-attr-parser-string-switches",
"Generate all parser-related attribute string switches"),
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
clEnumValN(GenClangAttrSubjectMatchRulesParserStringSwitches,
"gen-clang-attr-subject-match-rules-parser-string-switches",
"Generate all parser-related attribute subject match rule"
"string switches"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenClangAttrImpl, "gen-clang-attr-impl",
"Generate clang attribute implementations"),
clEnumValN(GenClangAttrList, "gen-clang-attr-list",
"Generate a clang attribute list"),
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
clEnumValN(GenClangAttrSubjectMatchRuleList,
"gen-clang-attr-subject-match-rule-list",
"Generate a clang attribute subject match rule list"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenClangAttrPCHRead, "gen-clang-attr-pch-read",
"Generate clang PCH attribute reader"),
clEnumValN(GenClangAttrPCHWrite, "gen-clang-attr-pch-write",
"Generate clang PCH attribute writer"),
Reapplying r204952 a second time. Clean up the __has_attribute implementation without modifying its behavior. Replaces the tablegen-driven AttrSpellings.inc, which lived in the lexing layer with AttrHasAttributeImpl.inc, which lives in the basic layer. Updates the preprocessor to call through to this new functionality which can take additional information into account (such as scopes and syntaxes). Expose the ability for parts of the compiler to ask whether an attribute is supported for a given spelling (including scope), syntax, triple and language options. llvm-svn: 205181
2014-03-31 21:14:44 +08:00
clEnumValN(GenClangAttrHasAttributeImpl,
"gen-clang-attr-has-attribute-impl",
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
"Generate a clang attribute spelling list"),
clEnumValN(GenClangAttrSpellingListIndex,
"gen-clang-attr-spelling-index",
"Generate a clang attribute spelling index"),
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
clEnumValN(GenClangAttrASTVisitor, "gen-clang-attr-ast-visitor",
Update RecursiveASTVisitor so that it visits attributes. This is currently important for thread safety attributes, which contain expressions that were not being visited, and were thus invisible to various tools. There are now Visit*Attr methods that can be overridden for every attribute. llvm-svn: 198224
2013-12-31 01:24:36 +08:00
"Generate a recursive AST visitor for clang attributes"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenClangAttrTemplateInstantiate,
"gen-clang-attr-template-instantiate",
"Generate a clang template instantiate code"),
PR17666: Instead of allowing an initial identifier argument in any attribute which we don't think can't have one, only allow it in the tiny number of attributes which opts into this weird parse rule. I've manually checked that the handlers for all these attributes can in fact cope with an identifier as the argument. This is still somewhat terrible; we should move more fully towards picking the parsing rules based on the attribute, and make the Parse -> Sema interface more type-safe. llvm-svn: 193295
2013-10-24 09:07:54 +08:00
clEnumValN(GenClangAttrParsedAttrList,
"gen-clang-attr-parsed-attr-list",
"Generate a clang parsed attribute list"),
clEnumValN(GenClangAttrParsedAttrImpl,
"gen-clang-attr-parsed-attr-impl",
"Generate the clang parsed attribute helpers"),
clEnumValN(GenClangAttrParsedAttrKinds,
"gen-clang-attr-parsed-attr-kinds",
"Generate a clang parsed attribute kinds"),
Implement Attr dumping in terms of visitors Remove now-vestigial dumpType and dumpBareDeclRef methods. The old tablegen generated code used to expect them to be present, but the new generated code has no such requirement. Reviewers: aaron.ballman Subscribers: mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D55492 llvm-svn: 350958
2019-01-12 03:16:01 +08:00
clEnumValN(GenClangAttrTextNodeDump, "gen-clang-attr-text-node-dump",
"Generate clang attribute text node dumper"),
clEnumValN(GenClangAttrNodeTraverse, "gen-clang-attr-node-traverse",
"Generate clang attribute traverser"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",
"Generate Clang diagnostics definitions"),
clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",
"Generate Clang diagnostic groups"),
clEnumValN(GenClangDiagsIndexName, "gen-clang-diags-index-name",
"Generate Clang diagnostic name index"),
Abstract serialization: TableGen "basic" reader/writer CRTP classes that serialize basic values
2019-12-14 10:52:16 +08:00
clEnumValN(GenClangBasicReader, "gen-clang-basic-reader",
"Generate Clang BasicReader classes"),
clEnumValN(GenClangBasicWriter, "gen-clang-basic-writer",
"Generate Clang BasicWriter classes"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenClangCommentNodes, "gen-clang-comment-nodes",
"Generate Clang AST comment nodes"),
clEnumValN(GenClangDeclNodes, "gen-clang-decl-nodes",
"Generate Clang AST declaration nodes"),
clEnumValN(GenClangStmtNodes, "gen-clang-stmt-nodes",
"Generate Clang AST statement nodes"),
Emit TypeNodes.def with tblgen. The primary goal here is to make the type node hierarchy available to other tblgen backends, although it should also make it easier to generate more selective x-macros in the future. Because tblgen doesn't seem to allow backends to preserve the source order of defs, this is not NFC because it significantly re-orders IDs. I've fixed the one (fortunately obvious) place where we relied on the old order. Unfortunately, I wasn't able to share code with the existing AST-node x-macro generators because the x-macro schema we use for types is different in a number of ways. The main loss is that subclasses aren't ordered together, which doesn't seem important for types because the hierarchy is generally very shallow with little clustering. llvm-svn: 373407
2019-10-02 07:13:03 +08:00
clEnumValN(GenClangTypeNodes, "gen-clang-type-nodes",
"Generate Clang AST type nodes"),
Abstract serialization: TableGen the (de)serialization code for Types. The basic technical design here is that we have three levels of readers and writers: - At the lowest level, there's a `Basic{Reader,Writer}` that knows how to emit the basic structures of the AST. CRTP allows this to be metaprogrammed so that the client only needs to support a handful of primitive types (e.g. `uint64_t` and `IdentifierInfo*`) and more complicated "inline" structures such as `DeclarationName` can just be emitted in terms of those primitives. In Clang's binary-serialization code, these are `ASTRecord{Reader,Writer}`. For now, a large number of basic structures are still emitted explicitly by code on those classes rather than by either TableGen or CRTP metaprogramming, but I expect to move more of these over. - In the middle, there's a `Property{Reader,Writer}` which is responsible for processing the properties of a larger object. The object-level reader/writer asks the property-level reader/writer to project out a particular property, yielding a basic reader/writer which will be used to read/write the property's value, like so: ``` propertyWriter.find("count").writeUInt32(node->getCount()); ``` Clang's binary-serialization code ignores this level (it uses the basic reader/writer as the property reader/writer and has the projection methods just return `*this`) and simply relies on the roperties being read/written in a stable order. - At the highest level, there's an object reader/writer (e.g. `Type{Reader,Writer}` which emits a logical object with properties. Think of this as writing something like a JSON dictionary literal. I haven't introduced support for bitcode abbreviations yet --- it turns out that there aren't any operative abbreviations for types besides the QualType one --- but I do have some ideas of how they should work. At any rate, they'll be necessary in order to handle statements. I'm sorry for not disentangling the patches that added basic and type reader/writers; I made some effort to, but I ran out of energy after disentangling a number of other patches from the work. Negligible impact on module size, time to build a set of about 20 fairly large modules, or time to read a few declarations out of them.
2019-12-14 10:54:44 +08:00
clEnumValN(GenClangTypeReader, "gen-clang-type-reader",
"Generate Clang AbstractTypeReader class"),
clEnumValN(GenClangTypeWriter, "gen-clang-type-writer",
"Generate Clang AbstractTypeWriter class"),
[Clang Interpreter] Initial patch for the constexpr interpreter Summary: This patch introduces the skeleton of the constexpr interpreter, capable of evaluating a simple constexpr functions consisting of if statements. The interpreter is described in more detail in the RFC. Further patches will add more features. Reviewers: Bigcheese, jfb, rsmith Subscribers: bruno, uenoku, ldionne, Tyker, thegameg, tschuett, dexonsmith, mgorny, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D64146 llvm-svn: 371834
2019-09-13 17:46:16 +08:00
clEnumValN(GenClangOpcodes, "gen-clang-opcodes",
"Generate Clang constexpr interpreter opcodes"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenClangSACheckers, "gen-clang-sa-checkers",
"Generate Clang Static Analyzer checkers"),
Reland [Syntax] Add minimal TableGen for syntax nodes. NFC This reverts commit 09c6259d6d0eb51b282f6c3a28052a8146bc095b. (Fixed side-effecting code being buried in an assert)
2020-11-10 07:00:51 +08:00
clEnumValN(GenClangSyntaxNodeList, "gen-clang-syntax-node-list",
"Generate list of Clang Syntax Tree node types"),
[Syntax] Start to move trivial Node class definitions to TableGen. NFC This defines two node archetypes with trivial class definitions: - Alternatives: the generated abstract classes are trivial as all functionality is via LLVM RTTI - Unconstrained: this is a placeholder, I think all of these are going to be Lists but today they have no special accessors etc, so we just say "could contain anything", and migrate them one-by-one to Sequence later. Compared to Dmitri's prototype, Nodes.td looks more like a class hierarchy and less like a grammar. (E.g. variants list the Alternatives parent rather than vice versa). The main reasons for this: - the hierarchy is an important part of the API we want direct control over. - e.g. we may introduce abstract bases like "loop" that the grammar doesn't care about in order to model is-a concepts that might make refactorings more expressive. This is less natural in a grammar-like idiom. - e.g. we're likely to have to model some alternatives as variants and others as class hierarchies, the choice will probably be based on natural is-a relationships. - it reduces the cognitive load of switching from editing *.td to working with code that uses the generated classes Differential Revision: https://reviews.llvm.org/D90543
2020-11-01 04:09:11 +08:00
clEnumValN(GenClangSyntaxNodeClasses, "gen-clang-syntax-node-classes",
"Generate definitions of Clang Syntax Tree node clasess"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenClangCommentHTMLTags, "gen-clang-comment-html-tags",
"Generate efficient matchers for HTML tag "
"names that are used in documentation comments"),
clEnumValN(GenClangCommentHTMLTagsProperties,
"gen-clang-comment-html-tags-properties",
"Generate efficient matchers for HTML tag "
"properties"),
clEnumValN(GenClangCommentHTMLNamedCharacterReferences,
"gen-clang-comment-html-named-character-references",
"Generate function to translate named character "
"references to UTF-8 sequences"),
clEnumValN(GenClangCommentCommandInfo, "gen-clang-comment-command-info",
"Generate command properties for commands that "
"are used in documentation comments"),
clEnumValN(GenClangCommentCommandList, "gen-clang-comment-command-list",
"Generate list of commands that are used in "
"documentation comments"),
[OpenCL] Declare builtin functions using TableGen This patch adds a `-fdeclare-opencl-builtins` command line option to the clang frontend. This enables clang to verify OpenCL C builtin function declarations using a fast StringMatcher lookup, instead of including the opencl-c.h file with the `-finclude-default-header` option. This avoids the large parse time penalty of the header file. This commit only adds the basic infrastructure and some of the OpenCL builtins. It does not cover all builtins defined by the various OpenCL specifications. As such, it is not a replacement for `-finclude-default-header` yet. RFC: http://lists.llvm.org/pipermail/cfe-dev/2018-November/060041.html Co-authored-by: Pierre Gondois Co-authored-by: Joey Gouly Co-authored-by: Sven van Haastregt Differential Revision: https://reviews.llvm.org/D60763 llvm-svn: 362371
2019-06-03 17:39:11 +08:00
clEnumValN(GenClangOpenCLBuiltins, "gen-clang-opencl-builtins",
"Generate OpenCL builtin declaration handlers"),
[OpenCL] Add OpenCL builtin test generator Add a new clang-tblgen flag `-gen-clang-opencl-builtin-tests` that generates a .cl file containing calls to every builtin function defined in the .td input. This patch does not add any use of the new flag yet, so the only way to obtain a generated test file is through a manual invocation of clang-tblgen. A test making use of this emitter will be added in a followup commit. Differential Revision: https://reviews.llvm.org/D97869
2021-06-09 19:43:50 +08:00
clEnumValN(GenClangOpenCLBuiltinTests, "gen-clang-opencl-builtin-tests",
"Generate OpenCL builtin declaration tests"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenArmNeon, "gen-arm-neon", "Generate arm_neon.h for clang"),
[AArch64] Add ARMv8.2-A FP16 scalar intrinsics https://reviews.llvm.org/D41792 llvm-svn: 323006
2018-01-20 07:11:18 +08:00
clEnumValN(GenArmFP16, "gen-arm-fp16", "Generate arm_fp16.h for clang"),
[clang][BFloat] add NEON emitter for bfloat Summary: This patch adds the bfloat16_t struct typedefs (e.g. bfloat16x8x2_t) to arm_neon.h This patch is part of a series implementing the Bfloat16 extension of the Armv8.6-a architecture, as detailed here: https://community.arm.com/developer/ip-products/processors/b/processors-ip-blog/posts/arm-architecture-developments-armv8-6-a The bfloat type, and its properties are specified in the Arm Architecture Reference Manual: https://developer.arm.com/docs/ddi0487/latest/arm-architecture-reference-manual-armv8-for-armv8-a-architecture-profile The following people contributed to this patch: - Luke Cheeseman - Simon Tatham - Ties Stuij Reviewers: t.p.northover, fpetrogalli, sdesmalen, az, LukeGeeson Reviewed By: fpetrogalli Subscribers: SjoerdMeijer, LukeGeeson, pbarrio, mgorny, kristof.beyls, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D79708
2020-06-05 20:06:01 +08:00
clEnumValN(GenArmBF16, "gen-arm-bf16", "Generate arm_bf16.h for clang"),
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
clEnumValN(GenArmNeonSema, "gen-arm-neon-sema",
"Generate ARM NEON sema support for clang"),
clEnumValN(GenArmNeonTest, "gen-arm-neon-test",
"Generate ARM NEON tests for clang"),
[Clang][SVE] Parse builtin type string for scalable vectors This patch adds 'q' to mean 'scalable vector' in the builtin type string, and for SVE will return the matching builtin type as defined in the C/C++ language extensions for SVE. This patch also adds some scaffolding to generate the arm_sve.h header file, and some builtin definitions (+CodeGen) to be able to implement some simple masked load intrinsics that use the ACLE types, such as: svint8_t test_svld1_s8(svbool_t pg, const int8_t *base) { return svld1_s8(pg, base); } Reviewers: efriedma, rjmccall, rovka, rsandifo-arm, rengolin Reviewed By: efriedma Tags: #clang Differential Revision: https://reviews.llvm.org/D75298
2020-03-15 22:29:45 +08:00
clEnumValN(GenArmSveHeader, "gen-arm-sve-header",
"Generate arm_sve.h for clang"),
Reland D75470 [SVE] Auto-generate builtins and header for svld1. Reworked the patch to avoid sharing a header (SVETypeFlags.h) between include/clang/Basic and utils/TableGen/SveEmitter.cpp. Now the patch generates the enum/flags which is included in TargetBuiltins.h. Also renamed one of the SveEmitter options to be in line with MVE. Summary: This is a first patch in a series for the SveEmitter to generate the arm_sve.h header file and builtins. I've tried my best to strip down this patch as best as I could, but there are still a few changes that are not necessarily exercised by the load intrinsics in this patch, mostly around the SVEType class which has some common logic to represent types from a type and prototype string. I thought it didn't make much sense to remove that from this patch and split it up.
2020-03-18 19:07:20 +08:00
clEnumValN(GenArmSveBuiltins, "gen-arm-sve-builtins",
"Generate arm_sve_builtins.inc for clang"),
clEnumValN(GenArmSveBuiltinCG, "gen-arm-sve-builtin-codegen",
"Generate arm_sve_builtin_cg_map.inc for clang"),
clEnumValN(GenArmSveTypeFlags, "gen-arm-sve-typeflags",
"Generate arm_sve_typeflags.inc for clang"),
[SveEmitter] Add range checks for immediates and predicate patterns. Summary: This patch adds a mechanism to easily add range checks for a builtin's immediate operands. This patch is tested with the qdech intrinsic, which takes both an enum for the predicate pattern, as well as an immediate for the multiplier. Reviewers: efriedma, SjoerdMeijer, rovka Reviewed By: efriedma, SjoerdMeijer Subscribers: mgorny, tschuett, mgrang, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D76678
2020-04-14 22:56:36 +08:00
clEnumValN(GenArmSveRangeChecks, "gen-arm-sve-sema-rangechecks",
"Generate arm_sve_sema_rangechecks.inc for clang"),
[clang,ARM] Initial ACLE intrinsics for MVE. This commit sets up the infrastructure for auto-generating <arm_mve.h> and doing clang-side code generation for the builtins it relies on, and demonstrates that it works by implementing a representative sample of the ACLE intrinsics, more or less matching the ones introduced in LLVM IR by D67158,D68699,D68700. Like NEON, that header file will provide a set of vector types like uint16x8_t and C functions with names like vaddq_u32(). Unlike NEON, the ACLE spec for <arm_mve.h> includes a polymorphism system, so that you can write plain vaddq() and disambiguate by the vector types you pass to it. Unlike the corresponding NEON code, I've arranged to make every user- facing ACLE intrinsic into a clang builtin, and implement all the code generation inside clang. So <arm_mve.h> itself contains nothing but typedefs and function declarations, with the latter all using the new `__attribute__((__clang_builtin))` system to arrange that the user- facing function names correspond to the right internal BuiltinIDs. So the new MveEmitter tablegen system specifies the full sequence of IRBuilder operations that each user-facing ACLE intrinsic should translate into. Where possible, the ACLE intrinsics map to standard IR operations such as vector-typed `add` and `fadd`; where no standard representation exists, I call down to the sample IR intrinsics introduced in an earlier commit. Doing it like this means that you get the polymorphism for free just by using __attribute__((overloadable)): the clang overload resolution decides which function declaration is the relevant one, and _then_ its BuiltinID is looked up, so by the time we're doing code generation, that's all been resolved by the standard system. It also means that you get really nice error messages if the user passes the wrong combination of types: clang will show the declarations from the header file and explain why each one doesn't match. (The obvious alternative approach would be to have wrapper functions in <arm_mve.h> which pass their arguments to the underlying builtins. But that doesn't work in the case where one of the arguments has to be a constant integer: the wrapper function can't pass the constantness through. So you'd have to do that case using a macro instead, and then use C11 `_Generic` to handle the polymorphism. Then you have to add horrible workarounds because `_Generic` requires even the untaken branches to type-check successfully, and //then// if the user gets the types wrong, the error message is totally unreadable!) Reviewers: dmgreen, miyuki, ostannard Subscribers: mgorny, javed.absar, kristof.beyls, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D67161
2019-09-02 22:50:50 +08:00
clEnumValN(GenArmMveHeader, "gen-arm-mve-header",
"Generate arm_mve.h for clang"),
clEnumValN(GenArmMveBuiltinDef, "gen-arm-mve-builtin-def",
"Generate ARM MVE builtin definitions for clang"),
clEnumValN(GenArmMveBuiltinSema, "gen-arm-mve-builtin-sema",
"Generate ARM MVE builtin sema checks for clang"),
clEnumValN(GenArmMveBuiltinCG, "gen-arm-mve-builtin-codegen",
"Generate ARM MVE builtin code-generator for clang"),
clEnumValN(GenArmMveBuiltinAliases, "gen-arm-mve-builtin-aliases",
"Generate list of valid ARM MVE builtin aliases for clang"),
[ARM,CDE] Generalize MVE intrinsics infrastructure to support CDE Summary: This patch generalizes the existing code to support CDE intrinsics which will share some properties with existing MVE intrinsics (some of the intrinsics will be polymorphic and accept/return values of MVE vector types). Specifically the patch: * Adds new tablegen backends -gen-arm-cde-builtin-def, -gen-arm-cde-builtin-codegen, -gen-arm-cde-builtin-sema, -gen-arm-cde-builtin-aliases, -gen-arm-cde-builtin-header based on existing MVE backends. * Renames the '__clang_arm_mve_alias' attribute into '__clang_arm_builtin_alias' (it will be used with CDE intrinsics as well as MVE intrinsics) * Implements semantic checks for the coprocessor argument of the CDE intrinsics as well as the existing coprocessor intrinsics. * Adds one CDE intrinsic __arm_cx1 to test the above changes Reviewers: simon_tatham, MarkMurrayARM, ostannard, dmgreen Reviewed By: simon_tatham Subscribers: sdesmalen, mgorny, kristof.beyls, danielkiss, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D75850
2020-03-10 22:01:42 +08:00
clEnumValN(GenArmCdeHeader, "gen-arm-cde-header",
"Generate arm_cde.h for clang"),
clEnumValN(GenArmCdeBuiltinDef, "gen-arm-cde-builtin-def",
"Generate ARM CDE builtin definitions for clang"),
clEnumValN(GenArmCdeBuiltinSema, "gen-arm-cde-builtin-sema",
"Generate ARM CDE builtin sema checks for clang"),
clEnumValN(GenArmCdeBuiltinCG, "gen-arm-cde-builtin-codegen",
"Generate ARM CDE builtin code-generator for clang"),
clEnumValN(GenArmCdeBuiltinAliases, "gen-arm-cde-builtin-aliases",
"Generate list of valid ARM CDE builtin aliases for clang"),
[Clang][RISCV] Add custom TableGen backend for riscv-vector intrinsics. Demonstrate how to generate vadd/vfadd intrinsic functions 1. add -gen-riscv-vector-builtins for clang builtins. 2. add -gen-riscv-vector-builtin-codegen for clang codegen. 3. add -gen-riscv-vector-header for riscv_vector.h. It also generates ifdef directives with extension checking, base on D94403. 4. add -gen-riscv-vector-generic-header for riscv_vector_generic.h. Generate overloading version Header for generic api. https://github.com/riscv/rvv-intrinsic-doc/blob/master/rvv-intrinsic-rfc.md#c11-generic-interface 5. update tblgen doc for riscv related options. riscv_vector.td also defines some unused type transformers for vadd, because I think it could demonstrate how tranfer type work and we need them for the whole intrinsic functions implementation in the future. Authored-by: Roger Ferrer Ibanez <rofirrim@gmail.com> Co-Authored-by: Zakk Chen <zakk.chen@sifive.com> Reviewed By: jrtc27, craig.topper, HsiangKai, Jim, Paul-C-Anagnostopoulos Differential Revision: https://reviews.llvm.org/D95016
2021-03-05 23:40:28 +08:00
clEnumValN(GenRISCVVectorHeader, "gen-riscv-vector-header",
"Generate riscv_vector.h for clang"),
clEnumValN(GenRISCVVectorBuiltins, "gen-riscv-vector-builtins",
"Generate riscv_vector_builtins.inc for clang"),
clEnumValN(GenRISCVVectorBuiltinCG, "gen-riscv-vector-builtin-codegen",
"Generate riscv_vector_builtin_cg.inc for clang"),
Implements a declarative approach to documenting individual attributes in Clang via a Documentation tablegen class. Also updates the internals manual with information about how to use this new, required, documentation feature. This patch adds some very, very sparse initial documentation for some attributes. Additional effort from attribute authors is greatly appreciated. llvm-svn: 201515
2014-02-17 23:27:10 +08:00
clEnumValN(GenAttrDocs, "gen-attr-docs",
"Generate attribute documentation"),
Add a mode to clang-tblgen to generate reference documentation for warning and remark flags. For now I'm checking in a copy of the built documentation, but we can replace this with a placeholder (as we do for the attributes reference documentation) once we enable building this server-side. llvm-svn: 281192
2016-09-12 13:58:29 +08:00
clEnumValN(GenDiagDocs, "gen-diag-docs",
[docs] Add TableGen-based generator for command line argument documentation, and generate documentation for all (non-hidden) options supported by the 'clang' driver. llvm-svn: 292968
2017-01-25 03:39:46 +08:00
"Generate diagnostic documentation"),
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
clEnumValN(GenOptDocs, "gen-opt-docs", "Generate option documentation"),
[AST] Add TableGen for StmtDataCollectors Summary: This adds an option "-gen-clang-data-collectors" to the Clang TableGen that is used to generate StmtDataCollectors.inc. Reviewers: arphaman, teemperor! Subscribers: mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D37383 llvm-svn: 312634
2017-09-06 21:20:51 +08:00
clEnumValN(GenDataCollectors, "gen-clang-data-collectors",
"Generate data collectors for AST nodes"),
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
clEnumValN(GenTestPragmaAttributeSupportedAttributes,
"gen-clang-test-pragma-attribute-supported-attributes",
"Generate a list of attributes supported by #pragma clang "
"attribute for testing purposes")));
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
clang-format utils/TableGen/TableGen.cpp. I have a patch that edits the file. Running clang-format first makes the patch a lot easier to review. llvm-svn: 188562
2013-08-17 00:46:27 +08:00
cl::opt<std::string>
ClangComponent("clang-component",
cl::desc("Only use warnings from specified component"),
cl::value_desc("component"), cl::Hidden);
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
bool ClangTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
switch (Action) {
[clang-tblgen] Add -print-records and -dump-json modes. Currently, if clang-tblgen is run without a mode option, it defaults to the first mode in its 'enum Action', which happens to be -gen-clang-attr-classes. I think it makes more sense for it to behave the same way as llvm-tblgen, i.e. print a diagnostic dump if it's not given any more specific instructions. I've also added the same -dump-json that llvm-tblgen supports. This means any tblgen command line (whether llvm- or clang-) can be mechanically turned into one that processes the same input into JSON. Reviewers: nhaehnle Reviewed By: nhaehnle Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50771 llvm-svn: 340390
2018-08-22 17:20:39 +08:00
case PrintRecords:
OS << Records; // No argument, dump all contents
break;
case DumpJSON:
EmitJSON(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenClangAttrClasses:
EmitClangAttrClass(Records, OS);
break;
Consolidating several table-generated files containing parser-related string switches into a single file. This reduces build-related complexity by replacing four separate projects (and table-gen instantiations) with a single one. No functional changes intended. llvm-svn: 200424
2014-01-30 06:13:45 +08:00
case GenClangAttrParserStringSwitches:
EmitClangAttrParserStringSwitches(Records, OS);
Attributes which accept a type as their sole argument are no longer hard coded into the parser. Instead, they are automatically listed through tablegen. llvm-svn: 193989
2013-11-04 20:55:56 +08:00
break;
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
case GenClangAttrSubjectMatchRulesParserStringSwitches:
EmitClangAttrSubjectMatchRulesParserStringSwitches(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenClangAttrImpl:
EmitClangAttrImpl(Records, OS);
break;
case GenClangAttrList:
EmitClangAttrList(Records, OS);
break;
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
case GenClangAttrSubjectMatchRuleList:
EmitClangAttrSubjectMatchRuleList(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenClangAttrPCHRead:
EmitClangAttrPCHRead(Records, OS);
break;
case GenClangAttrPCHWrite:
EmitClangAttrPCHWrite(Records, OS);
break;
Reapplying r204952 a second time. Clean up the __has_attribute implementation without modifying its behavior. Replaces the tablegen-driven AttrSpellings.inc, which lived in the lexing layer with AttrHasAttributeImpl.inc, which lives in the basic layer. Updates the preprocessor to call through to this new functionality which can take additional information into account (such as scopes and syntaxes). Expose the ability for parts of the compiler to ask whether an attribute is supported for a given spelling (including scope), syntax, triple and language options. llvm-svn: 205181
2014-03-31 21:14:44 +08:00
case GenClangAttrHasAttributeImpl:
EmitClangAttrHasAttrImpl(Records, OS);
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
break;
PR14922: when printing an attribute, use the real syntax of the attribute (GNU, C++11, MS Declspec) instead of hardcoded GNU syntax. Introduce a spelling index to Attr class, which is an index into the attribute spelling list of an attribute defined in Attr.td. This index will determine the actual spelling used by an attribute, as it incorporates both the syntax and naming of the attribute. When constructing an attribute AST node, the spelling index is computed based on attribute kind, scope (if it's a C++11 attribute), and name, then passed to Attr that will use the index to print itself. Thanks to Richard Smith for the idea and review. llvm-svn: 173358
2013-01-25 00:46:58 +08:00
case GenClangAttrSpellingListIndex:
EmitClangAttrSpellingListIndex(Records, OS);
break;
Update RecursiveASTVisitor so that it visits attributes. This is currently important for thread safety attributes, which contain expressions that were not being visited, and were thus invisible to various tools. There are now Visit*Attr methods that can be overridden for every attribute. llvm-svn: 198224
2013-12-31 01:24:36 +08:00
case GenClangAttrASTVisitor:
EmitClangAttrASTVisitor(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenClangAttrTemplateInstantiate:
EmitClangAttrTemplateInstantiate(Records, OS);
break;
case GenClangAttrParsedAttrList:
EmitClangAttrParsedAttrList(Records, OS);
break;
Attribute tablegen now understands that attribute arguments can be optional. This allows for automated checking of the number of arguments expected vs number of arguments given for attributes. Greatly reduces the amount of manual checking required. llvm-svn: 190368
2013-09-10 07:33:17 +08:00
case GenClangAttrParsedAttrImpl:
EmitClangAttrParsedAttrImpl(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenClangAttrParsedAttrKinds:
EmitClangAttrParsedAttrKinds(Records, OS);
break;
Implement Attr dumping in terms of visitors Remove now-vestigial dumpType and dumpBareDeclRef methods. The old tablegen generated code used to expect them to be present, but the new generated code has no such requirement. Reviewers: aaron.ballman Subscribers: mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D55492 llvm-svn: 350958
2019-01-12 03:16:01 +08:00
case GenClangAttrTextNodeDump:
EmitClangAttrTextNodeDump(Records, OS);
break;
case GenClangAttrNodeTraverse:
EmitClangAttrNodeTraverse(Records, OS);
Implement Attr dumping for -ast-dump. http://llvm-reviews.chandlerc.com/D234 Patch by Philip Craig! llvm-svn: 171760
2013-01-08 01:53:08 +08:00
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenClangDiagsDefs:
EmitClangDiagsDefs(Records, OS, ClangComponent);
break;
case GenClangDiagGroups:
EmitClangDiagGroups(Records, OS);
break;
case GenClangDiagsIndexName:
EmitClangDiagsIndexName(Records, OS);
break;
case GenClangCommentNodes:
[NFC] Add a tablegen node for the root of the AST node hierarchies. This is useful for the property databases we want to add for abstract serialization, since root classes can have interesting properties.
2019-10-26 07:28:03 +08:00
EmitClangASTNodes(Records, OS, CommentNodeClassName, "");
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
break;
case GenClangDeclNodes:
[NFC] Add a tablegen node for the root of the AST node hierarchies. This is useful for the property databases we want to add for abstract serialization, since root classes can have interesting properties.
2019-10-26 07:28:03 +08:00
EmitClangASTNodes(Records, OS, DeclNodeClassName, "Decl");
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
EmitClangDeclContext(Records, OS);
break;
case GenClangStmtNodes:
[NFC] Add a tablegen node for the root of the AST node hierarchies. This is useful for the property databases we want to add for abstract serialization, since root classes can have interesting properties.
2019-10-26 07:28:03 +08:00
EmitClangASTNodes(Records, OS, StmtNodeClassName, "");
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
break;
Emit TypeNodes.def with tblgen. The primary goal here is to make the type node hierarchy available to other tblgen backends, although it should also make it easier to generate more selective x-macros in the future. Because tblgen doesn't seem to allow backends to preserve the source order of defs, this is not NFC because it significantly re-orders IDs. I've fixed the one (fortunately obvious) place where we relied on the old order. Unfortunately, I wasn't able to share code with the existing AST-node x-macro generators because the x-macro schema we use for types is different in a number of ways. The main loss is that subclasses aren't ordered together, which doesn't seem important for types because the hierarchy is generally very shallow with little clustering. llvm-svn: 373407
2019-10-02 07:13:03 +08:00
case GenClangTypeNodes:
EmitClangTypeNodes(Records, OS);
break;
Abstract serialization: TableGen the (de)serialization code for Types. The basic technical design here is that we have three levels of readers and writers: - At the lowest level, there's a `Basic{Reader,Writer}` that knows how to emit the basic structures of the AST. CRTP allows this to be metaprogrammed so that the client only needs to support a handful of primitive types (e.g. `uint64_t` and `IdentifierInfo*`) and more complicated "inline" structures such as `DeclarationName` can just be emitted in terms of those primitives. In Clang's binary-serialization code, these are `ASTRecord{Reader,Writer}`. For now, a large number of basic structures are still emitted explicitly by code on those classes rather than by either TableGen or CRTP metaprogramming, but I expect to move more of these over. - In the middle, there's a `Property{Reader,Writer}` which is responsible for processing the properties of a larger object. The object-level reader/writer asks the property-level reader/writer to project out a particular property, yielding a basic reader/writer which will be used to read/write the property's value, like so: ``` propertyWriter.find("count").writeUInt32(node->getCount()); ``` Clang's binary-serialization code ignores this level (it uses the basic reader/writer as the property reader/writer and has the projection methods just return `*this`) and simply relies on the roperties being read/written in a stable order. - At the highest level, there's an object reader/writer (e.g. `Type{Reader,Writer}` which emits a logical object with properties. Think of this as writing something like a JSON dictionary literal. I haven't introduced support for bitcode abbreviations yet --- it turns out that there aren't any operative abbreviations for types besides the QualType one --- but I do have some ideas of how they should work. At any rate, they'll be necessary in order to handle statements. I'm sorry for not disentangling the patches that added basic and type reader/writers; I made some effort to, but I ran out of energy after disentangling a number of other patches from the work. Negligible impact on module size, time to build a set of about 20 fairly large modules, or time to read a few declarations out of them.
2019-12-14 10:54:44 +08:00
case GenClangTypeReader:
EmitClangTypeReader(Records, OS);
break;
case GenClangTypeWriter:
EmitClangTypeWriter(Records, OS);
break;
Abstract serialization: TableGen "basic" reader/writer CRTP classes that serialize basic values
2019-12-14 10:52:16 +08:00
case GenClangBasicReader:
EmitClangBasicReader(Records, OS);
break;
case GenClangBasicWriter:
EmitClangBasicWriter(Records, OS);
break;
[Clang Interpreter] Initial patch for the constexpr interpreter Summary: This patch introduces the skeleton of the constexpr interpreter, capable of evaluating a simple constexpr functions consisting of if statements. The interpreter is described in more detail in the RFC. Further patches will add more features. Reviewers: Bigcheese, jfb, rsmith Subscribers: bruno, uenoku, ldionne, Tyker, thegameg, tschuett, dexonsmith, mgorny, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D64146 llvm-svn: 371834
2019-09-13 17:46:16 +08:00
case GenClangOpcodes:
EmitClangOpcodes(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenClangSACheckers:
EmitClangSACheckers(Records, OS);
break;
case GenClangCommentHTMLTags:
EmitClangCommentHTMLTags(Records, OS);
break;
case GenClangCommentHTMLTagsProperties:
EmitClangCommentHTMLTagsProperties(Records, OS);
break;
Comment parsing: resolve more named character references This reimplements r173850 with a better approach: (1) use a TableGen-generated matcher instead of doing a linear search; (2) avoid allocations for new strings by converting code points to string iterals with TableGen. llvm-svn: 173931
2013-01-30 22:29:28 +08:00
case GenClangCommentHTMLNamedCharacterReferences:
EmitClangCommentHTMLNamedCharacterReferences(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenClangCommentCommandInfo:
EmitClangCommentCommandInfo(Records, OS);
break;
Comment parsing: improve the fidelity of XML output for many block commands This change introduces a 'kind' attribute for the <Para> tag, that captures the kind of the parent block command. For example: \todo Meow. used to be just <Para>Meow.</Para>, but now it is <Para kind="todo">Meow.</Para> llvm-svn: 174216
2013-02-02 04:23:57 +08:00
case GenClangCommentCommandList:
EmitClangCommentCommandList(Records, OS);
break;
[OpenCL] Declare builtin functions using TableGen This patch adds a `-fdeclare-opencl-builtins` command line option to the clang frontend. This enables clang to verify OpenCL C builtin function declarations using a fast StringMatcher lookup, instead of including the opencl-c.h file with the `-finclude-default-header` option. This avoids the large parse time penalty of the header file. This commit only adds the basic infrastructure and some of the OpenCL builtins. It does not cover all builtins defined by the various OpenCL specifications. As such, it is not a replacement for `-finclude-default-header` yet. RFC: http://lists.llvm.org/pipermail/cfe-dev/2018-November/060041.html Co-authored-by: Pierre Gondois Co-authored-by: Joey Gouly Co-authored-by: Sven van Haastregt Differential Revision: https://reviews.llvm.org/D60763 llvm-svn: 362371
2019-06-03 17:39:11 +08:00
case GenClangOpenCLBuiltins:
EmitClangOpenCLBuiltins(Records, OS);
break;
[OpenCL] Add OpenCL builtin test generator Add a new clang-tblgen flag `-gen-clang-opencl-builtin-tests` that generates a .cl file containing calls to every builtin function defined in the .td input. This patch does not add any use of the new flag yet, so the only way to obtain a generated test file is through a manual invocation of clang-tblgen. A test making use of this emitter will be added in a followup commit. Differential Revision: https://reviews.llvm.org/D97869
2021-06-09 19:43:50 +08:00
case GenClangOpenCLBuiltinTests:
EmitClangOpenCLBuiltinTests(Records, OS);
break;
Reland [Syntax] Add minimal TableGen for syntax nodes. NFC This reverts commit 09c6259d6d0eb51b282f6c3a28052a8146bc095b. (Fixed side-effecting code being buried in an assert)
2020-11-10 07:00:51 +08:00
case GenClangSyntaxNodeList:
EmitClangSyntaxNodeList(Records, OS);
break;
[Syntax] Start to move trivial Node class definitions to TableGen. NFC This defines two node archetypes with trivial class definitions: - Alternatives: the generated abstract classes are trivial as all functionality is via LLVM RTTI - Unconstrained: this is a placeholder, I think all of these are going to be Lists but today they have no special accessors etc, so we just say "could contain anything", and migrate them one-by-one to Sequence later. Compared to Dmitri's prototype, Nodes.td looks more like a class hierarchy and less like a grammar. (E.g. variants list the Alternatives parent rather than vice versa). The main reasons for this: - the hierarchy is an important part of the API we want direct control over. - e.g. we may introduce abstract bases like "loop" that the grammar doesn't care about in order to model is-a concepts that might make refactorings more expressive. This is less natural in a grammar-like idiom. - e.g. we're likely to have to model some alternatives as variants and others as class hierarchies, the choice will probably be based on natural is-a relationships. - it reduces the cognitive load of switching from editing *.td to working with code that uses the generated classes Differential Revision: https://reviews.llvm.org/D90543
2020-11-01 04:09:11 +08:00
case GenClangSyntaxNodeClasses:
EmitClangSyntaxNodeClasses(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenArmNeon:
EmitNeon(Records, OS);
break;
[AArch64] Add ARMv8.2-A FP16 scalar intrinsics https://reviews.llvm.org/D41792 llvm-svn: 323006
2018-01-20 07:11:18 +08:00
case GenArmFP16:
EmitFP16(Records, OS);
break;
[clang][BFloat] add NEON emitter for bfloat Summary: This patch adds the bfloat16_t struct typedefs (e.g. bfloat16x8x2_t) to arm_neon.h This patch is part of a series implementing the Bfloat16 extension of the Armv8.6-a architecture, as detailed here: https://community.arm.com/developer/ip-products/processors/b/processors-ip-blog/posts/arm-architecture-developments-armv8-6-a The bfloat type, and its properties are specified in the Arm Architecture Reference Manual: https://developer.arm.com/docs/ddi0487/latest/arm-architecture-reference-manual-armv8-for-armv8-a-architecture-profile The following people contributed to this patch: - Luke Cheeseman - Simon Tatham - Ties Stuij Reviewers: t.p.northover, fpetrogalli, sdesmalen, az, LukeGeeson Reviewed By: fpetrogalli Subscribers: SjoerdMeijer, LukeGeeson, pbarrio, mgorny, kristof.beyls, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D79708
2020-06-05 20:06:01 +08:00
case GenArmBF16:
EmitBF16(Records, OS);
break;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
case GenArmNeonSema:
EmitNeonSema(Records, OS);
break;
case GenArmNeonTest:
EmitNeonTest(Records, OS);
break;
[clang,ARM] Initial ACLE intrinsics for MVE. This commit sets up the infrastructure for auto-generating <arm_mve.h> and doing clang-side code generation for the builtins it relies on, and demonstrates that it works by implementing a representative sample of the ACLE intrinsics, more or less matching the ones introduced in LLVM IR by D67158,D68699,D68700. Like NEON, that header file will provide a set of vector types like uint16x8_t and C functions with names like vaddq_u32(). Unlike NEON, the ACLE spec for <arm_mve.h> includes a polymorphism system, so that you can write plain vaddq() and disambiguate by the vector types you pass to it. Unlike the corresponding NEON code, I've arranged to make every user- facing ACLE intrinsic into a clang builtin, and implement all the code generation inside clang. So <arm_mve.h> itself contains nothing but typedefs and function declarations, with the latter all using the new `__attribute__((__clang_builtin))` system to arrange that the user- facing function names correspond to the right internal BuiltinIDs. So the new MveEmitter tablegen system specifies the full sequence of IRBuilder operations that each user-facing ACLE intrinsic should translate into. Where possible, the ACLE intrinsics map to standard IR operations such as vector-typed `add` and `fadd`; where no standard representation exists, I call down to the sample IR intrinsics introduced in an earlier commit. Doing it like this means that you get the polymorphism for free just by using __attribute__((overloadable)): the clang overload resolution decides which function declaration is the relevant one, and _then_ its BuiltinID is looked up, so by the time we're doing code generation, that's all been resolved by the standard system. It also means that you get really nice error messages if the user passes the wrong combination of types: clang will show the declarations from the header file and explain why each one doesn't match. (The obvious alternative approach would be to have wrapper functions in <arm_mve.h> which pass their arguments to the underlying builtins. But that doesn't work in the case where one of the arguments has to be a constant integer: the wrapper function can't pass the constantness through. So you'd have to do that case using a macro instead, and then use C11 `_Generic` to handle the polymorphism. Then you have to add horrible workarounds because `_Generic` requires even the untaken branches to type-check successfully, and //then// if the user gets the types wrong, the error message is totally unreadable!) Reviewers: dmgreen, miyuki, ostannard Subscribers: mgorny, javed.absar, kristof.beyls, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D67161
2019-09-02 22:50:50 +08:00
case GenArmMveHeader:
EmitMveHeader(Records, OS);
break;
case GenArmMveBuiltinDef:
EmitMveBuiltinDef(Records, OS);
break;
case GenArmMveBuiltinSema:
EmitMveBuiltinSema(Records, OS);
break;
case GenArmMveBuiltinCG:
EmitMveBuiltinCG(Records, OS);
break;
case GenArmMveBuiltinAliases:
EmitMveBuiltinAliases(Records, OS);
break;
[Clang][SVE] Parse builtin type string for scalable vectors This patch adds 'q' to mean 'scalable vector' in the builtin type string, and for SVE will return the matching builtin type as defined in the C/C++ language extensions for SVE. This patch also adds some scaffolding to generate the arm_sve.h header file, and some builtin definitions (+CodeGen) to be able to implement some simple masked load intrinsics that use the ACLE types, such as: svint8_t test_svld1_s8(svbool_t pg, const int8_t *base) { return svld1_s8(pg, base); } Reviewers: efriedma, rjmccall, rovka, rsandifo-arm, rengolin Reviewed By: efriedma Tags: #clang Differential Revision: https://reviews.llvm.org/D75298
2020-03-15 22:29:45 +08:00
case GenArmSveHeader:
EmitSveHeader(Records, OS);
break;
Reland D75470 [SVE] Auto-generate builtins and header for svld1. Reworked the patch to avoid sharing a header (SVETypeFlags.h) between include/clang/Basic and utils/TableGen/SveEmitter.cpp. Now the patch generates the enum/flags which is included in TargetBuiltins.h. Also renamed one of the SveEmitter options to be in line with MVE. Summary: This is a first patch in a series for the SveEmitter to generate the arm_sve.h header file and builtins. I've tried my best to strip down this patch as best as I could, but there are still a few changes that are not necessarily exercised by the load intrinsics in this patch, mostly around the SVEType class which has some common logic to represent types from a type and prototype string. I thought it didn't make much sense to remove that from this patch and split it up.
2020-03-18 19:07:20 +08:00
case GenArmSveBuiltins:
EmitSveBuiltins(Records, OS);
break;
case GenArmSveBuiltinCG:
EmitSveBuiltinCG(Records, OS);
break;
case GenArmSveTypeFlags:
EmitSveTypeFlags(Records, OS);
break;
[SveEmitter] Add range checks for immediates and predicate patterns. Summary: This patch adds a mechanism to easily add range checks for a builtin's immediate operands. This patch is tested with the qdech intrinsic, which takes both an enum for the predicate pattern, as well as an immediate for the multiplier. Reviewers: efriedma, SjoerdMeijer, rovka Reviewed By: efriedma, SjoerdMeijer Subscribers: mgorny, tschuett, mgrang, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D76678
2020-04-14 22:56:36 +08:00
case GenArmSveRangeChecks:
EmitSveRangeChecks(Records, OS);
break;
[ARM,CDE] Generalize MVE intrinsics infrastructure to support CDE Summary: This patch generalizes the existing code to support CDE intrinsics which will share some properties with existing MVE intrinsics (some of the intrinsics will be polymorphic and accept/return values of MVE vector types). Specifically the patch: * Adds new tablegen backends -gen-arm-cde-builtin-def, -gen-arm-cde-builtin-codegen, -gen-arm-cde-builtin-sema, -gen-arm-cde-builtin-aliases, -gen-arm-cde-builtin-header based on existing MVE backends. * Renames the '__clang_arm_mve_alias' attribute into '__clang_arm_builtin_alias' (it will be used with CDE intrinsics as well as MVE intrinsics) * Implements semantic checks for the coprocessor argument of the CDE intrinsics as well as the existing coprocessor intrinsics. * Adds one CDE intrinsic __arm_cx1 to test the above changes Reviewers: simon_tatham, MarkMurrayARM, ostannard, dmgreen Reviewed By: simon_tatham Subscribers: sdesmalen, mgorny, kristof.beyls, danielkiss, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D75850
2020-03-10 22:01:42 +08:00
case GenArmCdeHeader:
EmitCdeHeader(Records, OS);
break;
case GenArmCdeBuiltinDef:
EmitCdeBuiltinDef(Records, OS);
break;
case GenArmCdeBuiltinSema:
EmitCdeBuiltinSema(Records, OS);
break;
case GenArmCdeBuiltinCG:
EmitCdeBuiltinCG(Records, OS);
break;
case GenArmCdeBuiltinAliases:
EmitCdeBuiltinAliases(Records, OS);
break;
[Clang][RISCV] Add custom TableGen backend for riscv-vector intrinsics. Demonstrate how to generate vadd/vfadd intrinsic functions 1. add -gen-riscv-vector-builtins for clang builtins. 2. add -gen-riscv-vector-builtin-codegen for clang codegen. 3. add -gen-riscv-vector-header for riscv_vector.h. It also generates ifdef directives with extension checking, base on D94403. 4. add -gen-riscv-vector-generic-header for riscv_vector_generic.h. Generate overloading version Header for generic api. https://github.com/riscv/rvv-intrinsic-doc/blob/master/rvv-intrinsic-rfc.md#c11-generic-interface 5. update tblgen doc for riscv related options. riscv_vector.td also defines some unused type transformers for vadd, because I think it could demonstrate how tranfer type work and we need them for the whole intrinsic functions implementation in the future. Authored-by: Roger Ferrer Ibanez <rofirrim@gmail.com> Co-Authored-by: Zakk Chen <zakk.chen@sifive.com> Reviewed By: jrtc27, craig.topper, HsiangKai, Jim, Paul-C-Anagnostopoulos Differential Revision: https://reviews.llvm.org/D95016
2021-03-05 23:40:28 +08:00
case GenRISCVVectorHeader:
EmitRVVHeader(Records, OS);
break;
case GenRISCVVectorBuiltins:
EmitRVVBuiltins(Records, OS);
break;
case GenRISCVVectorBuiltinCG:
EmitRVVBuiltinCG(Records, OS);
break;
Implements a declarative approach to documenting individual attributes in Clang via a Documentation tablegen class. Also updates the internals manual with information about how to use this new, required, documentation feature. This patch adds some very, very sparse initial documentation for some attributes. Additional effort from attribute authors is greatly appreciated. llvm-svn: 201515
2014-02-17 23:27:10 +08:00
case GenAttrDocs:
EmitClangAttrDocs(Records, OS);
break;
Add a mode to clang-tblgen to generate reference documentation for warning and remark flags. For now I'm checking in a copy of the built documentation, but we can replace this with a placeholder (as we do for the attributes reference documentation) once we enable building this server-side. llvm-svn: 281192
2016-09-12 13:58:29 +08:00
case GenDiagDocs:
EmitClangDiagDocs(Records, OS);
break;
[docs] Add TableGen-based generator for command line argument documentation, and generate documentation for all (non-hidden) options supported by the 'clang' driver. llvm-svn: 292968
2017-01-25 03:39:46 +08:00
case GenOptDocs:
EmitClangOptDocs(Records, OS);
break;
[AST] Add TableGen for StmtDataCollectors Summary: This adds an option "-gen-clang-data-collectors" to the Clang TableGen that is used to generate StmtDataCollectors.inc. Reviewers: arphaman, teemperor! Subscribers: mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D37383 llvm-svn: 312634
2017-09-06 21:20:51 +08:00
case GenDataCollectors:
EmitClangDataCollectors(Records, OS);
break;
Add #pragma clang attribute This is a recommit of r300539 that was reverted in r300543 due to test failures. The original commit message is displayed below: The new '#pragma clang attribute' directive can be used to apply attributes to multiple declarations. An attribute must satisfy the following conditions to be supported by the pragma: - It must have a subject list that's defined in the TableGen file. - It must be documented. - It must not be late parsed. - It must have a GNU/C++11 spelling. Differential Revision: https://reviews.llvm.org/D30009 llvm-svn: 300556
2017-04-18 22:33:39 +08:00
case GenTestPragmaAttributeSupportedAttributes:
EmitTestPragmaAttributeSupportedAttributes(Records, OS);
break;
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
}
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
return false;
}
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
int main(int argc, char **argv) {
Revert "Use InitLLVM to setup a pretty stack printer" This reverts commit 3f76260dc0674cc0acb25f550a0f0c594cf537ea. Breaks at least these tests on Windows: Clang :: Driver/clang-offload-bundler.c Clang :: Driver/clang-offload-wrapper.c
2019-11-26 10:06:56 +08:00
sys::PrintStackTraceOnErrorSignal(argv[0]);
PrettyStackTraceProgram X(argc, argv);
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
cl::ParseCommandLineOptions(argc, argv);
[TableGen] Call llvm_shutdown on exit so that all the ManagedStatic objects in the support library will be deleted. llvm-svn: 256731
2016-01-04 12:51:46 +08:00
llvm_shutdown_obj Y;
tblgen: Migrate clang-tblgen to new TableGenMain API. llvm-svn: 165167
2012-10-04 05:29:30 +08:00
return TableGenMain(argv[0], &ClangTableGenMain);
Add the Clang tblgen backends to Clang, and flip the switch to cause the build systems to use clang-tblgen. llvm-svn: 141291
2011-10-06 21:03:08 +08:00
}
reapply r198858: Disable LeakSanitizer in TableGen binaries, see PR18325; this time LeakSanitizerIsTurnedOffForTheCurrentProcess is used instead of __lsan_is_turned_off llvm-svn: 198922
2014-01-10 16:05:42 +08:00
replace LeakSanitizerIsTurnedOffForTheCurrentProcess with __lsan_is_turned_off, but this time hide it under __has_feature(address_sanitizer); also include <sanitizer/lsan_interface.h> llvm-svn: 199303
2014-01-15 15:59:37 +08:00
#ifdef __has_feature
#if __has_feature(address_sanitizer)
#include <sanitizer/lsan_interface.h>
reapply r198858: Disable LeakSanitizer in TableGen binaries, see PR18325; this time LeakSanitizerIsTurnedOffForTheCurrentProcess is used instead of __lsan_is_turned_off llvm-svn: 198922
2014-01-10 16:05:42 +08:00
// Disable LeakSanitizer for this binary as it has too many leaks that are not
replace LeakSanitizerIsTurnedOffForTheCurrentProcess with __lsan_is_turned_off, but this time hide it under __has_feature(address_sanitizer); also include <sanitizer/lsan_interface.h> llvm-svn: 199303
2014-01-15 15:59:37 +08:00
// very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .
int __lsan_is_turned_off() { return 1; }
#endif // __has_feature(address_sanitizer)
#endif // defined(__has_feature)